FlukyEngine

Include <glm/gtc/packing.hpp> to use the features of this extension. More...
Functions  
GLM_FUNC_DECL uint8  glm::packUnorm1x8 (float v) 
First, converts the normalized floatingpoint value v into a 8bit integer value. More...  
GLM_FUNC_DECL float  glm::unpackUnorm1x8 (uint8 p) 
Convert a single 8bit integer to a normalized floatingpoint value. More...  
GLM_FUNC_DECL uint16  glm::packUnorm2x8 (vec2 const &v) 
First, converts each component of the normalized floatingpoint value v into 8bit integer values. More...  
GLM_FUNC_DECL vec2  glm::unpackUnorm2x8 (uint16 p) 
First, unpacks a single 16bit unsigned integer p into a pair of 8bit unsigned integers. More...  
GLM_FUNC_DECL uint8  glm::packSnorm1x8 (float s) 
First, converts the normalized floatingpoint value v into 8bit integer value. More...  
GLM_FUNC_DECL float  glm::unpackSnorm1x8 (uint8 p) 
First, unpacks a single 8bit unsigned integer p into a single 8bit signed integers. More...  
GLM_FUNC_DECL uint16  glm::packSnorm2x8 (vec2 const &v) 
First, converts each component of the normalized floatingpoint value v into 8bit integer values. More...  
GLM_FUNC_DECL vec2  glm::unpackSnorm2x8 (uint16 p) 
First, unpacks a single 16bit unsigned integer p into a pair of 8bit signed integers. More...  
GLM_FUNC_DECL uint16  glm::packUnorm1x16 (float v) 
First, converts the normalized floatingpoint value v into a 16bit integer value. More...  
GLM_FUNC_DECL float  glm::unpackUnorm1x16 (uint16 p) 
First, unpacks a single 16bit unsigned integer p into a of 16bit unsigned integers. More...  
GLM_FUNC_DECL uint64  glm::packUnorm4x16 (vec4 const &v) 
First, converts each component of the normalized floatingpoint value v into 16bit integer values. More...  
GLM_FUNC_DECL vec4  glm::unpackUnorm4x16 (uint64 p) 
First, unpacks a single 64bit unsigned integer p into four 16bit unsigned integers. More...  
GLM_FUNC_DECL uint16  glm::packSnorm1x16 (float v) 
First, converts the normalized floatingpoint value v into 16bit integer value. More...  
GLM_FUNC_DECL float  glm::unpackSnorm1x16 (uint16 p) 
First, unpacks a single 16bit unsigned integer p into a single 16bit signed integers. More...  
GLM_FUNC_DECL uint64  glm::packSnorm4x16 (vec4 const &v) 
First, converts each component of the normalized floatingpoint value v into 16bit integer values. More...  
GLM_FUNC_DECL vec4  glm::unpackSnorm4x16 (uint64 p) 
First, unpacks a single 64bit unsigned integer p into four 16bit signed integers. More...  
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. More...  
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. More...  
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. More...  
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. More...  
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. More...  
GLM_FUNC_DECL ivec4  glm::unpackI3x10_1x2 (uint32 p) 
Unpacks a single 32bit unsigned integer p into three 10bit and one 2bit signed integers. More...  
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. More...  
GLM_FUNC_DECL uvec4  glm::unpackU3x10_1x2 (uint32 p) 
Unpacks a single 32bit unsigned integer p into three 10bit and one 2bit unsigned integers. More...  
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. More...  
GLM_FUNC_DECL vec4  glm::unpackSnorm3x10_1x2 (uint32 p) 
First, unpacks a single 32bit unsigned integer p into four 16bit signed integers. More...  
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. More...  
GLM_FUNC_DECL vec4  glm::unpackUnorm3x10_1x2 (uint32 p) 
First, unpacks a single 32bit unsigned integer p into four 16bit signed integers. More...  
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. More...  
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 . More...  
GLM_FUNC_DECL uint32  glm::packF3x9_E1x5 (vec3 const &v) 
First, converts the first two components of the normalized floatingpoint value v into 11bit signless floatingpoint values. More...  
GLM_FUNC_DECL vec3  glm::unpackF3x9_E1x5 (uint32 p) 
First, unpacks a single 32bit unsigned integer p into two 11bit signless floatingpoint values and one 10bit signless floatingpoint value . More...  
template<length_t L, typename T , qualifier Q>  
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. More...  
template<length_t L, typename T , qualifier Q>  
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. More...  
template<length_t L, qualifier Q>  
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. More...  
template<length_t L, qualifier Q>  
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. More...  
template<typename uintType , length_t L, typename floatType , qualifier Q>  
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. More...  
template<typename floatType , length_t L, typename uintType , qualifier Q>  
GLM_FUNC_DECL vec< L, floatType, Q >  glm::unpackUnorm (vec< L, uintType, Q > const &v) 
Convert a packed integer to a normalized floatingpoint vector. More...  
template<typename intType , length_t L, typename floatType , qualifier Q>  
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. More...  
template<typename floatType , length_t L, typename intType , qualifier Q>  
GLM_FUNC_DECL vec< L, floatType, Q >  glm::unpackSnorm (vec< L, intType, Q > const &v) 
Convert a packed integer to a normalized floatingpoint vector. More...  
GLM_FUNC_DECL uint8  glm::packUnorm2x4 (vec2 const &v) 
Convert each component of the normalized floatingpoint vector into unsigned integer values. More...  
GLM_FUNC_DECL vec2  glm::unpackUnorm2x4 (uint8 p) 
Convert a packed integer to a normalized floatingpoint vector. More...  
GLM_FUNC_DECL uint16  glm::packUnorm4x4 (vec4 const &v) 
Convert each component of the normalized floatingpoint vector into unsigned integer values. More...  
GLM_FUNC_DECL vec4  glm::unpackUnorm4x4 (uint16 p) 
Convert a packed integer to a normalized floatingpoint vector. More...  
GLM_FUNC_DECL uint16  glm::packUnorm1x5_1x6_1x5 (vec3 const &v) 
Convert each component of the normalized floatingpoint vector into unsigned integer values. More...  
GLM_FUNC_DECL vec3  glm::unpackUnorm1x5_1x6_1x5 (uint16 p) 
Convert a packed integer to a normalized floatingpoint vector. More...  
GLM_FUNC_DECL uint16  glm::packUnorm3x5_1x1 (vec4 const &v) 
Convert each component of the normalized floatingpoint vector into unsigned integer values. More...  
GLM_FUNC_DECL vec4  glm::unpackUnorm3x5_1x1 (uint16 p) 
Convert a packed integer to a normalized floatingpoint vector. More...  
GLM_FUNC_DECL uint8  glm::packUnorm2x3_1x2 (vec3 const &v) 
Convert each component of the normalized floatingpoint vector into unsigned integer values. More...  
GLM_FUNC_DECL vec3  glm::unpackUnorm2x3_1x2 (uint8 p) 
Convert a packed integer to a normalized floatingpoint vector. More...  
GLM_FUNC_DECL int16  glm::packInt2x8 (i8vec2 const &v) 
Convert each component from an integer vector into a packed integer. More...  
GLM_FUNC_DECL i8vec2  glm::unpackInt2x8 (int16 p) 
Convert a packed integer into an integer vector. More...  
GLM_FUNC_DECL uint16  glm::packUint2x8 (u8vec2 const &v) 
Convert each component from an integer vector into a packed unsigned integer. More...  
GLM_FUNC_DECL u8vec2  glm::unpackUint2x8 (uint16 p) 
Convert a packed integer into an integer vector. More...  
GLM_FUNC_DECL int32  glm::packInt4x8 (i8vec4 const &v) 
Convert each component from an integer vector into a packed integer. More...  
GLM_FUNC_DECL i8vec4  glm::unpackInt4x8 (int32 p) 
Convert a packed integer into an integer vector. More...  
GLM_FUNC_DECL uint32  glm::packUint4x8 (u8vec4 const &v) 
Convert each component from an integer vector into a packed unsigned integer. More...  
GLM_FUNC_DECL u8vec4  glm::unpackUint4x8 (uint32 p) 
Convert a packed integer into an integer vector. More...  
GLM_FUNC_DECL int  glm::packInt2x16 (i16vec2 const &v) 
Convert each component from an integer vector into a packed integer. More...  
GLM_FUNC_DECL i16vec2  glm::unpackInt2x16 (int p) 
Convert a packed integer into an integer vector. More...  
GLM_FUNC_DECL int64  glm::packInt4x16 (i16vec4 const &v) 
Convert each component from an integer vector into a packed integer. More...  
GLM_FUNC_DECL i16vec4  glm::unpackInt4x16 (int64 p) 
Convert a packed integer into an integer vector. More...  
GLM_FUNC_DECL uint  glm::packUint2x16 (u16vec2 const &v) 
Convert each component from an integer vector into a packed unsigned integer. More...  
GLM_FUNC_DECL u16vec2  glm::unpackUint2x16 (uint p) 
Convert a packed integer into an integer vector. More...  
GLM_FUNC_DECL uint64  glm::packUint4x16 (u16vec4 const &v) 
Convert each component from an integer vector into a packed unsigned integer. More...  
GLM_FUNC_DECL u16vec4  glm::unpackUint4x16 (uint64 p) 
Convert a packed integer into an integer vector. More...  
GLM_FUNC_DECL int64  glm::packInt2x32 (i32vec2 const &v) 
Convert each component from an integer vector into a packed integer. More...  
GLM_FUNC_DECL i32vec2  glm::unpackInt2x32 (int64 p) 
Convert a packed integer into an integer vector. More...  
GLM_FUNC_DECL uint64  glm::packUint2x32 (u32vec2 const &v) 
Convert each component from an integer vector into a packed unsigned integer. More...  
GLM_FUNC_DECL u32vec2  glm::unpackUint2x32 (uint64 p) 
Convert a packed integer into an integer vector. More...  
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_QUALIFIER 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_QUALIFIER int glm::packInt2x16  (  i16vec2 const &  v  ) 
Convert each component from an integer vector into a packed integer.
Convert each component from an integer vector into a packed integer.
Convert each component from an integer vector into a packed integer.
Convert each component from an integer vector into a packed integer.
Convert each component from an integer vector into a packed 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_QUALIFIER 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_QUALIFIER 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_QUALIFIER 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_QUALIFIER 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_QUALIFIER 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_QUALIFIER 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_QUALIFIER 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_QUALIFIER 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_QUALIFIER 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_QUALIFIER 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_QUALIFIER 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_QUALIFIER 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.