tests/fbo/fbo-readpixels.c

   1 /*
   2  * Copyright © 2009 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *    Eric Anholt <eric@anholt.net>
  25  *
  26  */
  27
  28 /** @file fbo-readpixels.c
  29  *
  30  * Tests that various formats of color renderbuffer get correct results from
  31  * glReadPixels() versus glClear and immediate mode rendering.
  32  */
  33
  34 #include "piglit-util-gl.h"
  35
  36 #define BUF_WIDTH 32
  37 #define BUF_HEIGHT 32
  38
  39 PIGLIT_GL_TEST_CONFIG_BEGIN
  40
  41         config.supports_gl_compat_version = 10;
  42
  43         config.window_visual = PIGLIT_GL_VISUAL_DOUBLE | PIGLIT_GL_VISUAL_RGB;
  44         config.khr_no_error_support = PIGLIT_NO_ERRORS;
  45
  46 PIGLIT_GL_TEST_CONFIG_END
  47
  48 static GLboolean
  49 test_with_format(GLenum internal_format, GLenum format,
  50                  float results_x, float results_y)
  51 {
  52         GLuint tex, fb;
  53         GLenum status;
  54         GLboolean pass = GL_TRUE;
  55         int subrect_w = BUF_WIDTH / 5;
  56         int subrect_h = BUF_HEIGHT / 5;
  57         int x, y;
  58         int rbits, gbits, bbits, abits;
  59
  60         glGenTextures(1, &tex);
  61         glBindTexture(GL_TEXTURE_2D, tex);
  62         glTexImage2D(GL_TEXTURE_2D, 0, internal_format,
  63                      BUF_WIDTH, BUF_HEIGHT, 0,
  64                      format, GL_UNSIGNED_BYTE, NULL);
  65
  66         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  67         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  68
  69         glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_RED_SIZE,
  70                                  &rbits);
  71         glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_GREEN_SIZE,
  72                                  &gbits);
  73         glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_BLUE_SIZE,
  74                                  &bbits);
  75         glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_ALPHA_SIZE,
  76                                  &abits);
  77
  78         printf("testing with format %s, %s "
  79                "(%d,%d,%d,%d rgba)\n",
  80                piglit_get_gl_enum_name(internal_format),
  81                piglit_get_gl_enum_name(format),
  82                rbits, gbits, bbits, abits);
  83
  84         glGenFramebuffersEXT(1, &fb);
  85         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
  86         glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
  87                                   GL_COLOR_ATTACHMENT0_EXT,
  88                                   GL_TEXTURE_2D,
  89                                   tex,
  90                                   0);
  91         if (!piglit_check_gl_error(GL_NO_ERROR))
  92                 piglit_report_result(PIGLIT_FAIL);
  93
  94         status = glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT);
  95         if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
  96                 fprintf(stderr, "texture for internalformat %s. "
  97                         "format %s is framebuffer "
  98                         "incomplete (status = %s)\n",
  99                         piglit_get_gl_enum_name(internal_format),
 100                         piglit_get_gl_enum_name(format),
 101                         piglit_get_gl_enum_name(status));
 102                 goto done;
 103         }
 104
 105         /* Set matrices */
 106         glViewport(0, 0, BUF_WIDTH, BUF_HEIGHT);
 107         piglit_ortho_projection(BUF_WIDTH, BUF_HEIGHT, GL_FALSE);
 108
 109         /* clear background to purple */
 110         glClearColor(1.0, 0.0, 1.0, 0.0);
 111         glClear(GL_COLOR_BUFFER_BIT);
 112
 113         /* lower-left square: red */
 114         glColor4f(1.0, 0.0, 0.0, 0.0);
 115         piglit_draw_rect(subrect_w * 1, subrect_h * 1,
 116                          subrect_w, subrect_h);
 117
 118         /* lower-right square: green */
 119         glColor4f(0.0, 1.0, 0.0, 0.0);
 120         piglit_draw_rect(subrect_w * 3, subrect_h * 1,
 121                          subrect_w, subrect_h);
 122
 123         /* upper-left square: blue */
 124         glColor4f(0.0, 0.0, 1.0, 0.0);
 125         piglit_draw_rect(subrect_w * 1, subrect_h * 3,
 126                          subrect_w, subrect_h);
 127
 128         /* upper-right square: black */
 129         glColor4f(0.0, 0.0, 0.0, 1.0);
 130         piglit_draw_rect(subrect_w * 3, subrect_h * 3,
 131                          subrect_w, subrect_h);
 132
 133         for (y = 0; y < BUF_HEIGHT; y++) {
 134                 for (x = 0; x < BUF_WIDTH; x++) {
 135                         float expected[4];
 136
 137                         if (x >= subrect_w * 1 && x < subrect_w * 2 &&
 138                             y >= subrect_h * 1 && y < subrect_h * 2) {
 139                                 expected[0] = 1.0;
 140                                 expected[1] = 0.0;
 141                                 expected[2] = 0.0;
 142                                 expected[3] = 0.0;
 143                         } else if (x >= subrect_w * 3 && x < subrect_w * 4 &&
 144                                    y >= subrect_h * 1 && y < subrect_h * 2) {
 145                                 expected[0] = 0.0;
 146                                 expected[1] = 1.0;
 147                                 expected[2] = 0.0;
 148                                 expected[3] = 0.0;
 149                         } else if (x >= subrect_w * 1 && x < subrect_w * 2 &&
 150                                    y >= subrect_h * 3 && y < subrect_h * 4) {
 151                                 expected[0] = 0.0;
 152                                 expected[1] = 0.0;
 153                                 expected[2] = 1.0;
 154                                 expected[3] = 0.0;
 155                         } else if (x >= subrect_w * 3 && x < subrect_w * 4 &&
 156                                    y >= subrect_h * 3 && y < subrect_h * 4) {
 157                                 expected[0] = 0.0;
 158                                 expected[1] = 0.0;
 159                                 expected[2] = 0.0;
 160                                 expected[3] = 1.0;
 161                         } else {
 162                                 expected[0] = 1.0;
 163                                 expected[1] = 0.0;
 164                                 expected[2] = 1.0;
 165                                 expected[3] = 0.0;
 166                         }
 167                         pass &= piglit_probe_pixel_rgb(x, y, expected);
 168                 }
 169         }
 170
 171         /* display the texture by drawing a quad */
 172         glViewport(0, 0, piglit_width, piglit_height);
 173         piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
 174
 175         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
 176         glEnable(GL_TEXTURE_2D);
 177         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 178
 179         piglit_draw_rect_tex(results_x, results_y, BUF_WIDTH, BUF_HEIGHT,
 180                              0, 0, 1, 1);
 181         glDisable(GL_TEXTURE_2D);
 182
 183 done:
 184         glDeleteFramebuffersEXT(1, &fb);
 185         glDeleteTextures(1, &tex);
 186         return pass;
 187 }
 188
 189 enum piglit_result
 190 piglit_display(void)
 191 {
 192         GLboolean pass = GL_TRUE;
 193
 194         glClearColor(1.0, 1.0, 1.0, 1.0);
 195         glClear(GL_COLOR_BUFFER_BIT);
 196
 197         pass &= test_with_format(GL_RGBA8, GL_BGRA,
 198                                  0, 0);
 199         pass &= test_with_format(GL_RGB5, GL_RGB,
 200                                  0, BUF_HEIGHT + 1);
 201         pass &= test_with_format(GL_RGBA4, GL_BGRA,
 202                                  0, (BUF_HEIGHT + 1) * 2);
 203         pass &= test_with_format(GL_RGB5_A1, GL_BGRA,
 204                                  0, (BUF_HEIGHT + 1) * 3);
 205         piglit_present_results();
 206
 207         return pass ? PIGLIT_PASS : PIGLIT_FAIL;
 208 }
 209
 210 void piglit_init(int argc, char **argv)
 211 {
 212         piglit_require_extension("GL_EXT_framebuffer_object");
 213 }