From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: HaHaWTH <102713261+HaHaWTH@users.noreply.github.com> Date: Tue, 9 Nov 2077 00:00:00 +0800 Subject: [PATCH] Faster Random Generator This patch replaces LegacyRandomSource with FasterRandomSource by default, which is faster in general. Benchmark results (10,000,000 iterations) (GraalVM 21) SimpleRandom (Moonrise): 80ms FasterRandomSource (Leaf) (Backed by Xoroshiro128PlusPlus): 35ms LegacyRandomSource (Vanilla): 200ms XoroshiroRandomSource (Vanilla): 47ms diff --git a/src/main/java/net/minecraft/util/RandomSource.java b/src/main/java/net/minecraft/util/RandomSource.java index 252aef3ffe0fecd47ebea1ed7df48e14fa873eb9..5b4599927effca11293b367c5bac4541570df06c 100644 --- a/src/main/java/net/minecraft/util/RandomSource.java +++ b/src/main/java/net/minecraft/util/RandomSource.java @@ -15,18 +15,32 @@ public interface RandomSource { return create(RandomSupport.generateUniqueSeed()); } + // Leaf start - Faster random generator @Deprecated static RandomSource createThreadSafe() { - return new ThreadSafeLegacyRandomSource(RandomSupport.generateUniqueSeed()); + return org.dreeam.leaf.config.modules.opt.FastRNG.enabled + ? new org.dreeam.leaf.util.math.random.FasterRandomSource(RandomSupport.generateUniqueSeed()) + : new ThreadSafeLegacyRandomSource(RandomSupport.generateUniqueSeed()); } static RandomSource create(long seed) { - return new LegacyRandomSource(seed); + return org.dreeam.leaf.config.modules.opt.FastRNG.enabled + ? new org.dreeam.leaf.util.math.random.FasterRandomSource(seed) + : new LegacyRandomSource(seed); + } + + static RandomSource createForSlimeChunk(long seed) { + return org.dreeam.leaf.config.modules.opt.FastRNG.enabled && !org.dreeam.leaf.config.modules.opt.FastRNG.useLegacyForSlimeChunk + ? new org.dreeam.leaf.util.math.random.FasterRandomSource(seed) + : new LegacyRandomSource(seed); } static RandomSource createNewThreadLocalInstance() { - return new SingleThreadedRandomSource(ThreadLocalRandom.current().nextLong()); + return org.dreeam.leaf.config.modules.opt.FastRNG.enabled + ? new org.dreeam.leaf.util.math.random.FasterRandomSource(RandomSupport.generateUniqueSeed()) + : new SingleThreadedRandomSource(ThreadLocalRandom.current().nextLong()); } + // Leaf end - Faster random generator RandomSource fork(); diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java index ee64667e5c33afd68d4458bffd858c66db4c1421..8ac2b3a17d1a9df6695c8034b71544704be23036 100644 --- a/src/main/java/net/minecraft/world/entity/Entity.java +++ b/src/main/java/net/minecraft/world/entity/Entity.java @@ -184,7 +184,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess } // Paper start - Share random for entities to make them more random - public static RandomSource SHARED_RANDOM = new RandomRandomSource(); + public static RandomSource SHARED_RANDOM = org.dreeam.leaf.config.modules.opt.FastRNG.enabled ? org.dreeam.leaf.util.math.random.FasterRandomSource.SHARED_INSTANCE : new RandomRandomSource(); // Leaf - Faster random generator // Paper start - replace random private static final class RandomRandomSource extends ca.spottedleaf.moonrise.common.util.ThreadUnsafeRandom { public RandomRandomSource() { diff --git a/src/main/java/net/minecraft/world/level/biome/Biome.java b/src/main/java/net/minecraft/world/level/biome/Biome.java index b725eea9d3ca81d2ef7802f5d0346d924aa1f808..c669c64189b9ae3ddd871290d18e54e3aa7463ea 100644 --- a/src/main/java/net/minecraft/world/level/biome/Biome.java +++ b/src/main/java/net/minecraft/world/level/biome/Biome.java @@ -50,14 +50,14 @@ public final class Biome { ); public static final Codec> CODEC = RegistryFileCodec.create(Registries.BIOME, DIRECT_CODEC); public static final Codec> LIST_CODEC = RegistryCodecs.homogeneousList(Registries.BIOME, DIRECT_CODEC); - private static final PerlinSimplexNoise TEMPERATURE_NOISE = new PerlinSimplexNoise(new WorldgenRandom(new LegacyRandomSource(1234L)), ImmutableList.of(0)); + private static final PerlinSimplexNoise TEMPERATURE_NOISE = new PerlinSimplexNoise(new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(1234L) : new LegacyRandomSource(1234L)), ImmutableList.of(0)); // Leaf - Faster random generator static final PerlinSimplexNoise FROZEN_TEMPERATURE_NOISE = new PerlinSimplexNoise( - new WorldgenRandom(new LegacyRandomSource(3456L)), ImmutableList.of(-2, -1, 0) + new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(3456L) : new LegacyRandomSource(3456L)), ImmutableList.of(-2, -1, 0) // Leaf - Faster random generator ); @Deprecated( forRemoval = true ) - public static final PerlinSimplexNoise BIOME_INFO_NOISE = new PerlinSimplexNoise(new WorldgenRandom(new LegacyRandomSource(2345L)), ImmutableList.of(0)); + public static final PerlinSimplexNoise BIOME_INFO_NOISE = new PerlinSimplexNoise(new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(2345L) : new LegacyRandomSource(2345L)), ImmutableList.of(0)); // Leaf - Faster random generator private static final int TEMPERATURE_CACHE_SIZE = 1024; public final Biome.ClimateSettings climateSettings; private final BiomeGenerationSettings generationSettings; diff --git a/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java b/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java index 1582771de72f713c155427587feea73ca7b4b273..c731c13f69dcf92de539707ccddc7089192a2f7c 100644 --- a/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java +++ b/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java @@ -494,7 +494,7 @@ public abstract class ChunkGenerator { int x = ichunkaccess.getPos().x; int z = ichunkaccess.getPos().z; for (org.bukkit.generator.BlockPopulator populator : world.getPopulators()) { - WorldgenRandom seededrandom = new WorldgenRandom(new net.minecraft.world.level.levelgen.LegacyRandomSource(generatoraccessseed.getSeed())); + WorldgenRandom seededrandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(generatoraccessseed.getSeed()) : new net.minecraft.world.level.levelgen.LegacyRandomSource(generatoraccessseed.getSeed())); // Leaf - Faster random generator seededrandom.setDecorationSeed(generatoraccessseed.getSeed(), x, z); populator.populate(world, new org.bukkit.craftbukkit.util.RandomSourceWrapper.RandomWrapper(seededrandom), x, z, limitedRegion); } @@ -594,7 +594,7 @@ public abstract class ChunkGenerator { chunkcoordintpair.x, chunkcoordintpair.z, su.plo.matter.Globals.Salt.GENERATE_FEATURE, 0 ); } else { - seededrandom = new WorldgenRandom(new LegacyRandomSource(0L)); + seededrandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0L) : new LegacyRandomSource(0L)); // Leaf - Faster random generator seededrandom.setLargeFeatureSeed(placementCalculator.getLevelSeed(), chunkcoordintpair.x, chunkcoordintpair.z); } diff --git a/src/main/java/net/minecraft/world/level/levelgen/DensityFunctions.java b/src/main/java/net/minecraft/world/level/levelgen/DensityFunctions.java index ac8447e20531ad59d5e26c6db541d6e844d56c0f..0dab53e8e99e7de71cbd2d22a283b49bac635178 100644 --- a/src/main/java/net/minecraft/world/level/levelgen/DensityFunctions.java +++ b/src/main/java/net/minecraft/world/level/levelgen/DensityFunctions.java @@ -521,7 +521,7 @@ public final class DensityFunctions { // Paper end - Perf: Optimize end generation public EndIslandDensityFunction(long seed) { - RandomSource randomSource = new LegacyRandomSource(seed); + RandomSource randomSource = org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(seed) : new LegacyRandomSource(seed); // Leaf - Faster random generator randomSource.consumeCount(17292); this.islandNoise = new SimplexNoise(randomSource); } diff --git a/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java b/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java index aa63b49738ef42122e7cd0f9dbec0d019c9b97b0..bd0eaa7d5253fd4ea9f9a6f0c7bfcf11fbc675a7 100644 --- a/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java +++ b/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java @@ -232,7 +232,7 @@ public final class NoiseBasedChunkGenerator extends ChunkGenerator { BiomeManager biomemanager1 = biomeAccess.withDifferentSource((j, k, l) -> { return this.biomeSource.getNoiseBiome(j, k, l, noiseConfig.sampler()); }); - WorldgenRandom seededrandom = new WorldgenRandom(new LegacyRandomSource(RandomSupport.generateUniqueSeed())); + WorldgenRandom seededrandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(RandomSupport.generateUniqueSeed()) : new LegacyRandomSource(RandomSupport.generateUniqueSeed())); // Leaf - Faster random generator boolean flag = true; ChunkPos chunkcoordintpair = chunk.getPos(); NoiseChunk noisechunk = chunk.getOrCreateNoiseChunk((ichunkaccess1) -> { @@ -427,7 +427,7 @@ public final class NoiseBasedChunkGenerator extends ChunkGenerator { if (!((NoiseGeneratorSettings) this.settings.value()).disableMobGeneration()) { ChunkPos chunkcoordintpair = region.getCenter(); Holder holder = region.getBiome(chunkcoordintpair.getWorldPosition().atY(region.getMaxY())); - WorldgenRandom seededrandom = new WorldgenRandom(new LegacyRandomSource(RandomSupport.generateUniqueSeed())); + WorldgenRandom seededrandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(RandomSupport.generateUniqueSeed()) : new LegacyRandomSource(RandomSupport.generateUniqueSeed())); // Leaf - Faster random generator seededrandom.setDecorationSeed(region.getSeed(), chunkcoordintpair.getMinBlockX(), chunkcoordintpair.getMinBlockZ()); NaturalSpawner.spawnMobsForChunkGeneration(region, holder, chunkcoordintpair, seededrandom); diff --git a/src/main/java/net/minecraft/world/level/levelgen/WorldgenRandom.java b/src/main/java/net/minecraft/world/level/levelgen/WorldgenRandom.java index c6efe6faf68c7a7b1df344e2e527aa7e44bfacb8..fe89e7b7c4267ee2969d1505f83cba1ac17cb13e 100644 --- a/src/main/java/net/minecraft/world/level/levelgen/WorldgenRandom.java +++ b/src/main/java/net/minecraft/world/level/levelgen/WorldgenRandom.java @@ -69,9 +69,9 @@ public class WorldgenRandom extends LegacyRandomSource { } public static RandomSource seedSlimeChunk(int chunkX, int chunkZ, long worldSeed, long scrambler) { - return RandomSource.create( + return RandomSource.createForSlimeChunk( worldSeed + (long)(chunkX * chunkX * 4987142) + (long)(chunkX * 5947611) + (long)(chunkZ * chunkZ) * 4392871L + (long)(chunkZ * 389711) ^ scrambler - ); + ); // Leaf - Faster RNG } public static enum Algorithm { diff --git a/src/main/java/net/minecraft/world/level/levelgen/feature/GeodeFeature.java b/src/main/java/net/minecraft/world/level/levelgen/feature/GeodeFeature.java index 56888e150a48cf338ecec591d47c979b5c24ad4d..321eb6b9f6ae244c74b801a7d6556dceb82a19dc 100644 --- a/src/main/java/net/minecraft/world/level/levelgen/feature/GeodeFeature.java +++ b/src/main/java/net/minecraft/world/level/levelgen/feature/GeodeFeature.java @@ -44,7 +44,7 @@ public class GeodeFeature extends Feature { // Leaf start - Matter - Feature Secure Seed WorldgenRandom worldgenRandom = org.dreeam.leaf.config.modules.misc.SecureSeed.enabled ? new su.plo.matter.WorldgenCryptoRandom(0, 0, su.plo.matter.Globals.Salt.GEODE_FEATURE, 0) - : new WorldgenRandom(new LegacyRandomSource(worldGenLevel.getSeed())); + : new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(worldGenLevel.getSeed()) : new LegacyRandomSource(worldGenLevel.getSeed())); // Leaf - Faster random generator // Leaf end - Matter - Feature Secure Seed NormalNoise normalNoise = NormalNoise.create(worldgenRandom, -4, 1.0); List list2 = Lists.newLinkedList(); diff --git a/src/main/java/net/minecraft/world/level/levelgen/feature/stateproviders/DualNoiseProvider.java b/src/main/java/net/minecraft/world/level/levelgen/feature/stateproviders/DualNoiseProvider.java index c7eabcbf9132c5dac1e376332f563d8912447b03..8b8cef5f8e73185ea2f8143fbd4fb5f5afc9ef6e 100644 --- a/src/main/java/net/minecraft/world/level/levelgen/feature/stateproviders/DualNoiseProvider.java +++ b/src/main/java/net/minecraft/world/level/levelgen/feature/stateproviders/DualNoiseProvider.java @@ -43,7 +43,7 @@ public class DualNoiseProvider extends NoiseProvider { this.variety = variety; this.slowNoiseParameters = slowNoiseParameters; this.slowScale = slowScale; - this.slowNoise = NormalNoise.create(new WorldgenRandom(new LegacyRandomSource(seed)), slowNoiseParameters); + this.slowNoise = NormalNoise.create(new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(seed) : new LegacyRandomSource(seed)), slowNoiseParameters); // Leaf - Faster random generator } @Override diff --git a/src/main/java/net/minecraft/world/level/levelgen/feature/stateproviders/NoiseBasedStateProvider.java b/src/main/java/net/minecraft/world/level/levelgen/feature/stateproviders/NoiseBasedStateProvider.java index 990457fb23d22c3b8732d70da54ac5aaed8221db..f55475b812fd989d076c7715b8f060ab8f9ddd26 100644 --- a/src/main/java/net/minecraft/world/level/levelgen/feature/stateproviders/NoiseBasedStateProvider.java +++ b/src/main/java/net/minecraft/world/level/levelgen/feature/stateproviders/NoiseBasedStateProvider.java @@ -28,7 +28,7 @@ public abstract class NoiseBasedStateProvider extends BlockStateProvider { this.seed = seed; this.parameters = noiseParameters; this.scale = scale; - this.noise = NormalNoise.create(new WorldgenRandom(new LegacyRandomSource(seed)), noiseParameters); + this.noise = NormalNoise.create(new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(seed) : new LegacyRandomSource(seed)), noiseParameters); // Leaf - Faster random generator } protected double getNoiseValue(BlockPos pos, double scale) { diff --git a/src/main/java/net/minecraft/world/level/levelgen/structure/Structure.java b/src/main/java/net/minecraft/world/level/levelgen/structure/Structure.java index c10efc79d2cab84703fa4ee6267e12b856f8e248..fb44cb370bdda8d161603ab06851dea6cbbc9d08 100644 --- a/src/main/java/net/minecraft/world/level/levelgen/structure/Structure.java +++ b/src/main/java/net/minecraft/world/level/levelgen/structure/Structure.java @@ -240,7 +240,7 @@ public abstract class Structure { ); } // Leaf end - Matter - Feature Secure Seed - WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L)); + WorldgenRandom worldgenRandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0L) : new LegacyRandomSource(0L)); // Leaf - Faster random generator worldgenRandom.setLargeFeatureSeed(seed, chunkPos.x, chunkPos.z); return worldgenRandom; } diff --git a/src/main/java/net/minecraft/world/level/levelgen/structure/placement/RandomSpreadStructurePlacement.java b/src/main/java/net/minecraft/world/level/levelgen/structure/placement/RandomSpreadStructurePlacement.java index 5ae511a5a178b0202e6a60cb882fca37a2a92fd4..c763b8a11786d8d746ee72218805aad601deaad4 100644 --- a/src/main/java/net/minecraft/world/level/levelgen/structure/placement/RandomSpreadStructurePlacement.java +++ b/src/main/java/net/minecraft/world/level/levelgen/structure/placement/RandomSpreadStructurePlacement.java @@ -78,7 +78,7 @@ public class RandomSpreadStructurePlacement extends StructurePlacement { i, j, su.plo.matter.Globals.Salt.POTENTIONAL_FEATURE, this.salt ); } else { - worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L)); + worldgenRandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0L) : new LegacyRandomSource(0L)); // Leaf - Faster random generator worldgenRandom.setLargeFeatureWithSalt(seed, i, j, this.salt()); } // Leaf end - Matter - Feature Secure Seed diff --git a/src/main/java/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java b/src/main/java/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java index d97bb945f59dc7d8da1374fda5beee0d6d0f0f5d..9973f89e65a6a6f7edfbd40b722f1d7b030872d5 100644 --- a/src/main/java/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java +++ b/src/main/java/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java @@ -125,7 +125,7 @@ public abstract class StructurePlacement { chunkX, chunkZ, su.plo.matter.Globals.Salt.UNDEFINED, salt ); } else { - worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L)); + worldgenRandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0L) : new LegacyRandomSource(0L)); // Leaf - Faster random generator worldgenRandom.setLargeFeatureWithSalt(seed, salt, chunkX, chunkZ); } // Leaf end - Matter - Feature Secure Seed @@ -134,7 +134,7 @@ public abstract class StructurePlacement { } private static boolean legacyProbabilityReducerWithDouble(long seed, int salt, int chunkX, int chunkZ, float frequency, @org.jetbrains.annotations.Nullable Integer saltOverride) { // Paper - Add missing structure set seed configs - WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L)); + WorldgenRandom worldgenRandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0L) : new LegacyRandomSource(0L)); // Leaf - Faster random generator if (saltOverride == null) { // Paper - Add missing structure set seed configs worldgenRandom.setLargeFeatureSeed(seed, chunkX, chunkZ); // Paper start - Add missing structure set seed configs @@ -146,7 +146,7 @@ public abstract class StructurePlacement { } private static boolean legacyArbitrarySaltProbabilityReducer(long seed, int salt, int chunkX, int chunkZ, float frequency, @org.jetbrains.annotations.Nullable Integer saltOverride) { // Paper - Add missing structure set seed configs - WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L)); + WorldgenRandom worldgenRandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0L) : new LegacyRandomSource(0L)); // Leaf - Faster random generator worldgenRandom.setLargeFeatureWithSalt(seed, chunkX, chunkZ, saltOverride != null ? saltOverride : HIGHLY_ARBITRARY_RANDOM_SALT); // Paper - Add missing structure set seed configs return worldgenRandom.nextFloat() < frequency; } @@ -154,7 +154,7 @@ public abstract class StructurePlacement { private static boolean legacyPillagerOutpostReducer(long seed, int salt, int chunkX, int chunkZ, float frequency, @org.jetbrains.annotations.Nullable Integer saltOverride) { // Paper - Add missing structure set seed configs; ignore here int i = chunkX >> 4; int j = chunkZ >> 4; - WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L)); + WorldgenRandom worldgenRandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0L) : new LegacyRandomSource(0L)); // Leaf - Faster random generator worldgenRandom.setSeed((long)(i ^ j << 4) ^ seed); worldgenRandom.nextInt(); return worldgenRandom.nextInt((int)(1.0F / frequency)) == 0; diff --git a/src/main/java/net/minecraft/world/level/levelgen/structure/structures/OceanMonumentStructure.java b/src/main/java/net/minecraft/world/level/levelgen/structure/structures/OceanMonumentStructure.java index 9693641e4129458d94f78a487d66d27fe35cd94e..019f9fb994a1836b73a68cfc9e120515884fba1e 100644 --- a/src/main/java/net/minecraft/world/level/levelgen/structure/structures/OceanMonumentStructure.java +++ b/src/main/java/net/minecraft/world/level/levelgen/structure/structures/OceanMonumentStructure.java @@ -55,7 +55,7 @@ public class OceanMonumentStructure extends Structure { if (pieces.isEmpty()) { return pieces; } else { - WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(RandomSupport.generateUniqueSeed())); + WorldgenRandom worldgenRandom = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(RandomSupport.generateUniqueSeed()) : new LegacyRandomSource(RandomSupport.generateUniqueSeed())); // Leaf - Faster random generator worldgenRandom.setLargeFeatureSeed(worldSeed, pos.x, pos.z); StructurePiece structurePiece = pieces.pieces().get(0); BoundingBox boundingBox = structurePiece.getBoundingBox(); diff --git a/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinSimplexNoise.java b/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinSimplexNoise.java index 64bddc5c2722f7d2a18c31dc654547907b663710..b7302317d47a13c153b7c9fea993635c8f347ef4 100644 --- a/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinSimplexNoise.java +++ b/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinSimplexNoise.java @@ -43,7 +43,7 @@ public class PerlinSimplexNoise { if (j > 0) { long n = (long)(simplexNoise.getValue(simplexNoise.xo, simplexNoise.yo, simplexNoise.zo) * 9.223372E18F); - RandomSource randomSource = new WorldgenRandom(new LegacyRandomSource(n)); + RandomSource randomSource = new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(n) : new LegacyRandomSource(n)); // Leaf - Faster random generator for (int o = l - 1; o >= 0; o--) { if (o < k && octaves.contains(l - o)) { diff --git a/src/main/java/org/bukkit/craftbukkit/generator/CustomChunkGenerator.java b/src/main/java/org/bukkit/craftbukkit/generator/CustomChunkGenerator.java index e34060c21755c61228ba91e468b7c92fc4c4cf0c..b45349c38011aca9b55fa9a82438e67b338cff6f 100644 --- a/src/main/java/org/bukkit/craftbukkit/generator/CustomChunkGenerator.java +++ b/src/main/java/org/bukkit/craftbukkit/generator/CustomChunkGenerator.java @@ -95,7 +95,7 @@ public class CustomChunkGenerator extends InternalChunkGenerator { } private static WorldgenRandom getSeededRandom() { - return new WorldgenRandom(new LegacyRandomSource(0)); + return new WorldgenRandom(org.dreeam.leaf.config.modules.opt.FastRNG.worldgenEnabled() ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0) : new LegacyRandomSource(0)); // Leaf - Faster random generator } @Override diff --git a/src/main/java/org/dreeam/leaf/config/modules/opt/FastRNG.java b/src/main/java/org/dreeam/leaf/config/modules/opt/FastRNG.java new file mode 100644 index 0000000000000000000000000000000000000000..c0fe3e9dfed1bbf3d1f5848b343928d9b80c443b --- /dev/null +++ b/src/main/java/org/dreeam/leaf/config/modules/opt/FastRNG.java @@ -0,0 +1,80 @@ +package org.dreeam.leaf.config.modules.opt; + +import org.dreeam.leaf.config.ConfigModules; +import org.dreeam.leaf.config.EnumConfigCategory; +import org.dreeam.leaf.config.LeafConfig; + +import java.util.random.RandomGeneratorFactory; + +public class FastRNG extends ConfigModules { + + public String getBasePath() { + return EnumConfigCategory.PERF.getBaseKeyName() + ".faster-random-generator"; + } + + public static boolean enabled = false; + public static boolean enableForWorldgen = false; + public static String randomGenerator = "Xoroshiro128PlusPlus"; + public static boolean warnForSlimeChunk = true; + public static boolean useLegacyForSlimeChunk = false; + + public static boolean worldgenEnabled() { return enabled && enableForWorldgen; } // Helper function + @Override + public void onLoaded() { + config.addCommentRegionBased(getBasePath(), """ + Use faster random generator? + Requires a JVM that supports RandomGenerator. + Some JREs don't support this.""", + """ + 是否使用更快的随机生成器? + 需要支持 RandomGenerator 的 JVM. + 一些 JRE 不支持此功能."""); + + enabled = config.getBoolean(getBasePath() + ".enabled", enabled); + randomGenerator = config.getString(getBasePath() + ".random-generator", randomGenerator, + config.pickStringRegionBased( + """ + Which random generator will be used? + See https://openjdk.org/jeps/356""", + """ + 使用什么种类的随机生成器. + 请参阅 https://openjdk.org/jeps/356""")); + enableForWorldgen = config.getBoolean(getBasePath() + ".enable-for-worldgen", enableForWorldgen, + config.pickStringRegionBased( + """ + Enable faster random generator for world generation. + WARNING: This will affect world generation!!!""", + """ + 是否为世界生成启用更快的随机生成器. + 警告: 此项会影响世界生成!!!""")); + warnForSlimeChunk = config.getBoolean(getBasePath() + ".warn-for-slime-chunk", warnForSlimeChunk, + config.pickStringRegionBased( + "Warn if you are not using legacy random source for slime chunk generation.", + "是否在没有为史莱姆区块使用原版随机生成器的情况下进行警告.")); + useLegacyForSlimeChunk = config.getBoolean(getBasePath() + ".use-legacy-random-for-slime-chunk", useLegacyForSlimeChunk, config.pickStringRegionBased( + """ + Use legacy random source for slime chunk generation, + to follow vanilla behavior.""", + """ + 是否使用原版随机生成器来生成史莱姆区块.""")); + + if (enabled) { + try { + RandomGeneratorFactory.of(randomGenerator); + } catch (Exception e) { + LeafConfig.LOGGER.error("Faster random generator is enabled but {} is not supported by your JVM, " + + "falling back to legacy random source.", randomGenerator); + enabled = false; + } + } + + if (enabled && warnForSlimeChunk) { + LeafConfig.LOGGER.warn("You enabled faster random generator, it will offset location of slime chunk"); + LeafConfig.LOGGER.warn("If your server has slime farms or facilities need vanilla slime chunk,"); + LeafConfig.LOGGER.warn("set performance.faster-random-generator.use-legacy-random-for-slime-chunk " + + "to true to use LegacyRandomSource for slime chunk generation."); + LeafConfig.LOGGER.warn("Set performance.faster-random-generator.warn-for-slime-chunk to false to " + + "disable this warning."); + } + } +} diff --git a/src/main/java/org/dreeam/leaf/util/math/random/FasterRandomSource.java b/src/main/java/org/dreeam/leaf/util/math/random/FasterRandomSource.java new file mode 100644 index 0000000000000000000000000000000000000000..77fe5ab83535156c016a4808969ae76bd6b92288 --- /dev/null +++ b/src/main/java/org/dreeam/leaf/util/math/random/FasterRandomSource.java @@ -0,0 +1,127 @@ +package org.dreeam.leaf.util.math.random; + +import com.google.common.annotations.VisibleForTesting; +import net.minecraft.util.Mth; +import net.minecraft.util.RandomSource; +import net.minecraft.world.level.levelgen.BitRandomSource; +import net.minecraft.world.level.levelgen.PositionalRandomFactory; +import org.dreeam.leaf.config.modules.opt.FastRNG; + +import java.util.concurrent.ThreadLocalRandom; +import java.util.random.RandomGenerator; +import java.util.random.RandomGeneratorFactory; + + +public class FasterRandomSource implements BitRandomSource { + private static final int INT_BITS = 48; + private static final long SEED_MASK = 0xFFFFFFFFFFFFL; + private static final long MULTIPLIER = 25214903917L; + private static final long INCREMENT = 11L; + private static final RandomGeneratorFactory RANDOM_GENERATOR_FACTORY = RandomGeneratorFactory.of(FastRNG.randomGenerator); + private static final boolean isSplittableGenerator = RANDOM_GENERATOR_FACTORY.isSplittable(); + private long seed; + private RandomGenerator randomGenerator; + public static final FasterRandomSource SHARED_INSTANCE = new FasterRandomSource(ThreadLocalRandom.current().nextLong()); + + public FasterRandomSource(long seed) { + this.seed = seed; + this.randomGenerator = RANDOM_GENERATOR_FACTORY.create(seed); + } + + private FasterRandomSource(long seed, RandomGenerator.SplittableGenerator randomGenerator) { + this.seed = seed; + this.randomGenerator = randomGenerator; + } + + @Override + public final RandomSource fork() { + if (isSplittableGenerator) { + return new FasterRandomSource(seed, ((RandomGenerator.SplittableGenerator) this.randomGenerator).split()); + } + return new FasterRandomSource(this.nextLong()); + } + + @Override + public final PositionalRandomFactory forkPositional() { + return new FasterRandomSourcePositionalRandomFactory(this.seed); + } + + @Override + public final void setSeed(long seed) { + this.seed = seed; + this.randomGenerator = RANDOM_GENERATOR_FACTORY.create(seed); + } + + @Override + public final int next(int bits) { + // >>> instead of Mojang's >> fixes MC-239059 + return (int) ((seed * MULTIPLIER + INCREMENT & SEED_MASK) >>> INT_BITS - bits); + } + + public static class FasterRandomSourcePositionalRandomFactory implements PositionalRandomFactory { + private final long seed; + + public FasterRandomSourcePositionalRandomFactory(long seed) { + this.seed = seed; + } + + @Override + public RandomSource at(int x, int y, int z) { + long l = Mth.getSeed(x, y, z); + long m = l ^ this.seed; + return new FasterRandomSource(m); + } + + @Override + public RandomSource fromHashOf(String seed) { + int i = seed.hashCode(); + return new FasterRandomSource((long)i ^ this.seed); + } + + @Override + public RandomSource fromSeed(long seed) { + return new FasterRandomSource(seed); + } + + @VisibleForTesting + @Override + public void parityConfigString(StringBuilder info) { + info.append("FasterRandomSourcePositionalRandomFactory{").append(this.seed).append("}"); + } + } + + @Override + public final int nextInt() { + return randomGenerator.nextInt(); + } + + @Override + public final int nextInt(int bound) { + return randomGenerator.nextInt(bound); + } + + @Override + public final long nextLong() { + return randomGenerator.nextLong(); + } + + @Override + public final boolean nextBoolean() { + return randomGenerator.nextBoolean(); + } + + @Override + public final float nextFloat() { + return randomGenerator.nextFloat(); + } + + @Override + public final double nextDouble() { + return randomGenerator.nextDouble(); + } + + @Override + public final double nextGaussian() { + return randomGenerator.nextGaussian(); + } +} diff --git a/src/main/java/su/plo/matter/WorldgenCryptoRandom.java b/src/main/java/su/plo/matter/WorldgenCryptoRandom.java index fab359afe44c573b8b315115810ddefd85b4d22b..42f4ca3f8ef3b5c4152b4b58e51cdba229ff1a0a 100644 --- a/src/main/java/su/plo/matter/WorldgenCryptoRandom.java +++ b/src/main/java/su/plo/matter/WorldgenCryptoRandom.java @@ -24,7 +24,7 @@ public class WorldgenCryptoRandom extends WorldgenRandom { private final long[] cachedInternalState = new long[16]; public WorldgenCryptoRandom(int x, int z, Globals.Salt typeSalt, long salt) { - super(new LegacyRandomSource(0L)); + super(org.dreeam.leaf.config.modules.opt.FastRNG.enabled ? new org.dreeam.leaf.util.math.random.FasterRandomSource(0L) : new LegacyRandomSource(0L)); if (typeSalt != null) { this.setSecureSeed(x, z, typeSalt, salt); }