xref: /third_party/openGLES/extensions/AMD/AMD_gpu_shader_int16.txt

Name

    AMD_gpu_shader_int16

Name Strings

    GL_AMD_gpu_shader_int16

Contact

    Dominik Witczak, AMD (dominik.witczak 'at' amd.com)

Contributors

    Daniel Rakos, AMD
    Matthaeus G. Chajdas, AMD
    Quentin Lin, AMD
    Rex Xu, AMD
    Timothy Lottes, AMD
    Zhi Cai, AMD

Status

    Shipping.

Version

    Last Modified Date:         03/28/2018
    Author Revision:            #2

Number

    OpenGL Extension #507

Dependencies

    This extension is written against version 4.50 of the OpenGL Shading
    Language Specification.

    GLSL 4.00 is required.

    This extension interacts with AMD_gpu_shader_half_float.
    This extension interacts with ARB_gpu_shader_int64.
    This extension interacts with KHR_vulkan_glsl.

Overview

    This extension was developed to allow implementations supporting 16-bit
    integers to expose the feature in GLSL.

    The extension introduces the following features for all shader types:

      * new built-in functions to pack and unpack 32-bit integer types into a
        two-component 16-bit integer vector;

      * new built-in functions to convert half-precision floating-point
        values to or from their 16-bit integer bit encodings;

      * vector relational functions supporting comparisons of vectors of
        16-bit integer types; and

      * common functions abs, frexp, ldexp, sign, min, max, clamp, and mix
        supporting arguments of 16-bit integer types.


New Procedures and Functions

    NONE


New Tokens

    NONE


Modifications to the OpenGL Shading Language Specification, Version 4.50

    Including the following line in a shader can be used to control the
    language features described in this extension:

      #extension GL_AMD_gpu_shader_int16 : <behavior>

    where <behavior> is as specified in section 3.3.

    New preprocessor #defines are added to the OpenGL Shading Language:

      #define GL_AMD_gpu_shader_int16       1


Additions to Chapter 3 of the OpenGL Shading Language Specification (Basics)

    Modify Section 3.6, Keywords

    (add the following to the list of reserved keywords at p. 18)

    int16_t  i16vec2  i16vec3  i16vec4  uint16_t  u16vec2  u16vec3  u16vec4


Additions to Chapter 4 of the OpenGL Shading Language Specification
(Variables and Types)

    Modify Section 4.1, Basic Types

    (add to the basic "Transparent Types" table, p. 19)

    +-----------+------------------------------------------------------------+
    | Type      | Meaning                                                    |
    +-----------+------------------------------------------------------------+
    | int16_t   | a 16-bit signed integer                                    |
    | uint16_t  | a 16-bit unsigned integer                                  |
    | i16vec2   | a two-component 16-bit signed integer vector               |
    | i16vec3   | a three-component 16-bit signed integer vector             |
    | i16vec4   | a four-component 16-bit signed integer vector              |
    | u16vec2   | a two-component 16-bit unsigned integer vector             |
    | u16vec3   | a three-component 16-bit unsigned integer vector           |
    | u16vec4   | a four-component 16-bit unsigned integer vector            |
    +-----------+------------------------------------------------------------+


    Modify Section 4.1.3, Integers

    (replace first paragraph of the section, p. 26)

    Signed and unsigned integer variables are fully supported. In this
    document, the term integer is meant to generally include both signed and
    unsigned integers, including both 16-bit and 32-bit integers. Unsigned
    integers of type uint16_t, u16vec2, u16vec3, and u16vec4 have exactly 16 bits
    of precision, while unsigned integers of type uint, uvec2, uvec3, and
    uvec4 have exactly 32 bits of precision. Signed integers of type int16_t,
    i16vec2, i16vec3, and i16vec4 have exactly 16 bits of precision, while signed
    integers of type int, ivec2, ivec3, and ivec4 have exactly 32 bits of precision.
    Addition, subtraction, and shift operations resulting in overflow or underflow
    will not cause any exceptions, nor will they saturate, rather they will "wrap"
    to yield the low-order bits of the result. Divison and multiplication operations
    resulting in overflow or underflow will not cause any exception but will result in
    an undefined value.

    Change "integer-suffix" definition:

     "integer-suffix:
         unsigned-suffix short-suffixopt
         short-suffix

      unsigned-suffix: one of
          u U
      short-suffix: one of
          s S

    Modify the next paragraph to say:
     "No white space is allowed between the digits of an integer constant,
     including after the leading 0 or after the leading 0x or 0X of a constant,
     or before the integer-suffix. When tokenizing, the maximal token matching
     the above will be recognized before a new token is started.
     When the suffix is present, the literal type is determined as follows:
     -------------------------------------
     | suffix           | type           |
     -------------------------------------
     | no suffix        | int            |
     | u or U           | uint           |
     | s or S           | int16_t        |
     | both u/U and s/S | uint16_t       |
     -------------------------------------
     A leading unary minus sign (-) is interpreted as an arithmetic
     unary negation, not as part of the constant. Hence, literals themselves
     are always expressed with non-negative syntax, though they could result
     in a negative value."

     Modify subsection 4.1.10 Implicit Conversions to say:
     "In some situations, an expression and its type will be implicitly
      converted to a different type. Such conversion are classified into the
      following types: integral promotions, floating-point promotions,
      integral conversions, floating-point conversions, and
      floating-integral conversions.

      The following table shows allowed integral promotions:
      --------------------------------------------------------
      | Type of    |     Can be implicitly promoted to       |
      | expression |                                         |
      --------------------------------------------------------
      | int16_t    | int, int64_t, uint16_t                  |
      | uint16_t   | uint, uint64_t                          |
      --------------------------------------------------------
      | i16vec2    | ivec2, i64vec2, u64vec2                 |
      | u16vec2    | uvec2, u64vec2                          |
      --------------------------------------------------------
      | i16vec3    | ivec3, i64vec3, u64vec3                 |
      | u16vec3    | uvec3, u64vec3                          |
      --------------------------------------------------------
      | i16vec4    | ivec4, i64vec4, u64vec4                 |
      | u16vec4    | uvec4, u64vec4                          |
      --------------------------------------------------------

       The following table shows allowed integral conversions:
      -------------------------------------------------------------------------
      | Type of    |     Can be implicitly converted to                       |
      | expression |                                                          |
      -------------------------------------------------------------------------
      | int16_t    | uint16_t, uint, uint64_t                                 |
      | i16vec2    | u16vec2, uvec2, u64vec2                                  |
      | i16vec3    | u16vec3, uvec3, u64vec3                                  |
      | i16vec4    | u16vec4, uvec4, u64vec4                                  |
      | uint16_t   | uint, uint64_t                                           |
      | u16vec2    | uvec2, u64vec2                                           |
      | u16vec3    | uvec3, u64vec3                                           |
      | u16vec4    | uvec4, u64vec4                                           |
      | int        | uint, uint64_t                                           |
      -------------------------------------------------------------------------

      The following table shows allowed floating-integral conversions:
      --------------------------------------------------------
      | Type of    |     Can be implicitly converted to      |
      | expression |                                         |
      --------------------------------------------------------
      | int16_t    | double, float16_t, float                |
      | i16vec2    | dvec2, f16vec2, vec2                    |
      | i16vec3    | dvec3, f16vec3, vec3                    |
      | i16vec4    | dvec4, f16vec4, vec4                    |
      | uint16_t   | double, float16_t, float                |
      | u16vec2    | dvec2, f16vec2, vec2                    |
      | u16vec3    | dvec3, f16vec3, vec3                    |
      | u16vec4    | dvec4, f16vec4, vec4                    |
      | int        | float                                   |
      | ivec2      | vec2                                    |
      | ivec3      | vec3                                    |
      | ivec4      | vec4                                    |
      | uint       | float                                   |
      | uvec2      | vec2                                    |
      | uvec3      | vec3                                    |
      | uvec4      | vec4                                    |
      --------------------------------------------------------

      When performing implicit conversion for binary operators, there may be
      multiple data types to which the two operands can be converted. For
      example, when adding an int32_t value to a uint32_t value, both values
      can be implicitly converted to uint32_t, float32_t, and double. In such
      cases conversion happens as defined as follows:
      (Note: In this paragraph vector and matrix types are referred to as
      types derived from scalar types with the same bit width and bit
      interpretation)
        - If either operand has type double or derived from double,
          the other shall be converted to double or derived type.
        - Otherwise, if either operand has type float32_t or derived from
          float32_t, the other shall be converted to float32_t or derived type.
        - Otherwise, if either operand has type float16_t or derived from
          float16_t, the other shall be converted to float16_t or derived type.
        - Otherwise, the integral promotions shall be performed on both
          operands. Then the following rules shall be applied to the promoted
          operands:
           - If both operands have the same type, no further conversion
             is needed.
           - Otherwise, if both operands have signed integer types or both
             have unsigned integer types, the operand with the type of lesser
             integer conversion rank shall be converted to the type of the
             operand with greater rank.
           - Otherwise, if the operand that has unsigned integer type has rank
             greater than or equal to the rank of the type of the other
             operand, the operand with signed integer type shall be converted
             to the type of the operand with unsigned integer type.
           - Otherwise, if the type of the operand with signed integer type can
             represent all of the values of the type of the operand with
             unsigned integer type, the operand with unsigned integer type
             shall be converted to the type of the operand with signed
             integer type.
           - Otherwise, both operands shall be converted to the unsigned
             integer type corresponding to the type of the operand with signed
             integer type.

      The conversions listed in the following subsections are done only as
      indicated by other sections of this specification.

      Every integer type has an integer conversion rank defined as follows:
       - No two signed integer types have the same rank.
       - The rank of a scalar signed integer type shall be greater than the rank
         of any scalar signed integer type with a smaller size.
       - The rank of any vector signed integer type is equal to the rank of the
         base scalar signed integer type.
       - The rank of int64_t shall be greater than the rank of int32_t, which
         shall be greater than the rank of int16_t.
       - The rank of any scalar unsigned integer type shall equal the rank of
         the corresponding scalar signed integer type.
       - The rank of any vector unsigned integer type is equal to the rank of
         the respective scalar unsigned integer type.

Additions to Chapter 5 of the OpenGL Shading Language Specification
(Operators and Expressions)

    Modify Section 5.4.1, Conversion and Scalar Constructors

    (add after first list of constructor examples on p. 97)

    bool(int16_t)       // converts a 16-bit signed integer value to a Boolean
                        // value.
    bool(uint16_t)      // converts a 16-bit unsigned integer value to a Boolean
                        // value.
    double(int16_t)     // converts a 16-bit signed integer value to a double
                        // value.
    double(uint16_t)    // converts a 16-bit unsigned integer value to a double
                        // value.
    float(int16_t)      // converts a 16-bit signed integer value to a float
                        // value.
    float(uint16_t)     // converts a 16-bit unsigned integer value to a float
                        // value.
    float16_t(int16_t)  // converts a 16-bit signed integer value to a 16-bit
                        // float value.
    float16_t(uint16_t) // converts a 16-bit unsigned integer value to a 16-bit
                        // float value.
    int16_t(bool)       // converts a Boolean value to a 16-bit signed integer
                        // value.
    int16_t(double)     // converts a double value to a 16-bit signed integer
                        // value.
    int16_t(float)      // converts a float value to a 16-bit signed integer
                        // value.
    int16_t(float16_t)  // converts a 16-bit float value to a 16-bit signed
                        // integer value.
    int16_t(int64_t)    // converts a 64-bit signed integer value to a 16-bit
                        // signed integer value.
    int16_t(int)        // converts a signed integer value to a 16-bit signed
                        // integer value.
    int16_t(uint)       // converts an unsigned integer value to a 16-bit signed
                        // integer value.
    int16_t(uint16_t)   // converts a 16-bit unsigned integer value to a 16-bit
                        // signed integer value.
    int16_t(uint64_t)   // converts a 64-bit unsigned integer value to a 16-bit
                        // signed integer value.
    int(int16_t)        // converts a 16-bit signed integer value to a signed
                        // integer value.
    int(uint16_t)       // converts a 16-bit unsigned integer value to a signed
                        // integer value.
    int64_t(int16_t)    // converts a 16-bit signed integer value to a 64-bit
                        // signed integer value.
    int64_t(uint16_t)   // converts a 16-bit unsigned integer value to a 64-bit
                        // signed integer value.
    uint16_t(bool)      // converts a Boolean value to a 16-bit unsigned integer
                        // value.
    uint16_t(double)    // converts a double value to a 16-bit unsigned integer
                        // value.
    uint16_t(float)     // converts a float value to a 16-bit unsigned integer
                        // value.
    uint16_t(float16_t) // converts a 16-bit float value to a 16-bit unsigned
                        // integer value.
    uint16_t(int)       // converts a signed integer value to a 16-bit unsigned
                        // integer value.
    uint16_t(int16_t)   // converts a 16-bit signed integer value to a 16-bit
                        // unsigned integer value.
    uint16_t(uint)      // converts an unsigned integer value to a 16-bit unsigned
                        // integer value.
    uint16_t(int64_t)   // converts a 64-bit signed integer value to a 16-bit
                        // unsigned integer value.
    uint16_t(uint64_t)  // converts a 64-bit unsigned integer value to a 16-bit
                        // unsigned integer value.
    uint(int16_t)       // converts a 16-bit signed integer value to an unsigned
                        // integer value.
    uint(uint16_t)      // converts a 16-bit unsigned integer value to an unsigned
                        // integer value.
    uint64_t(int16_t)   // converts a 16-bit signed integer value to a 64-bit
                        // unsigned integer value.
    uint64_t(uint16_t)  // converts a 16-bit unsigned integer value to a 64-bit
                        // unsigned integer value.

   (modify second sentence of first paragraph on p. 98)

    ... is dropped. It is undefined to convert a negative floating-point value
    to an uint or uint16_t.

    (replace third paragraph on p. 98)

    The constructors int(uint) and int16_t(uint16_t) preserve the bit pattern
    in the argument, which will change the argument's value if its sign bit is
    set. The constructor uint(int) and uint16_t(int16_t) preserve the bit
    pattern in the argument, which will change its value if it is negative.


Additions to Chapter 6 of the OpenGL Shading Language Specification
(Statements and Structure)

    Modify Section 6.1, Function Defintions

    (replace second rule in third paragraph on p. 113)

      2. A match involving a conversion from a signed integer, unsigned
         integer, or floating-point type to a similar type having a larger
         number of bits is better than a match involving any other implicit
         conversion.


Additions to Chapter 8 of the OpenGL Shading Language Specification
(Built-in Functions)

    (insert after third sentence of last paragraph on p. 132)

    ... genUType is used as the argument. Where the input arguments (and
    corresponding output) can be int16_t, i16vec2, i16vec3, i16vec4,
    genI16Type is used as the argument. Where the input arguments (and
    corresponding output) can be uint16_t, u16vec2, u16vec3, u16vec4,
    genU16Type is used as the argument.


    Modify Section 8.3, Common Functions

    (add to the table of common functions on p. 136)

    +-------------------------------------------------+----------------------------------------------------+
    | Syntax                                          | Desciption                                         |
    +-------------------------------------------------+----------------------------------------------------+
    | genI16Type abs(genI16Type x)                    | Returns x if x >= 0; otherwise it returns -x.      |
    +-------------------------------------------------+----------------------------------------------------+
    | genI16Type sign(genI16Type x)                   | Returns 1 if x > 0, 0 if x = 0, or -1 if x < 0.    |
    +-------------------------------------------------+----------------------------------------------------+
    | genI16Type min(genI16Type x,                    | Returns y if y < x; otherwise it returns x.        |
    |                genI16Type y)                    |                                                    |
    | genI16Type min(genI16Type x,                    |                                                    |
    |                int16_t y)                       |                                                    |
    | genU16Type min(genU16Type x,                    |                                                    |
    |                genU16Type y)                    |                                                    |
    | genU16Type min(genU16Type x,                    |                                                    |
    |                uint16_t y)                      |                                                    |
    +-------------------------------------------------+----------------------------------------------------+
    | genI16Type max(genI16Type x,                    | Returns y if x < y; otherwise it returns x.        |
    |                genI16Type y)                    |                                                    |
    | genI16Type max(genI16Type x,                    |                                                    |
    |                int16_t y)                       |                                                    |
    | genU16Type max(genU16Type x,                    |                                                    |
    |                genU16Type y)                    |                                                    |
    | genU16Type max(genU16Type x,                    |                                                    |
    |                uint16_t y)                      |                                                    |
    +-------------------------------------------------+----------------------------------------------------+
    | genI16Type clamp(genI16Type x,                  | Returns min(max(x, minVal), maxVal).               |
    |                  genI16Type minVal,             |                                                    |
    |                  genI16Type maxVal)             | Results are undefined if minVal > maxVal.          |
    | genI16Type clamp(genI16Type x,                  |                                                    |
    |                  int16_t minVal,                |                                                    |
    |                  int16_t maxVal)                |                                                    |
    | genU16Type clamp(genU16Type x,                  |                                                    |
    |                  genU16Type minVal,             |                                                    |
    |                  genU16Type maxVal)             |                                                    |
    | genU16Type clamp(genU16Type x,                  |                                                    |
    |                  uint16_t minVal,               |                                                    |
    |                  uint16_t maxVal)               |                                                    |
    +-------------------------------------------------+----------------------------------------------------+
    | genI16Type mix(genI16Type x,                    | Selects which vector each returned component comes |
    |                genI16Type y,                    | from. For a component of a that is false, the      |
    |                genBType a)                      | corresponding component of x is returned. For a    |
    | genU16Type mix(genU16Type x,                    | component of a that is true, the corresponding     |
    |                genU16Type y,                    | component of y is returned.                        |
    |                genBType a)                      |                                                    |
    +-------------------------------------------------+----------------------------------------------------+
    | genI16Type float16BitsToInt16(genF16Type value) | Returns a signed or unsigned 16-bit integer value  |
    | genU16Type float16BitsToUint16(genF16Type value)| representing the encoding of a 16-bit float. The   |
    |                                                 | half floating-point value's bit-level              |
    |                                                 | representation is preserved                        |
    +-------------------------------------------------+----------------------------------------------------+
    | genF16Type int16BitsToFloat16(genI16Type value) | Returns a half-floating point value corresponding  |
    | genF16Type uint16BitsToFloat16(genU16Type value)| to a signed or unsigned 16-bit integer encoding of |
    |                                                 | a 16-bit float. If a NaN is passed in, it will not |
    |                                                 | signal, and the resulting value is unspecified. If |
    |                                                 | an Inf is passed in, the resulting value is the    |
    |                                                 | corresponding Inf.                                 |
    +-------------------------------------------------+----------------------------------------------------+
    | genF16Type frexp(genF16Type x,                  | Splits x into a floating-point significand in the  |
    |                  out genI16Type exp)            | range [0.5, 1.0) and an integral exponent of two,  |
    |                                                 | such that:                                         |
    |                                                 |                                                    |
    |                                                 | x = significand * 2 ** exponent                    |
    |                                                 |                                                    |
    |                                                 | The significand is returned by the function and    |
    |                                                 | the exponent is returned in the parameter exp. For |
    |                                                 | a floating-point value of zero, the significand    |
    |                                                 | and exponent are both zero. For a floating-point   |
    |                                                 | value that is an infinity or is not a number, the  |
    |                                                 | results are undefined.                             |
    |                                                 |                                                    |
    |                                                 | If an implementation supports negative 0,          |
    |                                                 | frexp(-0) should return -0; otherwise it will      |
    |                                                 | return 0.                                          |
    +-------------------------------------------------+----------------------------------------------------+
    | genF16Type ldexp(genF16Type x,                  | Returns x * (2 ** exp).                            |
    |                  genI16Type exp)                |                                                    |
    +-------------------------------------------------+----------------------------------------------------+


    Modify Section 8.4, Floating-Point and Integer Pack and Unpack Functions

    (add to the table of pack and unpack functions on p. 149

    +-----------------------------------+------------------------------------------------------+
    | Syntax                            | Desciption                                           |
    +-----------------------------------+------------------------------------------------------+
    |                                   | Returns an unsigned 32- or 64-bit integer obtained   |
    | int      packInt2x16 (i16vec2 v)  | by packing the components of a two- or               |
    | int64_t  packInt4x16 (i16vec4 v)  | four-component 16-bit signed or unsigned integer     |
    | uint     packUint2x16(u16vec2 v)  | vector, respectively. The first vector component     |
    | uint64_t packUint4x16(u16vec4 v)  | specifies the 16 least significant bits; the         |
    |                                   | last component specifies the 16 most significant     |
    |                                   | bits.                                                |
    +-----------------------------------+------------------------------------------------------+
    |                                   | Returns a signed or unsigned integer vector built    |
    | i16vec2 unpackInt2x16 (int      v)| from a 32- or 64-bit signed or unsigned integer      |
    | i16vec4 unpackInt4x16 (int64_t  v)| scalar, respectively. The first component of the     |
    | u16vec2 unpackUint2x16(uint     v)| vector contains the 16 least significant bits of the |
    | u16vec4 unpackUint4x16(uint64_t v)| input; the last component specifies the 16 most      |
    |                                   | significant bits.                                    |
    |                                   |                                                      |
    +-----------------------------------+------------------------------------------------------+


    Modify Section, 8.7, Vector Relational Functions

    Modify the first table to state:

    +-------------+-----------------------------+
    | Placeholder | Specific Types Allowed      |
    +-------------+-----------------------------+
    | i16vec      | i16vec2, i16vec3, i16vec4   |
    | u16vec      | u16vec2, u16vec3, u16vec4   |
    +-------------+-----------------------------+

    (add to the table of vector relational functions at the bottom of p. 147)

    +-------------------------------------------+-----------------------------------------------+
    | Syntax                                    | Desciption                                    |
    +-------------------------------------------+-----------------------------------------------+
    | bvec lessThan(i16vec x, i16vec y)         | Returns the component-wise compare of x < y.  |
    | bvec lessThan(u16vec x, u16vec y)         |                                               |
    +-------------------------------------------+-----------------------------------------------+
    | bvec lessThanEqual(i16vec x, i16vec y)    | Returns the component-wise compare of x <= y. |
    | bvec lessThanEqual(u16vec x, u16vec y)    |                                               |
    +-------------------------------------------+-----------------------------------------------+
    | bvec greaterThan(i16vec x, i16vec y)      | Returns the component-wise compare of x > y.  |
    | bvec greaterThan(u16vec x, u16vec y)      |                                               |
    +-------------------------------------------+-----------------------------------------------+
    | bvec greaterThanEqual(i16vec x, i16vec y) | Returns the component-wise compare of x >= y. |
    | bvec greaterThanEqual(u16vec x, u16vec y) |                                               |
    +-------------------------------------------+-----------------------------------------------+
    | bvec equal(i16vec x, i16vec y)            | Returns the component-wise compare of x == y. |
    | bvec equal(u16vec x, u16vec y)            |                                               |
    +-------------------------------------------+-----------------------------------------------+
    | bvec notEqual(i16vec x, i16vec y)         | Returns the component-wise compare of x != y. |
    | bvec notEqual(u16vec x, u16vec y)         |                                               |
    +-------------------------------------------+-----------------------------------------------+


    Modify language in the Overview section of GL_KHR_vulkan_glsl

    Replace the following sentence:

    The constant_id can only be applied to a scalar *int*, a scalar *float*
    or a scalar *bool*.

    with:

    The constant_id can only be applied to a scalar *int* (incl. 16-bit signed
    and unsigned integers), a scalar *float* or a scalar *bool*.


Dependencies on AMD_gpu_shader_half_float

    If the shader enables only AMD_gpu_shader_int16, but not AMD_gpu_shader_half_float
    then:

    * the table describing floating-integral conversions is discarded.
    * the float16BitsTo{Int, Uint}16(), {int, uint}16BitsToFloat16(), frexp()
      and ldexp() functions are unavailable.


Dependencies on ARB_gpu_shader_int64:

    If the shader enables only AMD_gpu_shader_int16, but not ARB_gpu_shader_int64
    then:
    
    * all references to int64_t and uint64_t should be ignored.

Dependencies on KHR_vulkan_glsl:

    If the shader only enables AMD_gpu_shader_int16, but not KHR_vulkan_glsl,
    then any changes to the language of the latter specification should be discarded.

Dependencies on AMD_shader_trinary_minmax

    If the shader enables AMD_shader_trinary_minmax, this extension adds
    additional common functions.

    Modify Section 8.3, Common Functions

    (add to the table of common functions on p. 144)

    +-------------------------------------------+-----------------------------------------------+
    | Syntax                                    | Description                                   |
    +-------------------------------------------+-----------------------------------------------+
    | genI16Type min3(genI16Type x,             | Returns the per-component minimum value of x, |
    |                 genI16Type y,             | y, and z.                                     |
    |                 genI16Type z)             |                                               |
    | genU16Type min3(genU16Type x,             |                                               |
    |                 genU16Type y,             |                                               |
    |                 genU16Type z)             |                                               |
    +-------------------------------------------+-----------------------------------------------+
    | genI16Type max3(genI16Type x,             | Returns the per-component maximum value of x, |
    |                 genI16Type y,             | y, and z.                                     |
    |                 genI16Type z)             |                                               |
    | genU16Type max3(genU16Type x,             |                                               |
    |                 genU16Type y,             |                                               |
    |                 genU16Type z)             |                                               |
    +-------------------------------------------+-----------------------------------------------+
    | genI16Type mid3(genI16Type x,             | Returns the per-component median value of x,  |
    |                 genI16Type y,             | y, and z.                                     |
    |                 genI16Type z)             |                                               |
    | genU16Type mid3(genU16Type x,             |                                               |
    |                 genU16Type y,             |                                               |
    |                 genU16Type z)             |                                               |
    +-------------------------------------------+-----------------------------------------------+

Errors

    None.

New State

    None.

New Implementation Dependent State

    None.

Issues

    (1) Should the new int16_t and uint16_t types support types as members of
        uniform blocks and shader storage buffer blocks?
        
    RESOLVED: Yes, both types can be used in both SSBOs and UBOs, each consuming
              2 basic machine units.


    (2) Should we support int16_t and uint16_t types as members of uniform blocks,
        shader storage buffer blocks, or as transform feedback varyings?

      RESOLVED: Yes, support all of them. both types  consume two basic machine
      units. Some examples:

          struct S {

              uint16_t   x;     // rule 1:  align = 2, takes offsets 0-1
              u16vec2    y;     // rule 2:  align = 4, takes offsets 4-7
              u16vec3    z;     // rule 3:  align = 8, takes offsets 8-13
          };

          layout(std140) uniform B1 {

              uint16_t   a;     // rule 1:  align = 2, takes offsets 0-1
              u16vec2    b;     // rule 2:  align = 4, takes offsets 4-7
              u16vec3    c;     // rule 3:  align = 8, takes offsets 8-13
              uint16_t   d[2];  // rule 4:  align = 16, array stride = 16,
                                //          takes offsets 16-47
              S          g;     // rule 9:  align = 16, g.x takes offsets
                                //          48-49, g.y takes offsets 52-55,
                                //          g.z takes offsets 56-63
              S          h[2];  // rule 10: align = 16, array stride = 16, h[0]
                                //          takes offsets 64-77, h[1] takes
                                //          offsets 78-93
          };

          layout(std430) buffer B2 {

              uint16_t   o;     // rule 1:  align = 2, takes offsets 0-1
              u16vec2    p;     // rule 2:  align = 4, takes offsets 4-7
              u16vec3    q;     // rule 3:  align = 8, takes offsets 8-13
              uint16_t   r[2];  // rule 4:  align = 2, array stride = 2, takes
                                //          offsets 14-17
              S          u;     // rule 9:  align = 8, u.x takes offsets
                                //          24-25, u.y takes offsets 28-31, u.z
                                //          takes offsets 32-37
              S          v[2];  // rule 10: align = 8, array stride = 16, v[0]
                                //          takes offsets 40-55, v[1] takes
                                //          offsets 56-71
          };
          
    (3) Are interactions with GL_AMD_shader_ballot supported?
    (4) Are interactions with GL_AMD_shader_explicit_vertex_parameter supported?
    (5) Are interactions with GL_AMD_shader_trinary_minmax supported?
    
    RESOLVED: Not yet. These will be resolved at a later time.

    (6) Does this extension provide a new subpassLoad() function prototype which
        returns a(n) {u}int16 vector value?

    RESOLVED: No. This functionality may be added at a later time in a separate
              extension.

    (7) Can the new int16 and uint16 types be used as array indexes?

    RESOLVED: No.


Revision History

    Rev.    Date      Author    Changes
    ----  --------    --------  -----------------------------------------
    2     03/28/2018  rexu      Add interactions with AMD_shader_trinary_minmax.
                                New common functions are added to support
                                16-bit integer type in these trinary operations.

    1     06/08/2017  dwitczak  First release.