FlukyEngine

Provides GLSL functions to pack and unpack half, single and doubleprecision floating point values into more compact integer types. More...
Functions  
GLM_FUNC_QUALIFIER uint  glm::packUnorm2x16 (vec2 const &v) 
First, converts each component of the normalized floatingpoint value v into 8 or 16bit integer values. More...  
GLM_FUNC_QUALIFIER uint  glm::packSnorm2x16 (vec2 const &v) 
First, converts each component of the normalized floatingpoint value v into 8 or 16bit integer values. More...  
GLM_FUNC_QUALIFIER uint  glm::packUnorm4x8 (vec4 const &v) 
First, converts each component of the normalized floatingpoint value v into 8 or 16bit integer values. More...  
GLM_FUNC_QUALIFIER uint  glm::packSnorm4x8 (vec4 const &v) 
First, converts each component of the normalized floatingpoint value v into 8 or 16bit integer values. More...  
GLM_FUNC_QUALIFIER 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. More...  
GLM_FUNC_QUALIFIER 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. More...  
GLM_FUNC_QUALIFIER 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. More...  
GLM_FUNC_QUALIFIER glm::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. More...  
GLM_FUNC_QUALIFIER double  glm::packDouble2x32 (uvec2 const &v) 
Returns a doublequalifier value obtained by packing the components of v into a 64bit value. More...  
GLM_FUNC_QUALIFIER uvec2  glm::unpackDouble2x32 (double v) 
Returns a twocomponent unsigned integer vector representation of v. More...  
GLM_FUNC_QUALIFIER 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. More...  
GLM_FUNC_QUALIFIER 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. More...  
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.
GLM_FUNC_DECL double glm::packDouble2x32  (  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.
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.