0.9.7

Functions  
GLM_FUNC_DECL uint32  packF2x11_1x10 (vec3 const &v) 
GLM_FUNC_DECL uint16  packHalf1x16 (float v) 
GLM_FUNC_DECL uint64  packHalf4x16 (vec4 const &v) 
GLM_FUNC_DECL uint32  packI3x10_1x2 (ivec4 const &v) 
GLM_FUNC_DECL uint16  packSnorm1x16 (float v) 
GLM_FUNC_DECL uint8  packSnorm1x8 (float s) 
GLM_FUNC_DECL uint16  packSnorm2x8 (vec2 const &v) 
GLM_FUNC_DECL uint32  packSnorm3x10_1x2 (vec4 const &v) 
GLM_FUNC_DECL uint64  packSnorm4x16 (vec4 const &v) 
GLM_FUNC_DECL uint32  packU3x10_1x2 (uvec4 const &v) 
GLM_FUNC_DECL uint16  packUnorm1x16 (float v) 
GLM_FUNC_DECL uint8  packUnorm1x8 (float v) 
GLM_FUNC_DECL uint16  packUnorm2x8 (vec2 const &v) 
GLM_FUNC_DECL uint32  packUnorm3x10_1x2 (vec4 const &v) 
GLM_FUNC_DECL uint64  packUnorm4x16 (vec4 const &v) 
GLM_FUNC_DECL vec3  unpackF2x11_1x10 (uint32 p) 
GLM_FUNC_DECL float  unpackHalf1x16 (uint16 v) 
GLM_FUNC_DECL vec4  unpackHalf4x16 (uint64 p) 
GLM_FUNC_DECL ivec4  unpackI3x10_1x2 (uint32 p) 
GLM_FUNC_DECL float  unpackSnorm1x16 (uint16 p) 
GLM_FUNC_DECL float  unpackSnorm1x8 (uint8 p) 
GLM_FUNC_DECL vec2  unpackSnorm2x8 (uint16 p) 
GLM_FUNC_DECL vec4  unpackSnorm3x10_1x2 (uint32 p) 
GLM_FUNC_DECL vec4  unpackSnorm4x16 (uint64 p) 
GLM_FUNC_DECL uvec4  unpackU3x10_1x2 (uint32 p) 
GLM_FUNC_DECL float  unpackUnorm1x16 (uint16 p) 
GLM_FUNC_DECL float  unpackUnorm1x8 (uint8 p) 
GLM_FUNC_DECL vec2  unpackUnorm2x8 (uint16 p) 
GLM_FUNC_DECL vec4  unpackUnorm3x10_1x2 (uint32 p) 
GLM_FUNC_DECL vec4  unpackUnorm4x16 (uint64 p) 
This extension provides a set of function to convert vertors to packed formats.
<glm/gtc/packing.hpp> need to be included to use these features.
GLM_FUNC_DECL uint32 glm::packF2x11_1x10  (  vec3 const &  v  ) 
First, converts the first two components of the normalized floatingpoint value v into 11bit signless floatingpoint values.
Then, converts the third component of the normalized floatingpoint value v into a 10bit signless floatingpoint value. Then, the results are packed into the returned 32bit unsigned integer.
The first vector component specifies the 11 leastsignificant bits of the result; the last component specifies the 10 mostsignificant bits.
GLM_FUNC_DECL uint16 glm::packHalf1x16  (  float  v  ) 
Returns an unsigned integer obtained by converting the components of a floatingpoint scalar to the 16bit floatingpoint representation found in the OpenGL Specification, and then packing this 16bit value into a 16bit unsigned integer.
GLM_FUNC_DECL uint64 glm::packHalf4x16  (  vec4 const &  v  ) 
Returns an unsigned integer obtained by converting the components of a fourcomponent floatingpoint vector to the 16bit floatingpoint representation found in the OpenGL Specification, and then packing these four 16bit values into a 64bit unsigned integer.
The first vector component specifies the 16 leastsignificant bits of the result; the forth component specifies the 16 mostsignificant bits.
GLM_FUNC_DECL uint32 glm::packI3x10_1x2  (  ivec4 const &  v  ) 
Returns an unsigned integer obtained by converting the components of a fourcomponent signed integer vector to the 1010102bit signed integer representation found in the OpenGL Specification, and then packing these four values into a 32bit unsigned integer.
The first vector component specifies the 10 leastsignificant bits of the result; the forth component specifies the 2 mostsignificant bits.
GLM_FUNC_DECL uint16 glm::packSnorm1x16  (  float  v  ) 
First, converts the normalized floatingpoint value v into 16bit integer value.
Then, the results are packed into the returned 16bit unsigned integer.
The conversion to fixed point is done as follows: packSnorm1x8: round(clamp(s, 1, +1) * 32767.0)
GLM_FUNC_DECL uint8 glm::packSnorm1x8  (  float  s  ) 
First, converts the normalized floatingpoint value v into 8bit integer value.
Then, the results are packed into the returned 8bit unsigned integer.
The conversion to fixed point is done as follows: packSnorm1x8: round(clamp(s, 1, +1) * 127.0)
GLM_FUNC_DECL uint16 glm::packSnorm2x8  (  vec2 const &  v  ) 
First, converts each component of the normalized floatingpoint value v into 8bit integer values.
Then, the results are packed into the returned 16bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packSnorm2x8: 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 uint32 glm::packSnorm3x10_1x2  (  vec4 const &  v  ) 
First, converts the first three components of the normalized floatingpoint value v into 10bit signed integer values.
Then, converts the forth component of the normalized floatingpoint value v into 2bit signed 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: packSnorm3x10_1x2(xyz): round(clamp(c, 1, +1) * 511.0) packSnorm3x10_1x2(w): round(clamp(c, 1, +1) * 1.0)
The first vector component specifies the 10 leastsignificant bits of the result; the forth component specifies the 2 mostsignificant bits.
GLM_FUNC_DECL uint64 glm::packSnorm4x16  (  vec4 const &  v  ) 
First, converts each component of the normalized floatingpoint value v into 16bit integer values.
Then, the results are packed into the returned 64bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packSnorm2x8: round(clamp(c, 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 uint32 glm::packU3x10_1x2  (  uvec4 const &  v  ) 
Returns an unsigned integer obtained by converting the components of a fourcomponent unsigned integer vector to the 1010102bit unsigned integer representation found in the OpenGL Specification, and then packing these four values into a 32bit unsigned integer.
The first vector component specifies the 10 leastsignificant bits of the result; the forth component specifies the 2 mostsignificant bits.
GLM_FUNC_DECL uint16 glm::packUnorm1x16  (  float  v  ) 
First, converts the normalized floatingpoint value v into a 16bit integer value.
Then, the results are packed into the returned 16bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packUnorm1x16: round(clamp(c, 0, +1) * 65535.0)
GLM_FUNC_DECL uint8 glm::packUnorm1x8  (  float  v  ) 
First, converts the normalized floatingpoint value v into a 8bit integer value.
Then, the results are packed into the returned 8bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packUnorm1x8: round(clamp(c, 0, +1) * 255.0)
GLM_FUNC_DECL uint16 glm::packUnorm2x8  (  vec2 const &  v  ) 
First, converts each component of the normalized floatingpoint value v into 8bit integer values.
Then, the results are packed into the returned 16bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packUnorm2x8: 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 uint32 glm::packUnorm3x10_1x2  (  vec4 const &  v  ) 
First, converts the first three components of the normalized floatingpoint value v into 10bit unsigned integer values.
Then, converts the forth component of the normalized floatingpoint value v into 2bit signed uninteger 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: packUnorm3x10_1x2(xyz): round(clamp(c, 0, +1) * 1023.0) packUnorm3x10_1x2(w): round(clamp(c, 0, +1) * 3.0)
The first vector component specifies the 10 leastsignificant bits of the result; the forth component specifies the 2 mostsignificant bits.
GLM_FUNC_DECL uint64 glm::packUnorm4x16  (  vec4 const &  v  ) 
First, converts each component of the normalized floatingpoint value v into 16bit integer values.
Then, the results are packed into the returned 64bit unsigned integer.
The conversion for component c of v to fixed point is done as follows: packUnorm4x16: 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 vec3 glm::unpackF2x11_1x10  (  uint32  p  ) 
First, unpacks a single 32bit unsigned integer p into two 11bit signless floatingpoint values and one 10bit signless floatingpoint value .
Then, each component is converted to a normalized floatingpoint value to generate the returned threecomponent vector.
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 float glm::unpackHalf1x16  (  uint16  v  ) 
Returns a floatingpoint scalar with components obtained by unpacking a 16bit unsigned integer into a 16bit value, interpreted as a 16bit floatingpoint number according to the OpenGL Specification, and converting it to 32bit floatingpoint values.
GLM_FUNC_DECL vec4 glm::unpackHalf4x16  (  uint64  p  ) 
Returns a fourcomponent floatingpoint vector with components obtained by unpacking a 64bit unsigned integer into four 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 forth component is obtained from the 16 mostsignificant bits of v.
GLM_FUNC_DECL ivec4 glm::unpackI3x10_1x2  (  uint32  p  ) 
Unpacks a single 32bit unsigned integer p into three 10bit and one 2bit signed integers.
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 float glm::unpackSnorm1x16  (  uint16  p  ) 
First, unpacks a single 16bit unsigned integer p into a single 16bit signed integers.
Then, each component is converted to a normalized floatingpoint value to generate the returned scalar.
The conversion for unpacked fixedpoint value f to floating point is done as follows: unpackSnorm1x16: clamp(f / 32767.0, 1, +1)
GLM_FUNC_DECL float glm::unpackSnorm1x8  (  uint8  p  ) 
First, unpacks a single 8bit unsigned integer p into a single 8bit signed integers.
Then, the value is converted to a normalized floatingpoint value to generate the returned scalar.
The conversion for unpacked fixedpoint value f to floating point is done as follows: unpackSnorm1x8: clamp(f / 127.0, 1, +1)
GLM_FUNC_DECL vec2 glm::unpackSnorm2x8  (  uint16  p  ) 
First, unpacks a single 16bit unsigned integer p into a pair of 8bit signed integers.
Then, each component is converted to a normalized floatingpoint value to generate the returned twocomponent vector.
The conversion for unpacked fixedpoint value f to floating point is done as follows: unpackSnorm2x8: 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 vec4 glm::unpackSnorm3x10_1x2  (  uint32  p  ) 
First, unpacks a single 32bit unsigned integer p into four 16bit signed integers.
Then, each component is converted to a normalized floatingpoint value to generate the returned fourcomponent vector.
The conversion for unpacked fixedpoint value f to floating point is done as follows: unpackSnorm3x10_1x2(xyz): clamp(f / 511.0, 1, +1) unpackSnorm3x10_1x2(w): clamp(f / 511.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::unpackSnorm4x16  (  uint64  p  ) 
First, unpacks a single 64bit unsigned integer p into four 16bit signed integers.
Then, each component is converted to a normalized floatingpoint value to generate the returned fourcomponent vector.
The conversion for unpacked fixedpoint value f to floating point is done as follows: unpackSnorm4x16: 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 uvec4 glm::unpackU3x10_1x2  (  uint32  p  ) 
Unpacks a single 32bit unsigned integer p into three 10bit and one 2bit unsigned integers.
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 float glm::unpackUnorm1x16  (  uint16  p  ) 
First, unpacks a single 16bit unsigned integer p into a of 16bit unsigned integers.
Then, the value is converted to a normalized floatingpoint value to generate the returned scalar.
The conversion for unpacked fixedpoint value f to floating point is done as follows: unpackUnorm1x16: f / 65535.0
GLM_FUNC_DECL float glm::unpackUnorm1x8  (  uint8  p  ) 
Convert a single 8bit integer to a normalized floatingpoint value.
The conversion for unpacked fixedpoint value f to floating point is done as follows: unpackUnorm4x8: f / 255.0
GLM_FUNC_DECL vec2 glm::unpackUnorm2x8  (  uint16  p  ) 
First, unpacks a single 16bit unsigned integer p into a pair of 8bit unsigned integers.
Then, each component is converted to a normalized floatingpoint value to generate the returned twocomponent 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.
GLM_FUNC_DECL vec4 glm::unpackUnorm3x10_1x2  (  uint32  p  ) 
First, unpacks a single 32bit unsigned integer p into four 16bit signed integers.
Then, each component is converted to a normalized floatingpoint value to generate the returned fourcomponent vector.
The conversion for unpacked fixedpoint value f to floating point is done as follows: unpackSnorm3x10_1x2(xyz): clamp(f / 1023.0, 0, +1) unpackSnorm3x10_1x2(w): clamp(f / 3.0, 0, +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::unpackUnorm4x16  (  uint64  p  ) 
First, unpacks a single 64bit unsigned integer p into four 16bit unsigned integers.
Then, each component is converted to a normalized floatingpoint value to generate the returned fourcomponent vector.
The conversion for unpacked fixedpoint value f to floating point is done as follows: unpackUnormx4x16: 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.