Fixed merge

glm/core/_swizzle.hpp

@@ -191,7 +191,7 @@ namespace detail
 		typedef ValueType       value_type;
 
 		struct Stub {};
-		_swizzle_base2& operator= (Stub const &) {}
+		_swizzle_base2& operator= (Stub const &) { return *this; }
 
 		value_type  operator[]  (size_t i) const
 		{
@@ -640,22 +640,22 @@ namespace glm
 	struct { _swizzle<4, T, P, V<T, P>, 0,2,3,1> E0 ## E2 ## E3 ## E1; }; \
 	struct { _swizzle<4, T, P, V<T, P>, 0,2,3,2> E0 ## E2 ## E3 ## E2; }; \
 	struct { _swizzle<4, T, P, V<T, P>, 0,2,3,3> E0 ## E2 ## E3 ## E3; }; \
-	struct { _swizzle<4, T, P, V<T, P>, 0,3,0,0> E0 ## E2 ## E0 ## E0; }; \
-	struct { _swizzle<4, T, P, V<T, P>, 0,3,0,1> E0 ## E2 ## E0 ## E1; }; \
-	struct { _swizzle<4, T, P, V<T, P>, 0,3,0,2> E0 ## E2 ## E0 ## E2; }; \
-	struct { _swizzle<4, T, P, V<T, P>, 0,3,0,3> E0 ## E2 ## E0 ## E3; }; \
-	struct { _swizzle<4, T, P, V<T, P>, 0,3,1,0> E0 ## E2 ## E1 ## E0; }; \
-	struct { _swizzle<4, T, P, V<T, P>, 0,3,1,1> E0 ## E2 ## E1 ## E1; }; \
-	struct { _swizzle<4, T, P, V<T, P>, 0,3,1,2> E0 ## E2 ## E1 ## E2; }; \
-	struct { _swizzle<4, T, P, V<T, P>, 0,3,1,3> E0 ## E2 ## E1 ## E3; }; \
-	struct { _swizzle<4, T, P, V<T, P>, 0,3,2,0> E0 ## E2 ## E2 ## E0; }; \
-	struct { _swizzle<4, T, P, V<T, P>, 0,3,2,1> E0 ## E2 ## E2 ## E1; }; \
-	struct { _swizzle<4, T, P, V<T, P>, 0,3,2,2> E0 ## E2 ## E2 ## E2; }; \
-	struct { _swizzle<4, T, P, V<T, P>, 0,3,2,3> E0 ## E2 ## E2 ## E3; }; \
-	struct { _swizzle<4, T, P, V<T, P>, 0,3,3,0> E0 ## E2 ## E3 ## E0; }; \
-	struct { _swizzle<4, T, P, V<T, P>, 0,3,3,1> E0 ## E2 ## E3 ## E1; }; \
-	struct { _swizzle<4, T, P, V<T, P>, 0,3,3,2> E0 ## E2 ## E3 ## E2; }; \
-	struct { _swizzle<4, T, P, V<T, P>, 0,3,3,3> E0 ## E2 ## E3 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,0,0> E0 ## E3 ## E0 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,0,1> E0 ## E3 ## E0 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,0,2> E0 ## E3 ## E0 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,0,3> E0 ## E3 ## E0 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,1,0> E0 ## E3 ## E1 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,1,1> E0 ## E3 ## E1 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,1,2> E0 ## E3 ## E1 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,1,3> E0 ## E3 ## E1 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,2,0> E0 ## E3 ## E2 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,2,1> E0 ## E3 ## E2 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,2,2> E0 ## E3 ## E2 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,2,3> E0 ## E3 ## E2 ## E3; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,3,0> E0 ## E3 ## E3 ## E0; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,3,1> E0 ## E3 ## E3 ## E1; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,3,2> E0 ## E3 ## E3 ## E2; }; \
+	struct { _swizzle<4, T, P, V<T, P>, 0,3,3,3> E0 ## E3 ## E3 ## E3; }; \
 	struct { _swizzle<4, T, P, V<T, P>, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
 	struct { _swizzle<4, T, P, V<T, P>, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
 	struct { _swizzle<4, T, P, V<T, P>, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
@@ -847,6 +847,6 @@ namespace glm
 	struct { _swizzle<4, T, P, V<T, P>, 3,3,3,0> E3 ## E3 ## E3 ## E0; }; \
 	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; }; 
+	struct { _swizzle<4, T, P, V<T, P>, 3,3,3,3> E3 ## E3 ## E3 ## E3; };
 
 #endif//glm_core_swizzle

glm/core/func_common.hpp

@@ -51,7 +51,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	genType abs(genType const & x);
+	GLM_FUNC_DECL genType abs(genType const & x);
 
 	/// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0. 
 	/// 
@@ -60,8 +60,8 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sign.xml">GLSL sign man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	genType sign(genType const & x);
-
+	GLM_FUNC_DECL genType sign(genType const & x);
+	
 	/// Returns a value equal to the nearest integer that is less then or equal to x. 
 	/// 
 	/// @tparam genType Floating-point scalar or vector types.
@@ -69,7 +69,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floor.xml">GLSL floor man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	genType floor(genType const & x);
+	GLM_FUNC_DECL genType floor(genType const & x);
 
 	/// Returns a value equal to the nearest integer to x
 	/// whose absolute value is not larger than the absolute value of x.
@@ -79,7 +79,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/trunc.xml">GLSL trunc man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	genType trunc(genType const & x);
+	GLM_FUNC_DECL genType trunc(genType const & x);
 
 	/// Returns a value equal to the nearest integer to x.
 	/// The fraction 0.5 will round in a direction chosen by the
@@ -92,8 +92,8 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	genType round(genType const & x);
-
+	GLM_FUNC_DECL genType round(genType const & x);
+	
 	/// Returns a value equal to the nearest integer to x.
 	/// A fractional part of 0.5 will round toward the nearest even
 	/// integer. (Both 3.5 and 4.5 for x will return 4.0.)
@@ -104,7 +104,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	/// @see <a href="http://developer.amd.com/documentation/articles/pages/New-Round-to-Even-Technique.aspx">New round to even technique</a>
 	template <typename genType>
-	genType roundEven(genType const & x);
+	GLM_FUNC_DECL genType roundEven(genType const & x);
 
 	/// Returns a value equal to the nearest integer
 	/// that is greater than or equal to x.
@@ -114,7 +114,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ceil.xml">GLSL ceil man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	genType ceil(genType const & x);
+	GLM_FUNC_DECL genType ceil(genType const & x);
 
 	/// Return x - floor(x).
 	/// 
@@ -123,7 +123,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fract.xml">GLSL fract man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	genType fract(genType const & x);
+	GLM_FUNC_DECL genType fract(genType const & x);
 
 	/// Modulus. Returns x - y * floor(x / y)
 	/// for each component in x using the floating point value y.
@@ -133,7 +133,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	genType mod(
+	GLM_FUNC_DECL genType mod(
 		genType const & x,
 		genType const & y);
 
@@ -145,7 +145,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	genType mod(
+	GLM_FUNC_DECL genType mod(
 		genType const & x,
 		typename genType::value_type const & y);
 
@@ -159,7 +159,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/modf.xml">GLSL modf man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	genType modf(
+	GLM_FUNC_DECL genType modf(
 		genType const & x,
 		genType & i);
 
@@ -168,14 +168,14 @@ namespace glm
 	/// @tparam genType Floating-point or integer; scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a><<<<<<< HEAD
 	template <typename genType>
-	genType min(
+	GLM_FUNC_DECL genType min(
 		genType const & x,
 		genType const & y);
 
 	template <typename genType>
-	genType min(
+	GLM_FUNC_DECL genType min(
 		genType const & x,
 		typename genType::value_type const & y);
 
@@ -186,12 +186,12 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	genType max(
+	GLM_FUNC_DECL genType max(
 		genType const & x,
 		genType const & y);
 
 	template <typename genType>
-	genType max(
+	GLM_FUNC_DECL genType max(
 		genType const & x,
 		typename genType::value_type const & y);
 
@@ -203,13 +203,13 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	genType clamp(
+	GLM_FUNC_DECL genType clamp(
 		genType const & x,
 		genType const & minVal,
 		genType const & maxVal);
 
 	template <typename genType, precision P>
-	genType clamp(
+	GLM_FUNC_DECL genType clamp(
 		genType const & x,
 		typename genType::value_type const & minVal,
 		typename genType::value_type const & maxVal);
@@ -257,19 +257,22 @@ namespace glm
 	/// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter.
 	/// @endcode
 	template <typename genTypeT, typename genTypeU>
-	genTypeT mix(genTypeT const & x, genTypeT const & y, genTypeU const & a);
+	GLM_FUNC_DECL genTypeT mix(
+		genTypeT const & x,
+		genTypeT const & y,
+		genTypeU const & a);
 
-	//! Returns 0.0 if x < edge, otherwise it returns 1.0.
-	//! 
+	/// Returns 0.0 if x < edge, otherwise it returns 1.0.
+	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	genType step(
+	GLM_FUNC_DECL genType step(
 		genType const & edge,
 		genType const & x);
 
 	template <typename genType>
-	genType step(
+	GLM_FUNC_DECL genType step(
 		typename genType::value_type const & edge,
 		genType const & x);
 
@@ -288,13 +291,13 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/smoothstep.xml">GLSL smoothstep man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	genType smoothstep(
+	GLM_FUNC_DECL genType smoothstep(
 		genType const & edge0,
 		genType const & edge1,
 		genType const & x);
 
 	template <typename genType>
-	genType smoothstep(
+	GLM_FUNC_DECL genType smoothstep(
 		typename genType::value_type const & edge0,
 		typename genType::value_type const & edge1,
 		genType const & x);
@@ -312,7 +315,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType> 
-	typename genType::bool_type isnan(genType const & x);
+	GLM_FUNC_DECL typename genType::bool_type isnan(genType const & x);
 
 	/// Returns true if x holds a positive infinity or negative
 	/// infinity representation in the underlying implementation's
@@ -325,7 +328,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isinf.xml">GLSL isinf man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType> 
-	typename genType::bool_type isinf(genType const & x);
+	GLM_FUNC_DECL typename genType::bool_type isinf(genType const & x);
 
 	/// Returns a signed integer value representing
 	/// the encoding of a floating-point value. The floatingpoint
@@ -337,7 +340,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType, typename genIType>
-	genIType floatBitsToInt(genType const & value);
+	GLM_FUNC_DECL genIType floatBitsToInt(genType const & value);
 
 	/// Returns a unsigned integer value representing
 	/// the encoding of a floating-point value. The floatingpoint
@@ -349,7 +352,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType, typename genUType>
-	genUType floatBitsToUint(genType const & value);
+	GLM_FUNC_DECL genUType floatBitsToUint(genType const & value);
 
 	/// Returns a floating-point value corresponding to a signed
 	/// integer encoding of a floating-point value.
@@ -365,7 +368,7 @@ namespace glm
 	/// 
 	/// @todo Clarify this declaration, we don't need to actually specify the return type
 	template <typename genType, typename genIType>
-	genType intBitsToFloat(genIType const & value);
+	GLM_FUNC_DECL genType intBitsToFloat(genIType const & value);
 
 	/// Returns a floating-point value corresponding to a
 	/// unsigned integer encoding of a floating-point value.
@@ -381,7 +384,7 @@ namespace glm
 	/// 
 	/// @todo Clarify this declaration, we don't need to actually specify the return type
 	template <typename genType, typename genUType>
-	genType uintBitsToFloat(genUType const & value);
+	GLM_FUNC_DECL genType uintBitsToFloat(genUType const & value);
 
 	/// Computes and returns a * b + c.
 	/// 
@@ -390,7 +393,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fma.xml">GLSL fma man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	genType fma(genType const & a, genType const & b, genType const & c);
+	GLM_FUNC_DECL genType fma(genType const & a, genType const & b, genType const & c);
 
 	/// Splits x into a floating-point significand in the range
 	/// [0.5, 1.0) and an integral exponent of two, such that:
@@ -407,7 +410,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/frexp.xml">GLSL frexp man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType, typename genIType>
-	genType frexp(genType const & x, genIType & exp);
+	GLM_FUNC_DECL genType frexp(genType const & x, genIType & exp);
 
 	/// Builds a floating-point number from x and the
 	/// corresponding integral exponent of two in exp, returning:
@@ -421,7 +424,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ldexp.xml">GLSL ldexp man page</a>; 
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType, typename genIType>
-	genType ldexp(genType const & x, genIType const & exp);
+	GLM_FUNC_DECL genType ldexp(genType const & x, genIType const & exp);
 
 	/// @}
 }//namespace glm

glm/core/func_common.inl

@@ -36,7 +36,7 @@ namespace detail
 	template <typename genFIType>
 	struct Abs_<genFIType, true>
 	{
-		static genFIType get(genFIType const & x)
+		GLM_FUNC_QUALIFIER static genFIType get(genFIType const & x)
 		{
 			GLM_STATIC_ASSERT(
 				detail::type<genFIType>::is_float || 
@@ -49,7 +49,7 @@ namespace detail
 	template <typename genFIType>
 	struct Abs_<genFIType, false>
 	{
-		static genFIType get(genFIType const & x)
+		GLM_FUNC_QUALIFIER static genFIType get(genFIType const & x)
 		{
 			GLM_STATIC_ASSERT(
 					detail::type<genFIType>::is_uint, "'abs' only accept floating-point and integer inputs");

glm/core/func_exponential.hpp

@@ -50,7 +50,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/pow.xml">GLSL pow man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
 	template <typename genType> 
-	genType pow(genType const & base, genType const & exponent);
+	GLM_FUNC_DECL genType pow(genType const & base, genType const & exponent);
 
 	/// Returns the natural exponentiation of x, i.e., e^x.
 	///
@@ -60,7 +60,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp.xml">GLSL exp man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
 	template <typename genType> 
-	genType exp(genType const & x);
+	GLM_FUNC_DECL genType exp(genType const & x);
 
 	/// Returns the natural logarithm of x, i.e., 
 	/// returns the value y which satisfies the equation x = e^y. 
@@ -72,7 +72,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log.xml">GLSL log man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
 	template <typename genType> 
-	genType log(genType const & x);
+	GLM_FUNC_DECL genType log(genType const & x);
 
 	/// Returns 2 raised to the x power.
 	/// 
@@ -82,7 +82,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp2.xml">GLSL exp2 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
 	template <typename genType> 
-	genType exp2(genType const & x);
+	GLM_FUNC_DECL genType exp2(genType const & x);
 
 	/// Returns the base 2 log of x, i.e., returns the value y, 
 	/// which satisfies the equation x = 2 ^ y.
@@ -93,7 +93,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log2.xml">GLSL log2 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
 	template <typename genType> 
-	genType log2(genType const & x);
+	GLM_FUNC_DECL genType log2(genType const & x);
 
 	/// Returns the positive square root of x.
 	/// 
@@ -103,7 +103,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sqrt.xml">GLSL sqrt man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
 	template <typename genType> 
-	genType sqrt(genType const & x);
+	GLM_FUNC_DECL genType sqrt(genType const & x);
     
 	/// Returns the reciprocal of the positive square root of x.
 	/// 
@@ -113,7 +113,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inversesqrt.xml">GLSL inversesqrt man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
 	template <typename genType> 
-	genType inversesqrt(genType const & x);
+	GLM_FUNC_DECL genType inversesqrt(genType const & x);
 
 	/// @}
 }//namespace glm

glm/core/func_geometric.hpp

@@ -48,7 +48,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/length.xml">GLSL length man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
 	template <typename genType> 
-		typename genType::value_type length(
+	GLM_FUNC_DECL typename genType::value_type length(
 		genType const & x); 
 
 	/// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
@@ -58,7 +58,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/distance.xml">GLSL distance man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
 	template <typename genType> 
-	typename genType::value_type distance(
+	GLM_FUNC_DECL typename genType::value_type distance(
 		genType const & p0, 
 		genType const & p1);
 
@@ -69,7 +69,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/dot.xml">GLSL dot man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
 	template <typename genType>
-	typename genType::value_type dot(
+	GLM_FUNC_DECL typename genType::value_type dot(
 		genType const & x,
 		genType const & y);
 
@@ -80,7 +80,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cross.xml">GLSL cross man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
 	template <typename T, precision P>
-	detail::tvec3<T, P> cross(
+	GLM_FUNC_DECL detail::tvec3<T, P> cross(
 		detail::tvec3<T, P> const & x,
 		detail::tvec3<T, P> const & y);
 
@@ -89,7 +89,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/normalize.xml">GLSL normalize man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
 	template <typename genType>
-	genType normalize(
+	GLM_FUNC_DECL genType normalize(
 		genType const & x);
 
 	/// If dot(Nref, I) < 0.0, return N, otherwise, return -N.
@@ -99,7 +99,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/faceforward.xml">GLSL faceforward man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
 	template <typename genType>
-	genType faceforward(
+	GLM_FUNC_DECL genType faceforward(
 		genType const & N,
 		genType const & I,
 		genType const & Nref);
@@ -112,7 +112,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/reflect.xml">GLSL reflect man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
 	template <typename genType>
-	genType reflect(
+	GLM_FUNC_DECL genType reflect(
 		genType const & I,
 		genType const & N);
 
@@ -125,7 +125,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/refract.xml">GLSL refract man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
 	template <typename genType>
-	genType refract(
+	GLM_FUNC_DECL genType refract(
 		genType const & I,
 		genType const & N,
 		typename genType::value_type const & eta);

glm/core/func_integer.hpp

@@ -52,9 +52,9 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uaddCarry.xml">GLSL uaddCarry man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
 	template <typename genUType>
-	genUType uaddCarry(
-		genUType const & x, 
-		genUType const & y, 
+	GLM_FUNC_DECL genUType uaddCarry(
+		genUType const & x,
+		genUType const & y,
 		genUType & carry);
 
 	/// Subtracts the 32-bit unsigned integer y from x, returning
@@ -66,9 +66,9 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/usubBorrow.xml">GLSL usubBorrow man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
 	template <typename genUType>
-	genUType usubBorrow(
-		genUType const & x, 
-		genUType const & y, 
+	GLM_FUNC_DECL genUType usubBorrow(
+		genUType const & x,
+		genUType const & y,
 		genUType & borrow);
 		
 	/// Multiplies 32-bit integers x and y, producing a 64-bit
@@ -80,10 +80,10 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/umulExtended.xml">GLSL umulExtended man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
 	template <typename genUType>
-	void umulExtended(
-		genUType const & x, 
-		genUType const & y, 
-		genUType & msb, 
+	GLM_FUNC_DECL void umulExtended(
+		genUType const & x,
+		genUType const & y,
+		genUType & msb,
 		genUType & lsb);
 		
 	/// Multiplies 32-bit integers x and y, producing a 64-bit
@@ -95,10 +95,10 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/imulExtended.xml">GLSL imulExtended man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
 	template <typename genIType>
-	void imulExtended(
-		genIType const & x, 
-		genIType const & y, 
-		genIType & msb, 
+	GLM_FUNC_DECL void imulExtended(
+		genIType const & x,
+		genIType const & y,
+		genIType & msb,
 		genIType & lsb);
 
 	/// Extracts bits [offset, offset + bits - 1] from value,
@@ -117,9 +117,9 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
 	template <typename genIUType>
-	genIUType bitfieldExtract(
-		genIUType const & Value, 
-		int const & Offset, 
+	GLM_FUNC_DECL genIUType bitfieldExtract(
+		genIUType const & Value,
+		int const & Offset,
 		int const & Bits);
 
 	/// Returns the insertion the bits least-significant bits of insert into base.
@@ -137,10 +137,10 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
 	template <typename genIUType>
-	genIUType bitfieldInsert(
-		genIUType const & Base, 
-		genIUType const & Insert, 
-		int const & Offset, 
+	GLM_FUNC_DECL genIUType bitfieldInsert(
+		genIUType const & Base,
+		genIUType const & Insert,
+		int const & Offset,
 		int const & Bits);
 
 	/// Returns the reversal of the bits of value. 
@@ -152,7 +152,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
 	template <typename genIUType>
-	genIUType bitfieldReverse(genIUType const & Value);
+	GLM_FUNC_DECL genIUType bitfieldReverse(genIUType const & Value);
 		
 	/// Returns the number of bits set to 1 in the binary representation of value.
 	///
@@ -163,7 +163,7 @@ namespace glm
 	///
 	/// @todo Clarify the declaration to specify that scalars are suported.
 	template <typename T, template <typename> class genIUType>
-	typename genIUType<T>::signed_type bitCount(genIUType<T> const & Value);
+	GLM_FUNC_DECL typename genIUType<T>::signed_type bitCount(genIUType<T> const & Value);
 
 	/// Returns the bit number of the least significant bit set to
 	/// 1 in the binary representation of value. 
@@ -176,7 +176,7 @@ namespace glm
 	///
 	/// @todo Clarify the declaration to specify that scalars are suported.
 	template <typename T, template <typename> class genIUType>
-	typename genIUType<T>::signed_type findLSB(genIUType<T> const & Value);
+	GLM_FUNC_DECL typename genIUType<T>::signed_type findLSB(genIUType<T> const & Value);
 
 	/// Returns the bit number of the most significant bit in the binary representation of value.
 	/// For positive integers, the result will be the bit number of the most significant bit set to 1. 
@@ -190,7 +190,7 @@ namespace glm
 	///
 	/// @todo Clarify the declaration to specify that scalars are suported.
 	template <typename T, template <typename> class genIUType>
-	typename genIUType<T>::signed_type findMSB(genIUType<T> const & Value);
+	GLM_FUNC_DECL typename genIUType<T>::signed_type findMSB(genIUType<T> const & Value);
 
 	/// @}
 }//namespace glm

glm/core/func_matrix.hpp

@@ -52,8 +52,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/matrixCompMult.xml">GLSL matrixCompMult man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
-	template <typename matType> 
-	matType matrixCompMult(
+	template <typename matType>
+	GLM_FUNC_DECL matType matrixCompMult(
 		matType const & x, 
 		matType const & y);
 
@@ -68,8 +68,8 @@ namespace glm
 	/// 
 	/// @todo Clarify the declaration to specify that matType doesn't have to be provided when used.
 	template <typename vecType, typename matType>
-	matType outerProduct(
-		vecType const & c, 
+	GLM_FUNC_DECL matType outerProduct(
+		vecType const & c,
 		vecType const & r);
 
 	/// Returns the transposed matrix of x
@@ -79,7 +79,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/transpose.xml">GLSL transpose man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	
 	template <typename matType>
-	typename matType::transpose_type transpose(
+	GLM_FUNC_DECL typename matType::transpose_type transpose(
 		matType const & x);
 	
 	/// Return the determinant of a mat2 matrix.
@@ -89,7 +89,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	
 	template <typename T, precision P>
-	typename detail::tmat2x2<T, P>::value_type determinant(
+	GLM_FUNC_DECL typename detail::tmat2x2<T, P>::value_type determinant(
 		detail::tmat2x2<T, P> const & m);
 
 	/// Return the determinant of a mat3 matrix.
@@ -99,7 +99,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	
 	template <typename T, precision P>
-	typename detail::tmat3x3<T, P>::value_type determinant(
+	GLM_FUNC_DECL typename detail::tmat3x3<T, P>::value_type determinant(
 		detail::tmat3x3<T, P> const & m);
 
 	/// Return the determinant of a mat4 matrix.
@@ -109,7 +109,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>		
 	template <typename T, precision P>
-	typename detail::tmat4x4<T, P>::value_type determinant(
+	GLM_FUNC_DECL typename detail::tmat4x4<T, P>::value_type determinant(
 		detail::tmat4x4<T, P> const & m);
 
 	/// Return the inverse of a mat2 matrix.
@@ -119,7 +119,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>	 
 	template <typename T, precision P>
-	detail::tmat2x2<T, P> inverse(
+	GLM_FUNC_DECL detail::tmat2x2<T, P> inverse(
 		detail::tmat2x2<T, P> const & m);
 
 	/// Return the inverse of a mat3 matrix.
@@ -129,7 +129,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a> 
 	template <typename T, precision P>
-	detail::tmat3x3<T, P> inverse(
+	GLM_FUNC_DECL detail::tmat3x3<T, P> inverse(
 		detail::tmat3x3<T, P> const & m);
 
 	/// Return the inverse of a mat4 matrix.
@@ -139,7 +139,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
 	template <typename T, precision P>
-	detail::tmat4x4<T, P> inverse(
+	GLM_FUNC_DECL detail::tmat4x4<T, P> inverse(
 		detail::tmat4x4<T, P> const & m);
 
 	/// @}

glm/core/func_noise.hpp

@@ -50,7 +50,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise1.xml">GLSL noise1 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
 	template <typename genType>
-	typename genType::value_type noise1(genType const & x);
+	GLM_FUNC_DECL typename genType::value_type noise1(genType const & x);
 
 	/// Returns a 2D noise value based on the input value x.
 	///
@@ -59,7 +59,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise2.xml">GLSL noise2 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
 	template <typename genType>
-	detail::tvec2<typename genType::value_type, defaultp> noise2(genType const & x);
+	GLM_FUNC_DECL detail::tvec2<typename genType::value_type, defaultp> noise2(genType const & x);
 
 	/// Returns a 3D noise value based on the input value x.
 	///
@@ -68,7 +68,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise3.xml">GLSL noise3 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
 	template <typename genType>
-	detail::tvec3<typename genType::value_type, defaultp> noise3(genType const & x);
+	GLM_FUNC_DECL detail::tvec3<typename genType::value_type, defaultp> noise3(genType const & x);
 
 	/// Returns a 4D noise value based on the input value x.
 	///
@@ -77,7 +77,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise4.xml">GLSL noise4 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
 	template <typename genType>
-	detail::tvec4<typename genType::value_type, defaultp> noise4(genType const & x);
+	GLM_FUNC_DECL detail::tvec4<typename genType::value_type, defaultp> noise4(genType const & x);
 
 	/// @}
 }//namespace glm

glm/core/func_packing.hpp

@@ -52,7 +52,7 @@ namespace glm
 	//! 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm2x16.xml">GLSL packUnorm2x16 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	uint32 packUnorm2x16(vec2 const & v);
+	GLM_FUNC_DECL uint32 packUnorm2x16(vec2 const & v);
 
 	//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
 	//! Then, the results are packed into the returned 32-bit unsigned integer.
@@ -65,7 +65,7 @@ namespace glm
 	//! 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm2x16.xml">GLSL packSnorm2x16 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	uint32 packSnorm2x16(vec2 const & v);
+	GLM_FUNC_DECL uint32 packSnorm2x16(vec2 const & v);
 
 	//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
 	//! Then, the results are packed into the returned 32-bit unsigned integer.
@@ -78,7 +78,7 @@ namespace glm
 	//! 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	uint32 packUnorm4x8(vec4 const & v);
+	GLM_FUNC_DECL uint32 packUnorm4x8(vec4 const & v);
 
 	//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
 	//! Then, the results are packed into the returned 32-bit unsigned integer.
@@ -91,7 +91,7 @@ namespace glm
 	//! 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	uint32 packSnorm4x8(vec4 const & v);
+	GLM_FUNC_DECL uint32 packSnorm4x8(vec4 const & v);
 
 	//! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
 	//! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
@@ -104,7 +104,7 @@ namespace glm
 	//! 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	vec2 unpackUnorm2x16(uint32 const & p);
+	GLM_FUNC_DECL vec2 unpackUnorm2x16(uint32 const & p);
 
 	//! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
 	//! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
@@ -117,7 +117,7 @@ namespace glm
 	//! 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm2x16.xml">GLSL unpackSnorm2x16 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	vec2 unpackSnorm2x16(uint32 const & p);
+	GLM_FUNC_DECL vec2 unpackSnorm2x16(uint32 const & p);
 
 	/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
 	/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
@@ -130,7 +130,7 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	vec4 unpackUnorm4x8(uint32 const & p);
+	GLM_FUNC_DECL vec4 unpackUnorm4x8(uint32 const & p);
 
 	/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
 	/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
@@ -143,7 +143,7 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	vec4 unpackSnorm4x8(uint32 const & p);
+	GLM_FUNC_DECL vec4 unpackSnorm4x8(uint32 const & p);
 
 	/// Returns a double-precision value obtained by packing the components of v into a 64-bit value. 
 	/// If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified. 
@@ -153,7 +153,7 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packDouble2x32.xml">GLSL packDouble2x32 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	double packDouble2x32(uvec2 const & v);
+	GLM_FUNC_DECL double packDouble2x32(uvec2 const & v);
 
 	/// Returns a two-component unsigned integer vector representation of v. 
 	/// The bit-level representation of v is preserved. 
@@ -162,7 +162,7 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackDouble2x32.xml">GLSL unpackDouble2x32 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	uvec2 unpackDouble2x32(double const & v);
+	GLM_FUNC_DECL uvec2 unpackDouble2x32(double const & v);
 
 	/// Returns an unsigned integer obtained by converting the components of a two-component floating-point vector 
 	/// to the 16-bit floating-point representation found in the OpenGL Specification, 
@@ -172,7 +172,7 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packHalf2x16.xml">GLSL packHalf2x16 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	uint packHalf2x16(vec2 const & v);
+	GLM_FUNC_DECL uint32 packHalf2x16(vec2 const & v);
 	
 	/// Returns a two-component floating-point vector with components obtained by unpacking a 32-bit unsigned integer into a pair of 16-bit values, 
 	/// interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification, 
@@ -182,7 +182,7 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackHalf2x16.xml">GLSL unpackHalf2x16 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	vec2 unpackHalf2x16(uint32 const & v);
+	GLM_FUNC_DECL vec2 unpackHalf2x16(uint32 const & v);
 	
 	/// @}
 }//namespace glm

glm/core/func_trigonometric.hpp

@@ -52,7 +52,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/radians.xml">GLSL radians man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 	template <typename genType> 
-	genType radians(genType const & degrees);
+	GLM_FUNC_DECL genType radians(genType const & degrees);
 
 	/// Converts radians to degrees and returns the result.
 	///
@@ -61,7 +61,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/degrees.xml">GLSL degrees man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 	template <typename genType> 
-	genType degrees(genType const & radians);
+	GLM_FUNC_DECL genType degrees(genType const & radians);
 
 	/// The standard trigonometric sine function. 
 	/// The values returned by this function will range from [-1, 1].
@@ -71,7 +71,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sin.xml">GLSL sin man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 	template <typename genType> 
-	genType sin(genType const & angle);
+	GLM_FUNC_DECL genType sin(genType const & angle);
 
 	/// The standard trigonometric cosine function. 
 	/// The values returned by this function will range from [-1, 1].
@@ -81,7 +81,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cos.xml">GLSL cos man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 	template <typename genType> 
-	genType cos(genType const & angle);
+	GLM_FUNC_DECL genType cos(genType const & angle);
 
 	/// The standard trigonometric tangent function.
 	///
@@ -90,7 +90,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tan.xml">GLSL tan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 	template <typename genType> 
-	genType tan(genType const & angle); 
+	GLM_FUNC_DECL genType tan(genType const & angle); 
 
 	/// Arc sine. Returns an angle whose sine is x. 
 	/// The range of values returned by this function is [-PI/2, PI/2]. 
@@ -101,7 +101,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asin.xml">GLSL asin man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 	template <typename genType> 
-	genType asin(genType const & x);
+	GLM_FUNC_DECL genType asin(genType const & x);
 
 	/// Arc cosine. Returns an angle whose sine is x. 
 	/// The range of values returned by this function is [0, PI]. 
@@ -112,7 +112,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acos.xml">GLSL acos man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 	template <typename genType> 
-	genType acos(genType const & x);
+	GLM_FUNC_DECL genType acos(genType const & x);
 
 	/// Arc tangent. Returns an angle whose tangent is y/x. 
 	/// The signs of x and y are used to determine what 
@@ -125,7 +125,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 	template <typename genType> 
-	genType atan(genType const & y, genType const & x);
+	GLM_FUNC_DECL genType atan(genType const & y, genType const & x);
 
 	/// Arc tangent. Returns an angle whose tangent is y_over_x. 
 	/// The range of values returned by this function is [-PI/2, PI/2].
@@ -135,7 +135,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 	template <typename genType> 
-	genType atan(genType const & y_over_x);
+	GLM_FUNC_DECL genType atan(genType const & y_over_x);
 
 	/// Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2
 	///
@@ -144,7 +144,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sinh.xml">GLSL sinh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 	template <typename genType> 
-	genType sinh(genType const & angle);
+	GLM_FUNC_DECL genType sinh(genType const & angle);
 
 	/// Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2
 	///
@@ -153,7 +153,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cosh.xml">GLSL cosh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 	template <typename genType> 
-	genType cosh(genType const & angle);
+	GLM_FUNC_DECL genType cosh(genType const & angle);
 
 	/// Returns the hyperbolic tangent function, sinh(angle) / cosh(angle)
 	///
@@ -162,7 +162,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tanh.xml">GLSL tanh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 	template <typename genType> 
-	genType tanh(genType const & angle);
+	GLM_FUNC_DECL genType tanh(genType const & angle);
 
 	/// Arc hyperbolic sine; returns the inverse of sinh.
 	///
@@ -171,7 +171,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asinh.xml">GLSL asinh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 	template <typename genType> 
-	genType asinh(genType const & x);
+	GLM_FUNC_DECL genType asinh(genType const & x);
 	
 	/// Arc hyperbolic cosine; returns the non-negative inverse
 	/// of cosh. Results are undefined if x < 1.
@@ -181,7 +181,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acosh.xml">GLSL acosh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 	template <typename genType> 
-	genType acosh(genType const & x);
+	GLM_FUNC_DECL genType acosh(genType const & x);
 
 	/// Arc hyperbolic tangent; returns the inverse of tanh.
 	/// Results are undefined if abs(x) >= 1.
@@ -191,7 +191,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atanh.xml">GLSL atanh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 	template <typename genType> 
-	genType atanh(genType const & x);
+	GLM_FUNC_DECL genType atanh(genType const & x);
 
 	/// @}
 }//namespace glm

glm/core/func_vector_relational.hpp

@@ -53,7 +53,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThan.xml">GLSL lessThan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
 	template <typename T, precision P, template <typename, precision> class vecType>
-	typename vecType<T, P>::bool_type lessThan(vecType<T, P> const & x, vecType<T, P> const & y);
+	GLM_FUNC_DECL typename vecType<T, P>::bool_type lessThan(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x <= y.
 	///
@@ -62,7 +62,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThanEqual.xml">GLSL lessThanEqual man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
 	template <typename T, precision P, template <typename, precision> class vecType>
-	typename vecType<T, P>::bool_type lessThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
+	GLM_FUNC_DECL typename vecType<T, P>::bool_type lessThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x > y.
 	///
@@ -71,7 +71,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThan.xml">GLSL greaterThan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
 	template <typename T, precision P, template <typename, precision> class vecType>
-	typename vecType<T, P>::bool_type greaterThan(vecType<T, P> const & x, vecType<T, P> const & y);
+	GLM_FUNC_DECL typename vecType<T, P>::bool_type greaterThan(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x >= y.
 	///
@@ -80,7 +80,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThanEqual.xml">GLSL greaterThanEqual man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
 	template <typename T, precision P, template <typename, precision> class vecType>
-	typename vecType<T, P>::bool_type greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
+	GLM_FUNC_DECL typename vecType<T, P>::bool_type greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x == y.
 	///
@@ -89,7 +89,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/equal.xml">GLSL equal man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
 	template <typename T, precision P, template <typename, precision> class vecType>
-	typename vecType<T, P>::bool_type equal(vecType<T, P> const & x, vecType<T, P> const & y);
+	GLM_FUNC_DECL typename vecType<T, P>::bool_type equal(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x != y.
 	/// 
@@ -98,7 +98,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/notEqual.xml">GLSL notEqual man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
 	template <typename T, precision P, template <typename, precision> class vecType>
-	typename vecType<T, P>::bool_type notEqual(vecType<T, P> const & x, vecType<T, P> const & y);
+	GLM_FUNC_DECL typename vecType<T, P>::bool_type notEqual(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns true if any component of x is true.
 	///
@@ -107,7 +107,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/any.xml">GLSL any man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
 	template <precision P, template <typename, precision> class vecType>
-	bool any(vecType<bool, P> const & v);
+	GLM_FUNC_DECL bool any(vecType<bool, P> const & v);
 
 	/// Returns true if all components of x are true.
 	///
@@ -116,7 +116,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/all.xml">GLSL all man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
 	template <precision P, template <typename, precision> class vecType>
-	bool all(vecType<bool, P> const & v);
+	GLM_FUNC_DECL bool all(vecType<bool, P> const & v);
 
 	/// Returns the component-wise logical complement of x.
 	/// /!\ Because of language incompatibilities between C++ and GLSL, GLM defines the function not but not_ instead.
@@ -126,7 +126,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/not.xml">GLSL not man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
 	template <precision P, template <typename, precision> class vecType>
-	vecType<bool, P> not_(vecType<bool, P> const & v);
+	GLM_FUNC_DECL vecType<bool, P> not_(vecType<bool, P> const & v);
 
 	/// @}
 }//namespace glm

glm/core/type_mat2x2.hpp

@@ -146,101 +146,101 @@ namespace detail
 	};
 
 	// Binary operators
+
 	template <typename T, precision P>
-	tmat2x2<T, P> operator+ (
+	GLM_FUNC_DECL tmat2x2<T, P> operator+ (
 		tmat2x2<T, P> const & m,
 		typename tmat2x2<T, P>::value_type const & s);
 
-	template <typename T, precision P> 
-	tmat2x2<T, P> operator+ (
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x2<T, P> operator+ (
 		typename tmat2x2<T, P>::value_type const & s,
 		tmat2x2<T, P> const & m);
 
 	template <typename T, precision P>
-	tmat2x2<T, P> operator+ (
+	GLM_FUNC_DECL tmat2x2<T, P> operator+ (
 		tmat2x2<T, P> const & m1,
 		tmat2x2<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat2x2<T, P> operator- (
+	GLM_FUNC_DECL tmat2x2<T, P> operator- (
 		tmat2x2<T, P> const & m,
 		typename tmat2x2<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat2x2<T, P> operator- (
+	GLM_FUNC_DECL tmat2x2<T, P> operator- (
 		typename tmat2x2<T, P>::value_type const & s,
 		tmat2x2<T, P> const & m);
 
-	template <typename T, precision P> 
-	tmat2x2<T, P> operator- (
-		tmat2x2<T, P> const & m1, 
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x2<T, P> operator- (
+		tmat2x2<T, P> const & m1,
 		tmat2x2<T, P> const & m2);
 
-	template <typename T, precision P> 
-	tmat2x2<T, P> operator* (
-		tmat2x2<T, P> const & m, 
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x2<T, P> operator* (
+		tmat2x2<T, P> const & m,
 		typename tmat2x2<T, P>::value_type const & s);
 
-	template <typename T, precision P> 
-	tmat2x2<T, P> operator* (
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x2<T, P> operator* (
 		typename tmat2x2<T, P>::value_type const & s, 
 		tmat2x2<T, P> const & m);
 
 	template <typename T, precision P>
-	typename tmat2x2<T, P>::col_type operator* (
+	GLM_FUNC_DECL typename tmat2x2<T, P>::col_type operator* (
 		tmat2x2<T, P> const & m,
 		typename tmat2x2<T, P>::row_type const & v);
 
 	template <typename T, precision P>
-	typename tmat2x2<T, P>::row_type operator* (
+	GLM_FUNC_DECL typename tmat2x2<T, P>::row_type operator* (
 		typename tmat2x2<T, P>::col_type const & v,
 		tmat2x2<T, P> const & m);
 
 	template <typename T, precision P>
-	tmat2x2<T, P> operator* (
+	GLM_FUNC_DECL tmat2x2<T, P> operator* (
 		tmat2x2<T, P> const & m1,
 		tmat2x2<T, P> const & m2);
 		
 	template <typename T, precision P>
-	tmat3x2<T, P> operator* (
+	GLM_FUNC_DECL tmat3x2<T, P> operator* (
 		tmat2x2<T, P> const & m1,
 		tmat3x2<T, P> const & m2);
 		
 	template <typename T, precision P>
-	tmat4x2<T, P> operator* (
+	GLM_FUNC_DECL tmat4x2<T, P> operator* (
 		tmat2x2<T, P> const & m1,
 		tmat4x2<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat2x2<T, P> operator/ (
+	GLM_FUNC_DECL tmat2x2<T, P> operator/ (
 		tmat2x2<T, P> const & m,
 		typename tmat2x2<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat2x2<T, P> operator/ (
+	GLM_FUNC_DECL tmat2x2<T, P> operator/ (
 		typename tmat2x2<T, P>::value_type const & s,
 		tmat2x2<T, P> const & m);
 
 	template <typename T, precision P>
-	typename tmat2x2<T, P>::col_type operator/ (
+	GLM_FUNC_DECL typename tmat2x2<T, P>::col_type operator/ (
 		tmat2x2<T, P> const & m,
 		typename tmat2x2<T, P>::row_type const & v);
 
 	template <typename T, precision P>
-	typename tmat2x2<T, P>::row_type operator/ (
+	GLM_FUNC_DECL typename tmat2x2<T, P>::row_type operator/ (
 		typename tmat2x2<T, P>::col_type const & v,
 		tmat2x2<T, P> const & m);
 
 	template <typename T, precision P>
-	tmat2x2<T, P> operator/ (
+	GLM_FUNC_DECL tmat2x2<T, P> operator/ (
 		tmat2x2<T, P> const & m1,
 		tmat2x2<T, P> const & m2);
 
 	// Unary constant operators
 	template <typename T, precision P> 
-	tmat2x2<T, P> const operator-(
+	GLM_FUNC_DECL tmat2x2<T, P> const operator-(
 		tmat2x2<T, P> const & m);
-
 } //namespace detail
 } //namespace glm
 

glm/core/type_mat2x3.hpp

@@ -102,8 +102,8 @@ namespace detail
 		GLM_FUNC_DECL explicit tmat2x3(tmat4x3<T, P> const & x);
 
 		// Accesses
-		col_type & operator[](size_type i);
-		col_type const & operator[](size_type i) const;
+		GLM_FUNC_DECL col_type & operator[](size_type i);
+		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
 
 		// Unary updatable operators
 		GLM_FUNC_DECL tmat2x3<T, P> & operator=  (tmat2x3<T, P> const & m);
@@ -134,8 +134,9 @@ namespace detail
 	};
 
 	// Binary operators
+
 	template <typename T, precision P>
-	tmat2x3<T, P> operator+ (
+	GLM_FUNC_DECL tmat2x3<T, P> operator+ (
 		tmat2x3<T, P> const & m,
 		typename tmat2x3<T, P>::value_type const & s);
 
@@ -145,63 +146,63 @@ namespace detail
 		tmat2x3<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat2x3<T, P> operator- (
+	GLM_FUNC_DECL tmat2x3<T, P> operator- (
 		tmat2x3<T, P> const & m,
 		typename tmat2x3<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat2x3<T, P> operator- (
+	GLM_FUNC_DECL tmat2x3<T, P> operator- (
 		tmat2x3<T, P> const & m1,
 		tmat2x3<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat2x3<T, P> operator* (
+	GLM_FUNC_DECL tmat2x3<T, P> operator* (
 		tmat2x3<T, P> const & m,
 		typename tmat2x3<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat2x3<T, P> operator* (
+	GLM_FUNC_DECL tmat2x3<T, P> operator* (
 		typename tmat2x3<T, P>::value_type const & s,
 		tmat2x3<T, P> const & m);
 
 	template <typename T, precision P>
-	typename tmat2x3<T, P>::col_type operator* (
+	GLM_FUNC_DECL typename tmat2x3<T, P>::col_type operator* (
 		tmat2x3<T, P> const & m, 
 		typename tmat2x3<T, P>::row_type const & v);
 
 	template <typename T, precision P>
-	typename tmat2x3<T, P>::row_type operator* (
+	GLM_FUNC_DECL typename tmat2x3<T, P>::row_type operator* (
 		typename tmat2x3<T, P>::col_type const & v,
 		tmat2x3<T, P> const & m);
 
 	template <typename T, precision P>
-	tmat2x3<T, P> operator* (
+	GLM_FUNC_DECL tmat2x3<T, P> operator* (
 		tmat2x3<T, P> const & m1,
 		tmat2x2<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat3x3<T, P> operator* (
+	GLM_FUNC_DECL tmat3x3<T, P> operator* (
 		tmat2x3<T, P> const & m1,
 		tmat3x2<T, P> const & m2);
 		
 	template <typename T, precision P>
-	tmat4x3<T, P> operator* (
+	GLM_FUNC_DECL tmat4x3<T, P> operator* (
 		tmat2x3<T, P> const & m1,
 		tmat4x2<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat2x3<T, P> operator/ (
+	GLM_FUNC_DECL tmat2x3<T, P> operator/ (
 		tmat2x3<T, P> const & m,
 		typename tmat2x3<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat2x3<T, P> operator/ (
+	GLM_FUNC_DECL tmat2x3<T, P> operator/ (
 		typename tmat2x3<T, P>::value_type const & s,
 		tmat2x3<T, P> const & m);
 
 	// Unary constant operators
 	template <typename T, precision P>
-	tmat2x3<T, P> const operator- (
+	GLM_FUNC_DECL tmat2x3<T, P> const operator- (
 		tmat2x3<T, P> const & m);
 
 }//namespace detail

glm/core/type_mat2x4.hpp

@@ -136,74 +136,75 @@ namespace detail
 	};
 
 	// Binary operators
-	template <typename T, precision P> 
-	tmat2x4<T, P> operator+ (
-		tmat2x4<T, P> const & m, 
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x4<T, P> operator+ (
+		tmat2x4<T, P> const & m,
 		typename tmat2x4<T, P>::value_type const & s);
 
-	template <typename T, precision P> 
-	tmat2x4<T, P> operator+ (
-		tmat2x4<T, P> const & m1, 
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x4<T, P> operator+ (
+		tmat2x4<T, P> const & m1,
 		tmat2x4<T, P> const & m2);
 
-	template <typename T, precision P> 
-	tmat2x4<T, P> operator- (
-		tmat2x4<T, P> const & m, 
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x4<T, P> operator- (
+		tmat2x4<T, P> const & m,
 		typename tmat2x4<T, P>::value_type const & s);
 
-	template <typename T, precision P> 
-	tmat2x4<T, P> operator- (
-		tmat2x4<T, P> const & m1, 
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x4<T, P> operator- (
+		tmat2x4<T, P> const & m1,
 		tmat2x4<T, P> const & m2);
 
-	template <typename T, precision P> 
-	tmat2x4<T, P> operator* (
-		tmat2x4<T, P> const & m, 
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x4<T, P> operator* (
+		tmat2x4<T, P> const & m,
 		typename tmat2x4<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat2x4<T, P> operator* (
+	GLM_FUNC_DECL tmat2x4<T, P> operator* (
 		typename tmat2x4<T, P>::value_type const & s,
 		tmat2x4<T, P> const & m);
 
 	template <typename T, precision P>
-	typename tmat2x4<T, P>::col_type operator* (
+	GLM_FUNC_DECL typename tmat2x4<T, P>::col_type operator* (
 		tmat2x4<T, P> const & m,
 		typename tmat2x4<T, P>::row_type const & v);
 
 	template <typename T, precision P>
-	typename tmat2x4<T, P>::row_type operator* (
+	GLM_FUNC_DECL typename tmat2x4<T, P>::row_type operator* (
 		typename tmat2x4<T, P>::col_type const & v,
 		tmat2x4<T, P> const & m);
 
 	template <typename T, precision P>
-	tmat4x4<T, P> operator* (
+	GLM_FUNC_DECL tmat4x4<T, P> operator* (
 		tmat2x4<T, P> const & m1, 
 		tmat4x2<T, P> const & m2);
 		
 	template <typename T, precision P>
-	tmat2x4<T, P> operator* (
+	GLM_FUNC_DECL tmat2x4<T, P> operator* (
 		tmat2x4<T, P> const & m1,
 		tmat2x2<T, P> const & m2);
 		
 	template <typename T, precision P>
-	tmat3x4<T, P> operator* (
+	GLM_FUNC_DECL tmat3x4<T, P> operator* (
 		tmat2x4<T, P> const & m1,
 		tmat3x2<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat2x4<T, P> operator/ (
+	GLM_FUNC_DECL tmat2x4<T, P> operator/ (
 		tmat2x4<T, P> const & m,
 		typename tmat2x4<T, P>::value_type const & s);
 
 	template <typename T, precision P> 
-	tmat2x4<T, P> operator/ (
+	GLM_FUNC_DECL tmat2x4<T, P> operator/ (
 		typename tmat2x4<T, P>::value_type const & s,
 		tmat2x4<T, P> const & m);
 
 	// Unary constant operators
 	template <typename T, precision P>
-	tmat2x4<T, P> const operator-  (
+	GLM_FUNC_DECL tmat2x4<T, P> const operator- (
 		tmat2x4<T, P> const & m);
 
 }//namespace detail

glm/core/type_mat3x2.hpp

@@ -79,12 +79,10 @@ namespace detail
 		GLM_FUNC_DECL explicit tmat3x2(
 			U const & x);
 			
-		template
-		<
+		template<
 			typename X1, typename Y1,
 			typename X2, typename Y2,
-			typename X3, typename Y3
-		>
+			typename X3, typename Y3>
 		GLM_FUNC_DECL explicit tmat3x2(
 			X1 const & x1, Y1 const & y1,
 			X2 const & x2, Y2 const & y2,
@@ -143,73 +141,73 @@ namespace detail
 
 	// Binary operators
 	template <typename T, precision P>
-	tmat3x2<T, P> operator+ (
+	GLM_FUNC_DECL tmat3x2<T, P> operator+ (
 		tmat3x2<T, P> const & m,
 		typename tmat3x2<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat3x2<T, P> operator+ (
+	GLM_FUNC_DECL tmat3x2<T, P> operator+ (
 		tmat3x2<T, P> const & m1,
 		tmat3x2<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat3x2<T, P> operator- (
+	GLM_FUNC_DECL tmat3x2<T, P> operator- (
 		tmat3x2<T, P> const & m,
 		typename tmat3x2<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat3x2<T, P> operator- (
+	GLM_FUNC_DECL tmat3x2<T, P> operator- (
 		tmat3x2<T, P> const & m1,
 		tmat3x2<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat3x2<T, P> operator* (
+	GLM_FUNC_DECL tmat3x2<T, P> operator* (
 		tmat3x2<T, P> const & m,
 		typename tmat3x2<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat3x2<T, P> operator* (
+	GLM_FUNC_DECL tmat3x2<T, P> operator* (
 		typename tmat3x2<T, P>::value_type const & s,
 		tmat3x2<T, P> const & m);
 
 	template <typename T, precision P>
-	typename tmat3x2<T, P>::col_type operator* (
+	GLM_FUNC_DECL typename tmat3x2<T, P>::col_type operator* (
 		tmat3x2<T, P> const & m,
 		typename tmat3x2<T, P>::row_type const & v);
 
 	template <typename T, precision P>
-	typename tmat3x2<T, P>::row_type operator* (
+	GLM_FUNC_DECL typename tmat3x2<T, P>::row_type operator* (
 		typename tmat3x2<T, P>::col_type const & v,
 		tmat3x2<T, P> const & m);
 
 	template <typename T, precision P>
-	tmat2x2<T, P> operator* (
+	GLM_FUNC_DECL tmat2x2<T, P> operator* (
 		tmat3x2<T, P> const & m1,
 		tmat2x3<T, P> const & m2);
 		
 	template <typename T, precision P>
-	tmat3x2<T, P> operator* (
+	GLM_FUNC_DECL tmat3x2<T, P> operator* (
 		tmat3x2<T, P> const & m1,
 		tmat3x3<T, P> const & m2);
 		
 	template <typename T, precision P>
-	tmat4x2<T, P> operator* (
+	GLM_FUNC_DECL tmat4x2<T, P> operator* (
 		tmat3x2<T, P> const & m1,
 		tmat4x3<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat3x2<T, P> operator/ (
+	GLM_FUNC_DECL tmat3x2<T, P> operator/ (
 		tmat3x2<T, P> const & m,
 		typename tmat3x2<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat3x2<T, P> operator/ (
+	GLM_FUNC_DECL tmat3x2<T, P> operator/ (
 		typename tmat3x2<T, P>::value_type const & s,
 		tmat3x2<T, P> const & m);
 
 	// Unary constant operators
 	template <typename T, precision P>
-	tmat3x2<T, P> const operator-(
+	GLM_FUNC_DECL tmat3x2<T, P> const operator-(
 		tmat3x2<T, P> const & m);
 
 }//namespace detail

glm/core/type_mat3x3.hpp

@@ -85,12 +85,10 @@ namespace detail
 		GLM_FUNC_DECL explicit tmat3x3(
 			U const & x);
 			
-		template
-		<
+		template<
 			typename X1, typename Y1, typename Z1,
 			typename X2, typename Y2, typename Z2,
-			typename X3, typename Y3, typename Z3
-		>
+			typename X3, typename Y3, typename Z3>
 		GLM_FUNC_DECL explicit tmat3x3(
 			X1 const & x1, Y1 const & y1, Z1 const & z1,
 			X2 const & x2, Y2 const & y2, Z2 const & z2,
@@ -151,98 +149,98 @@ namespace detail
 
 	// Binary operators
 	template <typename T, precision P>
-	tmat3x3<T, P> operator+ (
+	GLM_FUNC_DECL tmat3x3<T, P> operator+ (
 		tmat3x3<T, P> const & m,
 		typename tmat3x3<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat3x3<T, P> operator+ (
+	GLM_FUNC_DECL tmat3x3<T, P> operator+ (
 		typename tmat3x3<T, P>::value_type const & s,
 		tmat3x3<T, P> const & m);
 
 	template <typename T, precision P>
-	tmat3x3<T, P> operator+ (
+	GLM_FUNC_DECL tmat3x3<T, P> operator+ (
 		tmat3x3<T, P> const & m1,
 		tmat3x3<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat3x3<T, P> operator- (
+	GLM_FUNC_DECL tmat3x3<T, P> operator- (
 		tmat3x3<T, P> const & m,
 		typename tmat3x3<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat3x3<T, P> operator- (
+	GLM_FUNC_DECL tmat3x3<T, P> operator- (
 		typename tmat3x3<T, P>::value_type const & s,
 		tmat3x3<T, P> const & m);
 
 	template <typename T, precision P>
-	tmat3x3<T, P> operator- (
+	GLM_FUNC_DECL tmat3x3<T, P> operator- (
 		tmat3x3<T, P> const & m1,
 		tmat3x3<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat3x3<T, P> operator* (
+	GLM_FUNC_DECL tmat3x3<T, P> operator* (
 		tmat3x3<T, P> const & m,
 		typename tmat3x3<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat3x3<T, P> operator* (
+	GLM_FUNC_DECL tmat3x3<T, P> operator* (
 		typename tmat3x3<T, P>::value_type const & s,
 		tmat3x3<T, P> const & m);
 
 	template <typename T, precision P>
-	typename tmat3x3<T, P>::col_type operator* (
+	GLM_FUNC_DECL typename tmat3x3<T, P>::col_type operator* (
 		tmat3x3<T, P> const & m,
 		typename tmat3x3<T, P>::row_type const & v);
 
 	template <typename T, precision P>
-	typename tmat3x3<T, P>::row_type operator* (
+	GLM_FUNC_DECL typename tmat3x3<T, P>::row_type operator* (
 		typename tmat3x3<T, P>::col_type const & v,
 		tmat3x3<T, P> const & m);
 
 	template <typename T, precision P>
-	tmat3x3<T, P> operator* (
+	GLM_FUNC_DECL tmat3x3<T, P> operator* (
 		tmat3x3<T, P> const & m1,
 		tmat3x3<T, P> const & m2);
 		
 	template <typename T, precision P>
-	tmat2x3<T, P> operator* (
+	GLM_FUNC_DECL tmat2x3<T, P> operator* (
 		tmat3x3<T, P> const & m1,
 		tmat2x3<T, P> const & m2);
 		
 	template <typename T, precision P>
-	tmat4x3<T, P> operator* (
+	GLM_FUNC_DECL tmat4x3<T, P> operator* (
 		tmat3x3<T, P> const & m1,
 		tmat4x3<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat3x3<T, P> operator/ (
+	GLM_FUNC_DECL tmat3x3<T, P> operator/ (
 		tmat3x3<T, P> const & m,
 		typename tmat3x3<T, P>::value_type const & s);
 
-	template <typename T, precision P> 
-	tmat3x3<T, P> operator/ (
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat3x3<T, P> operator/ (
 		typename tmat3x3<T, P>::value_type const & s,
 		tmat3x3<T, P> const & m);
 
-	template <typename T, precision P> 
-	typename tmat3x3<T, P>::col_type operator/ (
-		tmat3x3<T, P> const & m, 
+	template <typename T, precision P>
+	GLM_FUNC_DECL typename tmat3x3<T, P>::col_type operator/ (
+		tmat3x3<T, P> const & m,
 		typename tmat3x3<T, P>::row_type const & v);
 
 	template <typename T, precision P>
-	typename tmat3x3<T, P>::row_type operator/ (
+	GLM_FUNC_DECL typename tmat3x3<T, P>::row_type operator/ (
 		typename tmat3x3<T, P>::col_type const & v,
 		tmat3x3<T, P> const & m);
 
 	template <typename T, precision P>
-	tmat3x3<T, P> operator/ (
+	GLM_FUNC_DECL tmat3x3<T, P> operator/ (
 		tmat3x3<T, P> const & m1,
 		tmat3x3<T, P> const & m2);
 
 	// Unary constant operators
 	template <typename T, precision P>
-	tmat3x3<T, P> const operator-(
+	GLM_FUNC_DECL tmat3x3<T, P> const operator-(
 		tmat3x3<T, P> const & m);
 
 }//namespace detail

glm/core/type_mat3x4.hpp

@@ -79,12 +79,10 @@ namespace detail
 		GLM_FUNC_DECL explicit tmat3x4(
 			U const & x);
 			
-		template
-		<
+		template<
 			typename X1, typename Y1, typename Z1, typename W1,
 			typename X2, typename Y2, typename Z2, typename W2,
-			typename X3, typename Y3, typename Z3, typename W3
-		>
+			typename X3, typename Y3, typename Z3, typename W3>
 		GLM_FUNC_DECL explicit tmat3x4(
 			X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1,
 			X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2,
@@ -110,8 +108,8 @@ namespace detail
 		GLM_FUNC_DECL explicit tmat3x4(tmat4x3<T, P> const & x);
 
 		// Accesses
-		col_type & operator[](size_type i);
-		col_type const & operator[](size_type i) const;
+		GLM_FUNC_DECL col_type & operator[](size_type i);
+		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
 
 		// Unary updatable operators
 		GLM_FUNC_DECL tmat3x4<T, P> & operator=  (tmat3x4<T, P> const & m);
@@ -143,73 +141,73 @@ namespace detail
 
 	// Binary operators
 	template <typename T, precision P>
-	tmat3x4<T, P> operator+ (
+	GLM_FUNC_DECL tmat3x4<T, P> operator+ (
 		tmat3x4<T, P> const & m,
 		typename tmat3x4<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat3x4<T, P> operator+ (
+	GLM_FUNC_DECL tmat3x4<T, P> operator+ (
 		tmat3x4<T, P> const & m1,
 		tmat3x4<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat3x4<T, P> operator- (
+	GLM_FUNC_DECL tmat3x4<T, P> operator- (
 		tmat3x4<T, P> const & m,
 		typename tmat3x4<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat3x4<T, P> operator- (
+	GLM_FUNC_DECL tmat3x4<T, P> operator- (
 		tmat3x4<T, P> const & m1,
 		tmat3x4<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat3x4<T, P> operator* (
+	GLM_FUNC_DECL tmat3x4<T, P> operator* (
 		tmat3x4<T, P> const & m, 
 		typename tmat3x4<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat3x4<T, P> operator* (
+	GLM_FUNC_DECL tmat3x4<T, P> operator* (
 		typename tmat3x4<T, P>::value_type const & s,
 		tmat3x4<T, P> const & m);
 
 	template <typename T, precision P>
-	typename tmat3x4<T, P>::col_type operator* (
+	GLM_FUNC_DECL typename tmat3x4<T, P>::col_type operator* (
 		tmat3x4<T, P> const & m,
 		typename tmat3x4<T, P>::row_type const & v);
 
 	template <typename T, precision P> 
-	typename tmat3x4<T, P>::row_type operator* (
+	GLM_FUNC_DECL typename tmat3x4<T, P>::row_type operator* (
 		typename tmat3x4<T, P>::col_type const & v,
 		tmat3x4<T, P> const & m);
 
 	template <typename T, precision P>
-	tmat4x4<T, P> operator* (
+	GLM_FUNC_DECL tmat4x4<T, P> operator* (
 		tmat3x4<T, P> const & m1,
 		tmat4x3<T, P> const & m2);
 		
 	template <typename T, precision P>
-	tmat2x4<T, P> operator* (
+	GLM_FUNC_DECL tmat2x4<T, P> operator* (
 		tmat3x4<T, P> const & m1,
 		tmat2x3<T, P> const & m2);
 		
 	template <typename T, precision P>
-	tmat3x4<T, P> operator* (
+	GLM_FUNC_DECL tmat3x4<T, P> operator* (
 		tmat3x4<T, P> const & m1,
 		tmat3x3<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat3x4<T, P> operator/ (
+	GLM_FUNC_DECL tmat3x4<T, P> operator/ (
 		tmat3x4<T, P> const & m,
 		typename tmat3x4<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat3x4<T, P> operator/ (
+	GLM_FUNC_DECL tmat3x4<T, P> operator/ (
 		typename tmat3x4<T, P>::value_type const & s,
 		tmat3x4<T, P> const & m);
 
 	// Unary constant operators
 	template <typename T, precision P>
-	tmat3x4<T, P> const operator-(
+	GLM_FUNC_DECL tmat3x4<T, P> const operator-(
 		tmat3x4<T, P> const & m);
 
 }//namespace detail

glm/core/type_mat4x2.hpp

@@ -81,13 +81,11 @@ namespace detail
 		GLM_FUNC_DECL explicit tmat4x2(
 			U const & x);
 			
-		template
-		<
-			typename X1, typename Y1, 
-			typename X2, typename Y2, 
+		template<
+			typename X1, typename Y1,
+			typename X2, typename Y2,
 			typename X3, typename Y3,
-			typename X4, typename Y4
-		>
+			typename X4, typename Y4>
 		GLM_FUNC_DECL explicit tmat4x2(
 			X1 const & x1, Y1 const & y1,
 			X2 const & x2, Y2 const & y2,
@@ -148,75 +146,75 @@ namespace detail
 
 	// Binary operators
 	template <typename T, precision P>
-	tmat4x2<T, P> operator+ (
+	GLM_FUNC_DECL tmat4x2<T, P> operator+ (
 		tmat4x2<T, P> const & m,
 		typename tmat4x2<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat4x2<T, P> operator+ (
+	GLM_FUNC_DECL tmat4x2<T, P> operator+ (
 		tmat4x2<T, P> const & m1,
 		tmat4x2<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat4x2<T, P> operator- (
+	GLM_FUNC_DECL tmat4x2<T, P> operator- (
 		tmat4x2<T, P> const & m,
 		typename tmat4x2<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat4x2<T, P> operator- (
+	GLM_FUNC_DECL tmat4x2<T, P> operator- (
 		tmat4x2<T, P> const & m1,
 		tmat4x2<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat4x2<T, P> operator* (
+	GLM_FUNC_DECL tmat4x2<T, P> operator* (
 		tmat4x2<T, P> const & m,
 		typename tmat4x2<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat4x2<T, P> operator* (
+	GLM_FUNC_DECL tmat4x2<T, P> operator* (
 		typename tmat4x2<T, P>::value_type const & s,
 		tmat4x2<T, P> const & m);
 
 	template <typename T, precision P>
-	typename tmat4x2<T, P>::col_type operator* (
+	GLM_FUNC_DECL typename tmat4x2<T, P>::col_type operator* (
 		tmat4x2<T, P> const & m,
 		typename tmat4x2<T, P>::row_type const & v);
 
 	template <typename T, precision P>
-	typename tmat4x2<T, P>::row_type operator* (
+	GLM_FUNC_DECL typename tmat4x2<T, P>::row_type operator* (
 		typename tmat4x2<T, P>::col_type const & v,
 		tmat4x2<T, P> const & m);
 
 	template <typename T, precision P>
-	tmat3x2<T, P> operator* (
+	GLM_FUNC_DECL tmat3x2<T, P> operator* (
 		tmat4x2<T, P> const & m1,
 		tmat3x4<T, P> const & m2);
 		
 	template <typename T, precision P>
-	tmat4x2<T, P> operator* (
+	GLM_FUNC_DECL tmat4x2<T, P> operator* (
 		tmat4x2<T, P> const & m1,
 		tmat4x4<T, P> const & m2);
 		
 	template <typename T, precision P>
-	tmat2x3<T, P> operator* (
+	GLM_FUNC_DECL tmat2x3<T, P> operator* (
 		tmat4x3<T, P> const & m1,
 		tmat2x4<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat4x2<T, P> operator/ (
+	GLM_FUNC_DECL tmat4x2<T, P> operator/ (
 		tmat4x2<T, P> const & m,
 		typename tmat4x2<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat4x2<T, P> operator/ (
+	GLM_FUNC_DECL tmat4x2<T, P> operator/ (
 		typename tmat4x2<T, P>::value_type const & s,
 		tmat4x2<T, P> const & m);
 
 	// Unary constant operators
 	template <typename T, precision P>
-	tmat4x2<T, P> const operator-(
+	GLM_FUNC_DECL tmat4x2<T, P> const operator-(
 		tmat4x2<T, P> const & m);
-
+		
 }//namespace detail
 }//namespace glm
 

glm/core/type_mat4x3.hpp

@@ -113,8 +113,8 @@ namespace detail
 		GLM_FUNC_DECL explicit tmat4x3(tmat3x4<T, P> const & x);
 
 		// Accesses
-		col_type & operator[](size_type i);
-		col_type const & operator[](size_type i) const;
+		GLM_FUNC_DECL col_type & operator[](size_type i);
+		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
 
 		// Unary updatable operators
 		GLM_FUNC_DECL tmat4x3<T, P> & operator=  (tmat4x3<T, P> const & m);
@@ -146,73 +146,73 @@ namespace detail
 
 	// Binary operators
 	template <typename T, precision P>
-	tmat4x3<T, P> operator+ (
+	GLM_FUNC_DECL tmat4x3<T, P> operator+ (
 		tmat4x3<T, P> const & m,
 		typename tmat4x3<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat4x3<T, P> operator+ (
+	GLM_FUNC_DECL tmat4x3<T, P> operator+ (
 		tmat4x3<T, P> const & m1,
 		tmat4x3<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat4x3<T, P> operator- (
+	GLM_FUNC_DECL tmat4x3<T, P> operator- (
 		tmat4x3<T, P> const & m,
 		typename tmat4x3<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat4x3<T, P> operator- (
+	GLM_FUNC_DECL tmat4x3<T, P> operator- (
 		tmat4x3<T, P> const & m1,
 		tmat4x3<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat4x3<T, P> operator* (
+	GLM_FUNC_DECL tmat4x3<T, P> operator* (
 		tmat4x3<T, P> const & m,
 		typename tmat4x3<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat4x3<T, P> operator* (
+	GLM_FUNC_DECL tmat4x3<T, P> operator* (
 		typename tmat4x3<T, P>::value_type const & s,
 		tmat4x3<T, P> const & m);
 
 	template <typename T, precision P>
-	typename tmat4x3<T, P>::col_type operator* (
+	GLM_FUNC_DECL typename tmat4x3<T, P>::col_type operator* (
 		tmat4x3<T, P> const & m,
 		typename tmat4x3<T, P>::row_type const & v);
 
 	template <typename T, precision P>
-	typename tmat4x3<T, P>::row_type operator* (
+	GLM_FUNC_DECL typename tmat4x3<T, P>::row_type operator* (
 		typename tmat4x3<T, P>::col_type const & v,
 		tmat4x3<T, P> const & m);
 
 	template <typename T, precision P>
-	tmat2x3<T, P> operator* (
+	GLM_FUNC_DECL tmat2x3<T, P> operator* (
 		tmat4x3<T, P> const & m1,
 		tmat2x4<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat3x3<T, P> operator* (
+	GLM_FUNC_DECL tmat3x3<T, P> operator* (
 		tmat4x3<T, P> const & m1,
 		tmat3x4<T, P> const & m2);
 		
 	template <typename T, precision P>
-	tmat4x3<T, P> operator* (
+	GLM_FUNC_DECL tmat4x3<T, P> operator* (
 		tmat4x3<T, P> const & m1,
 		tmat4x4<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat4x3<T, P> operator/ (
+	GLM_FUNC_DECL tmat4x3<T, P> operator/ (
 		tmat4x3<T, P> const & m,
 		typename tmat4x3<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat4x3<T, P> operator/ (
+	GLM_FUNC_DECL tmat4x3<T, P> operator/ (
 		typename tmat4x3<T, P>::value_type const & s,
 		tmat4x3<T, P> const & m);
 
 	// Unary constant operators
 	template <typename T, precision P>
-	tmat4x3<T, P> const operator- (
+	GLM_FUNC_DECL tmat4x3<T, P> const operator- (
 		tmat4x3<T, P> const & m);
 
 }//namespace detail

glm/core/type_mat4x4.hpp

@@ -154,98 +154,98 @@ namespace detail
 
 	// Binary operators
 	template <typename T, precision P>
-	tmat4x4<T, P> operator+ (
+	GLM_FUNC_DECL tmat4x4<T, P> operator+ (
 		tmat4x4<T, P> const & m,
 		typename tmat4x4<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat4x4<T, P> operator+ (
+	GLM_FUNC_DECL tmat4x4<T, P> operator+ (
 		typename tmat4x4<T, P>::value_type const & s,
 		tmat4x4<T, P> const & m);
 
 	template <typename T, precision P> 
-	tmat4x4<T, P> operator+ (
+	GLM_FUNC_DECL tmat4x4<T, P> operator+ (
 		tmat4x4<T, P> const & m1, 
 		tmat4x4<T, P> const & m2);
 
 	template <typename T, precision P> 
-	tmat4x4<T, P> operator- (
+	GLM_FUNC_DECL tmat4x4<T, P> operator- (
 		tmat4x4<T, P> const & m, 
 		typename tmat4x4<T, P>::value_type const & s);
 
 	template <typename T, precision P> 
-	tmat4x4<T, P> operator- (
+	GLM_FUNC_DECL tmat4x4<T, P> operator- (
 		typename tmat4x4<T, P>::value_type const & s,
 		tmat4x4<T, P> const & m);
 
 	template <typename T, precision P>
-	tmat4x4<T, P> operator- (
+	GLM_FUNC_DECL tmat4x4<T, P> operator- (
 		tmat4x4<T, P> const & m1,
 		tmat4x4<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat4x4<T, P> operator* (
+	GLM_FUNC_DECL tmat4x4<T, P> operator* (
 		tmat4x4<T, P> const & m,
 		typename tmat4x4<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat4x4<T, P> operator* (
+	GLM_FUNC_DECL tmat4x4<T, P> operator* (
 		typename tmat4x4<T, P>::value_type const & s,
 		tmat4x4<T, P> const & m);
 
 	template <typename T, precision P>
-	typename tmat4x4<T, P>::col_type operator* (
+	GLM_FUNC_DECL typename tmat4x4<T, P>::col_type operator* (
 		tmat4x4<T, P> const & m,
 		typename tmat4x4<T, P>::row_type const & v);
 
 	template <typename T, precision P>
-	typename tmat4x4<T, P>::row_type operator* (
+	GLM_FUNC_DECL typename tmat4x4<T, P>::row_type operator* (
 		typename tmat4x4<T, P>::col_type const & v,
 		tmat4x4<T, P> const & m);
 		
 	template <typename T, precision P>
-	tmat2x4<T, P> operator* (
+	GLM_FUNC_DECL tmat2x4<T, P> operator* (
 		tmat4x4<T, P> const & m1,
 		tmat2x4<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat3x4<T, P> operator* (
+	GLM_FUNC_DECL tmat3x4<T, P> operator* (
 		tmat4x4<T, P> const & m1,
 		tmat3x4<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat4x4<T, P> operator* (
+	GLM_FUNC_DECL tmat4x4<T, P> operator* (
 		tmat4x4<T, P> const & m1,
 		tmat4x4<T, P> const & m2);
 
 	template <typename T, precision P>
-	tmat4x4<T, P> operator/ (
+	GLM_FUNC_DECL tmat4x4<T, P> operator/ (
 		tmat4x4<T, P> const & m,
 		typename tmat4x4<T, P>::value_type const & s);
 
 	template <typename T, precision P>
-	tmat4x4<T, P> operator/ (
+	GLM_FUNC_DECL tmat4x4<T, P> operator/ (
 		typename tmat4x4<T, P>::value_type const & s,
 		tmat4x4<T, P> const & m);
 
 	template <typename T, precision P>
-	typename tmat4x4<T, P>::col_type operator/ (
+	GLM_FUNC_DECL typename tmat4x4<T, P>::col_type operator/ (
 		tmat4x4<T, P> const & m,
 		typename tmat4x4<T, P>::row_type const & v);
 
 	template <typename T, precision P>
-	typename tmat4x4<T, P>::row_type operator/ (
+	GLM_FUNC_DECL typename tmat4x4<T, P>::row_type operator/ (
 		typename tmat4x4<T, P>::col_type & v,
 		tmat4x4<T, P> const & m);
 
 	template <typename T, precision P>
-	tmat4x4<T, P> operator/ (
+	GLM_FUNC_DECL tmat4x4<T, P> operator/ (
 		tmat4x4<T, P> const & m1,
 		tmat4x4<T, P> const & m2);
 
 	// Unary constant operators
 	template <typename T, precision P>
-	tmat4x4<T, P> const operator-  (
+	GLM_FUNC_DECL tmat4x4<T, P> const operator-  (
 		tmat4x4<T, P> const & m);
 
 }//namespace detail

glm/core/type_vec2.hpp

@@ -115,7 +115,7 @@ namespace detail
 		//////////////////////////////////////
 		// Swizzle constructors
 
-		tvec2(tref2<T, P> const & r);
+		GLM_FUNC_DECL tvec2(tref2<T, P> const & r);
 
 		template <int E0, int E1>
 		GLM_FUNC_DECL tvec2(_swizzle<2,T, P, tvec2<T, P>, E0, E1,-1,-2> const & that)

glm/core/type_vec4.inl

@@ -1140,7 +1140,7 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec4<T, P> operator|
 	(
-		tvec4<T, P> const & v1, 
+		tvec4<T, P> const & v1,
 		tvec4<T, P> const & v2
 	)
 	{

glm/gtc/constants.hpp

@@ -56,127 +56,127 @@ namespace glm
 	/// @todo Implement epsilon for half-precision floating point type.
 	/// @see gtc_constants
 	template <typename genType>
-	genType epsilon();
+	GLM_FUNC_DECL genType epsilon();
 
 	/// Return 0.
 	/// @see gtc_constants
 	template <typename genType>
-	genType zero();
+	GLM_FUNC_DECL genType zero();
 
 	/// Return 1.
 	/// @see gtc_constants
 	template <typename genType>
-	genType one();
+	GLM_FUNC_DECL genType one();
 
 	/// Return the pi constant.
 	/// @see gtc_constants
 	template <typename genType>
-	genType pi();
+	GLM_FUNC_DECL genType pi();
 
 	/// Return square root of pi.
 	/// @see gtc_constants
 	template <typename genType>
-	genType root_pi();
+	GLM_FUNC_DECL genType root_pi();
 
 	/// Return pi / 2.
 	/// @see gtc_constants
 	template <typename genType>
-	genType half_pi();
+	GLM_FUNC_DECL genType half_pi();
 
 	/// Return pi / 4.
 	/// @see gtc_constants
 	template <typename genType>
-	genType quarter_pi();
+	GLM_FUNC_DECL genType quarter_pi();
 
 	/// Return 1 / pi.
 	/// @see gtc_constants
 	template <typename genType>
-	genType one_over_pi();
+	GLM_FUNC_DECL genType one_over_pi();
 
 	/// Return 2 / pi.
 	/// @see gtc_constants
 	template <typename genType>
-	genType two_over_pi();
+	GLM_FUNC_DECL genType two_over_pi();
 
 	/// Return 2 / sqrt(pi).
 	/// @see gtc_constants
 	template <typename genType>
-	genType two_over_root_pi();
+	GLM_FUNC_DECL genType two_over_root_pi();
 
 	/// Return 1 / sqrt(2).
 	/// @see gtc_constants
 	template <typename genType>
-	genType one_over_root_two();
+	GLM_FUNC_DECL genType one_over_root_two();
 
 	/// Return sqrt(pi / 2).
 	/// @see gtc_constants
 	template <typename genType>
-	genType root_half_pi();
+	GLM_FUNC_DECL genType root_half_pi();
 
 	/// Return sqrt(2 * pi).
 	/// @see gtc_constants
 	template <typename genType>
-	genType root_two_pi();
+	GLM_FUNC_DECL genType root_two_pi();
 
 	/// Return sqrt(ln(4)).
 	/// @see gtc_constants
 	template <typename genType>
-	genType root_ln_four();
+	GLM_FUNC_DECL genType root_ln_four();
 
 	/// Return e constant.
 	/// @see gtc_constants
 	template <typename genType>
-	genType e();
+	GLM_FUNC_DECL genType e();
 
 	/// Return Euler's constant.
 	/// @see gtc_constants
 	template <typename genType>
-	genType euler();
+	GLM_FUNC_DECL genType euler();
 
 	/// Return sqrt(2).
 	/// @see gtc_constants
 	template <typename genType>
-	genType root_two();
+	GLM_FUNC_DECL genType root_two();
 
 	/// Return sqrt(3).
 	/// @see gtc_constants
 	template <typename genType>
-	genType root_three();
+	GLM_FUNC_DECL genType root_three();
 
 	/// Return sqrt(5).
 	/// @see gtc_constants
 	template <typename genType>
-	genType root_five();
+	GLM_FUNC_DECL genType root_five();
 
 	/// Return ln(2).
 	/// @see gtc_constants
 	template <typename genType>
-	genType ln_two();
+	GLM_FUNC_DECL genType ln_two();
 
 	/// Return ln(10).
 	/// @see gtc_constants
 	template <typename genType>
-	genType ln_ten();
+	GLM_FUNC_DECL genType ln_ten();
 
 	/// Return ln(ln(2)).
 	/// @see gtc_constants
 	template <typename genType>
-	genType ln_ln_two();
+	GLM_FUNC_DECL genType ln_ln_two();
 
 	/// Return 1 / 3.
 	/// @see gtc_constants
 	template <typename genType>
-	genType third();
+	GLM_FUNC_DECL genType third();
 
 	/// Return 2 / 3.
 	/// @see gtc_constants
 	template <typename genType>
-	genType two_thirds();
+	GLM_FUNC_DECL genType two_thirds();
 
 	/// Return the golden ratio constant.
 	/// @see gtc_constants
 	template <typename genType>
-	genType golden_ratio();
+	GLM_FUNC_DECL genType golden_ratio();
 
 	/// @}
 } //namespace glm

glm/gtc/half_float.hpp

@@ -68,77 +68,77 @@ namespace detail
 		//////////////////////////////////////
 		// Accesses
 
-		half & operator[](size_type i);
-		half const & operator[](size_type i) const;
+		GLM_FUNC_DECL half & operator[](size_type i);
+		GLM_FUNC_DECL half const & operator[](size_type i) const;
 
 		//////////////////////////////////////
 		// Implicit basic constructors
 
-		tvec2();
-		tvec2(tvec2<half, P> const & v);
+		GLM_FUNC_DECL tvec2();
+		GLM_FUNC_DECL tvec2(tvec2<half, P> const & v);
 
 		//////////////////////////////////////
 		// Explicit basic constructors
 
-		explicit tvec2(ctor){}
-		explicit tvec2(
+		GLM_FUNC_DECL explicit tvec2(ctor){}
+		GLM_FUNC_DECL explicit tvec2(
 			half const & s);
-		explicit tvec2(
+		GLM_FUNC_DECL explicit tvec2(
 			half const & s1,
 			half const & s2);
 
 		//////////////////////////////////////
 		// Swizzle constructors
 
-		tvec2(tref2<half, P> const & r);
+		GLM_FUNC_DECL tvec2(tref2<half, P> const & r);
 
 		//////////////////////////////////////
 		// Convertion scalar constructors
 
 		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U>
-		explicit tvec2(U const & x);
+		GLM_FUNC_DECL explicit tvec2(U const & x);
 		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, typename V>
-		explicit tvec2(U const & x, V const & y);			
+		template <typename U, typename V> 
+		GLM_FUNC_DECL explicit tvec2(U const & x, V const & y);			
 
 		//////////////////////////////////////
 		// Convertion vector constructors
 
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>
-		explicit tvec2(tvec2<U, Q> const & v);
+		GLM_FUNC_DECL explicit tvec2(tvec2<U, Q> const & v);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>
-		explicit tvec2(tvec3<U, Q> const & v);
+		GLM_FUNC_DECL explicit tvec2(tvec3<U, Q> const & v);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>
-		explicit tvec2(tvec4<U, Q> const & v);
+		GLM_FUNC_DECL explicit tvec2(tvec4<U, Q> const & v);
 
 		//////////////////////////////////////
 		// Unary arithmetic operators
 
-		tvec2<half, P>& operator= (tvec2<half, P> const & v);
+		GLM_FUNC_DECL tvec2<half, P>& operator= (tvec2<half, P> const & v);
 
-		tvec2<half, P>& operator+=(half const & s);
-		tvec2<half, P>& operator+=(tvec2<half, P> const & v);
-		tvec2<half, P>& operator-=(half const & s);
-		tvec2<half, P>& operator-=(tvec2<half, P> const & v);
-		tvec2<half, P>& operator*=(half const & s);
-		tvec2<half, P>& operator*=(tvec2<half, P> const & v);
-		tvec2<half, P>& operator/=(half const & s);
-		tvec2<half, P>& operator/=(tvec2<half, P> const & v);
-		tvec2<half, P>& operator++();
-		tvec2<half, P>& operator--();
+		GLM_FUNC_DECL tvec2<half, P>& operator+=(half const & s);
+		GLM_FUNC_DECL tvec2<half, P>& operator+=(tvec2<half, P> const & v);
+		GLM_FUNC_DECL tvec2<half, P>& operator-=(half const & s);
+		GLM_FUNC_DECL tvec2<half, P>& operator-=(tvec2<half, P> const & v);
+		GLM_FUNC_DECL tvec2<half, P>& operator*=(half const & s);
+		GLM_FUNC_DECL tvec2<half, P>& operator*=(tvec2<half, P> const & v);
+		GLM_FUNC_DECL tvec2<half, P>& operator/=(half const & s);
+		GLM_FUNC_DECL tvec2<half, P>& operator/=(tvec2<half, P> const & v);
+		GLM_FUNC_DECL tvec2<half, P>& operator++();
+		GLM_FUNC_DECL tvec2<half, P>& operator--();
 
 		//////////////////////////////////////
 		// Swizzle operators
 
-		half swizzle(comp X) const;
-		tvec2<half, P> swizzle(comp X, comp Y) const;
-		tvec3<half, P> swizzle(comp X, comp Y, comp Z) const;
-		tvec4<half, P> swizzle(comp X, comp Y, comp Z, comp W) const;
-		tref2<half, P> swizzle(comp X, comp Y);
+		GLM_FUNC_DECL half swizzle(comp X) const;
+		GLM_FUNC_DECL tvec2<half, P> swizzle(comp X, comp Y) const;
+		GLM_FUNC_DECL tvec3<half, P> swizzle(comp X, comp Y, comp Z) const;
+		GLM_FUNC_DECL tvec4<half, P> swizzle(comp X, comp Y, comp Z, comp W) const;
+		GLM_FUNC_DECL tref2<half, P> swizzle(comp X, comp Y);
 	};
 
 	template <precision P>
@@ -160,22 +160,22 @@ namespace detail
 		//////////////////////////////////////
 		// Accesses
 
-		half & operator[](size_type i);
-		half const & operator[](size_type i) const;
+		GLM_FUNC_DECL half & operator[](size_type i);
+		GLM_FUNC_DECL half const & operator[](size_type i) const;
 
 		//////////////////////////////////////
 		// Implicit basic constructors
 
-		tvec3();
-		tvec3(tvec3<half, P> const & v);
+		GLM_FUNC_DECL tvec3();
+		GLM_FUNC_DECL tvec3(tvec3<half, P> const & v);
 
 		//////////////////////////////////////
 		// Explicit basic constructors
 
-		explicit tvec3(ctor){}
-		explicit tvec3(
+		GLM_FUNC_DECL explicit tvec3(ctor){}
+		GLM_FUNC_DECL explicit tvec3(
 			half const & s);
-		explicit tvec3(
+		GLM_FUNC_DECL explicit tvec3(
 			half const & s1,
 			half const & s2,
 			half const & s3);
@@ -183,58 +183,59 @@ namespace detail
 		//////////////////////////////////////
 		// Swizzle constructors
 
-		tvec3(tref3<half, P> const & r);
+		GLM_FUNC_DECL tvec3(tref3<half, P> const & r);
 
 		//////////////////////////////////////
 		// Convertion scalar constructors
 
 		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U>
-		explicit tvec3(U const & x);
+		GLM_FUNC_DECL explicit tvec3(U const & x);
+
 		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, typename V, typename W> 
-		explicit tvec3(U const & x, V const & y, W const & z);			
+		GLM_FUNC_DECL explicit tvec3(U const & x, V const & y, W const & z);			
 
 		//////////////////////////////////////
 		// Convertion vector constructors
 
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, precision Q>
-		explicit tvec3(tvec2<A, Q> const & v, B const & s);
+		GLM_FUNC_DECL explicit tvec3(tvec2<A, Q> const & v, B const & s);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, precision Q>
-		explicit tvec3(A const & s, tvec2<B, Q> const & v);
+		GLM_FUNC_DECL explicit tvec3(A const & s, tvec2<B, Q> const & v);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>
-		explicit tvec3(tvec3<U, Q> const & v);
+		GLM_FUNC_DECL explicit tvec3(tvec3<U, Q> const & v);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>
-		explicit tvec3(tvec4<U, Q> const & v);
+		GLM_FUNC_DECL explicit tvec3(tvec4<U, Q> const & v);
 
 		//////////////////////////////////////
 		// Unary arithmetic operators
 
-		tvec3<half, P>& operator= (tvec3<half, P> const & v);
+		GLM_FUNC_DECL tvec3<half, P>& operator= (tvec3<half, P> const & v);
 
-		tvec3<half, P>& operator+=(half const & s);
-		tvec3<half, P>& operator+=(tvec3<half, P> const & v);
-		tvec3<half, P>& operator-=(half const & s);
-		tvec3<half, P>& operator-=(tvec3<half, P> const & v);
-		tvec3<half, P>& operator*=(half const & s);
-		tvec3<half, P>& operator*=(tvec3<half, P> const & v);
-		tvec3<half, P>& operator/=(half const & s);
-		tvec3<half, P>& operator/=(tvec3<half, P> const & v);
-		tvec3<half, P>& operator++();
-		tvec3<half, P>& operator--();
+		GLM_FUNC_DECL tvec3<half, P>& operator+=(half const & s);
+		GLM_FUNC_DECL tvec3<half, P>& operator+=(tvec3<half, P> const & v);
+		GLM_FUNC_DECL tvec3<half, P>& operator-=(half const & s);
+		GLM_FUNC_DECL tvec3<half, P>& operator-=(tvec3<half, P> const & v);
+		GLM_FUNC_DECL tvec3<half, P>& operator*=(half const & s);
+		GLM_FUNC_DECL tvec3<half, P>& operator*=(tvec3<half, P> const & v);
+		GLM_FUNC_DECL tvec3<half, P>& operator/=(half const & s);
+		GLM_FUNC_DECL tvec3<half, P>& operator/=(tvec3<half, P> const & v);
+		GLM_FUNC_DECL tvec3<half, P>& operator++();
+		GLM_FUNC_DECL tvec3<half, P>& operator--();
 
 		//////////////////////////////////////
 		// Swizzle operators
 
-		half swizzle(comp X) const;
-		tvec2<half, P> swizzle(comp X, comp Y) const;
-		tvec3<half, P> swizzle(comp X, comp Y, comp Z) const;
-		tvec4<half, P> swizzle(comp X, comp Y, comp Z, comp W) const;
-		tref3<half, P> swizzle(comp X, comp Y, comp Z);
+		GLM_FUNC_DECL half swizzle(comp X) const;
+		GLM_FUNC_DECL tvec2<half, P> swizzle(comp X, comp Y) const;
+		GLM_FUNC_DECL tvec3<half, P> swizzle(comp X, comp Y, comp Z) const;
+		GLM_FUNC_DECL tvec4<half, P> swizzle(comp X, comp Y, comp Z, comp W) const;
+		GLM_FUNC_DECL tref3<half, P> swizzle(comp X, comp Y, comp Z);
 	};
 
 	template <precision P>
@@ -256,22 +257,23 @@ namespace detail
 		//////////////////////////////////////
 		// Accesses
 
-		half & operator[](size_type i);
-		half const & operator[](size_type i) const;
+		GLM_FUNC_DECL half & operator[](size_type i);
+		GLM_FUNC_DECL half const & operator[](size_type i) const;
 
 		//////////////////////////////////////
 		// Implicit basic constructors
 
-		tvec4();
-		tvec4(tvec4<half, P> const & v);
+		GLM_FUNC_DECL tvec4();
+		GLM_FUNC_DECL tvec4(tvec4<half, P> const & v);
 
 		//////////////////////////////////////
 		// Explicit basic constructors
 
-		explicit tvec4(ctor){}
-		explicit tvec4(
+
+		GLM_FUNC_DECL explicit tvec4(ctor){}
+		GLM_FUNC_DECL explicit tvec4(
 			half const & s);
-		explicit tvec4(
+		GLM_FUNC_DECL explicit tvec4(
 			half const & s0,
 			half const & s1,
 			half const & s2,
@@ -280,67 +282,67 @@ namespace detail
 		//////////////////////////////////////
 		// Swizzle constructors
 
-		tvec4(tref4<half, P> const & r);
+		GLM_FUNC_DECL tvec4(tref4<half, P> const & r);
 
 		//////////////////////////////////////
 		// Convertion scalar constructors
 
 		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U>
-		explicit tvec4(U const & x);
+		GLM_FUNC_DECL explicit tvec4(U const & x);
 		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, typename C, typename D>
-		explicit tvec4(A const & x, B const & y, C const & z, D const & w);			
+		GLM_FUNC_DECL explicit tvec4(A const & x, B const & y, C const & z, D const & w);			
 
 		//////////////////////////////////////
 		// Convertion vector constructors
 
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, typename C, precision Q>
-		explicit tvec4(tvec2<A, Q> const & v, B const & s1, C const & s2);
+		GLM_FUNC_DECL explicit tvec4(tvec2<A, Q> const & v, B const & s1, C const & s2);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, typename C, precision Q>
-		explicit tvec4(A const & s1, tvec2<B, Q> const & v, C const & s2);
+		GLM_FUNC_DECL explicit tvec4(A const & s1, tvec2<B, Q> const & v, C const & s2);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, typename C, precision Q>
-		explicit tvec4(A const & s1, B const & s2, tvec2<C, Q> const & v);
+		GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tvec2<C, Q> const & v);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, precision Q>
-		explicit tvec4(tvec3<A, Q> const & v, B const & s);
+		GLM_FUNC_DECL explicit tvec4(tvec3<A, Q> const & v, B const & s);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, precision Q>
-		explicit tvec4(A const & s, tvec3<B, Q> const & v);
+		GLM_FUNC_DECL explicit tvec4(A const & s, tvec3<B, Q> const & v);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, precision Q>
-		explicit tvec4(tvec2<A, Q> const & v1, tvec2<B, Q> const & v2);
+		GLM_FUNC_DECL explicit tvec4(tvec2<A, Q> const & v1, tvec2<B, Q> const & v2);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>
-		explicit tvec4(tvec4<U, Q> const & v);
+		GLM_FUNC_DECL explicit tvec4(tvec4<U, Q> const & v);
 
 		//////////////////////////////////////
 		// Unary arithmetic operators
 
-		tvec4<half, P>& operator= (tvec4<half, P> const & v);
+		GLM_FUNC_DECL tvec4<half, P>& operator= (tvec4<half, P> const & v);
 
-		tvec4<half, P>& operator+=(half const & s);
-		tvec4<half, P>& operator+=(tvec4<half, P> const & v);
-		tvec4<half, P>& operator-=(half const & s);
-		tvec4<half, P>& operator-=(tvec4<half, P> const & v);
-		tvec4<half, P>& operator*=(half const & s);
-		tvec4<half, P>& operator*=(tvec4<half, P> const & v);
-		tvec4<half, P>& operator/=(half const & s);
-		tvec4<half, P>& operator/=(tvec4<half, P> const & v);
-		tvec4<half, P>& operator++();
-		tvec4<half, P>& operator--();
+		GLM_FUNC_DECL tvec4<half, P>& operator+=(half const & s);
+		GLM_FUNC_DECL tvec4<half, P>& operator+=(tvec4<half, P> const & v);
+		GLM_FUNC_DECL tvec4<half, P>& operator-=(half const & s);
+		GLM_FUNC_DECL tvec4<half, P>& operator-=(tvec4<half, P> const & v);
+		GLM_FUNC_DECL tvec4<half, P>& operator*=(half const & s);
+		GLM_FUNC_DECL tvec4<half, P>& operator*=(tvec4<half, P> const & v);
+		GLM_FUNC_DECL tvec4<half, P>& operator/=(half const & s);
+		GLM_FUNC_DECL tvec4<half, P>& operator/=(tvec4<half, P> const & v);
+		GLM_FUNC_DECL tvec4<half, P>& operator++();
+		GLM_FUNC_DECL tvec4<half, P>& operator--();
 
 		//////////////////////////////////////
 		// Swizzle operators
 
-		half swizzle(comp X) const;
-		tvec2<half, P> swizzle(comp X, comp Y) const;
-		tvec3<half, P> swizzle(comp X, comp Y, comp Z) const;
-		tvec4<half, P> swizzle(comp X, comp Y, comp Z, comp W) const;
-		tref4<half, P> swizzle(comp X, comp Y, comp Z, comp W);
+		GLM_FUNC_DECL half swizzle(comp X) const;
+		GLM_FUNC_DECL tvec2<half, P> swizzle(comp X, comp Y) const;
+		GLM_FUNC_DECL tvec3<half, P> swizzle(comp X, comp Y, comp Z) const;
+		GLM_FUNC_DECL tvec4<half, P> swizzle(comp X, comp Y, comp Z, comp W) const;
+		GLM_FUNC_DECL tref4<half, P> swizzle(comp X, comp Y, comp Z, comp W);
 	};
 #endif//(GLM_COMPONENT == GLM_COMPONENT_CXX98)
 }
@@ -647,19 +649,19 @@ namespace detail
 	
 	/// Returns the absolute value of a half-precision floating-point value
 	/// @see gtc_half_float
-	half abs(half const & x);
+	GLM_FUNC_DECL half abs(half const & x);
 
 	/// Returns the absolute value of a half-precision floating-point two dimensional vector
 	/// @see gtc_half_float
-	hvec2 abs(hvec2 const & x);
+	GLM_FUNC_DECL hvec2 abs(hvec2 const & x);
 
 	/// Returns the absolute value of a half-precision floating-point three dimensional vector
 	/// @see gtc_half_float
-	hvec3 abs(hvec3 const & x);
+	GLM_FUNC_DECL hvec3 abs(hvec3 const & x);
 
 	/// Returns the absolute value of a half-precision floating-point four dimensional vector
 	/// @see gtc_half_float
-	hvec4 abs(hvec4 const & x);
+	GLM_FUNC_DECL hvec4 abs(hvec4 const & x);
 
 	/// Selects which vector each returned component comes
 	/// from. For a component of <a> that is false, the
@@ -673,7 +675,7 @@ namespace detail
 	/// where a is a Boolean vector.
 	///
 	/// @see gtc_half_float
-	half mix(half const & x, half const & y, bool const & a);
+	GLM_FUNC_DECL half mix(half const & x, half const & y, bool const & a);
 
 	/// @}
 }// namespace glm