[Piglit] [PATCH 4/4] arb_fragment_layer_viewport: Add tests for FS reading correct values

[Chris Forbes]

This covers both in-range and out-of-range cases.
Note that we don't care what actually gets rendered -- we assume that
layered rendering and multiple viewports are verified in other tests.

The out-of-range cases are a little fiddly: the effect on the
framebuffer is undefined if gl_Layer or gl_ViewportIndex is out of
range; we may or may not actually produce any FS invocations, but if we
do, the FS must see the bogus value the previous stage wrote. This is
currently mishandled by i965.

Signed-off-by: Chris Forbes <chrisf at ijw.co.nz>
---
 .../layer-gs-writes-in-range.shader_test           | 75 +++++++++++++++++++++
 .../layer-gs-writes-out-of-range.shader_test       | 72 ++++++++++++++++++++
 .../viewport-gs-writes-in-range.shader_test        | 76 ++++++++++++++++++++++
 .../viewport-gs-writes-out-of-range.shader_test    | 73 +++++++++++++++++++++
 4 files changed, 296 insertions(+)
 create mode 100644 tests/spec/arb_fragment_layer_viewport/layer-gs-writes-in-range.shader_test
 create mode 100644 tests/spec/arb_fragment_layer_viewport/layer-gs-writes-out-of-range.shader_test
 create mode 100644 tests/spec/arb_fragment_layer_viewport/viewport-gs-writes-in-range.shader_test
 create mode 100644 tests/spec/arb_fragment_layer_viewport/viewport-gs-writes-out-of-range.shader_test

diff --git a/tests/spec/arb_fragment_layer_viewport/layer-gs-writes-in-range.shader_test b/tests/spec/arb_fragment_layer_viewport/layer-gs-writes-in-range.shader_test
new file mode 100644
index 0000000..0e899bb
--- /dev/null
+++ b/tests/spec/arb_fragment_layer_viewport/layer-gs-writes-in-range.shader_test
@@ -0,0 +1,75 @@
+[require]
+GLSL >= 1.50
+GL_ARB_fragment_layer_viewport
+GL_ARB_shader_atomic_counters
+
+#
+# Ensure that the fragment stage reads the same value for gl_Layer as was
+# written by the geometry stage.
+#
+# This test covers the case where the value written is in range.
+#
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+
+void main()
+{
+	gl_Position = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+
+layout(triangles) in;
+layout(triangle_strip, max_vertices=12) out;
+
+flat out int layer_written;
+
+void main()
+{
+	for (int layer = 0; layer < 4; layer++) {
+
+		for (int i = 0; i < 3; i++) {
+			gl_Position = gl_in[i].gl_Position;
+			layer_written = layer;
+			gl_Layer = layer;
+			EmitVertex();
+		}
+
+		EndPrimitive();
+	}
+}
+
+[fragment shader]
+#version 150
+#extension GL_ARB_fragment_layer_viewport: require
+#extension GL_ARB_shader_atomic_counters: require
+
+flat in int layer_written;
+
+layout(binding = 0) uniform atomic_uint matches;
+layout(binding = 0) uniform atomic_uint mismatches;
+
+void main()
+{
+	if (layer_written == gl_Layer)
+		atomicCounterIncrement(matches);
+	else
+		atomicCounterIncrement(mismatches);
+
+	gl_FragColor = vec4(0);
+}
+
+[test]
+texture junk 2DArray 0 ( 64 , 64 , 4 )
+fb tex layered 2DArray 0
+
+atomic counters 2
+
+
+draw rect -1 -1 2 2
+
+probe atomic counter 0 != 0
+probe atomic counter 1 == 0
diff --git a/tests/spec/arb_fragment_layer_viewport/layer-gs-writes-out-of-range.shader_test b/tests/spec/arb_fragment_layer_viewport/layer-gs-writes-out-of-range.shader_test
new file mode 100644
index 0000000..ad1bfa8
--- /dev/null
+++ b/tests/spec/arb_fragment_layer_viewport/layer-gs-writes-out-of-range.shader_test
@@ -0,0 +1,72 @@
+[require]
+GLSL >= 1.50
+GL_ARB_fragment_layer_viewport
+GL_ARB_shader_atomic_counters
+
+#
+# Ensure that the fragment stage reads the same value for gl_Layer as was
+# written by the geometry stage.
+#
+# This test covers the case where the value written is out of range.
+#
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+
+void main()
+{
+	gl_Position = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+
+layout(triangles) in;
+layout(triangle_strip, max_vertices=9) out;
+
+const int layers[] = int[]( -1, 4, 2048 );
+flat out int layer_written;
+
+void main()
+{
+	for (int layer = 0; layer < layers.length(); layer++) {
+
+		for (int i = 0; i < 3; i++) {
+			gl_Position = gl_in[i].gl_Position;
+			layer_written = layers[layer];
+			gl_Layer = layers[layer];
+			EmitVertex();
+		}
+
+		EndPrimitive();
+	}
+}
+
+[fragment shader]
+#version 150
+#extension GL_ARB_fragment_layer_viewport: require
+#extension GL_ARB_shader_atomic_counters: require
+
+flat in int layer_written;
+
+layout(binding = 0) uniform atomic_uint mismatches;
+
+void main()
+{
+	if (layer_written != gl_Layer)
+		atomicCounterIncrement(mismatches);
+
+	gl_FragColor = vec4(0);
+}
+
+[test]
+texture junk 2DArray 0 ( 64 , 64 , 4 )
+fb tex layered 2DArray 0
+
+atomic counters 1
+
+
+draw rect -1 -1 2 2
+
+probe atomic counter 0 == 0
diff --git a/tests/spec/arb_fragment_layer_viewport/viewport-gs-writes-in-range.shader_test b/tests/spec/arb_fragment_layer_viewport/viewport-gs-writes-in-range.shader_test
new file mode 100644
index 0000000..fdac3e3
--- /dev/null
+++ b/tests/spec/arb_fragment_layer_viewport/viewport-gs-writes-in-range.shader_test
@@ -0,0 +1,76 @@
+[require]
+GLSL >= 1.50
+GL_ARB_fragment_layer_viewport
+GL_ARB_shader_atomic_counters
+
+#
+# Ensure that the fragment stage reads the same value for gl_ViewportIndex as was
+# written by the geometry stage.
+#
+# This test covers the case where the value written is in range.
+#
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+
+void main()
+{
+	gl_Position = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_viewport_array: require
+
+layout(triangles) in;
+layout(triangle_strip, max_vertices=48) out;
+
+flat out int vp_written;
+
+void main()
+{
+	for (int vp = 0; vp < 16; vp++) {
+
+		for (int i = 0; i < 3; i++) {
+			gl_Position = gl_in[i].gl_Position;
+			vp_written = vp;
+			gl_ViewportIndex = vp;
+			EmitVertex();
+		}
+
+		EndPrimitive();
+	}
+}
+
+[fragment shader]
+#version 150
+#extension GL_ARB_fragment_layer_viewport: require
+#extension GL_ARB_shader_atomic_counters: require
+
+flat in int vp_written;
+
+layout(binding = 0) uniform atomic_uint matches;
+layout(binding = 0) uniform atomic_uint mismatches;
+
+void main()
+{
+	if (vp_written == gl_ViewportIndex)
+		atomicCounterIncrement(matches);
+	else
+		atomicCounterIncrement(mismatches);
+
+	gl_FragColor = vec4(0);
+}
+
+[test]
+texture junk 2DArray 0 ( 64 , 64 , 1 )
+fb tex layered 2DArray 0
+
+atomic counters 2
+
+
+draw rect -1 -1 2 2
+
+probe atomic counter 0 != 0
+probe atomic counter 1 == 0
diff --git a/tests/spec/arb_fragment_layer_viewport/viewport-gs-writes-out-of-range.shader_test b/tests/spec/arb_fragment_layer_viewport/viewport-gs-writes-out-of-range.shader_test
new file mode 100644
index 0000000..ca852f6
--- /dev/null
+++ b/tests/spec/arb_fragment_layer_viewport/viewport-gs-writes-out-of-range.shader_test
@@ -0,0 +1,73 @@
+[require]
+GLSL >= 1.50
+GL_ARB_fragment_layer_viewport
+GL_ARB_shader_atomic_counters
+
+#
+# Ensure that the fragment stage reads the same value for gl_ViewportIndex  as was
+# written by the geometry stage.
+#
+# This test covers the case where the value written is out of range.
+#
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+
+void main()
+{
+	gl_Position = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_viewport_array: require
+
+layout(triangles) in;
+layout(triangle_strip, max_vertices=9) out;
+
+const int vps[] = int[]( -1, 16, 2048 );
+flat out int vp_written;
+
+void main()
+{
+	for (int vp = 0; vp < vps.length(); vp++) {
+
+		for (int i = 0; i < 3; i++) {
+			gl_Position = gl_in[i].gl_Position;
+			vp_written = vps[vp];
+			gl_ViewportIndex = vps[vp];
+			EmitVertex();
+		}
+
+		EndPrimitive();
+	}
+}
+
+[fragment shader]
+#version 150
+#extension GL_ARB_fragment_layer_viewport: require
+#extension GL_ARB_shader_atomic_counters: require
+
+flat in int vp_written;
+
+layout(binding = 0) uniform atomic_uint mismatches;
+
+void main()
+{
+	if (vp_written != gl_ViewportIndex)
+		atomicCounterIncrement(mismatches);
+
+	gl_FragColor = vec4(0);
+}
+
+[test]
+texture junk 2DArray 0 ( 64 , 64 , 1 )
+fb tex layered 2DArray 0
+
+atomic counters 1
+
+
+draw rect -1 -1 2 2
+
+probe atomic counter 0 == 0
-- 
2.0.0