diff options
Diffstat (limited to 'tests/spec/amd_gpu_shader_half_float')
288 files changed, 5551 insertions, 0 deletions
diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/max3-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/max3-f16vec2.vert new file mode 100644 index 000000000..f584c0304 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/max3-f16vec2.vert @@ -0,0 +1,20 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float GL_AMD_shader_trinary_minmax +// [end config] +// +// Tests use of half float with max3() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable +#extension GL_AMD_shader_trinary_minmax : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + float16_t z = 0.123HF; + + return max3(f16vec2(x), f16vec2(y), f16vec2(z)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/max3-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/max3-f16vec3.vert new file mode 100644 index 000000000..bc886727b --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/max3-f16vec3.vert @@ -0,0 +1,20 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float GL_AMD_shader_trinary_minmax +// [end config] +// +// Tests use of half float with max3() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable +#extension GL_AMD_shader_trinary_minmax : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + float16_t z = 0.123HF; + + return max3(f16vec3(x), f16vec3(y), f16vec3(z)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/max3-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/max3-f16vec4.vert new file mode 100644 index 000000000..f96213fd8 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/max3-f16vec4.vert @@ -0,0 +1,20 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float GL_AMD_shader_trinary_minmax +// [end config] +// +// Tests use of half float with max3() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable +#extension GL_AMD_shader_trinary_minmax : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + float16_t z = 0.123HF; + + return max3(f16vec4(x), f16vec4(y), f16vec4(z)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/max3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/max3.vert new file mode 100644 index 000000000..93d70c1be --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/max3.vert @@ -0,0 +1,20 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float GL_AMD_shader_trinary_minmax +// [end config] +// +// Tests use of half float with max3() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable +#extension GL_AMD_shader_trinary_minmax : enable + +float16_t test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + float16_t z = 0.123HF; + + return max3(x, y, z); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/mid3-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/mid3-f16vec2.vert new file mode 100644 index 000000000..927d6d177 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/mid3-f16vec2.vert @@ -0,0 +1,20 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float GL_AMD_shader_trinary_minmax +// [end config] +// +// Tests use of half float with mid3() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable +#extension GL_AMD_shader_trinary_minmax : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + float16_t z = 0.123HF; + + return mid3(f16vec2(x), f16vec2(y), f16vec2(z)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/mid3-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/mid3-f16vec3.vert new file mode 100644 index 000000000..2b4990868 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/mid3-f16vec3.vert @@ -0,0 +1,20 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float GL_AMD_shader_trinary_minmax +// [end config] +// +// Tests use of half float with mid3() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable +#extension GL_AMD_shader_trinary_minmax : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + float16_t z = 0.123HF; + + return mid3(f16vec3(x), f16vec3(y), f16vec3(z)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/mid3-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/mid3-f16vec4.vert new file mode 100644 index 000000000..52aded51f --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/mid3-f16vec4.vert @@ -0,0 +1,20 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float GL_AMD_shader_trinary_minmax +// [end config] +// +// Tests use of half float with mid3() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable +#extension GL_AMD_shader_trinary_minmax : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + float16_t z = 0.123HF; + + return mid3(f16vec4(x), f16vec4(y), f16vec4(z)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/mid3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/mid3.vert new file mode 100644 index 000000000..10bbd6c47 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/mid3.vert @@ -0,0 +1,20 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float GL_AMD_shader_trinary_minmax +// [end config] +// +// Tests use of half float with mid3() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable +#extension GL_AMD_shader_trinary_minmax : enable + +float16_t test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + float16_t z = 0.123HF; + + return mid3(x, y, z); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/min3-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/min3-f16vec2.vert new file mode 100644 index 000000000..b1407e328 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/min3-f16vec2.vert @@ -0,0 +1,20 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float GL_AMD_shader_trinary_minmax +// [end config] +// +// Tests use of half float with min3() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable +#extension GL_AMD_shader_trinary_minmax : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + float16_t z = 0.123HF; + + return min3(f16vec2(x), f16vec2(y), f16vec2(z)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/min3-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/min3-f16vec3.vert new file mode 100644 index 000000000..f79db761c --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/min3-f16vec3.vert @@ -0,0 +1,20 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float GL_AMD_shader_trinary_minmax +// [end config] +// +// Tests use of half float with min3() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable +#extension GL_AMD_shader_trinary_minmax : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + float16_t z = 0.123HF; + + return min3(f16vec3(x), f16vec3(y), f16vec3(z)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/min3-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/min3-f16vec4.vert new file mode 100644 index 000000000..666f062ce --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/min3-f16vec4.vert @@ -0,0 +1,20 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float GL_AMD_shader_trinary_minmax +// [end config] +// +// Tests use of half float with min3() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable +#extension GL_AMD_shader_trinary_minmax : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + float16_t z = 0.123HF; + + return min3(f16vec4(x), f16vec4(y), f16vec4(z)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/min3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/min3.vert new file mode 100644 index 000000000..03210e305 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/AMD_shader_trinary_minmax/min3.vert @@ -0,0 +1,20 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float GL_AMD_shader_trinary_minmax +// [end config] +// +// Tests use of half float with min3() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable +#extension GL_AMD_shader_trinary_minmax : enable + +float16_t test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + float16_t z = 0.123HF; + + return min3(x, y, z); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acos-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acos-f16vec2.vert new file mode 100644 index 000000000..71d2414c6 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acos-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with acos() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return acos(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acos-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acos-f16vec3.vert new file mode 100644 index 000000000..b88928bd0 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acos-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with acos() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return acos(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acos-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acos-f16vec4.vert new file mode 100644 index 000000000..59bbf1c93 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acos-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with acos() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return acos(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acos.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acos.vert new file mode 100644 index 000000000..25a0475f6 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acos.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with acos() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return acos(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acosh-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acosh-f16vec2.vert new file mode 100644 index 000000000..f4ff07dd8 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acosh-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with acosh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return acosh(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acosh-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acosh-f16vec3.vert new file mode 100644 index 000000000..36ad7a640 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acosh-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with acosh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return acosh(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acosh-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acosh-f16vec4.vert new file mode 100644 index 000000000..0c51de30c --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acosh-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with acosh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return acosh(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acosh.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acosh.vert new file mode 100644 index 000000000..1dcb9d2c5 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/acosh.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with acosh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return acosh(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asin-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asin-f16vec2.vert new file mode 100644 index 000000000..2bdb95498 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asin-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with asin() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return asin(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asin-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asin-f16vec3.vert new file mode 100644 index 000000000..c0c507773 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asin-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with asin() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return asin(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asin-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asin-f16vec4.vert new file mode 100644 index 000000000..656b05210 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asin-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with asin() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return asin(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asin.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asin.vert new file mode 100644 index 000000000..6de8b8efa --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asin.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with asin() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return asin(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asinh-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asinh-f16vec2.vert new file mode 100644 index 000000000..c7c0603b6 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asinh-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with asinh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return asinh(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asinh-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asinh-f16vec3.vert new file mode 100644 index 000000000..7a682e588 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asinh-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with asinh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return asinh(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asinh-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asinh-f16vec4.vert new file mode 100644 index 000000000..5bab49a1d --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asinh-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with asinh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return asinh(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asinh.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asinh.vert new file mode 100644 index 000000000..924ea46f3 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/asinh.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with asinh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return asinh(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atan-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atan-f16vec2.vert new file mode 100644 index 000000000..fa028d0d6 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atan-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with atan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + float16_t y = 0.555HF; + + return atan(f16vec2(x)) + atan(f16vec2(y), f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atan-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atan-f16vec3.vert new file mode 100644 index 000000000..4528b473c --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atan-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with atan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + float16_t y = 0.555HF; + + return atan(f16vec3(x)) + atan(f16vec3(y), f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atan-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atan-f16vec4.vert new file mode 100644 index 000000000..93e23bd8e --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atan-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with atan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + float16_t y = 0.555HF; + + return atan(f16vec4(x)) + atan(f16vec4(y), f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atan.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atan.vert new file mode 100644 index 000000000..9d2b9f376 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atan.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with atan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + float16_t y = 0.555HF; + + return atan(x) + atan(y, x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atanh-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atanh-f16vec2.vert new file mode 100644 index 000000000..b19b618df --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atanh-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with atanh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return atanh(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atanh-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atanh-f16vec3.vert new file mode 100644 index 000000000..938e2a887 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atanh-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with atanh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return atanh(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atanh-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atanh-f16vec4.vert new file mode 100644 index 000000000..ff28645ca --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atanh-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with atanh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return atanh(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atanh.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atanh.vert new file mode 100644 index 000000000..c94a330e7 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/atanh.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with atanh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return atanh(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cos-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cos-f16vec2.vert new file mode 100644 index 000000000..c55b1a325 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cos-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with cos() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return cos(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cos-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cos-f16vec3.vert new file mode 100644 index 000000000..57d9d2022 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cos-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with cos() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return cos(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cos-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cos-f16vec4.vert new file mode 100644 index 000000000..aeaee2959 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cos-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with cos() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return cos(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cos.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cos.vert new file mode 100644 index 000000000..318cf86cd --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cos.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with cos() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return cos(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cosh-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cosh-f16vec2.vert new file mode 100644 index 000000000..503a7cae3 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cosh-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with cosh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return cosh(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cosh-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cosh-f16vec3.vert new file mode 100644 index 000000000..e4ab08455 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cosh-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with cosh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return cosh(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cosh-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cosh-f16vec4.vert new file mode 100644 index 000000000..158fd9e6e --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cosh-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with cosh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return cosh(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cosh.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cosh.vert new file mode 100644 index 000000000..e12fe0170 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/cosh.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with cosh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return cosh(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/degrees-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/degrees-f16vec2.vert new file mode 100644 index 000000000..2312c5c21 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/degrees-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with degrees() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return degrees(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/degrees-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/degrees-f16vec3.vert new file mode 100644 index 000000000..42fb247c7 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/degrees-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with degrees() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return degrees(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/degrees-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/degrees-f16vec4.vert new file mode 100644 index 000000000..3392ad056 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/degrees-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with degrees() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return degrees(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/degrees.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/degrees.vert new file mode 100644 index 000000000..9f4400c4a --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/degrees.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with degrees() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return degrees(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/radians-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/radians-f16vec2.vert new file mode 100644 index 000000000..eee5e3440 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/radians-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with radians() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return radians(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/radians-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/radians-f16vec3.vert new file mode 100644 index 000000000..1cdda8f96 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/radians-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with radians() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return radians(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/radians-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/radians-f16vec4.vert new file mode 100644 index 000000000..8aa8b7244 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/radians-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with radians() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return radians(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/radians.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/radians.vert new file mode 100644 index 000000000..365d97f82 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/radians.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with radians() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return radians(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sin-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sin-f16vec2.vert new file mode 100644 index 000000000..1cf5eb21b --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sin-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with sin() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return sin(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sin-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sin-f16vec3.vert new file mode 100644 index 000000000..8789c8e15 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sin-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with sin() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return sin(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sin-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sin-f16vec4.vert new file mode 100644 index 000000000..7d7ac862f --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sin-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with sin() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return sin(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sin.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sin.vert new file mode 100644 index 000000000..7ea3569d9 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sin.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with sin() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return sin(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sinh-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sinh-f16vec2.vert new file mode 100644 index 000000000..c83c7ecb7 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sinh-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with sinh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return sinh(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sinh-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sinh-f16vec3.vert new file mode 100644 index 000000000..0c48b40b2 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sinh-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with sinh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return sinh(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sinh-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sinh-f16vec4.vert new file mode 100644 index 000000000..8b6e6f2bf --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sinh-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with sinh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return sinh(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sinh.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sinh.vert new file mode 100644 index 000000000..510206484 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/sinh.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with sinh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return sinh(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tan-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tan-f16vec2.vert new file mode 100644 index 000000000..611474777 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tan-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with tan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return tan(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tan-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tan-f16vec3.vert new file mode 100644 index 000000000..e4004ae73 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tan-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with tan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return tan(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tan-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tan-f16vec4.vert new file mode 100644 index 000000000..0af95bf0a --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tan-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with tan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return tan(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tan.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tan.vert new file mode 100644 index 000000000..87acbaec2 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tan.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with tan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return tan(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tanh-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tanh-f16vec2.vert new file mode 100644 index 000000000..51b707eb4 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tanh-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with tanh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return tanh(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tanh-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tanh-f16vec3.vert new file mode 100644 index 000000000..5c4f958a0 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tanh-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with tanh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return tanh(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tanh-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tanh-f16vec4.vert new file mode 100644 index 000000000..b775edae6 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tanh-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with tanh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return tanh(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tanh.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tanh.vert new file mode 100644 index 000000000..c23d3cf72 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/angle-and-trigonometry/tanh.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with tanh() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return tanh(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/abs-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/abs-f16vec2.vert new file mode 100644 index 000000000..9796f095a --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/abs-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with abs() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return abs(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/abs-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/abs-f16vec3.vert new file mode 100644 index 000000000..f8729c721 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/abs-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with abs() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return abs(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/abs-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/abs-f16vec4.vert new file mode 100644 index 000000000..a36304508 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/abs-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with abs() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return abs(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/abs.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/abs.vert new file mode 100644 index 000000000..505087c63 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/abs.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with abs() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return abs(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ceil-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ceil-f16vec2.vert new file mode 100644 index 000000000..0de864bb2 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ceil-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with ceil() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return ceil(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ceil-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ceil-f16vec3.vert new file mode 100644 index 000000000..77c41c284 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ceil-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with ceil() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return ceil(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ceil-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ceil-f16vec4.vert new file mode 100644 index 000000000..b64bfb42f --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ceil-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with ceil() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return ceil(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ceil.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ceil.vert new file mode 100644 index 000000000..0de864bb2 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ceil.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with ceil() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return ceil(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/clamp-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/clamp-f16vec2.vert new file mode 100644 index 000000000..69b48844b --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/clamp-f16vec2.vert @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with clamp() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + float16_t minVal = 0.567HF; + float16_t maxVal = 0.890HF; + + return clamp(f16vec2(x), minVal, maxVal) + clamp(f16vec2(x), f16vec2(minVal), f16vec2(maxVal)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/clamp-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/clamp-f16vec3.vert new file mode 100644 index 000000000..f55b57e2d --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/clamp-f16vec3.vert @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with clamp() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + float16_t minVal = 0.567HF; + float16_t maxVal = 0.890HF; + + return clamp(f16vec3(x), minVal, maxVal) + clamp(f16vec3(x), f16vec3(minVal), f16vec3(maxVal)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/clamp-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/clamp-f16vec4.vert new file mode 100644 index 000000000..b98e17bb0 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/clamp-f16vec4.vert @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with clamp() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + float16_t minVal = 0.567HF; + float16_t maxVal = 0.890HF; + + return clamp(f16vec4(x), minVal, maxVal) + clamp(f16vec4(x), f16vec4(minVal), f16vec4(maxVal)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/clamp.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/clamp.vert new file mode 100644 index 000000000..be6cce593 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/clamp.vert @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with clamp() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + float16_t minVal = 0.567HF; + float16_t maxVal = 0.890HF; + + return clamp(x, minVal, maxVal); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/floor-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/floor-f16vec2.vert new file mode 100644 index 000000000..9edd9cedb --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/floor-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with floor() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return floor(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/floor-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/floor-f16vec3.vert new file mode 100644 index 000000000..dd52162dc --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/floor-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with floor() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return floor(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/floor-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/floor-f16vec4.vert new file mode 100644 index 000000000..3ee3d99a3 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/floor-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with floor() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return floor(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/floor.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/floor.vert new file mode 100644 index 000000000..011c747f6 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/floor.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with floor() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return floor(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fma-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fma-f16vec2.vert new file mode 100644 index 000000000..ff88f8100 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fma-f16vec2.vert @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fma() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t a = 0.999HF; + float16_t b = 0.345HF; + float16_t c = 0.678HF; + + return fma(f16vec2(a), f16vec2(b), f16vec2(c)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fma-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fma-f16vec3.vert new file mode 100644 index 000000000..b8196e37e --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fma-f16vec3.vert @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fma() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t a = 0.999HF; + float16_t b = 0.345HF; + float16_t c = 0.678HF; + + return fma(f16vec3(a), f16vec3(b), f16vec3(c)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fma-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fma-f16vec4.vert new file mode 100644 index 000000000..5b8a7d307 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fma-f16vec4.vert @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fma() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t a = 0.999HF; + float16_t b = 0.345HF; + float16_t c = 0.678HF; + + return fma(f16vec4(a), f16vec4(b), f16vec4(c)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fma.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fma.vert new file mode 100644 index 000000000..c01b3264b --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fma.vert @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fma() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t a = 0.999HF; + float16_t b = 0.345HF; + float16_t c = 0.678HF; + + return fma(a, b, c); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fract-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fract-f16vec2.vert new file mode 100644 index 000000000..908943c21 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fract-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fract() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return fract(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fract-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fract-f16vec3.vert new file mode 100644 index 000000000..b2f81fb9e --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fract-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fract() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return fract(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fract-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fract-f16vec4.vert new file mode 100644 index 000000000..79a411711 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fract-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fract() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return fract(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fract.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fract.vert new file mode 100644 index 000000000..2845d7898 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/fract.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fract() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return fract(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/frexp-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/frexp-f16vec2.vert new file mode 100644 index 000000000..103ec8405 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/frexp-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with frexp() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + ivec2 exp; + + return frexp(f16vec2(x), exp); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/frexp-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/frexp-f16vec3.vert new file mode 100644 index 000000000..c4c41fcf0 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/frexp-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with frexp() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + ivec3 exp; + + return frexp(f16vec3(x), exp); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/frexp-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/frexp-f16vec4.vert new file mode 100644 index 000000000..486524c33 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/frexp-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with frexp() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + ivec4 exp; + + return frexp(f16vec4(x), exp); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/frexp.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/frexp.vert new file mode 100644 index 000000000..0ca627955 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/frexp.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with frexp() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + int exp; + + return frexp(x, exp); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isinf-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isinf-f16vec2.vert new file mode 100644 index 000000000..040698fa3 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isinf-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with isinf() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec2 test() { + + float16_t x = 0.999HF; + + return isinf(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isinf-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isinf-f16vec3.vert new file mode 100644 index 000000000..6fca3c113 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isinf-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with isinf() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec3 test() { + + float16_t x = 0.999HF; + + return isinf(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isinf-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isinf-f16vec4.vert new file mode 100644 index 000000000..3aacf3005 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isinf-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with isinf() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec4 test() { + + float16_t x = 0.999HF; + + return isinf(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isinf.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isinf.vert new file mode 100644 index 000000000..5527ad399 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isinf.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with isinf() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bool test() { + + float16_t x = 0.999HF; + + return isinf(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isnan-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isnan-f16vec2.vert new file mode 100644 index 000000000..0623bc305 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isnan-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with isnan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec2 test() { + + float16_t x = 0.999HF; + + return isnan(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isnan-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isnan-f16vec3.vert new file mode 100644 index 000000000..1a6616a9d --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isnan-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with isnan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec3 test() { + + float16_t x = 0.999HF; + + return isnan(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isnan-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isnan-f16vec4.vert new file mode 100644 index 000000000..b65235449 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isnan-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with isnan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec4 test() { + + float16_t x = 0.999HF; + + return isnan(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isnan.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isnan.vert new file mode 100644 index 000000000..9736a740e --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/isnan.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with isnan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bool test() { + + float16_t x = 0.999HF; + + return isnan(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ldexp-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ldexp-f16vec2.vert new file mode 100644 index 000000000..50697d735 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ldexp-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with ldexp() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + int exp = 1; + + return ldexp(f16vec2(x), ivec2(exp)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ldexp-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ldexp-f16vec3.vert new file mode 100644 index 000000000..eea865ed5 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ldexp-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with ldexp() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + int exp = 1; + + return ldexp(f16vec3(x), ivec3(exp)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ldexp-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ldexp-f16vec4.vert new file mode 100644 index 000000000..3211c07bc --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ldexp-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with ldexp() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + int exp = 1; + + return ldexp(f16vec4(x), ivec4(exp)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ldexp.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ldexp.vert new file mode 100644 index 000000000..c555a9230 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/ldexp.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with ldexp() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + int exp = 1; + + return ldexp(x, exp); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/max-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/max-f16vec2.vert new file mode 100644 index 000000000..ed987474c --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/max-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with max() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return max(f16vec2(x), f16vec2(y)) + max(f16vec2(x), y); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/max-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/max-f16vec3.vert new file mode 100644 index 000000000..9d95cdfdb --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/max-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with max() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return max(f16vec3(x), f16vec3(y)) + max(f16vec3(x), y); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/max-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/max-f16vec4.vert new file mode 100644 index 000000000..36b0d45c7 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/max-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with max() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return max(f16vec4(x), f16vec4(y)) + max(f16vec4(x), y); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/max.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/max.vert new file mode 100644 index 000000000..daef36c26 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/max.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with max() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return max(x, y); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/min-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/min-f16vec2.vert new file mode 100644 index 000000000..476799139 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/min-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with min() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return min(f16vec2(x), f16vec2(y)) + min(f16vec2(x), y); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/min-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/min-f16vec3.vert new file mode 100644 index 000000000..88a9da094 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/min-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with min() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return min(f16vec3(x), f16vec3(y)) + min(f16vec3(x), y); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/min-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/min-f16vec4.vert new file mode 100644 index 000000000..b4e045458 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/min-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with min() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return min(f16vec4(x), f16vec4(y)) + min(f16vec4(x), y); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/min.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/min.vert new file mode 100644 index 000000000..e59e3311d --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/min.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with min() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return min(x, y); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mix-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mix-f16vec2.vert new file mode 100644 index 000000000..d9425af67 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mix-f16vec2.vert @@ -0,0 +1,22 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with mix() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + float16_t a = 0.890HF; + bool a_bool = false; + + return mix(f16vec2(x), f16vec2(y), f16vec2(a)) + + mix(f16vec2(x), f16vec2(y), a) + + mix(f16vec2(x), f16vec2(y), bvec2(a_bool)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mix-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mix-f16vec3.vert new file mode 100644 index 000000000..001801d92 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mix-f16vec3.vert @@ -0,0 +1,22 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with mix() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + float16_t a = 0.890HF; + bool a_bool = false; + + return mix(f16vec3(x), f16vec3(y), f16vec3(a)) + + mix(f16vec3(x), f16vec3(y), a) + + mix(f16vec3(x), f16vec3(y), bvec3(a_bool)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mix-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mix-f16vec4.vert new file mode 100644 index 000000000..ff07cbc97 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mix-f16vec4.vert @@ -0,0 +1,22 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with mix() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + float16_t a = 0.890HF; + bool a_bool = false; + + return mix(f16vec4(x), f16vec4(y), f16vec4(a)) + + mix(f16vec4(x), f16vec4(y), a) + + mix(f16vec4(x), f16vec4(y), bvec4(a_bool)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mix.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mix.vert new file mode 100644 index 000000000..9ac10d5ce --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mix.vert @@ -0,0 +1,20 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with mix() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + float16_t a = 0.890HF; + bool a_bool = false; + + return mix(x, y, a) + mix(x, y, a_bool); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mod-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mod-f16vec2.vert new file mode 100644 index 000000000..d2dbc2c39 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mod-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with mod() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return mod(f16vec2(x), y) + mod(f16vec2(x), f16vec2(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mod-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mod-f16vec3.vert new file mode 100644 index 000000000..c69339665 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mod-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with mod() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return mod(f16vec3(x), y) + mod(f16vec3(x), f16vec3(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mod-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mod-f16vec4.vert new file mode 100644 index 000000000..b9174c764 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mod-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with mod() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return mod(f16vec4(x), y) + mod(f16vec4(x), f16vec4(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mod.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mod.vert new file mode 100644 index 000000000..77f5c80e6 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/mod.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with mod() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return mod(x, y); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/modf-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/modf-f16vec2.vert new file mode 100644 index 000000000..0394adc9c --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/modf-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with modf() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + float16_t i = 0.567HF; + + return modf(f16vec2(x), f16vec2(i)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/modf-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/modf-f16vec3.vert new file mode 100644 index 000000000..d0df92fa4 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/modf-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with modf() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + float16_t i = 0.567HF; + + return modf(f16vec3(x), f16vec3(i)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/modf-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/modf-f16vec4.vert new file mode 100644 index 000000000..b33bc219a --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/modf-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with modf() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + float16_t i = 0.567HF; + + return modf(f16vec4(x), f16vec4(i)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/modf.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/modf.vert new file mode 100644 index 000000000..528c83ffb --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/modf.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with modf() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + float16_t i = 0.567HF; + + return modf(x, i); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/round-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/round-f16vec2.vert new file mode 100644 index 000000000..626d18c5f --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/round-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with round() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return round(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/round-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/round-f16vec3.vert new file mode 100644 index 000000000..d5ed65f69 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/round-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with round() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return round(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/round-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/round-f16vec4.vert new file mode 100644 index 000000000..e7cf088bf --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/round-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with round() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return round(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/round.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/round.vert new file mode 100644 index 000000000..cf1c05ade --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/round.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with round() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return round(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/roundEven-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/roundEven-f16vec2.vert new file mode 100644 index 000000000..a8b4031fe --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/roundEven-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with roundEven() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return roundEven(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/roundEven-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/roundEven-f16vec3.vert new file mode 100644 index 000000000..3cd49ef57 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/roundEven-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with roundEven() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return roundEven(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/roundEven-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/roundEven-f16vec4.vert new file mode 100644 index 000000000..1e45ea2a1 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/roundEven-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with roundEven() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return roundEven(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/roundEven.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/roundEven.vert new file mode 100644 index 000000000..14e139c53 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/roundEven.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with roundEven() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return roundEven(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/sign-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/sign-f16vec2.vert new file mode 100644 index 000000000..1791404d4 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/sign-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with sign() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return sign(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/sign-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/sign-f16vec3.vert new file mode 100644 index 000000000..78f135858 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/sign-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with sign() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return sign(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/sign-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/sign-f16vec4.vert new file mode 100644 index 000000000..57bd536e4 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/sign-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with sign() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return sign(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/sign.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/sign.vert new file mode 100644 index 000000000..48c111f9e --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/sign.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with sign() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return sign(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/smoothstep-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/smoothstep-f16vec2.vert new file mode 100644 index 000000000..ba99c8c0d --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/smoothstep-f16vec2.vert @@ -0,0 +1,20 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with smoothstep() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + float16_t edge0 = 0.567HF; + float16_t edge1 = 0.890HF; + + return smoothstep(f16vec2(edge0), f16vec2(edge1), f16vec2(x)) + + smoothstep(edge0, edge1, f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/smoothstep-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/smoothstep-f16vec3.vert new file mode 100644 index 000000000..6d4fd5bcd --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/smoothstep-f16vec3.vert @@ -0,0 +1,20 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with smoothstep() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + float16_t edge0 = 0.567HF; + float16_t edge1 = 0.890HF; + + return smoothstep(f16vec3(edge0), f16vec3(edge1), f16vec3(x)) + + smoothstep(edge0, edge1, f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/smoothstep-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/smoothstep-f16vec4.vert new file mode 100644 index 000000000..c59847f48 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/smoothstep-f16vec4.vert @@ -0,0 +1,20 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with smoothstep() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + float16_t edge0 = 0.567HF; + float16_t edge1 = 0.890HF; + + return smoothstep(f16vec4(edge0), f16vec4(edge1), f16vec4(x)) + + smoothstep(edge0, edge1, f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/smoothstep.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/smoothstep.vert new file mode 100644 index 000000000..5242c5eff --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/smoothstep.vert @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with smoothstep() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + float16_t edge0 = 0.567HF; + float16_t edge1 = 0.890HF; + + return smoothstep(edge0, edge1, x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/step-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/step-f16vec2.vert new file mode 100644 index 000000000..c6bdad935 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/step-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with step() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + float16_t edge = 0.567HF; + + return step(f16vec2(edge), f16vec2(x)) + step(edge, f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/step-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/step-f16vec3.vert new file mode 100644 index 000000000..c3579006a --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/step-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with step() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + float16_t edge = 0.567HF; + + return step(f16vec3(edge), f16vec3(x)) + step(edge, f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/step-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/step-f16vec4.vert new file mode 100644 index 000000000..5c6abe310 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/step-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with step() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + float16_t edge = 0.567HF; + + return step(f16vec4(edge), f16vec4(x)) + step(edge, f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/step.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/step.vert new file mode 100644 index 000000000..bd5a4bc05 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/step.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with step() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + float16_t edge = 0.567HF; + + return step(edge, x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/trunc-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/trunc-f16vec2.vert new file mode 100644 index 000000000..befd5c9fd --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/trunc-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with trunc() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return trunc(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/trunc-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/trunc-f16vec3.vert new file mode 100644 index 000000000..7cc7756f8 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/trunc-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with trunc() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return trunc(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/trunc-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/trunc-f16vec4.vert new file mode 100644 index 000000000..55564f70f --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/trunc-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with trunc() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return trunc(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/trunc.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/trunc.vert new file mode 100644 index 000000000..15262d506 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/common/trunc.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with trunc() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return trunc(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdx-f16vec2.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdx-f16vec2.frag new file mode 100644 index 000000000..c7f3ce790 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdx-f16vec2.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdx() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t p = 0.567HF; + + return dFdx(f16vec2(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdx-f16vec3.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdx-f16vec3.frag new file mode 100644 index 000000000..9a844e493 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdx-f16vec3.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdx() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t p = 0.567HF; + + return dFdx(f16vec3(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdx-f16vec4.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdx-f16vec4.frag new file mode 100644 index 000000000..7c6232bcb --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdx-f16vec4.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdx() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t p = 0.567HF; + + return dFdx(f16vec4(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdx.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdx.frag new file mode 100644 index 000000000..a9e4c9ab7 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdx.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdx() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t p = 0.567HF; + + return dFdx(p); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxCoarse-f16vec2.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxCoarse-f16vec2.frag new file mode 100644 index 000000000..b03910205 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxCoarse-f16vec2.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdxCoarse() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t p = 0.567HF; + + return dFdxCoarse(f16vec2(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxCoarse-f16vec3.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxCoarse-f16vec3.frag new file mode 100644 index 000000000..160df9fff --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxCoarse-f16vec3.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdxCoarse() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t p = 0.567HF; + + return dFdxCoarse(f16vec3(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxCoarse-f16vec4.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxCoarse-f16vec4.frag new file mode 100644 index 000000000..0d96433dd --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxCoarse-f16vec4.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdxCoarse() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t p = 0.567HF; + + return dFdxCoarse(f16vec4(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxCoarse.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxCoarse.frag new file mode 100644 index 000000000..0704b1990 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxCoarse.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdxCoarse() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t p = 0.567HF; + + return dFdxCoarse(p); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxFine-f16vec2.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxFine-f16vec2.frag new file mode 100644 index 000000000..a6a6b7054 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxFine-f16vec2.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdxFine() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t p = 0.567HF; + + return dFdxFine(f16vec2(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxFine-f16vec3.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxFine-f16vec3.frag new file mode 100644 index 000000000..41a44e953 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxFine-f16vec3.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdxFine() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t p = 0.567HF; + + return dFdxFine(f16vec3(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxFine-f16vec4.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxFine-f16vec4.frag new file mode 100644 index 000000000..73c94dd8b --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxFine-f16vec4.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdxFine() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t p = 0.567HF; + + return dFdxFine(f16vec4(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxFine.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxFine.frag new file mode 100644 index 000000000..7c558d6d1 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdxFine.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdxFine() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t p = 0.567HF; + + return dFdxFine(p); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdy-f16vec2.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdy-f16vec2.frag new file mode 100644 index 000000000..11b663aa2 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdy-f16vec2.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdy() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t p = 0.567HF; + + return dFdy(f16vec2(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdy-f16vec3.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdy-f16vec3.frag new file mode 100644 index 000000000..6bfdd40c7 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdy-f16vec3.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdy() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t p = 0.567HF; + + return dFdy(f16vec3(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdy-f16vec4.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdy-f16vec4.frag new file mode 100644 index 000000000..101ae8009 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdy-f16vec4.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdy() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t p = 0.567HF; + + return dFdy(f16vec4(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdy.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdy.frag new file mode 100644 index 000000000..83ccdea0a --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdy.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdy() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t p = 0.567HF; + + return dFdy(p); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyCoarse-f16vec2.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyCoarse-f16vec2.frag new file mode 100644 index 000000000..ac3f8d834 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyCoarse-f16vec2.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdyCoarse() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t p = 0.567HF; + + return dFdyCoarse(f16vec2(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyCoarse-f16vec3.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyCoarse-f16vec3.frag new file mode 100644 index 000000000..4949b13ab --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyCoarse-f16vec3.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdyCoarse() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t p = 0.567HF; + + return dFdyCoarse(f16vec3(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyCoarse-f16vec4.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyCoarse-f16vec4.frag new file mode 100644 index 000000000..887a175e8 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyCoarse-f16vec4.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdyCoarse() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t p = 0.567HF; + + return dFdyCoarse(f16vec4(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyCoarse.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyCoarse.frag new file mode 100644 index 000000000..cfe13df5b --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyCoarse.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdyCoarse() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t p = 0.567HF; + + return dFdyCoarse(p); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyFine-f16vec2.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyFine-f16vec2.frag new file mode 100644 index 000000000..ceefee15f --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyFine-f16vec2.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdyFine() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t p = 0.567HF; + + return dFdyFine(f16vec2(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyFine-f16vec3.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyFine-f16vec3.frag new file mode 100644 index 000000000..d8975fce8 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyFine-f16vec3.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdyFine() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t p = 0.567HF; + + return dFdyFine(f16vec3(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyFine-f16vec4.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyFine-f16vec4.frag new file mode 100644 index 000000000..fa156179f --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyFine-f16vec4.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdyFine() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t p = 0.567HF; + + return dFdyFine(f16vec4(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyFine.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyFine.frag new file mode 100644 index 000000000..fe0a775f5 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/dFdyFine.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dFdyFine() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t p = 0.567HF; + + return dFdyFine(p); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidth-f16vec2.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidth-f16vec2.frag new file mode 100644 index 000000000..8c0ea2dbe --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidth-f16vec2.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fwidth() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t p = 0.567HF; + + return fwidth(f16vec2(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidth-f16vec3.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidth-f16vec3.frag new file mode 100644 index 000000000..d37ef2988 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidth-f16vec3.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fwidth() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t p = 0.567HF; + + return fwidth(f16vec3(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidth-f16vec4.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidth-f16vec4.frag new file mode 100644 index 000000000..c17cfef78 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidth-f16vec4.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fwidth() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t p = 0.567HF; + + return fwidth(f16vec4(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidth.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidth.frag new file mode 100644 index 000000000..54874ce43 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidth.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fwidth() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t p = 0.567HF; + + return fwidth(p); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthCoarse-f16vec2.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthCoarse-f16vec2.frag new file mode 100644 index 000000000..f2949bca7 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthCoarse-f16vec2.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fwidthCoarse() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t p = 0.567HF; + + return fwidthCoarse(f16vec2(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthCoarse-f16vec3.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthCoarse-f16vec3.frag new file mode 100644 index 000000000..8abdd1479 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthCoarse-f16vec3.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fwidthCoarse() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t p = 0.567HF; + + return fwidthCoarse(f16vec3(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthCoarse-f16vec4.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthCoarse-f16vec4.frag new file mode 100644 index 000000000..1244a67b1 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthCoarse-f16vec4.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fwidthCoarse() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t p = 0.567HF; + + return fwidthCoarse(f16vec4(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthCoarse.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthCoarse.frag new file mode 100644 index 000000000..243590675 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthCoarse.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fwidthCoarse() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t p = 0.567HF; + + return fwidthCoarse(p); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthFine-f16vec2.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthFine-f16vec2.frag new file mode 100644 index 000000000..f9379489a --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthFine-f16vec2.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fwidthFine() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t p = 0.567HF; + + return fwidthFine(f16vec2(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthFine-f16vec3.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthFine-f16vec3.frag new file mode 100644 index 000000000..b6ad65df5 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthFine-f16vec3.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fwidthFine() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t p = 0.567HF; + + return fwidthFine(f16vec3(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthFine-f16vec4.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthFine-f16vec4.frag new file mode 100644 index 000000000..1537ac480 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthFine-f16vec4.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fwidthFine() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t p = 0.567HF; + + return fwidthFine(f16vec4(p)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthFine.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthFine.frag new file mode 100644 index 000000000..0e0c0ef86 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/derivative/fwidthFine.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.50 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with fwidthFine() builtin + +#version 450 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t p = 0.567HF; + + return fwidthFine(p); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp-f16vec2.vert new file mode 100644 index 000000000..da4447648 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with exp() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return exp(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp-f16vec3.vert new file mode 100644 index 000000000..d6ba70cda --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with exp() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return exp(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp-f16vec4.vert new file mode 100644 index 000000000..76b49a919 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with exp() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return exp(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp.vert new file mode 100644 index 000000000..9f7f9d8e5 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with exp() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return exp(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp2-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp2-f16vec2.vert new file mode 100644 index 000000000..95f200663 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp2-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with exp2() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return exp2(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp2-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp2-f16vec3.vert new file mode 100644 index 000000000..dbcce88a4 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp2-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with exp2() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return exp2(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp2-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp2-f16vec4.vert new file mode 100644 index 000000000..483b98e80 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp2-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with exp2() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return exp2(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp2.vert new file mode 100644 index 000000000..3967d97f9 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/exp2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with exp2() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return exp2(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/inversesqrt-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/inversesqrt-f16vec2.vert new file mode 100644 index 000000000..2c951abda --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/inversesqrt-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with inversesqrt() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return inversesqrt(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/inversesqrt-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/inversesqrt-f16vec3.vert new file mode 100644 index 000000000..2fb4f159b --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/inversesqrt-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with inversesqrt() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return inversesqrt(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/inversesqrt-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/inversesqrt-f16vec4.vert new file mode 100644 index 000000000..cd52dd2ce --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/inversesqrt-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with inversesqrt() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return inversesqrt(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/inversesqrt.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/inversesqrt.vert new file mode 100644 index 000000000..b62f641c3 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/inversesqrt.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with inversesqrt() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return inversesqrt(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log-f16vec2.vert new file mode 100644 index 000000000..93cdb4cb4 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with log() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return log(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log-f16vec3.vert new file mode 100644 index 000000000..f2fb1b549 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with log() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return log(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log-f16vec4.vert new file mode 100644 index 000000000..6af05793e --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with log() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return log(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log.vert new file mode 100644 index 000000000..ebb7a0299 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with log() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return log(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log2-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log2-f16vec2.vert new file mode 100644 index 000000000..cce6db214 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log2-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with log2() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return log2(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log2-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log2-f16vec3.vert new file mode 100644 index 000000000..1f0306c98 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log2-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with log2() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return log2(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log2-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log2-f16vec4.vert new file mode 100644 index 000000000..358dc4696 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log2-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with log2() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return log2(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log2.vert new file mode 100644 index 000000000..827501f87 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/log2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with log2() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return log2(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/pow-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/pow-f16vec2.vert new file mode 100644 index 000000000..cd15c8e67 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/pow-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with pow() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return pow(f16vec2(x), f16vec2(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/pow-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/pow-f16vec3.vert new file mode 100644 index 000000000..8080ecfa0 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/pow-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with pow() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return pow(f16vec3(x), f16vec3(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/pow-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/pow-f16vec4.vert new file mode 100644 index 000000000..6832d3fba --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/pow-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with pow() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return pow(f16vec4(x), f16vec4(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/pow.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/pow.vert new file mode 100644 index 000000000..243837df3 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/pow.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with pow() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return pow(x, y); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/sqrt-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/sqrt-f16vec2.vert new file mode 100644 index 000000000..f892cc88f --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/sqrt-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with sqrt() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.999HF; + + return sqrt(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/sqrt-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/sqrt-f16vec3.vert new file mode 100644 index 000000000..b17813787 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/sqrt-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with sqrt() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.999HF; + + return sqrt(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/sqrt-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/sqrt-f16vec4.vert new file mode 100644 index 000000000..7aae88d05 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/sqrt-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with sqrt() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.999HF; + + return sqrt(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/sqrt.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/sqrt.vert new file mode 100644 index 000000000..d2c62745f --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/exponential/sqrt.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with sqrt() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.999HF; + + return sqrt(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/cross.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/cross.vert new file mode 100644 index 000000000..2cd1dc460 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/cross.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with cross() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.123HF; + float16_t y = 0.456HF; + + return cross(f16vec3(x), f16vec3(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/distance-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/distance-f16vec2.vert new file mode 100644 index 000000000..2d10173b7 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/distance-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with distance() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t p0 = 0.123HF; + float16_t p1 = 0.456HF; + + return distance(f16vec2(p0), f16vec2(p1)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/distance-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/distance-f16vec3.vert new file mode 100644 index 000000000..22fe2bd79 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/distance-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with distance() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t p0 = 0.123HF; + float16_t p1 = 0.456HF; + + return distance(f16vec3(p0), f16vec3(p1)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/distance-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/distance-f16vec4.vert new file mode 100644 index 000000000..9036cd1e2 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/distance-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with distance() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t p0 = 0.123HF; + float16_t p1 = 0.456HF; + + return distance(f16vec4(p0), f16vec4(p1)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/distance.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/distance.vert new file mode 100644 index 000000000..2822f68ec --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/distance.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with distance() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t p0 = 0.123HF; + float16_t p1 = 0.456HF; + + return distance(p0, p1); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/dot-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/dot-f16vec2.vert new file mode 100644 index 000000000..8f50e6487 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/dot-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dot() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.123HF; + float16_t y = 0.456HF; + + return dot(f16vec2(x), f16vec2(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/dot-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/dot-f16vec3.vert new file mode 100644 index 000000000..5b14b4e71 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/dot-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dot() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.123HF; + float16_t y = 0.456HF; + + return dot(f16vec3(x), f16vec3(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/dot-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/dot-f16vec4.vert new file mode 100644 index 000000000..a6f888b7b --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/dot-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dot() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.123HF; + float16_t y = 0.456HF; + + return dot(f16vec4(x), f16vec4(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/dot.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/dot.vert new file mode 100644 index 000000000..23fb4ef57 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/dot.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with dot() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.123HF; + float16_t y = 0.456HF; + + return dot(x, y); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/faceforward-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/faceforward-f16vec2.vert new file mode 100644 index 000000000..5783e3a6d --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/faceforward-f16vec2.vert @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with faceforward() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t N = 0.123HF; + float16_t I = 0.456HF; + float16_t Nref = 0.789HF; + + return faceforward(f16vec2(N), f16vec2(I), f16vec2(Nref)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/faceforward-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/faceforward-f16vec3.vert new file mode 100644 index 000000000..b3dd003ff --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/faceforward-f16vec3.vert @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with faceforward() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t N = 0.123HF; + float16_t I = 0.456HF; + float16_t Nref = 0.789HF; + + return faceforward(f16vec3(N), f16vec3(I), f16vec3(Nref)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/faceforward-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/faceforward-f16vec4.vert new file mode 100644 index 000000000..d5866fb01 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/faceforward-f16vec4.vert @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with faceforward() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t N = 0.123HF; + float16_t I = 0.456HF; + float16_t Nref = 0.789HF; + + return faceforward(f16vec4(N), f16vec4(I), f16vec4(Nref)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/faceforward.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/faceforward.vert new file mode 100644 index 000000000..bc61cfa73 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/faceforward.vert @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with faceforward() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t N = 0.123HF; + float16_t I = 0.456HF; + float16_t Nref = 0.789HF; + + return faceforward(N, I, Nref); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/length-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/length-f16vec2.vert new file mode 100644 index 000000000..e02489743 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/length-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with length() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.123HF; + + return length(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/length-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/length-f16vec3.vert new file mode 100644 index 000000000..56b61bd66 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/length-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with length() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.123HF; + + return length(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/length-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/length-f16vec4.vert new file mode 100644 index 000000000..9b0c040a6 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/length-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with length() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.123HF; + + return length(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/length.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/length.vert new file mode 100644 index 000000000..17577c6a6 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/length.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with length() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.123HF; + + return length(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/normalize-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/normalize-f16vec2.vert new file mode 100644 index 000000000..fa2d2708c --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/normalize-f16vec2.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with normalize() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t x = 0.123HF; + + return normalize(f16vec2(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/normalize-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/normalize-f16vec3.vert new file mode 100644 index 000000000..7ad08d440 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/normalize-f16vec3.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with normalize() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t x = 0.123HF; + + return normalize(f16vec3(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/normalize-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/normalize-f16vec4.vert new file mode 100644 index 000000000..ec1a05a45 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/normalize-f16vec4.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with normalize() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t x = 0.123HF; + + return normalize(f16vec4(x)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/normalize.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/normalize.vert new file mode 100644 index 000000000..4d9a19ce8 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/normalize.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with normalize() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.123HF; + + return normalize(x); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/reflect-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/reflect-f16vec2.vert new file mode 100644 index 000000000..4149c7aea --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/reflect-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with reflect() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t N = 0.123HF; + float16_t I = 0.456HF; + + return reflect(f16vec2(I), f16vec2(N)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/reflect-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/reflect-f16vec3.vert new file mode 100644 index 000000000..3de8860a1 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/reflect-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with reflect() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t N = 0.123HF; + float16_t I = 0.456HF; + + return reflect(f16vec3(I), f16vec3(N)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/reflect-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/reflect-f16vec4.vert new file mode 100644 index 000000000..fad20b1be --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/reflect-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with reflect() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t N = 0.123HF; + float16_t I = 0.456HF; + + return reflect(f16vec4(I), f16vec4(N)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/reflect.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/reflect.vert new file mode 100644 index 000000000..1da84f2d8 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/reflect.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with reflect() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t N = 0.123HF; + float16_t I = 0.456HF; + + return reflect(I, N); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/refract-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/refract-f16vec2.vert new file mode 100644 index 000000000..5d5a713dc --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/refract-f16vec2.vert @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with refract() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + float16_t N = 0.123HF; + float16_t I = 0.456HF; + float16_t eta = 0.789HF; + + return refract(f16vec2(I), f16vec2(N), eta); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/refract-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/refract-f16vec3.vert new file mode 100644 index 000000000..c82f23182 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/refract-f16vec3.vert @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with refract() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec3 test() { + + float16_t N = 0.123HF; + float16_t I = 0.456HF; + float16_t eta = 0.789HF; + + return refract(f16vec3(I), f16vec3(N), eta); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/refract-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/refract-f16vec4.vert new file mode 100644 index 000000000..5cf76f3a4 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/refract-f16vec4.vert @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with refract() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec4 test() { + + float16_t N = 0.123HF; + float16_t I = 0.456HF; + float16_t eta = 0.789HF; + + return refract(f16vec4(I), f16vec4(N), eta); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/refract.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/refract.vert new file mode 100644 index 000000000..75928e330 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/geometric/refract.vert @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with refract() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t N = 0.123HF; + float16_t I = 0.456HF; + float16_t eta = 0.789HF; + + return refract(I, N, eta); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtCentroid-f16vec2.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtCentroid-f16vec2.frag new file mode 100644 index 000000000..afe28bbdd --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtCentroid-f16vec2.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with interpolateAtCentroid() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +in f16vec2 p; + +f16vec2 test() { + + return interpolateAtCentroid(p); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtCentroid-f16vec3.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtCentroid-f16vec3.frag new file mode 100644 index 000000000..578075614 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtCentroid-f16vec3.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with interpolateAtCentroid() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +in f16vec3 p; + +f16vec3 test() { + + return interpolateAtCentroid(p); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtCentroid-f16vec4.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtCentroid-f16vec4.frag new file mode 100644 index 000000000..511165c9e --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtCentroid-f16vec4.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with interpolateAtCentroid() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +in f16vec4 p; + +f16vec4 test() { + + return interpolateAtCentroid(p); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtCentroid.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtCentroid.frag new file mode 100644 index 000000000..c9e8f97f6 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtCentroid.frag @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with interpolateAtCentroid() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +in float16_t p; + +float16_t test() { + + return interpolateAtCentroid(p); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtOffset-f16vec2.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtOffset-f16vec2.frag new file mode 100644 index 000000000..3fb6d80bf --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtOffset-f16vec2.frag @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with interpolateAtOffset() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +in f16vec2 p; + +f16vec2 test() { + + f16vec2 offset = f16vec2(0.123, 0.456); + + return interpolateAtOffset(p, offset); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtOffset-f16vec3.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtOffset-f16vec3.frag new file mode 100644 index 000000000..662b9b5dc --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtOffset-f16vec3.frag @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with interpolateAtOffset() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +in f16vec3 p; + +f16vec3 test() { + + f16vec2 offset = f16vec2(0.123, 0.456); + + return interpolateAtOffset(p, offset); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtOffset-f16vec4.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtOffset-f16vec4.frag new file mode 100644 index 000000000..249ec5a76 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtOffset-f16vec4.frag @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with interpolateAtOffset() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +in f16vec4 p; + +f16vec4 test() { + + f16vec2 offset = f16vec2(0.123, 0.456); + + return interpolateAtOffset(p, offset); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtOffset.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtOffset.frag new file mode 100644 index 000000000..bf18a26e2 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtOffset.frag @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with interpolateAtOffset() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +in float16_t p; + +float16_t test() { + + f16vec2 offset = f16vec2(0.123, 0.456); + + return interpolateAtOffset(p, offset); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtSample-f16vec2.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtSample-f16vec2.frag new file mode 100644 index 000000000..fe5a4c8ee --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtSample-f16vec2.frag @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with interpolateAtSample() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +in f16vec2 p; + +f16vec2 test() { + + int s = 1; + + return interpolateAtSample(p, s); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtSample-f16vec3.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtSample-f16vec3.frag new file mode 100644 index 000000000..aa5dcec63 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtSample-f16vec3.frag @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with interpolateAtSample() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +in f16vec3 p; + +f16vec3 test() { + + int s = 1; + + return interpolateAtSample(p, s); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtSample-f16vec4.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtSample-f16vec4.frag new file mode 100644 index 000000000..0741efae8 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtSample-f16vec4.frag @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with interpolateAtSample() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +in f16vec4 p; + +f16vec4 test() { + + int s = 1; + + return interpolateAtSample(p, s); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtSample.frag b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtSample.frag new file mode 100644 index 000000000..9533610dc --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/interpolation/interpolateAtSample.frag @@ -0,0 +1,19 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with interpolateAtSample() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +in float16_t p; + +float16_t test() { + + int s = 1; + + return interpolateAtSample(p, s); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/matrix/determinant.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/matrix/determinant.vert new file mode 100644 index 000000000..01064a2ff --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/matrix/determinant.vert @@ -0,0 +1,31 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with determinant() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test_mat2() { + + float16_t m = 0.123HF; + + return determinant(f16mat2(m)); +} + +float16_t test_mat3() { + + float16_t m = 0.123HF; + + return determinant(f16mat3(m)); +} + +float16_t test_mat4() { + + float16_t m = 0.123HF; + + return determinant(f16mat4(m)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/matrix/inverse.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/matrix/inverse.vert new file mode 100644 index 000000000..0ce5a4032 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/matrix/inverse.vert @@ -0,0 +1,31 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with inverse() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16mat2 test_mat2() { + + float16_t m = 0.123HF; + + return inverse(f16mat2(m)); +} + +f16mat3 test_mat3() { + + float16_t m = 0.123HF; + + return inverse(f16mat3(m)); +} + +f16mat4 test_mat4() { + + float16_t m = 0.123HF; + + return inverse(f16mat4(m)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/matrix/matrixCompMult.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/matrix/matrixCompMult.vert new file mode 100644 index 000000000..a47335e94 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/matrix/matrixCompMult.vert @@ -0,0 +1,82 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with matrixCompMult() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16mat2x2 test_mat2x2() { + + float16_t x = 0.123HF; + float16_t y = 0.456HF; + + return matrixCompMult(f16mat2x2(x), f16mat2x2(y)); +} + +f16mat2x3 test_mat2x3() { + + float16_t x = 0.123HF; + float16_t y = 0.456HF; + + return matrixCompMult(f16mat2x3(x), f16mat2x3(y)); +} + +f16mat2x4 test_mat2x4() { + + float16_t x = 0.123HF; + float16_t y = 0.456HF; + + return matrixCompMult(f16mat2x4(x), f16mat2x4(y)); +} + +f16mat3x2 test_mat3x2() { + + float16_t x = 0.123HF; + float16_t y = 0.456HF; + + return matrixCompMult(f16mat3x2(x), f16mat3x2(y)); +} + +f16mat3x3 test_mat3x3() { + + float16_t x = 0.123HF; + float16_t y = 0.456HF; + + return matrixCompMult(f16mat3x3(x), f16mat3x3(y)); +} + +f16mat3x4 test_mat3x4() { + + float16_t x = 0.123HF; + float16_t y = 0.456HF; + + return matrixCompMult(f16mat3x4(x), f16mat3x4(y)); +} + +f16mat4x2 test_mat4x2() { + + float16_t x = 0.123HF; + float16_t y = 0.456HF; + + return matrixCompMult(f16mat4x2(x), f16mat4x2(y)); +} + +f16mat4x3 test_mat4x3() { + + float16_t x = 0.123HF; + float16_t y = 0.456HF; + + return matrixCompMult(f16mat4x3(x), f16mat4x3(y)); +} + +f16mat4x4 test_mat4x4() { + + float16_t x = 0.123HF; + float16_t y = 0.456HF; + + return matrixCompMult(f16mat4x4(x), f16mat4x4(y)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/matrix/outerProduct.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/matrix/outerProduct.vert new file mode 100644 index 000000000..7d957af55 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/matrix/outerProduct.vert @@ -0,0 +1,82 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with outerProduct() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16mat2 test_mat2() { + + float16_t c = 0.123HF; + float16_t r = 0.456HF; + + return outerProduct(f16vec2(c), f16vec2(r)); +} + +f16mat3 test_mat3() { + + float16_t c = 0.123HF; + float16_t r = 0.456HF; + + return outerProduct(f16vec3(c), f16vec3(r)); +} + +f16mat4 test_mat4() { + + float16_t c = 0.123HF; + float16_t r = 0.456HF; + + return outerProduct(f16vec4(c), f16vec4(r)); +} + +f16mat2x3 test_mat2x3() { + + float16_t c = 0.123HF; + float16_t r = 0.456HF; + + return outerProduct(f16vec3(c), f16vec2(r)); +} + +f16mat3x2 test_mat3x2() { + + float16_t c = 0.123HF; + float16_t r = 0.456HF; + + return outerProduct(f16vec2(c), f16vec3(r)); +} + +f16mat2x4 test_mat2x4() { + + float16_t c = 0.123HF; + float16_t r = 0.456HF; + + return outerProduct(f16vec4(c), f16vec2(r)); +} + +f16mat4x2 test_mat4x2() { + + float16_t c = 0.123HF; + float16_t r = 0.456HF; + + return outerProduct(f16vec2(c), f16vec4(r)); +} + +f16mat3x4 test_mat3x4() { + + float16_t c = 0.123HF; + float16_t r = 0.456HF; + + return outerProduct(f16vec4(c), f16vec3(r)); +} + +f16mat4x3 test_mat4x3() { + + float16_t c = 0.123HF; + float16_t r = 0.456HF; + + return outerProduct(f16vec3(c), f16vec4(r)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/matrix/transpose.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/matrix/transpose.vert new file mode 100644 index 000000000..5f33a2d1c --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/matrix/transpose.vert @@ -0,0 +1,73 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with transpose() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16mat2 test_mat2() { + + float16_t c = 0.123HF; + + return transpose(f16mat2(c)); +} + +f16mat3 test_mat3() { + + float16_t c = 0.123HF; + + return transpose(f16mat3(c)); +} + +f16mat4 test_mat4() { + + float16_t c = 0.123HF; + + return transpose(f16mat4(c)); +} + +f16mat2x3 test_mat2x3() { + + float16_t c = 0.123HF; + + return transpose(mat3x2(c)); +} + +f16mat3x2 test_mat3x2() { + + float16_t c = 0.123HF; + + return transpose(f16mat2x3(c)); +} + +f16mat2x4 test_mat2x4() { + + float16_t c = 0.123HF; + + return transpose(f16mat4x2(c)); +} + +f16mat4x2 test_mat4x2() { + + float16_t c = 0.123HF; + + return transpose(f16mat2x4(c)); +} + +f16mat3x4 test_mat3x4() { + + float16_t c = 0.123HF; + + return transpose(f16mat4x3(c)); +} + +f16mat4x3 test_mat4x3() { + + float16_t c = 0.123HF; + + return transpose(f16mat3x4(c)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/pack_float16.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/pack_float16.vert new file mode 100644 index 000000000..f39ae721e --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/pack_float16.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with packFloat2x16() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +uint test() { + + float16_t x = 0.999HF; + float16_t y = 0.123HF; + + return packFloat2x16(f16vec2(x, y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/unpack_float16.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/unpack_float16.vert new file mode 100644 index 000000000..bea1bab91 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/unpack_float16.vert @@ -0,0 +1,17 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with unpackFloat2x16() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +f16vec2 test() { + + uint v = 12345; + + return unpackFloat2x16(v); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/equal-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/equal-f16vec2.vert new file mode 100644 index 000000000..5d467c4e9 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/equal-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with equal() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec2 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return equal(f16vec2(x), f16vec2(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/equal-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/equal-f16vec3.vert new file mode 100644 index 000000000..bcdd55359 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/equal-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with equal() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec3 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return equal(f16vec3(x), f16vec3(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/equal-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/equal-f16vec4.vert new file mode 100644 index 000000000..560ae5f2b --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/equal-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with equal() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec4 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return equal(f16vec4(x), f16vec4(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThan-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThan-f16vec2.vert new file mode 100644 index 000000000..a2bed4b2d --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThan-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with greaterThan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec2 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return greaterThan(f16vec2(x), f16vec2(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThan-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThan-f16vec3.vert new file mode 100644 index 000000000..df83d881c --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThan-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with greaterThan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec3 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return greaterThan(f16vec3(x), f16vec3(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThan-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThan-f16vec4.vert new file mode 100644 index 000000000..1cf6741aa --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThan-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with greaterThan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec4 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return greaterThan(f16vec4(x), f16vec4(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThanEqual-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThanEqual-f16vec2.vert new file mode 100644 index 000000000..3e4a582d3 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThanEqual-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with greaterThanEqual() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec2 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return greaterThanEqual(f16vec2(x), f16vec2(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThanEqual-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThanEqual-f16vec3.vert new file mode 100644 index 000000000..132407cc3 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThanEqual-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with greaterThanEqual() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec3 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return greaterThanEqual(f16vec3(x), f16vec3(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThanEqual-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThanEqual-f16vec4.vert new file mode 100644 index 000000000..edb225d98 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/greaterThanEqual-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with greaterThanEqual() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec4 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return greaterThanEqual(f16vec4(x), f16vec4(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThan-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThan-f16vec2.vert new file mode 100644 index 000000000..8ca5c30b5 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThan-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with lessThan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec2 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return lessThan(f16vec2(x), f16vec2(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThan-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThan-f16vec3.vert new file mode 100644 index 000000000..4437bc97a --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThan-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with lessThan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec3 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return lessThan(f16vec3(x), f16vec3(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThan-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThan-f16vec4.vert new file mode 100644 index 000000000..5fbf55465 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThan-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with lessThan() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec4 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return lessThan(f16vec4(x), f16vec4(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThanEqual-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThanEqual-f16vec2.vert new file mode 100644 index 000000000..1ddd8d8f6 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThanEqual-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with lessThanEqual() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec2 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return lessThanEqual(f16vec2(x), f16vec2(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThanEqual-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThanEqual-f16vec3.vert new file mode 100644 index 000000000..0125cd881 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThanEqual-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with lessThanEqual() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec3 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return lessThanEqual(f16vec3(x), f16vec3(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThanEqual-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThanEqual-f16vec4.vert new file mode 100644 index 000000000..80ce4e76a --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/lessThanEqual-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with lessThanEqual() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec4 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return lessThanEqual(f16vec4(x), f16vec4(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/notEqual-f16vec2.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/notEqual-f16vec2.vert new file mode 100644 index 000000000..0b46eb9ba --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/notEqual-f16vec2.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with notEqual() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec2 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return notEqual(f16vec2(x), f16vec2(y)); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/notEqual-f16vec3.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/notEqual-f16vec3.vert new file mode 100644 index 000000000..a88cc826b --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/notEqual-f16vec3.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with notEqual() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec3 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return notEqual(f16vec3(x), f16vec3(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/notEqual-f16vec4.vert b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/notEqual-f16vec4.vert new file mode 100644 index 000000000..ebf4556d3 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/builtin-functions/vector-relational/notEqual-f16vec4.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float with notEqual() builtin + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +bvec4 test() { + + float16_t x = 0.999HF; + float16_t y = 0.567HF; + + return notEqual(f16vec4(x), f16vec4(y)); +} diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/conversions-int64.vert b/tests/spec/amd_gpu_shader_half_float/compiler/conversions-int64.vert new file mode 100644 index 000000000..2ffb97bac --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/conversions-int64.vert @@ -0,0 +1,39 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float GL_ARB_gpu_shader_int64 +// [end config] +// +// Tests use of half float conversions with the scalar constructors + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable +#extension GL_ARB_gpu_shader_int64 : enable + +float16_t test_int64_to_f16() { + + int64_t a = 5l; + + return float16_t(a); +} + +float16_t test_uint64_to_f16() { + + uint64_t a = 5ul; + + return float16_t(a); +} + +int64_t test_f16_to_int64() { + + float16_t a = 1.0; + + return int64_t(a); +} + +uint64_t test_f16_to_uint64() { + + float16_t a = 2.0; + + return uint64_t(a); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/conversions.vert b/tests/spec/amd_gpu_shader_half_float/compiler/conversions.vert new file mode 100644 index 000000000..d4fe0244d --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/conversions.vert @@ -0,0 +1,80 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float conversions with the scalar constructors + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test_bool_to_f16() { + + bool a = true; + + return float16_t(a); +} + +float16_t test_int_to_f16() { + + int a = 5; + + return float16_t(a); +} + +float16_t test_uint_to_f16() { + + uint a = 5u; + + return float16_t(a); +} + +float16_t test_float_to_f16() { + + float a = 0.345; + + return float16_t(a); +} + +float16_t test_double_to_f16() { + + double a = 0.345; + + return float16_t(a); +} + +bool test_f16_to_bool() { + + float16_t a = 0.0; + + return bool(a); +} + +int test_f16_to_int() { + + float16_t a = 2.0; + + return int(a); +} + +uint test_f16_to_uint() { + + float16_t a = 3.0; + + return uint(a); +} + +float test_f16_to_float() { + + float16_t a = 0.345; + + return float(a); +} + +double test_f16_to_double() { + + float16_t a = 0.345; + + return double(a); +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/implicit-conversions-doubles.vert b/tests/spec/amd_gpu_shader_half_float/compiler/implicit-conversions-doubles.vert new file mode 100644 index 000000000..cd0909ca6 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/implicit-conversions-doubles.vert @@ -0,0 +1,101 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float implicit conversions to doubles + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +double test_float16_t_to_double() { + + float16_t a = 0.123hf; + + return a; +} + +dvec2 test_f16vec2_to_dvec2() { + + f16vec2 a = f16vec2(0.123hf); + + return a; +} + +dvec3 test_f16vec3_to_dvec3() { + + f16vec3 a = f16vec3(0.123hf); + + return a; +} + +dvec4 test_f16vec4_to_dvec4() { + + f16vec4 a = f16vec4(0.123hf); + + return a; +} + +dmat2 test_f16mat2_to_dmat2() { + + f16mat2 a = f16mat2(0.123hf); + + return a; +} + +dmat3 test_f16mat3_to_dmat3() { + + f16mat3 a = f16mat3(0.123hf); + + return a; +} + +dmat4 test_f16mat4_to_dmat4() { + + f16mat4 a = f16mat4(0.123hf); + + return a; +} + +dmat2x3 test_f16mat2x3_to_dmat2x3() { + + f16mat2x3 a = f16mat2x3(0.123hf); + + return a; +} + +dmat2x4 test_f16mat2x4_to_dmat2x4() { + + f16mat2x4 a = f16mat2x4(0.123hf); + + return a; +} + +dmat3x2 test_f16mat3x2_to_dmat3x2() { + + f16mat3x2 a = f16mat3x2(0.123hf); + + return a; +} + +dmat3x4 test_f16mat3x4_to_dmat3x4() { + + f16mat3x4 a = f16mat3x4(0.123hf); + + return a; +} + +dmat4x2 test_f16mat4x2_to_dmat4x2() { + + f16mat4x2 a = f16mat4x2(0.123hf); + + return a; +} + +dmat4x3 test_f16mat4x3_to_dmat4x3() { + + f16mat4x3 a = f16mat4x3(0.123hf); + + return a; +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/implicit-conversions.vert b/tests/spec/amd_gpu_shader_half_float/compiler/implicit-conversions.vert new file mode 100644 index 000000000..bbf856340 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/implicit-conversions.vert @@ -0,0 +1,101 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of half float implicit conversions + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float test_float16_t_to_float() { + + float16_t a = 0.123hf; + + return a; +} + +vec2 test_f16vec2_to_vec2() { + + f16vec2 a = f16vec2(0.123hf); + + return a; +} + +vec3 test_f16vec3_to_vec3() { + + f16vec3 a = f16vec3(0.123hf); + + return a; +} + +vec4 test_f16vec4_to_vec4() { + + f16vec4 a = f16vec4(0.123hf); + + return a; +} + +mat2 test_f16mat2_to_mat2() { + + f16mat2 a = f16mat2(0.123hf); + + return a; +} + +mat3 test_f16mat3_to_mat3() { + + f16mat3 a = f16mat3(0.123hf); + + return a; +} + +mat4 test_f16mat4_to_mat4() { + + f16mat4 a = f16mat4(0.123hf); + + return a; +} + +mat2x3 test_f16mat2x3_to_mat2x3() { + + f16mat2x3 a = f16mat2x3(0.123hf); + + return a; +} + +mat2x4 test_f16mat2x4_to_mat2x4() { + + f16mat2x4 a = f16mat2x4(0.123hf); + + return a; +} + +mat3x2 test_f16mat3x2_to_mat3x2() { + + f16mat3x2 a = f16mat3x2(0.123hf); + + return a; +} + +mat3x4 test_f16mat3x4_to_mat3x4() { + + f16mat3x4 a = f16mat3x4(0.123hf); + + return a; +} + +mat4x2 test_f16mat4x2_to_mat4x2() { + + f16mat4x2 a = f16mat4x2(0.123hf); + + return a; +} + +mat4x3 test_f16mat4x3_to_mat4x3() { + + f16mat4x3 a = f16mat4x3(0.123hf); + + return a; +}
\ No newline at end of file diff --git a/tests/spec/amd_gpu_shader_half_float/compiler/suffix.vert b/tests/spec/amd_gpu_shader_half_float/compiler/suffix.vert new file mode 100644 index 000000000..bafd6a9cd --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/compiler/suffix.vert @@ -0,0 +1,18 @@ +// [config] +// expect_result: pass +// glsl_version: 4.00 +// require_extensions: GL_AMD_gpu_shader_half_float +// [end config] +// +// Tests use of lower and uppercase half float suffix + +#version 400 +#extension GL_AMD_gpu_shader_half_float : enable + +float16_t test() { + + float16_t x = 0.123HF; + float16_t y = 0.123hf; + + return x + y; +} diff --git a/tests/spec/amd_gpu_shader_half_float/preprocessor/extension-if-1.shader_test b/tests/spec/amd_gpu_shader_half_float/preprocessor/extension-if-1.shader_test new file mode 100644 index 000000000..0f7099da5 --- /dev/null +++ b/tests/spec/amd_gpu_shader_half_float/preprocessor/extension-if-1.shader_test @@ -0,0 +1,23 @@ +[require] +GLSL >= 4.00 +GL_AMD_gpu_shader_half_float + +[fragment shader] +#version 400 +#extension GL_AMD_gpu_shader_half_float : require + +out vec4 colour; + +void main() +{ +#if GL_AMD_gpu_shader_half_float == 1 + colour = vec4(0.0, 1.0, 0.0, 0.0); +#else + colour = vec4(1.0, 0.0, 0.0, 0.0); +#endif +} + + +[test] +draw rect -1 -1 2 2 +relative probe rgba (0.5, 0.5) (0.0, 1.0, 0.0, 0.0) |