Clean up white spaces, fix build with VC15

test/core/core_func_integer_bit_count.cpp

@@ -5,7 +5,8 @@
 #include <stdlib.h>     //To define "exit", req'd by XLC.
 #include <ctime>
 
-unsigned rotatel(unsigned x, int n) {
+unsigned rotatel(unsigned x, int n)
+{
 	if ((unsigned)n > 63) {printf("rotatel, n out of range.\n"); exit(1);}
 	return (x << n) | (x >> (32 - n));
 }
@@ -20,7 +21,8 @@ int pop0(unsigned x)
 	return x;
 }
 
-int pop1(unsigned x) {
+int pop1(unsigned x)
+{
 	x = x - ((x >> 1) & 0x55555555);
 	x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
 	x = (x + (x >> 4)) & 0x0F0F0F0F;
@@ -32,7 +34,8 @@ int pop1(unsigned x) {
    return x*0x01010101 >> 24;
 if your machine has a fast multiplier (suggested by Jari Kirma). */
 
-int pop2(unsigned x) {
+int pop2(unsigned x)
+{
 	unsigned n;
 
 	n = (x >> 1) & 033333333333;       // Count bits in
@@ -42,12 +45,14 @@ int pop2(unsigned x) {
 	x = (x + (x >> 3)) & 030707070707; // 6-bit sums.
 	return x%63;                       // Add 6-bit sums.
 }
+
 /* An alternative to the "return" statement above is:
    return ((x * 0404040404) >> 26) +  // Add 6-bit sums.
            (x >> 30);
 which runs faster on most machines (suggested by Norbert Juffa). */
 
-int pop3(unsigned x) {
+int pop3(unsigned x)
+{
 	unsigned n;
 
 	n = (x >> 1) & 0x77777777;        // Count bits in
@@ -101,7 +106,8 @@ int pop5a(unsigned x)
 	return sum;
 }
 
-int pop6(unsigned x) {               // Table lookup.
+int pop6(unsigned x)
+{ // Table lookup.
 	static char table[256] = {
 		0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
 		1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
@@ -130,7 +136,8 @@ int pop6(unsigned x) {               // Table lookup.
 }
 
 // The following works only for 8-bit quantities.
-int pop7(unsigned x) {
+int pop7(unsigned x)
+{
 	x = x*0x08040201;    // Make 4 copies.
 	x = x >> 3;          // So next step hits proper bits.
 	x = x & 0x11111111;  // Every 4th bit.
@@ -140,7 +147,8 @@ int pop7(unsigned x) {
 }
 
 // The following works only for 7-bit quantities.
-int pop8(unsigned x) {
+int pop8(unsigned x)
+{
 	x = x*0x02040810;    // Make 4 copies, left-adjusted.
 	x = x & 0x11111111;  // Every 4th bit.
 	x = x*0x11111111;    // Sum the digits (each 0 or 1).
@@ -149,7 +157,8 @@ int pop8(unsigned x) {
 }
 
 // The following works only for 15-bit quantities.
-int pop9(unsigned x) {
+int pop9(unsigned x)
+{
 	unsigned long long y;
 	y = x * 0x0002000400080010ULL;
 	y = y & 0x1111111111111111ULL;
@@ -159,7 +168,8 @@ int pop9(unsigned x) {
 }
 
 int errors;
-void error(int x, int y) {
+void error(int x, int y)
+{
 	errors = errors + 1;
 	printf("Error for x = %08x, got %08x\n", x, y);
 }

test/core/core_type_vec1.cpp

@@ -52,7 +52,6 @@ int test_vec1_ctor()
 	Error += std::is_trivially_copyable<glm::ivec1>::value ? 0 : 1;
 	Error += std::is_trivially_copyable<glm::uvec1>::value ? 0 : 1;
 
-	Error += std::has_trivial_copy_constructor<glm::vec1>::value ? 0 : 1;
 	Error += std::is_copy_constructible<glm::vec1>::value ? 0 : 1;
 #endif
 

test/core/core_type_vec2.cpp

@@ -11,6 +11,7 @@
 #include <glm/vector_relational.hpp>
 #include <glm/vec2.hpp>
 #include <vector>
+#include <type_traits>
 
 int test_vec2_operators()
 {
@@ -209,7 +210,6 @@ int test_vec2_ctor()
 	Error += std::is_trivially_copyable<glm::ivec2>::value ? 0 : 1;
 	Error += std::is_trivially_copyable<glm::uvec2>::value ? 0 : 1;
 
-	Error += std::has_trivial_copy_constructor<glm::vec2>::value ? 0 : 1;
 	Error += std::is_copy_constructible<glm::vec2>::value ? 0 : 1;
 #endif
 

test/core/core_type_vec3.cpp

@@ -28,7 +28,6 @@ int test_vec3_ctor()
 	Error += std::is_trivially_copyable<glm::ivec3>::value ? 0 : 1;
 	Error += std::is_trivially_copyable<glm::uvec3>::value ? 0 : 1;
 
-	Error += std::has_trivial_copy_constructor<glm::vec3>::value ? 0 : 1;
 	Error += std::is_copy_constructible<glm::vec3>::value ? 0 : 1;
 #endif
 

test/core/core_type_vec4.cpp

@@ -43,9 +43,11 @@ int test_vec4_ctor()
 {
 	int Error = 0;
 
+	{
 		glm::ivec4 A(1, 2, 3, 4);
 		glm::ivec4 B(A);
 		Error += glm::all(glm::equal(A, B)) ? 0 : 1;
+	}
 
 #if (GLM_LANG & GLM_LANG_CXX11_FLAG) || (GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)
 //	Error += std::is_trivially_default_constructible<glm::vec4>::value ? 0 : 1;
@@ -55,7 +57,6 @@ int test_vec4_ctor()
 	Error += std::is_trivially_copyable<glm::ivec4>::value ? 0 : 1;
 	Error += std::is_trivially_copyable<glm::uvec4>::value ? 0 : 1;
 
-	Error += std::has_trivial_copy_constructor<glm::vec4>::value ? 0 : 1;
 	Error += std::is_copy_constructible<glm::vec4>::value ? 0 : 1;
 #endif
 

test/gtc/gtc_quaternion.cpp

@@ -281,8 +281,6 @@ int test_quat_ctr()
 	Error += std::is_trivially_copyable<glm::quat>::value ? 0 : 1;
 	Error += std::is_trivially_copyable<glm::dquat>::value ? 0 : 1;
 
-	Error += std::has_trivial_copy_constructor<glm::quat>::value ? 0 : 1;
-	Error += std::has_trivial_copy_constructor<glm::dquat>::value ? 0 : 1;
 	Error += std::is_copy_constructible<glm::quat>::value ? 0 : 1;
 	Error += std::is_copy_constructible<glm::dquat>::value ? 0 : 1;
 #endif

test/gtc/gtc_random.cpp

@@ -194,10 +194,10 @@ int test_linearRand()
 
 	for(std::size_t i = 0; i < 100000; ++i)
 	{
-		glm::f32vec2 const A(glm::linearRand(glm::f32vec2(Min), glm::f32vec2(Max)));
-		if(!glm::all(glm::lessThanEqual(A, glm::f32vec2(Max))))
+		glm::f32vec2 const A(glm::linearRand(glm::f32vec2(static_cast<float>(Min)), glm::f32vec2(static_cast<float>(Max))));
+		if(!glm::all(glm::lessThanEqual(A, glm::f32vec2(static_cast<float>(Max)))))
 			++Error;
-		if(!glm::all(glm::greaterThanEqual(A, glm::f32vec2(Min))))
+		if(!glm::all(glm::greaterThanEqual(A, glm::f32vec2(static_cast<float>(Min)))))
 			++Error;
 
 		glm::f64vec2 const B(glm::linearRand(glm::f64vec2(Min), glm::f64vec2(Max)));

test/gtx/gtx_dual_quaternion.cpp

@@ -174,8 +174,6 @@ int test_dual_quat_ctr()
 	Error += std::is_trivially_copyable<glm::dualquat>::value ? 0 : 1;
 	Error += std::is_trivially_copyable<glm::ddualquat>::value ? 0 : 1;
 
-	Error += std::has_trivial_copy_constructor<glm::dualquat>::value ? 0 : 1;
-	Error += std::has_trivial_copy_constructor<glm::ddualquat>::value ? 0 : 1;
 	Error += std::is_copy_constructible<glm::dualquat>::value ? 0 : 1;
 	Error += std::is_copy_constructible<glm::ddualquat>::value ? 0 : 1;
 #endif