lwjgl，在屏幕上只旋转一个对象？

import org.lwjgl.glfw.GLFW;
import org.lwjgl.opengl.GL;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL20;
import org.lwjgl.opengl.GL30;

public class Main {
    private long window;
    private int vao;
    private int shaderProgram;
    private float rotation = 0.0f;

    public void run() {
        init();
        loop();
        cleanup();
    }

    private void init() {
        GLFW.glfwInit();
        GLFW.glfwWindowHint(GLFW.GLFW_CONTEXT_VERSION_MAJOR, 3);
        GLFW.glfwWindowHint(GLFW.GLFW_CONTEXT_VERSION_MINOR, 3);
        GLFW.glfwWindowHint(GLFW.GLFW_OPENGL_PROFILE, GLFW.GLFW_OPENGL_CORE_PROFILE);
        GLFW.glfwWindowHint(GLFW.GLFW_OPENGL_FORWARD_COMPAT, GLFW.GLFW_TRUE);

        window = GLFW.glfwCreateWindow(800, 600, "Rotation Example", 0, 0);
        GLFW.glfwMakeContextCurrent(window);
        GL.createCapabilities();

        GL11.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

        vao = GL30.glGenVertexArrays();
        GL30.glBindVertexArray(vao);

        float[] vertices = {
                -0.5f, -0.5f, 0.0f,
                0.5f, -0.5f, 0.0f,
                0.0f, 0.5f, 0.0f
        };

        int vbo = GL30.glGenBuffers();
        GL30.glBindBuffer(GL30.GL_ARRAY_BUFFER, vbo);
        GL30.glBufferData(GL30.GL_ARRAY_BUFFER, vertices, GL30.GL_STATIC_DRAW);
        GL20.glVertexAttribPointer(0, 3, GL11.GL_FLOAT, false, 0, 0);
        GL20.glEnableVertexAttribArray(0);

        String vertexShaderSource = "#version 330 core\n" +
                "layout (location = 0) in vec3 aPosition;\n" +
                "uniform mat4 uModel;\n" +
                "void main()\n" +
                "{\n" +
                "    gl_Position = uModel * vec4(aPosition, 1.0);\n" +
                "}";

        String fragmentShaderSource = "#version 330 core\n" +
                "out vec4 FragColor;\n" +
                "void main()\n" +
                "{\n" +
                "    FragColor = vec4(1.0, 1.0, 1.0, 1.0);\n" +
                "}";

        int vertexShader = GL20.glCreateShader(GL20.GL_VERTEX_SHADER);
        GL20.glShaderSource(vertexShader, vertexShaderSource);
        GL20.glCompileShader(vertexShader);

        int fragmentShader = GL20.glCreateShader(GL20.GL_FRAGMENT_SHADER);
        GL20.glShaderSource(fragmentShader, fragmentShaderSource);
        GL20.glCompileShader(fragmentShader);

        shaderProgram = GL20.glCreateProgram();
        GL20.glAttachShader(shaderProgram, vertexShader);
        GL20.glAttachShader(shaderProgram, fragmentShader);
        GL20.glLinkProgram(shaderProgram);
        GL20.glUseProgram(shaderProgram);
    }

    private void loop() {
        while (!GLFW.glfwWindowShouldClose(window)) {
            GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);

            GL20.glUseProgram(shaderProgram);
            int modelLocation = GL20.glGetUniformLocation(shaderProgram, "uModel");
            GL20.glUniformMatrix4fv(modelLocation, false, createModelMatrix(rotation));

            GL30.glBindVertexArray(vao);
            GL11.glDrawArrays(GL11.GL_TRIANGLES, 0, 3);

            GLFW.glfwSwapBuffers(window);
            GLFW.glfwPollEvents();

            rotation += 0.01f;
        }
    }

    private void cleanup() {
        GL20.glDeleteProgram(shaderProgram);
        GL20.glDeleteShader(vertexShader);
        GL20.glDeleteShader(fragmentShader);
        GL30.glDeleteVertexArrays(vao);
        GL30.glDeleteBuffers(vbo);

        GLFW.glfwTerminate();
    }

    private float[] createModelMatrix(float rotation) {
        float[] matrix = new float[16];
        matrix[0] = (float) Math.cos(rotation);
        matrix[1] = (float) -Math.sin(rotation);
        matrix[4] = (float) Math.sin(rotation);
        matrix[5] = (float) Math.cos(rotation);
        matrix[10] = 1.0f;
        matrix[15] = 1.0f;
        return matrix;
    }

    public static void main(String[] args) {
        new Main().run();
    }
}