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

Name

    AMD_gpu_shader_int64

Name Strings

    GL_AMD_gpu_shader_int64

Contact

    Daniel Rakos, AMD (daniel.rakos 'at' amd.com)

Contributors

    Daniel Rakos, AMD
    Graham Sellers, AMD

Status

    Shipping

Version

    Last Modified Date:         07/07/2014
    Author Revision:            3

Number

    OpenGL Extension #451

Dependencies

    This extension is written against the OpenGL 4.4 (Core Profile)
    Specification.

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

    OpenGL 4.0 and GLSL 4.00 are required.

    This extension interacts with NV_gpu_shader5.

    This extension interacts with NV_shader_buffer_load.

    This extension interacts with EXT_direct_state_access.

    This extension interacts with NV_vertex_attrib_integer_64bit.

    This extension interacts with EXT_shader_integer_mix.

Overview

    This extension was developed based on the NV_gpu_shader5 extension to
    allow implementations supporting 64-bit integers to expose the feature
    without the additional requirements that are present in NV_gpu_shader5.

    The extension introduces the following features for all shader types:

      * support for 64-bit scalar and vector integer data types, including
        uniform API, uniform buffer object, transform feedback, and shader
        input and output support;

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

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

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

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

    This extension is designed to be a functional superset of the 64-bit
    integer support introduced by NV_gpu_shader5 and to be source code
    compatible with that, thus the new procedures, functions, and tokens
    are identical to those found in that extension.


New Procedures and Functions

    (The functions are identical to those defined in NV_gpu_shader5.)

    void Uniform1i64NV(int location, int64EXT x);
    void Uniform2i64NV(int location, int64EXT x, int64EXT y);
    void Uniform3i64NV(int location, int64EXT x, int64EXT y, int64EXT z);
    void Uniform4i64NV(int location, int64EXT x, int64EXT y, int64EXT z,
                       int64EXT w);
    void Uniform1i64vNV(int location, sizei count, const int64EXT *value);
    void Uniform2i64vNV(int location, sizei count, const int64EXT *value);
    void Uniform3i64vNV(int location, sizei count, const int64EXT *value);
    void Uniform4i64vNV(int location, sizei count, const int64EXT *value);

    void Uniform1ui64NV(int location, uint64EXT x);
    void Uniform2ui64NV(int location, uint64EXT x, uint64EXT y);
    void Uniform3ui64NV(int location, uint64EXT x, uint64EXT y, uint64EXT z);
    void Uniform4ui64NV(int location, uint64EXT x, uint64EXT y, uint64EXT z,
                       uint64EXT w);
    void Uniform1ui64vNV(int location, sizei count, const uint64EXT *value);
    void Uniform2ui64vNV(int location, sizei count, const uint64EXT *value);
    void Uniform3ui64vNV(int location, sizei count, const uint64EXT *value);
    void Uniform4ui64vNV(int location, sizei count, const uint64EXT *value);

    void GetUniformi64vNV(uint program, int location, int64EXT *params);


    (The following function is also provided by NV_shader_buffer_load.)

    void GetUniformui64vNV(uint program, int location, uint64EXT *params);


    (All of the following ProgramUniform* functions are supported if and only
     if EXT_direct_state_access is supported.)

    void ProgramUniform1i64NV(uint program, int location, int64EXT x);
    void ProgramUniform2i64NV(uint program, int location, int64EXT x,
                              int64EXT y);
    void ProgramUniform3i64NV(uint program, int location, int64EXT x, 
                              int64EXT y, int64EXT z);
    void ProgramUniform4i64NV(uint program, int location, int64EXT x, 
                              int64EXT y, int64EXT z, int64EXT w);
    void ProgramUniform1i64vNV(uint program, int location, sizei count,
                               const int64EXT *value);
    void ProgramUniform2i64vNV(uint program, int location, sizei count,
                               const int64EXT *value);
    void ProgramUniform3i64vNV(uint program, int location, sizei count,
                               const int64EXT *value);
    void ProgramUniform4i64vNV(uint program, int location, sizei count,
                               const int64EXT *value);

    void ProgramUniform1ui64NV(uint program, int location, uint64EXT x);
    void ProgramUniform2ui64NV(uint program, int location, uint64EXT x, 
                               uint64EXT y);
    void ProgramUniform3ui64NV(uint program, int location, uint64EXT x, 
                               uint64EXT y, uint64EXT z);
    void ProgramUniform4ui64NV(uint program, int location, uint64EXT x, 
                               uint64EXT y, uint64EXT z, uint64EXT w);
    void ProgramUniform1ui64vNV(uint program, int location, sizei count,
                                const uint64EXT *value);
    void ProgramUniform2ui64vNV(uint program, int location, sizei count,
                                const uint64EXT *value);
    void ProgramUniform3ui64vNV(uint program, int location, sizei count,
                                const uint64EXT *value);
    void ProgramUniform4ui64vNV(uint program, int location, sizei count, 
                                const uint64EXT *value);


New Tokens

    Returned by the <type> parameter of GetActiveAttrib, GetActiveUniform, and
    GetTransformFeedbackVarying:

    (The tokens are identical to those defined in NV_gpu_shader5.)

        INT64_NV                                        0x140E
        UNSIGNED_INT64_NV                               0x140F

        INT8_NV                                         0x8FE0
        INT8_VEC2_NV                                    0x8FE1
        INT8_VEC3_NV                                    0x8FE2
        INT8_VEC4_NV                                    0x8FE3
        INT16_NV                                        0x8FE4
        INT16_VEC2_NV                                   0x8FE5
        INT16_VEC3_NV                                   0x8FE6
        INT16_VEC4_NV                                   0x8FE7
        INT64_VEC2_NV                                   0x8FE9
        INT64_VEC3_NV                                   0x8FEA
        INT64_VEC4_NV                                   0x8FEB
        UNSIGNED_INT8_NV                                0x8FEC
        UNSIGNED_INT8_VEC2_NV                           0x8FED
        UNSIGNED_INT8_VEC3_NV                           0x8FEE
        UNSIGNED_INT8_VEC4_NV                           0x8FEF
        UNSIGNED_INT16_NV                               0x8FF0
        UNSIGNED_INT16_VEC2_NV                          0x8FF1
        UNSIGNED_INT16_VEC3_NV                          0x8FF2
        UNSIGNED_INT16_VEC4_NV                          0x8FF3
        UNSIGNED_INT64_VEC2_NV                          0x8FF5
        UNSIGNED_INT64_VEC3_NV                          0x8FF6
        UNSIGNED_INT64_VEC4_NV                          0x8FF7
        FLOAT16_NV                                      0x8FF8
        FLOAT16_VEC2_NV                                 0x8FF9
        FLOAT16_VEC3_NV                                 0x8FFA
        FLOAT16_VEC4_NV                                 0x8FFB


Additions to Chapter 7 of the OpenGL 4.4 (Core Profile) Specification
(Program Objects)

    Modify Section 7.3.1, Program Interfaces

    (add to Table 7.3, OpenGL Shading Language type tokens, p. 107)

    +----------------------------+--------------+--------+--------+--------+
    | Type Name Token            | Keyword      | Attrib |  Xfb   | Buffer |
    +----------------------------+--------------+--------+--------+--------+
    | INT64_NV                   | int64_t      |   *    |   *    |   *    |
    | INT64_VEC2_NV              | i64vec2      |   *    |   *    |   *    |
    | INT64_VEC3_NV              | i64vec3      |   *    |   *    |   *    |
    | INT64_VEC4_NV              | i64vec4      |   *    |   *    |   *    |
    | UNSIGNED_INT64_NV          | uint64_t     |   *    |   *    |   *    |
    | UNSIGNED_INT64_VEC2_NV     | u64vec2      |   *    |   *    |   *    |
    | UNSIGNED_INT64_VEC3_NV     | u64vec3      |   *    |   *    |   *    |
    | UNSIGNED_INT64_VEC4_NV     | u64vec4      |   *    |   *    |   *    |
    +----------------------------+--------------+--------+--------+--------+

    Modify Section 7.6, Uniform Variables

    (modify second paragraph on p. 120)

        Scalar, vector, and matrix uniforms with double-precision components,
    and scalar and vector uniforms with 64-bit integer components will consume
    no more than twice the number of components of equivalent uniforms with
    single-precision components.


    Modify Section 7.6.1, Loading Uniform Variables

    (add to the list of commands in first paragraph on p. 125)

      void Uniform{1,2,3,4}{i64,ui64}NV(int location, T value);
      void Uniform{1,2,3,4}{i64,ui64}vNV(int location, T value);

    (insert after third paragraph on p. 127)

      The Uniform*i64{v}NV and Uniform*ui{v}NV commands will load count sets
    of one to four 64-bit signed or unsigned integer values into a uniform
    location defined as a 64-bit signed or unsigned integer scalar or vector
    types.


    Modify Section 7.6.2.1, Uniform Buffer Object Storage

    (modify the first two bullets of the first paragraph on p. 130)

      * Members of type bool int, uint, float, double, int64_t, and uint64_t
        are respectively extracted from a buffer object by reading a single
        uint, int, uint, float, double, int64_t, or uint64_t value at the
        specified offset.

      * Vectors with N elements with basic data types of bool, int, uint,
        float, double, int64_t, or uint64_t are extracted as N values in
        consecutive memory locations beginning at the specified offset, with
        components stored in order with the first (X) component at the
        lowest offset. The GL data type used for component extraction is
        derived according to the rules for scalar members above.


    Modify Section 7.13, Shader, Program, and Program Pipeline Queries

    (add to the list of commands in last paragraph on p. 155)

      void GetUniformi64vNV(uint program, int location, int64* params)
      void GetUniformui64vNV(uint program, int location, uint64* params)


Additions to Chapter 11 of the OpenGL 4.4 (Core Profile) Specification
(Programmable Vertex Processing)

    Modify Section 11.1.1, Vertex Attributes

    (modify third sentence of second paragraph on p. 344)

    ... hardware resources. For the purposes of this test, attribute variables
    of the type dvec3, dvec4, dmat2x3, dmat2x3, dmat3, dmat3x4, dmat4x3,
    dmat4, i64vec3, i64vec4, u64vec3, and u64vec4 may count as consuming twice
    as many attributes as equivalent single-precision types. While these types
    use the same number of generic attributes as their single-precision
    vectors of internal storage for each three- or four-component
    double-precision or 64-bit integer vector.


    Modify Section 11.1.2.1, Output Variables

    (modify last sentence of fourth paragraph on p. 345)

    ... multiple components. Each component of variables declared as double-
    precision floating point scalars, vectors, or matrices, or declared as
    64-bit integer scalars or vectors may be counted as consuming two
    components.

    (modify third bullet of the first paragraph on p. 349)

      * any variable containing double-precision floating-point or 64-bit
        integer components

        - has an xfb_offset layout qualifier that is not a multiple of eight;
          or
        - is associated with a binding point with an xfb_stride layout
          qualifier that is not a multiple of eight;

    (modify second paragraph on p. 349)

      For transform feedback purposes, each component of outputs declared as
    double-precision floating-point scalars, vectors, or matrices, or 64-bit
    integer scalars or vectors are considered to consume eight basic machine
    units, and each component of any other type is considered to consume four
    basic machine units.


Modifications to the OpenGL Shading Language Specification, Version 4.40

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

      #extension GL_AMD_gpu_shader_int64 : <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_int64       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. 15)

    int64_t  i64vec2  i64vec3  i64vec4  uint64_t  u64vec2  u64vec3  u64vec4


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                                                    |
    +-----------+------------------------------------------------------------+
    | int64_t   | a 64-bit signed integer                                    |
    | uint64_t  | a 64-bit unsigned integer                                  |
    | i64vec2   | a two-component 64-bit signed integer vector               |
    | i64vec3   | a three-component 64-bit signed integer vector             |
    | i64vec4   | a four-component 64-bit signed integer vector              |
    | u64vec2   | a two-component 64-bit unsigned integer vector             |
    | u64vec3   | a three-component 64-bit unsigned integer vector           |
    | u64vec4   | a four-component 64-bit unsigned integer vector            |
    +-----------+------------------------------------------------------------+


    Modify Section 4.1.3, Integers

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

    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 32-bit and 64-bit integers. Unsigned
    integers of type uint, uvec2, uvec3, and uvec4 have exactly 32 bits of
    precision, while unsigned integers of type uint64_t, u64vec2, u64vec3, and
    u64vec4 have exactly 64 bits of precision. Signed integers of type int,
    ivec2, ivec3, and ivec4 have exactly 32 bits of precision, while signed
    integers of type int64_t, i64vec2, i64vec3, and i64vec4 have exactly
    64 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.

    (add after the first paragraph of the section, p. 23)

    Variables with the types "int64_t" and "uint64_t" represent signed and
    unsigned integer values, respectively, with exactly 64 bits of precision.

    (modify grammar rule for "integer-suffix", p. 24)

      integer-suffix: one of
        u U l L ul UL

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

    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 suffix u, U, l, L, ul, or UL.

    (modify third sentence of second paragraph on p. 24)

    When the suffix u or U is present, the literal has type uint. When the
    suffix l or L is present, the literal has type int64_t. When the suffix
    ul or UL is present, the literal has type uint64_t. Otherwise, the type is
    int.


    Modify Section 4.1.10, Implicit Conversions

    (modify table of implicit conversions on p. 33)

    +----------------------+-------------------------------------------------+
    | Type of expression   | Can be implicitly converted to                  |
    +----------------------+-------------------------------------------------+
    | int                  | uint, int64_t, uint64_t, float, double          |
    | uint                 | uint64_t, float, double                         |
    | int64_t              | uint64_t, double                                |
    | uint64_t             | double                                          |
    | ivec2                | uvec2, i64vec2, u64vec2, vec2, dvec2            |
    | ivec3                | uvec3, i64vec3, u64vec3, vec3, dvec3            |
    | ivec4                | uvec4, i64vec4, u64vec4, vec4, dvec4            |
    | uvec2                | u64vec2, vec2, dvec2                            |
    | uvec3                | u64vec3, vec3, dvec3                            |
    | uvec4                | u64vec4, vec4, dvec4                            |
    | i64vec2              | u64vec2, dvec2                                  |
    | i64vec3              | u64vec3, dvec3                                  |
    | i64vec4              | u64vec4, dvec4                                  |
    | u64vec2              | dvec2                                           |
    | u64vec3              | dvec3                                           |
    | u64vec4              | dvec4                                           |
    +----------------------+-------------------------------------------------+


    Modify Section 4.3.6, Output Variables

    (modify third and fourth sentence of second paragraph on p. 46)

    ... in a fragment shader. Fragment outputs can only be float, single-
    precision floating-point vectors, signed or unsigned 32-bit integer
    vectors, or arrays of any these. It is a compile-time error to declare any
    double-precision type, 64-bit integer type, matrix, or structure as an
    output.


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. 91)

      int64_t(double) // converts a double value to a 64-bit signed integer
      uint64_t(bool)  // converts a Boolean value to a 64-bit unsigned integer

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

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

    (replace third paragraph on p. 92)

    The constructors int(uint) and int64_t(uint64_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 uint64_t(int64_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. 106)

      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 int64_t, i64vec2, i64vec3, i64vec4,
    genI64Type is used as the argument. Where the input arguments (and
    corresponding output) can be uint64_t, u64vec2, u64vec3, u64vec4,
    genU64Type is used as the argument.


    Modify Section 8.3, Common Functions

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

    +------------------------------------------------+----------------------------------------------------+
    | Syntax                                         | Desciption                                         |
    +------------------------------------------------+----------------------------------------------------+
    | genI64Type abs(genI64Type x)                   | Returns x if x >= 0; otherwise it returns -x.      |
    +------------------------------------------------+----------------------------------------------------+
    | genI64Type sign(genI64Type x)                  | Returns 1 if x > 0, 0 if x = 0, or -1 if x < 0.    |
    +------------------------------------------------+----------------------------------------------------+
    | genI64Type min(genI64Type x,                   | Returns y if y < x; otherwise it returns x.        |
    |                genI64Type y)                   |                                                    |
    | genI64Type min(genI64Type x,                   |                                                    |
    |                int64_t y)                      |                                                    |
    | genU64Type min(genU64Type x,                   |                                                    |
    |                genU64Type y)                   |                                                    |
    | genU64Type min(genU64Type x,                   |                                                    |
    |                uint64_t y)                     |                                                    |
    +------------------------------------------------+----------------------------------------------------+
    | genI64Type max(genI64Type x,                   | Returns y if x < y; otherwise it returns x.        |
    |                genI64Type y)                   |                                                    |
    | genI64Type max(genI64Type x,                   |                                                    |
    |                int64_t y)                      |                                                    |
    | genU64Type max(genU64Type x,                   |                                                    |
    |                genU64Type y)                   |                                                    |
    | genU64Type max(genU64Type x,                   |                                                    |
    |                uint64_t y)                     |                                                    |
    +------------------------------------------------+----------------------------------------------------+
    | genI64Type clamp(genI64Type x,                 | Returns min(max(x, minVal), maxVal).               |
    |                  genI64Type minVal,            |                                                    |
    |                  genI64Type maxVal)            | Results are undefined if minVal > maxVal.          |
    | genI64Type clamp(genI64Type x,                 |                                                    |
    |                  int64_t minVal,               |                                                    |
    |                  int64_t maxVal)               |                                                    |
    | genU64Type clamp(genU64Type x,                 |                                                    |
    |                  genU64Type minVal,            |                                                    |
    |                  genU64Type maxVal)            |                                                    |
    | genU64Type clamp(genU64Type x,                 |                                                    |
    |                  uint64_t minVal,              |                                                    |
    |                  uint64_t maxVal)              |                                                    |
    +------------------------------------------------+----------------------------------------------------+
    | genI64Type mix(genI64Type x,                   | Selects which vector each returned component comes |
    |                genI64Type y,                   | from. For a component of a that is false, the      |
    |                genBType a)                     | corresponding component of x is returned. For a    |
    | genU64Type mix(genU64Type x,                   | component of a that is true, the corresponding     |
    |                genU64Type y,                   | component of y is returned.                        |
    |                genBType a)                     |                                                    |
    +------------------------------------------------+----------------------------------------------------+
    | genI64Type doubleBitsToInt64(genDType value)   | Returns a signed or unsigned 64-bit integer value  |
    | genU64Type doubleBitsToUint64(genDType value)  | representing the encoding of a double. The double  |
    |                                                | value's bit-level representation is preserved      |
    +------------------------------------------------+----------------------------------------------------+
    | genDType int64BitsToDouble(genI64Type value)   | Returns a double value corresponding to a signed   |
    | genDType uint64BitsToDouble(genU64Type value)  | or unsigned integer encoding of a double. 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.                                 |
    +------------------------------------------------+----------------------------------------------------+


    Rename Section 8.4, Floating-Point Pack and Unpack Functions to
    8.4, Floating-Point and Integer Pack and Unpack Functions


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

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

    +-----------------------------------+------------------------------------------------------+
    | Syntax                            | Desciption                                           |
    +-----------------------------------+------------------------------------------------------+
    | int64_t packInt2x32(ivec2 v)      | Returns a signed or unsigned 64-bit integer obtained |
    | uint64_t packUint2x32(uvec2 v)    | by packing the components of a two-component signed  |
    |                                   | or unsigned integer vector, respectively. The first  |
    |                                   | vector component specifies the 32 least significant  |
    |                                   | bits; the second component specifies the 32 most     |
    |                                   | significant bits.                                    |
    +-----------------------------------+------------------------------------------------------+
    | ivec2 unpackInt2x32(int64_t v)    | Returns a signed or unsigned integer vector built    |
    | uvec2 unpackUint2x32(uint64_t v)  | from a 64-bit signed or unsigned integer scalar,     |
    |                                   | respectively. The first component of the vector      |
    |                                   | contains the 32 least significant bits of the input; |
    |                                   | the second component contains the 32 most            |
    |                                   | significant bits.                                    |
    +-----------------------------------+------------------------------------------------------+


    Modify Section, 8.7, Vector Relational Functions

    (add to the table of placeholders at the top of p. 147)

    +-------------+-----------------------------+
    | Placeholder | Specific Types Allowed      |
    +-------------+-----------------------------+
    | i64vec      | i64vec2, i64vec3, i64vec4   |
    | u64vec      | u64vec2, u64vec3, u64vec4   |
    +-------------+-----------------------------+

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

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


    Modify Section 9, Shading Language Grammar for Core Profile

    (add to the list of tokens on p. 180)

      ...
      INT64 UINT64 I64VEC2 I64VEC3 I64VEC4 U64VEC2 U64VEC3 U64VEC4
      ...
      INT64CONSTANT UINT64CONSTANT

    (add to the rule of "primary_expression" on p. 181)

      primary_expression:
        ...
        INT64CONSTANT
        UINT64CONSTANT
        ...

    (add to the rule of "type_specifier_nonarray" on p. 188)

      type_specifier_nonarray:
        ...
        INT64
        UINT64
        ...
        I64VEC2
        I64VEC3
        I64VEC4
        U64VEC2
        U64VEC3
        U64VEC4
        ...


Dependencies on NV_gpu_shader5

    If the shader enables only NV_gpu_shader5, but not AMD_gpu_shader_int64
    then implicit conversions from int and uint types to int64_t and uint64_t
    types are not allowed. Also, the overloaded built-in functions abs,
    sign, min, max, clamp, and mix are not available.


Dependencies on NV_shader_buffer_load

    If NV_shader_buffer_load is supported, that specification should be edited
    as follows, to allow pointers to dereference the new data types added by
    this extension.

    Modify "Section 2.20.X, Shader Memory Access" from NV_shader_buffer_load.

    (add rules for loads of variables having the new data types from this
    extension to the list of bullets following "When a shader dereferences a
    pointer variable")

    - Data of type int64_t and uint64_t are read from or written to memory as
      a signel 64-bit signed and unsigned integer value, respectively, at the
      specified GPU address.


Dependencies on EXT_direct_state_access

    If EXT_direct_state_access is supported, that specification should be
    edited as follows to include new ProgramUniform* functions.

    (add to the list of ProgramUniform* commands)

        void ProgramUniform{1,2,3,4}{i64,ui64}NV
            (uint program int location, T value);
        void ProgramUniform{1,2,3,4}{i64,ui64}vNV
            (uint program, int location, const T *value);

Dependencies on NV_vertex_attrib_integer_64bit

    This extension only provides the ability to specify 64-bit integer input
    variables in a GLSL vertex shader, but does not provide a way to specify
    the values of the corresponding vertex attributes via the OpenGL API.
    The NV_vertex_attrib_integer_64bit extension exactly provides that
    functionality.


Dependencies on EXT_shader_integer_mix

    If EXT_shader_integer_mix is not supported remove all references to the
    new overloaded built-in functions of mix.


Errors

    None.

New State

    None.

New Implementation Dependent State

    None.

Issues

    (1) How the functionality in this extension different than the 64-bit
        integer support introduced by NV_gpu_shader5?

      RESOLVED: This extension is designed to be source code compatible with
      the 64-bit integer support in NV_gpu_shader5. However, it is a
      functional superset of that, as it adds the following additional
      features:

        * support for overloaded versions of the functions abs, sign, min,
          max, clamp, and mix that accept 64-bit integers as parameters.

    (2) How do the implicit conversions impact binary operators?

      RESOLVED: For binary operators, we prefer converting to a common type
      that is as close as possible in size and type to the original
      expression.

    (3) How do the implicit conversions impact function overloading rules?

      RESOLVED: We extend the preference rules in core OpenGL to account
      for the new data types, adding a rule to favor conversion from 32-bit
      integers to 64-bit integers over coversions to floating-point values.

    (4) What should be done to distinguish between 32- and 64-bit integer
        constants?

      RESOLVED: We will use "L" and "UL" to identify signed and unsigned
      64-bit integer constants; the use of "L" matches a similar ("long")
      suffix in the C programming language.  C leaves the size of integer
      types implementation-dependent, and many implementations require an "LL"
      suffix to declare 64-bit integer constants.  With our size definitions,
      "L" will be considered sufficient to make an integer constant 64-bit.

    (5) Should provide support for vertex attributes with 64-bit components,
        and if so, how should the support be provided in the OpenGL API?

      RESOLVED: Yes, but in order to specify 64-bit vertex attribute values
      in the OpenGL API support for NV_vertex_attrib_integer_64bit or a
      similar extension is also required.

    (6) Should we support 64-bit integer uniforms in the default uniform
        block?

      DISCUSSION: There isn't much value in extending the standalone uniform
      API, as uniform buffers provide a way more efficient way to feed
      uniforms to the shaders, but in order to achieve feature parity with
      the 64-bit integer support in NV_gpu_shader5 it might be favorable to
      add support for it.

      RESOLVED: Yes, for compatibility with NV_gpu_shader5.

    (7) Should we support 64-bit integer types as members of uniform blocks,
        shader storage buffer blocks, or as transform feedback varyings?

      RESOLVED: Yes, support all of them. 64-bit integers will consume eight
      basic machine units just like double-precision floating-point variables.

    (8) How do the uniform loading commands introduced by this extension
        interact similar commands added by NV_shader_buffer_load?

      RESOLVED: NV_shader_buffer_load provided the command Uniformui64NV to
      load pointer uniforms with a single 64-bit unsigned integer.  This
      extension provides vectors of 64-bit unsigned integers, so we needed
      Uniform{2,3,4}ui64NV commands.  We chose to provide a Uniform1ui64NV
      command, which will be functionally equivalent to Uniformui64NV.

    (9) Should we provide distinct sized types for 32-bit integers, floats,
        and doubles?

      RESOLVED: No. While NV_gpu_shader5 does add such types, it seems there
      isn't much value in adding those in this extension, especially because
      this extension strictly focuses on supporting 64-bit integers.

    (10) Can the 64-bit uniform APIs be used to load values for uniforms of
         type "bool", "bvec2", "bvec3", or "bvec4"?

      RESOLVED: No. OpenGL 2.0 and beyond did allow "bool" variable to be
      set with Uniform*i* and Uniform*f APIs, and OpenGL 3.0 extended that
      support to Uniform*ui* for orthogonality.  But it seems pointless to
      extended this capability forward to 64-bit Uniform APIs as well.

    (11) There exists both an UNSIGNED_INT64_AMD and UNSIGNED_INT64_NV token
         with different values (the former existed earlier) so which one
         this extension should use?

      DISCUSSION: No functions in this extension accept these values as
      inputs, they only should return one of these in various scenarios.

      RESOLVED: This extension will return the value of UNSIGNED_INT64_NV to
      stay source code compatible with NV_gpu_shader5. However, future
      extensions that should accept any of these tokens as inputs should
      accept both of them.

Revision History

    Rev.    Date    Author    Changes
    ----  --------  --------  -------------------------------------------------
     3    07/07/14  drakos    Fixed inconsistency in implicit conversion rules.
     2    31/04/14  gsellers  Ready to post.
     1    10/09/13  drakos    Initial revision.