Package net.minecraftforge.fml.loading

Interface ImmediateWindowProvider

All Known Implementing Classes:
DisplayWindow, ImmediateWindowHandler.DummyProvider
public interface ImmediateWindowProvider
This is for allowing the plugging in of alternative early display implementations. They can be selected through the config value "earlyWindowProvider" which defaults to "fmlearlywindow" implemented by DisplayWindow There are a few key things to keep in mind if following through on implementation. You cannot access the game state as it literally DOES NOT EXIST at the time this object is constructed. You have to be very careful about managing the handoff to mojang, be sure that if you're trying to tick your window in a background thread (a nice idea!) that you properly transition to the main thread before handoff is complete. Do note that in general, you should construct your GL objects on the MAIN thread before starting your ticker, to ensure MacOS compatibility. No doubt many more things can be said here.

  • Method Details

    • name

      String name()
      Returns:
      The name of this window provider. Do NOT use fmlearlywindow.

    • initialize

      Runnable initialize(String[] arguments)
      This is called very early on to initialize ourselves. Use this to initialize the window and other GL core resources. One thing we want to ensure is that we try and create the highest GL_PROFILE we can accomplish. GLFW_CONTEXT_VERSION_MAJOR,GLFW_CONTEXT_VERSION_MINOR should be as high as possible on the created window, and it should have all the typical profile settings.
      Parameters:
      arguments - The arguments provided to the Java process. This is the entire command line, so you can process stuff from it.
      Returns:
      A runnable that will be periodically ticked by FML during startup ON THE MAIN THREAD. This is usually a good place to put glfwPollEvents() tests.

    • updateFramebufferSize

      void updateFramebufferSize(IntConsumer width, IntConsumer height)
      This will be called during the handoff to minecraft to update minecraft with the size of the framebuffer we have. Generally won't be called because Minecraft figures it out for itself.
      Parameters:
      width - Consumer of the framebuffer width
      height - Consumer of the framebuffer height

    • setupMinecraftWindow

      long setupMinecraftWindow(IntSupplier width, IntSupplier height, Supplier<String> title, LongSupplier monitor)
      This is called to setup the minecraft window, as if Mojang had done it themselves in their Window class. This handoff is difficult to get right - you have to make sure that any activities you're doing to the window are finished prior to returning. You should try and setup the width and height as Mojang expects - the suppliers give you all that information. Alternatively, you can force Mojang to update from the current position of the window in positionWindow(Optional, IntConsumer, IntConsumer, IntConsumer, IntConsumer) instead. This might give a more seamless experience.
      Parameters:
      width - This is the width of the window Mojang expects
      height - This is the height of the Window Mojang expects.
      title - This is the title for the window.
      monitor - This is the monitor it should appear on.
      Returns:
      The window id

    • positionWindow

      boolean positionWindow(Optional<Object> monitor, IntConsumer widthSetter, IntConsumer heightSetter, IntConsumer xSetter, IntConsumer ySetter)
      This is called after window handoff to allow us to tell Mojang about our window's position. This might give a preferrable user experience to users, because we just tell Mojang our truth, rather than accept theirs.
      Parameters:
      monitor - This is the monitor we're rendering on. Note that this is the Mojang monitor object. You might have trouble unwrapping it.
      widthSetter - This sets the width on the Mojang side
      heightSetter - This sets the height on the Mojang side
      xSetter - This sets the x coordinate on the Mojang side
      ySetter - This sets the y coordinate on the Mojang side
      Returns:
      true if you've handled the window positioning - this skips the "forced fullscreen" code until a later stage

    • loadingOverlay

      <T> Supplier<T> loadingOverlay(Supplier<?> mc, Supplier<?> ri, Consumer<Optional<Throwable>> ex, boolean fade)
      Return a Supplier of an object extending the LoadingOverlay class from Mojang. This is what will be used once the Mojang window code has taken over rendering of the window, to render the later stages of the loading process.
      Type Parameters:
      T - This is the type LoadingOverlay to allow type binding on the Mojang side
      Parameters:
      mc - This supplies the Minecraft object
      ri - This supplies the ReloadInstance object that tells us when the loading is finished
      ex - This Consumes the final state of the loading - if it's an error you pass it the Throwable, otherwise you pass Optional.empty()
      fade - This is the fade flag passed to LoadingOverlay. You probably want to ignore it.
      Returns:
      A supplier of your later LoadingOverlay screen.

    • updateModuleReads

      void updateModuleReads(ModuleLayer layer)
      This is called during the module loading process to allow us to find objects inside the GAME layer, such as a later loading screen.
      Parameters:
      layer - This is the GAME layer from ModLauncher

    • periodicTick

      void periodicTick()
      This is called periodically during the loading process to "tick" the window. It is typically the same as the Runnable from initialize(String[])

    • getGLVersion

      String getGLVersion()
      This is called to construct a ForgeFeature for the GL_VERSION we managed to create for the window. Should be a string of the format {MAJOR}.{MINOR}, such as 4.6, 4.5 or such.
      Returns:
      the GL profile we created