OpenGL, glDraw* random GL_INVALID_OPERATION error.

[Romain_c_]

Hi,

I have a bug in my program I have "resolved" but I can't figure out why it is happening :/ I am using the latest sdk and glfw. I have one vbo that is shared with openCL, when I render I get random GL_INVALID_OPERATION after a draw operation, so sometimes things are draw and sometimes the screen is black. (Even if I use an empty kernel I get this problem and if I run the program using nvidia implementation I don't have this problem.)

My loop is like that: 1) draw

                              2) execute kernel.

Here is the render code when it bugs (note that a vao is already bound):

[cpp]

glClear(GL_COLOR_BUFFER_BIT);        

GLenum glError = glGetError();    

glDrawElements(GL_TRIANGLES, NUM_INDICES * num_bacterias, GL_UNSIGNED_INT, NULL);    

glError = glGetError();    

assert (GL_NO_ERROR == glError);    

glfwSwapBuffers();     

return viewer_no_error;

[/cpp]

Here is the render code when it works:

[cpp]

glClear(GL_COLOR_BUFFER_BIT);

    glBindVertexArray(bacteria_vao);

    // Render code here.

    GLenum glError = glGetError();

    glDrawElements(GL_TRIANGLES,

                   NUM_INDICES * num_bacterias,

                   GL_UNSIGNED_INT,

                   NULL);

    glError = glGetError();

    assert (GL_NO_ERROR == glError);

    glfwSwapBuffers();

    glBindVertexArray(0);

    return viewer_no_error;

[/cpp]

Here is where I execute the kernel:

[cpp]

cl_engine_status_t cl_engine_step_1D (const cl_engine_t* engine,

                                      const char* kernel,

                                      cl_buffer_t** buffers_to_acquire,

                                      int num_buffers,

                                      size_t work_size,

                                      size_t local_work_size)

{

    cl_int err;

    size_t g_work_size[1] = {work_size};

    size_t l_work_size[1] = {local_work_size};

    cl_mem* buffers = alloca(sizeof(cl_mem) * num_buffers);

    if (0 != num_buffers && NULL != buffers_to_acquire)

    {

        for (int i = 0; i < num_buffers; i++)

        {

            buffers = buffers_to_acquire->buffer;               

        }

        glFinish();

        err = clEnqueueAcquireGLObjects(engine->queue,

                                        num_buffers,

                                        buffers,

                                        0,

                                        NULL,

                                        NULL);

        if (CL_SUCCESS != err)

        {

            return cl_engine_failed_sync_buffers;

        }

    }

    err = clEnqueueNDRangeKernel(engine->queue,

                                 get_kernel(&engine->program, kernel),

                                 1,

                                 NULL,

                                 g_work_size,

                                 0 == local_work_size ? NULL : l_work_size,

                                 0,

                                 NULL,

                                 NULL);

    if (CL_SUCCESS != err)

    {

        return cl_engine_failed_to_enqueue_kernel;

    }

    if (0 != num_buffers && NULL != buffers_to_acquire)

    {

        err = clEnqueueReleaseGLObjects(engine->queue,

                                        num_buffers,

                                        buffers,

                                        0,

                                        NULL,

                                        NULL);  

        if (CL_SUCCESS != err)

        {

            return cl_engine_failed_sync_buffers;

        }

    }

    clFinish(engine->queue);    

    return cl_engine_no_error;

}

[/cpp]

So the only thing that change is that I rebind everytimes before rendering. I thought opencl was unbinding the vao but glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &current_vao) always report that my vao is bound. I have tested with opengl 4.3 and 3.3.

Thanks in advance for any possible help ! :)