mirror of
https://github.com/g-truc/glm.git
synced 2024-11-22 17:04:35 +00:00
Initial experiments for EXT packing extension
This commit is contained in:
Christophe
parent
f3887d2053
commit
f6da0506b3
489
glm/ext/packing.hpp
Normal file
489
glm/ext/packing.hpp
Normal file
@ -0,0 +1,489 @@
|
||||
/// @ref ext_packing
|
||||
/// @file glm/ext/packing.hpp
|
||||
///
|
||||
/// @see core (dependence)
|
||||
///
|
||||
/// @defgroup ext_packing GLM_EXT_packing
|
||||
/// @ingroup ext
|
||||
///
|
||||
/// Include <glm/ext/packing.hpp> to use the features of this extension.
|
||||
///
|
||||
/// This extension provides a set of function to convert vertors to packed
|
||||
/// formats.
|
||||
|
||||
#pragma once
|
||||
|
||||
// Dependency:
|
||||
#include "../packing.hpp"
|
||||
|
||||
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
|
||||
# pragma message("GLM: GLM_EXT_packing extension included")
|
||||
#endif
|
||||
|
||||
namespace glm
|
||||
{
|
||||
/// @addtogroup ext_packing
|
||||
/// @{
|
||||
|
||||
/// First, converts the normalized floating-point value v into a 8-bit integer value.
|
||||
/// Then, the results are packed into the returned 8-bit unsigned integer.
|
||||
///
|
||||
/// The conversion for component c of v to fixed point is done as follows:
|
||||
/// packUnorm1x8: round(clamp(c, 0, +1) * 255.0)
|
||||
///
|
||||
/// @see ext_packing_sized
|
||||
/// @see uint16 packUnorm2x8(vec2 const& v)
|
||||
/// @see uint32 packUnorm4x8(vec4 const& v)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL uint8 packUnorm1x8(float v);
|
||||
|
||||
/// Convert a single 8-bit integer to a normalized floating-point value.
|
||||
///
|
||||
/// The conversion for unpacked fixed-point value f to floating point is done as follows:
|
||||
/// unpackUnorm4x8: f / 255.0
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec2 unpackUnorm2x8(uint16 p)
|
||||
/// @see vec4 unpackUnorm4x8(uint32 p)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL float unpackUnorm1x8(uint8 p);
|
||||
|
||||
/// First, converts each component of the normalized floating-point value v into 8-bit integer values.
|
||||
/// Then, the results are packed into the returned 16-bit 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.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint8 packUnorm1x8(float const& v)
|
||||
/// @see uint32 packUnorm4x8(vec4 const& v)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL uint16 packUnorm2x8(vec2 const& v);
|
||||
|
||||
/// First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit unsigned integers.
|
||||
/// Then, each component is converted to a normalized floating-point value to generate the returned two-component vector.
|
||||
///
|
||||
/// The conversion for unpacked fixed-point 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.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see float unpackUnorm1x8(uint8 v)
|
||||
/// @see vec4 unpackUnorm4x8(uint32 p)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL vec2 unpackUnorm2x8(uint16 p);
|
||||
|
||||
/// First, converts the normalized floating-point value v into 8-bit integer value.
|
||||
/// Then, the results are packed into the returned 8-bit unsigned integer.
|
||||
///
|
||||
/// The conversion to fixed point is done as follows:
|
||||
/// packSnorm1x8: round(clamp(s, -1, +1) * 127.0)
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint16 packSnorm2x8(vec2 const& v)
|
||||
/// @see uint32 packSnorm4x8(vec4 const& v)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL uint8 packSnorm1x8(float s);
|
||||
|
||||
/// First, unpacks a single 8-bit unsigned integer p into a single 8-bit signed integers.
|
||||
/// Then, the value is converted to a normalized floating-point value to generate the returned scalar.
|
||||
///
|
||||
/// The conversion for unpacked fixed-point value f to floating point is done as follows:
|
||||
/// unpackSnorm1x8: clamp(f / 127.0, -1, +1)
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec2 unpackSnorm2x8(uint16 p)
|
||||
/// @see vec4 unpackSnorm4x8(uint32 p)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL float unpackSnorm1x8(uint8 p);
|
||||
|
||||
/// First, converts each component of the normalized floating-point value v into 8-bit integer values.
|
||||
/// Then, the results are packed into the returned 16-bit 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.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint8 packSnorm1x8(float const& v)
|
||||
/// @see uint32 packSnorm4x8(vec4 const& v)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL uint16 packSnorm2x8(vec2 const& v);
|
||||
|
||||
/// First, unpacks a single 16-bit unsigned integer p into a pair of 8-bit signed integers.
|
||||
/// Then, each component is converted to a normalized floating-point value to generate the returned two-component vector.
|
||||
///
|
||||
/// The conversion for unpacked fixed-point 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.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see float unpackSnorm1x8(uint8 p)
|
||||
/// @see vec4 unpackSnorm4x8(uint32 p)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL vec2 unpackSnorm2x8(uint16 p);
|
||||
|
||||
/// First, converts the normalized floating-point value v into a 16-bit integer value.
|
||||
/// Then, the results are packed into the returned 16-bit unsigned integer.
|
||||
///
|
||||
/// The conversion for component c of v to fixed point is done as follows:
|
||||
/// packUnorm1x16: round(clamp(c, 0, +1) * 65535.0)
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint16 packSnorm1x16(float const& v)
|
||||
/// @see uint64 packSnorm4x16(vec4 const& v)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL uint16 packUnorm1x16(float v);
|
||||
|
||||
/// First, unpacks a single 16-bit unsigned integer p into a of 16-bit unsigned integers.
|
||||
/// Then, the value is converted to a normalized floating-point value to generate the returned scalar.
|
||||
///
|
||||
/// The conversion for unpacked fixed-point value f to floating point is done as follows:
|
||||
/// unpackUnorm1x16: f / 65535.0
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec2 unpackUnorm2x16(uint32 p)
|
||||
/// @see vec4 unpackUnorm4x16(uint64 p)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL float unpackUnorm1x16(uint16 p);
|
||||
|
||||
/// First, converts each component of the normalized floating-point value v into 16-bit integer values.
|
||||
/// Then, the results are packed into the returned 64-bit 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.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint16 packUnorm1x16(float const& v)
|
||||
/// @see uint32 packUnorm2x16(vec2 const& v)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL uint64 packUnorm4x16(vec4 const& v);
|
||||
|
||||
/// First, unpacks a single 64-bit unsigned integer p into four 16-bit unsigned integers.
|
||||
/// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
|
||||
///
|
||||
/// The conversion for unpacked fixed-point 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.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see float unpackUnorm1x16(uint16 p)
|
||||
/// @see vec2 unpackUnorm2x16(uint32 p)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL vec4 unpackUnorm4x16(uint64 p);
|
||||
|
||||
/// First, converts the normalized floating-point value v into 16-bit integer value.
|
||||
/// Then, the results are packed into the returned 16-bit unsigned integer.
|
||||
///
|
||||
/// The conversion to fixed point is done as follows:
|
||||
/// packSnorm1x8: round(clamp(s, -1, +1) * 32767.0)
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint32 packSnorm2x16(vec2 const& v)
|
||||
/// @see uint64 packSnorm4x16(vec4 const& v)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL uint16 packSnorm1x16(float v);
|
||||
|
||||
/// First, unpacks a single 16-bit unsigned integer p into a single 16-bit signed integers.
|
||||
/// Then, each component is converted to a normalized floating-point value to generate the returned scalar.
|
||||
///
|
||||
/// The conversion for unpacked fixed-point value f to floating point is done as follows:
|
||||
/// unpackSnorm1x16: clamp(f / 32767.0, -1, +1)
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec2 unpackSnorm2x16(uint32 p)
|
||||
/// @see vec4 unpackSnorm4x16(uint64 p)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm1x16.xml">GLSL unpackSnorm4x8 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL float unpackSnorm1x16(uint16 p);
|
||||
|
||||
/// First, converts each component of the normalized floating-point value v into 16-bit integer values.
|
||||
/// Then, the results are packed into the returned 64-bit 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.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint16 packSnorm1x16(float const& v)
|
||||
/// @see uint32 packSnorm2x16(vec2 const& v)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL uint64 packSnorm4x16(vec4 const& v);
|
||||
|
||||
/// First, unpacks a single 64-bit unsigned integer p into four 16-bit signed integers.
|
||||
/// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
|
||||
///
|
||||
/// The conversion for unpacked fixed-point 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.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see float unpackSnorm1x16(uint16 p)
|
||||
/// @see vec2 unpackSnorm2x16(uint32 p)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm2x16.xml">GLSL unpackSnorm4x8 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL vec4 unpackSnorm4x16(uint64 p);
|
||||
|
||||
/// First, converts the first three components of the normalized floating-point value v into 10-bit signed integer values.
|
||||
/// Then, converts the forth component of the normalized floating-point value v into 2-bit signed integer values.
|
||||
/// Then, the results are packed into the returned 32-bit 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 least-significant bits of the result;
|
||||
/// the forth component specifies the 2 most-significant bits.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec4 unpackSnorm3x10_1x2(uint32 const& p)
|
||||
/// @see uint32 packUnorm3x10_1x2(vec4 const& v)
|
||||
/// @see uint32 packU3x10_1x2(uvec4 const& v)
|
||||
/// @see uint32 packI3x10_1x2(ivec4 const& v)
|
||||
GLM_FUNC_DECL uint32 packSnorm3x10_1x2(vec4 const& v);
|
||||
|
||||
/// First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers.
|
||||
/// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
|
||||
///
|
||||
/// The conversion for unpacked fixed-point 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.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint32 packSnorm3x10_1x2(vec4 const& v)
|
||||
/// @see vec4 unpackUnorm3x10_1x2(uint32 const& p))
|
||||
/// @see uvec4 unpackI3x10_1x2(uint32 const& p)
|
||||
/// @see uvec4 unpackU3x10_1x2(uint32 const& p)
|
||||
GLM_FUNC_DECL vec4 unpackSnorm3x10_1x2(uint32 p);
|
||||
|
||||
/// First, converts the first three components of the normalized floating-point value v into 10-bit unsigned integer values.
|
||||
/// Then, converts the forth component of the normalized floating-point value v into 2-bit signed uninteger values.
|
||||
/// Then, the results are packed into the returned 32-bit 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 least-significant bits of the result;
|
||||
/// the forth component specifies the 2 most-significant bits.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec4 unpackUnorm3x10_1x2(uint32 const& p)
|
||||
/// @see uint32 packUnorm3x10_1x2(vec4 const& v)
|
||||
/// @see uint32 packU3x10_1x2(uvec4 const& v)
|
||||
/// @see uint32 packI3x10_1x2(ivec4 const& v)
|
||||
GLM_FUNC_DECL uint32 packUnorm3x10_1x2(vec4 const& v);
|
||||
|
||||
/// First, unpacks a single 32-bit unsigned integer p into four 16-bit signed integers.
|
||||
/// Then, each component is converted to a normalized floating-point value to generate the returned four-component vector.
|
||||
///
|
||||
/// The conversion for unpacked fixed-point 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.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint32 packSnorm3x10_1x2(vec4 const& v)
|
||||
/// @see vec4 unpackInorm3x10_1x2(uint32 const& p))
|
||||
/// @see uvec4 unpackI3x10_1x2(uint32 const& p)
|
||||
/// @see uvec4 unpackU3x10_1x2(uint32 const& p)
|
||||
GLM_FUNC_DECL vec4 unpackUnorm3x10_1x2(uint32 p);
|
||||
|
||||
/// Returns an unsigned integer obtained by converting the components of a floating-point scalar
|
||||
/// to the 16-bit floating-point representation found in the OpenGL Specification,
|
||||
/// and then packing this 16-bit value into a 16-bit unsigned integer.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint32 packHalf2x16(vec2 const& v)
|
||||
/// @see uint64 packHalf4x16(vec4 const& v)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packHalf2x16.xml">GLSL packHalf2x16 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL uint16 packHalf1x16(float v);
|
||||
|
||||
/// Returns a floating-point scalar with components obtained by unpacking a 16-bit unsigned integer into a 16-bit value,
|
||||
/// interpreted as a 16-bit floating-point number according to the OpenGL Specification,
|
||||
/// and converting it to 32-bit floating-point values.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec2 unpackHalf2x16(uint32 const& v)
|
||||
/// @see vec4 unpackHalf4x16(uint64 const& v)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackHalf2x16.xml">GLSL unpackHalf2x16 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL float unpackHalf1x16(uint16 v);
|
||||
|
||||
/// Returns an unsigned integer obtained by converting the components of a four-component floating-point vector
|
||||
/// to the 16-bit floating-point representation found in the OpenGL Specification,
|
||||
/// and then packing these four 16-bit values into a 64-bit unsigned integer.
|
||||
/// The first vector component specifies the 16 least-significant bits of the result;
|
||||
/// the forth component specifies the 16 most-significant bits.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint16 packHalf1x16(float const& v)
|
||||
/// @see uint32 packHalf2x16(vec2 const& v)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packHalf2x16.xml">GLSL packHalf2x16 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL uint64 packHalf4x16(vec4 const& v);
|
||||
|
||||
/// Returns a four-component floating-point vector with components obtained by unpacking a 64-bit unsigned integer into four 16-bit values,
|
||||
/// interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification,
|
||||
/// and converting them to 32-bit floating-point values.
|
||||
/// The first component of the vector is obtained from the 16 least-significant bits of v;
|
||||
/// the forth component is obtained from the 16 most-significant bits of v.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see float unpackHalf1x16(uint16 const& v)
|
||||
/// @see vec2 unpackHalf2x16(uint32 const& v)
|
||||
/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackHalf2x16.xml">GLSL unpackHalf2x16 man page</a>
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
GLM_FUNC_DECL vec4 unpackHalf4x16(uint64 p);
|
||||
|
||||
|
||||
|
||||
/// First, converts the first two components of the normalized floating-point value v into 11-bit signless floating-point values.
|
||||
/// Then, converts the third component of the normalized floating-point value v into a 10-bit signless floating-point value.
|
||||
/// Then, the results are packed into the returned 32-bit unsigned integer.
|
||||
///
|
||||
/// The first vector component specifies the 11 least-significant bits of the result;
|
||||
/// the last component specifies the 10 most-significant bits.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec3 unpackF2x11_1x10(uint32 const& p)
|
||||
GLM_FUNC_DECL uint32 packF2x11_1x10(vec3 const& v);
|
||||
|
||||
/// First, unpacks a single 32-bit unsigned integer p into two 11-bit signless floating-point values and one 10-bit signless floating-point value .
|
||||
/// Then, each component is converted to a normalized floating-point value to generate the returned three-component 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.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint32 packF2x11_1x10(vec3 const& v)
|
||||
GLM_FUNC_DECL vec3 unpackF2x11_1x10(uint32 p);
|
||||
|
||||
|
||||
/// First, converts the first two components of the normalized floating-point value v into 11-bit signless floating-point values.
|
||||
/// Then, converts the third component of the normalized floating-point value v into a 10-bit signless floating-point value.
|
||||
/// Then, the results are packed into the returned 32-bit unsigned integer.
|
||||
///
|
||||
/// The first vector component specifies the 11 least-significant bits of the result;
|
||||
/// the last component specifies the 10 most-significant bits.
|
||||
///
|
||||
/// packF3x9_E1x5 allows encoding into RGBE / RGB9E5 format
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec3 unpackF3x9_E1x5(uint32 const& p)
|
||||
GLM_FUNC_DECL uint32 packF3x9_E1x5(vec3 const& v);
|
||||
|
||||
/// First, unpacks a single 32-bit unsigned integer p into two 11-bit signless floating-point values and one 10-bit signless floating-point value .
|
||||
/// Then, each component is converted to a normalized floating-point value to generate the returned three-component 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
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint32 packF3x9_E1x5(vec3 const& v)
|
||||
GLM_FUNC_DECL vec3 unpackF3x9_E1x5(uint32 p);
|
||||
|
||||
/// Convert each component of the normalized floating-point vector into unsigned integer values.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec2 unpackUnorm2x4(uint8 p)
|
||||
GLM_FUNC_DECL uint8 packUnorm2x4(vec2 const& v);
|
||||
|
||||
/// Convert a packed integer to a normalized floating-point vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint8 packUnorm2x4(vec2 const& v)
|
||||
GLM_FUNC_DECL vec2 unpackUnorm2x4(uint8 p);
|
||||
|
||||
/// Convert each component of the normalized floating-point vector into unsigned integer values.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec4 unpackUnorm4x4(uint16 p)
|
||||
GLM_FUNC_DECL uint16 packUnorm4x4(vec4 const& v);
|
||||
|
||||
/// Convert a packed integer to a normalized floating-point vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint16 packUnorm4x4(vec4 const& v)
|
||||
GLM_FUNC_DECL vec4 unpackUnorm4x4(uint16 p);
|
||||
|
||||
/// Convert each component of the normalized floating-point vector into unsigned integer values.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec3 unpackUnorm1x5_1x6_1x5(uint16 p)
|
||||
GLM_FUNC_DECL uint16 packUnorm1x5_1x6_1x5(vec3 const& v);
|
||||
|
||||
/// Convert a packed integer to a normalized floating-point vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint16 packUnorm1x5_1x6_1x5(vec3 const& v)
|
||||
GLM_FUNC_DECL vec3 unpackUnorm1x5_1x6_1x5(uint16 p);
|
||||
|
||||
/// Convert each component of the normalized floating-point vector into unsigned integer values.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec4 unpackUnorm3x5_1x1(uint16 p)
|
||||
GLM_FUNC_DECL uint16 packUnorm3x5_1x1(vec4 const& v);
|
||||
|
||||
/// Convert a packed integer to a normalized floating-point vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint16 packUnorm3x5_1x1(vec4 const& v)
|
||||
GLM_FUNC_DECL vec4 unpackUnorm3x5_1x1(uint16 p);
|
||||
|
||||
/// Convert each component of the normalized floating-point vector into unsigned integer values.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec3 unpackUnorm2x3_1x2(uint8 p)
|
||||
GLM_FUNC_DECL uint8 packUnorm2x3_1x2(vec3 const& v);
|
||||
|
||||
/// Convert a packed integer to a normalized floating-point vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint8 packUnorm2x3_1x2(vec3 const& v)
|
||||
GLM_FUNC_DECL vec3 unpackUnorm2x3_1x2(uint8 p);
|
||||
|
||||
/// @}
|
||||
}// namespace glm
|
||||
|
||||
#include "packing.inl"
|
||||
938
glm/ext/packing.inl
Normal file
938
glm/ext/packing.inl
Normal file
@ -0,0 +1,938 @@
|
||||
/// @ref gtc_packing
|
||||
|
||||
#include "../ext/scalar_relational.hpp"
|
||||
#include "../ext/vector_relational.hpp"
|
||||
#include "../common.hpp"
|
||||
#include "../vec2.hpp"
|
||||
#include "../vec3.hpp"
|
||||
#include "../vec4.hpp"
|
||||
#include "../detail/type_half.hpp"
|
||||
#include <cstring>
|
||||
#include <limits>
|
||||
|
||||
namespace glm{
|
||||
namespace detail
|
||||
{
|
||||
GLM_FUNC_QUALIFIER glm::uint16 float2half(glm::uint32 f)
|
||||
{
|
||||
// 10 bits => EE EEEFFFFF
|
||||
// 11 bits => EEE EEFFFFFF
|
||||
// Half bits => SEEEEEFF FFFFFFFF
|
||||
// Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF
|
||||
|
||||
// 0x00007c00 => 00000000 00000000 01111100 00000000
|
||||
// 0x000003ff => 00000000 00000000 00000011 11111111
|
||||
// 0x38000000 => 00111000 00000000 00000000 00000000
|
||||
// 0x7f800000 => 01111111 10000000 00000000 00000000
|
||||
// 0x00008000 => 00000000 00000000 10000000 00000000
|
||||
return
|
||||
((f >> 16) & 0x8000) | // sign
|
||||
((((f & 0x7f800000) - 0x38000000) >> 13) & 0x7c00) | // exponential
|
||||
((f >> 13) & 0x03ff); // Mantissa
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER glm::uint32 float2packed11(glm::uint32 f)
|
||||
{
|
||||
// 10 bits => EE EEEFFFFF
|
||||
// 11 bits => EEE EEFFFFFF
|
||||
// Half bits => SEEEEEFF FFFFFFFF
|
||||
// Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF
|
||||
|
||||
// 0x000007c0 => 00000000 00000000 00000111 11000000
|
||||
// 0x00007c00 => 00000000 00000000 01111100 00000000
|
||||
// 0x000003ff => 00000000 00000000 00000011 11111111
|
||||
// 0x38000000 => 00111000 00000000 00000000 00000000
|
||||
// 0x7f800000 => 01111111 10000000 00000000 00000000
|
||||
// 0x00008000 => 00000000 00000000 10000000 00000000
|
||||
return
|
||||
((((f & 0x7f800000) - 0x38000000) >> 17) & 0x07c0) | // exponential
|
||||
((f >> 17) & 0x003f); // Mantissa
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER glm::uint32 packed11ToFloat(glm::uint32 p)
|
||||
{
|
||||
// 10 bits => EE EEEFFFFF
|
||||
// 11 bits => EEE EEFFFFFF
|
||||
// Half bits => SEEEEEFF FFFFFFFF
|
||||
// Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF
|
||||
|
||||
// 0x000007c0 => 00000000 00000000 00000111 11000000
|
||||
// 0x00007c00 => 00000000 00000000 01111100 00000000
|
||||
// 0x000003ff => 00000000 00000000 00000011 11111111
|
||||
// 0x38000000 => 00111000 00000000 00000000 00000000
|
||||
// 0x7f800000 => 01111111 10000000 00000000 00000000
|
||||
// 0x00008000 => 00000000 00000000 10000000 00000000
|
||||
return
|
||||
((((p & 0x07c0) << 17) + 0x38000000) & 0x7f800000) | // exponential
|
||||
((p & 0x003f) << 17); // Mantissa
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER glm::uint32 float2packed10(glm::uint32 f)
|
||||
{
|
||||
// 10 bits => EE EEEFFFFF
|
||||
// 11 bits => EEE EEFFFFFF
|
||||
// Half bits => SEEEEEFF FFFFFFFF
|
||||
// Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF
|
||||
|
||||
// 0x0000001F => 00000000 00000000 00000000 00011111
|
||||
// 0x0000003F => 00000000 00000000 00000000 00111111
|
||||
// 0x000003E0 => 00000000 00000000 00000011 11100000
|
||||
// 0x000007C0 => 00000000 00000000 00000111 11000000
|
||||
// 0x00007C00 => 00000000 00000000 01111100 00000000
|
||||
// 0x000003FF => 00000000 00000000 00000011 11111111
|
||||
// 0x38000000 => 00111000 00000000 00000000 00000000
|
||||
// 0x7f800000 => 01111111 10000000 00000000 00000000
|
||||
// 0x00008000 => 00000000 00000000 10000000 00000000
|
||||
return
|
||||
((((f & 0x7f800000) - 0x38000000) >> 18) & 0x03E0) | // exponential
|
||||
((f >> 18) & 0x001f); // Mantissa
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER glm::uint32 packed10ToFloat(glm::uint32 p)
|
||||
{
|
||||
// 10 bits => EE EEEFFFFF
|
||||
// 11 bits => EEE EEFFFFFF
|
||||
// Half bits => SEEEEEFF FFFFFFFF
|
||||
// Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF
|
||||
|
||||
// 0x0000001F => 00000000 00000000 00000000 00011111
|
||||
// 0x0000003F => 00000000 00000000 00000000 00111111
|
||||
// 0x000003E0 => 00000000 00000000 00000011 11100000
|
||||
// 0x000007C0 => 00000000 00000000 00000111 11000000
|
||||
// 0x00007C00 => 00000000 00000000 01111100 00000000
|
||||
// 0x000003FF => 00000000 00000000 00000011 11111111
|
||||
// 0x38000000 => 00111000 00000000 00000000 00000000
|
||||
// 0x7f800000 => 01111111 10000000 00000000 00000000
|
||||
// 0x00008000 => 00000000 00000000 10000000 00000000
|
||||
return
|
||||
((((p & 0x03E0) << 18) + 0x38000000) & 0x7f800000) | // exponential
|
||||
((p & 0x001f) << 18); // Mantissa
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER glm::uint half2float(glm::uint h)
|
||||
{
|
||||
return ((h & 0x8000) << 16) | ((( h & 0x7c00) + 0x1C000) << 13) | ((h & 0x03FF) << 13);
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER glm::uint floatTo11bit(float x)
|
||||
{
|
||||
if(x == 0.0f)
|
||||
return 0u;
|
||||
else if(glm::isnan(x))
|
||||
return ~0u;
|
||||
else if(glm::isinf(x))
|
||||
return 0x1Fu << 6u;
|
||||
|
||||
uint Pack = 0u;
|
||||
memcpy(&Pack, &x, sizeof(Pack));
|
||||
return float2packed11(Pack);
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER float packed11bitToFloat(glm::uint x)
|
||||
{
|
||||
if(x == 0)
|
||||
return 0.0f;
|
||||
else if(x == ((1 << 11) - 1))
|
||||
return ~0;//NaN
|
||||
else if(x == (0x1f << 6))
|
||||
return ~0;//Inf
|
||||
|
||||
uint Result = packed11ToFloat(x);
|
||||
|
||||
float Temp = 0;
|
||||
memcpy(&Temp, &Result, sizeof(Temp));
|
||||
return Temp;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER glm::uint floatTo10bit(float x)
|
||||
{
|
||||
if(x == 0.0f)
|
||||
return 0u;
|
||||
else if(glm::isnan(x))
|
||||
return ~0u;
|
||||
else if(glm::isinf(x))
|
||||
return 0x1Fu << 5u;
|
||||
|
||||
uint Pack = 0;
|
||||
memcpy(&Pack, &x, sizeof(Pack));
|
||||
return float2packed10(Pack);
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER float packed10bitToFloat(glm::uint x)
|
||||
{
|
||||
if(x == 0)
|
||||
return 0.0f;
|
||||
else if(x == ((1 << 10) - 1))
|
||||
return ~0;//NaN
|
||||
else if(x == (0x1f << 5))
|
||||
return ~0;//Inf
|
||||
|
||||
uint Result = packed10ToFloat(x);
|
||||
|
||||
float Temp = 0;
|
||||
memcpy(&Temp, &Result, sizeof(Temp));
|
||||
return Temp;
|
||||
}
|
||||
|
||||
// GLM_FUNC_QUALIFIER glm::uint f11_f11_f10(float x, float y, float z)
|
||||
// {
|
||||
// return ((floatTo11bit(x) & ((1 << 11) - 1)) << 0) | ((floatTo11bit(y) & ((1 << 11) - 1)) << 11) | ((floatTo10bit(z) & ((1 << 10) - 1)) << 22);
|
||||
// }
|
||||
|
||||
union u3u3u2
|
||||
{
|
||||
struct
|
||||
{
|
||||
uint x : 3;
|
||||
uint y : 3;
|
||||
uint z : 2;
|
||||
} data;
|
||||
uint8 pack;
|
||||
};
|
||||
|
||||
union u4u4
|
||||
{
|
||||
struct
|
||||
{
|
||||
uint x : 4;
|
||||
uint y : 4;
|
||||
} data;
|
||||
uint8 pack;
|
||||
};
|
||||
|
||||
union u4u4u4u4
|
||||
{
|
||||
struct
|
||||
{
|
||||
uint x : 4;
|
||||
uint y : 4;
|
||||
uint z : 4;
|
||||
uint w : 4;
|
||||
} data;
|
||||
uint16 pack;
|
||||
};
|
||||
|
||||
union u5u6u5
|
||||
{
|
||||
struct
|
||||
{
|
||||
uint x : 5;
|
||||
uint y : 6;
|
||||
uint z : 5;
|
||||
} data;
|
||||
uint16 pack;
|
||||
};
|
||||
|
||||
union u5u5u5u1
|
||||
{
|
||||
struct
|
||||
{
|
||||
uint x : 5;
|
||||
uint y : 5;
|
||||
uint z : 5;
|
||||
uint w : 1;
|
||||
} data;
|
||||
uint16 pack;
|
||||
};
|
||||
|
||||
union u10u10u10u2
|
||||
{
|
||||
struct
|
||||
{
|
||||
uint x : 10;
|
||||
uint y : 10;
|
||||
uint z : 10;
|
||||
uint w : 2;
|
||||
} data;
|
||||
uint32 pack;
|
||||
};
|
||||
|
||||
union i10i10i10i2
|
||||
{
|
||||
struct
|
||||
{
|
||||
int x : 10;
|
||||
int y : 10;
|
||||
int z : 10;
|
||||
int w : 2;
|
||||
} data;
|
||||
uint32 pack;
|
||||
};
|
||||
|
||||
union u9u9u9e5
|
||||
{
|
||||
struct
|
||||
{
|
||||
uint x : 9;
|
||||
uint y : 9;
|
||||
uint z : 9;
|
||||
uint w : 5;
|
||||
} data;
|
||||
uint32 pack;
|
||||
};
|
||||
|
||||
template<length_t L, qualifier Q>
|
||||
struct compute_half
|
||||
{};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_half<1, Q>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<1, uint16, Q> pack(vec<1, float, Q> const& v)
|
||||
{
|
||||
int16 const Unpack(detail::toFloat16(v.x));
|
||||
u16vec1 Packed;
|
||||
memcpy(&Packed, &Unpack, sizeof(Packed));
|
||||
return Packed;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER static vec<1, float, Q> unpack(vec<1, uint16, Q> const& v)
|
||||
{
|
||||
i16vec1 Unpack;
|
||||
memcpy(&Unpack, &v, sizeof(Unpack));
|
||||
return vec<1, float, Q>(detail::toFloat32(v.x));
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_half<2, Q>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<2, uint16, Q> pack(vec<2, float, Q> const& v)
|
||||
{
|
||||
vec<2, int16, Q> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y));
|
||||
u16vec2 Packed;
|
||||
memcpy(&Packed, &Unpack, sizeof(Packed));
|
||||
return Packed;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER static vec<2, float, Q> unpack(vec<2, uint16, Q> const& v)
|
||||
{
|
||||
i16vec2 Unpack;
|
||||
memcpy(&Unpack, &v, sizeof(Unpack));
|
||||
return vec<2, float, Q>(detail::toFloat32(v.x), detail::toFloat32(v.y));
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_half<3, Q>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<3, uint16, Q> pack(vec<3, float, Q> const& v)
|
||||
{
|
||||
vec<3, int16, Q> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z));
|
||||
u16vec3 Packed;
|
||||
memcpy(&Packed, &Unpack, sizeof(Packed));
|
||||
return Packed;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER static vec<3, float, Q> unpack(vec<3, uint16, Q> const& v)
|
||||
{
|
||||
i16vec3 Unpack;
|
||||
memcpy(&Unpack, &v, sizeof(Unpack));
|
||||
return vec<3, float, Q>(detail::toFloat32(v.x), detail::toFloat32(v.y), detail::toFloat32(v.z));
|
||||
}
|
||||
};
|
||||
|
||||
template<qualifier Q>
|
||||
struct compute_half<4, Q>
|
||||
{
|
||||
GLM_FUNC_QUALIFIER static vec<4, uint16, Q> pack(vec<4, float, Q> const& v)
|
||||
{
|
||||
vec<4, int16, Q> const Unpack(detail::toFloat16(v.x), detail::toFloat16(v.y), detail::toFloat16(v.z), detail::toFloat16(v.w));
|
||||
u16vec4 Packed;
|
||||
memcpy(&Packed, &Unpack, sizeof(Packed));
|
||||
return Packed;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER static vec<4, float, Q> unpack(vec<4, uint16, Q> const& v)
|
||||
{
|
||||
i16vec4 Unpack;
|
||||
memcpy(&Unpack, &v, sizeof(Unpack));
|
||||
return vec<4, float, Q>(detail::toFloat32(v.x), detail::toFloat32(v.y), detail::toFloat32(v.z), detail::toFloat32(v.w));
|
||||
}
|
||||
};
|
||||
}//namespace detail
|
||||
|
||||
GLM_FUNC_QUALIFIER uint8 packUnorm1x8(float v)
|
||||
{
|
||||
return static_cast<uint8>(round(clamp(v, 0.0f, 1.0f) * 255.0f));
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER float unpackUnorm1x8(uint8 p)
|
||||
{
|
||||
float const Unpack(p);
|
||||
return Unpack * static_cast<float>(0.0039215686274509803921568627451); // 1 / 255
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint16 packUnorm2x8(vec2 const& v)
|
||||
{
|
||||
u8vec2 const Topack(round(clamp(v, 0.0f, 1.0f) * 255.0f));
|
||||
|
||||
uint16 Unpack = 0;
|
||||
memcpy(&Unpack, &Topack, sizeof(Unpack));
|
||||
return Unpack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER vec2 unpackUnorm2x8(uint16 p)
|
||||
{
|
||||
u8vec2 Unpack;
|
||||
memcpy(&Unpack, &p, sizeof(Unpack));
|
||||
return vec2(Unpack) * float(0.0039215686274509803921568627451); // 1 / 255
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint8 packSnorm1x8(float v)
|
||||
{
|
||||
int8 const Topack(static_cast<int8>(round(clamp(v ,-1.0f, 1.0f) * 127.0f)));
|
||||
uint8 Packed = 0;
|
||||
memcpy(&Packed, &Topack, sizeof(Packed));
|
||||
return Packed;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER float unpackSnorm1x8(uint8 p)
|
||||
{
|
||||
int8 Unpack = 0;
|
||||
memcpy(&Unpack, &p, sizeof(Unpack));
|
||||
return clamp(
|
||||
static_cast<float>(Unpack) * 0.00787401574803149606299212598425f, // 1.0f / 127.0f
|
||||
-1.0f, 1.0f);
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint16 packSnorm2x8(vec2 const& v)
|
||||
{
|
||||
i8vec2 const Topack(round(clamp(v, -1.0f, 1.0f) * 127.0f));
|
||||
uint16 Packed = 0;
|
||||
memcpy(&Packed, &Topack, sizeof(Packed));
|
||||
return Packed;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER vec2 unpackSnorm2x8(uint16 p)
|
||||
{
|
||||
i8vec2 Unpack;
|
||||
memcpy(&Unpack, &p, sizeof(Unpack));
|
||||
return clamp(
|
||||
vec2(Unpack) * 0.00787401574803149606299212598425f, // 1.0f / 127.0f
|
||||
-1.0f, 1.0f);
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint16 packUnorm1x16(float s)
|
||||
{
|
||||
return static_cast<uint16>(round(clamp(s, 0.0f, 1.0f) * 65535.0f));
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER float unpackUnorm1x16(uint16 p)
|
||||
{
|
||||
float const Unpack(p);
|
||||
return Unpack * 1.5259021896696421759365224689097e-5f; // 1.0 / 65535.0
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint64 packUnorm4x16(vec4 const& v)
|
||||
{
|
||||
u16vec4 const Topack(round(clamp(v , 0.0f, 1.0f) * 65535.0f));
|
||||
uint64 Packed = 0;
|
||||
memcpy(&Packed, &Topack, sizeof(Packed));
|
||||
return Packed;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER vec4 unpackUnorm4x16(uint64 p)
|
||||
{
|
||||
u16vec4 Unpack;
|
||||
memcpy(&Unpack, &p, sizeof(Unpack));
|
||||
return vec4(Unpack) * 1.5259021896696421759365224689097e-5f; // 1.0 / 65535.0
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint16 packSnorm1x16(float v)
|
||||
{
|
||||
int16 const Topack = static_cast<int16>(round(clamp(v ,-1.0f, 1.0f) * 32767.0f));
|
||||
uint16 Packed = 0;
|
||||
memcpy(&Packed, &Topack, sizeof(Packed));
|
||||
return Packed;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER float unpackSnorm1x16(uint16 p)
|
||||
{
|
||||
int16 Unpack = 0;
|
||||
memcpy(&Unpack, &p, sizeof(Unpack));
|
||||
return clamp(
|
||||
static_cast<float>(Unpack) * 3.0518509475997192297128208258309e-5f, //1.0f / 32767.0f,
|
||||
-1.0f, 1.0f);
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint64 packSnorm4x16(vec4 const& v)
|
||||
{
|
||||
i16vec4 const Topack(round(clamp(v ,-1.0f, 1.0f) * 32767.0f));
|
||||
uint64 Packed = 0;
|
||||
memcpy(&Packed, &Topack, sizeof(Packed));
|
||||
return Packed;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER vec4 unpackSnorm4x16(uint64 p)
|
||||
{
|
||||
i16vec4 Unpack;
|
||||
memcpy(&Unpack, &p, sizeof(Unpack));
|
||||
return clamp(
|
||||
vec4(Unpack) * 3.0518509475997192297128208258309e-5f, //1.0f / 32767.0f,
|
||||
-1.0f, 1.0f);
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint16 packHalf1x16(float v)
|
||||
{
|
||||
int16 const Topack(detail::toFloat16(v));
|
||||
uint16 Packed = 0;
|
||||
memcpy(&Packed, &Topack, sizeof(Packed));
|
||||
return Packed;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER float unpackHalf1x16(uint16 v)
|
||||
{
|
||||
int16 Unpack = 0;
|
||||
memcpy(&Unpack, &v, sizeof(Unpack));
|
||||
return detail::toFloat32(Unpack);
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint64 packHalf4x16(glm::vec4 const& v)
|
||||
{
|
||||
i16vec4 const Unpack(
|
||||
detail::toFloat16(v.x),
|
||||
detail::toFloat16(v.y),
|
||||
detail::toFloat16(v.z),
|
||||
detail::toFloat16(v.w));
|
||||
uint64 Packed = 0;
|
||||
memcpy(&Packed, &Unpack, sizeof(Packed));
|
||||
return Packed;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER glm::vec4 unpackHalf4x16(uint64 v)
|
||||
{
|
||||
i16vec4 Unpack;
|
||||
memcpy(&Unpack, &v, sizeof(Unpack));
|
||||
return vec4(
|
||||
detail::toFloat32(Unpack.x),
|
||||
detail::toFloat32(Unpack.y),
|
||||
detail::toFloat32(Unpack.z),
|
||||
detail::toFloat32(Unpack.w));
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint32 packI3x10_1x2(ivec4 const& v)
|
||||
{
|
||||
detail::i10i10i10i2 Result;
|
||||
Result.data.x = v.x;
|
||||
Result.data.y = v.y;
|
||||
Result.data.z = v.z;
|
||||
Result.data.w = v.w;
|
||||
return Result.pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER ivec4 unpackI3x10_1x2(uint32 v)
|
||||
{
|
||||
detail::i10i10i10i2 Unpack;
|
||||
Unpack.pack = v;
|
||||
return ivec4(
|
||||
Unpack.data.x,
|
||||
Unpack.data.y,
|
||||
Unpack.data.z,
|
||||
Unpack.data.w);
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint32 packU3x10_1x2(uvec4 const& v)
|
||||
{
|
||||
detail::u10u10u10u2 Result;
|
||||
Result.data.x = v.x;
|
||||
Result.data.y = v.y;
|
||||
Result.data.z = v.z;
|
||||
Result.data.w = v.w;
|
||||
return Result.pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uvec4 unpackU3x10_1x2(uint32 v)
|
||||
{
|
||||
detail::u10u10u10u2 Unpack;
|
||||
Unpack.pack = v;
|
||||
return uvec4(
|
||||
Unpack.data.x,
|
||||
Unpack.data.y,
|
||||
Unpack.data.z,
|
||||
Unpack.data.w);
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint32 packSnorm3x10_1x2(vec4 const& v)
|
||||
{
|
||||
ivec4 const Pack(round(clamp(v,-1.0f, 1.0f) * vec4(511.f, 511.f, 511.f, 1.f)));
|
||||
|
||||
detail::i10i10i10i2 Result;
|
||||
Result.data.x = Pack.x;
|
||||
Result.data.y = Pack.y;
|
||||
Result.data.z = Pack.z;
|
||||
Result.data.w = Pack.w;
|
||||
return Result.pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER vec4 unpackSnorm3x10_1x2(uint32 v)
|
||||
{
|
||||
detail::i10i10i10i2 Unpack;
|
||||
Unpack.pack = v;
|
||||
|
||||
vec4 const Result(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w);
|
||||
|
||||
return clamp(Result * vec4(1.f / 511.f, 1.f / 511.f, 1.f / 511.f, 1.f), -1.0f, 1.0f);
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint32 packUnorm3x10_1x2(vec4 const& v)
|
||||
{
|
||||
uvec4 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec4(1023.f, 1023.f, 1023.f, 3.f)));
|
||||
|
||||
detail::u10u10u10u2 Result;
|
||||
Result.data.x = Unpack.x;
|
||||
Result.data.y = Unpack.y;
|
||||
Result.data.z = Unpack.z;
|
||||
Result.data.w = Unpack.w;
|
||||
return Result.pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER vec4 unpackUnorm3x10_1x2(uint32 v)
|
||||
{
|
||||
vec4 const ScaleFactors(1.0f / 1023.f, 1.0f / 1023.f, 1.0f / 1023.f, 1.0f / 3.f);
|
||||
|
||||
detail::u10u10u10u2 Unpack;
|
||||
Unpack.pack = v;
|
||||
return vec4(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w) * ScaleFactors;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint32 packF2x11_1x10(vec3 const& v)
|
||||
{
|
||||
return
|
||||
((detail::floatTo11bit(v.x) & ((1 << 11) - 1)) << 0) |
|
||||
((detail::floatTo11bit(v.y) & ((1 << 11) - 1)) << 11) |
|
||||
((detail::floatTo10bit(v.z) & ((1 << 10) - 1)) << 22);
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER vec3 unpackF2x11_1x10(uint32 v)
|
||||
{
|
||||
return vec3(
|
||||
detail::packed11bitToFloat(v >> 0),
|
||||
detail::packed11bitToFloat(v >> 11),
|
||||
detail::packed10bitToFloat(v >> 22));
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint32 packF3x9_E1x5(vec3 const& v)
|
||||
{
|
||||
float const SharedExpMax = (pow(2.0f, 9.0f - 1.0f) / pow(2.0f, 9.0f)) * pow(2.0f, 31.f - 15.f);
|
||||
vec3 const Color = clamp(v, 0.0f, SharedExpMax);
|
||||
float const MaxColor = max(Color.x, max(Color.y, Color.z));
|
||||
|
||||
float const ExpSharedP = max(-15.f - 1.f, floor(log2(MaxColor))) + 1.0f + 15.f;
|
||||
float const MaxShared = floor(MaxColor / pow(2.0f, (ExpSharedP - 15.f - 9.f)) + 0.5f);
|
||||
float const ExpShared = equal(MaxShared, pow(2.0f, 9.0f), epsilon<float>()) ? ExpSharedP + 1.0f : ExpSharedP;
|
||||
|
||||
uvec3 const ColorComp(floor(Color / pow(2.f, (ExpShared - 15.f - 9.f)) + 0.5f));
|
||||
|
||||
detail::u9u9u9e5 Unpack;
|
||||
Unpack.data.x = ColorComp.x;
|
||||
Unpack.data.y = ColorComp.y;
|
||||
Unpack.data.z = ColorComp.z;
|
||||
Unpack.data.w = uint(ExpShared);
|
||||
return Unpack.pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER vec3 unpackF3x9_E1x5(uint32 v)
|
||||
{
|
||||
detail::u9u9u9e5 Unpack;
|
||||
Unpack.pack = v;
|
||||
|
||||
return vec3(Unpack.data.x, Unpack.data.y, Unpack.data.z) * pow(2.0f, Unpack.data.w - 15.f - 9.f);
|
||||
}
|
||||
|
||||
// Based on Brian Karis http://graphicrants.blogspot.fr/2009/04/rgbm-color-encoding.html
|
||||
template<typename T, qualifier Q>
|
||||
GLM_FUNC_QUALIFIER vec<4, T, Q> packRGBM(vec<3, T, Q> const& rgb)
|
||||
{
|
||||
vec<3, T, Q> const Color(rgb * static_cast<T>(1.0 / 6.0));
|
||||
T Alpha = clamp(max(max(Color.x, Color.y), max(Color.z, static_cast<T>(1e-6))), static_cast<T>(0), static_cast<T>(1));
|
||||
Alpha = ceil(Alpha * static_cast<T>(255.0)) / static_cast<T>(255.0);
|
||||
return vec<4, T, Q>(Color / Alpha, Alpha);
|
||||
}
|
||||
|
||||
template<typename T, qualifier Q>
|
||||
GLM_FUNC_QUALIFIER vec<3, T, Q> unpackRGBM(vec<4, T, Q> const& rgbm)
|
||||
{
|
||||
return vec<3, T, Q>(rgbm.x, rgbm.y, rgbm.z) * rgbm.w * static_cast<T>(6);
|
||||
}
|
||||
|
||||
template<length_t L, qualifier Q>
|
||||
GLM_FUNC_QUALIFIER vec<L, uint16, Q> packHalf(vec<L, float, Q> const& v)
|
||||
{
|
||||
return detail::compute_half<L, Q>::pack(v);
|
||||
}
|
||||
|
||||
template<length_t L, qualifier Q>
|
||||
GLM_FUNC_QUALIFIER vec<L, float, Q> unpackHalf(vec<L, uint16, Q> const& v)
|
||||
{
|
||||
return detail::compute_half<L, Q>::unpack(v);
|
||||
}
|
||||
|
||||
template<typename uintType, length_t L, typename floatType, qualifier Q>
|
||||
GLM_FUNC_QUALIFIER vec<L, uintType, Q> packUnorm(vec<L, floatType, Q> const& v)
|
||||
{
|
||||
GLM_STATIC_ASSERT(std::numeric_limits<uintType>::is_integer, "uintType must be an integer type");
|
||||
GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
|
||||
|
||||
return vec<L, uintType, Q>(round(clamp(v, static_cast<floatType>(0), static_cast<floatType>(1)) * static_cast<floatType>(std::numeric_limits<uintType>::max())));
|
||||
}
|
||||
|
||||
template<typename floatType, length_t L, typename uintType, qualifier Q>
|
||||
GLM_FUNC_QUALIFIER vec<L, floatType, Q> unpackUnorm(vec<L, uintType, Q> const& v)
|
||||
{
|
||||
GLM_STATIC_ASSERT(std::numeric_limits<uintType>::is_integer, "uintType must be an integer type");
|
||||
GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
|
||||
|
||||
return vec<L, floatType, Q>(v) * (static_cast<floatType>(1) / static_cast<floatType>(std::numeric_limits<uintType>::max()));
|
||||
}
|
||||
|
||||
template<typename intType, length_t L, typename floatType, qualifier Q>
|
||||
GLM_FUNC_QUALIFIER vec<L, intType, Q> packSnorm(vec<L, floatType, Q> const& v)
|
||||
{
|
||||
GLM_STATIC_ASSERT(std::numeric_limits<intType>::is_integer, "uintType must be an integer type");
|
||||
GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
|
||||
|
||||
return vec<L, intType, Q>(round(clamp(v , static_cast<floatType>(-1), static_cast<floatType>(1)) * static_cast<floatType>(std::numeric_limits<intType>::max())));
|
||||
}
|
||||
|
||||
template<typename floatType, length_t L, typename intType, qualifier Q>
|
||||
GLM_FUNC_QUALIFIER vec<L, floatType, Q> unpackSnorm(vec<L, intType, Q> const& v)
|
||||
{
|
||||
GLM_STATIC_ASSERT(std::numeric_limits<intType>::is_integer, "uintType must be an integer type");
|
||||
GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
|
||||
|
||||
return clamp(vec<L, floatType, Q>(v) * (static_cast<floatType>(1) / static_cast<floatType>(std::numeric_limits<intType>::max())), static_cast<floatType>(-1), static_cast<floatType>(1));
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint8 packUnorm2x4(vec2 const& v)
|
||||
{
|
||||
u32vec2 const Unpack(round(clamp(v, 0.0f, 1.0f) * 15.0f));
|
||||
detail::u4u4 Result;
|
||||
Result.data.x = Unpack.x;
|
||||
Result.data.y = Unpack.y;
|
||||
return Result.pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER vec2 unpackUnorm2x4(uint8 v)
|
||||
{
|
||||
float const ScaleFactor(1.f / 15.f);
|
||||
detail::u4u4 Unpack;
|
||||
Unpack.pack = v;
|
||||
return vec2(Unpack.data.x, Unpack.data.y) * ScaleFactor;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint16 packUnorm4x4(vec4 const& v)
|
||||
{
|
||||
u32vec4 const Unpack(round(clamp(v, 0.0f, 1.0f) * 15.0f));
|
||||
detail::u4u4u4u4 Result;
|
||||
Result.data.x = Unpack.x;
|
||||
Result.data.y = Unpack.y;
|
||||
Result.data.z = Unpack.z;
|
||||
Result.data.w = Unpack.w;
|
||||
return Result.pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER vec4 unpackUnorm4x4(uint16 v)
|
||||
{
|
||||
float const ScaleFactor(1.f / 15.f);
|
||||
detail::u4u4u4u4 Unpack;
|
||||
Unpack.pack = v;
|
||||
return vec4(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w) * ScaleFactor;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint16 packUnorm1x5_1x6_1x5(vec3 const& v)
|
||||
{
|
||||
u32vec3 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec3(31.f, 63.f, 31.f)));
|
||||
detail::u5u6u5 Result;
|
||||
Result.data.x = Unpack.x;
|
||||
Result.data.y = Unpack.y;
|
||||
Result.data.z = Unpack.z;
|
||||
return Result.pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER vec3 unpackUnorm1x5_1x6_1x5(uint16 v)
|
||||
{
|
||||
vec3 const ScaleFactor(1.f / 31.f, 1.f / 63.f, 1.f / 31.f);
|
||||
detail::u5u6u5 Unpack;
|
||||
Unpack.pack = v;
|
||||
return vec3(Unpack.data.x, Unpack.data.y, Unpack.data.z) * ScaleFactor;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint16 packUnorm3x5_1x1(vec4 const& v)
|
||||
{
|
||||
u32vec4 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec4(31.f, 31.f, 31.f, 1.f)));
|
||||
detail::u5u5u5u1 Result;
|
||||
Result.data.x = Unpack.x;
|
||||
Result.data.y = Unpack.y;
|
||||
Result.data.z = Unpack.z;
|
||||
Result.data.w = Unpack.w;
|
||||
return Result.pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER vec4 unpackUnorm3x5_1x1(uint16 v)
|
||||
{
|
||||
vec4 const ScaleFactor(1.f / 31.f, 1.f / 31.f, 1.f / 31.f, 1.f);
|
||||
detail::u5u5u5u1 Unpack;
|
||||
Unpack.pack = v;
|
||||
return vec4(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w) * ScaleFactor;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint8 packUnorm2x3_1x2(vec3 const& v)
|
||||
{
|
||||
u32vec3 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec3(7.f, 7.f, 3.f)));
|
||||
detail::u3u3u2 Result;
|
||||
Result.data.x = Unpack.x;
|
||||
Result.data.y = Unpack.y;
|
||||
Result.data.z = Unpack.z;
|
||||
return Result.pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER vec3 unpackUnorm2x3_1x2(uint8 v)
|
||||
{
|
||||
vec3 const ScaleFactor(1.f / 7.f, 1.f / 7.f, 1.f / 3.f);
|
||||
detail::u3u3u2 Unpack;
|
||||
Unpack.pack = v;
|
||||
return vec3(Unpack.data.x, Unpack.data.y, Unpack.data.z) * ScaleFactor;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER int16 packInt2x8(i8vec2 const& v)
|
||||
{
|
||||
int16 Pack = 0;
|
||||
memcpy(&Pack, &v, sizeof(Pack));
|
||||
return Pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER i8vec2 unpackInt2x8(int16 p)
|
||||
{
|
||||
i8vec2 Unpack;
|
||||
memcpy(&Unpack, &p, sizeof(Unpack));
|
||||
return Unpack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint16 packUint2x8(u8vec2 const& v)
|
||||
{
|
||||
uint16 Pack = 0;
|
||||
memcpy(&Pack, &v, sizeof(Pack));
|
||||
return Pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER u8vec2 unpackUint2x8(uint16 p)
|
||||
{
|
||||
u8vec2 Unpack;
|
||||
memcpy(&Unpack, &p, sizeof(Unpack));
|
||||
return Unpack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER int32 packInt4x8(i8vec4 const& v)
|
||||
{
|
||||
int32 Pack = 0;
|
||||
memcpy(&Pack, &v, sizeof(Pack));
|
||||
return Pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER i8vec4 unpackInt4x8(int32 p)
|
||||
{
|
||||
i8vec4 Unpack;
|
||||
memcpy(&Unpack, &p, sizeof(Unpack));
|
||||
return Unpack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint32 packUint4x8(u8vec4 const& v)
|
||||
{
|
||||
uint32 Pack = 0;
|
||||
memcpy(&Pack, &v, sizeof(Pack));
|
||||
return Pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER u8vec4 unpackUint4x8(uint32 p)
|
||||
{
|
||||
u8vec4 Unpack;
|
||||
memcpy(&Unpack, &p, sizeof(Unpack));
|
||||
return Unpack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER int packInt2x16(i16vec2 const& v)
|
||||
{
|
||||
int Pack = 0;
|
||||
memcpy(&Pack, &v, sizeof(Pack));
|
||||
return Pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER i16vec2 unpackInt2x16(int p)
|
||||
{
|
||||
i16vec2 Unpack;
|
||||
memcpy(&Unpack, &p, sizeof(Unpack));
|
||||
return Unpack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER int64 packInt4x16(i16vec4 const& v)
|
||||
{
|
||||
int64 Pack = 0;
|
||||
memcpy(&Pack, &v, sizeof(Pack));
|
||||
return Pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER i16vec4 unpackInt4x16(int64 p)
|
||||
{
|
||||
i16vec4 Unpack;
|
||||
memcpy(&Unpack, &p, sizeof(Unpack));
|
||||
return Unpack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint packUint2x16(u16vec2 const& v)
|
||||
{
|
||||
uint Pack = 0;
|
||||
memcpy(&Pack, &v, sizeof(Pack));
|
||||
return Pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER u16vec2 unpackUint2x16(uint p)
|
||||
{
|
||||
u16vec2 Unpack;
|
||||
memcpy(&Unpack, &p, sizeof(Unpack));
|
||||
return Unpack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint64 packUint4x16(u16vec4 const& v)
|
||||
{
|
||||
uint64 Pack = 0;
|
||||
memcpy(&Pack, &v, sizeof(Pack));
|
||||
return Pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER u16vec4 unpackUint4x16(uint64 p)
|
||||
{
|
||||
u16vec4 Unpack;
|
||||
memcpy(&Unpack, &p, sizeof(Unpack));
|
||||
return Unpack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER int64 packInt2x32(i32vec2 const& v)
|
||||
{
|
||||
int64 Pack = 0;
|
||||
memcpy(&Pack, &v, sizeof(Pack));
|
||||
return Pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER i32vec2 unpackInt2x32(int64 p)
|
||||
{
|
||||
i32vec2 Unpack;
|
||||
memcpy(&Unpack, &p, sizeof(Unpack));
|
||||
return Unpack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER uint64 packUint2x32(u32vec2 const& v)
|
||||
{
|
||||
uint64 Pack = 0;
|
||||
memcpy(&Pack, &v, sizeof(Pack));
|
||||
return Pack;
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER u32vec2 unpackUint2x32(uint64 p)
|
||||
{
|
||||
u32vec2 Unpack;
|
||||
memcpy(&Unpack, &p, sizeof(Unpack));
|
||||
return Unpack;
|
||||
}
|
||||
}//namespace glm
|
||||
|
||||
200
glm/ext/packing_sized.hpp
Normal file
200
glm/ext/packing_sized.hpp
Normal file
@ -0,0 +1,200 @@
|
||||
/// @ref ext_packing
|
||||
/// @file glm/ext/packing.hpp
|
||||
///
|
||||
/// @see core (dependence)
|
||||
///
|
||||
/// @defgroup ext_packing GLM_EXT_packing
|
||||
/// @ingroup ext
|
||||
///
|
||||
/// Include <glm/ext/packing.hpp> to use the features of this extension.
|
||||
///
|
||||
/// This extension provides a set of function to convert vertors to packed
|
||||
/// formats.
|
||||
|
||||
#pragma once
|
||||
|
||||
// Dependency:
|
||||
#include "../packing.hpp"
|
||||
|
||||
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
|
||||
# pragma message("GLM: GLM_EXT_packing extension included")
|
||||
#endif
|
||||
|
||||
namespace glm
|
||||
{
|
||||
/// @addtogroup ext_packing
|
||||
/// @{
|
||||
|
||||
/// Returns an unsigned integer obtained by converting the components of a four-component signed integer vector
|
||||
/// to the 10-10-10-2-bit signed integer representation found in the OpenGL Specification,
|
||||
/// and then packing these four values into a 32-bit unsigned integer.
|
||||
/// The first vector component specifies the 10 least-significant bits of the result;
|
||||
/// the forth component specifies the 2 most-significant bits.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint32 packI3x10_1x2(uvec4 const& v)
|
||||
/// @see uint32 packSnorm3x10_1x2(vec4 const& v)
|
||||
/// @see uint32 packUnorm3x10_1x2(vec4 const& v)
|
||||
/// @see ivec4 unpackI3x10_1x2(uint32 const& p)
|
||||
GLM_FUNC_DECL uint32 packI3x10_1x2(ivec4 const& v);
|
||||
|
||||
/// Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit 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.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint32 packU3x10_1x2(uvec4 const& v)
|
||||
/// @see vec4 unpackSnorm3x10_1x2(uint32 const& p);
|
||||
/// @see uvec4 unpackI3x10_1x2(uint32 const& p);
|
||||
GLM_FUNC_DECL ivec4 unpackI3x10_1x2(uint32 p);
|
||||
|
||||
/// Returns an unsigned integer obtained by converting the components of a four-component unsigned integer vector
|
||||
/// to the 10-10-10-2-bit unsigned integer representation found in the OpenGL Specification,
|
||||
/// and then packing these four values into a 32-bit unsigned integer.
|
||||
/// The first vector component specifies the 10 least-significant bits of the result;
|
||||
/// the forth component specifies the 2 most-significant bits.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint32 packI3x10_1x2(ivec4 const& v)
|
||||
/// @see uint32 packSnorm3x10_1x2(vec4 const& v)
|
||||
/// @see uint32 packUnorm3x10_1x2(vec4 const& v)
|
||||
/// @see ivec4 unpackU3x10_1x2(uint32 const& p)
|
||||
GLM_FUNC_DECL uint32 packU3x10_1x2(uvec4 const& v);
|
||||
|
||||
/// Unpacks a single 32-bit unsigned integer p into three 10-bit and one 2-bit 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.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint32 packU3x10_1x2(uvec4 const& v)
|
||||
/// @see vec4 unpackSnorm3x10_1x2(uint32 const& p);
|
||||
/// @see uvec4 unpackI3x10_1x2(uint32 const& p);
|
||||
GLM_FUNC_DECL uvec4 unpackU3x10_1x2(uint32 p);
|
||||
|
||||
|
||||
/// Convert each component from an integer vector into a packed integer.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see i8vec2 unpackInt2x8(int16 p)
|
||||
GLM_FUNC_DECL int16 packInt2x8(i8vec2 const& v);
|
||||
|
||||
/// Convert a packed integer into an integer vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see int16 packInt2x8(i8vec2 const& v)
|
||||
GLM_FUNC_DECL i8vec2 unpackInt2x8(int16 p);
|
||||
|
||||
/// Convert each component from an integer vector into a packed unsigned integer.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see u8vec2 unpackInt2x8(uint16 p)
|
||||
GLM_FUNC_DECL uint16 packUint2x8(u8vec2 const& v);
|
||||
|
||||
/// Convert a packed integer into an integer vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint16 packInt2x8(u8vec2 const& v)
|
||||
GLM_FUNC_DECL u8vec2 unpackUint2x8(uint16 p);
|
||||
|
||||
/// Convert each component from an integer vector into a packed integer.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see i8vec4 unpackInt4x8(int32 p)
|
||||
GLM_FUNC_DECL int32 packInt4x8(i8vec4 const& v);
|
||||
|
||||
/// Convert a packed integer into an integer vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see int32 packInt2x8(i8vec4 const& v)
|
||||
GLM_FUNC_DECL i8vec4 unpackInt4x8(int32 p);
|
||||
|
||||
/// Convert each component from an integer vector into a packed unsigned integer.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see u8vec4 unpackUint4x8(uint32 p)
|
||||
GLM_FUNC_DECL uint32 packUint4x8(u8vec4 const& v);
|
||||
|
||||
/// Convert a packed integer into an integer vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint32 packUint4x8(u8vec2 const& v)
|
||||
GLM_FUNC_DECL u8vec4 unpackUint4x8(uint32 p);
|
||||
|
||||
/// Convert each component from an integer vector into a packed integer.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see i16vec2 unpackInt2x16(int p)
|
||||
GLM_FUNC_DECL int packInt2x16(i16vec2 const& v);
|
||||
|
||||
/// Convert a packed integer into an integer vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see int packInt2x16(i16vec2 const& v)
|
||||
GLM_FUNC_DECL i16vec2 unpackInt2x16(int p);
|
||||
|
||||
/// Convert each component from an integer vector into a packed integer.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see i16vec4 unpackInt4x16(int64 p)
|
||||
GLM_FUNC_DECL int64 packInt4x16(i16vec4 const& v);
|
||||
|
||||
/// Convert a packed integer into an integer vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see int64 packInt4x16(i16vec4 const& v)
|
||||
GLM_FUNC_DECL i16vec4 unpackInt4x16(int64 p);
|
||||
|
||||
/// Convert each component from an integer vector into a packed unsigned integer.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see u16vec2 unpackUint2x16(uint p)
|
||||
GLM_FUNC_DECL uint packUint2x16(u16vec2 const& v);
|
||||
|
||||
/// Convert a packed integer into an integer vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint packUint2x16(u16vec2 const& v)
|
||||
GLM_FUNC_DECL u16vec2 unpackUint2x16(uint p);
|
||||
|
||||
/// Convert each component from an integer vector into a packed unsigned integer.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see u16vec4 unpackUint4x16(uint64 p)
|
||||
GLM_FUNC_DECL uint64 packUint4x16(u16vec4 const& v);
|
||||
|
||||
/// Convert a packed integer into an integer vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see uint64 packUint4x16(u16vec4 const& v)
|
||||
GLM_FUNC_DECL u16vec4 unpackUint4x16(uint64 p);
|
||||
|
||||
/// Convert each component from an integer vector into a packed integer.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see i32vec2 unpackInt2x32(int p)
|
||||
GLM_FUNC_DECL int64 packInt2x32(i32vec2 const& v);
|
||||
|
||||
/// Convert a packed integer into an integer vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see int packInt2x16(i32vec2 const& v)
|
||||
GLM_FUNC_DECL i32vec2 unpackInt2x32(int64 p);
|
||||
|
||||
/// Convert each component from an integer vector into a packed unsigned integer.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see u32vec2 unpackUint2x32(int p)
|
||||
GLM_FUNC_DECL uint64 packUint2x32(u32vec2 const& v);
|
||||
|
||||
/// Convert a packed integer into an integer vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see int packUint2x16(u32vec2 const& v)
|
||||
GLM_FUNC_DECL u32vec2 unpackUint2x32(uint64 p);
|
||||
|
||||
/// @}
|
||||
}// namespace glm
|
||||
|
||||
#include "packing.inl"
|
||||
@ -22,9 +22,73 @@
|
||||
|
||||
namespace glm
|
||||
{
|
||||
/// Convert each component of the normalized floating-point vector into unsigned integer values.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec<L, floatType, Q> unpackUnorm(vec<L, intType, Q> const& p);
|
||||
template<typename uintType, length_t L, typename floatType, qualifier Q>
|
||||
GLM_FUNC_DECL void packUnorm(vec<L, floatType, Q> const& vector, vec<L, uintType, Q>& packed);
|
||||
|
||||
/// Convert a packed integer to a normalized floating-point vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec<L, intType, Q> packUnorm(vec<L, floatType, Q> const& v)
|
||||
template<typename floatType, length_t L, typename uintType, qualifier Q>
|
||||
GLM_FUNC_DECL void unpackUnorm(vec<L, uintType, Q> const& packed, vec<L, floatType, Q>& vector);
|
||||
|
||||
|
||||
|
||||
|
||||
/// Convert each component of the normalized floating-point vector into unsigned integer values.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec<L, floatType, Q> unpackUnorm(vec<L, intType, Q> const& p);
|
||||
template<typename uintType, length_t L, typename floatType, qualifier Q>
|
||||
GLM_FUNC_DECL vec<L, uintType, Q> packUnorm(vec<L, floatType, Q> const& vector);
|
||||
|
||||
/// Convert a packed integer to a normalized floating-point vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec<L, intType, Q> packUnorm(vec<L, floatType, Q> const& v)
|
||||
template<typename floatType, length_t L, typename uintType, qualifier Q>
|
||||
GLM_FUNC_DECL vec<L, floatType, Q> unpackUnorm(vec<L, uintType, Q> const& packed);
|
||||
|
||||
/// Convert each component of the normalized floating-point vector into signed integer values.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec<L, floatType, Q> unpackSnorm(vec<L, intType, Q> const& p);
|
||||
template<typename intType, length_t L, typename floatType, qualifier Q>
|
||||
GLM_FUNC_DECL vec<L, intType, Q> packSnorm(vec<L, floatType, Q> const& vector);
|
||||
|
||||
/// Convert a packed integer to a normalized floating-point vector.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec<L, intType, Q> packSnorm(vec<L, floatType, Q> const& v)
|
||||
template<typename floatType, length_t L, typename intType, qualifier Q>
|
||||
GLM_FUNC_DECL vec<L, floatType, Q> unpackSnorm(vec<L, intType, Q> const& packed);
|
||||
|
||||
/// @addtogroup ext_vector_packing
|
||||
/// @{
|
||||
/// Returns an unsigned integer vector obtained by converting the components of a floating-point vector
|
||||
/// to the 16-bit floating-point representation found in the OpenGL Specification.
|
||||
/// The first vector component specifies the 16 least-significant bits of the result;
|
||||
/// the forth component specifies the 16 most-significant bits.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec<L, float, Q> unpackHalf(vec<L, uint16, Q> const& p)
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
template<length_t L, qualifier Q>
|
||||
GLM_FUNC_DECL vec<L, uint16, Q> packHalf(vec<L, float, Q> const& vector);
|
||||
|
||||
/// Returns a floating-point vector with components obtained by reinterpreting an integer vector as 16-bit floating-point numbers and converting them to 32-bit floating-point values.
|
||||
/// The first component of the vector is obtained from the 16 least-significant bits of v;
|
||||
/// the forth component is obtained from the 16 most-significant bits of v.
|
||||
///
|
||||
/// @see gtc_packing
|
||||
/// @see vec<L, uint16, Q> packHalf(vec<L, float, Q> const& v)
|
||||
/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
|
||||
template<length_t L, qualifier Q>
|
||||
GLM_FUNC_DECL vec<L, float, Q> unpackHalf(vec<L, uint16, Q> const& packed);
|
||||
|
||||
/// @}
|
||||
}// namespace glm
|
||||
|
||||
@ -19,6 +19,7 @@ glmCreateTestGTC(ext_matrix_uint3x4_sized)
|
||||
glmCreateTestGTC(ext_matrix_uint4x2_sized)
|
||||
glmCreateTestGTC(ext_matrix_uint4x3_sized)
|
||||
glmCreateTestGTC(ext_matrix_uint4x4_sized)
|
||||
glmCreateTestGTC(ext_packing)
|
||||
glmCreateTestGTC(ext_quaternion_common)
|
||||
glmCreateTestGTC(ext_quaternion_exponential)
|
||||
glmCreateTestGTC(ext_quaternion_geometric)
|
||||
|
||||
877
test/ext/ext_packing.cpp
Normal file
877
test/ext/ext_packing.cpp
Normal file
@ -0,0 +1,877 @@
|
||||
#include <glm/packing.hpp>
|
||||
#include <glm/ext/packing.hpp>
|
||||
#include <glm/ext/vector_relational.hpp>
|
||||
#include <cstdio>
|
||||
#include <vector>
|
||||
|
||||
void print_bits(float const& s)
|
||||
{
|
||||
union
|
||||
{
|
||||
float f;
|
||||
unsigned int i;
|
||||
} uif;
|
||||
|
||||
uif.f = s;
|
||||
|
||||
std::printf("f32: ");
|
||||
for(std::size_t j = sizeof(s) * 8; j > 0; --j)
|
||||
{
|
||||
if(j == 23 || j == 31)
|
||||
std::printf(" ");
|
||||
std::printf("%d", (uif.i & (1 << (j - 1))) ? 1 : 0);
|
||||
}
|
||||
}
|
||||
|
||||
void print_10bits(glm::uint const& s)
|
||||
{
|
||||
std::printf("10b: ");
|
||||
for(std::size_t j = 10; j > 0; --j)
|
||||
{
|
||||
if(j == 5)
|
||||
std::printf(" ");
|
||||
std::printf("%d", (s & (1 << (j - 1))) ? 1 : 0);
|
||||
}
|
||||
}
|
||||
|
||||
void print_11bits(glm::uint const& s)
|
||||
{
|
||||
std::printf("11b: ");
|
||||
for(std::size_t j = 11; j > 0; --j)
|
||||
{
|
||||
if(j == 6)
|
||||
std::printf(" ");
|
||||
std::printf("%d", (s & (1 << (j - 1))) ? 1 : 0);
|
||||
}
|
||||
}
|
||||
|
||||
void print_value(float const& s)
|
||||
{
|
||||
std::printf("%2.5f, ", static_cast<double>(s));
|
||||
print_bits(s);
|
||||
std::printf(", ");
|
||||
// print_11bits(detail::floatTo11bit(s));
|
||||
// std::printf(", ");
|
||||
// print_10bits(detail::floatTo10bit(s));
|
||||
std::printf("\n");
|
||||
}
|
||||
|
||||
int test_Half1x16()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<float> Tests;
|
||||
Tests.push_back(0.0f);
|
||||
Tests.push_back(1.0f);
|
||||
Tests.push_back(-1.0f);
|
||||
Tests.push_back(2.0f);
|
||||
Tests.push_back(-2.0f);
|
||||
Tests.push_back(1.9f);
|
||||
|
||||
for(std::size_t i = 0; i < Tests.size(); ++i)
|
||||
{
|
||||
glm::uint16 p0 = glm::packHalf1x16(Tests[i]);
|
||||
float v0 = glm::unpackHalf1x16(p0);
|
||||
glm::uint16 p1 = glm::packHalf1x16(v0);
|
||||
float v1 = glm::unpackHalf1x16(p1);
|
||||
Error += glm::epsilonEqual(v0, v1, glm::epsilon<float>()) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_Half4x16()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec4> Tests;
|
||||
Tests.push_back(glm::vec4(1.0f));
|
||||
Tests.push_back(glm::vec4(0.0f));
|
||||
Tests.push_back(glm::vec4(2.0f));
|
||||
Tests.push_back(glm::vec4(0.1f));
|
||||
Tests.push_back(glm::vec4(0.5f));
|
||||
Tests.push_back(glm::vec4(-0.9f));
|
||||
|
||||
for(std::size_t i = 0; i < Tests.size(); ++i)
|
||||
{
|
||||
glm::uint64 p0 = glm::packHalf4x16(Tests[i]);
|
||||
glm::vec4 v0 = glm::unpackHalf4x16(p0);
|
||||
glm::uint64 p1 = glm::packHalf4x16(v0);
|
||||
glm::vec4 v1 = glm::unpackHalf4x16(p1);
|
||||
glm::u16vec4 p2 = glm::packHalf(v0);
|
||||
glm::vec4 v2 = glm::unpackHalf(p2);
|
||||
|
||||
Error += glm::all(glm::equal(v0, v1, glm::epsilon<float>())) ? 0 : 1;
|
||||
Error += glm::all(glm::equal(v0, v2, glm::epsilon<float>())) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_I3x10_1x2()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::ivec4> Tests;
|
||||
Tests.push_back(glm::ivec4(0));
|
||||
Tests.push_back(glm::ivec4(1));
|
||||
Tests.push_back(glm::ivec4(-1));
|
||||
Tests.push_back(glm::ivec4(2));
|
||||
Tests.push_back(glm::ivec4(-2));
|
||||
Tests.push_back(glm::ivec4(3));
|
||||
|
||||
for(std::size_t i = 0; i < Tests.size(); ++i)
|
||||
{
|
||||
glm::uint32 p0 = glm::packI3x10_1x2(Tests[i]);
|
||||
glm::ivec4 v0 = glm::unpackI3x10_1x2(p0);
|
||||
glm::uint32 p1 = glm::packI3x10_1x2(v0);
|
||||
glm::ivec4 v1 = glm::unpackI3x10_1x2(p1);
|
||||
Error += glm::all(glm::equal(v0, v1)) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_U3x10_1x2()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::uvec4> Tests;
|
||||
Tests.push_back(glm::uvec4(0));
|
||||
Tests.push_back(glm::uvec4(1));
|
||||
Tests.push_back(glm::uvec4(2));
|
||||
Tests.push_back(glm::uvec4(3));
|
||||
Tests.push_back(glm::uvec4(4));
|
||||
Tests.push_back(glm::uvec4(5));
|
||||
|
||||
for(std::size_t i = 0; i < Tests.size(); ++i)
|
||||
{
|
||||
glm::uint32 p0 = glm::packU3x10_1x2(Tests[i]);
|
||||
glm::uvec4 v0 = glm::unpackU3x10_1x2(p0);
|
||||
glm::uint32 p1 = glm::packU3x10_1x2(v0);
|
||||
glm::uvec4 v1 = glm::unpackU3x10_1x2(p1);
|
||||
Error += glm::all(glm::equal(v0, v1)) ? 0 : 1;
|
||||
}
|
||||
|
||||
glm::u8vec4 const v0(0xff, 0x77, 0x0, 0x33);
|
||||
glm::uint32 const p0 = *reinterpret_cast<glm::uint32 const*>(&v0[0]);
|
||||
glm::uint32 const r0 = 0x330077ff;
|
||||
|
||||
Error += p0 == r0 ? 0 : 1;
|
||||
|
||||
glm::uvec4 const v1(0xff, 0x77, 0x0, 0x33);
|
||||
glm::uint32 const p1 = glm::packU3x10_1x2(v1);
|
||||
glm::uint32 const r1 = 0xc001dcff;
|
||||
|
||||
Error += p1 == r1 ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_Snorm3x10_1x2()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec4> Tests;
|
||||
Tests.push_back(glm::vec4(1.0f));
|
||||
Tests.push_back(glm::vec4(0.0f));
|
||||
Tests.push_back(glm::vec4(2.0f));
|
||||
Tests.push_back(glm::vec4(0.1f));
|
||||
Tests.push_back(glm::vec4(0.5f));
|
||||
Tests.push_back(glm::vec4(0.9f));
|
||||
|
||||
for(std::size_t i = 0; i < Tests.size(); ++i)
|
||||
{
|
||||
glm::uint32 p0 = glm::packSnorm3x10_1x2(Tests[i]);
|
||||
glm::vec4 v0 = glm::unpackSnorm3x10_1x2(p0);
|
||||
glm::uint32 p1 = glm::packSnorm3x10_1x2(v0);
|
||||
glm::vec4 v1 = glm::unpackSnorm3x10_1x2(p1);
|
||||
|
||||
Error += glm::all(glm::epsilonEqual(v0, v1, 0.01f)) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_Unorm3x10_1x2()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec4> Tests;
|
||||
Tests.push_back(glm::vec4(1.0f));
|
||||
Tests.push_back(glm::vec4(0.0f));
|
||||
Tests.push_back(glm::vec4(2.0f));
|
||||
Tests.push_back(glm::vec4(0.1f));
|
||||
Tests.push_back(glm::vec4(0.5f));
|
||||
Tests.push_back(glm::vec4(0.9f));
|
||||
|
||||
for(std::size_t i = 0; i < Tests.size(); ++i)
|
||||
{
|
||||
glm::uint32 p0 = glm::packUnorm3x10_1x2(Tests[i]);
|
||||
glm::vec4 v0 = glm::unpackUnorm3x10_1x2(p0);
|
||||
glm::uint32 p1 = glm::packUnorm3x10_1x2(v0);
|
||||
glm::vec4 v1 = glm::unpackUnorm3x10_1x2(p1);
|
||||
|
||||
Error += glm::all(glm::epsilonEqual(v0, v1, 0.001f)) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_F2x11_1x10()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec3> Tests;
|
||||
Tests.push_back(glm::vec3(1.0f));
|
||||
Tests.push_back(glm::vec3(0.0f));
|
||||
Tests.push_back(glm::vec3(2.0f));
|
||||
Tests.push_back(glm::vec3(0.1f));
|
||||
Tests.push_back(glm::vec3(0.5f));
|
||||
Tests.push_back(glm::vec3(0.9f));
|
||||
|
||||
for(std::size_t i = 0; i < Tests.size(); ++i)
|
||||
{
|
||||
glm::uint32 p0 = glm::packF2x11_1x10(Tests[i]);
|
||||
glm::vec3 v0 = glm::unpackF2x11_1x10(p0);
|
||||
glm::uint32 p1 = glm::packF2x11_1x10(v0);
|
||||
glm::vec3 v1 = glm::unpackF2x11_1x10(p1);
|
||||
Error += glm::all(glm::equal(v0, v1, glm::epsilon<float>())) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_F3x9_E1x5()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec3> Tests;
|
||||
Tests.push_back(glm::vec3(1.0f));
|
||||
Tests.push_back(glm::vec3(0.0f));
|
||||
Tests.push_back(glm::vec3(2.0f));
|
||||
Tests.push_back(glm::vec3(0.1f));
|
||||
Tests.push_back(glm::vec3(0.5f));
|
||||
Tests.push_back(glm::vec3(0.9f));
|
||||
|
||||
for(std::size_t i = 0; i < Tests.size(); ++i)
|
||||
{
|
||||
glm::uint32 p0 = glm::packF3x9_E1x5(Tests[i]);
|
||||
glm::vec3 v0 = glm::unpackF3x9_E1x5(p0);
|
||||
glm::uint32 p1 = glm::packF3x9_E1x5(v0);
|
||||
glm::vec3 v1 = glm::unpackF3x9_E1x5(p1);
|
||||
Error += glm::all(glm::equal(v0, v1, glm::epsilon<float>())) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_RGBM()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
for(std::size_t i = 0; i < 1024; ++i)
|
||||
{
|
||||
glm::vec3 const Color(static_cast<float>(i));
|
||||
glm::vec4 const RGBM = glm::packRGBM(Color);
|
||||
glm::vec3 const Result= glm::unpackRGBM(RGBM);
|
||||
|
||||
Error += glm::all(glm::equal(Color, Result, 0.01f)) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packUnorm1x16()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec1> A;
|
||||
A.push_back(glm::vec1(1.0f));
|
||||
A.push_back(glm::vec1(0.5f));
|
||||
A.push_back(glm::vec1(0.1f));
|
||||
A.push_back(glm::vec1(0.0f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec1 B(A[i]);
|
||||
glm::uint16 C = glm::packUnorm1x16(B.x);
|
||||
glm::vec1 D(glm::unpackUnorm1x16(C));
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 65535.f)) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packSnorm1x16()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec1> A;
|
||||
A.push_back(glm::vec1( 1.0f));
|
||||
A.push_back(glm::vec1( 0.0f));
|
||||
A.push_back(glm::vec1(-0.5f));
|
||||
A.push_back(glm::vec1(-0.1f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec1 B(A[i]);
|
||||
glm::uint16 C = glm::packSnorm1x16(B.x);
|
||||
glm::vec1 D(glm::unpackSnorm1x16(C));
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 32767.0f * 2.0f)) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packUnorm2x16()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec2> A;
|
||||
A.push_back(glm::vec2(1.0f, 0.0f));
|
||||
A.push_back(glm::vec2(0.5f, 0.7f));
|
||||
A.push_back(glm::vec2(0.1f, 0.2f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec2 B(A[i]);
|
||||
glm::uint32 C = glm::packUnorm2x16(B);
|
||||
glm::vec2 D = glm::unpackUnorm2x16(C);
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 65535.f)) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packSnorm2x16()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec2> A;
|
||||
A.push_back(glm::vec2( 1.0f, 0.0f));
|
||||
A.push_back(glm::vec2(-0.5f,-0.7f));
|
||||
A.push_back(glm::vec2(-0.1f, 0.1f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec2 B(A[i]);
|
||||
glm::uint32 C = glm::packSnorm2x16(B);
|
||||
glm::vec2 D = glm::unpackSnorm2x16(C);
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 32767.0f * 2.0f)) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packUnorm4x16()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec4> A;
|
||||
A.push_back(glm::vec4(1.0f));
|
||||
A.push_back(glm::vec4(0.5f));
|
||||
A.push_back(glm::vec4(0.1f));
|
||||
A.push_back(glm::vec4(0.0f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec4 B(A[i]);
|
||||
glm::uint64 C = glm::packUnorm4x16(B);
|
||||
glm::vec4 D(glm::unpackUnorm4x16(C));
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 65535.f)) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packSnorm4x16()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec4> A;
|
||||
A.push_back(glm::vec4( 1.0f, 0.0f, -0.5f, 0.5f));
|
||||
A.push_back(glm::vec4(-0.3f,-0.7f, 0.3f, 0.7f));
|
||||
A.push_back(glm::vec4(-0.1f, 0.1f, -0.2f, 0.2f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec4 B(A[i]);
|
||||
glm::uint64 C = glm::packSnorm4x16(B);
|
||||
glm::vec4 D(glm::unpackSnorm4x16(C));
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 32767.0f * 2.0f)) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packUnorm1x8()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec1> A;
|
||||
A.push_back(glm::vec1(1.0f));
|
||||
A.push_back(glm::vec1(0.5f));
|
||||
A.push_back(glm::vec1(0.0f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec1 B(A[i]);
|
||||
glm::uint8 C = glm::packUnorm1x8(B.x);
|
||||
glm::vec1 D(glm::unpackUnorm1x8(C));
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 255.f)) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packSnorm1x8()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec1> A;
|
||||
A.push_back(glm::vec1( 1.0f));
|
||||
A.push_back(glm::vec1(-0.7f));
|
||||
A.push_back(glm::vec1(-1.0f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec1 B(A[i]);
|
||||
glm::uint8 C = glm::packSnorm1x8(B.x);
|
||||
glm::vec1 D(glm::unpackSnorm1x8(C));
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 127.f)) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packUnorm2x8()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec2> A;
|
||||
A.push_back(glm::vec2(1.0f, 0.7f));
|
||||
A.push_back(glm::vec2(0.5f, 0.1f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec2 B(A[i]);
|
||||
glm::uint16 C = glm::packUnorm2x8(B);
|
||||
glm::vec2 D = glm::unpackUnorm2x8(C);
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 255.f)) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packSnorm2x8()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec2> A;
|
||||
A.push_back(glm::vec2( 1.0f, 0.0f));
|
||||
A.push_back(glm::vec2(-0.7f,-0.1f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec2 B(A[i]);
|
||||
glm::uint16 C = glm::packSnorm2x8(B);
|
||||
glm::vec2 D = glm::unpackSnorm2x8(C);
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 127.f)) ? 0 : 1;
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packUnorm4x8()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec4> A;
|
||||
A.push_back(glm::vec4(1.0f, 0.7f, 0.3f, 0.0f));
|
||||
A.push_back(glm::vec4(0.5f, 0.1f, 0.2f, 0.3f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec4 B(A[i]);
|
||||
glm::uint32 C = glm::packUnorm4x8(B);
|
||||
glm::vec4 D = glm::unpackUnorm4x8(C);
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 255.f)) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packSnorm4x8()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec4> A;
|
||||
A.push_back(glm::vec4( 1.0f, 0.0f,-0.5f,-1.0f));
|
||||
A.push_back(glm::vec4(-0.7f,-0.1f, 0.1f, 0.7f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec4 B(A[i]);
|
||||
glm::uint32 C = glm::packSnorm4x8(B);
|
||||
glm::vec4 D = glm::unpackSnorm4x8(C);
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 127.f)) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packUnorm()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec2> A;
|
||||
A.push_back(glm::vec2(1.0f, 0.7f));
|
||||
A.push_back(glm::vec2(0.5f, 0.1f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec2 B(A[i]);
|
||||
glm::u16vec2 C = glm::packUnorm<glm::uint16>(B);
|
||||
glm::vec2 D = glm::unpackUnorm<float>(C);
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 255.f)) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packSnorm()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec2> A;
|
||||
A.push_back(glm::vec2( 1.0f, 0.0f));
|
||||
A.push_back(glm::vec2(-0.5f,-0.7f));
|
||||
A.push_back(glm::vec2(-0.1f, 0.1f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec2 B(A[i]);
|
||||
glm::i16vec2 C = glm::packSnorm<glm::int16>(B);
|
||||
glm::vec2 D = glm::unpackSnorm<float>(C);
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 32767.0f * 2.0f)) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packUnorm2x4()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec2> A;
|
||||
A.push_back(glm::vec2(1.0f, 0.7f));
|
||||
A.push_back(glm::vec2(0.5f, 0.0f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec2 B(A[i]);
|
||||
glm::uint8 C = glm::packUnorm2x4(B);
|
||||
glm::vec2 D = glm::unpackUnorm2x4(C);
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 15.f)) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packUnorm4x4()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec4> A;
|
||||
A.push_back(glm::vec4(1.0f, 0.7f, 0.5f, 0.0f));
|
||||
A.push_back(glm::vec4(0.5f, 0.1f, 0.0f, 1.0f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec4 B(A[i]);
|
||||
glm::uint16 C = glm::packUnorm4x4(B);
|
||||
glm::vec4 D = glm::unpackUnorm4x4(C);
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 15.f)) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packUnorm3x5_1x1()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec4> A;
|
||||
A.push_back(glm::vec4(1.0f, 0.7f, 0.5f, 0.0f));
|
||||
A.push_back(glm::vec4(0.5f, 0.1f, 0.0f, 1.0f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec4 B(A[i]);
|
||||
glm::uint16 C = glm::packUnorm3x5_1x1(B);
|
||||
glm::vec4 D = glm::unpackUnorm3x5_1x1(C);
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 15.f)) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packUnorm1x5_1x6_1x5()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec3> A;
|
||||
A.push_back(glm::vec3(1.0f, 0.7f, 0.5f));
|
||||
A.push_back(glm::vec3(0.5f, 0.1f, 0.0f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec3 B(A[i]);
|
||||
glm::uint16 C = glm::packUnorm1x5_1x6_1x5(B);
|
||||
glm::vec3 D = glm::unpackUnorm1x5_1x6_1x5(C);
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 15.f)) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packUnorm2x3_1x2()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
std::vector<glm::vec3> A;
|
||||
A.push_back(glm::vec3(1.0f, 0.7f, 0.5f));
|
||||
A.push_back(glm::vec3(0.5f, 0.1f, 0.0f));
|
||||
|
||||
for(std::size_t i = 0; i < A.size(); ++i)
|
||||
{
|
||||
glm::vec3 B(A[i]);
|
||||
glm::uint8 C = glm::packUnorm2x3_1x2(B);
|
||||
glm::vec3 D = glm::unpackUnorm2x3_1x2(C);
|
||||
Error += glm::all(glm::epsilonEqual(B, D, 1.0f / 3.f)) ? 0 : 1;
|
||||
assert(!Error);
|
||||
}
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packUint2x8()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::u8vec2 const Source(1, 2);
|
||||
|
||||
glm::uint16 const Packed = glm::packUint2x8(Source);
|
||||
Error += Packed != 0 ? 0 : 1;
|
||||
|
||||
glm::u8vec2 const Unpacked = glm::unpackUint2x8(Packed);
|
||||
Error += Source == Unpacked ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packUint4x8()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::u8vec4 const Source(1, 2, 3, 4);
|
||||
|
||||
glm::uint32 const Packed = glm::packUint4x8(Source);
|
||||
Error += Packed != 0 ? 0 : 1;
|
||||
|
||||
glm::u8vec4 const Unpacked = glm::unpackUint4x8(Packed);
|
||||
Error += Source == Unpacked ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packUint2x16()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::u16vec2 const Source(1, 2);
|
||||
|
||||
glm::uint32 const Packed = glm::packUint2x16(Source);
|
||||
Error += Packed != 0 ? 0 : 1;
|
||||
|
||||
glm::u16vec2 const Unpacked = glm::unpackUint2x16(Packed);
|
||||
Error += Source == Unpacked ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packUint4x16()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::u16vec4 const Source(1, 2, 3, 4);
|
||||
|
||||
glm::uint64 const Packed = glm::packUint4x16(Source);
|
||||
Error += Packed != 0 ? 0 : 1;
|
||||
|
||||
glm::u16vec4 const Unpacked = glm::unpackUint4x16(Packed);
|
||||
Error += Source == Unpacked ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packUint2x32()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::u32vec2 const Source(1, 2);
|
||||
|
||||
glm::uint64 const Packed = glm::packUint2x32(Source);
|
||||
Error += Packed != 0 ? 0 : 1;
|
||||
|
||||
glm::u32vec2 const Unpacked = glm::unpackUint2x32(Packed);
|
||||
Error += Source == Unpacked ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packInt2x8()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::i8vec2 const Source(1, 2);
|
||||
|
||||
glm::int16 const Packed = glm::packInt2x8(Source);
|
||||
Error += Packed != 0 ? 0 : 1;
|
||||
|
||||
glm::i8vec2 const Unpacked = glm::unpackInt2x8(Packed);
|
||||
Error += Source == Unpacked ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packInt4x8()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::i8vec4 const Source(1, 2, 3, 4);
|
||||
|
||||
glm::int32 const Packed = glm::packInt4x8(Source);
|
||||
Error += Packed != 0 ? 0 : 1;
|
||||
|
||||
glm::i8vec4 const Unpacked = glm::unpackInt4x8(Packed);
|
||||
Error += Source == Unpacked ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packInt2x16()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::i16vec2 const Source(1, 2);
|
||||
|
||||
glm::int32 const Packed = glm::packInt2x16(Source);
|
||||
Error += Packed != 0 ? 0 : 1;
|
||||
|
||||
glm::i16vec2 const Unpacked = glm::unpackInt2x16(Packed);
|
||||
Error += Source == Unpacked ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packInt4x16()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::i16vec4 const Source(1, 2, 3, 4);
|
||||
|
||||
glm::int64 const Packed = glm::packInt4x16(Source);
|
||||
Error += Packed != 0 ? 0 : 1;
|
||||
|
||||
glm::i16vec4 const Unpacked = glm::unpackInt4x16(Packed);
|
||||
Error += Source == Unpacked ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int test_packInt2x32()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
glm::i32vec2 const Source(1, 2);
|
||||
|
||||
glm::int64 const Packed = glm::packInt2x32(Source);
|
||||
Error += Packed != 0 ? 0 : 1;
|
||||
|
||||
glm::i32vec2 const Unpacked = glm::unpackInt2x32(Packed);
|
||||
Error += Source == Unpacked ? 0 : 1;
|
||||
|
||||
return Error;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
int Error = 0;
|
||||
|
||||
Error += test_packUnorm();
|
||||
Error += test_packSnorm();
|
||||
|
||||
Error += test_packSnorm1x16();
|
||||
Error += test_packSnorm2x16();
|
||||
Error += test_packSnorm4x16();
|
||||
|
||||
Error += test_packSnorm1x8();
|
||||
Error += test_packSnorm2x8();
|
||||
Error += test_packSnorm4x8();
|
||||
|
||||
Error += test_packUnorm1x16();
|
||||
Error += test_packUnorm2x16();
|
||||
Error += test_packUnorm4x16();
|
||||
|
||||
Error += test_packUnorm1x8();
|
||||
Error += test_packUnorm2x8();
|
||||
Error += test_packUnorm4x8();
|
||||
|
||||
Error += test_packUnorm2x4();
|
||||
Error += test_packUnorm4x4();
|
||||
Error += test_packUnorm3x5_1x1();
|
||||
Error += test_packUnorm1x5_1x6_1x5();
|
||||
Error += test_packUnorm2x3_1x2();
|
||||
|
||||
Error += test_packUint2x8();
|
||||
Error += test_packUint4x8();
|
||||
Error += test_packUint2x16();
|
||||
Error += test_packUint4x16();
|
||||
Error += test_packUint2x32();
|
||||
|
||||
Error += test_packInt2x8();
|
||||
Error += test_packInt4x8();
|
||||
Error += test_packInt2x16();
|
||||
Error += test_packInt4x16();
|
||||
Error += test_packInt2x32();
|
||||
|
||||
Error += test_F2x11_1x10();
|
||||
Error += test_F3x9_E1x5();
|
||||
Error += test_RGBM();
|
||||
Error += test_Unorm3x10_1x2();
|
||||
Error += test_Snorm3x10_1x2();
|
||||
|
||||
Error += test_I3x10_1x2();
|
||||
Error += test_U3x10_1x2();
|
||||
Error += test_Half1x16();
|
||||
Error += test_Half4x16();
|
||||
|
||||
return Error;
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user