switch from world preset to direct level stems

core/src/main/java/com/volmit/iris/Iris.java

@@ -516,7 +516,6 @@ public class Iris extends VolmitPlugin implements Listener {
 
                 Iris.info(C.LIGHT_PURPLE + "Preparing Spawn for " + s + "' using Iris:" + generator + "...");
                 WorldCreator c = new WorldCreator(s)
-                        .type(IrisWorldCreator.IRIS)
                         .generator(getDefaultWorldGenerator(s, generator))
                         .environment(IrisData.loadAnyDimension(generator).getEnvironment());
                 INMS.get().createWorld(c);

core/src/main/java/com/volmit/iris/core/nms/datapack/IDataFixer.java

@@ -20,46 +20,6 @@ public interface IDataFixer {
         return obj;
     }
 
-    default JSONObject createPreset() {
-        return new JSONObject("""
-{
-  "dimensions": {
-    "minecraft:overworld": {
-      "type": "iris:overworld",
-      "generator": {
-        "type": "minecraft:noise",
-        "biome_source": {
-          "type": "minecraft:multi_noise",
-          "preset": "minecraft:overworld"
-        },
-        "settings": "minecraft:overworld"
-      }
-    },
-    "minecraft:the_end": {
-      "type": "iris:the_end",
-      "generator": {
-        "type": "minecraft:noise",
-        "biome_source": {
-          "type": "minecraft:the_end"
-        },
-        "settings": "minecraft:end"
-      }
-    },
-    "minecraft:the_nether": {
-      "type": "iris:the_nether",
-      "generator": {
-        "type": "minecraft:noise",
-        "biome_source": {
-          "type": "minecraft:multi_noise",
-          "preset": "minecraft:nether"
-        },
-        "settings": "minecraft:nether"
-      }
-    }
-  }
-}""");
-    }
-
     enum Dimension {
         OVERRWORLD,
         NETHER,

core/src/main/java/com/volmit/iris/core/tools/IrisWorldCreator.java

@@ -32,8 +32,6 @@ import sun.misc.Unsafe;
 import java.io.File;
 
 public class IrisWorldCreator {
-    public static final WorldType IRIS;
-
     private String name;
     private boolean studio = false;
     private String dimensionName = null;
@@ -85,7 +83,6 @@ public class IrisWorldCreator {
 
 
         return new WorldCreator(name)
-                .type(IRIS)
                 .environment(findEnvironment())
                 .generateStructures(true)
                 .generator(g).seed(seed);
@@ -104,17 +101,4 @@ public class IrisWorldCreator {
         this.studio = studio;
         return this;
     }
-
-    static {
-        try {
-            var unsafe = new WrappedField<Unsafe, Unsafe>(Unsafe.class, "theUnsafe").get();
-            var iris = (WorldType) unsafe.allocateInstance(WorldType.class);
-            unsafe.putIntVolatile(iris, unsafe.objectFieldOffset(Enum.class.getDeclaredField("ordinal")), 0);
-            unsafe.putObjectVolatile(iris, unsafe.objectFieldOffset(Enum.class.getDeclaredField("name")), "IRIS");
-
-            IRIS = iris;
-        } catch (Throwable e) {
-            throw new ExceptionInInitializerError(e);
-        }
-    }
 }

nms/v1_20_R1/src/main/java/com/volmit/iris/core/nms/v1_20_R1/NMSBinding.java

@@ -27,6 +27,7 @@ import net.minecraft.core.Registry;
 import net.minecraft.core.registries.Registries;
 import net.minecraft.nbt.*;
 import net.minecraft.nbt.Tag;
+import net.minecraft.resources.ResourceKey;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.WorldLoader;
@@ -43,6 +44,8 @@ import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.chunk.ChunkAccess;
 import net.minecraft.world.level.chunk.ChunkStatus;
 import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.level.dimension.DimensionType;
+import net.minecraft.world.level.dimension.LevelStem;
 import org.bukkit.*;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
@@ -571,6 +574,8 @@ public class NMSBinding implements INMSBinding {
 
     public void inject(long seed, Engine engine, World world) {
         var chunkMap = ((CraftWorld)world).getHandle().getChunkSource().chunkMap;
+        if (!chunkMap.level.dimension().location().getPath().startsWith("iris"))
+            Iris.error("Loaded world %s with invalid dimension type!", world.getName());
         chunkMap.generator = new IrisChunkGenerator(chunkMap.generator, seed, engine, world);
     }
 
@@ -645,9 +650,7 @@ public class NMSBinding implements INMSBinding {
                 old.resources(),
                 old.dataConfiguration(),
                 old.datapackWorldgen(),
-                new RegistryAccess.Frozen.ImmutableRegistryAccess(List.of(
+                createRegistryAccess()
-                        new MappedRegistry<>(Registries.LEVEL_STEM, Lifecycle.experimental()).freeze()
-                )).freeze()
         )));
 
         try {
@@ -656,4 +659,24 @@ public class NMSBinding implements INMSBinding {
             field.set(nmsServer, old);
         }
     }
+
+    private RegistryAccess.Frozen createRegistryAccess() {
+        var access = registry();
+        var dimensions = access.registryOrThrow(Registries.DIMENSION_TYPE);
+        var levelStems = access.registryOrThrow(Registries.LEVEL_STEM);
+
+        var fake = new MappedRegistry<>(Registries.LEVEL_STEM, Lifecycle.experimental());
+        register(fake, levelStems, dimensions, LevelStem.OVERWORLD);
+        register(fake, levelStems, dimensions, LevelStem.NETHER);
+        register(fake, levelStems, dimensions, LevelStem.END);
+
+        return new RegistryAccess.Frozen.ImmutableRegistryAccess(List.of(fake.freeze())).freeze();
+    }
+
+    private void register(MappedRegistry<LevelStem> target, Registry<LevelStem> levelStems, Registry<DimensionType> dimensions, ResourceKey<LevelStem> key) {
+        target.register(key, new LevelStem(
+                dimensions.getHolderOrThrow(ResourceKey.create(Registries.DIMENSION_TYPE, new ResourceLocation("iris", key.location().getPath()))),
+                levelStems.getOrThrow(key).generator()
+        ), Lifecycle.stable());
+    }
 }

nms/v1_20_R2/src/main/java/com/volmit/iris/core/nms/v1_20_R2/NMSBinding.java

@@ -29,6 +29,8 @@ import net.minecraft.server.commands.data.BlockDataAccessor;
 import net.minecraft.tags.TagKey;
 import net.minecraft.world.level.LevelReader;
 import net.minecraft.world.level.block.EntityBlock;
+import net.minecraft.world.level.dimension.DimensionType;
+import net.minecraft.world.level.dimension.LevelStem;
 import org.bukkit.*;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
@@ -541,6 +543,8 @@ public class NMSBinding implements INMSBinding {
 
     public void inject(long seed, Engine engine, World world) {
         var chunkMap = ((CraftWorld)world).getHandle().getChunkSource().chunkMap;
+        if (!chunkMap.level.dimension().location().getPath().startsWith("iris"))
+            Iris.error("Loaded world %s with invalid dimension type!", world.getName());
         chunkMap.generator = new IrisChunkGenerator(chunkMap.generator, seed, engine, world);
     }
 
@@ -647,9 +651,7 @@ public class NMSBinding implements INMSBinding {
                 old.resources(),
                 old.dataConfiguration(),
                 old.datapackWorldgen(),
-                new RegistryAccess.Frozen.ImmutableRegistryAccess(List.of(
+                createRegistryAccess()
-                        new MappedRegistry<>(Registries.LEVEL_STEM, Lifecycle.experimental()).freeze()
-                )).freeze()
         )));
 
         try {
@@ -658,4 +660,24 @@ public class NMSBinding implements INMSBinding {
             field.set(nmsServer, old);
         }
     }
+
+    private RegistryAccess.Frozen createRegistryAccess() {
+        var access = registry();
+        var dimensions = access.registryOrThrow(Registries.DIMENSION_TYPE);
+        var levelStems = access.registryOrThrow(Registries.LEVEL_STEM);
+
+        var fake = new MappedRegistry<>(Registries.LEVEL_STEM, Lifecycle.experimental());
+        register(fake, levelStems, dimensions, LevelStem.OVERWORLD);
+        register(fake, levelStems, dimensions, LevelStem.NETHER);
+        register(fake, levelStems, dimensions, LevelStem.END);
+
+        return new RegistryAccess.Frozen.ImmutableRegistryAccess(List.of(fake.freeze())).freeze();
+    }
+
+    private void register(MappedRegistry<LevelStem> target, Registry<LevelStem> levelStems, Registry<DimensionType> dimensions, ResourceKey<LevelStem> key) {
+        target.register(key, new LevelStem(
+                dimensions.getHolderOrThrow(ResourceKey.create(Registries.DIMENSION_TYPE, new ResourceLocation("iris", key.location().getPath()))),
+                levelStems.getOrThrow(key).generator()
+        ), Lifecycle.stable());
+    }
 }

nms/v1_20_R3/src/main/java/com/volmit/iris/core/nms/v1_20_R3/NMSBinding.java

@@ -29,6 +29,8 @@ import net.minecraft.server.commands.data.BlockDataAccessor;
 import net.minecraft.tags.TagKey;
 import net.minecraft.world.level.LevelReader;
 import net.minecraft.world.level.block.EntityBlock;
+import net.minecraft.world.level.dimension.DimensionType;
+import net.minecraft.world.level.dimension.LevelStem;
 import org.bukkit.*;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
@@ -541,6 +543,8 @@ public class NMSBinding implements INMSBinding {
 
     public void inject(long seed, Engine engine, World world) {
         var chunkMap = ((CraftWorld)world).getHandle().getChunkSource().chunkMap;
+        if (!chunkMap.level.dimension().location().getPath().startsWith("iris"))
+            Iris.error("Loaded world %s with invalid dimension type!", world.getName());
         chunkMap.generator = new IrisChunkGenerator(chunkMap.generator, seed, engine, world);
     }
 
@@ -648,9 +652,7 @@ public class NMSBinding implements INMSBinding {
                 old.resources(),
                 old.dataConfiguration(),
                 old.datapackWorldgen(),
-                new RegistryAccess.Frozen.ImmutableRegistryAccess(List.of(
+                createRegistryAccess()
-                        new MappedRegistry<>(Registries.LEVEL_STEM, Lifecycle.experimental()).freeze()
-                )).freeze()
         )));
 
         try {
@@ -659,4 +661,24 @@ public class NMSBinding implements INMSBinding {
             field.set(nmsServer, old);
         }
     }
+
+    private RegistryAccess.Frozen createRegistryAccess() {
+        var access = registry();
+        var dimensions = access.registryOrThrow(Registries.DIMENSION_TYPE);
+        var levelStems = access.registryOrThrow(Registries.LEVEL_STEM);
+
+        var fake = new MappedRegistry<>(Registries.LEVEL_STEM, Lifecycle.experimental());
+        register(fake, levelStems, dimensions, LevelStem.OVERWORLD);
+        register(fake, levelStems, dimensions, LevelStem.NETHER);
+        register(fake, levelStems, dimensions, LevelStem.END);
+
+        return new RegistryAccess.Frozen.ImmutableRegistryAccess(List.of(fake.freeze())).freeze();
+    }
+
+    private void register(MappedRegistry<LevelStem> target, Registry<LevelStem> levelStems, Registry<DimensionType> dimensions, ResourceKey<LevelStem> key) {
+        target.register(key, new LevelStem(
+                dimensions.getHolderOrThrow(ResourceKey.create(Registries.DIMENSION_TYPE, new ResourceLocation("iris", key.location().getPath()))),
+                levelStems.getOrThrow(key).generator()
+        ), Lifecycle.stable());
+    }
 }

nms/v1_20_R4/src/main/java/com/volmit/iris/core/nms/v1_20_R4/NMSBinding.java

@@ -38,6 +38,8 @@ import net.minecraft.world.level.LevelReader;
 import net.minecraft.world.level.block.EntityBlock;
 import net.minecraft.world.level.block.entity.BlockEntityType;
 import net.minecraft.world.level.chunk.status.ChunkStatus;
+import net.minecraft.world.level.dimension.DimensionType;
+import net.minecraft.world.level.dimension.LevelStem;
 import org.bukkit.*;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
@@ -549,6 +551,9 @@ public class NMSBinding implements INMSBinding {
 
     public void inject(long seed, Engine engine, World world) {
         var chunkMap = ((CraftWorld)world).getHandle().getChunkSource().chunkMap;
+        if (!chunkMap.level.dimension().location().getPath().startsWith("iris"))
+            Iris.error("Loaded world %s with invalid dimension type!", world.getName());
+
         chunkMap.generator = new IrisChunkGenerator(chunkMap.generator, seed, engine, world);
     }
 
@@ -669,9 +674,7 @@ public class NMSBinding implements INMSBinding {
                 old.resources(),
                 old.dataConfiguration(),
                 old.datapackWorldgen(),
-                new RegistryAccess.Frozen.ImmutableRegistryAccess(List.of(
+                createRegistryAccess()
-                        new MappedRegistry<>(Registries.LEVEL_STEM, Lifecycle.experimental()).freeze()
-                )).freeze()
         )));
 
         try {
@@ -680,4 +683,24 @@ public class NMSBinding implements INMSBinding {
             field.set(nmsServer, old);
         }
     }
+
+    private RegistryAccess.Frozen createRegistryAccess() {
+        var access = registry();
+        var dimensions = access.registryOrThrow(Registries.DIMENSION_TYPE);
+        var levelStems = access.registryOrThrow(Registries.LEVEL_STEM);
+
+        var fake = new MappedRegistry<>(Registries.LEVEL_STEM, Lifecycle.experimental());
+        register(fake, levelStems, dimensions, LevelStem.OVERWORLD);
+        register(fake, levelStems, dimensions, LevelStem.NETHER);
+        register(fake, levelStems, dimensions, LevelStem.END);
+
+        return new RegistryAccess.Frozen.ImmutableRegistryAccess(List.of(fake.freeze())).freeze();
+    }
+
+    private void register(MappedRegistry<LevelStem> target, Registry<LevelStem> levelStems, Registry<DimensionType> dimensions, ResourceKey<LevelStem> key) {
+        target.register(key, new LevelStem(
+                dimensions.getHolder(new ResourceLocation("iris", key.location().getPath())).orElseThrow(),
+                levelStems.getOrThrow(key).generator()
+        ), RegistrationInfo.BUILT_IN);
+    }
 }

nms/v1_21_R1/src/main/java/com/volmit/iris/core/nms/v1_21_R1/NMSBinding.java

@@ -32,6 +32,8 @@ import net.minecraft.world.level.LevelReader;
 import net.minecraft.world.level.block.EntityBlock;
 import net.minecraft.world.level.chunk.status.ChunkStatus;
 import net.minecraft.world.level.chunk.status.WorldGenContext;
+import net.minecraft.world.level.dimension.DimensionType;
+import net.minecraft.world.level.dimension.LevelStem;
 import org.bukkit.*;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
@@ -549,6 +551,8 @@ public class NMSBinding implements INMSBinding {
         var worldGenContextField = getField(chunkMap.getClass(), WorldGenContext.class);
         worldGenContextField.setAccessible(true);
         var worldGenContext = (WorldGenContext) worldGenContextField.get(chunkMap);
+        if (!chunkMap.level.dimension().location().getPath().startsWith("iris"))
+            Iris.error("Loaded world %s with invalid dimension type!", world.getName());
 
         var newContext = new WorldGenContext(
                 worldGenContext.level(), new IrisChunkGenerator(worldGenContext.generator(), seed, engine, world),
@@ -674,9 +678,7 @@ public class NMSBinding implements INMSBinding {
                 old.resources(),
                 old.dataConfiguration(),
                 old.datapackWorldgen(),
-                new RegistryAccess.Frozen.ImmutableRegistryAccess(List.of(
+                createRegistryAccess()
-                        new MappedRegistry<>(Registries.LEVEL_STEM, Lifecycle.experimental()).freeze()
-                )).freeze()
         )));
 
         try {
@@ -685,4 +687,24 @@ public class NMSBinding implements INMSBinding {
             field.set(nmsServer, old);
         }
     }
+
+    private RegistryAccess.Frozen createRegistryAccess() {
+        var access = registry();
+        var dimensions = access.registryOrThrow(Registries.DIMENSION_TYPE);
+        var levelStems = access.registryOrThrow(Registries.LEVEL_STEM);
+
+        var fake = new MappedRegistry<>(Registries.LEVEL_STEM, Lifecycle.experimental());
+        register(fake, levelStems, dimensions, LevelStem.OVERWORLD);
+        register(fake, levelStems, dimensions, LevelStem.NETHER);
+        register(fake, levelStems, dimensions, LevelStem.END);
+
+        return new RegistryAccess.Frozen.ImmutableRegistryAccess(List.of(fake.freeze())).freeze();
+    }
+
+    private void register(MappedRegistry<LevelStem> target, Registry<LevelStem> levelStems, Registry<DimensionType> dimensions, ResourceKey<LevelStem> key) {
+        target.register(key, new LevelStem(
+                dimensions.getHolder(ResourceLocation.fromNamespaceAndPath("iris", key.location().getPath())).orElseThrow(),
+                levelStems.getOrThrow(key).generator()
+        ), RegistrationInfo.BUILT_IN);
+    }
 }

nms/v1_21_R2/src/main/java/com/volmit/iris/core/nms/v1_21_R2/NMSBinding.java

@@ -26,6 +26,8 @@ import net.minecraft.world.level.LevelReader;
 import net.minecraft.world.level.block.EntityBlock;
 import net.minecraft.world.level.chunk.status.ChunkStatus;
 import net.minecraft.world.level.chunk.status.WorldGenContext;
+import net.minecraft.world.level.dimension.DimensionType;
+import net.minecraft.world.level.dimension.LevelStem;
 import org.bukkit.*;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
@@ -538,6 +540,8 @@ public class NMSBinding implements INMSBinding {
         var worldGenContextField = getField(chunkMap.getClass(), WorldGenContext.class);
         worldGenContextField.setAccessible(true);
         var worldGenContext = (WorldGenContext) worldGenContextField.get(chunkMap);
+        if (!chunkMap.level.dimension().location().getPath().startsWith("iris"))
+            Iris.error("Loaded world %s with invalid dimension type!", world.getName());
 
         var newContext = new WorldGenContext(
                 worldGenContext.level(), new IrisChunkGenerator(worldGenContext.generator(), seed, engine, world),
@@ -663,9 +667,7 @@ public class NMSBinding implements INMSBinding {
                 old.resources(),
                 old.dataConfiguration(),
                 old.datapackWorldgen(),
-                new RegistryAccess.Frozen.ImmutableRegistryAccess(List.of(
+                createRegistryAccess()
-                        new MappedRegistry<>(Registries.LEVEL_STEM, Lifecycle.experimental()).freeze()
-                )).freeze()
         )));
 
         try {
@@ -674,4 +676,24 @@ public class NMSBinding implements INMSBinding {
             field.set(nmsServer, old);
         }
     }
+
+    private RegistryAccess.Frozen createRegistryAccess() {
+        var access = registry();
+        var dimensions = access.lookupOrThrow(Registries.DIMENSION_TYPE);
+        var levelStems = access.lookupOrThrow(Registries.LEVEL_STEM);
+
+        var fake = new MappedRegistry<>(Registries.LEVEL_STEM, Lifecycle.experimental());
+        register(fake, levelStems, dimensions, LevelStem.OVERWORLD);
+        register(fake, levelStems, dimensions, LevelStem.NETHER);
+        register(fake, levelStems, dimensions, LevelStem.END);
+
+        return new RegistryAccess.Frozen.ImmutableRegistryAccess(List.of(fake.freeze())).freeze();
+    }
+
+    private void register(MappedRegistry<LevelStem> target, Registry<LevelStem> levelStems, Registry<DimensionType> dimensions, ResourceKey<LevelStem> key) {
+        target.register(key, new LevelStem(
+                dimensions.get(ResourceLocation.fromNamespaceAndPath("iris", key.location().getPath())).orElseThrow(),
+                levelStems.getValueOrThrow(key).generator()
+        ), RegistrationInfo.BUILT_IN);
+    }
 }

nms/v1_21_R3/src/main/java/com/volmit/iris/core/nms/v1_21_R3/NMSBinding.java

@@ -45,6 +45,8 @@ import net.minecraft.world.level.chunk.ChunkAccess;
 import net.minecraft.world.level.chunk.LevelChunk;
 import net.minecraft.world.level.chunk.status.ChunkStatus;
 import net.minecraft.world.level.chunk.status.WorldGenContext;
+import net.minecraft.world.level.dimension.DimensionType;
+import net.minecraft.world.level.dimension.LevelStem;
 import org.bukkit.*;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
@@ -537,6 +539,8 @@ public class NMSBinding implements INMSBinding {
         var worldGenContextField = getField(chunkMap.getClass(), WorldGenContext.class);
         worldGenContextField.setAccessible(true);
         var worldGenContext = (WorldGenContext) worldGenContextField.get(chunkMap);
+        if (!chunkMap.level.dimension().location().getPath().startsWith("iris"))
+            Iris.error("Loaded world %s with invalid dimension type!", world.getName());
 
         var newContext = new WorldGenContext(
                 worldGenContext.level(), new IrisChunkGenerator(worldGenContext.generator(), seed, engine, world),
@@ -662,9 +666,7 @@ public class NMSBinding implements INMSBinding {
                 old.resources(),
                 old.dataConfiguration(),
                 old.datapackWorldgen(),
-                new RegistryAccess.Frozen.ImmutableRegistryAccess(List.of(
+                createRegistryAccess()
-                        new MappedRegistry<>(Registries.LEVEL_STEM, Lifecycle.experimental()).freeze()
-                )).freeze()
         )));
 
         try {
@@ -673,4 +675,24 @@ public class NMSBinding implements INMSBinding {
             field.set(nmsServer, old);
         }
     }
+
+    private RegistryAccess.Frozen createRegistryAccess() {
+        var access = registry();
+        var dimensions = access.lookupOrThrow(Registries.DIMENSION_TYPE);
+        var levelStems = access.lookupOrThrow(Registries.LEVEL_STEM);
+
+        var fake = new MappedRegistry<>(Registries.LEVEL_STEM, Lifecycle.experimental());
+        register(fake, levelStems, dimensions, LevelStem.OVERWORLD);
+        register(fake, levelStems, dimensions, LevelStem.NETHER);
+        register(fake, levelStems, dimensions, LevelStem.END);
+
+        return new RegistryAccess.Frozen.ImmutableRegistryAccess(List.of(fake.freeze())).freeze();
+    }
+
+    private void register(MappedRegistry<LevelStem> target, Registry<LevelStem> levelStems, Registry<DimensionType> dimensions, ResourceKey<LevelStem> key) {
+        target.register(key, new LevelStem(
+                dimensions.get(ResourceLocation.fromNamespaceAndPath("iris", key.location().getPath())).orElseThrow(),
+                levelStems.getValueOrThrow(key).generator()
+        ), RegistrationInfo.BUILT_IN);
+    }
 }