TerrainProvider.java

net.minecraft.data.worldgen.TerrainProvider

信息

• 全限定名：net.minecraft.data.worldgen.TerrainProvider
• 类型：public class
• 包：net.minecraft.data.worldgen
• 源码路径：src/main/java/net/minecraft/data/worldgen/TerrainProvider.java
• 起始行号：L8
• 职责：

  TODO

字段/常量

• DEEP_OCEAN_CONTINENTALNESS

  • 类型: float
  • 修饰符: private static final
  • 源码定位: L9
  • 说明:

    TODO

• OCEAN_CONTINENTALNESS

  • 类型: float
  • 修饰符: private static final
  • 源码定位: L10
  • 说明:

    TODO

• PLAINS_CONTINENTALNESS

  • 类型: float
  • 修饰符: private static final
  • 源码定位: L11
  • 说明:

    TODO

• BEACH_CONTINENTALNESS

  • 类型: float
  • 修饰符: private static final
  • 源码定位: L12
  • 说明:

    TODO

• NO_TRANSFORM

  • 类型: BoundedFloatFunction<Float>
  • 修饰符: private static final
  • 源码定位: L13
  • 说明:

    TODO

• AMPLIFIED_OFFSET

  • 类型: BoundedFloatFunction<Float>
  • 修饰符: private static final
  • 源码定位: L14
  • 说明:

    TODO

• AMPLIFIED_FACTOR

  • 类型: BoundedFloatFunction<Float>
  • 修饰符: private static final
  • 源码定位: L15
  • 说明:

    TODO

• AMPLIFIED_JAGGEDNESS

  • 类型: BoundedFloatFunction<Float>
  • 修饰符: private static final
  • 源码定位: L16
  • 说明:

    TODO

内部类/嵌套类型

• 无

构造器

• 无

方法

下面的方法块按源码顺序生成。

public static <C,I extends BoundedFloatFunction<C>> CubicSpline<C,I> overworldOffset(I continents, I erosion, I ridges, boolean amplified) @ L18

• 方法名：overworldOffset
• 源码定位：L18
• 返回类型：<C,I extends BoundedFloatFunction> CubicSpline<C,I>
• 修饰符：public static

参数:

• continents: I
• erosion: I
• ridges: I
• amplified: boolean

说明:

TODO

public static <C,I extends BoundedFloatFunction<C>> CubicSpline<C,I> overworldFactor(I continents, I erosion, I weirdness, I ridges, boolean amplified) @ L38

• 方法名：overworldFactor
• 源码定位：L38
• 返回类型：<C,I extends BoundedFloatFunction> CubicSpline<C,I>
• 修饰符：public static

参数:

• continents: I
• erosion: I
• weirdness: I
• ridges: I
• amplified: boolean

说明:

TODO

public static <C,I extends BoundedFloatFunction<C>> CubicSpline<C,I> overworldJaggedness(I continents, I erosion, I weirdness, I ridges, boolean amplified) @ L49

• 方法名：overworldJaggedness
• 源码定位：L49
• 返回类型：<C,I extends BoundedFloatFunction> CubicSpline<C,I>
• 修饰符：public static

参数:

• continents: I
• erosion: I
• weirdness: I
• ridges: I
• amplified: boolean

说明:

TODO

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

• 方法名：buildErosionJaggednessSpline
• 源码定位：L61
• 返回类型：<C,I extends BoundedFloatFunction> CubicSpline<C,I>
• 修饰符：private static

参数:

• erosion: I
• weirdness: I
• ridges: I
• jaggednessFactorAtPeakRidgeAndErosionIndex0: float
• jaggednessFactorAtPeakRidgeAndErosionIndex1: float
• jaggednessFactorAtHighRidgeAndErosionIndex0: float
• jaggednessFactorAtHighRidgeAndErosionIndex1: float
• jaggednessTransformer: BoundedFloatFunction

说明:

TODO

private static <C,I extends BoundedFloatFunction<C>> CubicSpline<C,I> buildRidgeJaggednessSpline(I weirdness, I ridges, float jaggednessFactorAtPeakRidge, float jaggednessFactorAtHighRidge, BoundedFloatFunction<Float> jaggednessTransformer) @ L86

• 方法名：buildRidgeJaggednessSpline
• 源码定位：L86
• 返回类型：<C,I extends BoundedFloatFunction> CubicSpline<C,I>
• 修饰符：private static

参数:

• weirdness: I
• ridges: I
• jaggednessFactorAtPeakRidge: float
• jaggednessFactorAtHighRidge: float
• jaggednessTransformer: BoundedFloatFunction

说明:

TODO

private static <C,I extends BoundedFloatFunction<C>> CubicSpline<C,I> buildWeirdnessJaggednessSpline(I weirdness, float jaggednessFactor, BoundedFloatFunction<Float> jaggednessTransformer) @ L109

• 方法名：buildWeirdnessJaggednessSpline
• 源码定位：L109
• 返回类型：<C,I extends BoundedFloatFunction> CubicSpline<C,I>
• 修饰符：private static

参数:

• weirdness: I
• jaggednessFactor: float
• jaggednessTransformer: BoundedFloatFunction

说明:

TODO

private static <C,I extends BoundedFloatFunction<C>> CubicSpline<C,I> getErosionFactor(I erosion, I weirdness, I ridges, float baseValue, boolean shatteredTerrain, BoundedFloatFunction<Float> factorTransformer) @ L120

• 方法名：getErosionFactor
• 源码定位：L120
• 返回类型：<C,I extends BoundedFloatFunction> CubicSpline<C,I>
• 修饰符：private static

参数:

• erosion: I
• weirdness: I
• ridges: I
• baseValue: float
• shatteredTerrain: boolean
• factorTransformer: BoundedFloatFunction

说明:

TODO

private static float calculateSlope(float y1, float y2, float x1, float x2) @ L160

• 方法名：calculateSlope
• 源码定位：L160
• 返回类型：float
• 修饰符：private static

参数:

• y1: float
• y2: float
• x1: float
• x2: float

说明:

TODO

private static <C,I extends BoundedFloatFunction<C>> CubicSpline<C,I> buildMountainRidgeSplineWithPoints(I ridges, float modulation, boolean saddle, BoundedFloatFunction<Float> offsetTransformer) @ L164

• 方法名：buildMountainRidgeSplineWithPoints
• 源码定位：L164
• 返回类型：<C,I extends BoundedFloatFunction> CubicSpline<C,I>
• 修饰符：private static

参数:

• ridges: I
• modulation: float
• saddle: boolean
• offsetTransformer: BoundedFloatFunction

说明:

TODO

private static float mountainContinentalness(float ridge, float modulation, float allowRiversBelow) @ L204

• 方法名：mountainContinentalness
• 源码定位：L204
• 返回类型：float
• 修饰符：private static

参数:

• ridge: float
• modulation: float
• allowRiversBelow: float

说明:

TODO

private static float calculateMountainRidgeZeroContinentalnessPoint(float modulation) @ L214

• 方法名：calculateMountainRidgeZeroContinentalnessPoint
• 源码定位：L214
• 返回类型：float
• 修饰符：private static

参数:

• modulation: float

说明:

TODO

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

• 方法名：buildErosionOffsetSpline
• 源码定位：L222
• 返回类型：<C,I extends BoundedFloatFunction> CubicSpline<C,I>
• 修饰符：public static

参数:

• erosion: I
• ridges: I
• lowValley: float
• hill: float
• tallHill: float
• mountainFactor: float
• plain: float
• swamp: float
• includeExtremeHills: boolean
• saddle: boolean
• offsetTransformer: BoundedFloatFunction

说明:

TODO

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

• 方法名：ridgeSpline
• 源码定位：L277
• 返回类型：<C,I extends BoundedFloatFunction> CubicSpline<C,I>
• 修饰符：private static

参数:

• ridges: I
• valley: float
• low: float
• mid: float
• high: float
• peaks: float
• minValleySteepness: float
• offsetTransformer: BoundedFloatFunction

说明:

TODO

代码

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 = buildErosionOffsetSpline(erosion, ridges, -0.15F, 0.0F, 0.0F, 0.1F, 0.0F, -0.03F, false, false, offsetTransformer);
        CubicSpline<C, I> lowSpline = buildErosionOffsetSpline(erosion, ridges, -0.1F, 0.03F, 0.1F, 0.1F, 0.01F, -0.03F, false, false, offsetTransformer);
        CubicSpline<C, I> midSpline = buildErosionOffsetSpline(erosion, ridges, -0.1F, 0.03F, 0.1F, 0.7F, 0.01F, -0.03F, true, true, offsetTransformer);
        CubicSpline<C, I> highSpline = buildErosionOffsetSpline(erosion, ridges, -0.05F, 0.03F, 0.1F, 1.0F, 0.01F, 0.01F, true, true, offsetTransformer);
        return CubicSpline.<C, I>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.<C, I>builder(continents, NO_TRANSFORM)
            .addPoint(-0.19F, 3.95F)
            .addPoint(-0.15F, getErosionFactor(erosion, weirdness, ridges, 6.25F, true, NO_TRANSFORM))
            .addPoint(-0.1F, getErosionFactor(erosion, weirdness, ridges, 5.47F, true, factorTransformer))
            .addPoint(0.03F, getErosionFactor(erosion, weirdness, ridges, 5.08F, true, factorTransformer))
            .addPoint(0.06F, 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.<C, I>builder(continents, jaggednessTransformer)
            .addPoint(-0.11F, 0.0F)
            .addPoint(0.03F, buildErosionJaggednessSpline(erosion, weirdness, ridges, 1.0F, 0.5F, 0.0F, 0.0F, jaggednessTransformer))
            .addPoint(0.65F, 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 = buildRidgeJaggednessSpline(
            weirdness, ridges, jaggednessFactorAtPeakRidgeAndErosionIndex0, jaggednessFactorAtHighRidgeAndErosionIndex0, jaggednessTransformer
        );
        CubicSpline<C, I> ridgeJaggednessSplineAtErosion1 = buildRidgeJaggednessSpline(
            weirdness, ridges, jaggednessFactorAtPeakRidgeAndErosionIndex1, jaggednessFactorAtHighRidgeAndErosionIndex1, jaggednessTransformer
        );
        return CubicSpline.<C, I>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, buildWeirdnessJaggednessSpline(weirdness, jaggednessFactorAtHighRidge, jaggednessTransformer));
        } else {
            ridgeSpline.addPoint(highSliceMiddle, 0.0F);
        }
 
        if (jaggednessFactorAtPeakRidge > 0.0F) {
            ridgeSpline.addPoint(1.0F, 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.<C, I>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<C, I> baseSpline = CubicSpline.<C, I>builder(weirdness, factorTransformer).addPoint(-0.2F, 6.3F).addPoint(0.2F, baseValue).build();
        CubicSpline.Builder<C, I> erosionPoints = CubicSpline.<C, I>builder(erosion, factorTransformer)
            .addPoint(-0.6F, baseSpline)
            .addPoint(-0.5F, CubicSpline.<C, I>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.<C, I>builder(weirdness, factorTransformer).addPoint(-0.05F, 2.67F).addPoint(0.05F, 6.3F).build())
            .addPoint(0.03F, baseSpline);
        if (shatteredTerrain) {
            CubicSpline<C, I> weirdnessShattered = CubicSpline.<C, I>builder(weirdness, factorTransformer)
                .addPoint(0.0F, baseValue)
                .addPoint(0.1F, 0.625F)
                .build();
            CubicSpline<C, I> ridgesShattered = CubicSpline.<C, I>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<C, I> extremeHillsTerrainFromMidSliceAndUp = CubicSpline.<C, I>builder(ridges, factorTransformer)
                .addPoint(-0.7F, baseSpline)
                .addPoint(-0.15F, 1.37F)
                .build();
            CubicSpline<C, I> extra3dNoiseOnPeaksOnly = CubicSpline.<C, I>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<C, I> build = CubicSpline.builder(ridges, offsetTransformer);
        float allowRiversBelow = -0.7F;
        float minPoint = -1.0F;
        float minPointContinentalness = mountainContinentalness(-1.0F, modulation, -0.7F);
        float maxPoint = 1.0F;
        float maxPointContinentalness = mountainContinentalness(1.0F, modulation, -0.7F);
        float ridgeZeroPoint = calculateMountainRidgeZeroContinentalnessPoint(modulation);
        float afterRiverPoint = -0.65F;
        if (-0.65F < ridgeZeroPoint && ridgeZeroPoint < 1.0F) {
            float afterRiverThresholdContinentalness = mountainContinentalness(-0.65F, modulation, -0.7F);
            float beforeRiverPoint = -0.75F;
            float beforeRiverThresholdContinentalness = mountainContinentalness(-0.75F, modulation, -0.7F);
            float minPointDerivative = 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 = mountainContinentalness(ridgeZeroPoint, modulation, -0.7F);
            float maxPointDerivative = 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 = 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;
        return ridge < allowRiversBelow ? Math.max(continentalness, -0.2222F) : 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 = buildMountainRidgeSplineWithPoints(ridges, Mth.lerp(mountainFactor, 0.6F, 1.5F), saddle, offsetTransformer);
        CubicSpline<C, I> lowErosionMountains = buildMountainRidgeSplineWithPoints(ridges, Mth.lerp(mountainFactor, 0.6F, 1.0F), saddle, offsetTransformer);
        CubicSpline<C, I> mountains = buildMountainRidgeSplineWithPoints(ridges, mountainFactor, saddle, offsetTransformer);
        CubicSpline<C, I> widePlateau = 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 = ridgeSpline(
            ridges, lowValley, plain * mountainFactor, hill * mountainFactor, 0.5F * mountainFactor, 0.6F * mountainFactor, 0.5F, offsetTransformer
        );
        CubicSpline<C, I> plains = ridgeSpline(ridges, lowValley, plain, plain, hill, tallHill, 0.5F, offsetTransformer);
        CubicSpline<C, I> plainsFarInland = ridgeSpline(ridges, lowValley, plain, plain, hill, tallHill, 0.5F, offsetTransformer);
        CubicSpline<C, I> extremeHills = CubicSpline.<C, I>builder(ridges, offsetTransformer)
            .addPoint(-1.0F, lowValley)
            .addPoint(-0.4F, plains)
            .addPoint(0.0F, tallHill + 0.07F)
            .build();
        CubicSpline<C, I> swamps = ridgeSpline(ridges, -0.02F, swamp, swamp, hill, tallHill, 0.0F, offsetTransformer);
        CubicSpline.Builder<C, I> builder = CubicSpline.<C, I>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.<C, I>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();
    }
}

引用的其他类

• BoundedFloatFunction

  • 引用位置: 参数/字段/方法调用/返回值
  • 关联成员: BoundedFloatFunction.createUnlimited()

• CubicSpline

  • 引用位置: 方法调用/返回值
  • 关联成员: CubicSpline.builder()

• Mth

  • 引用位置: 方法调用
  • 关联成员: Mth.lerp()

• NoiseRouterData

  • 引用位置: 方法调用
  • 关联成员: NoiseRouterData.peaksAndValleys()