lt_fp64.shader_test

# Check if double 'a' is less than 'b' 
# IEEE 754 compliant

[require]
GLSL >= 1.30

[vertex shader]
#version 130

void main()
{
    gl_Position = gl_Vertex;
}

[fragment shader]
#version 130

/* Returns the fraction bits of the double-precision floating-point value `a'.*/
uvec2
extractFloat64Frac( uvec2 a )
{
    return uvec2( a.x & 0x000FFFFFu, a.y );
}

/* Returns the exponent bits of the double-precision floating-point value `a'.*/
uint
extractFloat64Exp( uvec2 a )
{
    return (a.x>>20) & 0x7FFu;
}

/* Returns the sign bit of the double-precision floating-point value `a'.*/
uint
extractFloat64Sign( uvec2 a )
{
    return (a.x>>31);
}

/* Returns true if the 64-bit value formed by concatenating `a0' and `a1' is less
 * than the 64-bit value formed by concatenating `b0' and `b1'.  Otherwise,
 * returns false.
 */
bool
lt64( uint a0, uint a1, uint b0, uint b1 )
{
    return ( a0 < b0 ) || ( ( a0 == b0 ) && ( a1 < b1 ) );
}

/* Returns true if the double-precision floating-point value `a' is less than
 * the corresponding value `b', and false otherwise.  The comparison is performed
 * according to the IEEE Standard for Floating-Point Arithmetic.
 */
bool
lt_fp64( uvec2 a, uvec2 b )
{
    uint aSign;
    uint bSign;
    uvec2 aFrac;
    uvec2 bFrac;
    bool isaNaN;
    bool isbNaN;

    aFrac = extractFloat64Frac( a );
    bFrac = extractFloat64Frac( b );
    isaNaN = ( extractFloat64Exp( a ) == 0x7FFu ) &&
        ( ( aFrac.x | aFrac.y ) != 0u );
    isbNaN = ( extractFloat64Exp( b ) == 0x7FFu ) &&
       ( ( bFrac.x | bFrac.y ) != 0u );

    if ( isaNaN || isbNaN ) {
        return false;
    }

    aSign = extractFloat64Sign( a );
    bSign = extractFloat64Sign( b );
    if( aSign != bSign ) {
        return ( aSign != 0u ) &&
            ( ( ( ( ( a.x | b.x )<<1 ) ) | a.y | b.y ) != 0u );
    }
    return ( aSign != 0u ) ? lt64( b.x, b.y, a.x, a.y )
        : lt64( a.x, a.y, b.x, b.y );
}

uniform uvec2 a;
uniform uvec2 b;
uniform bool expected;

void main()
{
    /* Generate green if the expected value is producted, red
     * otherwise.
     */
    gl_FragColor = lt_fp64(a,b) == expected
        ? vec4(0.0, 1.0, 0.0, 1.0)
        : vec4(1.0, 0.0, 0.0, 1.0);
}

[test]
# A bunch of tests to run.  The 'uniform' lines set the uniforms.  The
# 'draw rect' line draws a rectangle that covers the whole window.
# The 'probe all' line verifies that every pixel contains the expected
# color.

# Try +0.0 and +0.0
uniform uvec2 a        0x00000000 0x00000000
uniform uvec2 b        0x00000000 0x00000000
uniform int expected   0
draw rect -1 -1 2 2
probe all rgba 0.0 1.0 0.0 1.0

# Try 0.1 and 0.0
uniform uvec2 a        0x3FB99999 0x9999999A
uniform uvec2 b        0x00000000 0x00000000
uniform int expected   0
draw rect -1 -1 2 2
probe all rgba 0.0 1.0 0.0 1.0

# Try 0.0 and 0.1
uniform uvec2 a        0x00000000 0x00000000
uniform uvec2 b        0x3FB99999 0x9999999A
uniform int expected   1
draw rect -1 -1 2 2
probe all rgba 0.0 1.0 0.0 1.0

# Try 1 bit set and 0.0
uniform uvec2 a        0x00000000 0x00000001
uniform uvec2 b        0x00000000 0x00000000
uniform int expected   0
draw rect -1 -1 2 2
probe all rgba 0.0 1.0 0.0 1.0

# Try 0.0 and 1 bit set
uniform uvec2 a        0x00000000 0x00000000
uniform uvec2 b        0x00000000 0x00000001
uniform int expected   1
draw rect -1 -1 2 2
probe all rgba 0.0 1.0 0.0 1.0

# Try 1 bit set and 1 bit set
uniform uvec2 a        0x00000000 0x00000001
uniform uvec2 b        0x00000000 0x00000001
uniform int expected   0
draw rect -1 -1 2 2
probe all rgba 0.0 1.0 0.0 1.0

# Try +Inf and +Inf
uniform uvec2 a       0x7FF00000 0x00000000
uniform uvec2 b       0x7FF00000 0x00000000
uniform int expected  0
draw rect -1 -1 2 2
probe all rgba 0.0 1.0 0.0 1.0

# Try +Inf and -Inf
uniform uvec2 a       0x7FF00000 0x00000000
uniform uvec2 b       0xFFF00000 0x00000000
uniform int expected  0
draw rect -1 -1 2 2
probe all rgba 0.0 1.0 0.0 1.0

# Try -Inf and +Inf
uniform uvec2 a       0xFFF00000 0x00000000
uniform uvec2 b       0x7FF00000 0x00000000
uniform int expected  1
draw rect -1 -1 2 2
probe all rgba 0.0 1.0 0.0 1.0

# Try 0 and NaN
uniform uvec2 a      0x00000000 0x00000000
uniform uvec2 b      0x7FF00000 0x00000001
uniform int expected 0
draw rect -1 -1 2 2
probe all rgba 0.0 1.0 0.0 1.0