diff options
Diffstat (limited to 'chromium/third_party/glslang/src/Test/310.frag')
-rw-r--r-- | chromium/third_party/glslang/src/Test/310.frag | 431 |
1 files changed, 431 insertions, 0 deletions
diff --git a/chromium/third_party/glslang/src/Test/310.frag b/chromium/third_party/glslang/src/Test/310.frag new file mode 100644 index 00000000000..2290ce17c76 --- /dev/null +++ b/chromium/third_party/glslang/src/Test/310.frag @@ -0,0 +1,431 @@ +#version 310 es +highp float nodef3(float); // ERROR, no default precision +precision mediump float; +precision highp usampler2D; +precision highp sampler2D; +precision highp isampler2DArray; + +layout(origin_upper_left, pixel_center_integer) in vec4 gl_FragCoord; // ERROR, not supported + +layout(location = 2) in vec3 v3; +layout(location = 2) in mat4 yi; // ERROR, locations conflict with xi + +uniform sampler2D arrayedSampler[5]; +uniform usampler2D usamp2d; +uniform usampler2DRect samp2dr; // ERROR, reserved +uniform isampler2DArray isamp2DA; + +in vec2 c2D; +uniform int i; + +void main() +{ + vec4 v = texture(arrayedSampler[i], c2D); // ERROR + + ivec2 offsets[4]; + const ivec2 constOffsets[4] = ivec2[4](ivec2(1,2), ivec2(3,4), ivec2(15,16), ivec2(-2,0)); + uvec4 uv4 = textureGatherOffsets(samp2dr, c2D, offsets, 2); // ERROR, not supported + vec4 v4 = textureGather(arrayedSampler[0], c2D); + ivec4 iv4 = textureGatherOffset(isamp2DA, vec3(0.1), ivec2(1), 3); + iv4 = textureGatherOffset(isamp2DA, vec3(0.1), ivec2(1), i); // ERROR, last argument not const + iv4 = textureGatherOffset(isamp2DA, vec3(0.1), ivec2(1), 4); // ERROR, last argument out of range + iv4 = textureGatherOffset(isamp2DA, vec3(0.1), ivec2(1), 1+2); + iv4 = textureGatherOffset(isamp2DA, vec3(0.1), ivec2(0.5)); + iv4 = textureGatherOffset(isamp2DA, vec3(0.1), ivec2(i)); // ERROR, offset not constant +} + +out vec4 outp; +void foo23() +{ + const ivec2[3] offsets = ivec2[3](ivec2(1,2), ivec2(3,4), ivec2(15,16)); + + textureProjGradOffset(usamp2d, outp, vec2(0.0), vec2(0.0), ivec2(c2D)); // ERROR, offset not constant + textureProjGradOffset(usamp2d, outp, vec2(0.0), vec2(0.0), offsets[1]); + textureProjGradOffset(usamp2d, outp, vec2(0.0), vec2(0.0), offsets[2]); // ERROR, offset out of range + textureProjGradOffset(usamp2d, outp, vec2(0.0), vec2(0.0), ivec2(-10, 20)); // ERROR, offset out of range + + if (gl_HelperInvocation) + ++outp; + + int sum = gl_MaxVertexImageUniforms + + gl_MaxFragmentImageUniforms + + gl_MaxComputeImageUniforms + + gl_MaxCombinedImageUniforms + + gl_MaxCombinedShaderOutputResources; + + bool b1, b2, b3, b; + + b1 = mix(b2, b3, b); + uvec3 um3 = mix(uvec3(i), uvec3(i), bvec3(b)); + ivec4 im4 = mix(ivec4(i), ivec4(i), bvec4(b)); +} + +layout(binding=3) uniform sampler2D s1; +layout(binding=3) uniform sampler2D s2; // ERROR: overlapping bindings? Don't see that in the 310 spec. +layout(binding=2) uniform writeonly image2D i2D; +layout(binding=4) uniform readonly image3D i3D; +layout(binding=5) uniform imageCube iCube; +layout(binding=6) uniform image2DArray i2DA; +layout(binding=6) uniform coherent volatile restrict image2D i2Dqualified; + +layout(binding = 1) uniform bb { + int foo; + layout(binding = 2) float f; // ERROR +} bbi; + +in centroid vec4 centroidIn; +layout(location = 200000) uniform vec4 bigl; // ERROR, location too big + +layout(early_fragment_tests) in; + +layout(location = 40) out vec4 bigout1; // ERROR, too big +layout(location = 40) out vec4 bigout2; // ERROR, overlap +layout(location = -2) out vec4 neg; // ERROR, negative + +layout(std430) buffer b430 { + int i; +} b430i; + +layout(shared) uniform bshar { + int i; +} bshari; + +in smooth vec4 smoothIn; +in flat int flatIn; + +uniform sampler2DMS s2dms; + +void foots() +{ + highp ivec2 v2 = textureSize(s1, 2); + highp ivec3 v3 = textureSize(isamp2DA, 3); + v2 = textureSize(s2dms); + v2 = imageSize(i2D); + v3 = imageSize(i3D); + v2 = imageSize(iCube); + v3 = imageSize(i2DA); + v2 = imageSize(i2Dqualified); +} + +out bool bout; // ERROR +out image2D imageOut; // ERROR +out mat2x3 mout; // ERROR + +in bool inb; // ERROR +in sampler2D ino; // ERROR +in float ina[4]; +in float inaa[4][2]; // ERROR +struct S { float f; }; +in S ins; +in S[4] inasa; // ERROR +in S insa[4]; // ERROR +struct SA { float f[4]; }; +in SA inSA; // ERROR +struct SS { float f; S s; }; +in SS inSS; // ERROR + +#ifndef GL_EXT_shader_io_blocks +#error GL_EXT_shader_io_blocks not defined +#endif + +#extension GL_EXT_shader_io_blocks : enable + +out outbname { int a; } outbinst; // ERROR, not out block in fragment shader + +in inbname { + int a; + vec4 v; + struct { int b; } s; // ERROR, nested struct definition +} inbinst; + +in inbname2 { + layout(location = 12) int aAnon; + layout(location = 13) centroid in vec4 vAnon; +}; + +in layout(location = 13) vec4 aliased; // ERROR, aliased + +in inbname2 { // ERROR, reuse of block name + int aAnon; + centroid in vec4 vAnon; +}; + +in badmember { // ERROR, aAnon already in global scope + int aAnon; +}; + +int inbname; // ERROR, redefinition of block name + +vec4 vAnon; // ERROR, anon in global scope; redefinition + +in arrayed { + float f; +} arrayedInst[4]; + +void fooIO() +{ + vec4 v = inbinst.v + vAnon; + v *= arrayedInst[2].f; + v *= arrayedInst[i].f; +} + +in vec4 gl_FragCoord; +layout(origin_upper_left, pixel_center_integer) in vec4 gl_FragCoord; // ERROR, non-ES + +layout(early_fragment_tests) in; +out float gl_FragDepth; +layout(depth_any) out float gl_FragDepth; // ERROR, non-ES + +void foo_IO() +{ + gl_FragDepth = 0.2; // ERROR, early_fragment_tests declared + gl_Layer; // ERROR, not present + gl_PrimitiveID; // ERROR, not present + bool f = gl_FrontFacing; +} + +out float gl_FragDepth; + +#extension GL_OES_geometry_shader : enable + +void foo_GS() +{ + highp int l = gl_Layer; + highp int p = gl_PrimitiveID; +} + +in vec2 inf, ing; +uniform ivec2 offsets[4]; +uniform sampler2D sArray[4]; +uniform int sIndex; +layout(binding = 0) uniform atomic_uint auArray[2]; +uniform ubName { int i; } ubInst[4]; +buffer bbName { int i; } bbInst[4]; +uniform writeonly image2D iArray[5]; +const ivec2 constOffsets[4] = ivec2[4](ivec2(0.1), ivec2(0.2), ivec2(0.3), ivec2(0.4)); + +void pfooBad() +{ + precise vec2 h; // ERROR reserved + h = fma(inf, ing, h); // ERROR, not available + textureGatherOffset(sArray[0], vec2(0.1), ivec2(inf)); // ERROR, offset not constant + textureGatherOffsets(sArray[0], vec2(0.1), constOffsets); // ERROR, not available +} + +#extension GL_OES_gpu_shader5 : enable + +void pfoo() +{ + precise vec2 h; + h = fma(inf, ing, h); + textureGatherOffset(sArray[0], vec2(0.1), ivec2(inf)); + textureGatherOffsets(sArray[0], vec2(0.1), constOffsets); + textureGatherOffsets(sArray[0], vec2(0.1), offsets); // ERROR, offset not constant +} + +#extension GL_EXT_texture_cube_map_array : enable + +precision highp imageCubeArray ; +precision highp iimageCubeArray ; +precision highp uimageCubeArray ; + +precision highp samplerCubeArray ; +precision highp samplerCubeArrayShadow; +precision highp isamplerCubeArray ; +precision highp usamplerCubeArray ; + +uniform writeonly imageCubeArray CA1; +uniform writeonly iimageCubeArray CA2; +uniform writeonly uimageCubeArray CA3; + +#ifdef GL_EXT_texture_cube_map_array +uniform samplerCubeArray CA4; +uniform samplerCubeArrayShadow CA5; +uniform isamplerCubeArray CA6; +uniform usamplerCubeArray CA7; +#endif + +void CAT() +{ + highp vec4 b4 = texture(CA4, vec4(0.5), 0.24); + highp ivec4 b6 = texture(CA6, vec4(0.5), 0.26); + highp uvec4 b7 = texture(CA7, vec4(0.5), 0.27); +} + +void badSample() +{ + lowp int a1 = gl_SampleID; // ERROR, need extension + mediump vec2 a2 = gl_SamplePosition; // ERROR, need extension + highp int a3 = gl_SampleMaskIn[0]; // ERROR, need extension + gl_SampleMask[0] = a3; // ERROR, need extension + mediump int n = gl_NumSamples; // ERROR, need extension +} + +#ifdef GL_OES_sample_variables +#extension GL_OES_sample_variables : enable +#endif + +void goodSample() +{ + lowp int a1 = gl_SampleID; + mediump vec2 a2 = gl_SamplePosition; + highp int a3 = gl_SampleMaskIn[0]; + gl_SampleMask[0] = a3; + mediump int n1 = gl_MaxSamples; + mediump int n2 = gl_NumSamples; +} + +uniform layout(r32f) highp image2D im2Df; +uniform layout(r32ui) highp uimage2D im2Du; +uniform layout(r32i) highp iimage2D im2Di; +uniform ivec2 P; + +void badImageAtom() +{ + float datf; + int dati; + uint datu; + + imageAtomicAdd( im2Di, P, dati); // ERROR, need extension + imageAtomicAdd( im2Du, P, datu); // ERROR, need extension + imageAtomicMin( im2Di, P, dati); // ERROR, need extension + imageAtomicMin( im2Du, P, datu); // ERROR, need extension + imageAtomicMax( im2Di, P, dati); // ERROR, need extension + imageAtomicMax( im2Du, P, datu); // ERROR, need extension + imageAtomicAnd( im2Di, P, dati); // ERROR, need extension + imageAtomicAnd( im2Du, P, datu); // ERROR, need extension + imageAtomicOr( im2Di, P, dati); // ERROR, need extension + imageAtomicOr( im2Du, P, datu); // ERROR, need extension + imageAtomicXor( im2Di, P, dati); // ERROR, need extension + imageAtomicXor( im2Du, P, datu); // ERROR, need extension + imageAtomicExchange(im2Di, P, dati); // ERROR, need extension + imageAtomicExchange(im2Du, P, datu); // ERROR, need extension + imageAtomicExchange(im2Df, P, datf); // ERROR, need extension + imageAtomicCompSwap(im2Di, P, 3, dati); // ERROR, need extension + imageAtomicCompSwap(im2Du, P, 5u, datu); // ERROR, need extension +} + +#ifdef GL_OES_shader_image_atomic +#extension GL_OES_shader_image_atomic : enable +#endif + +uniform layout(rgba32f) highp image2D badIm2Df; // ERROR, needs readonly or writeonly +uniform layout(rgba8ui) highp uimage2D badIm2Du; // ERROR, needs readonly or writeonly +uniform layout(rgba16i) highp iimage2D badIm2Di; // ERROR, needs readonly or writeonly + +void goodImageAtom() +{ + float datf; + int dati; + uint datu; + + imageAtomicAdd( im2Di, P, dati); + imageAtomicAdd( im2Du, P, datu); + imageAtomicMin( im2Di, P, dati); + imageAtomicMin( im2Du, P, datu); + imageAtomicMax( im2Di, P, dati); + imageAtomicMax( im2Du, P, datu); + imageAtomicAnd( im2Di, P, dati); + imageAtomicAnd( im2Du, P, datu); + imageAtomicOr( im2Di, P, dati); + imageAtomicOr( im2Du, P, datu); + imageAtomicXor( im2Di, P, dati); + imageAtomicXor( im2Du, P, datu); + imageAtomicExchange(im2Di, P, dati); + imageAtomicExchange(im2Du, P, datu); + imageAtomicExchange(im2Df, P, datf); + imageAtomicCompSwap(im2Di, P, 3, dati); + imageAtomicCompSwap(im2Du, P, 5u, datu); + + imageAtomicMax(badIm2Di, P, dati); // ERROR, not an allowed layout() on the image + imageAtomicMax(badIm2Du, P, datu); // ERROR, not an allowed layout() on the image + imageAtomicExchange(badIm2Df, P, datf); // ERROR, not an allowed layout() on the image +} + +sample in vec4 colorSampInBad; // ERROR, reserved +centroid out vec4 colorCentroidBad; // ERROR +flat out vec4 colorBadFlat; // ERROR +smooth out vec4 colorBadSmooth; // ERROR +noperspective out vec4 colorBadNo; // ERROR +flat centroid in vec2 colorfc; +in float scalarIn; + +void badInterp() +{ + interpolateAtCentroid(colorfc); // ERROR, need extension + interpolateAtSample(colorfc, 1); // ERROR, need extension + interpolateAtOffset(colorfc, vec2(0.2)); // ERROR, need extension +} + +#if defined GL_OES_shader_multisample_interpolation +#extension GL_OES_shader_multisample_interpolation : enable +#endif + +sample in vec4 colorSampIn; +sample out vec4 colorSampleBad; // ERROR +flat sample in vec4 colorfsi; +sample in vec3 sampInArray[4]; + +void interp() +{ + float res; + vec2 res2; + vec3 res3; + vec4 res4; + + res2 = interpolateAtCentroid(colorfc); + res4 = interpolateAtCentroid(colorSampIn); + res4 = interpolateAtCentroid(colorfsi); + res = interpolateAtCentroid(scalarIn); + res3 = interpolateAtCentroid(sampInArray); // ERROR + res3 = interpolateAtCentroid(sampInArray[2]); + res2 = interpolateAtCentroid(sampInArray[2].xy); // ERROR + + res3 = interpolateAtSample(sampInArray, 1); // ERROR + res3 = interpolateAtSample(sampInArray[i], 0); + res2 = interpolateAtSample(sampInArray[2].xy, 2); // ERROR + res = interpolateAtSample(scalarIn, 1); + + res3 = interpolateAtOffset(sampInArray, vec2(0.2)); // ERROR + res3 = interpolateAtOffset(sampInArray[2], vec2(0.2)); + res2 = interpolateAtOffset(sampInArray[2].xy, vec2(0.2)); // ERROR, no swizzle + res = interpolateAtOffset(scalarIn + scalarIn, vec2(0.2)); // ERROR, no binary ops other than dereference + res = interpolateAtOffset(scalarIn, vec2(0.2)); + + float f; + res = interpolateAtCentroid(f); // ERROR, not interpolant + res4 = interpolateAtSample(outp, 0); // ERROR, not interpolant +} + +layout(blend_support_softlight) out; // ERROR, need extension + +#ifdef GL_KHR_blend_equation_advanced +#extension GL_KHR_blend_equation_advanced : enable +#endif + +layout(blend_support_multiply) out; +layout(blend_support_screen) out; +layout(blend_support_overlay) out; +layout(blend_support_darken, blend_support_lighten) out; +layout(blend_support_colordodge) layout(blend_support_colorburn) out; +layout(blend_support_hardlight) out; +layout(blend_support_softlight) out; +layout(blend_support_difference) out; +layout(blend_support_exclusion) out; +layout(blend_support_hsl_hue) out; +layout(blend_support_hsl_saturation) out; +layout(blend_support_hsl_color) out; +layout(blend_support_hsl_luminosity) out; +layout(blend_support_all_equations) out; + +layout(blend_support_hsl_luminosity) out; // okay to repeat + +layout(blend_support_hsl_luminosity) in; // ERROR, only on "out" +layout(blend_support_hsl_luminosity) out vec4; // ERROR, only on standalone +layout(blend_support_hsl_luminosity) out vec4 badout; // ERROR, only on standalone +layout(blend_support_hsl_luminosity) struct badS {int i;}; // ERROR, only on standalone +layout(blend_support_hsl_luminosity) void blendFoo() { } // ERROR, only on standalone +void blendFoo(layout(blend_support_hsl_luminosity) vec3 v) { } // ERROR, only on standalone +layout(blend_support_flizbit) out; // ERROR, no flizbit + +out vec4 outAA[2][2]; // ERROR |