texture broken

package eu.robinkuester.opengltest;

import org.apache.commons.io.IOUtils;
import org.lwjgl.BufferUtils;
import org.lwjgl.glfw.Callbacks;
import org.lwjgl.glfw.GLFWErrorCallback;
import org.lwjgl.glfw.GLFWKeyCallback;
import org.lwjgl.opengl.GL;
import org.lwjgl.opengl.GLUtil;
import org.lwjgl.stb.STBImage;
import org.lwjgl.system.libffi.Closure;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.ShortBuffer;

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.GL13.GL_TEXTURE0;
import static org.lwjgl.opengl.GL13.glActiveTexture;
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;

/**
 * @author Robin Küster
 * @since 2015-09-13
 */
public class OpenGLTest {
    private GLFWKeyCallback keyCallback = new GLFWKeyCallback() {
        @Override
        public void invoke(long window, int key, int scancode, int action, int mods) {
            if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) {
                glfwSetWindowShouldClose(window, GL_TRUE);
            }
        }
    };

    private Closure glError;

    private GLFWErrorCallback errorCallback = Callbacks.errorCallbackPrint();

    private long windowID;

    private static int height, width;

    private int texUni;
    private int tex;
    private int uvAttrib;
    private int posAttrib;

    public static void main(String[] args) {
        String path = new File("natives").getAbsolutePath();
        System.setProperty("org.lwjgl.librarypath", path);

        new OpenGLTest().run();
    }

    private static FloatBuffer generateFloatBuffer(float[] array) {
        FloatBuffer buffer = BufferUtils.createFloatBuffer(array.length);
        buffer.put(array);
        buffer.flip();
        return buffer;
    }

    private static ShortBuffer generateShortBuffer(short[] array) {
        ShortBuffer buffer = BufferUtils.createShortBuffer(array.length);
        buffer.put(array);
        buffer.flip();
        return buffer;
    }

    private static ByteBuffer generateByteBuffer(byte[] array) {
        ByteBuffer buffer = BufferUtils.createByteBuffer(array.length);
        buffer.put(array);
        buffer.flip();
        return buffer;
    }

    private static int compileShader(int type, String source) {
        int shader = glCreateShader(type);
        glShaderSource(shader, source);
        glCompileShader(shader);

        int info = glGetShaderi(shader, GL_COMPILE_STATUS);
        if (info == GL_FALSE) {
            System.err.println(glGetShaderInfoLog(shader));
            return 0;
        }

        return shader;
    }

    private static int linkProgram(int vertexShader, int fragmentShaer) {
        int program = glCreateProgram();
        glAttachShader(program, vertexShader);
        glAttachShader(program, fragmentShaer);
        glLinkProgram(program);

        int info = glGetProgrami(program, GL_LINK_STATUS);
        if (info == GL_FALSE) {
            System.err.println(glGetProgramInfoLog(program));
            return 0;
        }
        return program;
    }

    private static ByteBuffer getTexture(String texture) {
        ByteBuffer imageFileBuffer;

        InputStream is = OpenGLTest.class.getResourceAsStream(texture);
        try {
            byte array[] = IOUtils.toByteArray(is);
            imageFileBuffer = generateByteBuffer(array);
            is.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        IntBuffer w = BufferUtils.createIntBuffer(1);
        IntBuffer h = BufferUtils.createIntBuffer(1);
        IntBuffer comp = BufferUtils.createIntBuffer(1);

        ByteBuffer buffer = STBImage.stbi_load_from_memory(imageFileBuffer, w, h, comp, 0);
        if (buffer == null) {
            throw new RuntimeException("Failed to load image: " + STBImage.stbi_failure_reason());
        }

        if (comp.get(0) != 4) {
            throw new RuntimeException("No alpha channel!");
        }

        width = w.get(0);
        height = h.get(0);

        return buffer;
    }

    public void run() {
        setupContext();
        setupOpenGL();
        while (glfwWindowShouldClose(windowID) != GL_TRUE) {
            loop();
            glfwSwapBuffers(windowID);
            glfwPollEvents();
        }
        glfwDestroyWindow(windowID);
        glfwTerminate();
    }

    public void setupContext() {
        glfwSetErrorCallback(errorCallback);

        glfwInit();

        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 4);
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
        glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
        glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
        glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);

        windowID = glfwCreateWindow(900, 900, "TEXTURE TEST", NULL, NULL);

        glfwMakeContextCurrent(windowID);

        glfwSetKeyCallback(windowID, keyCallback);
        GL.createCapabilities();

        glError = GLUtil.setupDebugMessageCallback();
    }

    public void setupOpenGL() {
        glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        int vao = glGenVertexArrays();
        glBindVertexArray(vao);

        int vbo = glGenBuffers();

        float vboArray[] = new float[] {
                -0.75f, -0.75f, 0.0f, 0.0f,
                -0.75f, 0.75f, 0.0f, 1.0f,
                0.75f, 0.75f, 1.0f, 1.0f,
                0.75f, -0.75f, 1.0f, 0.0f
        };

        FloatBuffer vboBuffer = generateFloatBuffer(vboArray);

        glBindBuffer(GL_ARRAY_BUFFER, vbo);
        glBufferData(GL_ARRAY_BUFFER, vboBuffer, GL_STATIC_DRAW);

        int ebo = glGenBuffers();

        short eboArray[] = new short[] {
                0, 1, 2,
                2, 3, 0
        };

        ShortBuffer eboBuffer = generateShortBuffer(eboArray);

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, eboBuffer, GL_STATIC_DRAW);

        String vertexShaderSource = "#version 150 core\n" +
                "in vec2 pos;\n" +
                "in vec2 uv;\n" +
                "out vec2 UV;\n" +
                "void main() {\n" +
                "UV = uv;\n" +
                "gl_Position = vec4(pos, 0.0, 1.0);\n" +
                "}";

        String fragmentShaderSource = "#version 150 core\n" +
                "in vec2 UV;\n" +
                "uniform sampler2D tex;\n" +
                "out vec4 fragColor;\n" +
                "void main() {\n" +
                "fragColor = texture(tex, UV);\n" +
                "}";

        int vertexShader = compileShader(GL_VERTEX_SHADER, vertexShaderSource);
        int fragmentShader = compileShader(GL_FRAGMENT_SHADER, fragmentShaderSource);
        int program = linkProgram(vertexShader, fragmentShader);

        glValidateProgram(program);
        glUseProgram(program);

        posAttrib = glGetAttribLocation(program, "pos");
        glEnableVertexAttribArray(posAttrib);
        glVertexAttribPointer(posAttrib, 2, GL_FLOAT, false, 4, 0);

        uvAttrib = glGetAttribLocation(program, "uv");
        glEnableVertexAttribArray(uvAttrib);
        glVertexAttribPointer(uvAttrib, 2, GL_FLOAT, false, 4, 2);

        glBindFragDataLocation(program, 0, "fragColor");

        texUni = glGetUniformLocation(program, "tex");

        tex = glGenTextures();
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, tex);
        ByteBuffer textureBuffer = getTexture("/borderPanelTest.png");
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, textureBuffer);
        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);
    }

    public void loop() {
        glClear(GL_COLOR_BUFFER_BIT);
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
    }
}