From cef58e189d908e9042b3305ca58196b5bafb1efe Mon Sep 17 00:00:00 2001 From: Christophe Riccio Date: Mon, 1 Oct 2018 18:48:40 +0200 Subject: [PATCH] Added packing experiments --- glm/ext/scalar_packing.hpp | 4 +- glm/ext/scalar_packing.inl | 4 +- glm/ext/vector_packing.hpp | 77 ++++++++++++++++++++++++++++++++- glm/ext/vector_packing.inl | 4 +- glm/gtc/packing.hpp | 21 +++++++++ glm/gtc/packing.inl | 12 +++++ test/ext/ext_scalar_packing.cpp | 8 ++-- test/ext/ext_vector_packing.cpp | 8 ++-- 8 files changed, 122 insertions(+), 16 deletions(-) diff --git a/glm/ext/scalar_packing.hpp b/glm/ext/scalar_packing.hpp index 421e11e7..c683a2e0 100644 --- a/glm/ext/scalar_packing.hpp +++ b/glm/ext/scalar_packing.hpp @@ -32,14 +32,14 @@ namespace glm /// the forth component specifies the 16 most-significant bits. /// /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - GLM_FUNC_DECL uint16 packHalf(float s); + GLM_FUNC_DECL uint16 packFloatToHalf(float s); /// Returns a floating-point scalar with components obtained by reinterpreting an integer scalar 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 GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions - GLM_FUNC_DECL float unpackHalf(uint16 p); + GLM_FUNC_DECL float unpackHalfToFloat(uint16 p); /// @} }//namespace glm diff --git a/glm/ext/scalar_packing.inl b/glm/ext/scalar_packing.inl index d586ae76..a23ebbc8 100644 --- a/glm/ext/scalar_packing.inl +++ b/glm/ext/scalar_packing.inl @@ -2,12 +2,12 @@ namespace glm { - GLM_FUNC_QUALIFIER uint16 packHalf(float Scalar) + GLM_FUNC_QUALIFIER uint16 packFloatToHalf(float Scalar) { return detail::toFloat16(Scalar); } - GLM_FUNC_QUALIFIER float unpackHalf(uint16 Packed) + GLM_FUNC_QUALIFIER float unpackHalfToFloat(uint16 Packed) { return detail::toFloat32(Packed); } diff --git a/glm/ext/vector_packing.hpp b/glm/ext/vector_packing.hpp index fbb6db10..e7a4d784 100644 --- a/glm/ext/vector_packing.hpp +++ b/glm/ext/vector_packing.hpp @@ -26,6 +26,48 @@ namespace glm /// @addtogroup ext_vector_packing /// @{ + GLM_FUNC_DECL uint8 packVecToUInt(vec<1, uint8> const& v); + + GLM_FUNC_DECL vec<1, uint8> unpackUInt(uint8 p); + + GLM_FUNC_DECL uint16 packUInt(vec<1, uint16> const& v); + + GLM_FUNC_DECL vec<1, uint16> unpackUInt(uint16 p); + + GLM_FUNC_DECL uint32 packUInt(vec<1, uint32> const& v); + + GLM_FUNC_DECL vec<1, uint32> unpackUInt(uint32 p); + + GLM_FUNC_DECL uint64 packUInt(vec<1, uint64> const& v); + + GLM_FUNC_DECL vec<1, uint64> unpackUInt(uint64 p); + + + + GLM_FUNC_DECL uint16 packUInt(vec<2, uint8> const& v); + + GLM_FUNC_DECL vec<2, uint8> unpackUInt(uint16 p); + + GLM_FUNC_DECL uint32 packUInt(vec<2, uint16> const& v); + + GLM_FUNC_DECL vec<2, uint16> unpackUInt(uint32 p); + + GLM_FUNC_DECL uint64 packUInt(vec<2, uint32> const& v); + + GLM_FUNC_DECL vec<2, uint32> unpackUInt(uint64 p); + + + + GLM_FUNC_DECL uint32 packUInt(vec<4, uint8> const& v); + + GLM_FUNC_DECL vec<4, uint8> unpackUInt(uint32 p); + + GLM_FUNC_DECL uint64 packUInt(vec<4, uint16> const& v); + + GLM_FUNC_DECL vec<4, uint16> unpackUInt(uint64 p); + + + /// 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; @@ -34,7 +76,7 @@ namespace glm /// @see vec unpackHalf(vec const& p) /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions template - GLM_FUNC_DECL vec packHalf(vec const& v); + GLM_FUNC_DECL vec packFloatToHalf(vec const& v); /// 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; @@ -43,7 +85,38 @@ namespace glm /// @see vec packHalf(vec const& v) /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions template - GLM_FUNC_DECL vec unpackHalf(vec const& p); + GLM_FUNC_DECL vec unpackHalfToFloat(vec const& p); + + + /// Convert each component of the normalized floating-point vector into unsigned integer values. + /// + /// @see gtc_packing + /// @see vec unpackUnorm(vec const& p); + template + GLM_FUNC_DECL vec packFloatToUnorm(vec const& v); + + /// Convert a packed integer to a normalized floating-point vector. + /// + /// @see gtc_packing + /// @see vec packUnorm(vec const& v) + template + GLM_FUNC_DECL vec unpackUnormToFloat(vec const& v); + + + /// Convert each component of the normalized floating-point vector into signed integer values. + /// + /// @see gtc_packing + /// @see vec unpackSnorm(vec const& p); + template + GLM_FUNC_DECL vec packFloatToSnorm(vec const& v); + + /// Convert a packed integer to a normalized floating-point vector. + /// + /// @see gtc_packing + /// @see vec packSnorm(vec const& v) + template + GLM_FUNC_DECL vec unpackSnormToFloat(vec const& v); + /// @} }//namespace glm diff --git a/glm/ext/vector_packing.inl b/glm/ext/vector_packing.inl index 72ba6dcd..bbbfa0b6 100644 --- a/glm/ext/vector_packing.inl +++ b/glm/ext/vector_packing.inl @@ -85,13 +85,13 @@ namespace detail }//namespace detail template - GLM_FUNC_QUALIFIER vec packHalf(vec const& v) + GLM_FUNC_QUALIFIER vec packFloatToHalf(vec const& v) { return detail::compute_half::pack(v); } template - GLM_FUNC_QUALIFIER vec unpackHalf(vec const& v) + GLM_FUNC_QUALIFIER vec unpackHalfToFloat(vec const& v) { return detail::compute_half::unpack(v); } diff --git a/glm/gtc/packing.hpp b/glm/gtc/packing.hpp index b391482e..25ff75d3 100644 --- a/glm/gtc/packing.hpp +++ b/glm/gtc/packing.hpp @@ -492,6 +492,27 @@ namespace glm template GLM_FUNC_DECL vec<3, T, Q> unpackRGBM(vec<4, T, Q> const& rgbm); + /// 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 unpackHalf(vec const& p) + /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions + template + GLM_FUNC_DECL vec packHalf(vec const& v); + + /// 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 packHalf(vec const& v) + /// @see GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions + template + GLM_FUNC_DECL vec unpackHalf(vec const& p); + /// Convert each component of the normalized floating-point vector into unsigned integer values. /// /// @see gtc_packing diff --git a/glm/gtc/packing.inl b/glm/gtc/packing.inl index 8039bef9..6b1113a8 100644 --- a/glm/gtc/packing.inl +++ b/glm/gtc/packing.inl @@ -576,6 +576,18 @@ namespace detail return vec<3, T, Q>(rgbm.x, rgbm.y, rgbm.z) * rgbm.w * static_cast(6); } + template + GLM_FUNC_QUALIFIER vec packHalf(vec const& v) + { + return detail::compute_half::pack(v); + } + + template + GLM_FUNC_QUALIFIER vec unpackHalf(vec const& v) + { + return detail::compute_half::unpack(v); + } + template GLM_FUNC_QUALIFIER vec packUnorm(vec const& v) { diff --git a/test/ext/ext_scalar_packing.cpp b/test/ext/ext_scalar_packing.cpp index b96b10a6..249ef31e 100644 --- a/test/ext/ext_scalar_packing.cpp +++ b/test/ext/ext_scalar_packing.cpp @@ -17,12 +17,12 @@ static int test_half() for(std::size_t i = 0; i < Tests.size(); ++i) { - glm::uint16 p0 = glm::packHalf(Tests[i]); - float v0 = glm::unpackHalf(p0); + glm::uint16 p0 = glm::packFloatToHalf(Tests[i]); + float v0 = glm::unpackHalfToFloat(p0); Error += glm::equal(v0, Tests[i], 0.01f) ? 0 : 1; - glm::uint16 p1 = glm::packHalf(v0); - float v1 = glm::unpackHalf(p1); + glm::uint16 p1 = glm::packFloatToHalf(v0); + float v1 = glm::unpackHalfToFloat(p1); Error += glm::equal(v1, Tests[i], 0.01f) ? 0 : 1; Error += glm::equal(v0, v1, 0) ? 0 : 1; diff --git a/test/ext/ext_vector_packing.cpp b/test/ext/ext_vector_packing.cpp index 12696098..e4fd9ac5 100644 --- a/test/ext/ext_vector_packing.cpp +++ b/test/ext/ext_vector_packing.cpp @@ -42,15 +42,15 @@ static int test_half() { vecFType const Data = Tests[i].Data; - vecUType const p0 = glm::packHalf(Data); + vecUType const p0 = glm::packFloatToHalf(Data); - vecFType const v0 = glm::unpackHalf(p0); + vecFType const v0 = glm::unpackHalfToFloat(p0); Error += glm::all(glm::equal(v0, Data, Epsilon)) ? 0 : 1; - vecUType const p1 = glm::packHalf(v0); + vecUType const p1 = glm::packFloatToHalf(v0); Error += glm::all(glm::equal(p0, p1)) ? 0 : 1; - vecFType const v1 = glm::unpackHalf(p1); + vecFType const v1 = glm::unpackHalfToFloat(p1); Error += glm::all(glm::equal(v1, Data, Epsilon)) ? 0 : 1; vecIType const ULPs = glm::float_distance(Data, v0);