tests/spec/ext_transform_feedback/get-buffer-state.c

   1 /*
   2  * Copyright © 2012 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
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 /**
  25  * \file get-buffer-state.c
  26  *
  27  * Test that "Get" functions can be used to query the state of
  28  * transform feedback buffers.
  29  */
  30
  31 #include "piglit-util-gl.h"
  32
  33 PIGLIT_GL_TEST_CONFIG_BEGIN
  34
  35         config.supports_gl_compat_version = 10;
  36
  37         config.window_visual = PIGLIT_GL_VISUAL_DOUBLE | PIGLIT_GL_VISUAL_RGB;
  38         config.khr_no_error_support = PIGLIT_NO_ERRORS;
  39
  40 PIGLIT_GL_TEST_CONFIG_END
  41
  42 #define XFB_BUFFER_SIZE 12
  43
  44 enum test_mode {
  45         MAIN,
  46         INDEXED,
  47 };
  48
  49 static struct test_desc
  50 {
  51         const char *name;
  52         enum test_mode mode;
  53         GLenum param;
  54 } tests[] = {
  55         /* name              mode     param */
  56         { "main_binding",    MAIN,    GL_TRANSFORM_FEEDBACK_BUFFER_BINDING },
  57         { "indexed_binding", INDEXED, GL_TRANSFORM_FEEDBACK_BUFFER_BINDING },
  58         { "buffer_start",    INDEXED, GL_TRANSFORM_FEEDBACK_BUFFER_START },
  59         { "buffer_size",     INDEXED, GL_TRANSFORM_FEEDBACK_BUFFER_SIZE },
  60 };
  61
  62 static GLboolean
  63 check_integer(const struct test_desc *test, GLenum param, GLint expected)
  64 {
  65         GLint get_result;
  66         const char *param_string = piglit_get_gl_enum_name(param);
  67
  68         if (test->mode == MAIN && test->param == param) {
  69                 glGetIntegerv(param, &get_result);
  70                 if (get_result != expected) {
  71                         printf("%s == %i, expected %i\n", param_string,
  72                                get_result, expected);
  73                         return GL_FALSE;
  74                 }
  75         }
  76         return GL_TRUE;
  77 }
  78
  79 static GLboolean
  80 check_indexed(const struct test_desc *test, GLenum param, GLuint index,
  81               GLint expected)
  82 {
  83         GLint get_result;
  84         const char *param_string = piglit_get_gl_enum_name(param);
  85
  86         if (test->mode == INDEXED && test->param == param) {
  87                 glGetIntegeri_v(param, index, &get_result);
  88                 if (get_result != expected) {
  89                         printf("%s[%u] == %i, expected %i\n", param_string,
  90                                index, get_result, expected);
  91                         return GL_FALSE;
  92                 }
  93         }
  94         return GL_TRUE;
  95 }
  96
  97 static GLboolean
  98 do_test(const struct test_desc *test)
  99 {
 100         GLuint *bufs;
 101         GLboolean pass = GL_TRUE;
 102         GLint max_separate_attribs;
 103         float initial_xfb_buffer_contents[XFB_BUFFER_SIZE];
 104         int i;
 105
 106         glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
 107                       &max_separate_attribs);
 108         printf("MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTIBS=%i\n",
 109                max_separate_attribs);
 110
 111         bufs = malloc(max_separate_attribs * sizeof(GLuint));
 112         glGenBuffers(max_separate_attribs, bufs);
 113         memset(initial_xfb_buffer_contents, 0,
 114                sizeof(initial_xfb_buffer_contents));
 115
 116         /* Main GL_TRANSFORM_FEEDBACK_BUFFER_BINDING should still be
 117          * set to its default value.
 118          */
 119         pass = check_integer(test, GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, 0) &&
 120                pass;
 121
 122         /* Set up buffers. */
 123         for (i = 0; i < max_separate_attribs; ++i) {
 124                 printf("BindBuffer(TRANSFORM_FEEDBACK_BUFFER, %u)\n", bufs[i]);
 125                 glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, bufs[i]);
 126                 pass = check_integer(test,
 127                                      GL_TRANSFORM_FEEDBACK_BUFFER_BINDING,
 128                                      bufs[i]) && pass;
 129                 glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER,
 130                              sizeof(initial_xfb_buffer_contents),
 131                              initial_xfb_buffer_contents, GL_STREAM_READ);
 132         }
 133
 134         /* Indexed bindings should still be set to their default values. */
 135         for (i = 0; i < max_separate_attribs; ++i) {
 136                 pass = check_indexed(test,
 137                                      GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, i,
 138                                      0) && pass;
 139                 pass = check_indexed(test, GL_TRANSFORM_FEEDBACK_BUFFER_START,
 140                                      i, 0) && pass;
 141                 pass = check_indexed(test, GL_TRANSFORM_FEEDBACK_BUFFER_SIZE,
 142                                      i, 0) && pass;
 143         }
 144
 145         /* Bind buffers, setting various offsets and sizes. */
 146         for (i = 0; i < max_separate_attribs; ++i) {
 147                 int offset = 4 * (i % 4);
 148                 int size = 4 * ((i % 3) + 1);
 149                 printf("BindBufferRange(TRANSFORM_FEEDBACK_BUFFER, %i, %u, %i, %i)\n",
 150                        i, bufs[i], offset, size);
 151                 glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, i,
 152                                   bufs[i], offset, size);
 153                 pass = check_integer(test,
 154                                      GL_TRANSFORM_FEEDBACK_BUFFER_BINDING,
 155                                      bufs[i]) && pass;
 156         }
 157
 158         /* Check indexed bindings. */
 159         for (i = 0; i < max_separate_attribs; ++i) {
 160                 int offset = 4 * (i % 4);
 161                 int size = 4 * ((i % 3) + 1);
 162                 pass = check_indexed(test,
 163                                      GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, i,
 164                                      bufs[i]) && pass;
 165                 pass = check_indexed(test, GL_TRANSFORM_FEEDBACK_BUFFER_START,
 166                                      i, offset) && pass;
 167                 pass = check_indexed(test, GL_TRANSFORM_FEEDBACK_BUFFER_SIZE,
 168                                      i, size) && pass;
 169         }
 170
 171         return pass;
 172 }
 173
 174 void
 175 print_usage_and_exit(const char *prog_name)
 176 {
 177         int i;
 178
 179         printf("Usage: %s <test_name>\n"
 180                "  where <test_name> is one of:\n", prog_name);
 181         for (i = 0; i < ARRAY_SIZE(tests); ++i)
 182                 printf("    %s\n", tests[i].name);
 183         exit(0);
 184 }
 185
 186 const struct test_desc *
 187 find_matching_test(const char *prog_name, const char *test_name)
 188 {
 189         int i;
 190         for (i = 0; i < ARRAY_SIZE(tests); ++i) {
 191                 if (strcmp(tests[i].name, test_name) == 0)
 192                         return &tests[i];
 193         }
 194         print_usage_and_exit(prog_name);
 195         return NULL; /* won't actually be reached */
 196 }
 197
 198 void
 199 piglit_init(int argc, char **argv)
 200 {
 201         const struct test_desc *test;
 202
 203         /* Parse params. */
 204         if (argc != 2)
 205                 print_usage_and_exit(argv[0]);
 206         test = find_matching_test(argv[0], argv[1]);
 207
 208         piglit_require_transform_feedback();
 209
 210         piglit_report_result(do_test(test) ? PIGLIT_PASS : PIGLIT_FAIL);
 211 }
 212
 213 enum piglit_result
 214 piglit_display(void)
 215 {
 216         /* Should never be reached */
 217         return PIGLIT_FAIL;
 218 }