Window resize doesn't effect contents

Question

I have an issue with resizing my window on LWJGL3 and GLFW. I can resize the window, however what is rendered to it does not size with it, most likely a coordinate issue. I've listed my Display and Main classes.

public static void init() {
    // Setup an error callback. The default implementation
    // will print the error message in System.err.
    GLFWErrorCallback.createPrint(System.err).set();

    // Initialize GLFW. Most GLFW functions will not work before doing this.
    if ( !glfwInit() )
        throw new IllegalStateException("Unable to initialize GLFW");

    // Configure GLFW
    glfwDefaultWindowHints(); // optional, the current window hints are already the default
    glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); // the window will stay hidden after creation
    glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); // the window will be resizable

    // Create the window
    window = glfwCreateWindow(800, 500, "Game Indev", NULL, NULL);
    if ( window == NULL )
        throw new RuntimeException("Failed to create the GLFW window");

    // Setup a key callback. It will be called every time a key is pressed, repeated or released.
    glfwSetKeyCallback(window, (window, key, scancode, action, mods) -> {
        if ( key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE )
            glfwSetWindowShouldClose(window, true); // We will detect this in the rendering loop
    });

    // Get the thread stack and push a new frame
    try ( MemoryStack stack = stackPush() ) {
        IntBuffer pWidth = stack.mallocInt(1); // int*
        IntBuffer pHeight = stack.mallocInt(1); // int*

        // Get the window size passed to glfwCreateWindow
        glfwGetWindowSize(window, pWidth, pHeight);

        // Get the resolution of the primary monitor
        GLFWVidMode vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());

        // Center the window
        glfwSetWindowPos(
                window,
                (vidmode.width() - pWidth.get(0)) / 2,
                (vidmode.height() - pHeight.get(0)) / 2
        );
    } // the stack frame is popped automatically

    // Make the OpenGL context current
    glfwMakeContextCurrent(window);
    // Enable v-sync
    glfwSwapInterval(1);

    // Make the window visible
    glfwShowWindow(window);
}

And my main class is here:

// The window handle

public static void main(String[] args) {
    System.out.println(Version.getVersion());

    Display.init();

    Loader loader = new Loader();
    Renderer renderer = new Renderer();
    // This line checks the context and capabilities
    GL.createCapabilities();
    float[] vertices = {

            -0.5f, 0.5f, 0f,
            -0.5f, -0.5f, 0f,
            0.5f, -0.5f, 0f,
            0.5f, -0.5f, 0f,
            0.5f, 0.5f, 0f,
            -0.5f, 0.5f, 0f
    };
    RawModel model = loader.loadToVao(vertices);

    // Set the clear color initially
    glClearColor(1.0f, 0.0f, 0.0f, 0.0f);

    /*
    THIS
    IS
    THE
    MAIN
    GAME
    LOGIC
    ---------------------------------------------------------------------------------
     */
    while ( !glfwWindowShouldClose(Display.window) ) {
        GL11.glClearColor(GameState.stateR, GameState.stateG, GameState.stateB, GameState.stateA);
        GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);

        renderer.renderModel(model);

        glfwSwapBuffers(Display.window); // swap the color buffers


        GameState.getStateInput();
        GameState.renderGameState(loader, renderer);
        glfwPollEvents();

    }

    //End of main loop -----------------------------------------------------------------

    // Free the window callbacks and destroy the window
    glfwFreeCallbacks(Display.window);
    glfwDestroyWindow(Display.window);

    // Terminate GLFW and free the error callback
    glfwTerminate();
    glfwSetErrorCallback(null).free();
}
// --------------------------------------------------------------------------------------------

I also have an image of what Im talking about.

Before resizing After resizing Obviously, I would want the quad to resize with the screen, making the fullscreen mode have a large quad in the middle, rather than the same size in the bottom left coordinates. How would I do this?

Answer 1

In order for the contents of the window to resize properly you need to respond to the resize of the window with:

glfwSetWindowSizeCallback(window, new GLFWWindowSizeCallback() {
        @Override
        public void invoke(long window, int argWidth, int argHeight) {
            resizeWindow(argWidth, argHeight);
        }
});

In resizeWindow(argWidth, argHeight) you need to set the viewport and to recalculate the projection matrix (only if you are using one).

private void resizeWindow(int argWidth, int argHeight) {
    glViewport(0, 0, argWidth,argHeight);

    adjustProjectionMatrix(width, height); // recalculating projection matrix (only if you are using one)
}

EDIT:

If you are using LWJGL 2 :

if (Display.wasResized()) {
    GL11.glViewport(0, 0, Display.getWidth(), Display.getHeight());

    adjustProjectionMatrix(Display.getWidth(), Display.getHeight()); // only if you are using one
}