OpenCL/GL Interop is all white :(

static int screenWidth = 800;
static int screenHeight = 600;
static int imageWidth = 512;
static int imageHeight = 512;

int main( int argc, char* argv[] )
{

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
    glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE );

    // Setup OpenGL context
    glfwInit();
    glfwSwapInterval(0);
    GLFWwindow* window = 0;
    window = glfwCreateWindow( screenWidth, screenHeight, "OpenCL Ray Tracer", nullptr, nullptr );

    if(!window)
    {
        glfwTerminate();
        return -1;
    }

    glfwSetErrorCallback( error_callback );
    glfwSetKeyCallback( window, key_callback );
    glfwMakeContextCurrent(window);

    glfwGetFramebufferSize(window, &screenWidth, &screenHeight);
    glViewport(0, 0, screenWidth, screenHeight);
    glfwSetFramebufferSizeCallback( window, framebuffer_size_callback );

    glewExperimental = GL_TRUE; //This makes it work on newer graphics cards
    if( glewInit() != GLEW_OK ){
            printf( "Failed to init GLEW\n" );
            return -3;
    }

    // Setup OpenCL context to work with OpenGL
    // Load source file
    std::ifstream file("vector_add_kernel.cl");
    if(!file.is_open())
    {
        return -1;
    }

    std::string source( (std::istreambuf_iterator<char>(file)),
                        std::istreambuf_iterator<char>() );
    unsigned int sourceLength = source.length();
    file.close();

    cl_platform_id platformId = 0;
    cl_device_id deviceId = 0;
    cl_uint numDevices;
    cl_uint numPlatforms;
    cl_int ret;

    // Get platform info
    ret = clGetPlatformIDs( 1, &platformId, &numPlatforms );

    // Get device info
    ret = clGetDeviceIDs( platformId, CL_DEVICE_TYPE_GPU, 1, &deviceId, &numDevices );

    // Create an OpenCL context shared with OpenGL
    cl_context_properties properties[] = {
        CL_CONTEXT_PLATFORM, (cl_context_properties)platformId,
        CL_GL_CONTEXT_KHR, (cl_context_properties)wglGetCurrentContext(),
        CL_WGL_HDC_KHR, (cl_context_properties)wglGetCurrentDC(),
        0
    };
    cl_context context = clCreateContext( properties, 1, &deviceId, cl_callback, 0, &ret );

    // Create a command queue
    cl_command_queue commandQueue = clCreateCommandQueue( context, deviceId, CL_QUEUE_PROFILING_ENABLE, &ret);

    // Create the kernel program
    const char* source_cst = source.c_str();
    cl_program program = clCreateProgramWithSource( context, 1,
        &source_cst, &sourceLength, &ret);

    // Build the program
    ret = clBuildProgram( program, 1, &deviceId, "-cl-single-precision-constant -cl-mad-enable -cl-fast-relaxed-math -I kernels/ -cl-std=CL1.1", NULL, NULL );

    // Check build for errors
    if( ret == CL_BUILD_PROGRAM_FAILURE )
    {
        // Determine the size of the log
        size_t log_size;
        clGetProgramBuildInfo( program, deviceId, CL_PROGRAM_BUILD_LOG,
            0, 0, &log_size );

        char* log = new char[log_size];

         // Get the log
        clGetProgramBuildInfo(program, deviceId, CL_PROGRAM_BUILD_LOG,
            log_size, log, NULL);

        // Print log
        std::cout << log;
        std::cin.get();
        return -1;

    }
    else
    {
        CLERR(ret);
    }

    // Create the OpenCL Kernel
    cl_kernel kernel = clCreateKernel( program, "Draw", &ret );

    // Create vertex buffer
    float qs = 1.0f;

    // posx, posy, u, v
    static const float vertexBufferData[] =
    {
        -qs, -qs, 0.0f, 0.0f,
        -qs, qs, 0.0f, 1.0f,
        qs, -qs, 1.0f, 0.0f,
        qs, qs, 1.0f, 1.0f,
    };

    GLuint vertexArrayID;
    glGenVertexArrays( 1, &vertexArrayID );
    glBindVertexArray( vertexArrayID );

    GLuint vertexBuffer;
    glGenBuffers( 1, &vertexBuffer );
    glBindBuffer( GL_ARRAY_BUFFER, vertexBuffer );
    glBufferData( GL_ARRAY_BUFFER, sizeof(float) * 16, vertexBufferData, GL_STATIC_DRAW );

    // Create the openGL fullscreen quad program
    GLuint quadProgramID = LoadShaders( "draw_quad.vertex", "draw_quad.fragment" );

    // Create a gl texture for use as the
    GLuint textureID;
    glGenTextures( 1, &textureID );
    glBindTexture( GL_TEXTURE_2D, textureID );

    // Fill texture with green
    std::vector<float> texdata(imageWidth * imageHeight * 4, 0);
    for( unsigned int i = 0; i < texdata.size(); i+=4 )
    {
        texdata[i]  = 0;
        texdata[i+1]    = 1.0f;
        texdata[i+2]    = 0;
        texdata[i+3]    = 1.0f;
    }
    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, imageWidth, imageHeight, 0, GL_RGBA, GL_FLOAT, &texdata[0] );
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
    glBindTexture( GL_TEXTURE_2D, 0 );
    glActiveTexture(GL_TEXTURE0);
    glBindTexture( GL_TEXTURE_2D, textureID );
    glUseProgram( quadProgramID );

    // Get texture shader location
    GLuint uniformTextureID = glGetUniformLocation( quadProgramID, "image" );

    // Set the texture uniform in shader
    glUniform1i( uniformTextureID, 0 );
    glBindTexture( GL_TEXTURE_2D, 0 );

    // Create OpenCL memobject from gl texture
    cl_mem textureMem = clCreateFromGLTexture2D( context, CL_MEM_WRITE_ONLY, GL_TEXTURE_2D, 0, textureID, &ret );

    while (!glfwWindowShouldClose(window))
    {

        float ratio;

        glfwGetFramebufferSize(window, &screenWidth, &screenHeight);
        ratio = screenWidth / (float) screenHeight;

        // Do OpenCL
        // Force OpenGL to finish
        glFinish();

        // Set kernel args
        ret = clSetKernelArg( kernel, 0, sizeof(cl_mem), (void *)&textureMem );
        ret = clSetKernelArg( kernel, 1, sizeof(int), (void *)&imageWidth );
        ret = clSetKernelArg( kernel, 2, sizeof(int), (void *)&imageHeight );

        cl_event event[3];
        // Aquire the texture memory
        ret = clEnqueueAcquireGLObjects( commandQueue, 1, &textureMem, 0, NULL, &event[0] );

        // Execute kernel
        size_t globalWorkSize[] = {imageWidth, imageHeight};
        size_t localWorkSize[] = {32,32};
        ret = clEnqueueNDRangeKernel( commandQueue, kernel, 2, NULL, globalWorkSize, localWorkSize, 1, &event[0], &event[1] );

        // Make OpenCL release the texture memory
        ret = clEnqueueReleaseGLObjects( commandQueue, 1, &textureMem, 1, &event[1], &event[2] );

        clWaitForEvents( 1, &event[2] );

        // Render a textured quad
        glClear( GL_COLOR_BUFFER_BIT );
        glUseProgram( quadProgramID );
        glBindBuffer( GL_ARRAY_BUFFER, vertexBuffer );

        glActiveTexture(GL_TEXTURE0);
        glBindTexture( GL_TEXTURE_2D, textureID );

        glEnableVertexAttribArray( 0 );
        glVertexAttribPointer( 0, 4, GL_FLOAT, GL_FALSE, 0, (void*)0 );

        glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );

        glDisableVertexAttribArray( 0 );

        glUseProgram(0);

        glfwSwapBuffers( window );

        glFinish();

        glfwPollEvents();


    }

    glfwDestroyWindow(window);
    glfwTerminate();
    return 0;
}