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

Merge branch 'ver/6.5.0' into dev/7.0-2

Browse Source
This commit is contained in:
Zoe Gidiere
2024-09-24 09:44:35 -06:00
parent 2df2755631 13782bb51e
commit c95b3c09a8
30 changed files with 1125 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
common/addons/biome-provider-extrusion/src/main/java/com/dfsek/terra/addons/biome/extrusion/api/Extrusion.java
View File

@@ -1,9 +1,9 @@
package com.dfsek.terra.addons.biome.extrusion.api;
import java.util.Collection;
import com.dfsek.terra.api.world.biome.Biome;
import java.util.Collection;
public interface Extrusion {
Biome extrude(Biome original, int x, int y, int z, long seed);

4
common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/biome/SelfPipelineBiome.java
View File

@@ -1,10 +1,10 @@
package com.dfsek.terra.addons.biome.pipeline.api.biome;
import com.dfsek.terra.api.world.biome.Biome;
import java.util.Collections;
import java.util.Set;
import com.dfsek.terra.api.world.biome.Biome;
final class SelfPipelineBiome implements PipelineBiome {
public static final SelfPipelineBiome INSTANCE = new SelfPipelineBiome();

4
common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/holder/PaletteHolderBuilder.java
View File

@@ -7,11 +7,11 @@
package com.dfsek.terra.addons.biome.holder;
import com.dfsek.terra.api.world.chunk.generation.util.Palette;
import java.util.Map;
import java.util.TreeMap;
import com.dfsek.terra.api.world.chunk.generation.util.Palette;
public class PaletteHolderBuilder {
private final TreeMap<Integer, Palette> paletteMap = new TreeMap<>();

4
common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PointSetDistributor.java
View File

@@ -7,11 +7,11 @@
package com.dfsek.terra.addons.feature.distributor.distributors;
import java.util.Set;
import com.dfsek.terra.addons.feature.distributor.util.Point;
import com.dfsek.terra.api.structure.feature.Distributor;
import java.util.Set;
public class PointSetDistributor implements Distributor {
private final Set<Point> points;

2
common/addons/config-noise-function/build.gradle.kts
View File

@@ -1,4 +1,4 @@
version = version("1.1.0")
version = version("1.2.0")
dependencies {
compileOnlyApi(project(":common:addons:manifest-addon-loader"))

47
common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java
View File

@@ -9,17 +9,46 @@ package com.dfsek.terra.addons.noise;
import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.function.Supplier;
import com.dfsek.terra.addons.manifest.api.AddonInitializer;
import com.dfsek.terra.addons.noise.config.CubicSplinePointTemplate;
import com.dfsek.terra.addons.noise.config.DimensionApplicableNoiseSampler;
import com.dfsek.terra.addons.noise.config.templates.*;
import com.dfsek.terra.addons.noise.config.templates.noise.*;
import com.dfsek.terra.addons.noise.config.templates.BinaryArithmeticTemplate;
import com.dfsek.terra.addons.noise.config.templates.DerivativeNoiseSamplerTemplate;
import com.dfsek.terra.addons.noise.config.templates.DomainWarpTemplate;
import com.dfsek.terra.addons.noise.config.templates.FunctionTemplate;
import com.dfsek.terra.addons.noise.config.templates.ImageSamplerTemplate;
import com.dfsek.terra.addons.noise.config.templates.KernelTemplate;
import com.dfsek.terra.addons.noise.config.templates.LinearHeightmapSamplerTemplate;
import com.dfsek.terra.addons.noise.config.templates.TranslateSamplerTemplate;
import com.dfsek.terra.addons.noise.config.templates.noise.CellularNoiseTemplate;
import com.dfsek.terra.addons.noise.config.templates.noise.ConstantNoiseTemplate;
import com.dfsek.terra.addons.noise.config.templates.noise.DistanceSamplerTemplate;
import com.dfsek.terra.addons.noise.config.templates.noise.ExpressionFunctionTemplate;
import com.dfsek.terra.addons.noise.config.templates.noise.GaborNoiseTemplate;
import com.dfsek.terra.addons.noise.config.templates.noise.PseudoErosionTemplate;
import com.dfsek.terra.addons.noise.config.templates.noise.SimpleNoiseTemplate;
import com.dfsek.terra.addons.noise.config.templates.noise.fractal.BrownianMotionTemplate;
import com.dfsek.terra.addons.noise.config.templates.noise.fractal.PingPongTemplate;
import com.dfsek.terra.addons.noise.config.templates.noise.fractal.RidgedFractalTemplate;
import com.dfsek.terra.addons.noise.config.templates.normalizer.*;
import com.dfsek.terra.addons.noise.config.templates.normalizer.ClampNormalizerTemplate;
import com.dfsek.terra.addons.noise.config.templates.normalizer.CubicSplineNormalizerTemplate;
import com.dfsek.terra.addons.noise.config.templates.normalizer.ExpressionNormalizerTemplate;
import com.dfsek.terra.addons.noise.config.templates.normalizer.LinearNormalizerTemplate;
import com.dfsek.terra.addons.noise.config.templates.normalizer.NormalNormalizerTemplate;
import com.dfsek.terra.addons.noise.config.templates.normalizer.PosterizationNormalizerTemplate;
import com.dfsek.terra.addons.noise.config.templates.normalizer.ProbabilityNormalizerTemplate;
import com.dfsek.terra.addons.noise.config.templates.normalizer.ScaleNormalizerTemplate;
import com.dfsek.terra.addons.noise.math.CubicSpline;
import com.dfsek.terra.addons.noise.samplers.arithmetic.*;
import com.dfsek.terra.addons.noise.samplers.arithmetic.AdditionSampler;
import com.dfsek.terra.addons.noise.samplers.arithmetic.DivisionSampler;
import com.dfsek.terra.addons.noise.samplers.arithmetic.MaxSampler;
import com.dfsek.terra.addons.noise.samplers.arithmetic.MinSampler;
import com.dfsek.terra.addons.noise.samplers.arithmetic.MultiplicationSampler;
import com.dfsek.terra.addons.noise.samplers.arithmetic.SubtractionSampler;
import com.dfsek.terra.addons.noise.samplers.noise.CellularSampler;
import com.dfsek.terra.addons.noise.samplers.noise.DistanceSampler;
import com.dfsek.terra.addons.noise.samplers.noise.random.GaussianNoiseSampler;
@@ -36,14 +65,11 @@ import com.dfsek.terra.api.addon.BaseAddon;
import com.dfsek.terra.api.event.events.config.pack.ConfigPackPreLoadEvent;
import com.dfsek.terra.api.event.functional.FunctionalEventHandler;
import com.dfsek.terra.api.inject.annotations.Inject;
import com.dfsek.terra.api.noise.DerivativeNoiseSampler;
import com.dfsek.terra.api.noise.NoiseSampler;
import com.dfsek.terra.api.registry.CheckedRegistry;
import com.dfsek.terra.api.util.reflection.TypeKey;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.function.Supplier;
public class NoiseAddon implements AddonInitializer {
public static final TypeKey<Supplier<ObjectTemplate<NoiseSampler>>> NOISE_SAMPLER_TOKEN = new TypeKey<>() {
@@ -71,7 +97,8 @@ public class NoiseAddon implements AddonInitializer {
(type, o, loader, depthTracker) -> DistanceSampler.DistanceFunction.valueOf((String) o))
.applyLoader(DimensionApplicableNoiseSampler.class, DimensionApplicableNoiseSampler::new)
.applyLoader(FunctionTemplate.class, FunctionTemplate::new)
.applyLoader(CubicSpline.Point.class, CubicSplinePointTemplate::new);
.applyLoader(CubicSpline.Point.class, CubicSplinePointTemplate::new)
.applyLoader(DerivativeNoiseSampler.class, DerivativeNoiseSamplerTemplate::new);
noiseRegistry.register(addon.key("LINEAR"), LinearNormalizerTemplate::new);
noiseRegistry.register(addon.key("LINEAR_MAP"), LinearMapNormalizerTemplate::new);
@@ -95,7 +122,7 @@ public class NoiseAddon implements AddonInitializer {
noiseRegistry.register(addon.key("PERLIN"), () -> new SimpleNoiseTemplate(PerlinSampler::new));
noiseRegistry.register(addon.key("SIMPLEX"), () -> new SimpleNoiseTemplate(SimplexSampler::new));
noiseRegistry.register(addon.key("GABOR"), GaborNoiseTemplate::new);
noiseRegistry.register(addon.key("PSEUDOEROSION"), PseudoErosionTemplate::new);
noiseRegistry.register(addon.key("VALUE"), () -> new SimpleNoiseTemplate(ValueSampler::new));
noiseRegistry.register(addon.key("VALUE_CUBIC"), () -> new SimpleNoiseTemplate(ValueCubicSampler::new));

6
common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseConfigPackTemplate.java
View File

@@ -11,14 +11,14 @@ import com.dfsek.tectonic.api.config.template.ConfigTemplate;
import com.dfsek.tectonic.api.config.template.annotations.Default;
import com.dfsek.tectonic.api.config.template.annotations.Value;
import java.util.LinkedHashMap;
import java.util.Map;
import com.dfsek.terra.addons.noise.config.DimensionApplicableNoiseSampler;
import com.dfsek.terra.addons.noise.config.templates.FunctionTemplate;
import com.dfsek.terra.api.config.meta.Meta;
import com.dfsek.terra.api.properties.Properties;
import java.util.LinkedHashMap;
import java.util.Map;
@SuppressWarnings("FieldMayBeFinal")
public class NoiseConfigPackTemplate implements ConfigTemplate, Properties {

26
common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/DerivativeNoiseSamplerTemplate.java Normal file
View File

@@ -0,0 +1,26 @@
package com.dfsek.terra.addons.noise.config.templates;
import com.dfsek.tectonic.api.config.template.annotations.Value;
import com.dfsek.tectonic.api.exception.ValidationException;
import com.dfsek.terra.api.noise.DerivativeNoiseSampler;
import com.dfsek.terra.api.noise.NoiseSampler;
public class DerivativeNoiseSamplerTemplate extends SamplerTemplate<DerivativeNoiseSampler> {
@Value(".")
private NoiseSampler sampler;
@Override
public boolean validate() throws ValidationException {
if(!DerivativeNoiseSampler.isDifferentiable(sampler)) throw new ValidationException(
"Provided sampler does not support calculating a derivative");
return super.validate();
}
@Override
public DerivativeNoiseSampler get() {
return (DerivativeNoiseSampler) sampler;
}
}

9
common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/ImageSamplerTemplate.java
View File

@@ -8,16 +8,15 @@
package com.dfsek.terra.addons.noise.config.templates;
import com.dfsek.tectonic.api.config.template.annotations.Value;
import com.dfsek.terra.addons.noise.samplers.ImageSampler;
import com.dfsek.terra.api.config.meta.Meta;
import com.dfsek.terra.api.noise.NoiseSampler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.awt.image.BufferedImage;
import com.dfsek.terra.addons.noise.samplers.ImageSampler;
import com.dfsek.terra.api.config.meta.Meta;
import com.dfsek.terra.api.noise.NoiseSampler;
@SuppressWarnings({ "unused", "FieldMayBeFinal" })
public class ImageSamplerTemplate extends SamplerTemplate<ImageSampler> {

8
common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/DerivativeNoiseTemplate.java Normal file
View File

@@ -0,0 +1,8 @@
package com.dfsek.terra.addons.noise.config.templates.noise;
import com.dfsek.terra.addons.noise.samplers.noise.DerivativeNoiseFunction;
public abstract class DerivativeNoiseTemplate<T extends DerivativeNoiseFunction> extends NoiseTemplate<T> {
}

79
common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/PseudoErosionTemplate.java Normal file
View File

@@ -0,0 +1,79 @@
package com.dfsek.terra.addons.noise.config.templates.noise;
import com.dfsek.tectonic.api.config.template.annotations.Default;
import com.dfsek.tectonic.api.config.template.annotations.Value;
import com.dfsek.terra.addons.noise.samplers.noise.PseudoErosionSampler;
import com.dfsek.terra.addons.noise.samplers.noise.simplex.OpenSimplex2Sampler;
import com.dfsek.terra.api.config.meta.Meta;
import com.dfsek.terra.api.noise.DerivativeNoiseSampler;
public class PseudoErosionTemplate extends NoiseTemplate<PseudoErosionSampler> {
@Value("frequency")
@Default
protected @Meta double frequency = 1d;
@Value("octaves")
@Default
private int octaves = 4;
@Value("lacunarity")
@Default
private double lacunarity = 2.0;
@Value("gain")
@Default
private double gain = 0.5;
@Value("slope-strength")
@Default
private double slopeStrength = 1.0;
@Value("branch-strength")
@Default
private double branchStrength = 1.0;
@Value("strength")
@Default
private double strength = 0.04;
@Value("erosion-frequency")
@Default
private double erosionFrequency = 0.02;
@Value("sampler")
@Default
private DerivativeNoiseSampler heightSampler = new OpenSimplex2Sampler();
@Value("slope-mask.enable")
@Default
private boolean slopeMask = true;
@Value("slope-mask.none")
@Default
private double slopeMaskNone = -0.5;
@Value("slope-mask.full")
@Default
private double slopeMaskFull = 1;
@Value("jitter")
@Default
private double jitterModifier = 1;
@Value("average-impulses")
@Default
private boolean averageErosionImpulses = true;
@Override
public PseudoErosionSampler get() {
PseudoErosionSampler pseudoErosion = new PseudoErosionSampler(octaves, gain, lacunarity,
slopeStrength, branchStrength, strength,
erosionFrequency, heightSampler, slopeMask, slopeMaskFull, slopeMaskNone, jitterModifier, averageErosionImpulses);
pseudoErosion.setFrequency(frequency);
pseudoErosion.setSalt(salt);
return pseudoErosion;
}
}

25
common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DerivativeNoiseFunction.java Normal file
View File

@@ -0,0 +1,25 @@
package com.dfsek.terra.addons.noise.samplers.noise;
import com.dfsek.terra.api.noise.DerivativeNoiseSampler;
public abstract class DerivativeNoiseFunction extends NoiseFunction implements DerivativeNoiseSampler {
@Override
public boolean isDifferentiable() {
return true;
}
@Override
public double[] noised(long seed, double x, double y) {
return getNoiseDerivativeRaw(seed + salt, x * frequency, y * frequency);
}
@Override
public double[] noised(long seed, double x, double y, double z) {
return getNoiseDerivativeRaw(seed + salt, x * frequency, y * frequency, z * frequency);
}
public abstract double[] getNoiseDerivativeRaw(long seed, double x, double y);
public abstract double[] getNoiseDerivativeRaw(long seed, double x, double y, double z);
}

173
common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/PseudoErosionSampler.java Normal file
View File

@@ -0,0 +1,173 @@
package com.dfsek.terra.addons.noise.samplers.noise;
import com.dfsek.terra.api.noise.DerivativeNoiseSampler;
import com.dfsek.terra.api.util.MathUtil;
public class PseudoErosionSampler extends NoiseFunction {
public static final double TAU = 2.0 * Math.PI;
private static final double HASH_X = 0.3183099f;
private static final double HASH_Y = 0.3678794f;
public final double gain;
public final double lacunarity;
public final double slopeStrength;
public final double branchStrength;
public final double erosionStrength;
private final int octaves;
private final double erosionFrequency;
private final DerivativeNoiseSampler sampler;
private final boolean slopeMask;
private final double slopeMaskFullSq;
private final double slopeMaskNoneSq;
private final double jitter;
private final double maxCellDistSq;
private final double maxCellDistSqRecip;
private final boolean averageErosionImpulses;
public PseudoErosionSampler(int octaves, double gain, double lacunarity, double slopeStrength, double branchStrength,
double erosionStrength, double erosionFrequency, DerivativeNoiseSampler sampler,
boolean slopeMask, double slopeMaskFull, double slopeMaskNone, double jitterModifier,
boolean averageErosionImpulses) {
this.octaves = octaves;
this.gain = gain;
this.lacunarity = lacunarity;
this.slopeStrength = slopeStrength;
this.branchStrength = branchStrength;
this.erosionStrength = erosionStrength;
this.erosionFrequency = erosionFrequency;
this.sampler = sampler;
this.slopeMask = slopeMask;
// Square these values and maintain sign since they're compared to a
// squared value, otherwise a sqrt would need to be used
this.slopeMaskFullSq = slopeMaskFull * slopeMaskFull * Math.signum(slopeMaskFull);
this.slopeMaskNoneSq = slopeMaskNone * slopeMaskNone * Math.signum((slopeMaskNone));
this.jitter = 0.43701595 * jitterModifier;
this.averageErosionImpulses = averageErosionImpulses;
this.maxCellDistSq = 1 + jitter * jitter;
this.maxCellDistSqRecip = 1 / maxCellDistSq;
}
public static double hashX(double seed, double n) {
// Swapped the components here
double nx = HASH_X * n * seed;
return -1.0f + 2.0f * fract(nx);
}
public static double hashY(double seed, double n) {
double ny = HASH_Y * n * seed;
return -1.0f + 2.0f * fract(ny);
}
public static double fract(double x) {
return (x - Math.floor(x));
}
public static double smoothstep(double edge0, double edge1, double x) {
// Scale, bias and saturate x to 0..1 range
x = clamp((x - edge0) / (edge1 - edge0), 0.0f, 1.0f);
// Evaluate polynomial
return x * x * (3 - 2 * x);
}
public static double clamp(double x, double minVal, double maxVal) {
return Math.max(minVal, Math.min(maxVal, x));
}
public static double dot(double x1, double y1, double x2, double y2) {
return x1 * x2 + y1 * y2;
}
public double[] erosion(int seed, double x, double y, double dirX, double dirY) {
int gridX = (int) Math.round(x);
int gridY = (int) Math.round(y);
double noise = 0.0f;
double dirOutX = 0.0f;
double dirOutY = 0.0f;
double cumAmp = 0.0f;
for(int cellX = gridX - 1; cellX <= gridX + 1; cellX++) {
for(int cellY = gridY - 1; cellY <= gridY + 1; cellY++) {
double cellHash = hash(seed, cellX, cellY);
double cellOffsetX = hashX(seed, cellHash) * jitter;
double cellOffsetY = hashY(seed, cellHash) * jitter;
double cellOriginDeltaX = (x - cellX) + cellOffsetX;
double cellOriginDeltaY = (y - cellY) + cellOffsetY;
double cellOriginDistSq = cellOriginDeltaX * cellOriginDeltaX + cellOriginDeltaY * cellOriginDeltaY;
if(cellOriginDistSq > maxCellDistSq) continue; // Skip calculating cells too far away
double ampTmp = (cellOriginDistSq * maxCellDistSqRecip) - 1;
double amp = ampTmp * ampTmp; // Decrease cell amplitude further away
cumAmp += amp;
double directionalStrength = dot(cellOriginDeltaX, cellOriginDeltaY, dirX, dirY) * TAU;
noise += MathUtil.cos(directionalStrength) * amp;
double sinAngle = MathUtil.sin(directionalStrength) * amp;
dirOutX -= sinAngle * (cellOriginDeltaX + dirX);
dirOutY -= sinAngle * (cellOriginDeltaY + dirY);
}
}
if(averageErosionImpulses && cumAmp != 0) {
noise /= cumAmp;
dirOutX /= cumAmp;
dirOutY /= cumAmp;
}
return new double[]{ noise, dirOutX, dirOutY };
}
public double heightMap(long seed, double x, double y) {
double[] sample = sampler.noised(seed, x, y);
double height = sample[0];
double heightDirX = sample[1];
double heightDirY = sample[2];
// Take the curl of the normal to get the gradient facing down the slope
double baseDirX = heightDirY * slopeStrength;
double baseDirY = -heightDirX * slopeStrength;
double erosion = 0.0f;
double dirX = 0.0f;
double dirY = 0.0f;
double amp = 1.0f;
double cumAmp = 0.0f;
double freq = 1.0f;
// Stack erosion octaves
for(int i = 0; i < octaves; i++) {
double[] erosionResult = erosion((int) seed,
x * freq * erosionFrequency,
y * freq * erosionFrequency,
baseDirX + dirY * branchStrength,
baseDirY - dirX * branchStrength);
erosion += erosionResult[0] * amp;
dirX += erosionResult[1] * amp * freq;
dirY += erosionResult[2] * amp * freq;
cumAmp += amp;
amp *= gain;
freq *= lacunarity;
}
// Normalize erosion noise
erosion /= cumAmp;
// [-1, 1] -> [0, 1]
erosion = erosion * 0.5F + 0.5F;
// Without masking, erosion noise in areas with small gradients tend to produce mounds,
// this reduces erosion amplitude towards smaller gradients to avoid this
if(slopeMask) {
double dirMagSq = dot(baseDirX, baseDirY, baseDirX, baseDirY);
double flatness = smoothstep((double) slopeMaskNoneSq, slopeMaskFullSq, dirMagSq);
erosion *= flatness;
}
return height + erosion * erosionStrength;
}
@Override
public double getNoiseRaw(long seed, double x, double y) {
return heightMap(seed, x, y);
}
@Override
public double getNoiseRaw(long seed, double x, double y, double z) {
return getNoiseRaw(seed, x, z);
}
}

420
common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2SSampler.java
View File

@@ -276,4 +276,424 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler {
return value * 9.046026385208288;
}
@Override
public boolean isDifferentiable() {
return true;
}
@Override
public double[] getNoiseDerivativeRaw(long sl, double x, double y) {
int seed = (int) sl;
// 2D OpenSimplex2S case is a modified 2D simplex noise.
final double SQRT3 = 1.7320508075688772935274463415059;
final double G2 = (3 - SQRT3) / 6;
final double F2 = 0.5f * (SQRT3 - 1);
double s = (x + y) * F2;
x += s;
y += s;
int i = (int) Math.floor(x);
int j = (int) Math.floor(y);
double xi = x - i;
double yi = y - j;
i *= PRIME_X;
j *= PRIME_Y;
int i1 = i + PRIME_X;
int j1 = j + PRIME_Y;
double t = (xi + yi) * G2;
double x0 = xi - t;
double y0 = yi - t;
double[] out = { 0.0f, 0.0f, 0.0f };
double a0 = (2.0 / 3.0) - x0 * x0 - y0 * y0;
double aa0 = a0 * a0, aaa0 = aa0 * a0, aaaa0 = aa0 * aa0;
int gi0 = gradCoordIndex(seed, i, j);
double gx0 = GRADIENTS_2_D[gi0], gy0 = GRADIENTS_2_D[gi0 | 1];
double rampValue0 = gx0 * x0 + gy0 * y0;
out[0] = aaaa0 * rampValue0;
out[1] = gx0 * aaaa0 - 8 * rampValue0 * aaa0 * x0;
out[2] = gy0 * aaaa0 - 8 * rampValue0 * aaa0 * y0;
double a1 = 2 * (1 - 2 * G2) * (1 / G2 - 2) * t + ((-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a0);
double x1 = x0 - (1 - 2 * G2);
double y1 = y0 - (1 - 2 * G2);
double aa1 = a1 * a1, aaa1 = aa1 * a1, aaaa1 = aa1 * aa1;
int gi1 = gradCoordIndex(seed, i1, j1);
double gx1 = GRADIENTS_2_D[gi1], gy1 = GRADIENTS_2_D[gi1 | 1];
double rampValue1 = gx1 * x1 + gy1 * y1;
out[0] += aaaa1 * rampValue1;
out[1] += gx1 * aaaa1 - 8 * rampValue1 * aaa1 * x1;
out[2] += gy1 * aaaa1 - 8 * rampValue1 * aaa1 * y1;
// Nested conditionals were faster than compact bit logic/arithmetic.
double xmyi = xi - yi;
if(t > G2) {
if(xi + xmyi > 1) {
double x2 = x0 + (3 * G2 - 2);
double y2 = y0 + (3 * G2 - 1);
double a2 = (2.0 / 3.0) - x2 * x2 - y2 * y2;
if(a2 > 0) {
double aa2 = a2 * a2, aaa2 = aa2 * a2, aaaa2 = aa2 * aa2;
int gi2 = gradCoordIndex(seed, i + (PRIME_X << 1), j + PRIME_Y);
double gx2 = GRADIENTS_2_D[gi2 | 0], gy2 = GRADIENTS_2_D[gi2 | 1];
double rampValue2 = gx2 * x2 + gy2 * y2;
out[0] += aaaa2 * rampValue2;
out[1] += gx2 * aaaa2 - 8 * rampValue2 * aaa2 * x2;
out[2] += gy2 * aaaa2 - 8 * rampValue2 * aaa2 * y2;
}
} else {
double x2 = x0 + G2;
double y2 = y0 + (G2 - 1);
double a2 = (2.0 / 3.0) - x2 * x2 - y2 * y2;
if(a2 > 0) {
double aa2 = a2 * a2, aaa2 = aa2 * a2, aaaa2 = aa2 * aa2;
int gi2 = gradCoordIndex(seed, i, j + PRIME_Y);
double gx2 = GRADIENTS_2_D[gi2], gy2 = GRADIENTS_2_D[gi2 | 1];
double rampValue2 = gx2 * x2 + gy2 * y2;
out[0] += aaaa2 * rampValue2;
out[1] += gx2 * aaaa2 - 8 * rampValue2 * aaa2 * x2;
out[2] += gy2 * aaaa2 - 8 * rampValue2 * aaa2 * y2;
}
}
if(yi - xmyi > 1) {
double x3 = x0 + (3 * G2 - 1);
double y3 = y0 + (3 * G2 - 2);
double a3 = (2.0 / 3.0) - x3 * x3 - y3 * y3;
if(a3 > 0) {
double aa3 = a3 * a3, aaa3 = aa3 * a3, aaaa3 = aa3 * aa3;
int gi3 = gradCoordIndex(seed, i + PRIME_X, j + (PRIME_Y << 1));
double gx3 = GRADIENTS_2_D[gi3], gy3 = GRADIENTS_2_D[gi3 | 1];
double rampValue3 = gx3 * x3 + gy3 * y3;
out[0] += aaaa3 * rampValue3;
out[1] += gx3 * aaaa3 - 8 * rampValue3 * aaa3 * x3;
out[2] += gy3 * aaaa3 - 8 * rampValue3 * aaa3 * y3;
}
} else {
double x3 = x0 + (G2 - 1);
double y3 = y0 + G2;
double a3 = (2.0 / 3.0) - x3 * x3 - y3 * y3;
if(a3 > 0) {
double aa3 = a3 * a3, aaa3 = aa3 * a3, aaaa3 = aa3 * aa3;
int gi3 = gradCoordIndex(seed, i + PRIME_X, j);
double gx3 = GRADIENTS_2_D[gi3], gy3 = GRADIENTS_2_D[gi3 | 1];
double rampValue3 = gx3 * x3 + gy3 * y3;
out[0] += aaaa3 * rampValue3;
out[1] += gx3 * aaaa3 - 8 * rampValue3 * aaa3 * x3;
out[2] += gy3 * aaaa3 - 8 * rampValue3 * aaa3 * y3;
}
}
} else {
if(xi + xmyi < 0) {
double x2 = x0 + (1 - G2);
double y2 = y0 - G2;
double a2 = (2.0 / 3.0) - x2 * x2 - y2 * y2;
if(a2 > 0) {
double aa2 = a2 * a2, aaa2 = aa2 * a2, aaaa2 = aa2 * aa2;
int gi2 = gradCoordIndex(seed, i - PRIME_X, j);
double gx2 = GRADIENTS_2_D[gi2], gy2 = GRADIENTS_2_D[gi2 | 1];
double rampValue2 = gx2 * x2 + gy2 * y2;
out[0] += aaaa2 * rampValue2;
out[1] += gx2 * aaaa2 - 8 * rampValue2 * aaa2 * x2;
out[2] += gy2 * aaaa2 - 8 * rampValue2 * aaa2 * y2;
}
} else {
double x2 = x0 + (G2 - 1);
double y2 = y0 + G2;
double a2 = (2.0 / 3.0) - x2 * x2 - y2 * y2;
if(a2 > 0) {
double aa2 = a2 * a2, aaa2 = aa2 * a2, aaaa2 = aa2 * aa2;
int gi2 = gradCoordIndex(seed, i + PRIME_X, j);
double gx2 = GRADIENTS_2_D[gi2], gy2 = GRADIENTS_2_D[gi2 | 1];
double rampValue2 = gx2 * x2 + gy2 * y2;
out[0] += aaaa2 * rampValue2;
out[1] += gx2 * aaaa2 - 8 * rampValue2 * aaa2 * x2;
out[2] += gy2 * aaaa2 - 8 * rampValue2 * aaa2 * y2;
}
}
if(yi < xmyi) {
double x2 = x0 - G2;
double y2 = y0 - (G2 - 1);
double a2 = (2.0 / 3.0) - x2 * x2 - y2 * y2;
if(a2 > 0) {
double aa2 = a2 * a2, aaa2 = aa2 * a2, aaaa2 = aa2 * aa2;
int gi2 = gradCoordIndex(seed, i, j - PRIME_Y);
double gx2 = GRADIENTS_2_D[gi2], gy2 = GRADIENTS_2_D[gi2 | 1];
double rampValue2 = gx2 * x2 + gy2 * y2;
out[0] += aaaa2 * rampValue2;
out[1] += gx2 * aaaa2 - 8 * rampValue2 * aaa2 * x2;
out[2] += gy2 * aaaa2 - 8 * rampValue2 * aaa2 * y2;
}
} else {
double x2 = x0 + G2;
double y2 = y0 + (G2 - 1);
double a2 = (2.0 / 3.0) - x2 * x2 - y2 * y2;
if(a2 > 0) {
double aa2 = a2 * a2, aaa2 = aa2 * a2, aaaa2 = aa2 * aa2;
int gi2 = gradCoordIndex(seed, i, j + PRIME_Y);
double gx2 = GRADIENTS_2_D[gi2], gy2 = GRADIENTS_2_D[gi2 | 1];
double rampValue2 = gx2 * x2 + gy2 * y2;
out[0] += aaaa2 * rampValue2;
out[1] += gx2 * aaaa2 - 8 * rampValue2 * aaa2 * x2;
out[2] += gy2 * aaaa2 - 8 * rampValue2 * aaa2 * y2;
}
}
}
out[0] *= 18.24196194486065;
out[1] *= 18.24196194486065;
out[2] *= 18.24196194486065;
return out;
}
@Override
public double[] getNoiseDerivativeRaw(long sl, double x, double y, double z) {
int seed = (int) sl;
// 3D OpenSimplex2S case uses two offset rotated cube grids.
final double R3 = (2.0 / 3.0);
double r = (x + y + z) * R3; // Rotation, not skew
x = r - x;
y = r - y;
z = r - z;
int i = (int) Math.floor(x);
int j = (int) Math.floor(y);
int k = (int) Math.floor(z);
double xi = x - i;
double yi = y - j;
double zi = z - k;
i *= PRIME_X;
j *= PRIME_Y;
k *= PRIME_Z;
int seed2 = seed + 1293373;
int xNMask = (int) (-0.5 - xi);
int yNMask = (int) (-0.5 - yi);
int zNMask = (int) (-0.5 - zi);
double[] out = { 0.0f, 0.0f, 0.0f, 0.0f };
double x0 = xi + xNMask;
double y0 = yi + yNMask;
double z0 = zi + zNMask;
double a0 = 0.75 - x0 * x0 - y0 * y0 - z0 * z0;
double aa0 = a0 * a0, aaa0 = aa0 * a0, aaaa0 = aa0 * aa0;
int gi0 = gradCoordIndex(seed, i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (zNMask & PRIME_Z));
double gx0 = GRADIENTS_3D[gi0], gy0 = GRADIENTS_3D[gi0 | 1], gz0 = GRADIENTS_3D[gi0 | 2];
double rampValue0 = gx0 * x0 + gy0 * y0 + gz0 * z0;
out[0] = aaaa0 * rampValue0;
out[1] = gx0 * aaaa0 - 8 * rampValue0 * aaa0 * x0;
out[2] = gy0 * aaaa0 - 8 * rampValue0 * aaa0 * y0;
out[3] = gz0 * aaaa0 - 8 * rampValue0 * aaa0 * z0;
double x1 = xi - 0.5;
double y1 = yi - 0.5;
double z1 = zi - 0.5;
double a1 = 0.75 - x1 * x1 - y1 * y1 - z1 * z1;
double aa1 = a1 * a1, aaa1 = aa1 * a1, aaaa1 = aa1 * aa1;
int gi1 = gradCoordIndex(seed2, i + PRIME_X, j + PRIME_Y, k + PRIME_Z);
double gx1 = GRADIENTS_3D[gi1], gy1 = GRADIENTS_3D[gi1 | 1], gz1 = GRADIENTS_3D[gi1 | 2];
double rampValue1 = gx1 * x1 + gy1 * y1 + gz1 * z1;
out[0] += aaaa1 * rampValue1;
out[1] += gx1 * aaaa1 - 8 * rampValue1 * aaa1 * x1;
out[2] += gy1 * aaaa1 - 8 * rampValue1 * aaa1 * y1;
out[3] += gz1 * aaaa1 - 8 * rampValue1 * aaa1 * z1;
double xAFlipMask0 = ((xNMask | 1) << 1) * x1;
double yAFlipMask0 = ((yNMask | 1) << 1) * y1;
double zAFlipMask0 = ((zNMask | 1) << 1) * z1;
double xAFlipMask1 = (-2 - (xNMask << 2)) * x1 - 1.0;
double yAFlipMask1 = (-2 - (yNMask << 2)) * y1 - 1.0;
double zAFlipMask1 = (-2 - (zNMask << 2)) * z1 - 1.0;
boolean skip5 = false;
double a2 = xAFlipMask0 + a0;
if(a2 > 0) {
double x2 = x0 - (xNMask | 1);
double aa2 = a2 * a2, aaa2 = aa2 * a2, aaaa2 = aa2 * aa2;
int gi2 = gradCoordIndex(seed, i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (zNMask & PRIME_Z));
double gx2 = GRADIENTS_3D[gi2], gy2 = GRADIENTS_3D[gi2 | 1], gz2 = GRADIENTS_3D[gi2 | 2];
double rampValue2 = gx2 * x2 + gy2 * y0 + gz2 * z0;
out[0] += aaaa2 * rampValue2;
out[1] += gx2 * aaaa2 - 8 * rampValue2 * aaa2 * x2;
out[2] += gy2 * aaaa2 - 8 * rampValue2 * aaa2 * y0;
out[3] += gz2 * aaaa2 - 8 * rampValue2 * aaa2 * z0;
} else {
double a3 = yAFlipMask0 + zAFlipMask0 + a0;
if(a3 > 0) {
double y3 = y0 - (yNMask | 1);
double z3 = z0 - (zNMask | 1);
double aa3 = a3 * a3, aaa3 = aa3 * a3, aaaa3 = aa3 * aa3;
int gi3 = gradCoordIndex(seed, i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (~zNMask & PRIME_Z));
double gx3 = GRADIENTS_3D[gi3], gy3 = GRADIENTS_3D[gi3 | 1], gz3 = GRADIENTS_3D[gi3 | 2];
double rampValue3 = gx3 * x0 + gy3 * y3 + gz3 * z3;
out[0] += aaaa3 * rampValue3;
out[1] += gx3 * aaaa3 - 8 * rampValue3 * aaa3 * x0;
out[2] += gy3 * aaaa3 - 8 * rampValue3 * aaa3 * y3;
out[3] += gz3 * aaaa3 - 8 * rampValue3 * aaa3 * z3;
}
double a4 = xAFlipMask1 + a1;
if(a4 > 0) {
double x4 = (xNMask | 1) + x1;
double aa4 = a4 * a4, aaa4 = aa4 * a4, aaaa4 = aa4 * aa4;
int gi4 = gradCoordIndex(seed2, i + (xNMask & (PRIME_X << 1)), j + PRIME_Y, k + PRIME_Z);
double gx4 = GRADIENTS_3D[gi4], gy4 = GRADIENTS_3D[gi4 | 1], gz4 = GRADIENTS_3D[gi4 | 2];
double rampValue4 = gx4 * x4 + gy4 * y1 + gz4 * z1;
out[0] += aaaa4 * rampValue4;
out[1] += gx4 * aaaa4 - 8 * rampValue4 * aaa4 * x4;
out[2] += gy4 * aaaa4 - 8 * rampValue4 * aaa4 * y1;
out[3] += gz4 * aaaa4 - 8 * rampValue4 * aaa4 * z1;
skip5 = true;
}
}
boolean skip9 = false;
double a6 = yAFlipMask0 + a0;
if(a6 > 0) {
double y6 = y0 - (yNMask | 1);
double aa6 = a6 * a6, aaa6 = aa6 * a6, aaaa6 = aa6 * aa6;
int gi6 = gradCoordIndex(seed, i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (zNMask & PRIME_Z));
double gx6 = GRADIENTS_3D[gi6], gy6 = GRADIENTS_3D[gi6 | 1], gz6 = GRADIENTS_3D[gi6 | 2];
double rampValue6 = gx6 * x0 + gy6 * y6 + gz6 * z0;
out[0] += aaaa6 * rampValue6;
out[1] += gx6 * aaaa6 - 8 * rampValue6 * aaa6 * x0;
out[2] += gy6 * aaaa6 - 8 * rampValue6 * aaa6 * y6;
out[3] += gz6 * aaaa6 - 8 * rampValue6 * aaa6 * z0;
} else {
double a7 = xAFlipMask0 + zAFlipMask0 + a0;
if(a7 > 0) {
double x7 = x0 - (xNMask | 1);
double z7 = z0 - (zNMask | 1);
double aa7 = a7 * a7, aaa7 = aa7 * a7, aaaa7 = aa7 * aa7;
int gi7 = gradCoordIndex(seed, i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (~zNMask & PRIME_Z));
double gx7 = GRADIENTS_3D[gi7], gy7 = GRADIENTS_3D[gi7 | 1], gz7 = GRADIENTS_3D[gi7 | 2];
double rampValue7 = gx7 * x7 + gy7 * y0 + gz7 * z7;
out[0] += aaaa7 * rampValue7;
out[1] += gx7 * aaaa7 - 8 * rampValue7 * aaa7 * x7;
out[2] += gy7 * aaaa7 - 8 * rampValue7 * aaa7 * y0;
out[3] += gz7 * aaaa7 - 8 * rampValue7 * aaa7 * z7;
}
double a8 = yAFlipMask1 + a1;
if(a8 > 0) {
double y8 = (yNMask | 1) + y1;
double aa8 = a8 * a8, aaa8 = aa8 * a8, aaaa8 = aa8 * aa8;
int gi8 = gradCoordIndex(seed2, i + PRIME_X, j + (yNMask & (PRIME_Y << 1)), k + PRIME_Z);
double gx8 = GRADIENTS_3D[gi8], gy8 = GRADIENTS_3D[gi8 | 1], gz8 = GRADIENTS_3D[gi8 | 2];
double rampValue8 = gx8 * x1 + gy8 * y8 + gz8 * z1;
out[0] += aaaa8 * rampValue8;
out[1] += gx8 * aaaa8 - 8 * rampValue8 * aaa8 * x1;
out[2] += gy8 * aaaa8 - 8 * rampValue8 * aaa8 * y8;
out[3] += gz8 * aaaa8 - 8 * rampValue8 * aaa8 * z1;
skip9 = true;
}
}
boolean skipD = false;
double aA = zAFlipMask0 + a0;
if(aA > 0) {
double zA = z0 - (zNMask | 1);
double aaA = aA * aA, aaaA = aaA * aA, aaaaA = aaA * aaA;
int giA = gradCoordIndex(seed, i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (~zNMask & PRIME_Z));
double gxA = GRADIENTS_3D[giA], gyA = GRADIENTS_3D[giA | 1], gzA = GRADIENTS_3D[giA | 2];
double rampValueA = gxA * x0 + gyA * y0 + gzA * zA;
out[0] += aaaaA * rampValueA;
out[1] += gxA * aaaaA - 8 * rampValueA * aaaA * x0;
out[2] += gyA * aaaaA - 8 * rampValueA * aaaA * y0;
out[3] += gzA * aaaaA - 8 * rampValueA * aaaA * zA;
} else {
double aB = xAFlipMask0 + yAFlipMask0 + a0;
if(aB > 0) {
double xB = x0 - (xNMask | 1);
double yB = y0 - (yNMask | 1);
double aaB = aB * aB, aaaB = aaB * aB, aaaaB = aaB * aaB;
int giB = gradCoordIndex(seed, i + (~xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (zNMask & PRIME_Z));
double gxB = GRADIENTS_3D[giB], gyB = GRADIENTS_3D[giB | 1], gzB = GRADIENTS_3D[giB | 2];
double rampValueB = gxB * xB + gyB * yB + gzB * z0;
out[0] += aaaaB * rampValueB;
out[1] += gxB * aaaaB - 8 * rampValueB * aaaB * xB;
out[2] += gyB * aaaaB - 8 * rampValueB * aaaB * yB;
out[3] += gzB * aaaaB - 8 * rampValueB * aaaB * z0;
}
double aC = zAFlipMask1 + a1;
if(aC > 0) {
double zC = (zNMask | 1) + z1;
double aaC = aC * aC, aaaC = aaC * aC, aaaaC = aaC * aaC;
int giC = gradCoordIndex(seed2, i + PRIME_X, j + PRIME_Y, k + (zNMask & (PRIME_Z << 1)));
double gxC = GRADIENTS_3D[giC], gyC = GRADIENTS_3D[giC | 1], gzC = GRADIENTS_3D[giC | 2];
double rampValueC = gxC * x1 + gyC * y1 + gzC * zC;
out[0] += aaaaC * rampValueC;
out[1] += gxC * aaaaC - 8 * rampValueC * aaaC * x1;
out[2] += gyC * aaaaC - 8 * rampValueC * aaaC * y1;
out[3] += gzC * aaaaC - 8 * rampValueC * aaaC * zC;
skipD = true;
}
}
if(!skip5) {
double a5 = yAFlipMask1 + zAFlipMask1 + a1;
if(a5 > 0) {
double y5 = (yNMask | 1) + y1;
double z5 = (zNMask | 1) + z1;
double aa5 = a5 * a5, aaa5 = aa5 * a5, aaaa5 = aa5 * aa5;
int gi5 = gradCoordIndex(seed2, i + PRIME_X, j + (yNMask & (PRIME_Y << 1)), k + (zNMask & (PRIME_Z << 1)));
double gx5 = GRADIENTS_3D[gi5], gy5 = GRADIENTS_3D[gi5 | 1], gz5 = GRADIENTS_3D[gi5 | 2];
double rampValue5 = gx5 * x1 + gy5 * y5 + gz5 * z5;
out[0] += aaaa5 * rampValue5;
out[1] += gx5 * aaaa5 - 8 * rampValue5 * aaa5 * x1;
out[2] += gy5 * aaaa5 - 8 * rampValue5 * aaa5 * y5;
out[3] += gz5 * aaaa5 - 8 * rampValue5 * aaa5 * z5;
}
}
if(!skip9) {
double a9 = xAFlipMask1 + zAFlipMask1 + a1;
if(a9 > 0) {
double x9 = (xNMask | 1) + x1;
double z9 = (zNMask | 1) + z1;
double aa9 = a9 * a9, aaa9 = aa9 * a9, aaaa9 = aa9 * aa9;
int gi9 = gradCoordIndex(seed2, i + (xNMask & (PRIME_X << 1)), j + PRIME_Y, k + (zNMask & (PRIME_Z << 1)));
double gx9 = GRADIENTS_3D[gi9], gy9 = GRADIENTS_3D[gi9 | 1], gz9 = GRADIENTS_3D[gi9 | 2];
double rampValue9 = gx9 * x9 + gy9 * y1 + gz9 * z9;
out[0] += aaaa9 * rampValue9;
out[1] += gx9 * aaaa9 - 8 * rampValue9 * aaa9 * x9;
out[2] += gy9 * aaaa9 - 8 * rampValue9 * aaa9 * y1;
out[3] += gz9 * aaaa9 - 8 * rampValue9 * aaa9 * z9;
}
}
if(!skipD) {
double aD = xAFlipMask1 + yAFlipMask1 + a1;
if(aD > 0) {
double xD = (xNMask | 1) + x1;
double yD = (yNMask | 1) + y1;
double aaD = aD * aD, aaaD = aaD * aD, aaaaD = aaD * aaD;
int giD = gradCoordIndex(seed2, i + (xNMask & (PRIME_X << 1)), j + (yNMask & (PRIME_Y << 1)), k + PRIME_Z);
double gxD = GRADIENTS_3D[giD], gyD = GRADIENTS_3D[giD | 1], gzD = GRADIENTS_3D[giD | 2];
double rampValueD = gxD * xD + gyD * yD + gzD * z1;
out[0] += aaaaD * rampValueD;
out[1] += gxD * aaaaD - 8 * rampValueD * aaaD * xD;
out[2] += gyD * aaaaD - 8 * rampValueD * aaaD * yD;
out[3] += gzD * aaaaD - 8 * rampValueD * aaaD * z1;
}
}
out[0] *= 9.046026385208288;
out[1] *= 9.046026385208288;
out[2] *= 9.046026385208288;
out[3] *= 9.046026385208288;
return out;
}
}

228
common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/OpenSimplex2Sampler.java
View File

@@ -37,41 +37,37 @@ public class OpenSimplex2Sampler extends SimplexStyleSampler {
i *= PRIME_X;
j *= PRIME_Y;
double n0, n1, n2;
double value = 0;
double a = 0.5 - x0 * x0 - y0 * y0;
if(a <= 0) n0 = 0;
else {
n0 = (a * a) * (a * a) * gradCoord(seed, i, j, x0, y0);
if(a > 0) {
value = (a * a) * (a * a) * gradCoord(seed, i, j, x0, y0);
}
double c = 2 * (1 - 2 * G2) * (1 / G2 - 2) * t + ((-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a);
if(c <= 0) n2 = 0;
else {
if(c > 0) {
double x2 = x0 + (2 * G2 - 1);
double y2 = y0 + (2 * G2 - 1);
n2 = (c * c) * (c * c) * gradCoord(seed, i + PRIME_X, j + PRIME_Y, x2, y2);
value += (c * c) * (c * c) * gradCoord(seed, i + PRIME_X, j + PRIME_Y, x2, y2);
}
if(y0 > x0) {
double x1 = x0 + G2;
double y1 = y0 + (G2 - 1);
double b = 0.5 - x1 * x1 - y1 * y1;
if(b <= 0) n1 = 0;
else {
n1 = (b * b) * (b * b) * gradCoord(seed, i, j + PRIME_Y, x1, y1);
if(b > 0) {
value += (b * b) * (b * b) * gradCoord(seed, i, j + PRIME_Y, x1, y1);
}
} else {
double x1 = x0 + (G2 - 1);
double y1 = y0 + G2;
double b = 0.5 - x1 * x1 - y1 * y1;
if(b <= 0) n1 = 0;
else {
n1 = (b * b) * (b * b) * gradCoord(seed, i + PRIME_X, j, x1, y1);
if(b <= 0) {
value += (b * b) * (b * b) * gradCoord(seed, i + PRIME_X, j, x1, y1);
}
}
return (n0 + n1 + n2) * 99.83685446303647f;
return value * 99.83685446303647f;
}
@Override
@@ -157,4 +153,208 @@ public class OpenSimplex2Sampler extends SimplexStyleSampler {
return value * 32.69428253173828125;
}
@Override
public boolean isDifferentiable() {
return true;
}
@Override
public double[] getNoiseDerivativeRaw(long sl, double x, double y) {
int seed = (int) sl;
// 2D OpenSimplex2 case uses the same algorithm as ordinary Simplex.
final double G2 = (3 - SQRT3) / 6;
final double F2 = 0.5f * (SQRT3 - 1);
double s = (x + y) * F2;
x += s;
y += s;
int i = (int) Math.floor(x);
int j = (int) Math.floor(y);
double xi = x - i;
double yi = y - j;
double t = (xi + yi) * G2;
double x0 = xi - t;
double y0 = yi - t;
i *= PRIME_X;
j *= PRIME_Y;
double[] out = { 0.0f, 0.0f, 0.0f };
double a = 0.5 - x0 * x0 - y0 * y0;
if(a > 0) {
double aa = a * a, aaa = aa * a, aaaa = aa * aa;
int gi = gradCoordIndex(seed, i, j);
double gx = GRADIENTS_2_D[gi], gy = GRADIENTS_2_D[gi | 1];
double rampValue = gx * x0 + gy * y0;
out[0] += aaaa * rampValue;
out[1] += gx * aaaa - 8 * rampValue * aaa * x0;
out[2] += gy * aaaa - 8 * rampValue * aaa * y0;
}
double c = 2 * (1 - 2 * G2) * (1 / G2 - 2) * t + ((-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a);
if(c > 0) {
double x2 = x0 + (2 * G2 - 1);
double y2 = y0 + (2 * G2 - 1);
double cc = c * c, ccc = cc * c, cccc = cc * cc;
int gi = gradCoordIndex(seed, i + PRIME_X, j + PRIME_Y);
double gx = GRADIENTS_2_D[gi], gy = GRADIENTS_2_D[gi | 1];
double rampValue = gx * x2 + gy * y2;
out[0] += cccc * rampValue;
out[1] += gx * cccc - 8 * rampValue * ccc * x2;
out[2] += gy * cccc - 8 * rampValue * ccc * y2;
}
if(y0 > x0) {
double x1 = x0 + G2;
double y1 = y0 + (G2 - 1);
double b = 0.5 - x1 * x1 - y1 * y1;
if(b > 0) {
double bb = b * b, bbb = bb * b, bbbb = bb * bb;
int gi = gradCoordIndex(seed, i, j + PRIME_Y);
double gx = GRADIENTS_2_D[gi], gy = GRADIENTS_2_D[gi | 1];
double rampValue = gx * x1 + gy * y1;
out[0] += bbbb * rampValue;
out[1] += gx * bbbb - 8 * rampValue * bbb * x1;
out[2] += gy * bbbb - 8 * rampValue * bbb * y1;
}
} else {
double x1 = x0 + (G2 - 1);
double y1 = y0 + G2;
double b = 0.5 - x1 * x1 - y1 * y1;
if(b > 0) {
double bb = b * b, bbb = bb * b, bbbb = bb * bb;
int gi = gradCoordIndex(seed, i + PRIME_X, j);
double gx = GRADIENTS_2_D[gi], gy = GRADIENTS_2_D[gi | 1];
double rampValue = gx * x1 + gy * y1;
out[0] += bbbb * rampValue;
out[1] += gx * bbbb - 8 * rampValue * bbb * x1;
out[2] += gy * bbbb - 8 * rampValue * bbb * y1;
}
}
out[0] *= 99.83685446303647f;
out[1] *= 99.83685446303647f;
out[2] *= 99.83685446303647f;
return out;
}
@Override
public double[] getNoiseDerivativeRaw(long sl, double x, double y, double z) {
int seed = (int) sl;
// 3D OpenSimplex2Sampler case uses two offset rotated cube grids.
final double R3 = (2.0 / 3.0);
double r = (x + y + z) * R3; // Rotation, not skew
x = r - x;
y = r - y;
z = r - z;
int i = (int) Math.round(x);
int j = (int) Math.round(y);
int k = (int) Math.round(z);
double x0 = x - i;
double y0 = y - j;
double z0 = z - k;
int xNSign = (int) (-1.0 - x0) | 1;
int yNSign = (int) (-1.0 - y0) | 1;
int zNSign = (int) (-1.0 - z0) | 1;
double ax0 = xNSign * -x0;
double ay0 = yNSign * -y0;
double az0 = zNSign * -z0;
i *= PRIME_X;
j *= PRIME_Y;
k *= PRIME_Z;
double[] out = { 0.0f, 0.0f, 0.0f, 0.0f };
double a = (0.6f - x0 * x0) - (y0 * y0 + z0 * z0);
for(int l = 0; ; l++) {
if(a > 0) {
double aa = a * a, aaa = aa * a, aaaa = aa * aa;
int gi = gradCoordIndex(seed, i, j, k);
double gx = GRADIENTS_3D[gi], gy = GRADIENTS_3D[gi | 1], gz = GRADIENTS_3D[gi | 2];
double rampValue = gx * x0 + gy * y0 + gz * z0;
out[0] += aaaa * rampValue;
out[1] += gx * aaaa - 8 * rampValue * aaa * x0;
out[1] += gy * aaaa - 8 * rampValue * aaa * y0;
out[2] += gz * aaaa - 8 * rampValue * aaa * z0;
}
if(ax0 >= ay0 && ax0 >= az0) {
double b = a + ax0 + ax0;
if(b > 1) {
b -= 1;
double bb = b * b, bbb = bb * b, bbbb = bb * bb;
int gi = gradCoordIndex(seed, i - xNSign * PRIME_X, j, k);
double gx = GRADIENTS_3D[gi], gy = GRADIENTS_3D[gi | 1], gz = GRADIENTS_3D[gi | 2];
double rampValue = gx * (x0 + xNSign) + gy * y0 + gz * z0;
out[0] += bbbb * rampValue;
out[1] += gx * bbbb - 8 * rampValue * bbb * (x0 + xNSign);
out[1] += gy * bbbb - 8 * rampValue * bbb * y0;
out[2] += gz * bbbb - 8 * rampValue * bbb * z0;
}
} else if(ay0 > ax0 && ay0 >= az0) {
double b = a + ay0 + ay0;
if(b > 1) {
b -= 1;
double bb = b * b, bbb = bb * b, bbbb = bb * bb;
int gi = gradCoordIndex(seed, i, j - yNSign * PRIME_Y, k);
double gx = GRADIENTS_3D[gi], gy = GRADIENTS_3D[gi | 1], gz = GRADIENTS_3D[gi | 2];
double rampValue = gx * x0 + gy * (y0 + yNSign) + gz * z0;
out[0] += bbbb * rampValue;
out[1] += gx * bbbb - 8 * rampValue * bbb * x0;
out[1] += gy * bbbb - 8 * rampValue * bbb * (y0 + yNSign);
out[2] += gz * bbbb - 8 * rampValue * bbb * z0;
}
} else {
double b = a + az0 + az0;
if(b > 1) {
b -= 1;
double bb = b * b, bbb = bb * b, bbbb = bb * bb;
int gi = gradCoordIndex(seed, i, j, k - zNSign * PRIME_Z);
double gx = GRADIENTS_3D[gi], gy = GRADIENTS_3D[gi | 1], gz = GRADIENTS_3D[gi | 2];
double rampValue = gx * x0 + gy * y0 + gz * (z0 + zNSign);
out[0] += bbbb * rampValue;
out[1] += gx * bbbb - 8 * rampValue * bbb * x0;
out[1] += gy * bbbb - 8 * rampValue * bbb * y0;
out[2] += gz * bbbb - 8 * rampValue * bbb * (z0 + zNSign);
}
}
if(l == 1) break;
ax0 = 0.5 - ax0;
ay0 = 0.5 - ay0;
az0 = 0.5 - az0;
x0 = xNSign * ax0;
y0 = yNSign * ay0;
z0 = zNSign * az0;
a += (0.75 - ax0) - (ay0 + az0);
i += (xNSign >> 1) & PRIME_X;
j += (yNSign >> 1) & PRIME_Y;
k += (zNSign >> 1) & PRIME_Z;
xNSign = -xNSign;
yNSign = -yNSign;
zNSign = -zNSign;
seed = ~seed;
}
out[0] *= 32.69428253173828125;
out[1] *= 32.69428253173828125;
out[2] *= 32.69428253173828125;
out[3] *= 32.69428253173828125;
return out;
}
}

45
common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/simplex/SimplexStyleSampler.java
View File

@@ -7,13 +7,13 @@
package com.dfsek.terra.addons.noise.samplers.noise.simplex;
import com.dfsek.terra.addons.noise.samplers.noise.NoiseFunction;
import com.dfsek.terra.addons.noise.samplers.noise.DerivativeNoiseFunction;
/**
* Abstract NoiseSampler implementation for simplex-style noise functions.
*/
public abstract class SimplexStyleSampler extends NoiseFunction {
public abstract class SimplexStyleSampler extends DerivativeNoiseFunction {
protected static final double[] GRADIENTS_2_D = {
0.130526192220052d, 0.99144486137381d, 0.38268343236509d, 0.923879532511287d, 0.608761429008721d, 0.793353340291235d,
0.793353340291235d, 0.608761429008721d, 0.923879532511287d, 0.38268343236509d, 0.99144486137381d, 0.130526192220051d,
@@ -79,26 +79,53 @@ public abstract class SimplexStyleSampler extends NoiseFunction {
1, 1, 0, 0, 0, -1, 1, 0, -1, 1, 0, 0, 0, -1, -1, 0
};
protected static double gradCoord(int seed, int xPrimed, int yPrimed, double xd, double yd) {
protected static int gradCoordIndex(int seed, int xPrimed, int yPrimed) {
int hash = hash(seed, xPrimed, yPrimed);
hash ^= hash >> 15;
hash &= 127 << 1;
double xg = GRADIENTS_2_D[hash];
double yg = GRADIENTS_2_D[hash | 1];
return hash;
}
protected static double gradCoord(int seed, int xPrimed, int yPrimed, double xd, double yd) {
int index = gradCoordIndex(seed, xPrimed, yPrimed);
double xg = GRADIENTS_2_D[index];
double yg = GRADIENTS_2_D[index | 1];
return xd * xg + yd * yg;
}
protected static double gradCoord(int seed, int xPrimed, int yPrimed, int zPrimed, double xd, double yd, double zd) {
protected static int gradCoordIndex(int seed, int xPrimed, int yPrimed, int zPrimed) {
int hash = hash(seed, xPrimed, yPrimed, zPrimed);
hash ^= hash >> 15;
hash &= 63 << 2;
double xg = GRADIENTS_3D[hash];
double yg = GRADIENTS_3D[hash | 1];
double zg = GRADIENTS_3D[hash | 2];
return hash;
}
protected static double gradCoord(int seed, int xPrimed, int yPrimed, int zPrimed, double xd, double yd, double zd) {
int index = gradCoordIndex(seed, xPrimed, yPrimed, zPrimed);
double xg = GRADIENTS_3D[index];
double yg = GRADIENTS_3D[index | 1];
double zg = GRADIENTS_3D[index | 2];
return xd * xg + yd * yg + zd * zg;
}
@Override
public double[] getNoiseDerivativeRaw(long seed, double x, double y) {
return new double[]{ 0, 0, 0 };
}
@Override
public double[] getNoiseDerivativeRaw(long seed, double x, double y, double z) {
return new double[]{ 0, 0, 0, 0 };
}
@Override
public boolean isDifferentiable() {
return false;
}
}

10
common/addons/generation-stage-feature/src/main/java/com/dfsek/terra/addons/generation/feature/FeatureGenerationAddon.java
View File

@@ -11,13 +11,6 @@ import com.dfsek.tectonic.api.config.template.dynamic.DynamicTemplate;
import com.dfsek.tectonic.api.config.template.dynamic.DynamicValue;
import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;
import com.dfsek.terra.addons.generation.feature.config.BiomeFeatures;
import com.dfsek.terra.addons.generation.feature.config.FeatureStageTemplate;
import com.dfsek.terra.addons.manifest.api.AddonInitializer;
@@ -35,6 +28,9 @@ import com.dfsek.terra.api.util.reflection.TypeKey;
import com.dfsek.terra.api.world.biome.Biome;
import com.dfsek.terra.api.world.chunk.generation.stage.GenerationStage;
import java.util.*;
import java.util.function.Supplier;
public class FeatureGenerationAddon implements AddonInitializer {
public static final TypeKey<Supplier<ObjectTemplate<GenerationStage>>> STAGE_TYPE_KEY = new TypeKey<>() {

8
common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/parser/ParserUtil.java
View File

@@ -7,15 +7,15 @@
package com.dfsek.terra.addons.terrascript.parser;
import com.dfsek.terra.addons.terrascript.parser.exceptions.ParseException;
import com.dfsek.terra.addons.terrascript.parser.lang.Returnable;
import com.dfsek.terra.addons.terrascript.tokenizer.Token;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.dfsek.terra.addons.terrascript.parser.exceptions.ParseException;
import com.dfsek.terra.addons.terrascript.parser.lang.Returnable;
import com.dfsek.terra.addons.terrascript.tokenizer.Token;
public class ParserUtil {

4
common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/script/builders/CheckBlockFunctionBuilder.java
View File

@@ -7,13 +7,13 @@
package com.dfsek.terra.addons.terrascript.script.builders;
import java.util.List;
import com.dfsek.terra.addons.terrascript.parser.lang.Returnable;
import com.dfsek.terra.addons.terrascript.parser.lang.functions.FunctionBuilder;
import com.dfsek.terra.addons.terrascript.script.functions.CheckBlockFunction;
import com.dfsek.terra.addons.terrascript.tokenizer.Position;
import java.util.List;
public class CheckBlockFunctionBuilder implements FunctionBuilder<CheckBlockFunction> {
@SuppressWarnings("unchecked")

4
common/api/src/main/java/com/dfsek/terra/api/event/events/platform/CommandRegistrationEvent.java
View File

@@ -1,10 +1,10 @@
package com.dfsek.terra.api.event.events.platform;
import org.incendo.cloud.CommandManager;
import com.dfsek.terra.api.command.CommandSender;
import com.dfsek.terra.api.event.events.Event;
import org.incendo.cloud.CommandManager;
public class CommandRegistrationEvent implements Event {
private final CommandManager<CommandSender> commandManager;

45
common/api/src/main/java/com/dfsek/terra/api/noise/DerivativeNoiseSampler.java Normal file
View File

@@ -0,0 +1,45 @@
package com.dfsek.terra.api.noise;
/**
* A NoiseSampler which additionally may provide a 1st directional derivative
*/
public interface DerivativeNoiseSampler extends NoiseSampler {
static boolean isDifferentiable(NoiseSampler sampler) {
if(sampler instanceof DerivativeNoiseSampler dSampler) {
return dSampler.isDifferentiable();
}
return false;
}
/**
* Samplers may or may not be able to provide a derivative depending on what
* inputs they take, this method signals whether this is the case.
*
* @return If the noise sampler provides a derivative or not
*/
boolean isDifferentiable();
/**
* Derivative return version of standard 2D noise evaluation
*
* @param seed
* @param x
* @param y
*
* @return 3 element array, in index order: noise value, partial x derivative, partial y derivative
*/
double[] noised(long seed, double x, double y);
/**
* Derivative return version of standard 3D noise evaluation
*
* @param seed
* @param x
* @param y
* @param z
*
* @return 4 element array, in index order: noise value, partial x derivative, partial y derivative, partial z derivative
*/
double[] noised(long seed, double x, double y, double z);
}

7
common/implementation/base/src/main/java/com/dfsek/terra/config/preprocessor/MetaNumberPreprocessor.java
View File

@@ -24,14 +24,15 @@ import com.dfsek.tectonic.api.depth.DepthTracker;
import com.dfsek.tectonic.api.exception.LoadException;
import com.dfsek.tectonic.api.loader.ConfigLoader;
import com.dfsek.tectonic.api.preprocessor.Result;
import com.dfsek.terra.api.config.meta.Meta;
import com.dfsek.terra.api.util.reflection.TypeKey;
import org.jetbrains.annotations.NotNull;
import java.lang.reflect.AnnotatedType;
import java.util.Map;
import com.dfsek.terra.api.config.meta.Meta;
import com.dfsek.terra.api.util.reflection.TypeKey;
public class MetaNumberPreprocessor extends MetaPreprocessor<Meta> {
public static final TypeKey<String> META_STRING_KEY = new TypeKey<@Meta String>() {

17
common/implementation/base/src/main/java/com/dfsek/terra/event/FunctionalEventHandlerImpl.java
View File

@@ -17,6 +17,17 @@
package com.dfsek.terra.event;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.dfsek.terra.api.addon.BaseAddon;
import com.dfsek.terra.api.event.events.Event;
import com.dfsek.terra.api.event.events.FailThroughEvent;
@@ -25,12 +36,6 @@ import com.dfsek.terra.api.event.functional.EventContext;
import com.dfsek.terra.api.event.functional.FunctionalEventHandler;
import com.dfsek.terra.api.util.reflection.TypeKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.Type;
import java.util.*;
public class FunctionalEventHandlerImpl implements FunctionalEventHandler {
private static final Logger logger = LoggerFactory.getLogger(FunctionalEventHandlerImpl.class);

6
platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/BukkitEntity.java
View File

@@ -17,14 +17,14 @@
package com.dfsek.terra.bukkit;
import io.papermc.lib.PaperLib;
import org.bukkit.Location;
import com.dfsek.terra.api.entity.Entity;
import com.dfsek.terra.api.util.vector.Vector3;
import com.dfsek.terra.api.world.ServerWorld;
import com.dfsek.terra.bukkit.world.BukkitAdapter;
import io.papermc.lib.PaperLib;
import org.bukkit.Location;
public class BukkitEntity implements Entity {
private final org.bukkit.entity.Entity entity;

4
platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/world/BukkitWorldProperties.java
View File

@@ -1,9 +1,9 @@
package com.dfsek.terra.bukkit.world;
import org.bukkit.generator.WorldInfo;
import com.dfsek.terra.api.world.info.WorldProperties;
import org.bukkit.generator.WorldInfo;
public class BukkitWorldProperties implements WorldProperties {
private final WorldInfo delegate;

4
platforms/bukkit/common/src/main/resources/plugin.yml
View File

@@ -2,8 +2,8 @@ name: "Terra"
main: "com.dfsek.terra.bukkit.TerraBukkitPlugin"
version: "@VERSION@"
load: "STARTUP"
author: dfsek
authors: [ "dfsek", "duplexsystem", "Astrash", "solonovamax", "Sancires", "Aureus", "RogueShade" ]
website: "@WIKI@"
api-version: "1.20"
api-version: "1.21.1"
description: "@DESCRIPTION@"
folia-supported: true

10
platforms/fabric/src/main/resources/fabric.mod.json
View File

@@ -5,7 +5,13 @@
"name": "Terra",
"description": "@DESCRIPTION@",
"authors": [
"dfsek"
"dfsek",
"duplexsystem",
"Astrash",
"solonovamax",
"Sancires",
"Aureus",
"RogueShade"
],
"contact": {
"homepage": "@WIKI@",
@@ -28,7 +34,7 @@
"depends": {
"fabricloader": ">=0.16.5",
"java": ">=21",
"minecraft": ">=1.20.6",
"minecraft": ">=1.21.1",
"fabric": "*"
}
}

6
platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/LifecycleEntryPoint.java
View File

@@ -1,5 +1,8 @@
package com.dfsek.terra.lifecycle;
import com.dfsek.terra.api.command.CommandSender;
import com.dfsek.terra.api.event.events.platform.CommandRegistrationEvent;
import net.minecraft.server.command.ServerCommandSource;
import org.incendo.cloud.SenderMapper;
import org.incendo.cloud.execution.ExecutionCoordinator;
@@ -7,9 +10,6 @@ import org.incendo.cloud.fabric.FabricServerCommandManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.dfsek.terra.api.command.CommandSender;
import com.dfsek.terra.api.event.events.platform.CommandRegistrationEvent;
public final class LifecycleEntryPoint {
private static final Logger logger = LoggerFactory.getLogger(LifecycleEntryPoint.class);

1
platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/mixin/lifecycle/MinecraftServerMixin.java
View File

@@ -18,6 +18,7 @@ import com.dfsek.terra.lifecycle.LifecyclePlatform;
import static com.dfsek.terra.lifecycle.util.LifecycleUtil.initialized;
@Mixin(MinecraftServer.class)
public class MinecraftServerMixin {
@Inject(method = "<init>(Ljava/lang/Thread;Lnet/minecraft/world/level/storage/LevelStorage$Session;" +

1
platforms/mixin-lifecycle/src/main/java/com/dfsek/terra/lifecycle/util/LifecycleUtil.java
View File

@@ -13,6 +13,7 @@ import com.dfsek.terra.mod.CommonPlatform;
public final class LifecycleUtil {
public static boolean initialized = false;
private LifecycleUtil() {
}