Added GLSL 4.20 pack/unpackHalf16x2 functions

glm/core/func_packing.hpp

@@ -106,51 +106,72 @@ namespace glm
     /// @see - <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4</a>
 	detail::tvec2<detail::float32> unpackUnorm2x16(detail::uint32 const & p);
 
-    //! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
-    //! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-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.
-    //! 
+    /// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
+    /// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-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 - <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</a>
     detail::tvec4<detail::float32> unpackUnorm4x8(detail::uint32 const & p);
         
-    //! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
-    //! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
-    //! 
-    //! The conversion for unpacked fixed-point value f to floating point is done as follows:
-    //! unpackSnorm4x8: clamp(f / 127.0, -1, +1)
-    //! 
-    //! The first component of the returned vector will be extracted from the least significant bits of the input; 
-    //! the last component will be extracted from the most significant bits.
-    //! 
+    /// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
+    /// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
+    /// 
+    /// The conversion for unpacked fixed-point value f to floating point is done as follows:
+    /// unpackSnorm4x8: clamp(f / 127.0, -1, +1)
+    /// 
+    /// The first component of the returned vector will be extracted from the least significant bits of the input; 
+    /// the last component will be extracted from the most significant bits.
+    /// 
     /// @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</a>
 	detail::tvec4<detail::float32> unpackSnorm4x8(detail::uint32 const & p);
 
-    //! Returns a double-precision value obtained by packing the components of v into a 64-bit value. 
-    //! If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified. 
-    //! Otherwise, the bit- level representation of v is preserved. 
-    //! The first vector component specifies the 32 least significant bits; 
-    //! the second component specifies the 32 most significant bits.
-    //! 
+    /// Returns a double-precision value obtained by packing the components of v into a 64-bit value. 
+    /// If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified. 
+    /// Otherwise, the bit- level representation of v is preserved. 
+    /// The first vector component specifies the 32 least significant bits; 
+    /// the second component specifies the 32 most significant bits.
+    /// 
     /// @see - <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packDouble2x32.xml">GLSL packDouble2x32 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</a>
 	double packDouble2x32(detail::tvec2<detail::uint32> const & v);
         
-    //! Returns a two-component unsigned integer vector representation of v. 
-    //! The bit-level representation of v is preserved. 
-    //! The first component of the vector contains the 32 least significant bits of the double; 
-    //! the second component consists the 32 most significant bits.
-    //! 
+    /// Returns a two-component unsigned integer vector representation of v. 
+    /// The bit-level representation of v is preserved. 
+    /// The first component of the vector contains the 32 least significant bits of the double; 
+    /// the second component consists the 32 most significant bits.
+    /// 
     /// @see - <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackDouble2x32.xml">GLSL unpackDouble2x32 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</a>
 	detail::tvec2<detail::uint32> unpackDouble2x32(double const & v);
 
+	
+	/// Returns an unsigned integer obtained by converting the components of a two-component floating-point vector 
+	/// to the 16-bit floating-point representation found in the OpenGL Specification, 
+	/// and then packing these two 16- bit integers into a 32-bit unsigned integer.
+	/// The first vector component specifies the 16 least-significant bits of the result; 
+	/// the second component specifies the 16 most-significant bits.
+    /// 
+    /// @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</a>
+	uint packHalf2x16(vec2 const & v);
+	
+	/// Returns a two-component floating-point vector with components obtained by unpacking a 32-bit unsigned integer into a pair of 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 second component is obtained from the 16 most-significant bits of 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</a>
+	vec2 unpackHalf2x16(uint const & v);
+	
 	/// @}
 }//namespace glm
 

glm/core/func_packing.inl

@@ -75,7 +75,7 @@ GLM_FUNC_QUALIFIER detail::tvec2<detail::float32> unpackSnorm2x16(detail::uint32
 	detail::uint16 B(detail::uint16(p >> 16));
 	return clamp(detail::tvec2<detail::float32>(
 		A * 1.0f / 32767.0f, 
-		B * 1.0f / 32767.0f));
+		B * 1.0f / 32767.0f), -1.0f, 1.0f);
 }
 
 GLM_FUNC_QUALIFIER detail::tvec4<detail::float32> unpackUnorm4x8(detail::uint32 const & p)
@@ -109,9 +109,21 @@ GLM_FUNC_QUALIFIER double packDouble2x32(detail::tvec2<detail::uint32> const & v
 	return *(double*)&v;
 }
 
-GLM_FUNC_QUALIFIER detail::tvec2<detail::uint32> unpackDouble2x32(double const & v)
+GLM_FUNC_QUALIFIER detail::tvec2<uint> unpackDouble2x32(double const & v)
 {
-	return *(detail::tvec2<detail::uint32>*)&v;
+	return *(detail::tvec2<uint>*)&v;
+}
+
+GLM_FUNC_QUALIFIER uint packHalf2x16(vec2 const & v)
+{
+	detail::tvec2<detail::hdata> Pack(detail::toFloat16(v.x), detail::toFloat16(v.y));
+	return *(uint*)&Pack;
+}
+
+GLM_FUNC_QUALIFIER vec2 unpackHalf2x16(uint const & v)
+{
+	detail::tvec2<detail::hdata> Unpack = *(detail::tvec2<detail::hdata>*)&v;
+	return vec2(detail::toFloat32(Unpack.x), detail::toFloat32(Unpack.y));
 }
 
 }//namespace glm

test/core/core_func_packing.cpp

@@ -9,10 +9,19 @@
 
 #include <glm/glm.hpp>
 
+int test_packHalf2x16()
+{
+	int Error = 0;
+	
+	return Error;
+}
+
 int main()
 {
-	int Failed = 0;
+	int Error = 0;
 
-	return Failed;
+	Error += test_packHalf2x16();
+	
+	return Error;
 }