tests/fbo/fbo-blending-format-quirks.c

   1 /*
   2  * Copyright © 2018 Collabora Ltd
   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  *    Erik Faye-Lund <erik.faye-lund@collabora.com>
  25  *
  26  */
  27
  28 #include "piglit-util-gl.h"
  29
  30 PIGLIT_GL_TEST_CONFIG_BEGIN
  31
  32         config.supports_gl_compat_version = 10;
  33
  34         /* Drivers that do not support GL_ARB_texture_non_power_of_two require
  35          * window dimensions that are powers of two for this test.
  36          */
  37         config.window_width = next_power_of_two(config.window_width);
  38         config.window_height = next_power_of_two(config.window_height);
  39
  40         config.window_visual = PIGLIT_GL_VISUAL_RGBA | PIGLIT_GL_VISUAL_DOUBLE;
  41         config.khr_no_error_support = PIGLIT_NO_ERRORS;
  42
  43 PIGLIT_GL_TEST_CONFIG_END
  44
  45 static enum piglit_result
  46 test_formats(const char *name, const GLenum formats[2],
  47              const float expect[2][4], const GLenum factors[2])
  48 {
  49         GLboolean pass = GL_TRUE;
  50         GLuint tex[2], fb;
  51         GLenum draw_bufs[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
  52         GLenum status;
  53         int i;
  54
  55         glGenFramebuffersEXT(1, &fb);
  56         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
  57         glViewport(0, 0, piglit_width, piglit_height);
  58
  59         glGenTextures(2, tex);
  60         for (i = 0; i < 2; ++i) {
  61                 glBindTexture(GL_TEXTURE_2D, tex[i]);
  62                 glTexImage2D(GL_TEXTURE_2D, 0, formats[i],
  63                              piglit_width, piglit_height, 0,
  64                              GL_RGBA, GL_FLOAT, NULL);
  65
  66                 glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
  67                                           GL_COLOR_ATTACHMENT0_EXT + i,
  68                                           GL_TEXTURE_2D,
  69                                           tex[i],
  70                                           0);
  71         }
  72         if (!piglit_check_gl_error(GL_NO_ERROR))
  73                 piglit_report_result(PIGLIT_FAIL);
  74
  75         status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
  76         if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
  77                 printf(" - fbo incomplete (status = %s)\n",
  78                        piglit_get_gl_enum_name(status));
  79                 return PIGLIT_SKIP;
  80         }
  81
  82         printf("Testing %s\n", name);
  83
  84         /* Tets 1 and 2 use glBlendFunc(GL_DST_ALPHA, ...) so make sure alpha
  85          * is initialized to the expected value.
  86          */
  87         for (i = 0; i < 2; i++) {
  88                 glDrawBuffers(1, &draw_bufs[i]);
  89                 glClearColor(0.0, 0.0, 0.0, expect[i][3]);
  90                 glClear(GL_COLOR_BUFFER_BIT);
  91         }
  92
  93         glDrawBuffers(2, draw_bufs);
  94
  95         glEnable(GL_BLEND);
  96         glBlendFunc(factors[0], factors[1]);
  97         glBlendColor(1.0, 0.5, 0.25, 0.125);
  98         glColor4f(1.0, 1.0, 1.0, 1.0);
  99
 100         piglit_draw_rect(-1.0, -1.0, 2.0, 2.0);
 101
 102         glReadBuffer(GL_COLOR_ATTACHMENT0);
 103         if (!piglit_probe_pixel_rgba(piglit_width / 2, piglit_height / 2,
 104                                      expect[0])) {
 105                 printf("  when testing GL_COLOR_ATTACHMENT0.\n");
 106                 pass = GL_FALSE;
 107         }
 108
 109         glReadBuffer(GL_COLOR_ATTACHMENT1);
 110         if (!piglit_probe_pixel_rgba(piglit_width / 2, piglit_height / 2,
 111                                      expect[1])) {
 112                 printf("  when testing GL_COLOR_ATTACHMENT1.\n");
 113                 pass = GL_FALSE;
 114         }
 115
 116         glDeleteTextures(2, tex);
 117         glDeleteFramebuffersEXT(1, &fb);
 118
 119         return pass ? PIGLIT_PASS : PIGLIT_FAIL;
 120 }
 121
 122 enum piglit_result piglit_display(void)
 123 {
 124         int i;
 125         enum piglit_result result, end_result = PIGLIT_PASS;
 126         bool all_skip = true;
 127
 128         static const struct {
 129                 const char *name;
 130                 GLenum formats[2];
 131                 GLenum factors[2];
 132                 float expect[2][4];
 133         } cases[] = {
 134                 { "alpha expand",
 135                         { GL_RGBA, GL_RGB },
 136                         { GL_DST_ALPHA, GL_ZERO }, {
 137                                 { 0.5, 0.5, 0.5, 0.5 },
 138                                 { 1.0, 1.0, 1.0, 1.0 }
 139                         }
 140                 },
 141
 142                 { "alpha swizzle, variant 1",
 143                         { GL_RGBA, GL_ALPHA },
 144                         { GL_DST_ALPHA, GL_ZERO }, {
 145                                 { 0.5, 0.5, 0.5, 0.5 },
 146                                 { 0.0, 0.0, 0.0, 0.0 }
 147                         }
 148                 },
 149
 150                 { "alpha swizzle, variant 2",
 151                         { GL_RGBA, GL_ALPHA },
 152                         { GL_CONSTANT_COLOR, GL_ZERO }, {
 153                                 { 1.0, 0.5, 0.25, 0.125 },
 154                                 { 0.0, 0.0, 0.0, 0.125 }
 155                         }
 156                 },
 157
 158                 { "alpha swizzle, variant 3",
 159                         { GL_ALPHA, GL_RGBA },
 160                         { GL_CONSTANT_COLOR, GL_ZERO }, {
 161                                 { 0.0, 0.0, 0.0, 0.125 },
 162                                 { 1.0, 0.5, 0.25, 0.125 }
 163                         }
 164                 }
 165         };
 166
 167         for (i = 0; i < ARRAY_SIZE(cases); ++i) {
 168                 result = test_formats(cases[i].name, cases[i].formats,
 169                                       cases[i].expect, cases[i].factors);
 170
 171                 if (result != PIGLIT_SKIP)
 172                         all_skip = false;
 173
 174                 if (result == PIGLIT_FAIL)
 175                         end_result = result;
 176         }
 177
 178         if (all_skip)
 179                 return PIGLIT_SKIP;
 180         return end_result;
 181 }
 182
 183 void piglit_init(int argc, char **argv)
 184 {
 185         piglit_require_extension("GL_EXT_framebuffer_object");
 186         piglit_require_draw_buffers(2);
 187
 188         glDisable(GL_DITHER);
 189 }