0.9.7

Functions  
GLM_FUNC_DECL double  packDouble2x32 (uvec2 const &v) 
GLM_FUNC_DECL uint  packHalf2x16 (vec2 const &v) 
GLM_FUNC_DECL uint  packSnorm2x16 (vec2 const &v) 
GLM_FUNC_DECL uint  packSnorm4x8 (vec4 const &v) 
GLM_FUNC_DECL uint  packUnorm2x16 (vec2 const &v) 
GLM_FUNC_DECL uint  packUnorm4x8 (vec4 const &v) 
GLM_FUNC_DECL uvec2  unpackDouble2x32 (double v) 
GLM_FUNC_DECL vec2  unpackHalf2x16 (uint v) 
GLM_FUNC_DECL vec2  unpackSnorm2x16 (uint p) 
GLM_FUNC_DECL vec4  unpackSnorm4x8 (uint p) 
GLM_FUNC_DECL vec2  unpackUnorm2x16 (uint p) 
GLM_FUNC_DECL vec4  unpackUnorm4x8 (uint p) 
These functions do not operate componentwise, rather as described in each case.
GLM_FUNC_DECL double glm::packDouble2x32  (  uvec2 const &  v  ) 
Returns a doubleprecision 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.
GLM_FUNC_DECL uint glm::packHalf2x16  (  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.
GLM_FUNC_DECL uint glm::packSnorm2x16  (  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.
GLM_FUNC_DECL uint glm::packSnorm4x8  (  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.
GLM_FUNC_DECL uint glm::packUnorm2x16  (  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.
GLM_FUNC_DECL uint glm::packUnorm4x8  (  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.
GLM_FUNC_DECL uvec2 glm::unpackDouble2x32  (  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.
GLM_FUNC_DECL vec2 glm::unpackHalf2x16  (  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.
GLM_FUNC_DECL vec2 glm::unpackSnorm2x16  (  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.
GLM_FUNC_DECL vec4 glm::unpackSnorm4x8  (  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.
GLM_FUNC_DECL vec2 glm::unpackUnorm2x16  (  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.
GLM_FUNC_DECL vec4 glm::unpackUnorm4x8  (  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.