0.9.9 API documenation

Functions  
GLM_FUNC_DECL uint32  packF2x11_1x10 (vec3 const &v) 
GLM_FUNC_DECL uint32  packF3x9_E1x5 (vec3 const &v) 
template<length_t L, qualifier Q>  
GLM_FUNC_DECL vec< L, uint16, Q >  packHalf (vec< L, float, Q > 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 int  packInt2x16 (i16vec2 const &v) 
GLM_FUNC_DECL int64  packInt2x32 (i32vec2 const &v) 
GLM_FUNC_DECL int16  packInt2x8 (i8vec2 const &v) 
GLM_FUNC_DECL int64  packInt4x16 (i16vec4 const &v) 
GLM_FUNC_DECL int32  packInt4x8 (i8vec4 const &v) 
template<length_t L, typename T , qualifier Q>  
GLM_FUNC_DECL vec< 4, T, Q >  packRGBM (vec< 3, T, Q > const &rgb) 
template<typename intType , length_t L, typename floatType , qualifier Q>  
GLM_FUNC_DECL vec< L, intType, Q >  packSnorm (vec< L, floatType, Q > 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 uint  packUint2x16 (u16vec2 const &v) 
GLM_FUNC_DECL uint64  packUint2x32 (u32vec2 const &v) 
GLM_FUNC_DECL uint16  packUint2x8 (u8vec2 const &v) 
GLM_FUNC_DECL uint64  packUint4x16 (u16vec4 const &v) 
GLM_FUNC_DECL uint32  packUint4x8 (u8vec4 const &v) 
template<typename uintType , length_t L, typename floatType , qualifier Q>  
GLM_FUNC_DECL vec< L, uintType, Q >  packUnorm (vec< L, floatType, Q > const &v) 
GLM_FUNC_DECL uint16  packUnorm1x16 (float v) 
GLM_FUNC_DECL uint16  packUnorm1x5_1x6_1x5 (vec3 const &v) 
GLM_FUNC_DECL uint8  packUnorm1x8 (float v) 
GLM_FUNC_DECL uint8  packUnorm2x3_1x2 (vec3 const &v) 
GLM_FUNC_DECL uint8  packUnorm2x4 (vec2 const &v) 
GLM_FUNC_DECL uint16  packUnorm2x8 (vec2 const &v) 
GLM_FUNC_DECL uint32  packUnorm3x10_1x2 (vec4 const &v) 
GLM_FUNC_DECL uint16  packUnorm3x5_1x1 (vec4 const &v) 
GLM_FUNC_DECL uint64  packUnorm4x16 (vec4 const &v) 
GLM_FUNC_DECL uint16  packUnorm4x4 (vec4 const &v) 
GLM_FUNC_DECL vec3  unpackF2x11_1x10 (uint32 p) 
GLM_FUNC_DECL vec3  unpackF3x9_E1x5 (uint32 p) 
template<length_t L, qualifier Q>  
GLM_FUNC_DECL vec< L, float, Q >  unpackHalf (vec< L, uint16, Q > const &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 i16vec2  unpackInt2x16 (int p) 
GLM_FUNC_DECL i32vec2  unpackInt2x32 (int64 p) 
GLM_FUNC_DECL i8vec2  unpackInt2x8 (int16 p) 
GLM_FUNC_DECL i16vec4  unpackInt4x16 (int64 p) 
GLM_FUNC_DECL i8vec4  unpackInt4x8 (int32 p) 
template<length_t L, typename T , qualifier Q>  
GLM_FUNC_DECL vec< 3, T, Q >  unpackRGBM (vec< 4, T, Q > const &rgbm) 
template<typename floatType , length_t L, typename intType , qualifier Q>  
GLM_FUNC_DECL vec< L, floatType, Q >  unpackSnorm (vec< L, intType, Q > const &v) 
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 u16vec2  unpackUint2x16 (uint p) 
GLM_FUNC_DECL u32vec2  unpackUint2x32 (uint64 p) 
GLM_FUNC_DECL u8vec2  unpackUint2x8 (uint16 p) 
GLM_FUNC_DECL u16vec4  unpackUint4x16 (uint64 p) 
GLM_FUNC_DECL u8vec4  unpackUint4x8 (uint32 p) 
template<typename floatType , length_t L, typename uintType , qualifier Q>  
GLM_FUNC_DECL vec< L, floatType, Q >  unpackUnorm (vec< L, uintType, Q > const &v) 
GLM_FUNC_DECL float  unpackUnorm1x16 (uint16 p) 
GLM_FUNC_DECL vec3  unpackUnorm1x5_1x6_1x5 (uint16 p) 
GLM_FUNC_DECL float  unpackUnorm1x8 (uint8 p) 
GLM_FUNC_DECL vec3  unpackUnorm2x3_1x2 (uint8 p) 
GLM_FUNC_DECL vec2  unpackUnorm2x4 (uint8 p) 
GLM_FUNC_DECL vec2  unpackUnorm2x8 (uint16 p) 
GLM_FUNC_DECL vec4  unpackUnorm3x10_1x2 (uint32 p) 
GLM_FUNC_DECL vec4  unpackUnorm3x5_1x1 (uint16 p) 
GLM_FUNC_DECL vec4  unpackUnorm4x16 (uint64 p) 
GLM_FUNC_DECL vec4  unpackUnorm4x4 (uint16 p) 
Include <glm/gtc/packing.hpp> to use the features of this extension.
This extension provides a set of function to convert vertors to packed formats.
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.
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.
packF3x9_E1x5 allows encoding into RGBE / RGB9E5 format
GLM_FUNC_DECL vec<L, uint16, Q> glm::packHalf  (  vec< L, float, Q > const &  v  ) 
Returns an unsigned integer vector obtained by converting the components of a floatingpoint vector to the 16bit floatingpoint representation found in the OpenGL Specification.
The first vector component specifies the 16 leastsignificant bits of the result; the forth component specifies the 16 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.
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.
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 int glm::packInt2x16  (  i16vec2 const &  v  ) 
Convert each component from an integer vector into a packed unsigned integer.
Convert each component from an integer vector into a packed unsigned integer.
Convert each component from an integer vector into a packed unsigned integer.
Convert each component from an integer vector into a packed unsigned integer.
Convert each component from an integer vector into a packed unsigned integer.
GLM_FUNC_DECL vec<4, T, Q> glm::packRGBM  (  vec< 3, T, Q > const &  rgb  ) 
Returns an unsigned integer vector obtained by converting the components of a floatingpoint vector to the 16bit floatingpoint representation found in the OpenGL Specification.
The first vector component specifies the 16 leastsignificant bits of the result; the forth component specifies the 16 mostsignificant bits.
GLM_FUNC_DECL vec<L, intType, Q> glm::packSnorm  (  vec< L, floatType, Q > const &  v  ) 
Convert each component of the normalized floatingpoint vector into signed integer values.
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)
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.
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.
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.
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 uint glm::packUint2x16  (  u16vec2 const &  v  ) 
Convert each component from an integer vector into a packed unsigned integer.
Convert each component from an integer vector into a packed unsigned integer.
Convert each component from an integer vector into a packed unsigned integer.
Convert each component from an integer vector into a packed unsigned integer.
Convert each component from an integer vector into a packed unsigned integer.
GLM_FUNC_DECL vec<L, uintType, Q> glm::packUnorm  (  vec< L, floatType, Q > const &  v  ) 
Convert each component of the normalized floatingpoint vector into unsigned integer values.
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)
Convert each component of the normalized floatingpoint vector into unsigned integer values.
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)
Convert each component of the normalized floatingpoint vector into unsigned integer values.
Convert each component of the normalized floatingpoint vector into unsigned integer values.
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.
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.
Convert each component of the normalized floatingpoint vector into unsigned integer values.
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.
Convert each component of the normalized floatingpoint vector into unsigned integer values.
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.
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.
unpackF3x9_E1x5 allows decoding RGBE / RGB9E5 data
GLM_FUNC_DECL vec<L, float, Q> glm::unpackHalf  (  vec< L, uint16, Q > const &  p  ) 
Returns a floatingpoint vector with components obtained by reinterpreting an integer vector as 16bit floatingpoint numbers 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 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.
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.
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 i16vec2 glm::unpackInt2x16  (  int  p  ) 
Convert a packed integer into an integer vector.
Convert a packed integer into an integer vector.
Convert a packed integer into an integer vector.
Convert a packed integer into an integer vector.
Convert a packed integer into an integer vector.
GLM_FUNC_DECL vec<3, T, Q> glm::unpackRGBM  (  vec< 4, T, Q > const &  rgbm  ) 
Returns a floatingpoint vector with components obtained by reinterpreting an integer vector as 16bit floatingpoint numbers 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 vec<L, floatType, Q> glm::unpackSnorm  (  vec< L, intType, Q > const &  v  ) 
Convert a packed integer to a normalized floatingpoint vector.
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)
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.
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.
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.
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 u16vec2 glm::unpackUint2x16  (  uint  p  ) 
Convert a packed integer into an integer vector.
Convert a packed integer into an integer vector.
Convert a packed integer into an integer vector.
Convert a packed integer into an integer vector.
Convert a packed integer into an integer vector.
GLM_FUNC_DECL vec<L, floatType, Q> glm::unpackUnorm  (  vec< L, uintType, Q > const &  v  ) 
Convert a packed integer to a normalized floatingpoint vector.
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
Convert a packed integer to a normalized floatingpoint vector.
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
Convert a packed integer to a normalized floatingpoint vector.
Convert a packed integer to a normalized floatingpoint vector.
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.
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.
Convert a packed integer to a normalized floatingpoint vector.
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.
Convert a packed integer to a normalized floatingpoint vector.