Optimized packing and unpacking functions

glm/core/func_packing.inl

@@ -30,169 +30,80 @@ namespace glm
 {
 	GLM_FUNC_QUALIFIER uint32 packUnorm2x16(vec2 const & v)
 	{
-		uint16 A(uint16(round(clamp(v.x, 0.0f, 1.0f) * 65535.0f)));
+		u16vec2 Topack(round(clamp(v, 0.0f, 1.0f) * 65535.0f));
-		uint16 B(uint16(round(clamp(v.y, 0.0f, 1.0f) * 65535.0f)));
+		return *reinterpret_cast<uint32*>(&Topack);
-		return uint32((B << 16) | A);
 	}
 
 	GLM_FUNC_QUALIFIER vec2 unpackUnorm2x16(uint32 const & p)
 	{
-		uint32 Mask16((1 << 16) - 1);
+		vec2 Unpack(*reinterpret_cast<u16vec2*>(const_cast<uint32*>(&p)));
-		uint32 A((p >>  0) & Mask16);
+		return Unpack * float(1.5259021896696421759365224689097e-5); // 1.0 / 65535.0
-		uint32 B((p >> 16) & Mask16);
-		return vec2(A, B) * float(1.5259021896696421759365224689097e-5); // 1.0 / 65535.0
 	}
 
 	GLM_FUNC_QUALIFIER uint32 packSnorm2x16(vec2 const & v)
 	{
-		i16vec2 Unpack(round(clamp(v ,-1.0f, 1.0f) * 32767.0f));
+		i16vec2 Topack(round(clamp(v ,-1.0f, 1.0f) * 32767.0f));
-		u32vec2 Topack(*reinterpret_cast<u16vec2*>(&Unpack));
+		return *reinterpret_cast<uint32*>(&Topack);
-		return (Topack.y << 16) | (Topack.x << 0);
 	}
 
 	GLM_FUNC_QUALIFIER vec2 unpackSnorm2x16(uint32 const & p)
 	{
-		union iu
+		vec2 Unpack(*reinterpret_cast<i16vec2*>(const_cast<uint32*>(&p)));
-		{
+		return clamp(Unpack * 1.0f / 32767.0f, -1.0f, 1.0f);
-			int16 i;
-			uint16 u;
-		} A, B;
-		
-		uint32 Mask16((1 << 16) - 1);
-		A.u = uint16((p >>  0) & Mask16);
-		B.u = uint16((p >> 16) & Mask16);
-		glm::vec2 Pack(A.i, B.i);
-		
-		return clamp(Pack * 1.0f / 32767.0f, -1.0f, 1.0f);
 	}
 
 	GLM_FUNC_QUALIFIER uint32 packUnorm4x8(vec4 const & v)
 	{
-		uint8 A((uint8)round(clamp(v.x, 0.0f, 1.0f) * 255.0f));
+		glm::u8vec4 Topack(round(clamp(v, 0.0f, 1.0f) * 255.0f));
-		uint8 B((uint8)round(clamp(v.y, 0.0f, 1.0f) * 255.0f));
+		return *reinterpret_cast<uint32*>(&Topack);
-		uint8 C((uint8)round(clamp(v.z, 0.0f, 1.0f) * 255.0f));
-		uint8 D((uint8)round(clamp(v.w, 0.0f, 1.0f) * 255.0f));
-		return uint32((D << 24) | (C << 16) | (B << 8) | A);
 	}
 
 	GLM_FUNC_QUALIFIER vec4 unpackUnorm4x8(uint32 const & p)
 	{
-		uint32 Mask8((1 << 8) - 1);
+		glm::vec4 Unpack(*reinterpret_cast<glm::u8vec4*>(const_cast<uint32*>(&p)));
-		uint32 A((p >>  0) & Mask8);
+		return Unpack * 0.003921568627451f; // 1 / 255
-		uint32 B((p >>  8) & Mask8);
-		uint32 C((p >> 16) & Mask8);
-		uint32 D((p >> 24) & Mask8);
-		return glm::vec4(
-			A * 1.0f / 255.0f, 
-			B * 1.0f / 255.0f, 
-			C * 1.0f / 255.0f, 
-			D * 1.0f / 255.0f);
 	}
 	
 	GLM_FUNC_QUALIFIER uint32 packSnorm4x8(vec4 const & v)
 	{
-		union iu
+		glm::i8vec4 Topack(round(clamp(v ,-1.0f, 1.0f) * 127.0f));
-		{
+		return *reinterpret_cast<uint32*>(&Topack);
-			int8 i;
-			uint8 u;
-		} A, B, C, D;
-	
-		glm::vec4 Unpack = clamp(v,-1.0f, 1.0f) * 127.0f;
-		A.i = int8(round(Unpack.x));
-		B.i = int8(round(Unpack.y));
-		C.i = int8(round(Unpack.z));
-		D.i = int8(round(Unpack.w));
-		uint32 Pack = (uint32(D.u) << 24) | (uint32(C.u) << 16) | (uint32(B.u) << 8) | (uint32(A.u) << 0);
-		return Pack;
 	}
 	
 	GLM_FUNC_QUALIFIER glm::vec4 unpackSnorm4x8(uint32 const & p)
 	{
-		union iu
+		glm::vec4 Unpack(*reinterpret_cast<glm::i8vec4*>(const_cast<uint32*>(&p)));
-		{
+		return clamp(
-			int8 i;
+			Unpack * 0.0078740157480315f, // 1.0f / 127.0f
-			uint8 u;
+			-1.0f, 1.0f);
-		} A, B, C, D;
-	
-		uint32 Mask8((1 << 8) - 1);
-		A.u = uint8((p >>  0) & Mask8);
-		B.u = uint8((p >>  8) & Mask8);
-		C.u = uint8((p >> 16) & Mask8);
-		D.u = uint8((p >> 24) & Mask8);
-		glm::vec4 Pack(A.i, B.i, C.i, D.i);
-	
-		return clamp(Pack * 1.0f / 127.0f, -1.0f, 1.0f);
 	}
 
 	GLM_FUNC_QUALIFIER double packDouble2x32(uvec2 const & v)
 	{
-		struct uint32_pair
+		return *reinterpret_cast<double*>(const_cast<uvec2*>(&v));
-		{
-			uint32 x;
-			uint32 y;
-		};
-
-		union helper
-		{
-			uint32_pair input;
-			double output;
-		} Helper;
-
-		Helper.input.x = v.x;
-		Helper.input.y = v.y;
-
-		return Helper.output;
-		//return *(double*)&v;
 	}
 
 	GLM_FUNC_QUALIFIER uvec2 unpackDouble2x32(double const & v)
 	{
-		struct uint32_pair
+		return *reinterpret_cast<uvec2*>(const_cast<double*>(&v));
-		{
-			uint32 x;
-			uint32 y;
-		};
-
-		union helper
-		{
-			double input;
-			uint32_pair output;
-		} Helper;
-
-		Helper.input = v;
-
-		return uvec2(Helper.output.x, Helper.output.y);
 	}
 
 	GLM_FUNC_QUALIFIER uint packHalf2x16(vec2 const & v)
 	{
-		union helper
+		i16vec2 Unpack(
-		{
+			detail::toFloat16(v.x),
-			uint other;
+			detail::toFloat16(v.y));
-			struct
-			{
-				detail::hdata a, b;
-			} orig;
-		} Pack;
 
-		Pack.orig.a = detail::toFloat16(v.x);
+		return *reinterpret_cast<uint*>(&Unpack);
-		Pack.orig.b = detail::toFloat16(v.y);
-		return Pack.other;
 	}
 
 	GLM_FUNC_QUALIFIER vec2 unpackHalf2x16(uint const & v)
 	{
-		union helper
+		i16vec2 Unpack = *reinterpret_cast<i16vec2*>(const_cast<uint*>(&v));
-		{
-			uint other;
-			struct
-			{
-				detail::hdata a, b;
-			} orig;
-		} Unpack;
-		Unpack.other = v;
 	
-		return vec2(detail::toFloat32(Unpack.orig.a), detail::toFloat32(Unpack.orig.b));
+		return vec2(
+			detail::toFloat32(Unpack.x), 
+			detail::toFloat32(Unpack.y));
 	}
 }//namespace glm
 

readme.txt

@@ -56,6 +56,7 @@ GLM 0.9.5.0: 2013-XX-XX
 - Uses C++ casts
 - Fixed .length() that should return a int and not a size_t
 - Removed unnecessary conversions
+- Optimized packing and unpacking functions
 
 ================================================================================
 GLM 0.9.4.6: 2013-08-XX

test/core/core_func_packing.cpp

@@ -41,12 +41,7 @@ int test_packUnorm2x16()
 int test_packSnorm2x16()
 {
 	int Error = 0;
-/*
+
-	std::vector<glm::hvec2> A;
-	A.push_back(glm::hvec2(glm::half( 1.0f), glm::half( 0.0f)));
-	A.push_back(glm::hvec2(glm::half(-0.5f), glm::half(-0.7f)));
-	A.push_back(glm::hvec2(glm::half(-0.1f), glm::half( 0.1f)));
-*/
 	std::vector<glm::vec2> A;
 	A.push_back(glm::vec2( 1.0f, 0.0f));
 	A.push_back(glm::vec2(-0.5f,-0.7f));