core_func_packing Module Reference
Provides GLSL functions to pack and unpack half, single and doubleprecision floating point values into more compact integer types.
These functions do not operate componentwise, rather as described in each case.
Include < glm/packing.hpp > to use these core features.
Public Member Functions

GLM_FUNC_QUALIFIER uintpackUnorm2x16 (vec2 const &v)
First, converts each component of the normalized floatingpoint value v into 8 or 16bit integer values. Then, the results are packed into the returned 32bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packUnorm2x16: round(clamp(c, 0, +1) * 65535.0)
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.
 See Also
 See Also
GLSL 4.20.8 specification, section 8.4 FloatingPoint Pack and Unpack Functions

GLM_FUNC_QUALIFIER uintpackSnorm2x16 (vec2 const &v)
First, converts each component of the normalized floatingpoint value v into 8 or 16bit integer values. Then, the results are packed into the returned 32bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packSnorm2x16: round(clamp(v, 1, +1) * 32767.0)
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.
 See Also
 See Also
GLSL 4.20.8 specification, section 8.4 FloatingPoint Pack and Unpack Functions

GLM_FUNC_QUALIFIER uintpackUnorm4x8 (vec4 const &v)
First, converts each component of the normalized floatingpoint value v into 8 or 16bit integer values. Then, the results are packed into the returned 32bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packUnorm4x8: round(clamp(c, 0, +1) * 255.0)
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.
 See Also
 See Also
GLSL 4.20.8 specification, section 8.4 FloatingPoint Pack and Unpack Functions

GLM_FUNC_QUALIFIER uintpackSnorm4x8 (vec4 const &v)
First, converts each component of the normalized floatingpoint value v into 8 or 16bit integer values. Then, the results are packed into the returned 32bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packSnorm4x8: round(clamp(c, 1, +1) * 127.0)
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.
 See Also
 See Also
GLSL 4.20.8 specification, section 8.4 FloatingPoint Pack and Unpack Functions

GLM_FUNC_QUALIFIER vec2unpackUnorm2x16 (uint p)
First, unpacks a single 32bit unsigned integer p into a pair of 16bit unsigned integers, four 8bit unsigned integers, or four 8bit signed integers. Then, each component is converted to a normalized floatingpoint value to generate the returned two or fourcomponent vector.
The conversion for unpacked fixedpoint value f to floating point is done as follows: unpackUnorm2x16: f / 65535.0
The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.
 See Also
 See Also
GLSL 4.20.8 specification, section 8.4 FloatingPoint Pack and Unpack Functions

GLM_FUNC_QUALIFIER vec2unpackSnorm2x16 (uint p)
First, unpacks a single 32bit unsigned integer p into a pair of 16bit unsigned integers, four 8bit unsigned integers, or four 8bit signed integers. Then, each component is converted to a normalized floatingpoint value to generate the returned two or fourcomponent vector.
The conversion for unpacked fixedpoint value f to floating point is done as follows: unpackSnorm2x16: clamp(f / 32767.0, 1, +1)
The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.
 See Also
 See Also
GLSL 4.20.8 specification, section 8.4 FloatingPoint Pack and Unpack Functions

GLM_FUNC_QUALIFIER vec4unpackUnorm4x8 (uint p)
First, unpacks a single 32bit unsigned integer p into a pair of 16bit unsigned integers, four 8bit unsigned integers, or four 8bit signed integers. Then, each component is converted to a normalized floatingpoint value to generate the returned two or fourcomponent vector.
The conversion for unpacked fixedpoint value f to floating point is done as follows: unpackUnorm4x8: f / 255.0
The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.
 See Also
 See Also
GLSL 4.20.8 specification, section 8.4 FloatingPoint Pack and Unpack Functions

GLM_FUNC_QUALIFIER glm::vec4unpackSnorm4x8 (uint p)
First, unpacks a single 32bit unsigned integer p into a pair of 16bit unsigned integers, four 8bit unsigned integers, or four 8bit signed integers. Then, each component is converted to a normalized floatingpoint value to generate the returned two or fourcomponent vector.
The conversion for unpacked fixedpoint value f to floating point is done as follows: unpackSnorm4x8: clamp(f / 127.0, 1, +1)
The first component of the returned vector will be extracted from the least significant bits of the input; the last component will be extracted from the most significant bits.
 See Also
 See Also
GLSL 4.20.8 specification, section 8.4 FloatingPoint Pack and Unpack Functions

GLM_FUNC_QUALIFIER doublepackDouble2x32 (uvec2 const &v)
Returns a doublequalifier value obtained by packing the components of v into a 64bit value. If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified. Otherwise, the bit level representation of v is preserved. The first vector component specifies the 32 least significant bits; the second component specifies the 32 most significant bits.
 See Also
 See Also
GLSL 4.20.8 specification, section 8.4 FloatingPoint Pack and Unpack Functions

GLM_FUNC_QUALIFIER uvec2unpackDouble2x32 (double v)
Returns a twocomponent unsigned integer vector representation of v. The bitlevel representation of v is preserved. The first component of the vector contains the 32 least significant bits of the double; the second component consists the 32 most significant bits.
 See Also
GLSL unpackDouble2x32 man page
 See Also
GLSL 4.20.8 specification, section 8.4 FloatingPoint Pack and Unpack Functions

GLM_FUNC_QUALIFIER uintpackHalf2x16 (vec2 const &v)
Returns an unsigned integer obtained by converting the components of a twocomponent floatingpoint vector to the 16bit floatingpoint representation found in the OpenGL Specification, and then packing these two 16 bit integers into a 32bit unsigned integer. The first vector component specifies the 16 leastsignificant bits of the result; the second component specifies the 16 mostsignificant bits.
 See Also
 See Also
GLSL 4.20.8 specification, section 8.4 FloatingPoint Pack and Unpack Functions

GLM_FUNC_QUALIFIER vec2unpackHalf2x16 (uint v)
Returns a twocomponent floatingpoint vector with components obtained by unpacking a 32bit unsigned integer into a pair of 16bit values, interpreting those values as 16bit floatingpoint numbers according to the OpenGL Specification, and converting them to 32bit floatingpoint values. The first component of the vector is obtained from the 16 leastsignificant bits of v; the second component is obtained from the 16 mostsignificant bits of v.
 See Also
 See Also
GLSL 4.20.8 specification, section 8.4 FloatingPoint Pack and Unpack Functions