Name ARB_shading_language_packing Name Strings GL_ARB_shading_language_packing Contact Pat Brown, NVIDIA Corporation (pbrown 'at' nvidia.com) Contributors Barthold Lichtenbelt, NVIDIA Chris Dodd, NVIDIA Daniel Koch, Transgaming Eric Werness, NVIDIA Greg Roth, NVIDIA Jeff Bolz, NVIDIA Piers Daniell, NVIDIA Notice Copyright (c) 2011-2013 The Khronos Group Inc. Copyright terms at http://www.khronos.org/registry/speccopyright.html Specification Update Policy Khronos-approved extension specifications are updated in response to issues and bugs prioritized by the Khronos OpenGL Working Group. For extensions which have been promoted to a core Specification, fixes will first appear in the latest version of that core Specification, and will eventually be backported to the extension document. This policy is described in more detail at https://www.khronos.org/registry/OpenGL/docs/update_policy.php Status Complete. Approved by the ARB on 2011/06/20. Approved by the Khronos Promoters on 2011/07/29. Version Last Modified Date: 06/13/2011 Revision: 5 Number ARB Extension #116 Dependencies This extension is written against version 4.1 (revision 09) of the OpenGL Shading Language Specification. Overview This extension provides the GLSL built-in functions to convert a 32-bit unsigned integer holding a pair of 16-bit floating-point values to or from a two-component floating-point vector (vec2). This mechanism allows GLSL shaders to read and write 16-bit floating-point encodings (via 32-bit unsigned integers) without introducing a full set of 16-bit floating-point data types. This extension also adds the GLSL built-in packing functions included in GLSL version 4.00 and the ARB_gpu_shader5 extension which pack and unpack vectors of small fixed-point data types into a larger scalar. By putting these packing functions in this separate extension it allows implementations to provide these functions in hardware that supports them independent of the other ARB_gpu_shader5 features. In addition to the packing functions from ARB_gpu_shader5 this extension also adds the missing [un]packSnorm2x16 for completeness. New Procedures and Functions None. New Tokens None. Modifications to the OpenGL API Specification None. Modifications to The OpenGL Shading Language Specification, Version 4.10 (Revision 6) Including the following line in a shader can be used to control the language features described in this extension: #extension GL_ARB_shading_language_packing : where is as specified in section 3.3. New preprocessor #defines are added to the OpenGL Shading Language: #define GL_ARB_shading_language_packing 1 Modify Section 8.4, Floating-Point Pack and Unpack Functions (add support for general packing functions) Syntax: uint packUnorm2x16(vec2 v); uint packSnorm2x16(vec2 v); uint packUnorm4x8(vec4 v); uint packSnorm4x8(vec4 v); vec2 unpackUnorm2x16(uint v); vec2 unpackSnorm2x16(uint v); vec4 unpackUnorm4x8(uint v); vec4 unpackSnorm4x8(uint v); The functions packUnorm2x16(), packSnorm2x16(), packUnorm4x8(), and packSnorm4x8() first convert each component of a two- or four-component vector of normalized floating-point values into 8- or 16-bit integer values. Then, the results are packed into a 32-bit unsigned integer. The first component of the vector will be written to the least significant bits of the output; the last component will be written to the most significant bits. The functions unpackUnorm2x16(), unpackSnorm2x16(), unpackUnorm4x8(), and unpackSnorm4x8() first unpacks a single 32-bit unsigned integer into a pair of 16-bit unsigned integers, a pair of 16-bit signed integers, four 8-bit unsigned integers, or four 8-bit signed integers. Then, each component is converted to a normalized floating-point value to generate a two- or four-component vector. The first component of the vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits. The conversion between fixed- and normalized floating-point values will be performed as below. function conversion --------------- ----------------------------------------------------- packUnorm2x16 fixed_val = round(clamp(float_val, 0, +1) * 65535.0); packSnorm2x16 fixed_val = round(clamp(float_val, -1, +1) * 32767.0); packUnorm4x8 fixed_val = round(clamp(float_val, 0, +1) * 255.0); packSnorm4x8 fixed_val = round(clamp(float_val, -1, +1) * 127.0); unpackUnorm2x16 float_val = fixed_val / 65535.0; unpackSnorm2x16 float_val = clamp(fixed_val / 32767.0, -1, +1); unpackUnorm4x8 float_val = fixed_val / 255.0; unpackSnorm4x8 float_val = clamp(fixed_val / 127.0, -1, +1); (add support for 16-bit floating-point packing and unpacking functions) Syntax: uint packHalf2x16(vec2 v); vec2 unpackHalf2x16(uint v); The function packHalf2x16() returns an unsigned integer obtained by converting the components of a two-component floating-point vector to the 16-bit floating-point representation found in the OpenGL Specification, and then packing these two 16-bit integers into a 32-bit unsigned integer. The first vector component specifies the 16 least-significant bits of the result; the second component specifies the 16 most-significant bits. The function unpackHalf2x16() returns a two-component floating-point vector with components obtained by unpacking a 32-bit unsigned integer into a pair of 16-bit values, interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification, and converting them to 32-bit floating-point values. The first component of the vector is obtained from the 16 least-significant bits of v; the second component is obtained from the 16 most-significant bits of v. GLX Protocol None. Errors None. New State None. New Implementation Dependent State None. Issues (1) What should this extension be called? RESOLVED: Proposed name is "ARB_shading_language_pack2h" (i.e., pack two half components). (2) This functionality is also provided in the NV_gpu_shader5 extension. Why provide a separate extension? RESOLVED: This extension provides an additional pack/unpack function on top of those added in GLSL 4.00 without requiring that implementors provide the entirety of NV_gpu_shader5. (3) Should we provide a different set of function names to disambiguate from the similar NV_gpu_shader5 versions (which use the "f16vec2" type to represent a pair of fp16 values)? If not, what happens if both this extension and NV_gpu_shader5 are enabled? RESOLVED: The functions in this extension will be called "packHalf2x16" and "unpackHalf2x16", which matches the convention of the other pack/unpack functions in GLSL 4.10 closely enough. For example, packUnorm2x16() packs a pair of 16-bit unsigned normalized integers into a 32-bit unsigned integer. Had we used the same names as in NV_gpu_shader5, there would be a conflict in the definitions -- the unpacked type here is "vec2", while the unpacked type in NV_gpu_shader5 is "f16vec2" (a two-component vector with explicit 16-bit floating-point types). This conflict poses a problem if both extensions are enabled, and would also arise if future GLSL versions chose to add explicit fp16 types. For the pack functions, an implementation supporting both versions could resolve via function overloading: uint packFloat2x16(vec2 v); uint packFloat2x16(f16vec2 v); Unfortunately, function overloading is not possible for the return type of the pack function. One could resolve this by providing only: f16vec2 unpackFloat2x16(uint v); If a shader included code like: vec2 unpacked = unpackFloat2x16(uint_value); the unpacked value would be returned as f16vec2 data. However, that could be implicitly converted to vec2 if implicit conversions from fp16 to fp32 were supported. Such behavior would be consistent with what we did for ARB_gpu_shader_fp64, where fp32 values can be implicitly converted to fp64. (4) The packing functions introduced in ARB_gpu_shader5 may be available on hardware that doesn't support the other features from ARB_gpu_shader5. How can an implementation expose those packing functions? RESOLVED: Added all the ARB_gpu_shader5 packing functions to revision #5 of this spec; [un]packUnorm2x16, [un]packUnorm4x8 and [un]packSnorm4x8. (5) Should we also provide a [un]packSnorm2x16 packing function, which was not included in ARB_gpu_shader5? RESOLVED: Yes, these functions have been added for completeness. They have been added to revision #5 of this extension and the extension has been renamed from _pack2h to _packing to encompass all these packing functions. Revision History Rev. Date Author Changes ---- ---------- -------- --------------------------------------------- 5 06/13/11 pdaniell Rename the spec to ARB_shading_language_packing and incorporate all the packing functions into this spec, including the [un]packSnorm2x16 functions, which have no extension spec. 4 12/17/10 johnk Put in the pack/unpack section instead of common functions. Change a reference to double. 3 12/12/2010 pbrown Rename the pack/unpack functions to avoid conflict with NV_gpu_shader5 names (bug 6858). Renamed last part of extension name from "pack2f" to "pack2h" to match the function name change. 2 11/08/2010 pbrown Fix minor errata in the first draft (bug 6999). 1 10/20/2010 pbrown Internal revision.