Sliced quaternions into multiple extensions

test/ext/CMakeLists.txt

@@ -1,6 +1,10 @@
 glmCreateTestGTC(ext_matrix_relational)
+glmCreateTestGTC(ext_matrix_transform)
+glmCreateTestGTC(ext_quaternion_common)
 glmCreateTestGTC(ext_quaternion_geometric)
 glmCreateTestGTC(ext_quaternion_relational)
+glmCreateTestGTC(ext_quaternion_transform)
+glmCreateTestGTC(ext_quaternion_trigonometric)
 glmCreateTestGTC(ext_quaternion_type)
 glmCreateTestGTC(ext_scalar_constants)
 glmCreateTestGTC(ext_scalar_float_sized)

test/ext/ext_matrix_transform.cpp

@@ -0,0 +1,10 @@
+#include <glm/ext/matrix_relational.hpp>
+//#include <glm/ext/matrix_transform.hpp>
+
+int main()
+{
+	int Error = 0;
+
+
+	return Error;
+}

test/ext/ext_quaternion_common.cpp

@@ -0,0 +1,28 @@
+#include <glm/ext/vector_float3.hpp>
+#include <glm/ext/quaternion_common.hpp>
+#include <glm/ext/quaternion_float.hpp>
+#include <glm/ext/quaternion_relational.hpp>
+#include <glm/ext/scalar_constants.hpp>
+
+static int test_conjugate()
+{
+	int Error = 0;
+
+	glm::quat const A(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0));
+	glm::quat const C = glm::conjugate(A);
+	Error += glm::any(glm::notEqual(A, C, glm::epsilon<float>())) ? 0 : 1;
+
+	glm::quat const B = glm::conjugate(C);
+	Error += glm::all(glm::equal(A, B, glm::epsilon<float>())) ? 0 : 1;
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_conjugate();
+
+	return Error;
+}

test/ext/ext_quaternion_geometric.cpp

@@ -1,6 +1,7 @@
 #include <glm/gtc/constants.hpp>
 #include <glm/ext/quaternion_geometric.hpp>
 #include <glm/ext/quaternion_float.hpp>
+#include <glm/ext/quaternion_trigonometric.hpp>
 #include <glm/ext/quaternion_float_precision.hpp>
 #include <glm/ext/quaternion_double.hpp>
 #include <glm/ext/quaternion_double_precision.hpp>
@@ -10,29 +11,8 @@
 #include <glm/ext/vector_double3_precision.hpp>
 #include <glm/ext/scalar_relational.hpp>
 
-#include <glm/gtc/quaternion.hpp>
-
 float const Epsilon = 0.001f;
 
-static int test_angle()
-{
-	int Error = 0;
-
-	{
-		glm::quat const Q = glm::quat(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0));
-		float const A = glm::degrees(glm::angle(Q));
-		Error += glm::equal(A, 90.0f, Epsilon) ? 0 : 1;
-	}
-
-	{
-		glm::quat const Q = glm::quat(glm::vec3(0, 1, 0), glm::vec3(1, 0, 0));
-		float const A = glm::degrees(glm::angle(Q));
-		Error += glm::equal(A, 90.0f, Epsilon) ? 0 : 1;
-	}
-
-	return Error;
-}
-
 static int test_length()
 {
 	int Error = 0;
@@ -74,14 +54,35 @@ static int test_normalize()
 	return Error;
 }
 
+static int test_dot()
+{
+	int Error = 0;
+
+	{
+		glm::quat const A = glm::quat(1, 0, 0, 0);
+		glm::quat const B = glm::quat(1, 0, 0, 0);
+		float const C = glm::dot(A, B);
+		Error += glm::equal(C, 1.0f, Epsilon) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+static int test_cross()
+{
+	int Error = 0;
+
+	return Error;
+}
 
 int main()
 {
 	int Error = 0;
 
-	Error += test_angle();
 	Error += test_length();
 	Error += test_normalize();
+	Error += test_dot();
+	Error += test_cross();
 
 	return Error;
 }

test/ext/ext_quaternion_transform.cpp

@@ -0,0 +1,11 @@
+#include <glm/ext/quaternion_transform.hpp>
+#include <glm/ext/quaternion_float.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/scalar_constants.hpp>
+
+int main()
+{
+	int Error = 0;
+
+	return Error;
+}

test/ext/ext_quaternion_trigonometric.cpp

@@ -0,0 +1,34 @@
+#include <glm/ext/quaternion_trigonometric.hpp>
+#include <glm/ext/quaternion_float.hpp>
+#include <glm/ext/vector_relational.hpp>
+#include <glm/ext/scalar_relational.hpp>
+
+float const Epsilon = 0.001f;
+
+static int test_angle()
+{
+	int Error = 0;
+
+	{
+		glm::quat const Q = glm::quat(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0));
+		float const A = glm::degrees(glm::angle(Q));
+		Error += glm::equal(A, 90.0f, Epsilon) ? 0 : 1;
+	}
+
+	{
+		glm::quat const Q = glm::quat(glm::vec3(0, 1, 0), glm::vec3(1, 0, 0));
+		float const A = glm::degrees(glm::angle(Q));
+		Error += glm::equal(A, 90.0f, Epsilon) ? 0 : 1;
+	}
+
+	return Error;
+}
+
+int main()
+{
+	int Error = 0;
+
+	Error += test_angle();
+
+	return Error;
+}