tests/spec/arb_program_interface_query/common.h

   1 /*
   2  * Copyright © 2015 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 #pragma once
  25 #ifndef __COMMON_H__
  26 #define __COMMON_H__
  27
  28
  29 /* /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\
  30  * If you modify any of these shaders, you need to modify the resources names in
  31  * resource-query.c.
  32  * /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\ /!\
  33  */
  34
  35 static const char vs_empty[] =
  36         "#version 150\n"
  37         "void main() {\n"
  38         "}";
  39
  40 static const char fs_empty[] =
  41         "#version 150\n"
  42         "void main() {\n"
  43         "}";
  44
  45 static const char vs_array[] =
  46         "#version 150\n"
  47         "in vec4 vs_input[2];\n"
  48         "struct vs_struct {\n"
  49         "       vec4 hello;\n"
  50         "       vec4 world[2];\n"
  51         "};\n"
  52         "uniform vs_struct sa[2];\n"
  53         "void main() {\n"
  54         "       gl_Position = vs_input[0] + sa[0].hello + sa[0].world[0];\n"
  55         "}";
  56
  57 static const char vs_aofa[] =
  58         "#version 150\n"
  59         "#extension GL_ARB_arrays_of_arrays : require\n"
  60         "in vec4 vs_input2[2][2];\n"
  61         "in vec4 vs_input3[2][2][2];\n"
  62         "void main() {\n"
  63         "       gl_Position = vs_input2[0][0] + vs_input3[0][0][0];\n"
  64         "}";
  65
  66 static const char vs_std[] =
  67         "#version 150\n"
  68         "struct vs_struct {\n"
  69         "       vec4 a[2];\n"
  70         "};\n"
  71         "uniform vs_uniform_block {\n"
  72         "       vec4 vs_test;\n"
  73         "};\n"
  74         "uniform vs_struct sa[2];\n"
  75         "in vec4 vs_input0;\n"
  76         "in vec4 vs_input1;\n"
  77         "out gl_PerVertex {\n"
  78         "       vec4 gl_Position;\n"
  79         "};\n"
  80         "out vec4 vs_output1;\n"
  81         "void main() {\n"
  82         "       gl_Position = vs_input0 * vs_test * vs_input1 + sa[0].a[1] +"
  83         "                     sa[1].a[1];\n"
  84         "       vs_output1 = vs_input0;\n"
  85         "}";
  86
  87 const char gs_std[] =
  88         "#version 150\n"
  89         "layout(triangles) in;\n"
  90         "layout(triangle_strip, max_vertices = 6) out;\n"
  91         "uniform gs_uniform_block {\n"
  92         "       vec4 gs_test;\n"
  93         "};\n"
  94         "in gl_PerVertex {\n"
  95         "       vec4 gl_Position;\n"
  96         "} gl_in[];\n"
  97         "out gl_PerVertex {\n"
  98         "       vec4 gl_Position;\n"
  99         "};\n"
 100         "in vec4 vs_output1[3];\n"
 101         "out vec4 fs_input1;\n"
 102         "void main() {\n"
 103         "       for (int i = 0; i < 6; i++) {\n"
 104         "               gl_Position = vs_output1[i % 3] *"
 105         "                             gl_in[i % 3].gl_Position * gs_test;\n"
 106         "               fs_input1 = vs_output1[0];\n"
 107         "               EmitVertex();\n"
 108         "       }\n"
 109         "}\n";
 110
 111 static const char fs_std[] =
 112         "#version 150\n"
 113         "uniform fs_uniform_block {"
 114         "       vec4 fs_color;\n"
 115         "       float fs_array[4];\n"
 116         "};\n"
 117         "uniform fs_array_uniform_block {\n"
 118         "       vec4 fs_color;\n"
 119         "       float fs_array[4];\n"
 120         "} faub[4];\n"
 121         "in vec4 vs_output1;\n"
 122         "out vec4 fs_output0;\n"
 123         "out vec4 fs_output1;\n"
 124         "void main() {\n"
 125                 "fs_output0 = fs_color * vs_output1 * fs_array[2] * \n"
 126                 "             faub[0].fs_array[2] * faub[2].fs_array[2];\n"
 127                 "fs_output1 = fs_color * vs_output1 * fs_array[3] * \n"
 128                 "             faub[1].fs_array[3] * faub[3].fs_array[3];\n"
 129         "}";
 130
 131 static const char fs_in[] =
 132         "#version 150\n"
 133         "uniform fs_uniform_block {"
 134         "       vec4 fs_color;\n"
 135         "       float fs_array[4];\n"
 136         "};\n"
 137         "uniform fs_array_uniform_block {\n"
 138         "       vec4 fs_color;\n"
 139         "       float fs_array[4];\n"
 140         "} faub[4];\n"
 141         "in vec4 fs_input1;\n"
 142         "out vec4 fs_output0;\n"
 143         "out vec4 fs_output1;\n"
 144         "void main() {\n"
 145                 "fs_output0 = fs_color * fs_input1 * fs_array[2] * \n"
 146                 "             faub[0].fs_array[2] * faub[2].fs_array[2];\n"
 147                 "fs_output1 = fs_color * fs_input1 * fs_array[3] * \n"
 148                 "             faub[1].fs_array[3] * faub[3].fs_array[3];\n"
 149         "}";
 150
 151 static const char vs_buff_blks[] =
 152         "#version 150\n"
 153         "#extension GL_ARB_shader_storage_buffer_object : require\n"
 154         "buffer vs_buffer_block { vec4 vs_buf_var; };"
 155         "uniform vs_uni_block {\n"
 156         "       vec4 vs_test;\n"
 157         "};\n"
 158         "void main() {\n"
 159         "       gl_Position = vs_buf_var + vs_test;\n"
 160         "}";
 161
 162 static const char fs_buff_blks[] =
 163         "#version 150\n"
 164         "#extension GL_ARB_shader_storage_buffer_object : require\n"
 165         "uniform fs_uni_block {"
 166         "       vec4 fs_color;\n"
 167         "       float fs_array[4];\n"
 168         "};\n"
 169         "buffer fs_buffer_block { vec4 fs_buf_var; };\n"
 170         "out vec4 fs_output0;\n"
 171         "void main() {\n"
 172         "       fs_output0 = fs_buf_var + fs_color +\n"
 173         "       vec4(fs_array[0], fs_array[1], fs_array[2], fs_array[3]);\n"
 174         "}";
 175
 176 static const char vs_stor[] =
 177         "#version 150\n"
 178         "#extension GL_ARB_shader_storage_buffer_object : require\n"
 179         "buffer vs_buffer_block { vec4 vs_buf_var; };"
 180         "out vec4 vs_output1;\n"
 181         "void main() {\n"
 182                 "vs_output1 = vs_buf_var;\n"
 183         "}";
 184
 185 static const char gs_stor[] =
 186         "#version 150\n"
 187         "#extension GL_ARB_shader_storage_buffer_object : require\n"
 188         "layout(triangles) in;\n"
 189         "layout(triangle_strip, max_vertices = 6) out;\n"
 190         "buffer gs_buffer_block { vec4 gs_buf_var; };"
 191         "in vec4 vs_output1[3];\n"
 192         "out gl_PerVertex {\n"
 193         "       vec4 gl_Position;\n"
 194         "};\n"
 195         "void main() {\n"
 196         "       for (int i = 0; i < 6; i++) {\n"
 197         "               gl_Position = vs_output1[i % 3] * gs_buf_var;\n"
 198         "               EmitVertex();\n"
 199         "       }\n"
 200         "}";
 201
 202 static const char fs_stor[] =
 203         "#version 150\n"
 204         "#extension GL_ARB_shader_storage_buffer_object : require\n"
 205         "buffer fs_buffer_block { vec4 fs_buf_var; };\n"
 206         "out vec4 fs_output0;\n"
 207         "void main() {\n"
 208         "       fs_output0 = fs_buf_var;\n"
 209         "}";
 210
 211 static const char vs_atom[] =
 212         "#version 150\n"
 213         "#extension GL_ARB_shader_atomic_counters : require\n"
 214         "layout (binding=0) uniform atomic_uint vs_counter;\n"
 215         "void main() {\n"
 216         "       atomicCounterIncrement(vs_counter);\n"
 217         "}";
 218
 219 static const char gs_atom[] =
 220         "#version 150\n"
 221         "#extension GL_ARB_shader_atomic_counters : require\n"
 222         "layout(triangles) in;\n"
 223         "layout(triangle_strip, max_vertices = 6) out;\n"
 224         "layout (binding=1) uniform atomic_uint gs_counter;\n"
 225         "void main() {\n"
 226         "       atomicCounterIncrement(gs_counter);\n"
 227         "}";
 228
 229 static const char fs_atom[] =
 230         "#version 150\n"
 231         "#extension GL_ARB_shader_atomic_counters : require\n"
 232         "layout (binding=2) uniform atomic_uint fs_counter;\n"
 233         "void main() {\n"
 234         "       atomicCounterIncrement(fs_counter);\n"
 235         "}";
 236
 237 static const char vs_loc[] =
 238         "#version 150\n"
 239         "#extension GL_ARB_explicit_attrib_location : require\n"
 240         "layout (location = 3) in vec4 input0;\n"
 241         "layout (location = 6) in vec4 input1;\n"
 242         "void main() {\n"
 243                 "gl_Position = input0 * input1;\n"
 244         "}";
 245
 246 static const char fs_loc[] =
 247         "#version 150\n"
 248         "#extension GL_ARB_explicit_attrib_location  : require\n"
 249         "#extension GL_ARB_explicit_uniform_location : require\n"
 250         "layout (location = 9) uniform vec4 color;\n"
 251         "layout (location = 1) uniform float array[4];\n"
 252         "layout (location = 1) out vec4 output0;\n"
 253         "layout (location = 0) out vec4 output1;\n"
 254         "void main() {\n"
 255                 "output0 = color * array[2];\n"
 256                 "output1 = color * array[3];\n"
 257         "}";
 258
 259 static const char vs_tfv[] =
 260         "#version 150\n"
 261         "in vec4 vs_input0;\n"
 262         "out vec4 vs_output1;\n"
 263         "out vec4 outValue;\n"
 264         "void main() {\n"
 265         "       vs_output1 = vs_input0;\n"
 266         "       outValue = vs_input0;\n"
 267         "}";
 268
 269 static const char vs_sub[] =
 270         "#version 150\n"
 271         "#extension GL_ARB_shader_subroutine : require\n"
 272         "in vec4 vs_input0;\n"
 273         "out vec4 vs_output1;\n"
 274         "out gl_PerVertex {\n"
 275         "       vec4 gl_Position;\n"
 276         "};\n"
 277         "subroutine vec4 vs_offset();\n"
 278         "subroutine uniform vs_offset VERTEX;\n"
 279         "subroutine (vs_offset) vec4 vss() { return vec4(1, 0, 0, 0); }\n"
 280         "subroutine (vs_offset) vec4 vss2() { return vec4(1, 0, 0, 0); }\n"
 281         "void main() {\n"
 282         "       gl_Position = vs_input0 + VERTEX();\n"
 283         "       vs_output1 = vs_input0;\n"
 284         "}";
 285
 286 static const char vs_subidx[] =
 287         "#version 150\n"
 288         "#extension GL_ARB_shader_subroutine : require\n"
 289         "#extension GL_ARB_explicit_uniform_location : require\n"
 290         "in vec4 vs_input0;\n"
 291         "out vec4 vs_output1;\n"
 292         "subroutine vec4 vs_offset();\n"
 293         "subroutine uniform vs_offset VERTEX;\n"
 294         "layout(index=5) subroutine (vs_offset) vec4 vss_idx() { return vec4(1, 0, 0, 0); }\n"
 295         "subroutine (vs_offset) vec4 vss2_idx() { return vec4(1, 0, 0, 0); }\n"
 296         "void main() {\n"
 297         "       gl_Position = vs_input0 + VERTEX();\n"
 298         "       vs_output1 = vs_input0;\n"
 299         "}";
 300
 301 static const char gs_sub[] =
 302         "#version 150\n"
 303         "#extension GL_ARB_shader_subroutine : require\n"
 304         "layout(triangles) in;\n"
 305         "layout(triangle_strip, max_vertices = 6) out;\n"
 306         "subroutine vec4 gs_offset();\n"
 307         "subroutine uniform gs_offset GEOMETRY;\n"
 308         "subroutine (gs_offset) vec4 gss() { return vec4(1, 0, 0, 0); }\n"
 309         "in gl_PerVertex {\n"
 310         "       vec4 gl_Position;\n"
 311         "} gl_in[];\n"
 312         "out gl_PerVertex {\n"
 313         "       vec4 gl_Position;\n"
 314         "};\n"
 315         "in vec4 vs_output1[3];\n"
 316         "void main() {\n"
 317         "       for (int i = 0; i < 6; i++) {\n"
 318         "               gl_Position = vs_output1[i % 3] + GEOMETRY();\n"
 319         "               EmitVertex();\n"
 320         "       }\n"
 321         "}";
 322
 323 static const char fs_sub[] =
 324         "#version 150\n"
 325         "#extension GL_ARB_shader_subroutine : require\n"
 326         "subroutine vec4 fs_offset();\n"
 327         "subroutine uniform fs_offset FRAGMENT;\n"
 328         "subroutine (fs_offset) vec4 fss() { return vec4(1, 0, 0, 1); }\n"
 329         "out vec4 fs_output0;\n"
 330         "void main() {\n"
 331         "       fs_output0 = FRAGMENT();\n"
 332         "}";
 333
 334 static const char tcs_sub[] =
 335         "#version 150\n"
 336         "#extension GL_ARB_shader_subroutine : require\n"
 337         "#extension GL_ARB_tessellation_shader : require\n"
 338         "layout(vertices = 3) out;\n"
 339         "uniform tcs_uniform_block {\n"
 340         "       vec4 tcs_test;\n"
 341         "};\n"
 342         "out gl_PerVertex {\n"
 343         "       vec4 gl_Position;\n"
 344         "} gl_out[];\n"
 345         "out vec4 tes_input1[3];\n"
 346         "in gl_PerVertex {\n"
 347         "       vec4 gl_Position;\n"
 348         "} gl_in[gl_MaxPatchVertices];\n"
 349         "in vec4 vs_output1[gl_MaxPatchVertices];\n"
 350         "patch out vec4 tcs_patch;\n"
 351         "subroutine vec4 tcs_offset();\n"
 352         "subroutine uniform tcs_offset TESS_CONTROL;\n"
 353         "subroutine (tcs_offset) vec4 tcss() { return vec4(1, 0, 0, 0); }\n"
 354         "void main() {\n"
 355         "       gl_out[gl_InvocationID].gl_Position = tcs_test +"
 356         "                                             gl_in[0].gl_Position *"
 357         "                                             TESS_CONTROL();\n"
 358         "       tes_input1[gl_InvocationID] = vs_output1[0] + TESS_CONTROL();\n"
 359         "       tcs_patch = TESS_CONTROL();\n"
 360         "}";
 361
 362 static const char tes_sub[] =
 363         "#version 150\n"
 364         "#extension GL_ARB_shader_subroutine : require\n"
 365         "#extension GL_ARB_tessellation_shader : require\n"
 366         "layout(triangles) in;\n"
 367         "uniform tes_uniform_block {\n"
 368         "       vec4 tes_test;\n"
 369         "};\n"
 370         "out vec4 tes_output1;\n"
 371         "in gl_PerVertex {\n"
 372         "       vec4 gl_Position;\n"
 373         "} gl_in[gl_MaxPatchVertices];\n"
 374         "in vec4 vs_output1[gl_MaxPatchVertices];\n"
 375         "subroutine vec4 tes_offset();\n"
 376         "subroutine uniform tes_offset TESS_EVALUATION;\n"
 377         "subroutine (tes_offset) vec4 tess() { return vec4(1, 0, 0, 0); }\n"
 378         "void main() {\n"
 379         "       gl_Position = tes_test + gl_in[0].gl_Position +"
 380         "                     TESS_EVALUATION();\n"
 381         "       tes_output1 = vs_output1[0] + TESS_EVALUATION();\n"
 382         "}";
 383
 384 static const char tes_in[] =
 385         "#version 150\n"
 386         "#extension GL_ARB_shader_subroutine : require\n"
 387         "#extension GL_ARB_tessellation_shader : require\n"
 388         "layout(triangles) in;\n"
 389         "uniform tes_uniform_block {\n"
 390         "       vec4 tes_test;\n"
 391         "};\n"
 392         "out gl_PerVertex {\n"
 393         "       vec4 gl_Position;\n"
 394         "};\n"
 395         "out vec4 vs_output1;\n"
 396         "in gl_PerVertex {\n"
 397         "       vec4 gl_Position;\n"
 398         "} gl_in[gl_MaxPatchVertices];\n"
 399         "in vec4 tes_input1[gl_MaxPatchVertices];\n"
 400         "subroutine vec4 tes_offset();\n"
 401         "subroutine uniform tes_offset TESS_EVALUATION;\n"
 402         "subroutine (tes_offset) vec4 tess() { return vec4(1, 0, 0, 0); }\n"
 403         "void main() {\n"
 404         "       gl_Position = tes_test + gl_in[0].gl_Position +"
 405         "                     TESS_EVALUATION();\n"
 406         "       vs_output1 = tes_input1[0] + TESS_EVALUATION();\n"
 407         "}";
 408
 409 static const char cs_sub[] =
 410         "#version 150\n"
 411         "#extension GL_ARB_shader_subroutine : require\n"
 412         "#extension GL_ARB_shader_image_load_store : require\n"
 413         "#extension GL_ARB_compute_shader : require\n"
 414         "layout(local_size_x = 4) in;\n"
 415         "uniform cs_uniform_block {\n"
 416         "       uniform vec4 cs_test;\n"
 417         "};\n"
 418         "layout(rgba32f) uniform image2D tex;\n"
 419         "subroutine vec4 com_offset();\n"
 420         "subroutine uniform com_offset COMPUTE;\n"
 421         "subroutine (com_offset) vec4 css() { return vec4(1, 0, 0, 0); }\n"
 422         "void main() {\n"
 423         "       imageStore(tex, ivec2(0.0), cs_test + COMPUTE());\n"
 424         "}";
 425
 426 #endif