Test/spv.float16.frag

#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));
}