Initial port to 26.1.2

.github/workflows/build.yml

@@ -3,7 +3,7 @@ name: Build
 on: [ workflow_dispatch, pull_request, push ]
 
 env:
-  JAVA_VERSION: 21
+  JAVA_VERSION: 25
 
 jobs:
   build:
@@ -31,7 +31,7 @@ jobs:
       - name: Build
         # Doesn't actually publish, as no secrets are passed in, just makes sure that publishing works
         # Also generate the mod jars for the test job
-        run: ./gradlew remapTestModJar publish --no-daemon
+        run: ./gradlew testModJar publish --no-daemon
 
       - name: Capture Build Artifacts
         uses: actions/upload-artifact@v4
@@ -74,7 +74,7 @@ jobs:
 
       # Lock to a specific commit, it would be bad if the tag is re-pushed with unwanted changes
       - name: Run the MC client
-        uses: 3arthqu4ke/mc-runtime-test@e72f8fe1134aabf6fc749a2a8c09bb56dd7d283e
+        uses: headlesshq/mc-runtime-test@9d9ea4af8ef6d82648051f750c49905f75d0c3bb
         with:
           mc: ${{ env.MINECRAFT_VERSION }}
           modloader: ${{ matrix.loader }}

build.gradle.kts

@@ -1,7 +1,8 @@
 plugins {
     idea
     java
-    id("dev.architectury.loom") apply false
+    alias(libs.plugins.loom) apply false
+    alias(libs.plugins.mdg) apply false
 }
 
 println("Java: ${System.getProperty("java.version")}, JVM: ${System.getProperty("java.vm.version")} (${System.getProperty("java.vendor")}), Arch: ${System.getProperty("os.arch")}")

buildSrc/build.gradle.kts

@@ -1,5 +1,3 @@
-import java.util.Properties
-
 plugins {
     `kotlin-dsl`
     idea
@@ -11,11 +9,9 @@ repositories {
     maven("https://maven.neoforged.net/releases/") {
         name = "NeoForged"
     }
-    maven("https://maven.architectury.dev/") {
-        name = "Architectury"
+    maven("https://maven.fabricmc.net/") {
+        name = "FabricMC"
     }
-    maven("https://repo.spongepowered.org/repository/maven-public")
-    maven("https://maven.parchmentmc.org")
 }
 
 idea.module {
@@ -36,12 +32,7 @@ gradlePlugin {
     }
 }
 
-val properties by lazy {
-    Properties().apply {
-        load(rootDir.parentFile.resolve("gradle.properties").inputStream())
-    }
-}
-
 dependencies {
-    implementation("dev.architectury.loom:dev.architectury.loom.gradle.plugin:${properties["arch_loom_version"]}")
+    implementation(libs.fabric.loom)
+    implementation(libs.mdg)
 }

buildSrc/settings.gradle.kts

@@ -0,0 +1,8 @@
+// https://discuss.gradle.org/t/using-version-catalog-from-buildsrc-buildlogic-xyz-common-conventions-scripts/48534
+dependencyResolutionManagement {
+    versionCatalogs {
+        create("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}

buildSrc/src/main/kotlin/dev/engine_room/gradle/jarset/JarSetExtension.kt

@@ -1,7 +1,5 @@
 package dev.engine_room.gradle.jarset
 
-import net.fabricmc.loom.task.RemapJarTask
-import net.fabricmc.loom.task.RemapSourcesJarTask
 import org.gradle.api.Project
 import org.gradle.api.tasks.SourceSet
 import org.gradle.jvm.tasks.Jar
@@ -15,11 +13,9 @@ open class JarSetExtension(private val project: Project) {
 
     val mainSet: JarTaskSet by lazy {
         val jarTask = project.tasks.named<Jar>("jar")
-        val remapJarTask = project.tasks.named<RemapJarTask>("remapJar")
         val sourcesJarTask = project.tasks.named<Jar>("sourcesJar")
-        val remapSourcesJarTask = project.tasks.named<RemapSourcesJarTask>("remapSourcesJar")
         val javadocJarTask = project.tasks.named<Jar>("javadocJar")
 
-        JarTaskSet(project, "main", jarTask, sourcesJarTask, javadocJarTask, remapJarTask, remapSourcesJarTask)
+        JarTaskSet(project, "main", jarTask, sourcesJarTask, javadocJarTask)
     }
 }

buildSrc/src/main/kotlin/dev/engine_room/gradle/jarset/JarTaskSet.kt

@@ -1,8 +1,5 @@
 package dev.engine_room.gradle.jarset
 
-import net.fabricmc.loom.task.AbstractRemapJarTask
-import net.fabricmc.loom.task.RemapJarTask
-import net.fabricmc.loom.task.RemapSourcesJarTask
 import org.gradle.api.Action
 import org.gradle.api.NamedDomainObjectProvider
 import org.gradle.api.Project
@@ -27,42 +24,26 @@ class JarTaskSet(
     val jar: TaskProvider<Jar>,
     val sources: TaskProvider<Jar>,
     val javadocJar: TaskProvider<Jar>,
-    val remapJar: TaskProvider<RemapJarTask>,
-    val remapSources: TaskProvider<RemapSourcesJarTask>
 ) {
 
     fun publishWithRawSources(action: Action<MavenPublication>): NamedDomainObjectProvider<MavenPublication> {
         return publish(sources, action)
     }
 
-    fun publishWithRemappedSources(action: Action<MavenPublication>): NamedDomainObjectProvider<MavenPublication> {
-        return publish(remapSources, action)
-    }
-
     private fun publish(
         sourceJar: TaskProvider<out Jar>,
         action: Action<MavenPublication>
     ): NamedDomainObjectProvider<MavenPublication> {
         return project.the<PublishingExtension>().publications.register<MavenPublication>("${name}RemapMaven") {
-            artifact(remapJar)
+            artifact(jar)
             artifact(sourceJar)
             artifact(javadocJar)
             action.execute(this)
         }
     }
 
     fun outgoing(name: String) {
-        outgoingRemapJar("${name}Remap")
-        outgoingJar("${name}Dev")
-    }
-
-    fun outgoingRemapJar(name: String) {
-        val config = project.configurations.register(name) {
-            isCanBeConsumed = true
-            isCanBeResolved = false
-        }
-
-        project.artifacts.add(config.name, remapJar)
+        outgoingJar(name)
     }
 
     fun outgoingJar(name: String) {
@@ -75,22 +56,14 @@ class JarTaskSet(
     }
 
     /**
-     * Configure the assemble task to depend on the remap tasks and javadoc jar.
+     * Configure the assemble task to depend on the regular jar tasks and javadoc jar.
      */
     fun addToAssemble() {
         project.tasks.named("assemble").configure {
-            dependsOn(remapJar, remapSources, javadocJar)
+            dependsOn(jar, sources, javadocJar)
         }
     }
 
-    /**
-     * Configure the remap tasks with the given action.
-     */
-    fun configureRemap(action: Action<AbstractRemapJarTask>) {
-        remapJar.configure(action)
-        remapSources.configure(action)
-    }
-
     /**
      * Configure the jar tasks with the given action.
      */
@@ -99,16 +72,6 @@ class JarTaskSet(
         sources.configure(action)
     }
 
-    /**
-     * Create a new JarTaskSet with the same base jars but new tasks for remapping.
-     */
-    fun forkRemap(newName: String): JarTaskSet {
-        val remapJarTask = createRemapJar(project, newName, jar)
-        val remapSourcesTask = createRemapSourcesJar(project, newName, sources)
-
-        return JarTaskSet(project, newName, jar, sources, javadocJar, remapJarTask, remapSourcesTask)
-    }
-
     companion object {
         private const val PACKAGE_INFOS_JAVA_PATTERN = "**/package-info.java"
         private const val BUILD_GROUP: String = "build"
@@ -138,10 +101,7 @@ class JarTaskSet(
             val sourcesTask = createSourcesJar(project, name, sourceSetSet)
             val javadocJarTask = createJavadocJar(project, name, sourceSetSet)
 
-            val remapJarTask = createRemapJar(project, name, jarTask)
-            val remapSourcesTask = createRemapSourcesJar(project, name, sourcesTask)
-
-            return JarTaskSet(project, name, jarTask, sourcesTask, javadocJarTask, remapJarTask, remapSourcesTask)
+            return JarTaskSet(project, name, jarTask, sourcesTask, javadocJarTask)
         }
 
         private fun createJar(
@@ -206,34 +166,5 @@ class JarTaskSet(
                 from(javadocTask.map { it.outputs })
             }
         }
-
-        private fun createRemapJar(
-            project: Project,
-            name: String,
-            jar: TaskProvider<Jar>
-        ): TaskProvider<RemapJarTask> {
-            return project.tasks.register<RemapJarTask>("${name}RemapJar") {
-                dependsOn(jar)
-                group = LOOM_GROUP
-                destinationDirectory.set(project.layout.buildDirectory.dir("libs/${name}"))
-
-                inputFile.set(jar.flatMap { it.archiveFile })
-            }
-        }
-
-        private fun createRemapSourcesJar(
-            project: Project,
-            name: String,
-            jar: TaskProvider<Jar>
-        ): TaskProvider<RemapSourcesJarTask> {
-            return project.tasks.register<RemapSourcesJarTask>("${name}RemapSourcesJar") {
-                dependsOn(jar)
-                group = LOOM_GROUP
-                destinationDirectory.set(project.layout.buildDirectory.dir("libs/${name}"))
-                archiveClassifier.set(SOURCES_CLASSIFIER)
-
-                inputFile.set(jar.flatMap { it.archiveFile })
-            }
-        }
     }
 }

buildSrc/src/main/kotlin/dev/engine_room/gradle/nullability/GeneratePackageInfosTask.kt

@@ -41,15 +41,8 @@ open class GeneratePackageInfosTask: DefaultTask() {
 
                 NioExtensions.withWriter(target.resolve("package-info.java"), closureOf<BufferedWriter> {
                     val packageName = relativePath.toString().replace(File.separator, ".")
-                    write(StringGroovyMethods.stripMargin("""@ParametersAreNonnullByDefault
-					|@FieldsAreNonnullByDefault
-					|@MethodsReturnNonnullByDefault
+                    write(StringGroovyMethods.stripMargin("""@org.jspecify.annotations.NullMarked
 					|package $packageName;
-					|
-					|import javax.annotation.ParametersAreNonnullByDefault;
-					|
-					|import net.minecraft.FieldsAreNonnullByDefault;
-					|import net.minecraft.MethodsReturnNonnullByDefault;
 					|"""))
                 })
             }

buildSrc/src/main/kotlin/dev/engine_room/gradle/nullability/PackageInfosExtension.kt

@@ -28,7 +28,7 @@ open class PackageInfosExtension(private val project: Project) {
         }
         sourceSet.java.srcDir(task)
 
-        project.tasks.named("ideaSyncTask").configure {
+        project.tasks.matching { it.name == "ideaSyncTask" || it.name == "neoForgeIdeSync" }.configureEach {
             finalizedBy(task)
         }
 

buildSrc/src/main/kotlin/dev/engine_room/gradle/platform/PlatformExtension.kt

@@ -1,7 +1,10 @@
 package dev.engine_room.gradle.platform
 
 import net.fabricmc.loom.api.LoomGradleExtensionAPI
-import net.fabricmc.loom.task.RemapJarTask
+import net.fabricmc.loom.task.RenderDocRunTask
+import net.fabricmc.loom.task.RenderDocRunUITask
+import net.neoforged.moddevgradle.dsl.ModDevExtension
+import net.neoforged.moddevgradle.dsl.RunModel
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.tasks.SourceSet
@@ -10,6 +13,7 @@ import org.gradle.kotlin.dsl.assign
 import org.gradle.kotlin.dsl.named
 import org.gradle.kotlin.dsl.register
 import org.gradle.kotlin.dsl.the
+import org.gradle.kotlin.dsl.withType
 import java.io.File
 
 open class PlatformExtension(val project: Project) {
@@ -19,11 +23,21 @@ open class PlatformExtension(val project: Project) {
         }
     }
 
+    fun setupMdgMod(vararg sourceSets: SourceSet) {
+        project.the<ModDevExtension>().mods.maybeCreate("main").apply {
+            sourceSets.forEach(::sourceSet)
+        }
+    }
+
     fun setupLoomRuns() {
         project.the<LoomGradleExtensionAPI>().runs.apply {
             named("client") {
                 isIdeConfigGenerated = true
 
+                // Better hotswap, only available with the JetBrains Runtime so we have to ignore invalid options aswell
+                jvmArguments.add("-XX:+IgnoreUnrecognizedVMOptions")
+                jvmArguments.add("-XX:+AllowEnhancedClassRedefinition")
+
                 // Turn on our own debug flags
                 property("flw.dumpShaderSource", "true")
                 property("flw.debugMemorySafety", "true")
@@ -32,6 +46,8 @@ open class PlatformExtension(val project: Project) {
                 property("mixin.debug.export", "true")
                 property("mixin.debug.verbose", "true")
 
+                programArgs("--renderDebugLabels")
+
                 // 720p baby!
                 programArgs("--width", "1280", "--height", "720")
             }
@@ -42,27 +58,61 @@ open class PlatformExtension(val project: Project) {
                 programArgs("--nogui")
             }
         }
+
+
+        if (System.getProperty("os.name") == "Linux") {
+            project.tasks.withType<RenderDocRunTask> {
+                renderDocExecutable.set(File("/usr/bin/renderdoccmd"))
+            }
+
+            project.tasks.withType<RenderDocRunUITask> {
+                renderDocExecutable.set(File("/usr/bin/qrenderdoc"))
+            }
+        }
+    }
+
+    fun setupMdgRuns() {
+        project.the<ModDevExtension>().runs.apply {
+            create("client") {
+                client()
+
+                // Better hotswap, only available with the JetBrains Runtime so we have to ignore invalid options aswell
+                jvmArgument("-XX:+IgnoreUnrecognizedVMOptions")
+                jvmArgument("-XX:+AllowEnhancedClassRedefinition")
+
+                // Turn on our own debug flags
+                systemProperty("flw.dumpShaderSource", "true")
+                systemProperty("flw.debugMemorySafety", "true")
+
+                // Turn on mixin debug flags
+                systemProperty("mixin.debug.export", "true")
+                systemProperty("mixin.debug.verbose", "true")
+
+                // 720p baby!
+                programArguments.addAll("--width", "1280", "--height", "720")
+
+                // Helpful when debugging issues
+                programArguments.addAll("--renderDebugLabels", "--vulkanValidation")
+            }
+
+            // We're a client mod, but we need to make sure we correctly render when playing on a server.
+            create("server") {
+                server()
+
+                programArgument("--nogui")
+            }
+        }
     }
 
     fun setupTestMod(sourceSet: SourceSet) {
         project.tasks.apply {
             val testModJar = register<Jar>("testModJar") {
                 from(sourceSet.output)
-                val file = File(project.layout.buildDirectory.asFile.get(), "devlibs");
-                destinationDirectory.set(file)
-                archiveClassifier = "testmod"
-            }
-
-            val remapTestModJar = register<RemapJarTask>("remapTestModJar") {
-                dependsOn(testModJar)
-                inputFile.set(testModJar.get().archiveFile)
                 archiveClassifier = "testmod"
-                addNestedDependencies = false
-                classpath.from(sourceSet.compileClasspath)
             }
 
             named<Task>("build").configure {
-                dependsOn(remapTestModJar)
+                dependsOn(testModJar)
             }
         }
     }