Revert "Update LICENSE.md"

This reverts commit 37893460f3.
Update LICENSE.md
2026-10-20 15:26:51 +00:00 · 2024-09-24 14:57:45 -04:00 · 2024-09-09 16:59:14 -04:00 · 2024-09-08 18:51:27 +02:00 · 2024-09-08 18:08:16 +02:00 · 2024-09-08 17:56:32 +02:00
1232 changed files with 29832 additions and 50444 deletions
@@ -15,17 +15,17 @@ Consider supporting our development by buying Iris on spigot! We work hard to ma

 ### Command Line Builds

-1. Install [Java JDK 21](https://www.oracle.com/java/technologies/javase/jdk21-archive-downloads.html)
+1. Install [Java JDK 17](https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html)
 2. Set the JDK installation path to `JAVA_HOME` as an environment variable.
    * Windows
        1. Start > Type `env` and press Enter
        2. Advanced > Environment Variables
        3. Under System Variables, click `New...`
        4. Variable Name: `JAVA_HOME`
-        5. Variable Value: `C:\Program Files\Java\jdk-21.0.1` (verify this exists after installing java don't just copy
+        5. Variable Value: `C:\Program Files\Java\jdk-17.0.1` (verify this exists after installing java don't just copy
           the example text)
    * MacOS
-        1. Run `/usr/libexec/java_home -V` and look for Java 21
+        1. Run `/usr/libexec/java_home -V` and look for Java 17
        2. Run `sudo nano ~/.zshenv`
        3. Add `export JAVA_HOME=$(/usr/libexec/java_home)` as a new line
        4. Use `CTRL + X`, then Press `Y`, Then `ENTER`
@@ -35,7 +35,7 @@ Consider supporting our development by buying Iris on spigot! We work hard to ma

 ### IDE Builds (for development)

-* Configure ITJ Gradle to use JDK 21 (in settings, search for gradle)
+* Configure ITJ Gradle to use JDK 17 (in settings, search for gradle)
 * Add a build line in the build.gradle for your own build task to directly compile Iris into your plugins folder if you
  prefer.
 * Resync the project & run your newly created task (under the development folder in gradle tasks!)
@@ -0,0 +1,234 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+buildscript() {
+    repositories {
+        maven { url 'https://jitpack.io'}
+    }
+    dependencies {
+        classpath 'com.github.VolmitSoftware:NMSTools:1.0.1'
+    }
+}
+
+plugins {
+    id 'java'
+    id 'java-library'
+    id "io.github.goooler.shadow" version "8.1.7"
+    id "de.undercouch.download" version "5.0.1"
+}
+
+version '4.0-1.19.2-1.21.1'
+
+// ADD YOURSELF AS A NEW LINE IF YOU WANT YOUR OWN BUILD TASK GENERATED
+// ======================== WINDOWS =============================
+registerCustomOutputTask('Cyberpwn', 'C://Users/cyberpwn/Documents/development/server/plugins')
+registerCustomOutputTask('Psycho', 'C://Dan/MinecraftDevelopment/Server/plugins')
+registerCustomOutputTask('ArcaneArts', 'C://Users/arcane/Documents/development/server/plugins')
+registerCustomOutputTask('Coco', 'D://mcsm/plugins')
+registerCustomOutputTask('Strange', 'D://Servers/1.17 Test Server/plugins')
+registerCustomOutputTask('Vatuu', 'D://Minecraft/Servers/1.19.4/plugins')
+registerCustomOutputTask('CrazyDev22', 'C://Users/Julian/Desktop/server/plugins')
+registerCustomOutputTask('Pixel', 'D://Iris Dimension Engine/1.20.4 - Development/plugins')
+// ========================== UNIX ==============================
+registerCustomOutputTaskUnix('CyberpwnLT', '/Users/danielmills/development/server/plugins')
+registerCustomOutputTaskUnix('PsychoLT', '/Users/brianfopiano/Developer/RemoteGit/Server/plugins')
+registerCustomOutputTaskUnix('PixelMac', '/Users/test/Desktop/mcserver/plugins')
+registerCustomOutputTaskUnix('CrazyDev22LT', '/home/julian/Desktop/server/plugins')
+// ==============================================================
+
+def NMS_BINDINGS = Map.of(
+        "v1_21_R1", "1.21-R0.1-SNAPSHOT",
+        "v1_20_R4", "1.20.6-R0.1-SNAPSHOT",
+        "v1_20_R3", "1.20.4-R0.1-SNAPSHOT",
+        "v1_20_R2", "1.20.2-R0.1-SNAPSHOT",
+        "v1_20_R1", "1.20.1-R0.1-SNAPSHOT",
+        "v1_19_R3", "1.19.4-R0.1-SNAPSHOT",
+        "v1_19_R2", "1.19.3-R0.1-SNAPSHOT",
+        "v1_19_R1", "1.19.2-R0.1-SNAPSHOT"
+)
+def JVM_VERSION = Map.of(
+        "v1_21_R1", 21,
+        "v1_20_R4", 21,
+)
+def entryPoint = 'com.volmit.iris.server.EntryPoint'
+NMS_BINDINGS.each { nms ->
+    project(":nms:${nms.key}") {
+        apply plugin: 'java'
+        apply plugin: 'com.volmit.nmstools'
+
+        nmsTools {
+            it.jvm = JVM_VERSION.getOrDefault(nms.key, 17)
+            it.version = nms.value
+        }
+
+        dependencies {
+            implementation project(":core")
+        }
+    }
+}
+
+shadowJar {
+    NMS_BINDINGS.each {
+        dependsOn(":nms:${it.key}:remap")
+        from("${project(":nms:${it.key}").layout.buildDirectory.asFile.get()}/libs/${it.key}-mapped.jar")
+    }
+    //dependsOn(':com.volmit.gui:build')
+
+    //minimize()
+    append("plugin.yml")
+    relocate 'com.dfsek.paralithic', 'com.volmit.iris.util.paralithic'
+    relocate 'io.papermc.lib', 'com.volmit.iris.util.paper'
+    relocate 'net.kyori', 'com.volmit.iris.util.kyori'
+    archiveFileName.set("Iris-${project.version}.jar")
+
+    manifest {
+        attributes 'Main-Class': entryPoint
+    }
+}
+
+dependencies {
+    implementation project(':core')
+}
+
+configurations.configureEach {
+    resolutionStrategy.cacheChangingModulesFor 60, 'minutes'
+    resolutionStrategy.cacheDynamicVersionsFor 60, 'minutes'
+}
+
+allprojects {
+    apply plugin: 'java'
+
+    repositories {
+        mavenCentral()
+        maven { url "https://repo.papermc.io/repository/maven-public/"}
+        maven { url "https://repo.codemc.org/repository/maven-public" }
+        maven { url "https://mvn.lumine.io/repository/maven-public/" }
+        maven { url "https://jitpack.io"}
+
+        maven { url "https://s01.oss.sonatype.org/content/repositories/snapshots" }
+        maven { url "https://mvn.lumine.io/repository/maven/" }
+        maven { url "https://repo.triumphteam.dev/snapshots" }
+        maven { url "https://repo.mineinabyss.com/releases" }
+        maven { url 'https://hub.jeff-media.com/nexus/repository/jeff-media-public/' }
+        maven { url "https://repo.oraxen.com/releases" }
+    }
+
+    dependencies {
+        // Provided or Classpath
+        compileOnly 'org.projectlombok:lombok:1.18.34'
+        annotationProcessor 'org.projectlombok:lombok:1.18.34'
+
+        // Shaded
+        implementation 'com.dfsek:Paralithic:0.4.0'
+        implementation 'io.papermc:paperlib:1.0.5'
+        implementation "net.kyori:adventure-text-minimessage:4.17.0"
+        implementation 'net.kyori:adventure-platform-bukkit:4.3.4'
+        implementation 'net.kyori:adventure-api:4.17.0'
+        //implementation 'org.bytedeco:javacpp:1.5.10'
+        //implementation 'org.bytedeco:cuda-platform:12.3-8.9-1.5.10'
+        //implementation "org.deeplearning4j:deeplearning4j-core:1.0.0-M2.1"
+        compileOnly 'io.lumine:Mythic-Dist:5.2.1'
+
+        // Dynamically Loaded
+        compileOnly 'io.timeandspace:smoothie-map:2.0.2'
+        compileOnly 'it.unimi.dsi:fastutil:8.5.8'
+        compileOnly 'com.googlecode.concurrentlinkedhashmap:concurrentlinkedhashmap-lru:1.4.2'
+        compileOnly 'org.zeroturnaround:zt-zip:1.14'
+        compileOnly 'com.google.code.gson:gson:2.10.1'
+        compileOnly 'org.ow2.asm:asm:9.2'
+        compileOnly 'com.google.guava:guava:33.0.0-jre'
+        compileOnly 'bsf:bsf:2.4.0'
+        compileOnly 'rhino:js:1.7R2'
+        compileOnly 'com.github.ben-manes.caffeine:caffeine:3.0.6'
+        compileOnly 'org.apache.commons:commons-lang3:3.12.0'
+        compileOnly 'net.bytebuddy:byte-buddy:1.14.14'
+        compileOnly 'net.bytebuddy:byte-buddy-agent:1.12.8'
+        compileOnly 'org.bytedeco:javacpp:1.5.10'
+        compileOnly 'org.bytedeco:cuda-platform:12.3-8.9-1.5.10'
+        compileOnly 'io.netty:netty-all:4.1.112.Final'
+    }
+
+    /**
+     * We need parameter meta for the decree command system
+     */
+    compileJava {
+        options.compilerArgs << '-parameters'
+        options.encoding = "UTF-8"
+    }
+}
+
+if (JavaVersion.current().toString() != "17") {
+    System.err.println()
+    System.err.println("=========================================================================================================")
+    System.err.println("You must run gradle on Java 17. You are using " + JavaVersion.current())
+    System.err.println()
+    System.err.println("=== For IDEs ===")
+    System.err.println("1. Configure the project for Java 17")
+    System.err.println("2. Configure the bundled gradle to use Java 17 in settings")
+    System.err.println()
+    System.err.println("=== For Command Line (gradlew) ===")
+    System.err.println("1. Install JDK 17 from https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html")
+    System.err.println("2. Set JAVA_HOME environment variable to the new jdk installation folder such as C:/Program Files/Java/jdk-17.0.1")
+    System.err.println("3. Open a new command prompt window to get the new environment variables if need be.")
+    System.err.println("=========================================================================================================")
+    System.err.println()
+    System.exit(69);
+}
+
+task iris(type: Copy) {
+    group "iris"
+    from new File(layout.buildDirectory.asFile.get(), "libs/Iris-${version}.jar")
+    into layout.buildDirectory.asFile.get()
+    dependsOn(build)
+}
+
+def registerCustomOutputTask(name, path) {
+    if (!System.properties['os.name'].toLowerCase().contains('windows')) {
+        return;
+    }
+
+    tasks.register('build' + name, Copy) {
+        group('development')
+        outputs.upToDateWhen { false }
+        dependsOn(iris)
+        from(new File(buildDir, "Iris-" + version + ".jar"))
+        into(file(path))
+        rename { String fileName ->
+            fileName.replace("Iris-" + version + ".jar", "Iris.jar")
+        }
+    }
+}
+
+def registerCustomOutputTaskUnix(name, path) {
+    if (System.properties['os.name'].toLowerCase().contains('windows')) {
+        return;
+    }
+
+    tasks.register('build' + name, Copy) {
+        group('development')
+        outputs.upToDateWhen { false }
+        dependsOn(iris)
+        from(new File(buildDir, "Iris-" + version + ".jar"))
+        into(file(path))
+        rename { String fileName ->
+            fileName.replace("Iris-" + version + ".jar", "Iris.jar")
+        }
+    }
+}
+
+tasks.build.dependsOn(shadowJar)
@@ -1,296 +0,0 @@
-import de.undercouch.gradle.tasks.download.Download
-import org.gradle.jvm.toolchain.JavaLanguageVersion
-import xyz.jpenilla.runpaper.task.RunServer
-import kotlin.system.exitProcess
-
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2021 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-buildscript {
-    repositories.maven("https://jitpack.io")
-    dependencies.classpath("com.github.VolmitSoftware:NMSTools:c88961416f")
-}
-
-plugins {
-    java
-    `java-library`
-    alias(libs.plugins.download)
-    alias(libs.plugins.runPaper)
-}
-
-group = "com.volmit"
-version = "3.9.2-1.20.1-26.3"
-
-apply<ApiGenerator>()
-
-// ADD YOURSELF AS A NEW LINE IF YOU WANT YOUR OWN BUILD TASK GENERATED
-// ======================== WINDOWS =============================
-registerCustomOutputTask("Cyberpwn", "C://Users/cyberpwn/Documents/development/server/plugins")
-registerCustomOutputTask("Psycho", "C://Dan/MinecraftDevelopment/Server/plugins")
-registerCustomOutputTask("ArcaneArts", "C://Users/arcane/Documents/development/server/plugins")
-registerCustomOutputTask("Coco", "D://mcsm/plugins")
-registerCustomOutputTask("Strange", "D://Servers/1.17 Test Server/plugins")
-registerCustomOutputTask("Vatuu", "D://Minecraft/Servers/1.19.4/plugins")
-registerCustomOutputTask("CrazyDev22", "C://Users/Julian/Desktop/server/plugins")
-registerCustomOutputTask("PixelFury", "C://Users/repix/workplace/Iris/1.21.3 - Development-Public-v3/plugins")
-registerCustomOutputTask("PixelFuryDev", "C://Users/repix/workplace/Iris/1.21 - Development-v3/plugins")
-// ========================== UNIX ==============================
-registerCustomOutputTaskUnix("CyberpwnLT", "/Users/danielmills/development/server/plugins")
-registerCustomOutputTaskUnix("PsychoLT", "/Users/brianfopiano/Developer/RemoteGit/[Minecraft Server]/plugins")
-registerCustomOutputTaskUnix("PixelMac", "/Users/test/Desktop/mcserver/plugins")
-registerCustomOutputTaskUnix("CrazyDev22LT", "/home/julian/Desktop/server/plugins")
-// ==============================================================
-
-val serverMinHeap = "10G"
-val serverMaxHeap = "10G"
-val additionalFlags = "-XX:+AlwaysPreTouch"
-//Valid values are: none, truecolor, indexed256, indexed16, indexed8
-val color = "truecolor"
-val errorReporting = "true" == findProperty("errorReporting")
-
-val nmsBindings = mapOf(
-    "v26_3_R1" to "26.3.build.176-stable",
-    "v26_1_R1" to "26.1.2.build.74-stable",
-    "v1_21_R7" to "1.21.11-R0.1-SNAPSHOT",
-    "v1_21_R6" to "1.21.10-R0.1-SNAPSHOT",
-    "v1_21_R5" to "1.21.8-R0.1-SNAPSHOT",
-    "v1_21_R4" to "1.21.5-R0.1-SNAPSHOT",
-    "v1_21_R3" to "1.21.4-R0.1-SNAPSHOT",
-    "v1_21_R2" to "1.21.3-R0.1-SNAPSHOT",
-    "v1_21_R1" to "1.21.1-R0.1-SNAPSHOT",
-    "v1_20_R4" to "1.20.6-R0.1-SNAPSHOT",
-    "v1_20_R3" to "1.20.4-R0.1-SNAPSHOT",
-    "v1_20_R2" to "1.20.2-R0.1-SNAPSHOT",
-    "v1_20_R1" to "1.20.1-R0.1-SNAPSHOT",
-)
-val jvmVersion = mapOf("v26_3_R1" to 25, "v26_1_R1" to 25)
-// From 26.1 on the server is not obfuscated, so these bindings compile against Paper's dev bundle as-is.
-val userDevBindings = setOf("v26_3_R1", "v26_1_R1")
-nmsBindings.forEach { (key, value) ->
-    project(":nms:$key") {
-        apply<JavaPlugin>()
-
-        nmsBinding {
-            jvm = jvmVersion.getOrDefault(key, 21)
-            version = value
-            type = if (key in userDevBindings) NMSBinding.Type.USER_DEV else NMSBinding.Type.DIRECT
-        }
-
-        dependencies {
-            compileOnly(project(":core"))
-            compileOnly(rootProject.libs.annotations)
-            compileOnly(rootProject.libs.byteBuddy.core)
-        }
-    }
-
-    tasks.register<RunServer>("runServer-$key") {
-        group = "servers"
-        minecraftVersion(value.substringBefore("-").substringBefore(".build"))
-        minHeapSize = serverMinHeap
-        maxHeapSize = serverMaxHeap
-        pluginJars(tasks.jar.flatMap { it.archiveFile })
-        javaLauncher = javaToolchains.launcherFor { languageVersion = JavaLanguageVersion.of(jvmVersion.getOrDefault(key, 21))}
-        runDirectory.convention(layout.buildDirectory.dir("run/$key"))
-        systemProperty("disable.watchdog", "true")
-        systemProperty("net.kyori.ansi.colorLevel", color)
-        systemProperty("com.mojang.eula.agree", true)
-        systemProperty("iris.suppressReporting", !errorReporting)
-        jvmArgs("-javaagent:${project(":core:agent").tasks.jar.flatMap { it.archiveFile }.get().asFile.absolutePath}")
-        jvmArgs(additionalFlags.split(' '))
-    }
-}
-
-val included: Configuration by configurations.creating
-val jarJar: Configuration by configurations.creating
-dependencies {
-    for (key in nmsBindings.keys) {
-        included(project(":nms:$key", if (key in userDevBindings) "runtimeElements" else "reobf"))
-    }
-    included(project(":core", "shadow"))
-    jarJar(project(":core:agent"))
-}
-
-tasks {
-    jar {
-        inputs.files(included)
-        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-        from(jarJar, provider { included.resolve().map(::zipTree) })
-        archiveFileName.set("Iris-${project.version}.jar")
-    }
-
-    register<Copy>("iris") {
-        group = "iris"
-        dependsOn("jar")
-        from(layout.buildDirectory.file("libs/Iris-${project.version}.jar"))
-        into(layout.buildDirectory)
-    }
-
-    register<Copy>("irisDev") {
-        group = "iris"
-        from(project(":core").layout.buildDirectory.files("libs/core-javadoc.jar", "libs/core-sources.jar"))
-        rename { it.replace("core", "Iris-${project.version}") }
-        into(layout.buildDirectory)
-        dependsOn(":core:sourcesJar")
-        dependsOn(":core:javadocJar")
-    }
-
-    val cli = file("sentry-cli.exe")
-    register<Download>("downloadCli") {
-        group = "io.sentry"
-        src("https://release-registry.services.sentry.io/apps/sentry-cli/latest?response=download&arch=x86_64&platform=${System.getProperty("os.name")}&package=sentry-cli")
-        dest(cli)
-
-        doLast {
-            cli.setExecutable(true)
-        }
-    }
-
-    register("release") {
-        group = "io.sentry"
-        dependsOn("downloadCli")
-        doLast {
-            val url = "http://sentry.volmit.com:8080"
-            val authToken = project.findProperty("sentry.auth.token") ?: System.getenv("SENTRY_AUTH_TOKEN")
-            val org = "sentry"
-            val projectName = "iris"
-            exec(cli, "--url", url , "--auth-token", authToken, "releases", "new", "-o", org, "-p", projectName, version)
-            exec(cli, "--url", url , "--auth-token", authToken, "releases", "set-commits", "-o", org, "-p", projectName, version, "--auto", "--ignore-missing")
-            //exec(cli, "--url", url, "--auth-token", authToken, "releases", "finalize", "-o", org, "-p", projectName, version)
-            cli.delete()
-        }
-    }
-}
-
-fun exec(vararg command: Any) {
-    val p = ProcessBuilder(command.map { it.toString() })
-        .start()
-    p.inputStream.reader().useLines { it.forEach(::println) }
-    p.errorStream.reader().useLines { it.forEach(::println) }
-    p.waitFor()
-}
-
-configurations.configureEach {
-    resolutionStrategy.cacheChangingModulesFor(60, "minutes")
-    resolutionStrategy.cacheDynamicVersionsFor(60, "minutes")
-}
-
-allprojects {
-    apply<JavaPlugin>()
-
-    java {
-        toolchain {
-            languageVersion.set(JavaLanguageVersion.of(jvmVersion.getOrDefault(name, 21)))
-        }
-    }
-
-    repositories {
-        mavenCentral()
-        maven("https://repo.papermc.io/repository/maven-public/")
-        maven("https://repo.codemc.org/repository/maven-public/")
-
-        maven("https://jitpack.io") // EcoItems, score
-        maven("https://repo.nexomc.com/releases/") // nexo
-        maven("https://maven.devs.beer/") // itemsadder
-        maven("https://repo.extendedclip.com/releases/") // placeholderapi
-        maven("https://mvn.lumine.io/repository/maven-public/") // mythic
-        maven("https://nexus.phoenixdevt.fr/repository/maven-public/") //MMOItems
-        maven("https://repo.onarandombox.com/content/groups/public/") //Multiverse Core
-        maven("https://repo.momirealms.net/releases/") //CraftEngine
-    }
-
-    dependencies {
-        // Provided or Classpath
-        compileOnly(rootProject.libs.lombok)
-        annotationProcessor(rootProject.libs.lombok)
-    }
-
-    /**
-     * We need parameter meta for the decree command system
-     */
-    tasks {
-        compileJava {
-            options.compilerArgs.add("-parameters")
-            options.encoding = "UTF-8"
-        }
-
-        javadoc {
-            options.encoding = "UTF-8"
-            options.quiet()
-            //options.addStringOption("Xdoclint:none") // TODO: Re-enable this
-        }
-
-        register<Jar>("sourcesJar") {
-            archiveClassifier.set("sources")
-            from(sourceSets.main.map { it.allSource })
-        }
-
-        register<Jar>("javadocJar") {
-            archiveClassifier.set("javadoc")
-            from(javadoc.map { it.destinationDir!! })
-        }
-    }
-}
-
-if (!JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_21)) {
-    System.err.println()
-    System.err.println("=========================================================================================================")
-    System.err.println("You must run gradle on Java 21 or newer. You are using " + JavaVersion.current())
-    System.err.println()
-    System.err.println("=== For IDEs ===")
-    System.err.println("1. Configure the project for Java 21 toolchain")
-    System.err.println("2. Configure the bundled gradle to use Java 21+ in settings")
-    System.err.println()
-    System.err.println("=== For Command Line (gradlew) ===")
-    System.err.println("1. Install JDK 21 from https://www.oracle.com/java/technologies/javase/jdk21-archive-downloads.html")
-    System.err.println("2. Set JAVA_HOME environment variable to the new jdk installation folder such as C:\\Program Files\\Java\\jdk-21.0.4")
-    System.err.println("3. Open a new command prompt window to get the new environment variables if need be.")
-    System.err.println("=========================================================================================================")
-    System.err.println()
-    exitProcess(69)
-}
-
-
-fun registerCustomOutputTask(name: String, path: String) {
-    if (!System.getProperty("os.name").lowercase().contains("windows")) {
-        return
-    }
-
-    tasks.register<Copy>("build$name") {
-        group = "development"
-        outputs.upToDateWhen { false }
-        dependsOn("iris")
-        from(layout.buildDirectory.file("Iris-${project.version}.jar"))
-        into(file(path))
-        rename { "Iris.jar" }
-    }
-}
-
-fun registerCustomOutputTaskUnix(name: String, path: String) {
-    if (System.getProperty("os.name").lowercase().contains("windows")) {
-        return
-    }
-
-    tasks.register<Copy>("build$name") {
-        group = "development"
-        outputs.upToDateWhen { false }
-        dependsOn("iris")
-        from(layout.buildDirectory.file("Iris-${project.version}.jar"))
-        into(file(path))
-        rename { "Iris.jar" }
-    }
-}
@@ -1,32 +0,0 @@
-import org.gradle.jvm.toolchain.JavaLanguageVersion
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
-
-plugins {
-    kotlin("jvm") version embeddedKotlinVersion
-}
-
-java {
-    toolchain {
-        languageVersion.set(JavaLanguageVersion.of(21))
-    }
-}
-
-kotlin {
-    jvmToolchain(21)
-    compilerOptions {
-        jvmTarget.set(JvmTarget.JVM_21)
-    }
-}
-
-repositories {
-    mavenCentral()
-    gradlePluginPortal()
-    maven("https://jitpack.io")
-}
-
-dependencies {
-    implementation("org.ow2.asm:asm:9.8")
-    implementation("com.github.VolmitSoftware:NMSTools:c88961416f")
-    implementation("io.papermc.paperweight:paperweight-userdev:2.0.0-beta.21")
-    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2")
-}
@@ -1,121 +0,0 @@
-import org.gradle.api.DefaultTask
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.publish.PublishingExtension
-import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.api.tasks.InputFile
-import org.gradle.api.tasks.OutputFile
-import org.gradle.api.tasks.TaskAction
-import org.gradle.jvm.tasks.Jar
-import org.objectweb.asm.*
-import java.io.File
-import java.util.jar.JarFile
-import java.util.jar.JarOutputStream
-
-class ApiGenerator : Plugin<Project> {
-    override fun apply(target: Project): Unit = with(target) {
-        plugins.apply("maven-publish")
-        val task = tasks.register("irisApi", GenerateApiTask::class.java)
-        extensions.findByType(PublishingExtension::class.java)!!.apply {
-            repositories.maven {
-                it.name = "deployDir"
-                it.url = targetDirectory.toURI()
-            }
-
-            publications.create("maven", MavenPublication::class.java) {
-                it.groupId = name
-                it.version = version.toString()
-                it.artifact(task)
-            }
-        }
-    }
-}
-
-abstract class GenerateApiTask : DefaultTask() {
-    init {
-        group = "iris"
-        dependsOn("jar")
-        finalizedBy("publishMavenPublicationToDeployDirRepository")
-        doLast {
-            logger.lifecycle("The API is located at ${outputFile.absolutePath}")
-        }
-    }
-
-    @InputFile
-    val inputFile: File = project.tasks
-        .named("jar", Jar::class.java)
-        .get()
-        .archiveFile
-        .get()
-        .asFile
-
-    @OutputFile
-    val outputFile: File = project.targetDirectory.resolve(inputFile.name)
-
-    @TaskAction
-    fun generate() {
-        JarFile(inputFile).use { jar ->
-            JarOutputStream(outputFile.apply { parentFile?.mkdirs() }.outputStream()).use { out ->
-                jar.stream()
-                    .parallel()
-                    .filter { !it.isDirectory }
-                    .filter { it.name.endsWith(".class") }
-                    .forEach {
-                        val bytes = jar.getInputStream(it).use { input ->
-                            val writer = ClassWriter(ClassWriter.COMPUTE_MAXS)
-                            val visitor = MethodClearingVisitor(writer)
-                            ClassReader(input).accept(visitor, 0)
-                            writer.toByteArray()
-                        }
-
-                        synchronized(out) {
-                            out.putNextEntry(it)
-                            out.write(bytes)
-                            out.closeEntry()
-                        }
-                    }
-            }
-        }
-    }
-}
-
-val Project.targetDirectory: File get() {
-    val dir = System.getenv("DEPLOY_DIR") ?: return project.layout.buildDirectory.dir("api").get().asFile
-    return File(dir)
-}
-
-private class MethodClearingVisitor(
-    cv: ClassVisitor
-) : ClassVisitor(Opcodes.ASM9, cv) {
-
-    override fun visitMethod(
-        access: Int,
-        name: String?,
-        descriptor: String?,
-        signature: String?,
-        exceptions: Array<out String>?
-    ) = ExceptionThrowingMethodVisitor(super.visitMethod(access, name, descriptor, signature, exceptions))
-}
-
-private class ExceptionThrowingMethodVisitor(
-    mv: MethodVisitor
-) : MethodVisitor(Opcodes.ASM9, mv) {
-
-    override fun visitCode() {
-        if (mv == null) return
-        mv.visitCode()
-
-        mv.visitTypeInsn(Opcodes.NEW, "java/lang/IllegalStateException")
-        mv.visitInsn(Opcodes.DUP)
-        mv.visitLdcInsn("Only API")
-        mv.visitMethodInsn(
-            Opcodes.INVOKESPECIAL,
-            "java/lang/IllegalStateException",
-            "<init>", "(Ljava/lang/String;)V", false
-        )
-        mv.visitInsn(Opcodes.ATHROW)
-
-        mv.visitMaxs(0, 0)
-        mv.visitEnd()
-    }
-}
@@ -1,187 +0,0 @@
-import NMSBinding.Type
-import com.volmit.nmstools.NMSToolsExtension
-import com.volmit.nmstools.NMSToolsPlugin
-import io.papermc.paperweight.userdev.PaperweightUser
-import io.papermc.paperweight.userdev.PaperweightUserDependenciesExtension
-import io.papermc.paperweight.userdev.PaperweightUserExtension
-import io.papermc.paperweight.userdev.attribute.Obfuscation
-import io.papermc.paperweight.util.constants.REOBF_CONFIG
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
-import org.gradle.api.*
-import org.gradle.api.attributes.Bundling
-import org.gradle.api.attributes.Category
-import org.gradle.api.attributes.LibraryElements
-import org.gradle.api.attributes.Usage
-import org.gradle.api.model.ObjectFactory
-import org.gradle.api.plugins.JavaPluginExtension
-import org.gradle.api.tasks.TaskAction
-import org.gradle.internal.extensions.core.extra
-import org.gradle.jvm.toolchain.JavaLanguageVersion
-import org.gradle.jvm.toolchain.JavaToolchainService
-import org.gradle.work.DisableCachingByDefault
-import java.io.RandomAccessFile
-import javax.inject.Inject
-
-class NMSBinding : Plugin<Project> {
-    override fun apply(target: Project): Unit = with(target) {
-        val config = extra["nms"] as? Config ?: throw GradleException("No NMS binding configuration found")
-        val jvm = config.jvm
-        val type = config.type
-
-        if (type == Type.USER_DEV) {
-            plugins.apply(PaperweightUser::class.java)
-            dependencies.extensions.findByType(PaperweightUserDependenciesExtension::class.java)
-                ?.paperDevBundle(config.version)
-
-            val java = extensions.findByType(JavaPluginExtension::class.java) ?: throw GradleException("Java plugin not found")
-            java.toolchain.languageVersion.set(JavaLanguageVersion.of(jvm))
-
-            val javaToolchains = project.extensions.getByType(JavaToolchainService::class.java) ?: throw GradleException("Java toolchain service not found")
-            extensions.configure(PaperweightUserExtension::class.java) {
-                it.javaLauncher.set(javaToolchains.launcherFor(java.toolchain))
-            }
-        } else {
-            extra["nmsTools.useBuildTools"] = type == Type.BUILD_TOOLS
-            plugins.apply(NMSToolsPlugin::class.java)
-            extensions.configure(NMSToolsExtension::class.java) {
-                it.jvm.set(jvm)
-                it.version.set(config.version)
-            }
-
-            registerReobfConfiguration("remap")
-        }
-
-        val (major, minor) = config.version.parseVersion()
-        if (major <= 20 && minor <= 4) return@with
-        tasks.register("convert", ConversionTask::class.java, type)
-        tasks.named("compileJava") { it.dependsOn("convert") }
-        rootProject.tasks.named("prepareKotlinBuildScriptModel") { it.dependsOn("$path:convert") }
-    }
-
-    private fun Project.registerReobfConfiguration(artifactTask: String) {
-        val conf = configurations.create(REOBF_CONFIG)
-        conf.isCanBeConsumed = true
-        conf.isCanBeResolved = false
-        conf.attributes {
-            it.attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))
-            it.attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.LIBRARY))
-            it.attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.JAR))
-            it.attribute(Bundling.BUNDLING_ATTRIBUTE, objects.named(Bundling.EXTERNAL))
-            it.attribute(Obfuscation.OBFUSCATION_ATTRIBUTE, objects.named(Obfuscation.OBFUSCATED))
-        }
-        conf.outgoing.artifact(tasks.named(artifactTask))
-    }
-
-    @DisableCachingByDefault
-    abstract class ConversionTask @Inject constructor(type: Type) : DefaultTask() {
-        private val pattern: Regex
-        private val replacement: String
-
-        init {
-            group = "nms"
-            inputs.property("type", type)
-            val java = project.extensions.findByType(JavaPluginExtension::class.java) ?: throw GradleException("Java plugin not found")
-            val source = java.sourceSets.named("main").map { it.allJava }
-            inputs.files(source)
-            outputs.files(source)
-
-            if (type == Type.USER_DEV) {
-                pattern = "org\\.bukkit\\.craftbukkit\\.${project.name}".toRegex()
-                replacement = "org.bukkit.craftbukkit"
-            } else {
-                pattern = "org\\.bukkit\\.craftbukkit\\.(?!${project.name})".toRegex()
-                replacement = "org.bukkit.craftbukkit.${project.name}."
-            }
-        }
-
-        @TaskAction
-        fun process() {
-            val dispatcher = Dispatchers.IO.limitedParallelism(16)
-            runBlocking {
-                for (file in inputs.files) {
-                    if (file.extension !in listOf("java"))
-                        continue
-
-                    launch(dispatcher) {
-                        val output = ArrayList<String>()
-                        var changed = false
-
-                        file.bufferedReader().use {
-                            for (line in it.lines()) {
-                                if (line.startsWith("package") || line.isBlank()) {
-                                    output += line
-                                    continue
-                                }
-
-                                if (!line.startsWith("import")) {
-                                    if (!changed) return@launch
-                                    else {
-                                        output += line
-                                        continue
-                                    }
-                                }
-
-                                if (!line.contains(pattern)) {
-                                    output += line
-                                    continue
-                                }
-
-                                output += line.replace(pattern, replacement)
-                                changed = true
-                            }
-                        }
-
-                        if (changed) {
-                            RandomAccessFile(file, "r").use { raf ->
-                                val bytes = ByteArray(NEW_LINE_BYTES.size)
-                                raf.seek(raf.length() - bytes.size)
-                                raf.readFully(bytes)
-                                if (bytes.contentEquals(NEW_LINE_BYTES))
-                                    output += ""
-                            }
-
-                            file.writer().use {
-                                val iterator = output.iterator()
-                                while (iterator.hasNext()) {
-                                    it.append(iterator.next())
-                                    if (iterator.hasNext())
-                                        it.append(NEW_LINE)
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    enum class Type {
-        USER_DEV,
-        BUILD_TOOLS,
-        DIRECT,
-    }
-}
-
-private val NEW_LINE = System.lineSeparator()
-private val NEW_LINE_BYTES = NEW_LINE.encodeToByteArray()
-// "1.21.11-R0.1-SNAPSHOT" -> (21, 11), "26.1.2.build.74-stable" -> (26, 1)
-private fun String.parseVersion() = substringBefore('-').split(".").let {
-    if (it[0] == "1") it[1].toInt() to it[2].toInt()
-    else it[0].toInt() to it[1].toInt()
-}
-
-class Config(
-    var jvm: Int = 21,
-    var type: Type = Type.DIRECT
-) {
-    lateinit var version: String
-}
-
-fun Project.nmsBinding(action: Config.() -> Unit) {
-    extra["nms"] = Config().apply(action)
-    plugins.apply(NMSBinding::class.java)
-}
-
-private inline fun <reified T : Named> ObjectFactory.named(name: String): T = named(T::class.java, name)
@@ -1,12 +0,0 @@
-plugins {
-    java
-}
-
-tasks.jar {
-    manifest.attributes(
-        "Agent-Class" to "com.volmit.iris.util.agent.Installer",
-        "Premain-Class" to "com.volmit.iris.util.agent.Installer",
-        "Can-Redefine-Classes" to true,
-        "Can-Retransform-Classes" to true
-    )
-}
@@ -1,29 +0,0 @@
-package com.volmit.iris.util.agent;
-
-import java.lang.instrument.Instrumentation;
-
-public class Installer {
-    private static volatile Instrumentation instrumentation;
-
-    public static Instrumentation getInstrumentation() {
-        Instrumentation instrumentation = Installer.instrumentation;
-        if (instrumentation == null) {
-            throw new IllegalStateException("The agent is not loaded or this method is not called via the system class loader");
-        }
-        return instrumentation;
-    }
-
-    public static void premain(String arguments, Instrumentation instrumentation) {
-        doMain(instrumentation);
-    }
-
-    public static void agentmain(String arguments, Instrumentation instrumentation) {
-        doMain(instrumentation);
-    }
-
-    private static synchronized void doMain(Instrumentation instrumentation) {
-        if (Installer.instrumentation != null)
-            return;
-        Installer.instrumentation = instrumentation;
-    }
-}
@@ -0,0 +1,92 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+plugins {
+    id 'java'
+    id 'java-library'
+    id "io.freefair.lombok" version "8.6"
+}
+
+def apiVersion = '1.19'
+def main = 'com.volmit.iris.Iris'
+
+/**
+ * We need parameter meta for the decree command system
+ */
+compileJava {
+    options.compilerArgs << '-parameters'
+    options.encoding = "UTF-8"
+}
+
+repositories {
+    maven { url 'https://nexus.phoenixdevt.fr/repository/maven-public/' }
+    maven { url 'https://repo.auxilor.io/repository/maven-public/' }
+}
+
+/**
+ * Dependencies.
+ *
+ * Provided or classpath dependencies are not shaded and are available on the runtime classpath
+ *
+ * Shaded dependencies are not available at runtime, nor are they available on mvn central so they
+ * need to be shaded into the jar (increasing binary size)
+ *
+ * Dynamically loaded dependencies are defined in the plugin.yml (updating these must be updated in the
+ * plugin.yml also, otherwise they wont be available). These do not increase binary size). Only declare
+ * these dependencies if they are available on mvn central.
+ */
+dependencies {
+    // Provided or Classpath
+    compileOnly 'org.spigotmc:spigot-api:1.20.1-R0.1-SNAPSHOT'
+    compileOnly 'org.apache.logging.log4j:log4j-api:2.19.0'
+    compileOnly 'org.apache.logging.log4j:log4j-core:2.19.0'
+    compileOnly 'commons-io:commons-io:2.13.0'
+    compileOnly 'commons-lang:commons-lang:2.6'
+    compileOnly 'com.github.oshi:oshi-core:5.8.5'
+    compileOnly 'org.lz4:lz4-java:1.8.0'
+
+    // Third Party Integrations
+    compileOnly 'com.ticxo.playeranimator:PlayerAnimator:R1.2.7'
+    compileOnly 'io.th0rgal:oraxen:1.173.0'
+    compileOnly 'com.github.LoneDev6:api-itemsadder:3.4.1-r4'
+    compileOnly 'com.github.PlaceholderAPI:placeholderapi:2.11.3'
+    compileOnly 'com.github.Ssomar-Developement:SCore:4.23.10.8'
+    compileOnly 'net.Indyuce:MMOItems-API:6.9.5-SNAPSHOT'
+    compileOnly 'com.willfp:EcoItems:5.44.0'
+    //implementation files('libs/CustomItems.jar')
+}
+
+
+/**
+ * Gradle is weird sometimes, we need to delete the plugin yml from the build folder to actually filter properly.
+ */
+file(jar.archiveFile.get().getAsFile().getParentFile().getParentFile().getParentFile().getAbsolutePath() + '/build/resources/main/plugin.yml').delete()
+
+/**
+ * Expand properties into plugin yml
+ */
+processResources {
+    filesMatching('**/plugin.yml') {
+        expand(
+                'name': rootProject.name.toString(),
+                'version': rootProject.version.toString(),
+                'main': main.toString(),
+                'apiversion': apiVersion.toString()
+        )
+    }
+}
@@ -1,231 +0,0 @@
-import io.github.slimjar.func.slimjarHelper
-import io.github.slimjar.resolver.data.Mirror
-import org.ajoberstar.grgit.Grgit
-import org.gradle.jvm.toolchain.JavaLanguageVersion
-import org.jetbrains.kotlin.gradle.dsl.JvmTarget
-import java.net.URI
-
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2021 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-plugins {
-    java
-    `java-library`
-    alias(libs.plugins.shadow)
-    alias(libs.plugins.sentry)
-    alias(libs.plugins.slimjar)
-    alias(libs.plugins.grgit)
-    alias(libs.plugins.kotlin.jvm)
-    alias(libs.plugins.kotlin.lombok)
-}
-
-val apiVersion = "1.19"
-val main = "com.volmit.iris.Iris"
-val lib = "com.volmit.iris.util"
-
-/**
- * Dependencies.
- *
- * Provided or classpath dependencies are not shaded and are available on the runtime classpath
- *
- * Shaded dependencies are not available at runtime, nor are they available on mvn central so they
- * need to be shaded into the jar (increasing binary size)
- *
- * Dynamically loaded dependencies are defined in the plugin.yml (updating these must be updated in the
- * plugin.yml also, otherwise they wont be available). These do not increase binary size). Only declare
- * these dependencies if they are available on mvn central.
- */
-dependencies {
-    // Provided or Classpath
-    compileOnly(libs.paper)
-    compileOnly(platform(libs.adventure.bom))
-    compileOnly(libs.log4j.api)
-    compileOnly(libs.log4j.core)
-
-    // Third Party Integrations
-    compileOnly(libs.nexo)
-    compileOnly(libs.itemsadder)
-    compileOnly(libs.placeholderApi)
-    compileOnly(libs.score)
-    compileOnly(libs.mmoitems)
-    compileOnly(libs.ecoitems)
-    compileOnly(libs.mythic)
-    compileOnly(libs.mythicChrucible)
-    compileOnly(libs.kgenerators) {
-        isTransitive = false
-    }
-    compileOnly(libs.multiverseCore)
-    compileOnly(libs.craftengine.core)
-    compileOnly(libs.craftengine.bukkit)
-    //compileOnly(libs.sparrowNbt)
-
-    // Shaded
-    implementation(slimjarHelper("spigot"))
-
-    // Dynamically Loaded
-    slim(libs.paralithic)
-    slim(libs.bstats)
-    slim(libs.sentry)
-
-    slim(libs.commons.io)
-    slim(libs.commons.lang)
-    slim(libs.commons.lang3)
-    slim(libs.commons.math3)
-    slim(libs.oshi)
-    slim(libs.lz4)
-    slim(libs.fastutil)
-    slim(libs.lru)
-    slim(libs.zip)
-    slim(libs.gson)
-    slim(libs.asm)
-    slim(libs.caffeine)
-    slim(libs.byteBuddy.core)
-    slim(libs.byteBuddy.agent)
-    slim(libs.dom4j)
-    slim(libs.jaxen)
-    slim(libs.flatlaf)
-    slim(libs.flatlaf.extras)
-
-    // Script Engine
-    slim(libs.kotlin.stdlib)
-    slim(libs.kotlin.coroutines)
-    slim(libs.kotlin.scripting.common)
-    slim(libs.kotlin.scripting.jvm)
-    slim(libs.kotlin.scripting.jvm.host)
-    slim(libs.kotlin.scripting.dependencies.maven) {
-        constraints {
-            slim(libs.mavenCore)
-        }
-    }
-}
-
-java {
-    disableAutoTargetJvm()
-    toolchain {
-        languageVersion.set(JavaLanguageVersion.of(21))
-    }
-}
-
-kotlin {
-    jvmToolchain(21)
-    compilerOptions {
-        jvmTarget.set(JvmTarget.JVM_21)
-    }
-}
-
-sentry {
-    url = "http://sentry.volmit.com:8080"
-    autoInstallation.enabled = false
-    includeSourceContext = true
-
-    org = "sentry"
-    projectName = "iris"
-    authToken = findProperty("sentry.auth.token") as String? ?: System.getenv("SENTRY_AUTH_TOKEN")
-}
-
-slimJar {
-    mirrors = listOf(Mirror(
-        URI.create("https://maven-central.storage-download.googleapis.com/maven2").toURL(),
-        URI.create("https://repo.maven.apache.org/maven2/").toURL()
-    ))
-
-    relocate("com.dfsek.paralithic", "$lib.paralithic")
-    relocate("org.bstats", "$lib.metrics")
-    relocate("io.sentry", "$lib.sentry")
-    relocate("org.apache.maven", "$lib.maven")
-    relocate("org.codehaus.plexus", "$lib.plexus")
-    relocate("org.eclipse.sisu", "$lib.sisu")
-    relocate("org.eclipse.aether", "$lib.aether")
-    relocate("com.google.inject", "$lib.guice")
-    relocate("org.dom4j", "$lib.dom4j")
-    relocate("org.jaxen", "$lib.jaxen")
-    relocate("com.github.benmanes.caffeine", "$lib.caffeine")
-}
-
-tasks {
-    /**
-     * We need parameter meta for the decree command system
-     */
-    compileJava {
-        options.compilerArgs.add("-parameters")
-        options.encoding = "UTF-8"
-    }
-
-    /**
-     * Expand properties into plugin yml
-     */
-    processResources {
-        inputs.properties(
-            "name" to rootProject.name,
-            "version" to rootProject.version,
-            "apiVersion" to apiVersion,
-            "main" to main,
-        )
-        filesMatching("**/plugin.yml") {
-            expand(inputs.properties)
-        }
-    }
-
-    shadowJar {
-        mergeServiceFiles()
-        //minimize()
-        relocate("io.github.slimjar", "$lib.slimjar")
-        exclude("modules/loader-agent.isolated-jar")
-    }
-
-    sentryCollectSourcesJava {
-        dependsOn(generateTemplates)
-    }
-}
-
-val templateSource = file("src/main/templates")
-val templateDest = layout.buildDirectory.dir("generated/sources/templates")!!
-val generateTemplates = tasks.register<Copy>("generateTemplates") {
-    inputs.properties(
-        "environment" to when {
-            project.hasProperty("release") -> "production"
-            project.hasProperty("argghh") -> "Argghh!"
-            else -> "development"
-        },
-        "commit" to provider {
-            val res = runCatching { project.extensions.getByType<Grgit>().head().id }
-            res.getOrDefault("")
-                .takeIf { it.length == 40 } ?: run {
-                this.logger.error("Git commit hash not found", res.exceptionOrNull())
-                "unknown"
-            }
-        },
-    )
-
-    from(templateSource)
-    into(templateDest)
-    rename { "com/volmit/iris/$it" }
-    expand(inputs.properties)
-}
-
-tasks.generateSentryBundleIdJava {
-    dependsOn(generateTemplates)
-}
-
-rootProject.tasks.named("prepareKotlinBuildScriptModel") {
-    dependsOn(generateTemplates)
-}
-
-sourceSets.main {
-    java.srcDir(generateTemplates.map { it.outputs })
-}
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -23,11 +23,8 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.json.JSONException;
 import com.volmit.iris.util.json.JSONObject;
-import com.volmit.iris.util.misc.getHardware;
 import com.volmit.iris.util.plugin.VolmitSender;
-import lombok.AllArgsConstructor;
 import lombok.Data;
-import lombok.NoArgsConstructor;

 import java.io.File;
 import java.io.IOException;
@@ -36,6 +33,7 @@ import java.io.IOException;
@Data
 public class IrisSettings {
    public static IrisSettings settings;
+    private IrisSafeGuard safeguard = new IrisSafeGuard();
    private IrisSettingsGeneral general = new IrisSettingsGeneral();
    private IrisSettingsWorld world = new IrisSettingsWorld();
    private IrisSettingsGUI gui = new IrisSettingsGUI();
@@ -44,15 +42,16 @@ public class IrisSettings {
    private IrisSettingsConcurrency concurrency = new IrisSettingsConcurrency();
    private IrisSettingsStudio studio = new IrisSettingsStudio();
    private IrisSettingsPerformance performance = new IrisSettingsPerformance();
-    private IrisSettingsUpdater updater = new IrisSettingsUpdater();
-    private IrisSettingsPregen pregen = new IrisSettingsPregen();
-    private IrisSettingsSentry sentry = new IrisSettingsSentry();
+    private IrisWorldDump worldDump = new IrisWorldDump();
+    private IrisWorldSettings irisWorldSettings = new IrisWorldSettings();
+    private IrisServerSettings server = new IrisServerSettings();

    public static int getThreadCount(int c) {
-        return Math.max(switch (c) {
+        return switch (c) {
            case -1, -2, -4 -> Runtime.getRuntime().availableProcessors() / -c;
+            case 0, 1, 2 -> 1;
            default -> Math.max(c, 2);
-        }, 1);
+        };
    }

    public static IrisSettings get() {
@@ -106,6 +105,12 @@ public class IrisSettings {
        }
    }

+    @Data
+    public static class IrisSafeGuard {
+        public boolean ignoreBootMode = false;
+        public boolean userUnstableWarning = true;
+    }
+
    @Data
    public static class IrisSettingsAutoconfiguration {
        public boolean configureSpigotTimeoutTime = true;
@@ -131,121 +136,39 @@ public class IrisSettings {
        public boolean markerEntitySpawningSystem = true;
        public boolean effectSystem = true;
        public boolean worldEditWandCUI = true;
-        public boolean globalPregenCache = false;
    }

    @Data
    public static class IrisSettingsConcurrency {
        public int parallelism = -1;
-        public int ioParallelism = -2;
-        public int worldGenParallelism = -1;
-
-        public int getWorldGenThreads() {
-            return getThreadCount(worldGenParallelism);
-        }
-    }
-
-    @Data
-    public static class IrisSettingsPregen {
-        private static final int MIN_RESIDENT_TECTONIC_PLATES = 16;
-        private static final double MANTLE_HEAP_FRACTION = 0.6D;
-        private static final int MEASURED_PLATE_MEGABYTES = 38;
-        private static final int MEASURED_WORLD_HEIGHT = 1088;
-
-        public boolean useCacheByDefault = true;
-        public boolean useHighPriority = false;
-        public boolean useVirtualThreads = false;
-        public boolean useTicketQueue = true;
-        public int maxConcurrency = 256;
-        public int maxResidentTectonicPlates = 96;
-        public int mantleBackpressureWaitMs = 25;
-        public int mantleBackpressureTimeoutMs = 60_000;
-
-        public int getEffectiveResidentTectonicPlates(int worldHeight) {
-            // Mantle chunks only hold the sections something was written to, so shorter worlds keep the measured size.
-            double heightScale = Math.max(1D, (double) worldHeight / MEASURED_WORLD_HEIGHT);
-            double plateMegabytes = MEASURED_PLATE_MEGABYTES * heightScale;
-            int heapBudget = (int) Math.floor(MANTLE_HEAP_FRACTION * getHardware.getProcessMemory() / plateMegabytes);
-            return Math.max(MIN_RESIDENT_TECTONIC_PLATES, Math.min(maxResidentTectonicPlates, heapBudget));
-        }
-
-        public int getMantleBackpressureWaitMs() {
-            return Math.max(5, Math.min(mantleBackpressureWaitMs, 1_000));
-        }
-
-        public int getMantleBackpressureTimeoutMs() {
-            return Math.max(5_000, Math.min(mantleBackpressureTimeoutMs, 600_000));
-        }
    }

    @Data
    public static class IrisSettingsPerformance {
-        private IrisSettingsEngineSVC engineSVC = new IrisSettingsEngineSVC();
-        public boolean trimMantleInStudio = false; 
+        public boolean trimMantleInStudio = false;
        public int mantleKeepAlive = 30;
-        public int noiseCacheSize = 1_024;
+        public int headlessKeepAlive = 10;
+        public int cacheSize = 4_096;
        public int resourceLoaderCacheSize = 1_024;
        public int objectLoaderCacheSize = 4_096;
        public int scriptLoaderCacheSize = 512;
-        public int tectonicPlateSize = -1;
-        public int mantleCleanupDelay = 200;
-
-        public int getTectonicPlateSize() {
-            if (tectonicPlateSize > 0)
-                return tectonicPlateSize;
-
-            return (int) (getHardware.getProcessMemory() / 512L);
-        }
-    }
-
-    @Data
-    public static class IrisSettingsUpdater {
-        public int maxConcurrency = 256;
-        public boolean nativeThreads = false;
-        public double threadMultiplier = 2;
-
-        public double chunkLoadSensitivity = 0.7;
-        public MsRange emptyMsRange = new MsRange(80, 100);
-        public MsRange defaultMsRange = new MsRange(20, 40);
-
-        public int getMaxConcurrency() {
-            return Math.max(Math.abs(maxConcurrency), 1);
-        }
-
-        public double getThreadMultiplier() {
-            return Math.min(Math.abs(threadMultiplier), 0.1);
-        }
-
-        public double getChunkLoadSensitivity() {
-            return Math.min(chunkLoadSensitivity, 0.9);
-        }
-    }
-
-    @Data
-    @NoArgsConstructor
-    @AllArgsConstructor
-    public static class MsRange {
-        public int min = 20;
-        public int max = 40;
    }

    @Data
    public static class IrisSettingsGeneral {
-        public boolean DoomsdayAnnihilationSelfDestructMode = false;
        public boolean commandSounds = true;
        public boolean debug = false;
-        public boolean dumpMantleOnError = false;
        public boolean disableNMS = false;
        public boolean pluginMetrics = true;
        public boolean splashLogoStartup = true;
        public boolean useConsoleCustomColors = true;
        public boolean useCustomColorsIngame = true;
-        public boolean adjustVanillaHeight = false;
        public String forceMainWorld = "";
        public int spinh = -20;
        public int spins = 7;
        public int spinb = 8;
        public String cartographerMessage = "Iris does not allow cartographers in its world due to crashes.";
+        public String[] dataPackPaths = new String[0];


        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
@@ -254,19 +177,11 @@ public class IrisSettings {
        }
    }

-    @Data
-    public static class IrisSettingsSentry {
-        public boolean includeServerId = true;
-        public boolean disableAutoReporting = false;
-        public boolean debug = false;
-    }
-
    @Data
    public static class IrisSettingsGUI {
        public boolean useServerLaunchedGuis = true;
        public boolean maximumPregenGuiFPS = false;
        public boolean colorMode = true;
-        public String theme = "auto";
    }

    @Data
@@ -274,10 +189,6 @@ public class IrisSettings {
        public String defaultWorldType = "overworld";
        public int maxBiomeChildDepth = 4;
        public boolean preventLeafDecay = true;
-        public boolean useMulticore = false;
-        public boolean useMulticoreMantle = false;
-        public boolean offsetNoiseTypes = false;
-        public boolean earlyCustomBlocks = false;
    }

    @Data
@@ -289,13 +200,26 @@ public class IrisSettings {
    }

    @Data
-    public static class IrisSettingsEngineSVC {
-        public boolean useVirtualThreads = true;
-        public boolean forceMulticoreWrite = false;
-        public int priority = Thread.NORM_PRIORITY;
+    public static class IrisWorldDump {
+        public int mcaCacheSize = 3;
+    }

-        public int getPriority() {
-            return Math.max(Math.min(priority, Thread.MAX_PRIORITY), Thread.MIN_PRIORITY);
+    @Data
+    public static class IrisServerSettings {
+        public boolean active = false;
+        public int port = 1337;
+        public String[] remote = new String[0];
+
+        public boolean isRemote() {
+            return remote.length != 0;
        }
    }
+
+    // todo: Goal:Have these as the default world settings and when put in bukkit.yml it will again overwrite that world from these.
+    @Data
+    public static class IrisWorldSettings {
+        public boolean dynamicEntityAdjustments;
+
+
+    }
 }
@@ -1,137 +0,0 @@
-package com.volmit.iris.core;
-
-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
-import com.google.gson.reflect.TypeToken;
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.core.world.WorldStorage;
-import com.volmit.iris.engine.data.cache.AtomicCache;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.io.IO;
-import com.volmit.iris.util.misc.ServerProperties;
-import org.bukkit.Bukkit;
-import org.bukkit.configuration.file.YamlConfiguration;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.OutputStreamWriter;
-import java.lang.reflect.Type;
-import java.util.HashSet;
-import java.util.Objects;
-import java.util.Set;
-import java.util.stream.Stream;
-
-public class IrisWorlds {
-    private static final AtomicCache<IrisWorlds> cache = new AtomicCache<>();
-    private static final Gson GSON = new GsonBuilder().setPrettyPrinting().create();
-    private static final Type TYPE = TypeToken.getParameterized(KMap.class, String.class, String.class).getType();
-    private final KMap<String, String> worlds;
-    private volatile boolean dirty = false;
-
-    private IrisWorlds(KMap<String, String> worlds) {
-        this.worlds = worlds;
-        readBukkitWorlds().forEach(this::put0);
-        save();
-    }
-
-    public static IrisWorlds get() {
-        return cache.aquire(() -> new IrisWorlds(readWorldsFile()));
-    }
-
-    public static Set<String> readKnownWorldNames() {
-        Set<String> names = new HashSet<>(readWorldsFile().keySet());
-        names.addAll(readBukkitWorlds().keySet());
-        return names;
-    }
-
-    private static KMap<String, String> readWorldsFile() {
-        File file = Iris.instance.getDataFile("worlds.json");
-        if (!file.exists()) {
-            return new KMap<>();
-        }
-
-        try {
-            String json = IO.readAll(file);
-            KMap<String, String> worlds = GSON.fromJson(json, TYPE);
-            return Objects.requireNonNullElseGet(worlds, KMap::new);
-        } catch (Throwable e) {
-            Iris.error("Failed to load worlds.json!");
-            e.printStackTrace();
-            Iris.reportError(e);
-        }
-
-        return new KMap<>();
-    }
-
-    public void put(String name, String type) {
-        put0(name, type);
-        save();
-    }
-
-    private void put0(String name, String type) {
-        String old = worlds.put(name, type);
-        if (!type.equals(old))
-            dirty = true;
-    }
-
-    public KMap<String, String> getWorlds() {
-        clean();
-        return readBukkitWorlds().put(worlds);
-    }
-
-    public Stream<IrisData> getPacks() {
-        return getDimensions()
-                .map(IrisDimension::getLoader)
-                .filter(Objects::nonNull);
-    }
-
-    public Stream<IrisDimension> getDimensions() {
-        return getWorlds()
-                .entrySet()
-                .stream()
-                .map(entry -> Iris.loadDimension(entry.getKey(), entry.getValue()))
-                .filter(Objects::nonNull);
-    }
-
-    public void clean() {
-        dirty = worlds.entrySet().removeIf(entry -> !new File(WorldStorage.get().worldFolder(entry.getKey()), "iris/pack/dimensions/" + entry.getValue() + ".json").exists());
-    }
-
-    public synchronized void save() {
-        clean();
-        if (!dirty) return;
-        try {
-            IO.write(Iris.instance.getDataFile("worlds.json"), OutputStreamWriter::new, writer -> GSON.toJson(worlds, TYPE, writer));
-            dirty = false;
-        } catch (IOException e) {
-            Iris.error("Failed to save worlds.json!");
-            e.printStackTrace();
-            Iris.reportError(e);
-        }
-    }
-
-    public static KMap<String, String> readBukkitWorlds() {
-        var bukkit = YamlConfiguration.loadConfiguration(ServerProperties.BUKKIT_YML);
-        var worlds = bukkit.getConfigurationSection("worlds");
-        if (worlds == null) return new KMap<>();
-
-        var result = new KMap<String, String>();
-        for (String world : worlds.getKeys(false)) {
-            var gen = worlds.getString(world + ".generator");
-            if (gen == null) continue;
-
-            String loadKey;
-            if (gen.equalsIgnoreCase("iris")) {
-                loadKey = IrisSettings.get().getGenerator().getDefaultWorldType();
-            } else if (gen.startsWith("Iris:")) {
-                loadKey = gen.substring(5);
-            } else continue;
-
-            result.put(world, loadKey);
-        }
-
-        return result;
-    }
-}
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -21,34 +21,19 @@ package com.volmit.iris.core;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.nms.INMS;
-import com.volmit.iris.core.nms.datapack.DataVersion;
-import com.volmit.iris.core.nms.datapack.IDataFixer;
-import com.volmit.iris.core.world.WorldStorage;
-import com.volmit.iris.engine.object.*;
+import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.engine.object.IrisDimension;
 import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.collection.KSet;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.misc.ServerProperties;
-import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.J;
-import lombok.NonNull;
-import lombok.SneakyThrows;
-import org.bukkit.Bukkit;
 import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.configuration.file.YamlConfiguration;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.Nullable;

 import java.io.File;
 import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
+import java.util.Arrays;
 import java.util.Objects;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicIntegerArray;
-import java.util.stream.Stream;

 public class ServerConfigurator {
    public static void configure() {
@@ -60,8 +45,6 @@ public class ServerConfigurator {
        if (s.isConfigurePaperWatchdogDelay()) {
            J.attempt(ServerConfigurator::increasePaperWatchdog);
        }
-
-        installDataPacks(true);
    }

    private static void increaseKeepAliveSpigot() throws IOException, InvalidConfigurationException {
@@ -70,242 +53,80 @@ public class ServerConfigurator {
        f.load(spigotConfig);
        long tt = f.getLong("settings.timeout-time");

-        long spigotTimeout = TimeUnit.MINUTES.toSeconds(5);
-
-        if (tt < spigotTimeout) {
-            Iris.warn("Updating spigot.yml timeout-time: " + tt + " -> " + spigotTimeout + " (5 minutes)");
+        if (tt < TimeUnit.MINUTES.toSeconds(5)) {
+            Iris.warn("Updating spigot.yml timeout-time: " + tt + " -> " + TimeUnit.MINUTES.toSeconds(20) + " (5 minutes)");
            Iris.warn("You can disable this change (autoconfigureServer) in Iris settings, then change back the value.");
-            f.set("settings.timeout-time", spigotTimeout);
+            f.set("settings.timeout-time", TimeUnit.MINUTES.toSeconds(5));
            f.save(spigotConfig);
        }
    }
+
    private static void increasePaperWatchdog() throws IOException, InvalidConfigurationException {
        File spigotConfig = new File("config/paper-global.yml");
        FileConfiguration f = new YamlConfiguration();
        f.load(spigotConfig);
        long tt = f.getLong("watchdog.early-warning-delay");

-        long watchdog = TimeUnit.MINUTES.toMillis(3);
-        if (tt < watchdog) {
-            Iris.warn("Updating paper.yml watchdog early-warning-delay: " + tt + " -> " + watchdog + " (3 minutes)");
+        if (tt < TimeUnit.MINUTES.toMillis(3)) {
+            Iris.warn("Updating paper.yml watchdog early-warning-delay: " + tt + " -> " + TimeUnit.MINUTES.toMillis(15) + " (3 minutes)");
            Iris.warn("You can disable this change (autoconfigureServer) in Iris settings, then change back the value.");
-            f.set("watchdog.early-warning-delay", watchdog);
+            f.set("watchdog.early-warning-delay", TimeUnit.MINUTES.toMillis(3));
            f.save(spigotConfig);
        }
    }

-    private static KList<File> getDatapacksFolder() {
-        if (!IrisSettings.get().getGeneral().forceMainWorld.isEmpty()) {
-            return new KList<File>().qadd(new File(Bukkit.getWorldContainer(), IrisSettings.get().getGeneral().forceMainWorld + "/datapacks"));
-        }
-        return WorldStorage.get().datapackFolders();
+    private static File[] getDataPacksFolder() {
+        KList<File> files = new KList<>();
+        files.add(new File("plugins/Iris/datapack"));
+        Arrays.stream(IrisSettings.get().getGeneral().dataPackPaths)
+                .map(File::new)
+                .forEach(files::add);
+        return files.toArray(File[]::new);
    }

-    public static boolean installDataPacks(boolean fullInstall) {
-        return installDataPacks(DataVersion.getDefault(), fullInstall);
-    }
-
-    public static boolean installDataPacks(IDataFixer fixer, boolean fullInstall) {
-        if (fixer == null) {
-            Iris.error("Unable to install datapacks, fixer is null!");
-            return false;
+    public static void setupDataPack() {
+        File packs = new File("plugins/Iris/packs");
+        if (!packs.exists()) {
+            disableDataPack();
+            return;
        }
-        Iris.info("Checking Data Packs...");
-        DimensionHeight height = new DimensionHeight(fixer);
-        KList<File> folders = getDatapacksFolder();
-        KMap<String, KSet<String>> biomes = new KMap<>();
+        for (File i : packs.listFiles()) {
+            if (!i.isDirectory()) continue;

-        try (Stream<IrisData> stream = allPacks()) {
-            stream.flatMap(height::merge)
-                    .parallel()
-                    .forEach(dim -> {
-                        Iris.verbose("  Checking Dimension " + dim.getLoadFile().getPath());
-                        dim.installBiomes(fixer, dim::getLoader, folders, biomes.computeIfAbsent(dim.getLoadKey(), k -> new KSet<>()));
-                        dim.installDimensionType(fixer, folders);
-                    });
-        }
-        IrisDimension.writeShared(folders, height);
-        Iris.info("Data Packs Setup!");
+            Iris.verbose("Checking Pack: " + i.getPath());
+            IrisData data = IrisData.get(i);
+            File dims = new File(i, "dimensions");

-        return fullInstall && verifyDataPacksPost(IrisSettings.get().getAutoConfiguration().isAutoRestartOnCustomBiomeInstall());
-    }
+            if (dims.exists()) {
+                for (File j : dims.listFiles((f, s) -> s.endsWith(".json"))) {
+                    if (!j.isFile()) continue;
+                    IrisDimension dim = data.getDimensionLoader().load(j.getName().split("\\Q.\\E")[0]);
+                    if (dim == null) continue;

-    private static boolean verifyDataPacksPost(boolean allowRestarting) {
-        try (Stream<IrisData> stream = allPacks()) {
-            boolean bad = stream
-                    .map(data -> {
-                        Iris.verbose("Checking Pack: " + data.getDataFolder().getPath());
-                        var loader = data.getDimensionLoader();
-                        return loader.loadAll(loader.getPossibleKeys())
-                                .stream()
-                                .filter(Objects::nonNull)
-                                .map(ServerConfigurator::verifyDataPackInstalled)
-                                .toList()
-                                .contains(false);
-                    })
-                    .toList()
-                    .contains(true);
-            if (!bad) return false;
-        }
-
-
-        if (allowRestarting) {
-            restart();
-        } else if (INMS.get().supportsDataPacks()) {
-            Iris.error("============================================================================");
-            Iris.error(C.ITALIC + "You need to restart your server to properly generate custom biomes.");
-            Iris.error(C.ITALIC + "By continuing, Iris will use backup biomes in place of the custom biomes.");
-            Iris.error("----------------------------------------------------------------------------");
-            Iris.error(C.UNDERLINE + "IT IS HIGHLY RECOMMENDED YOU RESTART THE SERVER BEFORE GENERATING!");
-            Iris.error("============================================================================");
-
-            for (Player i : Bukkit.getOnlinePlayers()) {
-                if (i.isOp() || i.hasPermission("iris.all")) {
-                    VolmitSender sender = new VolmitSender(i, Iris.instance.getTag("WARNING"));
-                    sender.sendMessage("There are some Iris Packs that have custom biomes in them");
-                    sender.sendMessage("You need to restart your server to use these packs.");
-                }
-            }
-
-            J.sleep(3000);
-        }
-        return true;
-    }
-
-    public static void restart() {
-        J.s(() -> {
-            Iris.warn("New data pack entries have been installed in Iris! Restarting server!");
-            Iris.warn("This will only happen when your pack changes (updates/first time setup)");
-            Iris.warn("(You can disable this auto restart in iris settings)");
-            J.s(() -> {
-                Iris.warn("Looks like the restart command didn't work. Stopping the server instead!");
-                Bukkit.shutdown();
-            }, 100);
-            Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "restart");
-        });
-    }
-
-    public static boolean verifyDataPackInstalled(IrisDimension dimension) {
-        KSet<String> keys = new KSet<>();
-        boolean warn = false;
-
-        for (IrisBiome i : dimension.getAllBiomes(dimension::getLoader)) {
-            if (i.isCustom()) {
-                for (IrisBiomeCustom j : i.getCustomDerivitives()) {
-                    keys.add(dimension.getLoadKey() + ":" + j.getId());
+                    dim.getAllBiomes(() -> data)
+                            .stream()
+                            .map(IrisBiome::getCustomDerivitives)
+                            .filter(Objects::nonNull)
+                            .flatMap(KList::stream)
+                            .forEach(b -> INMS.get().registerBiome(dim.getLoadKey(), b, false));
                }
            }
        }
-        String key = worldFolderNameOf(dimension.getLoader());
-        if (key == null) key = dimension.getLoadKey();
-        else key += "/" + dimension.getLoadKey();
-
-        if (!INMS.get().supportsDataPacks()) {
-            if (!keys.isEmpty()) {
-                Iris.warn("===================================================================================");
-                Iris.warn("Pack " + key + " has " + keys.size() + " custom biome(s). ");
-                Iris.warn("Your server version does not yet support datapacks for iris.");
-                Iris.warn("The world will generate these biomes as backup biomes.");
-                Iris.warn("====================================================================================");
-            }
-
-            return true;
-        }
-
-        for (String i : keys) {
-            Object o = INMS.get().getCustomBiomeBaseFor(i);
-
-            if (o == null) {
-                Iris.warn("The Biome " + i + " is not registered on the server.");
-                warn = true;
-            }
-        }
-
-        if (INMS.get().missingDimensionTypes(dimension.getDimensionTypeKey())) {
-            Iris.warn("The Dimension Type for " + dimension.getLoadFile() + " is not registered on the server.");
-            warn = true;
-        }
-
-        if (warn) {
-            Iris.error("The Pack " + key + " is INCAPABLE of generating custom biomes");
-            Iris.error("If not done automatically, restart your server before generating with this pack!");
-        }
-
-        return !warn;
+        dumpDataPack();
    }

-    public static Stream<IrisData> allPacks() {
-        return Stream.concat(listFiles(Iris.instance.getDataFolder("packs"))
-                .filter(File::isDirectory)
-                .filter( base -> {
-                    var content = new File(base, "dimensions").listFiles();
-                    return content != null && content.length > 0;
-                })
-                .map(IrisData::get), IrisWorlds.get().getPacks());
+    public static void dumpDataPack() {
+        if (!INMS.get().dumpRegistry(getDataPacksFolder())) {
+            return;
+        }
+        disableDataPack();
    }

-    @Nullable
-    private static String worldFolderNameOf(IrisData data) {
-        File pack = data.getDataFolder();
-        File iris = pack.getParentFile();
-        if (iris == null || iris.getParentFile() == null || !pack.getName().equals("pack") || !iris.getName().equals("iris")) {
-            return null;
-        }
-        return iris.getParentFile().getName();
-    }
-
-    @SneakyThrows
-    private static Stream<File> listFiles(File parent) {
-        if (!parent.isDirectory()) return Stream.empty();
-        return Files.walk(parent.toPath()).map(Path::toFile);
-    }
-
-    public static class DimensionHeight {
-        private final IDataFixer fixer;
-        private final AtomicIntegerArray[] dimensions = new AtomicIntegerArray[3];
-
-        public DimensionHeight(IDataFixer fixer) {
-            this.fixer = fixer;
-            for (int i = 0; i < 3; i++) {
-                dimensions[i] = new AtomicIntegerArray(new int[]{
-                        Integer.MAX_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE
-                });
-            }
-        }
-
-        public Stream<IrisDimension> merge(IrisData data) {
-            Iris.verbose("Checking Pack: " + data.getDataFolder().getPath());
-            var loader = data.getDimensionLoader();
-            return loader.loadAll(loader.getPossibleKeys())
-                    .stream()
-                    .filter(Objects::nonNull)
-                    .peek(this::merge);
-        }
-
-        public void merge(IrisDimension dimension) {
-            AtomicIntegerArray array = dimensions[dimension.getBaseDimension().ordinal()];
-            array.updateAndGet(0, min -> Math.min(min, dimension.getMinHeight()));
-            array.updateAndGet(1, max -> Math.max(max, dimension.getMaxHeight()));
-            array.updateAndGet(2, logical -> Math.max(logical, dimension.getLogicalHeight()));
-        }
-
-        public String[] jsonStrings() {
-            var dims = IDataFixer.Dimension.values();
-            var arr = new String[3];
-            for (int i = 0; i < 3; i++) {
-                arr[i] = jsonString(dims[i]);
-            }
-            return arr;
-        }
-
-        public String jsonString(IDataFixer.Dimension dimension) {
-            var data = dimensions[dimension.ordinal()];
-            int minY = data.get(0);
-            int maxY = data.get(1);
-            int logicalHeight = data.get(2);
-            if (minY == Integer.MAX_VALUE || maxY == Integer.MIN_VALUE || Integer.MIN_VALUE == logicalHeight)
-                return null;
-            return fixer.createDimension(dimension, minY, maxY - minY, logicalHeight, null).toString(4);
-        }
+    public static void disableDataPack() {
+        var packs = INMS.get().getPackRepository();
+        packs.reload();
+        if (!packs.removePack("file/iris"))
+            return;
+        packs.reloadWorldData();
    }
 }
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -18,44 +18,27 @@

 package com.volmit.iris.core.commands;

-import com.google.gson.JsonArray;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
 import com.volmit.iris.Iris;
-import com.volmit.iris.core.ServerConfigurator;
 import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.core.nms.INMS;
-import com.volmit.iris.core.nms.datapack.DataVersion;
-import com.volmit.iris.core.service.IrisEngineSVC;
 import com.volmit.iris.core.tools.IrisPackBenchmarking;
 import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.core.tools.IrisWorldDump;
 import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.framework.EnginePlayer;
 import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.object.IrisPosition;
-import com.volmit.iris.engine.object.annotations.Snippet;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.collection.KSet;
-import com.volmit.iris.util.context.IrisContext;
-import com.volmit.iris.engine.object.IrisJigsawStructurePlacement;
+import com.volmit.iris.engine.service.EngineStatusSVC;
 import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
 import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.decree.specialhandlers.NullableDimensionHandler;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.io.CountingDataInputStream;
 import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.mantle.TectonicPlate;
-import com.volmit.iris.util.math.M;
-import com.volmit.iris.util.matter.Matter;
-import com.volmit.iris.util.nbt.mca.MCAFile;
-import com.volmit.iris.util.nbt.mca.MCAUtil;
 import com.volmit.iris.util.parallel.MultiBurst;
 import com.volmit.iris.util.plugin.VolmitSender;
-import com.volmit.iris.util.scheduling.jobs.Job;
-import lombok.SneakyThrows;
 import net.jpountz.lz4.LZ4BlockInputStream;
 import net.jpountz.lz4.LZ4BlockOutputStream;
 import net.jpountz.lz4.LZ4FrameInputStream;
@@ -68,366 +51,91 @@ import org.bukkit.World;
 import java.io.*;
 import java.net.InetAddress;
 import java.net.NetworkInterface;
-import java.nio.file.Files;
 import java.util.*;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicInteger;
-import java.util.stream.Collectors;
 import java.util.zip.GZIPInputStream;
 import java.util.zip.GZIPOutputStream;

@Decree(name = "Developer", origin = DecreeOrigin.BOTH, description = "Iris World Manager", aliases = {"dev"})
 public class CommandDeveloper implements DecreeExecutor {
    private CommandTurboPregen turboPregen;
-    private CommandLazyPregen lazyPregen;
+    private CommandUpdater updater;

-    @Decree(description = "Get Loaded TectonicPlates Count", origin = DecreeOrigin.BOTH, sync = true)
+    @Decree(description = "Get Loaded TectonicPlates Count", origin = DecreeOrigin.BOTH, aliases = "status", sync = true)
    public void EngineStatus() {
-        Iris.service(IrisEngineSVC.class)
-                .engineStatus(sender());
-    }
+        var status = EngineStatusSVC.getStatus();

-    @Decree(description = "Send a test exception to sentry")
-    public void Sentry() {
-        Engine engine = engine();
-        if (engine != null) IrisContext.getOr(engine);
-        Iris.reportError(new Exception("This is a test"));
-    }
-
-    @Decree(description = "Dev cmd to fix all the broken objects caused by faulty shrinkwarp")
-    public void fixObjects(
-            @Param(aliases = "dimension", description = "The dimension type to create the world with")
-            IrisDimension type
-    ) {
-        if (type == null) {
-            sender().sendMessage("Type cant be null?");
-            return;
-        }
-
-        IrisData dm = IrisData.get(Iris.instance.getDataFolder("packs", type.getLoadKey()));
-        var loader = dm.getObjectLoader();
-        var processed = new KMap<String, IrisPosition>();
-
-        var objects = loader.getPossibleKeys();
-        var pieces = dm.getJigsawPieceLoader().getPossibleKeys();
-        var sender = sender();
-
-        sender.sendMessage(C.IRIS + "Found " + objects.length + " objects in " + type.getLoadKey());
-        sender.sendMessage(C.IRIS + "Found " + pieces.length + " jigsaw pieces in " + type.getLoadKey());
-
-        final int total = objects.length;
-        final AtomicInteger completed = new AtomicInteger();
-        final AtomicInteger changed = new AtomicInteger();
-
-        new Job() {
-            @Override
-            public String getName() {
-                return "Fixing Objects";
-            }
-
-            @Override
-            public void execute() {
-                Arrays.stream(pieces).parallel()
-                        .map(dm.getJigsawPieceLoader()::load)
-                        .filter(Objects::nonNull)
-                        .forEach(piece -> {
-                            var offset = processed.compute(piece.getObject(), (key, o) -> {
-                                if (o != null) return o;
-                                var obj = loader.load(key);
-                                if (obj == null) return new IrisPosition();
-
-                                obj.shrinkwrap();
-                                try {
-                                    if (!obj.getShrinkOffset().isZero()) {
-                                        changed.incrementAndGet();
-                                        obj.write(obj.getLoadFile());
-                                    }
-                                    completeWork();
-                                } catch (IOException e) {
-                                    Iris.error("Failed to write object " + obj.getLoadKey());
-                                    e.printStackTrace();
-                                    return new IrisPosition();
-                                }
-
-                                return new IrisPosition(obj.getShrinkOffset());
-                            });
-                            if (offset.getX() == 0 && offset.getY() == 0 && offset.getZ() == 0)
-                                return;
-
-                            piece.getConnectors().forEach(connector -> connector.setPosition(connector.getPosition().add(offset)));
-
-                            try {
-                                IO.writeAll(piece.getLoadFile(), dm.getGson().toJson(piece));
-                            } catch (IOException e) {
-                                Iris.error("Failed to write jigsaw piece " + piece.getLoadKey());
-                                e.printStackTrace();
-                            }
-                        });
-
-                Arrays.stream(loader.getPossibleKeys()).parallel()
-                        .filter(key -> !processed.containsKey(key))
-                        .map(loader::load)
-                        .forEach(obj -> {
-                            if (obj == null) {
-                                completeWork();
-                                return;
-                            }
-
-                            obj.shrinkwrap();
-                            if (obj.getShrinkOffset().isZero()) {
-                                completeWork();
-                                return;
-                            }
-
-                            try {
-                                obj.write(obj.getLoadFile());
-                                completeWork();
-                                changed.incrementAndGet();
-                            } catch (IOException e) {
-                                Iris.error("Failed to write object " + obj.getLoadKey());
-                                e.printStackTrace();
-                            }
-                        });
-            }
-
-            @Override
-            public void completeWork() {
-                completed.incrementAndGet();
-            }
-
-            @Override
-            public int getTotalWork() {
-                return total;
-            }
-
-            @Override
-            public int getWorkCompleted() {
-                return completed.get();
-            }
-        }.execute(sender, () -> {
-            var failed = total - completed.get();
-            if (failed != 0) sender.sendMessage(C.IRIS + "" + failed + " objects failed!");
-            if (changed.get() != 0) sender.sendMessage(C.IRIS + "" + changed.get() + " objects had their offsets changed!");
-            else sender.sendMessage(C.IRIS + "No objects had their offsets changed!");
-        });
+        sender().sendMessage("-------------------------");
+        sender().sendMessage(C.DARK_PURPLE + "Engine Status");
+        sender().sendMessage(C.DARK_PURPLE + "Total Engines: " + C.LIGHT_PURPLE + status.engineCount());
+        sender().sendMessage(C.DARK_PURPLE + "Total Loaded Chunks: " + C.LIGHT_PURPLE + status.loadedChunks());
+        sender().sendMessage(C.DARK_PURPLE + "Tectonic Limit: " + C.LIGHT_PURPLE + status.tectonicLimit());
+        sender().sendMessage(C.DARK_PURPLE + "Tectonic Total Plates: " + C.LIGHT_PURPLE + status.tectonicPlates());
+        sender().sendMessage(C.DARK_PURPLE + "Tectonic Active Plates: " + C.LIGHT_PURPLE + status.activeTectonicPlates());
+        sender().sendMessage(C.DARK_PURPLE + "Tectonic ToUnload: " + C.LIGHT_PURPLE + status.queuedTectonicPlates());
+        sender().sendMessage(C.DARK_PURPLE + "Lowest Tectonic Unload Duration: " + C.LIGHT_PURPLE + Form.duration(status.minTectonicUnloadDuration()));
+        sender().sendMessage(C.DARK_PURPLE + "Highest Tectonic Unload Duration: " + C.LIGHT_PURPLE + Form.duration(status.maxTectonicUnloadDuration()));
+        sender().sendMessage(C.DARK_PURPLE + "Cache Size: " + C.LIGHT_PURPLE + Form.f(IrisData.cacheSize()));
+        sender().sendMessage("-------------------------");
    }

    @Decree(description = "Test")
-    public void mantle(@Param(defaultValue = "false") boolean plate, @Param(defaultValue = "21474836474") String name) throws Throwable {
-        var base = Iris.instance.getDataFile("dump", "pv." + name + ".ttp.lz4b.bin");
-        var section = Iris.instance.getDataFile("dump", "pv." + name + ".section.bin");
+    public void benchmarkMantle(
+            @Param(description = "The world to bench", aliases = {"world"})
+            World world
+    ) throws IOException, ClassNotFoundException {
+        Engine engine = IrisToolbelt.access(world).getEngine();
+        int maxHeight = engine.getTarget().getHeight();
+        File folder = new File(Bukkit.getWorldContainer(), world.getName());
+        int c = 0;
+        //MCAUtil.read()

-        //extractSection(base, section, 5604930, 4397);
+        File tectonicplates = new File(folder, "mantle");
+        for (File i : Objects.requireNonNull(tectonicplates.listFiles())) {
+            TectonicPlate.read(maxHeight, i);
+            c++;
+            sender().sendMessage("Loaded count: " + c);

-        if (plate) {
-            try (var in = CountingDataInputStream.wrap(new BufferedInputStream(new FileInputStream(base)))) {
-                new TectonicPlate(1088, in, true);
-            } catch (Throwable e) {
-                e.printStackTrace();
-            }
-        } else Matter.read(section);
-        if (!TectonicPlate.hasError())
-            Iris.info("Read " + (plate ? base : section).length() + " bytes from " + (plate ? base : section).getAbsolutePath());
-    }
-
-    private void extractSection(File source, File target, long offset, int length) throws IOException {
-        var raf = new RandomAccessFile(source, "r");
-        var bytes = new byte[length];
-        raf.seek(offset);
-        raf.readFully(bytes);
-        raf.close();
-        Files.write(target.toPath(), bytes);
-    }
-
-    @Decree(description = "Test")
-    public void dumpThreads() {
-        try {
-            File fi = Iris.instance.getDataFile("dump", "td-" + new java.sql.Date(M.ms()) + ".txt");
-            FileOutputStream fos = new FileOutputStream(fi);
-            Map<Thread, StackTraceElement[]> f = Thread.getAllStackTraces();
-            PrintWriter pw = new PrintWriter(fos);
-
-            pw.println(Thread.activeCount() + "/" + f.size());
-            var run = Runtime.getRuntime();
-            pw.println("Memory:");
-            pw.println("\tMax: " + run.maxMemory());
-            pw.println("\tTotal: " + run.totalMemory());
-            pw.println("\tFree: " + run.freeMemory());
-            pw.println("\tUsed: " + (run.totalMemory() - run.freeMemory()));
-
-            for (Thread i : f.keySet()) {
-                pw.println("========================================");
-                pw.println("Thread: '" + i.getName() + "' ID: " + i.getId() + " STATUS: " + i.getState().name());
-
-                for (StackTraceElement j : f.get(i)) {
-                    pw.println("    @ " + j.toString());
-                }
-
-                pw.println("========================================");
-                pw.println();
-                pw.println();
-            }
-
-            pw.close();
-            Iris.info("DUMPED! See " + fi.getAbsolutePath());
-        } catch (Throwable e) {
-            e.printStackTrace();
-        }
-    }
-
-    @SneakyThrows
-    @Decree(description = "Generate Iris structures for all loaded datapack structures")
-    public void generateStructures(
-            @Param(description = "The pack to add the generated structures to", aliases = "pack", defaultValue = "null", customHandler = NullableDimensionHandler.class)
-            IrisDimension dimension,
-            @Param(description = "Ignore existing structures", defaultValue = "false")
-            boolean force
-    ) {
-        var map = INMS.get().collectStructures();
-        if (map.isEmpty()) {
-            sender().sendMessage(C.IRIS + "No structures found");
-            return;
        }

-        sender().sendMessage(C.IRIS + "Found " + map.size() + " structures");
-
-        final File dataDir;
-        final IrisData data;
-        final Set<String> existingStructures;
-        final Map<String, Set<String>> snippets;
-        final File dimensionFile;
-        final File structuresFolder;
-        final File snippetsFolder;
-
-        var dimensionObj = new JsonObject();
-
-        if (dimension == null) {
-            dataDir = Iris.instance.getDataFolder("structures");
-            IO.delete(dataDir);
-            data = IrisData.get(dataDir);
-            existingStructures = Set.of();
-            snippets = Map.of();
-            dimensionFile = new File(dataDir, "structures.json");
-        } else {
-            data = dimension.getLoader();
-            dataDir = data.getDataFolder();
-            existingStructures = new KSet<>(data.getJigsawStructureLoader().getPossibleKeys());
-
-            dimensionObj = data.getGson().fromJson(IO.readAll(dimension.getLoadFile()), JsonObject.class);
-            snippets = Optional.ofNullable(dimensionObj.getAsJsonArray("jigsawStructures"))
-                    .map(array -> array.asList()
-                            .stream()
-                            .filter(JsonElement::isJsonPrimitive)
-                            .collect(Collectors.toMap(element -> data.getGson()
-                                            .fromJson(element, IrisJigsawStructurePlacement.class)
-                                            .getStructure(),
-                                    element -> Set.of(element.getAsString()),
-                                    KSet::merge)))
-                    .orElse(Map.of());
-
-            dimensionFile = dimension.getLoadFile();
-        }
-        structuresFolder = new File(dataDir, "jigsaw-structures");
-        snippetsFolder = new File(dataDir, "snippet" + "/" + IrisJigsawStructurePlacement.class.getAnnotation(Snippet.class).value());
-
-        var gson = data.getGson();
-        var jigsawStructures = Optional.ofNullable(dimensionObj.getAsJsonArray("jigsawStructures"))
-                .orElse(new JsonArray(map.size()));
-
-        map.forEach((key, placement) -> {
-            String loadKey = "datapack/" + key.namespace() + "/" + key.key();
-            if (existingStructures.contains(loadKey) && !force)
-                return;
-
-            var structures = placement.structures();
-            var obj = placement.toJson(loadKey);
-            if (obj == null || structures.isEmpty()) {
-                sender().sendMessage(C.RED + "Failed to generate hook for " + key);
-                return;
-            }
-            File snippetFile = new File(snippetsFolder, loadKey + ".json");
-            try {
-                IO.writeAll(snippetFile, gson.toJson(obj));
-            } catch (IOException e) {
-                sender().sendMessage(C.RED + "Failed to generate snippet for " + key);
-                e.printStackTrace();
-                return;
-            }
-
-            Set<String> loadKeys = snippets.getOrDefault(loadKey, Set.of(loadKey));
-            jigsawStructures.asList().removeIf(e -> loadKeys.contains((e.isJsonObject() ? e.getAsJsonObject().get("structure") : e).getAsString()));
-            jigsawStructures.add("snippet/" + loadKey);
-
-            String structureKey;
-            if (structures.size() > 1) {
-                KList<String> common = new KList<>();
-                for (int i = 0; i < structures.size(); i++) {
-                    var tags = structures.get(i).tags();
-                    if (i == 0) common.addAll(tags);
-                    else common.removeIf(tag -> !tags.contains(tag));
-                }
-                structureKey = common.isNotEmpty() ? "#" + common.getFirst() : structures.getFirst().key();
-            } else structureKey = structures.getFirst().key();
-
-            JsonArray array = new JsonArray();
-            if (structures.size() > 1) {
-                structures.stream()
-                        .flatMap(structure -> {
-                            String[] arr = new String[structure.weight()];
-                            Arrays.fill(arr, structure.key());
-                            return Arrays.stream(arr);
-                        })
-                        .forEach(array::add);
-            } else array.add(structureKey);
-
-            obj = new JsonObject();
-            obj.addProperty("structureKey", structureKey);
-            obj.add("datapackStructures", array);
-
-            File out = new File(structuresFolder, loadKey + ".json");
-            out.getParentFile().mkdirs();
-            try {
-                IO.writeAll(out, gson.toJson(obj));
-            } catch (IOException e) {
-                e.printStackTrace();
-            }
-        });
-
-        dimensionObj.add("jigsawStructures", jigsawStructures);
-        IO.writeAll(dimensionFile, gson.toJson(dimensionObj));
-
-        data.hotloaded();
    }

    @Decree(description = "Test")
    public void packBenchmark(
-            @Param(description = "The pack to bench", aliases = {"pack"}, defaultValue = "overworld")
+            @Param(description = "The pack to bench", defaultValue = "overworld", aliases = {"pack"})
            IrisDimension dimension,
-            @Param(description = "Radius in regions", defaultValue = "2048")
-            int radius,
-            @Param(description = "Open GUI while benchmarking", defaultValue = "false")
-            boolean gui
+            @Param(description = "The address to use", defaultValue = "-")
+            String address,
+            @Param(description = "Headless", defaultValue = "true")
+            boolean headless,
+            @Param(description = "GUI", defaultValue = "false")
+            boolean gui,
+            @Param(description = "Diameter in regions", defaultValue = "5")
+            int diameter
    ) {
-        new IrisPackBenchmarking(dimension, radius, gui);
-    }
-
-    @Decree(description = "Upgrade to another Minecraft version")
-    public void upgrade(
-            @Param(description = "The version to upgrade to", defaultValue = "latest") DataVersion version) {
-        sender().sendMessage(C.GREEN + "Upgrading to " + version.getVersion() + "...");
-        ServerConfigurator.installDataPacks(version.get(), false);
-        sender().sendMessage(C.GREEN + "Done upgrading! You can now update your server version to " + version.getVersion());
+        int rb = diameter << 9;
+        Iris.info("Benchmarking pack " + dimension.getName() + " with diameter: " + rb + "(" + diameter + ")");
+        IrisPackBenchmarking benchmark = new IrisPackBenchmarking(dimension, address.replace("-", "").trim(), diameter, headless, gui);
+        benchmark.runBenchmark();
    }

    @Decree(description = "test")
-    public void mca (
-            @Param(description = "String") String world) {
+    public void mca(
+            @Param(description = "String") World world) {
        try {
-            File[] McaFiles = new File(world, "region").listFiles((dir, name) -> name.endsWith(".mca"));
-            for (File mca : McaFiles) {
-                MCAFile MCARegion = MCAUtil.read(mca);
-            }
+            IrisWorldDump dump = new IrisWorldDump(world, sender());
+            dump.start();
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    @Decree(description = "test")
+    public void test() {
+        try {
+
        } catch (Exception e) {
            e.printStackTrace();
        }
@@ -493,13 +201,40 @@ public class CommandDeveloper implements DecreeExecutor {
        }
    }

+    @Decree(description = "All players in iris worlds")
+    public void getPlayers() {
+        KList<World> IrisWorlds = new KList<>();
+        for (World w : Bukkit.getServer().getWorlds()) {
+            if(IrisToolbelt.isIrisWorld(w)) {
+                IrisWorlds.add(w);
+            }
+        }
+
+        if (sender().isPlayer()) {
+            sender().sendMessage(C.BLUE + "Iris Worlds: ");
+            for (World IrisWorld : IrisWorlds.copy()) {
+                sender().sendMessage(C.IRIS + "- " + IrisWorld.getName() + C.GRAY + ", " + IrisToolbelt.access(IrisWorld).getEngine().getEnginePlayers().stream().count() + " players");
+                for (EnginePlayer player : IrisToolbelt.access(IrisWorld).getEngine().getEnginePlayers()) {
+                    sender().sendMessage(C.DARK_GRAY + "> " + player.getPlayer().getName());
+                }
+            }
+        } else {
+            Iris.info(C.BLUE + "Iris Worlds: ");
+            for (World IrisWorld : IrisWorlds.copy()) {
+                Iris.info(C.IRIS + "- " + IrisWorld.getName() + C.GRAY + ", " + IrisToolbelt.access(IrisWorld).getEngine().getEnginePlayers().stream().count() + " players");
+                for (EnginePlayer player : IrisToolbelt.access(IrisWorld).getEngine().getEnginePlayers()) {
+                    Iris.info(C.DARK_GRAY + "> " + player.getPlayer().getName());
+                }
+            }
+        }
+    }
+
    @Decree(description = "Test the compression algorithms")
    public void compression(
            @Param(description = "base IrisWorld") World world,
            @Param(description = "raw TectonicPlate File") String path,
            @Param(description = "Algorithm to Test") String algorithm,
-            @Param(description = "Amount of Tests") int amount,
-            @Param(description = "Is versioned", defaultValue = "false") boolean versioned) {
+            @Param(description = "Amount of Tests") int amount) {
        if (!IrisToolbelt.isIrisWorld(world)) {
            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", Bukkit.getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
            return;
@@ -509,14 +244,13 @@ public class CommandDeveloper implements DecreeExecutor {
        if (!file.exists()) return;

        Engine engine = IrisToolbelt.access(world).getEngine();
-        if(engine != null) {
+        if (engine != null) {
            int height = engine.getTarget().getHeight();
-            ExecutorService service = Executors.newFixedThreadPool(1);
            VolmitSender sender = sender();
-            service.submit(() -> {
+            new Thread(() -> {
                try {
-                    CountingDataInputStream raw = CountingDataInputStream.wrap(new FileInputStream(file));
-                    TectonicPlate plate = new TectonicPlate(height, raw, versioned);
+                    DataInputStream raw = new DataInputStream(new FileInputStream(file));
+                    TectonicPlate plate = new TectonicPlate(height, raw);
                    raw.close();

                    double d1 = 0;
@@ -534,30 +268,29 @@ public class CommandDeveloper implements DecreeExecutor {
                        if (size == 0)
                            size = tmp.length();
                        start = System.currentTimeMillis();
-                        CountingDataInputStream din = createInput(tmp, algorithm);
-                        new TectonicPlate(height, din, true);
+                        DataInputStream din = createInput(tmp, algorithm);
+                        new TectonicPlate(height, din);
                        din.close();
                        d2 += System.currentTimeMillis() - start;
                        tmp.delete();
                    }
                    IO.delete(folder);
                    sender.sendMessage(algorithm + " is " + Form.fileSize(size) + " big after compression");
-                    sender.sendMessage(algorithm + " Took " + d2/amount + "ms to read");
-                    sender.sendMessage(algorithm + " Took " + d1/amount + "ms to write");
+                    sender.sendMessage(algorithm + " Took " + d2 / amount + "ms to read");
+                    sender.sendMessage(algorithm + " Took " + d1 / amount + "ms to write");
                } catch (Throwable e) {
                    e.printStackTrace();
                }
-            });
-            service.shutdown();
-		} else {
+            }, "Compression Test").start();
+        } else {
            Iris.info(C.RED + "Engine is null!");
        }
    }

-    private CountingDataInputStream createInput(File file, String algorithm) throws Throwable {
+    private DataInputStream createInput(File file, String algorithm) throws Throwable {
        FileInputStream in = new FileInputStream(file);

-        return CountingDataInputStream.wrap(switch (algorithm) {
+        return new DataInputStream(switch (algorithm) {
            case "gzip" -> new GZIPInputStream(in);
            case "lz4f" -> new LZ4FrameInputStream(in);
            case "lz4b" -> new LZ4BlockInputStream(in);
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -19,13 +19,17 @@
 package com.volmit.iris.core.commands;

 import com.volmit.iris.Iris;
+import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.service.StudioSVC;
 import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
 import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.decree.specialhandlers.NullableBiomeHandler;
+import com.volmit.iris.util.decree.specialhandlers.NullableRegionHandler;
 import com.volmit.iris.util.format.C;
+import org.bukkit.block.Biome;

 import java.awt.*;

@@ -46,27 +50,36 @@ public class CommandEdit implements DecreeExecutor {
            sender().sendMessage(C.RED + "You must be in a studio world!");
            return true;
        }
-
-        if (GraphicsEnvironment.isHeadless()) {
-            sender().sendMessage(C.RED + "Cannot open files in headless environments!");
-            return true;
-        }
-
-        if (!Desktop.isDesktopSupported()) {
-            sender().sendMessage(C.RED + "Desktop is not supported by this environment!");
-            return true;
-        }
        return false;
    }


    @Decree(description = "Edit the biome you specified", aliases = {"b"}, origin = DecreeOrigin.PLAYER)
-    public void biome(@Param(contextual = false, description = "The biome to edit") IrisBiome biome) {
+    public void biome(@Param(contextual = false, description = "The biome to edit", defaultValue = "---", customHandler = NullableBiomeHandler.class) IrisBiome biome) {
        if (noStudio()) {
            return;
        }
+        if (biome == null) {
+            try {
+                IrisBiome b = engine().getBiome(player().getLocation().getBlockX(), player().getLocation().getBlockY() - player().getWorld().getMinHeight(), player().getLocation().getBlockZ());
+                Desktop.getDesktop().open(b.getLoadFile());
+                sender().sendMessage(C.GREEN + "Opening " + b.getTypeName() + " " + b.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
+            } catch (Throwable e) {
+                Iris.reportError(e);
+                sender().sendMessage("Non-Iris Biome: " + player().getLocation().getBlock().getBiome().name());
+                if (player().getLocation().getBlock().getBiome().equals(Biome.CUSTOM)) {
+                    try {
+                        sender().sendMessage("Data Pack Biome: " + INMS.get().getTrueBiomeBaseKey(player().getLocation()) + " (ID: " + INMS.get().getTrueBiomeBaseId(INMS.get().getTrueBiomeBase(player().getLocation())) + ")");
+                    } catch (Throwable ee) {
+                        Iris.reportError(ee);
+                    }
+                }
+            }
+            return;
+        }
+
        try {
-            if (biome == null || biome.getLoadFile() == null) {
+            if (biome.getLoadFile() == null) {
                sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
                return;
            }
@@ -79,10 +92,20 @@ public class CommandEdit implements DecreeExecutor {
    }

    @Decree(description = "Edit the region you specified", aliases = {"r"}, origin = DecreeOrigin.PLAYER)
-    public void region(@Param(contextual = false, description = "The region to edit") IrisRegion region) {
+    public void region(@Param(contextual = false, description = "The region to edit", defaultValue = "---", customHandler = NullableRegionHandler.class) IrisRegion region) {
        if (noStudio()) {
            return;
        }
+        if (region == null) {
+            try {
+                IrisRegion r = engine().getRegion(player().getLocation().getBlockX(), player().getLocation().getBlockZ());
+                Desktop.getDesktop().open(r.getLoadFile());
+                sender().sendMessage(C.GREEN + "Opening " + r.getTypeName() + " " + r.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
+            } catch (Throwable e) {
+                sender().sendMessage(C.RED + "Failed to get region.");
+            }
+            return;
+        }
        try {
            if (region == null || region.getLoadFile() == null) {
                sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -48,7 +48,7 @@ public class CommandJigsaw implements DecreeExecutor {
            IrisJigsawPiece piece
    ) {
        File dest = piece.getLoadFile();
-        new JigsawEditor(player(), piece, IrisData.loadAnyObject(piece.getObject(), data()), dest);
+        new JigsawEditor(player(), piece, IrisData.loadAnyObject(piece.getObject()), dest);
    }

    @Decree(description = "Place a jigsaw structure")
@@ -60,7 +60,7 @@ public class CommandJigsaw implements DecreeExecutor {
        try {
            var world = world();
            WorldObjectPlacer placer = new WorldObjectPlacer(world);
-            PlannedStructure ps = new PlannedStructure(structure, new IrisPosition(player().getLocation().add(0, world.getMinHeight(), 0)), new RNG(), true);
+            PlannedStructure ps = new PlannedStructure(structure, new IrisPosition(player().getLocation().add(0, world.getMinHeight(), 0)), new RNG());
            VolmitSender sender = sender();
            sender.sendMessage(C.GREEN + "Generated " + ps.getPieces().size() + " pieces in " + Form.duration(p.getMilliseconds(), 2));
            ps.place(placer, failed -> sender.sendMessage(failed ? C.GREEN + "Placed the structure!" : C.RED + "Failed to place the structure!"));
@@ -78,7 +78,7 @@ public class CommandJigsaw implements DecreeExecutor {
            @Param(description = "The object to use for this piece", customHandler = ObjectHandler.class)
            String object
    ) {
-        IrisObject o = IrisData.loadAnyObject(object, data());
+        IrisObject o = IrisData.loadAnyObject(object);

        if (object == null) {
            sender().sendMessage(C.RED + "Failed to find existing object");
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -19,16 +19,11 @@
 package com.volmit.iris.core.commands;

 import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.gui.PregeneratorJob;
 import com.volmit.iris.core.pregenerator.LazyPregenerator;
-import com.volmit.iris.core.pregenerator.PregenTask;
-import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
 import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.math.Position2;
 import org.bukkit.Bukkit;
 import org.bukkit.World;
 import org.bukkit.util.Vector;
@@ -39,6 +34,7 @@ import java.io.IOException;
@Decree(name = "lazypregen", aliases = "lazy", description = "Pregenerate your Iris worlds!")
 public class CommandLazyPregen implements DecreeExecutor {
    public String worldName;
+
    @Decree(description = "Pregenerate a world")
    public void start(
            @Param(description = "The radius of the pregen in blocks", aliases = "size")
@@ -51,10 +47,10 @@ public class CommandLazyPregen implements DecreeExecutor {
            int cpm,
            @Param(aliases = "silent", description = "Silent generation", defaultValue = "false")
            boolean silent
-            ) {
+    ) {

        worldName = world.getName();
-        File worldDirectory = world.getWorldFolder();
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
        File lazyFile = new File(worldDirectory, "lazygen.json");
        if (lazyFile.exists()) {
            sender().sendMessage(C.BLUE + "Lazy pregen is already in progress");
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -28,8 +28,6 @@ import com.volmit.iris.core.tools.IrisConverter;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.data.Cuboid;
-import com.volmit.iris.util.data.IrisCustomData;
-import com.volmit.iris.util.data.registry.Materials;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
 import com.volmit.iris.util.decree.annotations.Decree;
@@ -38,8 +36,12 @@ import com.volmit.iris.util.decree.specialhandlers.ObjectHandler;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.math.Direction;
 import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.misc.E;
+import com.volmit.iris.util.scheduling.Queue;
 import org.bukkit.*;
 import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
+import org.bukkit.block.TileState;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.util.Vector;
@@ -52,7 +54,7 @@ import java.util.*;
@Decree(name = "object", aliases = "o", origin = DecreeOrigin.PLAYER, studio = true, description = "Iris object manipulation")
 public class CommandObject implements DecreeExecutor {

-    private static final Set<Material> skipBlocks = Set.of(Materials.GRASS, Material.SNOW, Material.VINE, Material.TORCH, Material.DEAD_BUSH,
+    private static final Set<Material> skipBlocks = Set.of(E.getOrDefault(Material.class, "GRASS", "SHORT_GRASS"), Material.SNOW, Material.VINE, Material.TORCH, Material.DEAD_BUSH,
            Material.POPPY, Material.DANDELION);

    public static IObjectPlacer createPlacer(World world, Map<Block, BlockData> futureBlockChanges) {
@@ -73,14 +75,12 @@ public class CommandObject implements DecreeExecutor {
                Block block = world.getBlockAt(x, y, z);

                //Prevent blocks being set in or bellow bedrock
-                if (y <= world.getMinHeight() || block.getType() == Material.BEDROCK) return;
+                if (y <= world.getMinHeight() || block.getType() == Material.BEDROCK)
+                    return;

                futureBlockChanges.put(block, block.getBlockData());

-                if (d instanceof IrisCustomData data) {
-                    block.setBlockData(data.getBase(), false);
-                    Iris.warn("Tried to place custom block at " + x + ", " + y + ", " + z + " which is not supported!");
-                } else block.setBlockData(d, false);
+                block.setBlockData(d);
            }

            @Override
@@ -123,16 +123,6 @@ public class CommandObject implements DecreeExecutor {
                tile.toBukkitTry(world.getBlockAt(xx, yy, zz));
            }

-            @Override
-            public <T> void setData(int xx, int yy, int zz, T data) {
-
-            }
-
-            @Override
-            public <T> T getData(int xx, int yy, int zz, Class<T> t) {
-                return null;
-            }
-
            @Override
            public Engine getEngine() {
                return null;
@@ -145,11 +135,11 @@ public class CommandObject implements DecreeExecutor {
            @Param(description = "The object to analyze", customHandler = ObjectHandler.class)
            String object
    ) {
-        IrisObject o = IrisData.loadAnyObject(object, data());
+        IrisObject o = IrisData.loadAnyObject(object);
        sender().sendMessage("Object Size: " + o.getW() + " * " + o.getH() + " * " + o.getD() + "");
        sender().sendMessage("Blocks Used: " + NumberFormat.getIntegerInstance().format(o.getBlocks().size()));

-        var queue = o.getBlocks().values();
+        Queue<BlockData> queue = o.getBlocks().enqueueValues();
        Map<Material, Set<BlockData>> unsorted = new HashMap<>();
        Map<BlockData, Integer> amounts = new HashMap<>();
        Map<Material, Integer> materials = new HashMap<>();
@@ -210,7 +200,7 @@ public class CommandObject implements DecreeExecutor {

    @Decree(description = "Shrink an object to its minimum size")
    public void shrink(@Param(description = "The object to shrink", customHandler = ObjectHandler.class) String object) {
-        IrisObject o = IrisData.loadAnyObject(object, data());
+        IrisObject o = IrisData.loadAnyObject(object);
        sender().sendMessage("Current Object Size: " + o.getW() + " * " + o.getH() + " * " + o.getD());
        o.shrinkwrap();
        sender().sendMessage("New Object Size: " + o.getW() + " * " + o.getH() + " * " + o.getD());
@@ -250,8 +240,7 @@ public class CommandObject implements DecreeExecutor {


        Location[] b = WandSVC.getCuboid(player());
-        if (b == null || b[0] == null || b[1] == null) {
-            sender().sendMessage("No area selected.");
+        if (b == null) {
            return;
        }
        Location a1 = b[0].clone();
@@ -334,7 +323,7 @@ public class CommandObject implements DecreeExecutor {
 //            @Param(description = "The scale interpolator to use", defaultValue = "none")
 //            IrisObjectPlacementScaleInterpolator interpolator
    ) {
-        IrisObject o = IrisData.loadAnyObject(object, data());
+        IrisObject o = IrisData.loadAnyObject(object);
        double maxScale = Double.max(10 - o.getBlocks().size() / 10000d, 1);
        if (scale > maxScale) {
            sender().sendMessage(C.YELLOW + "Indicated scale exceeds maximum. Downscaled to maximum: " + maxScale);
@@ -388,11 +377,9 @@ public class CommandObject implements DecreeExecutor {
            @Param(description = "The file to store it in, can use / for subfolders")
            String name,
            @Param(description = "Overwrite existing object files", defaultValue = "false", aliases = "force")
-            boolean overwrite,
-            @Param(description = "Use legacy TileState serialization if possible", defaultValue = "true")
-            boolean legacy
+            boolean overwrite
    ) {
-        IrisObject o = WandSVC.createSchematic(player(), legacy);
+        IrisObject o = WandSVC.createSchematic(player());

        if (o == null) {
            sender().sendMessage(C.YELLOW + "You need to hold your wand!");
@@ -427,10 +414,6 @@ public class CommandObject implements DecreeExecutor {
        }

        Location[] b = WandSVC.getCuboid(player());
-        if (b == null || b[0] == null || b[1] == null) {
-            sender().sendMessage("No area selected.");
-            return;
-        }
        Location a1 = b[0].clone();
        Location a2 = b[1].clone();
        Direction d = Direction.closest(player().getLocation().getDirection()).reverse();
@@ -455,7 +438,7 @@ public class CommandObject implements DecreeExecutor {
        ObjectSVC service = Iris.service(ObjectSVC.class);
        int actualReverts = Math.min(service.getUndos().size(), amount);
        service.revertChanges(actualReverts);
-        sender().sendMessage(C.BLUE + "Reverted " + actualReverts + C.BLUE +" pastes!");
+        sender().sendMessage(C.BLUE + "Reverted " + actualReverts + C.BLUE + " pastes!");
    }

    @Decree(description = "Gets an object wand and grabs the current WorldEdit selection.", aliases = "we", origin = DecreeOrigin.PLAYER, studio = true)
@@ -491,10 +474,6 @@ public class CommandObject implements DecreeExecutor {
        }

        Location[] b = WandSVC.getCuboid(player());
-        if (b == null || b[0] == null || b[1] == null) {
-            sender().sendMessage("No area selected.");
-            return;
-        }
        Location a1 = b[0].clone();
        Location a2 = b[1].clone();
        Location a1x = b[0].clone();
@@ -542,10 +521,6 @@ public class CommandObject implements DecreeExecutor {
        }

        Location[] b = WandSVC.getCuboid(player());
-        if (b == null || b[0] == null || b[1] == null) {
-            sender().sendMessage("No area selected.");
-            return;
-        }
        b[0].add(new Vector(0, 1, 0));
        b[1].add(new Vector(0, 1, 0));
        Location a1 = b[0].clone();
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -19,9 +19,16 @@
 package com.volmit.iris.core.commands;

 import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.gui.PregeneratorJob;
 import com.volmit.iris.core.pregenerator.PregenTask;
+import com.volmit.iris.core.pregenerator.methods.HeadlessPregenMethod;
+import com.volmit.iris.core.pregenerator.methods.HybridPregenMethod;
 import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.IrisEngine;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.framework.EngineTarget;
+import com.volmit.iris.engine.object.IrisWorld;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
@@ -30,6 +37,8 @@ import com.volmit.iris.util.math.Position2;
 import org.bukkit.World;
 import org.bukkit.util.Vector;

+import java.awt.*;
+
@Decree(name = "pregen", aliases = "pregenerate", description = "Pregenerate your Iris worlds!")
 public class CommandPregen implements DecreeExecutor {
    @Decree(description = "Pregenerate a world")
@@ -40,22 +49,38 @@ public class CommandPregen implements DecreeExecutor {
            World world,
            @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
            Vector center,
-            @Param(description = "Open the Iris pregen gui", defaultValue = "true")
-            boolean gui
-            ) {
+            @Param(aliases = "headless", description = "Toggle headless pregeneration", defaultValue = "true")
+            boolean headless,
+            @Param(aliases = "gui", description = "Enable or disable the Iris GUI.", defaultValue = "true")
+            boolean gui,
+            @Param(aliases = "resetCache", description = "If it should reset the generated region cache", defaultValue = "false")
+            boolean resetCache
+
+    ) {
        try {
            if (sender().isPlayer() && access() == null) {
                sender().sendMessage(C.RED + "The engine access for this world is null!");
                sender().sendMessage(C.RED + "Please make sure the world is loaded & the engine is initialized. Generate a new chunk, for example.");
            }
            radius = Math.max(radius, 1024);
+            int w = (radius >> 9 + 1) * 2;
+
+           Engine engine = IrisToolbelt.access(world).getEngine();
+           if(!engine.setEngineHeadless()) {
+               Iris.error("Failed to enable headless engine!");
+               return;
+           }
+
            IrisToolbelt.pregenerate(PregenTask
                    .builder()
-                    .center(new Position2(center.getBlockX(), center.getBlockZ()))
-                    .gui(gui)
-                    .radiusX(radius)
-                    .radiusZ(radius)
-                    .build(), world);
+                    .resetCache(resetCache)
+                    .center(new Position2(center.getBlockX() >> 9, center.getBlockZ() >> 9))
+                    .gui(!GraphicsEnvironment.isHeadless() && gui)
+                    .width(w)
+                    .height(w)
+                    .build(), headless ? new HeadlessPregenMethod(engine) : new HybridPregenMethod(engine.getWorld().realWorld(),
+                    IrisSettings.getThreadCount(IrisSettings.get().getConcurrency().getParallelism())), engine);
+           if (headless) sender().sendMessage("Using the headless Pregenerator.");
            String msg = C.GREEN + "Pregen started in " + C.GOLD + world.getName() + C.GREEN + " of " + C.GOLD + (radius * 2) + C.GREEN + " by " + C.GOLD + (radius * 2) + C.GREEN + " blocks from " + C.GOLD + center.getX() + "," + center.getZ();
            sender().sendMessage(msg);
            Iris.info(msg);
@@ -69,7 +94,7 @@ public class CommandPregen implements DecreeExecutor {
    @Decree(description = "Stop the active pregeneration task", aliases = "x")
    public void stop() {
        if (PregeneratorJob.shutdownInstance()) {
-            Iris.info( C.BLUE + "Finishing up mca region...");
+            Iris.info(C.BLUE + "Finishing up mca region...");
        } else {
            sender().sendMessage(C.YELLOW + "No active pregeneration tasks to stop");
        }
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -20,14 +20,12 @@ package com.volmit.iris.core.commands;

 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.gui.GuiHost;
-import com.volmit.iris.core.gui.MapWindow;
 import com.volmit.iris.core.gui.NoiseExplorerGUI;
-import com.volmit.iris.core.gui.PaletteExplorerStart;
-import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.core.gui.VisionGUI;
 import com.volmit.iris.core.project.IrisProject;
 import com.volmit.iris.core.service.ConversionSVC;
 import com.volmit.iris.core.service.StudioSVC;
+import com.volmit.iris.core.tools.IrisNoiseBenchmark;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.*;
@@ -42,27 +40,25 @@ import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.function.NoiseProvider;
-import com.volmit.iris.util.interpolation.InterpolationMethod;
-import com.volmit.iris.util.io.IO;
+import com.volmit.iris.util.function.Function2;
 import com.volmit.iris.util.json.JSONArray;
 import com.volmit.iris.util.json.JSONObject;
-import com.volmit.iris.util.mantle.MantleChunk;
 import com.volmit.iris.util.math.M;
 import com.volmit.iris.util.math.Position2;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.math.Spiraler;
-import com.volmit.iris.util.noise.CNG;
+import com.volmit.iris.util.parallel.BurstExecutor;
 import com.volmit.iris.util.parallel.MultiBurst;
-import com.volmit.iris.util.parallel.SyncExecutor;
 import com.volmit.iris.util.plugin.VolmitSender;
+import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.O;
-import com.volmit.iris.util.scheduling.PrecisionStopwatch;
-import com.volmit.iris.util.scheduling.jobs.ParallelRadiusJob;
+import com.volmit.iris.util.scheduling.jobs.QueueJob;
+import io.papermc.lib.PaperLib;
 import org.bukkit.*;
 import org.bukkit.event.inventory.InventoryType;
 import org.bukkit.inventory.Inventory;
+import org.bukkit.scheduler.BukkitRunnable;
 import org.bukkit.util.BlockVector;
 import org.bukkit.util.Vector;

@@ -77,33 +73,33 @@ import java.time.temporal.ChronoUnit;
 import java.util.Arrays;
 import java.util.Date;
 import java.util.Objects;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.Executors;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Supplier;

@Decree(name = "studio", aliases = {"std", "s"}, description = "Studio Commands", studio = true)
 public class CommandStudio implements DecreeExecutor {
    private CommandFind find;
    private CommandEdit edit;
-    //private CommandDeepSearch deepSearch;

    public static String hrf(Duration duration) {
        return duration.toString().substring(2).replaceAll("(\\d[HMS])(?!$)", "$1 ").toLowerCase();
    }

-    //TODO fix pack trimming
    @Decree(description = "Download a project.", aliases = "dl")
    public void download(
            @Param(name = "pack", description = "The pack to download", defaultValue = "overworld", aliases = "project")
            String pack,
            @Param(name = "branch", description = "The branch to download from", defaultValue = "master")
            String branch,
-            //@Param(name = "trim", description = "Whether or not to download a trimmed version (do not enable when editing)", defaultValue = "false")
-            //boolean trim,
+            @Param(name = "trim", description = "Whether or not to download a trimmed version (do not enable when editing)", defaultValue = "false")
+            boolean trim,
            @Param(name = "overwrite", description = "Whether or not to overwrite the pack with the downloaded one", aliases = "force", defaultValue = "false")
            boolean overwrite
    ) {
-        new CommandIris().download(pack, branch, overwrite);
+        new CommandIris().download(pack, branch, trim, overwrite);
    }

    @Decree(description = "Open a new studio world", aliases = "o", sync = true)
@@ -162,74 +158,71 @@ public class CommandStudio implements DecreeExecutor {
            @Param(name = "radius", description = "The radius of nearby cunks", defaultValue = "5")
            int radius
    ) {
-        World world = player().getWorld();
-        if (!IrisToolbelt.isIrisWorld(world)) {
+        if (IrisToolbelt.isIrisWorld(player().getWorld())) {
+            VolmitSender sender = sender();
+            J.a(() -> {
+                DecreeContext.touch(sender);
+                PlatformChunkGenerator plat = IrisToolbelt.access(player().getWorld());
+                Engine engine = plat.getEngine();
+                try {
+                    Chunk cx = player().getLocation().getChunk();
+                    KList<Runnable> js = new KList<>();
+                    BurstExecutor b = MultiBurst.burst.burst();
+                    b.setMulticore(false);
+                    int rad = engine.getMantle().getRealRadius();
+                    for (int i = -(radius + rad); i <= radius + rad; i++) {
+                        for (int j = -(radius + rad); j <= radius + rad; j++) {
+                            engine.getMantle().getMantle().deleteChunk(i + cx.getX(), j + cx.getZ());
+                        }
+                    }
+
+                    for (int i = -radius; i <= radius; i++) {
+                        for (int j = -radius; j <= radius; j++) {
+                            int finalJ = j;
+                            int finalI = i;
+                            b.queue(() -> plat.injectChunkReplacement(player().getWorld(), finalI + cx.getX(), finalJ + cx.getZ(), (f) -> {
+                                synchronized (js) {
+                                    js.add(f);
+                                }
+                            }));
+                        }
+                    }
+
+                    b.complete();
+                    sender().sendMessage(C.GREEN + "Regenerating " + Form.f(js.size()) + " Sections");
+                    QueueJob<Runnable> r = new QueueJob<>() {
+                        final KList<Future<?>> futures = new KList<>();
+
+                        @Override
+                        public void execute(Runnable runnable) {
+                            futures.add(J.sfut(runnable));
+
+                            if (futures.size() > 64) {
+                                while (futures.isNotEmpty()) {
+                                    try {
+                                        futures.remove(0).get();
+                                    } catch (InterruptedException |
+                                             ExecutionException e) {
+                                        e.printStackTrace();
+                                    }
+                                }
+                            }
+                        }
+
+                        @Override
+                        public String getName() {
+                            return "Regenerating";
+                        }
+                    };
+                    r.queue(js);
+                    r.execute(sender());
+                } catch (Throwable e) {
+                    sender().sendMessage("Unable to parse view-distance");
+                }
+            });
+        } else {
            sender().sendMessage(C.RED + "You must be in an Iris World to use regen!");
        }
-
-        VolmitSender sender = sender();
-        var loc = player().getLocation().clone();
-
-        J.a(() -> {
-            PlatformChunkGenerator plat = IrisToolbelt.access(world);
-            Engine engine = plat.getEngine();
-            DecreeContext.touch(sender);
-            try (SyncExecutor executor = new SyncExecutor(20);
-                 var service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors())
-            ) {
-                int x = loc.getBlockX() >> 4;
-                int z = loc.getBlockZ() >> 4;
-
-                int rad = engine.getMantle().getRadius();
-                var mantle = engine.getMantle().getMantle();
-                var chunkMap = new KMap<Position2, MantleChunk>();
-                ParallelRadiusJob prep = new ParallelRadiusJob(Integer.MAX_VALUE, service) {
-                    @Override
-                    protected void execute(int rX, int rZ) {
-                        if (Math.abs(rX) <= radius && Math.abs(rZ) <= radius) {
-                            mantle.deleteChunk(rX + x, rZ + z);
-                            return;
-                        }
-                        rX += x;
-                        rZ += z;
-                        chunkMap.put(new Position2(rX, rZ), mantle.getChunk(rX, rZ));
-                        mantle.deleteChunk(rX, rZ);
-                    }
-
-                    @Override
-                    public String getName() {
-                        return "Preparing Mantle";
-                    }
-                }.retarget(radius + rad, 0, 0);
-                CountDownLatch pLatch = new CountDownLatch(1);
-                prep.execute(sender(), pLatch::countDown);
-                pLatch.await();
-
-
-                ParallelRadiusJob job = new ParallelRadiusJob(Integer.MAX_VALUE, service) {
-                    @Override
-                    protected void execute(int x, int z) {
-                        plat.injectChunkReplacement(world, x, z, executor);
-                    }
-
-                    @Override
-                    public String getName() {
-                        return "Regenerating";
-                    }
-                }.retarget(radius, x, z);
-                CountDownLatch latch = new CountDownLatch(1);
-                job.execute(sender(), latch::countDown);
-                latch.await();
-
-                chunkMap.forEach((pos, chunk) ->
-                        mantle.getChunk(pos.getX(), pos.getZ()).copyFrom(chunk));
-            } catch (Throwable e) {
-                sender().sendMessage("Error while regenerating chunks");
-                e.printStackTrace();
-            } finally {
-                DecreeContext.remove();
-            }
-        });
    }

    @Decree(description = "Convert objects in the \"convert\" folder")
@@ -246,47 +239,11 @@ public class CommandStudio implements DecreeExecutor {
        engine().getExecution().execute(script.getLoadKey());
    }

-    @Decree(description = "Open the map on its noise explorer (External GUI)", aliases = {"nmap", "n"})
+    @Decree(description = "Open the noise explorer (External GUI)", aliases = {"nmap", "n"})
    public void noise() {
        if (noGUI()) return;
-        Engine playerEngine = engine();
-        Engine engine = playerEngine != null ? playerEngine : GuiHost.findActiveEngine();
-        World world = engine == null ? null : engine.getWorld().realWorld();
-        if (world == null) {
-            sender().sendMessage(C.RED + "Open a studio or stand in an Iris world to explore its noise!");
-            return;
-        }
-        Location center = playerEngine != null ? player().getLocation() : null;
-        sender().sendMessage(C.GREEN + "Opening the map on its noise!");
-        MapWindow.openNoise(new PaletteExplorerStart(
-                engine,
-                world.getUID(),
-                sender().isPlayer() ? player().getUniqueId() : null,
-                null,
-                center == null ? 0D : center.getX(),
-                center == null ? 0D : center.getZ()
-        ));
-    }
-
-    @Decree(description = "Preview the palettes around you (External GUI)", aliases = "pal", origin = DecreeOrigin.PLAYER)
-    public void palette() {
-        if (noGUI()) return;
-        Engine engine = engine();
-        if (engine == null) {
-            sender().sendMessage(C.RED + "Stand in an Iris world to preview its palettes!");
-            return;
-        }
-        Location location = player().getLocation();
-        IrisBiome surfaceBiome = engine.getSurfaceBiome(location.getBlockX(), location.getBlockZ());
-        sender().sendMessage(C.GREEN + "Opening the map on its palettes!");
-        MapWindow.openPalettes(new PaletteExplorerStart(
-                engine,
-                location.getWorld().getUID(),
-                player().getUniqueId(),
-                surfaceBiome == null ? null : surfaceBiome.getLoadKey(),
-                location.getX(),
-                location.getZ()
-        ));
+        sender().sendMessage(C.GREEN + "Opening Noise Explorer!");
+        NoiseExplorerGUI.launch();
    }

    @Decree(description = "Charges all spawners in the area", aliases = "zzt", origin = DecreeOrigin.PLAYER)
@@ -308,7 +265,16 @@ public class CommandStudio implements DecreeExecutor {
    ) {
        if (noGUI()) return;
        sender().sendMessage(C.GREEN + "Opening Noise Explorer!");
-        NoiseExplorerGUI.launchGeneratorKey(engine(), generator == null ? null : generator.getLoadKey(), generator, seed);
+
+        Supplier<Function2<Double, Double, Double>> l = () -> {
+
+            if (generator == null) {
+                return (x, z) -> 0D;
+            }
+
+            return (x, z) -> generator.getHeight(x, z, new RNG(seed).nextParallelRNG(3245).lmax());
+        };
+        NoiseExplorerGUI.launch(l, "Custom Generator");
    }

    @Decree(description = "Hotload a studio", aliases = {"reload", "h"})
@@ -317,8 +283,8 @@ public class CommandStudio implements DecreeExecutor {
            sender().sendMessage(C.RED + "No studio world open!");
            return;
        }
-        Iris.service(StudioSVC.class).getActiveProject().getActiveProvider().getEngine().hotload();
-        sender().sendMessage(C.GREEN + "Hotloaded");
+        var provider = Iris.service(StudioSVC.class).getActiveProject().getActiveProvider();
+        provider.getEngine().hotload();
    }

    @Decree(description = "Show loot if a chest were right here", origin = DecreeOrigin.PLAYER, sync = true)
@@ -334,7 +300,7 @@ public class CommandStudio implements DecreeExecutor {
        Inventory inv = Bukkit.createInventory(null, 27 * 2);

        try {
-            engine().addItems(true, inv, RNG.r, tables, InventorySlotType.STORAGE, player().getWorld(), player().getLocation().getBlockX(), player().getLocation().getBlockY(), player().getLocation().getBlockZ(), 1);
+            engine().addItems(true, inv, RNG.r, tables, InventorySlotType.STORAGE, player().getLocation().getBlockX(), player().getLocation().getBlockY(), player().getLocation().getBlockZ(), 1);
        } catch (Throwable e) {
            Iris.reportError(e);
            sender().sendMessage(C.RED + "Cannot add items to virtual inventory because of: " + e.getMessage());
@@ -345,15 +311,11 @@ public class CommandStudio implements DecreeExecutor {
        O<Integer> ta = new O<>();
        ta.set(-1);

-        var sender = sender();
-        var player = player();
-        var engine = engine();
-
        ta.set(Bukkit.getScheduler().scheduleSyncRepeatingTask(Iris.instance, () ->
        {
-            if (!player.getOpenInventory().getType().equals(InventoryType.CHEST)) {
+            if (!player().getOpenInventory().getType().equals(InventoryType.CHEST)) {
                Bukkit.getScheduler().cancelTask(ta.get());
-                sender.sendMessage(C.GREEN + "Opened inventory!");
+                sender().sendMessage(C.GREEN + "Opened inventory!");
                return;
            }

@@ -361,49 +323,13 @@ public class CommandStudio implements DecreeExecutor {
                inv.clear();
            }

-            engine.addItems(true, inv, new RNG(RNG.r.imax()), tables, InventorySlotType.STORAGE, player.getWorld(), player.getLocation().getBlockX(), player.getLocation().getBlockY(), player.getLocation().getBlockZ(), 1);
+            engine().addItems(true, inv, new RNG(RNG.r.imax()), tables, InventorySlotType.STORAGE, player().getLocation().getBlockX(), player().getLocation().getBlockY(), player().getLocation().getBlockZ(), 1);
        }, 0, fast ? 5 : 35));

        sender().sendMessage(C.GREEN + "Opening inventory now!");
        player().openInventory(inv);
    }

-    @Decree(description = "Calculate the chance for each region to generate", origin = DecreeOrigin.PLAYER)
-    public void regions(@Param(description = "The radius in chunks", defaultValue = "500") int radius) {
-        var engine = engine();
-        if (engine == null) {
-            sender().sendMessage(C.RED + "Only works in an Iris world!");
-            return;
-        }
-        var sender = sender();
-        var player = player();
-        Thread.ofVirtual()
-                .start(() -> {
-                    int d = radius * 2;
-                    KMap<String, AtomicInteger> data = new KMap<>();
-                    engine.getDimension().getRegions().forEach(key -> data.put(key, new AtomicInteger(0)));
-                    var multiBurst = new MultiBurst("Region Sampler");
-                    var executor = multiBurst.burst(radius * radius);
-                    sender.sendMessage(C.GRAY + "Generating data...");
-                    var loc = player.getLocation();
-                    int totalTasks = d * d;
-                    AtomicInteger completedTasks = new AtomicInteger(0);
-                    int c = J.ar(() -> sender.sendProgress((double) completedTasks.get() / totalTasks, "Finding regions"), 0);
-                    new Spiraler(d, d, (x, z) -> executor.queue(() -> {
-                        var region = engine.getRegion((x << 4) + 8, (z << 4) + 8);
-                        data.computeIfAbsent(region.getLoadKey(), (k) -> new AtomicInteger(0))
-                                .incrementAndGet();
-                        completedTasks.incrementAndGet();
-                    })).setOffset(loc.getBlockX(), loc.getBlockZ()).drain();
-                    executor.complete();
-                    multiBurst.close();
-                    J.car(c);
-
-                    sender.sendMessage(C.GREEN + "Done!");
-                    var loader = engine.getData().getRegionLoader();
-                    data.forEach((k, v) -> sender.sendMessage(C.GREEN + k + ": " + loader.load(k).getRarity() + " / " + Form.f((double) v.get() / totalTasks * 100, 2) + "%"));
-                });
-    }

    @Decree(description = "Get all structures in a radius of chunks", aliases = "dist", origin = DecreeOrigin.PLAYER)
    public void distances(@Param(description = "The radius in chunks") int radius) {
@@ -415,7 +341,7 @@ public class CommandStudio implements DecreeExecutor {
        var sender = sender();
        int d = radius * 2;
        KMap<String, KList<Position2>> data = new KMap<>();
-        var multiBurst = new MultiBurst("Distance Sampler");
+        var multiBurst = new MultiBurst("Distance Sampler", Thread.MIN_PRIORITY);
        var executor = multiBurst.burst(radius * radius);

        sender.sendMessage(C.GRAY + "Generating data...");
@@ -472,26 +398,10 @@ public class CommandStudio implements DecreeExecutor {


    @Decree(description = "Render a world map (External GUI)", aliases = "render")
-    public void map(
-            @Param(name = "world", description = "The world to open the generator for", contextual = true)
-            World world
-    ) {
+    public void map() {
        if (noGUI()) return;
-
-        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage(C.RED + "You need to be in or specify an Iris-generated world!");
-            return;
-        }
-
-        Location center = sender().isPlayer() && player().getWorld().equals(world) ? player().getLocation() : null;
-        MapWindow.openMap(new PaletteExplorerStart(
-                IrisToolbelt.access(world).getEngine(),
-                world.getUID(),
-                sender().isPlayer() ? player().getUniqueId() : null,
-                null,
-                center == null ? 0D : center.getX(),
-                center == null ? 0D : center.getZ()
-        ));
+        if (noStudio()) return;
+        VisionGUI.launch(IrisToolbelt.access(player().getWorld()).getEngine(), 0);
        sender().sendMessage(C.GREEN + "Opening map!");
    }

@@ -512,188 +422,8 @@ public class CommandStudio implements DecreeExecutor {
            @Param(description = "The dimension to profile", contextual = true, defaultValue = "default")
            IrisDimension dimension
    ) {
-        // Todo: Make this more accurate
-        File pack = dimension.getLoadFile().getParentFile().getParentFile();
-        File report = Iris.instance.getDataFile("profile.txt");
-        IrisProject project = new IrisProject(pack);
-        IrisData data = IrisData.get(pack);
-
-        KList<String> fileText = new KList<>();
-
-        KMap<NoiseStyle, Double> styleTimings = new KMap<>();
-        KMap<InterpolationMethod, Double> interpolatorTimings = new KMap<>();
-        KMap<String, Double> generatorTimings = new KMap<>();
-        KMap<String, Double> biomeTimings = new KMap<>();
-        KMap<String, Double> regionTimings = new KMap<>();
-
-        sender().sendMessage("Calculating Performance Metrics for Noise generators");
-
-        for (NoiseStyle i : NoiseStyle.values()) {
-            CNG c = i.create(new RNG(i.hashCode()));
-
-            for (int j = 0; j < 3000; j++) {
-                c.noise(j, j + 1000, j * j);
-                c.noise(j, -j);
-            }
-
-            PrecisionStopwatch px = PrecisionStopwatch.start();
-
-            for (int j = 0; j < 100000; j++) {
-                c.noise(j, j + 1000, j * j);
-                c.noise(j, -j);
-            }
-
-            styleTimings.put(i, px.getMilliseconds());
-        }
-
-        fileText.add("Noise Style Performance Impacts: ");
-
-        for (NoiseStyle i : styleTimings.sortKNumber()) {
-            fileText.add(i.name() + ": " + styleTimings.get(i));
-        }
-
-        fileText.add("");
-
-        sender().sendMessage("Calculating Interpolator Timings...");
-
-        for (InterpolationMethod i : InterpolationMethod.values()) {
-            IrisInterpolator in = new IrisInterpolator();
-            in.setFunction(i);
-            in.setHorizontalScale(8);
-
-            NoiseProvider np = (x, z) -> Math.random();
-
-            for (int j = 0; j < 3000; j++) {
-                in.interpolate(j, -j, np);
-            }
-
-            PrecisionStopwatch px = PrecisionStopwatch.start();
-
-            for (int j = 0; j < 100000; j++) {
-                in.interpolate(j + 10000, -j - 100000, np);
-            }
-
-            interpolatorTimings.put(i, px.getMilliseconds());
-        }
-
-        fileText.add("Noise Interpolator Performance Impacts: ");
-
-        for (InterpolationMethod i : interpolatorTimings.sortKNumber()) {
-            fileText.add(i.name() + ": " + interpolatorTimings.get(i));
-        }
-
-        fileText.add("");
-
-        sender().sendMessage("Processing Generator Scores: ");
-
-        KMap<String, KList<String>> btx = new KMap<>();
-
-        for (String i : data.getGeneratorLoader().getPossibleKeys()) {
-            KList<String> vv = new KList<>();
-            IrisGenerator g = data.getGeneratorLoader().load(i);
-            KList<IrisNoiseGenerator> composites = g.getAllComposites();
-            double score = 0;
-            int m = 0;
-            for (IrisNoiseGenerator j : composites) {
-                m++;
-                score += styleTimings.get(j.getStyle().getStyle());
-                vv.add("Composite Noise Style " + m + " " + j.getStyle().getStyle().name() + ": " + styleTimings.get(j.getStyle().getStyle()));
-            }
-
-            score += interpolatorTimings.get(g.getInterpolator().getFunction());
-            vv.add("Interpolator " + g.getInterpolator().getFunction().name() + ": " + interpolatorTimings.get(g.getInterpolator().getFunction()));
-            generatorTimings.put(i, score);
-            btx.put(i, vv);
-        }
-
-        fileText.add("Project Generator Performance Impacts: ");
-
-        for (String i : generatorTimings.sortKNumber()) {
-            fileText.add(i + ": " + generatorTimings.get(i));
-
-            btx.get(i).forEach((ii) -> fileText.add("  " + ii));
-        }
-
-        fileText.add("");
-
-        KMap<String, KList<String>> bt = new KMap<>();
-
-        for (String i : data.getBiomeLoader().getPossibleKeys()) {
-            KList<String> vv = new KList<>();
-            IrisBiome b = data.getBiomeLoader().load(i);
-            double score = 0;
-
-            int m = 0;
-            for (IrisBiomePaletteLayer j : b.getLayers()) {
-                m++;
-                score += styleTimings.get(j.getStyle().getStyle());
-                vv.add("Palette Layer " + m + ": " + styleTimings.get(j.getStyle().getStyle()));
-            }
-
-            score += styleTimings.get(b.getBiomeStyle().getStyle());
-            vv.add("Biome Style: " + styleTimings.get(b.getBiomeStyle().getStyle()));
-            score += styleTimings.get(b.getChildStyle().getStyle());
-            vv.add("Child Style: " + styleTimings.get(b.getChildStyle().getStyle()));
-            biomeTimings.put(i, score);
-            bt.put(i, vv);
-        }
-
-        fileText.add("Project Biome Performance Impacts: ");
-
-        for (String i : biomeTimings.sortKNumber()) {
-            fileText.add(i + ": " + biomeTimings.get(i));
-
-            bt.get(i).forEach((ff) -> fileText.add("  " + ff));
-        }
-
-        fileText.add("");
-
-        for (String i : data.getRegionLoader().getPossibleKeys()) {
-            IrisRegion b = data.getRegionLoader().load(i);
-            double score = 0;
-
-            score += styleTimings.get(b.getLakeStyle().getStyle());
-            score += styleTimings.get(b.getRiverStyle().getStyle());
-            regionTimings.put(i, score);
-        }
-
-        fileText.add("Project Region Performance Impacts: ");
-
-        for (String i : regionTimings.sortKNumber()) {
-            fileText.add(i + ": " + regionTimings.get(i));
-        }
-
-        fileText.add("");
-
-        double m = 0;
-        for (double i : biomeTimings.v()) {
-            m += i;
-        }
-        m /= biomeTimings.size();
-        double mm = 0;
-        for (double i : generatorTimings.v()) {
-            mm += i;
-        }
-        mm /= generatorTimings.size();
-        m += mm;
-        double mmm = 0;
-        for (double i : regionTimings.v()) {
-            mmm += i;
-        }
-        mmm /= regionTimings.size();
-        m += mmm;
-
-        fileText.add("Average Score: " + m);
-        sender().sendMessage("Score: " + Form.duration(m, 0));
-
-        try {
-            IO.writeAll(report, fileText.toString("\n"));
-        } catch (IOException e) {
-            Iris.reportError(e);
-            e.printStackTrace();
-        }
-
-        sender().sendMessage(C.GREEN + "Done! " + report.getPath());
+        IrisNoiseBenchmark noiseBenchmark = new IrisNoiseBenchmark(dimension, sender());
+        noiseBenchmark.runAll();
    }

    @Decree(description = "Spawn an Iris entity", aliases = "summon", origin = DecreeOrigin.PLAYER)
@@ -722,14 +452,8 @@ public class CommandStudio implements DecreeExecutor {
        }

        sender().sendMessage(C.GREEN + "Sending you to the studio world!");
-        var player = player();
-        player.teleportAsync(Iris.service(StudioSVC.class)
-                .getActiveProject()
-                .getActiveProvider()
-                .getTarget()
-                .getWorld()
-                .spawnLocation()
-        ).thenRun(() -> player.setGameMode(GameMode.SPECTATOR));
+        player().teleport(Iris.service(StudioSVC.class).getActiveProject().getActiveProvider().getTarget().getWorld().spawnLocation());
+        player().setGameMode(GameMode.SPECTATOR);
    }

    @Decree(description = "Update your dimension projects VSCode workspace")
@@ -782,6 +506,7 @@ public class CommandStudio implements DecreeExecutor {
            pw.println("Iris Version: " + Iris.instance.getDescription().getVersion());
            pw.println("Bukkit Version: " + Bukkit.getBukkitVersion());
            pw.println("MC Version: " + Bukkit.getVersion());
+            pw.println("PaperSpigot: " + (PaperLib.isPaper() ? "Yup!" : "Nope!"));
            pw.println("Report Captured At: " + new Date());
            pw.println("Chunks: (" + chunks.size() + "): ");

@@ -912,10 +637,6 @@ public class CommandStudio implements DecreeExecutor {
            sender().sendMessage(C.RED + "You must have server launched GUIs enabled in the settings!");
            return true;
        }
-        if (!GuiHost.isAvailable()) {
-            sender().sendMessage(C.RED + "This server runs without a desktop, so it cannot open windows!");
-            return true;
-        }
        return false;
    }

@@ -0,0 +1,48 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.commands;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.DecreeOrigin;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.misc.Hastebin;
+
+@Decree(name = "Support", origin = DecreeOrigin.BOTH, description = "Iris World Manager", aliases = {"support"})
+public class CommandSupport implements DecreeExecutor {
+
+    @Decree(description = "report")
+    public void report() {
+        try {
+            if (sender().isPlayer())
+                sender().sendMessage(C.GOLD + "Creating report..");
+            if (!sender().isPlayer()) Iris.info(C.GOLD + "Creating report..");
+            Hastebin.enviornment(sender());
+
+        } catch (Exception e) {
+            Iris.info(C.RED + "Something went wrong: ");
+            e.printStackTrace();
+        }
+    }
+
+
+}
+
+
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -19,8 +19,6 @@
 package com.volmit.iris.core.commands;

 import com.volmit.iris.Iris;
-import com.volmit.iris.core.pregenerator.LazyPregenerator;
-import com.volmit.iris.core.pregenerator.TurboPregenerator;
 import com.volmit.iris.core.pregenerator.TurboPregenerator;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.annotations.Decree;
@@ -36,6 +34,7 @@ import java.io.IOException;
@Decree(name = "turbopregen", aliases = "turbo", description = "Pregenerate your Iris worlds!")
 public class CommandTurboPregen implements DecreeExecutor {
    public String worldName;
+
    @Decree(description = "Pregenerate a world")
    public void start(
            @Param(description = "The radius of the pregen in blocks", aliases = "size")
@@ -44,10 +43,10 @@ public class CommandTurboPregen implements DecreeExecutor {
            World world,
            @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
            Vector center
-            ) {
+    ) {

        worldName = world.getName();
-        File worldDirectory = world.getWorldFolder();
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
        File TurboFile = new File(worldDirectory, "turbogen.json");
        if (TurboFile.exists()) {
            if (TurboPregenerator.getInstance() != null) {
@@ -57,9 +56,9 @@ public class CommandTurboPregen implements DecreeExecutor {
            } else {
                try {
                    TurboFile.delete();
-                } catch (Exception e){
-                   Iris.error("Failed to delete the old instance file of Turbo Pregen!");
-                   return;
+                } catch (Exception e) {
+                    Iris.error("Failed to delete the old instance file of Turbo Pregen!");
+                    return;
                }
            }
        }
@@ -93,7 +92,7 @@ public class CommandTurboPregen implements DecreeExecutor {
    @Decree(description = "Stop the active pregeneration task", aliases = "x")
    public void stop(@Param(aliases = "world", description = "The world to pause") World world) throws IOException {
        TurboPregenerator turboPregenInstance = TurboPregenerator.getInstance();
-        File worldDirectory = world.getWorldFolder();
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
        File turboFile = new File(worldDirectory, "turbogen.json");

        if (turboPregenInstance != null) {
@@ -117,9 +116,9 @@ public class CommandTurboPregen implements DecreeExecutor {
            TurboPregenerator.setPausedTurbo(world);
            sender().sendMessage(C.GREEN + "Paused/unpaused Turbo Pregen, now: " + (TurboPregenerator.isPausedTurbo(world) ? "Paused" : "Running") + ".");
        } else {
-            File worldDirectory = world.getWorldFolder();
+            File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
            File TurboFile = new File(worldDirectory, "turbogen.json");
-            if (TurboFile.exists()){
+            if (TurboFile.exists()) {
                TurboPregenerator.loadTurboGenerator(world.getName());
                sender().sendMessage(C.YELLOW + "Started Turbo Pregen back up!");
            } else {
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -18,9 +18,6 @@

 package com.volmit.iris.core.commands;

-import lombok.Synchronized;
-import org.bukkit.World;
-
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.pregenerator.ChunkUpdater;
 import com.volmit.iris.core.tools.IrisToolbelt;
@@ -30,11 +27,11 @@ import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
+import org.bukkit.World;

@Decree(name = "updater", origin = DecreeOrigin.BOTH, description = "Iris World Updater")
 public class CommandUpdater implements DecreeExecutor {
-    private final Object lock = new Object();
-    private transient ChunkUpdater chunkUpdater;
+    private ChunkUpdater chunkUpdater;

    @Decree(description = "Updates all chunk in the specified world")
    public void start(
@@ -45,24 +42,24 @@ public class CommandUpdater implements DecreeExecutor {
            sender().sendMessage(C.GOLD + "This is not an Iris world");
            return;
        }
-        synchronized (lock) {
-            if (chunkUpdater != null) {
-                chunkUpdater.stop();
-            }
-
-            chunkUpdater = new ChunkUpdater(world);
-            if (sender().isPlayer()) {
-                sender().sendMessage(C.GREEN + "Updating " + world.getName()  + C.GRAY + " Total chunks: " + Form.f(chunkUpdater.getChunks()));
-            } else {
-                Iris.info(C.GREEN + "Updating " + world.getName() + C.GRAY + " Total chunks: " + Form.f(chunkUpdater.getChunks()));
-            }
-            chunkUpdater.start();
+        chunkUpdater = new ChunkUpdater(world);
+        if (sender().isPlayer()) {
+            sender().sendMessage(C.GREEN + "Updating " + world.getName() + C.GRAY + " Total chunks: " + Form.f(chunkUpdater.getChunks()));
+        } else {
+            Iris.info(C.GREEN + "Updating " + world.getName() + C.GRAY + " Total chunks: " + Form.f(chunkUpdater.getChunks()));
        }
+        chunkUpdater.start();
    }

-    @Synchronized("lock")
    @Decree(description = "Pause the updater")
-    public void pause( ) {
+    public void pause(
+            @Param(description = "World to pause the Updater at")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.GOLD + "This is not an Iris world");
+            return;
+        }
        if (chunkUpdater == null) {
            sender().sendMessage(C.GOLD + "You cant pause something that doesnt exist?");
            return;
@@ -70,33 +67,40 @@ public class CommandUpdater implements DecreeExecutor {
        boolean status = chunkUpdater.pause();
        if (sender().isPlayer()) {
            if (status) {
-                sender().sendMessage(C.IRIS + "Paused task for: " + C.GRAY + chunkUpdater.getName());
+                sender().sendMessage(C.IRIS + "Paused task for: " + C.GRAY + world.getName());
            } else {
-                sender().sendMessage(C.IRIS + "Unpause task for: " + C.GRAY + chunkUpdater.getName());
+                sender().sendMessage(C.IRIS + "Unpause task for: " + C.GRAY + world.getName());
            }
        } else {
            if (status) {
-                Iris.info(C.IRIS + "Paused task for: " + C.GRAY + chunkUpdater.getName());
+                Iris.info(C.IRIS + "Paused task for: " + C.GRAY + world.getName());
            } else {
-                Iris.info(C.IRIS + "Unpause task for: " + C.GRAY + chunkUpdater.getName());
+                Iris.info(C.IRIS + "Unpause task for: " + C.GRAY + world.getName());
            }
        }
    }

-    @Synchronized("lock")
    @Decree(description = "Stops the updater")
-    public void stop() {
+    public void stop(
+            @Param(description = "World to stop the Updater at")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.GOLD + "This is not an Iris world");
+            return;
+        }
        if (chunkUpdater == null) {
            sender().sendMessage(C.GOLD + "You cant stop something that doesnt exist?");
            return;
        }
        if (sender().isPlayer()) {
-            sender().sendMessage("Stopping Updater for: " + C.GRAY + chunkUpdater.getName());
+            sender().sendMessage("Stopping Updater for: " + C.GRAY + world.getName());
        } else {
-            Iris.info("Stopping Updater for: " + C.GRAY + chunkUpdater.getName());
+            Iris.info("Stopping Updater for: " + C.GRAY + world.getName());
        }
        chunkUpdater.stop();
    }
+
 }


@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -22,7 +22,6 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.edit.BlockSignal;
 import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisBiome;
 import com.volmit.iris.engine.object.IrisRegion;
 import com.volmit.iris.util.data.B;
@@ -39,7 +38,6 @@ import org.bukkit.Material;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;

-import java.util.Objects;
 import java.util.concurrent.atomic.AtomicInteger;

@Decree(name = "what", origin = DecreeOrigin.PLAYER, studio = true, description = "Iris What?")
@@ -88,8 +86,7 @@ public class CommandWhat implements DecreeExecutor {
    @Decree(description = "What region am i in?", origin = DecreeOrigin.PLAYER)
    public void region() {
        try {
-            Chunk chunk = world().getChunkAt(player().getLocation().getBlockZ() / 16, player().getLocation().getBlockZ() /  16);
-            IrisRegion r = engine().getRegion(chunk);
+            IrisRegion r = engine().getRegion(player().getLocation());
            sender().sendMessage("IRegion: " + r.getLoadKey() + " (" + r.getName() + ")");

        } catch (Throwable e) {
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -61,14 +61,14 @@ public class JigsawEditor implements Listener {
    private Location target;

    public JigsawEditor(Player player, IrisJigsawPiece piece, IrisObject object, File saveLocation) {
-        if (object == null) throw new RuntimeException("Object is null! " + piece.getObject());
-        editors.compute(player, ($, current) -> {
-            if (current != null) {
-                current.exit();
-            }
-            return this;
-        });
+        if (editors.containsKey(player)) {
+            editors.get(player).close();
+        }

+        editors.put(player, this);
+        if (object == null) {
+            throw new RuntimeException("Object is null! " + piece.getObject());
+        }
        this.object = object;
        this.player = player;
        origin = player.getLocation().clone().add(0, 7, 0);
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -1,113 +0,0 @@
-package com.volmit.iris.core.events;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.InventorySlotType;
-import com.volmit.iris.engine.object.IrisLootTable;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.scheduling.J;
-import lombok.Getter;
-import org.bukkit.*;
-import org.bukkit.block.Block;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.world.LootGenerateEvent;
-
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.InventoryHolder;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.loot.LootContext;
-import org.bukkit.loot.LootTable;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Random;
-
-@Getter
-public class IrisLootEvent extends Event {
-    private static final HandlerList handlers = new HandlerList();
-    private static final LootTable EMPTY = new LootTable() {
-        @NotNull
-        @Override
-        public NamespacedKey getKey() {
-            return new NamespacedKey(Iris.instance, "empty");
-        }
-
-        @NotNull
-        @Override
-        public Collection<ItemStack> populateLoot(@Nullable Random random, @NotNull LootContext context) {
-            return List.of();
-        }
-
-        @Override
-        public void fillInventory(@NotNull Inventory inventory, @Nullable Random random, @NotNull LootContext context) {
-        }
-    };
-
-    private final Engine engine;
-    private final Block block;
-    private final InventorySlotType slot;
-    private final KList<IrisLootTable> tables;
-
-    /**
-     * Constructor for IrisLootEvent with mode selection.
-     *
-     * @param engine The engine instance.
-     * @param block The block associated with the event.
-     * @param slot The inventory slot type.
-     * @param tables The list of IrisLootTables. (mutable*)
-     */
-    public IrisLootEvent(Engine engine, Block block, InventorySlotType slot, KList<IrisLootTable> tables) {
-        this.engine = engine;
-        this.block = block;
-        this.slot = slot;
-        this.tables = tables;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-
-    /**
-     * Required method to get the HandlerList for this event.
-     *
-     * @return The HandlerList.
-     */
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    /**
-     * Triggers the corresponding Bukkit loot event.
-     * This method integrates your custom IrisLootTables with Bukkit's LootGenerateEvent,
-     * allowing other plugins to modify or cancel the loot generation.
-     *
-     * @return true when the event was canceled
-     */
-    public static boolean callLootEvent(KList<ItemStack> loot, Inventory inv, World world, int x, int y, int z) {
-        InventoryHolder holder = inv.getHolder();
-        Location loc = new Location(world, x, y, z);
-        if (holder == null) {
-            holder = new InventoryHolder() {
-                @NotNull
-                @Override
-                public Inventory getInventory() {
-                    return inv;
-                }
-            };
-        }
-
-        LootContext context = new LootContext.Builder(loc).build();
-        LootGenerateEvent event = new LootGenerateEvent(world, null, holder, EMPTY, context, loot, true);
-        if (!Bukkit.isPrimaryThread()) {
-            Iris.warn("LootGenerateEvent was not called on the main thread, please report this issue.");
-            Thread.dumpStack();
-            J.sfut(() -> Bukkit.getPluginManager().callEvent(event)).join();
-        } else Bukkit.getPluginManager().callEvent(event);
-
-        return event.isCancelled();
-    }
-}
@@ -1,96 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-
-package com.volmit.iris.core.gui;
-
-import java.util.Random;
-
-// A copy of Minecraft's Biome.BIOME_INFO_NOISE, the 2D simplex noise swamps use to pick between their two grass colours.
-// Minecraft seeds it through a LegacyRandomSource, which draws the same numbers as java.util.Random.
-final class BiomeInfoNoise {
-    private static final long SEED = 2345L;
-    private static final int PERMUTATION_SIZE = 256;
-    private static final int GRADIENT_COUNT = 12;
-    private static final double SKEW = 0.5D * (Math.sqrt(3D) - 1D);
-    private static final double UNSKEW = (3D - Math.sqrt(3D)) / 6D;
-    private static final double CORNER_RADIUS = 0.5D;
-    private static final double OUTPUT_SCALE = 70D;
-    private static final int[][] GRADIENTS = {
-            {1, 1}, {-1, 1}, {1, -1}, {-1, -1},
-            {1, 0}, {-1, 0}, {1, 0}, {-1, 0},
-            {0, 1}, {0, -1}, {0, 1}, {0, -1}
-    };
-    private static final int[] PERMUTATION = createPermutation();
-
-    private BiomeInfoNoise() {
-    }
-
-    static float at(double x, double z) {
-        double skewOffset = (x + z) * SKEW;
-        int cellX = (int) Math.floor(x + skewOffset);
-        int cellZ = (int) Math.floor(z + skewOffset);
-        double unskewOffset = (cellX + cellZ) * UNSKEW;
-        double x0 = x - (cellX - unskewOffset);
-        double z0 = z - (cellZ - unskewOffset);
-        int stepX = x0 > z0 ? 1 : 0;
-        int stepZ = 1 - stepX;
-        double x1 = x0 - stepX + UNSKEW;
-        double z1 = z0 - stepZ + UNSKEW;
-        double x2 = x0 - 1D + 2D * UNSKEW;
-        double z2 = z0 - 1D + 2D * UNSKEW;
-        int wrappedX = cellX & 0xFF;
-        int wrappedZ = cellZ & 0xFF;
-        int gradient0 = permute(wrappedX + permute(wrappedZ)) % GRADIENT_COUNT;
-        int gradient1 = permute(wrappedX + stepX + permute(wrappedZ + stepZ)) % GRADIENT_COUNT;
-        int gradient2 = permute(wrappedX + 1 + permute(wrappedZ + 1)) % GRADIENT_COUNT;
-        return (float) (OUTPUT_SCALE * (corner(gradient0, x0, z0) + corner(gradient1, x1, z1) + corner(gradient2, x2, z2)));
-    }
-
-    private static double corner(int gradient, double x, double z) {
-        double falloff = CORNER_RADIUS - x * x - z * z;
-        if (falloff < 0D) {
-            return 0D;
-        }
-        falloff *= falloff;
-        return falloff * falloff * (GRADIENTS[gradient][0] * x + GRADIENTS[gradient][1] * z);
-    }
-
-    private static int permute(int index) {
-        return PERMUTATION[index & 0xFF];
-    }
-
-    // Minecraft draws three offsets first and discards them for this noise, so they are drawn here too to stay in step.
-    private static int[] createPermutation() {
-        Random random = new Random(SEED);
-        for (int discardedOffset = 0; discardedOffset < 3; discardedOffset++) {
-            random.nextDouble();
-        }
-        int[] permutation = new int[PERMUTATION_SIZE];
-        for (int i = 0; i < PERMUTATION_SIZE; i++) {
-            permutation[i] = i;
-        }
-        for (int i = 0; i < PERMUTATION_SIZE; i++) {
-            int swap = i + random.nextInt(PERMUTATION_SIZE - i);
-            int previous = permutation[i];
-            permutation[i] = permutation[swap];
-            permutation[swap] = previous;
-        }
-        return permutation;
-    }
-}
@@ -1,195 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisBiomePaletteLayer;
-import com.volmit.iris.engine.object.IrisBlockData;
-import com.volmit.iris.engine.object.IrisDecorator;
-import com.volmit.iris.util.collection.KList;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Locale;
-
-/**
- * One of the block palettes a biome places: a surface, sea or cave ceiling layer, its wall or slab blocks, or a
- * decorator.
- */
-record BiomePalette(String biomeKey, Kind kind, int index) {
-    private static final String ID_PREFIX = "palette:";
-    private static final char ID_SEPARATOR = '#';
-    private static final String SNIPPET_PREFIX = "snippet/";
-
-    enum Kind {
-        LAYER("Layer", "layers", SnippetFolder.BLOCK_PALETTES, true, true),
-        SEA_LAYER("Sea layer", "seaLayers", SnippetFolder.BLOCK_PALETTES, true, true),
-        CAVE_CEILING_LAYER("Cave ceiling layer", "caveCeilingLayers", SnippetFolder.BLOCK_PALETTES, true, true),
-        WALL("Wall", "wall", SnippetFolder.BLOCK_PALETTES, false, false),
-        SLAB("Slab", "slab", SnippetFolder.BLOCK_PALETTES, false, false),
-        DECORATOR("Decorator", "decorators", SnippetFolder.DECORATORS, false, true);
-
-        private final String label;
-        private final String jsonKey;
-        private final SnippetFolder snippetFolder;
-        private final boolean stacked;
-        private final boolean numbered;
-
-        Kind(String label, String jsonKey, SnippetFolder snippetFolder, boolean stacked, boolean numbered) {
-            this.label = label;
-            this.jsonKey = jsonKey;
-            this.snippetFolder = snippetFolder;
-            this.stacked = stacked;
-            this.numbered = numbered;
-        }
-
-        SnippetFolder snippetFolder() {
-            return snippetFolder;
-        }
-
-        /**
-         * Whether the palette is a stack of blocks with a thickness, rather than single blocks on walls or slopes.
-         */
-        boolean isStacked() {
-            return stacked;
-        }
-
-        /**
-         * The biome file's key holding these palettes: a list of them, or a single one for walls and slabs.
-         */
-        String jsonKey() {
-            return jsonKey;
-        }
-
-        // A biome without wall or slab blocks still has those palettes, just empty.
-        List<IrisBiomePaletteLayer> layersOf(IrisBiome biome) {
-            return switch (this) {
-                case LAYER -> biome.getLayers();
-                case SEA_LAYER -> biome.getSeaLayers();
-                case CAVE_CEILING_LAYER -> biome.getCaveCeilingLayers();
-                case WALL -> biome.getWall().getPalette().isEmpty() ? List.of() : List.of(biome.getWall());
-                case SLAB -> biome.getSlab().getPalette().isEmpty() ? List.of() : List.of(biome.getSlab());
-                case DECORATOR -> List.of();
-            };
-        }
-
-        // A decorator snippet that couldn't be found loads as an empty entry, which places nothing.
-        List<KList<IrisBlockData>> blockListsOf(IrisBiome biome) {
-            if (this != DECORATOR) {
-                return layersOf(biome).stream().map(IrisBiomePaletteLayer::getPalette).toList();
-            }
-            return biome.getDecorators().stream()
-                    .map(decorator -> decorator == null ? new KList<IrisBlockData>() : decorator.getPalette())
-                    .toList();
-        }
-    }
-
-    /**
-     * The folders under snippet/ that palettes can come from, named after the Iris type they hold.
-     */
-    enum SnippetFolder {
-        BLOCK_PALETTES("biome-palette", "Block palettes"),
-        DECORATORS("decorator", "Decorators");
-
-        private final String folder;
-        private final String label;
-
-        SnippetFolder(String folder, String label) {
-            this.folder = folder;
-            this.label = label;
-        }
-
-        String folder() {
-            return folder;
-        }
-
-        String label() {
-            return label;
-        }
-
-        /**
-         * The snippet's path inside this folder. Packs may leave the folder out, the way the snippet loader allows.
-         */
-        String pathOf(String reference) {
-            String path = reference.startsWith(SNIPPET_PREFIX) ? reference.substring(SNIPPET_PREFIX.length()) : reference;
-            return path.startsWith(folder + "/") ? path.substring(folder.length() + 1) : path;
-        }
-    }
-
-    static List<BiomePalette> allOf(String biomeKey, IrisBiome biome) {
-        List<BiomePalette> palettes = new ArrayList<>();
-        for (Kind kind : Kind.values()) {
-            List<KList<IrisBlockData>> blockLists = kind.blockListsOf(biome);
-            for (int index = 0; index < blockLists.size(); index++) {
-                if (!blockLists.get(index).isEmpty()) {
-                    palettes.add(new BiomePalette(biomeKey, kind, index));
-                }
-            }
-        }
-        return List.copyOf(palettes);
-    }
-
-    static BiomePalette fromId(String id) {
-        if (id == null || !id.startsWith(ID_PREFIX)) {
-            return null;
-        }
-        int indexSeparator = id.lastIndexOf(ID_SEPARATOR);
-        int kindSeparator = id.lastIndexOf(ID_SEPARATOR, indexSeparator - 1);
-        if (kindSeparator < ID_PREFIX.length()) {
-            return null;
-        }
-        return new BiomePalette(
-                id.substring(ID_PREFIX.length(), kindSeparator),
-                Kind.valueOf(id.substring(kindSeparator + 1, indexSeparator)),
-                Integer.parseInt(id.substring(indexSeparator + 1))
-        );
-    }
-
-    static boolean belongsTo(String id, String biomeKey) {
-        return id != null && id.startsWith(ID_PREFIX + biomeKey + ID_SEPARATOR);
-    }
-
-    String id() {
-        return ID_PREFIX + biomeKey + ID_SEPARATOR + kind.name() + ID_SEPARATOR + index;
-    }
-
-    String label() {
-        return kind.numbered ? kind.label + " " + index : kind.label;
-    }
-
-    String lowercaseLabel() {
-        return label().toLowerCase(Locale.ROOT);
-    }
-
-    /**
-     * The palette's blocks in the given copy of the biome, or null when a hotload removed it.
-     */
-    KList<IrisBlockData> blocksIn(IrisBiome biome) {
-        List<KList<IrisBlockData>> blockLists = kind.blockListsOf(biome);
-        return index < blockLists.size() ? blockLists.get(index) : null;
-    }
-
-    IrisBiomePaletteLayer layerIn(IrisBiome biome) {
-        return kind.layersOf(biome).get(index);
-    }
-
-    IrisDecorator decoratorIn(IrisBiome biome) {
-        return biome.getDecorators().get(index);
-    }
-}
@@ -1,325 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.engine.decorator.IrisEngineDecorator;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisBiomePaletteLayer;
-import com.volmit.iris.engine.object.IrisBlockData;
-import com.volmit.iris.engine.object.IrisDecorationPart;
-import com.volmit.iris.engine.object.IrisDecorator;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.math.RNG;
-import com.volmit.iris.util.noise.CNG;
-import org.bukkit.block.data.Bisected;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * How thick one biome palette is at a spot and which noise picks its block there, sampled exactly the way the
- * generator does for that kind of palette. The generator seeds each palette's noise from the first call it makes,
- * so these use the same random sources the terrain, carving, post and decorator passes use.
- */
-abstract class BiomePalettePlacement {
-    protected final IrisData data;
-
-    private BiomePalettePlacement(IrisData data) {
-        this.data = data;
-    }
-
-    static BiomePalettePlacement of(Engine engine, IrisBiome biome, BiomePalette palette) {
-        IrisData data = engine.getData();
-        RNG terrainRandom = new RNG(engine.getSeedManager().getTerrain());
-        RNG carveRandom = new RNG(engine.getSeedManager().getCarve());
-        RNG postRandom = new RNG(engine.getSeedManager().getPost());
-        int seaLevel = seaLevel(engine.getDimension());
-        return switch (palette.kind()) {
-            case LAYER -> new SurfaceLayer(biome, palette.index(), palette.layerIn(biome), terrainRandom, data);
-            case SEA_LAYER -> new LegacyStackedLayer(palette.layerIn(biome), data, terrainRandom.nextParallelRNG(palette.index()),
-                    biome.getLayerSeaHeightGenerators(terrainRandom, data), palette.index());
-            case CAVE_CEILING_LAYER -> new LegacyStackedLayer(palette.layerIn(biome), data, carveRandom.nextParallelRNG(palette.index()),
-                    biome.getLayerHeightGenerators(terrainRandom, data), palette.index());
-            case WALL -> new SingleBlocks(palette.layerIn(biome), data, carveRandom, seaLevel);
-            case SLAB -> new SingleBlocks(palette.layerIn(biome), data, postRandom, seaLevel);
-            case DECORATOR -> new Decorations(biome, palette.decoratorIn(biome), engine.getSeedManager().getComponent(),
-                    seaLevel, data);
-        };
-    }
-
-    private static int seaLevel(IrisDimension dimension) {
-        return dimension == null ? 0 : dimension.getFluidHeight();
-    }
-
-    abstract KList<IrisBlockData> blocks();
-
-    abstract double zoom();
-
-    int minThickness() {
-        return 1;
-    }
-
-    int maxThickness() {
-        return 1;
-    }
-
-    abstract boolean hasSlopeCondition();
-
-    /**
-     * How many blocks of this palette are stacked at the spot.
-     */
-    abstract int thickness(int blockX, int blockZ);
-
-    abstract double noise(int blockX, int blockZ, int depth);
-
-    /**
-     * What the preview simplifies about this palette, or null when it shows exactly what the world places.
-     */
-    String simplification() {
-        return null;
-    }
-
-    private abstract static class LayerPlacement extends BiomePalettePlacement {
-        protected final IrisBiomePaletteLayer layer;
-
-        private LayerPlacement(IrisBiomePaletteLayer layer, IrisData data) {
-            super(data);
-            this.layer = layer;
-        }
-
-        @Override
-        KList<IrisBlockData> blocks() {
-            return layer.getPalette();
-        }
-
-        @Override
-        double zoom() {
-            return layer.getZoom();
-        }
-
-        @Override
-        int minThickness() {
-            return layer.getMinHeight();
-        }
-
-        @Override
-        int maxThickness() {
-            return layer.getMaxHeight();
-        }
-
-        @Override
-        boolean hasSlopeCondition() {
-            return !layer.getSlopeCondition().isDefault();
-        }
-    }
-
-    private static final class SurfaceLayer extends LayerPlacement {
-        private final IrisBiome biome;
-        private final int index;
-        private final RNG random;
-
-        private SurfaceLayer(IrisBiome biome, int index, IrisBiomePaletteLayer layer, RNG random, IrisData data) {
-            super(layer, data);
-            this.biome = biome;
-            this.index = index;
-            this.random = random;
-        }
-
-        @Override
-        int thickness(int blockX, int blockZ) {
-            return biome.getLayerThickness(index, blockX, blockZ, random, data);
-        }
-
-        @Override
-        double noise(int blockX, int blockZ, int depth) {
-            return biome.getLayerNoise(index, blockX, blockZ, depth, random, data);
-        }
-    }
-
-    /**
-     * Sea and cave ceiling layers go through the older sampling path, which divides by the zoom twice and borrows
-     * its thickness noise from another list: a cave ceiling layer uses the surface layer at the same position's.
-     */
-    private static final class LegacyStackedLayer extends LayerPlacement {
-        private final RNG random;
-        private final CNG thicknessNoise;
-
-        private LegacyStackedLayer(IrisBiomePaletteLayer layer, IrisData data, RNG random, KList<CNG> thicknessNoises,
-                                   int index) {
-            super(layer, data);
-            this.random = random;
-            this.thicknessNoise = index < thicknessNoises.size() ? thicknessNoises.get(index) : null;
-        }
-
-        @Override
-        int thickness(int blockX, int blockZ) {
-            if (thicknessNoise == null) {
-                return 0;
-            }
-            double zoom = layer.getZoom();
-            return Math.max(0, thicknessNoise.fit(layer.getMinHeight(), layer.getMaxHeight(), blockX / zoom, blockZ / zoom));
-        }
-
-        @Override
-        double noise(int blockX, int blockZ, int depth) {
-            double zoom = layer.getZoom();
-            return layer.getLayerGenerator(random, data)
-                    .noise((blockX + depth) / zoom / zoom, depth / zoom, (blockZ - depth) / zoom / zoom);
-        }
-
-        @Override
-        String simplification() {
-            return thicknessNoise == null
-                    ? "The generator takes this layer's thickness from the surface layer at the same position, which doesn't exist, so it is never placed."
-                    : null;
-        }
-    }
-
-    /**
-     * Wall and slab blocks are picked one at a time with noise that also changes with height.
-     */
-    private static final class SingleBlocks extends LayerPlacement {
-        private final RNG random;
-        private final int sampleHeight;
-
-        private SingleBlocks(IrisBiomePaletteLayer layer, IrisData data, RNG random, int sampleHeight) {
-            super(layer, data);
-            this.random = random;
-            this.sampleHeight = sampleHeight;
-        }
-
-        @Override
-        int minThickness() {
-            return 1;
-        }
-
-        @Override
-        int maxThickness() {
-            return 1;
-        }
-
-        @Override
-        int thickness(int blockX, int blockZ) {
-            return 1;
-        }
-
-        @Override
-        double noise(int blockX, int blockZ, int depth) {
-            double zoom = layer.getZoom();
-            return layer.getLayerGenerator(random, data).noise(blockX / zoom, sampleHeight / zoom, blockZ / zoom);
-        }
-
-        @Override
-        String simplification() {
-            return "These blocks also change with height; the preview shows them at sea level (Y " + sampleHeight + ").";
-        }
-    }
-
-    /**
-     * A decorator places where its style noise stays under its chance, and its variance noise picks the block there.
-     * The generator seeds the variance noise from whichever block it decorates first, so the preview reuses that noise
-     * once the world has generated some decorations.
-     */
-    private static final class Decorations extends BiomePalettePlacement {
-        private final IrisDecorator decorator;
-        private final CNG placementNoise;
-        private final CNG blockNoise;
-        private final int sampleHeight;
-        private final boolean sharesSpotsWithOtherDecorators;
-
-        private Decorations(IrisBiome biome, IrisDecorator decorator, long componentSeed, int sampleHeight, IrisData data) {
-            super(data);
-            this.decorator = decorator;
-            RNG partRandom = new RNG(IrisEngineDecorator.partSeed(componentSeed, decorator.getPartOf()));
-            this.placementNoise = decorator.getGenerator(partRandom, data);
-            this.blockNoise = decorator.getVarianceGenerator(partRandom, data);
-            this.sampleHeight = sampleHeight;
-            this.sharesSpotsWithOtherDecorators = biome.getDecorators().stream()
-                    .anyMatch(other -> other != null && other != decorator && other.getPartOf() == decorator.getPartOf());
-        }
-
-        @Override
-        KList<IrisBlockData> blocks() {
-            return decorator.getPalette();
-        }
-
-        @Override
-        double zoom() {
-            return decorator.getStyle().getZoom();
-        }
-
-        @Override
-        boolean hasSlopeCondition() {
-            return !decorator.getSlopeCondition().isDefault();
-        }
-
-        @Override
-        int thickness(int blockX, int blockZ) {
-            double zoom = zoom();
-            return placementNoise.fitDouble(0D, 1D, blockX / zoom, blockZ / zoom) <= decorator.getChance() ? 1 : 0;
-        }
-
-        // The generator swaps X and Z when it picks the block.
-        @Override
-        double noise(int blockX, int blockZ, int depth) {
-            return blockNoise.noise(blockZ, sampleHeight, blockX);
-        }
-
-        @Override
-        String simplification() {
-            List<String> notes = new ArrayList<>();
-            String partNote = partNote(decorator.getPartOf());
-            if (partNote != null) {
-                notes.add(partNote);
-            }
-            if (sharesSpotsWithOtherDecorators) {
-                notes.add("Where other decorators of this biome could place too, the world picks one of them at random.");
-            }
-            if (placesTwoBlockTallPlants()) {
-                notes.add("Two block tall plants stand up on the map: their top half covers the block above them.");
-            }
-            if (decorator.isStacking()) {
-                notes.add("It stacks " + decorator.getStackMin() + "–" + decorator.getStackMax()
-                        + " blocks high; the preview shows the bottom block.");
-            }
-            if (blocks().size() > 1) {
-                notes.add("The block also changes with height; the preview picks it at sea level (Y " + sampleHeight + ").");
-            }
-            return notes.isEmpty() ? null : String.join(" ", notes);
-        }
-
-        // The generator places any two-part block as a bottom half with its top half above it.
-        private boolean placesTwoBlockTallPlants() {
-            return !decorator.isStacking() && blocks().stream().anyMatch(block -> block.getBlockData(data) instanceof Bisected);
-        }
-
-        private static String partNote(IrisDecorationPart part) {
-            return switch (part) {
-                case NONE -> null;
-                case SHORE_LINE -> "It only places along shore lines.";
-                case SEA_SURFACE -> "It only places on the sea surface.";
-                case SEA_FLOOR -> "It only places on the sea floor.";
-                case CEILING -> "It places on cave ceilings and the undersides of overhangs, not on the ground.";
-            };
-        }
-    }
-}
@@ -1,68 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-
-package com.volmit.iris.core.gui;
-
-import java.util.Locale;
-
-// The colours one Minecraft biome multiplies onto tinted blocks, as worked out by Biome#getGrassColor and friends.
-record BiomeTintColors(int grass, GrassColorModifier grassModifier, int foliage, int dryFoliage, int water) {
-    int colorAt(BiomeTint tint, int blockX, int blockZ) {
-        return switch (tint) {
-            case GRASS -> grassModifier.modify(blockX, blockZ, grass);
-            case FOLIAGE -> foliage;
-            case DRY_FOLIAGE -> dryFoliage;
-            case WATER -> water;
-        };
-    }
-
-    boolean variesByPosition() {
-        return grassModifier == GrassColorModifier.SWAMP;
-    }
-
-    enum GrassColorModifier {
-        NONE,
-        DARK_FOREST,
-        SWAMP;
-
-        private static final double SWAMP_NOISE_SCALE = 0.0225D;
-        private static final double SWAMP_WET_THRESHOLD = -0.1D;
-        private static final int SWAMP_WET_GRASS = 0x4C763C;
-        private static final int SWAMP_DRY_GRASS = 0x6A7039;
-        private static final int DARK_FOREST_SHIFT = 0x28340A;
-
-        static GrassColorModifier named(String name) {
-            return switch (name.toLowerCase(Locale.ROOT)) {
-                case "dark_forest" -> DARK_FOREST;
-                case "swamp" -> SWAMP;
-                default -> NONE;
-            };
-        }
-
-        int modify(int blockX, int blockZ, int baseColor) {
-            return switch (this) {
-                case NONE -> baseColor;
-                case DARK_FOREST -> ((baseColor & 0xFEFEFE) + DARK_FOREST_SHIFT) >> 1;
-                case SWAMP -> BiomeInfoNoise.at(blockX * SWAMP_NOISE_SCALE, blockZ * SWAMP_NOISE_SCALE) < SWAMP_WET_THRESHOLD
-                        ? SWAMP_WET_GRASS
-                        : SWAMP_DRY_GRASS;
-            };
-        }
-    }
-}
@@ -1,138 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisBiomeCustom;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.math.RNG;
-import org.bukkit.block.Biome;
-
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-// The tint Minecraft draws on each column of one Iris biome. Iris picks the Minecraft biome once per chunk
-// (see IrisBiomeActuator), and the client averages the colours of the columns around each block.
-final class BiomeTintField {
-    private static final int MINECRAFT_DEFAULT_BLEND_RADIUS = 2;
-    private static final int BLENDED_COLUMN_COUNT = (MINECRAFT_DEFAULT_BLEND_RADIUS * 2 + 1) * (MINECRAFT_DEFAULT_BLEND_RADIUS * 2 + 1);
-    private static final int BLENDED_TINT_CACHE_SIZE = 1 << 16;
-    private static final int CHUNK_COLORS_CACHE_SIZE = 1 << 10;
-
-    private final IrisBiome biome;
-    private final RNG biomeRandom;
-    private final MinecraftBiomeColors minecraftColors;
-    private final BiomeTintColors sameColorsEverywhere;
-    private final Map<IrisBiomeCustom, BiomeTintColors> colorsByCustomBiome = new ConcurrentHashMap<>();
-    private final BlendedTint[] blendedTintCache = new BlendedTint[BLENDED_TINT_CACHE_SIZE];
-    private final ChunkColors[] chunkColorsCache = new ChunkColors[CHUNK_COLORS_CACHE_SIZE];
-
-    BiomeTintField(IrisBiome biome, RNG biomeRandom, MinecraftBiomeColors minecraftColors) {
-        this.biome = biome;
-        this.biomeRandom = biomeRandom;
-        this.minecraftColors = minecraftColors;
-        BiomeTintColors onlyColors = onlyPossibleColors();
-        this.sameColorsEverywhere = onlyColors == null || onlyColors.variesByPosition() ? null : onlyColors;
-    }
-
-    int colorAt(BiomeTint tint, int blockX, int blockZ) {
-        if (sameColorsEverywhere != null) {
-            return sameColorsEverywhere.colorAt(tint, blockX, blockZ);
-        }
-        int cacheSlot = cacheSlot(blockX, blockZ, tint.ordinal(), BLENDED_TINT_CACHE_SIZE);
-        BlendedTint cached = blendedTintCache[cacheSlot];
-        if (cached != null && cached.x() == blockX && cached.z() == blockZ && cached.tint() == tint) {
-            return cached.color();
-        }
-        int color = blendedColor(tint, blockX, blockZ);
-        blendedTintCache[cacheSlot] = new BlendedTint(blockX, blockZ, tint, color);
-        return color;
-    }
-
-    // Minecraft's ClientLevel#calculateBlockTint at the default biome blend radius.
-    private int blendedColor(BiomeTint tint, int blockX, int blockZ) {
-        int red = 0;
-        int green = 0;
-        int blue = 0;
-        for (int x = blockX - MINECRAFT_DEFAULT_BLEND_RADIUS; x <= blockX + MINECRAFT_DEFAULT_BLEND_RADIUS; x++) {
-            for (int z = blockZ - MINECRAFT_DEFAULT_BLEND_RADIUS; z <= blockZ + MINECRAFT_DEFAULT_BLEND_RADIUS; z++) {
-                int color = chunkColors(x >> 4, z >> 4).colorAt(tint, x, z);
-                red += (color >>> 16) & 0xFF;
-                green += (color >>> 8) & 0xFF;
-                blue += color & 0xFF;
-            }
-        }
-        return (red / BLENDED_COLUMN_COUNT) << 16 | (green / BLENDED_COLUMN_COUNT) << 8 | (blue / BLENDED_COLUMN_COUNT);
-    }
-
-    private BiomeTintColors chunkColors(int chunkX, int chunkZ) {
-        int cacheSlot = cacheSlot(chunkX, chunkZ, 0, CHUNK_COLORS_CACHE_SIZE);
-        ChunkColors cached = chunkColorsCache[cacheSlot];
-        if (cached != null && cached.chunkX() == chunkX && cached.chunkZ() == chunkZ) {
-            return cached.colors();
-        }
-        BiomeTintColors colors = colorsForChunkAt(chunkX << 4, chunkZ << 4);
-        chunkColorsCache[cacheSlot] = new ChunkColors(chunkX, chunkZ, colors);
-        return colors;
-    }
-
-    private BiomeTintColors colorsForChunkAt(int originX, int originZ) {
-        if (biome.isCustom()) {
-            return customColors(biome.getCustomBiome(biomeRandom, originX, 0, originZ));
-        }
-        return vanillaColors(biome.getSkyBiome(biomeRandom, originX, 0, originZ));
-    }
-
-    // Follows the same choices as IrisBiome#getSkyBiome and #getCustomBiome, returning null when chunks can differ.
-    private BiomeTintColors onlyPossibleColors() {
-        if (biome.isCustom()) {
-            KList<IrisBiomeCustom> variants = biome.getCustomDerivitives();
-            return variants.size() == 1 ? customColors(variants.get(0)) : null;
-        }
-        KList<Biome> skyBiomes = biome.getBiomeSkyScatter();
-        if (!skyBiomes.isEmpty()) {
-            return skyBiomes.size() == 1 ? vanillaColors(skyBiomes.get(0)) : null;
-        }
-        KList<Biome> groundBiomes = biome.getBiomeScatter();
-        if (groundBiomes.isEmpty()) {
-            return vanillaColors(biome.getDerivative());
-        }
-        return groundBiomes.size() == 1 ? vanillaColors(groundBiomes.get(0)) : null;
-    }
-
-    private BiomeTintColors customColors(IrisBiomeCustom customBiome) {
-        return colorsByCustomBiome.computeIfAbsent(customBiome, minecraftColors::custom);
-    }
-
-    private BiomeTintColors vanillaColors(Biome vanillaBiome) {
-        return minecraftColors.vanilla(vanillaBiome.getKey());
-    }
-
-    private static int cacheSlot(int x, int z, int salt, int cacheSize) {
-        long hash = x * 0x9E3779B97F4A7C15L ^ z * 0xC2B2AE3D27D4EB4FL ^ salt * 0x165667B19E3779F9L;
-        return (int) ((hash ^ (hash >>> 29)) & (cacheSize - 1));
-    }
-
-    private record BlendedTint(int x, int z, BiomeTint tint, int color) {
-    }
-
-    private record ChunkColors(int chunkX, int chunkZ, BiomeTintColors colors) {
-    }
-}
@@ -1,213 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.core.gui.BlockTextures.BlockTexture;
-
-import java.util.ArrayList;
-import java.util.EnumSet;
-import java.util.IdentityHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.function.UnaryOperator;
-
-/**
- * A block as the object viewer draws it: the textured faces of its model, in block units, already turned the way the
- * blockstate faces.
- *
- * @param faces               every face of every box in the model
- * @param coveredSides        the block's sides that a solid face fills completely, which hide whatever touches them
- * @param hidesSameBlockSides whether the model fills the whole block, so like glass it hides the sides between two of
- *                            the same blocks
- */
-record BlockModel(List<Face> faces, Set<CubeFace> coveredSides, boolean hidesSameBlockSides) {
-    static final BlockModel EMPTY = new BlockModel(List.of(), Set.of(), false);
-    private static final int SIDE_CELLS = 16;
-    private static final double ON_SIDE_TOLERANCE = 1e-4D;
-
-    static BlockModel of(List<Face> faces) {
-        Set<CubeFace> coveredSides = EnumSet.noneOf(CubeFace.class);
-        boolean fillsEverySide = true;
-        for (CubeFace side : CubeFace.values()) {
-            if (sideIsFilled(faces, side, true)) {
-                coveredSides.add(side);
-            }
-            fillsEverySide &= sideIsFilled(faces, side, false);
-        }
-        return new BlockModel(List.copyOf(faces), Set.copyOf(coveredSides), fillsEverySide);
-    }
-
-    static BlockModel solidColor(int color) {
-        BlockTexture texture = BlockTexture.solid(color);
-        List<Face> faces = new ArrayList<>();
-        for (CubeFace side : CubeFace.values()) {
-            faces.add(Face.boxSide(Vec3.ZERO, new Vec3(1D, 1D, 1D), side, texture, side));
-        }
-        return of(faces);
-    }
-
-    boolean isEmpty() {
-        return faces.isEmpty();
-    }
-
-    BlockModel withTextures(UnaryOperator<BlockTexture> change) {
-        Map<BlockTexture, BlockTexture> changed = new IdentityHashMap<>();
-        List<Face> changedFaces = new ArrayList<>(faces.size());
-        for (Face face : faces) {
-            changedFaces.add(face.withTexture(changed.computeIfAbsent(face.texture(), change)));
-        }
-        return new BlockModel(List.copyOf(changedFaces), coveredSides, hidesSameBlockSides);
-    }
-
-    // The side is split into a grid, and every cell has to lie under a face pressed flat against it.
-    private static boolean sideIsFilled(List<Face> faces, CubeFace side, boolean onlySolidFaces) {
-        boolean[] filled = new boolean[SIDE_CELLS * SIDE_CELLS];
-        for (Face face : faces) {
-            if (face.liesOn(side) && (!onlySolidFaces || face.texture().isFullyOpaque())) {
-                face.fillCells(side, filled, SIDE_CELLS);
-            }
-        }
-        for (boolean cell : filled) {
-            if (!cell) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * A parallelogram from {@code origin} along {@code edgeU} and {@code edgeV}. The texture point at the origin and
-     * how it moves along each edge are given as fractions of the texture.
-     *
-     * @param normal   the way the face looks out; it is hidden when seen from behind
-     * @param cullFace the block side whose neighbour hides this face when it covers that side, or null
-     */
-    record Face(Vec3 origin, Vec3 edgeU, Vec3 edgeV, Vec3 normal, BlockTexture texture, TextureMapping mapping,
-                double shade, CubeFace cullFace) {
-
-        // Laid out as seen from outside: u to the right and v downwards, matching Minecraft's UVs for a whole texture.
-        static Face boxSide(Vec3 from, Vec3 to, CubeFace side, BlockTexture texture, CubeFace cullFace) {
-            Vec3[] corners = BoxCorners.of(from, to, side);
-            return new Face(corners[0], corners[3].minus(corners[0]), corners[1].minus(corners[0]), side.direction(),
-                    texture, TextureMapping.WHOLE, side.shade(), cullFace);
-        }
-
-        Face withTexture(BlockTexture changedTexture) {
-            return new Face(origin, edgeU, edgeV, normal, changedTexture, mapping, shade, cullFace);
-        }
-
-        Face transformed(Transform transform) {
-            Vec3 turnedNormal = transform.direction(normal);
-            double length = Math.sqrt(turnedNormal.x() * turnedNormal.x() + turnedNormal.y() * turnedNormal.y() + turnedNormal.z() * turnedNormal.z());
-            return new Face(transform.point(origin), transform.direction(edgeU), transform.direction(edgeV),
-                    length == 0D ? turnedNormal : turnedNormal.times(1D / length), texture, mapping, shade,
-                    cullFace == null ? null : CubeFace.nearest(transform.direction(cullFace.direction())));
-        }
-
-        Face withCullFace(CubeFace side) {
-            return new Face(origin, edgeU, edgeV, normal, texture, mapping, shade, side);
-        }
-
-        Face withShade(double changedShade) {
-            return new Face(origin, edgeU, edgeV, normal, texture, mapping, changedShade, cullFace);
-        }
-
-        private boolean liesOn(CubeFace side) {
-            int axis = side.axis();
-            double plane = side.pointsPositive() ? 1D : 0D;
-            return CubeFace.nearest(normal) == side
-                    && Math.abs(normal.component(axis)) > 1D - ON_SIDE_TOLERANCE
-                    && Math.abs(origin.component(axis) - plane) < ON_SIDE_TOLERANCE
-                    && Math.abs(edgeU.component(axis)) < ON_SIDE_TOLERANCE
-                    && Math.abs(edgeV.component(axis)) < ON_SIDE_TOLERANCE;
-        }
-
-        private void fillCells(CubeFace side, boolean[] filled, int cells) {
-            int firstAxis = side.axis() == 0 ? 1 : 0;
-            int secondAxis = side.axis() == 2 ? 1 : 2;
-            double[] firstRange = range(firstAxis);
-            double[] secondRange = range(secondAxis);
-            for (int first = 0; first < cells; first++) {
-                double firstCenter = (first + 0.5D) / cells;
-                if (firstCenter < firstRange[0] || firstCenter > firstRange[1]) {
-                    continue;
-                }
-                for (int second = 0; second < cells; second++) {
-                    double secondCenter = (second + 0.5D) / cells;
-                    if (secondCenter >= secondRange[0] && secondCenter <= secondRange[1]) {
-                        filled[first * cells + second] = true;
-                    }
-                }
-            }
-        }
-
-        private double[] range(int axis) {
-            double start = origin.component(axis);
-            double alongU = edgeU.component(axis);
-            double alongV = edgeV.component(axis);
-            double low = start + Math.min(0D, alongU) + Math.min(0D, alongV);
-            double high = start + Math.max(0D, alongU) + Math.max(0D, alongV);
-            return new double[]{low, high};
-        }
-    }
-
-    /**
-     * Where a face's corner sits in its texture and how the texture point moves along the face's two edges, all as
-     * fractions of the texture's width and height.
-     */
-    record TextureMapping(double u, double v, double uAlongU, double vAlongU, double uAlongV, double vAlongV) {
-        static final TextureMapping WHOLE = new TextureMapping(0D, 0D, 1D, 0D, 0D, 1D);
-    }
-
-    /**
-     * A box side's corners in Minecraft's order: top left, bottom left, bottom right and top right, as seen from
-     * outside the box.
-     */
-    static final class BoxCorners {
-        private BoxCorners() {
-        }
-
-        static Vec3[] of(Vec3 from, Vec3 to, CubeFace side) {
-            double minX = from.x();
-            double minY = from.y();
-            double minZ = from.z();
-            double maxX = to.x();
-            double maxY = to.y();
-            double maxZ = to.z();
-            return switch (side) {
-                case DOWN -> corners(minX, minY, maxZ, minX, minY, minZ, maxX, minY, minZ, maxX, minY, maxZ);
-                case UP -> corners(minX, maxY, minZ, minX, maxY, maxZ, maxX, maxY, maxZ, maxX, maxY, minZ);
-                case NORTH -> corners(maxX, maxY, minZ, maxX, minY, minZ, minX, minY, minZ, minX, maxY, minZ);
-                case SOUTH -> corners(minX, maxY, maxZ, minX, minY, maxZ, maxX, minY, maxZ, maxX, maxY, maxZ);
-                case WEST -> corners(minX, maxY, minZ, minX, minY, minZ, minX, minY, maxZ, minX, maxY, maxZ);
-                case EAST -> corners(maxX, maxY, maxZ, maxX, minY, maxZ, maxX, minY, minZ, maxX, maxY, minZ);
-            };
-        }
-
-        private static Vec3[] corners(double... coordinates) {
-            Vec3[] corners = new Vec3[4];
-            for (int corner = 0; corner < 4; corner++) {
-                corners[corner] = new Vec3(coordinates[corner * 3], coordinates[corner * 3 + 1], coordinates[corner * 3 + 2]);
-            }
-            return corners;
-        }
-    }
-}
@@ -1,351 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-
-package com.volmit.iris.core.gui;
-
-import com.google.gson.JsonArray;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
-import com.volmit.iris.core.gui.BlockModel.BoxCorners;
-import com.volmit.iris.core.gui.BlockModel.Face;
-import com.volmit.iris.core.gui.BlockModel.TextureMapping;
-import com.volmit.iris.core.gui.BlockTextures.BlockStateId;
-import com.volmit.iris.core.gui.BlockTextures.BlockTexture;
-import com.volmit.iris.core.gui.BlockTextures.ModelDefinition;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-
-/**
- * Reads a block's look the way Minecraft does: every model part the blockstate picks, every box with its own texture
- * and UVs, tilted boxes, the blockstate's turn with or without locked textures, and which faces a neighbour hides.
- */
-final class BlockModelBuilder {
-    private static final double MODEL_UNITS = 16D;
-    private static final double BLOCK_CENTER = 0.5D;
-    private static final int QUARTER_TURN = 90;
-
-    private final BlockTextures textures;
-    private final EntityBlockShapes entityShapes;
-
-    BlockModelBuilder(BlockTextures textures) {
-        this.textures = textures;
-        this.entityShapes = new EntityBlockShapes(textures);
-    }
-
-    Optional<BlockModel> build(String blockState) {
-        try {
-            BlockStateId state = BlockStateId.parse(blockState);
-            List<JsonObject> placements = placementsOf(state);
-            if (placements == null) {
-                return Optional.empty();
-            }
-            List<Face> faces = new ArrayList<>();
-            for (JsonObject placement : placements) {
-                faces.addAll(placedFaces(state, placement));
-            }
-            faces.addAll(entityShapes.facesAddedTo(state));
-            return Optional.of(BlockModel.of(faces));
-        } catch (IOException | RuntimeException error) {
-            return Optional.empty();
-        }
-    }
-
-    /**
-     * A box with Minecraft's default UVs on each side, for shapes the game draws in code.
-     */
-    static List<Face> box(Vec3 fromPixels, Vec3 toPixels, BlockTexture texture, boolean culledBySides) {
-        List<Face> faces = new ArrayList<>();
-        for (CubeFace side : CubeFace.values()) {
-            FaceUv uv = FaceUv.byDefault(side, fromPixels, toPixels);
-            Face face = boxFace(fromPixels, toPixels, side, texture, uv).withShade(side.shade());
-            faces.add(culledBySides ? face.withCullFace(side) : face);
-        }
-        return faces;
-    }
-
-    // A variant names one model; a multipart blockstate, like a fence's, adds a part for every condition that holds.
-    private List<JsonObject> placementsOf(BlockStateId state) throws IOException {
-        JsonObject definition = textures.readJson(BlockTextures.assetPath(state.namespace() + ":" + state.name(), "blockstates", ".json"));
-        if (definition == null) {
-            return null;
-        }
-        List<JsonObject> placements = new ArrayList<>();
-        if (definition.has("variants")) {
-            for (Map.Entry<String, JsonElement> variant : definition.getAsJsonObject("variants").entrySet()) {
-                if (BlockTextures.variantMatches(variant.getKey(), state.properties())) {
-                    addPlacement(placements, variant.getValue());
-                    break;
-                }
-            }
-        }
-        if (definition.has("multipart")) {
-            for (JsonElement part : definition.getAsJsonArray("multipart")) {
-                JsonObject rule = part.getAsJsonObject();
-                if (!rule.has("when") || BlockTextures.conditionMatches(rule.getAsJsonObject("when"), state.properties())) {
-                    addPlacement(placements, rule.get("apply"));
-                }
-            }
-        }
-        return placements;
-    }
-
-    private static void addPlacement(List<JsonObject> placements, JsonElement models) {
-        JsonObject first = BlockTextures.firstModel(models);
-        if (first != null && first.has("model")) {
-            placements.add(first);
-        }
-    }
-
-    private List<Face> placedFaces(BlockStateId state, JsonObject placement) throws IOException {
-        ModelDefinition model = textures.readModel(placement.get("model").getAsString());
-        if (model.elements() == null) {
-            return entityShapes.facesOf(state, model);
-        }
-        BlockRotation rotation = BlockRotation.of(placement);
-        List<Face> faces = new ArrayList<>();
-        for (JsonElement element : model.elements()) {
-            addElementFaces(faces, state, model, element.getAsJsonObject(), rotation);
-        }
-        return faces;
-    }
-
-    private void addElementFaces(List<Face> faces, BlockStateId state, ModelDefinition model, JsonObject element, BlockRotation rotation) {
-        JsonObject elementFaces = element.getAsJsonObject("faces");
-        if (elementFaces == null) {
-            return;
-        }
-        Vec3 from = vector(element.getAsJsonArray("from"));
-        Vec3 to = vector(element.getAsJsonArray("to"));
-        Transform tilt = tiltOf(element);
-        boolean shaded = !element.has("shade") || element.get("shade").getAsBoolean();
-        CubeFace shadeSide = element.has("shade_direction_override")
-                ? CubeFace.named(element.get("shade_direction_override").getAsString()) : null;
-        for (Map.Entry<String, JsonElement> entry : elementFaces.entrySet()) {
-            CubeFace side = CubeFace.named(entry.getKey());
-            JsonObject faceJson = entry.getValue().getAsJsonObject();
-            if (side == null || !faceJson.has("texture")) {
-                continue;
-            }
-            String textureName = BlockTextures.dereference(faceJson.get("texture").getAsString(), model.textures());
-            if (textureName == null) {
-                continue;
-            }
-            Optional<BlockTexture> texture = textures.faceTexture(state, textureName, BlockTextures.tintIndexOf(faceJson));
-            if (texture.isEmpty()) {
-                continue;
-            }
-            FaceUv uv = FaceUv.of(faceJson, side, from, to);
-            if (rotation.locksTextures()) {
-                uv = uv.lockedTo(side, rotation);
-            }
-            Face face = boxFace(from, to, side, texture.get(), uv).transformed(tilt);
-            if (faceJson.has("cullface")) {
-                face = face.withCullFace(CubeFace.named(faceJson.get("cullface").getAsString()));
-            }
-            face = face.transformed(rotation.transform());
-            faces.add(face.withShade(shadeOf(face, shaded, shadeSide, rotation)));
-        }
-    }
-
-    private static Face boxFace(Vec3 fromPixels, Vec3 toPixels, CubeFace side, BlockTexture texture, FaceUv uv) {
-        Vec3[] corners = BoxCorners.of(fromPixels.times(1D / MODEL_UNITS), toPixels.times(1D / MODEL_UNITS), side);
-        return new Face(corners[0], corners[3].minus(corners[0]), corners[1].minus(corners[0]), side.direction(),
-                texture, uv.mapping(), side.shade(), null);
-    }
-
-    private static double shadeOf(Face face, boolean shaded, CubeFace shadeSide, BlockRotation rotation) {
-        if (!shaded) {
-            return CubeFace.UP.shade();
-        }
-        if (shadeSide != null) {
-            return CubeFace.nearest(rotation.transform().direction(shadeSide.direction())).shade();
-        }
-        return CubeFace.nearest(face.normal()).shade();
-    }
-
-    // A box can be tilted around a point, on one axis or, since 1.21.?, on all three; rescaling stretches a tilted
-    // plant back to the full block width.
-    private static Transform tiltOf(JsonObject element) {
-        if (!element.has("rotation")) {
-            return Transform.IDENTITY;
-        }
-        JsonObject rotation = element.getAsJsonObject("rotation");
-        Vec3 origin = rotation.has("origin") ? vector(rotation.getAsJsonArray("origin")).times(1D / MODEL_UNITS) : new Vec3(BLOCK_CENTER, BLOCK_CENTER, BLOCK_CENTER);
-        Transform around = Transform.IDENTITY.translate(origin.x(), origin.y(), origin.z());
-        Transform back = Transform.IDENTITY.translate(-origin.x(), -origin.y(), -origin.z());
-        if (!rotation.has("axis")) {
-            return around
-                    .rotateX(numberOr(rotation, "x", 0D))
-                    .rotateY(numberOr(rotation, "y", 0D))
-                    .rotateZ(numberOr(rotation, "z", 0D))
-                    .then(back);
-        }
-        String axis = rotation.get("axis").getAsString();
-        double angle = numberOr(rotation, "angle", 0D);
-        boolean rescale = rotation.has("rescale") && rotation.get("rescale").getAsBoolean();
-        double stretch = rescale ? 1D / Math.cos(Math.toRadians(angle)) : 1D;
-        Transform stretched = around.scale(axis.equals("x") ? 1D : stretch, axis.equals("y") ? 1D : stretch, axis.equals("z") ? 1D : stretch);
-        Transform tilted = switch (axis) {
-            case "x" -> stretched.rotateX(angle);
-            case "y" -> stretched.rotateY(angle);
-            default -> stretched.rotateZ(angle);
-        };
-        return tilted.then(back);
-    }
-
-    private static double numberOr(JsonObject object, String key, double fallback) {
-        return object.has(key) ? object.get(key).getAsDouble() : fallback;
-    }
-
-    private static Vec3 vector(JsonArray values) {
-        return new Vec3(values.get(0).getAsDouble(), values.get(1).getAsDouble(), values.get(2).getAsDouble());
-    }
-
-    /**
-     * How a blockstate turns its model: around the x axis first, then the y axis, both in quarter turns against the
-     * right-hand rule. With uvlock the textures stay put while the shape turns.
-     */
-    private record BlockRotation(int x, int y, boolean uvlock) {
-        static BlockRotation of(JsonObject placement) {
-            int x = placement.has("x") ? Math.floorMod(placement.get("x").getAsInt(), 360) : 0;
-            int y = placement.has("y") ? Math.floorMod(placement.get("y").getAsInt(), 360) : 0;
-            return new BlockRotation(x, y, placement.has("uvlock") && placement.get("uvlock").getAsBoolean());
-        }
-
-        boolean locksTextures() {
-            return uvlock && (x != 0 || y != 0);
-        }
-
-        Transform transform() {
-            return Transform.IDENTITY
-                    .translate(BLOCK_CENTER, BLOCK_CENTER, BLOCK_CENTER)
-                    .then(turn())
-                    .translate(-BLOCK_CENTER, -BLOCK_CENTER, -BLOCK_CENTER);
-        }
-
-        Transform turn() {
-            return Transform.IDENTITY.rotateY(-y).rotateX(-x);
-        }
-
-        Transform inverseTurn() {
-            return Transform.IDENTITY.rotateX(x).rotateY(y);
-        }
-    }
-
-    /**
-     * A face's corner UVs in model pixels and the quarter turn of the texture on it.
-     */
-    private record FaceUv(double u1, double v1, double u2, double v2, int rotation) {
-        static FaceUv of(JsonObject face, CubeFace side, Vec3 from, Vec3 to) {
-            int rotation = face.has("rotation") ? Math.floorMod(face.get("rotation").getAsInt(), 360) : 0;
-            if (!face.has("uv")) {
-                return byDefault(side, from, to).withRotation(rotation);
-            }
-            JsonArray uv = face.getAsJsonArray("uv");
-            return new FaceUv(uv.get(0).getAsDouble(), uv.get(1).getAsDouble(), uv.get(2).getAsDouble(), uv.get(3).getAsDouble(), rotation);
-        }
-
-        // The part of the texture the face would cover if the texture were laid over the whole block side.
-        static FaceUv byDefault(CubeFace side, Vec3 from, Vec3 to) {
-            double full = MODEL_UNITS;
-            return switch (side) {
-                case DOWN -> new FaceUv(from.x(), full - to.z(), to.x(), full - from.z(), 0);
-                case UP -> new FaceUv(from.x(), from.z(), to.x(), to.z(), 0);
-                case NORTH -> new FaceUv(full - to.x(), full - to.y(), full - from.x(), full - from.y(), 0);
-                case SOUTH -> new FaceUv(from.x(), full - to.y(), to.x(), full - from.y(), 0);
-                case WEST -> new FaceUv(from.z(), full - to.y(), to.z(), full - from.y(), 0);
-                case EAST -> new FaceUv(full - to.z(), full - to.y(), full - from.z(), full - from.y(), 0);
-            };
-        }
-
-        FaceUv withRotation(int changedRotation) {
-            return new FaceUv(u1, v1, u2, v2, changedRotation);
-        }
-
-        // Each corner takes the UV a quarter turn further along for every quarter turn of the texture.
-        TextureMapping mapping() {
-            double[] origin = cornerUv(0);
-            double[] alongU = cornerUv(3);
-            double[] alongV = cornerUv(1);
-            return new TextureMapping(origin[0] / MODEL_UNITS, origin[1] / MODEL_UNITS,
-                    (alongU[0] - origin[0]) / MODEL_UNITS, (alongU[1] - origin[1]) / MODEL_UNITS,
-                    (alongV[0] - origin[0]) / MODEL_UNITS, (alongV[1] - origin[1]) / MODEL_UNITS);
-        }
-
-        private double[] cornerUv(int corner) {
-            return switch ((corner + rotation / QUARTER_TURN) % 4) {
-                case 0 -> new double[]{u1, v1};
-                case 1 -> new double[]{u1, v2};
-                case 2 -> new double[]{u2, v2};
-                default -> new double[]{u2, v1};
-            };
-        }
-
-        /**
-         * Minecraft's uvlock: the UVs are carried through the reverse of the blockstate's turn, so the texture keeps
-         * its place in the world while the face moves to another side.
-         */
-        FaceUv lockedTo(CubeFace side, BlockRotation blockRotation) {
-            CubeFace turnedSide = CubeFace.nearest(blockRotation.turn().direction(side.direction()));
-            Transform uvTurn = Transform.IDENTITY
-                    .translate(BLOCK_CENTER, BLOCK_CENTER, BLOCK_CENTER)
-                    .then(faceFromWorld(side))
-                    .then(blockRotation.inverseTurn())
-                    .then(worldFromFace(turnedSide))
-                    .translate(-BLOCK_CENTER, -BLOCK_CENTER, -BLOCK_CENTER);
-            Vec3 first = uvTurn.point(new Vec3(u1 / MODEL_UNITS, v1 / MODEL_UNITS, 0D)).times(MODEL_UNITS);
-            Vec3 second = uvTurn.point(new Vec3(u2 / MODEL_UNITS, v2 / MODEL_UNITS, 0D)).times(MODEL_UNITS);
-            boolean keepsUOrder = Math.signum(u2 - u1) == Math.signum(second.x() - first.x());
-            boolean keepsVOrder = Math.signum(v2 - v1) == Math.signum(second.y() - first.y());
-            Vec3 textureRight = uvTurn.direction(new Vec3(Math.cos(Math.toRadians(rotation)), Math.sin(Math.toRadians(rotation)), 0D));
-            long quarterTurns = Math.round(Math.toDegrees(Math.atan2(textureRight.y(), textureRight.x())) / QUARTER_TURN);
-            return new FaceUv(
-                    keepsUOrder ? first.x() : second.x(), keepsVOrder ? first.y() : second.y(),
-                    keepsUOrder ? second.x() : first.x(), keepsVOrder ? second.y() : first.y(),
-                    (int) Math.floorMod(-quarterTurns * QUARTER_TURN, 360L));
-        }
-
-        // Minecraft lays every side's texture out as if it were the south side, turned into place.
-        private static Transform worldFromFace(CubeFace side) {
-            return switch (side) {
-                case SOUTH -> Transform.IDENTITY;
-                case EAST -> Transform.IDENTITY.rotateY(90D);
-                case WEST -> Transform.IDENTITY.rotateY(-90D);
-                case NORTH -> Transform.IDENTITY.rotateY(180D);
-                case UP -> Transform.IDENTITY.rotateX(-90D);
-                case DOWN -> Transform.IDENTITY.rotateX(90D);
-            };
-        }
-
-        private static Transform faceFromWorld(CubeFace side) {
-            return switch (side) {
-                case SOUTH -> Transform.IDENTITY;
-                case EAST -> Transform.IDENTITY.rotateY(-90D);
-                case WEST -> Transform.IDENTITY.rotateY(90D);
-                case NORTH -> Transform.IDENTITY.rotateY(180D);
-                case UP -> Transform.IDENTITY.rotateX(90D);
-                case DOWN -> Transform.IDENTITY.rotateX(-90D);
-            };
-        }
-    }
-}
@@ -1,101 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import org.bukkit.block.data.BlockData;
-
-import java.awt.Color;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-final class BlockPreviewColors {
-    private static final Method MAP_COLOR_METHOD = findMapColorMethod();
-    private static final double[] MAP_SHADES = {1D, 0.86D, 0.71D, 0.53D};
-    private static final int NO_MAP_COLOR = 0;
-
-    private BlockPreviewColors() {
-    }
-
-    static Map<String, Integer> colorsByBlock(List<BlockData> blocks) {
-        Map<String, Integer> colors = new HashMap<>();
-        List<Integer> usedColors = new ArrayList<>();
-        for (BlockData block : blocks) {
-            String key = block.getAsString(true);
-            if (colors.containsKey(key)) {
-                continue;
-            }
-            int baseColor = baseColor(block);
-            int color = firstUnusedShade(baseColor, usedColors);
-            usedColors.add(color);
-            colors.put(key, color);
-        }
-        return colors;
-    }
-
-    // Blocks that share a map colour, like sand and sandstone, get darker shades the way Minecraft maps shade them.
-    private static int firstUnusedShade(int baseColor, List<Integer> usedColors) {
-        for (double shade : MAP_SHADES) {
-            int shaded = shade(baseColor, shade);
-            if (!usedColors.contains(shaded)) {
-                return shaded;
-            }
-        }
-        return baseColor;
-    }
-
-    private static int baseColor(BlockData block) {
-        int mapColor = mapColor(block);
-        return mapColor == NO_MAP_COLOR ? colorFromName(block.getMaterial().getKey().getKey()) : mapColor;
-    }
-
-    private static int mapColor(BlockData block) {
-        if (MAP_COLOR_METHOD == null) {
-            return NO_MAP_COLOR;
-        }
-        try {
-            return ((org.bukkit.Color) MAP_COLOR_METHOD.invoke(block)).asRGB();
-        } catch (ReflectiveOperationException | RuntimeException error) {
-            return NO_MAP_COLOR;
-        }
-    }
-
-    private static int colorFromName(String name) {
-        float hue = (name.hashCode() & 0xFFFF) / (float) 0xFFFF;
-        return Color.HSBtoRGB(hue, 0.45F, 0.75F) & 0xFFFFFF;
-    }
-
-    static int shade(int color, double shade) {
-        int red = (int) Math.min(255, ((color >>> 16) & 0xFF) * shade);
-        int green = (int) Math.min(255, ((color >>> 8) & 0xFF) * shade);
-        int blue = (int) Math.min(255, (color & 0xFF) * shade);
-        return (red << 16) | (green << 8) | blue;
-    }
-
-    // Iris compiles against the 1.20.1 API, which predates BlockData#getMapColor.
-    private static Method findMapColorMethod() {
-        try {
-            return BlockData.class.getMethod("getMapColor");
-        } catch (NoSuchMethodException error) {
-            return null;
-        }
-    }
-}
@@ -1,603 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.google.gson.JsonArray;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
-import org.bukkit.block.data.Bisected;
-import org.bukkit.block.data.BlockData;
-
-import java.awt.Graphics2D;
-import java.awt.image.BufferedImage;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.zip.ZipFile;
-
-final class BlockTextures {
-    private static final String DEFAULT_NAMESPACE = "minecraft";
-    private static final int MAX_MODEL_PARENTS = 16;
-    private static final int MAX_TEXTURE_REFERENCES = 16;
-    static final int NO_TINT_INDEX = -1;
-    private static final Object SHARED_LOCK = new Object();
-    private static CompletableFuture<BlockTextures> shared;
-
-    private final ZipFile clientJar;
-    private final MinecraftBiomeColors biomeColors;
-    private final Map<String, Optional<ResolvedTexture>> resolvedTextures = new ConcurrentHashMap<>();
-    private final Map<String, Optional<BlockModel>> resolvedModels = new ConcurrentHashMap<>();
-    private final Map<String, Optional<BlockTexture>> faceTextures = new ConcurrentHashMap<>();
-    private final BlockModelBuilder modelBuilder = new BlockModelBuilder(this);
-
-    private BlockTextures(ZipFile clientJar, MinecraftBiomeColors biomeColors) {
-        this.clientJar = clientJar;
-        this.biomeColors = biomeColors;
-    }
-
-    static CompletableFuture<BlockTextures> shared() {
-        synchronized (SHARED_LOCK) {
-            if (shared == null || shared.isCompletedExceptionally()) {
-                shared = MinecraftClientJar.open().thenApply(BlockTextures::load);
-            }
-            return shared;
-        }
-    }
-
-    private static BlockTextures load(ZipFile clientJar) {
-        try {
-            return new BlockTextures(clientJar, MinecraftBiomeColors.load(clientJar));
-        } catch (IOException error) {
-            throw new IllegalStateException("Could not read Minecraft's biome colour maps", error);
-        }
-    }
-
-    MinecraftBiomeColors biomeColors() {
-        return biomeColors;
-    }
-
-    /**
-     * What the block looks like from above. Plants and other side-on sprites become their average colour, because
-     * their sprite would read as stripes across a stack of ground blocks.
-     */
-    Optional<BlockTexture> topTexture(BlockData block) {
-        return resolve(block).map(resolved -> resolved.isSideOnSprite() ? resolved.texture().flattened() : resolved.texture());
-    }
-
-    /**
-     * Like {@link #topTexture}, but plants keep their sprite, so single decorations on the ground stay recognisable.
-     * Two block tall plants give their bottom half, the part standing on the ground.
-     */
-    Optional<BlockTexture> iconTexture(BlockData block) {
-        BlockData standing = block instanceof Bisected ? withHalf(block, Bisected.Half.BOTTOM) : block;
-        return resolve(standing).map(ResolvedTexture::texture);
-    }
-
-    /**
-     * The sprite of a two block tall plant's top half, or nothing for any other block.
-     */
-    Optional<BlockTexture> upperHalfIcon(BlockData block) {
-        if (!(block instanceof Bisected)) {
-            return Optional.empty();
-        }
-        return resolve(withHalf(block, Bisected.Half.TOP)).filter(ResolvedTexture::isSideOnSprite).map(ResolvedTexture::texture);
-    }
-
-    /**
-     * What the block looks like from every side, for drawing it in 3D.
-     */
-    Optional<BlockModel> model(BlockData block) {
-        return resolvedModels.computeIfAbsent(block.getAsString(false), modelBuilder::build);
-    }
-
-    private static BlockData withHalf(BlockData block, Bisected.Half half) {
-        BlockData copy = block.clone();
-        ((Bisected) copy).setHalf(half);
-        return copy;
-    }
-
-    // Blockstate files match on every property, so defaults the pack left out have to be spelled out too.
-    private Optional<ResolvedTexture> resolve(BlockData block) {
-        return resolvedTextures.computeIfAbsent(block.getAsString(false), this::resolveTopTexture);
-    }
-
-    private Optional<ResolvedTexture> resolveTopTexture(String blockState) {
-        try {
-            BlockStateId state = BlockStateId.parse(blockState);
-            JsonObject variant = variantOf(state);
-            if (variant == null || !variant.has("model")) {
-                return Optional.empty();
-            }
-            ModelFace face = readModel(variant.get("model").getAsString()).visibleFace(faceSeenFromAbove(variant));
-            if (face == null) {
-                return Optional.empty();
-            }
-            return readTexture(state, face).map(texture -> new ResolvedTexture(texture, face.isSideOnSprite()));
-        } catch (IOException | RuntimeException error) {
-            return Optional.empty();
-        }
-    }
-
-    private JsonObject variantOf(BlockStateId state) throws IOException {
-        JsonObject definition = readJson(assetPath(state.namespace() + ":" + state.name(), "blockstates", ".json"));
-        return definition == null ? null : pickVariant(definition, state.properties());
-    }
-
-    private static int rotationOf(JsonObject variant, String axis) {
-        return variant.has(axis) ? Math.floorMod(variant.get(axis).getAsInt(), 360) : 0;
-    }
-
-    /**
-     * One model face's texture with the block's tint, shared by every block state that uses it.
-     */
-    Optional<BlockTexture> faceTexture(BlockStateId state, String texture, int tintIndex) {
-        int fixedTint = MinecraftBlockTints.fixedTint(state.name(), state.properties(), tintIndex);
-        BiomeTint biomeTint = MinecraftBlockTints.biomeTint(state.name(), tintIndex).orElse(null);
-        return faceTextures.computeIfAbsent(texture + "|" + fixedTint + "|" + biomeTint, key -> {
-            try {
-                return readTexture(state, new ModelFace(List.of(texture), tintIndex, false));
-            } catch (IOException | RuntimeException error) {
-                return Optional.empty();
-            }
-        });
-    }
-
-    /**
-     * A texture drawn on a block entity, like a chest, whole and tinted with a fixed colour.
-     */
-    Optional<BlockTexture> entityTexture(String texture, int tint) {
-        return faceTextures.computeIfAbsent(texture + "|entity|" + tint, key -> {
-            try {
-                BufferedImage image = readImage(assetPath(texture, "textures", ".png"));
-                return image == null ? Optional.empty() : Optional.of(BlockTexture.fromWholeImage(image, tint));
-            } catch (IOException | RuntimeException error) {
-                return Optional.empty();
-            }
-        });
-    }
-
-    private Optional<BlockTexture> readTexture(BlockStateId state, ModelFace face) throws IOException {
-        BufferedImage image = readLayeredImage(face.textures());
-        if (image == null) {
-            return Optional.empty();
-        }
-        try {
-            return Optional.of(BlockTexture.fromImage(
-                    image,
-                    MinecraftBlockTints.fixedTint(state.name(), state.properties(), face.tintIndex()),
-                    MinecraftBlockTints.biomeTint(state.name(), face.tintIndex()).orElse(null)
-            ));
-        } catch (IllegalArgumentException invisibleTexture) {
-            return Optional.empty();
-        }
-    }
-
-    // A block rotated on its x axis, like a sideways log, shows a side face on top. Blockstates turn the model
-    // against the right-hand rule, so 90 degrees brings the south side up.
-    private static String faceSeenFromAbove(JsonObject variant) {
-        return switch (rotationOf(variant, "x")) {
-            case 90 -> "south";
-            case 270 -> "north";
-            case 180 -> "down";
-            default -> "up";
-        };
-    }
-
-    ModelDefinition readModel(String modelReference) throws IOException {
-        Map<String, String> textures = new HashMap<>();
-        JsonArray elements = null;
-        String current = modelReference;
-        for (int depth = 0; current != null && depth < MAX_MODEL_PARENTS; depth++) {
-            JsonObject model = readJson(assetPath(current, "models", ".json"));
-            if (model == null) {
-                break;
-            }
-            if (model.has("textures")) {
-                for (Map.Entry<String, JsonElement> texture : model.getAsJsonObject("textures").entrySet()) {
-                    textures.putIfAbsent(texture.getKey(), spriteName(texture.getValue()));
-                }
-            }
-            if (elements == null && model.has("elements")) {
-                elements = model.getAsJsonArray("elements");
-            }
-            current = model.has("parent") ? model.get("parent").getAsString() : null;
-        }
-        return new ModelDefinition(textures, elements);
-    }
-
-    // Since 1.21.? a texture can also be an object naming its sprite, like glass's {"sprite": ..., "force_translucent": true}.
-    private static String spriteName(JsonElement texture) {
-        return texture.isJsonObject() ? texture.getAsJsonObject().get("sprite").getAsString() : texture.getAsString();
-    }
-
-    // Some plants draw a second sprite over the first, like the glowing fireflies on a firefly bush.
-    private static List<String> spriteLayers(JsonArray elements, Map<String, String> textures) {
-        Set<String> layers = new LinkedHashSet<>();
-        for (JsonElement element : elements) {
-            JsonObject faces = element.getAsJsonObject().getAsJsonObject("faces");
-            if (faces == null) {
-                continue;
-            }
-            for (Map.Entry<String, JsonElement> face : faces.entrySet()) {
-                String texture = dereference(face.getValue().getAsJsonObject().get("texture").getAsString(), textures);
-                if (texture != null) {
-                    layers.add(texture);
-                }
-            }
-        }
-        return List.copyOf(layers);
-    }
-
-    private static int firstTintIndex(JsonArray elements) {
-        for (JsonElement element : elements) {
-            JsonObject faces = element.getAsJsonObject().getAsJsonObject("faces");
-            if (faces == null) {
-                continue;
-            }
-            for (Map.Entry<String, JsonElement> face : faces.entrySet()) {
-                int tintIndex = tintIndexOf(face.getValue().getAsJsonObject());
-                if (tintIndex != NO_TINT_INDEX) {
-                    return tintIndex;
-                }
-            }
-        }
-        return NO_TINT_INDEX;
-    }
-
-    static int tintIndexOf(JsonObject face) {
-        return face.has("tintindex") ? face.get("tintindex").getAsInt() : NO_TINT_INDEX;
-    }
-
-    private static JsonObject topmostFace(JsonArray elements, String faceName) {
-        JsonObject best = null;
-        double bestHeight = Double.NEGATIVE_INFINITY;
-        double bestArea = -1D;
-        for (JsonElement element : elements) {
-            JsonObject cuboid = element.getAsJsonObject();
-            JsonObject faces = cuboid.getAsJsonObject("faces");
-            if (faces == null || !faces.has(faceName)) {
-                continue;
-            }
-            JsonArray from = cuboid.getAsJsonArray("from");
-            JsonArray to = cuboid.getAsJsonArray("to");
-            double height = to.get(1).getAsDouble();
-            double area = (to.get(0).getAsDouble() - from.get(0).getAsDouble()) * (to.get(2).getAsDouble() - from.get(2).getAsDouble());
-            if (height > bestHeight || (height == bestHeight && area > bestArea)) {
-                best = faces.getAsJsonObject(faceName);
-                bestHeight = height;
-                bestArea = area;
-            }
-        }
-        return best;
-    }
-
-    static String dereference(String reference, Map<String, String> textures) {
-        String resolved = reference;
-        for (int hop = 0; resolved != null && resolved.startsWith("#") && hop < MAX_TEXTURE_REFERENCES; hop++) {
-            resolved = textures.get(resolved.substring(1));
-        }
-        return resolved == null || resolved.startsWith("#") ? null : resolved;
-    }
-
-    private static JsonObject pickVariant(JsonObject definition, Map<String, String> properties) {
-        if (definition.has("variants")) {
-            for (Map.Entry<String, JsonElement> variant : definition.getAsJsonObject("variants").entrySet()) {
-                if (variantMatches(variant.getKey(), properties)) {
-                    return firstModel(variant.getValue());
-                }
-            }
-            return null;
-        }
-        if (definition.has("multipart")) {
-            for (JsonElement part : definition.getAsJsonArray("multipart")) {
-                JsonObject rule = part.getAsJsonObject();
-                if (!rule.has("when") || conditionMatches(rule.getAsJsonObject("when"), properties)) {
-                    return firstModel(rule.get("apply"));
-                }
-            }
-        }
-        return null;
-    }
-
-    static boolean variantMatches(String variantKey, Map<String, String> properties) {
-        if (variantKey.isEmpty()) {
-            return true;
-        }
-        for (String condition : variantKey.split(",")) {
-            String[] pair = condition.split("=", 2);
-            if (pair.length != 2 || !pair[1].equals(properties.get(pair[0]))) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    static boolean conditionMatches(JsonObject condition, Map<String, String> properties) {
-        if (condition.has("OR")) {
-            for (JsonElement option : condition.getAsJsonArray("OR")) {
-                if (conditionMatches(option.getAsJsonObject(), properties)) {
-                    return true;
-                }
-            }
-            return false;
-        }
-        if (condition.has("AND")) {
-            for (JsonElement requirement : condition.getAsJsonArray("AND")) {
-                if (!conditionMatches(requirement.getAsJsonObject(), properties)) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        for (Map.Entry<String, JsonElement> requirement : condition.entrySet()) {
-            String actual = properties.get(requirement.getKey());
-            boolean anyAllowed = false;
-            for (String allowed : requirement.getValue().getAsString().split("\\|")) {
-                anyAllowed |= allowed.equals(actual);
-            }
-            if (!anyAllowed) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    static JsonObject firstModel(JsonElement models) {
-        if (models.isJsonArray()) {
-            JsonArray choices = models.getAsJsonArray();
-            return choices.isEmpty() ? null : choices.get(0).getAsJsonObject();
-        }
-        return models.getAsJsonObject();
-    }
-
-    static String assetPath(String resource, String folder, String extension) {
-        int separator = resource.indexOf(':');
-        String namespace = separator < 0 ? DEFAULT_NAMESPACE : resource.substring(0, separator);
-        String path = separator < 0 ? resource : resource.substring(separator + 1);
-        return "assets/" + namespace + "/" + folder + "/" + path + extension;
-    }
-
-    JsonObject readJson(String path) throws IOException {
-        return ClientJarFiles.readJson(clientJar, path);
-    }
-
-    // Each layer is drawn over the ones before it, using only its first frame when it is animated.
-    private BufferedImage readLayeredImage(List<String> layers) throws IOException {
-        BufferedImage bottom = readImage(assetPath(layers.get(0), "textures", ".png"));
-        if (bottom == null || layers.size() == 1) {
-            return bottom;
-        }
-        int size = bottom.getWidth();
-        BufferedImage combined = new BufferedImage(size, size, BufferedImage.TYPE_INT_ARGB);
-        Graphics2D canvas = combined.createGraphics();
-        try {
-            for (String layer : layers) {
-                BufferedImage image = readImage(assetPath(layer, "textures", ".png"));
-                if (image != null) {
-                    int frameSize = image.getWidth();
-                    canvas.drawImage(image, 0, 0, size, size, 0, 0, frameSize, frameSize, null);
-                }
-            }
-        } finally {
-            canvas.dispose();
-        }
-        return combined;
-    }
-
-    private BufferedImage readImage(String path) throws IOException {
-        return ClientJarFiles.readImage(clientJar, path);
-    }
-
-    // Plants and other blocks without a top face only have a side-on sprite, which would read as stripes from above.
-    private record ModelFace(List<String> textures, int tintIndex, boolean isSideOnSprite) {
-    }
-
-    /**
-     * A block model with its parents' textures merged in. Models drawn in code, like chests, have no elements.
-     */
-    record ModelDefinition(Map<String, String> textures, JsonArray elements) {
-        ModelFace visibleFace(String faceName) {
-            ModelFace face = sideFace(faceName);
-            if (face != null) {
-                return face;
-            }
-            return elements != null && !spriteLayers(elements, textures).isEmpty() ? spriteFace() : particleFace();
-        }
-
-        // The face's texture on the model's topmost box, the particle texture for models without boxes, or null when
-        // the model leaves that side open.
-        ModelFace sideFace(String faceName) {
-            if (elements == null) {
-                return particleFace();
-            }
-            JsonObject face = topmostFace(elements, faceName);
-            if (face == null) {
-                return null;
-            }
-            String texture = dereference(face.get("texture").getAsString(), textures);
-            return texture == null ? null : new ModelFace(List.of(texture), tintIndexOf(face), false);
-        }
-
-        ModelFace spriteFace() {
-            return new ModelFace(spriteLayers(elements, textures), firstTintIndex(elements), true);
-        }
-
-        private ModelFace particleFace() {
-            String particle = dereference("#particle", textures);
-            return particle == null ? null : new ModelFace(List.of(particle), NO_TINT_INDEX, false);
-        }
-
-    }
-
-    private record ResolvedTexture(BlockTexture texture, boolean isSideOnSprite) {
-    }
-
-    record BlockStateId(String namespace, String name, Map<String, String> properties) {
-        static BlockStateId parse(String blockState) {
-            int propertiesStart = blockState.indexOf('[');
-            String id = propertiesStart < 0 ? blockState : blockState.substring(0, propertiesStart);
-            int separator = id.indexOf(':');
-            String namespace = separator < 0 ? DEFAULT_NAMESPACE : id.substring(0, separator);
-            String name = separator < 0 ? id : id.substring(separator + 1);
-            Map<String, String> properties = new HashMap<>();
-            if (propertiesStart >= 0) {
-                String body = blockState.substring(propertiesStart + 1, blockState.length() - 1);
-                for (String pair : body.split(",")) {
-                    String[] keyValue = pair.split("=", 2);
-                    if (keyValue.length == 2) {
-                        properties.put(keyValue[0], keyValue[1]);
-                    }
-                }
-            }
-            return new BlockStateId(namespace, name, properties);
-        }
-    }
-
-    // Biome tinted textures keep their grey pixels, because the biome colour changes from column to column.
-    // See-through pixels get a darker shade of the average colour, and the opaque mask remembers which they were.
-    // Textures with partly see-through pixels, like stained glass, ice and water, keep each pixel's alpha too.
-    record BlockTexture(int width, int height, int[] pixels, boolean[] opaque, int[] alphas, int averageColor,
-                        BiomeTint biomeTint) {
-        private static final double GAP_SHADE = 0.55D;
-        private static final int FULL_ALPHA = 255;
-
-        // Animated textures stack their frames vertically, so only the first square frame is used.
-        static BlockTexture fromImage(BufferedImage image, int fixedTint, BiomeTint biomeTint) {
-            return fromPixels(image, image.getWidth(), Math.min(image.getWidth(), image.getHeight()), fixedTint, biomeTint);
-        }
-
-        // Entity textures, like a chest's, are laid out for a model and can be wider than they are tall.
-        static BlockTexture fromWholeImage(BufferedImage image, int fixedTint) {
-            return fromPixels(image, image.getWidth(), image.getHeight(), fixedTint, null);
-        }
-
-        static BlockTexture solid(int color) {
-            return new BlockTexture(1, 1, new int[]{color}, new boolean[]{true}, null, color, null);
-        }
-
-        private static BlockTexture fromPixels(BufferedImage image, int width, int height, int fixedTint, BiomeTint biomeTint) {
-            int[] pixels = new int[width * height];
-            boolean[] opaque = new boolean[pixels.length];
-            int[] alphas = new int[pixels.length];
-            boolean translucent = false;
-            long red = 0;
-            long green = 0;
-            long blue = 0;
-            int opaqueCount = 0;
-            for (int y = 0; y < height; y++) {
-                for (int x = 0; x < width; x++) {
-                    int argb = image.getRGB(x, y);
-                    int index = y * width + x;
-                    int alpha = argb >>> 24;
-                    alphas[index] = alpha;
-                    if (alpha == 0) {
-                        continue;
-                    }
-                    translucent |= alpha < FULL_ALPHA;
-                    int color = multiply(argb & 0xFFFFFF, fixedTint);
-                    pixels[index] = color;
-                    opaque[index] = true;
-                    red += (color >>> 16) & 0xFF;
-                    green += (color >>> 8) & 0xFF;
-                    blue += color & 0xFF;
-                    opaqueCount++;
-                }
-            }
-            if (opaqueCount == 0) {
-                throw new IllegalArgumentException("Texture has no visible pixels");
-            }
-            int average = (int) (red / opaqueCount) << 16 | (int) (green / opaqueCount) << 8 | (int) (blue / opaqueCount);
-            int gapColor = BlockPreviewColors.shade(average, GAP_SHADE);
-            for (int index = 0; index < pixels.length; index++) {
-                if (!opaque[index]) {
-                    pixels[index] = gapColor;
-                }
-            }
-            return new BlockTexture(width, height, pixels, opaque, translucent ? alphas : null, average, biomeTint);
-        }
-
-        boolean isTranslucent() {
-            return alphas != null;
-        }
-
-        boolean isFullyOpaque() {
-            if (isTranslucent()) {
-                return false;
-            }
-            for (boolean pixelOpaque : opaque) {
-                if (!pixelOpaque) {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        BlockTexture flattened() {
-            int[] flat = new int[pixels.length];
-            Arrays.fill(flat, averageColor);
-            boolean[] allOpaque = new boolean[pixels.length];
-            Arrays.fill(allOpaque, true);
-            return new BlockTexture(width, height, flat, allOpaque, null, averageColor, biomeTint);
-        }
-
-        BlockTexture tinted(int tint) {
-            int[] tintedPixels = new int[pixels.length];
-            for (int index = 0; index < pixels.length; index++) {
-                tintedPixels[index] = multiply(pixels[index], tint);
-            }
-            return new BlockTexture(width, height, tintedPixels, opaque, alphas, multiply(averageColor, tint), null);
-        }
-
-        int texelAt(double worldX, double worldZ) {
-            return pixels[texelIndex(worldX, worldZ)];
-        }
-
-        boolean isOpaqueAt(double worldX, double worldZ) {
-            return opaque[texelIndex(worldX, worldZ)];
-        }
-
-        private int texelIndex(double worldX, double worldZ) {
-            int x = Math.min(width - 1, (int) ((worldX - Math.floor(worldX)) * width));
-            int z = Math.min(height - 1, (int) ((worldZ - Math.floor(worldZ)) * height));
-            return z * width + x;
-        }
-
-        BufferedImage toImage() {
-            BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
-            image.setRGB(0, 0, width, height, pixels, 0, width);
-            return image;
-        }
-
-        // The GPU multiplies the texture by the tint in floating point and rounds back to 8 bits per channel.
-        static int multiply(int color, int tint) {
-            return multiplyChannel(color, tint, 16) << 16 | multiplyChannel(color, tint, 8) << 8 | multiplyChannel(color, tint, 0);
-        }
-
-        private static int multiplyChannel(int color, int tint, int shift) {
-            return (((color >>> shift) & 0xFF) * ((tint >>> shift) & 0xFF) + 127) / 255;
-        }
-    }
-}
@@ -1,82 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-
-package com.volmit.iris.core.gui;
-
-import com.google.gson.JsonObject;
-import com.google.gson.JsonParser;
-
-import javax.imageio.ImageIO;
-import java.awt.color.ColorSpace;
-import java.awt.image.BufferedImage;
-import java.awt.image.Raster;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.nio.charset.StandardCharsets;
-import java.util.zip.ZipEntry;
-import java.util.zip.ZipFile;
-
-final class ClientJarFiles {
-    private ClientJarFiles() {
-    }
-
-    static JsonObject readJson(ZipFile clientJar, String path) throws IOException {
-        ZipEntry entry = clientJar.getEntry(path);
-        if (entry == null) {
-            return null;
-        }
-        try (InputStreamReader reader = new InputStreamReader(clientJar.getInputStream(entry), StandardCharsets.UTF_8)) {
-            return JsonParser.parseReader(reader).getAsJsonObject();
-        }
-    }
-
-    static BufferedImage readImage(ZipFile clientJar, String path) throws IOException {
-        ZipEntry entry = clientJar.getEntry(path);
-        if (entry == null) {
-            return null;
-        }
-        try (InputStream input = clientJar.getInputStream(entry)) {
-            BufferedImage image = ImageIO.read(input);
-            return image != null && isGrey(image) ? withGreyKept(image) : image;
-        }
-    }
-
-    private static boolean isGrey(BufferedImage image) {
-        return image.getColorModel().getColorSpace().getType() == ColorSpace.TYPE_GRAY;
-    }
-
-    // Java treats grey PNGs, like stone's, as linear light and brightens them when converting to RGB; Minecraft reads
-    // the stored values as they are.
-    private static BufferedImage withGreyKept(BufferedImage image) {
-        Raster raster = image.getRaster();
-        boolean hasAlpha = raster.getNumBands() > 1;
-        int greyMax = (1 << raster.getSampleModel().getSampleSize(0)) - 1;
-        int alphaMax = hasAlpha ? (1 << raster.getSampleModel().getSampleSize(1)) - 1 : 1;
-        BufferedImage converted = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_ARGB);
-        for (int y = 0; y < image.getHeight(); y++) {
-            for (int x = 0; x < image.getWidth(); x++) {
-                int grey = raster.getSample(x, y, 0) * 255 / greyMax;
-                int alpha = hasAlpha ? raster.getSample(x, y, 1) * 255 / alphaMax : 255;
-                converted.setRGB(x, y, alpha << 24 | grey << 16 | grey << 8 | grey);
-            }
-        }
-        return converted;
-    }
-}
@@ -1,114 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-
-package com.volmit.iris.core.gui;
-
-/**
- * The six sides of a block, named as in Minecraft's model files, with the light Minecraft gives each side.
- */
-enum CubeFace {
-    UP("up", 0, 1, 0, 1.0D),
-    DOWN("down", 0, -1, 0, 0.5D),
-    NORTH("north", 0, 0, -1, 0.8D),
-    SOUTH("south", 0, 0, 1, 0.8D),
-    EAST("east", 1, 0, 0, 0.6D),
-    WEST("west", -1, 0, 0, 0.6D);
-
-    private final String modelName;
-    private final int stepX;
-    private final int stepY;
-    private final int stepZ;
-    private final double shade;
-
-    CubeFace(String modelName, int stepX, int stepY, int stepZ, double shade) {
-        this.modelName = modelName;
-        this.stepX = stepX;
-        this.stepY = stepY;
-        this.stepZ = stepZ;
-        this.shade = shade;
-    }
-
-    static CubeFace named(String modelName) {
-        for (CubeFace face : values()) {
-            if (face.modelName.equals(modelName)) {
-                return face;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * The side a direction points at most, like Minecraft picks for a tilted face.
-     */
-    static CubeFace nearest(Vec3 direction) {
-        CubeFace nearest = UP;
-        double best = Double.NEGATIVE_INFINITY;
-        for (CubeFace face : values()) {
-            double alignment = face.stepX * direction.x() + face.stepY * direction.y() + face.stepZ * direction.z();
-            if (alignment > best) {
-                best = alignment;
-                nearest = face;
-            }
-        }
-        return nearest;
-    }
-
-    String modelName() {
-        return modelName;
-    }
-
-    int stepX() {
-        return stepX;
-    }
-
-    int stepY() {
-        return stepY;
-    }
-
-    int stepZ() {
-        return stepZ;
-    }
-
-    double shade() {
-        return shade;
-    }
-
-    Vec3 direction() {
-        return new Vec3(stepX, stepY, stepZ);
-    }
-
-    CubeFace opposite() {
-        return switch (this) {
-            case UP -> DOWN;
-            case DOWN -> UP;
-            case NORTH -> SOUTH;
-            case SOUTH -> NORTH;
-            case EAST -> WEST;
-            case WEST -> EAST;
-        };
-    }
-
-    int axis() {
-        return stepX != 0 ? 0 : stepY != 0 ? 1 : 2;
-    }
-
-    boolean pointsPositive() {
-        return stepX + stepY + stepZ > 0;
-    }
-}
@@ -1,298 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.core.gui.BlockModel.Face;
-import com.volmit.iris.core.gui.BlockModel.TextureMapping;
-import com.volmit.iris.core.gui.BlockTextures.BlockStateId;
-import com.volmit.iris.core.gui.BlockTextures.BlockTexture;
-import com.volmit.iris.core.gui.BlockTextures.ModelDefinition;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-
-/**
- * Shapes for the blocks Minecraft draws in code instead of from a model file, like chests, heads, banners and
- * fluids, which fill their block. Chests, heads, banners and the bell use their entity textures laid out the way Minecraft's model parts are;
- * rarer ones are a simple box in their particle texture.
- */
-final class EntityBlockShapes {
-    private static final Set<String> INVISIBLE = Set.of("air", "cave_air", "void_air", "barrier", "light",
-            "structure_void", "moving_piston", "pitcher_crop");
-    private static final int END_PORTAL_COLOR = 0x0E1219;
-    private static final double SKULL_WALL_OFFSET = 0.25D;
-    private static final double ROTATION_SEGMENT_DEGREES = 22.5D;
-    private static final double BANNER_SCALE = 2D / 3D;
-    private static final double MODEL_UNITS = 16D;
-    private static final Map<String, Integer> DYE_COLORS = Map.ofEntries(
-            Map.entry("white", 0xF9FFFE), Map.entry("orange", 0xF9801D), Map.entry("magenta", 0xC74EBD),
-            Map.entry("light_blue", 0x3AB3DA), Map.entry("yellow", 0xFED83D), Map.entry("lime", 0x80C71F),
-            Map.entry("pink", 0xF38BAA), Map.entry("gray", 0x474F52), Map.entry("light_gray", 0x9D9D97),
-            Map.entry("cyan", 0x169C9C), Map.entry("purple", 0x8932B8), Map.entry("blue", 0x3C44AA),
-            Map.entry("brown", 0x835432), Map.entry("green", 0x5E7C16), Map.entry("red", 0xB02E26),
-            Map.entry("black", 0x1D1D21));
-
-    private final BlockTextures textures;
-
-    EntityBlockShapes(BlockTextures textures) {
-        this.textures = textures;
-    }
-
-    /**
-     * The faces of a block whose model has no boxes of its own.
-     */
-    List<Face> facesOf(BlockStateId state, ModelDefinition model) {
-        String name = state.name();
-        if (INVISIBLE.contains(name)) {
-            return List.of();
-        }
-        if (name.endsWith("chest")) {
-            return chest(state);
-        }
-        if (name.endsWith("_skull") || name.endsWith("_head")) {
-            return head(state, model);
-        }
-        if (name.endsWith("banner")) {
-            return banner(state);
-        }
-        return switch (name) {
-            case "conduit" -> particleBox(state, model, new Vec3(5, 5, 5), new Vec3(11, 11, 11), false);
-            case "decorated_pot" -> decoratedPot(state, model);
-            case "end_portal" -> BlockModelBuilder.box(new Vec3(0, 0, 0), new Vec3(16, 12, 16), BlockTexture.solid(END_PORTAL_COLOR), true);
-            case "end_gateway" -> BlockModelBuilder.box(new Vec3(0, 0, 0), new Vec3(16, 16, 16), BlockTexture.solid(END_PORTAL_COLOR), true);
-            default -> name.endsWith("copper_golem_statue")
-                    ? particleBox(state, model, new Vec3(4, 0, 4), new Vec3(12, 14, 12), false)
-                    : particleBox(state, model, new Vec3(0, 0, 0), new Vec3(16, 16, 16), true);
-        };
-    }
-
-    /**
-     * Parts a block draws in code on top of its model, like the bell hanging in its frame.
-     */
-    List<Face> facesAddedTo(BlockStateId state) {
-        if (!state.name().equals("bell")) {
-            return List.of();
-        }
-        Optional<BlockTexture> texture = textures.entityTexture("entity/bell/bell_body", MinecraftBlockTints.NO_TINT);
-        if (texture.isEmpty()) {
-            return List.of();
-        }
-        List<Face> faces = new ArrayList<>();
-        faces.addAll(modelPartBox(texture.get(), 0, 0, new Vec3(5, 6, 5), new Vec3(6, 7, 6), Transform.IDENTITY));
-        faces.addAll(modelPartBox(texture.get(), 0, 13, new Vec3(4, 4, 4), new Vec3(8, 2, 8), Transform.IDENTITY));
-        return faces;
-    }
-
-    private List<Face> particleBox(BlockStateId state, ModelDefinition model, Vec3 from, Vec3 to, boolean culledBySides) {
-        String particle = BlockTextures.dereference("#particle", model.textures());
-        if (particle == null) {
-            return List.of();
-        }
-        return textures.faceTexture(state, particle, BlockTextures.NO_TINT_INDEX)
-                .map(texture -> BlockModelBuilder.box(from, to, texture, culledBySides))
-                .orElse(List.of());
-    }
-
-    private List<Face> decoratedPot(BlockStateId state, ModelDefinition model) {
-        List<Face> faces = new ArrayList<>(particleBox(state, model, new Vec3(1, 0, 1), new Vec3(15, 16, 15), false));
-        faces.addAll(particleBox(state, model, new Vec3(4, 16, 4), new Vec3(12, 20, 12), false));
-        return faces;
-    }
-
-    // Single chests are 14 pixels wide; each half of a double chest is 15, reaching over to its partner.
-    private List<Face> chest(BlockStateId state) {
-        String type = state.properties().getOrDefault("type", "single");
-        String suffix = type.equals("single") ? "" : "_" + type;
-        Optional<BlockTexture> texture = textures.entityTexture("entity/chest/" + chestTextureName(state.name()) + suffix, MinecraftBlockTints.NO_TINT);
-        if (texture.isEmpty()) {
-            return List.of();
-        }
-        Transform place = Transform.IDENTITY
-                .translate(0.5D, 0.5D, 0.5D)
-                .rotateY(-yRotationOf(state.properties().getOrDefault("facing", "north")))
-                .translate(-0.5D, -0.5D, -0.5D);
-        double left = type.equals("left") ? 0D : 1D;
-        double width = type.equals("single") ? 14D : 15D;
-        double lockX = switch (type) {
-            case "left" -> 0D;
-            case "right" -> 15D;
-            default -> 7D;
-        };
-        double lockWidth = type.equals("single") ? 2D : 1D;
-        List<Face> faces = new ArrayList<>();
-        faces.addAll(modelPartBox(texture.get(), 0, 19, new Vec3(left, 0, 1), new Vec3(width, 10, 14), place));
-        faces.addAll(modelPartBox(texture.get(), 0, 0, new Vec3(left, 9, 1), new Vec3(width, 5, 14), place));
-        faces.addAll(modelPartBox(texture.get(), 0, 0, new Vec3(lockX, 7, 15), new Vec3(lockWidth, 4, 1), place));
-        return faces;
-    }
-
-    private static String chestTextureName(String blockName) {
-        String name = blockName.startsWith("waxed_") ? blockName.substring("waxed_".length()) : blockName;
-        return switch (name) {
-            case "trapped_chest" -> "trapped";
-            case "ender_chest" -> "ender";
-            case "copper_chest" -> "copper";
-            case "exposed_copper_chest" -> "copper_exposed";
-            case "weathered_copper_chest" -> "copper_weathered";
-            case "oxidized_copper_chest" -> "copper_oxidized";
-            default -> "normal";
-        };
-    }
-
-    // Heads are drawn upside down and mirrored in their model, and turn in sixteenths like signs.
-    private List<Face> head(BlockStateId state, ModelDefinition model) {
-        boolean onWall = state.name().contains("_wall_");
-        String kind = state.name().replace("_wall_", "_");
-        Optional<HeadLook> look = HeadLook.of(kind);
-        Optional<BlockTexture> texture = look.flatMap(found -> textures.entityTexture(found.texture(), MinecraftBlockTints.NO_TINT));
-        if (texture.isEmpty()) {
-            return onWall
-                    ? particleBox(state, model, new Vec3(4, 4, 8), new Vec3(12, 12, 16), false)
-                    : particleBox(state, model, new Vec3(4, 0, 4), new Vec3(12, 8, 12), false);
-        }
-        Transform place;
-        if (onWall) {
-            CubeFace facing = CubeFace.named(state.properties().getOrDefault("facing", "north"));
-            place = Transform.IDENTITY
-                    .translate(0.5D - facing.stepX() * SKULL_WALL_OFFSET, SKULL_WALL_OFFSET, 0.5D - facing.stepZ() * SKULL_WALL_OFFSET)
-                    .scale(-1D, -1D, 1D)
-                    .rotateY(yRotationOf(facing.opposite().modelName()));
-        } else {
-            int rotation = Integer.parseInt(state.properties().getOrDefault("rotation", "0"));
-            place = Transform.IDENTITY
-                    .translate(0.5D, 0D, 0.5D)
-                    .scale(-1D, -1D, 1D)
-                    .rotateY(rotation * ROTATION_SEGMENT_DEGREES);
-        }
-        HeadLook found = look.get();
-        return modelPartBox(texture.get(), 0, 0, new Vec3(-found.width() / 2D, -8, -4), new Vec3(found.width(), 8, 8), place);
-    }
-
-    private List<Face> banner(BlockStateId state) {
-        boolean onWall = state.name().endsWith("_wall_banner");
-        String color = state.name().substring(0, state.name().length() - (onWall ? "_wall_banner" : "_banner").length());
-        Optional<BlockTexture> frame = textures.entityTexture("entity/banner/banner_base", MinecraftBlockTints.NO_TINT);
-        Optional<BlockTexture> cloth = textures.entityTexture("entity/banner/base", DYE_COLORS.getOrDefault(color, MinecraftBlockTints.NO_TINT));
-        if (frame.isEmpty() || cloth.isEmpty()) {
-            return List.of();
-        }
-        Transform place;
-        if (onWall) {
-            CubeFace facing = CubeFace.named(state.properties().getOrDefault("facing", "north"));
-            place = Transform.IDENTITY
-                    .translate(0.5D, -1D / 6D, 0.5D)
-                    .rotateY(-yRotationOf(facing.modelName()))
-                    .translate(0D, -0.3125D, -0.4375D)
-                    .scale(BANNER_SCALE, -BANNER_SCALE, -BANNER_SCALE);
-        } else {
-            int rotation = Integer.parseInt(state.properties().getOrDefault("rotation", "0"));
-            place = Transform.IDENTITY
-                    .translate(0.5D, 0.5D, 0.5D)
-                    .rotateY(-rotation * ROTATION_SEGMENT_DEGREES)
-                    .scale(BANNER_SCALE, -BANNER_SCALE, -BANNER_SCALE);
-        }
-        List<Face> faces = new ArrayList<>();
-        if (!onWall) {
-            faces.addAll(modelPartBox(frame.get(), 44, 0, new Vec3(-1, -30, -1), new Vec3(2, 42, 2), place));
-        }
-        faces.addAll(modelPartBox(frame.get(), 0, 42, new Vec3(-10, -32, -1), new Vec3(20, 2, 2), place));
-        faces.addAll(modelPartBox(cloth.get(), 0, 0, new Vec3(-10, -32, -2), new Vec3(20, 40, 1), place));
-        return faces;
-    }
-
-    // Minecraft's facing angle: south is 0 and each quarter turn clockwise seen from above adds 90 degrees.
-    private static double yRotationOf(String facing) {
-        return switch (facing) {
-            case "west" -> 90D;
-            case "north" -> 180D;
-            case "east" -> 270D;
-            default -> 0D;
-        };
-    }
-
-    /**
-     * A box of a block entity's model, in model pixels, with its sides laid out on the texture the way Minecraft's
-     * model parts are: the top and bottom in a row above the four sides.
-     */
-    static List<Face> modelPartBox(BlockTexture texture, int textureU, int textureV, Vec3 from, Vec3 size, Transform place) {
-        double minX = from.x() / MODEL_UNITS;
-        double minY = from.y() / MODEL_UNITS;
-        double minZ = from.z() / MODEL_UNITS;
-        double maxX = (from.x() + size.x()) / MODEL_UNITS;
-        double maxY = (from.y() + size.y()) / MODEL_UNITS;
-        double maxZ = (from.z() + size.z()) / MODEL_UNITS;
-        Vec3 v0 = new Vec3(minX, minY, minZ);
-        Vec3 v1 = new Vec3(maxX, minY, minZ);
-        Vec3 v2 = new Vec3(maxX, maxY, minZ);
-        Vec3 v3 = new Vec3(minX, maxY, minZ);
-        Vec3 v4 = new Vec3(minX, minY, maxZ);
-        Vec3 v5 = new Vec3(maxX, minY, maxZ);
-        Vec3 v6 = new Vec3(maxX, maxY, maxZ);
-        Vec3 v7 = new Vec3(minX, maxY, maxZ);
-        double u = textureU;
-        double v = textureV;
-        double width = size.x();
-        double height = size.y();
-        double depth = size.z();
-        List<Face> faces = new ArrayList<>(6);
-        faces.add(polygon(texture, place, CubeFace.DOWN, v5, v4, v0, u + depth, v, u + depth + width, v + depth));
-        faces.add(polygon(texture, place, CubeFace.UP, v2, v3, v7, u + depth + width, v + depth, u + depth + width + width, v));
-        faces.add(polygon(texture, place, CubeFace.WEST, v0, v4, v7, u, v + depth, u + depth, v + depth + height));
-        faces.add(polygon(texture, place, CubeFace.NORTH, v1, v0, v3, u + depth, v + depth, u + depth + width, v + depth + height));
-        faces.add(polygon(texture, place, CubeFace.EAST, v5, v1, v2, u + depth + width, v + depth, u + depth + width + depth, v + depth + height));
-        faces.add(polygon(texture, place, CubeFace.SOUTH, v4, v5, v6, u + depth + width + depth, v + depth, u + depth + width + depth + width, v + depth + height));
-        return faces;
-    }
-
-    // A model part's polygon gives its first corner (u2, v1), its second (u1, v1) and its third (u1, v2).
-    private static Face polygon(BlockTexture texture, Transform place, CubeFace side, Vec3 first, Vec3 second, Vec3 third,
-                                double u1, double v1, double u2, double v2) {
-        double textureWidth = texture.width();
-        double textureHeight = texture.height();
-        TextureMapping mapping = new TextureMapping(u1 / textureWidth, v1 / textureHeight,
-                (u2 - u1) / textureWidth, 0D, 0D, (v2 - v1) / textureHeight);
-        Face face = new Face(second, first.minus(second), third.minus(second), side.direction(), texture, mapping, side.shade(), null)
-                .transformed(place);
-        return face.withShade(CubeFace.nearest(face.normal()).shade());
-    }
-
-    /**
-     * The entity texture of a mob head and how wide its head is.
-     */
-    private record HeadLook(String texture, double width) {
-        private static final double HEAD_WIDTH = 8D;
-        private static final double PIGLIN_HEAD_WIDTH = 10D;
-
-        static Optional<HeadLook> of(String kind) {
-            return Optional.ofNullable(switch (kind) {
-                case "skeleton_skull" -> new HeadLook("entity/skeleton/skeleton", HEAD_WIDTH);
-                case "wither_skeleton_skull" -> new HeadLook("entity/skeleton/wither_skeleton", HEAD_WIDTH);
-                case "zombie_head" -> new HeadLook("entity/zombie/zombie", HEAD_WIDTH);
-                case "creeper_head" -> new HeadLook("entity/creeper/creeper", HEAD_WIDTH);
-                case "player_head" -> new HeadLook("entity/player/wide/steve", HEAD_WIDTH);
-                case "piglin_head" -> new HeadLook("entity/piglin/piglin", PIGLIN_HEAD_WIDTH);
-                default -> null;
-            });
-        }
-    }
-}
@@ -1,224 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.events.IrisEngineHotloadEvent;
-import com.volmit.iris.core.project.IrisProject;
-import com.volmit.iris.core.service.PreservationSVC;
-import com.volmit.iris.core.service.StudioSVC;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.platform.PlatformChunkGenerator;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-
-import javax.swing.JFrame;
-import java.awt.Desktop;
-import java.awt.Dimension;
-import java.awt.EventQueue;
-import java.awt.GraphicsEnvironment;
-import java.awt.Rectangle;
-import java.awt.desktop.QuitResponse;
-import java.awt.image.BufferedImage;
-import java.awt.event.WindowAdapter;
-import java.awt.event.WindowEvent;
-import java.util.ArrayList;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-public final class GuiHost {
-    private static final AtomicBoolean DESKTOP_QUIT_GUARD_INSTALLED = new AtomicBoolean(false);
-    private static final Set<JFrame> MANAGED_FRAMES = ConcurrentHashMap.newKeySet();
-    private static final Map<Runnable, Listener> HOTLOAD_HOOKS = new ConcurrentHashMap<>();
-
-    private GuiHost() {
-    }
-
-    public static boolean isAvailable() {
-        return !GraphicsEnvironment.isHeadless();
-    }
-
-    public static JFrame createFrame(String title) {
-        XwaylandWindowManagerHint.apply();
-        StudioTheme.install();
-        JFrame frame = new JFrame(title);
-        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
-        MANAGED_FRAMES.add(frame);
-        frame.addWindowListener(new WindowAdapter() {
-            @Override
-            public void windowClosed(WindowEvent event) {
-                MANAGED_FRAMES.remove(frame);
-            }
-
-            @Override
-            public void windowActivated(WindowEvent event) {
-                StudioTheme.followSystem();
-            }
-        });
-        installMacQuitGuard();
-        return frame;
-    }
-
-    /**
-     * Wraps rendered pixels in an image Java2D draws straight from memory. Left to itself Java2D copies every image it
-     * draws into a texture inside the display server; with a map's hundreds of tiles that crashed Xwayland's Intel driver
-     * and took every X window on the desktop down with it.
-     */
-    public static BufferedImage uncachedImage(int[] pixels, int width, int height) {
-        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
-        image.getRaster().setDataElements(0, 0, width, height, pixels);
-        image.setAccelerationPriority(0F);
-        return image;
-    }
-
-    // A scaled-up default size can be bigger than a small or low resolution screen.
-    static Dimension fitToScreen(Dimension preferred) {
-        Rectangle usable = GraphicsEnvironment.getLocalGraphicsEnvironment().getMaximumWindowBounds();
-        return new Dimension(Math.min(preferred.width, usable.width), Math.min(preferred.height, usable.height));
-    }
-
-    /**
-     * The engine of the open studio project, which reads the pack folder you edit, or else the first Iris world.
-     * A normal Iris world runs on its own copy of the pack, made when the world was created.
-     */
-    public static Engine findActiveEngine() {
-        Engine studioEngine = findStudioEngine();
-        if (studioEngine != null) {
-            return studioEngine;
-        }
-        try {
-            for (World world : new ArrayList<>(Bukkit.getWorlds())) {
-                Engine engine = engineOf(world);
-                if (engine != null) {
-                    return engine;
-                }
-            }
-        } catch (Throwable ignored) {
-        }
-        return null;
-    }
-
-    private static Engine findStudioEngine() {
-        try {
-            StudioSVC studio = Iris.service(StudioSVC.class);
-            IrisProject project = studio == null || !studio.isProjectOpen() ? null : studio.getActiveProject();
-            PlatformChunkGenerator provider = project == null ? null : project.getActiveProvider();
-            Engine engine = provider == null ? null : provider.getEngine();
-            return engine == null || engine.isClosed() ? null : engine;
-        } catch (Throwable ignored) {
-            return null;
-        }
-    }
-
-    public static Engine findEngine(UUID worldId) {
-        World world = Bukkit.getWorld(worldId);
-        return world == null ? null : engineOf(world);
-    }
-
-    public static void registerHotloadHook(Runnable onHotload) {
-        Listener listener = new HotloadListener(onHotload);
-        HOTLOAD_HOOKS.put(onHotload, listener);
-        Iris.instance.registerListener(listener);
-    }
-
-    public static void unregisterHotloadHook(Runnable onHotload) {
-        Listener listener = HOTLOAD_HOOKS.remove(onHotload);
-        if (listener != null) {
-            Iris.instance.unregisterListener(listener);
-        }
-    }
-
-    static void interruptOnPluginShutdown(ExecutorService executor) {
-        PreservationSVC preservation = Iris.service(PreservationSVC.class);
-        if (preservation != null) {
-            preservation.register(executor);
-        }
-    }
-
-    static void interruptOnPluginShutdown(Thread thread) {
-        PreservationSVC preservation = Iris.service(PreservationSVC.class);
-        if (preservation != null) {
-            preservation.register(thread);
-        }
-    }
-
-    private static Engine engineOf(World world) {
-        try {
-            PlatformChunkGenerator access = IrisToolbelt.access(world);
-            if (access != null && access.getEngine() != null && !access.getEngine().isClosed()) {
-                return access.getEngine();
-            }
-        } catch (Throwable ignored) {
-        }
-        return null;
-    }
-
-    // macOS Quit in the dock menu would otherwise stop the whole server.
-    private static void installMacQuitGuard() {
-        if (!isAvailable()
-                || !System.getProperty("os.name", "").toLowerCase(Locale.ROOT).contains("mac")
-                || !DESKTOP_QUIT_GUARD_INSTALLED.compareAndSet(false, true)) {
-            return;
-        }
-
-        try {
-            if (!Desktop.isDesktopSupported()) {
-                return;
-            }
-            Desktop desktop = Desktop.getDesktop();
-            if (!desktop.isSupported(Desktop.Action.APP_QUIT_HANDLER)) {
-                return;
-            }
-            desktop.setQuitHandler((event, response) -> closeWindowsAndCancelQuit(response));
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            Iris.info("Unable to install the Iris desktop quit guard; use the server stop command instead of macOS Quit");
-        }
-    }
-
-    private static void closeWindowsAndCancelQuit(QuitResponse response) {
-        response.cancelQuit();
-        EventQueue.invokeLater(() -> {
-            for (JFrame frame : MANAGED_FRAMES) {
-                frame.dispose();
-            }
-        });
-    }
-
-    private static final class HotloadListener implements Listener {
-        private final Runnable onHotload;
-
-        private HotloadListener(Runnable onHotload) {
-            this.onHotload = onHotload;
-        }
-
-        @EventHandler
-        public void on(IrisEngineHotloadEvent event) {
-            onHotload.run();
-        }
-    }
-}
@@ -1,105 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-
-package com.volmit.iris.core.gui;
-
-import javax.swing.JComponent;
-import javax.swing.JLayeredPane;
-import java.awt.Cursor;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
-
-/**
- * Lays an island over content that fills the whole area behind it. Dragging the island's right edge resizes it,
- * always leaving the content some room beside it.
- */
-final class IslandOverlay extends JLayeredPane {
-    private static final long serialVersionUID = -4182209135360718342L;
-
-    private final IslandPanel island;
-    private final JComponent background;
-    private final int minimumIslandWidth;
-    private final int minimumUncoveredWidth;
-    private int islandWidth;
-
-    IslandOverlay(IslandPanel island, JComponent background, int islandWidth, int minimumIslandWidth, int minimumUncoveredWidth) {
-        this.island = island;
-        this.background = background;
-        this.islandWidth = islandWidth;
-        this.minimumIslandWidth = minimumIslandWidth;
-        this.minimumUncoveredWidth = minimumUncoveredWidth;
-        add(background, JLayeredPane.DEFAULT_LAYER);
-        add(island, JLayeredPane.PALETTE_LAYER);
-        installResizing();
-    }
-
-    @Override
-    public void doLayout() {
-        background.setBounds(0, 0, getWidth(), getHeight());
-        island.setBounds(0, 0, clampedIslandWidth(), getHeight());
-    }
-
-    private int clampedIslandWidth() {
-        int widest = Math.max(minimumIslandWidth, getWidth() - minimumUncoveredWidth);
-        return Math.clamp(islandWidth, minimumIslandWidth, widest);
-    }
-
-    private void installResizing() {
-        MouseAdapter resizer = new MouseAdapter() {
-            private boolean dragging;
-
-            @Override
-            public void mouseMoved(MouseEvent event) {
-                island.setCursor(island.isOnResizeEdge(event.getX(), event.getY())
-                        ? Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR)
-                        : Cursor.getDefaultCursor());
-            }
-
-            @Override
-            public void mouseExited(MouseEvent event) {
-                if (!dragging) {
-                    island.setCursor(Cursor.getDefaultCursor());
-                }
-            }
-
-            @Override
-            public void mousePressed(MouseEvent event) {
-                dragging = island.isOnResizeEdge(event.getX(), event.getY());
-            }
-
-            @Override
-            public void mouseDragged(MouseEvent event) {
-                if (!dragging) {
-                    return;
-                }
-                islandWidth = event.getX();
-                islandWidth = clampedIslandWidth();
-                revalidate();
-                repaint();
-            }
-
-            @Override
-            public void mouseReleased(MouseEvent event) {
-                dragging = false;
-            }
-        };
-        island.addMouseListener(resizer);
-        island.addMouseMotionListener(resizer);
-    }
-}
@@ -1,77 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-
-package com.volmit.iris.core.gui;
-
-import javax.swing.JComponent;
-import javax.swing.JPanel;
-import java.awt.BorderLayout;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
-import java.awt.RenderingHints;
-import java.awt.geom.RoundRectangle2D;
-
-/**
- * A rounded panel floating over the window content with a gap all around it, like the tool windows of IntelliJ's
- * islands theme. The gap belongs to the content behind it, except for the strip along the right edge, which grabs the
- * island to resize it.
- */
-final class IslandPanel extends JPanel {
-    private static final long serialVersionUID = 7313084027614358519L;
-    private static final int GAP = 6;
-    private static final int CORNER_ARC = 12;
-    private static final int INNER_PADDING = 4;
-
-    IslandPanel(JComponent content) {
-        super(new BorderLayout());
-        setOpaque(false);
-        int inset = GAP + INNER_PADDING;
-        setBorder(StudioTheme.emptyBorder(inset, inset, inset, inset));
-        add(content, BorderLayout.CENTER);
-    }
-
-    boolean isOnResizeEdge(int x, int y) {
-        int edgeWidth = StudioTheme.scale(GAP + INNER_PADDING);
-        return x >= getWidth() - edgeWidth && x < getWidth() && y >= 0 && y < getHeight();
-    }
-
-    // Clicks in the gap reach the content behind the island instead of the island itself.
-    @Override
-    public boolean contains(int x, int y) {
-        return island().contains(x, y) || isOnResizeEdge(x, y);
-    }
-
-    @Override
-    protected void paintComponent(Graphics graphics) {
-        Graphics2D canvas = (Graphics2D) graphics.create();
-        try {
-            canvas.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
-            canvas.setColor(StudioTheme.PANEL_BACKGROUND);
-            canvas.fill(island());
-        } finally {
-            canvas.dispose();
-        }
-    }
-
-    private RoundRectangle2D island() {
-        double gap = StudioTheme.scale(GAP);
-        double arc = StudioTheme.scale(CORNER_ARC);
-        return new RoundRectangle2D.Double(gap, gap, getWidth() - gap * 2D, getHeight() - gap * 2D, arc, arc);
-    }
-}
@@ -1,183 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.core.gui.components.MapLabels;
-import com.volmit.iris.core.gui.components.MapStyle;
-import com.volmit.iris.core.gui.components.MapTile;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.function.ToIntFunction;
-
-/**
- * Measures the visible part of the map from the tiles already drawn: how much each biome or region covers, and which
- * heights it spans.
- */
-final class MapCensus {
-    private static final long MAXIMUM_COUNTED_PIXELS = 250_000L;
-    private static final int MINIMUM_HEIGHT_SAMPLES = 64;
-    private static final double LOW_HEIGHT_PERCENTILE = 0.01D;
-    private static final double HIGH_HEIGHT_PERCENTILE = 0.99D;
-    private static final double HEIGHT_RANGE_STEP_BLOCKS = 8D;
-    private static final double MINIMUM_WATER_DEPTH_BLOCKS = 8D;
-    private static final double MINIMUM_LAND_HEIGHT_BLOCKS = 16D;
-
-    private MapCensus() {
-    }
-
-    static List<Share> count(VisionRenderController.Frame frame, ViewArea area, ToIntFunction<MapLabels.Label> colorOf) {
-        Map<Short, long[]> counts = new HashMap<>();
-        MapLabels[] labels = new MapLabels[1];
-        long counted = visitVisiblePixels(frame, area, (tile, pixelX, pixelZ) -> {
-            labels[0] = tile.labels();
-            counts.computeIfAbsent(tile.subjectAt(pixelX, pixelZ), id -> new long[1])[0]++;
-        });
-        return shares(counts, labels[0], counted, colorOf);
-    }
-
-    /**
-     * The heights on screen, ignoring the highest and lowest few percent so one spike doesn't wash out every colour.
-     * Rounded to whole steps, so panning around doesn't recolour the map for every small change.
-     *
-     * @return the range, or null until enough of the map is drawn to tell
-     */
-    static MapStyle.HeightRange heightRange(VisionRenderController.Frame frame, ViewArea area, double seaLevel) {
-        DoubleList heights = new DoubleList();
-        visitVisiblePixels(frame, area, (tile, pixelX, pixelZ) -> {
-            if (tile.hasHeights()) {
-                heights.add(tile.heightAt(pixelX, pixelZ));
-            }
-        });
-        if (heights.size() < MINIMUM_HEIGHT_SAMPLES) {
-            return null;
-        }
-        double[] sorted = heights.sorted();
-        double low = sorted[(int) ((sorted.length - 1) * LOW_HEIGHT_PERCENTILE)];
-        double high = sorted[(int) ((sorted.length - 1) * HIGH_HEIGHT_PERCENTILE)];
-        double lowest = Math.floor(Math.min(low, seaLevel - MINIMUM_WATER_DEPTH_BLOCKS) / HEIGHT_RANGE_STEP_BLOCKS)
-                * HEIGHT_RANGE_STEP_BLOCKS;
-        double highest = Math.ceil(Math.max(high, seaLevel + MINIMUM_LAND_HEIGHT_BLOCKS) / HEIGHT_RANGE_STEP_BLOCKS)
-                * HEIGHT_RANGE_STEP_BLOCKS;
-        return new MapStyle.HeightRange(lowest, seaLevel, highest);
-    }
-
-    private static long visitVisiblePixels(VisionRenderController.Frame frame, ViewArea area, PixelVisitor visitor) {
-        if (frame == null) {
-            return 0L;
-        }
-        double blocksPerPixel = frame.renderBlocksPerPixel();
-        int stride = countingStride(area.maximumX() - area.minimumX(), area.maximumZ() - area.minimumZ(), blocksPerPixel);
-        double tileSpan = VisionRenderController.TILE_PIXELS * blocksPerPixel;
-        long visited = 0L;
-        for (VisionRenderController.VisibleTile visible : frame.tiles()) {
-            MapTile tile = visible.tile();
-            if (tile == null) {
-                continue;
-            }
-            double originX = visible.tileX() * tileSpan;
-            double originZ = visible.tileZ() * tileSpan;
-            int firstX = firstPixel(area.minimumX() - originX, blocksPerPixel, stride, visible.tileX());
-            int firstZ = firstPixel(area.minimumZ() - originZ, blocksPerPixel, stride, visible.tileZ());
-            int endX = endPixel(area.maximumX() - originX, blocksPerPixel, tile.size());
-            int endZ = endPixel(area.maximumZ() - originZ, blocksPerPixel, tile.size());
-            for (int pixelZ = firstZ; pixelZ < endZ; pixelZ += stride) {
-                for (int pixelX = firstX; pixelX < endX; pixelX += stride) {
-                    visitor.visit(tile, pixelX, pixelZ);
-                    visited++;
-                }
-            }
-        }
-        return visited;
-    }
-
-    private static List<Share> shares(Map<Short, long[]> counts, MapLabels labels, long counted,
-                                      ToIntFunction<MapLabels.Label> colorOf) {
-        if (labels == null || counted == 0L) {
-            return List.of();
-        }
-        List<Share> shares = new ArrayList<>(counts.size());
-        for (Map.Entry<Short, long[]> entry : counts.entrySet()) {
-            MapLabels.Label label = labels.label(entry.getKey());
-            if (label != null) {
-                shares.add(new Share(label, colorOf.applyAsInt(label), entry.getValue()[0] / (double) counted));
-            }
-        }
-        shares.sort(Comparator.comparingDouble(Share::fraction).reversed().thenComparing(share -> share.label().name()));
-        return List.copyOf(shares);
-    }
-
-    // Counting every pixel of a big screen is wasted work; an evenly spread sample gives the same percentages.
-    private static int countingStride(double widthBlocks, double heightBlocks, double blocksPerPixel) {
-        double pixels = (widthBlocks / blocksPerPixel) * (heightBlocks / blocksPerPixel);
-        return Math.max(1, (int) Math.ceil(Math.sqrt(pixels / MAXIMUM_COUNTED_PIXELS)));
-    }
-
-    // Starting on the global stride grid keeps neighbouring tiles from sampling the same columns twice as densely.
-    private static int firstPixel(double offsetBlocks, double blocksPerPixel, int stride, long tileIndex) {
-        int first = Math.max(0, (int) Math.ceil(offsetBlocks / blocksPerPixel));
-        long globalPixel = tileIndex * VisionRenderController.TILE_PIXELS + first;
-        int misalignment = (int) Math.floorMod(globalPixel, (long) stride);
-        return misalignment == 0 ? first : first + stride - misalignment;
-    }
-
-    private static int endPixel(double offsetBlocks, double blocksPerPixel, int size) {
-        return Math.min(size, (int) Math.ceil(offsetBlocks / blocksPerPixel));
-    }
-
-    record Share(MapLabels.Label label, int color, double fraction) {
-    }
-
-    /**
-     * The world area the screen shows, in blocks.
-     */
-    record ViewArea(double minimumX, double minimumZ, double maximumX, double maximumZ) {
-    }
-
-    @FunctionalInterface
-    private interface PixelVisitor {
-        void visit(MapTile tile, int pixelX, int pixelZ);
-    }
-
-    private static final class DoubleList {
-        private double[] values = new double[1024];
-        private int size;
-
-        void add(double value) {
-            if (size == values.length) {
-                values = Arrays.copyOf(values, size * 2);
-            }
-            values[size++] = value;
-        }
-
-        int size() {
-            return size;
-        }
-
-        double[] sorted() {
-            double[] sorted = Arrays.copyOf(values, size);
-            Arrays.sort(sorted);
-            return sorted;
-        }
-    }
-}
@@ -1,112 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.core.gui.components.MapLabels;
-import com.volmit.iris.core.gui.components.RenderType;
-import com.volmit.iris.core.loader.IrisRegistrant;
-import com.volmit.iris.engine.object.IrisBiome;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * The text of the card that follows the cursor: what the drawn map shows there at once, and the rest once probed.
- */
-final class MapHoverCard {
-    private MapHoverCard() {
-    }
-
-    /**
-     * @param subject the biome, or region in the region view, the drawn tile shows; null while that tile is drawing
-     * @param details the probed facts about the spot, or null until they arrive
-     * @param detailed whether Shift is held, which adds keys and files
-     */
-    static List<String> lines(MapLabels.Label subject, MapLabels.Label region, MapHoverProbe.Details details,
-                              RenderType type, boolean detailed, double worldX, double worldZ) {
-        List<String> lines = new ArrayList<>();
-        lines.add(title(subject, details));
-        if (type != RenderType.REGION) {
-            String regionName = region != null ? region.name() : details != null ? details.region().getName() : null;
-            if (regionName != null) {
-                lines.add("Region " + regionName);
-            }
-        }
-        if (details != null) {
-            addTerrain(lines, details, type);
-        }
-        int blockX = MapCanvas.floorWorldCoordinate(worldX);
-        int blockZ = MapCanvas.floorWorldCoordinate(worldZ);
-        lines.add("Block " + blockX + ", " + blockZ + " · chunk " + (blockX >> 4) + ", " + (blockZ >> 4));
-        if (!detailed) {
-            lines.add("Shift for keys and files · H highlights");
-            return lines;
-        }
-        addSource(lines, subject);
-        if (subject != null && subject.kind() != MapLabels.Kind.REGION) {
-            addSource(lines, region);
-        }
-        lines.add("Region file r." + (blockX >> 9) + "." + (blockZ >> 9) + ".mca");
-        return lines;
-    }
-
-    private static String title(MapLabels.Label subject, MapHoverProbe.Details details) {
-        if (subject != null) {
-            return subject.name();
-        }
-        if (details != null && details.surfaceBiome() != null) {
-            return details.surfaceBiome().getName();
-        }
-        return "Drawing…";
-    }
-
-    private static void addTerrain(List<String> lines, MapHoverProbe.Details details, RenderType type) {
-        lines.add("Height " + Math.round(details.height()) + " · sea level " + Math.round(details.fluidHeight()));
-        String slope = "slope " + Math.round(details.slopeDegrees()) + "°";
-        lines.add(details.terrainKind() == null ? capitalize(slope) : details.terrainKind() + " · " + slope);
-        IrisBiome surface = details.surfaceBiome();
-        IrisBiome cave = details.caveBiome();
-        if (type == RenderType.CAVE_LAND && surface != null) {
-            lines.add("Surface biome " + surface.getName());
-        } else if (type != RenderType.CAVE_LAND && cave != null && cave != surface) {
-            lines.add("Cave biome " + cave.getName());
-        }
-        if (details.vanillaBiome() != null) {
-            lines.add("Minecraft biome " + details.vanillaBiome().replace('_', ' '));
-        }
-    }
-
-    private static void addSource(List<String> lines, MapLabels.Label label) {
-        if (label == null || !(label.subject() instanceof IrisRegistrant registrant)) {
-            return;
-        }
-        String kind = label.kind() == MapLabels.Kind.REGION ? "Region" : "Biome";
-        lines.add(kind + " key " + label.key());
-        File file = registrant.getLoadFile();
-        if (file != null) {
-            File folder = file.getParentFile();
-            lines.add(kind + " file " + (folder == null ? "" : folder.getName() + "/") + file.getName());
-        }
-    }
-
-    private static String capitalize(String text) {
-        return Character.toUpperCase(text.charAt(0)) + text.substring(1);
-    }
-}
@@ -1,90 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.engine.IrisComplex;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.InferredType;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.object.IrisRegion;
-import org.bukkit.block.Biome;
-
-import java.util.Locale;
-
-/**
- * Looks up everything the hover card can tell about one spot of the world; runs off the Swing thread.
- */
-final class MapHoverProbe {
-    // IrisComplex measures slope as the height change over this many blocks.
-    private static final double SLOPE_STREAM_RANGE_BLOCKS = 3D;
-
-    private MapHoverProbe() {
-    }
-
-    static Details sample(Engine engine, double worldX, double worldZ) {
-        IrisComplex complex = engine.getComplex();
-        IrisBiome surfaceBiome = complex.getBaseBiomeStream().get(worldX, worldZ);
-        IrisBiome caveBiome = complex.getCaveBiomeStream().get(worldX, worldZ);
-        IrisRegion region = complex.getRegionStream().get(worldX, worldZ);
-        InferredType terrainKind = complex.getBridgeStream().get(worldX, worldZ);
-        Biome vanillaBiome = complex.getTrueBiomeDerivativeStream().get(worldX, worldZ);
-        double height = complex.getHeightStream().getDouble(worldX, worldZ);
-        double slope = complex.getSlopeStream().getDouble(worldX, worldZ);
-        IrisDimension dimension = engine.getDimension();
-        return new Details(
-                worldX,
-                worldZ,
-                surfaceBiome,
-                caveBiome,
-                region,
-                terrainKindName(surfaceBiome, terrainKind),
-                vanillaBiome == null ? null : vanillaBiome.getKey().getKey(),
-                height,
-                dimension == null ? 0D : dimension.getFluidHeight(),
-                Math.toDegrees(Math.atan(slope / SLOPE_STREAM_RANGE_BLOCKS))
-        );
-    }
-
-    // A shore biome sits on land the continent stream calls land or sea, so the biome's own type says it best.
-    private static String terrainKindName(IrisBiome surfaceBiome, InferredType continentKind) {
-        InferredType kind = surfaceBiome != null && surfaceBiome.getInferredType() != null
-                ? surfaceBiome.getInferredType()
-                : continentKind;
-        if (kind == null) {
-            return null;
-        }
-        String name = kind.name().toLowerCase(Locale.ROOT);
-        return Character.toUpperCase(name.charAt(0)) + name.substring(1);
-    }
-
-    record Details(
-            double worldX,
-            double worldZ,
-            IrisBiome surfaceBiome,
-            IrisBiome caveBiome,
-            IrisRegion region,
-            String terrainKind,
-            String vanillaBiome,
-            double height,
-            double fluidHeight,
-            double slopeDegrees
-    ) {
-    }
-}
@@ -1,230 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.core.gui.components.MapStyle;
-
-import javax.swing.BorderFactory;
-import javax.swing.DefaultListCellRenderer;
-import javax.swing.DefaultListModel;
-import javax.swing.JLabel;
-import javax.swing.JList;
-import javax.swing.JPanel;
-import javax.swing.ListSelectionModel;
-import java.awt.BorderLayout;
-import java.awt.Color;
-import java.awt.Component;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
-import java.awt.Point;
-import java.awt.Rectangle;
-import java.awt.RenderingHints;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Locale;
-import java.util.Set;
-import java.util.function.Consumer;
-
-/**
- * The biomes or regions on screen with how much of it each covers; clicking one highlights it on the map.
- */
-final class MapLegendPanel extends JPanel {
-    private static final long serialVersionUID = 4471297416386034128L;
-    private static final int PANEL_WIDTH = 250;
-    private static final int ROW_HEIGHT = 26;
-    private static final int SWATCH_SIZE = 12;
-    private static final int SWATCH_GAP = 8;
-    private static final int ROW_PADDING = 10;
-    private static final int PERCENT_WIDTH = 42;
-    private static final String DRAWING_MESSAGE = "Drawing the map…";
-
-    private final JLabel title = new JLabel();
-    private final DefaultListModel<MapCensus.Share> rows = new DefaultListModel<>();
-    private final JList<MapCensus.Share> list = new JList<>(rows) {
-        // Long names shorten with an ellipsis instead of pushing the percentages out of sight.
-        @Override
-        public boolean getScrollableTracksViewportWidth() {
-            return true;
-        }
-    };
-    private final Set<String> sharedNames = new HashSet<>();
-    private MapStyle.Highlight highlight;
-
-    MapLegendPanel(Consumer<MapCensus.Share> onRowClicked) {
-        super(new BorderLayout());
-        setPreferredSize(StudioTheme.scaledSize(PANEL_WIDTH, 0));
-        setBorder(BorderFactory.createMatteBorder(0, 1, 0, 0, StudioTheme.SEPARATOR));
-        setBackground(StudioTheme.PANEL_BACKGROUND);
-
-        title.setFont(StudioTheme.sectionFont());
-        title.setForeground(StudioTheme.MUTED_TEXT);
-        title.setBorder(StudioTheme.emptyBorder(10, 16, 6, 16));
-        add(title, BorderLayout.NORTH);
-
-        list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
-        list.setFocusable(false);
-        list.setFixedCellHeight(StudioTheme.scale(ROW_HEIGHT));
-        list.setCellRenderer(new ShareRenderer());
-        list.setBackground(StudioTheme.PANEL_BACKGROUND);
-        list.setBorder(StudioTheme.emptyBorder(0, 6, 4, 6));
-        list.addMouseListener(new MouseAdapter() {
-            @Override
-            public void mouseClicked(MouseEvent event) {
-                MapCensus.Share share = shareAt(event.getPoint());
-                if (share != null) {
-                    onRowClicked.accept(share);
-                }
-            }
-        });
-        add(StudioToolbar.scroll(list), BorderLayout.CENTER);
-
-        JLabel hint = new JLabel("Click to highlight · Esc clears");
-        hint.setFont(StudioTheme.smallFont());
-        hint.setForeground(StudioTheme.MUTED_TEXT);
-        hint.setBorder(StudioTheme.emptyBorder(6, 16, 8, 16));
-        add(hint, BorderLayout.SOUTH);
-    }
-
-    void show(String subjectTitle, List<MapCensus.Share> shares, MapStyle.Highlight nextHighlight) {
-        title.setText(subjectTitle.toUpperCase(Locale.ROOT));
-        highlight = nextHighlight;
-        rememberSharedNames(shares);
-        if (!sameRows(shares)) {
-            rows.clear();
-            rows.addAll(shares);
-        }
-        list.repaint();
-    }
-
-    // Two biomes can share a display name; those rows show their key so they can be told apart.
-    private void rememberSharedNames(List<MapCensus.Share> shares) {
-        Set<String> seen = new HashSet<>();
-        sharedNames.clear();
-        for (MapCensus.Share share : shares) {
-            if (!seen.add(share.label().name())) {
-                sharedNames.add(share.label().name());
-            }
-        }
-    }
-
-    private String rowText(MapCensus.Share share) {
-        String name = share.label().name();
-        return sharedNames.contains(name) ? name + " (" + share.label().key() + ")" : name;
-    }
-
-    private boolean sameRows(List<MapCensus.Share> shares) {
-        if (rows.size() != shares.size()) {
-            return false;
-        }
-        for (int index = 0; index < shares.size(); index++) {
-            if (!rows.get(index).equals(shares.get(index))) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    private MapCensus.Share shareAt(Point point) {
-        int index = list.locationToIndex(point);
-        if (index < 0) {
-            return null;
-        }
-        Rectangle bounds = list.getCellBounds(index, index);
-        return bounds != null && bounds.contains(point) ? rows.get(index) : null;
-    }
-
-    private boolean isHighlighted(MapCensus.Share share) {
-        return highlight != null
-                && highlight.kind() == share.label().kind()
-                && highlight.key().equals(share.label().key());
-    }
-
-    @Override
-    protected void paintChildren(Graphics graphics) {
-        super.paintChildren(graphics);
-        if (!rows.isEmpty()) {
-            return;
-        }
-        Graphics2D canvas = (Graphics2D) graphics.create();
-        try {
-            canvas.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
-            canvas.setFont(StudioTheme.font());
-            canvas.setColor(StudioTheme.MUTED_TEXT);
-            canvas.drawString(DRAWING_MESSAGE, StudioTheme.scale(16),
-                    title.getHeight() + StudioTheme.scale(4) + canvas.getFontMetrics().getAscent());
-        } finally {
-            canvas.dispose();
-        }
-    }
-
-    private final class ShareRenderer extends DefaultListCellRenderer {
-        private static final long serialVersionUID = -2350212934617052618L;
-        private Color swatch = Color.BLACK;
-        private String percent = "";
-
-        @Override
-        public Component getListCellRendererComponent(JList<?> owner, Object value, int index, boolean selected, boolean focused) {
-            MapCensus.Share share = (MapCensus.Share) value;
-            super.getListCellRendererComponent(owner, rowText(share), index, isHighlighted(share), false);
-            setFont(StudioTheme.font());
-            setBorder(StudioTheme.emptyBorder(0, ROW_PADDING + SWATCH_SIZE + SWATCH_GAP, 0, ROW_PADDING + PERCENT_WIDTH));
-            setToolTipText(share.label().key());
-            swatch = new Color(share.color());
-            percent = formatPercent(share.fraction());
-            return this;
-        }
-
-        @Override
-        protected void paintComponent(Graphics graphics) {
-            super.paintComponent(graphics);
-            Graphics2D canvas = (Graphics2D) graphics.create();
-            try {
-                canvas.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
-                canvas.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
-                int size = StudioTheme.scale(SWATCH_SIZE);
-                int swatchX = StudioTheme.scale(ROW_PADDING);
-                int swatchY = (getHeight() - size) / 2;
-                int arc = StudioTheme.scale(4);
-                canvas.setColor(swatch);
-                canvas.fillRoundRect(swatchX, swatchY, size, size, arc, arc);
-                canvas.setColor(StudioTheme.CONTROL_BORDER);
-                canvas.drawRoundRect(swatchX, swatchY, size - 1, size - 1, arc, arc);
-                canvas.setFont(StudioTheme.smallFont());
-                canvas.setColor(StudioTheme.SECONDARY_TEXT);
-                int textWidth = canvas.getFontMetrics().stringWidth(percent);
-                int baseline = (getHeight() + canvas.getFontMetrics().getAscent() - canvas.getFontMetrics().getDescent()) / 2;
-                canvas.drawString(percent, getWidth() - StudioTheme.scale(ROW_PADDING) - textWidth, baseline);
-            } finally {
-                canvas.dispose();
-            }
-        }
-    }
-
-    private static String formatPercent(double fraction) {
-        double percent = fraction * 100D;
-        if (percent < 0.1D) {
-            return "<0.1%";
-        }
-        return percent < 10D
-                ? String.format(Locale.ROOT, "%.1f%%", percent)
-                : String.format(Locale.ROOT, "%.0f%%", percent);
-    }
-}
@@ -1,116 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.core.gui.components.RenderType;
-
-import java.awt.event.KeyEvent;
-
-/**
- * Everything the map window can show, in the order and groups of its view list.
- */
-enum MapView {
-    BIOMES("Biomes", "The biome at each spot, in the biome's colour", Group.WORLD, RenderType.BIOME, KeyEvent.VK_1),
-    REGIONS("Regions", "The region each spot belongs to", Group.WORLD, RenderType.REGION, KeyEvent.VK_2),
-    HEIGHT("Height", "Terrain height, from deep water to snowy peaks", Group.WORLD, RenderType.HEIGHT, KeyEvent.VK_3),
-    CONTINENTS("Continents", "Land, coast or sea, judged by each biome's first height generator",
-            Group.WORLD, RenderType.CONTINENT, KeyEvent.VK_4),
-    LAND_BIOMES("Land biomes", "The land biome each spot would get, also where the sea is",
-            Group.BIOME_STREAMS, RenderType.BIOME_LAND, KeyEvent.VK_5),
-    SEA_BIOMES("Sea biomes", "The sea biome each spot would get, also where the land is",
-            Group.BIOME_STREAMS, RenderType.BIOME_SEA, KeyEvent.VK_6),
-    CAVE_BIOMES("Cave biomes", "The cave biome under each spot", Group.BIOME_STREAMS, RenderType.CAVE_LAND, KeyEvent.VK_7),
-    PALETTES("Palettes", "The blocks each biome's palette layers place, with their textures",
-            Group.BLOCKS, null, KeyEvent.VK_P),
-    OBJECTS("Objects", "Every object in the pack in 3D, with the blocks it is made of",
-            Group.BLOCKS, null, KeyEvent.VK_O),
-    NOISE("Noise", "The pack's noise generators and Iris' built-in noise styles",
-            Group.GENERATORS, null, KeyEvent.VK_N);
-
-    private final String label;
-    private final String description;
-    private final Group group;
-    private final RenderType renderType;
-    private final int shortcutKey;
-
-    MapView(String label, String description, Group group, RenderType renderType, int shortcutKey) {
-        this.label = label;
-        this.description = description;
-        this.group = group;
-        this.renderType = renderType;
-        this.shortcutKey = shortcutKey;
-    }
-
-    String label() {
-        return label;
-    }
-
-    String description() {
-        return description;
-    }
-
-    Group group() {
-        return group;
-    }
-
-    /**
-     * The tile renderer's mode for this view, or null for the palette, object and noise views, which draw themselves.
-     */
-    RenderType renderType() {
-        return renderType;
-    }
-
-    int shortcutKey() {
-        return shortcutKey;
-    }
-
-    String shortcutText() {
-        return KeyEvent.getKeyText(shortcutKey);
-    }
-
-    boolean isTileMap() {
-        return renderType != null;
-    }
-
-    static MapView forShortcut(int keyCode) {
-        for (MapView view : values()) {
-            if (view.shortcutKey == keyCode) {
-                return view;
-            }
-        }
-        return null;
-    }
-
-    enum Group {
-        WORLD("World"),
-        BIOME_STREAMS("Biome layers"),
-        BLOCKS("Blocks"),
-        GENERATORS("Generators");
-
-        private final String label;
-
-        Group(String label) {
-            this.label = label;
-        }
-
-        String label() {
-            return label;
-        }
-    }
-}
@@ -1,47 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.formdev.flatlaf.extras.FlatSVGIcon;
-
-import javax.swing.Icon;
-import java.util.EnumMap;
-import java.util.Locale;
-import java.util.Map;
-
-/**
- * The icon of each map view, taken from IntelliJ's new UI icon set (see the NOTICE next to the files).
- */
-final class MapViewIcon {
-    private static final String ICON_FOLDER = "iris/icons/views/";
-    private static final int SIZE = 16;
-    private static final Map<MapView, Icon> LOADED = new EnumMap<>(MapView.class);
-
-    private MapViewIcon() {
-    }
-
-    static Icon of(MapView view) {
-        return LOADED.computeIfAbsent(view, MapViewIcon::load);
-    }
-
-    private static Icon load(MapView view) {
-        String fileName = view.name().toLowerCase(Locale.ROOT).replace('_', '-') + ".svg";
-        return new FlatSVGIcon(ICON_FOLDER + fileName, SIZE, SIZE, MapViewIcon.class.getClassLoader());
-    }
-}
@@ -1,246 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import javax.swing.DefaultListCellRenderer;
-import javax.swing.DefaultListModel;
-import javax.swing.JList;
-import javax.swing.ListSelectionModel;
-import javax.swing.UIManager;
-import java.awt.Component;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
-import java.awt.Insets;
-import java.awt.Rectangle;
-import java.awt.RenderingHints;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
-import java.util.Locale;
-import java.util.function.Consumer;
-
-/**
- * The map window's list of views, grouped under headers, each row with a picture of the view and the key that opens
- * it.
- */
-final class MapViewList extends JList<MapViewList.Row> {
-    private static final long serialVersionUID = -4130872409914437415L;
-    private static final int ROW_HEIGHT = 28;
-    private static final int NO_ROW = -1;
-
-    private final DefaultListModel<Row> rows = new DefaultListModel<>();
-    private int lastViewRow;
-    private int hoveredRow = NO_ROW;
-
-    MapViewList(Consumer<MapView> onViewChosen) {
-        fillRows();
-        setModel(rows);
-        setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
-        setFixedCellHeight(StudioTheme.scale(ROW_HEIGHT));
-        setCellRenderer(new RowRenderer());
-        setBorder(StudioTheme.emptyBorder(4, 6, 4, 6));
-        addListSelectionListener(event -> {
-            if (event.getValueIsAdjusting() || skipHeaderRow()) {
-                return;
-            }
-            Row selected = getSelectedValue();
-            if (selected == null) {
-                return;
-            }
-            lastViewRow = getSelectedIndex();
-            onViewChosen.accept(selected.view());
-        });
-        MouseAdapter hover = new MouseAdapter() {
-            @Override
-            public void mouseMoved(MouseEvent event) {
-                hover(viewRowAt(event));
-            }
-
-            @Override
-            public void mouseExited(MouseEvent event) {
-                hover(NO_ROW);
-            }
-        };
-        addMouseListener(hover);
-        addMouseMotionListener(hover);
-    }
-
-    private int viewRowAt(MouseEvent event) {
-        int row = locationToIndex(event.getPoint());
-        if (row < 0 || rows.get(row).isHeader() || !getCellBounds(row, row).contains(event.getPoint())) {
-            return NO_ROW;
-        }
-        return row;
-    }
-
-    private void hover(int row) {
-        if (row == hoveredRow) {
-            return;
-        }
-        repaintRow(hoveredRow);
-        hoveredRow = row;
-        repaintRow(hoveredRow);
-    }
-
-    private void repaintRow(int row) {
-        Rectangle bounds = row == NO_ROW ? null : getCellBounds(row, row);
-        if (bounds != null) {
-            repaint(bounds);
-        }
-    }
-
-    void select(MapView view) {
-        for (int row = 0; row < rows.size(); row++) {
-            if (rows.get(row).view() == view) {
-                lastViewRow = row;
-                setSelectedIndex(row);
-                ensureIndexIsVisible(row);
-                return;
-            }
-        }
-    }
-
-    private void fillRows() {
-        MapView.Group currentGroup = null;
-        for (MapView view : MapView.values()) {
-            if (view.group() != currentGroup) {
-                currentGroup = view.group();
-                rows.addElement(Row.header(currentGroup));
-            }
-            rows.addElement(Row.of(view));
-        }
-    }
-
-    // Headers can't be chosen: clicking one keeps the current view, and the arrow keys carry on past it.
-    private boolean skipHeaderRow() {
-        int row = getSelectedIndex();
-        if (row < 0 || !rows.get(row).isHeader()) {
-            return false;
-        }
-        int step = row >= lastViewRow ? 1 : -1;
-        int next = nextViewRow(row, step);
-        if (next < 0) {
-            next = nextViewRow(row, -step);
-        }
-        setSelectedIndex(next < 0 ? lastViewRow : next);
-        ensureIndexIsVisible(getSelectedIndex());
-        return true;
-    }
-
-    private int nextViewRow(int from, int step) {
-        for (int row = from + step; row >= 0 && row < rows.size(); row += step) {
-            if (!rows.get(row).isHeader()) {
-                return row;
-            }
-        }
-        return -1;
-    }
-
-    record Row(MapView.Group group, MapView view) {
-        static Row header(MapView.Group group) {
-            return new Row(group, null);
-        }
-
-        static Row of(MapView view) {
-            return new Row(view.group(), view);
-        }
-
-        boolean isHeader() {
-            return view == null;
-        }
-    }
-
-    private static final class RowRenderer extends DefaultListCellRenderer {
-        private static final long serialVersionUID = 6302156810211578474L;
-        private static final int ICON_TEXT_GAP = 8;
-        private static final int KEYCAP_SIZE = 17;
-        private static final int KEYCAP_ARC = 5;
-        private String shortcut;
-        private boolean hovered;
-
-        @Override
-        public Component getListCellRendererComponent(JList<?> list, Object value, int index, boolean selected, boolean focused) {
-            Row row = (Row) value;
-            super.getListCellRendererComponent(list, row.isHeader() ? "" : row.view().label(), index, selected && !row.isHeader(), false);
-            if (row.isHeader()) {
-                setText(row.group().label().toUpperCase(Locale.ROOT));
-                setFont(StudioTheme.sectionFont());
-                setForeground(StudioTheme.MUTED_TEXT);
-                setBorder(StudioTheme.emptyBorder(index == 0 ? 2 : 10, 8, 0, 6));
-                setIcon(null);
-                setToolTipText(null);
-                shortcut = null;
-                hovered = false;
-                setOpaque(true);
-                return this;
-            }
-            setFont(StudioTheme.font());
-            setBorder(StudioTheme.emptyBorder(0, 8, 0, 8));
-            setIcon(MapViewIcon.of(row.view()));
-            setIconTextGap(StudioTheme.scale(ICON_TEXT_GAP));
-            setToolTipText(row.view().description());
-            shortcut = row.view().shortcutText();
-            hovered = !selected && list instanceof MapViewList viewList && viewList.hoveredRow == index;
-            setOpaque(!hovered);
-            return this;
-        }
-
-        @Override
-        protected void paintComponent(Graphics graphics) {
-            Graphics2D canvas = (Graphics2D) graphics.create();
-            try {
-                canvas.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
-                canvas.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
-                if (hovered) {
-                    paintHoverBackground(canvas);
-                }
-                super.paintComponent(graphics);
-                if (shortcut != null) {
-                    paintKeycap(canvas);
-                }
-            } finally {
-                canvas.dispose();
-            }
-        }
-
-        // Shaped like the selection the look and feel paints, so moving between them doesn't jump.
-        private void paintHoverBackground(Graphics2D canvas) {
-            Insets inset = UIManager.getInsets("List.selectionInsets");
-            int left = inset == null ? 0 : StudioTheme.scale(inset.left);
-            int right = inset == null ? 0 : StudioTheme.scale(inset.right);
-            int arc = StudioTheme.scale(UIManager.getInt("List.selectionArc"));
-            canvas.setColor(StudioTheme.HOVER_BACKGROUND);
-            canvas.fillRoundRect(left, 0, getWidth() - left - right, getHeight(), arc, arc);
-        }
-
-        private void paintKeycap(Graphics2D canvas) {
-            canvas.setFont(StudioTheme.smallFont());
-            int textWidth = canvas.getFontMetrics().stringWidth(shortcut);
-            int height = StudioTheme.scale(KEYCAP_SIZE);
-            int width = Math.max(height, textWidth + StudioTheme.scale(8));
-            int x = getWidth() - getInsets().right - width;
-            int y = (getHeight() - height) / 2;
-            int arc = StudioTheme.scale(KEYCAP_ARC);
-            canvas.setColor(StudioTheme.CONTROL_BORDER);
-            canvas.drawRoundRect(x, y, width - 1, height - 1, arc, arc);
-            canvas.setColor(StudioTheme.SECONDARY_TEXT);
-            int baseline = y + (height + canvas.getFontMetrics().getAscent() - canvas.getFontMetrics().getDescent()) / 2;
-            canvas.drawString(shortcut, x + (width - textWidth) / 2, baseline);
-        }
-    }
-}
@@ -1,497 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.core.gui.components.MapStyle;
-
-import javax.swing.AbstractAction;
-import javax.swing.BorderFactory;
-import javax.swing.Box;
-import javax.swing.JComponent;
-import javax.swing.JFrame;
-import javax.swing.JLabel;
-import javax.swing.JPanel;
-import javax.swing.JRootPane;
-import javax.swing.JSplitPane;
-import javax.swing.JToggleButton;
-import javax.swing.JToolBar;
-import javax.swing.KeyStroke;
-import javax.swing.SwingConstants;
-import javax.swing.text.JTextComponent;
-import java.awt.BorderLayout;
-import java.awt.CardLayout;
-import java.awt.Dimension;
-import java.awt.EventQueue;
-import java.awt.KeyboardFocusManager;
-import java.awt.event.ActionEvent;
-import java.awt.event.ComponentAdapter;
-import java.awt.event.ComponentEvent;
-import java.awt.event.KeyEvent;
-import java.awt.event.WindowAdapter;
-import java.awt.event.WindowEvent;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.IntConsumer;
-
-/**
- * The studio map: one window showing the world as tiles in several views, with the palette, object and noise explorers
- * as its Palettes, Objects and Noise views.
- */
-public final class MapWindow implements MapCanvas.Listener {
-    private static final String MAP_CARD = "map";
-    private static final String PALETTES_CARD = "palettes";
-    private static final String OBJECTS_CARD = "objects";
-    private static final String NOISE_CARD = "noise";
-    private static final int SIDEBAR_WIDTH = 270;
-    private static final int SIDEBAR_MINIMUM_WIDTH = 200;
-    private static final int CONTENT_MINIMUM_WIDTH = 320;
-    private static final double PALETTE_RECENTER_DISTANCE_BLOCKS = 1D;
-    private static final int VIEW_LIST_SCROLL_INSETS = 4;
-    private static final int EXPLORER_DIVIDER_HEIGHT = 7;
-
-    private final JFrame frame;
-    private final PaletteExplorerStart start;
-    private final MapCanvas canvas;
-    private final MapViewList viewList;
-    private final JLabel viewTitle = new JLabel();
-    private final JPanel content = new JPanel(new CardLayout());
-    private final JPanel statusBars = new JPanel(new CardLayout());
-    private final JPanel sidebar = new JPanel(new BorderLayout());
-    private final IslandPanel sidebarIsland = new IslandPanel(sidebar);
-    private final JPanel inspectorSlot = new JPanel(new BorderLayout());
-    private final JComponent viewListScroll;
-    private final JSplitPane explorerSplit = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
-    private final List<JComponent> mapControls = new ArrayList<>();
-    private final List<JComponent> explorerControls = new ArrayList<>();
-    private final List<JComponent> noiseControls = new ArrayList<>();
-    private final JToolBar toolbar = StudioToolbar.create();
-    private final JComponent resetViewButton = StudioToolbar.button("Reset view", "Go back to the starting position and zoom (R)",
-            this::resetExplorerView);
-    private final JToggleButton gridToggle = StudioToolbar.toggle("Grid", "Show chunk and region borders (G)");
-    private final JToggleButton entitiesToggle = StudioToolbar.toggle("Entities", "Show mobs and other entities (E)");
-    private final JToggleButton followToggle = StudioToolbar.toggle("Follow", "Keep your player in the middle (F)");
-    private final JToggleButton shadingToggle = StudioToolbar.toggle("Shading", "Shade hills and valleys on every view (S)");
-    private final JToggleButton bordersToggle = StudioToolbar.toggle("Borders", "Outline the regions on every view (B)");
-    private final MapLegendPanel legendPanel;
-
-    private NoiseExplorerGUI paletteExplorer;
-    private ObjectExplorer objectExplorer;
-    private NoiseExplorerGUI noiseExplorer;
-    private JComponent noiseSidebar;
-    private MapView currentView;
-    private double paletteCenterX;
-    private double paletteCenterZ;
-
-    private MapWindow(PaletteExplorerStart start) {
-        this.start = start;
-        this.frame = GuiHost.createFrame("Iris Map");
-        this.canvas = new MapCanvas(start.engine(), start.worldId(), start.playerId(), this);
-        this.viewList = new MapViewList(this::showView);
-        this.viewListScroll = StudioToolbar.scroll(viewList);
-        this.legendPanel = new MapLegendPanel(share -> canvas.toggleHighlight(share.label()));
-        canvas.centerOn(start.centerX(), start.centerZ());
-        buildFrame();
-    }
-
-    public static void openMap(PaletteExplorerStart start) {
-        EventQueue.invokeLater(() -> open(start, MapView.BIOMES));
-    }
-
-    public static void openPalettes(PaletteExplorerStart start) {
-        EventQueue.invokeLater(() -> open(start, MapView.PALETTES));
-    }
-
-    public static void openNoise(PaletteExplorerStart start) {
-        EventQueue.invokeLater(() -> open(start, MapView.NOISE));
-    }
-
-    private static void open(PaletteExplorerStart start, MapView initialView) {
-        StudioTheme.install();
-        MapWindow window = new MapWindow(start);
-        window.frame.setVisible(true);
-        window.canvas.start();
-        window.showView(initialView);
-    }
-
-    private void buildFrame() {
-        styleExplorerSplit();
-        content.add(canvas, MAP_CARD);
-        statusBars.add(canvas.statusBar(), MAP_CARD);
-        sidebar.add(viewListScroll, BorderLayout.CENTER);
-
-        frame.setLayout(new BorderLayout());
-        frame.add(buildToolbar(), BorderLayout.NORTH);
-        frame.add(new IslandOverlay(sidebarIsland, content, StudioTheme.scale(SIDEBAR_WIDTH),
-                StudioTheme.scale(SIDEBAR_MINIMUM_WIDTH), StudioTheme.scale(CONTENT_MINIMUM_WIDTH)), BorderLayout.CENTER);
-        frame.add(inspectorSlot, BorderLayout.EAST);
-        frame.add(statusBars, BorderLayout.SOUTH);
-        installShortcuts(frame.getRootPane());
-        keepClearOfIsland(canvas::setCoveredLeftWidth);
-        frame.setSize(GuiHost.fitToScreen(StudioTheme.scaledSize(1440, 880)));
-        frame.setMinimumSize(StudioTheme.scaledSize(820, 520));
-        frame.setLocationRelativeTo(null);
-        frame.addWindowListener(new WindowAdapter() {
-            @Override
-            public void windowClosed(WindowEvent event) {
-                close();
-            }
-        });
-    }
-
-    private JToolBar buildToolbar() {
-        viewTitle.setFont(StudioTheme.titleFont());
-        viewTitle.setBorder(StudioTheme.emptyBorder(0, 6, 0, 14));
-        toolbar.add(viewTitle);
-
-        mapControls.add(StudioToolbar.button("Refresh", "Redraw the map with the latest pack files (R)", canvas::refreshContent));
-        mapControls.add(StudioToolbar.button("Reset zoom", "Go back to the default zoom (\\)", canvas::resetZoom));
-        mapControls.add(gridToggle);
-        mapControls.add(entitiesToggle);
-        mapControls.add(followToggle);
-        mapControls.add(toolbarSeparator());
-        mapControls.add(shadingToggle);
-        mapControls.add(bordersToggle);
-        gridToggle.addActionListener(event -> canvas.toggleGrid());
-        entitiesToggle.addActionListener(event -> canvas.toggleEntities());
-        followToggle.addActionListener(event -> canvas.toggleFollow());
-        shadingToggle.addActionListener(event -> canvas.toggleShading());
-        bordersToggle.addActionListener(event -> canvas.toggleRegionBorders());
-        mapControls.forEach(toolbar::add);
-
-        explorerControls.add(resetViewButton);
-        explorerControls.forEach(toolbar::add);
-
-        toolbar.add(Box.createHorizontalGlue());
-        toolbar.add(StudioToolbar.themeButton());
-        JComponent help = StudioToolbar.button("Shortcuts", "Show every mouse and key shortcut (/)", canvas::toggleHelp);
-        mapControls.add(help);
-        toolbar.add(help);
-        return toolbar;
-    }
-
-    private static JComponent toolbarSeparator() {
-        JToolBar.Separator separator = new JToolBar.Separator();
-        separator.setOrientation(SwingConstants.VERTICAL);
-        return separator;
-    }
-
-    private void showView(MapView view) {
-        if (view == null || view == currentView) {
-            return;
-        }
-        MapView previousView = currentView;
-        currentView = view;
-        viewList.select(view);
-        viewTitle.setText(view.label());
-        viewTitle.setToolTipText(view.description());
-        if (view.isTileMap()) {
-            showMap(previousView, view);
-        } else if (view == MapView.PALETTES) {
-            showPalettes(previousView);
-        } else if (view == MapView.OBJECTS) {
-            showObjects();
-        } else {
-            showNoise();
-        }
-        frame.getRootPane().revalidate();
-        frame.getRootPane().repaint();
-    }
-
-    private void showMap(MapView previousView, MapView view) {
-        if (previousView == MapView.PALETTES && paletteExplorer != null) {
-            canvas.centerOn(paletteExplorer.centerX(), paletteExplorer.centerZ());
-        }
-        canvas.showView(view);
-        canvas.setActive(true);
-        showControls(mapControls);
-        useSidebar(viewListScroll);
-        inspectorSlot.removeAll();
-        inspectorSlot.add(legendPanel, BorderLayout.CENTER);
-        showCard(MAP_CARD);
-        canvas.requestFocusInWindow();
-    }
-
-    private void showPalettes(MapView previousView) {
-        boolean firstOpen = paletteExplorer == null;
-        if (firstOpen) {
-            createPaletteExplorer(previousView == null);
-        } else {
-            followMapIntoPalettes();
-        }
-        canvas.setActive(false);
-        showControls(explorerControls);
-        useSidebar(viewListAbove(paletteExplorer.paletteSidebar()));
-        inspectorSlot.removeAll();
-        inspectorSlot.add(paletteExplorer.paletteInspector(), BorderLayout.CENTER);
-        showCard(PALETTES_CARD);
-        EventQueue.invokeLater(() -> viewList.select(currentView));
-        if (firstOpen) {
-            paletteExplorer.openViewer();
-        }
-    }
-
-    private void showObjects() {
-        boolean firstOpen = objectExplorer == null;
-        if (firstOpen) {
-            createObjectExplorer();
-        }
-        canvas.setActive(false);
-        showControls(explorerControls);
-        useSidebar(viewListAbove(objectExplorer.browser()));
-        inspectorSlot.removeAll();
-        inspectorSlot.add(objectExplorer.overview(), BorderLayout.CENTER);
-        showCard(OBJECTS_CARD);
-        EventQueue.invokeLater(() -> viewList.select(currentView));
-        if (firstOpen) {
-            objectExplorer.open();
-        }
-    }
-
-    private void keepClearOfIsland(IntConsumer setCoveredLeftWidth) {
-        setCoveredLeftWidth.accept(sidebarIsland.getWidth());
-        sidebarIsland.addComponentListener(new ComponentAdapter() {
-            @Override
-            public void componentResized(ComponentEvent event) {
-                setCoveredLeftWidth.accept(sidebarIsland.getWidth());
-            }
-        });
-    }
-
-    private void createObjectExplorer() {
-        objectExplorer = new ObjectExplorer(start.engine(), start.worldId());
-        keepClearOfIsland(objectExplorer.viewport()::setCoveredLeftWidth);
-        content.add(objectExplorer.view(), OBJECTS_CARD);
-        statusBars.add(objectExplorer.statusBar(), OBJECTS_CARD);
-    }
-
-    private void showNoise() {
-        boolean firstOpen = noiseExplorer == null;
-        if (firstOpen) {
-            createNoiseExplorer();
-        }
-        canvas.setActive(false);
-        showControls(noiseControls, explorerControls);
-        useSidebar(viewListAbove(noiseSidebar));
-        inspectorSlot.removeAll();
-        showCard(NOISE_CARD);
-        EventQueue.invokeLater(() -> viewList.select(currentView));
-        if (firstOpen) {
-            noiseExplorer.openViewer();
-        }
-    }
-
-    // Both explorers share one split, so the divider stays where it was dragged when switching between them.
-    private JSplitPane viewListAbove(JComponent explorerSidebar) {
-        boolean firstUse = explorerSplit.getBottomComponent() == null;
-        explorerSplit.setTopComponent(viewListScroll);
-        explorerSplit.setBottomComponent(explorerSidebar);
-        if (firstUse) {
-            EventQueue.invokeLater(this::fitViewListAboveExplorer);
-        }
-        return explorerSplit;
-    }
-
-    private void styleExplorerSplit() {
-        explorerSplit.setBorder(BorderFactory.createEmptyBorder());
-        explorerSplit.setResizeWeight(0D);
-        explorerSplit.setBackground(StudioTheme.PANEL_BACKGROUND);
-        explorerSplit.setDividerSize(StudioTheme.scale(EXPLORER_DIVIDER_HEIGHT));
-        explorerSplit.putClientProperty("FlatLaf.style", "style: grip");
-    }
-
-    // Every view stays in sight, so the divider starts below the last one and can only be dragged further down. Measured
-    // once the sidebar is laid out, since the list's rows are taller before they know their width.
-    private void fitViewListAboveExplorer() {
-        int fullHeight = viewList.getPreferredSize().height + VIEW_LIST_SCROLL_INSETS;
-        viewListScroll.setMinimumSize(new Dimension(0, fullHeight));
-        explorerSplit.setDividerLocation(fullHeight);
-    }
-
-    private void createNoiseExplorer() {
-        noiseExplorer = NoiseExplorerGUI.createNoiseExplorer(start.engine());
-        noiseSidebar = noiseExplorer.noiseSidebar();
-        noiseControls.addAll(noiseExplorer.noiseControls());
-        noiseControls.forEach(control -> toolbar.add(control, toolbar.getComponentIndex(resetViewButton)));
-        content.add(noiseExplorer, NOISE_CARD);
-        statusBars.add(noiseExplorer.statusBar(), NOISE_CARD);
-    }
-
-    private void createPaletteExplorer(boolean openedOnPalettes) {
-        PaletteExplorerStart explorerStart = openedOnPalettes
-                ? start
-                : new PaletteExplorerStart(start.engine(), start.worldId(), start.playerId(), null, canvas.centerX(), canvas.centerZ());
-        paletteExplorer = NoiseExplorerGUI.createPaletteExplorer(explorerStart);
-        content.add(paletteExplorer, PALETTES_CARD);
-        statusBars.add(paletteExplorer.statusBar(), PALETTES_CARD);
-        rememberPaletteCenter(explorerStart.centerX(), explorerStart.centerZ());
-        if (!openedOnPalettes) {
-            showSurfaceBiomePalettes(explorerStart.centerX(), explorerStart.centerZ());
-        }
-    }
-
-    // Coming back from the map only moves the palettes when the map was moved, so a chosen layer survives a quick look.
-    private void followMapIntoPalettes() {
-        double movedX = canvas.centerX() - paletteCenterX;
-        double movedZ = canvas.centerZ() - paletteCenterZ;
-        if (Math.hypot(movedX, movedZ) < PALETTE_RECENTER_DISTANCE_BLOCKS) {
-            return;
-        }
-        paletteExplorer.centerOn(canvas.centerX(), canvas.centerZ());
-        rememberPaletteCenter(canvas.centerX(), canvas.centerZ());
-        showSurfaceBiomePalettes(canvas.centerX(), canvas.centerZ());
-    }
-
-    @Override
-    public void onShowPalettesAt(double worldX, double worldZ) {
-        canvas.centerOn(worldX, worldZ);
-        showView(MapView.PALETTES);
-    }
-
-    private void showSurfaceBiomePalettes(double worldX, double worldZ) {
-        canvas.findSurfaceBiome(worldX, worldZ, biomeKey -> {
-            if (paletteExplorer != null) {
-                paletteExplorer.showPalettesAt(worldX, worldZ, biomeKey);
-            }
-        });
-    }
-
-    private void rememberPaletteCenter(double worldX, double worldZ) {
-        paletteCenterX = worldX;
-        paletteCenterZ = worldZ;
-    }
-
-    @Override
-    public void onTogglesChanged() {
-        gridToggle.setSelected(canvas.isGridVisible());
-        entitiesToggle.setSelected(canvas.areEntitiesVisible());
-        followToggle.setSelected(canvas.isFollowing());
-        shadingToggle.setSelected(canvas.style().shading());
-        bordersToggle.setSelected(canvas.style().regionBorders());
-    }
-
-    @Override
-    public void onLegendChanged(String title, List<MapCensus.Share> shares, MapStyle.Highlight highlight) {
-        legendPanel.show(title, shares, highlight);
-    }
-
-    private void resetExplorerView() {
-        if (currentView == MapView.OBJECTS) {
-            objectExplorer.resetCamera();
-            return;
-        }
-        NoiseExplorerGUI explorer = currentView == MapView.NOISE ? noiseExplorer : paletteExplorer;
-        if (explorer != null) {
-            explorer.resetViewport();
-        }
-    }
-
-    private void useSidebar(JComponent component) {
-        sidebar.removeAll();
-        sidebar.add(component, BorderLayout.CENTER);
-    }
-
-    private void showCard(String card) {
-        ((CardLayout) content.getLayout()).show(content, card);
-        ((CardLayout) statusBars.getLayout()).show(statusBars, card);
-    }
-
-    @SafeVarargs
-    private void showControls(List<JComponent>... visibleControls) {
-        for (List<JComponent> controls : List.of(mapControls, explorerControls, noiseControls)) {
-            controls.forEach(control -> control.setVisible(false));
-        }
-        for (List<JComponent> controls : visibleControls) {
-            controls.forEach(control -> control.setVisible(true));
-        }
-    }
-
-    private void installShortcuts(JRootPane rootPane) {
-        for (MapView view : MapView.values()) {
-            bind(rootPane, KeyStroke.getKeyStroke(view.shortcutKey(), 0), "view-" + view.name(), () -> showView(view));
-        }
-        bind(rootPane, KeyStroke.getKeyStroke(KeyEvent.VK_M, 0), "next-view", this::showNextView);
-        bind(rootPane, KeyStroke.getKeyStroke(KeyEvent.VK_R, 0), "refresh", this::refreshOrReset);
-        bindMap(rootPane, KeyEvent.VK_F, 0, "follow", canvas::toggleFollow);
-        bindMap(rootPane, KeyEvent.VK_G, 0, "grid", canvas::toggleGrid);
-        bindMap(rootPane, KeyEvent.VK_E, 0, "entities", canvas::toggleEntities);
-        bindMap(rootPane, KeyEvent.VK_F3, 0, "debug", canvas::toggleDebug);
-        bindMap(rootPane, KeyEvent.VK_H, 0, "highlight", canvas::highlightUnderCursor);
-        bindMap(rootPane, KeyEvent.VK_ESCAPE, 0, "dismiss", canvas::dismissEmphasis);
-        bindMap(rootPane, KeyEvent.VK_S, 0, "shading", canvas::toggleShading);
-        bindMap(rootPane, KeyEvent.VK_B, 0, "borders", canvas::toggleRegionBorders);
-        bindMap(rootPane, KeyEvent.VK_EQUALS, 0, "zoom-in", canvas::zoomIn);
-        bindMap(rootPane, KeyEvent.VK_EQUALS, KeyEvent.SHIFT_DOWN_MASK, "zoom-in-plus", canvas::zoomIn);
-        bindMap(rootPane, KeyEvent.VK_ADD, 0, "zoom-in-keypad", canvas::zoomIn);
-        bindMap(rootPane, KeyEvent.VK_MINUS, 0, "zoom-out", canvas::zoomOut);
-        bindMap(rootPane, KeyEvent.VK_SUBTRACT, 0, "zoom-out-keypad", canvas::zoomOut);
-        bindMap(rootPane, KeyEvent.VK_BACK_SLASH, 0, "reset-zoom", canvas::resetZoom);
-        bindMap(rootPane, KeyEvent.VK_SLASH, 0, "help", canvas::toggleHelp);
-        bindMap(rootPane, KeyEvent.VK_SLASH, KeyEvent.SHIFT_DOWN_MASK, "help-question", canvas::toggleHelp);
-        bind(rootPane, KeyStroke.getKeyStroke(KeyEvent.VK_SHIFT, KeyEvent.SHIFT_DOWN_MASK, false), "details-on",
-                () -> canvas.setDetailedHover(true));
-        bind(rootPane, KeyStroke.getKeyStroke(KeyEvent.VK_SHIFT, 0, true), "details-off", () -> canvas.setDetailedHover(false));
-    }
-
-    private void bindMap(JRootPane rootPane, int keyCode, int modifiers, String name, Runnable action) {
-        bind(rootPane, KeyStroke.getKeyStroke(keyCode, modifiers), name, () -> {
-            if (currentView != null && currentView.isTileMap()) {
-                action.run();
-            }
-        });
-    }
-
-    // Keys typed into a search box belong to that box, not to the window's shortcuts.
-    private static void bind(JRootPane rootPane, KeyStroke keyStroke, String name, Runnable action) {
-        rootPane.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(keyStroke, name);
-        rootPane.getActionMap().put(name, new AbstractAction() {
-            @Override
-            public void actionPerformed(ActionEvent event) {
-                if (!(KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner() instanceof JTextComponent)) {
-                    action.run();
-                }
-            }
-        });
-    }
-
-    private void showNextView() {
-        MapView[] views = MapView.values();
-        showView(views[(currentView.ordinal() + 1) % views.length]);
-    }
-
-    private void refreshOrReset() {
-        if (currentView.isTileMap()) {
-            canvas.refreshContent();
-        } else {
-            resetExplorerView();
-        }
-    }
-
-    private void close() {
-        canvas.close();
-        if (paletteExplorer != null) {
-            paletteExplorer.close();
-        }
-        if (objectExplorer != null) {
-            objectExplorer.close();
-        }
-        if (noiseExplorer != null) {
-            noiseExplorer.close();
-        }
-    }
-}
@@ -1,155 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-
-package com.volmit.iris.core.gui;
-
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
-import com.volmit.iris.engine.object.IrisBiomeCustom;
-import org.bukkit.NamespacedKey;
-
-import java.awt.Color;
-import java.awt.image.BufferedImage;
-import java.io.IOException;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.zip.ZipFile;
-
-// Works out biome tint colours the way Minecraft does, from the colour maps and vanilla biome files in the client jar.
-final class MinecraftBiomeColors {
-    private static final String COLOR_MAP_FOLDER = "assets/minecraft/textures/colormap/";
-    private static final int COLOR_MAP_SIZE = 256;
-    private static final int GRASS_FALLBACK = 0xFF00FF;
-    private static final int FOLIAGE_FALLBACK = 0x48B518;
-    private static final int DRY_FOLIAGE_FALLBACK = 0x5C3C32;
-    private static final float UNKNOWN_BIOME_TEMPERATURE = 0.5F;
-    private static final float UNKNOWN_BIOME_DOWNFALL = 0.5F;
-    private static final int UNKNOWN_BIOME_WATER = 0x3F76E4;
-    private static final int UNPARSEABLE_COLOR = 0x000000;
-
-    private final ZipFile clientJar;
-    private final ColorMap grassMap;
-    private final ColorMap foliageMap;
-    private final ColorMap dryFoliageMap;
-    private final Map<NamespacedKey, BiomeTintColors> vanillaBiomes = new ConcurrentHashMap<>();
-
-    private MinecraftBiomeColors(ZipFile clientJar, ColorMap grassMap, ColorMap foliageMap, ColorMap dryFoliageMap) {
-        this.clientJar = clientJar;
-        this.grassMap = grassMap;
-        this.foliageMap = foliageMap;
-        this.dryFoliageMap = dryFoliageMap;
-    }
-
-    static MinecraftBiomeColors load(ZipFile clientJar) throws IOException {
-        return new MinecraftBiomeColors(
-                clientJar,
-                ColorMap.read(clientJar, "grass.png", GRASS_FALLBACK),
-                ColorMap.read(clientJar, "foliage.png", FOLIAGE_FALLBACK),
-                ColorMap.read(clientJar, "dry_foliage.png", DRY_FOLIAGE_FALLBACK)
-        );
-    }
-
-    BiomeTintColors vanilla(NamespacedKey biome) {
-        return vanillaBiomes.computeIfAbsent(biome, this::readVanillaBiome);
-    }
-
-    // Iris registers custom biomes as data pack biomes built from these fields, see IrisBiomeCustom#generateJson.
-    BiomeTintColors custom(IrisBiomeCustom biome) {
-        float temperature = (float) biome.getTemperature();
-        float downfall = (float) biome.getHumidity();
-        return new BiomeTintColors(
-                biome.getGrassColor().isEmpty() ? grassMap.colorAt(temperature, downfall) : parseIrisColor(biome.getGrassColor()),
-                BiomeTintColors.GrassColorModifier.NONE,
-                biome.getFoliageColor().isEmpty() ? foliageMap.colorAt(temperature, downfall) : parseIrisColor(biome.getFoliageColor()),
-                dryFoliageMap.colorAt(temperature, downfall),
-                parseIrisColor(biome.getWaterColor())
-        );
-    }
-
-    private BiomeTintColors readVanillaBiome(NamespacedKey biome) {
-        JsonObject definition = readBiomeDefinition(biome);
-        if (definition == null) {
-            return fromClimate(UNKNOWN_BIOME_TEMPERATURE, UNKNOWN_BIOME_DOWNFALL, new JsonObject());
-        }
-        JsonObject effects = definition.has("effects") ? definition.getAsJsonObject("effects") : new JsonObject();
-        return fromClimate(definition.get("temperature").getAsFloat(), definition.get("downfall").getAsFloat(), effects);
-    }
-
-    private BiomeTintColors fromClimate(float temperature, float downfall, JsonObject effects) {
-        return new BiomeTintColors(
-                effects.has("grass_color") ? parseVanillaColor(effects.get("grass_color")) : grassMap.colorAt(temperature, downfall),
-                effects.has("grass_color_modifier")
-                        ? BiomeTintColors.GrassColorModifier.named(effects.get("grass_color_modifier").getAsString())
-                        : BiomeTintColors.GrassColorModifier.NONE,
-                effects.has("foliage_color") ? parseVanillaColor(effects.get("foliage_color")) : foliageMap.colorAt(temperature, downfall),
-                effects.has("dry_foliage_color") ? parseVanillaColor(effects.get("dry_foliage_color")) : dryFoliageMap.colorAt(temperature, downfall),
-                effects.has("water_color") ? parseVanillaColor(effects.get("water_color")) : UNKNOWN_BIOME_WATER
-        );
-    }
-
-    private JsonObject readBiomeDefinition(NamespacedKey biome) {
-        try {
-            return ClientJarFiles.readJson(clientJar, "data/" + biome.getNamespace() + "/worldgen/biome/" + biome.getKey() + ".json");
-        } catch (IOException | RuntimeException error) {
-            return null;
-        }
-    }
-
-    // Older versions store colours as plain numbers, newer ones as "#rrggbb" strings.
-    private static int parseVanillaColor(JsonElement color) {
-        if (color.getAsJsonPrimitive().isNumber()) {
-            return color.getAsInt() & 0xFFFFFF;
-        }
-        return Integer.parseInt(color.getAsString().substring(1), 16);
-    }
-
-    private static int parseIrisColor(String color) {
-        try {
-            return Color.decode((color.startsWith("#") ? color : "#" + color).trim()).getRGB() & 0xFFFFFF;
-        } catch (RuntimeException error) {
-            return UNPARSEABLE_COLOR;
-        }
-    }
-
-    // Minecraft's ColorMapColorUtil: temperature picks the column and temperature times downfall picks the row.
-    private record ColorMap(int[] pixels, int fallback) {
-        private static ColorMap read(ZipFile clientJar, String name, int fallback) throws IOException {
-            BufferedImage image = ClientJarFiles.readImage(clientJar, COLOR_MAP_FOLDER + name);
-            if (image == null) {
-                throw new IOException("Minecraft colour map " + name + " is missing");
-            }
-            int[] pixels = new int[COLOR_MAP_SIZE * COLOR_MAP_SIZE];
-            for (int y = 0; y < COLOR_MAP_SIZE; y++) {
-                for (int x = 0; x < COLOR_MAP_SIZE; x++) {
-                    pixels[y * COLOR_MAP_SIZE + x] = image.getRGB(x, y) & 0xFFFFFF;
-                }
-            }
-            return new ColorMap(pixels, fallback);
-        }
-
-        private int colorAt(float temperature, float downfall) {
-            double clampedTemperature = Math.clamp(temperature, 0F, 1F);
-            double clampedDownfall = Math.clamp(downfall, 0F, 1F) * clampedTemperature;
-            int x = (int) ((1D - clampedTemperature) * 255D);
-            int y = (int) ((1D - clampedDownfall) * 255D);
-            int index = y << 8 | x;
-            return index >= pixels.length ? fallback : pixels[index];
-        }
-    }
-}
@@ -1,85 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-
-package com.volmit.iris.core.gui;
-
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-
-// Mirrors Minecraft's BlockColors: which colour each tinted face of a block is multiplied with in the world.
-final class MinecraftBlockTints {
-    static final int NO_TINT = 0xFFFFFF;
-    private static final Set<String> GRASS_TINTED = Set.of(
-            "grass_block", "short_grass", "fern", "potted_fern", "bush", "tall_grass", "large_fern", "sugar_cane");
-    private static final Set<String> GRASS_TINTED_ON_SECOND_LAYER = Set.of("pink_petals", "wildflowers");
-    private static final Set<String> FOLIAGE_TINTED = Set.of(
-            "oak_leaves", "jungle_leaves", "acacia_leaves", "dark_oak_leaves", "vine", "mangrove_leaves");
-    private static final Set<String> WATER_TINTED_BY_FLUID_RENDERER = Set.of("water", "bubble_column");
-    private static final Set<String> GROWING_STEMS = Set.of("melon_stem", "pumpkin_stem");
-    private static final Map<String, Integer> FIXED_TINTS = Map.of(
-            "spruce_leaves", 0x619961,
-            "birch_leaves", 0x80A755,
-            "attached_melon_stem", 0xE0C71C,
-            "attached_pumpkin_stem", 0xE0C71C,
-            "lily_pad", 0x208030
-    );
-
-    private MinecraftBlockTints() {
-    }
-
-    static Optional<BiomeTint> biomeTint(String blockName, int tintIndex) {
-        if (WATER_TINTED_BY_FLUID_RENDERER.contains(blockName)) {
-            return Optional.of(BiomeTint.WATER);
-        }
-        if (GRASS_TINTED_ON_SECOND_LAYER.contains(blockName)) {
-            return tintIndex == 1 ? Optional.of(BiomeTint.GRASS) : Optional.empty();
-        }
-        if (tintIndex != 0) {
-            return Optional.empty();
-        }
-        if (GRASS_TINTED.contains(blockName)) {
-            return Optional.of(BiomeTint.GRASS);
-        }
-        if (FOLIAGE_TINTED.contains(blockName)) {
-            return Optional.of(BiomeTint.FOLIAGE);
-        }
-        if (blockName.equals("leaf_litter")) {
-            return Optional.of(BiomeTint.DRY_FOLIAGE);
-        }
-        if (blockName.equals("water_cauldron")) {
-            return Optional.of(BiomeTint.WATER);
-        }
-        return Optional.empty();
-    }
-
-    static int fixedTint(String blockName, Map<String, String> properties, int tintIndex) {
-        if (tintIndex != 0) {
-            return NO_TINT;
-        }
-        if (GROWING_STEMS.contains(blockName)) {
-            return stemTint(Integer.parseInt(properties.getOrDefault("age", "0")));
-        }
-        return FIXED_TINTS.getOrDefault(blockName, NO_TINT);
-    }
-
-    private static int stemTint(int age) {
-        return (age * 32) << 16 | (255 - age * 8) << 8 | (age * 4);
-    }
-}
@@ -1,145 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.google.gson.JsonObject;
-import com.google.gson.JsonParser;
-import com.volmit.iris.Iris;
-import org.bukkit.Bukkit;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.net.URI;
-import java.net.http.HttpClient;
-import java.net.http.HttpRequest;
-import java.net.http.HttpResponse;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.StandardCopyOption;
-import java.security.DigestInputStream;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
-import java.time.Duration;
-import java.util.HexFormat;
-import java.util.concurrent.CompletableFuture;
-import java.util.zip.ZipFile;
-
-final class MinecraftClientJar {
-    private static final URI VERSION_MANIFEST = URI.create("https://piston-meta.mojang.com/mc/game/version_manifest_v2.json");
-    private static final Duration CONNECT_TIMEOUT = Duration.ofSeconds(15);
-    private static final Duration DOWNLOAD_TIMEOUT = Duration.ofMinutes(10);
-    private static final HttpClient HTTP = HttpClient.newBuilder()
-            .connectTimeout(CONNECT_TIMEOUT)
-            .followRedirects(HttpClient.Redirect.NORMAL)
-            .build();
-
-    private MinecraftClientJar() {
-    }
-
-    static boolean isCached() {
-        return cachedJar().exists();
-    }
-
-    static CompletableFuture<ZipFile> open() {
-        return CompletableFuture.supplyAsync(() -> {
-            try {
-                File jar = cachedJar();
-                if (!jar.exists()) {
-                    download(Bukkit.getMinecraftVersion(), jar.toPath());
-                }
-                return new ZipFile(jar);
-            } catch (IOException | InterruptedException error) {
-                throw new IllegalStateException(readableReason(error), error);
-            }
-        }, MinecraftClientJar::runInBackground);
-    }
-
-    private static void runInBackground(Runnable task) {
-        Thread thread = new Thread(task, "Iris Minecraft Client Download");
-        thread.setDaemon(true);
-        thread.start();
-    }
-
-    private static File cachedJar() {
-        return Iris.instance.getDataFile("cache", "minecraft-client", Bukkit.getMinecraftVersion() + ".jar");
-    }
-
-    private static void download(String version, Path destination) throws IOException, InterruptedException {
-        JsonObject versionInfo = fetchJson(findVersionUrl(version));
-        JsonObject client = versionInfo.getAsJsonObject("downloads").getAsJsonObject("client");
-        URI clientUrl = URI.create(client.get("url").getAsString());
-        String expectedSha1 = client.get("sha1").getAsString();
-
-        Path partial = destination.resolveSibling(destination.getFileName() + ".part");
-        HttpResponse<InputStream> response = HTTP.send(
-                HttpRequest.newBuilder(clientUrl).timeout(DOWNLOAD_TIMEOUT).build(),
-                HttpResponse.BodyHandlers.ofInputStream()
-        );
-        requireSuccess(response.statusCode(), clientUrl);
-        String actualSha1;
-        try (DigestInputStream body = new DigestInputStream(response.body(), sha1())) {
-            Files.copy(body, partial, StandardCopyOption.REPLACE_EXISTING);
-            actualSha1 = HexFormat.of().formatHex(body.getMessageDigest().digest());
-        }
-        if (!actualSha1.equalsIgnoreCase(expectedSha1)) {
-            Files.deleteIfExists(partial);
-            throw new IOException("the downloaded client jar was damaged (checksum mismatch)");
-        }
-        Files.move(partial, destination, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE);
-    }
-
-    private static URI findVersionUrl(String version) throws IOException, InterruptedException {
-        for (var entry : fetchJson(VERSION_MANIFEST).getAsJsonArray("versions")) {
-            JsonObject candidate = entry.getAsJsonObject();
-            if (candidate.get("id").getAsString().equals(version)) {
-                return URI.create(candidate.get("url").getAsString());
-            }
-        }
-        throw new IOException("Mojang doesn't list Minecraft " + version);
-    }
-
-    private static JsonObject fetchJson(URI url) throws IOException, InterruptedException {
-        HttpResponse<String> response = HTTP.send(
-                HttpRequest.newBuilder(url).timeout(CONNECT_TIMEOUT).build(),
-                HttpResponse.BodyHandlers.ofString()
-        );
-        requireSuccess(response.statusCode(), url);
-        return JsonParser.parseString(response.body()).getAsJsonObject();
-    }
-
-    private static void requireSuccess(int statusCode, URI url) throws IOException {
-        if (statusCode / 100 != 2) {
-            throw new IOException(url.getHost() + " answered HTTP " + statusCode);
-        }
-    }
-
-    private static MessageDigest sha1() {
-        try {
-            return MessageDigest.getInstance("SHA-1");
-        } catch (NoSuchAlgorithmException error) {
-            throw new IllegalStateException(error);
-        }
-    }
-
-    private static String readableReason(Throwable error) {
-        String message = error.getMessage();
-        return message == null || message.isBlank() ? error.getClass().getSimpleName() : message;
-    }
-}
@@ -1,124 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import java.awt.Color;
-
-enum NoisePalette implements NoiseColorScale {
-    TERRAIN("Terrain", 0D, 1D, new int[]{0x071A2F, 0x155E75, 0x2A9D8F, 0xE9C46A, 0xF4F1DE}),
-    SIGNED("Signed", -1D, 1D, new int[]{0x173B66, 0x4F86C6, 0xE7EDF3, 0xE89555, 0x9D3B35}),
-    GRAYSCALE("Grayscale", 0D, 1D, new int[]{0x050505, 0xFFFFFF});
-
-    static final int INVALID_COLOR = 0xFF2DAA;
-
-    private final String label;
-    private final double minimum;
-    private final double maximum;
-    private final int[] lookup;
-    private final Color[] displayColors;
-
-    NoisePalette(String label, double minimum, double maximum, int[] stops) {
-        this.label = label;
-        this.minimum = minimum;
-        this.maximum = maximum;
-        this.lookup = buildLookup(stops);
-        this.displayColors = buildDisplayColors(lookup);
-    }
-
-    int color(double value) {
-        if (!Double.isFinite(value)) {
-            return INVALID_COLOR;
-        }
-        return colorFinite(value);
-    }
-
-    @Override
-    public int colorFinite(double value) {
-        double normalized = (value - minimum) / (maximum - minimum);
-        return colorNormalized(normalized);
-    }
-
-    int colorNormalized(double normalized) {
-        double clipped = Math.max(0D, Math.min(1D, normalized));
-        return lookup[(int) Math.round(clipped * (lookup.length - 1))];
-    }
-
-    @Override
-    public int colorInvalid() {
-        return INVALID_COLOR;
-    }
-
-    @Override
-    public Color displayColorNormalized(double normalized) {
-        double clipped = Math.max(0D, Math.min(1D, normalized));
-        return displayColors[(int) Math.round(clipped * (displayColors.length - 1))];
-    }
-
-    @Override
-    public String label() {
-        return label;
-    }
-
-    @Override
-    public double minimum() {
-        return minimum;
-    }
-
-    @Override
-    public double maximum() {
-        return maximum;
-    }
-
-    @Override
-    public String toString() {
-        return label;
-    }
-
-    private static int[] buildLookup(int[] stops) {
-        int[] values = new int[256];
-        for (int index = 0; index < values.length; index++) {
-            double position = (index / 255D) * (stops.length - 1);
-            int lowerIndex = Math.min(stops.length - 2, (int) position);
-            double fraction = position - lowerIndex;
-            values[index] = interpolate(stops[lowerIndex], stops[lowerIndex + 1], fraction);
-        }
-        return values;
-    }
-
-    private static Color[] buildDisplayColors(int[] lookup) {
-        Color[] colors = new Color[lookup.length];
-        for (int index = 0; index < lookup.length; index++) {
-            colors[index] = new Color(lookup[index]);
-        }
-        return colors;
-    }
-
-    private static int interpolate(int from, int to, double fraction) {
-        int red = channel(from, 16, to, fraction);
-        int green = channel(from, 8, to, fraction);
-        int blue = channel(from, 0, to, fraction);
-        return (red << 16) | (green << 8) | blue;
-    }
-
-    private static int channel(int from, int shift, int to, double fraction) {
-        int fromChannel = (from >>> shift) & 0xFF;
-        int toChannel = (to >>> shift) & 0xFF;
-        return (int) Math.round(fromChannel + ((toChannel - fromChannel) * fraction));
-    }
-}
@@ -1,378 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.util.function.NoiseProvider;
-
-import java.awt.image.BufferedImage;
-import java.util.Objects;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.RejectedExecutionException;
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.concurrent.atomic.AtomicReference;
-
-final class NoiseRenderCoordinator implements AutoCloseable {
-    private static final int BANDS_PER_WORKER = 4;
-
-    private final int workerCount;
-    private final Listener listener;
-    private final ThreadPoolExecutor workers;
-    private final AtomicReference<RenderGeneration> latestRequested = new AtomicReference<>();
-    private final AtomicLong latestRevision = new AtomicLong();
-    private final AtomicBoolean closed = new AtomicBoolean();
-
-    NoiseRenderCoordinator(Listener listener) {
-        this(Math.min(4, Math.max(1, Runtime.getRuntime().availableProcessors() / 2)), listener);
-    }
-
-    NoiseRenderCoordinator(int workerCount, Listener listener) {
-        this.workerCount = Math.max(1, workerCount);
-        this.listener = Objects.requireNonNull(listener, "listener");
-        AtomicInteger threadIds = new AtomicInteger();
-        ThreadFactory workerThreadFactory = runnable -> {
-            Thread thread = new Thread(runnable, "Iris Noise Renderer " + threadIds.incrementAndGet());
-            thread.setDaemon(true);
-            thread.setPriority(Thread.MIN_PRIORITY);
-            return thread;
-        };
-        workers = new ThreadPoolExecutor(this.workerCount, this.workerCount, 30L, TimeUnit.SECONDS,
-                new LinkedBlockingQueue<>(), workerThreadFactory);
-        workers.allowCoreThreadTimeOut(true);
-        GuiHost.interruptOnPluginShutdown(workers);
-    }
-
-    void request(Request request) {
-        Objects.requireNonNull(request, "request");
-        if (closed.get()) {
-            return;
-        }
-        latestRevision.accumulateAndGet(request.revision(), Math::max);
-        RenderGeneration generation = new RenderGeneration(request, Math.min(workerCount * BANDS_PER_WORKER, outputHeight(request)));
-        latestRequested.set(generation);
-        listener.onRenderStarted(request);
-        for (int band = 0; band < generation.bandCount(); band++) {
-            int bandIndex = band;
-            try {
-                workers.execute(() -> renderBand(generation, bandIndex));
-            } catch (RejectedExecutionException rejected) {
-                generation.fail(rejected);
-                finishBand(generation);
-            }
-        }
-    }
-
-    void cancel(long revision) {
-        latestRevision.accumulateAndGet(revision, Math::max);
-        latestRequested.set(null);
-    }
-
-    boolean isClosed() {
-        return closed.get();
-    }
-
-    static int sampleStepForBudget(int width, int height, long sampleBudget) {
-        if (width < 1 || height < 1 || sampleBudget < 1L) {
-            throw new IllegalArgumentException("Invalid noise sample budget");
-        }
-        long totalSamples = (long) width * height;
-        int sampleStep = Math.max(1, (int) Math.ceil(Math.sqrt(totalSamples / (double) sampleBudget)));
-        while (sampleCount(width, height, sampleStep) > sampleBudget) {
-            sampleStep++;
-        }
-        return sampleStep;
-    }
-
-    static long sampleCount(int width, int height, int sampleStep) {
-        if (width < 1 || height < 1 || sampleStep < 1) {
-            throw new IllegalArgumentException("Invalid noise sample dimensions");
-        }
-        long outputWidth = ((long) width + sampleStep - 1L) / sampleStep;
-        long outputHeight = ((long) height + sampleStep - 1L) / sampleStep;
-        return outputWidth * outputHeight;
-    }
-
-    static int nextRefinementStep(int width, int height, int currentStep, long sampleBudget) {
-        if (currentStep <= 1) {
-            throw new IllegalArgumentException("Noise refinement requires a coarse input");
-        }
-        return Math.min(currentStep, sampleStepForBudget(width, height, sampleBudget));
-    }
-
-    static long timeBoundSampleBudget(long completedSamples, double milliseconds, double targetMilliseconds,
-                                      long minimumBudget, long maximumBudget) {
-        if (completedSamples < 1L
-                || !Double.isFinite(milliseconds)
-                || milliseconds <= 0D
-                || !Double.isFinite(targetMilliseconds)
-                || targetMilliseconds <= 0D
-                || minimumBudget < 1L
-                || maximumBudget < minimumBudget) {
-            throw new IllegalArgumentException("Invalid timed noise sample budget");
-        }
-        double projectedSamples = Math.ceil((completedSamples / milliseconds) * targetMilliseconds);
-        long timeBoundBudget = (long) Math.min(maximumBudget, projectedSamples);
-        return Math.max(minimumBudget, timeBoundBudget);
-    }
-
-    @Override
-    public void close() {
-        if (!closed.compareAndSet(false, true)) {
-            return;
-        }
-        latestRevision.incrementAndGet();
-        latestRequested.set(null);
-        workers.shutdownNow();
-    }
-
-    // Bands of a frame that was replaced are skipped, so a new frame only waits for the rows already being drawn.
-    private void renderBand(RenderGeneration generation, int bandIndex) {
-        try {
-            if (isCurrent(generation)) {
-                renderRows(generation, bandIndex);
-            }
-        } catch (Throwable error) {
-            generation.fail(error);
-        } finally {
-            finishBand(generation);
-        }
-    }
-
-    private void finishBand(RenderGeneration generation) {
-        if (!generation.completeBand() || !isCurrent(generation)) {
-            return;
-        }
-        Throwable failure = generation.failure();
-        if (failure != null) {
-            listener.onRenderFailed(generation.request(), failure);
-            return;
-        }
-        listener.onRenderCompleted(generation.result());
-    }
-
-    private void renderRows(RenderGeneration generation, int bandIndex) {
-        Request request = generation.request();
-        int outputWidth = generation.outputWidth();
-        int outputHeight = generation.outputHeight();
-        int[] pixels = generation.pixels();
-        BandStats stats = generation.bandStats(bandIndex);
-        int fromY = (outputHeight * bandIndex) / generation.bandCount();
-        int toY = (outputHeight * (bandIndex + 1)) / generation.bandCount();
-        double sampleOffset = request.sampleStep() * 0.5D;
-        double startWorldX = request.viewport().worldX(sampleOffset, request.width());
-        double worldStep = request.viewport().blocksPerPixel() * request.sampleStep();
-        NoiseColorScale colorScale = request.colorScale();
-        double paletteMinimum = colorScale.minimum();
-        double paletteMaximum = colorScale.maximum();
-        for (int y = fromY; y < toY; y++) {
-            double screenY = (y * (double) request.sampleStep()) + sampleOffset;
-            double worldZ = request.viewport().worldZ(screenY, request.height());
-            double worldX = startWorldX;
-            int pixelIndex = y * outputWidth;
-            boolean centerRow = y == outputHeight / 2;
-            for (int x = 0; x < outputWidth; x++) {
-                if ((x & 31) == 0 && (!isCurrent(generation) || Thread.currentThread().isInterrupted())) {
-                    return;
-                }
-                double value = request.sampler().noise(worldX, worldZ);
-                boolean center = centerRow && x == outputWidth / 2;
-                if (Double.isFinite(value)) {
-                    pixels[pixelIndex++] = colorScale.colorAt(value, worldX, worldZ);
-                    stats.acceptFinite(value, center, paletteMinimum, paletteMaximum);
-                } else {
-                    pixels[pixelIndex++] = colorScale.colorInvalidAt(worldX, worldZ);
-                    stats.acceptInvalid(value, center);
-                }
-                worldX += worldStep;
-            }
-        }
-    }
-
-    private boolean isCurrent(RenderGeneration generation) {
-        return !closed.get()
-                && latestRequested.get() == generation
-                && generation.request().revision() >= latestRevision.get();
-    }
-
-    private static int outputWidth(Request request) {
-        return Math.max(1, (request.width() + request.sampleStep() - 1) / request.sampleStep());
-    }
-
-    private static int outputHeight(Request request) {
-        return Math.max(1, (request.height() + request.sampleStep() - 1) / request.sampleStep());
-    }
-
-    private static RenderStats combine(BandStats[] bands) {
-        long samples = 0L;
-        long underflow = 0L;
-        long overflow = 0L;
-        long invalid = 0L;
-        double minimum = Double.POSITIVE_INFINITY;
-        double maximum = Double.NEGATIVE_INFINITY;
-        double centerValue = Double.NaN;
-        for (BandStats band : bands) {
-            samples += band.samples;
-            underflow += band.underflow;
-            overflow += band.overflow;
-            invalid += band.invalid;
-            minimum = Math.min(minimum, band.minimum);
-            maximum = Math.max(maximum, band.maximum);
-            if (!Double.isNaN(band.centerValue)) {
-                centerValue = band.centerValue;
-            }
-        }
-        if (minimum == Double.POSITIVE_INFINITY) {
-            minimum = Double.NaN;
-            maximum = Double.NaN;
-        }
-        return new RenderStats(samples, minimum, maximum, centerValue, underflow, overflow, invalid);
-    }
-
-    interface Listener {
-        void onRenderStarted(Request request);
-
-        void onRenderCompleted(Result result);
-
-        void onRenderFailed(Request request, Throwable error);
-    }
-
-    record Request(long revision, NoiseProvider sampler, NoiseViewport viewport, NoiseColorScale colorScale,
-                   int width, int height, int sampleStep) {
-        Request {
-            Objects.requireNonNull(sampler, "sampler");
-            Objects.requireNonNull(viewport, "viewport");
-            Objects.requireNonNull(colorScale, "colorScale");
-            if (revision < 0L || width < 1 || height < 1 || sampleStep < 1) {
-                throw new IllegalArgumentException("Invalid noise render request");
-            }
-        }
-    }
-
-    record Result(Request request, BufferedImage image, double milliseconds, long samples, double minimum,
-                  double maximum, double centerValue, long underflow, long overflow, long invalid) {
-    }
-
-    private static final class RenderGeneration {
-        private final Request request;
-        private final long startedNanos = System.nanoTime();
-        private final int outputWidth;
-        private final int outputHeight;
-        private final int[] pixels;
-        private final BandStats[] bandStats;
-        private final AtomicInteger remainingBands;
-        private final AtomicReference<Throwable> failure = new AtomicReference<>();
-
-        private RenderGeneration(Request request, int bandCount) {
-            this.request = request;
-            this.outputWidth = NoiseRenderCoordinator.outputWidth(request);
-            this.outputHeight = NoiseRenderCoordinator.outputHeight(request);
-            this.pixels = new int[outputWidth * outputHeight];
-            this.bandStats = new BandStats[Math.max(1, bandCount)];
-            for (int band = 0; band < bandStats.length; band++) {
-                bandStats[band] = new BandStats();
-            }
-            this.remainingBands = new AtomicInteger(bandStats.length);
-        }
-
-        private Request request() {
-            return request;
-        }
-
-        private int bandCount() {
-            return bandStats.length;
-        }
-
-        private int outputWidth() {
-            return outputWidth;
-        }
-
-        private int outputHeight() {
-            return outputHeight;
-        }
-
-        private int[] pixels() {
-            return pixels;
-        }
-
-        private BandStats bandStats(int band) {
-            return bandStats[band];
-        }
-
-        private void fail(Throwable error) {
-            failure.compareAndSet(null, error);
-        }
-
-        private Throwable failure() {
-            return failure.get();
-        }
-
-        // True for the band that finishes last, which is the one that publishes the frame.
-        private boolean completeBand() {
-            return remainingBands.decrementAndGet() == 0;
-        }
-
-        private Result result() {
-            BufferedImage image = GuiHost.uncachedImage(pixels, outputWidth, outputHeight);
-            RenderStats combined = combine(bandStats);
-            double milliseconds = (System.nanoTime() - startedNanos) / 1_000_000D;
-            return new Result(request, image, milliseconds, combined.samples, combined.minimum, combined.maximum,
-                    combined.centerValue, combined.underflow, combined.overflow, combined.invalid);
-        }
-    }
-
-    private static final class BandStats {
-        private long samples;
-        private long underflow;
-        private long overflow;
-        private long invalid;
-        private double minimum = Double.POSITIVE_INFINITY;
-        private double maximum = Double.NEGATIVE_INFINITY;
-        private double centerValue = Double.NaN;
-
-        private void acceptFinite(double value, boolean center, double paletteMinimum, double paletteMaximum) {
-            samples++;
-            if (center) {
-                centerValue = value;
-            }
-            minimum = Math.min(minimum, value);
-            maximum = Math.max(maximum, value);
-            if (value < paletteMinimum) {
-                underflow++;
-            } else if (value > paletteMaximum) {
-                overflow++;
-            }
-        }
-
-        private void acceptInvalid(double value, boolean center) {
-            samples++;
-            invalid++;
-            if (center) {
-                centerValue = value;
-            }
-        }
-    }
-
-    private record RenderStats(long samples, double minimum, double maximum, double centerValue,
-                               long underflow, long overflow, long invalid) {
-    }
-}
@@ -1,70 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-record NoiseViewport(double centerX, double centerZ, double blocksPerPixel) {
-    static final double MIN_BLOCKS_PER_PIXEL = 0.0001D;
-    static final double MAX_BLOCKS_PER_PIXEL = 1_000_000D;
-
-    NoiseViewport {
-        if (!Double.isFinite(centerX) || !Double.isFinite(centerZ)) {
-            throw new IllegalArgumentException("Viewport center must be finite");
-        }
-        if (!Double.isFinite(blocksPerPixel) || blocksPerPixel <= 0D) {
-            throw new IllegalArgumentException("Viewport scale must be finite and positive");
-        }
-    }
-
-    double worldX(double screenX, int width) {
-        return centerX + ((screenX - (width / 2D)) * blocksPerPixel);
-    }
-
-    double worldZ(double screenZ, int height) {
-        return centerZ + ((screenZ - (height / 2D)) * blocksPerPixel);
-    }
-
-    double screenX(double worldX, int width) {
-        return ((worldX - centerX) / blocksPerPixel) + (width / 2D);
-    }
-
-    double screenZ(double worldZ, int height) {
-        return ((worldZ - centerZ) / blocksPerPixel) + (height / 2D);
-    }
-
-    NoiseViewport panPixels(double deltaX, double deltaZ) {
-        return new NoiseViewport(
-                centerX - (deltaX * blocksPerPixel),
-                centerZ - (deltaZ * blocksPerPixel),
-                blocksPerPixel
-        );
-    }
-
-    NoiseViewport zoomAt(double screenX, double screenZ, int width, int height, double factor) {
-        if (!Double.isFinite(factor) || factor <= 0D) {
-            throw new IllegalArgumentException("Zoom factor must be finite and positive");
-        }
-        double anchorX = worldX(screenX, width);
-        double anchorZ = worldZ(screenZ, height);
-        double nextScale = Math.max(MIN_BLOCKS_PER_PIXEL,
-                Math.min(MAX_BLOCKS_PER_PIXEL, blocksPerPixel * factor));
-        double nextCenterX = anchorX - ((screenX - (width / 2D)) * nextScale);
-        double nextCenterZ = anchorZ - ((screenZ - (height / 2D)) * nextScale);
-        return new NoiseViewport(nextCenterX, nextCenterZ, nextScale);
-    }
-}
@@ -1,270 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import javax.swing.JLabel;
-import javax.swing.JPanel;
-import javax.swing.JTextField;
-import javax.swing.JTree;
-import javax.swing.ToolTipManager;
-import javax.swing.event.DocumentEvent;
-import javax.swing.event.DocumentListener;
-import javax.swing.tree.DefaultMutableTreeNode;
-import javax.swing.tree.DefaultTreeCellRenderer;
-import javax.swing.tree.DefaultTreeModel;
-import javax.swing.tree.TreePath;
-import javax.swing.tree.TreeSelectionModel;
-import java.awt.BorderLayout;
-import java.awt.Component;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.function.Consumer;
-
-/**
- * Every object in the pack as a folder tree, with a search that matches every word typed anywhere in an object's path.
- */
-final class ObjectBrowser extends JPanel {
-    private static final long serialVersionUID = 6795434561028735214L;
-    private static final int ROW_HEIGHT = 24;
-
-    private final Consumer<String> onObjectChosen;
-    private final JTextField searchField = new JTextField();
-    private final DefaultTreeModel treeModel = new DefaultTreeModel(new DefaultMutableTreeNode());
-    private final JTree tree = new JTree(treeModel);
-    private final JLabel countLabel = new JLabel("Loading objects...");
-    private List<String> objectKeys = List.of();
-    private String chosenKey;
-    private boolean updatingSelection;
-
-    ObjectBrowser(Consumer<String> onObjectChosen) {
-        super(new BorderLayout());
-        this.onObjectChosen = onObjectChosen;
-        StudioToolbar.makeSearchField(searchField, "Search objects...");
-        searchField.getDocument().addDocumentListener(new DocumentListener() {
-            @Override
-            public void insertUpdate(DocumentEvent event) {
-                rebuildTree();
-            }
-
-            @Override
-            public void removeUpdate(DocumentEvent event) {
-                rebuildTree();
-            }
-
-            @Override
-            public void changedUpdate(DocumentEvent event) {
-                rebuildTree();
-            }
-        });
-        tree.setRootVisible(false);
-        tree.setShowsRootHandles(true);
-        tree.setRowHeight(StudioTheme.scale(ROW_HEIGHT));
-        tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
-        tree.setCellRenderer(new EntryRenderer());
-        ToolTipManager.sharedInstance().registerComponent(tree);
-        tree.addTreeSelectionListener(event -> {
-            if (!updatingSelection && nodeAt(event.getPath()) instanceof Entry entry && entry.isObject()) {
-                chosenKey = entry.key();
-                onObjectChosen.accept(entry.key());
-            }
-        });
-        countLabel.setFont(StudioTheme.smallFont());
-        countLabel.setForeground(StudioTheme.SECONDARY_TEXT);
-        add(StudioToolbar.padded(searchField, 8, 8, 8, 8), BorderLayout.NORTH);
-        add(StickyFolderHeaders.around(tree, StudioToolbar.scroll(tree)), BorderLayout.CENTER);
-        add(StudioToolbar.padded(countLabel, 6, 12, 8, 12), BorderLayout.SOUTH);
-    }
-
-    void showObjects(List<String> keys) {
-        objectKeys = keys.stream().sorted(Comparator.comparing(key -> key.toLowerCase(Locale.ROOT))).toList();
-        countLabel.setText(objectKeys.size() == 1 ? "1 object" : objectKeys.size() + " objects");
-        rebuildTree();
-    }
-
-    void showError(String text) {
-        countLabel.setText(text);
-    }
-
-    String firstObject() {
-        return objectKeys.isEmpty() ? null : objectKeys.get(0);
-    }
-
-    private void rebuildTree() {
-        String[] words = searchField.getText().trim().toLowerCase(Locale.ROOT).split("\\s+");
-        boolean searching = !searchField.getText().isBlank();
-        DefaultMutableTreeNode root = searching ? searchResults(words) : folderTree();
-        treeModel.setRoot(root);
-        if (searching) {
-            expandAll();
-        }
-        selectChosen();
-    }
-
-    private DefaultMutableTreeNode searchResults(String[] words) {
-        DefaultMutableTreeNode root = new DefaultMutableTreeNode();
-        for (String key : objectKeys) {
-            if (matchesEveryWord(key, words)) {
-                root.add(new DefaultMutableTreeNode(Entry.object(key, key)));
-            }
-        }
-        if (root.getChildCount() == 0) {
-            root.add(new DefaultMutableTreeNode(Entry.note("No matching objects")));
-        }
-        return root;
-    }
-
-    private static boolean matchesEveryWord(String key, String[] words) {
-        String lowerKey = key.toLowerCase(Locale.ROOT);
-        for (String word : words) {
-            if (!lowerKey.contains(word)) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    // Folders come before the objects beside them, like a file browser.
-    private DefaultMutableTreeNode folderTree() {
-        Folder top = new Folder();
-        for (String key : objectKeys) {
-            Folder folder = top;
-            String[] parts = key.split("/");
-            for (int index = 0; index < parts.length - 1; index++) {
-                folder = folder.subfolders.computeIfAbsent(parts[index], name -> new Folder());
-            }
-            folder.objects.add(key);
-        }
-        DefaultMutableTreeNode root = new DefaultMutableTreeNode();
-        addFolderContents(root, top, "");
-        return root;
-    }
-
-    private static void addFolderContents(DefaultMutableTreeNode node, Folder folder, String path) {
-        for (Map.Entry<String, Folder> subfolder : folder.subfolders.entrySet()) {
-            String subfolderPath = path + subfolder.getKey() + "/";
-            DefaultMutableTreeNode child = new DefaultMutableTreeNode(Entry.folder(subfolder.getKey(), subfolderPath));
-            addFolderContents(child, subfolder.getValue(), subfolderPath);
-            node.add(child);
-        }
-        for (String key : folder.objects) {
-            node.add(new DefaultMutableTreeNode(Entry.object(key.substring(key.lastIndexOf('/') + 1), key)));
-        }
-    }
-
-    void select(String key) {
-        chosenKey = key;
-        selectChosen();
-    }
-
-    private void selectChosen() {
-        DefaultMutableTreeNode node = chosenKey == null ? null : findObjectNode((DefaultMutableTreeNode) treeModel.getRoot());
-        updatingSelection = true;
-        try {
-            if (node == null) {
-                tree.clearSelection();
-                return;
-            }
-            TreePath path = new TreePath(node.getPath());
-            tree.setSelectionPath(path);
-            tree.scrollPathToVisible(path);
-        } finally {
-            updatingSelection = false;
-        }
-    }
-
-    private DefaultMutableTreeNode findObjectNode(DefaultMutableTreeNode node) {
-        if (node.getUserObject() instanceof Entry entry && entry.isObject() && entry.key().equals(chosenKey)) {
-            return node;
-        }
-        for (int index = 0; index < node.getChildCount(); index++) {
-            DefaultMutableTreeNode found = findObjectNode((DefaultMutableTreeNode) node.getChildAt(index));
-            if (found != null) {
-                return found;
-            }
-        }
-        return null;
-    }
-
-    private void expandAll() {
-        for (int row = 0; row < tree.getRowCount(); row++) {
-            tree.expandRow(row);
-        }
-    }
-
-    private static Object nodeAt(TreePath path) {
-        return path == null ? null : ((DefaultMutableTreeNode) path.getLastPathComponent()).getUserObject();
-    }
-
-    private static final class Folder {
-        private final Map<String, Folder> subfolders = new LinkedHashMap<>();
-        private final List<String> objects = new ArrayList<>();
-    }
-
-    /**
-     * A row of the tree: an object with its key, a folder with its path, or a note without either.
-     */
-    private record Entry(String label, String key, String folderPath) {
-        static Entry object(String label, String key) {
-            return new Entry(label, key, null);
-        }
-
-        static Entry folder(String label, String path) {
-            return new Entry(label, null, path);
-        }
-
-        static Entry note(String text) {
-            return new Entry(text, null, null);
-        }
-
-        boolean isObject() {
-            return key != null;
-        }
-
-        @Override
-        public String toString() {
-            return label;
-        }
-    }
-
-    private static final class EntryRenderer extends DefaultTreeCellRenderer {
-        private static final long serialVersionUID = -4316652201793418740L;
-
-        private EntryRenderer() {
-            setLeafIcon(null);
-            setOpenIcon(null);
-            setClosedIcon(null);
-        }
-
-        @Override
-        public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded,
-                                                      boolean leaf, int row, boolean focus) {
-            Object userObject = ((DefaultMutableTreeNode) value).getUserObject();
-            super.getTreeCellRendererComponent(tree, userObject == null ? "" : userObject.toString(), selected, expanded, leaf, row, false);
-            boolean isNote = userObject instanceof Entry entry && !entry.isObject() && entry.folderPath() == null;
-            setFont(StudioTheme.font());
-            setForeground(isNote ? StudioTheme.MUTED_TEXT : StudioTheme.TEXT);
-            setToolTipText(userObject instanceof Entry entry ? entry.isObject() ? entry.key() : entry.folderPath() : null);
-            return this;
-        }
-    }
-}
@@ -1,44 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-/**
- * Where the object viewer looks from: turned by yaw around the vertical axis, tilted down by pitch, both in radians.
- * Zoom 1 fits the object in the view at the starting angle. Pan moves the picture in fractions of the view's size.
- */
-record ObjectCamera(double yaw, double pitch, double zoom, double panX, double panY) {
-    static final ObjectCamera START = new ObjectCamera(0.76D, 0.38D, 1.72D, 0D, 0.025D);
-    private static final double RADIANS_PER_DRAGGED_PIXEL = 0.008D;
-    private static final double MAXIMUM_PITCH = 1.3D;
-    private static final double MINIMUM_ZOOM = 0.4D;
-    private static final double MAXIMUM_ZOOM = 12D;
-
-    ObjectCamera orbitedBy(double draggedX, double draggedY) {
-        double nextPitch = Math.max(-MAXIMUM_PITCH, Math.min(MAXIMUM_PITCH, pitch + draggedY * RADIANS_PER_DRAGGED_PIXEL));
-        return new ObjectCamera(yaw + draggedX * RADIANS_PER_DRAGGED_PIXEL, nextPitch, zoom, panX, panY);
-    }
-
-    ObjectCamera zoomedBy(double factor) {
-        return new ObjectCamera(yaw, pitch, Math.max(MINIMUM_ZOOM, Math.min(MAXIMUM_ZOOM, zoom * factor)), panX, panY);
-    }
-
-    ObjectCamera pannedBy(double fractionX, double fractionY) {
-        return new ObjectCamera(yaw, pitch, zoom, panX + fractionX, panY + fractionY);
-    }
-}
@@ -1,317 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.core.gui.BlockTextures.BlockTexture;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisObject;
-import org.bukkit.NamespacedKey;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.util.BlockVector;
-
-import javax.swing.JComponent;
-import java.awt.EventQueue;
-import java.awt.event.KeyEvent;
-import java.awt.image.BufferedImage;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.atomic.AtomicLong;
-
-/**
- * The map window's Objects view: every object in the pack in a folder tree, the chosen one in 3D, and what it is made
- * of. Inspired by the Procedural Objects workbench.
- */
-final class ObjectExplorer {
-    private static final NamespacedKey TINT_BIOME = NamespacedKey.minecraft("plains");
-    private static final int UNKNOWN_BLOCK_COLOR = 0x8A8A8A;
-    private static final String CAMERA_HINT = "Drag to orbit · Shift-drag to pan · Scroll to zoom · Page Up/Down cuts layers · R resets";
-
-    private final Engine startEngine;
-    private final UUID worldId;
-    private final ObjectBrowser browser = new ObjectBrowser(this::showObject);
-    private final ObjectViewport viewport = new ObjectViewport();
-    private final ObjectLayerCut layerCut = new ObjectLayerCut(shownLayers -> showLayerCut());
-    private final JComponent viewWithLayerCut = layerCut.floatingOver(viewport);
-    private final ObjectOverviewPanel overview = new ObjectOverviewPanel(this::showSeeThrough);
-    private final StudioStatusBar statusBar = new StudioStatusBar();
-    private final ExecutorService loader = Executors.newSingleThreadExecutor(runnable -> {
-        Thread thread = new Thread(runnable, "Iris Object Loader");
-        thread.setDaemon(true);
-        thread.setPriority(Thread.MIN_PRIORITY);
-        return thread;
-    });
-    private final AtomicLong objectRevision = new AtomicLong();
-    private final AtomicLong meshRevision = new AtomicLong();
-    private final Map<String, BlockModel> models = new ConcurrentHashMap<>();
-    private final Runnable hotloadHook = this::reloadPack;
-    private volatile BlockTextures textures;
-    private volatile BiomeTintColors tintColors;
-    private String shownKey;
-    private LoadedObject shown;
-    private ObjectMesh wholeMesh;
-    private Set<String> seeThroughTypes = Set.of();
-
-    ObjectExplorer(Engine engine, UUID worldId) {
-        this.startEngine = engine;
-        this.worldId = worldId;
-        GuiHost.interruptOnPluginShutdown(loader);
-        GuiHost.registerHotloadHook(hotloadHook);
-        statusBar.showPosition(CAMERA_HINT);
-        viewport.bindKey(KeyEvent.VK_PAGE_UP, "show-layer-above", () -> layerCut.stepBy(1));
-        viewport.bindKey(KeyEvent.VK_PAGE_DOWN, "hide-top-layer", () -> layerCut.stepBy(-1));
-    }
-
-    JComponent browser() {
-        return browser;
-    }
-
-    ObjectViewport viewport() {
-        return viewport;
-    }
-
-    /**
-     * The 3D view with the slider that cuts away its top layers.
-     */
-    JComponent view() {
-        return viewWithLayerCut;
-    }
-
-    JComponent overview() {
-        return overview;
-    }
-
-    StudioStatusBar statusBar() {
-        return statusBar;
-    }
-
-    void resetCamera() {
-        viewport.resetCamera();
-    }
-
-    // Textures load first, since the first object would otherwise be drawn in flat colours.
-    void open() {
-        statusBar.showActivity("Loading Minecraft textures...");
-        loader.execute(() -> {
-            loadTextures();
-            List<String> keys = objectKeys();
-            EventQueue.invokeLater(() -> showCatalog(keys));
-        });
-    }
-
-    void close() {
-        GuiHost.unregisterHotloadHook(hotloadHook);
-        objectRevision.incrementAndGet();
-        loader.shutdownNow();
-        viewport.close();
-    }
-
-    private void loadTextures() {
-        try {
-            BlockTextures loaded = BlockTextures.shared().join();
-            tintColors = loaded.biomeColors().vanilla(TINT_BIOME);
-            textures = loaded;
-        } catch (RuntimeException unavailable) {
-            EventQueue.invokeLater(() -> statusBar.showError("Minecraft textures are unavailable, objects use plain colours"));
-        }
-    }
-
-    private List<String> objectKeys() {
-        return Arrays.asList(engine().getData().getObjectLoader().getPossibleKeys());
-    }
-
-    private void showCatalog(List<String> keys) {
-        statusBar.showActivity("");
-        browser.showObjects(keys);
-        String key = shownKey != null && keys.contains(shownKey) ? shownKey : browser.firstObject();
-        if (key == null) {
-            viewport.showMessage("This pack has no objects");
-            overview.clear();
-            layerCut.showHeight(1);
-            return;
-        }
-        browser.select(key);
-        showObject(key);
-    }
-
-    private void showObject(String key) {
-        shownKey = key;
-        shown = null;
-        wholeMesh = null;
-        meshRevision.incrementAndGet();
-        long revision = objectRevision.incrementAndGet();
-        viewport.showMessage("Loading " + key + "...");
-        statusBar.showActivity("Loading " + key + "...");
-        loader.execute(() -> {
-            if (revision != objectRevision.get()) {
-                return;
-            }
-            try {
-                LoadedObject loaded = load(key);
-                EventQueue.invokeLater(() -> showLoaded(revision, loaded));
-            } catch (RuntimeException error) {
-                EventQueue.invokeLater(() -> showFailure(revision, key, error));
-            }
-        });
-    }
-
-    private LoadedObject load(String key) {
-        IrisObject object = engine().getData().getObjectLoader().load(key);
-        if (object == null) {
-            throw new IllegalStateException("The object file could not be read");
-        }
-        Map<BlockVector, BlockData> blocks = new HashMap<>();
-        object.getBlocks().forEach((position, block) -> {
-            if (!block.getMaterial().isAir()) {
-                blocks.put(position, block);
-            }
-        });
-        ObjectMesh mesh = ObjectMesh.build(blocks, this::modelOf);
-        ObjectSummary summary = ObjectSummary.of(key, mesh.bounds(), blocks.values(), this::iconOf);
-        return new LoadedObject(blocks, mesh, summary);
-    }
-
-    private void showLoaded(long revision, LoadedObject loaded) {
-        if (revision != objectRevision.get()) {
-            return;
-        }
-        shown = loaded;
-        wholeMesh = loaded.mesh();
-        seeThroughTypes = Set.of();
-        statusBar.showActivity("");
-        viewport.show(loaded.mesh());
-        overview.show(loaded.summary());
-        layerCut.showHeight(loaded.mesh().bounds().sizeY());
-        showMeshSummary(loaded.mesh());
-    }
-
-    private void showMeshSummary(ObjectMesh mesh) {
-        ObjectSummary summary = shown.summary();
-        String cut = layerCut.isCutting()
-                ? String.format(Locale.ROOT, " · showing layers 1-%d of %d", layerCut.shownLayerCount(), layerCut.layerCount())
-                : "";
-        statusBar.showSummary(String.format(Locale.ROOT, "%s · %,d blocks · %,d faces drawn%s",
-                summary.key(), summary.blockCount(), mesh.faceCount(), cut));
-    }
-
-    private void showSeeThrough(Set<String> blockTypes) {
-        seeThroughTypes = blockTypes;
-        rebuildWholeMesh();
-    }
-
-    // Blocks behind see-through ones get their hidden faces back, so the mesh is built again.
-    private void rebuildWholeMesh() {
-        LoadedObject object = shown;
-        if (object == null) {
-            return;
-        }
-        long revision = meshRevision.incrementAndGet();
-        Set<String> seeThrough = seeThroughTypes;
-        loader.execute(() -> {
-            if (revision != meshRevision.get()) {
-                return;
-            }
-            ObjectMesh mesh = seeThrough.isEmpty()
-                    ? object.mesh()
-                    : ObjectMesh.build(object.blocks(), this::modelOf, object.mesh().bounds(),
-                    block -> seeThrough.contains(block.getMaterial().getKey().getKey()));
-            EventQueue.invokeLater(() -> {
-                if (revision == meshRevision.get() && shown == object) {
-                    wholeMesh = mesh;
-                    showLayerCut();
-                }
-            });
-        });
-    }
-
-    private void showLayerCut() {
-        if (wholeMesh == null) {
-            return;
-        }
-        int highestShownY = wholeMesh.bounds().minY() + layerCut.shownLayerCount() - 1;
-        ObjectMesh mesh = layerCut.isCutting() ? wholeMesh.cutAbove(highestShownY) : wholeMesh;
-        viewport.replaceMesh(mesh);
-        showMeshSummary(mesh);
-    }
-
-    private void showFailure(long revision, String key, Throwable error) {
-        if (revision != objectRevision.get()) {
-            return;
-        }
-        statusBar.showActivity("");
-        viewport.showMessage("Could not load " + key);
-        overview.clear();
-        layerCut.showHeight(1);
-        statusBar.showError(error.getMessage() == null ? error.getClass().getSimpleName() : error.getMessage());
-    }
-
-    // The pack's files may have changed, so the list and the shown object are read again.
-    private void reloadPack() {
-        loader.execute(() -> {
-            List<String> keys = objectKeys();
-            EventQueue.invokeLater(() -> showCatalog(keys));
-        });
-    }
-
-    private Engine engine() {
-        Engine current = GuiHost.findEngine(worldId);
-        return current != null && !current.isClosed() ? current : startEngine;
-    }
-
-    private BlockModel modelOf(BlockData block) {
-        return models.computeIfAbsent(block.getAsString(false), state -> {
-            BlockTextures available = textures;
-            if (available == null) {
-                return BlockModel.solidColor(UNKNOWN_BLOCK_COLOR);
-            }
-            return available.model(block).map(this::withBiomeTint).orElseGet(() -> BlockModel.solidColor(UNKNOWN_BLOCK_COLOR));
-        });
-    }
-
-    private BufferedImage iconOf(BlockData block) {
-        BlockTextures available = textures;
-        if (available == null) {
-            return null;
-        }
-        return available.iconTexture(block).map(this::withBiomeTint).map(BlockTexture::toImage).orElse(null);
-    }
-
-    // Objects have no biome of their own, so grass and leaves get plains' colours.
-    private BlockModel withBiomeTint(BlockModel model) {
-        return model.withTextures(this::withBiomeTint);
-    }
-
-    private BlockTexture withBiomeTint(BlockTexture texture) {
-        BiomeTintColors colors = tintColors;
-        if (texture.biomeTint() == null || colors == null) {
-            return texture;
-        }
-        return texture.tinted(colors.colorAt(texture.biomeTint(), 0, 0));
-    }
-
-    private record LoadedObject(Map<BlockVector, BlockData> blocks, ObjectMesh mesh, ObjectSummary summary) {
-    }
-}
@@ -1,179 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-
-package com.volmit.iris.core.gui;
-
-import javax.swing.JComponent;
-import javax.swing.JLabel;
-import javax.swing.JPanel;
-import javax.swing.JSlider;
-import javax.swing.SwingConstants;
-import java.awt.AlphaComposite;
-import java.awt.BorderLayout;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
-import java.util.function.IntConsumer;
-
-/**
- * A slim slider floating on the right of the 3D view that hides an object's top layers, to look inside buildings
- * floor by floor. Most objects never need it, so it stays faint until the mouse comes near or a cut is active.
- */
-final class ObjectLayerCut extends JPanel {
-    private static final long serialVersionUID = 4473820211915526120L;
-    private static final int PANEL_WIDTH = 30;
-    private static final int MAX_HEIGHT = 320;
-    private static final double HEIGHT_SHARE_OF_VIEW = 0.5D;
-    private static final int EDGE_MARGIN = 8;
-    private static final float FAINT_OPACITY = 0.28F;
-
-    private final JSlider slider = new JSlider(SwingConstants.VERTICAL, 1, 1, 1);
-    private final JLabel shownLayers = new JLabel(" ", SwingConstants.CENTER);
-    private final IntConsumer onLayersChanged;
-    private boolean resetting;
-    private boolean hovered;
-
-    /**
-     * @param onLayersChanged told how many layers from the bottom stay visible whenever the user moves the slider
-     */
-    ObjectLayerCut(IntConsumer onLayersChanged) {
-        super(new BorderLayout(0, StudioTheme.scale(4)));
-        this.onLayersChanged = onLayersChanged;
-        setOpaque(false);
-        setToolTipText("Hide the top layers to look inside · Page Up / Page Down");
-        shownLayers.setFont(StudioTheme.smallFont());
-        shownLayers.setForeground(StudioTheme.SECONDARY_TEXT);
-        slider.setOpaque(false);
-        slider.setFocusable(false);
-        slider.setToolTipText(getToolTipText());
-        slider.addChangeListener(event -> {
-            showLayerLabel();
-            if (!resetting) {
-                onLayersChanged.accept(slider.getValue());
-            }
-        });
-        MouseAdapter hover = new MouseAdapter() {
-            @Override
-            public void mouseEntered(MouseEvent event) {
-                setHovered(true);
-            }
-
-            @Override
-            public void mouseExited(MouseEvent event) {
-                setHovered(slider.getValueIsAdjusting());
-            }
-
-            @Override
-            public void mouseReleased(MouseEvent event) {
-                setHovered(slider.contains(event.getPoint()));
-            }
-        };
-        slider.addMouseListener(hover);
-        addMouseListener(hover);
-        add(shownLayers, BorderLayout.NORTH);
-        add(slider, BorderLayout.CENTER);
-        showHeight(1);
-    }
-
-    /**
-     * The view with this slider floating over its right edge, halfway down.
-     */
-    JComponent floatingOver(JComponent view) {
-        ObjectLayerCut cut = this;
-        JPanel stack = new JPanel(null) {
-            private static final long serialVersionUID = -1950381405658102347L;
-
-            // The slider overlaps the view, so the view may not repaint without the slider on top of it.
-            @Override
-            public boolean isOptimizedDrawingEnabled() {
-                return false;
-            }
-
-            @Override
-            public void doLayout() {
-                view.setBounds(0, 0, getWidth(), getHeight());
-                int width = StudioTheme.scale(PANEL_WIDTH);
-                int height = Math.min(StudioTheme.scale(MAX_HEIGHT), (int) (getHeight() * HEIGHT_SHARE_OF_VIEW));
-                cut.setBounds(getWidth() - width - StudioTheme.scale(EDGE_MARGIN), (getHeight() - height) / 2, width, height);
-            }
-        };
-        stack.add(cut);
-        stack.add(view);
-        return stack;
-    }
-
-    /**
-     * Shows every layer of a newly chosen object without telling anyone, since nothing is hidden yet.
-     */
-    void showHeight(int layers) {
-        resetting = true;
-        try {
-            slider.setMaximum(Math.max(1, layers));
-            slider.setValue(slider.getMaximum());
-        } finally {
-            resetting = false;
-        }
-        showLayerLabel();
-        setVisible(layers > 1);
-    }
-
-    void stepBy(int layers) {
-        if (isVisible()) {
-            slider.setValue(slider.getValue() + layers);
-        }
-    }
-
-    boolean isCutting() {
-        return slider.getValue() < slider.getMaximum();
-    }
-
-    int shownLayerCount() {
-        return slider.getValue();
-    }
-
-    int layerCount() {
-        return slider.getMaximum();
-    }
-
-    @Override
-    protected void paintChildren(Graphics graphics) {
-        Graphics2D canvas = (Graphics2D) graphics.create();
-        try {
-            if (!hovered && !isCutting()) {
-                canvas.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, FAINT_OPACITY));
-            }
-            super.paintChildren(canvas);
-        } finally {
-            canvas.dispose();
-        }
-    }
-
-    private void setHovered(boolean nowHovered) {
-        if (hovered != nowHovered) {
-            hovered = nowHovered;
-            repaint();
-        }
-    }
-
-    private void showLayerLabel() {
-        shownLayers.setText(isCutting() ? Integer.toString(slider.getValue()) : " ");
-        repaint();
-    }
-}
@@ -1,243 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.core.gui.BlockModel.Face;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.util.BlockVector;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Function;
-import java.util.function.Predicate;
-
-/**
- * The faces of an object's blocks that can be seen from outside. A face is left out when the neighbour on its side
- * covers that side, which is most of them in a large object. See-through faces, like water and stained glass, are
- * kept apart because they are drawn last, blended over everything behind them. Top faces covered only by the block
- * above are kept aside too, so the top layers can be cut away without building the mesh again; what is cut away stays
- * as a faint ghost of the object's shape.
- */
-record ObjectMesh(List<Quad> solidQuads, List<Quad> translucentQuads, List<Quad> cutAwayQuads, List<Quad> topsUnderBlockAbove,
-                  Bounds bounds) {
-    private static final double SEE_THROUGH_OPACITY = 0.22D;
-    private static final double FULL_OPACITY = 1D;
-    private static final double CUT_AWAY_OPACITY = 0.1D;
-
-    static ObjectMesh build(Map<BlockVector, BlockData> blocks, Function<BlockData, BlockModel> modelOf) {
-        return build(blocks, modelOf, Bounds.of(blocks.keySet()), block -> false);
-    }
-
-    /**
-     * @param bounds       the whole object's extent, kept when only part of it is drawn so the view does not jump
-     * @param isSeeThrough blocks drawn faintly, which hide nothing behind them, to look past them into the object
-     */
-    static ObjectMesh build(Map<BlockVector, BlockData> blocks, Function<BlockData, BlockModel> modelOf, Bounds bounds,
-                            Predicate<BlockData> isSeeThrough) {
-        List<Quad> solid = new ArrayList<>();
-        List<Quad> translucent = new ArrayList<>();
-        List<Quad> topsUnderBlockAbove = new ArrayList<>();
-        BlockGrid grid = new BlockGrid(blocks, modelOf, bounds, isSeeThrough);
-        for (BlockVector position : blocks.keySet()) {
-            int x = position.getBlockX();
-            int y = position.getBlockY();
-            int z = position.getBlockZ();
-            int cell = grid.cellAt(x, y, z);
-            for (Face face : grid.modelIn(cell).faces()) {
-                Quad quad = new Quad(face, x, y, z, grid.isSeeThroughIn(cell) ? SEE_THROUGH_OPACITY : FULL_OPACITY);
-                if (!grid.isHiddenByNeighbour(x, y, z, face)) {
-                    (quad.isBlended() ? translucent : solid).add(quad);
-                } else if (face.cullFace() == CubeFace.UP) {
-                    topsUnderBlockAbove.add(quad);
-                }
-            }
-        }
-        return new ObjectMesh(List.copyOf(solid), List.copyOf(translucent), List.of(), List.copyOf(topsUnderBlockAbove), bounds);
-    }
-
-    /**
-     * This mesh with the blocks above the given layer faded to a ghost of the object's shape, and the tops of that
-     * layer's blocks showing again. Quick enough to follow a slider as it moves.
-     */
-    ObjectMesh cutAbove(int highestShownY) {
-        List<Quad> solid = new ArrayList<>();
-        List<Quad> translucent = new ArrayList<>();
-        List<Quad> cutAway = new ArrayList<>();
-        for (Quad quad : solidQuads) {
-            keepOrCutAway(quad, highestShownY, solid, cutAway);
-        }
-        for (Quad quad : translucentQuads) {
-            keepOrCutAway(quad, highestShownY, translucent, cutAway);
-        }
-        for (Quad quad : topsUnderBlockAbove) {
-            if (quad.y() == highestShownY) {
-                (quad.isBlended() ? translucent : solid).add(quad);
-            }
-        }
-        return new ObjectMesh(solid, translucent, cutAway, List.of(), bounds);
-    }
-
-    private static void keepOrCutAway(Quad quad, int highestShownY, List<Quad> kept, List<Quad> cutAway) {
-        if (quad.y() <= highestShownY) {
-            kept.add(quad);
-        } else {
-            cutAway.add(quad.faded(CUT_AWAY_OPACITY));
-        }
-    }
-
-    boolean isEmpty() {
-        return solidQuads.isEmpty() && translucentQuads.isEmpty() && cutAwayQuads.isEmpty();
-    }
-
-    int faceCount() {
-        return solidQuads.size() + translucentQuads.size();
-    }
-
-    /**
-     * The object's blocks laid out in an array over its bounds, so finding a block's neighbours is quick. Looking them
-     * up by {@link BlockVector} in a map is slow, since its hash codes collide a lot.
-     */
-    private static final class BlockGrid {
-        private final Bounds bounds;
-        private final BlockData[] blocks;
-        private final BlockModel[] models;
-        private final boolean[] seeThrough;
-
-        BlockGrid(Map<BlockVector, BlockData> placed, Function<BlockData, BlockModel> modelOf, Bounds bounds,
-                  Predicate<BlockData> isSeeThrough) {
-            this.bounds = bounds;
-            int cells = bounds.sizeX() * bounds.sizeY() * bounds.sizeZ();
-            this.blocks = new BlockData[cells];
-            this.models = new BlockModel[cells];
-            this.seeThrough = new boolean[cells];
-            placed.forEach((position, block) -> {
-                int cell = cellAt(position.getBlockX(), position.getBlockY(), position.getBlockZ());
-                blocks[cell] = block;
-                models[cell] = modelOf.apply(block);
-                seeThrough[cell] = isSeeThrough.test(block);
-            });
-        }
-
-        int cellAt(int x, int y, int z) {
-            return ((y - bounds.minY()) * bounds.sizeZ() + (z - bounds.minZ())) * bounds.sizeX() + (x - bounds.minX());
-        }
-
-        BlockModel modelIn(int cell) {
-            return models[cell];
-        }
-
-        boolean isSeeThroughIn(int cell) {
-            return seeThrough[cell];
-        }
-
-        // Glass next to glass and water next to water hide the side between them too, as they do in the game. A
-        // see-through block only hides sides of other see-through blocks, so whatever it covers shows through it.
-        boolean isHiddenByNeighbour(int x, int y, int z, Face face) {
-            CubeFace side = face.cullFace();
-            if (side == null || !contains(x + side.stepX(), y + side.stepY(), z + side.stepZ())) {
-                return false;
-            }
-            int cell = cellAt(x, y, z);
-            int neighbourCell = cellAt(x + side.stepX(), y + side.stepY(), z + side.stepZ());
-            BlockData neighbour = blocks[neighbourCell];
-            if (neighbour == null || (seeThrough[neighbourCell] && !seeThrough[cell])) {
-                return false;
-            }
-            BlockModel neighbourModel = models[neighbourCell];
-            if (neighbourModel.coveredSides().contains(side.opposite())) {
-                return true;
-            }
-            return neighbour.getMaterial() == blocks[cell].getMaterial() && models[cell].hidesSameBlockSides()
-                    && neighbourModel.hidesSameBlockSides();
-        }
-
-        private boolean contains(int x, int y, int z) {
-            return x >= bounds.minX() && x < bounds.maxX() && y >= bounds.minY() && y < bounds.maxY()
-                    && z >= bounds.minZ() && z < bounds.maxZ();
-        }
-    }
-
-    /**
-     * A model face placed at a block in the object, drawn at the given opacity on top of its texture's own.
-     */
-    record Quad(Face face, int x, int y, int z, double opacity) {
-        boolean isBlended() {
-            return opacity < FULL_OPACITY || face.texture().isTranslucent();
-        }
-
-        Quad faded(double factor) {
-            return new Quad(face, x, y, z, opacity * factor);
-        }
-
-        double originX() {
-            return x + face.origin().x();
-        }
-
-        double originY() {
-            return y + face.origin().y();
-        }
-
-        double originZ() {
-            return z + face.origin().z();
-        }
-    }
-
-    /**
-     * The blocks' extent, with the maximum one past the last block so a single block spans one unit.
-     */
-    record Bounds(int minX, int minY, int minZ, int maxX, int maxY, int maxZ) {
-        private static final Bounds EMPTY = new Bounds(0, 0, 0, 1, 1, 1);
-
-        static Bounds of(Iterable<BlockVector> positions) {
-            int minX = Integer.MAX_VALUE;
-            int minY = Integer.MAX_VALUE;
-            int minZ = Integer.MAX_VALUE;
-            int maxX = Integer.MIN_VALUE;
-            int maxY = Integer.MIN_VALUE;
-            int maxZ = Integer.MIN_VALUE;
-            for (BlockVector position : positions) {
-                minX = Math.min(minX, position.getBlockX());
-                minY = Math.min(minY, position.getBlockY());
-                minZ = Math.min(minZ, position.getBlockZ());
-                maxX = Math.max(maxX, position.getBlockX() + 1);
-                maxY = Math.max(maxY, position.getBlockY() + 1);
-                maxZ = Math.max(maxZ, position.getBlockZ() + 1);
-            }
-            return minX == Integer.MAX_VALUE ? EMPTY : new Bounds(minX, minY, minZ, maxX, maxY, maxZ);
-        }
-
-        int sizeX() {
-            return maxX - minX;
-        }
-
-        int sizeY() {
-            return maxY - minY;
-        }
-
-        int sizeZ() {
-            return maxZ - minZ;
-        }
-
-        int largestSize() {
-            return Math.max(sizeX(), Math.max(sizeY(), sizeZ()));
-        }
-    }
-}
@@ -1,351 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import javax.swing.BorderFactory;
-import javax.swing.BoxLayout;
-import javax.swing.JButton;
-import javax.swing.SwingUtilities;
-import javax.swing.DefaultListCellRenderer;
-import javax.swing.DefaultListModel;
-import javax.swing.JLabel;
-import javax.swing.JList;
-import javax.swing.JPanel;
-import javax.swing.JTextField;
-import javax.swing.event.DocumentEvent;
-import javax.swing.event.DocumentListener;
-import java.awt.AlphaComposite;
-import java.awt.BorderLayout;
-import java.awt.Component;
-import java.awt.Composite;
-import java.awt.Cursor;
-import java.awt.Insets;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
-import java.awt.GridLayout;
-import java.awt.RenderingHints;
-import java.awt.image.BufferedImage;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Locale;
-import java.util.Set;
-import java.util.function.Consumer;
-
-/**
- * The chosen object's size and the blocks it is made of, most used first, like the overview in Procedural Objects.
- * Clicking a block makes it see-through in the 3D view, to look past walls into the object.
- */
-final class ObjectOverviewPanel extends JPanel {
-    private static final long serialVersionUID = -8811407613645718290L;
-    private static final int PANEL_WIDTH = 280;
-    private static final int ROW_HEIGHT = 26;
-    private static final int ICON_SIZE = 16;
-    private static final int ICON_GAP = 8;
-    private static final int ROW_PADDING = 10;
-    private static final int SHARE_WIDTH = 92;
-    private static final int SHARE_BAR_HEIGHT = 4;
-    private static final float SEE_THROUGH_ICON_OPACITY = 0.3F;
-    private static final String SEE_THROUGH_HINT = "Click a block to see through it";
-
-    private final JLabel title = new JLabel(" ");
-    private final JLabel path = new JLabel(" ");
-    private final JLabel size = statValue();
-    private final JLabel blockCount = statValue();
-    private final JLabel blockTypes = statValue();
-    private final JLabel filled = statValue();
-    private final JTextField filterField = new JTextField();
-    private final DefaultListModel<ObjectSummary.BlockUse> rows = new DefaultListModel<>();
-    private final JList<ObjectSummary.BlockUse> list = new JList<>(rows) {
-        @Override
-        public boolean getScrollableTracksViewportWidth() {
-            return true;
-        }
-    };
-    private final JLabel seeThroughHint = new JLabel(SEE_THROUGH_HINT);
-    private final JButton showAllSolid = new JButton("Show all solid");
-    private final Set<String> seeThroughTypes = new LinkedHashSet<>();
-    private final Consumer<Set<String>> onSeeThroughChanged;
-    private ObjectSummary summary;
-
-    /**
-     * @param onSeeThroughChanged told which block types to draw see-through whenever the user changes them
-     */
-    ObjectOverviewPanel(Consumer<Set<String>> onSeeThroughChanged) {
-        super(new BorderLayout());
-        this.onSeeThroughChanged = onSeeThroughChanged;
-        setPreferredSize(StudioTheme.scaledSize(PANEL_WIDTH, 0));
-        setBorder(BorderFactory.createMatteBorder(0, 1, 0, 0, StudioTheme.SEPARATOR));
-        setBackground(StudioTheme.PANEL_BACKGROUND);
-        add(buildHeader(), BorderLayout.NORTH);
-        add(buildBlockList(), BorderLayout.CENTER);
-    }
-
-    void show(ObjectSummary nextSummary) {
-        summary = nextSummary;
-        title.setText(nextSummary.name());
-        path.setText(nextSummary.key());
-        path.setToolTipText(nextSummary.key());
-        size.setText(nextSummary.sizeX() + " × " + nextSummary.sizeY() + " × " + nextSummary.sizeZ());
-        blockCount.setText(formatCount(nextSummary.blockCount()));
-        blockTypes.setText(formatCount(nextSummary.blockUses().size()));
-        filled.setText(String.format(Locale.ROOT, "%.1f%%", nextSummary.filledFraction() * 100D));
-        seeThroughTypes.clear();
-        showSeeThroughState();
-        refilter();
-    }
-
-    void clear() {
-        summary = null;
-        title.setText(" ");
-        path.setText(" ");
-        for (JLabel value : List.of(size, blockCount, blockTypes, filled)) {
-            value.setText("—");
-        }
-        rows.clear();
-        seeThroughTypes.clear();
-        showSeeThroughState();
-    }
-
-    private JPanel buildHeader() {
-        JPanel header = new JPanel();
-        header.setLayout(new BoxLayout(header, BoxLayout.Y_AXIS));
-        header.setOpaque(false);
-        header.setBorder(StudioTheme.emptyBorder(12, 16, 8, 16));
-        title.setFont(StudioTheme.titleFont());
-        path.setFont(StudioTheme.smallFont());
-        path.setForeground(StudioTheme.SECONDARY_TEXT);
-        header.add(leftAligned(title));
-        header.add(leftAligned(path));
-
-        JPanel stats = new JPanel(new GridLayout(2, 2, StudioTheme.scale(12), StudioTheme.scale(8)));
-        stats.setOpaque(false);
-        stats.setBorder(StudioTheme.emptyBorder(12, 0, 4, 0));
-        stats.add(stat("Size · X × Y × Z", size));
-        stats.add(stat("Blocks", blockCount));
-        stats.add(stat("Block types", blockTypes));
-        stats.add(stat("Filled volume", filled));
-        filled.setToolTipText("How much of the object's bounding box its blocks fill");
-        header.add(leftAligned(stats));
-        clear();
-        return header;
-    }
-
-    private JPanel buildBlockList() {
-        JPanel blocks = new JPanel(new BorderLayout());
-        blocks.setOpaque(false);
-        StudioToolbar.makeSearchField(filterField, "Find a block...");
-        filterField.getDocument().addDocumentListener(new DocumentListener() {
-            @Override
-            public void insertUpdate(DocumentEvent event) {
-                refilter();
-            }
-
-            @Override
-            public void removeUpdate(DocumentEvent event) {
-                refilter();
-            }
-
-            @Override
-            public void changedUpdate(DocumentEvent event) {
-                refilter();
-            }
-        });
-        list.setFocusable(false);
-        list.setFixedCellHeight(StudioTheme.scale(ROW_HEIGHT));
-        list.setCellRenderer(new BlockUseRenderer());
-        list.setBackground(StudioTheme.PANEL_BACKGROUND);
-        list.setBorder(StudioTheme.emptyBorder(0, 6, 4, 6));
-        list.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
-        list.addMouseListener(new MouseAdapter() {
-            @Override
-            public void mouseClicked(MouseEvent event) {
-                int row = list.locationToIndex(event.getPoint());
-                if (SwingUtilities.isLeftMouseButton(event) && row >= 0 && list.getCellBounds(row, row).contains(event.getPoint())) {
-                    toggleSeeThrough(rows.get(row).blockType());
-                }
-            }
-        });
-        JPanel top = new JPanel();
-        top.setLayout(new BoxLayout(top, BoxLayout.Y_AXIS));
-        top.setOpaque(false);
-        top.add(leftAligned(StudioToolbar.padded(filterField, 4, 12, 4, 12)));
-        top.add(leftAligned(StudioToolbar.padded(seeThroughRow(), 0, 14, 6, 12)));
-        blocks.add(top, BorderLayout.NORTH);
-        blocks.add(StudioToolbar.scroll(list), BorderLayout.CENTER);
-        return blocks;
-    }
-
-    private JPanel seeThroughRow() {
-        seeThroughHint.setFont(StudioTheme.smallFont());
-        seeThroughHint.setForeground(StudioTheme.MUTED_TEXT);
-        showAllSolid.setFont(StudioTheme.smallFont());
-        showAllSolid.setForeground(StudioTheme.LINK);
-        showAllSolid.setBorderPainted(false);
-        showAllSolid.setContentAreaFilled(false);
-        showAllSolid.setFocusable(false);
-        showAllSolid.setMargin(new Insets(0, 0, 0, 0));
-        showAllSolid.setBorder(BorderFactory.createEmptyBorder());
-        showAllSolid.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
-        showAllSolid.addActionListener(event -> {
-            seeThroughTypes.clear();
-            seeThroughChanged();
-        });
-        JPanel row = new JPanel(new BorderLayout());
-        row.setOpaque(false);
-        row.add(seeThroughHint, BorderLayout.CENTER);
-        row.add(showAllSolid, BorderLayout.EAST);
-        showSeeThroughState();
-        return row;
-    }
-
-    private void toggleSeeThrough(String blockType) {
-        if (!seeThroughTypes.remove(blockType)) {
-            seeThroughTypes.add(blockType);
-        }
-        seeThroughChanged();
-    }
-
-    private void seeThroughChanged() {
-        showSeeThroughState();
-        list.repaint();
-        onSeeThroughChanged.accept(Set.copyOf(seeThroughTypes));
-    }
-
-    private void showSeeThroughState() {
-        int count = seeThroughTypes.size();
-        seeThroughHint.setText(count == 0 ? SEE_THROUGH_HINT : count == 1 ? "1 block see-through" : count + " blocks see-through");
-        showAllSolid.setVisible(count > 0);
-    }
-
-    private void refilter() {
-        rows.clear();
-        if (summary == null) {
-            return;
-        }
-        String filter = filterField.getText().trim().toLowerCase(Locale.ROOT).replace(' ', '_');
-        for (ObjectSummary.BlockUse use : summary.blockUses()) {
-            if (use.blockType().contains(filter)) {
-                rows.addElement(use);
-            }
-        }
-    }
-
-    private static JPanel stat(String label, JLabel value) {
-        JPanel stat = new JPanel(new BorderLayout());
-        stat.setOpaque(false);
-        JLabel name = new JLabel(label);
-        name.setFont(StudioTheme.smallFont());
-        name.setForeground(StudioTheme.MUTED_TEXT);
-        stat.add(name, BorderLayout.NORTH);
-        stat.add(value, BorderLayout.CENTER);
-        return stat;
-    }
-
-    private static JLabel statValue() {
-        JLabel value = new JLabel("—");
-        value.setFont(StudioTheme.boldFont());
-        return value;
-    }
-
-    private static Component leftAligned(JPanel panel) {
-        panel.setAlignmentX(LEFT_ALIGNMENT);
-        return panel;
-    }
-
-    private static Component leftAligned(JLabel label) {
-        label.setAlignmentX(LEFT_ALIGNMENT);
-        return label;
-    }
-
-    private static String formatCount(int count) {
-        return String.format(Locale.ROOT, "%,d", count);
-    }
-
-    private final class BlockUseRenderer extends DefaultListCellRenderer {
-        private static final long serialVersionUID = 2785337045812613941L;
-        private transient BufferedImage icon;
-        private boolean seeThrough;
-        private double share;
-        private String percent = "";
-
-        @Override
-        public Component getListCellRendererComponent(JList<?> owner, Object value, int index, boolean selected, boolean focused) {
-            ObjectSummary.BlockUse use = (ObjectSummary.BlockUse) value;
-            super.getListCellRendererComponent(owner, use.blockType(), index, false, false);
-            seeThrough = seeThroughTypes.contains(use.blockType());
-            setFont(StudioTheme.font());
-            setForeground(seeThrough ? StudioTheme.MUTED_TEXT : StudioTheme.TEXT);
-            setBorder(StudioTheme.emptyBorder(0, ROW_PADDING + ICON_SIZE + ICON_GAP, 0, ROW_PADDING + SHARE_WIDTH));
-            setToolTipText(use.blockType() + " · " + formatCount(use.count()) + " blocks · click to "
-                    + (seeThrough ? "make solid again" : "see through it"));
-            icon = use.icon();
-            share = summary == null || summary.blockCount() == 0 ? 0D : use.count() / (double) summary.blockCount();
-            percent = share > 0D && share < 0.001D ? "<0.1%" : String.format(Locale.ROOT, "%.1f%%", share * 100D);
-            return this;
-        }
-
-        @Override
-        protected void paintComponent(Graphics graphics) {
-            super.paintComponent(graphics);
-            Graphics2D canvas = (Graphics2D) graphics.create();
-            try {
-                int iconSize = StudioTheme.scale(ICON_SIZE);
-                int iconX = StudioTheme.scale(ROW_PADDING);
-                int iconY = (getHeight() - iconSize) / 2;
-                if (icon != null) {
-                    canvas.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
-                    Composite solid = canvas.getComposite();
-                    if (seeThrough) {
-                        canvas.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, SEE_THROUGH_ICON_OPACITY));
-                    }
-                    canvas.drawImage(icon, iconX, iconY, iconSize, iconSize, null);
-                    canvas.setComposite(solid);
-                } else {
-                    canvas.setColor(StudioTheme.CONTROL_BORDER);
-                    canvas.drawRect(iconX, iconY, iconSize - 1, iconSize - 1);
-                }
-                drawShare(canvas);
-            } finally {
-                canvas.dispose();
-            }
-        }
-
-        private void drawShare(Graphics2D canvas) {
-            canvas.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
-            canvas.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
-            canvas.setFont(StudioTheme.smallFont());
-            int padding = StudioTheme.scale(ROW_PADDING);
-            int percentWidth = canvas.getFontMetrics().stringWidth("100.0%");
-            int barWidth = StudioTheme.scale(SHARE_WIDTH) - percentWidth - StudioTheme.scale(6);
-            int barX = getWidth() - padding - StudioTheme.scale(SHARE_WIDTH);
-            int barHeight = StudioTheme.scale(SHARE_BAR_HEIGHT);
-            int barY = (getHeight() - barHeight) / 2;
-            canvas.setColor(StudioTheme.HOVER_BACKGROUND);
-            canvas.fillRoundRect(barX, barY, barWidth, barHeight, barHeight, barHeight);
-            canvas.setColor(seeThrough ? StudioTheme.CONTROL_BORDER : StudioTheme.ACCENT);
-            canvas.fillRoundRect(barX, barY, Math.max(barHeight, (int) Math.round(barWidth * share)), barHeight, barHeight, barHeight);
-            canvas.setColor(StudioTheme.SECONDARY_TEXT);
-            int textWidth = canvas.getFontMetrics().stringWidth(percent);
-            int baseline = (getHeight() + canvas.getFontMetrics().getAscent() - canvas.getFontMetrics().getDescent()) / 2;
-            canvas.drawString(percent, getWidth() - padding - textWidth, baseline);
-        }
-    }
-}
@@ -1,331 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.core.gui.BlockModel.Face;
-import com.volmit.iris.core.gui.BlockModel.TextureMapping;
-import com.volmit.iris.core.gui.BlockTextures.BlockTexture;
-
-import java.awt.Color;
-import java.awt.image.BufferedImage;
-import java.awt.image.DataBufferInt;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.List;
-
-/**
- * Draws an object mesh with an orthographic camera into a picture, without a graphics card: each quad is filled pixel
- * by pixel, and a depth buffer keeps the nearest one. A cut-away part's faint ghost only fills pixels the object
- * leaves empty, so it never hazes over what is shown. See-through quads come last, farthest first, each blended over
- * what is already drawn.
- */
-final class ObjectRenderer {
-    private static final Color GRID = new ThemeColor(0xE3E4E8, 0x34373C);
-    private static final int GRID_LINES_PER_SIDE = 25;
-    private static final double GRID_REACH = 0.7D;
-    private static final double GRID_BELOW_OBJECT = 0.035D;
-    // Shared quad edges land exactly on pixel centres now and then; a little overlap keeps them from leaving cracks.
-    private static final double EDGE_TOLERANCE = 1e-6D;
-    private static final double EDGE_ON_DETERMINANT = 1e-9D;
-    // A face's own texels end a hair inside its UV rectangle, so rounding never picks the texel next to it.
-    private static final double TEXEL_EDGE_MARGIN = 1e-6D;
-    private static final double FULL_ALPHA = 255D;
-
-    private final int width;
-    private final int height;
-    private final int[] pixels;
-    private final double[] depths;
-    private final boolean[] showsObject;
-    private final Projection projection;
-    private final int gridColor = GRID.getRGB() & 0xFFFFFF;
-
-    private ObjectRenderer(ObjectMesh mesh, ObjectCamera camera, BufferedImage image, int coveredLeftWidth) {
-        this.width = image.getWidth();
-        this.height = image.getHeight();
-        this.pixels = ((DataBufferInt) image.getRaster().getDataBuffer()).getData();
-        this.depths = new double[pixels.length];
-        this.showsObject = new boolean[pixels.length];
-        this.projection = new Projection(mesh.bounds(), camera, width, height, coveredLeftWidth);
-    }
-
-    /**
-     * @param coveredLeftWidth how much of the picture's left side something floats over, so the object is centred and
-     *                         fitted in the rest
-     */
-    static BufferedImage render(ObjectMesh mesh, ObjectCamera camera, int width, int height, int coveredLeftWidth) {
-        BufferedImage image = new BufferedImage(Math.max(1, width), Math.max(1, height), BufferedImage.TYPE_INT_RGB);
-        ObjectRenderer renderer = new ObjectRenderer(mesh, camera, image, Math.max(0, Math.min(width - 1, coveredLeftWidth)));
-        Arrays.fill(renderer.pixels, StudioTheme.EDITOR_BACKGROUND.getRGB() & 0xFFFFFF);
-        Arrays.fill(renderer.depths, Double.NEGATIVE_INFINITY);
-        renderer.drawGrid(mesh.bounds());
-        for (ObjectMesh.Quad quad : mesh.solidQuads()) {
-            renderer.drawQuad(quad, Pass.SOLID);
-        }
-        for (ObjectMesh.Quad quad : mesh.cutAwayQuads()) {
-            renderer.drawQuad(quad, Pass.CUT_AWAY_GHOST);
-        }
-        for (ObjectMesh.Quad quad : renderer.farthestFirst(mesh.translucentQuads())) {
-            renderer.drawQuad(quad, Pass.BLENDED);
-        }
-        return image;
-    }
-
-    private List<ObjectMesh.Quad> farthestFirst(List<ObjectMesh.Quad> quads) {
-        List<ObjectMesh.Quad> sorted = new ArrayList<>(quads);
-        sorted.sort(Comparator.comparingDouble(this::centerDepth));
-        return sorted;
-    }
-
-    private double centerDepth(ObjectMesh.Quad quad) {
-        Face face = quad.face();
-        return projection.depth(
-                quad.originX() + (face.edgeU().x() + face.edgeV().x()) / 2D,
-                quad.originY() + (face.edgeU().y() + face.edgeV().y()) / 2D,
-                quad.originZ() + (face.edgeU().z() + face.edgeV().z()) / 2D);
-    }
-
-    private void drawGrid(ObjectMesh.Bounds bounds) {
-        int reach = (int) Math.ceil(bounds.largestSize() * GRID_REACH);
-        int step = Math.max(1, (int) Math.ceil(reach / (double) GRID_LINES_PER_SIDE));
-        double floor = bounds.minY() - GRID_BELOW_OBJECT;
-        int centerX = Math.floorDiv(bounds.minX() + bounds.maxX(), 2);
-        int centerZ = Math.floorDiv(bounds.minZ() + bounds.maxZ(), 2);
-        for (int offset = -reach; offset <= reach; offset += step) {
-            drawLine(centerX + offset, floor, centerZ - reach, centerX + offset, floor, centerZ + reach);
-            drawLine(centerX - reach, floor, centerZ + offset, centerX + reach, floor, centerZ + offset);
-        }
-    }
-
-    private void drawLine(double fromX, double fromY, double fromZ, double toX, double toY, double toZ) {
-        double startX = projection.screenX(fromX, fromY, fromZ);
-        double startY = projection.screenY(fromX, fromY, fromZ);
-        double startDepth = projection.depth(fromX, fromY, fromZ);
-        double endX = projection.screenX(toX, toY, toZ);
-        double endY = projection.screenY(toX, toY, toZ);
-        double endDepth = projection.depth(toX, toY, toZ);
-        int steps = (int) Math.ceil(Math.max(Math.abs(endX - startX), Math.abs(endY - startY)));
-        for (int step = 0; step <= steps; step++) {
-            double progress = steps == 0 ? 0D : step / (double) steps;
-            int x = (int) (startX + (endX - startX) * progress);
-            int y = (int) (startY + (endY - startY) * progress);
-            if (x < 0 || y < 0 || x >= width || y >= height) {
-                continue;
-            }
-            int index = y * width + x;
-            double depth = startDepth + (endDepth - startDepth) * progress;
-            if (depth > depths[index]) {
-                depths[index] = depth;
-                pixels[index] = gridColor;
-            }
-        }
-    }
-
-    // Later faces win ties, so an overlay drawn on the same box, like grass on a grass block's side, shows on top.
-    private void drawQuad(ObjectMesh.Quad quad, Pass pass) {
-        Face face = quad.face();
-        if (!projection.facesCamera(face.normal().x(), face.normal().y(), face.normal().z())) {
-            return;
-        }
-        Vec3 u = face.edgeU();
-        Vec3 v = face.edgeV();
-        double originX = projection.screenX(quad.originX(), quad.originY(), quad.originZ());
-        double originY = projection.screenY(quad.originX(), quad.originY(), quad.originZ());
-        double originDepth = projection.depth(quad.originX(), quad.originY(), quad.originZ());
-        double edgeUX = projection.screenStepX(u.x(), u.z());
-        double edgeUY = projection.screenStepY(u.x(), u.y(), u.z());
-        double edgeUDepth = projection.depthStep(u.x(), u.y(), u.z());
-        double edgeVX = projection.screenStepX(v.x(), v.z());
-        double edgeVY = projection.screenStepY(v.x(), v.y(), v.z());
-        double edgeVDepth = projection.depthStep(v.x(), v.y(), v.z());
-        double determinant = edgeUX * edgeVY - edgeUY * edgeVX;
-        if (Math.abs(determinant) < EDGE_ON_DETERMINANT) {
-            return;
-        }
-
-        int left = Math.max(0, (int) Math.floor(min4(originX, originX + edgeUX, originX + edgeVX, originX + edgeUX + edgeVX)));
-        int right = Math.min(width - 1, (int) Math.ceil(max4(originX, originX + edgeUX, originX + edgeVX, originX + edgeUX + edgeVX)));
-        int top = Math.max(0, (int) Math.floor(min4(originY, originY + edgeUY, originY + edgeVY, originY + edgeUY + edgeVY)));
-        int bottom = Math.min(height - 1, (int) Math.ceil(max4(originY, originY + edgeUY, originY + edgeVY, originY + edgeUY + edgeVY)));
-        if (left > right || top > bottom) {
-            return;
-        }
-
-        BlockTexture texture = face.texture();
-        TextureMapping mapping = face.mapping();
-        TexelRange columns = TexelRange.of(mapping.u(), mapping.uAlongU(), mapping.uAlongV(), texture.width());
-        TexelRange rows = TexelRange.of(mapping.v(), mapping.vAlongU(), mapping.vAlongV(), texture.height());
-        int[] texels = texture.pixels();
-        boolean[] opaque = texture.opaque();
-        int[] alphas = texture.alphas();
-        double shade = face.shade();
-        double alongUPerPixelX = edgeVY / determinant;
-        double alongVPerPixelX = -edgeUY / determinant;
-        for (int y = top; y <= bottom; y++) {
-            double offsetX = left + 0.5D - originX;
-            double offsetY = y + 0.5D - originY;
-            double alongU = (offsetX * edgeVY - offsetY * edgeVX) / determinant;
-            double alongV = (offsetY * edgeUX - offsetX * edgeUY) / determinant;
-            int rowStart = y * width;
-            for (int x = left; x <= right; x++, alongU += alongUPerPixelX, alongV += alongVPerPixelX) {
-                if (alongU < -EDGE_TOLERANCE || alongU > 1D + EDGE_TOLERANCE || alongV < -EDGE_TOLERANCE || alongV > 1D + EDGE_TOLERANCE) {
-                    continue;
-                }
-                int index = rowStart + x;
-                double depth = originDepth + alongU * edgeUDepth + alongV * edgeVDepth;
-                if (depth < depths[index] || (pass == Pass.CUT_AWAY_GHOST && showsObject[index])) {
-                    continue;
-                }
-                int texelX = columns.texelAt(mapping.u() + alongU * mapping.uAlongU() + alongV * mapping.uAlongV());
-                int texelY = rows.texelAt(mapping.v() + alongU * mapping.vAlongU() + alongV * mapping.vAlongV());
-                int texel = texelY * texture.width() + texelX;
-                if (!opaque[texel]) {
-                    continue;
-                }
-                int color = BlockPreviewColors.shade(texels[texel], shade);
-                if (pass != Pass.SOLID) {
-                    pixels[index] = blend(color, pixels[index], (alphas == null ? 1D : alphas[texel] / FULL_ALPHA) * quad.opacity());
-                    continue;
-                }
-                depths[index] = depth;
-                pixels[index] = color;
-                showsObject[index] = true;
-            }
-        }
-    }
-
-    private static int blend(int over, int under, double coverage) {
-        return blendChannel(over, under, coverage, 16) << 16 | blendChannel(over, under, coverage, 8) << 8 | blendChannel(over, under, coverage, 0);
-    }
-
-    private static int blendChannel(int over, int under, double coverage, int shift) {
-        return (int) Math.round(((over >>> shift) & 0xFF) * coverage + ((under >>> shift) & 0xFF) * (1D - coverage));
-    }
-
-    private static double min4(double a, double b, double c, double d) {
-        return Math.min(Math.min(a, b), Math.min(c, d));
-    }
-
-    private static double max4(double a, double b, double c, double d) {
-        return Math.max(Math.max(a, b), Math.max(c, d));
-    }
-
-    /**
-     * The texels a face covers along one texture axis, so a pixel on the face's edge never takes its neighbour's.
-     */
-    private record TexelRange(int first, int last, int size) {
-        static TexelRange of(double start, double alongU, double alongV, int size) {
-            double low = start + Math.min(0D, alongU) + Math.min(0D, alongV);
-            double high = start + Math.max(0D, alongU) + Math.max(0D, alongV);
-            int first = clamp((int) Math.floor(low * size + TEXEL_EDGE_MARGIN), size);
-            int last = Math.max(first, clamp((int) Math.ceil(high * size - TEXEL_EDGE_MARGIN) - 1, size));
-            return new TexelRange(first, last, size);
-        }
-
-        int texelAt(double fraction) {
-            int texel = (int) Math.floor(fraction * size);
-            return texel < first ? first : Math.min(texel, last);
-        }
-
-        private static int clamp(int texel, int size) {
-            return Math.max(0, Math.min(size - 1, texel));
-        }
-    }
-
-    /**
-     * Turns block positions into pixels. Larger depth is nearer the camera.
-     */
-    private static final class Projection {
-        private final double centerX;
-        private final double centerY;
-        private final double centerZ;
-        private final double cosYaw;
-        private final double sinYaw;
-        private final double cosPitch;
-        private final double sinPitch;
-        private final double pixelsPerBlock;
-        private final double screenCenterX;
-        private final double screenCenterY;
-
-        private Projection(ObjectMesh.Bounds bounds, ObjectCamera camera, int width, int height, int coveredLeftWidth) {
-            this.centerX = (bounds.minX() + bounds.maxX()) / 2D;
-            this.centerY = (bounds.minY() + bounds.maxY()) / 2D;
-            this.centerZ = (bounds.minZ() + bounds.maxZ()) / 2D;
-            this.cosYaw = Math.cos(camera.yaw());
-            this.sinYaw = Math.sin(camera.yaw());
-            this.cosPitch = Math.cos(camera.pitch());
-            this.sinPitch = Math.sin(camera.pitch());
-            int visibleWidth = width - coveredLeftWidth;
-            double fit = fitAtStartingAngle(bounds, visibleWidth / (double) height);
-            this.pixelsPerBlock = camera.zoom() * fit * height / 2D / bounds.largestSize();
-            this.screenCenterX = coveredLeftWidth + visibleWidth / 2D + camera.panX() * visibleWidth / 2D;
-            this.screenCenterY = height / 2D - camera.panY() * height / 2D;
-        }
-
-        // How far to scale the object down so it fits the view at the starting angle; orbiting keeps the scale.
-        private static double fitAtStartingAngle(ObjectMesh.Bounds bounds, double aspect) {
-            double size = bounds.largestSize();
-            double width = bounds.sizeX() / size;
-            double height = bounds.sizeY() / size;
-            double depth = bounds.sizeZ() / size;
-            double yaw = ObjectCamera.START.yaw();
-            double pitch = ObjectCamera.START.pitch();
-            double projectedWidth = Math.abs(Math.cos(yaw)) * width + Math.abs(Math.sin(yaw)) * depth;
-            double projectedDepth = Math.abs(Math.sin(yaw)) * width + Math.abs(Math.cos(yaw)) * depth;
-            double projectedHeight = Math.abs(Math.cos(pitch)) * height + Math.abs(Math.sin(pitch)) * projectedDepth;
-            return Math.min(1D, Math.min(aspect / projectedWidth, 1D / projectedHeight));
-        }
-
-        double screenX(double x, double y, double z) {
-            return screenCenterX + screenStepX(x - centerX, z - centerZ);
-        }
-
-        double screenY(double x, double y, double z) {
-            return screenCenterY + screenStepY(x - centerX, y - centerY, z - centerZ);
-        }
-
-        double depth(double x, double y, double z) {
-            return depthStep(x - centerX, y - centerY, z - centerZ);
-        }
-
-        double screenStepX(double x, double z) {
-            return (cosYaw * x - sinYaw * z) * pixelsPerBlock;
-        }
-
-        double screenStepY(double x, double y, double z) {
-            double towardCamera = sinYaw * x + cosYaw * z;
-            return -(cosPitch * y - sinPitch * towardCamera) * pixelsPerBlock;
-        }
-
-        double depthStep(double x, double y, double z) {
-            double towardCamera = sinYaw * x + cosYaw * z;
-            return sinPitch * y + cosPitch * towardCamera;
-        }
-
-        boolean facesCamera(double normalX, double normalY, double normalZ) {
-            return depthStep(normalX, normalY, normalZ) > 0D;
-        }
-    }
-
-    private enum Pass {
-        SOLID,
-        CUT_AWAY_GHOST,
-        BLENDED
-    }
-}
@@ -1,65 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import org.bukkit.block.data.BlockData;
-
-import java.awt.image.BufferedImage;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Function;
-
-/**
- * What an object is made of: its size and how many of each block type it uses, most used first.
- */
-record ObjectSummary(String key, int sizeX, int sizeY, int sizeZ, int blockCount, List<BlockUse> blockUses) {
-    static ObjectSummary of(String key, ObjectMesh.Bounds bounds, Iterable<BlockData> blocks, Function<BlockData, BufferedImage> iconOf) {
-        Map<String, Integer> counts = new HashMap<>();
-        Map<String, BlockData> examples = new HashMap<>();
-        int blockCount = 0;
-        for (BlockData block : blocks) {
-            String blockType = block.getMaterial().getKey().getKey();
-            counts.merge(blockType, 1, Integer::sum);
-            examples.putIfAbsent(blockType, block);
-            blockCount++;
-        }
-        List<BlockUse> uses = counts.entrySet().stream()
-                .map(count -> new BlockUse(count.getKey(), count.getValue(), iconOf.apply(examples.get(count.getKey()))))
-                .sorted(Comparator.comparingInt(BlockUse::count).reversed().thenComparing(BlockUse::blockType))
-                .toList();
-        return new ObjectSummary(key, bounds.sizeX(), bounds.sizeY(), bounds.sizeZ(), blockCount, uses);
-    }
-
-    String name() {
-        return key.substring(key.lastIndexOf('/') + 1);
-    }
-
-    double filledFraction() {
-        long volume = (long) sizeX * sizeY * sizeZ;
-        return volume == 0 ? 0D : blockCount / (double) volume;
-    }
-
-    /**
-     * @param icon the block's texture, or null when Minecraft's textures are not available
-     */
-    record BlockUse(String blockType, int count, BufferedImage icon) {
-    }
-}
@@ -1,250 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import javax.swing.AbstractAction;
-import javax.swing.JComponent;
-import javax.swing.KeyStroke;
-import javax.swing.SwingUtilities;
-import java.awt.EventQueue;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
-import java.awt.Point;
-import java.awt.RenderingHints;
-import java.awt.event.ActionEvent;
-import java.awt.event.ComponentAdapter;
-import java.awt.event.ComponentEvent;
-import java.awt.event.KeyEvent;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
-import java.awt.event.MouseWheelEvent;
-import java.awt.image.BufferedImage;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.function.UnaryOperator;
-
-/**
- * The 3D view of one object. Drag to orbit, shift-drag or middle-drag to pan, scroll to zoom; arrow keys orbit and
- * plus and minus zoom too. Frames are drawn on a background thread, one at a time, always for the latest camera.
- */
-final class ObjectViewport extends JComponent {
-    private static final long serialVersionUID = -3175226517409913524L;
-    private static final double WHEEL_ZOOM_EXPONENT = 0.12D;
-    private static final double KEY_ZOOM_FACTOR = 1.1D;
-    private static final int KEY_ORBIT_PIXELS = 12;
-
-    private final ExecutorService renderThread = Executors.newSingleThreadExecutor(runnable -> {
-        Thread thread = new Thread(runnable, "Iris Object Viewer");
-        thread.setDaemon(true);
-        return thread;
-    });
-    private ObjectMesh mesh;
-    private ObjectCamera camera = ObjectCamera.START;
-    private BufferedImage frame;
-    private String message = "Choose an object";
-    private boolean rendering;
-    private boolean renderAgain;
-    private Point dragPoint;
-    private int coveredLeftWidth;
-
-    ObjectViewport() {
-        setOpaque(true);
-        setBackground(StudioTheme.EDITOR_BACKGROUND);
-        setFocusable(true);
-        installMouseControls();
-        installKeyControls();
-        addComponentListener(new ComponentAdapter() {
-            @Override
-            public void componentResized(ComponentEvent event) {
-                requestFrame();
-            }
-        });
-    }
-
-    // The theme changed, and the last frame was drawn on the old theme's background.
-    @Override
-    public void updateUI() {
-        super.updateUI();
-        requestFrame();
-    }
-
-    void show(ObjectMesh nextMesh) {
-        mesh = nextMesh;
-        camera = ObjectCamera.START;
-        message = nextMesh.isEmpty() ? "No visible blocks" : null;
-        frame = null;
-        requestFrame();
-        repaint();
-    }
-
-    /**
-     * Swaps in another mesh of the same object, like one with its top layers cut away, keeping the camera.
-     */
-    void replaceMesh(ObjectMesh nextMesh) {
-        mesh = nextMesh;
-        message = nextMesh.isEmpty() ? "No visible blocks" : null;
-        requestFrame();
-        repaint();
-    }
-
-    void bindKey(int keyCode, String name, Runnable action) {
-        getInputMap(WHEN_FOCUSED).put(KeyStroke.getKeyStroke(keyCode, 0), name);
-        getActionMap().put(name, new AbstractAction() {
-            @Override
-            public void actionPerformed(ActionEvent event) {
-                action.run();
-            }
-        });
-    }
-
-    void showMessage(String text) {
-        mesh = null;
-        message = text;
-        frame = null;
-        repaint();
-    }
-
-    /**
-     * Keeps the object clear of a panel floating over the viewport's left side.
-     */
-    void setCoveredLeftWidth(int width) {
-        if (width == coveredLeftWidth) {
-            return;
-        }
-        coveredLeftWidth = width;
-        requestFrame();
-    }
-
-    void resetCamera() {
-        moveCamera(current -> ObjectCamera.START);
-    }
-
-    void close() {
-        renderThread.shutdownNow();
-    }
-
-    private void moveCamera(UnaryOperator<ObjectCamera> move) {
-        camera = move.apply(camera);
-        requestFrame();
-    }
-
-    private void requestFrame() {
-        if (mesh == null || mesh.isEmpty() || getWidth() < 1 || getHeight() < 1) {
-            return;
-        }
-        if (rendering) {
-            renderAgain = true;
-            return;
-        }
-        rendering = true;
-        ObjectMesh frameMesh = mesh;
-        ObjectCamera frameCamera = camera;
-        int width = getWidth();
-        int height = getHeight();
-        int covered = coveredLeftWidth;
-        renderThread.execute(() -> {
-            BufferedImage image = ObjectRenderer.render(frameMesh, frameCamera, width, height, covered);
-            EventQueue.invokeLater(() -> finishFrame(frameMesh, image));
-        });
-    }
-
-    private void finishFrame(ObjectMesh frameMesh, BufferedImage image) {
-        rendering = false;
-        if (frameMesh == mesh) {
-            frame = image;
-            repaint();
-        }
-        if (renderAgain) {
-            renderAgain = false;
-            requestFrame();
-        }
-    }
-
-    @Override
-    protected void paintComponent(Graphics graphics) {
-        graphics.setColor(getBackground());
-        graphics.fillRect(0, 0, getWidth(), getHeight());
-        if (frame != null) {
-            graphics.drawImage(frame, 0, 0, null);
-        }
-        if (message != null) {
-            drawMessage((Graphics2D) graphics);
-        }
-    }
-
-    private void drawMessage(Graphics2D canvas) {
-        canvas.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
-        canvas.setFont(StudioTheme.font());
-        canvas.setColor(StudioTheme.MUTED_TEXT);
-        int textWidth = canvas.getFontMetrics().stringWidth(message);
-        canvas.drawString(message, (getWidth() - textWidth) / 2, getHeight() / 2);
-    }
-
-    private void installMouseControls() {
-        MouseAdapter mouse = new MouseAdapter() {
-            @Override
-            public void mousePressed(MouseEvent event) {
-                dragPoint = event.getPoint();
-                requestFocusInWindow();
-            }
-
-            @Override
-            public void mouseReleased(MouseEvent event) {
-                dragPoint = null;
-            }
-
-            @Override
-            public void mouseDragged(MouseEvent event) {
-                if (dragPoint == null) {
-                    return;
-                }
-                int draggedX = event.getX() - dragPoint.x;
-                int draggedY = event.getY() - dragPoint.y;
-                dragPoint = event.getPoint();
-                boolean panning = event.isShiftDown() || SwingUtilities.isMiddleMouseButton(event);
-                moveCamera(current -> panning
-                        ? current.pannedBy(2D * draggedX / Math.max(1, getWidth() - coveredLeftWidth), -2D * draggedY / getHeight())
-                        : current.orbitedBy(draggedX, draggedY));
-            }
-
-            @Override
-            public void mouseWheelMoved(MouseWheelEvent event) {
-                moveCamera(current -> current.zoomedBy(Math.exp(-event.getPreciseWheelRotation() * WHEEL_ZOOM_EXPONENT)));
-            }
-        };
-        addMouseListener(mouse);
-        addMouseMotionListener(mouse);
-        addMouseWheelListener(mouse);
-    }
-
-    private void installKeyControls() {
-        bindKey(KeyEvent.VK_LEFT, "orbit-left", current -> current.orbitedBy(-KEY_ORBIT_PIXELS, 0));
-        bindKey(KeyEvent.VK_RIGHT, "orbit-right", current -> current.orbitedBy(KEY_ORBIT_PIXELS, 0));
-        bindKey(KeyEvent.VK_UP, "orbit-up", current -> current.orbitedBy(0, KEY_ORBIT_PIXELS));
-        bindKey(KeyEvent.VK_DOWN, "orbit-down", current -> current.orbitedBy(0, -KEY_ORBIT_PIXELS));
-        bindKey(KeyEvent.VK_EQUALS, "zoom-in", current -> current.zoomedBy(KEY_ZOOM_FACTOR));
-        bindKey(KeyEvent.VK_ADD, "zoom-in-keypad", current -> current.zoomedBy(KEY_ZOOM_FACTOR));
-        bindKey(KeyEvent.VK_MINUS, "zoom-out", current -> current.zoomedBy(1D / KEY_ZOOM_FACTOR));
-        bindKey(KeyEvent.VK_SUBTRACT, "zoom-out-keypad", current -> current.zoomedBy(1D / KEY_ZOOM_FACTOR));
-    }
-
-    private void bindKey(int keyCode, String name, UnaryOperator<ObjectCamera> move) {
-        bindKey(keyCode, name, () -> moveCamera(move));
-    }
-}
@@ -1,263 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.google.gson.JsonArray;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
-import com.google.gson.JsonParser;
-import com.google.gson.stream.JsonReader;
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisBlockData;
-import com.volmit.iris.engine.object.IrisRegion;
-import com.volmit.iris.util.collection.KList;
-
-import java.io.File;
-import java.io.FileReader;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Set;
-
-record PaletteCatalog(List<RegionEntry> regions, List<String> biomesOutsideRegions, Map<String, BiomeEntry> biomes,
-                      List<SnippetEntry> snippets) {
-    private static final int SUMMARIZED_BLOCK_COUNT = 3;
-
-    static PaletteCatalog load(Engine engine) {
-        IrisData data = engine.getData();
-        Map<String, BiomeEntry> biomes = loadBiomes(data);
-        List<RegionEntry> regions = new ArrayList<>();
-        Set<String> biomesInRegions = new HashSet<>();
-        for (String regionKey : regionKeysInUse(engine)) {
-            IrisRegion region = data.getRegionLoader().load(regionKey);
-            if (region == null) {
-                continue;
-            }
-            RegionEntry entry = describeRegion(regionKey, region, biomes);
-            regions.add(entry);
-            entry.groups().forEach(group -> group.biomeKeys().forEach(key -> collectWithChildren(key, biomes, biomesInRegions)));
-        }
-        List<String> outside = biomes.keySet().stream().filter(key -> !biomesInRegions.contains(key)).toList();
-        return new PaletteCatalog(List.copyOf(regions), outside, Map.copyOf(biomes), loadSnippets(data, biomes));
-    }
-
-    // Snippet files no biome refers to are listed too, so a new snippet shows up before it is put to use.
-    private static List<SnippetEntry> loadSnippets(IrisData data, Map<String, BiomeEntry> biomes) {
-        Map<String, SnippetEntry> snippets = new LinkedHashMap<>();
-        for (BiomeEntry biome : biomes.values()) {
-            for (PaletteSummary summary : biome.palettes()) {
-                if (summary.snippet() == null) {
-                    continue;
-                }
-                BiomePalette.SnippetFolder folder = summary.palette().kind().snippetFolder();
-                snippets.computeIfAbsent(folder.folder() + "/" + summary.snippet(),
-                                key -> new SnippetEntry(folder, summary.snippet(), summary.blocks(), new ArrayList<>()))
-                        .uses().add(summary.palette());
-            }
-        }
-        for (BiomePalette.SnippetFolder folder : BiomePalette.SnippetFolder.values()) {
-            for (String reference : data.getPossibleSnippets(folder.folder())) {
-                String path = folder.pathOf(reference);
-                snippets.putIfAbsent(folder.folder() + "/" + path, new SnippetEntry(folder, path, null, List.of()));
-            }
-        }
-        return snippets.values().stream()
-                .map(snippet -> new SnippetEntry(snippet.folder(), snippet.path(), snippet.blocks(), List.copyOf(snippet.uses())))
-                .sorted(Comparator.comparing(SnippetEntry::folder).thenComparing(SnippetEntry::path))
-                .toList();
-    }
-
-    // A studio focus region is generated even when the dimension's region list doesn't include it.
-    private static Set<String> regionKeysInUse(Engine engine) {
-        Set<String> keys = new LinkedHashSet<>();
-        if (engine.getDimension().hasFocusRegion()) {
-            keys.add(engine.getDimension().getFocusRegion());
-        }
-        keys.addAll(engine.getDimension().getRegions());
-        return keys;
-    }
-
-    BiomeEntry biome(String key) {
-        return key == null ? null : biomes.get(key);
-    }
-
-    RegionEntry region(String key) {
-        return regions.stream().filter(region -> region.key().equals(key)).findFirst().orElse(null);
-    }
-
-    static String summarizeBlocks(KList<IrisBlockData> blocks) {
-        List<String> names = blocks.stream()
-                .map(block -> block.getBlock().replace("minecraft:", "").toLowerCase(Locale.ROOT))
-                .distinct()
-                .toList();
-        if (names.size() <= SUMMARIZED_BLOCK_COUNT) {
-            return String.join(", ", names);
-        }
-        return String.join(", ", names.subList(0, SUMMARIZED_BLOCK_COUNT))
-                + " +" + (names.size() - SUMMARIZED_BLOCK_COUNT) + " more";
-    }
-
-    private static Map<String, BiomeEntry> loadBiomes(IrisData data) {
-        String[] keys = data.getBiomeLoader().getPossibleKeys();
-        Map<String, IrisBiome> loaded = new LinkedHashMap<>();
-        if (keys == null) {
-            return Map.of();
-        }
-        Arrays.sort(keys);
-        for (String key : keys) {
-            IrisBiome biome = data.getBiomeLoader().load(key);
-            if (biome != null) {
-                loaded.put(key, biome);
-            }
-        }
-        Map<String, List<String>> parentsByChild = parentsByChild(loaded);
-        Map<String, BiomeEntry> biomes = new LinkedHashMap<>();
-        loaded.forEach((key, biome) -> biomes.put(key, new BiomeEntry(
-                key,
-                biome.getName(),
-                summarizePalettes(key, biome),
-                biome.getChildren().stream().filter(loaded::containsKey).distinct().toList(),
-                parentsByChild.getOrDefault(key, List.of())
-        )));
-        return biomes;
-    }
-
-    private static Map<String, List<String>> parentsByChild(Map<String, IrisBiome> biomes) {
-        Map<String, List<String>> parents = new LinkedHashMap<>();
-        biomes.forEach((parentKey, parent) -> parent.getChildren().stream().distinct().forEach(childKey ->
-                parents.computeIfAbsent(childKey, key -> new ArrayList<>()).add(parentKey)));
-        return parents;
-    }
-
-    static List<PaletteSummary> summarizePalettes(String key, IrisBiome biome) {
-        JsonObject biomeSource = readSource(biome.getLoadFile());
-        return BiomePalette.allOf(key, biome).stream()
-                .map(palette -> new PaletteSummary(palette, snippetName(biomeSource, palette),
-                        summarizeBlocks(palette.blocksIn(biome))))
-                .toList();
-    }
-
-    // Snippets are copied into the biome when it loads, so only its file still tells which palettes came from one.
-    private static String snippetName(JsonObject biomeSource, BiomePalette palette) {
-        JsonElement element = biomeSource == null ? null : biomeSource.get(palette.kind().jsonKey());
-        if (element instanceof JsonArray list) {
-            element = palette.index() < list.size() ? list.get(palette.index()) : null;
-        }
-        if (element == null || !element.isJsonPrimitive()) {
-            return null;
-        }
-        return palette.kind().snippetFolder().pathOf(element.getAsString());
-    }
-
-    private static JsonObject readSource(File file) {
-        if (file == null || !file.isFile()) {
-            return null;
-        }
-        try (JsonReader reader = new JsonReader(new FileReader(file))) {
-            reader.setLenient(true);
-            JsonElement source = JsonParser.parseReader(reader);
-            return source.isJsonObject() ? source.getAsJsonObject() : null;
-        } catch (IOException | RuntimeException e) {
-            return null;
-        }
-    }
-
-    private static RegionEntry describeRegion(String key, IrisRegion region, Map<String, BiomeEntry> biomes) {
-        List<BiomeGroup> groups = new ArrayList<>();
-        addGroup(groups, "Land", region.getLandBiomes(), biomes);
-        addGroup(groups, "Shore", region.getShoreBiomes(), biomes);
-        addGroup(groups, "Sea", region.getSeaBiomes(), biomes);
-        addGroup(groups, "Cave", region.getCaveBiomes(), biomes);
-        return new RegionEntry(key, region.getName(), List.copyOf(groups));
-    }
-
-    private static void addGroup(List<BiomeGroup> groups, String label, List<String> keys, Map<String, BiomeEntry> biomes) {
-        List<String> known = keys.stream().filter(biomes::containsKey).distinct().toList();
-        if (!known.isEmpty()) {
-            groups.add(new BiomeGroup(label, known));
-        }
-    }
-
-    private static void collectWithChildren(String key, Map<String, BiomeEntry> biomes, Set<String> collected) {
-        BiomeEntry biome = biomes.get(key);
-        if (biome == null || !collected.add(key)) {
-            return;
-        }
-        biome.childKeys().forEach(child -> collectWithChildren(child, biomes, collected));
-    }
-
-    record RegionEntry(String key, String name, List<BiomeGroup> groups) {
-        List<String> allBiomeKeys() {
-            return groups.stream().flatMap(group -> group.biomeKeys().stream()).distinct().toList();
-        }
-    }
-
-    record BiomeGroup(String label, List<String> biomeKeys) {
-    }
-
-    /**
-     * @param parentKeys the biomes that list this one as a child, which it can appear inside of
-     */
-    record BiomeEntry(String key, String name, List<PaletteSummary> palettes, List<String> childKeys,
-                      List<String> parentKeys) {
-        boolean matches(String filter) {
-            if (key.toLowerCase().contains(filter) || name.toLowerCase().contains(filter)) {
-                return true;
-            }
-            return palettes.stream().anyMatch(summary -> summary.text().toLowerCase().contains(filter));
-        }
-
-        BiomePalette firstPalette() {
-            return palettes.isEmpty() ? null : palettes.get(0).palette();
-        }
-    }
-
-    /**
-     * A snippet file palettes can come from.
-     *
-     * @param blocks a summary of its blocks, or null when no biome uses it
-     * @param uses   the palettes made from it, in biome order
-     */
-    record SnippetEntry(BiomePalette.SnippetFolder folder, String path, String blocks, List<BiomePalette> uses) {
-        boolean matches(String filter) {
-            return path.toLowerCase(Locale.ROOT).contains(filter)
-                    || (blocks != null && blocks.toLowerCase(Locale.ROOT).contains(filter));
-        }
-    }
-
-    /**
-     * @param snippet the path of the snippet file the palette comes from, or null when the biome defines it itself
-     */
-    record PaletteSummary(BiomePalette palette, String snippet, String blocks) {
-        String text() {
-            return snippet == null
-                    ? palette.label() + " · " + blocks
-                    : palette.label() + " · " + snippet + " snippet · " + blocks;
-        }
-    }
-}
@@ -1,500 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import javax.swing.BorderFactory;
-import javax.swing.ButtonGroup;
-import javax.swing.JButton;
-import javax.swing.JComponent;
-import javax.swing.JLabel;
-import javax.swing.JPanel;
-import javax.swing.JToggleButton;
-import javax.swing.SwingConstants;
-import java.awt.BorderLayout;
-import java.awt.Color;
-import java.awt.Dimension;
-import java.awt.FontMetrics;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
-import java.awt.GridLayout;
-import java.awt.RenderingHints;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Locale;
-
-
-final class PaletteInspectorPanel extends JPanel {
-    private static final long serialVersionUID = 4473102938518712001L;
-    private static final int PANEL_WIDTH = 310;
-    private static final Color HISTOGRAM_BAR = new Color(0x9D, 0xA0, 0xA8, 150);
-    private static final Color BAND_DIVIDER = new Color(255, 255, 255, 70);
-
-    private final Listener listener;
-    private final JLabel titleLabel = new JLabel();
-    private final JLabel detailLabel = new JLabel();
-    private final JLabel depthLabel = new JLabel("", SwingConstants.CENTER);
-    private final JButton shallowerButton = new JButton("‹");
-    private final JButton deeperButton = new JButton("›");
-    private final JPanel depthRow = new JPanel(new BorderLayout(StudioTheme.scale(6), 0));
-    private final StatisticsView statisticsView = new StatisticsView();
-    private PaletteLayerScale.View selectedView = PaletteLayerScale.View.BLOCKS;
-    private int depth;
-    private int deepestDepth;
-
-    PaletteInspectorPanel(Listener listener) {
-        super(new BorderLayout());
-        this.listener = listener;
-        setPreferredSize(StudioTheme.scaledSize(PANEL_WIDTH, 0));
-        setBorder(BorderFactory.createMatteBorder(0, 1, 0, 0, StudioTheme.SEPARATOR));
-        add(buildControls(), BorderLayout.NORTH);
-        add(StudioToolbar.scroll(statisticsView), BorderLayout.CENTER);
-        setVisible(false);
-    }
-
-    void showPreview(PaletteLayerPreview preview) {
-        titleLabel.setText(preview.biomeKey() + " · " + preview.palette().lowercaseLabel());
-        detailLabel.setText(placementText(preview));
-        depth = preview.depth();
-        deepestDepth = Math.max(0, preview.maxThickness() - 1);
-        refreshDepthControls();
-        statisticsView.show(preview);
-        setVisible(true);
-    }
-
-    void showTextureStatus(String status) {
-        statisticsView.showTextureStatus(status);
-    }
-
-    void hideInspector() {
-        setVisible(false);
-    }
-
-    PaletteLayerScale.View selectedView() {
-        return selectedView;
-    }
-
-    private JPanel buildControls() {
-        JPanel controls = new JPanel(new GridLayout(0, 1, 0, StudioTheme.scale(6)));
-        controls.setBorder(BorderFactory.createCompoundBorder(
-                BorderFactory.createMatteBorder(0, 0, 1, 0, StudioTheme.SEPARATOR),
-                StudioTheme.emptyBorder(12, 14, 12, 14)
-        ));
-        titleLabel.setFont(StudioTheme.titleFont());
-        detailLabel.setForeground(StudioTheme.SECONDARY_TEXT);
-        detailLabel.setFont(StudioTheme.smallFont());
-        controls.add(titleLabel);
-        controls.add(detailLabel);
-
-        controls.add(sectionLabel("Show"));
-        controls.add(buildViewButtons());
-        controls.add(sectionLabel("Depth"));
-        controls.add(buildDepthRow());
-        return controls;
-    }
-
-    private JPanel buildViewButtons() {
-        JPanel row = new JPanel(new GridLayout(1, 0, StudioTheme.scale(4), 0));
-        row.setOpaque(false);
-        ButtonGroup group = new ButtonGroup();
-        for (PaletteLayerScale.View view : PaletteLayerScale.View.values()) {
-            JToggleButton button = new JToggleButton(view.toString());
-            button.setFocusable(false);
-            button.setSelected(view == selectedView);
-            button.addActionListener(event -> {
-                selectedView = view;
-                listener.onViewChanged(view);
-            });
-            group.add(button);
-            row.add(button);
-        }
-        return row;
-    }
-
-    private JPanel buildDepthRow() {
-        depthRow.setOpaque(false);
-        shallowerButton.setToolTipText("Show the block one higher up");
-        deeperButton.setToolTipText("Show the block one further down");
-        shallowerButton.addActionListener(event -> changeDepth(-1));
-        deeperButton.addActionListener(event -> changeDepth(1));
-        depthRow.add(shallowerButton, BorderLayout.WEST);
-        depthRow.add(depthLabel, BorderLayout.CENTER);
-        depthRow.add(deeperButton, BorderLayout.EAST);
-        return depthRow;
-    }
-
-    private void changeDepth(int step) {
-        int nextDepth = Math.clamp(depth + step, 0, deepestDepth);
-        if (nextDepth == depth) {
-            return;
-        }
-        depth = nextDepth;
-        refreshDepthControls();
-        listener.onDepthChanged(depth);
-    }
-
-    private void refreshDepthControls() {
-        depthLabel.setText(depthText(depth, deepestDepth));
-        shallowerButton.setEnabled(depth > 0);
-        deeperButton.setEnabled(depth < deepestDepth);
-    }
-
-    private static JLabel sectionLabel(String text) {
-        JLabel label = new JLabel(text.toUpperCase(Locale.ROOT));
-        label.setForeground(StudioTheme.MUTED_TEXT);
-        label.setFont(StudioTheme.sectionFont());
-        return label;
-    }
-
-    // Stacked layers divide their coordinates by the zoom twice before sampling; wall and slab blocks only once.
-    private static String placementText(PaletteLayerPreview preview) {
-        if (!preview.palette().kind().isStacked()) {
-            return "Single blocks · zoom " + formatZoom(preview.zoom());
-        }
-        return thicknessText(preview) + " · zoom " + formatZoom(preview.zoom())
-                + " (×" + formatZoom(preview.zoom() * preview.zoom()) + " effective)";
-    }
-
-    private static String thicknessText(PaletteLayerPreview preview) {
-        if (preview.minThickness() == preview.maxThickness()) {
-            return preview.maxThickness() + (preview.maxThickness() == 1 ? " block thick" : " blocks thick");
-        }
-        return preview.minThickness() + "–" + preview.maxThickness() + " blocks thick";
-    }
-
-    private static String depthText(int depth, int deepestDepth) {
-        if (deepestDepth == 0) {
-            return "Top block only";
-        }
-        return depth == 0 ? "Top block" : depth + (depth == 1 ? " block down" : " blocks down");
-    }
-
-    private static String formatZoom(double zoom) {
-        return zoom == Math.rint(zoom) ? Long.toString((long) zoom) : String.format(Locale.ROOT, "%.2f", zoom);
-    }
-
-    private static String percent(double share) {
-        if (share > 0D && share < 0.001D) {
-            return "<0.1%";
-        }
-        return String.format(Locale.ROOT, "%.1f%%", share * 100D);
-    }
-
-    interface Listener {
-        void onViewChanged(PaletteLayerScale.View view);
-
-        void onDepthChanged(int depth);
-    }
-
-    private static final class StatisticsView extends JComponent {
-        private static final long serialVersionUID = -2318840125766150871L;
-        private static final int MARGIN = 14;
-        private static final int HISTOGRAM_HEIGHT = 84;
-        private static final int BAND_HEIGHT = 12;
-        private static final int SECTION_GAP = 18;
-        private static final int TITLE_GAP = 6;
-        private static final int NOTE_GAP = 4;
-        private static final String WIDEST_WEIGHT = "100.0%";
-        private static final String WIDEST_ACTUAL = "▲ 100.0%";
-
-        private PaletteLayerPreview preview;
-        private String textureStatus;
-
-        private StatisticsView() {
-            setOpaque(true);
-            setBackground(StudioTheme.PANEL_BACKGROUND);
-        }
-
-        private void show(PaletteLayerPreview nextPreview) {
-            preview = nextPreview;
-            revalidate();
-            repaint();
-        }
-
-        private void showTextureStatus(String status) {
-            textureStatus = status;
-            revalidate();
-            repaint();
-        }
-
-        @Override
-        public Dimension getPreferredSize() {
-            int preferredWidth = StudioTheme.scale(PANEL_WIDTH - 20);
-            if (preview == null) {
-                return new Dimension(preferredWidth, 0);
-            }
-            int margin = StudioTheme.scale(MARGIN);
-            int width = Math.max(getWidth(), preferredWidth) - margin * 2;
-            int height = margin + valueSpreadHeight() + StudioTheme.scale(SECTION_GAP) + blockTableHeight()
-                    + StudioTheme.scale(SECTION_GAP) + notesHeight(width) + margin;
-            return new Dimension(preferredWidth, height);
-        }
-
-        @Override
-        protected void paintComponent(Graphics graphics) {
-            Graphics2D canvas = (Graphics2D) graphics.create();
-            try {
-                canvas.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
-                canvas.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
-                canvas.setColor(StudioTheme.PANEL_BACKGROUND);
-                canvas.fillRect(0, 0, getWidth(), getHeight());
-                if (preview == null) {
-                    return;
-                }
-                int margin = StudioTheme.scale(MARGIN);
-                int width = getWidth() - margin * 2;
-                int top = margin;
-                drawValueSpread(canvas, margin, top, width);
-                top += valueSpreadHeight() + StudioTheme.scale(SECTION_GAP);
-                drawBlockTable(canvas, margin, top, width);
-                top += blockTableHeight() + StudioTheme.scale(SECTION_GAP);
-                drawNotes(canvas, margin, top, width);
-            } finally {
-                canvas.dispose();
-            }
-        }
-
-        private int valueSpreadHeight() {
-            return sectionMetrics().getHeight() + StudioTheme.scale(TITLE_GAP) + StudioTheme.scale(HISTOGRAM_HEIGHT)
-                    + StudioTheme.scale(2) + StudioTheme.scale(BAND_HEIGHT) + StudioTheme.scale(3) + smallMetrics().getHeight();
-        }
-
-        private int blockTableHeight() {
-            return sectionMetrics().getHeight() + StudioTheme.scale(TITLE_GAP) + rowHeight() * preview.entries().size();
-        }
-
-        private int notesHeight(int width) {
-            FontMetrics metrics = smallMetrics();
-            int height = 0;
-            for (String note : notes()) {
-                height += wrap(note, metrics, width).size() * metrics.getHeight() + StudioTheme.scale(NOTE_GAP);
-            }
-            return height;
-        }
-
-        private int rowHeight() {
-            return textMetrics().getHeight() + StudioTheme.scale(4);
-        }
-
-        private FontMetrics textMetrics() {
-            return getFontMetrics(StudioTheme.font());
-        }
-
-        private FontMetrics smallMetrics() {
-            return getFontMetrics(StudioTheme.smallFont());
-        }
-
-        private FontMetrics sectionMetrics() {
-            return getFontMetrics(StudioTheme.sectionFont());
-        }
-
-        private void drawValueSpread(Graphics2D canvas, int x, int top, int width) {
-            drawSectionTitle(canvas, "Noise values this layer produces", x, top + sectionMetrics().getAscent());
-            int histogramTop = top + sectionMetrics().getHeight() + StudioTheme.scale(TITLE_GAP);
-            int histogramHeight = StudioTheme.scale(HISTOGRAM_HEIGHT);
-            int bandHeight = StudioTheme.scale(BAND_HEIGHT);
-            long[] histogram = preview.histogram();
-            long peak = 1L;
-            for (long count : histogram) {
-                peak = Math.max(peak, count);
-            }
-            canvas.setColor(HISTOGRAM_BAR);
-            for (int bin = 0; bin < histogram.length; bin++) {
-                int barLeft = x + (bin * width) / histogram.length;
-                int barRight = x + ((bin + 1) * width) / histogram.length;
-                int barHeight = (int) Math.round(histogramHeight * (histogram[bin] / (double) peak));
-                canvas.fillRect(barLeft, histogramTop + histogramHeight - barHeight, Math.max(1, barRight - barLeft - 1), barHeight);
-            }
-
-            int bandTop = histogramTop + histogramHeight + StudioTheme.scale(2);
-            for (PaletteLayerPreview.Entry entry : preview.entries()) {
-                if (Double.isNaN(entry.lowestNoise())) {
-                    continue;
-                }
-                int bandLeft = x + (int) Math.round(entry.lowestNoise() * width);
-                int bandRight = x + (int) Math.round(entry.highestNoise() * width);
-                canvas.setColor(new Color(entry.color()));
-                canvas.fillRect(bandLeft, bandTop, Math.max(1, bandRight - bandLeft), bandHeight);
-                if (entry.highestNoise() < 1D) {
-                    canvas.setColor(BAND_DIVIDER);
-                    canvas.drawLine(bandRight, histogramTop, bandRight, bandTop + bandHeight - 1);
-                }
-            }
-
-            canvas.setFont(StudioTheme.smallFont());
-            canvas.setColor(StudioTheme.SECONDARY_TEXT);
-            FontMetrics metrics = canvas.getFontMetrics();
-            int labelY = bandTop + bandHeight + StudioTheme.scale(3) + metrics.getAscent();
-            canvas.drawString("0", x, labelY);
-            canvas.drawString("0.5", x + (width - metrics.stringWidth("0.5")) / 2, labelY);
-            canvas.drawString("1", x + width - metrics.stringWidth("1"), labelY);
-        }
-
-        private void drawBlockTable(Graphics2D canvas, int x, int top, int width) {
-            int columnGap = StudioTheme.scale(10);
-            int actualRight = x + width;
-            int weightRight = actualRight - textMetrics().stringWidth(WIDEST_ACTUAL) - columnGap;
-            int nameRight = weightRight - textMetrics().stringWidth(WIDEST_WEIGHT) - columnGap;
-            int titleBaseline = top + sectionMetrics().getAscent();
-            drawSectionTitle(canvas, "Blocks", x, titleBaseline);
-            drawRightAligned(canvas, "weight", weightRight, titleBaseline);
-            drawRightAligned(canvas, "actual", actualRight, titleBaseline);
-
-            int rowHeight = rowHeight();
-            FontMetrics text = textMetrics();
-            int swatchSize = text.getAscent() - text.getDescent();
-            int rowTop = top + sectionMetrics().getHeight() + StudioTheme.scale(TITLE_GAP);
-            for (PaletteLayerPreview.Entry entry : preview.entries()) {
-                int baseline = rowTop + (rowHeight + text.getAscent() - text.getDescent()) / 2;
-                drawSwatch(canvas, entry, x, rowTop + (rowHeight - swatchSize) / 2, swatchSize);
-                canvas.setFont(StudioTheme.font());
-                canvas.setColor(entry.found() ? StudioTheme.TEXT : StudioTheme.ERROR);
-                String name = entry.found() ? shortBlockName(entry.block()) : shortBlockName(entry.block()) + " (not found)";
-                int nameLeft = x + swatchSize + StudioTheme.scale(7);
-                canvas.drawString(fit(canvas, name, nameRight - nameLeft), nameLeft, baseline);
-                canvas.setColor(StudioTheme.SECONDARY_TEXT);
-                drawRightAligned(canvas, percent(entry.weightShare()), weightRight, baseline);
-                canvas.setColor(actualColor(entry));
-                drawRightAligned(canvas, actualText(entry), actualRight, baseline);
-                rowTop += rowHeight;
-            }
-        }
-
-        private static void drawSwatch(Graphics2D canvas, PaletteLayerPreview.Entry entry, int x, int y, int size) {
-            if (entry.texture() != null) {
-                canvas.drawImage(entry.texture().toImage(), x, y, size, size, null);
-                return;
-            }
-            canvas.setColor(new Color(entry.color()));
-            int arc = StudioTheme.scale(3);
-            canvas.fillRoundRect(x, y, size, size, arc, arc);
-        }
-
-        private void drawNotes(Graphics2D canvas, int x, int top, int width) {
-            canvas.setFont(StudioTheme.smallFont());
-            canvas.setColor(StudioTheme.SECONDARY_TEXT);
-            FontMetrics metrics = canvas.getFontMetrics();
-            int lineY = top + metrics.getAscent();
-            for (String note : notes()) {
-                for (String line : wrap(note, metrics, width)) {
-                    canvas.drawString(line, x, lineY);
-                    lineY += metrics.getHeight();
-                }
-                lineY += StudioTheme.scale(NOTE_GAP);
-            }
-        }
-
-        private List<String> notes() {
-            List<String> notes = new ArrayList<>();
-            if (textureStatus != null) {
-                notes.add(textureStatus);
-            }
-            notes.add("▼ gets under half its weight, ▲ gets over double.");
-            notes.add(String.format(Locale.ROOT, "Measured on a %d × %d grid spread over %,.0f blocks around 0, 0.",
-                    PaletteLayerPreview.STATISTICS_GRID_SIZE, PaletteLayerPreview.STATISTICS_GRID_SIZE,
-                    PaletteLayerPreview.statisticsAreaBlocks()));
-            if (preview.absentShare() > 0D) {
-                notes.add(absentText(preview) + " That ground is dark on the map and left out of the shares.");
-            }
-            if (preview.outOfRangeShare() > 0D) {
-                notes.add(percent(preview.outOfRangeShare()) + " of the noise values fall outside 0 to 1."
-                        + " Those spots get the first block.");
-            }
-            if (preview.simplification() != null) {
-                notes.add(preview.simplification());
-            }
-            if (preview.hasSlopeCondition()) {
-                notes.add("This " + paletteNoun(preview) + " has a slope condition, which the preview ignores.");
-            }
-            return notes;
-        }
-
-        private static String absentText(PaletteLayerPreview preview) {
-            if (isDecorator(preview)) {
-                return "The decorator leaves " + percent(preview.absentShare()) + " of the ground bare.";
-            }
-            return "The layer doesn't reach this depth on " + percent(preview.absentShare()) + " of the ground.";
-        }
-
-        private static String paletteNoun(PaletteLayerPreview preview) {
-            return isDecorator(preview) ? "decorator" : "layer";
-        }
-
-        private static boolean isDecorator(PaletteLayerPreview preview) {
-            return preview.palette().kind() == BiomePalette.Kind.DECORATOR;
-        }
-
-        private static String actualText(PaletteLayerPreview.Entry entry) {
-            if (entry.isFarBelowWeight()) {
-                return "▼ " + percent(entry.actualShare());
-            }
-            if (entry.isFarAboveWeight()) {
-                return "▲ " + percent(entry.actualShare());
-            }
-            return percent(entry.actualShare());
-        }
-
-        private static Color actualColor(PaletteLayerPreview.Entry entry) {
-            return entry.isFarBelowWeight() || entry.isFarAboveWeight() ? StudioTheme.WARNING : StudioTheme.TEXT;
-        }
-
-        private static void drawSectionTitle(Graphics2D canvas, String title, int x, int y) {
-            canvas.setFont(StudioTheme.sectionFont());
-            canvas.setColor(StudioTheme.MUTED_TEXT);
-            canvas.drawString(title.toUpperCase(Locale.ROOT), x, y);
-        }
-
-        private static void drawRightAligned(Graphics2D canvas, String text, int right, int y) {
-            canvas.drawString(text, right - canvas.getFontMetrics().stringWidth(text), y);
-        }
-
-        private static String shortBlockName(String block) {
-            return block.startsWith("minecraft:") ? block.substring("minecraft:".length()) : block;
-        }
-
-        private static String fit(Graphics2D canvas, String text, int maxWidth) {
-            FontMetrics metrics = canvas.getFontMetrics();
-            if (metrics.stringWidth(text) <= maxWidth) {
-                return text;
-            }
-            String shortened = text;
-            while (shortened.length() > 1 && metrics.stringWidth(shortened + "…") > maxWidth) {
-                shortened = shortened.substring(0, shortened.length() - 1);
-            }
-            return shortened + "…";
-        }
-
-        private static List<String> wrap(String text, FontMetrics metrics, int maxWidth) {
-            List<String> lines = new ArrayList<>();
-            StringBuilder line = new StringBuilder();
-            for (String word : text.split(" ")) {
-                String candidate = line.isEmpty() ? word : line + " " + word;
-                if (metrics.stringWidth(candidate) > maxWidth && !line.isEmpty()) {
-                    lines.add(line.toString());
-                    line = new StringBuilder(word);
-                } else {
-                    line = new StringBuilder(candidate);
-                }
-            }
-            if (!line.isEmpty()) {
-                lines.add(line.toString());
-            }
-            return lines;
-        }
-    }
-}
@@ -1,457 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.core.gui.BlockTextures.BlockTexture;
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisBiomePaletteLayer;
-import com.volmit.iris.engine.object.IrisBlockData;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.math.RNG;
-import org.bukkit.block.data.BlockData;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
-
-final class PaletteLayerPreview {
-    static final int HISTOGRAM_BINS = 50;
-    static final int STATISTICS_GRID_SIZE = 64;
-    static final double STATISTICS_SPACING_BLOCKS = 37D;
-    private static final int MISSING_BLOCK_COLOR = 0x5A5F6B;
-    private static final double FAR_FROM_WEIGHT_FACTOR = 2D;
-    private static final int BLOCK_CACHE_SIZE = 1 << 16;
-    private static final int NO_OVERHANG = -1;
-
-    private final BiomePalette palette;
-    private final KList<IrisBlockData> blocks;
-    private final BiomePalettePlacement placement;
-    private final PaletteLayerPreview ground;
-    private final boolean[] showsGroundByEntry;
-    private final int depth;
-    private final IrisData data;
-    private final int[] entryBySlot;
-    private final BiomeTintField biomeTints;
-    private final BlockTexture[] textureByEntry;
-    private final BlockTexture[] upperHalfByEntry;
-    private final boolean hasTallPlants;
-    private final BlockTexture[] legendTextureByEntry;
-    private final int[] legendColorByEntry;
-    private final List<Entry> entries;
-    private final SampledBlock[] blockCache = new SampledBlock[BLOCK_CACHE_SIZE];
-    private final long[] histogram;
-    private final double absentShare;
-    private final double outOfRangeShare;
-
-    private PaletteLayerPreview(BiomePalette palette, BiomePalettePlacement placement, PaletteLayerPreview ground, int depth,
-                                IrisData data, BlockTextures textures, BiomeTintField biomeTints) {
-        this.palette = palette;
-        this.blocks = placement.blocks();
-        this.placement = placement;
-        this.ground = ground;
-        this.depth = depth;
-        this.data = data;
-        this.entryBySlot = IrisBiomePaletteLayer.paletteEntryPerSlot(blocks, data).stream().mapToInt(Integer::intValue).toArray();
-        if (entryBySlot.length == 0) {
-            throw new IllegalStateException("No block of " + palette.biomeKey() + " " + palette.lowercaseLabel() + " could be found");
-        }
-        this.biomeTints = biomeTints;
-        this.showsGroundByEntry = resolveGroundShowingEntries();
-        this.textureByEntry = resolveEntryTextures(textures);
-        this.upperHalfByEntry = resolveUpperHalves(textures);
-        this.hasTallPlants = Arrays.stream(upperHalfByEntry).anyMatch(Objects::nonNull);
-        this.legendTextureByEntry = tintForLegend(legendTextures());
-        this.legendColorByEntry = resolveLegendColors();
-
-        Statistics statistics = measure();
-        this.histogram = statistics.histogram();
-        this.absentShare = statistics.absentShare();
-        this.outOfRangeShare = statistics.outOfRangeShare();
-        this.entries = describeEntries(statistics.sharesByEntry());
-    }
-
-    static PaletteLayerPreview load(Engine engine, BiomePalette palette, int depth, BlockTextures textures) {
-        if (engine == null || engine.isClosed()) {
-            throw new IllegalStateException("Open a studio world to preview pack palettes");
-        }
-        IrisData data = engine.getData();
-        IrisBiome biome = data.getBiomeLoader().load(palette.biomeKey());
-        if (biome == null || palette.blocksIn(biome) == null) {
-            throw new IllegalStateException("Palette removed during hotload: " + palette.biomeKey() + " " + palette.lowercaseLabel());
-        }
-        BiomePalettePlacement placement = BiomePalettePlacement.of(engine, biome, palette);
-        BiomeTintField biomeTints = textures == null
-                ? null
-                : new BiomeTintField(biome, new RNG(engine.getSeedManager().getBiome()), textures.biomeColors());
-        PaletteLayerPreview ground = palette.kind() == BiomePalette.Kind.DECORATOR
-                ? groundUnder(engine, palette.biomeKey(), biome, data, textures, biomeTints)
-                : null;
-        return new PaletteLayerPreview(palette, placement, ground, depth, data, textures, biomeTints);
-    }
-
-    // Decorations stand on the biome's top surface layer, so that is what shows around and between them.
-    private static PaletteLayerPreview groundUnder(Engine engine, String biomeKey, IrisBiome biome, IrisData data,
-                                                   BlockTextures textures, BiomeTintField biomeTints) {
-        BiomePalette topLayer = new BiomePalette(biomeKey, BiomePalette.Kind.LAYER, 0);
-        KList<IrisBlockData> blocks = topLayer.blocksIn(biome);
-        if (blocks == null || blocks.isEmpty()) {
-            return null;
-        }
-        return new PaletteLayerPreview(topLayer, BiomePalettePlacement.of(engine, biome, topLayer), null, 0, data, textures,
-                biomeTints);
-    }
-
-    // The world picks one block per whole coordinate, and zoomed in, many pixels fall on the same block.
-    double sample(double x, double z) {
-        int blockX = (int) Math.floor(x);
-        int blockZ = (int) Math.floor(z);
-        int cacheSlot = blockCacheSlot(blockX, blockZ);
-        SampledBlock cached = blockCache[cacheSlot];
-        if (cached != null && cached.x() == blockX && cached.z() == blockZ) {
-            return cached.noise();
-        }
-        double noise = sampleBlock(blockX, blockZ);
-        blockCache[cacheSlot] = new SampledBlock(blockX, blockZ, noise);
-        return noise;
-    }
-
-    private double sampleBlock(int blockX, int blockZ) {
-        if (placement.thickness(blockX, blockZ) <= depth) {
-            return Double.NaN;
-        }
-        return placement.noise(blockX, blockZ, depth);
-    }
-
-    private static int blockCacheSlot(int blockX, int blockZ) {
-        long hash = blockX * 0x9E3779B97F4A7C15L ^ blockZ * 0xC2B2AE3D27D4EB4FL;
-        return (int) ((hash ^ (hash >>> 29)) & (BLOCK_CACHE_SIZE - 1));
-    }
-
-    int colorForNoise(double noise) {
-        return legendColorByEntry[entryIndexForNoise(noise)];
-    }
-
-    int blockColorAt(double noise, double worldX, double worldZ, boolean showTexturePixels) {
-        int overhang = showTexturePixels ? overhangColorAt(worldX, worldZ) : NO_OVERHANG;
-        if (overhang != NO_OVERHANG) {
-            return overhang;
-        }
-        int entry = entryIndexForNoise(noise);
-        if (showsGroundByEntry[entry]) {
-            return bareColorAt(worldX, worldZ, showTexturePixels);
-        }
-        BlockTexture texture = textureByEntry[entry];
-        if (texture == null) {
-            return legendColorByEntry[entry];
-        }
-        if (ground != null && showTexturePixels && !texture.isOpaqueAt(worldX, worldZ)) {
-            return groundColorAt(worldX, worldZ, true);
-        }
-        int untintedColor = showTexturePixels ? texture.texelAt(worldX, worldZ) : texture.averageColor();
-        return tinted(texture, untintedColor, worldX, worldZ);
-    }
-
-    /**
-     * The colour where the palette places nothing: the ground under a decorator, or plain dark otherwise.
-     */
-    int bareColorAt(double worldX, double worldZ, boolean showTexturePixels) {
-        if (ground == null) {
-            return PaletteLayerScale.ABSENT_COLOR;
-        }
-        int overhang = showTexturePixels ? overhangColorAt(worldX, worldZ) : NO_OVERHANG;
-        return overhang != NO_OVERHANG ? overhang : groundColorAt(worldX, worldZ, showTexturePixels);
-    }
-
-    // A two block tall plant stands up on the map: its top half covers the block above it, which is one block north.
-    private int overhangColorAt(double worldX, double worldZ) {
-        if (!hasTallPlants) {
-            return NO_OVERHANG;
-        }
-        double plantZ = worldZ + 1D;
-        double noise = sample(worldX, plantZ);
-        if (Double.isNaN(noise)) {
-            return NO_OVERHANG;
-        }
-        BlockTexture upperHalf = upperHalfByEntry[entryIndexForNoise(noise)];
-        if (upperHalf == null || !upperHalf.isOpaqueAt(worldX, worldZ)) {
-            return NO_OVERHANG;
-        }
-        return tinted(upperHalf, upperHalf.texelAt(worldX, worldZ), worldX, plantZ);
-    }
-
-    private int tinted(BlockTexture texture, int untintedColor, double worldX, double worldZ) {
-        if (texture.biomeTint() == null) {
-            return untintedColor;
-        }
-        int tint = biomeTints.colorAt(texture.biomeTint(), (int) Math.floor(worldX), (int) Math.floor(worldZ));
-        return BlockTexture.multiply(untintedColor, tint);
-    }
-
-    private int groundColorAt(double worldX, double worldZ, boolean showTexturePixels) {
-        double noise = ground.sample(worldX, worldZ);
-        return Double.isNaN(noise) ? PaletteLayerScale.ABSENT_COLOR : ground.blockColorAt(noise, worldX, worldZ, showTexturePixels);
-    }
-
-    // A decorator places air to leave gaps, which looks the same as placing nothing.
-    private boolean[] resolveGroundShowingEntries() {
-        boolean[] showsGround = new boolean[blocks.size()];
-        for (int entry = 0; entry < blocks.size(); entry++) {
-            BlockData block = blocks.get(entry).getBlockData(data);
-            showsGround[entry] = ground != null && block != null && block.getMaterial().isAir();
-        }
-        return showsGround;
-    }
-
-    Entry entryForNoise(double noise) {
-        return entries.get(entryIndexForNoise(noise));
-    }
-
-    String biomeKey() {
-        return palette.biomeKey();
-    }
-
-    BiomePalette palette() {
-        return palette;
-    }
-
-    String simplification() {
-        return placement.simplification();
-    }
-
-    int depth() {
-        return depth;
-    }
-
-    int minThickness() {
-        return placement.minThickness();
-    }
-
-    int maxThickness() {
-        return placement.maxThickness();
-    }
-
-    double zoom() {
-        return placement.zoom();
-    }
-
-    boolean hasSlopeCondition() {
-        return placement.hasSlopeCondition();
-    }
-
-    List<Entry> entries() {
-        return entries;
-    }
-
-    long[] histogram() {
-        return histogram.clone();
-    }
-
-    double absentShare() {
-        return absentShare;
-    }
-
-    double outOfRangeShare() {
-        return outOfRangeShare;
-    }
-
-    static double statisticsAreaBlocks() {
-        return STATISTICS_GRID_SIZE * STATISTICS_SPACING_BLOCKS;
-    }
-
-    private int entryIndexForNoise(double noise) {
-        return entryBySlot[IrisBiomePaletteLayer.slotForNoise(noise, entryBySlot.length)];
-    }
-
-    private BlockTexture[] resolveEntryTextures(BlockTextures textures) {
-        BlockTexture[] resolved = new BlockTexture[blocks.size()];
-        if (textures == null) {
-            return resolved;
-        }
-        for (int entry = 0; entry < blocks.size(); entry++) {
-            BlockData block = blocks.get(entry).getBlockData(data);
-            resolved[entry] = block == null ? null : textureOf(block, textures).orElse(null);
-        }
-        return resolved;
-    }
-
-    private BlockTexture[] resolveUpperHalves(BlockTextures textures) {
-        BlockTexture[] resolved = new BlockTexture[blocks.size()];
-        if (textures == null || palette.kind() != BiomePalette.Kind.DECORATOR) {
-            return resolved;
-        }
-        for (int entry = 0; entry < blocks.size(); entry++) {
-            BlockData block = blocks.get(entry).getBlockData(data);
-            resolved[entry] = block == null ? null : textures.upperHalfIcon(block).orElse(null);
-        }
-        return resolved;
-    }
-
-    // Tall plants are known by their top half, the way Minecraft draws them in the inventory.
-    private BlockTexture[] legendTextures() {
-        BlockTexture[] legend = textureByEntry.clone();
-        for (int entry = 0; entry < legend.length; entry++) {
-            if (upperHalfByEntry[entry] != null) {
-                legend[entry] = upperHalfByEntry[entry];
-            }
-        }
-        return legend;
-    }
-
-    private Optional<BlockTexture> textureOf(BlockData block, BlockTextures textures) {
-        return palette.kind() == BiomePalette.Kind.DECORATOR ? textures.iconTexture(block) : textures.topTexture(block);
-    }
-
-    // The legend shows tinted blocks as they look at the world origin, where the statistics are sampled too.
-    private BlockTexture[] tintForLegend(BlockTexture[] textures) {
-        BlockTexture[] tinted = new BlockTexture[textures.length];
-        for (int entry = 0; entry < textures.length; entry++) {
-            BlockTexture texture = textures[entry];
-            tinted[entry] = texture == null || texture.biomeTint() == null
-                    ? texture
-                    : texture.tinted(biomeTints.colorAt(texture.biomeTint(), 0, 0));
-        }
-        return tinted;
-    }
-
-    // Blocks without a texture, like custom blocks or everything before the textures load, fall back to map colours.
-    private int[] resolveLegendColors() {
-        List<BlockData> untexturedBlocks = new ArrayList<>();
-        for (int entry = 0; entry < blocks.size(); entry++) {
-            BlockData block = blocks.get(entry).getBlockData(data);
-            if (block != null && textureByEntry[entry] == null) {
-                untexturedBlocks.add(block);
-            }
-        }
-        Map<String, Integer> mapColorsByBlock = BlockPreviewColors.colorsByBlock(untexturedBlocks);
-        int[] colors = new int[blocks.size()];
-        for (int entry = 0; entry < blocks.size(); entry++) {
-            BlockData block = blocks.get(entry).getBlockData(data);
-            if (block == null) {
-                colors[entry] = MISSING_BLOCK_COLOR;
-            } else if (legendTextureByEntry[entry] != null) {
-                colors[entry] = legendTextureByEntry[entry].averageColor();
-            } else {
-                colors[entry] = mapColorsByBlock.get(block.getAsString(true));
-            }
-        }
-        return colors;
-    }
-
-    private Statistics measure() {
-        long[] values = new long[HISTOGRAM_BINS];
-        long[] samplesByEntry = new long[blocks.size()];
-        long present = 0;
-        long absent = 0;
-        long outOfRange = 0;
-        double origin = -statisticsAreaBlocks() / 2D;
-        for (int gridX = 0; gridX < STATISTICS_GRID_SIZE; gridX++) {
-            for (int gridZ = 0; gridZ < STATISTICS_GRID_SIZE; gridZ++) {
-                double noise = sample(origin + gridX * STATISTICS_SPACING_BLOCKS, origin + gridZ * STATISTICS_SPACING_BLOCKS);
-                if (Double.isNaN(noise)) {
-                    absent++;
-                    continue;
-                }
-                present++;
-                if (noise < 0D || noise > 1D) {
-                    outOfRange++;
-                }
-                values[Math.clamp((int) (noise * HISTOGRAM_BINS), 0, HISTOGRAM_BINS - 1)]++;
-                samplesByEntry[entryIndexForNoise(noise)]++;
-            }
-        }
-        double[] sharesByEntry = new double[samplesByEntry.length];
-        for (int entry = 0; entry < samplesByEntry.length; entry++) {
-            sharesByEntry[entry] = present == 0 ? 0D : samplesByEntry[entry] / (double) present;
-        }
-        long total = present + absent;
-        return new Statistics(values, sharesByEntry, absent / (double) total, present == 0 ? 0D : outOfRange / (double) present);
-    }
-
-    private List<Entry> describeEntries(double[] sharesByEntry) {
-        int slotCount = entryBySlot.length;
-        List<Entry> described = new ArrayList<>(blocks.size());
-        for (int entry = 0; entry < blocks.size(); entry++) {
-            IrisBlockData block = blocks.get(entry);
-            int firstSlot = firstSlotOf(entry);
-            int lastSlot = lastSlotOf(entry);
-            boolean placed = firstSlot >= 0;
-            described.add(new Entry(
-                    block.getBlock(),
-                    block.getWeight(),
-                    block.getBlockData(data) != null,
-                    legendColorByEntry[entry],
-                    legendTextureByEntry[entry],
-                    placed ? (lastSlot - firstSlot + 1) / (double) slotCount : 0D,
-                    sharesByEntry[entry],
-                    placed ? slotLowerBound(firstSlot, slotCount) : Double.NaN,
-                    placed ? slotUpperBound(lastSlot, slotCount) : Double.NaN
-            ));
-        }
-        return List.copyOf(described);
-    }
-
-    private int firstSlotOf(int entry) {
-        for (int slot = 0; slot < entryBySlot.length; slot++) {
-            if (entryBySlot[slot] == entry) {
-                return slot;
-            }
-        }
-        return -1;
-    }
-
-    private int lastSlotOf(int entry) {
-        for (int slot = entryBySlot.length - 1; slot >= 0; slot--) {
-            if (entryBySlot[slot] == entry) {
-                return slot;
-            }
-        }
-        return -1;
-    }
-
-    // Slots are picked by rounding, so the first and last slot only own half a step of the value range.
-    private static double slotLowerBound(int slot, int slotCount) {
-        return slot == 0 ? 0D : (slot - 0.5D) / (slotCount - 1);
-    }
-
-    private static double slotUpperBound(int slot, int slotCount) {
-        return slot == slotCount - 1 ? 1D : (slot + 0.5D) / (slotCount - 1);
-    }
-
-    record Entry(String block, int weight, boolean found, int color, BlockTexture texture, double weightShare,
-                 double actualShare, double lowestNoise, double highestNoise) {
-        boolean isFarBelowWeight() {
-            return found && actualShare < weightShare / FAR_FROM_WEIGHT_FACTOR;
-        }
-
-        boolean isFarAboveWeight() {
-            return found && actualShare > weightShare * FAR_FROM_WEIGHT_FACTOR;
-        }
-    }
-
-    private record SampledBlock(int x, int z, double noise) {
-    }
-
-    private record Statistics(long[] histogram, double[] sharesByEntry, double absentShare, double outOfRangeShare) {
-    }
-}
@@ -1,107 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import java.awt.Color;
-
-final class PaletteLayerScale implements NoiseColorScale {
-    static final int ABSENT_COLOR = 0x161A24;
-    private static final double OVERLAY_DARKEST_SHADE = 0.3D;
-
-    private final View view;
-    private final PaletteLayerPreview preview;
-    private final NoisePalette noisePalette;
-    private final boolean showTexturePixels;
-
-    PaletteLayerScale(View view, PaletteLayerPreview preview, NoisePalette noisePalette, boolean showTexturePixels) {
-        this.view = view;
-        this.preview = preview;
-        this.noisePalette = noisePalette;
-        this.showTexturePixels = showTexturePixels;
-    }
-
-    @Override
-    public int colorAt(double value, double worldX, double worldZ) {
-        if (view == View.NOISE) {
-            return noisePalette.colorFinite(value);
-        }
-        int blockColor = preview.blockColorAt(value, worldX, worldZ, showTexturePixels);
-        return view == View.BLOCKS ? blockColor : BlockPreviewColors.shade(blockColor, overlayShade(value));
-    }
-
-    @Override
-    public int colorFinite(double value) {
-        return switch (view) {
-            case BLOCKS -> preview.colorForNoise(value);
-            case NOISE -> noisePalette.colorFinite(value);
-            case BLOCKS_SHADED_BY_NOISE -> BlockPreviewColors.shade(preview.colorForNoise(value), overlayShade(value));
-        };
-    }
-
-    @Override
-    public int colorInvalid() {
-        return ABSENT_COLOR;
-    }
-
-    @Override
-    public int colorInvalidAt(double worldX, double worldZ) {
-        return view == View.NOISE ? ABSENT_COLOR : preview.bareColorAt(worldX, worldZ, showTexturePixels);
-    }
-
-    @Override
-    public Color displayColorNormalized(double normalized) {
-        return new Color(colorFinite(minimum() + normalized * (maximum() - minimum())));
-    }
-
-    @Override
-    public String label() {
-        return view == View.NOISE ? noisePalette.label() : view.toString();
-    }
-
-    @Override
-    public double minimum() {
-        return view == View.NOISE ? noisePalette.minimum() : 0D;
-    }
-
-    @Override
-    public double maximum() {
-        return view == View.NOISE ? noisePalette.maximum() : 1D;
-    }
-
-    private static double overlayShade(double value) {
-        return OVERLAY_DARKEST_SHADE + (1D - OVERLAY_DARKEST_SHADE) * Math.clamp(value, 0D, 1D);
-    }
-
-    enum View {
-        BLOCKS("Blocks"),
-        NOISE("Noise"),
-        BLOCKS_SHADED_BY_NOISE("Both");
-
-        private final String label;
-
-        View(String label) {
-            this.label = label;
-        }
-
-        @Override
-        public String toString() {
-            return label;
-        }
-    }
-}
@@ -1,527 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.core.gui.PaletteCatalog.BiomeEntry;
-import com.volmit.iris.core.gui.PaletteCatalog.BiomeGroup;
-import com.volmit.iris.core.gui.PaletteCatalog.RegionEntry;
-import com.volmit.iris.core.gui.PlayerLocationTracker.PlayerLocation;
-
-import javax.swing.BorderFactory;
-import javax.swing.ButtonGroup;
-import javax.swing.DefaultListCellRenderer;
-import javax.swing.DefaultListModel;
-import javax.swing.JLabel;
-import javax.swing.JList;
-import javax.swing.JPanel;
-import javax.swing.JTextField;
-import javax.swing.JToggleButton;
-import javax.swing.JTree;
-import javax.swing.ListSelectionModel;
-import javax.swing.event.DocumentEvent;
-import javax.swing.event.DocumentListener;
-import javax.swing.tree.DefaultMutableTreeNode;
-import javax.swing.tree.DefaultTreeCellRenderer;
-import javax.swing.tree.DefaultTreeModel;
-import javax.swing.tree.TreePath;
-import javax.swing.tree.TreeSelectionModel;
-import java.awt.BorderLayout;
-import java.awt.CardLayout;
-import java.awt.Component;
-import java.awt.GridLayout;
-import java.awt.Rectangle;
-import java.util.Enumeration;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Locale;
-import java.util.Set;
-
-
-final class PaletteNavigator extends JPanel {
-    private static final long serialVersionUID = -6402313718430917284L;
-    private static final String HERE_CARD = "here";
-    private static final String OVERVIEW_CARD = "overview";
-    private static final int MESSAGE_WRAP_WIDTH_PIXELS = 190;
-
-    private final Listener listener;
-    private final CardLayout cards = new CardLayout();
-    private final JPanel cardPanel = new JPanel(cards);
-    private final JLabel regionLabel = new JLabel();
-    private final DefaultListModel<HereRow> hereRows = new DefaultListModel<>();
-    private final JList<HereRow> hereList = new JList<>(hereRows);
-    private final JTextField searchField = new JTextField();
-    private final DefaultTreeModel treeModel = new DefaultTreeModel(new DefaultMutableTreeNode());
-    private final JTree overviewTree = new JTree(treeModel);
-
-    private PaletteCatalog catalog;
-    private PlayerLocation location;
-    private BiomePalette selectedPalette;
-    private boolean updatingSelection;
-    private boolean untracked;
-
-    PaletteNavigator(Listener listener) {
-        super(new BorderLayout());
-        this.listener = listener;
-        cardPanel.add(buildHereCard(), HERE_CARD);
-        cardPanel.add(buildOverviewCard(), OVERVIEW_CARD);
-        add(buildTabBar(), BorderLayout.NORTH);
-        add(cardPanel, BorderLayout.CENTER);
-        refreshHere();
-    }
-
-    void showCatalog(PaletteCatalog nextCatalog) {
-        catalog = nextCatalog;
-        rebuildOverview();
-        refreshHere();
-    }
-
-    void showLocation(PlayerLocation nextLocation) {
-        location = nextLocation;
-        refreshHere();
-    }
-
-    // Without a player there is nowhere to call "here", so the Here tab explains how to get one instead.
-    void showUntracked() {
-        untracked = true;
-        refreshHere();
-    }
-
-    void markSelected(BiomePalette palette) {
-        selectedPalette = palette;
-        updatingSelection = true;
-        try {
-            selectInHereList();
-            selectInTree();
-        } finally {
-            updatingSelection = false;
-        }
-    }
-
-    private JPanel buildTabBar() {
-        JPanel bar = new JPanel(new GridLayout(1, 2, 0, 0));
-        bar.setBorder(BorderFactory.createMatteBorder(0, 0, 1, 0, StudioTheme.SEPARATOR));
-        ButtonGroup group = new ButtonGroup();
-        JToggleButton here = createTab("Here", HERE_CARD, group);
-        JToggleButton overview = createTab("Overview", OVERVIEW_CARD, group);
-        bar.add(here);
-        bar.add(overview);
-        here.doClick();
-        return bar;
-    }
-
-    private JToggleButton createTab(String text, String card, ButtonGroup group) {
-        JToggleButton tab = StudioToolbar.tab(text);
-        tab.addActionListener(event -> cards.show(cardPanel, card));
-        group.add(tab);
-        return tab;
-    }
-
-    private JPanel buildHereCard() {
-        JPanel card = new JPanel(new BorderLayout());
-        JPanel location = new JPanel(new GridLayout(0, 1, 0, StudioTheme.scale(3)));
-        location.setBorder(StudioTheme.emptyBorder(9, 12, 5, 12));
-        location.add(regionLabel);
-
-        hereList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
-        hereList.setCellRenderer(new HereRowRenderer());
-        hereList.addListSelectionListener(event -> {
-            HereRow row = hereList.getSelectedValue();
-            if (!event.getValueIsAdjusting() && !updatingSelection && row != null && row.biomeKey() != null) {
-                choose(row.biomeKey(), row.palette());
-            }
-        });
-        card.add(location, BorderLayout.NORTH);
-        card.add(StudioToolbar.scroll(hereList), BorderLayout.CENTER);
-        return card;
-    }
-
-    private JPanel buildOverviewCard() {
-        JPanel card = new JPanel(new BorderLayout());
-        StudioToolbar.makeSearchField(searchField, "Search biomes, snippets or blocks...");
-        searchField.getDocument().addDocumentListener(new DocumentListener() {
-            @Override
-            public void insertUpdate(DocumentEvent event) {
-                rebuildOverview();
-            }
-
-            @Override
-            public void removeUpdate(DocumentEvent event) {
-                rebuildOverview();
-            }
-
-            @Override
-            public void changedUpdate(DocumentEvent event) {
-                rebuildOverview();
-            }
-        });
-
-        overviewTree.setRootVisible(false);
-        overviewTree.setShowsRootHandles(true);
-        overviewTree.setRowHeight(StudioTheme.scale(24));
-        overviewTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
-        overviewTree.setCellRenderer(new OverviewRenderer());
-        overviewTree.addTreeSelectionListener(event -> {
-            if (!updatingSelection && nodeAt(event.getPath()) instanceof OverviewNode node && node.biomeKey() != null) {
-                choose(node.biomeKey(), node.palette());
-            }
-        });
-        card.add(StudioToolbar.padded(searchField, 8, 8, 8, 8), BorderLayout.NORTH);
-        card.add(StudioToolbar.scroll(overviewTree), BorderLayout.CENTER);
-        return card;
-    }
-
-    // Choosing a biome rather than one of its palettes opens its first palette.
-    private void choose(String biomeKey, BiomePalette palette) {
-        BiomeEntry biome = catalog == null ? null : catalog.biome(biomeKey);
-        BiomePalette chosen = palette != null ? palette : biome == null ? null : biome.firstPalette();
-        if (chosen != null) {
-            listener.onPaletteChosen(chosen);
-        }
-    }
-
-    private void refreshHere() {
-        updatingSelection = true;
-        try {
-            hereRows.clear();
-            if (untracked) {
-                showHereMessage("Run /iris std pal in-game to see the palettes where you stand.");
-                return;
-            }
-            if (location == null || catalog == null) {
-                showHereMessage("Finding where you are...");
-                return;
-            }
-            switch (location.status()) {
-                case OFFLINE -> showHereMessage("You are offline.");
-                case IN_OTHER_WORLD -> showHereMessage("You left the world this window shows.");
-                case IN_REGION -> showHereRows(location);
-            }
-            selectInHereList();
-        } finally {
-            updatingSelection = false;
-        }
-    }
-
-    private void showHereMessage(String message) {
-        regionLabel.setText("<html><body style='width:" + StudioTheme.scale(MESSAGE_WRAP_WIDTH_PIXELS) + "px'>" + message + "</body></html>");
-    }
-
-    private void showHereRows(PlayerLocation here) {
-        RegionEntry region = catalog.region(here.regionKey());
-        regionLabel.setText(labeled("Region", region == null ? here.regionKey() : region.name(), here.regionKey()));
-        addBiomePalettes("Surface biome here", here.surfaceBiomeKey());
-        if (here.isBelowSurfaceBiome()) {
-            addBiomePalettes("Underground biome at your height", here.biomeAtPositionKey());
-        }
-        if (region == null) {
-            return;
-        }
-        hereRows.addElement(HereRow.header("Biomes in this region"));
-        for (String biomeKey : region.allBiomeKeys()) {
-            addRegionBiome(biomeKey, 0, new HashSet<>(), here);
-        }
-    }
-
-    private void addBiomePalettes(String title, String biomeKey) {
-        BiomeEntry biome = catalog.biome(biomeKey);
-        if (biome == null) {
-            return;
-        }
-        hereRows.addElement(HereRow.header(title));
-        hereRows.addElement(HereRow.biome(biomeText(biome, childOfText(biome)), biomeKey, 0));
-        addPaletteRows(biome, 0);
-    }
-
-    private void addPaletteRows(BiomeEntry biome, int nesting) {
-        for (PaletteCatalog.PaletteSummary summary : biome.palettes()) {
-            hereRows.addElement(HereRow.palette(summary.text(), summary.palette(), nesting));
-        }
-    }
-
-    // Children sit under the biome they grow inside of, so a child biome is found where it actually appears.
-    private void addRegionBiome(String biomeKey, int nesting, Set<String> ancestors, PlayerLocation here) {
-        BiomeEntry biome = catalog.biome(biomeKey);
-        if (biome == null || !ancestors.add(biomeKey)) {
-            return;
-        }
-        boolean standingHere = biomeKey.equals(here.surfaceBiomeKey()) || biomeKey.equals(here.biomeAtPositionKey());
-        hereRows.addElement(HereRow.biome(biomeText(biome, standingHere ? "you are here" : null), biomeKey, nesting));
-        addPaletteRows(biome, nesting);
-        for (String childKey : biome.childKeys()) {
-            addRegionBiome(childKey, nesting + 1, new HashSet<>(ancestors), here);
-        }
-    }
-
-    private String childOfText(BiomeEntry biome) {
-        if (biome.parentKeys().isEmpty()) {
-            return null;
-        }
-        List<String> parentNames = biome.parentKeys().stream()
-                .map(key -> catalog.biome(key) == null ? key : catalog.biome(key).name())
-                .toList();
-        return "child of " + String.join(", ", parentNames);
-    }
-
-    private void rebuildOverview() {
-        if (catalog == null) {
-            return;
-        }
-        String filter = searchField.getText().trim().toLowerCase(Locale.ROOT);
-        DefaultMutableTreeNode root = new DefaultMutableTreeNode();
-        for (RegionEntry region : catalog.regions()) {
-            boolean regionMatches = !filter.isEmpty() && region.name().toLowerCase(Locale.ROOT).contains(filter);
-            DefaultMutableTreeNode regionNode = new DefaultMutableTreeNode(new OverviewNode(region.name(), region.key(), null, null));
-            for (BiomeGroup group : region.groups()) {
-                DefaultMutableTreeNode groupNode = new DefaultMutableTreeNode();
-                for (String biomeKey : group.biomeKeys()) {
-                    addBiomeNode(groupNode, biomeKey, regionMatches ? "" : filter, new HashSet<>());
-                }
-                if (groupNode.getChildCount() > 0) {
-                    groupNode.setUserObject(new OverviewNode(group.label(), groupNode.getChildCount() + " biomes", null, null));
-                    regionNode.add(groupNode);
-                }
-            }
-            if (regionNode.getChildCount() > 0) {
-                root.add(regionNode);
-            }
-        }
-        DefaultMutableTreeNode outside = new DefaultMutableTreeNode();
-        for (String biomeKey : catalog.biomesOutsideRegions()) {
-            addBiomeNode(outside, biomeKey, filter, new HashSet<>());
-        }
-        if (outside.getChildCount() > 0) {
-            outside.setUserObject(new OverviewNode("Not in any region", outside.getChildCount() + " biomes", null, null));
-            root.add(outside);
-        }
-        addSnippetNodes(root, filter);
-        updatingSelection = true;
-        try {
-            treeModel.setRoot(root);
-            if (!filter.isEmpty()) {
-                expandDownToBiomes(root);
-            }
-            selectInTree();
-        } finally {
-            updatingSelection = false;
-        }
-    }
-
-    private void addBiomeNode(DefaultMutableTreeNode parent, String biomeKey, String filter, Set<String> ancestors) {
-        BiomeEntry biome = catalog.biome(biomeKey);
-        if (biome == null || !ancestors.add(biomeKey)) {
-            return;
-        }
-        DefaultMutableTreeNode biomeNode = new DefaultMutableTreeNode(new OverviewNode(biome.name(), biomeKey, biomeKey, null));
-        for (PaletteCatalog.PaletteSummary summary : biome.palettes()) {
-            biomeNode.add(new DefaultMutableTreeNode(new OverviewNode(summary.text(), null, biomeKey, summary.palette())));
-        }
-        for (String childKey : biome.childKeys()) {
-            addBiomeNode(biomeNode, childKey, filter, new HashSet<>(ancestors));
-        }
-        boolean hasMatchingChild = biomeNode.getChildCount() > biome.palettes().size();
-        if (filter.isEmpty() || biome.matches(filter) || hasMatchingChild) {
-            parent.add(biomeNode);
-        }
-    }
-
-    // Snippets sit below the regions, so a palette picked elsewhere is still found in its biome first.
-    private void addSnippetNodes(DefaultMutableTreeNode root, String filter) {
-        for (BiomePalette.SnippetFolder folder : BiomePalette.SnippetFolder.values()) {
-            DefaultMutableTreeNode folderNode = new DefaultMutableTreeNode();
-            catalog.snippets().stream()
-                    .filter(snippet -> snippet.folder() == folder && (filter.isEmpty() || snippet.matches(filter)))
-                    .forEach(snippet -> folderNode.add(snippetNode(snippet)));
-            if (folderNode.getChildCount() > 0) {
-                folderNode.setUserObject(new OverviewNode(folder.label() + " snippets", folderNode.getChildCount() + " files", null, null));
-                root.add(folderNode);
-            }
-        }
-    }
-
-    // Picking a snippet opens it where the first biome using it places it; its children open the other uses.
-    private DefaultMutableTreeNode snippetNode(PaletteCatalog.SnippetEntry snippet) {
-        if (snippet.uses().isEmpty()) {
-            return new DefaultMutableTreeNode(new OverviewNode(snippet.path(), "not used by any biome", null, null));
-        }
-        BiomePalette firstUse = snippet.uses().get(0);
-        String usedBy = snippet.uses().size() == 1 ? "used once" : "used " + snippet.uses().size() + " times";
-        DefaultMutableTreeNode node = new DefaultMutableTreeNode(new OverviewNode(snippet.path() + " · " + snippet.blocks(),
-                usedBy, firstUse.biomeKey(), firstUse));
-        for (BiomePalette use : snippet.uses()) {
-            BiomeEntry biome = catalog.biome(use.biomeKey());
-            String biomeName = biome == null ? use.biomeKey() : biome.name();
-            node.add(new DefaultMutableTreeNode(new OverviewNode(biomeName + " · " + use.lowercaseLabel(), use.biomeKey(),
-                    use.biomeKey(), use)));
-        }
-        return node;
-    }
-
-    private void expandDownToBiomes(DefaultMutableTreeNode root) {
-        Enumeration<?> nodes = root.breadthFirstEnumeration();
-        while (nodes.hasMoreElements()) {
-            DefaultMutableTreeNode node = (DefaultMutableTreeNode) nodes.nextElement();
-            if (node.getUserObject() instanceof OverviewNode overview && overview.biomeKey() != null) {
-                overviewTree.expandPath(new TreePath(((DefaultMutableTreeNode) node.getParent()).getPath()));
-            }
-        }
-    }
-
-    private void selectInTree() {
-        if (selectedNodeShowsSelectedPalette()) {
-            return;
-        }
-        DefaultMutableTreeNode match = findLayerNode((DefaultMutableTreeNode) treeModel.getRoot());
-        if (match == null) {
-            overviewTree.clearSelection();
-            return;
-        }
-        TreePath path = new TreePath(match.getPath());
-        overviewTree.setSelectionPath(path);
-        overviewTree.makeVisible(path);
-        Rectangle row = overviewTree.getPathBounds(path);
-        if (row != null) {
-            overviewTree.scrollRectToVisible(new Rectangle(0, row.y, 1, row.height));
-        }
-    }
-
-    // The same palette can be listed under its biome and under its snippet; the row the user picked stays picked.
-    private boolean selectedNodeShowsSelectedPalette() {
-        return nodeAt(overviewTree.getSelectionPath()) instanceof OverviewNode node
-                && node.palette() != null
-                && node.palette().equals(selectedPalette);
-    }
-
-    private DefaultMutableTreeNode findLayerNode(DefaultMutableTreeNode root) {
-        Enumeration<?> nodes = root.depthFirstEnumeration();
-        while (nodes.hasMoreElements()) {
-            DefaultMutableTreeNode node = (DefaultMutableTreeNode) nodes.nextElement();
-            if (node.getUserObject() instanceof OverviewNode overview
-                    && overview.palette() != null
-                    && overview.palette().equals(selectedPalette)) {
-                return node;
-            }
-        }
-        return null;
-    }
-
-    private void selectInHereList() {
-        for (int index = 0; index < hereRows.size(); index++) {
-            HereRow row = hereRows.get(index);
-            if (row.palette() != null && row.palette().equals(selectedPalette)) {
-                hereList.setSelectedIndex(index);
-                return;
-            }
-        }
-        hereList.clearSelection();
-    }
-
-    private static Object nodeAt(TreePath path) {
-        return path == null ? null : ((DefaultMutableTreeNode) path.getLastPathComponent()).getUserObject();
-    }
-
-    private static String biomeText(BiomeEntry biome, String note) {
-        String noteText = note == null ? "" : " · " + escape(note);
-        return "<html>" + escape(biome.name()) + noteText + " <font color='" + StudioTheme.SECONDARY_TEXT.toHtml() + "'>" + escape(biome.key())
-                + "</font></html>";
-    }
-
-    private static String labeled(String title, String name, String key) {
-        return "<html><font color='" + StudioTheme.SECONDARY_TEXT.toHtml() + "'>" + title + "</font>&nbsp; " + escape(name)
-                + " <font color='" + StudioTheme.SECONDARY_TEXT.toHtml() + "'>" + escape(key) + "</font></html>";
-    }
-
-    private static String escape(String text) {
-        return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;");
-    }
-
-    interface Listener {
-        void onPaletteChosen(BiomePalette palette);
-    }
-
-    /**
-     * @param nesting how many parent biomes deep the row's biome sits
-     */
-    private record HereRow(String text, String biomeKey, BiomePalette palette, int nesting, boolean header) {
-        private static HereRow header(String text) {
-            return new HereRow(text, null, null, 0, true);
-        }
-
-        private static HereRow biome(String text, String biomeKey, int nesting) {
-            return new HereRow(text, biomeKey, null, nesting, false);
-        }
-
-        private static HereRow palette(String text, BiomePalette palette, int nesting) {
-            return new HereRow(text, palette.biomeKey(), palette, nesting, false);
-        }
-    }
-
-    private record OverviewNode(String label, String detail, String biomeKey, BiomePalette palette) {
-        private String html() {
-            if (detail == null) {
-                return escape(label);
-            }
-            return "<html>" + escape(label) + " <font color='" + StudioTheme.SECONDARY_TEXT.toHtml() + "'>" + escape(detail) + "</font></html>";
-        }
-    }
-
-    private static final class HereRowRenderer extends DefaultListCellRenderer {
-        private static final long serialVersionUID = 2785341117408251320L;
-        private static final int HEADER_INDENT = 11;
-        private static final int BIOME_INDENT = 20;
-        private static final int PALETTE_INDENT = 34;
-        private static final int CHILD_INDENT = 16;
-
-        @Override
-        public Component getListCellRendererComponent(JList<?> list, Object value, int index, boolean selected, boolean focus) {
-            HereRow row = (HereRow) value;
-            boolean selectable = row.biomeKey() != null;
-            super.getListCellRendererComponent(list, row.header() ? row.text().toUpperCase(Locale.ROOT) : row.text(), index,
-                    selected && selectable, false);
-            setFont(row.header() ? StudioTheme.sectionFont() : StudioTheme.font());
-            if (row.header()) {
-                setForeground(StudioTheme.MUTED_TEXT);
-            }
-            int indent = row.header() ? HEADER_INDENT
-                    : (row.palette() != null ? PALETTE_INDENT : BIOME_INDENT) + row.nesting() * CHILD_INDENT;
-            setBorder(StudioTheme.emptyBorder(row.header() ? 11 : 4, indent, 4, 10));
-            return this;
-        }
-    }
-
-    private static final class OverviewRenderer extends DefaultTreeCellRenderer {
-        private static final long serialVersionUID = -1950176034017718227L;
-
-        private OverviewRenderer() {
-            setLeafIcon(null);
-            setOpenIcon(null);
-            setClosedIcon(null);
-        }
-
-        @Override
-        public Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded,
-                                                      boolean leaf, int row, boolean focus) {
-            Object userObject = ((DefaultMutableTreeNode) value).getUserObject();
-            String text = userObject instanceof OverviewNode node ? node.html() : "";
-            super.getTreeCellRendererComponent(tree, text, selected, expanded, leaf, row, false);
-            boolean groupsOthers = userObject instanceof OverviewNode node && node.biomeKey() == null && !leaf;
-            setFont(groupsOthers ? StudioTheme.boldFont() : StudioTheme.font());
-            return this;
-        }
-    }
-}
@@ -1,124 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisRegion;
-import com.volmit.iris.engine.platform.PlatformChunkGenerator;
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.bukkit.entity.Player;
-import org.bukkit.scheduler.BukkitTask;
-
-import java.awt.EventQueue;
-import java.util.UUID;
-
-final class PlayerLocationTracker {
-    private static final long CHECK_INTERVAL_TICKS = 10L;
-
-    private final UUID playerId;
-    private final UUID worldId;
-    private final Listener listener;
-    private BukkitTask task;
-    private PlayerLocation lastLocation;
-
-    private PlayerLocationTracker(UUID playerId, UUID worldId, Listener listener) {
-        this.playerId = playerId;
-        this.worldId = worldId;
-        this.listener = listener;
-    }
-
-    static PlayerLocationTracker follow(UUID playerId, UUID worldId, Listener listener) {
-        PlayerLocationTracker tracker = new PlayerLocationTracker(playerId, worldId, listener);
-        tracker.task = Bukkit.getScheduler().runTaskTimer(Iris.instance, tracker::checkLocation, 0L, CHECK_INTERVAL_TICKS);
-        return tracker;
-    }
-
-    void stop() {
-        if (task != null) {
-            task.cancel();
-        }
-    }
-
-    private void checkLocation() {
-        PlayerLocation location = locate();
-        if (location.equals(lastLocation)) {
-            return;
-        }
-        lastLocation = location;
-        EventQueue.invokeLater(() -> listener.onLocationChanged(location));
-    }
-
-    private PlayerLocation locate() {
-        Player player = Bukkit.getPlayer(playerId);
-        if (player == null) {
-            return PlayerLocation.OFFLINE;
-        }
-        if (player.getWorld() == null || !player.getWorld().getUID().equals(worldId)) {
-            return PlayerLocation.IN_OTHER_WORLD;
-        }
-        Engine engine = engineAt(player.getLocation());
-        if (engine == null) {
-            return PlayerLocation.IN_OTHER_WORLD;
-        }
-        Location position = player.getLocation();
-        IrisRegion region = engine.getRegion(position);
-        String surfaceBiome = keyOf(engine.getSurfaceBiome(position.getBlockX(), position.getBlockZ()));
-        String biomeAtPosition = keyOf(engine.getBiomeOrMantle(position));
-        if (region == null || region.getLoadKey() == null || surfaceBiome == null) {
-            return PlayerLocation.IN_OTHER_WORLD;
-        }
-        return new PlayerLocation(Status.IN_REGION, region.getLoadKey(), surfaceBiome, biomeAtPosition);
-    }
-
-    private static String keyOf(IrisBiome biome) {
-        return biome == null ? null : biome.getLoadKey();
-    }
-
-    private static Engine engineAt(Location location) {
-        if (location.getWorld() == null || !IrisToolbelt.isIrisWorld(location.getWorld())) {
-            return null;
-        }
-        PlatformChunkGenerator generator = IrisToolbelt.access(location.getWorld());
-        return generator == null ? null : generator.getEngine();
-    }
-
-    enum Status {
-        OFFLINE,
-        IN_OTHER_WORLD,
-        IN_REGION
-    }
-
-    // Biomes are 3D: underground, the biome at the player's position can differ from the surface biome above it.
-    record PlayerLocation(Status status, String regionKey, String surfaceBiomeKey, String biomeAtPositionKey) {
-        static final PlayerLocation OFFLINE = new PlayerLocation(Status.OFFLINE, null, null, null);
-        static final PlayerLocation IN_OTHER_WORLD = new PlayerLocation(Status.IN_OTHER_WORLD, null, null, null);
-
-        boolean isBelowSurfaceBiome() {
-            return biomeAtPositionKey != null && !biomeAtPositionKey.equals(surfaceBiomeKey);
-        }
-    }
-
-    interface Listener {
-        void onLocationChanged(PlayerLocation location);
-    }
-}
@@ -1,6 +1,6 @@
 /*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -34,16 +34,15 @@ import com.volmit.iris.util.math.M;
 import com.volmit.iris.util.math.Position2;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;

 import javax.swing.*;
 import java.awt.*;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
 import java.awt.image.BufferedImage;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Consumer;

@@ -56,7 +55,7 @@ public class PregeneratorJob implements PregenListener {
    private static final Color COLOR_NETWORK_GENERATING = parseColor("#836b8c");
    private static final Color COLOR_GENERATED = parseColor("#65c295");
    private static final Color COLOR_CLEANED = parseColor("#34eb93");
-    private static final AtomicReference<PregeneratorJob> instance = new AtomicReference<>();
+    public static PregeneratorJob instance;
    private final MemoryMonitor monitor;
    private final PregenTask task;
    private final boolean saving;
@@ -67,33 +66,26 @@ public class PregeneratorJob implements PregenListener {
    private final Position2 max;
    private final ChronoLatch cl = new ChronoLatch(TimeUnit.MINUTES.toMillis(1));
    private final Engine engine;
-    private final ExecutorService service;
    private JFrame frame;
    private PregenRenderer renderer;
    private int rgc = 0;
    private String[] info;

    public PregeneratorJob(PregenTask task, PregeneratorMethod method, Engine engine) {
-        instance.updateAndGet(old -> {
-            if (old != null) {
-                old.pregenerator.close();
-                old.close();
-            }
-            return this;
-        });
        this.engine = engine;
+        instance = this;
        monitor = new MemoryMonitor(50);
        saving = false;
        info = new String[]{"Initializing..."};
        this.task = task;
        this.pregenerator = new IrisPregenerator(task, method, this);
        max = new Position2(0, 0);
-        min = new Position2(Integer.MAX_VALUE, Integer.MAX_VALUE);
-        task.iterateAllChunks((xx, zz) -> {
-            min.setX(Math.min(xx, min.getX()));
-            min.setZ(Math.min(zz, min.getZ()));
-            max.setX(Math.max(xx, max.getX()));
-            max.setZ(Math.max(zz, max.getZ()));
+        min = new Position2(0, 0);
+        task.iterateRegions((xx, zz) -> {
+            min.setX(Math.min(xx << 5, min.getX()));
+            min.setZ(Math.min(zz << 5, min.getZ()));
+            max.setX(Math.max((xx << 5) + 31, max.getX()));
+            max.setZ(Math.max((zz << 5) + 31, max.getZ()));
        });

        if (IrisSettings.get().getGui().isUseServerLaunchedGuis() && task.isGui()) {
@@ -106,44 +98,41 @@ public class PregeneratorJob implements PregenListener {
        }, "Iris Pregenerator");
        t.setPriority(Thread.MIN_PRIORITY);
        t.start();
-        service = Executors.newVirtualThreadPerTaskExecutor();
    }

+
    public static boolean shutdownInstance() {
-        PregeneratorJob inst = instance.get();
-        if (inst == null) {
+        if (instance == null) {
            return false;
        }

-        J.a(inst.pregenerator::close);
+        J.a(() -> instance.pregenerator.close());
        return true;
    }

    public static PregeneratorJob getInstance() {
-        return instance.get();
+        return instance;
    }

    public static boolean pauseResume() {
-        PregeneratorJob inst = instance.get();
-        if (inst == null) {
+        if (instance == null) {
            return false;
        }

        if (isPaused()) {
-            inst.pregenerator.resume();
+            instance.pregenerator.resume();
        } else {
-            inst.pregenerator.pause();
+            instance.pregenerator.pause();
        }
        return true;
    }

    public static boolean isPaused() {
-        PregeneratorJob inst = instance.get();
-        if (inst == null) {
+        if (instance == null) {
            return true;
        }

-        return inst.paused();
+        return instance.paused();
    }

    private static Color parseColor(String c) {
@@ -173,7 +162,7 @@ public class PregeneratorJob implements PregenListener {
    }

    public void drawRegion(int x, int z, Color color) {
-        J.a(() -> task.iterateChunks(x, z, (xx, zz) -> {
+        J.a(() -> PregenTask.iterateRegion(x, z, (xx, zz) -> {
            draw(xx, zz, color);
            J.sleep(3);
        }));
@@ -193,7 +182,7 @@ public class PregeneratorJob implements PregenListener {
        J.a(() -> {
            pregenerator.close();
            close();
-            instance.compareAndSet(this, null);
+            instance = null;
        });
    }

@@ -212,7 +201,7 @@ public class PregeneratorJob implements PregenListener {
    public void open() {
        J.a(() -> {
            try {
-                frame = GuiHost.createFrame("Pregen View");
+                frame = new JFrame("Pregen View");
                renderer = new PregenRenderer();
                frame.addKeyListener(renderer);
                renderer.l = new ReentrantLock();
@@ -233,10 +222,10 @@ public class PregeneratorJob implements PregenListener {
    }

    @Override
-    public void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, long generated, long totalChunks, long chunksRemaining, long eta, long elapsed, String method, boolean cached) {
+    public void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, int generated, int totalChunks, int chunksRemaining, long eta, long elapsed, String method) {
        info = new String[]{
                (paused() ? "PAUSED" : (saving ? "Saving... " : "Generating")) + " " + Form.f(generated) + " of " + Form.f(totalChunks) + " (" + Form.pc(percent, 0) + " Complete)",
-                "Speed: " + (cached ? "Cached " : "") + Form.f(chunksPerSecond, 0) + " Chunks/s, " + Form.f(regionsPerMinute, 1) + " Regions/m, " + Form.f(chunksPerMinute, 0) + " Chunks/m",
+                "Speed: " + Form.f(chunksPerSecond, 0) + " Chunks/s, " + Form.f(regionsPerMinute, 1) + " Regions/m, " + Form.f(chunksPerMinute, 0) + " Chunks/m",
                Form.duration(eta, 2) + " Remaining " + " (" + Form.duration(elapsed, 2) + " Elapsed)",
                "Generation Method: " + method,
                "Memory: " + Form.memSize(monitor.getUsedBytes(), 2) + " (" + Form.pc(monitor.getUsagePercent(), 0) + ") Pressure: " + Form.memSize(monitor.getPressure(), 0) + "/s",
@@ -254,22 +243,40 @@ public class PregeneratorJob implements PregenListener {
    }

    @Override
-    public void onChunkGenerated(int x, int z, boolean cached) {
-        if (renderer == null || frame == null || !frame.isVisible()) return;
-        service.submit(() -> {
-            if (engine != null) {
-                draw(x, z, engine.draw((x << 4) + 8, (z << 4) + 8));
-                return;
-            }
+    public void onChunkGenerated(int x, int z) {
+        if (engine != null) {
+            draw(x, z, engine.draw((x << 4) + 8, (z << 4) + 8));
+            return;
+        }

-            draw(x, z, COLOR_GENERATED);
-        });
+        draw(x, z, COLOR_GENERATED);
    }

    @Override
    public void onRegionGenerated(int x, int z) {
        shouldGc();
        rgc++;
+
+        // Each region is 32x32 chunks
+        for (int chunkOffsetX = 0; chunkOffsetX < 32; chunkOffsetX++) {
+            for (int chunkOffsetZ = 0; chunkOffsetZ < 32; chunkOffsetZ++) {
+                // Calculate actual chunk coordinates
+                int chunkX = (x << 5) + chunkOffsetX;
+                int chunkZ = (z << 5) + chunkOffsetZ;
+
+                if (engine != null) {
+                    // Calculate the center block of the chunk
+                    int centerBlockX = (chunkX << 4) + 8;
+                    int centerBlockZ = (chunkZ << 4) + 8;
+
+                    // Draw the chunk
+                    draw(chunkX, chunkZ, engine.draw(centerBlockX, centerBlockZ));
+                } else {
+                    // If engine is null, use the default color
+                    draw(chunkX, chunkZ, COLOR_GENERATED);
+                }
+            }
+        }
    }

    private void shouldGc() {
@@ -321,9 +328,8 @@ public class PregeneratorJob implements PregenListener {
    @Override
    public void onClose() {
        close();
-        instance.compareAndSet(this, null);
+        instance = null;
        whenDone.forEach(Runnable::run);
-        service.shutdownNow();
    }

    @Override
@@ -1,268 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-
-package com.volmit.iris.core.gui;
-
-import javax.swing.CellRendererPane;
-import javax.swing.Icon;
-import javax.swing.JComponent;
-import javax.swing.JLayer;
-import javax.swing.JScrollPane;
-import javax.swing.JTree;
-import javax.swing.JViewport;
-import javax.swing.SwingUtilities;
-import javax.swing.UIManager;
-import javax.swing.plaf.LayerUI;
-import javax.swing.plaf.basic.BasicTreeUI;
-import javax.swing.tree.TreePath;
-import java.awt.AWTEvent;
-import java.awt.Color;
-import java.awt.Component;
-import java.awt.Cursor;
-import java.awt.GradientPaint;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
-import java.awt.Point;
-import java.awt.Rectangle;
-import java.awt.event.MouseEvent;
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Keeps the folders around the top row of a scrolled tree pinned at the top, so a long folder never hides where it
- * is. The next folder pushes the last header up as it arrives, and clicking a header jumps to its folder.
- */
-final class StickyFolderHeaders extends LayerUI<JScrollPane> {
-    private static final long serialVersionUID = -2205474187531254372L;
-    private static final int SHADOW_HEIGHT = 4;
-    private static final Color SHADOW = new ThemeColor(new Color(0, 0, 0, 28), new Color(0, 0, 0, 90));
-    private static final Color NO_SHADOW = new Color(0, 0, 0, 0);
-    // The folder handle sits one indent to the left of the folder's name, as the tree draws it.
-    private static final int HANDLE_NUDGE = 1;
-
-    private final JTree tree;
-    private final CellRendererPane rendererPane = new CellRendererPane();
-    private transient JLayer<JScrollPane> layer;
-    private int hoveredHeader = -1;
-
-    private StickyFolderHeaders(JTree tree) {
-        this.tree = tree;
-    }
-
-    static JLayer<JScrollPane> around(JTree tree, JScrollPane scrollPane) {
-        // Copying the scrolled pixels would drag the pinned headers along, so every scroll repaints instead.
-        scrollPane.getViewport().setScrollMode(JViewport.SIMPLE_SCROLL_MODE);
-        StickyFolderHeaders headers = new StickyFolderHeaders(tree);
-        JLayer<JScrollPane> layer = new JLayer<>(scrollPane, headers);
-        scrollPane.getViewport().addChangeListener(event -> layer.repaint());
-        return layer;
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public void installUI(JComponent component) {
-        super.installUI(component);
-        layer = (JLayer<JScrollPane>) component;
-        layer.setLayerEventMask(AWTEvent.MOUSE_EVENT_MASK | AWTEvent.MOUSE_MOTION_EVENT_MASK);
-        tree.add(rendererPane);
-    }
-
-    @Override
-    public void uninstallUI(JComponent component) {
-        layer.setLayerEventMask(0);
-        tree.remove(rendererPane);
-        layer = null;
-        super.uninstallUI(component);
-    }
-
-    @Override
-    public void paint(Graphics graphics, JComponent component) {
-        super.paint(graphics, component);
-        List<Header> headers = pinnedHeaders();
-        if (headers.isEmpty()) {
-            return;
-        }
-        Graphics2D canvas = (Graphics2D) graphics.create();
-        try {
-            Rectangle viewport = viewportBounds();
-            canvas.clipRect(viewport.x, viewport.y, viewport.width, viewport.height);
-            for (int index = 0; index < headers.size(); index++) {
-                paintHeader(canvas, headers.get(index), index == hoveredHeader, viewport);
-            }
-            Header last = headers.get(headers.size() - 1);
-            int shadowTop = viewport.y + last.top() + tree.getRowHeight();
-            canvas.setPaint(new GradientPaint(0, shadowTop, SHADOW, 0, shadowTop + StudioTheme.scale(SHADOW_HEIGHT), NO_SHADOW));
-            canvas.fillRect(viewport.x, shadowTop, viewport.width, StudioTheme.scale(SHADOW_HEIGHT));
-        } finally {
-            canvas.dispose();
-        }
-    }
-
-    private void paintHeader(Graphics2D canvas, Header header, boolean hovered, Rectangle viewport) {
-        int rowHeight = tree.getRowHeight();
-        int top = viewport.y + header.top();
-        Rectangle row = tree.getRowBounds(header.row());
-        int left = viewport.x + row.x - scrolledView().x;
-        canvas.setColor(hovered ? StudioTheme.HOVER_BACKGROUND : tree.getBackground());
-        canvas.fillRect(viewport.x, top, viewport.width, rowHeight);
-        paintFolderHandle(canvas, left, top + rowHeight / 2);
-        Component renderer = tree.getCellRenderer().getTreeCellRendererComponent(
-                tree, header.path().getLastPathComponent(), false, true, false, header.row(), false);
-        rendererPane.paintComponent(canvas, renderer, tree, left, top, viewport.x + viewport.width - left, rowHeight, true);
-    }
-
-    private void paintFolderHandle(Graphics2D canvas, int folderLeft, int middleY) {
-        Icon handle = UIManager.getIcon("Tree.expandedIcon");
-        if (handle == null || !(tree.getUI() instanceof BasicTreeUI treeUI)) {
-            return;
-        }
-        int middleX = folderLeft - treeUI.getRightChildIndent() + HANDLE_NUDGE;
-        handle.paintIcon(tree, canvas, middleX - handle.getIconWidth() / 2, middleY - handle.getIconHeight() / 2);
-    }
-
-    @Override
-    protected void processMouseEvent(MouseEvent event, JLayer<? extends JScrollPane> source) {
-        if (event.getID() == MouseEvent.MOUSE_EXITED) {
-            hover(-1);
-            return;
-        }
-        int index = headerAt(event);
-        if (index < 0) {
-            return;
-        }
-        event.consume();
-        if (event.getID() == MouseEvent.MOUSE_CLICKED && SwingUtilities.isLeftMouseButton(event)) {
-            jumpTo(pinnedHeaders().get(index), index);
-        }
-    }
-
-    @Override
-    protected void processMouseMotionEvent(MouseEvent event, JLayer<? extends JScrollPane> source) {
-        hover(headerAt(event));
-    }
-
-    private void hover(int index) {
-        if (index == hoveredHeader) {
-            return;
-        }
-        hoveredHeader = index;
-        tree.setCursor(index >= 0 ? Cursor.getPredefinedCursor(Cursor.HAND_CURSOR) : null);
-        layer.repaint();
-    }
-
-    // The folder lands just below the headers of the folders around it.
-    private void jumpTo(Header header, int level) {
-        Rectangle row = tree.getRowBounds(header.row());
-        JViewport viewport = layer.getView().getViewport();
-        int top = Math.max(0, row.y - level * tree.getRowHeight());
-        int bottomLimit = Math.max(0, tree.getHeight() - viewport.getExtentSize().height);
-        viewport.setViewPosition(new Point(viewport.getViewPosition().x, Math.min(top, bottomLimit)));
-    }
-
-    private int headerAt(MouseEvent event) {
-        if (layer == null || event.getComponent() == null) {
-            return -1;
-        }
-        Point point = SwingUtilities.convertPoint(event.getComponent(), event.getPoint(), layer);
-        Rectangle viewport = viewportBounds();
-        if (!viewport.contains(point)) {
-            return -1;
-        }
-        List<Header> headers = pinnedHeaders();
-        for (int index = headers.size() - 1; index >= 0; index--) {
-            int top = viewport.y + headers.get(index).top();
-            if (point.y >= top && point.y < top + tree.getRowHeight()) {
-                return index;
-            }
-        }
-        return -1;
-    }
-
-    /**
-     * For each depth, the folder holding the row just under the headers above it, as long as that folder's own row
-     * has scrolled out of sight.
-     */
-    private List<Header> pinnedHeaders() {
-        List<Header> headers = new ArrayList<>();
-        int rowHeight = tree.getRowHeight();
-        if (layer == null || rowHeight <= 0 || tree.getRowCount() == 0) {
-            return headers;
-        }
-        Rectangle view = scrolledView();
-        for (int level = 0; ; level++) {
-            int slotTop = level * rowHeight;
-            int row = tree.getClosestRowForLocation(view.x, view.y + slotTop);
-            TreePath path = row < 0 ? null : tree.getPathForRow(row);
-            if (path == null || !isInsideFolderAt(path, level)) {
-                return headers;
-            }
-            TreePath folder = ancestorAt(path, level);
-            Rectangle lastRow = tree.getRowBounds(lastRowInside(folder, row));
-            int top = Math.min(slotTop, lastRow.y + lastRow.height - view.y - rowHeight);
-            headers.add(new Header(folder, tree.getRowForPath(folder), top));
-            if (top < slotTop) {
-                return headers;
-            }
-        }
-    }
-
-    // The hidden root is the path's first element, so the folder at depth 0 is its second.
-    private static boolean isInsideFolderAt(TreePath path, int level) {
-        return path.getPathCount() > level + 2;
-    }
-
-    private static TreePath ancestorAt(TreePath path, int level) {
-        TreePath ancestor = path;
-        while (ancestor.getPathCount() > level + 2) {
-            ancestor = ancestor.getParentPath();
-        }
-        return ancestor;
-    }
-
-    // A folder's rows sit together, so the last one is found by halving the rows after a row known to be inside.
-    private int lastRowInside(TreePath folder, int rowInside) {
-        int low = rowInside;
-        int high = tree.getRowCount() - 1;
-        while (low < high) {
-            int middle = (low + high + 1) >>> 1;
-            if (folder.isDescendant(tree.getPathForRow(middle))) {
-                low = middle;
-            } else {
-                high = middle - 1;
-            }
-        }
-        return low;
-    }
-
-    private Rectangle scrolledView() {
-        return layer.getView().getViewport().getViewRect();
-    }
-
-    private Rectangle viewportBounds() {
-        JViewport viewport = layer.getView().getViewport();
-        Point origin = SwingUtilities.convertPoint(viewport, 0, 0, layer);
-        return new Rectangle(origin.x, origin.y, viewport.getWidth(), viewport.getHeight());
-    }
-
-    /**
-     * A pinned folder, its row in the tree and how far below the top of the visible rows it is drawn.
-     */
-    private record Header(TreePath path, int row, int top) {
-    }
-}
@@ -1,43 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import java.awt.Graphics2D;
-import java.awt.RenderingHints;
-import java.awt.geom.RoundRectangle2D;
-
-/**
- * Draws the floating cards (legends, hover details, hints) on top of a map, styled like IntelliJ's popups.
- */
-final class StudioOverlay {
-    private StudioOverlay() {
-    }
-
-    static void drawCard(Graphics2D canvas, int x, int y, int width, int height) {
-        Object antialiasing = canvas.getRenderingHint(RenderingHints.KEY_ANTIALIASING);
-        canvas.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
-        RoundRectangle2D card = new RoundRectangle2D.Double(x + 0.5D, y + 0.5D, width - 1D, height - 1D,
-                StudioTheme.scale(StudioTheme.OVERLAY_ARC), StudioTheme.scale(StudioTheme.OVERLAY_ARC));
-        canvas.setColor(StudioTheme.OVERLAY_BACKGROUND);
-        canvas.fill(card);
-        canvas.setColor(StudioTheme.OVERLAY_BORDER);
-        canvas.draw(card);
-        canvas.setRenderingHint(RenderingHints.KEY_ANTIALIASING, antialiasing);
-    }
-}
@@ -1,110 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import javax.swing.BorderFactory;
-import javax.swing.Box;
-import javax.swing.BoxLayout;
-import javax.swing.JLabel;
-import javax.swing.JPanel;
-import javax.swing.JProgressBar;
-import java.awt.Dimension;
-import java.util.Objects;
-
-/**
- * An IntelliJ style status bar: what is shown on the left, work in progress in the middle and where the pointer is on the right.
- */
-final class StudioStatusBar extends JPanel {
-    private static final long serialVersionUID = 6302468216735125611L;
-    private static final int HEIGHT = 26;
-    private static final int PROGRESS_STEPS = 1_000;
-
-    private final JLabel summary = statusLabel();
-    private final JLabel activity = statusLabel();
-    private final JProgressBar progress = new JProgressBar(0, PROGRESS_STEPS);
-    private final JLabel position = statusLabel();
-
-    StudioStatusBar() {
-        setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
-        setBackground(StudioTheme.PANEL_BACKGROUND);
-        setBorder(BorderFactory.createCompoundBorder(
-                BorderFactory.createMatteBorder(1, 0, 0, 0, StudioTheme.SEPARATOR),
-                StudioTheme.emptyBorder(0, 10, 0, 10)
-        ));
-        setPreferredSize(StudioTheme.scaledSize(0, HEIGHT));
-        progress.setMaximumSize(StudioTheme.scaledSize(120, 4));
-        progress.setPreferredSize(StudioTheme.scaledSize(120, 4));
-        progress.setVisible(false);
-        allowShrinking(summary);
-        allowShrinking(activity);
-        add(summary);
-        add(Box.createHorizontalGlue());
-        add(activity);
-        add(Box.createHorizontalStrut(StudioTheme.scale(8)));
-        add(progress);
-        add(Box.createHorizontalStrut(StudioTheme.scale(18)));
-        add(position);
-    }
-
-    void showSummary(String text) {
-        setTextIfChanged(summary, text);
-        summary.setForeground(StudioTheme.SECONDARY_TEXT);
-    }
-
-    void showError(String text) {
-        setTextIfChanged(summary, text);
-        summary.setForeground(StudioTheme.ERROR);
-    }
-
-    void showActivity(String text) {
-        setTextIfChanged(activity, text);
-    }
-
-    void showProgress(double completion) {
-        boolean working = completion < 1D;
-        progress.setVisible(working);
-        if (working) {
-            progress.setValue((int) Math.round(Math.max(0D, completion) * PROGRESS_STEPS));
-        }
-    }
-
-    void showPosition(String text) {
-        setTextIfChanged(position, text);
-    }
-
-    // Long text gives way with an ellipsis instead of pushing the other parts of the bar out of view.
-    private static void allowShrinking(JLabel label) {
-        label.setMinimumSize(new Dimension(0, 0));
-    }
-
-    private static JLabel statusLabel() {
-        JLabel label = new JLabel();
-        label.setFont(StudioTheme.smallFont());
-        label.setForeground(StudioTheme.SECONDARY_TEXT);
-        return label;
-    }
-
-    // Status text changes on every mouse move, and an unchanged label shouldn't trigger a relayout.
-    private static void setTextIfChanged(JLabel label, String text) {
-        String next = text == null ? "" : text;
-        if (!Objects.equals(label.getText(), next)) {
-            label.setText(next);
-        }
-    }
-}
@@ -1,291 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.formdev.flatlaf.FlatDarkLaf;
-import com.formdev.flatlaf.FlatLaf;
-import com.formdev.flatlaf.FlatLightLaf;
-import com.formdev.flatlaf.util.UIScale;
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-
-import javax.swing.BorderFactory;
-import javax.swing.UIManager;
-import javax.swing.border.Border;
-import java.awt.Color;
-import java.awt.Dimension;
-import java.awt.EventQueue;
-import java.awt.Font;
-import java.util.HashMap;
-import java.util.Locale;
-import java.util.Map;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-/**
- * The colours of IntelliJ's "New UI", light and dark, shared by FlatLaf's controls and everything the studio windows
- * draw themselves. The theme follows the system unless the user picked light or dark.
- */
-final class StudioTheme {
-    static final Color EDITOR_BACKGROUND = new ThemeColor(0xFFFFFF, 0x1E1F22);
-    static final Color PANEL_BACKGROUND = new ThemeColor(0xF7F8FA, 0x2B2D30);
-    static final Color HOVER_BACKGROUND = new ThemeColor(0xDFE1E5, 0x393B40);
-    static final Color INACTIVE_SELECTION = new ThemeColor(0xDFE1E5, 0x43454A);
-    static final Color SELECTION = new ThemeColor(0xD4E2FF, 0x2E436E);
-    static final Color CONTROL_BORDER = new ThemeColor(0xC9CCD6, 0x4E5157);
-    static final Color SEPARATOR = new ThemeColor(0xEBECF0, 0x1E1F22);
-    static final Color TEXT = new ThemeColor(0x000000, 0xDFE1E5);
-    static final ThemeColor SECONDARY_TEXT = new ThemeColor(0x6C707E, 0x9DA0A8);
-    static final Color MUTED_TEXT = new ThemeColor(0x818594, 0x6F737A);
-    static final Color ACCENT = new Color(0x3574F0);
-    static final Color LINK = new ThemeColor(0x315FBD, 0x548AF7);
-    static final Color ERROR = new ThemeColor(0xDB3B4B, 0xF75464);
-    static final Color WARNING = new ThemeColor(0xC27D04, 0xF2C55C);
-    static final Color SUCCESS = new ThemeColor(0x208A3C, 0x5FB865);
-    static final Color OVERLAY_BACKGROUND = new ThemeColor(new Color(0xFF, 0xFF, 0xFF, 240), new Color(0x2B, 0x2D, 0x30, 236));
-    static final Color OVERLAY_BORDER = new ThemeColor(0xDFE1E5, 0x43454A);
-    static final int OVERLAY_ARC = 10;
-
-    private static final boolean DARK_WITHOUT_SYSTEM_PREFERENCE = true;
-    private static final AtomicBoolean INSTALLED = new AtomicBoolean();
-    private static final ExecutorService SYSTEM_CHECK = Executors.newSingleThreadExecutor(runnable -> {
-        Thread thread = new Thread(runnable, "Iris Theme Check");
-        thread.setDaemon(true);
-        return thread;
-    });
-    private static volatile boolean dark = DARK_WITHOUT_SYSTEM_PREFERENCE;
-    private static volatile float pixelScale = 1F;
-    private static final Map<String, String> SHARED_DEFAULTS = Map.ofEntries(
-            Map.entry("Component.focusWidth", "1"),
-            Map.entry("Component.innerFocusWidth", "0"),
-            Map.entry("Component.arc", "8"),
-            Map.entry("Button.arc", "8"),
-            Map.entry("TextComponent.arc", "8"),
-            Map.entry("List.selectionArc", "6"),
-            Map.entry("List.selectionInsets", "0,6,0,6"),
-            Map.entry("Tree.selectionArc", "6"),
-            Map.entry("Tree.selectionInsets", "0,6,0,6"),
-            Map.entry("Tree.border", "0,8,0,0"),
-            Map.entry("ScrollBar.width", "10"),
-            Map.entry("ScrollBar.thumbArc", "999"),
-            Map.entry("ScrollBar.thumbInsets", "2,2,2,2"),
-            Map.entry("ScrollBar.showButtons", "false"),
-            Map.entry("ScrollPane.border", "0,0,0,0"),
-            Map.entry("SplitPane.dividerSize", "1"),
-            Map.entry("SplitPaneDivider.style", "plain"),
-            Map.entry("ProgressBar.arc", "999"),
-            Map.entry("ProgressBar.horizontalSize", "120,4")
-    );
-    private static final Map<String, String> DARK_DEFAULTS = withShared(Map.ofEntries(
-            Map.entry("@background", "#2B2D30"),
-            Map.entry("@foreground", "#DFE1E5"),
-            Map.entry("@accentColor", "#3574F0"),
-            Map.entry("@selectionBackground", "#2E436E"),
-            Map.entry("@selectionInactiveBackground", "#43454A"),
-            Map.entry("@disabledForeground", "#6F737A"),
-            Map.entry("Component.borderColor", "#4E5157"),
-            Map.entry("Component.focusedBorderColor", "#3574F0"),
-            Map.entry("Button.toolbar.hoverBackground", "#393B40"),
-            Map.entry("Button.toolbar.pressedBackground", "#43454A"),
-            Map.entry("Button.toolbar.selectedBackground", "#43454A"),
-            Map.entry("ToggleButton.toolbar.selectedBackground", "#43454A"),
-            Map.entry("ScrollBar.track", "#2B2D30"),
-            Map.entry("SplitPane.background", "#1E1F22"),
-            Map.entry("Separator.foreground", "#1E1F22"),
-            Map.entry("ToolTip.background", "#393B40")
-    ));
-    private static final Map<String, String> LIGHT_DEFAULTS = withShared(Map.ofEntries(
-            Map.entry("@background", "#F7F8FA"),
-            Map.entry("@foreground", "#000000"),
-            Map.entry("@accentColor", "#3574F0"),
-            Map.entry("@selectionBackground", "#D4E2FF"),
-            Map.entry("@selectionForeground", "#000000"),
-            Map.entry("@selectionInactiveBackground", "#DFE1E5"),
-            Map.entry("@selectionInactiveForeground", "#000000"),
-            Map.entry("@disabledForeground", "#A8ADBD"),
-            Map.entry("Component.borderColor", "#C9CCD6"),
-            Map.entry("Component.focusedBorderColor", "#3574F0"),
-            Map.entry("Button.toolbar.hoverBackground", "#DFE1E5"),
-            Map.entry("Button.toolbar.pressedBackground", "#C9CCD6"),
-            Map.entry("Button.toolbar.selectedBackground", "#DFE1E5"),
-            Map.entry("ToggleButton.toolbar.selectedBackground", "#DFE1E5"),
-            Map.entry("ScrollBar.track", "#F7F8FA"),
-            Map.entry("SplitPane.background", "#EBECF0"),
-            Map.entry("Separator.foreground", "#EBECF0")
-    ));
-
-    private StudioTheme() {
-    }
-
-    static void install() {
-        if (!INSTALLED.compareAndSet(false, true)) {
-            return;
-        }
-        try {
-            applyLookAndFeel(darkFor(mode()));
-            pixelScale = UIScale.getUserScaleFactor();
-        } catch (Throwable error) {
-            Iris.reportError(error);
-            Iris.warn("Could not apply the Iris studio theme, the studio windows will use Java's default look.");
-        }
-    }
-
-    static boolean isDark() {
-        return dark;
-    }
-
-    static Mode mode() {
-        return Mode.fromSetting(IrisSettings.get().getGui().getTheme());
-    }
-
-    /**
-     * Remembers the user's choice and switches every studio window to it.
-     */
-    static void choose(Mode next) {
-        IrisSettings settings = IrisSettings.get();
-        settings.getGui().setTheme(next.settingName());
-        settings.forceSave();
-        if (next == Mode.AUTO) {
-            followSystem();
-            return;
-        }
-        switchTo(next == Mode.DARK);
-    }
-
-    // Studio windows call this when they come to the front, so a change made in the system's settings shows up.
-    static void followSystem() {
-        if (!INSTALLED.get() || mode() != Mode.AUTO) {
-            return;
-        }
-        SYSTEM_CHECK.execute(() -> {
-            boolean systemDark = SystemAppearance.prefersDark().orElse(DARK_WITHOUT_SYSTEM_PREFERENCE);
-            EventQueue.invokeLater(() -> switchTo(systemDark));
-        });
-    }
-
-    private static boolean darkFor(Mode chosen) {
-        return switch (chosen) {
-            case LIGHT -> false;
-            case DARK -> true;
-            case AUTO -> SystemAppearance.prefersDark().orElse(DARK_WITHOUT_SYSTEM_PREFERENCE);
-        };
-    }
-
-    private static void switchTo(boolean nextDark) {
-        if (nextDark == dark) {
-            return;
-        }
-        applyLookAndFeel(nextDark);
-        FlatLaf.updateUI();
-    }
-
-    private static void applyLookAndFeel(boolean nextDark) {
-        dark = nextDark;
-        FlatLaf.setGlobalExtraDefaults(nextDark ? DARK_DEFAULTS : LIGHT_DEFAULTS);
-        if (nextDark) {
-            FlatDarkLaf.setup();
-        } else {
-            FlatLightLaf.setup();
-        }
-    }
-
-    private static Map<String, String> withShared(Map<String, String> themeDefaults) {
-        Map<String, String> merged = new HashMap<>(SHARED_DEFAULTS);
-        merged.putAll(themeDefaults);
-        return Map.copyOf(merged);
-    }
-
-    /**
-     * FlatLaf grows fonts and its own controls to the screen's DPI; every size the studio sets itself has to grow with them.
-     */
-    static int scale(int pixels) {
-        return Math.round(pixels * pixelScale);
-    }
-
-    static double scale(double pixels) {
-        return pixels * pixelScale;
-    }
-
-    static Dimension scaledSize(int width, int height) {
-        return new Dimension(scale(width), scale(height));
-    }
-
-    static Border emptyBorder(int top, int left, int bottom, int right) {
-        return BorderFactory.createEmptyBorder(scale(top), scale(left), scale(bottom), scale(right));
-    }
-
-    static Font font() {
-        return themeFont("defaultFont", Font.PLAIN, 13);
-    }
-
-    static Font smallFont() {
-        return themeFont("small.font", Font.PLAIN, 11);
-    }
-
-    static Font boldFont() {
-        return font().deriveFont(Font.BOLD);
-    }
-
-    static Font titleFont() {
-        return font().deriveFont(Font.BOLD, font().getSize2D() + 1F);
-    }
-
-    static Font sectionFont() {
-        return smallFont().deriveFont(Font.BOLD);
-    }
-
-    static Font monospacedFont() {
-        return themeFont("monospaced.font", Font.PLAIN, 12);
-    }
-
-    private static Font themeFont(String key, int fallbackStyle, int fallbackSize) {
-        Font font = UIManager.getFont(key);
-        return font != null ? font : new Font(Font.SANS_SERIF, fallbackStyle, fallbackSize);
-    }
-
-    enum Mode {
-        AUTO("Match system"),
-        LIGHT("Light"),
-        DARK("Dark");
-
-        private final String label;
-
-        Mode(String label) {
-            this.label = label;
-        }
-
-        String label() {
-            return label;
-        }
-
-        String settingName() {
-            return name().toLowerCase(Locale.ROOT);
-        }
-
-        static Mode fromSetting(String setting) {
-            for (Mode mode : values()) {
-                if (mode.settingName().equalsIgnoreCase(setting)) {
-                    return mode;
-                }
-            }
-            return AUTO;
-        }
-    }
-}
@@ -1,144 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.formdev.flatlaf.FlatClientProperties;
-import com.formdev.flatlaf.icons.FlatSearchIcon;
-
-import javax.swing.BorderFactory;
-import javax.swing.ButtonGroup;
-import javax.swing.JButton;
-import javax.swing.JComponent;
-import javax.swing.JLabel;
-import javax.swing.JPanel;
-import javax.swing.JPopupMenu;
-import javax.swing.JRadioButtonMenuItem;
-import javax.swing.JScrollPane;
-import javax.swing.JTextField;
-import javax.swing.JToggleButton;
-import javax.swing.JToolBar;
-import javax.swing.ScrollPaneConstants;
-import java.awt.BorderLayout;
-import java.awt.Insets;
-
-/**
- * Builds the IntelliJ style controls the studio windows share: a flat main toolbar, borderless toolbar buttons and search boxes.
- */
-final class StudioToolbar {
-    private static final int TOOLBAR_HEIGHT_PADDING = 5;
-
-    private StudioToolbar() {
-    }
-
-    static JToolBar create() {
-        JToolBar toolbar = new JToolBar();
-        toolbar.setFloatable(false);
-        toolbar.setRollover(true);
-        toolbar.setBackground(StudioTheme.PANEL_BACKGROUND);
-        toolbar.setBorder(BorderFactory.createCompoundBorder(
-                BorderFactory.createMatteBorder(0, 0, 1, 0, StudioTheme.SEPARATOR),
-                StudioTheme.emptyBorder(TOOLBAR_HEIGHT_PADDING, 8, TOOLBAR_HEIGHT_PADDING, 8)
-        ));
-        return toolbar;
-    }
-
-    static JLabel label(String text) {
-        JLabel label = new JLabel(text);
-        label.setForeground(StudioTheme.SECONDARY_TEXT);
-        label.setBorder(StudioTheme.emptyBorder(0, 6, 0, 6));
-        return label;
-    }
-
-    static JButton button(String text, String tooltip, Runnable action) {
-        JButton button = toolbarButton(text, tooltip);
-        button.addActionListener(event -> action.run());
-        return button;
-    }
-
-    /**
-     * Opens a menu to pick light, dark or the system's theme.
-     */
-    static JButton themeButton() {
-        JButton button = toolbarButton("Theme", "Light, dark, or whatever the system uses");
-        button.addActionListener(event -> themeMenu().show(button, 0, button.getHeight()));
-        return button;
-    }
-
-    private static JPopupMenu themeMenu() {
-        JPopupMenu menu = new JPopupMenu();
-        ButtonGroup choices = new ButtonGroup();
-        StudioTheme.Mode current = StudioTheme.mode();
-        for (StudioTheme.Mode mode : StudioTheme.Mode.values()) {
-            JRadioButtonMenuItem item = new JRadioButtonMenuItem(mode.label(), mode == current);
-            item.addActionListener(event -> StudioTheme.choose(mode));
-            choices.add(item);
-            menu.add(item);
-        }
-        return menu;
-    }
-
-    private static JButton toolbarButton(String text, String tooltip) {
-        JButton button = new JButton(text);
-        button.setToolTipText(tooltip);
-        button.setFocusable(false);
-        button.setMargin(new Insets(4, 8, 4, 8));
-        button.putClientProperty(FlatClientProperties.BUTTON_TYPE, FlatClientProperties.BUTTON_TYPE_TOOLBAR_BUTTON);
-        return button;
-    }
-
-    static JToggleButton toggle(String text, String tooltip) {
-        JToggleButton toggle = new JToggleButton(text);
-        toggle.setToolTipText(tooltip);
-        toggle.setFocusable(false);
-        toggle.setMargin(new Insets(4, 8, 4, 8));
-        toggle.putClientProperty(FlatClientProperties.BUTTON_TYPE, FlatClientProperties.BUTTON_TYPE_TOOLBAR_BUTTON);
-        return toggle;
-    }
-
-    // An underlined tab like IntelliJ's tool window tabs.
-    static JToggleButton tab(String text) {
-        JToggleButton tab = new JToggleButton(text);
-        tab.setFocusable(false);
-        tab.putClientProperty(FlatClientProperties.BUTTON_TYPE, FlatClientProperties.BUTTON_TYPE_TAB);
-        return tab;
-    }
-
-    static void makeSearchField(JTextField field, String placeholder) {
-        field.putClientProperty(FlatClientProperties.PLACEHOLDER_TEXT, placeholder);
-        field.putClientProperty(FlatClientProperties.TEXT_FIELD_LEADING_ICON, new FlatSearchIcon());
-        field.putClientProperty(FlatClientProperties.TEXT_FIELD_SHOW_CLEAR_BUTTON, true);
-        field.setToolTipText(placeholder);
-    }
-
-    static JPanel padded(JComponent content, int top, int left, int bottom, int right) {
-        JPanel panel = new JPanel(new BorderLayout());
-        panel.setOpaque(false);
-        panel.setBorder(StudioTheme.emptyBorder(top, left, bottom, right));
-        panel.add(content, BorderLayout.CENTER);
-        return panel;
-    }
-
-    static JScrollPane scroll(JComponent content) {
-        JScrollPane scrollPane = new JScrollPane(content);
-        scrollPane.setBorder(BorderFactory.createEmptyBorder());
-        scrollPane.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
-        scrollPane.getVerticalScrollBar().setUnitIncrement(18);
-        return scrollPane;
-    }
-}
@@ -1,110 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.nio.charset.StandardCharsets;
-import java.util.List;
-import java.util.Locale;
-import java.util.Optional;
-import java.util.concurrent.TimeUnit;
-
-/**
- * Asks the operating system whether its user prefers dark or light apps, through the same settings desktop apps
- * follow: the freedesktop portal or GNOME's setting on Linux, the apps theme on Windows, the appearance on macOS.
- */
-final class SystemAppearance {
-    private static final long COMMAND_TIMEOUT_MILLIS = 2000L;
-    private static final String PORTAL_DARK = "uint32 1";
-    private static final String PORTAL_LIGHT = "uint32 2";
-
-    private SystemAppearance() {
-    }
-
-    /**
-     * Empty when the system has no preference or could not be asked.
-     */
-    static Optional<Boolean> prefersDark() {
-        String os = System.getProperty("os.name", "").toLowerCase(Locale.ROOT);
-        if (os.contains("win")) {
-            return windowsPrefersDark();
-        }
-        if (os.contains("mac")) {
-            return macPrefersDark();
-        }
-        return linuxPrefersDark();
-    }
-
-    private static Optional<Boolean> linuxPrefersDark() {
-        Optional<String> portal = output(List.of("gdbus", "call", "--session", "--dest", "org.freedesktop.portal.Desktop",
-                "--object-path", "/org/freedesktop/portal/desktop", "--method", "org.freedesktop.portal.Settings.ReadOne",
-                "org.freedesktop.appearance", "color-scheme"));
-        if (portal.filter(answer -> answer.contains(PORTAL_DARK)).isPresent()) {
-            return Optional.of(true);
-        }
-        if (portal.filter(answer -> answer.contains(PORTAL_LIGHT)).isPresent()) {
-            return Optional.of(false);
-        }
-        Optional<String> gnome = output(List.of("gsettings", "get", "org.gnome.desktop.interface", "color-scheme"));
-        if (gnome.filter(scheme -> scheme.contains("prefer-dark")).isPresent()) {
-            return Optional.of(true);
-        }
-        if (gnome.filter(scheme -> scheme.contains("prefer-light")).isPresent()) {
-            return Optional.of(false);
-        }
-        return output(List.of("gsettings", "get", "org.gnome.desktop.interface", "gtk-theme"))
-                .map(theme -> theme.toLowerCase(Locale.ROOT).contains("dark"));
-    }
-
-    private static Optional<Boolean> windowsPrefersDark() {
-        return output(List.of("reg", "query", "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize",
-                "/v", "AppsUseLightTheme"))
-                .filter(answer -> answer.contains("AppsUseLightTheme"))
-                .map(answer -> answer.trim().endsWith("0x0"));
-    }
-
-    // The setting only exists while macOS is dark, so a failed read means light.
-    private static Optional<Boolean> macPrefersDark() {
-        return Optional.of(output(List.of("defaults", "read", "-g", "AppleInterfaceStyle"))
-                .filter(style -> style.trim().equalsIgnoreCase("dark"))
-                .isPresent());
-    }
-
-    private static Optional<String> output(List<String> command) {
-        try {
-            Process process = new ProcessBuilder(command).redirectErrorStream(true).start();
-            if (!process.waitFor(COMMAND_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)) {
-                process.destroyForcibly();
-                return Optional.empty();
-            }
-            if (process.exitValue() != 0) {
-                return Optional.empty();
-            }
-            try (InputStream stream = process.getInputStream()) {
-                return Optional.of(new String(stream.readAllBytes(), StandardCharsets.UTF_8));
-            }
-        } catch (IOException missingCommand) {
-            return Optional.empty();
-        } catch (InterruptedException interrupted) {
-            Thread.currentThread().interrupt();
-            return Optional.empty();
-        }
-    }
-}
@@ -1,55 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import java.awt.Color;
-
-/**
- * A colour with a light and a dark version that always answers with the one of the current theme, like IntelliJ's
- * JBColor. Components keep the same colour object across a theme switch and simply paint in the other version.
- */
-final class ThemeColor extends Color {
-    private static final long serialVersionUID = 2286435620386470207L;
-    private final Color light;
-    private final Color dark;
-
-    ThemeColor(int lightRgb, int darkRgb) {
-        this(new Color(lightRgb), new Color(darkRgb));
-    }
-
-    ThemeColor(Color light, Color dark) {
-        super(dark.getRGB(), true);
-        this.light = light;
-        this.dark = dark;
-    }
-
-    // Every other colour query of Color, and Java2D's painting, go through this one.
-    @Override
-    public int getRGB() {
-        return current().getRGB();
-    }
-
-    String toHtml() {
-        return String.format("#%06X", getRGB() & 0xFFFFFF);
-    }
-
-    private Color current() {
-        return StudioTheme.isDark() ? dark : light;
-    }
-}
@@ -1,107 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-
-package com.volmit.iris.core.gui;
-
-/**
- * An affine transform built up like Minecraft's pose stack: each step applies to points before the steps added
- * earlier. Rotations follow the right-hand rule, the way Minecraft turns model parts.
- */
-final class Transform {
-    static final Transform IDENTITY = new Transform(new double[]{1D, 0D, 0D, 0D, 1D, 0D, 0D, 0D, 1D}, Vec3.ZERO);
-
-    private final double[] matrix;
-    private final Vec3 translation;
-
-    private Transform(double[] matrix, Vec3 translation) {
-        this.matrix = matrix;
-        this.translation = translation;
-    }
-
-    Transform translate(double x, double y, double z) {
-        return then(new Transform(IDENTITY.matrix, new Vec3(x, y, z)));
-    }
-
-    Transform rotateX(double degrees) {
-        double cos = cosine(degrees);
-        double sin = sine(degrees);
-        return then(new Transform(new double[]{1D, 0D, 0D, 0D, cos, -sin, 0D, sin, cos}, Vec3.ZERO));
-    }
-
-    Transform rotateY(double degrees) {
-        double cos = cosine(degrees);
-        double sin = sine(degrees);
-        return then(new Transform(new double[]{cos, 0D, sin, 0D, 1D, 0D, -sin, 0D, cos}, Vec3.ZERO));
-    }
-
-    Transform rotateZ(double degrees) {
-        double cos = cosine(degrees);
-        double sin = sine(degrees);
-        return then(new Transform(new double[]{cos, -sin, 0D, sin, cos, 0D, 0D, 0D, 1D}, Vec3.ZERO));
-    }
-
-    Transform scale(double x, double y, double z) {
-        return then(new Transform(new double[]{x, 0D, 0D, 0D, y, 0D, 0D, 0D, z}, Vec3.ZERO));
-    }
-
-    /**
-     * This transform applied after {@code next}.
-     */
-    Transform then(Transform next) {
-        double[] product = new double[9];
-        for (int row = 0; row < 3; row++) {
-            for (int column = 0; column < 3; column++) {
-                product[row * 3 + column] = matrix[row * 3] * next.matrix[column]
-                        + matrix[row * 3 + 1] * next.matrix[3 + column]
-                        + matrix[row * 3 + 2] * next.matrix[6 + column];
-            }
-        }
-        return new Transform(product, direction(next.translation).plus(translation));
-    }
-
-    Vec3 point(Vec3 point) {
-        return direction(point).plus(translation);
-    }
-
-    Vec3 direction(Vec3 direction) {
-        return new Vec3(
-                matrix[0] * direction.x() + matrix[1] * direction.y() + matrix[2] * direction.z(),
-                matrix[3] * direction.x() + matrix[4] * direction.y() + matrix[5] * direction.z(),
-                matrix[6] * direction.x() + matrix[7] * direction.y() + matrix[8] * direction.z());
-    }
-
-    // Quarter turns stay exact, so faces turned by a blockstate still line up with the block's sides.
-    private static double cosine(double degrees) {
-        return sine(degrees + 90D);
-    }
-
-    private static double sine(double degrees) {
-        double turned = ((degrees % 360D) + 360D) % 360D;
-        if (turned == 0D || turned == 180D) {
-            return 0D;
-        }
-        if (turned == 90D) {
-            return 1D;
-        }
-        if (turned == 270D) {
-            return -1D;
-        }
-        return Math.sin(Math.toRadians(turned));
-    }
-}
@@ -1,47 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-
-package com.volmit.iris.core.gui;
-
-/**
- * A position or direction in a block, in block units.
- */
-record Vec3(double x, double y, double z) {
-    static final Vec3 ZERO = new Vec3(0D, 0D, 0D);
-
-    Vec3 plus(Vec3 other) {
-        return new Vec3(x + other.x, y + other.y, z + other.z);
-    }
-
-    Vec3 minus(Vec3 other) {
-        return new Vec3(x - other.x, y - other.y, z - other.z);
-    }
-
-    Vec3 times(double factor) {
-        return new Vec3(x * factor, y * factor, z * factor);
-    }
-
-    double component(int axis) {
-        return switch (axis) {
-            case 0 -> x;
-            case 1 -> y;
-            default -> z;
-        };
-    }
-}
@@ -0,0 +1,844 @@
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.gui;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.gui.components.IrisRenderer;
+import com.volmit.iris.core.gui.components.RenderType;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.IrisComplex;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.engine.object.IrisRegion;
+import com.volmit.iris.engine.object.IrisWorld;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.math.BlockPosition;
+import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.RollingSequence;
+import com.volmit.iris.util.scheduling.ChronoLatch;
+import com.volmit.iris.util.scheduling.J;
+import com.volmit.iris.util.scheduling.O;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
+import org.bukkit.Location;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+
+import javax.imageio.ImageIO;
+import javax.swing.*;
+import javax.swing.event.MouseInputListener;
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.util.Locale;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.function.BiFunction;
+
+public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener, MouseMotionListener, MouseInputListener {
+    private static final long serialVersionUID = 2094606939770332040L;
+    private final KList<LivingEntity> lastEntities = new KList<>();
+    private final KMap<String, Long> notifications = new KMap<>();
+    private final ChronoLatch centities = new ChronoLatch(1000);
+    private final RollingSequence rs = new RollingSequence(512);
+    private final O<Integer> m = new O<>();
+    private final KMap<BlockPosition, BufferedImage> positions = new KMap<>();
+    private final KMap<BlockPosition, BufferedImage> fastpositions = new KMap<>();
+    private final KSet<BlockPosition> working = new KSet<>();
+    private final KSet<BlockPosition> workingfast = new KSet<>();
+    double tfps = 240D;
+    int ltc = 3;
+    private RenderType currentType = RenderType.BIOME;
+    private boolean help = true;
+    private boolean helpIgnored = false;
+    private boolean shift = false;
+    private Player player = null;
+    private boolean debug = false;
+    private boolean control = false;
+    private boolean eco = false;
+    private boolean lowtile = false;
+    private boolean follow = false;
+    private boolean alt = false;
+    private boolean dragging = false;
+    private IrisRenderer renderer;
+    private IrisWorld world;
+    private double velocity = 0;
+    private int lowq = 12;
+    private double scale = 128;
+    private double mscale = 4D;
+    private int w = 0;
+    private int h = 0;
+    private double lx = 0;
+    private double lz = 0;
+    private double ox = 0;
+    private double oz = 0;
+    private double hx = 0;
+    private double hz = 0;
+    private double oxp = 0;
+    private double ozp = 0;
+    private Engine engine;
+    private int tid = 0;
+    private final ExecutorService e = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors(), r -> {
+        tid++;
+        Thread t = new Thread(r);
+        t.setName("Iris HD Renderer " + tid);
+        t.setPriority(Thread.MIN_PRIORITY);
+        t.setUncaughtExceptionHandler((et, e) ->
+        {
+            Iris.info("Exception encountered in " + et.getName());
+            e.printStackTrace();
+        });
+
+        return t;
+    });
+
+    private final ExecutorService eh = Executors.newFixedThreadPool(ltc, r -> {
+        tid++;
+        Thread t = new Thread(r);
+        t.setName("Iris Renderer " + tid);
+        t.setPriority(Thread.NORM_PRIORITY);
+        t.setUncaughtExceptionHandler((et, e) ->
+        {
+            Iris.info("Exception encountered in " + et.getName());
+            e.printStackTrace();
+        });
+
+        return t;
+    });
+    private BufferedImage texture;
+
+    public VisionGUI(JFrame frame) {
+        m.set(8);
+        rs.put(1);
+        addMouseWheelListener(this);
+        addMouseMotionListener(this);
+        addMouseListener(this);
+        frame.addKeyListener(this);
+        J.a(() -> {
+            J.sleep(10000);
+
+            if (!helpIgnored && help) {
+                help = false;
+            }
+        });
+        frame.addWindowListener(new java.awt.event.WindowAdapter() {
+            @Override
+            public void windowClosing(java.awt.event.WindowEvent windowEvent) {
+                e.shutdown();
+                eh.shutdown();
+            }
+        });
+    }
+
+    private static void createAndShowGUI(Engine r, int s, IrisWorld world) {
+        JFrame frame = new JFrame("Vision");
+        VisionGUI nv = new VisionGUI(frame);
+        nv.world = world;
+        nv.engine = r;
+        nv.renderer = new IrisRenderer(r);
+        frame.add(nv);
+        frame.setSize(1440, 820);
+        frame.setVisible(true);
+        File file = Iris.getCached("Iris Icon", "https://raw.githubusercontent.com/VolmitSoftware/Iris/master/icon.png");
+
+        if (file != null) {
+            try {
+                nv.texture = ImageIO.read(file);
+                frame.setIconImage(ImageIO.read(file));
+            } catch (IOException e) {
+                Iris.reportError(e);
+
+            }
+        }
+    }
+
+    public static void launch(Engine g, int i) {
+        J.a(() ->
+                createAndShowGUI(g, i, g.getWorld()));
+    }
+
+    public boolean updateEngine() {
+        if (engine.isClosed()) {
+            if (world.hasRealWorld()) {
+                try {
+                    engine = IrisToolbelt.access(world.realWorld()).getEngine();
+                    return !engine.isClosed();
+                } catch (Throwable e) {
+
+                }
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public void mouseMoved(MouseEvent e) {
+        Point cp = e.getPoint();
+        lx = (cp.getX());
+        lz = (cp.getY());
+    }
+
+    @Override
+    public void mouseDragged(MouseEvent e) {
+        dragging = true;
+        Point cp = e.getPoint();
+        ox += (lx - cp.getX()) * scale;
+        oz += (lz - cp.getY()) * scale;
+        lx = cp.getX();
+        lz = cp.getY();
+    }
+
+    public int getColor(double wx, double wz) {
+        BiFunction<Double, Double, Integer> colorFunction = (d, dx) -> Color.black.getRGB();
+
+        switch (currentType) {
+            case BIOME, DECORATOR_LOAD, OBJECT_LOAD, LAYER_LOAD ->
+                    colorFunction = (x, z) -> engine.getComplex().getTrueBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
+            case BIOME_LAND ->
+                    colorFunction = (x, z) -> engine.getComplex().getLandBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
+            case BIOME_SEA ->
+                    colorFunction = (x, z) -> engine.getComplex().getSeaBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
+            case REGION ->
+                    colorFunction = (x, z) -> engine.getComplex().getRegionStream().get(x, z).getColor(engine.getComplex(), currentType).getRGB();
+            case CAVE_LAND ->
+                    colorFunction = (x, z) -> engine.getComplex().getCaveBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
+            case HEIGHT ->
+                    colorFunction = (x, z) -> Color.getHSBColor(engine.getComplex().getHeightStream().get(x, z).floatValue(), 100, 100).getRGB();
+        }
+
+        return colorFunction.apply(wx, wz);
+    }
+
+    public void notify(String s) {
+        notifications.put(s, M.ms() + 2500);
+    }
+
+    @Override
+    public void keyTyped(KeyEvent e) {
+
+    }
+
+    @Override
+    public void keyPressed(KeyEvent e) {
+        if (e.getKeyCode() == KeyEvent.VK_SHIFT) {
+            shift = true;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_CONTROL) {
+            control = true;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_SEMICOLON) {
+            debug = true;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_SLASH) {
+            help = true;
+            helpIgnored = true;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_ALT) {
+            alt = true;
+        }
+    }
+
+    @Override
+    public void keyReleased(KeyEvent e) {
+        if (e.getKeyCode() == KeyEvent.VK_SEMICOLON) {
+            debug = false;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_SHIFT) {
+            shift = false;
+        }
+
+        if (e.getKeyCode() == KeyEvent.VK_CONTROL) {
+            control = false;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_SLASH) {
+            help = false;
+            helpIgnored = true;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_ALT) {
+            alt = false;
+        }
+
+        // Pushes
+        if (e.getKeyCode() == KeyEvent.VK_F) {
+            follow = !follow;
+
+            if (player != null && follow) {
+                notify("Following " + player.getName() + ". Press F to disable");
+            } else if (follow) {
+                notify("Can't follow, no one is in the world");
+                follow = false;
+            } else {
+                notify("Follow Off");
+            }
+
+            return;
+        }
+
+        if (e.getKeyCode() == KeyEvent.VK_R) {
+            dump();
+            notify("Refreshing Chunks");
+            return;
+        }
+
+        if (e.getKeyCode() == KeyEvent.VK_P) {
+            lowtile = !lowtile;
+            dump();
+            notify("Rendering " + (lowtile ? "Low" : "High") + " Quality Tiles");
+            return;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_E) {
+            eco = !eco;
+            dump();
+            notify("Using " + (eco ? "60" : "Uncapped") + " FPS Limit");
+            return;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_EQUALS) {
+            mscale = mscale + ((0.044 * mscale) * -3);
+            mscale = Math.max(mscale, 0.00001);
+            dump();
+            return;
+        }
+        if (e.getKeyCode() == KeyEvent.VK_MINUS) {
+            mscale = mscale + ((0.044 * mscale) * 3);
+            mscale = Math.max(mscale, 0.00001);
+            dump();
+            return;
+        }
+
+        if (e.getKeyCode() == KeyEvent.VK_BACK_SLASH) {
+            mscale = 1D;
+            dump();
+            notify("Zoom Reset");
+            return;
+        }
+
+        int currentMode = currentType.ordinal();
+
+        for (RenderType i : RenderType.values()) {
+            if (e.getKeyChar() == String.valueOf(i.ordinal() + 1).charAt(0)) {
+                if (i.ordinal() != currentMode) {
+                    currentType = i;
+                    dump();
+                    notify("Rendering " + Form.capitalizeWords(currentType.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
+                    return;
+                }
+            }
+        }
+
+        if (e.getKeyCode() == KeyEvent.VK_M) {
+            currentType = RenderType.values()[(currentMode + 1) % RenderType.values().length];
+            notify("Rendering " + Form.capitalizeWords(currentType.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
+            dump();
+        }
+    }
+
+    private void dump() {
+        positions.clear();
+        fastpositions.clear();
+    }
+
+    public BufferedImage getTile(KSet<BlockPosition> fg, int div, int x, int z, O<Integer> m) {
+        BlockPosition key = new BlockPosition((int) mscale, Math.floorDiv(x, div), Math.floorDiv(z, div));
+        fg.add(key);
+
+        if (positions.containsKey(key)) {
+            return positions.get(key);
+        }
+
+        if (fastpositions.containsKey(key)) {
+            if (!working.contains(key) && working.size() < 9) {
+                m.set(m.get() - 1);
+
+                if (m.get() >= 0 && velocity < 50) {
+                    working.add(key);
+                    double mk = mscale;
+                    double mkd = scale;
+                    e.submit(() ->
+                    {
+                        PrecisionStopwatch ps = PrecisionStopwatch.start();
+                        BufferedImage b = renderer.render(x * mscale, z * mscale, div * mscale, div / (lowtile ? 3 : 1), currentType);
+                        rs.put(ps.getMilliseconds());
+                        working.remove(key);
+
+                        if (mk == mscale && mkd == scale) {
+                            positions.put(key, b);
+                        }
+                    });
+                }
+            }
+
+            return fastpositions.get(key);
+        }
+
+        if (workingfast.contains(key) || workingfast.size() > Runtime.getRuntime().availableProcessors()) {
+            return null;
+        }
+
+        workingfast.add(key);
+        double mk = mscale;
+        double mkd = scale;
+        eh.submit(() ->
+        {
+            PrecisionStopwatch ps = PrecisionStopwatch.start();
+            BufferedImage b = renderer.render(x * mscale, z * mscale, div * mscale, div / lowq, currentType);
+            rs.put(ps.getMilliseconds());
+            workingfast.remove(key);
+
+            if (mk == mscale && mkd == scale) {
+                fastpositions.put(key, b);
+            }
+        });
+        return null;
+    }
+
+    private double getWorldX(double screenX) {
+        //return (mscale * screenX) + ((oxp / scale) * mscale);
+        return (mscale * screenX) + ((oxp / scale) * mscale);
+    }
+
+    private double getWorldZ(double screenZ) {
+        return (mscale * screenZ) + ((ozp / scale) * mscale);
+    }
+
+    private double getScreenX(double x) {
+        return (x / mscale) - ((oxp / scale));
+    }
+
+    private double getScreenZ(double z) {
+        return (z / mscale) - ((ozp / scale));
+    }
+
+    @Override
+    public void paint(Graphics gx) {
+
+        if (engine.isClosed()) {
+            EventQueue.invokeLater(() -> {
+                try {
+                    setVisible(false);
+                } catch (Throwable e) {
+
+                }
+            });
+
+            return;
+        }
+
+        if (updateEngine()) {
+            dump();
+        }
+
+        if (ox < oxp) {
+            velocity = Math.abs(ox - oxp) * 0.36;
+            oxp -= velocity;
+        }
+
+        if (ox > oxp) {
+            velocity = Math.abs(oxp - ox) * 0.36;
+            oxp += velocity;
+        }
+
+        if (oz < ozp) {
+            velocity = Math.abs(oz - ozp) * 0.36;
+            ozp -= velocity;
+        }
+
+        if (oz > ozp) {
+            velocity = Math.abs(ozp - oz) * 0.36;
+            ozp += velocity;
+        }
+
+        if (lx < hx) {
+            hx -= Math.abs(lx - hx) * 0.36;
+        }
+
+        if (lx > hx) {
+            hx += Math.abs(hx - lx) * 0.36;
+        }
+
+        if (lz < hz) {
+            hz -= Math.abs(lz - hz) * 0.36;
+        }
+
+        if (lz > hz) {
+            hz += Math.abs(hz - lz) * 0.36;
+        }
+
+        if (centities.flip()) {
+            J.s(() -> {
+                synchronized (lastEntities) {
+                    lastEntities.clear();
+                    lastEntities.addAll(world.getEntitiesByClass(LivingEntity.class));
+                }
+            });
+        }
+        lowq = Math.max(Math.min((int) M.lerp(8, 28, velocity / 1000D), 28), 8);
+        PrecisionStopwatch p = PrecisionStopwatch.start();
+        Graphics2D g = (Graphics2D) gx;
+        w = getWidth();
+        h = getHeight();
+        double vscale = scale;
+        scale = w / 12D;
+
+        if (scale != vscale) {
+            positions.clear();
+        }
+
+        KSet<BlockPosition> gg = new KSet<>();
+        int iscale = (int) scale;
+        g.setColor(Color.white);
+        g.clearRect(0, 0, w, h);
+        int posX = (int) oxp;
+        int posZ = (int) ozp;
+        m.set(3);
+
+        for (int r = 0; r < Math.max(w, h); r += iscale) {
+            for (int i = -iscale; i < w + iscale; i += iscale) {
+                for (int j = -iscale; j < h + iscale; j += iscale) {
+                    int a = i - (w / 2);
+                    int b = j - (h / 2);
+                    if (a * a + b * b <= r * r) {
+                        BufferedImage t = getTile(gg, iscale, Math.floorDiv((posX / iscale) + i, iscale) * iscale, Math.floorDiv((posZ / iscale) + j, iscale) * iscale, m);
+
+                        if (t != null) {
+                            g.drawImage(t, i - ((posX / iscale) % (iscale)), j - ((posZ / iscale) % (iscale)), iscale, iscale, (img, infoflags, x, y, width, height) -> true);
+                        }
+                    }
+                }
+            }
+        }
+
+        p.end();
+
+        for (BlockPosition i : positions.k()) {
+            if (!gg.contains(i)) {
+                positions.remove(i);
+            }
+        }
+
+        hanleFollow();
+        renderOverlays(g);
+
+        if (!isVisible()) {
+            return;
+        }
+
+        if (!getParent().isVisible()) {
+            return;
+        }
+
+        if (!getParent().getParent().isVisible()) {
+            return;
+        }
+
+        J.a(() ->
+        {
+            J.sleep(eco ? 15 : 1);
+            repaint();
+        });
+    }
+
+    private void hanleFollow() {
+        if (follow && player != null) {
+            animateTo(player.getLocation().getX(), player.getLocation().getZ());
+        }
+    }
+
+    private void renderOverlays(Graphics2D g) {
+        renderPlayer(g);
+
+        if (help) {
+            renderOverlayHelp(g);
+        } else if (debug) {
+            renderOverlayDebug(g);
+        }
+
+        renderOverlayLegend(g);
+
+        renderHoverOverlay(g, shift);
+        if (!notifications.isEmpty()) {
+            renderNotification(g);
+        }
+    }
+
+    private void renderOverlayLegend(Graphics2D g) {
+        KList<String> l = new KList<>();
+        l.add("Zoom: " + Form.pc(mscale, 0));
+        l.add("Blocks: " + Form.f((int) mscale * w) + " by " + Form.f((int) mscale * h));
+        l.add("BPP: " + Form.f(mscale, 1));
+        l.add("Render Mode: " + Form.capitalizeWords(currentType.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
+
+        drawCardBR(g, l);
+    }
+
+    private void renderNotification(Graphics2D g) {
+        drawCardCB(g, notifications.k());
+
+        for (String i : notifications.k()) {
+            if (M.ms() > notifications.get(i)) {
+                notifications.remove(i);
+            }
+        }
+    }
+
+    private void renderPlayer(Graphics2D g) {
+        Player b = null;
+
+        for (Player i : world.getPlayers()) {
+            b = i;
+            renderPosition(g, i.getLocation().getX(), i.getLocation().getZ());
+        }
+
+        synchronized (lastEntities) {
+            double dist = Double.MAX_VALUE;
+            LivingEntity h = null;
+
+            for (LivingEntity i : lastEntities) {
+                if (i instanceof Player) {
+                    continue;
+                }
+
+                renderMobPosition(g, i, i.getLocation().getX(), i.getLocation().getZ());
+                if (shift) {
+                    double d = i.getLocation().distanceSquared(new Location(i.getWorld(), getWorldX(hx), i.getLocation().getY(), getWorldZ(hz)));
+
+                    if (d < dist) {
+                        dist = d;
+                        h = i;
+                    }
+                }
+            }
+
+            if (h != null && shift) {
+                g.setColor(Color.red);
+                g.fillRoundRect((int) getScreenX(h.getLocation().getX()) - 10, (int) getScreenZ(h.getLocation().getZ()) - 10, 20, 20, 20, 20);
+                KList<String> k = new KList<>();
+                k.add(Form.capitalizeWords(h.getType().name().toLowerCase(Locale.ROOT).replaceAll("\\Q_\\E", " ")) + h.getEntityId());
+
+                k.add("Pos: " + h.getLocation().getBlockX() + ", " + h.getLocation().getBlockY() + ", " + h.getLocation().getBlockZ());
+                k.add("UUID: " + h.getUniqueId());
+                k.add("HP: " + h.getHealth() + " / " + h.getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue());
+
+                drawCardTR(g, k);
+            }
+        }
+
+        player = b;
+    }
+
+    private void animateTo(double wx, double wz) {
+        double cx = getWorldX(getWidth() / 2);
+        double cz = getWorldZ(getHeight() / 2);
+        ox += (wx - cx);
+        oz += (wz - cz);
+    }
+
+    private void renderPosition(Graphics2D g, double x, double z) {
+        if (texture != null) {
+            g.drawImage(texture, (int) getScreenX(x), (int) getScreenZ(z), 66, 66, (img, infoflags, xx, xy, width, height) -> true);
+        } else {
+            g.setColor(Color.darkGray);
+            g.fillRoundRect((int) getScreenX(x) - 15, (int) getScreenZ(z) - 15, 30, 30, 15, 15);
+            g.setColor(Color.cyan.darker().darker());
+            g.fillRoundRect((int) getScreenX(x) - 10, (int) getScreenZ(z) - 10, 20, 20, 10, 10);
+        }
+    }
+
+    private void renderMobPosition(Graphics2D g, LivingEntity e, double x, double z) {
+        g.setColor(Color.red.darker().darker());
+        g.fillRoundRect((int) getScreenX(x) - 2, (int) getScreenZ(z) - 2, 4, 4, 4, 4);
+    }
+
+    private void renderHoverOverlay(Graphics2D g, boolean detailed) {
+        IrisBiome biome = engine.getComplex().getTrueBiomeStream().get(getWorldX(hx), getWorldZ(hz));
+        IrisRegion region = engine.getComplex().getRegionStream().get(getWorldX(hx), getWorldZ(hz));
+        KList<String> l = new KList<>();
+        l.add("Biome: " + biome.getName());
+        l.add("Region: " + region.getName() + "(" + region.getLoadKey() + ")");
+        l.add("Block " + (int) getWorldX(hx) + ", " + (int) getWorldZ(hz));
+        if (detailed) {
+            l.add("Chunk " + ((int) getWorldX(hx) >> 4) + ", " + ((int) getWorldZ(hz) >> 4));
+            l.add("Region " + (((int) getWorldX(hx) >> 4) >> 5) + ", " + (((int) getWorldZ(hz) >> 4) >> 5));
+            l.add("Key: " + biome.getLoadKey());
+            l.add("File: " + biome.getLoadFile());
+        }
+
+        drawCardAt((float) hx, (float) hz, 0, 0, g, l);
+    }
+
+    private void renderOverlayDebug(Graphics2D g) {
+        KList<String> l = new KList<>();
+        l.add("Velocity: " + (int) velocity);
+        l.add("Center Pos: " + Form.f((int) getWorldX(getWidth() / 2)) + ", " + Form.f((int) getWorldZ(getHeight() / 2)));
+        drawCardBL(g, l);
+    }
+
+    private void renderOverlayHelp(Graphics2D g) {
+        KList<String> l = new KList<>();
+        l.add("/ to show this help screen");
+        l.add("R to repaint the screen");
+        l.add("F to follow first player");
+        l.add("+/- to Change Zoom");
+        l.add("\\ to reset zoom to 1");
+        l.add("M to cycle render modes");
+        l.add("P to toggle Tile Quality Mode");
+        l.add("E to toggle Eco FPS Mode");
+
+        int ff = 0;
+        for (RenderType i : RenderType.values()) {
+            ff++;
+            l.add(ff + " to view " + Form.capitalizeWords(i.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
+        }
+
+        l.add("Shift for additional biome details (at cursor)");
+        l.add("CTRL + Click to teleport to location");
+        l.add("ALT + Click to open biome in VSCode");
+        drawCardTL(g, l);
+    }
+
+    private void drawCardTL(Graphics2D g, KList<String> text) {
+        drawCardAt(0, 0, 0, 0, g, text);
+    }
+
+    private void drawCardBR(Graphics2D g, KList<String> text) {
+        drawCardAt(getWidth(), getHeight(), 1, 1, g, text);
+    }
+
+    private void drawCardBL(Graphics2D g, KList<String> text) {
+        drawCardAt(0, getHeight(), 0, 1, g, text);
+    }
+
+    private void drawCardTR(Graphics2D g, KList<String> text) {
+        drawCardAt(getWidth(), 0, 1, 0, g, text);
+    }
+
+    private void open() {
+        IrisComplex complex = engine.getComplex();
+        File r = null;
+        switch (currentType) {
+            case BIOME, LAYER_LOAD, DECORATOR_LOAD, OBJECT_LOAD, HEIGHT ->
+                    r = complex.getTrueBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
+            case BIOME_LAND -> r = complex.getLandBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
+            case BIOME_SEA -> r = complex.getSeaBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
+            case REGION -> r = complex.getRegionStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
+            case CAVE_LAND -> r = complex.getCaveBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
+        }
+
+        notify("Opening " + r.getPath() + " in VSCode");
+    }
+
+    private void teleport() {
+        J.s(() -> {
+            if (player != null) {
+                int xx = (int) getWorldX(hx);
+                int zz = (int) getWorldZ(hz);
+                int h = engine.getComplex().getRoundedHeighteightStream().get(xx, zz);
+                player.teleport(new Location(player.getWorld(), xx, h, zz));
+                notify("Teleporting to " + xx + ", " + h + ", " + zz);
+            } else {
+                notify("No player in world, can't teleport.");
+            }
+        });
+    }
+
+    private void drawCardCB(Graphics2D g, KList<String> text) {
+        drawCardAt(getWidth() / 2, getHeight(), 0.5, 1, g, text);
+    }
+
+    private void drawCardCT(Graphics2D g, KList<String> text) {
+        drawCardAt(getWidth() / 2, 0, 0.5, 0, g, text);
+    }
+
+    private void drawCardAt(float x, float y, double pushX, double pushZ, Graphics2D g, KList<String> text) {
+        g.setFont(new Font("Hevetica", Font.BOLD, 16));
+        int h = 0;
+        int w = 0;
+
+        for (String i : text) {
+            h += g.getFontMetrics().getHeight();
+            w = Math.max(w, g.getFontMetrics().stringWidth(i));
+        }
+
+        w += 28;
+        h += 14;
+
+        int cw = (int) ((w + 26) * pushX);
+        int ch = (int) ((h + 26) * pushZ);
+
+        g.setColor(Color.darkGray);
+        g.fillRect((int) x + 7 + 2 - cw, (int) y + 12 + 2 - ch, w + 7, h); // Shadow
+        g.setColor(Color.gray);
+        g.fillRect((int) x + 7 + 1 - cw, (int) y + 12 + 1 - ch, w + 7, h); // Shadow
+        g.setColor(Color.white);
+        g.fillRect((int) x + 7 - cw, (int) y + 12 - ch, w + 7, h);
+
+        g.setColor(Color.black);
+        int m = 0;
+        for (String i : text) {
+            g.drawString(i, x + 14 - cw, y + 14 - ch + (++m * g.getFontMetrics().getHeight()));
+        }
+    }
+
+    public void mouseWheelMoved(MouseWheelEvent e) {
+        int notches = e.getWheelRotation();
+        if (e.isControlDown()) {
+            return;
+        }
+
+        //Iris.info("Blocks/Pixel: " + (mscale) + ", Blocks Wide: " + (w * mscale));
+        positions.clear();
+        fastpositions.clear();
+        mscale = mscale + ((0.25 * mscale) * notches);
+        mscale = Math.max(mscale, 0.00001);
+    }
+
+    @Override
+    public void mouseClicked(MouseEvent e) {
+        if (control) {
+            teleport();
+        } else if (alt) {
+            open();
+        }
+    }
+
+    @Override
+    public void mousePressed(MouseEvent e) {
+
+    }
+
+    @Override
+    public void mouseReleased(MouseEvent e) {
+
+    }
+
+    @Override
+    public void mouseEntered(MouseEvent e) {
+
+    }
+
+    @Override
+    public void mouseExited(MouseEvent e) {
+
+    }
+}
@@ -1,173 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.gui.components.RenderType;
-import com.volmit.iris.engine.IrisComplex;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisWorld;
-import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.scheduling.J;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Player;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Locale;
-import java.util.Optional;
-import java.util.UUID;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.Consumer;
-
-import static com.volmit.iris.util.data.registry.Attributes.MAX_HEALTH;
-
-final class VisionOverlay {
-    private final Engine engine;
-    private final UUID openerId;
-    private final AtomicBoolean playerRefreshQueued = new AtomicBoolean();
-    private volatile List<GuiMarker> playerMarkers = List.of();
-
-    VisionOverlay(Engine engine, UUID openerId) {
-        this.engine = engine;
-        this.openerId = openerId;
-    }
-
-    List<GuiMarker> lastKnownPlayers() {
-        queuePlayerRefresh();
-        return playerMarkers;
-    }
-
-    void requestEntities(Consumer<List<GuiMarker>> sink) {
-        runOnServerThread(() -> sink.accept(collectEntities()));
-    }
-
-    void teleport(int blockX, int blockZ) {
-        runOnServerThread(() -> teleportOpener(blockX, blockZ));
-    }
-
-    Optional<String> openInEditor(double worldX, double worldZ, RenderType type) {
-        IrisComplex complex = engine.getComplex();
-        File file = switch (type) {
-            case BIOME, HEIGHT ->
-                    complex.getTrueBiomeStream().get(worldX, worldZ).openInVSCode();
-            case BIOME_LAND -> complex.getLandBiomeStream().get(worldX, worldZ).openInVSCode();
-            case BIOME_SEA -> complex.getSeaBiomeStream().get(worldX, worldZ).openInVSCode();
-            case REGION -> complex.getRegionStream().get(worldX, worldZ).openInVSCode();
-            case CAVE_LAND -> complex.getCaveBiomeStream().get(worldX, worldZ).openInVSCode();
-            case CONTINENT -> null;
-        };
-        return Optional.ofNullable(file).map(File::getName);
-    }
-
-    private void queuePlayerRefresh() {
-        if (!playerRefreshQueued.compareAndSet(false, true)) {
-            return;
-        }
-
-        boolean scheduled = runOnServerThread(() -> {
-            try {
-                playerMarkers = collectPlayers();
-            } finally {
-                playerRefreshQueued.set(false);
-            }
-        });
-        if (!scheduled) {
-            playerRefreshQueued.set(false);
-        }
-    }
-
-    private List<GuiMarker> collectPlayers() {
-        List<GuiMarker> markers = new ArrayList<>();
-        for (Player player : engine.getWorld().getPlayers()) {
-            Location at = player.getLocation();
-            markers.add(GuiMarker.player(player.getName(), at.getX(), at.getZ()));
-        }
-        return List.copyOf(markers);
-    }
-
-    private List<GuiMarker> collectEntities() {
-        IrisWorld world = engine.getWorld();
-        if (!world.hasRealWorld()) {
-            return List.of();
-        }
-
-        List<GuiMarker> markers = new ArrayList<>();
-        for (LivingEntity entity : world.getEntitiesByClass(LivingEntity.class)) {
-            if (!(entity instanceof Player)) {
-                markers.add(marker(entity));
-            }
-        }
-        return List.copyOf(markers);
-    }
-
-    private static GuiMarker marker(LivingEntity entity) {
-        Location at = entity.getLocation();
-        String label = Form.capitalizeWords(entity.getType().name().toLowerCase(Locale.ROOT).replace('_', ' '));
-        double maxHealth = 0D;
-        try {
-            maxHealth = entity.getAttribute(MAX_HEALTH).getValue();
-        } catch (Throwable ignored) {
-        }
-        return GuiMarker.entity(label, at.getX(), at.getY(), at.getZ(), entity.getHealth(), maxHealth);
-    }
-
-    private void teleportOpener(int blockX, int blockZ) {
-        IrisWorld target = engine.getWorld();
-        Player player = selectPlayer(target.getPlayers());
-        if (player == null || !target.hasRealWorld() || engine.isClosed()) {
-            return;
-        }
-
-        World world = target.realWorld();
-        int blockY = engine.getMinHeight() + engine.getHeight(blockX, blockZ, false) + 2;
-        Location destination = new Location(world, blockX + 0.5D, blockY, blockZ + 0.5D);
-        player.teleportAsync(destination).whenComplete((success, failure) -> {
-            if (failure != null) {
-                Iris.reportError(failure);
-                Iris.warn("Vision could not teleport %s to %d, %d.", player.getName(), blockX, blockZ);
-            }
-        });
-    }
-
-    private Player selectPlayer(List<Player> players) {
-        if (openerId == null) {
-            return players.isEmpty() ? null : players.get(0);
-        }
-        for (Player player : players) {
-            if (openerId.equals(player.getUniqueId())) {
-                return player;
-            }
-        }
-        return null;
-    }
-
-    private static boolean runOnServerThread(Runnable task) {
-        try {
-            J.s(task);
-            return true;
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            return false;
-        }
-    }
-}
@@ -1,649 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.gui.components.IrisRenderer;
-import com.volmit.iris.core.gui.components.MapLabels;
-import com.volmit.iris.core.gui.components.MapTile;
-import com.volmit.iris.core.gui.components.RenderType;
-
-import java.awt.EventQueue;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.Callable;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.RejectedExecutionException;
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.function.Consumer;
-
-/**
- * Renders the map as tiles on fixed zoom levels, so zooming within a level and panning reuse tiles that are already drawn.
- * Tiles keep rendering while the view moves, as long as they are still on screen.
- */
-final class VisionRenderController implements AutoCloseable {
-    static final int TILE_PIXELS = 64;
-    static final double MINIMUM_VIEW_BLOCKS_PER_PIXEL = 1D / 8D;
-    static final double MAXIMUM_BLOCKS_PER_PIXEL = 4_096D;
-
-    private static final double MINIMUM_RENDER_BLOCKS_PER_PIXEL = 1D;
-    private static final int MAXIMUM_VISIBLE_TILES = 32_768;
-    private static final int PROBE_QUEUE_CAPACITY = 1;
-    private static final int COARSER_FALLBACK_LEVELS = 6;
-    private static final long CACHE_BYTES = 256L * 1024L * 1024L;
-
-    private final Runnable listener;
-    private final int workerCount;
-    private final ThreadPoolExecutor renderExecutor;
-    private final ThreadPoolExecutor probeExecutor;
-    private final WeightedTileCache cache;
-    private final Set<TileKey> tilesInFlight = new HashSet<>();
-    private final AtomicInteger activeWorkers = new AtomicInteger();
-    private final AtomicLong viewSequence = new AtomicLong();
-    private final AtomicLong probeSequence = new AtomicLong();
-    private final AtomicBoolean closed = new AtomicBoolean();
-    private final AtomicBoolean publicationQueued = new AtomicBoolean();
-    private final AtomicBoolean publicationDirty = new AtomicBoolean();
-    private volatile Frame currentFrame;
-
-    VisionRenderController(Runnable listener) {
-        this.listener = Objects.requireNonNull(listener, "listener");
-        int processors = Math.max(1, Runtime.getRuntime().availableProcessors());
-        this.workerCount = Math.max(1, Math.min(6, processors / 2));
-        AtomicInteger threadSequence = new AtomicInteger();
-        this.renderExecutor = new ThreadPoolExecutor(
-                workerCount,
-                workerCount,
-                30L,
-                TimeUnit.SECONDS,
-                new LinkedBlockingQueue<>(),
-                daemonFactory("Iris Vision Render", Thread.NORM_PRIORITY, threadSequence)
-        );
-        this.renderExecutor.allowCoreThreadTimeOut(true);
-        this.probeExecutor = new ThreadPoolExecutor(
-                1,
-                1,
-                0L,
-                TimeUnit.MILLISECONDS,
-                new ArrayBlockingQueue<>(PROBE_QUEUE_CAPACITY),
-                daemonFactory("Iris Vision Probe", Thread.MIN_PRIORITY, threadSequence),
-                new ThreadPoolExecutor.DiscardOldestPolicy()
-        );
-        this.cache = new WeightedTileCache(CACHE_BYTES);
-        GuiHost.interruptOnPluginShutdown(renderExecutor);
-        GuiHost.interruptOnPluginShutdown(probeExecutor);
-    }
-
-    // Snapping to powers of two keeps every zoom within a level on the same tiles; nearest keeps tiles within 1.41x of screen size.
-    static double renderBlocksPerPixel(double viewBlocksPerPixel) {
-        double level = Math.pow(2D, Math.round(Math.log(viewBlocksPerPixel) / Math.log(2D)));
-        return Math.max(MINIMUM_RENDER_BLOCKS_PER_PIXEL, Math.min(MAXIMUM_BLOCKS_PER_PIXEL, level));
-    }
-
-    Frame request(RenderSpec spec) {
-        Objects.requireNonNull(spec, "spec");
-        if (closed.get()) {
-            throw new IllegalStateException("Vision render controller is closed");
-        }
-        double renderScale = renderBlocksPerPixel(spec.blocksPerPixel());
-        List<VisibleTile> tiles = visibleTiles(spec, renderScale);
-        Frame frame = new Frame(viewSequence.incrementAndGet(), spec, renderScale, tiles);
-        for (VisibleTile tile : tiles) {
-            tile.setTile(cachedTileServing(tile.key()));
-        }
-        currentFrame = frame;
-        probeSequence.incrementAndGet();
-        probeExecutor.getQueue().clear();
-        startWorkers();
-        publish();
-        return frame;
-    }
-
-    /**
-     * A tile from another zoom level covering the given one, to draw while the real tile renders.
-     */
-    Fallback fallback(Frame frame, VisibleTile tile) {
-        MapTile withoutHeights = cache.get(tile.key().withHeights(false));
-        if (withoutHeights != null) {
-            return new Fallback(List.of(new FallbackPiece(withoutHeights, 0, 0, TILE_PIXELS, 0D, 0D, 1D)));
-        }
-        Fallback coarser = coarserFallback(frame, tile);
-        return coarser != null ? coarser : finerFallback(frame, tile);
-    }
-
-    // A tile drawn with heights serves just as well where no heights are needed, so turning shading off redraws nothing.
-    private MapTile cachedTileServing(TileKey key) {
-        MapTile exact = cache.get(key);
-        if (exact != null || key.heights()) {
-            return exact;
-        }
-        return cache.get(key.withHeights(true));
-    }
-
-    Progress progress(Frame frame) {
-        if (frame == null) {
-            return new Progress(0, 0, 0);
-        }
-        int ready = 0;
-        for (VisibleTile tile : frame.tiles()) {
-            if (tile.tile() != null) {
-                ready++;
-            }
-        }
-        return new Progress(frame.tiles().size(), ready, activeWorkers.get());
-    }
-
-    <T> void submitProbe(Frame frame, Callable<T> probe, Consumer<T> consumer) {
-        Objects.requireNonNull(probe, "probe");
-        Objects.requireNonNull(consumer, "consumer");
-        if (frame == null || closed.get() || currentFrame != frame) {
-            return;
-        }
-        long probeRevision = probeSequence.incrementAndGet();
-        probeExecutor.getQueue().clear();
-        try {
-            probeExecutor.execute(() -> runProbe(probeRevision, probe, consumer));
-        } catch (RejectedExecutionException ignored) {
-            probeExecutor.getQueue().clear();
-        }
-    }
-
-    @Override
-    public void close() {
-        if (!closed.compareAndSet(false, true)) {
-            return;
-        }
-        currentFrame = null;
-        renderExecutor.shutdownNow();
-        probeExecutor.shutdownNow();
-        cache.clear();
-    }
-
-    static List<VisibleTile> visibleTiles(RenderSpec spec, double renderScale) {
-        Objects.requireNonNull(spec, "spec");
-        double blocksPerPixel = spec.blocksPerPixel();
-        double tileSpan = TILE_PIXELS * renderScale;
-        double halfWidth = spec.width() * blocksPerPixel * 0.5D;
-        double halfHeight = spec.height() * blocksPerPixel * 0.5D;
-        long minimumX = floorTile(spec.centerX() - halfWidth, tileSpan);
-        long maximumX = floorTile(Math.nextDown(spec.centerX() + halfWidth), tileSpan);
-        long minimumZ = floorTile(spec.centerZ() - halfHeight, tileSpan);
-        long maximumZ = floorTile(Math.nextDown(spec.centerZ() + halfHeight), tileSpan);
-        long tileCount = Math.multiplyExact(maximumX - minimumX + 1L, maximumZ - minimumZ + 1L);
-        if (tileCount > MAXIMUM_VISIBLE_TILES) {
-            throw new IllegalArgumentException("Vision viewport contains too many tiles");
-        }
-
-        ArrayList<VisibleTile> tiles = new ArrayList<>((int) tileCount);
-        double centerTileX = spec.centerX() / tileSpan;
-        double centerTileZ = spec.centerZ() / tileSpan;
-        for (long tileZ = minimumZ; tileZ <= maximumZ; tileZ++) {
-            for (long tileX = minimumX; tileX <= maximumX; tileX++) {
-                double deltaX = tileX + 0.5D - centerTileX;
-                double deltaZ = tileZ + 0.5D - centerTileZ;
-                TileKey key = new TileKey(spec.contentRevision(), spec.type(), spec.heights(), renderScale, tileX, tileZ);
-                tiles.add(new VisibleTile(key, deltaX * deltaX + deltaZ * deltaZ));
-            }
-        }
-        tiles.sort(Comparator.comparingDouble(VisibleTile::distanceSquared)
-                .thenComparingLong(VisibleTile::tileZ)
-                .thenComparingLong(VisibleTile::tileX));
-        return List.copyOf(tiles);
-    }
-
-    private static long floorTile(double coordinate, double tileSpan) {
-        double tile = Math.floor(coordinate / tileSpan);
-        if (tile < Long.MIN_VALUE || tile > Long.MAX_VALUE) {
-            throw new IllegalArgumentException("Vision viewport exceeds tile coordinate range");
-        }
-        return (long) tile;
-    }
-
-    private static ThreadFactory daemonFactory(String name, int priority, AtomicInteger sequence) {
-        return (Runnable runnable) -> {
-            Thread thread = new Thread(runnable, name + " " + sequence.incrementAndGet());
-            thread.setDaemon(true);
-            thread.setPriority(priority);
-            thread.setUncaughtExceptionHandler((Thread failedThread, Throwable error) -> Iris.reportError(error));
-            return thread;
-        };
-    }
-
-    private void startWorkers() {
-        while (!closed.get()) {
-            int active = activeWorkers.get();
-            if (active >= workerCount || !hasWork()) {
-                return;
-            }
-            if (!activeWorkers.compareAndSet(active, active + 1)) {
-                continue;
-            }
-            try {
-                renderExecutor.execute(this::renderUntilIdle);
-            } catch (RejectedExecutionException ignored) {
-                activeWorkers.decrementAndGet();
-                return;
-            }
-        }
-    }
-
-    // Each worker keeps taking the most central missing tile of whatever frame is current, until the screen is covered.
-    private void renderUntilIdle() {
-        try {
-            TileJob job;
-            while ((job = claimNextTile()) != null) {
-                render(job);
-            }
-        } finally {
-            activeWorkers.decrementAndGet();
-        }
-        startWorkers();
-    }
-
-    private synchronized boolean hasWork() {
-        Frame frame = currentFrame;
-        return frame != null && frame.nextMissing(tilesInFlight, false) != null;
-    }
-
-    private synchronized TileJob claimNextTile() {
-        Frame frame = currentFrame;
-        if (frame == null || closed.get()) {
-            return null;
-        }
-        VisibleTile tile = frame.nextMissing(tilesInFlight, true);
-        if (tile == null) {
-            return null;
-        }
-        tilesInFlight.add(tile.key());
-        return new TileJob(frame.spec().renderer(), tile.key());
-    }
-
-    private synchronized void release(TileKey key) {
-        tilesInFlight.remove(key);
-    }
-
-    private void render(TileJob job) {
-        TileKey key = job.key();
-        try {
-            double tileSpan = TILE_PIXELS * key.blocksPerPixel();
-            MapTile tile = job.renderer().renderTile(
-                    key.tileX() * tileSpan,
-                    key.tileZ() * tileSpan,
-                    key.blocksPerPixel(),
-                    TILE_PIXELS,
-                    key.type(),
-                    key.heights(),
-                    () -> !isWanted(key)
-            );
-            cache.put(key, tile);
-            Frame frame = currentFrame;
-            VisibleTile visible = frame == null ? null : frame.tile(key);
-            if (visible != null) {
-                visible.setTile(tile);
-                publish();
-            }
-        } catch (CancellationException ignored) {
-        } catch (Throwable error) {
-            Iris.debug("Vision tile render failed: " + error.getClass().getSimpleName() + ": " + error.getMessage());
-        } finally {
-            release(key);
-        }
-    }
-
-    private boolean isWanted(TileKey key) {
-        Frame frame = currentFrame;
-        return !closed.get() && frame != null && frame.tile(key) != null;
-    }
-
-    private Fallback coarserFallback(Frame frame, VisibleTile tile) {
-        TileKey key = tile.key();
-        for (int level = 1; level <= COARSER_FALLBACK_LEVELS; level++) {
-            long scale = 1L << level;
-            int sourceSize = TILE_PIXELS >> level;
-            double parentScale = key.blocksPerPixel() * scale;
-            if (sourceSize < 1 || parentScale > MAXIMUM_BLOCKS_PER_PIXEL) {
-                return null;
-            }
-            long parentX = Math.floorDiv(key.tileX(), scale);
-            long parentZ = Math.floorDiv(key.tileZ(), scale);
-            MapTile parent = cache.get(new TileKey(key.contentRevision(), key.type(), key.heights(), parentScale, parentX,
-                    parentZ));
-            if (parent != null) {
-                int sourceX = (int) (key.tileX() - parentX * scale) * sourceSize;
-                int sourceZ = (int) (key.tileZ() - parentZ * scale) * sourceSize;
-                return new Fallback(List.of(new FallbackPiece(parent, sourceX, sourceZ, sourceSize, 0D, 0D, 1D)));
-            }
-        }
-        return null;
-    }
-
-    private Fallback finerFallback(Frame frame, VisibleTile tile) {
-        TileKey key = tile.key();
-        double childScale = key.blocksPerPixel() / 2D;
-        if (childScale < MINIMUM_RENDER_BLOCKS_PER_PIXEL) {
-            return null;
-        }
-        List<FallbackPiece> pieces = new ArrayList<>(4);
-        for (int childZ = 0; childZ < 2; childZ++) {
-            for (int childX = 0; childX < 2; childX++) {
-                MapTile child = cache.get(new TileKey(key.contentRevision(), key.type(), key.heights(), childScale,
-                        key.tileX() * 2L + childX, key.tileZ() * 2L + childZ));
-                if (child != null) {
-                    pieces.add(new FallbackPiece(child, 0, 0, TILE_PIXELS, childX * 0.5D, childZ * 0.5D, 0.5D));
-                }
-            }
-        }
-        return pieces.isEmpty() ? null : new Fallback(List.copyOf(pieces));
-    }
-
-    private <T> void runProbe(long probeRevision, Callable<T> probe, Consumer<T> consumer) {
-        try {
-            if (!isProbeCurrent(probeRevision)) {
-                return;
-            }
-            T result = probe.call();
-            if (!isProbeCurrent(probeRevision)) {
-                return;
-            }
-            EventQueue.invokeLater(() -> {
-                if (isProbeCurrent(probeRevision)) {
-                    consumer.accept(result);
-                }
-            });
-        } catch (InterruptedException interrupted) {
-            Thread.currentThread().interrupt();
-        } catch (Throwable error) {
-            Iris.debug("Vision probe failed: " + error.getClass().getSimpleName() + ": " + error.getMessage());
-        }
-    }
-
-    private boolean isProbeCurrent(long probeRevision) {
-        return !closed.get() && probeSequence.get() == probeRevision;
-    }
-
-    private void publish() {
-        if (closed.get()) {
-            return;
-        }
-        publicationDirty.set(true);
-        queuePublication();
-    }
-
-    private void queuePublication() {
-        if (!publicationQueued.compareAndSet(false, true)) {
-            return;
-        }
-        EventQueue.invokeLater(() -> {
-            try {
-                if (publicationDirty.getAndSet(false) && !closed.get()) {
-                    listener.run();
-                }
-            } finally {
-                publicationQueued.set(false);
-                if (publicationDirty.get() && !closed.get()) {
-                    queuePublication();
-                }
-            }
-        });
-    }
-
-    record RenderSpec(
-            IrisRenderer renderer,
-            RenderType type,
-            long contentRevision,
-            double centerX,
-            double centerZ,
-            double blocksPerPixel,
-            int width,
-            int height,
-            boolean heights
-    ) {
-        RenderSpec {
-            Objects.requireNonNull(renderer, "renderer");
-            Objects.requireNonNull(type, "type");
-            if (!Double.isFinite(centerX) || !Double.isFinite(centerZ)) {
-                throw new IllegalArgumentException("Vision center must be finite");
-            }
-            if (!Double.isFinite(blocksPerPixel)
-                    || blocksPerPixel < MINIMUM_VIEW_BLOCKS_PER_PIXEL
-                    || blocksPerPixel > MAXIMUM_BLOCKS_PER_PIXEL) {
-                throw new IllegalArgumentException("Vision scale is outside the supported range");
-            }
-            if (width < 1 || height < 1) {
-                throw new IllegalArgumentException("Vision viewport must be positive");
-            }
-        }
-    }
-
-    static final class Frame {
-        private final long viewRevision;
-        private final RenderSpec spec;
-        private final double renderBlocksPerPixel;
-        private final List<VisibleTile> tiles;
-        private final Map<TileKey, VisibleTile> tilesByKey;
-        private int nextCandidate;
-
-        private Frame(long viewRevision, RenderSpec spec, double renderBlocksPerPixel, List<VisibleTile> tiles) {
-            this.viewRevision = viewRevision;
-            this.spec = Objects.requireNonNull(spec, "spec");
-            this.renderBlocksPerPixel = renderBlocksPerPixel;
-            this.tiles = tiles;
-            this.tilesByKey = new HashMap<>(tiles.size() * 2);
-            for (VisibleTile tile : tiles) {
-                tilesByKey.put(tile.key(), tile);
-            }
-        }
-
-        long viewRevision() {
-            return viewRevision;
-        }
-
-        RenderSpec spec() {
-            return spec;
-        }
-
-        double renderBlocksPerPixel() {
-            return renderBlocksPerPixel;
-        }
-
-        List<VisibleTile> tiles() {
-            return tiles;
-        }
-
-        private VisibleTile tile(TileKey key) {
-            return tilesByKey.get(key);
-        }
-
-        /**
-         * The tile covering a world position together with the pixel of it there, or null when that tile is not drawn yet.
-         */
-        TilePixel pixelAt(double worldX, double worldZ) {
-            double tileSpan = TILE_PIXELS * renderBlocksPerPixel;
-            long tileX = (long) Math.floor(worldX / tileSpan);
-            long tileZ = (long) Math.floor(worldZ / tileSpan);
-            VisibleTile visible = tilesByKey.get(new TileKey(spec.contentRevision(), spec.type(), spec.heights(),
-                    renderBlocksPerPixel, tileX, tileZ));
-            MapTile tile = visible == null ? null : visible.tile();
-            if (tile == null) {
-                return null;
-            }
-            int pixelX = pixelWithin(worldX - tileX * tileSpan);
-            int pixelZ = pixelWithin(worldZ - tileZ * tileSpan);
-            return new TilePixel(tile, pixelX, pixelZ);
-        }
-
-        private int pixelWithin(double offsetBlocks) {
-            return Math.max(0, Math.min(TILE_PIXELS - 1, (int) Math.floor(offsetBlocks / renderBlocksPerPixel)));
-        }
-
-        // Tiles are sorted centre first, and everything before the cursor is drawn or claimed, so each search resumes there.
-        private VisibleTile nextMissing(Set<TileKey> inFlight, boolean advance) {
-            for (int index = nextCandidate; index < tiles.size(); index++) {
-                VisibleTile tile = tiles.get(index);
-                if (tile.tile() == null && !inFlight.contains(tile.key())) {
-                    if (advance) {
-                        nextCandidate = index + 1;
-                    }
-                    return tile;
-                }
-            }
-            if (advance) {
-                nextCandidate = tiles.size();
-            }
-            return null;
-        }
-    }
-
-    static final class VisibleTile {
-        private final TileKey key;
-        private final double distanceSquared;
-        private volatile MapTile tile;
-
-        private VisibleTile(TileKey key, double distanceSquared) {
-            this.key = key;
-            this.distanceSquared = distanceSquared;
-        }
-
-        TileKey key() {
-            return key;
-        }
-
-        long tileX() {
-            return key.tileX();
-        }
-
-        long tileZ() {
-            return key.tileZ();
-        }
-
-        double distanceSquared() {
-            return distanceSquared;
-        }
-
-        MapTile tile() {
-            return tile;
-        }
-
-        private void setTile(MapTile tile) {
-            this.tile = tile;
-        }
-    }
-
-    /**
-     * @param heights whether the tile also carries terrain heights, for shading
-     */
-    record TileKey(long contentRevision, RenderType type, boolean heights, double blocksPerPixel, long tileX, long tileZ) {
-        TileKey {
-            Objects.requireNonNull(type, "type");
-            if (!Double.isFinite(blocksPerPixel) || blocksPerPixel <= 0D) {
-                throw new IllegalArgumentException("Vision cache scale must be finite and positive");
-            }
-        }
-
-        TileKey withHeights(boolean nextHeights) {
-            return new TileKey(contentRevision, type, nextHeights, blocksPerPixel, tileX, tileZ);
-        }
-    }
-
-    record TilePixel(MapTile tile, int pixelX, int pixelZ) {
-        MapLabels.Label subject() {
-            return tile.labels().label(tile.subjectAt(pixelX, pixelZ));
-        }
-
-        MapLabels.Label region() {
-            return tile.labels().label(tile.regionAt(pixelX, pixelZ));
-        }
-    }
-
-    /**
-     * Pieces of cached tiles that together cover a missing tile; offsets and size are fractions of the tile.
-     */
-    record Fallback(List<FallbackPiece> pieces) {
-    }
-
-    record FallbackPiece(MapTile tile, int sourceX, int sourceZ, int sourceSize, double offsetX, double offsetZ,
-                         double size) {
-    }
-
-    record Progress(int total, int ready, int activeWorkers) {
-        double completion() {
-            if (total == 0) {
-                return 1D;
-            }
-            return Math.min(1D, ready / (double) total);
-        }
-    }
-
-    private record TileJob(IrisRenderer renderer, TileKey key) {
-    }
-
-    private static final class WeightedTileCache {
-        private final long maximumBytes;
-        private final LinkedHashMap<TileKey, CacheEntry> entries;
-        private long bytes;
-
-        private WeightedTileCache(long maximumBytes) {
-            this.maximumBytes = maximumBytes;
-            this.entries = new LinkedHashMap<>(128, 0.75F, true);
-        }
-
-        synchronized MapTile get(TileKey key) {
-            CacheEntry entry = entries.get(key);
-            return entry == null ? null : entry.tile();
-        }
-
-        synchronized void put(TileKey key, MapTile tile) {
-            long tileBytes = tile.bytes();
-            CacheEntry previous = entries.put(key, new CacheEntry(tile, tileBytes));
-            if (previous != null) {
-                bytes -= previous.bytes();
-            }
-            bytes += tileBytes;
-            while (bytes > maximumBytes && !entries.isEmpty()) {
-                Iterator<Map.Entry<TileKey, CacheEntry>> iterator = entries.entrySet().iterator();
-                Map.Entry<TileKey, CacheEntry> eldest = iterator.next();
-                bytes -= eldest.getValue().bytes();
-                iterator.remove();
-            }
-        }
-
-        synchronized void clear() {
-            entries.clear();
-            bytes = 0L;
-        }
-    }
-
-    private record CacheEntry(MapTile tile, long bytes) {
-    }
-}
@@ -1,60 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-record VisionViewport(double centerX, double centerZ, double blocksPerPixel) {
-    VisionViewport {
-        if (!Double.isFinite(centerX) || !Double.isFinite(centerZ)) {
-            throw new IllegalArgumentException("Vision viewport center must be finite");
-        }
-        if (!Double.isFinite(blocksPerPixel) || blocksPerPixel <= 0D) {
-            throw new IllegalArgumentException("Vision viewport scale must be finite and positive");
-        }
-    }
-
-    double worldX(double screenX, int width) {
-        return centerX + (screenX - width * 0.5D) * blocksPerPixel;
-    }
-
-    double worldZ(double screenZ, int height) {
-        return centerZ + (screenZ - height * 0.5D) * blocksPerPixel;
-    }
-
-    VisionViewport zoomAt(
-            double screenX,
-            double screenZ,
-            int width,
-            int height,
-            double factor,
-            double minimumScale,
-            double maximumScale
-    ) {
-        if (!Double.isFinite(factor) || factor <= 0D) {
-            throw new IllegalArgumentException("Vision zoom factor must be finite and positive");
-        }
-        double anchorX = worldX(screenX, width);
-        double anchorZ = worldZ(screenZ, height);
-        double nextScale = Math.max(minimumScale, Math.min(maximumScale, blocksPerPixel * factor));
-        return new VisionViewport(
-                anchorX - (screenX - width * 0.5D) * nextScale,
-                anchorZ - (screenZ - height * 0.5D) * nextScale,
-                nextScale
-        );
-    }
-}
@@ -1,86 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.sun.jna.platform.linux.LibC;
-import com.volmit.iris.Iris;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-/**
- * Java does not recognise the non-reparenting Xwayland window managers of compositors such as niri, sway and Hyprland.
- * It waits for a reparent that never comes and paints only a corner of each window. Java reads this hint from the
- * native environment once, at the first decorated window, so it is set through libc before Iris opens any window.
- */
-final class XwaylandWindowManagerHint {
-    private static final String NON_REPARENTING_VARIABLE = "_JAVA_AWT_WM_NONREPARENTING";
-    private static final int KEEP_EXISTING_VALUE = 0;
-    private static final List<String> REPARENTING_DESKTOPS = List.of("GNOME", "KDE");
-    private static final AtomicBoolean APPLIED = new AtomicBoolean();
-
-    private XwaylandWindowManagerHint() {
-    }
-
-    static void apply() {
-        if (!APPLIED.compareAndSet(false, true) || !isNeeded(System.getenv(), System.getProperty("os.name", ""))) {
-            return;
-        }
-
-        try {
-            if (LibC.INSTANCE.setenv(NON_REPARENTING_VARIABLE, "1", KEEP_EXISTING_VALUE) != 0) {
-                warnUnapplied();
-            }
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            warnUnapplied();
-        }
-    }
-
-    static boolean isNeeded(Map<String, String> environment, String osName) {
-        return osName.toLowerCase(Locale.ROOT).contains("linux")
-                && isSet(environment, "WAYLAND_DISPLAY")
-                && isSet(environment, "DISPLAY")
-                && !isSet(environment, NON_REPARENTING_VARIABLE)
-                && !isReparentingDesktop(environment.get("XDG_CURRENT_DESKTOP"));
-    }
-
-    private static boolean isReparentingDesktop(String currentDesktop) {
-        if (currentDesktop == null) {
-            return false;
-        }
-
-        return Arrays.stream(currentDesktop.split(":"))
-                .map(desktop -> desktop.trim().toUpperCase(Locale.ROOT))
-                .anyMatch(REPARENTING_DESKTOPS::contains);
-    }
-
-    private static boolean isSet(Map<String, String> environment, String variable) {
-        String value = environment.get(variable);
-        return value != null && !value.isBlank();
-    }
-
-    private static void warnUnapplied() {
-        Iris.warn("Iris could not adjust Java for this Wayland desktop, so its windows may stay blank. "
-                + "Start the server with %s=1 set to fix that.", NON_REPARENTING_VARIABLE);
-    }
-}
@@ -1,474 +1,85 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui.components;
-
-import com.volmit.iris.engine.IrisComplex;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisBiomeGeneratorLink;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.object.IrisRegion;
-import com.volmit.iris.util.stream.ProceduralStream;
-
-import java.awt.Color;
-import java.util.Arrays;
-import java.util.IdentityHashMap;
-import java.util.List;
-import java.util.Objects;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.function.BooleanSupplier;
-
-/**
- * Draws map tiles for one generation of the pack: a hotload needs a new renderer, which also starts new labels.
- */
-public final class IrisRenderer {
-    private static final int BLUE = rgb(45, 91, 156);
-    private static final int YELLOW = rgb(211, 164, 67);
-    private static final int GREEN = rgb(78, 137, 83);
-    private static final int DEEP_WATER = rgb(20, 48, 92);
-    private static final int SHALLOW_WATER = rgb(50, 112, 154);
-    private static final int LOWLAND = rgb(78, 128, 76);
-    private static final int HIGHLAND = rgb(151, 139, 92);
-    private static final int ROCK = rgb(126, 119, 112);
-    private static final int SNOW = rgb(226, 230, 232);
-    private static final int UNKNOWN_SUBJECT = rgb(90, 92, 98);
-    private static final int LARGEST_SAMPLE_BLOCK_PIXELS = 16;
-    private static final double LARGEST_SAMPLE_BLOCK_BLOCKS = 64D;
-    private static final double DEFAULT_DEPTH_BELOW_SEA_BLOCKS = 48D;
-    private static final double DEFAULT_HEIGHT_ABOVE_SEA_BLOCKS = 160D;
-
-    private final Engine engine;
-    private final MapLabels labels = new MapLabels();
-    private final ConcurrentHashMap<LabelColorKey, Integer> labelColors = new ConcurrentHashMap<>();
-
-    public IrisRenderer(Engine engine) {
-        this.engine = Objects.requireNonNull(engine, "engine");
-    }
-
-    public MapLabels labels() {
-        return labels;
-    }
-
-    /**
-     * Renders the square of {@code size} pixels whose top left pixel samples the given world position.
-     *
-     * @param withHeights also sample terrain heights for shading; the height view always has them
-     */
-    public MapTile renderTile(
-            double startX,
-            double startZ,
-            double blocksPerPixel,
-            int size,
-            RenderType type,
-            boolean withHeights,
-            BooleanSupplier cancelled
-    ) {
-        if (!Double.isFinite(startX) || !Double.isFinite(startZ) || !Double.isFinite(blocksPerPixel) || blocksPerPixel <= 0D) {
-            throw new IllegalArgumentException("Map tile coordinates and scale must be finite");
-        }
-        if (size < 1) {
-            throw new IllegalArgumentException("Map tile size must be positive");
-        }
-        Objects.requireNonNull(type, "type");
-        Objects.requireNonNull(cancelled, "cancelled");
-        checkCancelled(cancelled);
-
-        TileGrid grid = new TileGrid(size + 2, startX - blocksPerPixel, startZ - blocksPerPixel, blocksPerPixel, cancelled);
-        int[] identities = sampleIdentities(grid, type);
-        double[] heights = withHeights || type == RenderType.HEIGHT ? sampleHeights(grid) : null;
-        short[] subjects = new short[identities.length];
-        short[] regions = new short[identities.length];
-        for (int index = 0; index < identities.length; index++) {
-            subjects[index] = subjectOf(identities[index]);
-            regions[index] = regionOf(identities[index]);
-        }
-        int[] colors = type == RenderType.HEIGHT ? null : tileColors(size, type, subjects);
-        MapLabels.Kind subjectKind = type == RenderType.REGION ? MapLabels.Kind.REGION : MapLabels.Kind.BIOME;
-        return new MapTile(size, blocksPerPixel, labels, subjectKind, colors, defaultHeightRange(), subjects, regions, heights);
-    }
-
-    /**
-     * The colour a biome or region has on the map in the given view, for legends.
-     */
-    public int legendColor(MapLabels.Label label, RenderType type) {
-        RenderType colorType = type == RenderType.HEIGHT ? RenderType.BIOME : type;
-        return labelColor(label.id(), colorType);
-    }
-
-    /**
-     * Until the map has measured the heights on screen, land colours cover the band most terrain sits in.
-     */
-    public MapStyle.HeightRange defaultHeightRange() {
-        double seaLevel = fluidHeight();
-        return new MapStyle.HeightRange(Math.max(0D, seaLevel - DEFAULT_DEPTH_BELOW_SEA_BLOCKS), seaLevel,
-                Math.min(engine.getHeight(), seaLevel + DEFAULT_HEIGHT_ABOVE_SEA_BLOCKS));
-    }
-
-    public static int heightColor(double height, MapStyle.HeightRange range) {
-        double seaLevel = range.seaLevel();
-        if (height <= seaLevel) {
-            double waterDepthRange = Math.max(1D, seaLevel - range.lowest());
-            return blend(DEEP_WATER, SHALLOW_WATER, (height - range.lowest()) / waterDepthRange);
-        }
-
-        double landRange = Math.max(1D, range.highest() - seaLevel);
-        double land = clamp((height - seaLevel) / landRange, 0D, 1D);
-        if (land < 0.45D) {
-            return blend(LOWLAND, HIGHLAND, land / 0.45D);
-        }
-        if (land < 0.78D) {
-            return blend(HIGHLAND, ROCK, (land - 0.45D) / 0.33D);
-        }
-        return blend(ROCK, SNOW, (land - 0.78D) / 0.22D);
-    }
-
-    private int[] sampleIdentities(TileGrid grid, RenderType type) {
-        IdentitySampler sampler = new IdentitySampler(grid, identityShader(type));
-        sampler.renderAll(sampleBlockPixels(grid.step()));
-        return sampler.identities;
-    }
-
-    private double[] sampleHeights(TileGrid grid) {
-        return new HeightLattice(grid, engine.getComplex().getHeightStream()).interpolatedHeights();
-    }
-
-    // Large uniform squares are filled after a few samples; squares stay small enough to not skip tiny biomes.
-    private static int sampleBlockPixels(double blocksPerPixel) {
-        int largestPixels = (int) Math.floor(LARGEST_SAMPLE_BLOCK_BLOCKS / blocksPerPixel);
-        return Integer.highestOneBit(Math.max(1, Math.min(LARGEST_SAMPLE_BLOCK_PIXELS, largestPixels)));
-    }
-
-    private IdentityShader identityShader(RenderType type) {
-        IrisComplex complex = engine.getComplex();
-        ProceduralStream<IrisRegion> regionStream = complex.getRegionStream();
-        LabelLookup lookup = new LabelLookup(labels);
-        if (type == RenderType.REGION) {
-            return (double x, double z) -> {
-                short region = lookup.idOf(regionStream.get(x, z));
-                return identity(region, region);
-            };
-        }
-        ProceduralStream<IrisBiome> biomeStream = subjectBiomeStream(complex, type);
-        return (double x, double z) -> identity(lookup.idOf(biomeStream.get(x, z)), lookup.idOf(regionStream.get(x, z)));
-    }
-
-    private static ProceduralStream<IrisBiome> subjectBiomeStream(IrisComplex complex, RenderType type) {
-        return switch (type) {
-            case BIOME_LAND -> complex.getLandBiomeStream();
-            case BIOME_SEA -> complex.getSeaBiomeStream();
-            case CAVE_LAND -> complex.getCaveBiomeStream();
-            case BIOME, HEIGHT, CONTINENT, REGION -> complex.getBaseBiomeStream();
-        };
-    }
-
-    private int[] tileColors(int size, RenderType type, short[] subjects) {
-        int[] colors = new int[size * size];
-        short previousSubject = MapLabels.NONE;
-        int previousColor = UNKNOWN_SUBJECT;
-        for (int pixelZ = 0; pixelZ < size; pixelZ++) {
-            for (int pixelX = 0; pixelX < size; pixelX++) {
-                int gridIndex = (pixelZ + 1) * (size + 2) + pixelX + 1;
-                short subject = subjects[gridIndex];
-                if (subject != previousSubject) {
-                    previousSubject = subject;
-                    previousColor = labelColor(subject, type);
-                }
-                colors[pixelZ * size + pixelX] = previousColor;
-            }
-        }
-        return colors;
-    }
-
-    private double fluidHeight() {
-        IrisDimension dimension = engine.getDimension();
-        return dimension == null ? 0D : dimension.getFluidHeight();
-    }
-
-    private int labelColor(short id, RenderType type) {
-        MapLabels.Label label = labels.label(id);
-        if (label == null) {
-            return UNKNOWN_SUBJECT;
-        }
-        return labelColors.computeIfAbsent(new LabelColorKey(type, id), key -> subjectColor(label.subject(), type));
-    }
-
-    private int subjectColor(Object subject, RenderType type) {
-        if (type == RenderType.CONTINENT && subject instanceof IrisBiome biome) {
-            return continentColor(biome);
-        }
-        if (subject instanceof IrisRegion region) {
-            return region.getColor(engine.getComplex(), type).getRGB() & 0xFFFFFF;
-        }
-        if (subject instanceof IrisBiome biome) {
-            return biome.getColor(engine, type).getRGB() & 0xFFFFFF;
-        }
-        return UNKNOWN_SUBJECT;
-    }
-
-    private static int continentColor(IrisBiome biome) {
-        List<IrisBiomeGeneratorLink> generators = biome.getGenerators();
-        if (generators.isEmpty()) {
-            return GREEN;
-        }
-        IrisBiomeGeneratorLink generator = generators.get(0);
-        if (generator.getMax() <= 0D) {
-            return BLUE;
-        }
-        if (generator.getMin() < 0D) {
-            return YELLOW;
-        }
-        return GREEN;
-    }
-
-    private static int identity(short subject, short region) {
-        return (subject << 16) | (region & 0xFFFF);
-    }
-
-    private static short subjectOf(int identity) {
-        return (short) (identity >> 16);
-    }
-
-    private static short regionOf(int identity) {
-        return (short) identity;
-    }
-
-    private static int rgb(int red, int green, int blue) {
-        return new Color(red, green, blue).getRGB() & 0xFFFFFF;
-    }
-
-    private static int blend(int first, int second, double progress) {
-        double bounded = clamp(progress, 0D, 1D);
-        int red = (int) Math.round(((first >> 16) & 0xFF) * (1D - bounded) + ((second >> 16) & 0xFF) * bounded);
-        int green = (int) Math.round(((first >> 8) & 0xFF) * (1D - bounded) + ((second >> 8) & 0xFF) * bounded);
-        int blue = (int) Math.round((first & 0xFF) * (1D - bounded) + (second & 0xFF) * bounded);
-        return (red << 16) | (green << 8) | blue;
-    }
-
-    private static double clamp(double value, double minimum, double maximum) {
-        return Math.max(minimum, Math.min(maximum, value));
-    }
-
-    private static void checkCancelled(BooleanSupplier cancelled) {
-        if (cancelled.getAsBoolean() || Thread.currentThread().isInterrupted()) {
-            throw new CancellationException("Map tile render cancelled");
-        }
-    }
-
-    @FunctionalInterface
-    private interface IdentityShader {
-        int identity(double x, double z);
-    }
-
-    private record LabelColorKey(RenderType type, short id) {
-    }
-
-    /**
-     * The square of world positions one tile samples, including the one pixel ring borrowed from its neighbours.
-     */
-    private record TileGrid(int size, double startX, double startZ, double step, BooleanSupplier cancelled) {
-        double worldX(int gridX) {
-            return startX + gridX * step;
-        }
-
-        double worldZ(int gridZ) {
-            return startZ + gridZ * step;
-        }
-    }
-
-    /**
-     * Labels the biomes and regions one tile meets, asking the shared labels only for ones this tile has not seen yet.
-     */
-    private static final class LabelLookup {
-        private final MapLabels labels;
-        private final IdentityHashMap<Object, Short> seen = new IdentityHashMap<>();
-
-        private LabelLookup(MapLabels labels) {
-            this.labels = labels;
-        }
-
-        short idOf(IrisBiome biome) {
-            if (biome == null) {
-                return MapLabels.NONE;
-            }
-            return seen.computeIfAbsent(biome, subject -> labels.idOf(biome));
-        }
-
-        short idOf(IrisRegion region) {
-            if (region == null) {
-                return MapLabels.NONE;
-            }
-            return seen.computeIfAbsent(region, subject -> labels.idOf(region));
-        }
-    }
-
-    /**
-     * Samples the biome and region of every grid cell in squares, filling a square without sampling its inside when
-     * its corners and centre agree, and splitting it into quarters otherwise.
-     */
-    private static final class IdentitySampler {
-        private final TileGrid grid;
-        private final IdentityShader shader;
-        private final int[] identities;
-        private final boolean[] sampled;
-
-        private IdentitySampler(TileGrid grid, IdentityShader shader) {
-            this.grid = grid;
-            this.shader = shader;
-            this.identities = new int[grid.size() * grid.size()];
-            this.sampled = new boolean[identities.length];
-        }
-
-        void renderAll(int blockPixels) {
-            int size = grid.size();
-            for (int gridZ = 0; gridZ < size; gridZ += blockPixels) {
-                int height = Math.min(blockPixels, size - gridZ);
-                for (int gridX = 0; gridX < size; gridX += blockPixels) {
-                    render(gridX, gridZ, Math.min(blockPixels, size - gridX), height);
-                }
-            }
-        }
-
-        private void render(int gridX, int gridZ, int width, int height) {
-            checkCancelled(grid.cancelled());
-            if (width == 1 && height == 1) {
-                sample(gridX, gridZ);
-                return;
-            }
-            if (fillIfUniform(gridX, gridZ, width, height)) {
-                return;
-            }
-            int leftWidth = Math.max(1, width / 2);
-            int rightWidth = width - leftWidth;
-            int topHeight = Math.max(1, height / 2);
-            int bottomHeight = height - topHeight;
-            render(gridX, gridZ, leftWidth, topHeight);
-            if (rightWidth > 0) {
-                render(gridX + leftWidth, gridZ, rightWidth, topHeight);
-            }
-            if (bottomHeight > 0) {
-                render(gridX, gridZ + topHeight, leftWidth, bottomHeight);
-                if (rightWidth > 0) {
-                    render(gridX + leftWidth, gridZ + topHeight, rightWidth, bottomHeight);
-                }
-            }
-        }
-
-        private boolean fillIfUniform(int gridX, int gridZ, int width, int height) {
-            int maximumX = gridX + width - 1;
-            int maximumZ = gridZ + height - 1;
-            int identity = sample(gridX, gridZ);
-            boolean uniform = sample(maximumX, gridZ) == identity
-                    && sample(gridX, maximumZ) == identity
-                    && sample(maximumX, maximumZ) == identity
-                    && sample(gridX + width / 2, gridZ + height / 2) == identity;
-            if (!uniform) {
-                return false;
-            }
-            for (int row = gridZ; row <= maximumZ; row++) {
-                int start = row * grid.size() + gridX;
-                Arrays.fill(identities, start, start + width, identity);
-                Arrays.fill(sampled, start, start + width, true);
-            }
-            return true;
-        }
-
-        private int sample(int gridX, int gridZ) {
-            int index = gridZ * grid.size() + gridX;
-            if (!sampled[index]) {
-                identities[index] = shader.identity(grid.worldX(gridX), grid.worldZ(gridZ));
-                sampled[index] = true;
-            }
-            return identities[index];
-        }
-    }
-
-    /**
-     * Terrain heights from samples on a coarse lattice, smoothly interpolated in between. Iris heights are costly to
-     * sample, and shading turns the steps of cheaper shortcuts into visible creases, so a smooth curve through fewer
-     * exact samples looks better and draws an order of magnitude faster than sampling every pixel. The lattice lines
-     * up across tiles, so slopes continue seamlessly from one tile into the next.
-     */
-    private static final class HeightLattice {
-        private static final int LATTICE_PIXELS = 4;
-        private static final int LATTICE_MARGIN = 2;
-
-        private final TileGrid grid;
-        private final ProceduralStream<Double> stream;
-        private final int pointsPerSide;
-        private final double[] points;
-
-        private HeightLattice(TileGrid grid, ProceduralStream<Double> stream) {
-            this.grid = grid;
-            this.stream = stream;
-            this.pointsPerSide = (grid.size() - 2) / LATTICE_PIXELS + LATTICE_MARGIN * 2 + 1;
-            this.points = new double[pointsPerSide * pointsPerSide];
-        }
-
-        double[] interpolatedHeights() {
-            samplePoints();
-            int size = grid.size();
-            double[] heights = new double[size * size];
-            for (int gridZ = 0; gridZ < size; gridZ++) {
-                for (int gridX = 0; gridX < size; gridX++) {
-                    heights[gridZ * size + gridX] = heightAt(gridX - 1, gridZ - 1);
-                }
-            }
-            return heights;
-        }
-
-        // Lattice point 0 sits on the tile's first pixel; the margin covers the border ring and the curve's reach.
-        private void samplePoints() {
-            double latticeStep = grid.step() * LATTICE_PIXELS;
-            double firstX = grid.worldX(1) - LATTICE_MARGIN * latticeStep;
-            double firstZ = grid.worldZ(1) - LATTICE_MARGIN * latticeStep;
-            for (int pointZ = 0; pointZ < pointsPerSide; pointZ++) {
-                checkCancelled(grid.cancelled());
-                for (int pointX = 0; pointX < pointsPerSide; pointX++) {
-                    points[pointZ * pointsPerSide + pointX] = stream.getDouble(firstX + pointX * latticeStep,
-                            firstZ + pointZ * latticeStep);
-                }
-            }
-        }
-
-        private double heightAt(int pixelX, int pixelZ) {
-            int cellX = Math.floorDiv(pixelX, LATTICE_PIXELS);
-            int cellZ = Math.floorDiv(pixelZ, LATTICE_PIXELS);
-            double fractionX = (pixelX - cellX * LATTICE_PIXELS) / (double) LATTICE_PIXELS;
-            double fractionZ = (pixelZ - cellZ * LATTICE_PIXELS) / (double) LATTICE_PIXELS;
-            int baseX = cellX + LATTICE_MARGIN;
-            int baseZ = cellZ + LATTICE_MARGIN;
-            double[] rows = new double[4];
-            for (int row = 0; row < 4; row++) {
-                int offset = (baseZ - 1 + row) * pointsPerSide + baseX - 1;
-                rows[row] = catmullRom(points[offset], points[offset + 1], points[offset + 2], points[offset + 3], fractionX);
-            }
-            return catmullRom(rows[0], rows[1], rows[2], rows[3], fractionZ);
-        }
-
-        private static double catmullRom(double before, double start, double end, double after, double fraction) {
-            double squared = fraction * fraction;
-            double cubed = squared * fraction;
-            return 0.5D * (2D * start
-                    + (end - before) * fraction
-                    + (2D * before - 5D * start + 4D * end - after) * squared
-                    + (3D * start - before - 3D * end + after) * cubed);
-        }
-    }
-}
+/*
+ *  Iris is a World Generator for Minecraft Bukkit Servers
+ *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.gui.components;
+
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.engine.object.IrisBiomeGeneratorLink;
+import com.volmit.iris.util.interpolation.IrisInterpolation;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.util.function.BiFunction;
+
+public class IrisRenderer {
+    private final Engine renderer;
+
+    public IrisRenderer(Engine renderer) {
+        this.renderer = renderer;
+    }
+
+    public BufferedImage render(double sx, double sz, double size, int resolution, RenderType currentType) {
+        BufferedImage image = new BufferedImage(resolution, resolution, BufferedImage.TYPE_INT_RGB);
+        BiFunction<Double, Double, Integer> colorFunction = (d, dx) -> Color.black.getRGB();
+
+        switch (currentType) {
+            case BIOME, DECORATOR_LOAD, OBJECT_LOAD, LAYER_LOAD ->
+                    colorFunction = (x, z) -> renderer.getComplex().getTrueBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
+            case BIOME_LAND ->
+                    colorFunction = (x, z) -> renderer.getComplex().getLandBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
+            case BIOME_SEA ->
+                    colorFunction = (x, z) -> renderer.getComplex().getSeaBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
+            case REGION ->
+                    colorFunction = (x, z) -> renderer.getComplex().getRegionStream().get(x, z).getColor(renderer.getComplex(), currentType).getRGB();
+            case CAVE_LAND ->
+                    colorFunction = (x, z) -> renderer.getComplex().getCaveBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
+            case HEIGHT ->
+                    colorFunction = (x, z) -> Color.getHSBColor(renderer.getComplex().getHeightStream().get(x, z).floatValue(), 100, 100).getRGB();
+            case CONTINENT -> colorFunction = (x, z) -> {
+                IrisBiome b = renderer.getBiome((int) Math.round(x), renderer.getMaxHeight() - 1, (int) Math.round(z));
+                IrisBiomeGeneratorLink g = b.getGenerators().get(0);
+                Color c;
+                if (g.getMax(renderer) <= 0) {
+                    // Max is below water level, so it is most likely an ocean biome
+                    c = Color.BLUE;
+                } else if (g.getMin(renderer) < 0) {
+                    // Min is below water level, but max is not, so it is most likely a shore biome
+                    c = Color.YELLOW;
+                } else {
+                    // Both min and max are above water level, so it is most likely a land biome
+                    c = Color.GREEN;
+                }
+                return c.getRGB();
+            };
+        }
+
+        double x, z;
+        int i, j;
+        for (i = 0; i < resolution; i++) {
+            x = IrisInterpolation.lerp(sx, sx + size, (double) i / (double) (resolution));
+
+            for (j = 0; j < resolution; j++) {
+                z = IrisInterpolation.lerp(sz, sz + size, (double) j / (double) (resolution));
+                image.setRGB(i, j, colorFunction.apply(x, z));
+            }
+        }
+
+        return image;
+    }
+}
@@ -1,80 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui.components;
-
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisRegion;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.IdentityHashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Numbers every biome and region the map has drawn, so a tile can remember what each of its pixels shows in two bytes.
- * One set of labels belongs to one generation of the pack: a hotload starts a new one.
- */
-public final class MapLabels {
-    public static final short NONE = -1;
-
-    private final IdentityHashMap<Object, Short> idsBySubject = new IdentityHashMap<>();
-    private final Map<String, Short> idsByKey = new HashMap<>();
-    private final List<Label> labels = new ArrayList<>();
-
-    synchronized short idOf(IrisBiome biome) {
-        return idOf(biome, Kind.BIOME, biome.getLoadKey(), biome.getName());
-    }
-
-    synchronized short idOf(IrisRegion region) {
-        return idOf(region, Kind.REGION, region.getLoadKey(), region.getName());
-    }
-
-    public synchronized Label label(short id) {
-        return id < 0 || id >= labels.size() ? null : labels.get(id);
-    }
-
-    public synchronized short idOf(Kind kind, String key) {
-        Short id = idsByKey.get(kind.name() + ':' + key);
-        return id == null ? NONE : id;
-    }
-
-    private short idOf(Object subject, Kind kind, String key, String name) {
-        Short existing = idsBySubject.get(subject);
-        if (existing != null) {
-            return existing;
-        }
-        if (labels.size() >= Short.MAX_VALUE) {
-            return NONE;
-        }
-        short id = (short) labels.size();
-        labels.add(new Label(id, kind, key, name, subject));
-        idsBySubject.put(subject, id);
-        idsByKey.putIfAbsent(kind.name() + ':' + key, id);
-        return id;
-    }
-
-    public enum Kind {
-        BIOME,
-        REGION
-    }
-
-    public record Label(short id, Kind kind, String key, String name, Object subject) {
-    }
-}
@@ -1,54 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.gui.components;
-
-/**
- * How map tiles are drawn on top of their plain colours: terrain shading, region borders and one highlighted biome or region.
- *
- * @param highlight the biome or region to keep bright while everything else dims, or null to show all
- * @param heightRange the heights the height view spreads its colours over, or null outside the height view
- */
-public record MapStyle(boolean shading, boolean regionBorders, Highlight highlight, HeightRange heightRange) {
-    public static final MapStyle PLAIN = new MapStyle(false, false, null, null);
-
-    public MapStyle withShading(boolean nextShading) {
-        return new MapStyle(nextShading, regionBorders, highlight, heightRange);
-    }
-
-    public MapStyle withRegionBorders(boolean nextRegionBorders) {
-        return new MapStyle(shading, nextRegionBorders, highlight, heightRange);
-    }
-
-    public MapStyle withHighlight(Highlight nextHighlight) {
-        return new MapStyle(shading, regionBorders, nextHighlight, heightRange);
-    }
-
-    public MapStyle withHeightRange(HeightRange nextHeightRange) {
-        return new MapStyle(shading, regionBorders, highlight, nextHeightRange);
-    }
-
-    public record Highlight(MapLabels.Kind kind, String key, String name) {
-    }
-
-    /**
-     * Water colours run from the lowest height up to sea level, land colours from sea level up to the highest.
-     */
-    public record HeightRange(double lowest, double seaLevel, double highest) {
-    }
-}
Author	SHA1	Message	Date
Brian Neumann-Fopiano	d9c7f35709	Revert "Update LICENSE.md" This reverts commit `37893460f3`.	2024-09-24 14:57:45 -04:00
Brian Fopiano	37893460f3	Update LICENSE.md	2024-09-09 16:59:14 -04:00
RePixelatedMC	898f815878	sync	2024-09-08 18:51:27 +02:00
RePixelatedMC	49ee36b089	renames!	2024-09-08 18:08:16 +02:00
RePixelatedMC	073be82dcc	Sync!	2024-09-08 17:56:32 +02:00
RePixelatedMC	713c3a4762	Merge remote-tracking branch 'origin/iris4' into iris4	2024-09-08 17:45:44 +02:00
Julian Krings	b736377aec	woops	2024-09-08 15:01:37 +02:00
Julian Krings	62fff7a56e	take server size into account when picking a server	2024-09-08 13:41:08 +02:00
RePixelatedMC	5efb71eb3e	Merge remote-tracking branch 'origin/iris4' into iris4	2024-09-07 12:54:12 +02:00
Julian Krings	d22f49492f	implement done packet into master and add safety checks for remote server version	2024-09-07 12:32:09 +02:00
Julian Krings	b65b112220	Merge branch 'refs/heads/v3.4.3' into iris4 # Conflicts: # build.gradle # core/src/main/java/com/volmit/iris/core/commands/CommandDeveloper.java # core/src/main/java/com/volmit/iris/core/pregenerator/methods/AsyncPregenMethod.java # core/src/main/java/com/volmit/iris/core/service/WandSVC.java # core/src/main/java/com/volmit/iris/core/tools/IrisConverter.java # core/src/main/java/com/volmit/iris/engine/framework/Engine.java	2024-09-06 23:32:21 +02:00
Julian Krings	c5456aa65c	Merge remote-tracking branch 'origin/iris4' into iris4	2024-09-06 23:21:30 +02:00
Julian Krings	0a256eaa4c	remote/cloud pregen!	2024-09-06 23:21:08 +02:00
RePixelatedMC	7d07ee4eb2	Merge remote-tracking branch 'origin/iris4' into iris4	2024-09-06 15:24:28 +02:00
Julian Krings	c98ed48ee2	reconnect players on dimension type registry change	2024-09-06 14:58:09 +02:00
RePixelatedMC	9f392654d3	cleaner	2024-09-06 14:35:42 +02:00
RePixelatedMC	613575c0c5	e	2024-08-29 22:02:23 +02:00
RePixelatedMC	b414b01ac4	Headless pregen!	2024-08-29 21:40:34 +02:00
RePixelatedMC	65dd039b07	ops	2024-08-29 15:57:03 +02:00
RePixelatedMC	747adb53d9	Merge remote-tracking branch 'origin/iris4' into iris4	2024-08-29 15:46:24 +02:00
RePixelatedMC	7125b38fd5	Sync!	2024-08-29 15:46:16 +02:00
Julian Krings	82f71198e6	add saving headless regions after x seconds	2024-08-23 23:13:23 +02:00
Julian Krings	b1e87afc93	more headless speed	2024-08-23 15:05:45 +02:00
RePixelatedMC	3bffe4cc7e	- Removed VanillaHeight. - Removed useless code - okey I really need to sync now	2024-08-23 13:19:29 +02:00
Julian Krings	08ab82216d	improve headless speed	2024-08-23 12:34:43 +02:00
Julian Krings	c3ed7080dc	improve headless chunk saving	2024-08-23 12:33:51 +02:00
RePixelatedMC	ea8fb1bf86	- Iris doesnt kill engines on shutdown anymore!	2024-08-23 12:02:17 +02:00
Julian Krings	4434cf6475	add headless pregen to world creation	2024-08-22 20:31:24 +02:00
RePixelatedMC	26aae2b730	em	2024-08-22 20:24:59 +02:00
RePixelatedMC	e5c818cf7b	save	2024-08-22 20:23:58 +02:00
RePixelatedMC	6b4575e75d	Merge remote-tracking branch 'origin/iris4' into iris4	2024-08-22 17:16:54 +02:00
RePixelatedMC	773be08b24	SYNc	2024-08-22 17:16:46 +02:00
Julian Krings	386131ddf0	wait for all loaded chunks to be saved	2024-08-22 16:20:16 +02:00
RePixelatedMC	3dfdb9654a	Sync! x2	2024-08-22 16:14:58 +02:00
RePixelatedMC	805523d069	Sync!	2024-08-22 16:07:02 +02:00
repixelatedmc	6cfa593eee	em	2024-08-22 10:42:45 +02:00
repixelatedmc	00c2a5245a	Bit more performance ig	2024-08-20 19:23:12 +02:00
repixelatedmc	f6791b786e	Merge remote-tracking branch 'origin/iris4' into iris4	2024-08-20 19:22:48 +02:00
repixelatedmc	0fa9654824	20-30% performance increase	2024-08-20 19:22:36 +02:00
Julian Krings	2262e19cd1	fix world creation	2024-08-20 16:25:05 +02:00
repixelatedmc	055ddc7c9b	wops	2024-08-20 13:40:39 +02:00
repixelatedmc	817d7a602b	Fixed biome NMS calculations	2024-08-20 13:36:46 +02:00
Julian Krings	3af4a8f621	implement biome replacements in all bindings	2024-08-19 22:03:30 +02:00
Julian Krings	7b80eb1c06	woops	2024-08-19 20:45:06 +02:00
Julian Krings	19c6f4f2ba	example	2024-08-19 20:43:30 +02:00
repixelatedmc	8a753b42f8	weeee	2024-08-19 20:33:26 +02:00
repixelatedmc	3f66634e5f	Stash!	2024-08-19 19:35:16 +02:00
repixelatedmc	c86815f47b	Every Biome is custom	2024-08-18 21:39:24 +02:00
repixelatedmc	f9d108dbb7	Merge remote-tracking branch 'origin/iris4' into iris4	2024-08-18 17:15:06 +02:00
Julian Krings	302e02ddac	Merge branch 'v3.4.3' into iris4	2024-08-18 17:06:06 +02:00
repixelatedmc	f32f8744b2	Merge remote-tracking branch 'origin/iris4' into iris4	2024-08-18 12:32:03 +02:00
Julian Krings	dd98f6f07e	Merge branch 'v3.4.3' into iris4	2024-08-17 19:06:31 +02:00
Julian Krings	bbf42d1af0	fix headless chunk offset	2024-08-17 15:23:23 +02:00
RePixelatedMC	70aa607e5b	Merge remote-tracking branch 'origin/iris4' into iris4	2024-08-17 14:29:47 +02:00
Julian Krings	09635e12a9	woops	2024-08-17 14:04:30 +02:00
RePixelatedMC	7b283a56ee	commit	2024-08-17 13:55:32 +02:00
Julian Krings	888ba34eee	Merge branch 'v3.4.3' into iris4 # Conflicts: # core/src/main/java/com/volmit/iris/core/nms/INMSBinding.java # core/src/main/java/com/volmit/iris/core/nms/v1X/NMSBinding1X.java # core/src/main/java/com/volmit/iris/core/service/DolphinSVC.java # core/src/main/java/com/volmit/iris/core/service/VillageSVC.java # core/src/main/java/com/volmit/iris/util/mantle/MantleFlag.java # nms/v1_19_R1/src/main/java/com/volmit/iris/core/nms/v1_19_R1/NMSBinding.java # nms/v1_19_R2/src/main/java/com/volmit/iris/core/nms/v1_19_R2/NMSBinding.java # nms/v1_19_R3/src/main/java/com/volmit/iris/core/nms/v1_19_R3/NMSBinding.java # nms/v1_20_R1/src/main/java/com/volmit/iris/core/nms/v1_20_R1/NMSBinding.java # nms/v1_20_R2/src/main/java/com/volmit/iris/core/nms/v1_20_R2/NMSBinding.java # nms/v1_20_R3/src/main/java/com/volmit/iris/core/nms/v1_20_R3/NMSBinding.java # nms/v1_20_R4/src/main/java/com/volmit/iris/core/nms/v1_20_R4/NMSBinding.java # nms/v1_21_R1/src/main/java/com/volmit/iris/core/nms/v1_21_R1/NMSBinding.java	2024-08-17 13:25:48 +02:00
Julian Krings	62e98cc371	Merge branch 'master' into iris4 # Conflicts: # build.gradle # core/src/main/java/com/volmit/iris/core/nms/INMS.java # core/src/main/java/com/volmit/iris/engine/IrisEngine.java	2024-08-17 01:03:17 +02:00
Julian Krings	8fc70f42fc	Merge branch 'v3.4.3' into iris4 # Conflicts: # core/src/main/java/com/volmit/iris/engine/IrisEngine.java	2024-08-17 01:00:36 +02:00
repixelatedmc	13447b882c	No deadlock?	2024-08-16 13:44:44 +02:00
Julian Krings	344c50154a	Merge branch 'v3.4.2' into iris4 # Conflicts: # core/src/main/java/com/volmit/iris/core/nms/INMSBinding.java # core/src/main/java/com/volmit/iris/core/safeguard/ModesSFG.java # core/src/main/java/com/volmit/iris/core/service/WandSVC.java # core/src/main/java/com/volmit/iris/engine/framework/Engine.java # core/src/main/java/com/volmit/iris/engine/object/TileBanner.java # core/src/main/java/com/volmit/iris/engine/object/TileData.java # core/src/main/java/com/volmit/iris/engine/object/TileSign.java # core/src/main/java/com/volmit/iris/engine/object/TileSpawner.java # core/src/main/java/com/volmit/iris/engine/platform/BukkitChunkGenerator.java # core/src/main/java/com/volmit/iris/util/matter/TileWrapper.java # nms/v1_19_R1/src/main/java/com/volmit/iris/core/nms/v1_19_R1/NMSBinding.java # nms/v1_19_R2/src/main/java/com/volmit/iris/core/nms/v1_19_R2/NMSBinding.java # nms/v1_19_R3/src/main/java/com/volmit/iris/core/nms/v1_19_R3/NMSBinding.java # nms/v1_20_R1/src/main/java/com/volmit/iris/core/nms/v1_20_R1/NMSBinding.java # nms/v1_20_R2/src/main/java/com/volmit/iris/core/nms/v1_20_R2/NMSBinding.java # nms/v1_20_R3/src/main/java/com/volmit/iris/core/nms/v1_20_R3/NMSBinding.java # nms/v1_20_R4/src/main/java/com/volmit/iris/core/nms/v1_20_R4/NMSBinding.java # nms/v1_21_R1/src/main/java/com/volmit/iris/core/nms/v1_21_R1/NMSBinding.java	2024-08-14 21:53:13 +02:00
RePixelatedMC	ef93bee0b9	Fixed double hotload and added a tone for hotload,	2024-08-12 22:28:27 +02:00
Brian Fopiano	9de0c5b96f	Merge branch 'master' into iris4	2024-08-09 12:53:09 -04:00
Brian Neumann-Fopiano	a0a7b8cb3e	.	2024-08-07 20:40:56 -04:00
Brian Neumann-Fopiano	ae2600227e	Formatting	2024-08-07 20:08:11 -04:00
Brian Neumann-Fopiano	ec1187923b	Gradle Update	2024-08-07 20:01:32 -04:00
Brian Neumann-Fopiano	ab04a686e9	The Great Copyright Number 3	2024-08-07 19:47:23 -04:00
repixelatedmc	efbfad437a	Decorators wont be placed above sea level when set to sea_floor	2024-08-07 16:03:21 +02:00
repixelatedmc	9bcb1845b8	magic	2024-08-07 15:29:42 +02:00
repixelatedmc	0f5364982d	Merge remote-tracking branch 'origin/iris4' into iris4	2024-08-07 15:01:43 +02:00
repixelatedmc	1b0411e23a	Need help on this one.	2024-08-07 15:00:10 +02:00
Julian Krings	29199dc2d2	woops	2024-08-07 14:57:53 +02:00
Julian Krings	3cb5f612c6	use world name as thread id	2024-08-07 14:56:44 +02:00
Julian Krings	3b98b20f73	implement engine services and other improvements	2024-08-07 13:40:17 +02:00
repixelatedmc	90bab2b292	Reset Region cache option.	2024-08-07 11:46:52 +02:00
repixelatedmc	8ad3cdf820	- Decos dont float anymore - Decos dont go over fluidheight anymore	2024-08-07 11:22:55 +02:00
repixelatedmc	ca8933541a	Merge remote-tracking branch 'origin/iris4' into iris4	2024-08-07 09:19:24 +02:00
Brian Neumann-Fopiano	8572a444fa	Making Logo Changes for V4 This is a simplified image print so my file is not bloated	2024-08-06 19:18:41 -04:00
repixelatedmc	8dd14c80f0	eh	2024-08-05 10:53:10 +02:00
Julian Krings	61410aea97	iris go brrrr	2024-08-04 16:58:36 +02:00
Julian Krings	f892eb599c	build headless biome cache at creation	2024-08-03 20:14:19 +02:00
Julian Krings	86f89bc718	Merge remote-tracking branch 'origin/master' into iris4 # Conflicts: # core/src/main/java/com/volmit/iris/core/nms/INMSBinding.java # nms/v1_20_R4/src/main/java/com/volmit/iris/core/nms/v1_20_R4/NMSBinding.java # nms/v1_21_R1/src/main/java/com/volmit/iris/core/nms/v1_21_R1/NMSBinding.java	2024-08-03 18:50:38 +02:00
Julian Krings	5be19c7c3c	fix nullpointer with headless	2024-08-03 18:43:21 +02:00
RePixelatedMC	9d8be5b382	did nextdoors work	2024-08-03 17:18:24 +02:00
Julian Krings	ab30710e2a	make PackBenchmark startup show errors	2024-08-03 16:56:17 +02:00
Julian Krings	d2ecbc5727	fix datapack dump + change target location	2024-08-03 16:55:39 +02:00
RePixelatedMC	22f9306fa3	eghem	2024-08-03 15:52:24 +02:00
RePixelatedMC	6b4a19a525	Merge remote-tracking branch 'origin/iris4' into iris4	2024-08-03 15:25:55 +02:00
RePixelatedMC	ad8ff2643b	wee	2024-08-03 15:25:23 +02:00
Julian Krings	e6f829db31	Merge remote-tracking branch 'origin/master' into iris4	2024-08-03 13:31:09 +02:00
RePixelatedMC	b429448885	e	2024-08-03 10:11:55 +02:00
RePixelatedMC	f00e037e26	bug fix + better eta	2024-08-03 10:07:03 +02:00
RePixelatedMC	bad3cd27e1	bug fix	2024-08-03 09:09:02 +02:00
RePixelatedMC	cad679a808	Fast pregen	2024-08-02 23:17:52 +02:00
Julian Krings	488b76d1d2	add dummy datapack + fix world creation	2024-08-02 18:14:41 +02:00
RePixelatedMC	1e22a65329	whopsie	2024-08-02 18:09:03 +02:00
RePixelatedMC	1477dc037c	changes i guess	2024-08-02 17:29:39 +02:00
RePixelatedMC	6174ec04ab	changes	2024-08-02 16:31:36 +02:00
RePixelatedMC	1cac86252f	Refactors	2024-08-02 15:05:23 +02:00
RePixelatedMC	773065eb56	Advanced world loading!	2024-08-02 14:59:05 +02:00
RePixelatedMC	a8524e43b9	dev shit	2024-08-01 13:26:13 +02:00
RePixelatedMC	0a62e222ee	No gui errors anymore!	2024-07-30 15:24:26 +02:00
Julian Krings	ec9a000bcf	Merge remote-tracking branch 'origin/master' into iris4	2024-07-30 12:57:34 +02:00
RePixelatedMC	0445b6fe6e	Merge branch 'iris4' of https://github.com/VolmitSoftware/Iris into mca	2024-07-29 20:41:25 +02:00
RePixelatedMC	a0719117ad	Iris wont fail loading the rest of the worlds if 1 fails	2024-07-29 20:40:01 +02:00
RePixelatedMC	7ae846af6f	eghum	2024-07-29 20:16:15 +02:00
RePixelatedMC	fe5bb67973	okey back to normal	2024-07-29 18:51:07 +02:00
Julian Krings	482fa9b11e	add missing methods to 1.21 bindings	2024-07-29 18:29:28 +02:00
Julian Krings	295fe16f8f	Merge remote-tracking branch 'refs/remotes/origin/v1_21' into iris4 # Conflicts: # core/src/main/java/com/volmit/iris/core/commands/CommandDeveloper.java # core/src/main/java/com/volmit/iris/core/nms/v1X/NMSBinding1X.java # nms/v1_19_R1/src/main/java/com/volmit/iris/core/nms/v1_19_R1/NMSBinding.java # nms/v1_19_R2/src/main/java/com/volmit/iris/core/nms/v1_19_R2/NMSBinding.java # nms/v1_19_R3/src/main/java/com/volmit/iris/core/nms/v1_19_R3/NMSBinding.java # nms/v1_20_R1/src/main/java/com/volmit/iris/core/nms/v1_20_R1/NMSBinding.java # nms/v1_20_R2/src/main/java/com/volmit/iris/core/nms/v1_20_R2/NMSBinding.java # nms/v1_20_R3/src/main/java/com/volmit/iris/core/nms/v1_20_R3/NMSBinding.java # nms/v1_20_R4/src/main/java/com/volmit/iris/core/nms/v1_20_R4/NMSBinding.java	2024-07-29 18:11:11 +02:00
RePixelatedMC	c2ab688590	Merge branch 'mca' of https://github.com/RePixelatedMC/Iris into mca	2024-07-29 16:24:42 +02:00
RePixelatedMC	13c61501e6	Merge pull request #27 from CrazyDev05/mca Revert "Revert "Merge branch 'mca' into jigsaw_dist""	2024-07-09 20:43:44 +02:00
Julian Krings	5ad848fc54	Revert "Revert "Merge branch 'mca' into jigsaw_dist"" This reverts commit `55017b9a`	2024-07-09 20:24:21 +02:00
RePixelatedMC	f6cf0682ed	Merge branch 'mca' of https://github.com/RePixelatedMC/Iris into mca	2024-07-06 13:50:31 +02:00
RePixelatedMC	3cb74ac922	Merge branch 'mca' of https://github.com/RePixelatedMC/Iris into mca # Conflicts: # core/src/main/java/com/volmit/iris/core/safeguard/ServerBootSFG.java	2024-06-05 09:53:46 +02:00
RePixelatedMC	dae3de8982	1.20.6 compat	2024-06-05 09:48:27 +02:00