tests/fbo/fbo-colormask-formats.c

   1 /*
   2  * Copyright © 2010 Intel Corporation
   3  * Copyright © 2012 Marek Olšák <maraeo@gmail.com>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  22  * IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Marek Olšák <maraeo@gmail.com>
  26  *
  27  */
  28
  29 #include "piglit-util-gl.h"
  30 #include "fbo-formats.h"
  31
  32 PIGLIT_GL_TEST_CONFIG_BEGIN
  33
  34         config.supports_gl_compat_version = 10;
  35
  36         config.window_width = 512;
  37         config.window_height = 32;
  38         config.window_visual = PIGLIT_GL_VISUAL_RGBA | PIGLIT_GL_VISUAL_DOUBLE;
  39         config.khr_no_error_support = PIGLIT_NO_ERRORS;
  40
  41 PIGLIT_GL_TEST_CONFIG_END
  42
  43 /**
  44  * Draw a quad with colormask
  45  */
  46 static void colormask(const float *rect, unsigned mask)
  47 {
  48         glColorMask(!!(mask & 1), !!(mask & 2), !!(mask & 4), !!(mask & 8));
  49         piglit_draw_rect(rect[0], rect[1], rect[2], rect[3]);
  50         glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  51 }
  52
  53 static enum piglit_result test_format(const struct format_desc *format)
  54 {
  55         GLboolean pass = GL_TRUE;
  56         GLuint tex, fb;
  57         GLenum status;
  58         int r, g, b, l, a, i;
  59         unsigned mask, k;
  60         float defaults[] = {-1, -1, -1, -1};
  61         const char *name = get_format_name(format->internalformat);
  62
  63         if (format->base_internal_format == GL_DEPTH_COMPONENT ||
  64             format->base_internal_format == GL_DEPTH_STENCIL ||
  65             format->base_internal_format == GL_STENCIL_INDEX)
  66                 return PIGLIT_SKIP;
  67
  68         glGenFramebuffersEXT(1, &fb);
  69         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
  70         glViewport(0, 0, piglit_width, piglit_height);
  71
  72         glGenTextures(1, &tex);
  73         glBindTexture(GL_TEXTURE_2D, tex);
  74         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  75         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  76         glTexImage2D(GL_TEXTURE_2D, 0, format->internalformat,
  77                      piglit_width, piglit_height, 0,
  78                      GL_RGBA, GL_FLOAT, NULL);
  79
  80         glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
  81                                  GL_TEXTURE_LUMINANCE_SIZE, &l);
  82         glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
  83                                  GL_TEXTURE_ALPHA_SIZE, &a);
  84         glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
  85                                  GL_TEXTURE_INTENSITY_SIZE, &i);
  86         glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
  87                                  GL_TEXTURE_RED_SIZE, &r);
  88         glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
  89                                  GL_TEXTURE_GREEN_SIZE, &g);
  90         glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
  91                                  GL_TEXTURE_BLUE_SIZE, &b);
  92
  93         /* Set up expected defaults.
  94          * We're using glReadPixels from the texture.
  95          */
  96         if (i) {
  97                 /* GL_INTENSITY texture:  result = (I,0,0,1) */
  98                 defaults[3] = 1;
  99                 defaults[2] = defaults[1] = 0;
 100         } else if (l) {
 101                 /* GL_LUMINANCE texture:  result = (L,0,0,A) */
 102                 defaults[2] = defaults[1] = 0;
 103                 if (!a) {
 104                         defaults[3] = 1;
 105                 }
 106         } else {
 107                 /* other format */
 108                 if (!r) {
 109                         defaults[0] = 0;
 110                 }
 111                 if (!g) {
 112                         defaults[1] = 0;
 113                 }
 114                 if (!b) {
 115                         defaults[2] = 0;
 116                 }
 117                 if (!a) {
 118                         defaults[3] = 1;
 119                 }
 120         }
 121
 122         /* Clamp the bits for the framebuffer, except we aren't checking
 123          * the actual framebuffer bits.
 124          */
 125         if (l > 8)
 126                 l = 8;
 127         if (i > 8)
 128                 i = 8;
 129         if (r > 8)
 130                 r = 8;
 131         if (g > 8)
 132                 g = 8;
 133         if (b > 8)
 134                 b = 8;
 135         if (a > 8)
 136                 a = 8;
 137
 138         if (i) {
 139                 piglit_set_tolerance_for_bits(i, i, i, i);
 140         } else if (l) {
 141                 piglit_set_tolerance_for_bits(l, l, l, a);
 142         } else {
 143                 piglit_set_tolerance_for_bits(r, g, b, a);
 144         }
 145
 146         glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
 147                                   GL_COLOR_ATTACHMENT0_EXT,
 148                                   GL_TEXTURE_2D,
 149                                   tex,
 150                                   0);
 151         if (!piglit_check_gl_error(GL_NO_ERROR))
 152                 piglit_report_result(PIGLIT_FAIL);
 153
 154         status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
 155         printf("Testing %s", name);
 156         if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
 157                 printf(" - fbo incomplete (status = %s)\n",
 158                        piglit_get_gl_enum_name(status));
 159                 piglit_report_subtest_result(PIGLIT_SKIP,
 160                                              "%s (fbo incomplete)",
 161                                              name);
 162                 return PIGLIT_SKIP;
 163         }
 164         printf("\n");
 165
 166         glClearColor(0.0, 0.0, 0.0, 0.0);
 167         glClear(GL_COLOR_BUFFER_BIT);
 168
 169         for (mask = 0; mask <= 15; mask++) {
 170                 float rect[4];
 171                 rect[0] = -1 + (mask / 8.0);
 172                 rect[1] = -1;
 173                 rect[2] = 2 / 16.0;
 174                 rect[3] = 2;
 175
 176                 colormask(rect, mask);
 177         }
 178
 179         for (mask = 0; mask <= 15; mask++) {
 180                 float color[4], out[4];
 181
 182                 for (k = 0; k < 4; k++) {
 183                         if (defaults[k] >= 0)
 184                                 color[k] = defaults[k];
 185                         else
 186                                 color[k] = (mask & (1 << k)) ? 1 : 0;
 187                 }
 188
 189                 if (!piglit_probe_pixel_rgba_silent(piglit_width * mask / 16, 0,
 190                                                     color, out)) {
 191                         printf("glColorMask(%i, %i, %i, %i)\n",
 192                                !!(mask & 1), !!(mask & 2),
 193                                !!(mask & 4), !!(mask & 8));
 194                         printf("  Expected: %f %f %f %f\n",
 195                                color[0], color[1], color[2], color[3]);
 196                         printf("  Observed: %f %f %f %f\n",
 197                                out[0], out[1], out[2], out[3]);
 198                         pass = GL_FALSE;
 199                 }
 200         }
 201
 202         /*
 203          * Display the texture.
 204          */
 205         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
 206         glViewport(0, 0, piglit_width, piglit_height);
 207
 208         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
 209         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,   GL_REPLACE);
 210         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
 211
 212         glColor4f(1, 1, 1, 1);
 213         glEnable(GL_TEXTURE_2D);
 214         glBindTexture(GL_TEXTURE_2D, tex);
 215         piglit_draw_rect_tex(-1, -1, 2, 2,
 216                              0, 0, 1, 1);
 217
 218         glDisable(GL_TEXTURE_2D);
 219         glDeleteTextures(1, &tex);
 220         glBindFramebufferEXT(GL_FRAMEBUFFER, piglit_winsys_fbo);
 221         glDeleteFramebuffersEXT(1, &fb);
 222
 223         piglit_present_results();
 224
 225         piglit_report_subtest_result(pass ? PIGLIT_PASS : PIGLIT_FAIL,
 226                                      "%s", name);
 227
 228         return pass ? PIGLIT_PASS : PIGLIT_FAIL;
 229 }
 230
 231 enum piglit_result piglit_display(void)
 232 {
 233         return fbo_formats_display(test_format);
 234 }
 235
 236 void piglit_init(int argc, char **argv)
 237 {
 238         fbo_formats_init(argc, argv, GL_TRUE);
 239 }