Clean up white spaces

test/gtx/gtx_dual_quaternion.cpp

@@ -36,128 +36,131 @@ int test_dquat_type()
 	return 0;
 }
 
-int test_scalars() {
-    float const Epsilon = 0.0001f;
-
-    int Error(0);
-
-    glm::quat src_q1 = glm::quat(1.0f,2.0f,3.0f,4.0f);
-    glm::quat src_q2 = glm::quat(5.0f,6.0f,7.0f,8.0f);
-    glm::dualquat src1(src_q1,src_q2);
-
-    {
-        glm::dualquat dst1 = src1 * 2.0f;
-        glm::dualquat dst2 = 2.0f * src1;
-        glm::dualquat dst3 = src1;
-        dst3 *= 2.0f;
-        glm::dualquat dstCmp(src_q1 * 2.0f,src_q2 * 2.0f);
-        Error += glm::all(glm::epsilonEqual(dst1.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst1.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
-        Error += glm::all(glm::epsilonEqual(dst2.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst2.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
-        Error += glm::all(glm::epsilonEqual(dst3.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst3.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
-    }
-
-    {
-        glm::dualquat dst1 = src1 / 2.0f;
-        glm::dualquat dst2 = src1;
-        dst2 /= 2.0f;
-        glm::dualquat dstCmp(src_q1 / 2.0f,src_q2 / 2.0f);
-        Error += glm::all(glm::epsilonEqual(dst1.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst1.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
-        Error += glm::all(glm::epsilonEqual(dst2.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst2.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
-    }
-    return Error;
+int test_scalars()
+{
+	float const Epsilon = 0.0001f;
+
+	int Error(0);
+
+	glm::quat src_q1 = glm::quat(1.0f,2.0f,3.0f,4.0f);
+	glm::quat src_q2 = glm::quat(5.0f,6.0f,7.0f,8.0f);
+	glm::dualquat src1(src_q1,src_q2);
+
+	{
+		glm::dualquat dst1 = src1 * 2.0f;
+		glm::dualquat dst2 = 2.0f * src1;
+		glm::dualquat dst3 = src1;
+		dst3 *= 2.0f;
+		glm::dualquat dstCmp(src_q1 * 2.0f,src_q2 * 2.0f);
+		Error += glm::all(glm::epsilonEqual(dst1.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst1.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(dst2.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst2.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(dst3.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst3.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
+	}
+
+	{
+		glm::dualquat dst1 = src1 / 2.0f;
+		glm::dualquat dst2 = src1;
+		dst2 /= 2.0f;
+		glm::dualquat dstCmp(src_q1 / 2.0f,src_q2 / 2.0f);
+		Error += glm::all(glm::epsilonEqual(dst1.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst1.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(dst2.real,dstCmp.real, Epsilon)) && glm::all(glm::epsilonEqual(dst2.dual,dstCmp.dual, Epsilon)) ? 0 : 1;
+	}
+	return Error;
 }
 
 int test_inverse() 
 {
-    int Error(0);
+	int Error(0);
 
-    float const Epsilon = 0.0001f;
+	float const Epsilon = 0.0001f;
 
-    glm::dualquat dqid;
-    glm::mat4x4 mid(1.0f);
+	glm::dualquat dqid;
+	glm::mat4x4 mid(1.0f);
 
-    for (int j = 0; j < 100; ++j)
+	for (int j = 0; j < 100; ++j)
 	{
-        glm::mat4x4 rot = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
-        glm::vec3 vt = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
+		glm::mat4x4 rot = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
+		glm::vec3 vt = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
 
-        glm::mat4x4 m = glm::translate(mid, vt) * rot;
+		glm::mat4x4 m = glm::translate(mid, vt) * rot;
 
-        glm::quat qr = glm::quat_cast(m);
+		glm::quat qr = glm::quat_cast(m);
 
-        glm::dualquat dq(qr);
-        
-        glm::dualquat invdq = glm::inverse(dq);
+		glm::dualquat dq(qr);
 
-        glm::dualquat r1 = invdq * dq;
-        glm::dualquat r2 = dq * invdq;
+		glm::dualquat invdq = glm::inverse(dq);
 
-        Error += glm::all(glm::epsilonEqual(r1.real, dqid.real, Epsilon)) && glm::all(glm::epsilonEqual(r1.dual, dqid.dual, Epsilon)) ? 0 : 1;
-        Error += glm::all(glm::epsilonEqual(r2.real, dqid.real, Epsilon)) && glm::all(glm::epsilonEqual(r2.dual, dqid.dual, Epsilon)) ? 0 : 1;
+		glm::dualquat r1 = invdq * dq;
+		glm::dualquat r2 = dq * invdq;
 
-        // testing commutative property
-        glm::dualquat r (   glm::quat( myfrand() * glm::pi<float>() * 2.0f, myfrand(), myfrand(), myfrand() ),
-                            glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f) );
-        glm::dualquat riq = (r * invdq) * dq;
-        glm::dualquat rqi = (r * dq) * invdq;
+		Error += glm::all(glm::epsilonEqual(r1.real, dqid.real, Epsilon)) && glm::all(glm::epsilonEqual(r1.dual, dqid.dual, Epsilon)) ? 0 : 1;
+		Error += glm::all(glm::epsilonEqual(r2.real, dqid.real, Epsilon)) && glm::all(glm::epsilonEqual(r2.dual, dqid.dual, Epsilon)) ? 0 : 1;
 
-        Error += glm::all(glm::epsilonEqual(riq.real, rqi.real, Epsilon)) && glm::all(glm::epsilonEqual(riq.dual, rqi.dual, Epsilon)) ? 0 : 1;
-    }
+		// testing commutative property
+		glm::dualquat r (   glm::quat( myfrand() * glm::pi<float>() * 2.0f, myfrand(), myfrand(), myfrand() ),
+							glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f) );
+		glm::dualquat riq = (r * invdq) * dq;
+		glm::dualquat rqi = (r * dq) * invdq;
 
-    return Error;
+		Error += glm::all(glm::epsilonEqual(riq.real, rqi.real, Epsilon)) && glm::all(glm::epsilonEqual(riq.dual, rqi.dual, Epsilon)) ? 0 : 1;
+	}
+
+	return Error;
 }
 
 int test_mul() 
 {
-    int Error(0);
-
-    float const Epsilon = 0.0001f;
-
-    glm::mat4x4 mid(1.0f);
-
-    for (int j = 0; j < 100; ++j) {
-        // generate random rotations and translations and compare transformed by matrix and dualquats random points 
-        glm::vec3 vt1 = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
-        glm::vec3 vt2 = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
-
-        glm::mat4x4 rot1 = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
-        glm::mat4x4 rot2 = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
-        glm::mat4x4 m1 = glm::translate(mid, vt1) * rot1;
-        glm::mat4x4 m2 = glm::translate(mid, vt2) * rot2;
-        glm::mat4x4 m3 = m2 * m1;
-        glm::mat4x4 m4 = m1 * m2;
+	int Error(0);
 
-        glm::quat qrot1 = glm::quat_cast(rot1);
-        glm::quat qrot2 = glm::quat_cast(rot2);
+	float const Epsilon = 0.0001f;
 
-        glm::dualquat dq1 = glm::dualquat(qrot1,vt1);
-        glm::dualquat dq2 = glm::dualquat(qrot2,vt2);
-        glm::dualquat dq3 = dq2 * dq1;
-        glm::dualquat dq4 = dq1 * dq2;
+	glm::mat4x4 mid(1.0f);
 
-        for (int i = 0; i < 100; ++i) {
-            glm::vec4 src_pt = glm::vec4(myfrand() * 4.0f, myfrand() * 5.0f, myfrand() * 3.0f,1.0f);
-            // test both multiplication orders        
-            glm::vec4 dst_pt_m3  = m3 * src_pt; 
-            glm::vec4 dst_pt_dq3 = dq3 * src_pt;
+	for (int j = 0; j < 100; ++j)
+	{
+		// generate random rotations and translations and compare transformed by matrix and dualquats random points 
+		glm::vec3 vt1 = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
+		glm::vec3 vt2 = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);
+
+		glm::mat4x4 rot1 = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
+		glm::mat4x4 rot2 = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
+		glm::mat4x4 m1 = glm::translate(mid, vt1) * rot1;
+		glm::mat4x4 m2 = glm::translate(mid, vt2) * rot2;
+		glm::mat4x4 m3 = m2 * m1;
+		glm::mat4x4 m4 = m1 * m2;
+
+		glm::quat qrot1 = glm::quat_cast(rot1);
+		glm::quat qrot2 = glm::quat_cast(rot2);
+
+		glm::dualquat dq1 = glm::dualquat(qrot1,vt1);
+		glm::dualquat dq2 = glm::dualquat(qrot2,vt2);
+		glm::dualquat dq3 = dq2 * dq1;
+		glm::dualquat dq4 = dq1 * dq2;
+
+		for (int i = 0; i < 100; ++i)
+		{
+			glm::vec4 src_pt = glm::vec4(myfrand() * 4.0f, myfrand() * 5.0f, myfrand() * 3.0f,1.0f);
+			// test both multiplication orders        
+			glm::vec4 dst_pt_m3  = m3 * src_pt; 
+			glm::vec4 dst_pt_dq3 = dq3 * src_pt;
          
-            glm::vec4 dst_pt_m3_i  = glm::inverse(m3) * src_pt;
-            glm::vec4 dst_pt_dq3_i = src_pt * dq3;
+			glm::vec4 dst_pt_m3_i  = glm::inverse(m3) * src_pt;
+			glm::vec4 dst_pt_dq3_i = src_pt * dq3;
 
-            glm::vec4 dst_pt_m4  = m4 * src_pt;
-            glm::vec4 dst_pt_dq4 = dq4 * src_pt;
+			glm::vec4 dst_pt_m4  = m4 * src_pt;
+			glm::vec4 dst_pt_dq4 = dq4 * src_pt;
 
-            glm::vec4 dst_pt_m4_i  = glm::inverse(m4) * src_pt;
-            glm::vec4 dst_pt_dq4_i = src_pt * dq4;
+			glm::vec4 dst_pt_m4_i  = glm::inverse(m4) * src_pt;
+			glm::vec4 dst_pt_dq4_i = src_pt * dq4;
 
-            Error += glm::all(glm::epsilonEqual(dst_pt_m3, dst_pt_dq3, Epsilon)) ? 0 : 1;
-            Error += glm::all(glm::epsilonEqual(dst_pt_m4, dst_pt_dq4, Epsilon)) ? 0 : 1;
-            Error += glm::all(glm::epsilonEqual(dst_pt_m3_i, dst_pt_dq3_i, Epsilon)) ? 0 : 1;
-            Error += glm::all(glm::epsilonEqual(dst_pt_m4_i, dst_pt_dq4_i, Epsilon)) ? 0 : 1;
-        }
-    } 
+			Error += glm::all(glm::epsilonEqual(dst_pt_m3, dst_pt_dq3, Epsilon)) ? 0 : 1;
+			Error += glm::all(glm::epsilonEqual(dst_pt_m4, dst_pt_dq4, Epsilon)) ? 0 : 1;
+			Error += glm::all(glm::epsilonEqual(dst_pt_m3_i, dst_pt_dq3_i, Epsilon)) ? 0 : 1;
+			Error += glm::all(glm::epsilonEqual(dst_pt_m4_i, dst_pt_dq4_i, Epsilon)) ? 0 : 1;
+		}
+	} 
 
-    return Error;
+	return Error;
 }
 
 int test_dual_quat_ctr()
@@ -191,6 +194,5 @@ int main()
 	Error += test_inverse();
 	Error += test_mul();
 
-	//std::cout << "Errors count: " << Error << std::endl;
 	return Error;
 }