Added tests for different shader varying vec width

Vulkan specification (1.0.8, 14.1.3) states that vertex and fragment
shader varyings may differ as long as they are of the same type and the
vertex shader outputs at least as wide vectors as the fragment shader
inputs.

This set of tests link various varying vector types, all of which
are legal even though they do not match.

Affects:

dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec4_vec3
dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec4_vec2
dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec4_float
dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec3_vec2
dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec3_float
dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec2_float
dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec4_ivec3
dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec4_ivec2
dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec4_int
dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec3_ivec2
dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec3_int
dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec2_int

Components: Vulkan

VK-Gl-CTS issue: 821

Change-Id: I4afc3edb77fd6f421cafce20d09bbdd948f16dcf

diff --git a/android/cts/master/vk-master.txt b/android/cts/master/vk-master.txt
index d03906d..b5fcebc 100644 (file)
--- a/android/cts/master/vk-master.txt
+++ b/android/cts/master/vk-master.txt
@@ -185302,6 +185302,18 @@ dEQP-VK.glsl.functions.misc.argument_eval_order_2_vertex
 dEQP-VK.glsl.functions.misc.argument_eval_order_2_fragment
 dEQP-VK.glsl.linkage.varying.rules.vertex_declare
 dEQP-VK.glsl.linkage.varying.rules.both_declare
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec4_vec3
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec4_vec2
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec4_float
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec3_vec2
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec3_float
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec2_float
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec4_ivec3
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec4_ivec2
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec4_int
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec3_ivec2
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec3_int
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec2_int
 dEQP-VK.glsl.linkage.varying.rules.vertex_declare_fragment_use
 dEQP-VK.glsl.linkage.varying.rules.vertex_use_fragment_declare
 dEQP-VK.glsl.linkage.varying.rules.vertex_use_declare_fragment

diff --git a/external/vulkancts/data/vulkan/glsl/es310/linkage.test b/external/vulkancts/data/vulkan/glsl/es310/linkage.test
index 51c5dd1..87b190f 100644 (file)
--- a/external/vulkancts/data/vulkan/glsl/es310/linkage.test
+++ b/external/vulkancts/data/vulkan/glsl/es310/linkage.test
@@ -51,6 +51,352 @@ group varying "Varying linkage"
                        ""
                end
 
+               # vec4 vs vec3
+               case legal_mismatch_vec4_vec3
+                       version 310 es
+                       desc "legal vertex to fragment shader varying type mismatches (vec4 to vec3)"
+                       vertex ""
+                               #version 310 es
+                               ${VERTEX_DECLARATIONS}
+                               layout(location = 0) out mediump vec4 var;
+                               void main()
+                               {
+                                       var.x = 0.0;
+                                       var.y = 0.0;
+                                       var.z = 0.0;
+                                       var.w = 0.0;
+                                       ${VERTEX_OUTPUT}
+                               }
+                       ""
+                       fragment ""
+                               #version 310 es
+                               layout(location = 0) in mediump vec3 var;
+                               ${FRAGMENT_DECLARATIONS}
+                               void main()
+                               {
+                                       ${FRAG_COLOR} = vec4(1.0 + var.x + var.y + var.z);
+                               }
+                       ""
+               end
+
+               # vec4 vs vec2
+               case legal_mismatch_vec4_vec2
+                       version 310 es
+                       desc "legal vertex to fragment shader varying type mismatches (vec4 to vec2)"
+                       vertex ""
+                               #version 310 es
+                               ${VERTEX_DECLARATIONS}
+                               layout(location = 0) out mediump vec4 var;
+                               void main()
+                               {
+                                       var.x = 0.0;
+                                       var.y = 0.0;
+                                       var.z = 0.0;
+                                       var.w = 0.0;
+                                       ${VERTEX_OUTPUT}
+                               }
+                       ""
+                       fragment ""
+                               #version 310 es
+                               layout(location = 0) in mediump vec2 var;
+                               ${FRAGMENT_DECLARATIONS}
+                               void main()
+                               {
+                                       ${FRAG_COLOR} = vec4(1.0 + var.x + var.y);
+                               }
+                       ""
+               end
+
+               # vec4 vs float
+               case legal_mismatch_vec4_float
+                       version 310 es
+                       desc "legal vertex to fragment shader varying type mismatches (vec4 to float)"
+                       vertex ""
+                               #version 310 es
+                               ${VERTEX_DECLARATIONS}
+                               layout(location = 0) out mediump vec4 var;
+                               void main()
+                               {
+                                       var.x = 0.0;
+                                       var.y = 0.0;
+                                       var.z = 0.0;
+                                       var.w = 0.0;
+                                       ${VERTEX_OUTPUT}
+                               }
+                       ""
+                       fragment ""
+                               #version 310 es
+                               layout(location = 0) in mediump float var;
+                               ${FRAGMENT_DECLARATIONS}
+                               void main()
+                               {
+                                       ${FRAG_COLOR} = vec4(1.0 + var);
+                               }
+                       ""
+               end
+
+               # vec3 vs vec2
+               case legal_mismatch_vec3_vec2
+                       version 310 es
+                       desc "legal vertex to fragment shader varying type mismatches (vec3 to vec2)"
+                       vertex ""
+                               #version 310 es
+                               ${VERTEX_DECLARATIONS}
+                               layout(location = 0) out mediump vec3 var;
+                               void main()
+                               {
+                                       var.x = 0.0;
+                                       var.y = 0.0;
+                                       var.z = 0.0;
+                                       ${VERTEX_OUTPUT}
+                               }
+                       ""
+                       fragment ""
+                               #version 310 es
+                               layout(location = 0) in mediump vec2 var;
+                               ${FRAGMENT_DECLARATIONS}
+                               void main()
+                               {
+                                       ${FRAG_COLOR} = vec4(1.0 + var.x + var.y);
+                               }
+                       ""
+               end
+
+               # vec3 vs float
+               case legal_mismatch_vec3_float
+                       version 310 es
+                       desc "legal vertex to fragment shader varying type mismatches (vec3 to float)"
+                       vertex ""
+                               #version 310 es
+                               ${VERTEX_DECLARATIONS}
+                               layout(location = 0) out mediump vec3 var;
+                               void main()
+                               {
+                                       var.x = 0.0;
+                                       var.y = 0.0;
+                                       var.z = 0.0;
+                                       ${VERTEX_OUTPUT}
+                               }
+                       ""
+                       fragment ""
+                               #version 310 es
+                               layout(location = 0) in mediump float var;
+                               ${FRAGMENT_DECLARATIONS}
+                               void main()
+                               {
+                                       ${FRAG_COLOR} = vec4(1.0 + var);
+                               }
+                       ""
+               end
+
+               # vec2 vs float
+               case legal_mismatch_vec2_float
+                       version 310 es
+                       desc "legal vertex to fragment shader varying type mismatches (vec2 to float)"
+                       vertex ""
+                               #version 310 es
+                               ${VERTEX_DECLARATIONS}
+                               layout(location = 0) out mediump vec2 var;
+                               void main()
+                               {
+                                       var.x = 0.0;
+                                       var.y = 0.0;
+                                       ${VERTEX_OUTPUT}
+                               }
+                       ""
+                       fragment ""
+                               #version 310 es
+                               layout(location = 0) in mediump float var;
+                               ${FRAGMENT_DECLARATIONS}
+                               void main()
+                               {
+                                       ${FRAG_COLOR} = vec4(1.0 + var);
+                               }
+                       ""
+               end
+
+               # ivec4 vs ivec3
+               case legal_mismatch_ivec4_ivec3
+                       version 310 es
+                       desc "legal vertex to fragment shader varying type mismatches (ivec4 to ivec3)"
+                       vertex ""
+                               #version 310 es
+                               ${VERTEX_DECLARATIONS}
+                               layout(location = 0) out mediump ivec4 var;
+                               void main()
+                               {
+                                       var.x = 0;
+                                       var.y = 0;
+                                       var.z = 0;
+                                       var.w = 0;
+                                       ${VERTEX_OUTPUT}
+                               }
+                       ""
+                       fragment ""
+                               #version 310 es
+                               layout(location = 0) in mediump flat ivec3 var;
+                               ${FRAGMENT_DECLARATIONS}
+                               void main()
+                               {
+                                       if (var.x + var.y + var.z == 0)
+                                               ${FRAG_COLOR} = vec4(1.0);
+                                       else
+                                               ${FRAG_COLOR} = vec4(0.0);
+                               }
+                       ""
+               end
+
+               # ivec4 vs ivec2
+               case legal_mismatch_ivec4_ivec2
+                       version 310 es
+                       desc "legal vertex to fragment shader varying type mismatches (ivec4 to ivec2)"
+                       vertex ""
+                               #version 310 es
+                               ${VERTEX_DECLARATIONS}
+                               layout(location = 0) out mediump ivec4 var;
+                               void main()
+                               {
+                                       var.x = 0;
+                                       var.y = 0;
+                                       var.z = 0;
+                                       var.w = 0;
+                                       ${VERTEX_OUTPUT}
+                               }
+                       ""
+                       fragment ""
+                               #version 310 es
+                               layout(location = 0) in mediump flat ivec2 var;
+                               ${FRAGMENT_DECLARATIONS}
+                               void main()
+                               {
+                                       if (var.x + var.y == 0)
+                                               ${FRAG_COLOR} = vec4(1.0);
+                                       else
+                                               ${FRAG_COLOR} = vec4(0.0);
+                               }
+                       ""
+               end
+
+               # ivec4 vs int
+               case legal_mismatch_ivec4_int
+                       version 310 es
+                       desc "legal vertex to fragment shader varying type mismatches (ivec4 to int)"
+                       vertex ""
+                               #version 310 es
+                               ${VERTEX_DECLARATIONS}
+                               layout(location = 0) out mediump ivec4 var;
+                               void main()
+                               {
+                                       var.x = 0;
+                                       var.y = 0;
+                                       var.z = 0;
+                                       var.w = 0;
+                                       ${VERTEX_OUTPUT}
+                               }
+                       ""
+                       fragment ""
+                               #version 310 es
+                               layout(location = 0) in mediump flat int var;
+                               ${FRAGMENT_DECLARATIONS}
+                               void main()
+                               {
+                                       if (var == 0)
+                                               ${FRAG_COLOR} = vec4(1.0);
+                                       else
+                                               ${FRAG_COLOR} = vec4(0.0);
+                               }
+                       ""
+               end
+
+               # ivec3 vs ivec2
+               case legal_mismatch_ivec3_ivec2
+                       version 310 es
+                       desc "legal vertex to fragment shader varying type mismatches (ivec3 to ivec2)"
+                       vertex ""
+                               #version 310 es
+                               ${VERTEX_DECLARATIONS}
+                               layout(location = 0) out mediump ivec3 var;
+                               void main()
+                               {
+                                       var.x = 0;
+                                       var.y = 0;
+                                       var.z = 0;
+                                       ${VERTEX_OUTPUT}
+                               }
+                       ""
+                       fragment ""
+                               #version 310 es
+                               layout(location = 0) in mediump flat ivec2 var;
+                               ${FRAGMENT_DECLARATIONS}
+                               void main()
+                               {
+                                       if (var.x + var.y == 0)
+                                               ${FRAG_COLOR} = vec4(1.0);
+                                       else
+                                               ${FRAG_COLOR} = vec4(0.0);
+                               }
+                       ""
+               end
+
+               # ivec3 vs int
+               case legal_mismatch_ivec3_int
+                       version 310 es
+                       desc "legal vertex to fragment shader varying type mismatches (ivec3 to int)"
+                       vertex ""
+                               #version 310 es
+                               ${VERTEX_DECLARATIONS}
+                               layout(location = 0) out mediump ivec3 var;
+                               void main()
+                               {
+                                       var.x = 0;
+                                       var.y = 0;
+                                       var.z = 0;
+                                       ${VERTEX_OUTPUT}
+                               }
+                       ""
+                       fragment ""
+                               #version 310 es
+                               layout(location = 0) in mediump flat int var;
+                               ${FRAGMENT_DECLARATIONS}
+                               void main()
+                               {
+                                       if (var == 0)
+                                               ${FRAG_COLOR} = vec4(1.0);
+                                       else
+                                               ${FRAG_COLOR} = vec4(0.0);
+                               }
+                       ""
+               end
+
+               # ivec2 vs int
+               case legal_mismatch_ivec2_int
+                       version 310 es
+                       desc "legal vertex to fragment shader varying type mismatches (ivec2 to int)"
+                       vertex ""
+                               #version 310 es
+                               ${VERTEX_DECLARATIONS}
+                               layout(location = 0) out mediump ivec2 var;
+                               void main()
+                               {
+                                       var.x = 0;
+                                       var.y = 0;
+                                       ${VERTEX_OUTPUT}
+                               }
+                       ""
+                       fragment ""
+                               #version 310 es
+                               layout(location = 0) in mediump flat int var;
+                               ${FRAGMENT_DECLARATIONS}
+                               void main()
+                               {
+                                       if (var == 0)
+                                               ${FRAG_COLOR} = vec4(1.0);
+                                       else
+                                               ${FRAG_COLOR} = vec4(0.0);
+                               }
+                       ""
+               end
+
                # declared in vertex shader, static use in frag shader
                case vertex_declare_fragment_use
                        version 310 es

diff --git a/external/vulkancts/mustpass/1.0.3/vk-default.txt b/external/vulkancts/mustpass/1.0.3/vk-default.txt
index 88350a1..d00d7d4 100644 (file)
--- a/external/vulkancts/mustpass/1.0.3/vk-default.txt
+++ b/external/vulkancts/mustpass/1.0.3/vk-default.txt
@@ -185283,6 +185283,18 @@ dEQP-VK.glsl.functions.misc.argument_eval_order_2_vertex
 dEQP-VK.glsl.functions.misc.argument_eval_order_2_fragment
 dEQP-VK.glsl.linkage.varying.rules.vertex_declare
 dEQP-VK.glsl.linkage.varying.rules.both_declare
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec4_vec3
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec4_vec2
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec4_float
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec3_vec2
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec3_float
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_vec2_float
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec4_ivec3
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec4_ivec2
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec4_int
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec3_ivec2
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec3_int
+dEQP-VK.glsl.linkage.varying.rules.legal_mismatch_ivec2_int
 dEQP-VK.glsl.linkage.varying.rules.vertex_declare_fragment_use
 dEQP-VK.glsl.linkage.varying.rules.vertex_use_fragment_declare
 dEQP-VK.glsl.linkage.varying.rules.vertex_use_declare_fragment