glslang/Test/spv.float16.frag

307 lines
8.1 KiB
GLSL

#version 450 core
#extension GL_AMD_gpu_shader_half_float: enable
#extension GL_ARB_gpu_shader_int64: enable
void main()
{
}
// Half float literals
void literal()
{
const float16_t f16c = 0.000001hf;
const f16vec2 f16cv = f16vec2(-0.25HF, 0.03HF);
f16vec2 f16v;
f16v.x = f16c;
f16v += f16cv;
}
// Block memory layout
struct S
{
float16_t x; // rule 1: align = 2, takes offsets 0-1
f16vec2 y; // rule 2: align = 4, takes offsets 4-7
f16vec3 z; // rule 3: align = 8, takes offsets 8-13
};
layout(column_major, std140) uniform B1
{
float16_t a; // rule 1: align = 2, takes offsets 0-1
f16vec2 b; // rule 2: align = 4, takes offsets 4-7
f16vec3 c; // rule 3: align = 8, takes offsets 8-15
float16_t d[2]; // rule 4: align = 16, array stride = 16,
// takes offsets 16-47
f16mat2x3 e; // rule 5: align = 16, matrix stride = 16,
// takes offsets 48-79
f16mat2x3 f[2]; // rule 6: align = 16, matrix stride = 16,
// array stride = 32, f[0] takes
// offsets 80-111, f[1] takes offsets
// 112-143
S g; // rule 9: align = 16, g.x takes offsets
// 144-145, g.y takes offsets 148-151,
// g.z takes offsets 152-159
S h[2]; // rule 10: align = 16, array stride = 16, h[0]
// takes offsets 160-175, h[1] takes
// offsets 176-191
};
layout(row_major, std430) buffer B2
{
float16_t o; // rule 1: align = 2, takes offsets 0-1
f16vec2 p; // rule 2: align = 4, takes offsets 4-7
f16vec3 q; // rule 3: align = 8, takes offsets 8-13
float16_t r[2]; // rule 4: align = 2, array stride = 2, takes
// offsets 14-17
f16mat2x3 s; // rule 7: align = 4, matrix stride = 4, takes
// offsets 20-31
f16mat2x3 t[2]; // rule 8: align = 4, matrix stride = 4, array
// stride = 12, t[0] takes offsets
// 32-43, t[1] takes offsets 44-55
S u; // rule 9: align = 8, u.x takes offsets
// 56-57, u.y takes offsets 60-63, u.z
// takes offsets 64-69
S v[2]; // rule 10: align = 8, array stride = 16, v[0]
// takes offsets 72-87, v[1] takes
// offsets 88-103
};
// Specialization constant
layout(constant_id = 100) const float16_t sf16 = 0.125hf;
layout(constant_id = 101) const float sf = 0.25;
layout(constant_id = 102) const double sd = 0.5lf;
const float f16_to_f = float(sf16);
const double f16_to_d = float(sf16);
const float16_t f_to_f16 = float16_t(sf);
const float16_t d_to_f16 = float16_t(sd);
void operators()
{
float16_t f16;
f16vec2 f16v;
f16mat2x2 f16m;
bool b;
// Arithmetic
f16v += f16v;
f16v -= f16v;
f16v *= f16v;
f16v /= f16v;
f16v++;
f16v--;
++f16m;
--f16m;
f16v = -f16v;
f16m = -f16m;
f16 = f16v.x + f16v.y;
f16 = f16v.x - f16v.y;
f16 = f16v.x * f16v.y;
f16 = f16v.x / f16v.y;
// Relational
b = (f16v.x != f16);
b = (f16v.y == f16);
b = (f16v.x > f16);
b = (f16v.y < f16);
b = (f16v.x >= f16);
b = (f16v.y <= f16);
// Vector/matrix operations
f16v = f16v * f16;
f16m = f16m * f16;
f16v = f16m * f16v;
f16v = f16v * f16m;
f16m = f16m * f16m;
}
void typeCast()
{
bvec3 bv;
vec3 fv;
dvec3 dv;
ivec3 iv;
uvec3 uv;
i64vec3 i64v;
u64vec3 u64v;
f16vec3 f16v;
f16v = f16vec3(bv); // bool -> float16
bv = bvec3(f16v); // float16 -> bool
f16v = f16vec3(fv); // float -> float16
fv = vec3(f16v); // float16 -> float
f16v = f16vec3(dv); // double -> float16
dv = dvec3(dv); // float16 -> double
f16v = f16vec3(iv); // int -> float16
iv = ivec3(f16v); // float16 -> int
f16v = f16vec3(uv); // uint -> float16
uv = uvec3(f16v); // float16 -> uint
f16v = f16vec3(i64v); // int64 -> float16
i64v = i64vec3(f16v); // float16 -> int64
f16v = f16vec3(u64v); // uint64 -> float16
u64v = u64vec3(f16v); // float16 -> uint64
}
void builtinAngleTrigFuncs()
{
f16vec4 f16v1, f16v2;
f16v2 = radians(f16v1);
f16v2 = degrees(f16v1);
f16v2 = sin(f16v1);
f16v2 = cos(f16v1);
f16v2 = tan(f16v1);
f16v2 = asin(f16v1);
f16v2 = acos(f16v1);
f16v2 = atan(f16v1, f16v2);
f16v2 = atan(f16v1);
f16v2 = sinh(f16v1);
f16v2 = cosh(f16v1);
f16v2 = tanh(f16v1);
f16v2 = asinh(f16v1);
f16v2 = acosh(f16v1);
f16v2 = atanh(f16v1);
}
void builtinExpFuncs()
{
f16vec2 f16v1, f16v2;
f16v2 = pow(f16v1, f16v2);
f16v2 = exp(f16v1);
f16v2 = log(f16v1);
f16v2 = exp2(f16v1);
f16v2 = log2(f16v1);
f16v2 = sqrt(f16v1);
f16v2 = inversesqrt(f16v1);
}
void builtinCommonFuncs()
{
f16vec3 f16v1, f16v2, f16v3;
float16_t f16;
bool b;
bvec3 bv;
ivec3 iv;
f16v2 = abs(f16v1);
f16v2 = sign(f16v1);
f16v2 = floor(f16v1);
f16v2 = trunc(f16v1);
f16v2 = round(f16v1);
f16v2 = roundEven(f16v1);
f16v2 = ceil(f16v1);
f16v2 = fract(f16v1);
f16v2 = mod(f16v1, f16v2);
f16v2 = mod(f16v1, f16);
f16v3 = modf(f16v1, f16v2);
f16v3 = min(f16v1, f16v2);
f16v3 = min(f16v1, f16);
f16v3 = max(f16v1, f16v2);
f16v3 = max(f16v1, f16);
f16v3 = clamp(f16v1, f16, f16v2.x);
f16v3 = clamp(f16v1, f16v2, f16vec3(f16));
f16v3 = mix(f16v1, f16v2, f16);
f16v3 = mix(f16v1, f16v2, f16v3);
f16v3 = mix(f16v1, f16v2, bv);
f16v3 = step(f16v1, f16v2);
f16v3 = step(f16, f16v3);
f16v3 = smoothstep(f16v1, f16v2, f16v3);
f16v3 = smoothstep(f16, f16v1.x, f16v2);
b = isnan(f16);
bv = isinf(f16v1);
f16v3 = fma(f16v1, f16v2, f16v3);
f16v2 = frexp(f16v1, iv);
f16v2 = ldexp(f16v1, iv);
}
void builtinPackUnpackFuncs()
{
uint u;
f16vec2 f16v;
u = packFloat2x16(f16v);
f16v = unpackFloat2x16(u);
}
void builtinGeometryFuncs()
{
float16_t f16;
f16vec3 f16v1, f16v2, f16v3;
f16 = length(f16v1);
f16 = distance(f16v1, f16v2);
f16 = dot(f16v1, f16v2);
f16v3 = cross(f16v1, f16v2);
f16v2 = normalize(f16v1);
f16v3 = faceforward(f16v1, f16v2, f16v3);
f16v3 = reflect(f16v1, f16v2);
f16v3 = refract(f16v1, f16v2, f16);
}
void builtinMatrixFuncs()
{
f16mat2x3 f16m1, f16m2, f16m3;
f16mat3x2 f16m4;
f16mat3 f16m5;
f16mat4 f16m6, f16m7;
f16vec3 f16v1;
f16vec2 f16v2;
float16_t f16;
f16m3 = matrixCompMult(f16m1, f16m2);
f16m1 = outerProduct(f16v1, f16v2);
f16m4 = transpose(f16m1);
f16 = determinant(f16m5);
f16m6 = inverse(f16m7);
}
void builtinVecRelFuncs()
{
f16vec3 f16v1, f16v2;
bvec3 bv;
bv = lessThan(f16v1, f16v2);
bv = lessThanEqual(f16v1, f16v2);
bv = greaterThan(f16v1, f16v2);
bv = greaterThanEqual(f16v1, f16v2);
bv = equal(f16v1, f16v2);
bv = notEqual(f16v1, f16v2);
}
in f16vec3 if16v;
void builtinFragProcFuncs()
{
f16vec3 f16v;
// Derivative
f16v.x = dFdx(if16v.x);
f16v.y = dFdy(if16v.y);
f16v.xy = dFdxFine(if16v.xy);
f16v.xy = dFdyFine(if16v.xy);
f16v = dFdxCoarse(if16v);
f16v = dFdxCoarse(if16v);
f16v.x = fwidth(if16v.x);
f16v.xy = fwidthFine(if16v.xy);
f16v = fwidthCoarse(if16v);
// Interpolation
f16v.x = interpolateAtCentroid(if16v.x);
f16v.xy = interpolateAtSample(if16v.xy, 1);
f16v = interpolateAtOffset(if16v, f16vec2(0.5hf));
}