Merge branch '0.9.6'

glm/common.hpp

@@ -26,9 +26,6 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_COMMON_INCLUDED
-#define GLM_COMMON_INCLUDED
+#pragma once
 
 #include "detail/func_common.hpp"
-
-#endif//GLM_COMMON_INCLUDED

glm/detail/_features.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_features
-#define glm_core_features
+#pragma once
 
 // #define GLM_CXX98_EXCEPTIONS
 // #define GLM_CXX98_RTTI
@@ -423,5 +422,3 @@
 #	endif
 
 #endif//(GLM_COMPILER & GLM_COMPILER_CLANG)
-
-#endif//glm_core_features

glm/detail/_literals.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_literals
-#define glm_core_literals
+#pragma once
 
 namespace glm
 {
@@ -47,5 +46,3 @@ namespace glm
 #endif//GLM_CXX11_USER_LITERALS
 
 }//namespace glm
-
-#endif//glm_core_literals

glm/detail/_noise.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_DETAIL_NOISE_INCLUDED
-#define GLM_DETAIL_NOISE_INCLUDED
+#pragma once
 
 namespace glm{
 namespace detail
@@ -126,5 +125,3 @@ namespace detail
 }//namespace detail
 }//namespace glm
 
-#endif//GLM_DETAIL_NOISE_INCLUDED
-

glm/detail/_swizzle.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_swizzle
-#define glm_core_swizzle
+#pragma once
 
 namespace glm{
 namespace detail
@@ -836,5 +835,3 @@ namespace glm
 	struct { _swizzle<4, T, P, V<T, P>, 3,3,3,1> E3 ## E3 ## E3 ## E1; }; \
 	struct { _swizzle<4, T, P, V<T, P>, 3,3,3,2> E3 ## E3 ## E3 ## E2; }; \
 	struct { _swizzle<4, T, P, V<T, P>, 3,3,3,3> E3 ## E3 ## E3 ## E3; };
-
-#endif//glm_core_swizzle

glm/detail/_swizzle_func.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_swizzle_func
-#define glm_core_swizzle_func
+#pragma once
 
 #define GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B)	\
 	SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B() CONST												\
@@ -720,5 +719,3 @@
 	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p, q)
 
 //GLM_SWIZZLE_GEN_VEC_FROM_VEC4(valType, detail::vec4, detail::vec2, detail::vec3, detail::vec4)
-
-#endif//glm_core_swizzle_func

glm/detail/_vectorize.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_CORE_DETAIL_INCLUDED
-#define GLM_CORE_DETAIL_INCLUDED
+#pragma once
 
 #include "type_vec1.hpp"
 #include "type_vec2.hpp"
@@ -213,5 +212,3 @@ namespace detail
 	};
 }//namespace detail
 }//namespace glm
-
-#endif//GLM_CORE_DETAIL_INCLUDED

glm/detail/dummy.cpp

@@ -41,7 +41,8 @@ struct material
 	glm::vec4 diffuse; // Dcm
 	glm::vec4 specular; // Scm
 	float shininess; // Srm
-};
+};
+
 struct light
 {
 	glm::vec4 ambient; // Acli
@@ -58,7 +59,8 @@ struct light
 	float constantAttenuation; // K0
 	float linearAttenuation; // K1
 	float quadraticAttenuation;// K2
-};
+};
+
 
 // Sample 1
 #include <glm/vec3.hpp>// glm::vec3

glm/detail/func_common.hpp

@@ -33,8 +33,7 @@
 /// These all operate component-wise. The description is per component.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_FUNC_COMMON_INCLUDED
-#define GLM_FUNC_COMMON_INCLUDED
+#pragma once
 
 #include "setup.hpp"
 #include "precision.hpp"
@@ -469,4 +468,3 @@ namespace glm
 
 #include "func_common.inl"
 
-#endif//GLM_FUNC_COMMON_INCLUDED

glm/detail/func_exponential.hpp

@@ -33,8 +33,7 @@
 /// These all operate component-wise. The description is per component.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_func_exponential
-#define glm_core_func_exponential
+#pragma once
 
 #include "type_vec1.hpp"
 #include "type_vec2.hpp"
@@ -128,5 +127,3 @@ namespace glm
 }//namespace glm
 
 #include "func_exponential.inl"
-
-#endif//glm_core_func_exponential

glm/detail/func_geometric.hpp

@@ -33,8 +33,7 @@
 /// These operate on vectors as vectors, not component-wise.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_func_geometric
-#define glm_core_func_geometric
+#pragma once
 
 #include "type_vec3.hpp"
 
@@ -147,5 +146,3 @@ namespace glm
 }//namespace glm
 
 #include "func_geometric.inl"
-
-#endif//glm_core_func_geometric

glm/detail/func_integer.hpp

@@ -35,8 +35,7 @@
 /// b, inclusive. The lowest-order bit is bit 0.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_func_integer
-#define glm_core_func_integer
+#pragma once
 
 #include "setup.hpp"
 
@@ -198,6 +197,3 @@ namespace glm
 }//namespace glm
 
 #include "func_integer.inl"
-
-#endif//glm_core_func_integer
-

glm/detail/func_matrix.hpp

@@ -37,8 +37,7 @@
 /// floating point version is shown.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_CORE_func_matrix
-#define GLM_CORE_func_matrix
+#pragma once
 
 // Dependencies
 #include "../detail/precision.hpp"
@@ -175,5 +174,3 @@ namespace detail
 }//namespace glm
 
 #include "func_matrix.inl"
-
-#endif//GLM_CORE_func_matrix

glm/detail/func_noise.hpp

@@ -35,8 +35,7 @@
 /// appearance of randomness, but are not truly random.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_func_noise
-#define glm_core_func_noise
+#pragma once
 
 #include "type_vec1.hpp"
 #include "type_vec2.hpp"
@@ -88,5 +87,3 @@ namespace glm
 }//namespace glm
 
 #include "func_noise.inl"
-
-#endif//glm_core_func_noise

glm/detail/func_packing.hpp

@@ -33,8 +33,7 @@
 /// These functions do not operate component-wise, rather as described in each case.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_CORE_func_packing
-#define GLM_CORE_func_packing
+#pragma once
 
 #include "type_vec2.hpp"
 #include "type_vec4.hpp"
@@ -191,5 +190,3 @@ namespace glm
 }//namespace glm
 
 #include "func_packing.inl"
-
-#endif//GLM_CORE_func_packing

glm/detail/func_trigonometric.hpp

@@ -37,8 +37,7 @@
 /// These all operate component-wise. The description is per component.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_CORE_func_trigonometric
-#define GLM_CORE_func_trigonometric
+#pragma once
 
 namespace glm
 {
@@ -197,7 +196,3 @@ namespace glm
 }//namespace glm
 
 #include "func_trigonometric.inl"
-
-#endif//GLM_CORE_func_trigonometric
-
-

glm/detail/func_vector_relational.hpp

@@ -38,8 +38,7 @@
 /// call must match.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_CORE_func_vector_relational
-#define GLM_CORE_func_vector_relational
+#pragma once
 
 #include "precision.hpp"
 #include "setup.hpp"
@@ -141,5 +140,3 @@ namespace glm
 #endif
 
 #include "func_vector_relational.inl"
-
-#endif//GLM_CORE_func_vector_relational

glm/detail/hint.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type
-#define glm_core_type
+#pragma once
 
 namespace glm
 {
@@ -36,5 +35,3 @@ namespace glm
 	class nicest {};
 	class fastest {};
 }//namespace glm
-
-#endif//glm_core_type

glm/detail/intrinsic_common.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_detail_intrinsic_common
-#define glm_detail_intrinsic_common
+#pragma once
 
 #include "setup.hpp"
 
@@ -86,4 +85,3 @@ namespace detail
 #include "intrinsic_common.inl"
 
 #endif//GLM_ARCH
-#endif//glm_detail_intrinsic_common

glm/detail/intrinsic_exponential.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_detail_intrinsic_exponential
-#define glm_detail_intrinsic_exponential
+#pragma once
 
 #include "setup.hpp"
 
@@ -76,4 +75,3 @@ GLM_FUNC_QUALIFIER __m128 sse_normalize_fast_ps(  float * RESTRICT vOut, float *
 }//namespace glm
 
 #endif//GLM_ARCH
-#endif//glm_detail_intrinsic_exponential

glm/detail/intrinsic_geometric.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_intrinsic_geometric
-#define glm_core_intrinsic_geometric
+#pragma once
 
 #include "setup.hpp"
 
@@ -73,4 +72,3 @@ namespace detail
 #include "intrinsic_geometric.inl"
 
 #endif//GLM_ARCH
-#endif//glm_core_intrinsic_geometric

glm/detail/intrinsic_integer.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_detail_intrinsic_integer
-#define glm_detail_intrinsic_integer
+#pragma once
 
 #include "glm/glm.hpp"
 
@@ -47,4 +46,3 @@ namespace detail
 #include "intrinsic_integer.inl"
 
 #endif//GLM_ARCH
-#endif//glm_detail_intrinsic_integer

glm/detail/intrinsic_matrix.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_detail_intrinsic_matrix
-#define glm_detail_intrinsic_matrix
+#pragma once
 
 #include "setup.hpp"
 
@@ -66,4 +65,3 @@ namespace detail
 #include "intrinsic_matrix.inl"
 
 #endif//GLM_ARCH
-#endif//glm_detail_intrinsic_matrix

glm/detail/intrinsic_trigonometric.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_detail_intrinsic_trigonometric
-#define glm_detail_intrinsic_trigonometric
+#pragma once
 
 #include "setup.hpp"
 
@@ -45,4 +44,3 @@ namespace detail
 #include "intrinsic_trigonometric.inl"
 
 #endif//GLM_ARCH
-#endif//glm_detail_intrinsic_trigonometric

glm/detail/intrinsic_vector_relational.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_detail_intrinsic_vector_relational
-#define glm_detail_intrinsic_vector_relational
+#pragma once
 
 #include "setup.hpp"
 
@@ -45,4 +44,3 @@ namespace detail
 #include "intrinsic_vector_relational.inl"
 
 #endif//GLM_ARCH
-#endif//glm_detail_intrinsic_vector_relational

glm/detail/precision.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_CORE_PRECISION_INCLUDED
-#define GLM_CORE_PRECISION_INCLUDED
+#pragma once
 
 namespace glm
 {
@@ -39,5 +38,3 @@ namespace glm
 		defaultp = highp
 	};
 }//namespace glm
-
-#endif//GLM_CORE_PRECISION_INCLUDED

glm/detail/setup.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_SETUP_INCLUDED
-#define GLM_SETUP_INCLUDED
+#pragma once
 
 #include <cassert>
 
@@ -801,5 +800,3 @@ namespace glm
 #else
 #	define GLM_CONSTEXPR
 #endif
-
-#endif//GLM_SETUP_INCLUDED

glm/detail/type_float.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_float
-#define glm_core_type_float
+#pragma once
 
 #include "setup.hpp"
 
@@ -91,5 +90,3 @@ namespace detail
 	/// @}
 
 }//namespace glm
-
-#endif//glm_core_type_float

glm/detail/type_gentype.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_gentype
-#define glm_core_type_gentype
+#pragma once
 
 namespace glm
 {
@@ -219,5 +218,3 @@ namespace detail
 }//namespace glm
 
 //#include "type_gentype.inl"
-
-#endif//glm_core_type_gentype

glm/detail/type_half.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_half
-#define glm_core_type_half
+#pragma once
 
 #include "setup.hpp"
 
@@ -47,5 +46,3 @@ namespace detail
 }//namespace glm
 
 #include "type_half.inl"
-
-#endif//glm_core_type_half

glm/detail/type_int.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_int
-#define glm_core_type_int
+#pragma once
 
 #include "setup.hpp"
 
@@ -187,5 +186,3 @@ namespace detail
 #endif//GLM_STATIC_ASSERT_NULL
 
 }//namespace glm
-
-#endif//glm_core_type_int

glm/detail/type_mat.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_mat
-#define glm_core_type_mat
+#pragma once
 
 #include "precision.hpp"
 
@@ -791,5 +790,3 @@ namespace detail
 	
 	/// @}
 }//namespace glm
-
-#endif//glm_core_type_mat

glm/detail/type_mat2x2.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_mat2x2
-#define glm_core_type_mat2x2
+#pragma once
 
 #include "../fwd.hpp"
 #include "type_vec2.hpp"
@@ -259,5 +258,3 @@ namespace detail
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat2x2.inl"
 #endif
-
-#endif //glm_core_type_mat2x2

glm/detail/type_mat2x3.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_mat2x3
-#define glm_core_type_mat2x3
+#pragma once
 
 #include "../fwd.hpp"
 #include "type_vec2.hpp"
@@ -223,5 +222,3 @@ namespace detail
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat2x3.inl"
 #endif
-
-#endif //glm_core_type_mat2x3

glm/detail/type_mat2x4.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_mat2x4
-#define glm_core_type_mat2x4
+#pragma once
 
 #include "../fwd.hpp"
 #include "type_vec2.hpp"
@@ -225,5 +224,3 @@ namespace detail
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat2x4.inl"
 #endif
-
-#endif //glm_core_type_mat2x4

glm/detail/type_mat3x2.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_mat3x2
-#define glm_core_type_mat3x2
+#pragma once
 
 #include "../fwd.hpp"
 #include "type_vec2.hpp"
@@ -229,5 +228,3 @@ namespace detail
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat3x2.inl"
 #endif
-
-#endif //glm_core_type_mat3x2

glm/detail/type_mat3x3.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_mat3x3
-#define glm_core_type_mat3x3
+#pragma once
 
 #include "../fwd.hpp"
 #include "type_vec3.hpp"
@@ -263,5 +262,3 @@ namespace detail
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat3x3.inl"
 #endif
-
-#endif //glm_core_type_mat3x3

glm/detail/type_mat3x4.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_mat3x4
-#define glm_core_type_mat3x4
+#pragma once
 
 #include "../fwd.hpp"
 #include "type_vec3.hpp"
@@ -229,5 +228,3 @@ namespace detail
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat3x4.inl"
 #endif
-
-#endif //glm_core_type_mat3x4

glm/detail/type_mat4x2.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_mat4x2
-#define glm_core_type_mat4x2
+#pragma once
 
 #include "../fwd.hpp"
 #include "type_vec2.hpp"
@@ -236,5 +235,3 @@ namespace detail
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat4x2.inl"
 #endif
-
-#endif //glm_core_type_mat4x2

glm/detail/type_mat4x3.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_mat4x3
-#define glm_core_type_mat4x3
+#pragma once
 
 #include "../fwd.hpp"
 #include "type_vec3.hpp"
@@ -236,5 +235,3 @@ namespace detail
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat4x3.inl"
 #endif //GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_mat4x3

glm/detail/type_mat4x4.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_mat4x4
-#define glm_core_type_mat4x4
+#pragma once
 
 #include "../fwd.hpp"
 #include "type_vec4.hpp"
@@ -264,5 +263,3 @@ namespace detail
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat4x4.inl"
 #endif//GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_mat4x4

glm/detail/type_vec.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_vec
-#define glm_core_type_vec
+#pragma once
 
 #include "precision.hpp"
 #include "type_int.hpp"
@@ -512,5 +511,3 @@ namespace detail
 	
 	/// @}
 }//namespace glm
-
-#endif//glm_core_type_vec

glm/detail/type_vec1.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_gentype1
-#define glm_core_type_gentype1
+#pragma once
 
 #include "../fwd.hpp"
 #include "type_vec.hpp"
@@ -273,5 +272,3 @@ namespace detail
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_vec1.inl"
 #endif//GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_gentype1

glm/detail/type_vec2.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_gentype2
-#define glm_core_type_gentype2
+#pragma once
 
 //#include "../fwd.hpp"
 #include "type_vec.hpp"
@@ -311,5 +310,3 @@ namespace detail
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_vec2.inl"
 #endif//GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_gentype2

glm/detail/type_vec3.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_gentype3
-#define glm_core_type_gentype3
+#pragma once
 
 //#include "../fwd.hpp"
 #include "type_vec.hpp"
@@ -329,5 +328,3 @@ namespace detail
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_vec3.inl"
 #endif//GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_gentype3

glm/detail/type_vec4.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_gentype4
-#define glm_core_type_gentype4
+#pragma once
 
 //#include "../fwd.hpp"
 #include "setup.hpp"
@@ -245,13 +244,13 @@ namespace detail
 
 		GLM_FUNC_DECL tvec4<T, P> & operator= (tvec4<T, P> const & v);
 
-		GLM_FUNC_DECL tvec4<T, P> & operator+=(T s);
+		GLM_FUNC_DECL tvec4<T, P> & operator+=(T v);
 		GLM_FUNC_DECL tvec4<T, P> & operator+=(tvec4<T, P> const & v);
-		GLM_FUNC_DECL tvec4<T, P> & operator-=(T s);
+		GLM_FUNC_DECL tvec4<T, P> & operator-=(T v);
 		GLM_FUNC_DECL tvec4<T, P> & operator-=(tvec4<T, P> const & v);
-		GLM_FUNC_DECL tvec4<T, P> & operator*=(T s);
+		GLM_FUNC_DECL tvec4<T, P> & operator*=(T v);
 		GLM_FUNC_DECL tvec4<T, P> & operator*=(tvec4<T, P> const & v);
-		GLM_FUNC_DECL tvec4<T, P> & operator/=(T s);
+		GLM_FUNC_DECL tvec4<T, P> & operator/=(T v);
 		GLM_FUNC_DECL tvec4<T, P> & operator/=(tvec4<T, P> const & v);
 		
 		template <typename U, precision Q>
@@ -418,5 +417,3 @@ namespace detail
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_vec4.inl"
 #endif//GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_gentype4

glm/detail/type_vec4.inl

@@ -295,12 +295,12 @@ namespace detail
 #endif
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator+= (T s)
+	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator+= (T v)
 	{
-		this->x += s;
-		this->y += s;
-		this->z += s;
-		this->w += s;
+		this->x += v;
+		this->y += v;
+		this->z += v;
+		this->w += v;
 		return *this;
 	}
 	
@@ -331,12 +331,12 @@ namespace detail
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator-= (T s)
+	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator-= (T v)
 	{
-		this->x -= s;
-		this->y -= s;
-		this->z -= s;
-		this->w -= s;
+		this->x -= v;
+		this->y -= v;
+		this->z -= v;
+		this->w -= v;
 		return *this;
 	}
 	
@@ -351,12 +351,12 @@ namespace detail
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator*= (T s)
+	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator*= (T v)
 	{
-		this->x *= s;
-		this->y *= s;
-		this->z *= s;
-		this->w *= s;
+		this->x *= v;
+		this->y *= v;
+		this->z *= v;
+		this->w *= v;
 		return *this;
 	}
 	
@@ -371,12 +371,12 @@ namespace detail
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator/= (T s)
+	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator/= (T v)
 	{
-		this->x /= s;
-		this->y /= s;
-		this->z /= s;
-		this->w /= s;
+		this->x /= v;
+		this->y /= v;
+		this->z /= v;
+		this->w /= v;
 		return *this;
 	}
 	
@@ -390,9 +390,6 @@ namespace detail
 		return *this;
 	}
 
-	
-	
-	
 	template <typename T, precision P>
 	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator= (tvec4<U, Q> const & v)

glm/exponential.hpp

@@ -26,9 +26,6 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_EXPONENTIAL_INCLUDED
-#define GLM_EXPONENTIAL_INCLUDED
+#pragma once
 
 #include "detail/func_exponential.hpp"
-
-#endif//GLM_EXPONENTIAL_INCLUDED

glm/ext.hpp

@@ -55,8 +55,7 @@
 /// (http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showprofile&User=22660).
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_EXT_INCLUDED
-#define GLM_EXT_INCLUDED
+#pragma once
 
 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_EXT_INCLUDED_DISPLAYED))
 #	define GLM_MESSAGE_EXT_INCLUDED_DISPLAYED
@@ -133,5 +132,3 @@
 #	include "./gtx/simd_vec4.hpp"
 #	include "./gtx/simd_mat4.hpp"
 #endif
-
-#endif //GLM_EXT_INCLUDED

glm/fwd.hpp

@@ -26,8 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_FWD_INCLUDED
-#define GLM_FWD_INCLUDED
+#pragma once
 
 #include "detail/type_int.hpp"
 #include "detail/type_float.hpp"
@@ -2594,5 +2593,3 @@ namespace glm
 	typedef highp_f64quat			f64quat;
 #endif
 }//namespace glm
-
-#endif//GLM_FWD_INCLUDED

glm/geometric.hpp

@@ -26,9 +26,6 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GEOMETRIC_INCLUDED
-#define GLM_GEOMETRIC_INCLUDED
+#pragma once
 
 #include "detail/func_geometric.hpp"
-
-#endif//GLM_GEOMETRIC_INCLUDED

glm/glm.hpp

@@ -77,8 +77,7 @@
 
 #include "detail/_fixes.hpp"
 
-#ifndef GLM_INCLUDED
-#define GLM_INCLUDED
+#pragma once
 
 #include <cmath>
 #include <climits>
@@ -113,5 +112,3 @@
 #include "matrix.hpp"
 #include "vector_relational.hpp"
 #include "integer.hpp"
-
-#endif//GLM_INCLUDED

glm/gtc/constants.hpp

@@ -36,8 +36,7 @@
 /// <glm/gtc/constants.hpp> need to be included to use these features.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTC_constants
-#define GLM_GTC_constants
+#pragma once
 
 // Dependencies
 #include "../detail/setup.hpp"
@@ -181,5 +180,3 @@ namespace glm
 } //namespace glm
 
 #include "constants.inl"
-
-#endif//GLM_GTC_constants

glm/gtc/epsilon.hpp

@@ -37,8 +37,7 @@
 /// <glm/gtc/epsilon.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTC_epsilon
-#define GLM_GTC_epsilon
+#pragma once
 
 // Dependencies
 #include "../detail/setup.hpp"
@@ -97,5 +96,3 @@ namespace glm
 }//namespace glm
 
 #include "epsilon.inl"
-
-#endif//GLM_GTC_epsilon

glm/gtc/matrix_access.hpp

@@ -34,8 +34,7 @@
 /// <glm/gtc/matrix_access.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTC_matrix_access
-#define GLM_GTC_matrix_access
+#pragma once
 
 // Dependency:
 #include "../detail/setup.hpp"
@@ -83,5 +82,3 @@ namespace glm
 }//namespace glm
 
 #include "matrix_access.inl"
-
-#endif//GLM_GTC_matrix_access

glm/gtc/matrix_integer.hpp

@@ -34,8 +34,7 @@
 /// <glm/gtc/matrix_integer.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTC_matrix_integer
-#define GLM_GTC_matrix_integer
+#pragma once
 
 // Dependency:
 #include "../mat2x2.hpp"
@@ -510,5 +509,3 @@ namespace glm
 
 	/// @}
 }//namespace glm
-
-#endif//GLM_GTC_matrix_integer

glm/gtc/matrix_inverse.hpp

@@ -34,8 +34,7 @@
 /// <glm/gtc/matrix_inverse.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTC_matrix_inverse
-#define GLM_GTC_matrix_inverse
+#pragma once
 
 // Dependencies
 #include "../detail/setup.hpp"
@@ -70,5 +69,3 @@ namespace glm
 }//namespace glm
 
 #include "matrix_inverse.inl"
-
-#endif//GLM_GTC_matrix_inverse

glm/gtc/matrix_transform.hpp

@@ -43,8 +43,7 @@
 /// <glm/gtc/matrix_transform.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTC_matrix_transform
-#define GLM_GTC_matrix_transform
+#pragma once
 
 // Dependency:
 #include "../mat4x4.hpp"
@@ -302,5 +301,3 @@ namespace glm
 }//namespace glm
 
 #include "matrix_transform.inl"
-
-#endif//GLM_GTC_matrix_transform

glm/gtc/matrix_transform.inl

@@ -167,7 +167,7 @@ namespace glm
 		detail::tmat4x4<T, defaultp> Result(1);
 		Result[0][0] = static_cast<T>(2) / (right - left);
 		Result[1][1] = static_cast<T>(2) / (top - bottom);
-		Result[2][2] = - T(2) / (zFar - zNear);
+		Result[2][2] = - static_cast<T>(2) / (zFar - zNear);
 		Result[3][0] = - (right + left) / (right - left);
 		Result[3][1] = - (top + bottom) / (top - bottom);
 		Result[3][2] = - (zFar + zNear) / (zFar - zNear);
@@ -186,7 +186,7 @@ namespace glm
 		detail::tmat4x4<T, defaultp> Result(1);
 		Result[0][0] = static_cast<T>(2) / (right - left);
 		Result[1][1] = static_cast<T>(2) / (top - bottom);
-		Result[2][2] = - T(1);
+		Result[2][2] = - static_cast<T>(1);
 		Result[3][0] = - (right + left) / (right - left);
 		Result[3][1] = - (top + bottom) / (top - bottom);
 		return Result;

glm/gtc/noise.hpp

@@ -38,8 +38,7 @@
 /// <glm/gtc/noise.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTC_noise
-#define GLM_GTC_noise
+#pragma once
 
 // Dependencies
 #include "../detail/setup.hpp"
@@ -77,5 +76,3 @@ namespace glm
 }//namespace glm
 
 #include "noise.inl"
-
-#endif//GLM_GTC_noise

glm/gtc/packing.hpp

@@ -36,8 +36,7 @@
 /// <glm/gtc/packing.hpp> need to be included to use these features.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTC_packing
-#define GLM_GTC_packing
+#pragma once
 
 // Dependency:
 #include "type_precision.hpp"
@@ -473,6 +472,3 @@ namespace glm
 }// namespace glm
 
 #include "packing.inl"
-
-#endif//GLM_GTC_packing
-

glm/gtc/quaternion.hpp

@@ -37,8 +37,7 @@
 /// <glm/gtc/quaternion.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTC_quaternion
-#define GLM_GTC_quaternion
+#pragma once
 
 // Dependency:
 #include "../mat3x3.hpp"
@@ -59,7 +58,7 @@ namespace detail
 	{
 		enum ctor{null};
 
-                typedef T value_type;
+		typedef T value_type;
 		typedef tvec4<bool, P> bool_type;
 
 	public:
@@ -400,5 +399,3 @@ namespace detail
 } //namespace glm
 
 #include "quaternion.inl"
-
-#endif//GLM_GTC_quaternion

glm/gtc/quaternion.inl

@@ -114,9 +114,9 @@ namespace detail
 		detail::tvec3<T, P> const & v
 	)
 	{
-		detail::tvec3<T, P> w = cross(u, v);
+		detail::tvec3<T, P> const LocalW(cross(u, v));
 		T Dot = detail::compute_dot<detail::tvec3, T, P>::call(u, v);
-		detail::tquat<T, P> q(T(1) + Dot, w.x, w.y, w.z);
+		detail::tquat<T, P> q(T(1) + Dot, LocalW.x, LocalW.y, LocalW.z);
 
 		*this = normalize(q);
 	}

glm/gtc/random.hpp

@@ -37,8 +37,7 @@
 /// <glm/gtc/random.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTC_random
-#define GLM_GTC_random
+#pragma once
 
 // Dependency:
 #include "../vec2.hpp"
@@ -110,5 +109,3 @@ namespace glm
 }//namespace glm
 
 #include "random.inl"
-
-#endif//GLM_GTC_random

glm/gtc/reciprocal.hpp

@@ -35,8 +35,7 @@
 /// <glm/gtc/reciprocal.hpp> need to be included to use these features.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTC_reciprocal
-#define GLM_GTC_reciprocal
+#pragma once
 
 // Dependencies
 #include "../detail/setup.hpp"
@@ -129,5 +128,3 @@ namespace glm
 }//namespace glm
 
 #include "reciprocal.inl"
-
-#endif//GLM_GTC_reciprocal

glm/gtc/type_precision.hpp

@@ -40,8 +40,7 @@
 /// <glm/gtc/type_precision.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTC_type_precision
-#define GLM_GTC_type_precision
+#pragma once
 
 // Dependency:
 #include "../gtc/quaternion.hpp"
@@ -870,5 +869,3 @@ namespace glm
 }//namespace glm
 
 #include "type_precision.inl"
-
-#endif//GLM_GTC_type_precision

glm/gtc/type_ptr.hpp

@@ -56,8 +56,7 @@
 /// <glm/gtc/type_ptr.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTC_type_ptr
-#define GLM_GTC_type_ptr
+#pragma once
 
 // Dependency:
 #include "../gtc/quaternion.hpp"
@@ -174,6 +173,3 @@ namespace glm
 }//namespace glm
 
 #include "type_ptr.inl"
-
-#endif//GLM_GTC_type_ptr
-

glm/gtc/ulp.hpp

@@ -36,8 +36,7 @@
 /// <glm/gtc/ulp.hpp> need to be included to use these features.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTC_ulp
-#define GLM_GTC_ulp
+#pragma once
 
 // Dependencies
 #include "../detail/setup.hpp"
@@ -87,6 +86,3 @@ namespace glm
 }// namespace glm
 
 #include "ulp.inl"
-
-#endif//GLM_GTC_ulp
-

glm/gtc/ulp.inl

@@ -201,8 +201,10 @@ namespace glm
 	{
 #		if((GLM_LANG & GLM_LANG_CXX11_FLAG) && !(GLM_PLATFORM & GLM_PLATFORM_ANDROID))
 			return std::nextafter(x, std::numeric_limits<float>::max());
-#		elif((GLM_PLATFORM & GLM_PLATFORM_ANDROID) || (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
+#		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
 			return detail::nextafterf(x, FLT_MAX);
+#		elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
+			return _nextafterf(x, FLT_MAX);
 #		else
 			return nextafterf(x, FLT_MAX);
 #		endif
@@ -213,7 +215,7 @@ namespace glm
 	{
 #		if((GLM_LANG & GLM_LANG_CXX11_FLAG) && !(GLM_PLATFORM & GLM_PLATFORM_ANDROID))
 			return std::nextafter(x, std::numeric_limits<double>::max());
-#		elif((GLM_PLATFORM & GLM_PLATFORM_ANDROID) || (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
+#		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
 			return detail::nextafter(x, std::numeric_limits<double>::max());
 #		else
 			return nextafter(x, DBL_MAX);
@@ -233,8 +235,10 @@ namespace glm
 	{
 #		if((GLM_LANG & GLM_LANG_CXX11_FLAG) && !(GLM_PLATFORM & GLM_PLATFORM_ANDROID))
 			return std::nextafter(x, std::numeric_limits<float>::min());
-#		elif((GLM_PLATFORM & GLM_PLATFORM_ANDROID) || (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
+#		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
 			return detail::nextafterf(x, FLT_MIN);
+#		elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
+			return _nextafterf(x, FLT_MIN);
 #		else
 			return nextafterf(x, FLT_MIN);
 #		endif

glm/gtx/associated_min_max.hpp

@@ -35,8 +35,7 @@
 /// <glm/gtx/associated_min_max.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_associated_min_max
-#define GLM_GTX_associated_min_max
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -102,5 +101,3 @@ namespace glm
 } //namespace glm
 
 #include "associated_min_max.inl"
-
-#endif//GLM_GTX_associated_min_max

glm/gtx/bit.hpp

@@ -36,8 +36,7 @@
 /// <glm/gtx/bit.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_bit
-#define GLM_GTX_bit
+#pragma once
 
 // Dependencies
 #include "../detail/type_int.hpp"
@@ -230,5 +229,3 @@ namespace glm
 } //namespace glm
 
 #include "bit.inl"
-
-#endif//GLM_GTX_bit

glm/gtx/closest_point.hpp

@@ -35,8 +35,7 @@
 /// <glm/gtx/closest_point.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_closest_point
-#define GLM_GTX_closest_point
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -62,5 +61,3 @@ namespace glm
 }// namespace glm
 
 #include "closest_point.inl"
-
-#endif//GLM_GTX_closest_point

glm/gtx/color_space.hpp

@@ -35,8 +35,7 @@
 /// <glm/gtx/color_space.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_color_space
-#define GLM_GTX_color_space
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -92,5 +91,3 @@ namespace glm
 }//namespace glm
 
 #include "color_space.inl"
-
-#endif//GLM_GTX_color_space

glm/gtx/color_space_YCoCg.hpp

@@ -35,8 +35,7 @@
 /// <glm/gtx/color_space_YCoCg.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_gtx_color_space_YCoCg
-#define glm_gtx_color_space_YCoCg
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -80,5 +79,3 @@ namespace glm
 }//namespace glm
 
 #include "color_space_YCoCg.inl"
-
-#endif//glm_gtx_color_space_YCoCg

glm/gtx/compatibility.hpp

@@ -36,8 +36,7 @@
 /// <glm/gtx/compatibility.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_compatibility
-#define GLM_GTX_compatibility
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"  
@@ -155,6 +154,3 @@ namespace glm
 }//namespace glm
 
 #include "compatibility.inl"
-
-#endif//GLM_GTX_compatibility
-

glm/gtx/component_wise.hpp

@@ -35,8 +35,7 @@
 /// <glm/gtx/component_wise.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_component_wise
-#define GLM_GTX_component_wise
+#pragma once
 
 // Dependencies
 #include "../detail/setup.hpp"
@@ -78,5 +77,3 @@ namespace glm
 }//namespace glm
 
 #include "component_wise.inl"
-
-#endif//GLM_GTX_component_wise

glm/gtx/dual_quaternion.hpp

@@ -38,8 +38,7 @@
 /// <glm/gtx/dual_quaternion.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_dual_quaternion
-#define GLM_GTX_dual_quaternion
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -57,13 +56,13 @@ namespace detail
 	struct tdualquat
 	{
 		enum ctor{null};
-		
+		typedef T value_type;
 		typedef glm::detail::tquat<T, P> part_type;
 		
 	public:
 		glm::detail::tquat<T, P> real, dual;
 		
-		GLM_FUNC_DECL GLM_CONSTEXPR int length() const;
+		GLM_FUNC_DECL GLM_CONSTEXPR length_t length() const;
 		
 		// Constructors
 		GLM_FUNC_DECL tdualquat();
@@ -291,5 +290,3 @@ namespace detail
 } //namespace glm
 
 #include "dual_quaternion.inl"
-
-#endif//GLM_GTX_dual_quaternion

glm/gtx/dual_quaternion.inl

@@ -33,7 +33,7 @@ namespace glm{
 namespace detail
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR int tdualquat<T, P>::length() const
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR length_t tdualquat<T, P>::length() const
 	{
 		return 8;
 	}

glm/gtx/euler_angles.hpp

@@ -36,8 +36,7 @@
 /// <glm/gtx/euler_angles.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_euler_angles
-#define GLM_GTX_euler_angles
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -151,5 +150,3 @@ namespace glm
 }//namespace glm
 
 #include "euler_angles.inl"
-
-#endif//GLM_GTX_euler_angles

glm/gtx/extend.hpp

@@ -35,8 +35,7 @@
 /// <glm/gtx/extend.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_extend
-#define GLM_GTX_extend
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -62,5 +61,3 @@ namespace glm
 }//namespace glm
 
 #include "extend.inl"
-
-#endif//GLM_GTX_extend

glm/gtx/extented_min_max.hpp

@@ -36,8 +36,7 @@
 /// <glm/gtx/extented_min_max.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_extented_min_max
-#define GLM_GTX_extented_min_max
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -157,5 +156,3 @@ namespace glm
 }//namespace glm
 
 #include "extented_min_max.inl"
-
-#endif//GLM_GTX_extented_min_max

glm/gtx/fast_exponential.hpp

@@ -36,8 +36,7 @@
 /// <glm/gtx/fast_exponential.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_fast_exponential
-#define GLM_GTX_fast_exponential
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -94,5 +93,3 @@ namespace glm
 }//namespace glm
 
 #include "fast_exponential.inl"
-
-#endif//GLM_GTX_fast_exponential

glm/gtx/fast_square_root.hpp

@@ -37,8 +37,7 @@
 /// <glm/gtx/fast_square_root.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_fast_square_root
-#define GLM_GTX_fast_square_root
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -86,5 +85,3 @@ namespace glm
 }// namespace glm
 
 #include "fast_square_root.inl"
-
-#endif//GLM_GTX_fast_square_root

glm/gtx/fast_trigonometry.hpp

@@ -35,8 +35,7 @@
 /// <glm/gtx/fast_trigonometry.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_fast_trigonometry
-#define GLM_GTX_fast_trigonometry
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -96,5 +95,3 @@ namespace glm
 }//namespace glm
 
 #include "fast_trigonometry.inl"
-
-#endif//GLM_GTX_fast_trigonometry

glm/gtx/gradient_paint.hpp

@@ -35,8 +35,7 @@
 /// <glm/gtx/gradient_paint.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_gradient_paint
-#define GLM_GTX_gradient_paint
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -72,5 +71,3 @@ namespace glm
 }// namespace glm
 
 #include "gradient_paint.inl"
-
-#endif//GLM_GTX_gradient_paint

glm/gtx/handed_coordinate_space.hpp

@@ -35,8 +35,7 @@
 /// <glm/gtx/handed_coordinate_system.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_handed_coordinate_space
-#define GLM_GTX_handed_coordinate_space
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -70,5 +69,3 @@ namespace glm
 }// namespace glm
 
 #include "handed_coordinate_space.inl"
-
-#endif//GLM_GTX_handed_coordinate_space

glm/gtx/inertia.hpp

@@ -36,8 +36,7 @@
 /// <glm/gtx/inertia.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_inertia
-#define GLM_GTX_inertia
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -112,5 +111,3 @@ namespace glm
 }// namespace glm
 
 #include "inertia.inl"
-
-#endif//GLM_GTX_inertia

glm/gtx/integer.hpp

@@ -35,8 +35,7 @@
 /// <glm/gtx/integer.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_integer
-#define GLM_GTX_integer
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -100,5 +99,3 @@ namespace glm
 }//namespace glm
 
 #include "integer.inl"
-
-#endif//GLM_GTX_integer

glm/gtx/intersect.hpp

@@ -36,8 +36,7 @@
 /// <glm/gtx/intersect.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_intersect
-#define GLM_GTX_intersect
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -107,5 +106,3 @@ namespace glm
 }//namespace glm
 
 #include "intersect.inl"
-
-#endif//GLM_GTX_intersect

glm/gtx/io.hpp

@@ -40,8 +40,7 @@
 /// <glm/gtx/io.hpp> needs to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_io
-#define GLM_GTX_io GLM_VERSION
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -222,5 +221,3 @@ namespace glm
 }//namespace glm
 
 #include "io.inl"
-
-#endif//GLM_GTX_io

glm/gtx/log_base.hpp

@@ -35,8 +35,7 @@
 /// <glm/gtx/log_base.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_log_base
-#define GLM_GTX_log_base
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -61,5 +60,3 @@ namespace glm
 }//namespace glm
 
 #include "log_base.inl"
-
-#endif//GLM_GTX_log_base

glm/gtx/matrix_cross_product.hpp

@@ -36,8 +36,7 @@
 /// <glm/gtx/matrix_cross_product.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_matrix_cross_product
-#define GLM_GTX_matrix_cross_product
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -67,5 +66,3 @@ namespace glm
 }//namespace glm
 
 #include "matrix_cross_product.inl"
-
-#endif//GLM_GTX_matrix_cross_product

glm/gtx/matrix_interpolation.hpp

@@ -35,8 +35,7 @@
 /// <glm/gtx/matrix_interpolation.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_matrix_interpolation
-#define GLM_GTX_matrix_interpolation
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -84,5 +83,3 @@ namespace glm
 }//namespace glm
 
 #include "matrix_interpolation.inl"
-
-#endif//GLM_GTX_matrix_interpolation

glm/gtx/matrix_major_storage.hpp

@@ -36,8 +36,7 @@
 /// <glm/gtx/matrix_major_storage.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_matrix_major_storage
-#define GLM_GTX_matrix_major_storage
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -139,5 +138,3 @@ namespace glm
 }//namespace glm
 
 #include "matrix_major_storage.inl"
-
-#endif//GLM_GTX_matrix_major_storage

glm/gtx/matrix_operation.hpp

@@ -35,8 +35,7 @@
 /// <glm/gtx/matrix_operation.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_matrix_operation
-#define GLM_GTX_matrix_operation
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -108,5 +107,3 @@ namespace glm
 }//namespace glm
 
 #include "matrix_operation.inl"
-
-#endif//GLM_GTX_matrix_operation

glm/gtx/matrix_query.hpp

@@ -36,8 +36,7 @@
 /// <glm/gtx/matrix_query.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_matrix_query
-#define GLM_GTX_matrix_query
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -97,5 +96,3 @@ namespace glm
 }//namespace glm
 
 #include "matrix_query.inl"
-
-#endif//GLM_GTX_matrix_query

glm/gtx/matrix_transform_2d.hpp

@@ -35,8 +35,7 @@
 /// <glm/gtx/matrix_transform_2d.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_matrix_transform_2d
-#define GLM_GTX_matrix_transform_2d
+#pragma once
 
 // Dependency:
 #include "../mat3x3.hpp"
@@ -101,5 +100,3 @@ namespace glm
 }//namespace glm
 
 #include "matrix_transform_2d.inl"
-
-#endif//GLM_GTX_matrix_transform_2d

glm/gtx/mixed_product.hpp

@@ -35,8 +35,7 @@
 /// <glm/gtx/mixed_product.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_mixed_product
-#define GLM_GTX_mixed_product
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -61,5 +60,3 @@ namespace glm
 }// namespace glm
 
 #include "mixed_product.inl"
-
-#endif//GLM_GTX_mixed_product

glm/gtx/multiple.hpp

@@ -36,8 +36,7 @@
 /// <glm/gtx/multiple.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_multiple
-#define GLM_GTX_multiple
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -79,5 +78,3 @@ namespace glm
 }//namespace glm
 
 #include "multiple.inl"
-
-#endif//GLM_GTX_multiple

glm/gtx/norm.hpp

@@ -36,8 +36,7 @@
 /// <glm/gtx/norm.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_GTX_norm
-#define GLM_GTX_norm
+#pragma once
 
 // Dependency:
 #include "../glm.hpp"
@@ -123,5 +122,3 @@ namespace glm
 }//namespace glm
 
 #include "norm.inl"
-
-#endif//GLM_GTX_norm