Home | History | Annotate | Download | only in shaders 
      1 group extension_macros "Extension macro definitions"
      2 
      3 	case android_extension_pack_es31a
      4 		version 310 es
      5 		desc "Test GL_ANDROID_extension_pack_es31a macro"
      6 		require extension { "GL_ANDROID_extension_pack_es31a" }
      7 		values
      8 		{
      9 			output float out0 = 1.0;
     10 		}
     11 
     12 		vertex ""
     13 			#version 310 es
     14 			${VERTEX_DECLARATIONS}
     15 
     16 			void main()
     17 			{
     18 				${VERTEX_OUTPUT}
     19 			}
     20 		""
     21 		fragment ""
     22 			#version 310 es
     23 			precision mediump float;
     24 			${FRAGMENT_DECLARATIONS}
     25 
     26 			void main()
     27 			{
     28 				out0 = float(GL_ANDROID_extension_pack_es31a);
     29 				${FRAGMENT_OUTPUT}
     30 			}
     31 		""
     32 	end
     33 end
     34 
     35 group extension_directive "Extension directive"
     36 
     37 	case oes_sample_variables
     38 		version 310 es
     39 		desc "Test oes_sample_variables extension"
     40 		require extension { "GL_ANDROID_extension_pack_es31a" }
     41 		values
     42 		{
     43 			output float out0 = 1.0;
     44 		}
     45 
     46 		vertex ""
     47 			#version 310 es
     48 			${VERTEX_DECLARATIONS}
     49 
     50 			void main()
     51 			{
     52 				${VERTEX_OUTPUT}
     53 			}
     54 		""
     55 		fragment ""
     56 			#version 310 es
     57 			precision mediump float;
     58 			${FRAGMENT_DECLARATIONS}
     59 
     60 			void main()
     61 			{
     62 				out0 = (gl_SampleID < 0) ? (0.0) : (1.0);
     63 				${FRAGMENT_OUTPUT}
     64 			}
     65 		""
     66 	end
     67 
     68 	case oes_shader_image_atomic
     69 		version 310 es
     70 		desc "Test oes_shader_image_atomic extension"
     71 		require extension { "GL_ANDROID_extension_pack_es31a" }
     72 		expect build_successful
     73 
     74 		vertex ""
     75 			#version 310 es
     76 			${VERTEX_DECLARATIONS}
     77 
     78 			void main()
     79 			{
     80 				${VERTEX_OUTPUT}
     81 			}
     82 		""
     83 		fragment ""
     84 			#version 310 es
     85 			precision mediump float;
     86 			${FRAGMENT_DECLARATIONS}
     87 			layout(binding=0, r32i) coherent uniform highp iimage2D u_image;
     88 
     89 			void main()
     90 			{
     91 				if (imageAtomicXor(u_image, ivec2(0, 0), 1) == 0)
     92 					discard;
     93 				${FRAGMENT_OUTPUT}
     94 			}
     95 		""
     96 	end
     97 
     98 	case oes_shader_multisample_interpolation
     99 		version 310 es
    100 		desc "Test oes_shader_multisample_interpolation extension"
    101 		require extension { "GL_ANDROID_extension_pack_es31a" }
    102 		values
    103 		{
    104 			input float in0 = 1.0;
    105 			output float out0 = 1.0;
    106 		}
    107 
    108 		vertex ""
    109 			#version 310 es
    110 			${VERTEX_DECLARATIONS}
    111 			sample out highp float v_var;
    112 
    113 			void main()
    114 			{
    115 				v_var = in0;
    116 				${VERTEX_OUTPUT}
    117 			}
    118 		""
    119 		fragment ""
    120 			#version 310 es
    121 			precision mediump float;
    122 			${FRAGMENT_DECLARATIONS}
    123 			sample in mediump float v_var;
    124 
    125 			void main()
    126 			{
    127 				out0 = v_var;
    128 				${FRAGMENT_OUTPUT}
    129 			}
    130 		""
    131 	end
    132 
    133 	case oes_texture_storage_multisample_2d_array
    134 		version 310 es
    135 		desc "Test oes_texture_storage_multisample_2d_array extension"
    136 		require extension { "GL_ANDROID_extension_pack_es31a" }
    137 		expect build_successful
    138 
    139 		vertex ""
    140 			#version 310 es
    141 			${VERTEX_DECLARATIONS}
    142 
    143 			void main()
    144 			{
    145 				${VERTEX_OUTPUT}
    146 			}
    147 		""
    148 		fragment ""
    149 			#version 310 es
    150 			precision mediump float;
    151 			${FRAGMENT_DECLARATIONS}
    152 			uniform mediump sampler2DMSArray u_sampler;
    153 
    154 			void main()
    155 			{
    156 				if (texelFetch(u_sampler, ivec3(0, 0, 0), 0).r > 0.5)
    157 					discard;
    158 				${FRAGMENT_OUTPUT}
    159 			}
    160 		""
    161 	end
    162 
    163 	case ext_geometry_shader
    164 		version 310 es
    165 		desc "Test ext_geometry_shader extension"
    166 		require extension { "GL_ANDROID_extension_pack_es31a" }
    167 		values
    168 		{
    169 			input float in0 = 1.0;
    170 			output float out0 = 1.0;
    171 		}
    172 
    173 		vertex ""
    174 			#version 310 es
    175 			${VERTEX_DECLARATIONS}
    176 			out highp float geo_in;
    177 			void main()
    178 			{
    179 				geo_in = in0;
    180 				${VERTEX_OUTPUT}
    181 			}
    182 		""
    183 		geometry ""
    184 			#version 310 es
    185 			${GEOMETRY_DECLARATIONS}
    186 			in lowp float geo_in[];
    187 			out mediump float geo_out;
    188 			void main()
    189 			{
    190 				for (int ndx = 0; ndx < gl_in.length(); ++ndx)
    191 				{
    192 					geo_out = geo_in[ndx];
    193 					gl_Position = gl_in[ndx].gl_Position;
    194 					EmitVertex();
    195 				}
    196 			}
    197 		""
    198 		fragment ""
    199 			#version 310 es
    200 			precision mediump float;
    201 			${FRAGMENT_DECLARATIONS}
    202 			in mediump float geo_out;
    203 			void main()
    204 			{
    205 				out0 = geo_out;
    206 				${FRAGMENT_OUTPUT}
    207 			}
    208 		""
    209 	end
    210 
    211 	case ext_gpu_shader5
    212 		version 310 es
    213 		desc "Test ext_gpu_shader5 extension"
    214 		require extension { "GL_ANDROID_extension_pack_es31a" }
    215 		values
    216 		{
    217 			input float in0 = 1.0;
    218 			output float out0 = 2.0;
    219 		}
    220 
    221 		vertex ""
    222 			#version 310 es
    223 			${VERTEX_DECLARATIONS}
    224 			out highp float v_var;
    225 			void main()
    226 			{
    227 				v_var = in0;
    228 				${VERTEX_OUTPUT}
    229 			}
    230 		""
    231 		fragment ""
    232 			#version 310 es
    233 			precision mediump float;
    234 			${FRAGMENT_DECLARATIONS}
    235 			in mediump float v_var;
    236 			void main()
    237 			{
    238 				precise float fmaResult = fma(v_var, v_var, v_var);
    239 				out0 = fmaResult;
    240 				${FRAGMENT_OUTPUT}
    241 			}
    242 		""
    243 	end
    244 
    245 	case ext_primitive_bounding_box
    246 		version 310 es
    247 		desc "Test ext_primitive_bounding_box extension"
    248 		require extension { "GL_ANDROID_extension_pack_es31a" }
    249 		values
    250 		{
    251 			input float in0 = 1.0;
    252 			output float out0 = 1.0;
    253 		}
    254 
    255 		vertex ""
    256 			#version 310 es
    257 			${VERTEX_DECLARATIONS}
    258 			out highp float tc_in;
    259 			void main()
    260 			{
    261 				tc_in = in0;
    262 				${VERTEX_OUTPUT}
    263 			}
    264 		""
    265 		tessellation_control ""
    266 			#version 310 es
    267 			${TESSELLATION_CONTROL_DECLARATIONS}
    268 			in highp float tc_in[];
    269 			out highp float tc_out[];
    270 			void main()
    271 			{
    272 				tc_out[gl_InvocationID] = tc_in[gl_InvocationID];
    273 				// set bounding box to (-1,-1,-1, 1) .. (1,1,1,1)
    274 				gl_BoundingBoxEXT[0] = vec4(tc_in[0]-2.0, tc_in[1]-2.0, tc_in[2]-2.0, 1.0);
    275 				gl_BoundingBoxEXT[1] = vec4(tc_in[0], tc_in[1], tc_in[2], 1.0);
    276 				${TESSELLATION_CONTROL_OUTPUT}
    277 			}
    278 		""
    279 		tessellation_evaluation ""
    280 			#version 310 es
    281 			${TESSELLATION_EVALUATION_DECLARATIONS}
    282 			in highp float tc_out[];
    283 			out highp float te_out;
    284 			void main()
    285 			{
    286 				te_out = tc_out[2];
    287 				${TESSELLATION_EVALUATION_OUTPUT}
    288 			}
    289 		""
    290 		fragment ""
    291 			#version 310 es
    292 			precision mediump float;
    293 			${FRAGMENT_DECLARATIONS}
    294 			in mediump float te_out;
    295 			void main()
    296 			{
    297 				out0 = te_out;
    298 				${FRAGMENT_OUTPUT}
    299 			}
    300 		""
    301 	end
    302 
    303 	case ext_shader_io_blocks
    304 		version 310 es
    305 		desc "Test ext_shader_io_blocks extension"
    306 		require extension { "GL_ANDROID_extension_pack_es31a" }
    307 		values
    308 		{
    309 			input float in0 = 1.0;
    310 			output float out0 = 1.0;
    311 		}
    312 
    313 		vertex ""
    314 			#version 310 es
    315 			${VERTEX_DECLARATIONS}
    316 			out VaryingIOBlockName { highp float v_var; } instanceName;
    317 			void main()
    318 			{
    319 				instanceName.v_var = in0;
    320 				${VERTEX_OUTPUT}
    321 			}
    322 		""
    323 		fragment ""
    324 			#version 310 es
    325 			precision mediump float;
    326 			${FRAGMENT_DECLARATIONS}
    327 			in VaryingIOBlockName { highp float v_var; } instanceName;
    328 			void main()
    329 			{
    330 				out0 = instanceName.v_var;
    331 				${FRAGMENT_OUTPUT}
    332 			}
    333 		""
    334 	end
    335 
    336 	case ext_tessellation_shader
    337 		version 310 es
    338 		desc "Test ext_tessellation_shader extension"
    339 		require extension { "GL_ANDROID_extension_pack_es31a" }
    340 		values
    341 		{
    342 			input float in0 = 1.0;
    343 			output float out0 = 1.0;
    344 		}
    345 
    346 		vertex ""
    347 			#version 310 es
    348 			${VERTEX_DECLARATIONS}
    349 			out highp float tc_in;
    350 			void main()
    351 			{
    352 				tc_in = in0;
    353 				${VERTEX_OUTPUT}
    354 			}
    355 		""
    356 		tessellation_control ""
    357 			#version 310 es
    358 			${TESSELLATION_CONTROL_DECLARATIONS}
    359 			in highp float tc_in[];
    360 			out highp float tc_out[];
    361 			void main()
    362 			{
    363 				tc_out[gl_InvocationID] = tc_in[gl_InvocationID];
    364 				${TESSELLATION_CONTROL_OUTPUT}
    365 			}
    366 		""
    367 		tessellation_evaluation ""
    368 			#version 310 es
    369 			${TESSELLATION_EVALUATION_DECLARATIONS}
    370 			in highp float tc_out[];
    371 			out highp float te_out;
    372 			void main()
    373 			{
    374 				te_out = tc_out[2];
    375 				${TESSELLATION_EVALUATION_OUTPUT}
    376 			}
    377 		""
    378 		fragment ""
    379 			#version 310 es
    380 			precision mediump float;
    381 			${FRAGMENT_DECLARATIONS}
    382 			in mediump float te_out;
    383 			void main()
    384 			{
    385 				out0 = te_out;
    386 				${FRAGMENT_OUTPUT}
    387 			}
    388 		""
    389 	end
    390 
    391 	case ext_texture_buffer
    392 		version 310 es
    393 		desc "Test ext_texture_buffer extension"
    394 		require extension { "GL_ANDROID_extension_pack_es31a" }
    395 		expect build_successful
    396 
    397 		vertex ""
    398 			#version 310 es
    399 			${VERTEX_DECLARATIONS}
    400 
    401 			void main()
    402 			{
    403 				${VERTEX_OUTPUT}
    404 			}
    405 		""
    406 		fragment ""
    407 			#version 310 es
    408 			precision mediump float;
    409 			${FRAGMENT_DECLARATIONS}
    410 			uniform mediump samplerBuffer u_sampler;
    411 
    412 			void main()
    413 			{
    414 				if (textureSize(u_sampler) > 10)
    415 					discard;
    416 				${FRAGMENT_OUTPUT}
    417 			}
    418 		""
    419 	end
    420 
    421 	case ext_texture_cube_map_array
    422 		version 310 es
    423 		desc "Test ext_texture_cube_map_array extension"
    424 		require extension { "GL_ANDROID_extension_pack_es31a" }
    425 		expect build_successful
    426 
    427 		vertex ""
    428 			#version 310 es
    429 			${VERTEX_DECLARATIONS}
    430 
    431 			void main()
    432 			{
    433 				${VERTEX_OUTPUT}
    434 			}
    435 		""
    436 		fragment ""
    437 			#version 310 es
    438 			precision mediump float;
    439 			${FRAGMENT_DECLARATIONS}
    440 			uniform mediump samplerCubeArray u_sampler;
    441 
    442 			void main()
    443 			{
    444 				if (textureSize(u_sampler, 3).y > 10)
    445 					discard;
    446 				${FRAGMENT_OUTPUT}
    447 			}
    448 		""
    449 	end
    450 end
    451 
    452 group implementation_limits "Extended implementation limits"
    453 
    454 	case max_fragment_atomic_counter_buffers
    455 		version 310 es
    456 		desc "Test MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS limit"
    457 		require extension { "GL_ANDROID_extension_pack_es31a" }
    458 		expect build_successful
    459 
    460 		vertex ""
    461 			#version 310 es
    462 			${VERTEX_DECLARATIONS}
    463 
    464 			void main()
    465 			{
    466 				${VERTEX_OUTPUT}
    467 			}
    468 		""
    469 		fragment ""
    470 			#version 310 es
    471 			precision mediump float;
    472 			${FRAGMENT_DECLARATIONS}
    473 			layout(binding=0) uniform atomic_uint u_counter;
    474 
    475 			void main()
    476 			{
    477 				if (atomicCounterIncrement(u_counter) == 0u)
    478 					discard;
    479 				${FRAGMENT_OUTPUT}
    480 			}
    481 		""
    482 	end
    483 
    484 	case max_fragment_atomic_counters
    485 		version 310 es
    486 		desc "Test MAX_FRAGMENT_ATOMIC_COUNTERS limit"
    487 		require extension { "GL_ANDROID_extension_pack_es31a" }
    488 		expect build_successful
    489 
    490 		vertex ""
    491 			#version 310 es
    492 			${VERTEX_DECLARATIONS}
    493 
    494 			void main()
    495 			{
    496 				${VERTEX_OUTPUT}
    497 			}
    498 		""
    499 		fragment ""
    500 			#version 310 es
    501 			precision mediump float;
    502 			${FRAGMENT_DECLARATIONS}
    503 			layout(binding=0) uniform atomic_uint u_counter[8];
    504 
    505 			void main()
    506 			{
    507 				if (atomicCounterIncrement(u_counter[0]) == 0u)
    508 					discard;
    509 				if (atomicCounterIncrement(u_counter[1]) == 0u)
    510 					discard;
    511 				if (atomicCounterIncrement(u_counter[2]) == 0u)
    512 					discard;
    513 				if (atomicCounterIncrement(u_counter[3]) == 0u)
    514 					discard;
    515 				if (atomicCounterIncrement(u_counter[4]) == 0u)
    516 					discard;
    517 				if (atomicCounterIncrement(u_counter[5]) == 0u)
    518 					discard;
    519 				if (atomicCounterIncrement(u_counter[6]) == 0u)
    520 					discard;
    521 				if (atomicCounterIncrement(u_counter[7]) == 0u)
    522 					discard;
    523 				${FRAGMENT_OUTPUT}
    524 			}
    525 		""
    526 	end
    527 
    528 	case max_fragment_image_uniforms
    529 		version 310 es
    530 		desc "Test MAX_FRAGMENT_IMAGE_UNIFORMS limit"
    531 		require extension { "GL_ANDROID_extension_pack_es31a" }
    532 		expect build_successful
    533 
    534 		vertex ""
    535 			#version 310 es
    536 			${VERTEX_DECLARATIONS}
    537 
    538 			void main()
    539 			{
    540 				${VERTEX_OUTPUT}
    541 			}
    542 		""
    543 		fragment ""
    544 			#version 310 es
    545 			precision mediump float;
    546 			${FRAGMENT_DECLARATIONS}
    547 			layout(binding=0, r32i) uniform readonly highp iimage2D u_image0;
    548 			layout(binding=1, rgba16i) uniform readonly highp iimage3D u_image1;
    549 			layout(binding=2, rgba8ui) uniform readonly highp uimageCube u_image2;
    550 			layout(binding=3, rgba16f) uniform readonly highp image2DArray u_image3;
    551 
    552 			void main()
    553 			{
    554 				if (imageLoad(u_image0, ivec2(0, 0)).r == 0)
    555 					discard;
    556 				if (imageLoad(u_image1, ivec3(0, 0, 0)).r == 0)
    557 					discard;
    558 				if (imageLoad(u_image2, ivec3(0, 0, 0)).r == 0u)
    559 					discard;
    560 				if (imageLoad(u_image3, ivec3(0, 0, 0)).r == 0.0)
    561 					discard;
    562 				${FRAGMENT_OUTPUT}
    563 			}
    564 		""
    565 	end
    566 
    567 	case max_fragment_shader_storage_blocks
    568 		version 310 es
    569 		desc "Test MAX_FRAGMENT_SHADER_STORAGE_BLOCKS limit"
    570 		require extension { "GL_ANDROID_extension_pack_es31a" }
    571 		expect build_successful
    572 
    573 		vertex ""
    574 			#version 310 es
    575 			${VERTEX_DECLARATIONS}
    576 
    577 			void main()
    578 			{
    579 				${VERTEX_OUTPUT}
    580 			}
    581 		""
    582 		fragment ""
    583 			#version 310 es
    584 			precision mediump float;
    585 			${FRAGMENT_DECLARATIONS}
    586 			layout(binding=0, std430) coherent readonly buffer Buffer0
    587 			{
    588 				highp int val;
    589 				highp float vals[32];
    590 			} buffer0;
    591 			layout(binding=1, std140) volatile buffer Buffer1
    592 			{
    593 				highp float vals[];
    594 			} buffer1;
    595 			layout(binding=2, packed) restrict buffer Buffer2
    596 			{
    597 				highp int vals[15];
    598 			} buffer2;
    599 			layout(binding=3, std140) writeonly buffer Buffer3
    600 			{
    601 				highp vec3 vals[8];
    602 			} buffer3;
    603 
    604 			void main()
    605 			{
    606 				highp int readNdx = abs(int(gl_FragCoord.x));
    607 				highp int writeNdx = abs(int(gl_FragCoord.y));
    608 
    609 				if (buffer0.vals[readNdx % 32] == 0.0)
    610 					discard;
    611 
    612 				if (buffer1.vals[readNdx % 1024] == 0.0)
    613 					discard;
    614 				buffer1.vals[writeNdx % 1024] = float(readNdx);
    615 
    616 				if (buffer2.vals[readNdx % 15] == 0)
    617 					discard;
    618 				buffer2.vals[writeNdx % 15] = readNdx;
    619 
    620 				buffer3.vals[writeNdx % 8] = vec3(float(writeNdx), 0.0, float(readNdx));
    621 				${FRAGMENT_OUTPUT}
    622 			}
    623 		""
    624 	end
    625 end
    626