Add 5 additional tests for arb_cull_distance

Submitted by Tobias Klausmann on May 21, 2015, 9:45 p.m.

Details

Message ID 1432244732-20026-1-git-send-email-tobias.johannes.klausmann@mni.thm.de
State New
Headers show

Not browsing as part of any series.

Commit Message

Tobias Klausmann May 21, 2015, 9:45 p.m.
These five tests are testing the actual culling.
Short description:
If a positive value is supplied to gl_CullDistance, the vertex is inside the
cull volume. If a negative value is supplied, the vertex is outside the cull
volume and is discarded.

Signed-off-by: Tobias Klausmann <tobias.johannes.klausmann@mni.thm.de>
---
 ...-distance-vertex-inside-cull-volume.shader_test | 41 +++++++++++++++
 ...e-vertex-inside-outside-cull-volume.shader_test | 58 ++++++++++++++++++++
 .../vs-cull-distance-vertex-on-plane.shader_test   | 41 +++++++++++++++
 ...side-cull-volume-inside-clip-volume.shader_test | 61 ++++++++++++++++++++++
 ...distance-vertex-outside-cull-volume.shader_test | 44 ++++++++++++++++
 5 files changed, 245 insertions(+)
 create mode 100644 tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-cull-volume.shader_test
 create mode 100644 tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-outside-cull-volume.shader_test
 create mode 100644 tests/spec/arb_cull_distance/vs-cull-distance-vertex-on-plane.shader_test
 create mode 100644 tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume-inside-clip-volume.shader_test
 create mode 100644 tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume.shader_test

Patch hide | download patch | download mbox

diff --git a/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-cull-volume.shader_test b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-cull-volume.shader_test
new file mode 100644
index 0000000..5dfa194
--- /dev/null
+++ b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-cull-volume.shader_test
@@ -0,0 +1,41 @@ 
+# [description]
+# Use one gl_CullDistance values to _not_ "cull" away a vertex with a positive
+# value supplied to gl_CullDistance.
+#
+# The gl_CullDistance variable provides a mechanism for controlling user
+# culling. The element gl_CullDistance[i] specifies a cull distance for each
+# plane i. A distance of 0.0 means that the vertex is on the plane, a positive
+# distance means that the vertex is insider the cull volume, and a negative
+# distance means that the point is outside the cull volume. Primitives whose
+# vertices all have a negative clip distance for plane i will be discarded. 
+
+[require]
+GLSL >= 1.30
+GL_ARB_cull_distance
+
+[vertex shader]
+#version 130
+#extension GL_ARB_cull_distance: enable
+
+out float gl_CullDistance[1];
+
+void main(void)
+{
+	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+	gl_CullDistance[0] = 1;
+}
+
+[fragment shader]
+#version 130
+#extension GL_ARB_cull_distance: enable
+
+void main(void)
+{
+	gl_FragColor = vec4(0, 1, 0, 1);
+}
+
+[test]
+clear color 1.0 0.0 0.0 1.0
+clear
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-outside-cull-volume.shader_test b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-outside-cull-volume.shader_test
new file mode 100644
index 0000000..1b0df9b
--- /dev/null
+++ b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-outside-cull-volume.shader_test
@@ -0,0 +1,58 @@ 
+# [description]
+# Use 4 gl_CullDistance values to "cull" away some vertices with negative values
+# supplied to gl_CullDistance.
+#
+# The gl_CullDistance variable provides a mechanism for controlling user
+# culling. The element gl_CullDistance[i] specifies a cull distance for each
+# plane i. A distance of 0.0 means that the vertex is on the plane, a positive
+# distance means that the vertex is insider the cull volume, and a negative
+# distance means that the point is outside the cull volume. Primitives whose
+# vertices all have a negative clip distance for plane i will be discarded. 
+
+[require]
+GLSL >= 1.30
+GL_ARB_cull_distance
+
+[vertex shader]
+#version 130
+#extension GL_ARB_cull_distance: enable
+
+out float gl_CullDistance[4];
+
+void main(void)
+{
+         gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+         // Compute 2D cordinates relative to a center point of (0.5,
+         // 0.5).
+         vec2 coord = gl_Vertex.xy - vec2(0.5, 0.5);
+
+         for (int i = 0; i < 4; ++i) {
+                  uint j = uint(i);
+
+                  // Compute a unit vector in the direction i*45deg from
+                  // the x axis.
+                  float angle = i*(3.141592653589793/4);
+                  vec2 u = vec2(cos(angle), sin(angle));
+
+                  gl_CullDistance[j] = -0.5 - dot(u, coord);
+         }
+}
+
+[fragment shader]
+#version 130
+#extension GL_ARB_cull_distance: enable
+
+void main(void)
+{
+         gl_FragColor = vec4(0, 1, 1, 1);
+}
+
+[test]
+clear color 0.0 1.0 0.0 1.0
+clear
+ortho 0 2 0 2
+draw rect 0.0 0.0 1.0 1.0
+
+relative probe rgba (0.100, 0.100) (0.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.900, 0.900) (0.0, 1.0, 0.0, 1.0)
diff --git a/tests/spec/arb_cull_distance/vs-cull-distance-vertex-on-plane.shader_test b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-on-plane.shader_test
new file mode 100644
index 0000000..40b74ce
--- /dev/null
+++ b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-on-plane.shader_test
@@ -0,0 +1,41 @@ 
+# [description]
+# Use one gl_CullDistance values to _not_ "cull" away a vertex with it on
+# the plane (gl_CullDistance=0).
+#
+# The gl_CullDistance variable provides a mechanism for controlling user
+# culling. The element gl_CullDistance[i] specifies a cull distance for each
+# plane i. A distance of 0.0 means that the vertex is on the plane, a positive
+# distance means that the vertex is insider the cull volume, and a negative
+# distance means that the point is outside the cull volume. Primitives whose
+# vertices all have a negative clip distance for plane i will be discarded. 
+
+[require]
+GLSL >= 1.30
+GL_ARB_cull_distance
+
+[vertex shader]
+#version 130
+#extension GL_ARB_cull_distance: enable
+
+out float gl_CullDistance[1];
+
+void main(void)
+{
+	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+	gl_CullDistance[0] = 0;
+}
+
+[fragment shader]
+#version 130
+#extension GL_ARB_cull_distance: enable
+
+void main(void)
+{
+	gl_FragColor = vec4(0, 1, 0, 1);
+}
+
+[test]
+clear color 1.0 0.0 0.0 1.0
+clear
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume-inside-clip-volume.shader_test b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume-inside-clip-volume.shader_test
new file mode 100644
index 0000000..a060ac1
--- /dev/null
+++ b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume-inside-clip-volume.shader_test
@@ -0,0 +1,61 @@ 
+# [description]
+# Use two gl_CullDistance values to "cull" away some vertices with negative
+# values. Additionally use two gl_ClipDistance values with positive values to
+# see if gl_CullDistance and gl_ClipDistance are different arrays.
+#
+# The gl_CullDistance variable provides a mechanism for controlling user
+# culling. The element gl_CullDistance[i] specifies a cull distance for each
+# plane i. A distance of 0.0 means that the vertex is on the plane, a positive
+# distance means that the vertex is insider the cull volume, and a negative
+# distance means that the point is outside the cull volume. Primitives whose
+# vertices all have a negative clip distance for plane i will be discarded. 
+
+[require]
+GLSL >= 1.30
+GL_ARB_cull_distance
+
+[vertex shader]
+#version 130
+#extension GL_ARB_cull_distance: enable
+
+out float gl_ClipDistance[2];
+out float gl_CullDistance[2];
+
+void main(void)
+{
+         gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+         // Compute 2D cordinates relative to a center point of (0.5,
+         // 0.5).
+         vec2 coord = gl_Vertex.xy - vec2(0.5, 0.5);
+
+         for (int i = 0; i < 2; ++i) {
+                  uint j = uint(i);
+
+                  // Compute a unit vector in the direction i*45deg from
+                  // the x axis.
+                  float angle = i*(3.141592653589793/4);
+                  vec2 u = vec2(cos(angle), sin(angle));
+
+                  gl_CullDistance[j] = -0.5 - dot(u, coord);
+                  gl_ClipDistance[j] = 1 - dot(u, coord);
+         }
+}
+
+[fragment shader]
+#version 130
+#extension GL_ARB_cull_distance: enable
+
+void main(void)
+{
+         gl_FragColor = vec4(0, 1, 1, 1);
+}
+
+[test]
+clear color 0.0 1.0 0.0 1.0
+clear
+ortho 0 2 0 2
+draw rect 0.0 0.0 1.0 1.0
+
+relative probe rgba (0.100, 0.100) (0.0, 1.0, 1.0, 1.0)
+relative probe rgba (0.900, 0.900) (0.0, 1.0, 0.0, 1.0)
diff --git a/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume.shader_test b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume.shader_test
new file mode 100644
index 0000000..7ad7e5f
--- /dev/null
+++ b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume.shader_test
@@ -0,0 +1,44 @@ 
+# [description]
+# Use one gl_CullDistance values to "cull" away a vertex with a negative value
+# supplied to gl_CullDistance.
+#
+# The gl_CullDistance variable provides a mechanism for controlling user
+# culling. The element gl_CullDistance[i] specifies a cull distance for each
+# plane i. A distance of 0.0 means that the vertex is on the plane, a positive
+# distance means that the vertex is insider the cull volume, and a negative
+# distance means that the point is outside the cull volume. Primitives whose
+# vertices all have a negative clip distance for plane i will be discarded. 
+
+[require]
+GLSL >= 1.30
+GL_ARB_cull_distance
+
+[vertex shader]
+#version 130
+#extension GL_ARB_cull_distance: enable
+
+out float gl_CullDistance[1];
+
+void main(void)
+{
+         gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+         gl_CullDistance[0] = -1;
+}
+
+[fragment shader]
+#version 130
+#extension GL_ARB_cull_distance: enable
+
+void main(void)
+{
+         gl_FragColor = vec4(1, 0, 0, 1);
+}
+
+[test]
+clear color 0.0 1.0 0.0 1.0
+clear
+ortho 0 1 0 1
+draw rect 1.0 0.0 0.0 1.0
+
+probe all rgba 0.0 1.0 0.0 1.0

Comments

On Thu, May 21, 2015 at 11:45:32PM +0200, Tobias Klausmann wrote:
> These five tests are testing the actual culling.
> Short description:
> If a positive value is supplied to gl_CullDistance, the vertex is inside the
> cull volume. If a negative value is supplied, the vertex is outside the cull
> volume and is discarded.
> 
> Signed-off-by: Tobias Klausmann <tobias.johannes.klausmann@mni.thm.de>
> ---
>  ...-distance-vertex-inside-cull-volume.shader_test | 41 +++++++++++++++
>  ...e-vertex-inside-outside-cull-volume.shader_test | 58 ++++++++++++++++++++
>  .../vs-cull-distance-vertex-on-plane.shader_test   | 41 +++++++++++++++
>  ...side-cull-volume-inside-clip-volume.shader_test | 61 ++++++++++++++++++++++
>  ...distance-vertex-outside-cull-volume.shader_test | 44 ++++++++++++++++
>  5 files changed, 245 insertions(+)
>  create mode 100644 tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-cull-volume.shader_test
>  create mode 100644 tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-outside-cull-volume.shader_test
>  create mode 100644 tests/spec/arb_cull_distance/vs-cull-distance-vertex-on-plane.shader_test
>  create mode 100644 tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume-inside-clip-volume.shader_test
>  create mode 100644 tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume.shader_test
> 
> diff --git a/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-cull-volume.shader_test b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-cull-volume.shader_test
> new file mode 100644
> index 0000000..5dfa194
> --- /dev/null
> +++ b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-cull-volume.shader_test
> @@ -0,0 +1,41 @@
> +# [description]

Does this tag actually do anything?

> +# Use one gl_CullDistance values to _not_ "cull" away a vertex with a positive
> +# value supplied to gl_CullDistance.
> +#
> +# The gl_CullDistance variable provides a mechanism for controlling user
> +# culling. The element gl_CullDistance[i] specifies a cull distance for each
> +# plane i. A distance of 0.0 means that the vertex is on the plane, a positive
> +# distance means that the vertex is insider the cull volume, and a negative
> +# distance means that the point is outside the cull volume. Primitives whose
> +# vertices all have a negative clip distance for plane i will be discarded. 
> +
> +[require]
> +GLSL >= 1.30
> +GL_ARB_cull_distance
> +
> +[vertex shader]
> +#version 130
> +#extension GL_ARB_cull_distance: enable
> +
> +out float gl_CullDistance[1];
> +
> +void main(void)
> +{
> +	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
> +	gl_CullDistance[0] = 1;
> +}
> +
> +[fragment shader]
> +#version 130
> +#extension GL_ARB_cull_distance: enable
> +
> +void main(void)
> +{
> +	gl_FragColor = vec4(0, 1, 0, 1);
> +}
> +
> +[test]
> +clear color 1.0 0.0 0.0 1.0
> +clear
> +draw rect -1 -1 2 2
> +probe all rgba 0.0 1.0 0.0 1.0
> diff --git a/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-outside-cull-volume.shader_test b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-outside-cull-volume.shader_test
> new file mode 100644
> index 0000000..1b0df9b
> --- /dev/null
> +++ b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-outside-cull-volume.shader_test
> @@ -0,0 +1,58 @@
> +# [description]
> +# Use 4 gl_CullDistance values to "cull" away some vertices with negative values
> +# supplied to gl_CullDistance.
> +#
> +# The gl_CullDistance variable provides a mechanism for controlling user
> +# culling. The element gl_CullDistance[i] specifies a cull distance for each
> +# plane i. A distance of 0.0 means that the vertex is on the plane, a positive
> +# distance means that the vertex is insider the cull volume, and a negative
> +# distance means that the point is outside the cull volume. Primitives whose
> +# vertices all have a negative clip distance for plane i will be discarded. 
> +
> +[require]
> +GLSL >= 1.30
> +GL_ARB_cull_distance
> +
> +[vertex shader]
> +#version 130
> +#extension GL_ARB_cull_distance: enable
> +
> +out float gl_CullDistance[4];
> +
> +void main(void)
> +{
> +         gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
> +
> +         // Compute 2D cordinates relative to a center point of (0.5,
> +         // 0.5).
> +         vec2 coord = gl_Vertex.xy - vec2(0.5, 0.5);
> +
> +         for (int i = 0; i < 4; ++i) {
> +                  uint j = uint(i);
> +
> +                  // Compute a unit vector in the direction i*45deg from
> +                  // the x axis.
> +                  float angle = i*(3.141592653589793/4);
> +                  vec2 u = vec2(cos(angle), sin(angle));
> +
> +                  gl_CullDistance[j] = -0.5 - dot(u, coord);
> +         }
> +}
> +
> +[fragment shader]
> +#version 130
> +#extension GL_ARB_cull_distance: enable
> +
> +void main(void)
> +{
> +         gl_FragColor = vec4(0, 1, 1, 1);
> +}
> +
> +[test]
> +clear color 0.0 1.0 0.0 1.0
> +clear
> +ortho 0 2 0 2
> +draw rect 0.0 0.0 1.0 1.0
> +
> +relative probe rgba (0.100, 0.100) (0.0, 1.0, 1.0, 1.0)
> +relative probe rgba (0.900, 0.900) (0.0, 1.0, 0.0, 1.0)
> diff --git a/tests/spec/arb_cull_distance/vs-cull-distance-vertex-on-plane.shader_test b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-on-plane.shader_test
> new file mode 100644
> index 0000000..40b74ce
> --- /dev/null
> +++ b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-on-plane.shader_test
> @@ -0,0 +1,41 @@
> +# [description]
> +# Use one gl_CullDistance values to _not_ "cull" away a vertex with it on
> +# the plane (gl_CullDistance=0).
> +#
> +# The gl_CullDistance variable provides a mechanism for controlling user
> +# culling. The element gl_CullDistance[i] specifies a cull distance for each
> +# plane i. A distance of 0.0 means that the vertex is on the plane, a positive
> +# distance means that the vertex is insider the cull volume, and a negative
> +# distance means that the point is outside the cull volume. Primitives whose
> +# vertices all have a negative clip distance for plane i will be discarded. 
> +
> +[require]
> +GLSL >= 1.30
> +GL_ARB_cull_distance
> +
> +[vertex shader]
> +#version 130
> +#extension GL_ARB_cull_distance: enable
> +
> +out float gl_CullDistance[1];
> +
> +void main(void)
> +{
> +	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
> +	gl_CullDistance[0] = 0;
> +}
> +
> +[fragment shader]
> +#version 130
> +#extension GL_ARB_cull_distance: enable
> +
> +void main(void)
> +{
> +	gl_FragColor = vec4(0, 1, 0, 1);
> +}
> +
> +[test]
> +clear color 1.0 0.0 0.0 1.0
> +clear
> +draw rect -1 -1 2 2
> +probe all rgba 0.0 1.0 0.0 1.0
> diff --git a/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume-inside-clip-volume.shader_test b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume-inside-clip-volume.shader_test
> new file mode 100644
> index 0000000..a060ac1
> --- /dev/null
> +++ b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume-inside-clip-volume.shader_test
> @@ -0,0 +1,61 @@
> +# [description]
> +# Use two gl_CullDistance values to "cull" away some vertices with negative
> +# values. Additionally use two gl_ClipDistance values with positive values to
> +# see if gl_CullDistance and gl_ClipDistance are different arrays.
> +#
> +# The gl_CullDistance variable provides a mechanism for controlling user
> +# culling. The element gl_CullDistance[i] specifies a cull distance for each
> +# plane i. A distance of 0.0 means that the vertex is on the plane, a positive
> +# distance means that the vertex is insider the cull volume, and a negative
> +# distance means that the point is outside the cull volume. Primitives whose
> +# vertices all have a negative clip distance for plane i will be discarded. 
> +
> +[require]
> +GLSL >= 1.30
> +GL_ARB_cull_distance
> +
> +[vertex shader]
> +#version 130
> +#extension GL_ARB_cull_distance: enable
> +
> +out float gl_ClipDistance[2];
> +out float gl_CullDistance[2];
> +
> +void main(void)
> +{
> +         gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
> +
> +         // Compute 2D cordinates relative to a center point of (0.5,
> +         // 0.5).
> +         vec2 coord = gl_Vertex.xy - vec2(0.5, 0.5);
> +
> +         for (int i = 0; i < 2; ++i) {
> +                  uint j = uint(i);
> +
> +                  // Compute a unit vector in the direction i*45deg from
> +                  // the x axis.
> +                  float angle = i*(3.141592653589793/4);
> +                  vec2 u = vec2(cos(angle), sin(angle));
> +
> +                  gl_CullDistance[j] = -0.5 - dot(u, coord);
> +                  gl_ClipDistance[j] = 1 - dot(u, coord);
> +         }
> +}
> +
> +[fragment shader]
> +#version 130
> +#extension GL_ARB_cull_distance: enable
> +
> +void main(void)
> +{
> +         gl_FragColor = vec4(0, 1, 1, 1);
> +}
> +
> +[test]
> +clear color 0.0 1.0 0.0 1.0
> +clear
> +ortho 0 2 0 2
> +draw rect 0.0 0.0 1.0 1.0
> +
> +relative probe rgba (0.100, 0.100) (0.0, 1.0, 1.0, 1.0)
> +relative probe rgba (0.900, 0.900) (0.0, 1.0, 0.0, 1.0)
> diff --git a/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume.shader_test b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume.shader_test
> new file mode 100644
> index 0000000..7ad7e5f
> --- /dev/null
> +++ b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume.shader_test
> @@ -0,0 +1,44 @@
> +# [description]
> +# Use one gl_CullDistance values to "cull" away a vertex with a negative value
> +# supplied to gl_CullDistance.
> +#
> +# The gl_CullDistance variable provides a mechanism for controlling user
> +# culling. The element gl_CullDistance[i] specifies a cull distance for each
> +# plane i. A distance of 0.0 means that the vertex is on the plane, a positive
> +# distance means that the vertex is insider the cull volume, and a negative
> +# distance means that the point is outside the cull volume. Primitives whose
> +# vertices all have a negative clip distance for plane i will be discarded. 
> +
> +[require]
> +GLSL >= 1.30
> +GL_ARB_cull_distance
> +
> +[vertex shader]
> +#version 130
> +#extension GL_ARB_cull_distance: enable
> +
> +out float gl_CullDistance[1];
> +
> +void main(void)
> +{
> +         gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
> +
> +         gl_CullDistance[0] = -1;
> +}
> +
> +[fragment shader]
> +#version 130
> +#extension GL_ARB_cull_distance: enable
> +
> +void main(void)
> +{
> +         gl_FragColor = vec4(1, 0, 0, 1);
> +}
> +
> +[test]
> +clear color 0.0 1.0 0.0 1.0
> +clear
> +ortho 0 1 0 1
> +draw rect 1.0 0.0 0.0 1.0
> +
> +probe all rgba 0.0 1.0 0.0 1.0
> -- 
> 2.4.1
> 
> _______________________________________________
> Piglit mailing list
> Piglit@lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/piglit
On 22.05.2015 01:08, Dylan Baker wrote:
> On Thu, May 21, 2015 at 11:45:32PM +0200, Tobias Klausmann wrote:
>> These five tests are testing the actual culling.
>> Short description:
>> If a positive value is supplied to gl_CullDistance, the vertex is inside the
>> cull volume. If a negative value is supplied, the vertex is outside the cull
>> volume and is discarded.
>>
>> Signed-off-by: Tobias Klausmann <tobias.johannes.klausmann@mni.thm.de>
>> ---
>>   ...-distance-vertex-inside-cull-volume.shader_test | 41 +++++++++++++++
>>   ...e-vertex-inside-outside-cull-volume.shader_test | 58 ++++++++++++++++++++
>>   .../vs-cull-distance-vertex-on-plane.shader_test   | 41 +++++++++++++++
>>   ...side-cull-volume-inside-clip-volume.shader_test | 61 ++++++++++++++++++++++
>>   ...distance-vertex-outside-cull-volume.shader_test | 44 ++++++++++++++++
>>   5 files changed, 245 insertions(+)
>>   create mode 100644 tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-cull-volume.shader_test
>>   create mode 100644 tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-outside-cull-volume.shader_test
>>   create mode 100644 tests/spec/arb_cull_distance/vs-cull-distance-vertex-on-plane.shader_test
>>   create mode 100644 tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume-inside-clip-volume.shader_test
>>   create mode 100644 tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume.shader_test
>>
>> diff --git a/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-cull-volume.shader_test b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-cull-volume.shader_test
>> new file mode 100644
>> index 0000000..5dfa194
>> --- /dev/null
>> +++ b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-cull-volume.shader_test
>> @@ -0,0 +1,41 @@
>> +# [description]
> Does this tag actually do anything?

To answer your rhetoric question: No it does not. But it makes a nice 
complete picture :-) If you really want it, i can remove this tag...

>> +# Use one gl_CullDistance values to _not_ "cull" away a vertex with a positive
>> +# value supplied to gl_CullDistance.
>> +#
>> +# The gl_CullDistance variable provides a mechanism for controlling user
>> +# culling. The element gl_CullDistance[i] specifies a cull distance for each
>> +# plane i. A distance of 0.0 means that the vertex is on the plane, a positive
>> +# distance means that the vertex is insider the cull volume, and a negative
>> +# distance means that the point is outside the cull volume. Primitives whose
>> +# vertices all have a negative clip distance for plane i will be discarded.
>> +
>> +[require]
>> +GLSL >= 1.30
>> +GL_ARB_cull_distance
>> +
>> +[vertex shader]
>> +#version 130
>> +#extension GL_ARB_cull_distance: enable
>> +
>> +out float gl_CullDistance[1];
>> +
>> +void main(void)
>> +{
>> +	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
>> +	gl_CullDistance[0] = 1;
>> +}
>> +
>> +[fragment shader]
>> +#version 130
>> +#extension GL_ARB_cull_distance: enable
>> +
>> +void main(void)
>> +{
>> +	gl_FragColor = vec4(0, 1, 0, 1);
>> +}
>> +
>> +[test]
>> +clear color 1.0 0.0 0.0 1.0
>> +clear
>> +draw rect -1 -1 2 2
>> +probe all rgba 0.0 1.0 0.0 1.0
>> diff --git a/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-outside-cull-volume.shader_test b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-outside-cull-volume.shader_test
>> new file mode 100644
>> index 0000000..1b0df9b
>> --- /dev/null
>> +++ b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-inside-outside-cull-volume.shader_test
>> @@ -0,0 +1,58 @@
>> +# [description]
>> +# Use 4 gl_CullDistance values to "cull" away some vertices with negative values
>> +# supplied to gl_CullDistance.
>> +#
>> +# The gl_CullDistance variable provides a mechanism for controlling user
>> +# culling. The element gl_CullDistance[i] specifies a cull distance for each
>> +# plane i. A distance of 0.0 means that the vertex is on the plane, a positive
>> +# distance means that the vertex is insider the cull volume, and a negative
>> +# distance means that the point is outside the cull volume. Primitives whose
>> +# vertices all have a negative clip distance for plane i will be discarded.
>> +
>> +[require]
>> +GLSL >= 1.30
>> +GL_ARB_cull_distance
>> +
>> +[vertex shader]
>> +#version 130
>> +#extension GL_ARB_cull_distance: enable
>> +
>> +out float gl_CullDistance[4];
>> +
>> +void main(void)
>> +{
>> +         gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
>> +
>> +         // Compute 2D cordinates relative to a center point of (0.5,
>> +         // 0.5).
>> +         vec2 coord = gl_Vertex.xy - vec2(0.5, 0.5);
>> +
>> +         for (int i = 0; i < 4; ++i) {
>> +                  uint j = uint(i);
>> +
>> +                  // Compute a unit vector in the direction i*45deg from
>> +                  // the x axis.
>> +                  float angle = i*(3.141592653589793/4);
>> +                  vec2 u = vec2(cos(angle), sin(angle));
>> +
>> +                  gl_CullDistance[j] = -0.5 - dot(u, coord);
>> +         }
>> +}
>> +
>> +[fragment shader]
>> +#version 130
>> +#extension GL_ARB_cull_distance: enable
>> +
>> +void main(void)
>> +{
>> +         gl_FragColor = vec4(0, 1, 1, 1);
>> +}
>> +
>> +[test]
>> +clear color 0.0 1.0 0.0 1.0
>> +clear
>> +ortho 0 2 0 2
>> +draw rect 0.0 0.0 1.0 1.0
>> +
>> +relative probe rgba (0.100, 0.100) (0.0, 1.0, 1.0, 1.0)
>> +relative probe rgba (0.900, 0.900) (0.0, 1.0, 0.0, 1.0)
>> diff --git a/tests/spec/arb_cull_distance/vs-cull-distance-vertex-on-plane.shader_test b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-on-plane.shader_test
>> new file mode 100644
>> index 0000000..40b74ce
>> --- /dev/null
>> +++ b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-on-plane.shader_test
>> @@ -0,0 +1,41 @@
>> +# [description]
>> +# Use one gl_CullDistance values to _not_ "cull" away a vertex with it on
>> +# the plane (gl_CullDistance=0).
>> +#
>> +# The gl_CullDistance variable provides a mechanism for controlling user
>> +# culling. The element gl_CullDistance[i] specifies a cull distance for each
>> +# plane i. A distance of 0.0 means that the vertex is on the plane, a positive
>> +# distance means that the vertex is insider the cull volume, and a negative
>> +# distance means that the point is outside the cull volume. Primitives whose
>> +# vertices all have a negative clip distance for plane i will be discarded.
>> +
>> +[require]
>> +GLSL >= 1.30
>> +GL_ARB_cull_distance
>> +
>> +[vertex shader]
>> +#version 130
>> +#extension GL_ARB_cull_distance: enable
>> +
>> +out float gl_CullDistance[1];
>> +
>> +void main(void)
>> +{
>> +	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
>> +	gl_CullDistance[0] = 0;
>> +}
>> +
>> +[fragment shader]
>> +#version 130
>> +#extension GL_ARB_cull_distance: enable
>> +
>> +void main(void)
>> +{
>> +	gl_FragColor = vec4(0, 1, 0, 1);
>> +}
>> +
>> +[test]
>> +clear color 1.0 0.0 0.0 1.0
>> +clear
>> +draw rect -1 -1 2 2
>> +probe all rgba 0.0 1.0 0.0 1.0
>> diff --git a/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume-inside-clip-volume.shader_test b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume-inside-clip-volume.shader_test
>> new file mode 100644
>> index 0000000..a060ac1
>> --- /dev/null
>> +++ b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume-inside-clip-volume.shader_test
>> @@ -0,0 +1,61 @@
>> +# [description]
>> +# Use two gl_CullDistance values to "cull" away some vertices with negative
>> +# values. Additionally use two gl_ClipDistance values with positive values to
>> +# see if gl_CullDistance and gl_ClipDistance are different arrays.
>> +#
>> +# The gl_CullDistance variable provides a mechanism for controlling user
>> +# culling. The element gl_CullDistance[i] specifies a cull distance for each
>> +# plane i. A distance of 0.0 means that the vertex is on the plane, a positive
>> +# distance means that the vertex is insider the cull volume, and a negative
>> +# distance means that the point is outside the cull volume. Primitives whose
>> +# vertices all have a negative clip distance for plane i will be discarded.
>> +
>> +[require]
>> +GLSL >= 1.30
>> +GL_ARB_cull_distance
>> +
>> +[vertex shader]
>> +#version 130
>> +#extension GL_ARB_cull_distance: enable
>> +
>> +out float gl_ClipDistance[2];
>> +out float gl_CullDistance[2];
>> +
>> +void main(void)
>> +{
>> +         gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
>> +
>> +         // Compute 2D cordinates relative to a center point of (0.5,
>> +         // 0.5).
>> +         vec2 coord = gl_Vertex.xy - vec2(0.5, 0.5);
>> +
>> +         for (int i = 0; i < 2; ++i) {
>> +                  uint j = uint(i);
>> +
>> +                  // Compute a unit vector in the direction i*45deg from
>> +                  // the x axis.
>> +                  float angle = i*(3.141592653589793/4);
>> +                  vec2 u = vec2(cos(angle), sin(angle));
>> +
>> +                  gl_CullDistance[j] = -0.5 - dot(u, coord);
>> +                  gl_ClipDistance[j] = 1 - dot(u, coord);
>> +         }
>> +}
>> +
>> +[fragment shader]
>> +#version 130
>> +#extension GL_ARB_cull_distance: enable
>> +
>> +void main(void)
>> +{
>> +         gl_FragColor = vec4(0, 1, 1, 1);
>> +}
>> +
>> +[test]
>> +clear color 0.0 1.0 0.0 1.0
>> +clear
>> +ortho 0 2 0 2
>> +draw rect 0.0 0.0 1.0 1.0
>> +
>> +relative probe rgba (0.100, 0.100) (0.0, 1.0, 1.0, 1.0)
>> +relative probe rgba (0.900, 0.900) (0.0, 1.0, 0.0, 1.0)
>> diff --git a/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume.shader_test b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume.shader_test
>> new file mode 100644
>> index 0000000..7ad7e5f
>> --- /dev/null
>> +++ b/tests/spec/arb_cull_distance/vs-cull-distance-vertex-outside-cull-volume.shader_test
>> @@ -0,0 +1,44 @@
>> +# [description]
>> +# Use one gl_CullDistance values to "cull" away a vertex with a negative value
>> +# supplied to gl_CullDistance.
>> +#
>> +# The gl_CullDistance variable provides a mechanism for controlling user
>> +# culling. The element gl_CullDistance[i] specifies a cull distance for each
>> +# plane i. A distance of 0.0 means that the vertex is on the plane, a positive
>> +# distance means that the vertex is insider the cull volume, and a negative
>> +# distance means that the point is outside the cull volume. Primitives whose
>> +# vertices all have a negative clip distance for plane i will be discarded.
>> +
>> +[require]
>> +GLSL >= 1.30
>> +GL_ARB_cull_distance
>> +
>> +[vertex shader]
>> +#version 130
>> +#extension GL_ARB_cull_distance: enable
>> +
>> +out float gl_CullDistance[1];
>> +
>> +void main(void)
>> +{
>> +         gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
>> +
>> +         gl_CullDistance[0] = -1;
>> +}
>> +
>> +[fragment shader]
>> +#version 130
>> +#extension GL_ARB_cull_distance: enable
>> +
>> +void main(void)
>> +{
>> +         gl_FragColor = vec4(1, 0, 0, 1);
>> +}
>> +
>> +[test]
>> +clear color 0.0 1.0 0.0 1.0
>> +clear
>> +ortho 0 1 0 1
>> +draw rect 1.0 0.0 0.0 1.0
>> +
>> +probe all rgba 0.0 1.0 0.0 1.0
>> -- 
>> 2.4.1
>>
>> _______________________________________________
>> Piglit mailing list
>> Piglit@lists.freedesktop.org
>> http://lists.freedesktop.org/mailman/listinfo/piglit
On Fri, May 22, 2015 at 02:16:56AM +0200, Tobias Klausmann wrote:
> On 22.05.2015 01:08, Dylan Baker wrote:
> > Does this tag actually do anything?
> 
> To answer your rhetoric question: No it does not. But it makes a nice 
> complete picture :-) If you really want it, i can remove this tag...

I don't have a strong opinion either way, it just seems a little odd to
me to add headers that aren't parsed. :shrug:

[snip]