177 lines
15 KiB
Java
177 lines
15 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*/
|
|
package net.minecraft.data.worldgen;
|
|
|
|
import net.minecraft.util.BoundedFloatFunction;
|
|
import net.minecraft.util.CubicSpline;
|
|
import net.minecraft.util.Mth;
|
|
import net.minecraft.world.level.levelgen.NoiseRouterData;
|
|
|
|
public class TerrainProvider {
|
|
private static final float DEEP_OCEAN_CONTINENTALNESS = -0.51f;
|
|
private static final float OCEAN_CONTINENTALNESS = -0.4f;
|
|
private static final float PLAINS_CONTINENTALNESS = 0.1f;
|
|
private static final float BEACH_CONTINENTALNESS = -0.15f;
|
|
private static final BoundedFloatFunction<Float> NO_TRANSFORM = BoundedFloatFunction.IDENTITY;
|
|
private static final BoundedFloatFunction<Float> AMPLIFIED_OFFSET = BoundedFloatFunction.createUnlimited(offset -> offset < 0.0f ? offset : offset * 2.0f);
|
|
private static final BoundedFloatFunction<Float> AMPLIFIED_FACTOR = BoundedFloatFunction.createUnlimited(factor -> 1.25f - 6.25f / (factor + 5.0f));
|
|
private static final BoundedFloatFunction<Float> AMPLIFIED_JAGGEDNESS = BoundedFloatFunction.createUnlimited(jaggedness -> jaggedness * 2.0f);
|
|
|
|
public static <C, I extends BoundedFloatFunction<C>> CubicSpline<C, I> overworldOffset(I continents, I erosion, I ridges, boolean amplified) {
|
|
BoundedFloatFunction<Float> offsetTransformer = amplified ? AMPLIFIED_OFFSET : NO_TRANSFORM;
|
|
CubicSpline<C, I> beachSpline = TerrainProvider.buildErosionOffsetSpline(erosion, ridges, -0.15f, 0.0f, 0.0f, 0.1f, 0.0f, -0.03f, false, false, offsetTransformer);
|
|
CubicSpline<C, I> lowSpline = TerrainProvider.buildErosionOffsetSpline(erosion, ridges, -0.1f, 0.03f, 0.1f, 0.1f, 0.01f, -0.03f, false, false, offsetTransformer);
|
|
CubicSpline<C, I> midSpline = TerrainProvider.buildErosionOffsetSpline(erosion, ridges, -0.1f, 0.03f, 0.1f, 0.7f, 0.01f, -0.03f, true, true, offsetTransformer);
|
|
CubicSpline<C, I> highSpline = TerrainProvider.buildErosionOffsetSpline(erosion, ridges, -0.05f, 0.03f, 0.1f, 1.0f, 0.01f, 0.01f, true, true, offsetTransformer);
|
|
return CubicSpline.builder(continents, offsetTransformer).addPoint(-1.1f, 0.044f).addPoint(-1.02f, -0.2222f).addPoint(-0.51f, -0.2222f).addPoint(-0.44f, -0.12f).addPoint(-0.18f, -0.12f).addPoint(-0.16f, beachSpline).addPoint(-0.15f, beachSpline).addPoint(-0.1f, lowSpline).addPoint(0.25f, midSpline).addPoint(1.0f, highSpline).build();
|
|
}
|
|
|
|
public static <C, I extends BoundedFloatFunction<C>> CubicSpline<C, I> overworldFactor(I continents, I erosion, I weirdness, I ridges, boolean amplified) {
|
|
BoundedFloatFunction<Float> factorTransformer = amplified ? AMPLIFIED_FACTOR : NO_TRANSFORM;
|
|
return CubicSpline.builder(continents, NO_TRANSFORM).addPoint(-0.19f, 3.95f).addPoint(-0.15f, TerrainProvider.getErosionFactor(erosion, weirdness, ridges, 6.25f, true, NO_TRANSFORM)).addPoint(-0.1f, TerrainProvider.getErosionFactor(erosion, weirdness, ridges, 5.47f, true, factorTransformer)).addPoint(0.03f, TerrainProvider.getErosionFactor(erosion, weirdness, ridges, 5.08f, true, factorTransformer)).addPoint(0.06f, TerrainProvider.getErosionFactor(erosion, weirdness, ridges, 4.69f, false, factorTransformer)).build();
|
|
}
|
|
|
|
public static <C, I extends BoundedFloatFunction<C>> CubicSpline<C, I> overworldJaggedness(I continents, I erosion, I weirdness, I ridges, boolean amplified) {
|
|
BoundedFloatFunction<Float> jaggednessTransformer = amplified ? AMPLIFIED_JAGGEDNESS : NO_TRANSFORM;
|
|
float farInlandMiddle = 0.65f;
|
|
return CubicSpline.builder(continents, jaggednessTransformer).addPoint(-0.11f, 0.0f).addPoint(0.03f, TerrainProvider.buildErosionJaggednessSpline(erosion, weirdness, ridges, 1.0f, 0.5f, 0.0f, 0.0f, jaggednessTransformer)).addPoint(0.65f, TerrainProvider.buildErosionJaggednessSpline(erosion, weirdness, ridges, 1.0f, 1.0f, 1.0f, 0.0f, jaggednessTransformer)).build();
|
|
}
|
|
|
|
private static <C, I extends BoundedFloatFunction<C>> CubicSpline<C, I> buildErosionJaggednessSpline(I erosion, I weirdness, I ridges, float jaggednessFactorAtPeakRidgeAndErosionIndex0, float jaggednessFactorAtPeakRidgeAndErosionIndex1, float jaggednessFactorAtHighRidgeAndErosionIndex0, float jaggednessFactorAtHighRidgeAndErosionIndex1, BoundedFloatFunction<Float> jaggednessTransformer) {
|
|
float erosionIndex1Middle = -0.5775f;
|
|
CubicSpline<C, I> ridgeJaggednessSplineAtErosion0 = TerrainProvider.buildRidgeJaggednessSpline(weirdness, ridges, jaggednessFactorAtPeakRidgeAndErosionIndex0, jaggednessFactorAtHighRidgeAndErosionIndex0, jaggednessTransformer);
|
|
CubicSpline<C, I> ridgeJaggednessSplineAtErosion1 = TerrainProvider.buildRidgeJaggednessSpline(weirdness, ridges, jaggednessFactorAtPeakRidgeAndErosionIndex1, jaggednessFactorAtHighRidgeAndErosionIndex1, jaggednessTransformer);
|
|
return CubicSpline.builder(erosion, jaggednessTransformer).addPoint(-1.0f, ridgeJaggednessSplineAtErosion0).addPoint(-0.78f, ridgeJaggednessSplineAtErosion1).addPoint(-0.5775f, ridgeJaggednessSplineAtErosion1).addPoint(-0.375f, 0.0f).build();
|
|
}
|
|
|
|
private static <C, I extends BoundedFloatFunction<C>> CubicSpline<C, I> buildRidgeJaggednessSpline(I weirdness, I ridges, float jaggednessFactorAtPeakRidge, float jaggednessFactorAtHighRidge, BoundedFloatFunction<Float> jaggednessTransformer) {
|
|
float highSliceStart = NoiseRouterData.peaksAndValleys(0.4f);
|
|
float highSliceEnd = NoiseRouterData.peaksAndValleys(0.56666666f);
|
|
float highSliceMiddle = (highSliceStart + highSliceEnd) / 2.0f;
|
|
CubicSpline.Builder<C, I> ridgeSpline = CubicSpline.builder(ridges, jaggednessTransformer);
|
|
ridgeSpline.addPoint(highSliceStart, 0.0f);
|
|
if (jaggednessFactorAtHighRidge > 0.0f) {
|
|
ridgeSpline.addPoint(highSliceMiddle, TerrainProvider.buildWeirdnessJaggednessSpline(weirdness, jaggednessFactorAtHighRidge, jaggednessTransformer));
|
|
} else {
|
|
ridgeSpline.addPoint(highSliceMiddle, 0.0f);
|
|
}
|
|
if (jaggednessFactorAtPeakRidge > 0.0f) {
|
|
ridgeSpline.addPoint(1.0f, TerrainProvider.buildWeirdnessJaggednessSpline(weirdness, jaggednessFactorAtPeakRidge, jaggednessTransformer));
|
|
} else {
|
|
ridgeSpline.addPoint(1.0f, 0.0f);
|
|
}
|
|
return ridgeSpline.build();
|
|
}
|
|
|
|
private static <C, I extends BoundedFloatFunction<C>> CubicSpline<C, I> buildWeirdnessJaggednessSpline(I weirdness, float jaggednessFactor, BoundedFloatFunction<Float> jaggednessTransformer) {
|
|
float maxJaggednessAtNegativeWeirdness = 0.63f * jaggednessFactor;
|
|
float maxJaggednessAtPositiveWeirdness = 0.3f * jaggednessFactor;
|
|
return CubicSpline.builder(weirdness, jaggednessTransformer).addPoint(-0.01f, maxJaggednessAtNegativeWeirdness).addPoint(0.01f, maxJaggednessAtPositiveWeirdness).build();
|
|
}
|
|
|
|
private static <C, I extends BoundedFloatFunction<C>> CubicSpline<C, I> getErosionFactor(I erosion, I weirdness, I ridges, float baseValue, boolean shatteredTerrain, BoundedFloatFunction<Float> factorTransformer) {
|
|
CubicSpline baseSpline = CubicSpline.builder(weirdness, factorTransformer).addPoint(-0.2f, 6.3f).addPoint(0.2f, baseValue).build();
|
|
CubicSpline.Builder erosionPoints = CubicSpline.builder(erosion, factorTransformer).addPoint(-0.6f, baseSpline).addPoint(-0.5f, CubicSpline.builder(weirdness, factorTransformer).addPoint(-0.05f, 6.3f).addPoint(0.05f, 2.67f).build()).addPoint(-0.35f, baseSpline).addPoint(-0.25f, baseSpline).addPoint(-0.1f, CubicSpline.builder(weirdness, factorTransformer).addPoint(-0.05f, 2.67f).addPoint(0.05f, 6.3f).build()).addPoint(0.03f, baseSpline);
|
|
if (shatteredTerrain) {
|
|
CubicSpline weirdnessShattered = CubicSpline.builder(weirdness, factorTransformer).addPoint(0.0f, baseValue).addPoint(0.1f, 0.625f).build();
|
|
CubicSpline ridgesShattered = CubicSpline.builder(ridges, factorTransformer).addPoint(-0.9f, baseValue).addPoint(-0.69f, weirdnessShattered).build();
|
|
erosionPoints.addPoint(0.35f, baseValue).addPoint(0.45f, ridgesShattered).addPoint(0.55f, ridgesShattered).addPoint(0.62f, baseValue);
|
|
} else {
|
|
CubicSpline extremeHillsTerrainFromMidSliceAndUp = CubicSpline.builder(ridges, factorTransformer).addPoint(-0.7f, baseSpline).addPoint(-0.15f, 1.37f).build();
|
|
CubicSpline extra3dNoiseOnPeaksOnly = CubicSpline.builder(ridges, factorTransformer).addPoint(0.45f, baseSpline).addPoint(0.7f, 1.56f).build();
|
|
erosionPoints.addPoint(0.05f, extra3dNoiseOnPeaksOnly).addPoint(0.4f, extra3dNoiseOnPeaksOnly).addPoint(0.45f, extremeHillsTerrainFromMidSliceAndUp).addPoint(0.55f, extremeHillsTerrainFromMidSliceAndUp).addPoint(0.58f, baseValue);
|
|
}
|
|
return erosionPoints.build();
|
|
}
|
|
|
|
private static float calculateSlope(float y1, float y2, float x1, float x2) {
|
|
return (y2 - y1) / (x2 - x1);
|
|
}
|
|
|
|
private static <C, I extends BoundedFloatFunction<C>> CubicSpline<C, I> buildMountainRidgeSplineWithPoints(I ridges, float modulation, boolean saddle, BoundedFloatFunction<Float> offsetTransformer) {
|
|
CubicSpline.Builder build = CubicSpline.builder(ridges, offsetTransformer);
|
|
float allowRiversBelow = -0.7f;
|
|
float minPoint = -1.0f;
|
|
float minPointContinentalness = TerrainProvider.mountainContinentalness(-1.0f, modulation, -0.7f);
|
|
float maxPoint = 1.0f;
|
|
float maxPointContinentalness = TerrainProvider.mountainContinentalness(1.0f, modulation, -0.7f);
|
|
float ridgeZeroPoint = TerrainProvider.calculateMountainRidgeZeroContinentalnessPoint(modulation);
|
|
float afterRiverPoint = -0.65f;
|
|
if (-0.65f < ridgeZeroPoint && ridgeZeroPoint < 1.0f) {
|
|
float afterRiverThresholdContinentalness = TerrainProvider.mountainContinentalness(-0.65f, modulation, -0.7f);
|
|
float beforeRiverPoint = -0.75f;
|
|
float beforeRiverThresholdContinentalness = TerrainProvider.mountainContinentalness(-0.75f, modulation, -0.7f);
|
|
float minPointDerivative = TerrainProvider.calculateSlope(minPointContinentalness, beforeRiverThresholdContinentalness, -1.0f, -0.75f);
|
|
build.addPoint(-1.0f, minPointContinentalness, minPointDerivative);
|
|
build.addPoint(-0.75f, beforeRiverThresholdContinentalness);
|
|
build.addPoint(-0.65f, afterRiverThresholdContinentalness);
|
|
float ridgeZeroPointContinentalness = TerrainProvider.mountainContinentalness(ridgeZeroPoint, modulation, -0.7f);
|
|
float maxPointDerivative = TerrainProvider.calculateSlope(ridgeZeroPointContinentalness, maxPointContinentalness, ridgeZeroPoint, 1.0f);
|
|
float smallOffset = 0.01f;
|
|
build.addPoint(ridgeZeroPoint - 0.01f, ridgeZeroPointContinentalness);
|
|
build.addPoint(ridgeZeroPoint, ridgeZeroPointContinentalness, maxPointDerivative);
|
|
build.addPoint(1.0f, maxPointContinentalness, maxPointDerivative);
|
|
} else {
|
|
float simpleDerivative = TerrainProvider.calculateSlope(minPointContinentalness, maxPointContinentalness, -1.0f, 1.0f);
|
|
if (saddle) {
|
|
build.addPoint(-1.0f, Math.max(0.2f, minPointContinentalness));
|
|
build.addPoint(0.0f, Mth.lerp(0.5f, minPointContinentalness, maxPointContinentalness), simpleDerivative);
|
|
} else {
|
|
build.addPoint(-1.0f, minPointContinentalness, simpleDerivative);
|
|
}
|
|
build.addPoint(1.0f, maxPointContinentalness, simpleDerivative);
|
|
}
|
|
return build.build();
|
|
}
|
|
|
|
private static float mountainContinentalness(float ridge, float modulation, float allowRiversBelow) {
|
|
float ridgeOffset = 1.17f;
|
|
float ridgeAmplitude = 0.46082947f;
|
|
float ridgeSlope = 1.0f - (1.0f - modulation) * 0.5f;
|
|
float ridgeIntersect = 0.5f * (1.0f - modulation);
|
|
float adjustedRidgeHeight = (ridge + 1.17f) * 0.46082947f;
|
|
float continentalness = adjustedRidgeHeight * ridgeSlope - ridgeIntersect;
|
|
if (ridge < allowRiversBelow) {
|
|
return Math.max(continentalness, -0.2222f);
|
|
}
|
|
return Math.max(continentalness, 0.0f);
|
|
}
|
|
|
|
private static float calculateMountainRidgeZeroContinentalnessPoint(float modulation) {
|
|
float ridgeOffset = 1.17f;
|
|
float ridgeAmplitude = 0.46082947f;
|
|
float ridgeSlope = 1.0f - (1.0f - modulation) * 0.5f;
|
|
float ridgeIntersect = 0.5f * (1.0f - modulation);
|
|
return ridgeIntersect / (0.46082947f * ridgeSlope) - 1.17f;
|
|
}
|
|
|
|
public static <C, I extends BoundedFloatFunction<C>> CubicSpline<C, I> buildErosionOffsetSpline(I erosion, I ridges, float lowValley, float hill, float tallHill, float mountainFactor, float plain, float swamp, boolean includeExtremeHills, boolean saddle, BoundedFloatFunction<Float> offsetTransformer) {
|
|
float lowPeaks = 0.6f;
|
|
float valleyPlateau = 0.5f;
|
|
float plateau = 0.5f;
|
|
CubicSpline<C, I> veryLowErosionMountains = TerrainProvider.buildMountainRidgeSplineWithPoints(ridges, Mth.lerp(mountainFactor, 0.6f, 1.5f), saddle, offsetTransformer);
|
|
CubicSpline<C, I> lowErosionMountains = TerrainProvider.buildMountainRidgeSplineWithPoints(ridges, Mth.lerp(mountainFactor, 0.6f, 1.0f), saddle, offsetTransformer);
|
|
CubicSpline<C, I> mountains = TerrainProvider.buildMountainRidgeSplineWithPoints(ridges, mountainFactor, saddle, offsetTransformer);
|
|
CubicSpline<C, I> widePlateau = TerrainProvider.ridgeSpline(ridges, lowValley - 0.15f, 0.5f * mountainFactor, Mth.lerp(0.5f, 0.5f, 0.5f) * mountainFactor, 0.5f * mountainFactor, 0.6f * mountainFactor, 0.5f, offsetTransformer);
|
|
CubicSpline<C, I> narrowPlateau = TerrainProvider.ridgeSpline(ridges, lowValley, plain * mountainFactor, hill * mountainFactor, 0.5f * mountainFactor, 0.6f * mountainFactor, 0.5f, offsetTransformer);
|
|
CubicSpline<C, I> plains = TerrainProvider.ridgeSpline(ridges, lowValley, plain, plain, hill, tallHill, 0.5f, offsetTransformer);
|
|
CubicSpline<C, I> plainsFarInland = TerrainProvider.ridgeSpline(ridges, lowValley, plain, plain, hill, tallHill, 0.5f, offsetTransformer);
|
|
CubicSpline extremeHills = CubicSpline.builder(ridges, offsetTransformer).addPoint(-1.0f, lowValley).addPoint(-0.4f, plains).addPoint(0.0f, tallHill + 0.07f).build();
|
|
CubicSpline<C, I> swamps = TerrainProvider.ridgeSpline(ridges, -0.02f, swamp, swamp, hill, tallHill, 0.0f, offsetTransformer);
|
|
CubicSpline.Builder<C, I> builder = CubicSpline.builder(erosion, offsetTransformer).addPoint(-0.85f, veryLowErosionMountains).addPoint(-0.7f, lowErosionMountains).addPoint(-0.4f, mountains).addPoint(-0.35f, widePlateau).addPoint(-0.1f, narrowPlateau).addPoint(0.2f, plains);
|
|
if (includeExtremeHills) {
|
|
builder.addPoint(0.4f, plainsFarInland).addPoint(0.45f, extremeHills).addPoint(0.55f, extremeHills).addPoint(0.58f, plainsFarInland);
|
|
}
|
|
builder.addPoint(0.7f, swamps);
|
|
return builder.build();
|
|
}
|
|
|
|
private static <C, I extends BoundedFloatFunction<C>> CubicSpline<C, I> ridgeSpline(I ridges, float valley, float low, float mid, float high, float peaks, float minValleySteepness, BoundedFloatFunction<Float> offsetTransformer) {
|
|
float d1 = Math.max(0.5f * (low - valley), minValleySteepness);
|
|
float d2 = 5.0f * (mid - low);
|
|
return CubicSpline.builder(ridges, offsetTransformer).addPoint(-1.0f, valley, d1).addPoint(-0.4f, low, Math.min(d1, d2)).addPoint(0.0f, mid, d2).addPoint(0.4f, high, 2.0f * (high - mid)).addPoint(1.0f, peaks, 0.7f * (peaks - high)).build();
|
|
}
|
|
}
|
|
|