[Piglit] [PATCH 7/8] arb_gpu_shader_fp64: add tests for UBOs
Andres Gomez
agomez at igalia.com
Tue Mar 15 15:50:48 UTC 2016
From: "Juan A. Suarez Romero" <jasuarez at igalia.com>
Add several tests for double-precision usage inside UBOs.
Signed-off-by: Andres Gomez <agomez at igalia.com>
---
.../uniform_buffers/fs-array-copy.shader_test | 40 +++++++++++
.../uniform_buffers/fs-dmat4-row-major.shader_test | 33 +++++++++
.../uniform_buffers/fs-dmat4.shader_test | 34 +++++++++
.../fs-double-array-const-index.shader_test | 37 ++++++++++
.../fs-double-array-variable-index.shader_test | 45 ++++++++++++
.../fs-double-bool-double.shader_test | 38 ++++++++++
...ouble-uniform-array-direct-indirect.shader_test | 34 +++++++++
.../fs-doubles-float-mixed.shader_test | 40 +++++++++++
.../uniform_buffers/fs-doubles.shader_test | 40 +++++++++++
...dvec4-uniform-array-direct-indirect.shader_test | 32 +++++++++
.../uniform_buffers/fs-nested-struct.shader_test | 56 +++++++++++++++
.../uniform_buffers/fs-ubo-direct-1.shader_test | 38 ++++++++++
.../fs-ubo-load.indirect.1.shader_test | 38 ++++++++++
.../fs-ubo-load.indirect.2.shader_test | 34 +++++++++
.../fs-ubo-load.indirect.3.shader_test | 37 ++++++++++
.../fs-ubo-load.indirect.4.shader_test | 52 ++++++++++++++
.../uniform_buffers/gs-array-copy.shader_test | 69 ++++++++++++++++++
.../uniform_buffers/gs-dmat4-row-major.shader_test | 60 ++++++++++++++++
.../uniform_buffers/gs-dmat4.shader_test | 60 ++++++++++++++++
.../gs-double-array-const-index.shader_test | 63 ++++++++++++++++
.../gs-double-array-variable-index.shader_test | 71 ++++++++++++++++++
.../gs-double-bool-double.shader_test | 65 +++++++++++++++++
...ouble-uniform-array-direct-indirect.shader_test | 64 +++++++++++++++++
.../gs-doubles-float-mixed.shader_test | 66 +++++++++++++++++
...dvec4-uniform-array-direct-indirect.shader_test | 62 ++++++++++++++++
.../uniform_buffers/gs-nested-struct.shader_test | 83 ++++++++++++++++++++++
26 files changed, 1291 insertions(+)
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-array-copy.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dmat4-row-major.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dmat4.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-array-const-index.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-array-variable-index.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-bool-double.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-uniform-array-direct-indirect.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-doubles-float-mixed.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-doubles.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dvec4-uniform-array-direct-indirect.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-nested-struct.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-direct-1.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.1.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.2.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.3.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.4.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-array-copy.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dmat4-row-major.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dmat4.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-array-const-index.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-array-variable-index.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-bool-double.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-uniform-array-direct-indirect.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-doubles-float-mixed.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dvec4-uniform-array-direct-indirect.shader_test
create mode 100644 tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-nested-struct.shader_test
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-array-copy.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-array-copy.shader_test
new file mode 100644
index 0000000..5e68932
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-array-copy.shader_test
@@ -0,0 +1,40 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform int i;
+uniform ubo1 {
+ dvec4 colors[4];
+};
+
+out vec4 color;
+
+void main()
+{
+ dvec4 temp[4] = colors;
+ temp[0] = dvec4(1.0, 0.0, arg0, 0.0);
+ dvec4 result = temp[i];
+ color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.0 1.0 0.0 0.0
+uniform int i 1
+uniform dvec4 colors[0] 0.0 0.0 0.0 0.0
+uniform dvec4 colors[1] 0.0 1.0 0.0 0.0
+uniform dvec4 colors[2] 0.0 1.0 1.0 0.0
+uniform dvec4 colors[3] 1.0 0.0 1.0 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dmat4-row-major.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dmat4-row-major.shader_test
new file mode 100644
index 0000000..7f40e77
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dmat4-row-major.shader_test
@@ -0,0 +1,33 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+ layout(row_major) dmat4 m;
+};
+
+out vec4 color;
+
+void main()
+{
+ dvec4 result = dvec4(m[0] + m[1] + m[2] + m[3] + arg0);
+ color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.5 0.75 1.0 1.25
+uniform dmat4 m 0.25 0.0 0.0 0.0 0.0 0.0 0.75 0.0 0.0 0.5 0.0 0.0 0.0 0.0 0.0 1.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
\ No newline at end of file
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dmat4.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dmat4.shader_test
new file mode 100644
index 0000000..e4f01c9
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dmat4.shader_test
@@ -0,0 +1,34 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+ dmat4 m;
+};
+
+out vec4 color;
+
+void main()
+{
+ dvec4 result = dvec4(m[0] + m[1] + m[2] + m[3] + arg0);
+ color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.5 0.75 1.0 1.25
+
+uniform dmat4 m 0.25 0.0 0.0 0.0 0.0 0.0 0.75 0.0 0.0 0.5 0.0 0.0 0.0 0.0 0.0 1.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-array-const-index.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-array-const-index.shader_test
new file mode 100644
index 0000000..16f2ea2
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-array-const-index.shader_test
@@ -0,0 +1,37 @@
+# test indirect access to a temporary array of doubles as a source
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+ double d[4];
+};
+
+out vec4 color;
+
+void main()
+{
+ dvec4 result = dvec4(d[0] + arg0, d[1], d[2], d[3]);
+ color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 0.0 0.0
+uniform double d[0] 0.0
+uniform double d[1] 1.0
+uniform double d[2] 0.0
+uniform double d[3] 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-array-variable-index.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-array-variable-index.shader_test
new file mode 100644
index 0000000..d2cff9f
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-array-variable-index.shader_test
@@ -0,0 +1,45 @@
+# test indirect access to a temporary array of doubles as a source
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform int ri, gi, bi, ai;
+
+uniform ubo1 {
+ double d[4];
+};
+
+out vec4 color;
+
+void main()
+{
+ dvec4 result = dvec4(d[ri] + arg0, d[gi], d[bi], d[ai]);
+ color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 0.0 0.0
+
+uniform int ri 0
+uniform int gi 1
+uniform int bi 2
+uniform int ai 3
+
+uniform double d[0] 0.0
+uniform double d[1] 1.0
+uniform double d[2] 0.0
+uniform double d[3] 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-bool-double.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-bool-double.shader_test
new file mode 100644
index 0000000..3698458
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-bool-double.shader_test
@@ -0,0 +1,38 @@
+# test indirect access to a temporary array of doubles as a source
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform double arg0;
+uniform bool arg1;
+uniform double arg2;
+
+out vec4 color;
+
+void main()
+{
+ dvec4 result;
+ if (arg1)
+ result = dvec4(arg0, arg2, 0.0, 0.0);
+ else
+ result = dvec4(arg0, arg2, 1.0, 0.0);
+ color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double tolerance 0.0
+uniform dvec4 expected 1.0 1.0 0.0 0.0
+uniform double arg0 1.0
+uniform int arg1 1
+uniform double arg2 1.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-uniform-array-direct-indirect.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-uniform-array-direct-indirect.shader_test
new file mode 100644
index 0000000..1de93e9
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-double-uniform-array-direct-indirect.shader_test
@@ -0,0 +1,34 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#extension GL_ARB_gpu_shader_fp64 : enable
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform double arg[7];
+out vec4 color;
+void main()
+{
+ dvec4 result = dvec4(arg[int(arg[6])] + arg0);
+ color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.65 0.65 0.65 0.65
+uniform double arg[0] 0.1
+uniform double arg[1] 0.2
+uniform double arg[2] 0.3
+uniform double arg[3] 0.4
+uniform double arg[4] 0.5
+uniform double arg[5] 0.6
+uniform double arg[6] 3.0
+draw rect -1 -1 2 2
+probe rgba 1 1 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-doubles-float-mixed.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-doubles-float-mixed.shader_test
new file mode 100644
index 0000000..a150fef
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-doubles-float-mixed.shader_test
@@ -0,0 +1,40 @@
+# test indirect access to a temporary array of doubles as a source
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+ double r;
+ float g;
+ double b;
+ double a;
+};
+
+out vec4 color;
+
+void main()
+{
+ dvec4 result = dvec4(r + arg0, g, b, a);
+ color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 1.0 0.0
+uniform double r 0.0
+uniform float g 1.0
+uniform double b 1.0
+uniform double a 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-doubles.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-doubles.shader_test
new file mode 100644
index 0000000..9e57608
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-doubles.shader_test
@@ -0,0 +1,40 @@
+# test indirect access to a temporary array of doubles as a source
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+ double r;
+ double g;
+ double b;
+ double a;
+};
+
+out vec4 color;
+
+void main()
+{
+ dvec4 result = dvec4(r + arg0, g, b, a);
+ color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 0.0 0.0
+uniform double r 0.0
+uniform double g 1.0
+uniform double b 0.0
+uniform double a 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dvec4-uniform-array-direct-indirect.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dvec4-uniform-array-direct-indirect.shader_test
new file mode 100644
index 0000000..239ec59
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-dvec4-uniform-array-direct-indirect.shader_test
@@ -0,0 +1,32 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#extension GL_ARB_gpu_shader_fp64 : enable
+
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform dvec4 arg[7];
+out vec4 color;
+void main()
+{
+ dvec4 result = dvec4(arg[int(arg[6].w)]);
+ color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double tolerance 0.0
+uniform dvec4 expected 0.40 0.41 0.42 0.43
+uniform dvec4 arg[0] 0.10 0.11 0.12 0.13
+uniform dvec4 arg[1] 0.20 0.21 0.22 0.23
+uniform dvec4 arg[2] 0.30 0.31 0.32 0.33
+uniform dvec4 arg[3] 0.40 0.41 0.42 0.43
+uniform dvec4 arg[4] 0.50 0.51 0.52 0.53
+uniform dvec4 arg[5] 0.60 0.61 0.62 0.63
+uniform dvec4 arg[6] 0.70 0.71 0.72 3.00
+draw rect -1 -1 2 2
+probe rgba 1 1 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-nested-struct.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-nested-struct.shader_test
new file mode 100644
index 0000000..e026795
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-nested-struct.shader_test
@@ -0,0 +1,56 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+struct S1 {
+ double r;
+};
+
+struct S2 {
+ float p1;
+ double r;
+ double g;
+ double b;
+ float p2;
+ double a;
+};
+
+struct S {
+ S1 s1;
+ S2 s2;
+};
+
+uniform ubo1 {
+ S s;
+};
+
+out vec4 color;
+
+void main()
+{
+ dvec4 result = dvec4(s.s1.r + arg0, s.s2.g, s.s2.b, s.s2.a);
+ color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 0.0 0.0
+uniform double s.s1.r 0.0
+uniform float s.s2.p1 1.0
+uniform double s.s2.g 1.0
+uniform double s.s2.b 0.0
+uniform float s.s2.p2 1.0
+uniform double s.s2.a 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-direct-1.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-direct-1.shader_test
new file mode 100644
index 0000000..0889bd5
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-direct-1.shader_test
@@ -0,0 +1,38 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#extension GL_ARB_gpu_shader_fp64 : enable
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+ double d1;
+ dvec2 d2;
+ dvec3 d3;
+ dvec4 d4;
+};
+
+out vec4 color;
+
+void main()
+{
+ dvec4 result = dvec4(d1, d2.y, d3.z, d4.w + arg0);
+ color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.1 0.3 0.6 1.25
+uniform double d1 0.1
+uniform dvec2 d2 0.2 0.3
+uniform dvec3 d3 0.4 0.5 0.6
+uniform dvec4 d4 0.7 0.8 0.9 1.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
\ No newline at end of file
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.1.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.1.shader_test
new file mode 100644
index 0000000..c5ae503
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.1.shader_test
@@ -0,0 +1,38 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#extension GL_ARB_gpu_shader_fp64 : enable
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform int index;
+uniform ubo1 {
+ double data[8];
+};
+
+out vec4 color;
+
+void main()
+{
+ dvec4 result = dvec4(data[index] + arg0);
+ color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.55 0.55 0.55 0.55
+uniform int index 2
+uniform double data[0] 0.1
+uniform double data[1] 0.2
+uniform double data[2] 0.3
+uniform double data[3] 0.4
+
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.2.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.2.shader_test
new file mode 100644
index 0000000..774370d
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.2.shader_test
@@ -0,0 +1,34 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#extension GL_ARB_gpu_shader_fp64 : enable
+
+uniform double tolerance;
+uniform dvec4 expected;
+uniform int index;
+uniform ubo1 {
+ dvec4 data[4];
+};
+
+out vec4 color;
+
+void main()
+{
+ dvec4 result = data[index];
+ color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double tolerance 0.0
+uniform dvec4 expected 0.30 0.31 0.32 0.33
+uniform int index 2
+uniform dvec4 data[0] 0.10 0.11 0.12 0.13
+uniform dvec4 data[1] 0.20 0.21 0.22 0.23
+uniform dvec4 data[2] 0.30 0.31 0.32 0.33
+uniform dvec4 data[3] 0.40 0.41 0.42 0.43
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.3.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.3.shader_test
new file mode 100644
index 0000000..b2de98e
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.3.shader_test
@@ -0,0 +1,37 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#extension GL_ARB_gpu_shader_fp64 : enable
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform int index;
+uniform ubo1 {
+ dvec4 data[4];
+};
+
+out vec4 color;
+
+void main()
+{
+ dvec4 result = dvec4(data[index].z + arg0);
+ color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.47 0.47 0.47 0.47
+uniform int index 1
+uniform dvec4 data[0] 0.10 0.11 0.12 0.13
+uniform dvec4 data[1] 0.20 0.21 0.22 0.23
+uniform dvec4 data[2] 0.30 0.31 0.32 0.33
+uniform dvec4 data[3] 0.40 0.41 0.42 0.43
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.4.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.4.shader_test
new file mode 100644
index 0000000..cb57d11
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/fs-ubo-load.indirect.4.shader_test
@@ -0,0 +1,52 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader passthrough]
+
+[fragment shader]
+#extension GL_ARB_gpu_shader_fp64 : enable
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+struct S {
+ double d1[2];
+ dvec3 d3[2];
+};
+
+uniform int index1;
+uniform int index2;
+uniform ubo1 {
+ S data[2];
+};
+
+out vec4 color;
+
+void main()
+{
+ dvec4 result = dvec4(data[index1].d3[index2], arg0);
+ color = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.70 0.71 0.72 0.25
+
+uniform int index1 1
+uniform int index2 1
+
+uniform double data[0].d1[0] 0.0
+uniform dvec3 data[0].d1[1] 0.1
+uniform double data[0].d3[0] 0.20 0.21 0.22
+uniform dvec3 data[0].d3[1] 0.30 0.31 0.32
+
+uniform double data[1].d1[0] 0.4
+uniform dvec3 data[1].d1[1] 0.5
+uniform double data[1].d3[0] 0.60 0.61 0.62
+uniform dvec3 data[1].d3[1] 0.70 0.71 0.72
+
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
\ No newline at end of file
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-array-copy.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-array-copy.shader_test
new file mode 100644
index 0000000..acf7131
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-array-copy.shader_test
@@ -0,0 +1,69 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+ vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform int i;
+uniform ubo1 {
+ dvec4 colors[4];
+};
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+ dvec4 temp[4] = colors;
+ temp[0] = dvec4(1.0, 0.0, 0.0, arg0);
+ dvec4 result = temp[i];
+ v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+ for (int j = 0; j < 3; j++) {
+ gl_Position = vertex_to_gs[j];
+ EmitVertex();
+ }
+}
+
+[fragment shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+ color = v;
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.0 1.0 0.0 0.0
+uniform int i 1
+uniform dvec4 colors[0] 0.0 0.0 0.0 0.0
+uniform dvec4 colors[1] 0.0 1.0 0.0 0.0
+uniform dvec4 colors[2] 0.0 1.0 1.0 0.0
+uniform dvec4 colors[3] 1.0 0.0 1.0 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dmat4-row-major.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dmat4-row-major.shader_test
new file mode 100644
index 0000000..7eaa1bf
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dmat4-row-major.shader_test
@@ -0,0 +1,60 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+ vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+ layout(row_major) dmat4 m;
+};
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+ dvec4 result = dvec4(m[0] + m[1] + m[2] + m[3] + arg0);
+ v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+ for (int i = 0; i < 3; i++) {
+ gl_Position = vertex_to_gs[i];
+ EmitVertex();
+ }
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+ color = v;
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.5 0.75 1.0 1.25
+uniform dmat4 m 0.25 0.0 0.0 0.0 0.0 0.0 0.75 0.0 0.0 0.5 0.0 0.0 0.0 0.0 0.0 1.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dmat4.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dmat4.shader_test
new file mode 100644
index 0000000..5f0825b
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dmat4.shader_test
@@ -0,0 +1,60 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+ vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+ dmat4 m;
+};
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+ dvec4 result = dvec4(m[0] + m[1] + m[2] + m[3] + arg0);
+ v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+ for (int i = 0; i < 3; i++) {
+ gl_Position = vertex_to_gs[i];
+ EmitVertex();
+ }
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+ color = v;
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.5 0.75 1.0 1.25
+uniform dmat4 m 0.25 0.0 0.0 0.0 0.0 0.0 0.75 0.0 0.0 0.5 0.0 0.0 0.0 0.0 0.0 1.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-array-const-index.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-array-const-index.shader_test
new file mode 100644
index 0000000..20ff3a3
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-array-const-index.shader_test
@@ -0,0 +1,63 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+ vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+ double d[4];
+};
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+ dvec4 result = dvec4(d[0] + arg0, d[1], d[2], d[3]);
+ v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+ for (int i = 0; i < 3; i++) {
+ gl_Position = vertex_to_gs[i];
+ EmitVertex();
+ }
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+ color = v;
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 0.0 0.0
+uniform double d[0] 0.0
+uniform double d[1] 1.0
+uniform double d[2] 0.0
+uniform double d[3] 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-array-variable-index.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-array-variable-index.shader_test
new file mode 100644
index 0000000..840de49
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-array-variable-index.shader_test
@@ -0,0 +1,71 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+ vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform int ri, gi, bi, ai;
+
+uniform ubo1 {
+ double d[4];
+};
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+ dvec4 result = dvec4(d[ri] + arg0, d[gi], d[bi], d[ai]);
+ v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+ for (int i = 0; i < 3; i++) {
+ gl_Position = vertex_to_gs[i];
+ EmitVertex();
+ }
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+ color = v;
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 0.0 0.0
+
+uniform int ri 0
+uniform int gi 1
+uniform int bi 2
+uniform int ai 3
+
+uniform double d[0] 0.0
+uniform double d[1] 1.0
+uniform double d[2] 0.0
+uniform double d[3] 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-bool-double.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-bool-double.shader_test
new file mode 100644
index 0000000..3f44122
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-bool-double.shader_test
@@ -0,0 +1,65 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+ vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform double arg0;
+uniform bool arg1;
+uniform double arg2;
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+ dvec4 result;
+ if (arg1)
+ result = dvec4(arg0, arg2, 0.0, 0.0);
+ else
+ result = dvec4(arg0, arg2, 1.0, 0.0);
+ v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+ for (int i = 0; i < 3; i++) {
+ gl_Position = vertex_to_gs[i];
+ EmitVertex();
+ }
+
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+ color = v;
+}
+
+[test]
+uniform double tolerance 0.0
+uniform dvec4 expected 1.0 1.0 0.0 0.0
+uniform double arg0 1.0
+uniform int arg1 1
+uniform double arg2 1.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-uniform-array-direct-indirect.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-uniform-array-direct-indirect.shader_test
new file mode 100644
index 0000000..b4e0e75
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-double-uniform-array-direct-indirect.shader_test
@@ -0,0 +1,64 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+ vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform double arg[7];
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+ dvec4 result = dvec4(arg[int(arg[6])] + arg0);
+ v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+ for (int i = 0; i < 3; i++) {
+ gl_Position = vertex_to_gs[i];
+ EmitVertex();
+ }
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+ color = v;
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.65 0.65 0.65 0.65
+uniform double arg[0] 0.1
+uniform double arg[1] 0.2
+uniform double arg[2] 0.3
+uniform double arg[3] 0.4
+uniform double arg[4] 0.5
+uniform double arg[5] 0.6
+uniform double arg[6] 3.0
+draw rect -1 -1 2 2
+probe rgba 1 1 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-doubles-float-mixed.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-doubles-float-mixed.shader_test
new file mode 100644
index 0000000..2d29464
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-doubles-float-mixed.shader_test
@@ -0,0 +1,66 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+ vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform ubo1 {
+ double r;
+ float g;
+ double b;
+ double a;
+};
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+ dvec4 result = dvec4(r + arg0, g, b, a);
+ v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+ for (int i = 0; i < 3; i++) {
+ gl_Position = vertex_to_gs[i];
+ EmitVertex();
+ }
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+ color = v;
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 1.0 0.0
+uniform double r 0.0
+uniform float g 1.0
+uniform double b 1.0
+uniform double a 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dvec4-uniform-array-direct-indirect.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dvec4-uniform-array-direct-indirect.shader_test
new file mode 100644
index 0000000..ff1d5f9
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-dvec4-uniform-array-direct-indirect.shader_test
@@ -0,0 +1,62 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+ vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double tolerance;
+uniform dvec4 expected;
+
+uniform dvec4 arg[7];
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+ dvec4 result = dvec4(arg[int(arg[6].w)]);
+ v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+ for (int i = 0; i < 3; i++) {
+ gl_Position = vertex_to_gs[i];
+ EmitVertex();
+ }
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+ color = v;
+}
+
+[test]
+uniform double tolerance 0.0
+uniform dvec4 expected 0.40 0.41 0.42 0.43
+uniform dvec4 arg[0] 0.10 0.11 0.12 0.13
+uniform dvec4 arg[1] 0.20 0.21 0.22 0.23
+uniform dvec4 arg[2] 0.30 0.31 0.32 0.33
+uniform dvec4 arg[3] 0.40 0.41 0.42 0.43
+uniform dvec4 arg[4] 0.50 0.51 0.52 0.53
+uniform dvec4 arg[5] 0.60 0.61 0.62 0.63
+uniform dvec4 arg[6] 0.70 0.71 0.72 3.00
+draw rect -1 -1 2 2
+probe rgba 1 1 0.0 1.0 0.0 1.0
diff --git a/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-nested-struct.shader_test b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-nested-struct.shader_test
new file mode 100644
index 0000000..b9ebc6e
--- /dev/null
+++ b/tests/spec/arb_gpu_shader_fp64/uniform_buffers/gs-nested-struct.shader_test
@@ -0,0 +1,83 @@
+[require]
+GLSL >= 1.50
+GL_ARB_gpu_shader_fp64
+
+[vertex shader]
+#version 150
+in vec4 piglit_vertex;
+out vec4 vertex_to_gs;
+
+void main()
+{
+ vertex_to_gs = piglit_vertex;
+}
+
+[geometry shader]
+#version 150
+#extension GL_ARB_gpu_shader_fp64 : require
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+uniform double arg0;
+uniform double tolerance;
+uniform dvec4 expected;
+
+struct S1 {
+ double r;
+};
+
+struct S2 {
+ float p1;
+ double r;
+ double g;
+ double b;
+ float p2;
+ double a;
+};
+
+struct S {
+ S1 s1;
+ S2 s2;
+};
+
+uniform ubo1 {
+ S s;
+};
+
+in vec4 vertex_to_gs[3];
+out vec4 v;
+
+void main()
+{
+ dvec4 result = dvec4(s.s1.r + arg0, s.s2.g, s.s2.b, s.s2.a);
+ v = distance(result, expected) <= tolerance ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 1.0, 0.0, 1.0);
+
+ for (int i = 0; i < 3; i++) {
+ gl_Position = vertex_to_gs[i];
+ EmitVertex();
+ }
+}
+
+[fragment shader]
+#version 150
+
+in vec4 v;
+out vec4 color;
+
+void main()
+{
+ color = v;
+}
+
+[test]
+uniform double arg0 0.25
+uniform double tolerance 0.0
+uniform dvec4 expected 0.25 1.0 0.0 0.0
+uniform double s.s1.r 0.0
+uniform float s.s2.p1 1.0
+uniform double s.s2.g 1.0
+uniform double s.s2.b 0.0
+uniform float s.s2.p2 1.0
+uniform double s.s2.a 0.0
+draw rect -1 -1 2 2
+probe all rgba 0.0 1.0 0.0 1.0
--
2.1.0
More information about the Piglit
mailing list