Clean up white spaces, fix build with VC15

glm/gtc/vec1.hpp

@@ -74,7 +74,7 @@ namespace glm
 	/// 1 component vector of low precision floating-point numbers. 
 	/// There is no guarantee on the actual precision.
 	/// @see gtc_vec1 extension.
-	typedef lowp_dvec1_t				lowp_dvec1;
+	typedef lowp_dvec1_t			lowp_dvec1;
 
 	/// 1 component vector of high precision signed integer numbers. 
 	/// There is no guarantee on the actual precision.

test/core/core_func_integer_bit_count.cpp

@@ -5,9 +5,10 @@
 #include <stdlib.h>     //To define "exit", req'd by XLC.
 #include <ctime>
 
-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));
+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));
 }
 
 int pop0(unsigned x)
@@ -20,45 +21,49 @@ int pop0(unsigned x)
 	return x;
 }
 
-int pop1(unsigned x) {
-   x = x - ((x >> 1) & 0x55555555);
-   x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
-   x = (x + (x >> 4)) & 0x0F0F0F0F;
-   x = x + (x >> 8);
-   x = x + (x >> 16);
-   return x & 0x0000003F;
+int pop1(unsigned x)
+{
+	x = x - ((x >> 1) & 0x55555555);
+	x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
+	x = (x + (x >> 4)) & 0x0F0F0F0F;
+	x = x + (x >> 8);
+	x = x + (x >> 16);
+	return x & 0x0000003F;
 }
 /* Note: an alternative to the last three executable lines above is:
    return x*0x01010101 >> 24;
 if your machine has a fast multiplier (suggested by Jari Kirma). */
 
-int pop2(unsigned x) {
-   unsigned n;
-
-   n = (x >> 1) & 033333333333;       // Count bits in
-   x = x - n;                         // each 3-bit
-   n = (n >> 1) & 033333333333;       // field.
-   x = x - n;
-   x = (x + (x >> 3)) & 030707070707; // 6-bit sums.
-   return x%63;                       // Add 6-bit sums.
+int pop2(unsigned x)
+{
+	unsigned n;
+
+	n = (x >> 1) & 033333333333;       // Count bits in
+	x = x - n;                         // each 3-bit
+	n = (n >> 1) & 033333333333;       // field.
+	x = x - n;
+	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) {
-   unsigned n;
-
-   n = (x >> 1) & 0x77777777;        // Count bits in
-   x = x - n;                        // each 4-bit
-   n = (n >> 1) & 0x77777777;        // field.
-   x = x - n;
-   n = (n >> 1) & 0x77777777;
-   x = x - n;
-   x = (x + (x >> 4)) & 0x0F0F0F0F;  // Get byte sums.
-   x = x*0x01010101;                 // Add the bytes.
-   return x >> 24;
+int pop3(unsigned x)
+{
+	unsigned n;
+
+	n = (x >> 1) & 0x77777777;        // Count bits in
+	x = x - n;                        // each 4-bit
+	n = (n >> 1) & 0x77777777;        // field.
+	x = x - n;
+	n = (n >> 1) & 0x77777777;
+	x = x - n;
+	x = (x + (x >> 4)) & 0x0F0F0F0F;  // Get byte sums.
+	x = x*0x01010101;                 // Add the bytes.
+	return x >> 24;
 }
 
 int pop4(unsigned x)
@@ -101,67 +106,72 @@ int pop5a(unsigned x)
 	return sum;
 }
 
-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,
-      1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-      2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-
-      1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-      2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-      2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-      3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-
-      1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-      2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-      2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-      3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-
-      2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-      3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-      3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-      4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8};
-
-   return table[x         & 0xFF] +
-          table[(x >>  8) & 0xFF] +
-          table[(x >> 16) & 0xFF] +
-          table[(x >> 24)];
+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,
+		1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+
+		1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+		3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+
+		1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+		3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+
+		2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+		3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+		3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+		4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8};
+
+	return table[x         & 0xFF] +
+			table[(x >>  8) & 0xFF] +
+			table[(x >> 16) & 0xFF] +
+			table[(x >> 24)];
 }
 
 // The following works only for 8-bit quantities.
-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.
-   x = x*0x11111111;    // Sum the digits (each 0 or 1).
-   x = x >> 28;         // Position the result.
-   return 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.
+	x = x*0x11111111;    // Sum the digits (each 0 or 1).
+	x = x >> 28;         // Position the result.
+	return x;
 }
 
 // The following works only for 7-bit quantities.
-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).
-   x = x >> 28;         // Position the result.
-   return 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).
+	x = x >> 28;         // Position the result.
+	return x;
 }
 
 // The following works only for 15-bit quantities.
-int pop9(unsigned x) {
-   unsigned long long y;
-   y = x * 0x0002000400080010ULL;
-   y = y & 0x1111111111111111ULL;
-   y = y * 0x1111111111111111ULL;
-   y = y >> 60;
-   return y;
+int pop9(unsigned x)
+{
+	unsigned long long y;
+	y = x * 0x0002000400080010ULL;
+	y = y & 0x1111111111111111ULL;
+	y = y * 0x1111111111111111ULL;
+	y = y >> 60;
+	return y;
 }
 
 int errors;
-void error(int x, int y) {
-   errors = errors + 1;
-   printf("Error for x = %08x, got %08x\n", x, y);
+void error(int x, int y)
+{
+	errors = errors + 1;
+	printf("Error for x = %08x, got %08x\n", x, y);
 }
 
 int main()

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;
+	{
+		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