I&#39;ve been attempting to write a two-pass GPU implementation of the Marching Cubes algorithm, similar to the one detailed in the first chapter of GPU Gems 3, using OpenGL and GLSL. However, the call to `glDrawArrays` in my first pass consistently fails with a `GL_INVALID_OPERATION`.

I&#39;ve looked up all the documentation I can find, and found these conditions under which `glDrawArrays` can throw that error:

 1. `GL_INVALID_OPERATION` is generated if a non-zero buffer object name is bound to an enabled array or to the `GL_DRAW_INDIRECT_BUFFER` binding and the buffer object&#39;s data store is currently mapped.
 2. `GL_INVALID_OPERATION` is generated if `glDrawArrays` is executed between the execution of `glBegin` and the corresponding `glEnd`.
 3. `GL_INVALID_OPERATION` will be generated by `glDrawArrays` or `glDrawElements` if any two active samplers in the current program object are of different types, but refer to the same texture image unit.
 4. `GL_INVALID_OPERATION` is generated if a geometry shader is active and mode is incompatible with the input primitive type of the geometry shader in the currently installed program object.
 5. `GL_INVALID_OPERATION` is generated if mode is `GL_PATCHES` and no tessellation control shader is active.
 6. `GL_INVALID_OPERATION` is generated if recording the vertices of a primitive to the buffer objects being used for transform feedback purposes would result in either exceeding the limits of any buffer object’s size, or in exceeding the end position offset + size - 1, as set by `glBindBufferRange`.
 7. `GL_INVALID_OPERATION` is generated by `glDrawArrays()` if no geometry shader is present, transform feedback is active and mode is not one of the allowed modes.
 8. `GL_INVALID_OPERATION` is generated by `glDrawArrays()` if a geometry shader is present, transform feedback is active and the output primitive type of the geometry shader does not match the transform feedback primitiveMode.
 9. `GL_INVALID_OPERATION` is generated if the bound shader program is invalid.
 10. **EDIT 10/10/12:** `GL_INVALID_OPERATION` is generated if transform feedback is in use, and the buffer bound to the transform feedback binding point is also bound to the array buffer binding point. **This is the problem I was having, due to a typo in which buffer I bound. While the spec does state that this is illegal, it isn&#39;t listed under glDrawArrays as one of the reasons it can throw an error, in any documentation I found.**

Unfortunately, no one piece of official documentation I can find covers more than 3 of these. I had to collect this list from numerous sources. Points 7 and 8 actually come from the documentation for `glBeginTransformFeedback`, and point 9 doesn&#39;t seem to be documented at all. I found it mentioned in a forum post somewhere. However, I still don&#39;t think this list is complete, as none of these seem to explain the error I&#39;m getting.

 1. I&#39;m not mapping any buffers at all in my program, anywhere.
 2. I&#39;m using the Core profile, so `glBegin` and `glEnd` aren&#39;t even available.
 3. I have two samplers, and they are of different types, but they&#39;re definitely mapped to different textures.
 4. A geometry shader is active, but it&#39;s input layout is `layout (points) in`, and `glDrawArrays` is being called with `GL_POINTS`.
 5. I&#39;m not using `GL_PATCHES` or tessellation shaders of any sort.
 6. I&#39;ve made sure I&#39;m allocating the maximum amount of space my geometry shaders could possible output. Then I tried quadrupling it. Didn&#39;t help.
 7. There is a geometry shader. See the next point.
 8. Transform feedback is being used, and there is a geometry shader, but the output layout is `layout (points) out` and `glBeginTransformFeedback` is called with `GL_POINTS`.
 9. I tried inserting a call to `glValidateProgram` right before the call to `glDrawArrays`, and it returned `GL_TRUE`.

The actual OpenGL code is here:

        const int SECTOR_SIZE = 32;
        const int SECTOR_SIZE_CUBED = SECTOR_SIZE * SECTOR_SIZE * SECTOR_SIZE;
        const int CACHE_SIZE = SECTOR_SIZE + 3;
        const int CACHE_SIZE_CUBED = CACHE_SIZE * CACHE_SIZE * CACHE_SIZE;
        
        MarchingCubesDoublePass::MarchingCubesDoublePass(ServiceProvider* svc, DensityMap* sourceData) {
            this-&gt;sourceData = sourceData;
            densityCache = new float[CACHE_SIZE_CUBED];
        }
        
        MarchingCubesDoublePass::~MarchingCubesDoublePass() {
            delete densityCache;
        }
        
        void MarchingCubesDoublePass::InitShaders() {
            ShaderInfo vertShader, geoShader, fragShader;
            
            vertShader = svc-&gt;shader-&gt;Load(&quot;data/shaders/MarchingCubesDoublePass-Pass1.vert&quot;, GL_VERTEX_SHADER);
            svc-&gt;shader-&gt;Compile(vertShader);
            geoShader = svc-&gt;shader-&gt;Load(&quot;data/shaders/MarchingCubesDoublePass-Pass1.geo&quot;, GL_GEOMETRY_SHADER);
            svc-&gt;shader-&gt;Compile(geoShader);
            shaderPass1 = glCreateProgram();
            static const char* outputVaryings[] = { &quot;triangle&quot; };
            glTransformFeedbackVaryings(shaderPass1, 1, outputVaryings, GL_SEPARATE_ATTRIBS);
            assert(svc-&gt;shader-&gt;Link(shaderPass1, vertShader, geoShader));
            
            uniPass1DensityMap = glGetUniformLocation(shaderPass1, &quot;densityMap&quot;);
            uniPass1TriTable = glGetUniformLocation(shaderPass1, &quot;triangleTable&quot;);
            uniPass1Size = glGetUniformLocation(shaderPass1, &quot;size&quot;);
            attribPass1VertPosition = glGetAttribLocation(shaderPass1, &quot;vertPosition&quot;);
            
            vertShader = svc-&gt;shader-&gt;Load(&quot;data/shaders/MarchingCubesDoublePass-Pass2.vert&quot;, GL_VERTEX_SHADER);
            svc-&gt;shader-&gt;Compile(vertShader);
            geoShader = svc-&gt;shader-&gt;Load(&quot;data/shaders/MarchingCubesDoublePass-Pass2.geo&quot;, GL_GEOMETRY_SHADER);
            svc-&gt;shader-&gt;Compile(geoShader);
            fragShader = svc-&gt;shader-&gt;Load(&quot;data/shaders/MarchingCubesDoublePass-Pass2.frag&quot;, GL_FRAGMENT_SHADER);
            svc-&gt;shader-&gt;Compile(fragShader);
            shaderPass2 = glCreateProgram();
            assert(svc-&gt;shader-&gt;Link(shaderPass2, vertShader, geoShader, fragShader));
            
            uniPass2DensityMap = glGetUniformLocation(shaderPass2, &quot;densityMap&quot;);
            uniPass2Size = glGetUniformLocation(shaderPass2, &quot;size&quot;);
            uniPass2Offset = glGetUniformLocation(shaderPass2, &quot;offset&quot;);
            uniPass2Matrix = glGetUniformLocation(shaderPass2, &quot;matrix&quot;);
            attribPass2Triangle = glGetAttribLocation(shaderPass2, &quot;triangle&quot;);
        }
        
        void MarchingCubesDoublePass::InitTextures() {
            for (int x = 0; x &lt; CACHE_SIZE; x++) {
                for (int y = 0; y &lt; CACHE_SIZE; y++) {
                    for (int z = 0; z &lt; CACHE_SIZE; z++) {
                        densityCache[x + y*CACHE_SIZE + z*CACHE_SIZE*CACHE_SIZE] = sourceData-&gt;GetDensity(Vector3(x-1, y-1, z-1));
                    }
                }
            }
            glGenTextures(1, &amp;densityTex);
            glBindTexture(GL_TEXTURE_3D, densityTex);
            glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
            glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
            glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
            glTexImage3D(GL_TEXTURE_3D, 0, GL_R32F, CACHE_SIZE, CACHE_SIZE, CACHE_SIZE, 0, GL_RED, GL_FLOAT, densityCache);
            
            glGenTextures(1, &amp;triTableTex);
            glBindTexture(GL_TEXTURE_RECTANGLE, triTableTex);
            glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
            glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
            glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
            glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
            glTexImage2D(GL_TEXTURE_RECTANGLE, 0, GL_R16I, 16, 256, 0, GL_RED_INTEGER, GL_INT, triTable);
        }
        
        void MarchingCubesDoublePass::InitBuffers() {
            float* voxelGrid = new float[SECTOR_SIZE_CUBED*3];
            unsigned int index = 0;
            for (int x = 0; x &lt; SECTOR_SIZE; x++) {
                for (int y = 0; y &lt; SECTOR_SIZE; y++) {
                    for (int z = 0; z &lt; SECTOR_SIZE; z++) {
                        voxelGrid[index*3 + 0] = x;
                        voxelGrid[index*3 + 1] = y;
                        voxelGrid[index*3 + 2] = z;
                        index++;
                    }
                }
            }
            
            glGenBuffers(1, &amp;bufferPass1);
            glBindBuffer(GL_ARRAY_BUFFER, bufferPass1);
            glBufferData(GL_ARRAY_BUFFER, SECTOR_SIZE_CUBED*3*sizeof(float), voxelGrid, GL_STATIC_DRAW);
            glBindBuffer(GL_ARRAY_BUFFER, 0);
            
            glGenBuffers(1, &amp;bufferPass2);
            glBindBuffer(GL_ARRAY_BUFFER, bufferPass2);
            glBufferData(GL_ARRAY_BUFFER, SECTOR_SIZE_CUBED*5*sizeof(int), NULL, GL_DYNAMIC_COPY);
            glBindBuffer(GL_ARRAY_BUFFER, 0);
            
            glGenVertexArrays(1, &amp;vaoPass1);
            glBindVertexArray(vaoPass1);
            glBindBuffer(GL_ARRAY_BUFFER, bufferPass1);
            glVertexAttribPointer(attribPass1VertPosition, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
            glBindBuffer(GL_ARRAY_BUFFER, 0);
            glEnableVertexAttribArray(attribPass1VertPosition);
            glBindVertexArray(0);
            
            glGenVertexArrays(1, &amp;vaoPass2);
            glBindVertexArray(vaoPass2);
            glBindBuffer(GL_ARRAY_BUFFER, bufferPass2);
            glVertexAttribIPointer(attribPass2Triangle, 1, GL_INT, 0, (void*)0);
            glBindBuffer(GL_ARRAY_BUFFER, 0);
            glEnableVertexAttribArray(attribPass2Triangle);
            glBindVertexArray(0);
            
            glGenQueries(1, &amp;queryNumTriangles);
        }
        
        void MarchingCubesDoublePass::Register(Genesis::ServiceProvider* svc, Genesis::Entity* ent) {
            this-&gt;svc = svc;
            this-&gt;ent = ent;
            svc-&gt;scene-&gt;RegisterEntity(ent);
            
            InitShaders();
            InitTextures();
            InitBuffers();
        }
        
        void MarchingCubesDoublePass::Unregister() {
            if (!ent-&gt;GetBehavior&lt;Genesis::Render&gt;()) {
                svc-&gt;scene-&gt;UnregisterEntity(ent);
            }
        }
        
        void MarchingCubesDoublePass::RenderPass1() {
            glEnable(GL_RASTERIZER_DISCARD);
            
            glUseProgram(shaderPass1);
            glActiveTexture(GL_TEXTURE0);
            glBindTexture(GL_TEXTURE_3D, densityTex);
            glActiveTexture(GL_TEXTURE1);
            glBindTexture(GL_TEXTURE_RECTANGLE, triTableTex);
            glUniform1i(uniPass1DensityMap, 0);
            glUniform1i(uniPass1TriTable, 1);
            glUniform1i(uniPass1Size, SECTOR_SIZE);
            
            glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufferPass2);
            
            glBindVertexArray(vaoPass2);
            glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, queryNumTriangles);
            glBeginTransformFeedback(GL_POINTS);
                GLenum error = glGetError();
                glDrawArrays(GL_POINTS, 0, SECTOR_SIZE_CUBED);
                error = glGetError();
            glEndTransformFeedback();
            glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
            glBindVertexArray(0);
            
            glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
            
            glUseProgram(0);
            
            glDisable(GL_RASTERIZER_DISCARD);
            
            glGetQueryObjectuiv(queryNumTriangles, GL_QUERY_RESULT, &amp;numTriangles);
        }
        
        void MarchingCubesDoublePass::RenderPass2(Matrix mat) {
            glUseProgram(shaderPass2);
            
            glActiveTexture(GL_TEXTURE0);
            glBindTexture(GL_TEXTURE_3D, densityTex);
            
            glUniform1i(uniPass2DensityMap, 0);
            glUniform1i(uniPass2Size, SECTOR_SIZE);
            glUniform3f(uniPass2Offset, 0, 0, 0);
            mat.UniformMatrix(uniPass2Matrix);
            
            glBindVertexArray(vaoPass2);
            glDrawArrays(GL_POINTS, 0, numTriangles);
            glBindVertexArray(0);
            
            glUseProgram(0);
        }
        
        void MarchingCubesDoublePass::OnRender(Matrix mat) {
            RenderPass1();
            RenderPass2(mat);
        }

The actual error is the call to `glDrawArrays` in `RenderPass1`. Worth noting that if I comment out the calls to `glBeginTransformFeedback` and `glEndTransformFeedback`, then `glDrawArrays` stops generating the error. So whatever&#39;s wrong, it&#39;s probably somehow related to transform feedback.

**Edit 8/18/12, 9 PM:**

I just found the NVIDIA GLExpert feature in gDEBugger, which I wasn&#39;t previously familiar with. When I turned this on, it gave somewhat more substantial information on the `GL_INVALID_OPERATION`, specifically `The current operation is illegal in the current state:  Buffer is mapped.`. So I&#39;m running into point 1, above. Though I have no idea how.

I have no calls to `glMapBuffer`, or any related function, anywhere in my code. I set gDEBugger to break on any calls to `glMapBuffer`, `glMapBufferARB`, `glMapBufferRange`, `glUnmapBuffer` and `glUnmapBufferARB`, and it didn&#39;t break anywhere. Then I added code to the start of `RenderPass1` to explicitly unmap bother buffers. Not only did the error not go away, but calls to `glUnmapBuffer` now both generate `The current operation is illegal in the current state:  Buffer is unbound or is already unmapped.`. So if neither of the buffers I&#39;m using are mapped, where is the error coming from?

**Edit 8/19/12, 12 AM:**

Based on the error messages I&#39;m getting out of GLExpert in gDEBugger, it appears that calling `glBeginTransformFeedback` is causing the buffer bound to `GL_TRANSFORM_FEEDBACK_BUFFER` to become mapped. Specifically, when I click on the buffer in &quot;Textures, Buffers and Images Viewer&quot; it outputs the message `The current operation is illegal in the current state:  Buffer must be bound and not mapped.`. However, if I add this between `glBeginTransformFeedback` and `glEndTransformFeedback`:

    int bufferBinding;
    glGetBufferParameteriv(GL_TRANSFORM_FEEDBACK_BUFFER, GL_BUFFER_MAPPED, &amp;bufferBinding);
    printf(&quot;Transform feedback buffer binding: %d\n&quot;, bufferBinding);

it outputs 0, which would indicate that `GL_TRANSFORM_FEEDBACK_BUFFER` is not mapped. If this buffer is mapped on another binding point, would this still return 0? Why would `glBeginTransformFeedback` map the buffer, thus rendering it unusable for transform feedback?

The more I learn here, the more confused I&#39;m becoming.

**Edit 10/10/12:**

As indicated in my reply below to Nicol Bolas&#39; solution, I found the problem, and it&#39;s the same one he found: Due to a stupid typo, I was binding the same buffer to both the input and output binding points.

I found it probably two weeks after posting the question. I&#39;d given up in frustration for a time, and eventually came back and basically re-implemented the whole thing from scratch, regularly comparing bits and pieces the older, non-working one. When I was done, the new version worked, and it was when I searched out the differences that I discovered I&#39;d been binding the wrong buffer.

All Marching Cubes Solutions on Gang of Coders

Total of 1 Marching Cubes Solutions

What can cause glDrawArrays to generate a GL_INVALID_OPERATION error?