Rework the interface between NeoForge and the FML early loading screen (#260)

Author: shartte

earlydisplay/src/main/java/net/neoforged/fml/earlydisplay/DisplayWindow.java

@@ -11,8 +11,6 @@
 
 import java.awt.Desktop;
 import java.io.IOException;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
 import java.net.URI;
 import java.nio.ByteBuffer;
 import java.nio.file.Files;
@@ -22,7 +20,6 @@
 import java.util.Calendar;
 import java.util.List;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.StringJoiner;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executors;
@@ -34,18 +31,12 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.function.IntConsumer;
-import java.util.function.IntSupplier;
-import java.util.function.LongSupplier;
-import java.util.function.Supplier;
 import java.util.stream.Collector;
 import java.util.stream.Collectors;
 import joptsimple.OptionParser;
 import net.neoforged.fml.loading.FMLConfig;
 import net.neoforged.fml.loading.FMLPaths;
-import net.neoforged.fml.loading.ImmediateWindowHandler;
+import net.neoforged.fml.loading.progress.ProgressMeter;
 import net.neoforged.fml.loading.progress.StartupNotificationManager;
 import net.neoforged.neoforgespi.earlywindow.ImmediateWindowProvider;
 import org.jetbrains.annotations.Nullable;
@@ -76,6 +67,7 @@ public class DisplayWindow implements ImmediateWindowProvider {
     private static final int[][] GL_VERSIONS = new int[][] { { 4, 6 }, { 4, 5 }, { 4, 4 }, { 4, 3 }, { 4, 2 }, { 4, 1 }, { 4, 0 }, { 3, 3 }, { 3, 2 } };
     private static final Logger LOGGER = LoggerFactory.getLogger("EARLYDISPLAY");
     private final AtomicBoolean animationTimerTrigger = new AtomicBoolean(true);
+    private final ProgressMeter mainProgress;
 
     private ColourScheme colourScheme;
     private ElementShader elementShader;
@@ -103,10 +95,13 @@ public class DisplayWindow implements ImmediateWindowProvider {
 
     private final Semaphore renderLock = new Semaphore(1);
     private boolean maximized;
-    private String glVersion;
     private SimpleFont font;
     private Runnable repaintTick = () -> {};
 
+    public DisplayWindow() {
+        mainProgress = StartupNotificationManager.addProgressBar("EARLY", 0);
+    }
+
     @Override
     public String name() {
         return "fmlearlywindow";
@@ -270,15 +265,14 @@ void paintFramebuffer() {
     }
 
     // Called from NeoForge
-    public void render(int alpha) {
+    public void renderToFramebuffer() {
         GlDebug.pushGroup("update EarlyDisplay framebuffer");
         GlState.readFromOpenGL();
         var backup = GlState.createSnapshot();
 
         GlState.viewport(0, 0, this.context.scaledWidth(), this.context.scaledHeight());
-        RenderElement.globalAlpha = alpha;
         framebuffer.activate();
-        GlState.clearColor(colourScheme.background().redf(), colourScheme.background().greenf(), colourScheme.background().bluef(), alpha / 255f);
+        GlState.clearColor(colourScheme.background().redf(), colourScheme.background().greenf(), colourScheme.background().bluef(), 1f);
         elementShader.activate();
         elementShader.updateScreenSizeUniform(this.context.scaledWidth(), this.context.scaledHeight());
         paintFramebuffer();
@@ -305,11 +299,6 @@ public Runnable start(@Nullable String mcVersion, final String forgeVersion) {
 
     private static final String ERROR_URL = "https://links.neoforged.net/early-display-errors";
 
-    @Override
-    public String getGLVersion() {
-        return this.glVersion;
-    }
-
     private final ReentrantLock crashLock = new ReentrantLock();
 
     private void crashElegantly(String errorDetails) {
@@ -445,7 +434,6 @@ public void initWindow(@Nullable String mcVersion) {
         var min = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MINOR);
         var gotVersion = maj + "." + min;
         LOGGER.info("Requested GL version " + requestedVersion + " got version " + gotVersion);
-        this.glVersion = gotVersion;
         this.window = window;
 
         int[] x = new int[1];
@@ -539,7 +527,7 @@ private void handleLastGLFWError(BiConsumer<Integer, String> handler) {
      *
      * @return the Window we own.
      */
-    public long setupMinecraftWindow(final IntSupplier width, final IntSupplier height, final Supplier<String> title, final LongSupplier monitorSupplier) {
+    public long takeOverGlfwWindow() {
         // wait for the window to actually be initialized
         try {
             this.initializationFuture.get(30, TimeUnit.SECONDS);
@@ -550,7 +538,7 @@ public long setupMinecraftWindow(final IntSupplier width, final IntSupplier heig
             crashElegantly("We seem to be having trouble initializing the window, waited for 30 seconds");
         }
         // we have to spin wait for the window ticker
-        ImmediateWindowHandler.updateProgress("Initializing Game Graphics");
+        updateProgress("Initializing Game Graphics");
         while (!this.windowTick.isDone()) {
             this.windowTick.cancel(false);
         }
@@ -572,7 +560,6 @@ public long setupMinecraftWindow(final IntSupplier width, final IntSupplier heig
 
         glfwMakeContextCurrent(window);
         // Set the title to what the game wants
-        glfwSetWindowTitle(window, title.get());
         glfwSwapInterval(0);
         // Clean up our hooks
         glfwSetFramebufferSizeCallback(window, null).free();
@@ -584,40 +571,7 @@ public long setupMinecraftWindow(final IntSupplier width, final IntSupplier heig
     }
 
     @Override
-    public boolean positionWindow(final Optional<Object> monitor, final IntConsumer widthSetter, final IntConsumer heightSetter, final IntConsumer xSetter, final IntConsumer ySetter) {
-        widthSetter.accept(this.winWidth);
-        heightSetter.accept(this.winHeight);
-        xSetter.accept(this.winX);
-        ySetter.accept(this.winY);
-        return true;
-    }
-
-    @Override
-    public void updateFramebufferSize(final IntConsumer width, final IntConsumer height) {
-        width.accept(this.fbWidth);
-        height.accept(this.fbHeight);
-    }
-
-    private Method loadingOverlay;
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public <T> Supplier<T> loadingOverlay(final Supplier<?> mc, final Supplier<?> ri, final Consumer<Optional<Throwable>> ex, final boolean fade) {
-        try {
-            return (Supplier<T>) loadingOverlay.invoke(null, mc, ri, ex, this);
-        } catch (Throwable e) {
-            throw new IllegalStateException("How did you get here?", e);
-        }
-    }
-
-    @Override
-    public void updateModuleReads(final ModuleLayer layer) {
-        var fm = layer.findModule("neoforge").orElseThrow();
-        getClass().getModule().addReads(fm);
-        var clz = Class.forName(fm, "net.neoforged.neoforge.client.loading.NeoForgeLoadingOverlay");
-        var methods = Arrays.stream(clz.getMethods()).filter(m -> Modifier.isStatic(m.getModifiers())).collect(Collectors.toMap(Method::getName, Function.identity()));
-        loadingOverlay = methods.get("newInstance");
-    }
+    public void updateModuleReads(final ModuleLayer layer) {}
 
     public int getFramebufferTextureId() {
         return framebuffer.getTexture();
@@ -633,6 +587,16 @@ public void periodicTick() {
         repaintTick.run();
     }
 
+    @Override
+    public void updateProgress(String label) {
+        mainProgress.label(label);
+    }
+
+    @Override
+    public void completeProgress() {
+        mainProgress.complete();
+    }
+
     public void addMojangTexture(final int textureId) {
         this.elements.add(0, RenderElement.mojang(textureId, framecount));
 //        this.elements.get(0).retire(framecount + 1);

loader/src/main/java/net/neoforged/fml/ModLoader.java

@@ -34,7 +34,6 @@
 import net.neoforged.fml.i18n.FMLTranslations;
 import net.neoforged.fml.loading.FMLEnvironment;
 import net.neoforged.fml.loading.FMLLoader;
-import net.neoforged.fml.loading.ImmediateWindowHandler;
 import net.neoforged.fml.loading.LoadingModList;
 import net.neoforged.fml.loading.moddiscovery.ModFileInfo;
 import net.neoforged.fml.loading.moddiscovery.ModInfo;
@@ -96,7 +95,6 @@ public static void gatherAndInitializeMods(final Executor syncExecutor, final Ex
         loadingIssues.addAll(loadingModList.getModLoadingIssues());
 
         ForgeFeature.registerFeature("javaVersion", ForgeFeature.VersionFeatureTest.forVersionString(IModInfo.DependencySide.BOTH, System.getProperty("java.version")));
-        ForgeFeature.registerFeature("openGLVersion", ForgeFeature.VersionFeatureTest.forVersionString(IModInfo.DependencySide.CLIENT, ImmediateWindowHandler.getGLVersion()));
         FMLLoader.backgroundScanHandler.waitForScanToComplete(periodicTask);
         final ModList modList = ModList.of(loadingModList.getModFiles().stream().map(ModFileInfo::getFile).toList(),
                 loadingModList.getMods());

loader/src/main/java/net/neoforged/fml/loading/EarlyLoadingScreenController.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) NeoForged and contributors
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+package net.neoforged.fml.loading;
+
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Interface for use by NeoForge to control the early loading screen.
+ */
+public interface EarlyLoadingScreenController {
+    /**
+     * Gets the current loading screen controller.
+     */
+    @Nullable
+    static EarlyLoadingScreenController current() {
+        return ImmediateWindowHandler.provider;
+    }
+
+    /**
+     * Takes over ownership of the GLFW window created by the early loading screen.
+     * <p>
+     * This method can only be called once and once this method is called, any off-thread
+     * interaction with the window seizes.
+     *
+     * @return The GLFW window handle for the window in a state that can be used by the game.
+     */
+    long takeOverGlfwWindow();
+
+    /**
+     * After calling {@linkplain #takeOverGlfwWindow() taking over} the main window, the game may still want to
+     * periodically ask the loading screen to update itself independently. It will call this method to do so.
+     */
+    void periodicTick();
+
+    /**
+     * Sets a label for the main progress bar on the early loading screen.
+     */
+    void updateProgress(String label);
+
+    /**
+     * Clears all current progress in preparation for drawing a Minecraft overlay on top of the loading
+     * screen.
+     */
+    void completeProgress();
+}