OpenGL Texture Tutorial Java

//Import everything..
import static org.lwjgl.glfw.Callbacks.errorCallbackPrint;
import static org.lwjgl.glfw.GLFW.*;
import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL12.GL_CLAMP_TO_EDGE;
import static org.lwjgl.opengl.GL15.*;
import static org.lwjgl.opengl.GL20.*;
import static org.lwjgl.opengl.GL30.*;
import static org.lwjgl.system.MemoryUtil.NULL;

import java.awt.image.BufferedImage;
import java.io.File;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;

import javax.imageio.ImageIO;

import org.lwjgl.BufferUtils;
import org.lwjgl.glfw.GLFWErrorCallback;
import org.lwjgl.opengl.GLContext;

public class OpenGLTextureTutorial {
    private static GLFWErrorCallback errorCallback;
    private static long window;

    private static String vertexShaderSource =
            "#version 150 core\n" +
            "in vec2 position;" +
            "in vec3 color;" +
            "in vec2 texcoord;" +
            "out vec3 Color;" +
            "out vec2 Texcoord;" +
            "void main() {" +
            "   Color = color;" +
            "   Texcoord = texcoord;" +
            "   gl_Position = vec4(position, 0.0, 1.0);" +
            "}";

    private static String fragmentShaderSource =
            "#version 150 core\n" +
            "in vec3 Color;" +
            "in vec2 Texcoord;" +
            "out vec4 outColor;" +
            "uniform sampler2D tex;" +
            "void main() {" +
            "   outColor = texture(tex, Texcoord) * vec4(Color, 1.0);" +
            "}";

    public static void main(String[] args) {
        //Initialize GLFW and create the window

        glfwSetErrorCallback(errorCallback = errorCallbackPrint(System.err));

        if (glfwInit() != GL_TRUE)
            throw new IllegalStateException("Unable to initialize GLFW");

        glfwDefaultWindowHints();

        glfwWindowHint(GLFW_VISIBLE, GL_FALSE);

        window = glfwCreateWindow(800, 600, "OpenGL ", NULL, NULL);
        if (window == NULL)
            throw new RuntimeException("Failed to create the GLFW window");

        glfwMakeContextCurrent(window);

        glfwShowWindow(window);

        GLContext.createFromCurrent();

        //Create Vertex Array Object
        int vaoID = glGenVertexArrays();
        glBindVertexArray(vaoID);

        //Create a Vertex Buffer Object and copy the vertex data to it
        int vboID = glGenBuffers();

        float[] vertices = {
                  //Position     Color             Texcoords
                   -0.5f,  0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, // Top-left
                    0.5f,  0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, // Top-right
                    0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, // Bottom-right
                   -0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f  // Bottom-left
        };

        glBindBuffer(GL_ARRAY_BUFFER, vboID);
        glBufferData(GL_ARRAY_BUFFER, convertToFloatBuffer(vertices), GL_STATIC_DRAW);

        //Create an element array
        int eboID = glGenBuffers();

        int[] elements = {
                0, 1, 2,
                2, 3, 0
        };

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, eboID);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, convertToIntBuffer(elements), GL_STATIC_DRAW);

        //Create and compile the vertex shader
        int vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(vertexShaderID, vertexShaderSource);
        glCompileShader(vertexShaderID);

        //Create and compile the fragment shader
        int fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fragmentShaderID, fragmentShaderSource);
        glCompileShader(fragmentShaderID);

        // Link the vertex and fragment shader into a shader program
        int shaderProgram = glCreateProgram();
        glAttachShader(shaderProgram, vertexShaderID);
        glAttachShader(shaderProgram, fragmentShaderID);
        glBindFragDataLocation(shaderProgram, 0, "outColor");
        glLinkProgram(shaderProgram);
        glUseProgram(shaderProgram);

        int sizeOfFloat = 4;

        // Specify the layout of the vertex data
        int positionAttribute = glGetAttribLocation(shaderProgram, "position");
        glEnableVertexAttribArray(positionAttribute);
        glVertexAttribPointer(positionAttribute, 2, GL_FLOAT, false, 7 * sizeOfFloat, 0);

        int colorAttribute = glGetAttribLocation(shaderProgram, "color");
        glEnableVertexAttribArray(colorAttribute);
        glVertexAttribPointer(colorAttribute, 3, GL_FLOAT, false, 7 * sizeOfFloat, 2 * sizeOfFloat);

        int textureAttribute = glGetAttribLocation(shaderProgram, "texcoord");
        glEnableVertexAttribArray(textureAttribute);
        glVertexAttribPointer(textureAttribute, 2, GL_FLOAT, false, 7 * sizeOfFloat, 5 * sizeOfFloat);

        //Load texture
        int textureID = loadTexture("test.jpg");

        while (glfwWindowShouldClose(window) != GL_TRUE)
        {
            glfwPollEvents();

            // Clear the screen to black
            glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
            glClear(GL_COLOR_BUFFER_BIT);

            glBindTexture(GL_TEXTURE_2D, textureID);

            // Draw a rectangle from the 2 triangles using 6 indices
            glDrawElements(GL_TRIANGLES, elements.length, GL_UNSIGNED_INT, 0);

            // Swap buffers
            glfwSwapBuffers(window);
        }

        //Delete all the textures, buffers and shaders we created
        glDeleteTextures(textureID);

        glDeleteProgram(shaderProgram);
        glDeleteShader(vertexShaderID);
        glDeleteShader(fragmentShaderID);

        glDeleteBuffers(vboID);
        glDeleteBuffers(eboID);

        glDeleteVertexArrays(vaoID);

        //Destroy the window and terminate GLFW
        glfwDestroyWindow(window);

        glfwTerminate();
        errorCallback.release();
    }

    private static int loadTexture(String fileName) {
        try {
            BufferedImage image = ImageIO.read(new File(fileName));

            int[] pixels = image.getRGB(0, 0, image.getWidth(), image.getHeight(), null, 0, image.getWidth());

            ByteBuffer buffer = BufferUtils.createByteBuffer(image.getHeight() * image.getWidth() * 4);

            boolean hasAlpha = image.getColorModel().hasAlpha();

            for (int y = 0; y < image.getHeight(); y++) {
                for (int x = 0; x < image.getWidth(); x++) {
                    int pixel = pixels[y * image.getWidth() + x];
                    buffer.put((byte) ((pixel >> 16) & 0xFF));
                    buffer.put((byte) ((pixel >> 8) & 0xFF));
                    buffer.put((byte) ((pixel) & 0xFF));
                    if (hasAlpha) buffer.put((byte) ((pixel >> 24) & 0xFF));
                    else
                        buffer.put((byte) (0xFF));
                }
            }

            buffer.flip();

            int id = glGenTextures();

            glBindTexture(GL_TEXTURE_2D, id);

            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, image.getWidth(), image.getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer);

            return id;
        } catch (Exception ex) {
            ex.printStackTrace();
            return -1;
        }
    }

    public static FloatBuffer convertToFloatBuffer(float[] vertices) {
        FloatBuffer buffer = BufferUtils.createFloatBuffer(vertices.length);
        for(int i = 0; i < vertices.length; i++) {
            buffer.put(vertices[i]);
        }
        buffer.flip();

        return buffer;
    }

    public static IntBuffer convertToIntBuffer(int... values) {
        IntBuffer buffer = BufferUtils.createIntBuffer(values.length);
        buffer.put(values);
        buffer.flip();

        return buffer;
    }
}