Completed swizzle operations implemenation

glm/gtc/swizzle.hpp

@@ -15,6 +15,7 @@
 
 // Dependency:
 #include "../glm.hpp"
+#include "../gtc/type_precision.hpp"
 
 namespace glm
 {
@@ -24,48 +25,323 @@ namespace glm
 
 	namespace gtc{
 	//! GLM_GTC_swizzle extension
-	namespace swizzle{
+	namespace swizzle
+	{
+		using namespace gtc::half_float;
 
 		template <typename T, template <typename> class vecType>
-		T swizzle(	
+		T const & swizzle(	
 			vecType<T> const & v,
 			comp x);
 
-		template <typename T>
+		template <typename T, template <typename> class vecType>
-		detail::tvec2<T> swizzle(
+		detail::tvec2<T> const & swizzle(
-			detail::tvec4<T> const & v,
+			vecType<T> const & v,
 			comp x, comp y);
 
-		template <typename T>
+		template <typename T, template <typename> class vecType>
-		detail::tvec3<T> swizzle(
+		detail::tvec3<T> const & swizzle(
-			detail::tvec4<T> const & v,
+			vecType<T> const & v,
 			comp x, comp y, comp z);
 
-		template <typename T>
+		template <typename T, template <typename> class vecType>
-		detail::tvec4<T> swizzle(
+		detail::tvec4<T> const & swizzle(
-			detail::tvec4<T> const & v,
+			vecType<T> const & v,
 			comp x, comp y, comp z, comp w);
 
-		template <typename T>
+		template <typename T, template <typename> class vecType>
 		T & swizzle(
-			detail::tvec4<T> & v,
+			vecType<T> & v,
 			comp x);
 
-		template <typename T>
+		template <typename T, template <typename> class vecType>
 		detail::tref2<T> swizzle(
-			detail::tvec4<T> & v,
+			vecType<T> & v,
 			comp x, comp y);
 
-		template <typename T>
+		template <typename T, template <typename> class vecType>
 		detail::tref3<T> swizzle(
-			detail::tvec4<T> & v,
+			vecType<T> & v,
 			comp x, comp y, comp z);
 
-		template <typename T>
+		template <typename T, template <typename> class vecType>
 		detail::tref4<T> swizzle(
-			detail::tvec4<T> & v,
+			vecType<T> & v,
 			comp x, comp y, comp z, comp w);
 
+#		define static_swizzle1(TYPE, SIZE)							\
+			template <comp x>										\
+			inline TYPE swizzle(detail::tvec##SIZE<TYPE> const & v)	\
+			{return v[x];}											\
+																	\
+			template <comp x>										\
+			inline TYPE& swizzle(detail::tvec##SIZE<TYPE> & v)		\
+			{return v[x];}
+
+		static_swizzle1(detail::float16, 2)
+		static_swizzle1(detail::float16, 3)
+		static_swizzle1(detail::float16, 4)
+		static_swizzle1(detail::float32, 2)
+		static_swizzle1(detail::float32, 3)
+		static_swizzle1(detail::float32, 4)
+		static_swizzle1(detail::float64, 2)
+		static_swizzle1(detail::float64, 3)
+		static_swizzle1(detail::float64, 4)
+
+		static_swizzle1(detail::int8,  2)
+		static_swizzle1(detail::int8,  3)
+		static_swizzle1(detail::int8,  4)
+		static_swizzle1(detail::int16, 2)
+		static_swizzle1(detail::int16, 3)
+		static_swizzle1(detail::int16, 4)
+		static_swizzle1(detail::int32, 2)
+		static_swizzle1(detail::int32, 3)
+		static_swizzle1(detail::int32, 4)
+		static_swizzle1(detail::int64, 2)
+		static_swizzle1(detail::int64, 3)
+		static_swizzle1(detail::int64, 4)
+
+		static_swizzle1(detail::uint8,  2)
+		static_swizzle1(detail::uint8,  3)
+		static_swizzle1(detail::uint8,  4)
+		static_swizzle1(detail::uint16, 2)
+		static_swizzle1(detail::uint16, 3)
+		static_swizzle1(detail::uint16, 4)
+		static_swizzle1(detail::uint32, 2)
+		static_swizzle1(detail::uint32, 3)
+		static_swizzle1(detail::uint32, 4)
+		static_swizzle1(detail::uint64, 2)
+		static_swizzle1(detail::uint64, 3)
+		static_swizzle1(detail::uint64, 4)
+
+#		define static_swizzle2_const(TYPE) \
+			template <comp x, comp y> \
+			inline TYPE swizzle(TYPE const & v) \
+			{return TYPE(v[x], v[y]);}
+
+#		define static_swizzle3_const(TYPE) \
+			template <comp x, comp y, comp z> \
+			inline TYPE swizzle(TYPE const & v) \
+			{return TYPE(v[x], v[y], v[z]);}
+
+#		define static_swizzle4_const(TYPE) \
+			template <comp x, comp y, comp z, comp w> \
+			inline TYPE swizzle(TYPE const & v) \
+			{return TYPE(v[x], v[y], v[z], v[w]);}
+/*
+#		define static_swizzle2_const(TYPE, SIZE)									\
+			template <comp x, comp y>												\
+			inline detail::tvec2<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v)	\
+			{return detail::tvec2<TYPE>(v[x], v[y]);}
+
+#		define static_swizzle3_const(TYPE, SIZE)									\
+			template <comp x, comp y, comp z>										\
+			inline detail::tvec3<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v)	\
+			{return detail::tvec3<TYPE>(v[x], v[y], v[z]);}
+
+#		define static_swizzle4_const(TYPE, SIZE)									\
+			template <comp x, comp y, comp z, comp w>								\
+			inline detail::tvec4<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v)	\
+			{return detail::tvec4<TYPE>(v[x], v[y], v[z], v[w]);}
+*/
+		static_swizzle2_const(glm::f16vec2);
+		static_swizzle2_const(glm::f16vec3);
+		static_swizzle2_const(glm::f16vec4);
+		static_swizzle2_const(glm::f32vec2);
+		static_swizzle2_const(glm::f32vec3);
+		static_swizzle2_const(glm::f32vec4);
+		static_swizzle2_const(glm::f64vec2);
+		static_swizzle2_const(glm::f64vec3);
+		static_swizzle2_const(glm::f64vec4);
+
+		static_swizzle2_const(glm::i8vec2);
+		static_swizzle2_const(glm::i8vec3);
+		static_swizzle2_const(glm::i8vec4);
+		static_swizzle2_const(glm::i16vec2);
+		static_swizzle2_const(glm::i16vec3);
+		static_swizzle2_const(glm::i16vec4);
+		static_swizzle2_const(glm::i32vec2);
+		static_swizzle2_const(glm::i32vec3);
+		static_swizzle2_const(glm::i32vec4);
+		static_swizzle2_const(glm::i64vec2);
+		static_swizzle2_const(glm::i64vec3);
+		static_swizzle2_const(glm::i64vec4);
+
+		static_swizzle2_const(glm::u8vec2);
+		static_swizzle2_const(glm::u8vec3);
+		static_swizzle2_const(glm::u8vec4);
+		static_swizzle2_const(glm::u16vec2);
+		static_swizzle2_const(glm::u16vec3);
+		static_swizzle2_const(glm::u16vec4);
+		static_swizzle2_const(glm::u32vec2);
+		static_swizzle2_const(glm::u32vec3);
+		static_swizzle2_const(glm::u32vec4);
+		static_swizzle2_const(glm::u64vec2);
+		static_swizzle2_const(glm::u64vec3);
+		static_swizzle2_const(glm::u64vec4);
+
+		static_swizzle3_const(glm::f16vec2);
+		static_swizzle3_const(glm::f16vec3);
+		static_swizzle3_const(glm::f16vec4);
+		static_swizzle3_const(glm::f32vec2);
+		static_swizzle3_const(glm::f32vec3);
+		static_swizzle3_const(glm::f32vec4);
+		static_swizzle3_const(glm::f64vec2);
+		static_swizzle3_const(glm::f64vec3);
+		static_swizzle3_const(glm::f64vec4);
+
+		static_swizzle3_const(glm::i8vec2);
+		static_swizzle3_const(glm::i8vec3);
+		static_swizzle3_const(glm::i8vec4);
+		static_swizzle3_const(glm::i16vec2);
+		static_swizzle3_const(glm::i16vec3);
+		static_swizzle3_const(glm::i16vec4);
+		static_swizzle3_const(glm::i32vec2);
+		static_swizzle3_const(glm::i32vec3);
+		static_swizzle3_const(glm::i32vec4);
+		static_swizzle3_const(glm::i64vec2);
+		static_swizzle3_const(glm::i64vec3);
+		static_swizzle3_const(glm::i64vec4);
+
+		static_swizzle3_const(glm::u8vec2);
+		static_swizzle3_const(glm::u8vec3);
+		static_swizzle3_const(glm::u8vec4);
+		static_swizzle3_const(glm::u16vec2);
+		static_swizzle3_const(glm::u16vec3);
+		static_swizzle3_const(glm::u16vec4);
+		static_swizzle3_const(glm::u32vec2);
+		static_swizzle3_const(glm::u32vec3);
+		static_swizzle3_const(glm::u32vec4);
+		static_swizzle3_const(glm::u64vec2);
+		static_swizzle3_const(glm::u64vec3);
+		static_swizzle3_const(glm::u64vec4);
+
+		static_swizzle4_const(glm::f16vec2);
+		static_swizzle4_const(glm::f16vec3);
+		static_swizzle4_const(glm::f16vec4);
+		static_swizzle4_const(glm::f32vec2);
+		static_swizzle4_const(glm::f32vec3);
+		static_swizzle4_const(glm::f32vec4);
+		static_swizzle4_const(glm::f64vec2);
+		static_swizzle4_const(glm::f64vec3);
+		static_swizzle4_const(glm::f64vec4);
+
+		static_swizzle4_const(glm::i8vec2);
+		static_swizzle4_const(glm::i8vec3);
+		static_swizzle4_const(glm::i8vec4);
+		static_swizzle4_const(glm::i16vec2);
+		static_swizzle4_const(glm::i16vec3);
+		static_swizzle4_const(glm::i16vec4);
+		static_swizzle4_const(glm::i32vec2);
+		static_swizzle4_const(glm::i32vec3);
+		static_swizzle4_const(glm::i32vec4);
+		static_swizzle4_const(glm::i64vec2);
+		static_swizzle4_const(glm::i64vec3);
+		static_swizzle4_const(glm::i64vec4);
+
+		static_swizzle4_const(glm::u8vec2);
+		static_swizzle4_const(glm::u8vec3);
+		static_swizzle4_const(glm::u8vec4);
+		static_swizzle4_const(glm::u16vec2);
+		static_swizzle4_const(glm::u16vec3);
+		static_swizzle4_const(glm::u16vec4);
+		static_swizzle4_const(glm::u32vec2);
+		static_swizzle4_const(glm::u32vec3);
+		static_swizzle4_const(glm::u32vec4);
+		static_swizzle4_const(glm::u64vec2);
+		static_swizzle4_const(glm::u64vec3);
+		static_swizzle4_const(glm::u64vec4);
+
+#		define static_swizzle2_ref(TYPE) \
+			template <glm::comp x, glm::comp y> \
+			inline glm::detail::tref2<typename TYPE::value_type> swizzle(TYPE & v) \
+			{return glm::detail::tref2<typename TYPE::value_type>(v[x], v[y]);}	
+
+#		define static_swizzle3_ref(TYPE) \
+			template <glm::comp x, glm::comp y, glm::comp z> \
+			inline glm::detail::tref3<typename TYPE::value_type> swizzle(TYPE & v) \
+			{return glm::detail::tref3<typename TYPE::value_type>(v[x], v[y], v[z]);}	
+
+#		define static_swizzle4_ref(TYPE) \
+			template <glm::comp x, glm::comp y, glm::comp z, glm::comp w> \
+			inline glm::detail::tref4<typename TYPE::value_type> swizzle(TYPE & v) \
+			{return glm::detail::tref4<typename TYPE::value_type>(v[x], v[y], v[z], v[w]);}	
+
+		static_swizzle2_ref(glm::f16vec2);
+		static_swizzle2_ref(glm::f16vec3);
+		static_swizzle2_ref(glm::f16vec4);
+		static_swizzle2_ref(glm::f32vec2);
+		static_swizzle2_ref(glm::f32vec3);
+		static_swizzle2_ref(glm::f32vec4);
+		static_swizzle2_ref(glm::f64vec2);
+		static_swizzle2_ref(glm::f64vec3);
+		static_swizzle2_ref(glm::f64vec4);
+
+		static_swizzle2_ref(glm::i8vec2);
+		static_swizzle2_ref(glm::i8vec3);
+		static_swizzle2_ref(glm::i8vec4);
+		static_swizzle2_ref(glm::i16vec2);
+		static_swizzle2_ref(glm::i16vec3);
+		static_swizzle2_ref(glm::i16vec4);
+		static_swizzle2_ref(glm::i32vec2);
+		static_swizzle2_ref(glm::i32vec3);
+		static_swizzle2_ref(glm::i32vec4);
+		static_swizzle2_ref(glm::i64vec2);
+		static_swizzle2_ref(glm::i64vec3);
+		static_swizzle2_ref(glm::i64vec4);
+
+		static_swizzle2_ref(glm::u8vec2);
+		static_swizzle2_ref(glm::u8vec3);
+		static_swizzle2_ref(glm::u8vec4);
+		static_swizzle2_ref(glm::u16vec2);
+		static_swizzle2_ref(glm::u16vec3);
+		static_swizzle2_ref(glm::u16vec4);
+		static_swizzle2_ref(glm::u32vec2);
+		static_swizzle2_ref(glm::u32vec3);
+		static_swizzle2_ref(glm::u32vec4);
+		static_swizzle2_ref(glm::u64vec2);
+		static_swizzle2_ref(glm::u64vec3);
+		static_swizzle2_ref(glm::u64vec4);
+
+		static_swizzle3_ref(glm::f16vec3);
+		static_swizzle3_ref(glm::f16vec4);
+		static_swizzle3_ref(glm::f32vec3);
+		static_swizzle3_ref(glm::f32vec4);
+		static_swizzle3_ref(glm::f64vec3);
+		static_swizzle3_ref(glm::f64vec4);
+
+		static_swizzle3_ref(glm::i8vec3);
+		static_swizzle3_ref(glm::i8vec4);
+		static_swizzle3_ref(glm::i16vec3);
+		static_swizzle3_ref(glm::i16vec4);
+		static_swizzle3_ref(glm::i32vec3);
+		static_swizzle3_ref(glm::i32vec4);
+		static_swizzle3_ref(glm::i64vec3);
+		static_swizzle3_ref(glm::i64vec4);
+
+		static_swizzle3_ref(glm::u8vec3);
+		static_swizzle3_ref(glm::u8vec4);
+		static_swizzle3_ref(glm::u16vec3);
+		static_swizzle3_ref(glm::u16vec4);
+		static_swizzle3_ref(glm::u32vec3);
+		static_swizzle3_ref(glm::u32vec4);
+		static_swizzle3_ref(glm::u64vec3);
+		static_swizzle3_ref(glm::u64vec4);
+
+		static_swizzle4_ref(glm::f16vec4);
+		static_swizzle4_ref(glm::f32vec4);
+		static_swizzle4_ref(glm::f64vec4);
+
+		static_swizzle4_ref(glm::i8vec4);
+		static_swizzle4_ref(glm::i16vec4);
+		static_swizzle4_ref(glm::i32vec4);
+		static_swizzle4_ref(glm::i64vec4);
+
+		static_swizzle4_ref(glm::u8vec4);
+		static_swizzle4_ref(glm::u16vec4);
+		static_swizzle4_ref(glm::u32vec4);
+		static_swizzle4_ref(glm::u64vec4);
+
 	}//namespace swizzle
 	}//namespace gtc
 }//namespace glm

glm/gtc/swizzle.inl

@@ -25,10 +25,10 @@ inline T swizzle
 	return v[x];
 }
 
-template <typename T>
+template <typename T, template <typename> class vecType>
 inline detail::tvec2<T> swizzle
 (
-	detail::tvec4<T> const & v,
+	vecType<T> const & v,
 	comp x, comp y
 )
 {
@@ -37,10 +37,10 @@ inline detail::tvec2<T> swizzle
 		v[y]);
 }
 
-template <typename T>
+template <typename T, template <typename> class vecType>
 inline detail::tvec3<T> swizzle
 (
-	detail::tvec4<T> const & v,
+	vecType<T> const & v,
 	comp x, comp y, comp z
 )
 {
@@ -50,89 +50,16 @@ inline detail::tvec3<T> swizzle
 		v[z]);
 }
 
-template <typename T>
+template <typename T, template <typename> class vecType>
 inline detail::tvec4<T> swizzle
 (
-	detail::tvec4<T> const & v,
+	vecType<T> const & v,
 	comp x, comp y, comp z, comp w
 )
 {
 	return detail::tvec4<T>(v[x], v[y],	v[z], v[w]);
 }
 
-template <comp X>
-inline int swizzle
-(
-	detail::tvec4<int> const & v
-)
-{
-	return v[X];
-}
-
-template <comp X>
-inline float swizzle
-(
-	detail::tvec4<float> const & v
-)
-{
-	return v[X];
-}
-
-template <comp X, comp Y>
-inline detail::tvec2<int> swizzle
-(
-	detail::tvec4<int> const & v
-)
-{
-	return detail::tvec2<int>(v[X], v[Y]);
-}
-
-template <comp X, comp Y>
-inline detail::tvec2<float> swizzle
-(
-	detail::tvec4<float> const & v
-)
-{
-	return detail::tvec2<float>(v[X], v[Y]);
-}
-
-template <comp X, comp Y, comp Z>
-inline detail::tvec3<int> swizzle
-(
-	detail::tvec4<int> const & v
-)
-{
-	return detail::tvec3<int>(v[X], v[Y], v[Z]);
-}
-
-template <comp X, comp Y, comp Z>
-inline detail::tvec3<float> swizzle
-(
-	detail::tvec4<float> const & v
-)
-{
-	return detail::tvec3<float>(v[X], v[Y],	v[Z]);
-}
-
-template <comp X, comp Y, comp Z, comp W>
-inline detail::tvec4<int> swizzle
-(
-	detail::tvec4<int> const & v
-)
-{
-	return detail::tvec4<int>(v[X], v[Y], v[Z], v[W]);
-}
-
-template <comp X, comp Y, comp Z, comp W>
-inline detail::tvec4<float> swizzle
-(
-	detail::tvec4<float> const & v
-)
-{
-	return detail::tvec4<float>(v[X], v[Y],	v[Z], v[W]);
-}
-
-
 template <typename T>
 inline T& swizzle
 (
@@ -172,7 +99,7 @@ inline detail::tref4<T> swizzle
 {
 	return detail::tref4<T>(v[x], v[y],	v[z], v[w]);
 }
-
+/*
 template <comp x>
 inline float& swizzle
 (
@@ -244,7 +171,7 @@ inline detail::tref4<int> swizzle
 {
 	return detail::tref4<int>(v[x], v[y],	v[z], v[w]);
 }
-
+*/
 }//namespace swizzle
 }//namespace gtc
 }//namespace glm

test/gtc/gtc-swizzle.cpp

@@ -38,7 +38,7 @@ int test_swizzle_vec4_ref_dynamic()
 		glm::ivec4 A(0, 1, 2, 3);
 		int B(2);
 		glm::swizzle(A, glm::Z) = B;
-		assert(A.x == B.x && A.y == B.y);
+		assert(A.x == B);
 	}
 
 	return 0;
@@ -71,7 +71,7 @@ int test_swizzle_vec4_ref_static()
 		glm::ivec4 A(0, 1, 2, 3);
 		int B(2);
 		glm::swizzle<glm::Z>(A) = B;
-		assert(A.x == B.x && A.y == B.y);
+		assert(A.x == B);
 	}
 
 	return 0;
@@ -84,12 +84,11 @@ int test_swizzle_vec4_const_dynamic()
 	assert(glm::all(glm::equal(A, B)));
 
 	glm::ivec3 C = glm::swizzle(A, glm::W, glm::Y, glm::Z);
-	assert(glm::all(glm::equal(A, C)));
+	assert(glm::all(glm::equal(glm::ivec3(A), C)));
 
 	glm::ivec2 D = glm::swizzle(A, glm::W, glm::X);
-	assert(glm::all(glm::equal(A, D)));
+	assert(glm::all(glm::equal(glm::ivec2(A), D)));
 
-	assert(D.x == A.w && D.y == A.x);
 	int E = glm::swizzle(A, glm::Q);
 	assert(E == A.q);
 
@@ -104,10 +103,10 @@ int test_swizzle_vec4_const_static()
 	assert(glm::all(glm::equal(A, B)));
 
 	glm::ivec3 C = glm::swizzle<glm::W, glm::Y, glm::Z>(A);
-	assert(glm::all(glm::equal(A, C)));
+	assert(glm::all(glm::equal(glm::ivec3(A), C)));
 
 	glm::ivec2 D = glm::swizzle<glm::W, glm::X>(A);
-	assert(glm::all(glm::equal(A, D)));
+	assert(glm::all(glm::equal(glm::ivec2(A), D)));
 
 	int E = glm::swizzle<glm::Q>(A);
 	assert(E == A.q);