tests/spec/arb_shader_atomic_counters/common.c

   1 /*
   2  * Copyright © 2013 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 common.c
  25  *
  26  * Common utility functions for the ARB_shader_atomic_counters tests.
  27  */
  28
  29 #include "common.h"
  30
  31 bool
  32 atomic_counters_probe_buffer(unsigned base, unsigned count,
  33                              const uint32_t *expected)
  34 {
  35         uint32_t *p = glMapBufferRange(
  36                 GL_ATOMIC_COUNTER_BUFFER, base * sizeof(uint32_t),
  37                 count * sizeof(uint32_t), GL_MAP_READ_BIT);
  38         bool pass = true;
  39         unsigned i;
  40
  41         if (!p) {
  42                 printf("Couldn't map atomic counter buffer for read-back.\n");
  43                 return false;
  44         }
  45
  46         for (i = 0; i < count; ++i) {
  47                 uint32_t found = p[i];
  48                 if (found != expected[i]) {
  49                         printf("Probe value at (%i)\n", i);
  50                         printf("  Expected: 0x%08x\n", expected[i]);
  51                         printf("  Observed: 0x%08x\n", found);
  52                         pass = false;
  53                         break;
  54                 }
  55         }
  56
  57         glUnmapBuffer(GL_ATOMIC_COUNTER_BUFFER);
  58         return pass;
  59 }
  60
  61 bool
  62 atomic_counters_compile(GLuint prog, GLuint stage, const char *src)
  63 {
  64         GLuint shader = glCreateShader(stage);
  65         int status, log_size;
  66         char *log;
  67
  68         glShaderSource(shader, 1, (const GLchar **)&src, NULL);
  69         glCompileShader(shader);
  70
  71         glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
  72
  73         if (status) {
  74                 glAttachShader(prog, shader);
  75         } else {
  76                 glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_size);
  77                 log = malloc(log_size);
  78                 glGetShaderInfoLog(shader, log_size, NULL, log);
  79
  80                 printf("Failed to compile shader: %s\n", log);
  81                 printf("source:\n%s", src);
  82
  83                 free(log);
  84         }
  85
  86         glDeleteShader(shader);
  87
  88         return status;
  89 }
  90
  91 bool
  92 atomic_counters_link(GLuint prog)
  93 {
  94         int status;
  95
  96         glGetProgramiv(prog, GL_LINK_STATUS, &status);
  97         if (!status) {
  98            glLinkProgram(prog);
  99            glGetProgramiv(prog, GL_LINK_STATUS, &status);
 100         }
 101
 102         return status;
 103 }
 104
 105 bool
 106 atomic_counters_draw_point(GLuint prog, unsigned buf_size,
 107                            const uint32_t *buf)
 108 {
 109         GLuint vao;
 110
 111         /* Initialize the atomic counter buffer. */
 112         glBufferData(GL_ATOMIC_COUNTER_BUFFER,
 113                      buf_size * sizeof(uint32_t),
 114                      buf, GL_STATIC_DRAW);
 115
 116         /* Link and set the current shader program. */
 117         atomic_counters_link(prog);
 118         glUseProgram(prog);
 119
 120         /* Draw. */
 121         glClearColor(0.5, 0.5, 0.5, 0.5);
 122         glClear(GL_COLOR_BUFFER_BIT);
 123
 124         glGenVertexArrays(1, &vao);
 125         glBindVertexArray(vao);
 126         glVertexAttrib4f(0, 0, 0, 0, 1);
 127
 128         glDrawArrays(GL_POINTS, 0, 1);
 129
 130         glDeleteVertexArrays(1, &vao);
 131
 132         return piglit_check_gl_error(GL_NO_ERROR);
 133 }
 134
 135 bool
 136 atomic_counters_draw_rect(GLuint prog, unsigned buf_size, const uint32_t *buf)
 137 {
 138         /* Initialize the atomic counter buffer. */
 139         glBufferData(GL_ATOMIC_COUNTER_BUFFER,
 140                      buf_size * sizeof(uint32_t),
 141                      buf, GL_STATIC_DRAW);
 142
 143         /* Set current shader program. */
 144         glLinkProgram(prog);
 145         glUseProgram(prog);
 146
 147         /* Draw. */
 148         glClearColor(0.5, 0.5, 0.5, 0.5);
 149         glClear(GL_COLOR_BUFFER_BIT);
 150
 151         piglit_draw_rect(-1, -1, 2, 2);
 152
 153         return piglit_check_gl_error(GL_NO_ERROR);
 154 }
 155
 156 bool
 157 atomic_counters_draw_patch(GLuint prog, unsigned buf_size,
 158                            const uint32_t *buf)
 159 {
 160
 161         const GLfloat verts[3][4] = { { 0.0, 0.0, 0.0, 1.0 },
 162                                       { 1.0, 0.0, 0.0, 1.0 },
 163                                       { 0.0, 1.0, 0.0, 1.0 } };
 164         GLuint vao, vbo;
 165
 166         /* Initialize the atomic counter buffer. */
 167         glBufferData(GL_ATOMIC_COUNTER_BUFFER,
 168                      buf_size * sizeof(uint32_t),
 169                      buf, GL_STATIC_DRAW);
 170
 171         /* Set current shader program. */
 172         glLinkProgram(prog);
 173         glUseProgram(prog);
 174
 175         /* Initialize a vertex array object and a vertex buffer object. */
 176         glGenVertexArrays(1, &vao);
 177         glBindVertexArray(vao);
 178         glGenBuffers(1, &vbo);
 179         glBindBuffer(GL_ARRAY_BUFFER, vbo);
 180         glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
 181
 182         /* Set up the current vertex attributes. */
 183         glVertexAttribPointer(PIGLIT_ATTRIB_POS, 4, GL_FLOAT,
 184                               GL_FALSE, 0, 0);
 185         glEnableVertexAttribArray(PIGLIT_ATTRIB_POS);
 186
 187         /* Draw. */
 188         glClearColor(0.5, 0.5, 0.5, 0.5);
 189         glClear(GL_COLOR_BUFFER_BIT);
 190
 191         glDrawArrays(GL_PATCHES, 0, 3);
 192
 193         /* Clean up. */
 194         glDisableVertexAttribArray(PIGLIT_ATTRIB_POS);
 195         glDeleteBuffers(1, &vbo);
 196         glDeleteVertexArrays(1, &vao);
 197
 198         return piglit_check_gl_error(GL_NO_ERROR);
 199 }
 200
 201 bool
 202 atomic_counters_supported(GLenum shader_stage)
 203 {
 204         int n = 0;
 205
 206         switch (shader_stage) {
 207         case GL_NONE:
 208         case GL_FRAGMENT_SHADER:
 209                 return true;
 210
 211         case GL_VERTEX_SHADER:
 212                 glGetIntegerv(GL_MAX_VERTEX_ATOMIC_COUNTERS, &n);
 213                 return n;
 214
 215         case GL_GEOMETRY_SHADER:
 216                 if (piglit_get_gl_version() >= 32)
 217                         glGetIntegerv(GL_MAX_GEOMETRY_ATOMIC_COUNTERS, &n);
 218                 return n;
 219
 220         case GL_TESS_CONTROL_SHADER:
 221                 if (piglit_is_extension_supported("GL_ARB_tessellation_shader"))
 222                         glGetIntegerv(GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS, &n);
 223                 return n;
 224
 225         case GL_TESS_EVALUATION_SHADER:
 226                 if (piglit_is_extension_supported("GL_ARB_tessellation_shader"))
 227                         glGetIntegerv(GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS,
 228                                       &n);
 229                 return n;
 230
 231         default:
 232                 assert(!"Unreachable");
 233                 abort();
 234         }
 235 }
 236
 237 struct atomic_counters_limits
 238 atomic_counters_get_limits()
 239 {
 240         struct atomic_counters_limits ls = { 0 };
 241
 242         piglit_require_extension("GL_ARB_shader_atomic_counters");
 243
 244         glGetIntegerv(GL_MAX_FRAGMENT_ATOMIC_COUNTERS,
 245                       &ls.fragment_counters);
 246         glGetIntegerv(GL_MAX_VERTEX_ATOMIC_COUNTERS,
 247                       &ls.vertex_counters);
 248         glGetIntegerv(GL_MAX_COMBINED_ATOMIC_COUNTERS,
 249                       &ls.combined_counters);
 250         glGetIntegerv(GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS,
 251                       &ls.fragment_buffers);
 252         glGetIntegerv(GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS,
 253                       &ls.vertex_buffers);
 254         glGetIntegerv(GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS,
 255                       &ls.combined_buffers);
 256         glGetIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS,
 257                       &ls.bindings);
 258         glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS,
 259                       &ls.uniform_components);
 260
 261         return ls;
 262 }
 263
 264