tests/spec/arb_clear_texture/integer.c

   1 /*
   2  * Copyright (c) 2014 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
  24 /** @file integer.c
  25  *
  26  * A test of using glClearTexSubImage to clear sub-regions of integer
  27  * tetures with a range of formats. Each format is created as a 4x4
  28  * texture where the first four texels are cleared to known values
  29  * using separate calls to glClearTexSubImage. The values are chosen
  30  * to potentially trigger problems with signed conversions. The rest
  31  * of the texture is initialised to zeroes. The textures are then read
  32  * back with glGetTexImage and compared with the expected values.
  33  */
  34
  35 #define TEX_WIDTH 4
  36 #define TEX_HEIGHT 4
  37
  38 #include "piglit-util-gl.h"
  39
  40 PIGLIT_GL_TEST_CONFIG_BEGIN
  41
  42         config.supports_gl_compat_version = 13;
  43
  44         config.window_visual = PIGLIT_GL_VISUAL_RGB | PIGLIT_GL_VISUAL_DOUBLE;
  45
  46         config.khr_no_error_support = PIGLIT_NO_ERRORS;
  47
  48 PIGLIT_GL_TEST_CONFIG_END
  49
  50 /* Values to try clearing the texture to. The number of bytes used
  51  * will depend on the component size for the format. The actual value
  52  * used will depend on the endianness of the architecture but this
  53  * shouldn't really matter for the test */
  54
  55 static const uint32_t
  56 clear_values[][4] = {
  57         { 0xffffffffU, 0x00000000U, 0x12345678U, 0x78274827U },
  58         { 0x00000000U, 0xffffffffU, 0x12345678U, 0x78274827U },
  59         { 0x12345678U, 0x00000000U, 0xffffffffU, 0x78274827U },
  60         { 0xa82748b7U, 0x12345678U, 0x00000000U, 0xffffffffU },
  61 };
  62
  63 struct format {
  64         GLenum internal_format;
  65         GLenum format;
  66         GLenum type;
  67         int component_size;
  68         int n_components;
  69 };
  70
  71 static const struct format
  72 formats[] = {
  73         { GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT, 4, 4 },
  74         { GL_RGB32UI, GL_RGB_INTEGER, GL_UNSIGNED_INT, 4, 3 },
  75         { GL_RGBA16UI, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT, 2, 4 },
  76         { GL_RGB16UI, GL_RGB_INTEGER, GL_UNSIGNED_SHORT, 2, 3 },
  77         { GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, 1, 4 },
  78         { GL_RGB8UI, GL_RGB_INTEGER, GL_UNSIGNED_BYTE, 1, 3 },
  79         { GL_RGBA32I, GL_RGBA_INTEGER, GL_INT, 4, 4 },
  80         { GL_RGB32I, GL_RGB_INTEGER, GL_INT, 4, 3 },
  81         { GL_RGBA16I, GL_RGBA_INTEGER, GL_SHORT, 2, 4 },
  82         { GL_RGB16I, GL_RGB_INTEGER, GL_SHORT, 2, 3 },
  83         { GL_RGBA8I, GL_RGBA_INTEGER, GL_BYTE, 1, 4 },
  84         { GL_RGB8I, GL_RGB_INTEGER, GL_BYTE, 1, 3 },
  85 };
  86
  87 static GLuint
  88 create_texture(const struct format *format)
  89 {
  90         GLubyte *tex_data;
  91         int texel_size;
  92         GLuint tex;
  93
  94         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  95
  96         texel_size = format->component_size * format->n_components;
  97         tex_data = malloc(texel_size * TEX_WIDTH * TEX_HEIGHT);
  98
  99         memset(tex_data, 0, texel_size * TEX_WIDTH * TEX_HEIGHT);
 100
 101         glGenTextures(1, &tex);
 102         glBindTexture(GL_TEXTURE_2D, tex);
 103         glTexImage2D(GL_TEXTURE_2D,
 104                      0, /* level */
 105                      format->internal_format,
 106                      TEX_WIDTH, TEX_HEIGHT,
 107                      0, /* border */
 108                      format->format,
 109                      format->type,
 110                      tex_data);
 111         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 112         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 113
 114         free(tex_data);
 115
 116         return tex;
 117 }
 118
 119 static bool
 120 clear_texture(GLuint tex,
 121               const struct format *format)
 122 {
 123         int i;
 124
 125         for (i = 0; i < ARRAY_SIZE(clear_values); i++) {
 126                 glClearTexSubImage(tex,
 127                                    0, /* level */
 128                                    i % TEX_WIDTH, /* x */
 129                                    i / TEX_WIDTH, /* y */
 130                                    0, /* z */
 131                                    1, 1, 1, /* width/height/depth */
 132                                    format->format,
 133                                    format->type,
 134                                    clear_values[i]);
 135
 136                 if (!piglit_check_gl_error(GL_NO_ERROR))
 137                         return false;
 138         }
 139
 140         return true;
 141 }
 142
 143 static bool
 144 check_texture(GLuint tex,
 145               const struct format *format)
 146 {
 147         GLubyte *tex_data, *p;
 148         int texel_size;
 149         int i, j;
 150         bool pass = true;
 151
 152         glPixelStorei(GL_PACK_ALIGNMENT, 1);
 153
 154         texel_size = format->component_size * format->n_components;
 155         p = tex_data = malloc(texel_size * TEX_WIDTH * TEX_HEIGHT);
 156
 157         glGetTexImage(GL_TEXTURE_2D, 0, format->format, format->type, tex_data);
 158
 159         for (i = 0; i < ARRAY_SIZE(clear_values); i++) {
 160                 if (memcmp(p, clear_values[i], texel_size)) {
 161                         pass = false;
 162                         break;
 163                 }
 164                 p += texel_size;
 165         }
 166
 167         /* The rest of the values should be zeroes */
 168         for (i = ARRAY_SIZE(clear_values); i < TEX_WIDTH * TEX_HEIGHT; i++)
 169                 for (j = 0; j < texel_size; j++)
 170                         if (*(p++) != 0) {
 171                                 pass = false;
 172                                 break;
 173                         }
 174
 175         free(tex_data);
 176
 177         return pass;
 178 }
 179
 180 void
 181 piglit_init(int argc, char **argv)
 182 {
 183         bool pass = true;
 184         GLuint tex;
 185         int i;
 186
 187         /* glClearTexture is either in the GL_ARB_clear_texture
 188          * extension or in core in GL 4.4
 189          */
 190         if (piglit_get_gl_version() < 44 &&
 191             !piglit_is_extension_supported("GL_ARB_clear_texture")) {
 192                 printf("OpenGL 4.4 or GL_ARB_clear_texture is required.\n");
 193                 piglit_report_result(PIGLIT_SKIP);
 194         }
 195
 196         /* Integer textures are either in GL 3.0 or GL_EXT_texture_integer
 197          */
 198         if (piglit_get_gl_version() < 30 &&
 199             !piglit_is_extension_supported("GL_EXT_texture_integer")) {
 200                 printf("OpenGL 3.0 or GL_EXT_texture_integer is required.\n");
 201                 piglit_report_result(PIGLIT_SKIP);
 202         }
 203
 204         for (i = 0; i < ARRAY_SIZE(formats); i++) {
 205                 tex = create_texture(formats + i);
 206                 pass &= clear_texture(tex, formats + i);
 207                 pass &= check_texture(tex, formats + i);
 208                 glBindTexture(GL_TEXTURE_2D, 0);
 209                 glDeleteTextures(1, &tex);
 210         }
 211
 212         piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
 213 }
 214
 215 enum piglit_result
 216 piglit_display(void)
 217 {
 218         /* unused */
 219         return PIGLIT_FAIL;
 220 }