tests/spec/arb_enhanced_layouts/transform-feedback-layout-query-api.c

   1 /*
   2  * Copyright © 2016 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 #include "piglit-util-gl.h"
  25
  26 PIGLIT_GL_TEST_CONFIG_BEGIN
  27
  28         config.supports_gl_compat_version = 32;
  29         config.supports_gl_core_version = 32;
  30
  31 PIGLIT_GL_TEST_CONFIG_END
  32
  33 static const char vs_two_buff_text[] =
  34         "#version 150\n"
  35         "#extension GL_ARB_enhanced_layouts: require\n"
  36         "\n"
  37         "layout(xfb_buffer = 1) out;\n"
  38         "layout(xfb_offset = 0) out float x1_out;\n"
  39         "layout(xfb_offset = 4) out float x2_out[2];\n"
  40         "layout(xfb_offset = 12) out vec3 x3_out;\n"
  41         "layout(xfb_buffer = 3) out;\n"
  42         "layout(xfb_offset = 0, xfb_buffer = 3) out float y1_out;\n"
  43         "layout(xfb_offset = 4) out vec4 y2_out;\n"
  44         "void main() {\n"
  45         "  gl_Position = vec4(0.0);\n"
  46         "  x1_out = 1.0;\n"
  47         "  x2_out[0] = 2.0;\n"
  48         "  x2_out[1] = 3.0;\n"
  49         "  x3_out = vec3(4.0, 5.0, 6.0);\n"
  50         "  y1_out = 7.0;\n"
  51         "  y2_out = vec4(8.0, 9.0, 10.0, 11.0);\n"
  52         "}";
  53
  54 static const char *varying_names[2][3] = {
  55          {"x1_out", "x2_out", "x3_out"},
  56          {"y1_out", "y2_out", ""} };
  57
  58
  59 static GLuint
  60 build_and_use_program(const char *vs_text)
  61 {
  62         GLuint prog = piglit_build_simple_program_multiple_shaders(
  63                                 GL_VERTEX_SHADER, vs_text, 0);
  64
  65         glLinkProgram(prog);
  66         if (!piglit_link_check_status(prog))
  67                 piglit_report_result(PIGLIT_FAIL);
  68         if (!piglit_check_gl_error(GL_NO_ERROR))
  69                 piglit_report_result(PIGLIT_FAIL);
  70
  71         glUseProgram(prog);
  72
  73         return prog;
  74 }
  75
  76 static bool
  77 check_varyings_match(GLuint prog, GLint *values, unsigned num_values,
  78                 unsigned buffer)
  79 {
  80         bool match = true;
  81
  82         for (unsigned i = 0; i < num_values; i++) {
  83                 char name[10];
  84                 glGetProgramResourceName(prog, GL_TRANSFORM_FEEDBACK_VARYING,
  85                                         values[i], 10, NULL, name);
  86
  87                 bool match_found = false;
  88                 for (unsigned i = 0; i < num_values; i++) {
  89                         if (strcmp(name, varying_names[buffer][i]) == 0) {
  90                                 match_found = true;
  91                                 break;
  92                         }
  93                 }
  94                 if (!match_found) {
  95                         match = false;
  96                         printf("ACTIVE_VARIABLES did no return an index for "
  97                                 "%s\n", varying_names[buffer][i]);
  98                         break;
  99                 }
 100         }
 101
 102         return match;
 103 }
 104
 105 void
 106 piglit_init(int argc, char **argv)
 107 {
 108         bool pass = true;
 109         bool active_res = true;
 110         bool max_active = true;
 111         bool buff_bind[2] = { true, true };
 112         bool num_active[2] = { false, false };
 113         bool varying_idx[2] = { false, false };
 114         GLuint prog;
 115
 116         piglit_require_extension("GL_ARB_transform_feedback3");
 117         piglit_require_extension("GL_ARB_enhanced_layouts");
 118
 119         prog = build_and_use_program(vs_two_buff_text);
 120
 121         GLint value;
 122         GLint values[5];
 123         glGetProgramInterfaceiv(prog, GL_TRANSFORM_FEEDBACK_BUFFER,
 124                         GL_ACTIVE_RESOURCES, &value);
 125         if (value != 2) {
 126                 printf("Expected 2 ACTIVE_RESOURCES found %d\n", value);
 127                 active_res = false;
 128         }
 129
 130         piglit_report_subtest_result(active_res ? PIGLIT_PASS : PIGLIT_FAIL,
 131                         "Query ACTIVE_RESOURCES");
 132
 133         glGetProgramInterfaceiv(prog, GL_TRANSFORM_FEEDBACK_BUFFER,
 134                         GL_MAX_NUM_ACTIVE_VARIABLES, &value);
 135         if (value != 3) {
 136                 printf("Expected MAX_NUM_ACTIVE_VARIABLES to be 3 found %d\n",
 137                 value);
 138                 max_active = false;
 139         }
 140
 141         piglit_report_subtest_result(max_active ? PIGLIT_PASS : PIGLIT_FAIL,
 142                         "Query MAX_NUM_ACTIVE_VARIABLES");
 143
 144         GLenum props[] = {GL_BUFFER_BINDING, GL_NUM_ACTIVE_VARIABLES,
 145                         GL_ACTIVE_VARIABLES};
 146         for (unsigned i = 0; i < 2; i++) {
 147                 glGetProgramResourceiv(prog, GL_TRANSFORM_FEEDBACK_BUFFER, i,
 148                                 3, props, 5, NULL, values);
 149
 150                 if (values[0] != 1 && values[0] != 3)
 151                         buff_bind[i] = false;
 152                 if (values[0] == 1) {
 153                         if(values[1] == 3) {
 154                                 num_active[i] = true;
 155                         } else {
 156                                 printf("Expected 3 NUM_ACTIVE_VARIABLES "
 157                                         "found %d\n", values[1]);
 158                         }
 159
 160                         varying_idx[i] =
 161                                 check_varyings_match(prog, &values[2], 3, 0);
 162                 } else if (values[0] == 3) {
 163                         if (values[1] == 2) {
 164                                 num_active[i] = true;
 165                         } else {
 166                                 printf("Expected 2 NUM_ACTIVE_VARIABLES "
 167                                         "found %d\n", values[1]);
 168                         }
 169
 170                         varying_idx[i] =
 171                                  check_varyings_match(prog, &values[2], 2, 1);
 172                 }
 173         }
 174
 175         piglit_report_subtest_result(buff_bind[0] && buff_bind[1] ?
 176                          PIGLIT_PASS : PIGLIT_FAIL,
 177                         "Query BUFFER_BINDING");
 178
 179         piglit_report_subtest_result(num_active[0] && num_active[1] ?
 180                          PIGLIT_PASS : PIGLIT_FAIL,
 181                         "Query NUM_ACTIVE_VARIABLES");
 182
 183         piglit_report_subtest_result(varying_idx[0] && varying_idx[1] ?
 184                          PIGLIT_PASS : PIGLIT_FAIL,
 185                         "Query ACTIVE_VARIABLES");
 186
 187         if (!piglit_check_gl_error(GL_NO_ERROR))
 188                 piglit_report_result(PIGLIT_FAIL);
 189
 190         pass = active_res && max_active && buff_bind[0] && buff_bind[1] &&
 191                 num_active[0] && num_active[1] && varying_idx[0] &&
 192                 varying_idx[1];
 193
 194         piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
 195 }
 196
 197 enum piglit_result
 198 piglit_display(void)
 199 {
 200         /* Should never be reached */
 201         return PIGLIT_FAIL;
 202 }