title: glReadPixels always returns the same value in glClearColor
body: <p>I've been struggling to understand the output of glReadPixels, which appears to be straightforward in theory, but actually produces puzzling (at least to me) results. </p>
  
  <p>Let's assume I have a simple fragment shader that draws a single triangle with a color value of vec4(0.2, 0, 0, 0), whereas the background color is set to (0.3, 1.0, 1.0, 0.0), like so:</p>
  
  <p><a href="https://i.stack.imgur.com/XlgnP.jpg" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/XlgnP.jpg" alt="enter image description here"></a></p>
  
  <p>Below is the complete code (with the exception of shader construction) that I use to produce the image above:</p>
  
  <pre><code>#include "shader.h" // shader compile/link/use 
  #include &lt;GLFW\glfw3.h&gt;
  #include &lt;iostream&gt;
  
  const int DISPLAY_WIDTH = 16; 
  const int DISPLAY_HEIGHT = 16; 
  
  //============= shader code ==========================
  
  const GLchar *vertexShaderSource = R"glsl(#version 440
  in vec2 position;
  void main()
  {
      gl_Position = vec4(position, 0.0, 1.0);
  })glsl";
  
  const GLchar *fragmentShaderSource = R"glsl(#version 440
  out vec4 outColor;
  
  void main()
  {   
      outColor = vec4(0.2,0.,0.,0.);
  })glsl";
  
  //============= c++ entry point ==========================
  
  int main(int argc, char** argv) {
  
      glfwInit();
      GLFWwindow* window = glfwCreateWindow(DISPLAY_WIDTH, DISPLAY_HEIGHT, "test", NULL, NULL);
      glfwMakeContextCurrent(window);
  
      GLenum res = glewInit();
  
      // triangle data (xy-position)
      float vertices[] = {
      0.0f, 0.5f, 
      0.5f, -0.5f, 
      -0.5f, -0.5f  
      };
  
      GLuint vbo;
      glGenBuffers(1, &amp;vbo); 
      glBindBuffer(GL_ARRAY_BUFFER, vbo);
      glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
  
      // enable vertex xy-position attribute 
      glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
      glEnableVertexAttribArray(0);
  
      // compile, link and use shader program
      Shader shader(vertexShaderSource, fragmentShaderSource);
      shader.Use();
  
      // rendering loop
      while (!glfwWindowShouldClose(window)) {
  
         glClearColor(0.3f, 1.0f, 1.0f, 0.0f);
         glClear(GL_COLOR_BUFFER_BIT);
  
         glDrawArrays(GL_TRIANGLES, 0, 3);
         glFlush();
  
         // read pixels from backbuffer 
         GLubyte data[DISPLAY_WIDTH * DISPLAY_HEIGHT];
         glReadPixels(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT, GL_RED, GL_UNSIGNED_BYTE, data);
  
         for (int i = 0; i &lt; DISPLAY_WIDTH * DISPLAY_HEIGHT; i++) {
             int a = data[i]; // implicit conversion of unsigned char to int
             std::cout &lt;&lt; a &lt;&lt; std::endl;
         }
         std::getchar(); // wait for user input
  
         glfwSwapBuffers(window);
         glfwPollEvents();
      }
  
     glfwTerminate(); 
     return 0;
  }
  </code></pre>
  
  <p>Note, that I am using a default framebuffer, which will treat my color values as normalized signed integers and will convert them to the range between [0-255], i.e. my background color is going to be (76, 255, 255, 0), whereas my geometry color is going to be (51, 0, 0, 0).</p>
  
  <p>And so after I draw my geometry and swap the buffers, I get my image. Now I want to read out the color values. In order to do it, I insert the necessary glReadPixels related code right before I swap buffers:</p>
  
  <pre><code>GLubyte* data = new GLubyte[DISPLAY_WIDTH * DISPLAY_HEIGHT];
  glReadPixels(0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT, GL_RED, GL_UNSIGNED_BYTE, data);
  </code></pre>
  
  <p>In order to facilitate the process of examining pixel values that I read out from the framebuffer, I just extract red channel, hence the size of data necessary to accommodate pixel data is <code>DISPLAY_WIDTH * DISPLAY_HEIGHT</code>. Furthermore, it means that the values I print out are supposed to be '76' for the background color, and '51' for geometry. </p>
  
  <p>Surprisingly, every single red channel pixel data (all the DISPLAY_WIDTH * DISPLAY_HEIGHT pixels are printed) I print out happens to be '76', as if geometry is ignored. Note that I read pixels after the draw call and before I swap buffers. </p>
  
  <p>I would greatly appreciate if you could let me know what I am missing in here.</p>