Added missing GLM_FUNC_DECL specifiers

glm/core/func_common.hpp

@@ -50,7 +50,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. 
 	/// 
@@ -59,7 +59,7 @@ 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. 
 	/// 
@@ -68,7 +68,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. 
@@ -78,7 +78,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 
@@ -91,7 +91,7 @@ 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
@@ -103,7 +103,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. 
@@ -113,7 +113,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).
 	/// 
@@ -122,7 +122,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.
@@ -132,7 +132,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);
 
@@ -144,7 +144,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);
 
@@ -158,7 +158,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);
 
@@ -169,12 +169,12 @@ namespace glm
 	/// @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>
 	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);
 
@@ -185,12 +185,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);
 
@@ -202,13 +202,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> 
-	genType clamp(
+	GLM_FUNC_DECL genType clamp(
 		genType const & x, 
 		typename genType::value_type const & minVal, 
 		typename genType::value_type const & maxVal); 
@@ -256,19 +256,19 @@ 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.
 	//! 
 	/// @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);
 
@@ -287,13 +287,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);
@@ -311,7 +311,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
@@ -324,7 +324,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
@@ -336,7 +336,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
@@ -348,7 +348,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.
@@ -364,7 +364,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.
@@ -380,7 +380,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.
 	/// 
@@ -389,7 +389,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:
@@ -406,7 +406,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:
@@ -420,7 +420,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_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 valType> 
-	detail::tvec3<valType> cross(
+	GLM_FUNC_DECL detail::tvec3<valType> cross(
 		detail::tvec3<valType> const & x, 
 		detail::tvec3<valType> 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,7 +52,7 @@ 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(
+	GLM_FUNC_DECL genUType uaddCarry(
 		genUType const & x, 
 		genUType const & y, 
 		genUType & carry);
@@ -66,7 +66,7 @@ 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(
+	GLM_FUNC_DECL genUType usubBorrow(
 		genUType const & x, 
 		genUType const & y, 
 		genUType & borrow);
@@ -80,7 +80,7 @@ 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(
+	GLM_FUNC_DECL void umulExtended(
 		genUType const & x, 
 		genUType const & y, 
 		genUType & msb, 
@@ -95,7 +95,7 @@ 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(
+	GLM_FUNC_DECL void imulExtended(
 		genIType const & x, 
 		genIType const & y, 
 		genIType & msb, 
@@ -117,7 +117,7 @@ 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(
+	GLM_FUNC_DECL genIUType bitfieldExtract(
 		genIUType const & Value, 
 		int const & Offset, 
 		int const & Bits);
@@ -137,7 +137,7 @@ 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(
+	GLM_FUNC_DECL genIUType bitfieldInsert(
 		genIUType const & Base, 
 		genIUType const & Insert, 
 		int const & Offset, 
@@ -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

@@ -53,7 +53,7 @@ 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(
+	GLM_FUNC_DECL matType matrixCompMult(
 		matType const & x, 
 		matType const & y);
 
@@ -68,7 +68,7 @@ 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(
+	GLM_FUNC_DECL matType outerProduct(
 		vecType const & c, 
 		vecType const & r);
 
@@ -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 valType> 
-	typename detail::tmat2x2<valType>::value_type determinant(
+	GLM_FUNC_DECL typename detail::tmat2x2<valType>::value_type determinant(
 		detail::tmat2x2<valType> 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 valType> 
-	typename detail::tmat3x3<valType>::value_type determinant(
+	GLM_FUNC_DECL typename detail::tmat3x3<valType>::value_type determinant(
 		detail::tmat3x3<valType> 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 valType> 
-	typename detail::tmat4x4<valType>::value_type determinant(
+	GLM_FUNC_DECL typename detail::tmat4x4<valType>::value_type determinant(
 		detail::tmat4x4<valType> 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 valType> 
-	detail::tmat2x2<valType> inverse(
+	GLM_FUNC_DECL detail::tmat2x2<valType> inverse(
 		detail::tmat2x2<valType> 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 valType> 
-	detail::tmat3x3<valType> inverse(
+	GLM_FUNC_DECL detail::tmat3x3<valType> inverse(
 		detail::tmat3x3<valType> 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 valType> 
-	detail::tmat4x4<valType> inverse(
+	GLM_FUNC_DECL detail::tmat4x4<valType> inverse(
 		detail::tmat4x4<valType> 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> noise2(genType const & x);
+	GLM_FUNC_DECL detail::tvec2<typename genType::value_type> 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> noise3(genType const & x);
+	GLM_FUNC_DECL detail::tvec3<typename genType::value_type> 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> noise4(genType const & x);
+	GLM_FUNC_DECL detail::tvec4<typename genType::value_type> 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>
-	detail::uint32 packUnorm2x16(detail::tvec2<detail::float32> const & v);
+	GLM_FUNC_DECL detail::uint32 packUnorm2x16(detail::tvec2<detail::float32> 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>
-	detail::uint32 packSnorm2x16(detail::tvec2<detail::float32> const & v);
+	GLM_FUNC_DECL detail::uint32 packSnorm2x16(detail::tvec2<detail::float32> 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>
-	detail::uint32 packUnorm4x8(detail::tvec4<detail::float32> const & v);
+	GLM_FUNC_DECL detail::uint32 packUnorm4x8(detail::tvec4<detail::float32> 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>
-	detail::uint32 packSnorm4x8(detail::tvec4<detail::float32> const & v);
+	GLM_FUNC_DECL detail::uint32 packSnorm4x8(detail::tvec4<detail::float32> 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>
-	detail::tvec2<detail::float32> unpackUnorm2x16(detail::uint32 const & p);
+	GLM_FUNC_DECL detail::tvec2<detail::float32> unpackUnorm2x16(detail::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>
-	detail::tvec2<detail::float32> unpackSnorm2x16(detail::uint32 const & p);
+	GLM_FUNC_DECL detail::tvec2<detail::float32> unpackSnorm2x16(detail::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>
-	detail::tvec4<detail::float32> unpackUnorm4x8(detail::uint32 const & p);
+	GLM_FUNC_DECL detail::tvec4<detail::float32> unpackUnorm4x8(detail::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>
-	detail::tvec4<detail::float32> unpackSnorm4x8(detail::uint32 const & p);
+	GLM_FUNC_DECL detail::tvec4<detail::float32> unpackSnorm4x8(detail::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(detail::tvec2<detail::uint32> const & v);
+	GLM_FUNC_DECL double packDouble2x32(detail::tvec2<detail::uint32> 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>
-	detail::tvec2<detail::uint32> unpackDouble2x32(double const & v);
+	GLM_FUNC_DECL detail::tvec2<detail::uint32> 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 uint 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(uint const & v);
+	GLM_FUNC_DECL vec2 unpackHalf2x16(uint 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

@@ -55,7 +55,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 vecType> 
-	typename vecType::bool_type lessThan(vecType const & x, vecType const & y);
+	GLM_FUNC_DECL typename vecType::bool_type lessThan(vecType const & x, vecType const & y);
 
 	/// Returns the component-wise comparison of result x <= y.
 	///
@@ -64,7 +64,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 vecType> 
-	typename vecType::bool_type lessThanEqual(vecType const & x, vecType const & y);
+	GLM_FUNC_DECL typename vecType::bool_type lessThanEqual(vecType const & x, vecType const & y);
 
 	/// Returns the component-wise comparison of result x > y.
 	///
@@ -73,7 +73,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 vecType> 
-	typename vecType::bool_type greaterThan(vecType const & x, vecType const & y);
+	GLM_FUNC_DECL typename vecType::bool_type greaterThan(vecType const & x, vecType const & y);
 
 	/// Returns the component-wise comparison of result x >= y.
 	///
@@ -82,7 +82,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 vecType> 
-	typename vecType::bool_type greaterThanEqual(vecType const & x, vecType const & y);
+	GLM_FUNC_DECL typename vecType::bool_type greaterThanEqual(vecType const & x, vecType const & y);
 
 	/// Returns the component-wise comparison of result x == y.
 	///
@@ -91,7 +91,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 vecType> 
-	typename vecType::bool_type equal(vecType const & x, vecType const & y);
+	GLM_FUNC_DECL typename vecType::bool_type equal(vecType const & x, vecType const & y);
 
 	/// Returns the component-wise comparison of result x != y.
 	/// 
@@ -100,7 +100,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 vecType> 
-	typename vecType::bool_type notEqual(vecType const & x, vecType const & y);
+	GLM_FUNC_DECL typename vecType::bool_type notEqual(vecType const & x, vecType const & y);
 
 	/// Returns true if any component of x is true.
 	///
@@ -109,7 +109,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 <template <typename> class vecType> 
-	bool any(vecType<bool> const & v);
+	GLM_FUNC_DECL bool any(vecType<bool> const & v);
 
 	/// Returns true if all components of x are true.
 	///
@@ -118,7 +118,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 <template <typename> class vecType> 
-	bool all(vecType<bool> const & v);
+	GLM_FUNC_DECL bool all(vecType<bool> 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.
@@ -128,7 +128,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 <template <typename> class vecType> 
-	vecType<bool> not_(vecType<bool> const & v);
+	GLM_FUNC_DECL vecType<bool> not_(vecType<bool> const & v);
 
 	/// @}
 }//namespace glm

glm/core/type_mat2x2.hpp

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

glm/core/type_mat2x3.hpp

@@ -115,8 +115,8 @@ namespace detail
 		GLM_FUNC_DECL explicit tmat2x3(tmat4x3<T> 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> & operator=  (tmat2x3<T> const & m);
@@ -143,82 +143,82 @@ namespace detail
 
 	// Binary operators
 	template <typename T> 
-	tmat2x3<T> operator+ (
+	GLM_FUNC_DECL tmat2x3<T> operator+ (
 		tmat2x3<T> const & m, 
 		typename tmat2x3<T>::value_type const & s);
 
 	template <typename T> 
-	tmat2x3<T> operator+ (
+	GLM_FUNC_DECL tmat2x3<T> operator+ (
 		tmat2x3<T> const & m1, 
 		tmat2x3<T> const & m2);
 
 	template <typename T> 
-	tmat2x3<T> operator- (
+	GLM_FUNC_DECL tmat2x3<T> operator- (
 		tmat2x3<T> const & m, 
 		typename tmat2x3<T>::value_type const & s);
 
 	template <typename T> 
-	tmat2x3<T> operator- (
+	GLM_FUNC_DECL tmat2x3<T> operator- (
 		tmat2x3<T> const & m1, 
 		tmat2x3<T> const & m2);
 
 	template <typename T> 
-	tmat2x3<T> operator* (
+	GLM_FUNC_DECL tmat2x3<T> operator* (
 		tmat2x3<T> const & m, 
 		typename tmat2x3<T>::value_type const & s);
 
 	template <typename T> 
-	tmat2x3<T> operator* (
+	GLM_FUNC_DECL tmat2x3<T> operator* (
 		typename tmat2x3<T>::value_type const & s, 
 		tmat2x3<T> const & m);
 
 	template <typename T>
-	typename tmat2x3<T>::col_type operator* (
+	GLM_FUNC_DECL typename tmat2x3<T>::col_type operator* (
 		tmat2x3<T> const & m, 
 		typename tmat2x3<T>::row_type const & v);
 
 	template <typename T> 
-	typename tmat2x3<T>::row_type operator* (
+	GLM_FUNC_DECL typename tmat2x3<T>::row_type operator* (
 		typename tmat2x3<T>::col_type const & v, 
 		tmat2x3<T> const & m);
 
 	template <typename T>
-	tmat2x3<T> operator* (
+	GLM_FUNC_DECL tmat2x3<T> operator* (
 		tmat2x3<T> const & m1, 
 		tmat2x2<T> const & m2);
 
 	template <typename T>
-	tmat3x3<T> operator* (
+	GLM_FUNC_DECL tmat3x3<T> operator* (
 		tmat2x3<T> const & m1, 
 		tmat3x2<T> const & m2);
 		
 	template <typename T>
-	tmat4x3<T> operator* (
+	GLM_FUNC_DECL tmat4x3<T> operator* (
 		tmat2x3<T> const & m1, 
 		tmat4x2<T> const & m2);
 
 	template <typename T> 
-	tmat2x3<T> operator/ (
+	GLM_FUNC_DECL tmat2x3<T> operator/ (
 		tmat2x3<T> const & m, 
 		typename tmat2x3<T>::value_type const & s);
 
 	template <typename T> 
-	tmat2x3<T> operator/ (
+	GLM_FUNC_DECL tmat2x3<T> operator/ (
 		typename tmat2x3<T>::value_type const & s,
 		tmat2x3<T> const & m);
 
 	// Unary constant operators
 	template <typename T> 
-	tmat2x3<T> const operator-  (
+	GLM_FUNC_DECL tmat2x3<T> const operator-  (
 		tmat2x3<T> const & m);
 
 	template <typename T> 
-	tmat2x3<T> const operator-- (
+	GLM_FUNC_DECL tmat2x3<T> const operator-- (
 		tmat2x3<T> const & m, 
 		int);
 
 	template <typename T> 
-	tmat2x3<T> const operator++ (
+	GLM_FUNC_DECL tmat2x3<T> const operator++ (
 		tmat2x3<T> const & m, 
 		int);
 

glm/core/type_mat2x4.hpp

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

glm/core/type_mat3x2.hpp

@@ -151,82 +151,82 @@ namespace detail
 
 	// Binary operators
 	template <typename T> 
-	tmat3x2<T> operator+ (
+	GLM_FUNC_DECL tmat3x2<T> operator+ (
 		tmat3x2<T> const & m, 
 		typename tmat3x2<T>::value_type const & s);
 
 	template <typename T> 
-	tmat3x2<T> operator+ (
+	GLM_FUNC_DECL tmat3x2<T> operator+ (
 		tmat3x2<T> const & m1, 
 		tmat3x2<T> const & m2);
 
 	template <typename T> 
-	tmat3x2<T> operator- (
+	GLM_FUNC_DECL tmat3x2<T> operator- (
 		tmat3x2<T> const & m, 
 		typename tmat3x2<T>::value_type const & s);
 
 	template <typename T> 
-	tmat3x2<T> operator- (
+	GLM_FUNC_DECL tmat3x2<T> operator- (
 		tmat3x2<T> const & m1, 
 		tmat3x2<T> const & m2);
 
 	template <typename T> 
-	tmat3x2<T> operator* (
+	GLM_FUNC_DECL tmat3x2<T> operator* (
 		tmat3x2<T> const & m, 
 		typename tmat3x2<T>::value_type const & s);
 
 	template <typename T> 
-	tmat3x2<T> operator* (
+	GLM_FUNC_DECL tmat3x2<T> operator* (
 		typename tmat3x2<T>::value_type const & s, 
 		tmat3x2<T> const & m);
 
 	template <typename T>
-	typename tmat3x2<T>::col_type operator* (
+	GLM_FUNC_DECL typename tmat3x2<T>::col_type operator* (
 		tmat3x2<T> const & m, 
 		typename tmat3x2<T>::row_type const & v);
 
 	template <typename T> 
-	typename tmat3x2<T>::row_type operator* (
+	GLM_FUNC_DECL typename tmat3x2<T>::row_type operator* (
 		typename tmat3x2<T>::col_type const & v,
 		tmat3x2<T> const & m);
 
 	template <typename T>
-	tmat2x2<T> operator* (
+	GLM_FUNC_DECL tmat2x2<T> operator* (
 		tmat3x2<T> const & m1, 
 		tmat2x3<T> const & m2);
 		
 	template <typename T>
-	tmat3x2<T> operator* (
+	GLM_FUNC_DECL tmat3x2<T> operator* (
 		tmat3x2<T> const & m1, 
 		tmat3x3<T> const & m2);
 		
 	template <typename T>
-	tmat4x2<T> operator* (
+	GLM_FUNC_DECL tmat4x2<T> operator* (
 		tmat3x2<T> const & m1, 
 		tmat4x3<T> const & m2);
 
 	template <typename T> 
-	tmat3x2<T> operator/ (
+	GLM_FUNC_DECL tmat3x2<T> operator/ (
 		tmat3x2<T> const & m, 
 		typename tmat3x2<T>::value_type const & s);
 
 	template <typename T> 
-	tmat3x2<T> operator/ (
+	GLM_FUNC_DECL tmat3x2<T> operator/ (
 		typename tmat3x2<T>::value_type const & s, 
 		tmat3x2<T> const & m);
 
 	// Unary constant operators
 	template <typename T> 
-	tmat3x2<T> const operator-  (
+	GLM_FUNC_DECL tmat3x2<T> const operator-  (
 		tmat3x2<T> const & m);
 
 	template <typename T> 
-	tmat3x2<T> const operator-- (
+	GLM_FUNC_DECL tmat3x2<T> const operator-- (
 		tmat3x2<T> const & m, 
 		int);
 
 	template <typename T> 
-	tmat3x2<T> const operator++ (
+	GLM_FUNC_DECL tmat3x2<T> const operator++ (
 		tmat3x2<T> const & m, 
 		int);
 } //namespace detail

glm/core/type_mat3x3.hpp

@@ -158,107 +158,107 @@ namespace detail
 
 	// Binary operators
 	template <typename T> 
-	tmat3x3<T> operator+ (
+	GLM_FUNC_DECL tmat3x3<T> operator+ (
 		tmat3x3<T> const & m, 
 		typename tmat3x3<T>::value_type const & s);
 
 	template <typename T> 
-	tmat3x3<T> operator+ (
+	GLM_FUNC_DECL tmat3x3<T> operator+ (
 		typename tmat3x3<T>::value_type const & s, 
 		tmat3x3<T> const & m);
 
 	template <typename T> 
-	tmat3x3<T> operator+ (
+	GLM_FUNC_DECL tmat3x3<T> operator+ (
 		tmat3x3<T> const & m1, 
 		tmat3x3<T> const & m2);
 	    
 	template <typename T> 
-	tmat3x3<T> operator- (
+	GLM_FUNC_DECL tmat3x3<T> operator- (
 		tmat3x3<T> const & m, 
 		typename tmat3x3<T>::value_type const & s);
 
 	template <typename T> 
-	tmat3x3<T> operator- (
+	GLM_FUNC_DECL tmat3x3<T> operator- (
 		typename tmat3x3<T>::value_type const & s, 
 		tmat3x3<T> const & m);
 
 	template <typename T> 
-	tmat3x3<T> operator- (
+	GLM_FUNC_DECL tmat3x3<T> operator- (
 		tmat3x3<T> const & m1, 
 		tmat3x3<T> const & m2);
 
 	template <typename T> 
-	tmat3x3<T> operator* (
+	GLM_FUNC_DECL tmat3x3<T> operator* (
 		tmat3x3<T> const & m, 
 		typename tmat3x3<T>::value_type const & s);
 
 	template <typename T> 
-	tmat3x3<T> operator* (
+	GLM_FUNC_DECL tmat3x3<T> operator* (
 		typename tmat3x3<T>::value_type const & s, 
 		tmat3x3<T> const & m);
 
 	template <typename T> 
-	typename tmat3x3<T>::col_type operator* (
+	GLM_FUNC_DECL typename tmat3x3<T>::col_type operator* (
 		tmat3x3<T> const & m, 
 		typename tmat3x3<T>::row_type const & v);
 
 	template <typename T> 
-	typename tmat3x3<T>::row_type operator* (
+	GLM_FUNC_DECL typename tmat3x3<T>::row_type operator* (
 		typename tmat3x3<T>::col_type const & v, 
 		tmat3x3<T> const & m);
 
 	template <typename T> 
-	tmat3x3<T> operator* (
+	GLM_FUNC_DECL tmat3x3<T> operator* (
 		tmat3x3<T> const & m1, 
 		tmat3x3<T> const & m2);
 		
 	template <typename T>
-	tmat2x3<T> operator* (
+	GLM_FUNC_DECL tmat2x3<T> operator* (
 		tmat3x3<T> const & m1, 
 		tmat2x3<T> const & m2);
 		
 	template <typename T>
-	tmat4x3<T> operator* (
+	GLM_FUNC_DECL tmat4x3<T> operator* (
 		tmat3x3<T> const & m1, 
 		tmat4x3<T> const & m2);
 
 	template <typename T> 
-	tmat3x3<T> operator/ (
+	GLM_FUNC_DECL tmat3x3<T> operator/ (
 		tmat3x3<T> const & m, 
 		typename tmat3x3<T>::value_type const & s);
 
 	template <typename T> 
-	tmat3x3<T> operator/ (
+	GLM_FUNC_DECL tmat3x3<T> operator/ (
 		typename tmat3x3<T>::value_type const & s, 
 		tmat3x3<T> const & m);
 
 	template <typename T> 
-	typename tmat3x3<T>::col_type operator/ (
+	GLM_FUNC_DECL typename tmat3x3<T>::col_type operator/ (
 		tmat3x3<T> const & m, 
 		typename tmat3x3<T>::row_type const & v);
 
 	template <typename T> 
-	typename tmat3x3<T>::row_type operator/ (
+	GLM_FUNC_DECL typename tmat3x3<T>::row_type operator/ (
 		typename tmat3x3<T>::col_type const & v, 
 		tmat3x3<T> const & m);
 
 	template <typename T> 
-	tmat3x3<T> operator/ (
+	GLM_FUNC_DECL tmat3x3<T> operator/ (
 		tmat3x3<T> const & m1, 
 		tmat3x3<T> const & m2);
 
 	// Unary constant operators
 	template <typename T> 
-	tmat3x3<T> const operator-  (
+	GLM_FUNC_DECL tmat3x3<T> const operator-  (
 		tmat3x3<T> const & m);
 
 	template <typename T> 
-	tmat3x3<T> const operator-- (
+	GLM_FUNC_DECL tmat3x3<T> const operator-- (
 		tmat3x3<T> const & m, 
 		int);
 
 	template <typename T> 
-	tmat3x3<T> const operator++ (
+	GLM_FUNC_DECL tmat3x3<T> const operator++ (
 		tmat3x3<T> const & m, 
 		int);
 } //namespace detail

glm/core/type_mat3x4.hpp

@@ -123,8 +123,8 @@ namespace detail
 		GLM_FUNC_DECL explicit tmat3x4(tmat4x3<T> 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> & operator=  (tmat3x4<T> const & m);
@@ -151,82 +151,82 @@ namespace detail
 
 	// Binary operators
 	template <typename T> 
-	tmat3x4<T> operator+ (
+	GLM_FUNC_DECL tmat3x4<T> operator+ (
 		tmat3x4<T> const & m, 
 		typename tmat3x4<T>::value_type const & s);
 	    
 	template <typename T> 
-	tmat3x4<T> operator+ (
+	GLM_FUNC_DECL tmat3x4<T> operator+ (
 		tmat3x4<T> const & m1, 
 		tmat3x4<T> const & m2);
 	    
 	template <typename T> 
-	tmat3x4<T> operator- (
+	GLM_FUNC_DECL tmat3x4<T> operator- (
 		tmat3x4<T> const & m, 
 		typename tmat3x4<T>::value_type const & s);
 
 	template <typename T> 
-	tmat3x4<T> operator- (
+	GLM_FUNC_DECL tmat3x4<T> operator- (
 		tmat3x4<T> const & m1, 
 		tmat3x4<T> const & m2);
 
 	template <typename T> 
-	tmat3x4<T> operator* (
+	GLM_FUNC_DECL tmat3x4<T> operator* (
 		tmat3x4<T> const & m, 
 		typename tmat3x4<T>::value_type const & s);
 
 	template <typename T> 
-	tmat3x4<T> operator* (
+	GLM_FUNC_DECL tmat3x4<T> operator* (
 		typename tmat3x4<T>::value_type const & s, 
 		tmat3x4<T> const & m);
 
 	template <typename T>
-	typename tmat3x4<T>::col_type operator* (
+	GLM_FUNC_DECL typename tmat3x4<T>::col_type operator* (
 		tmat3x4<T> const & m, 
 		typename tmat3x4<T>::row_type const & v);
 
 	template <typename T> 
-	typename tmat3x4<T>::row_type operator* (
+	GLM_FUNC_DECL typename tmat3x4<T>::row_type operator* (
 		typename tmat3x4<T>::col_type const & v, 
 		tmat3x4<T> const & m);
 
 	template <typename T>
-	tmat4x4<T> operator* (
+	GLM_FUNC_DECL tmat4x4<T> operator* (
 		tmat3x4<T> const & m1, 
 		tmat4x3<T> const & m2);
 		
 	template <typename T>
-	tmat2x4<T> operator* (
+	GLM_FUNC_DECL tmat2x4<T> operator* (
 		tmat3x4<T> const & m1, 
 		tmat2x3<T> const & m2);
 		
 	template <typename T>
-	tmat3x4<T> operator* (
+	GLM_FUNC_DECL tmat3x4<T> operator* (
 		tmat3x4<T> const & m1, 
 		tmat3x3<T> const & m2);
 
 	template <typename T> 
-	tmat3x4<T> operator/ (
+	GLM_FUNC_DECL tmat3x4<T> operator/ (
 		tmat3x4<T> const & m, 
 		typename tmat3x4<T>::value_type const & s);
 
 	template <typename T> 
-	tmat3x4<T> operator/ (
+	GLM_FUNC_DECL tmat3x4<T> operator/ (
 		typename tmat3x4<T>::value_type const & s, 
 		tmat3x4<T> const & m);
 
 	// Unary constant operators
 	template <typename T> 
-	tmat3x4<T> const operator-  (
+	GLM_FUNC_DECL tmat3x4<T> const operator-  (
 		tmat3x4<T> const & m);
 
 	template <typename T> 
-	tmat3x4<T> const operator-- (
+	GLM_FUNC_DECL tmat3x4<T> const operator-- (
 		tmat3x4<T> const & m, 
 		int);
 
 	template <typename T> 
-	tmat3x4<T> const operator++ (
+	GLM_FUNC_DECL tmat3x4<T> const operator++ (
 		tmat3x4<T> const & m, 
 		int);
 

glm/core/type_mat4x2.hpp

@@ -156,82 +156,82 @@ namespace detail
 
 	// Binary operators
 	template <typename T> 
-	tmat4x2<T> operator+ (
+	GLM_FUNC_DECL tmat4x2<T> operator+ (
 		tmat4x2<T> const & m, 
 		typename tmat4x2<T>::value_type const & s);
 
 	template <typename T> 
-	tmat4x2<T> operator+ (
+	GLM_FUNC_DECL tmat4x2<T> operator+ (
 		tmat4x2<T> const & m1, 
 		tmat4x2<T> const & m2);
 
 	template <typename T> 
-	tmat4x2<T> operator- (
+	GLM_FUNC_DECL tmat4x2<T> operator- (
 		tmat4x2<T> const & m, 
 		typename tmat4x2<T>::value_type const & s);
 
 	template <typename T> 
-	tmat4x2<T> operator- (
+	GLM_FUNC_DECL tmat4x2<T> operator- (
 		tmat4x2<T> const & m1, 
 		tmat4x2<T> const & m2);
 
 	template <typename T> 
-	tmat4x2<T> operator* (
+	GLM_FUNC_DECL tmat4x2<T> operator* (
 		tmat4x2<T> const & m, 
 		typename tmat4x2<T>::value_type const & s);
 
 	template <typename T> 
-	tmat4x2<T> operator* (
+	GLM_FUNC_DECL tmat4x2<T> operator* (
 		typename tmat4x2<T>::value_type const & s, 
 		tmat4x2<T> const & m);
 
 	template <typename T>
-	typename tmat4x2<T>::col_type operator* (
+	GLM_FUNC_DECL typename tmat4x2<T>::col_type operator* (
 		tmat4x2<T> const & m, 
 		typename tmat4x2<T>::row_type const & v);
 
 	template <typename T> 
-	typename tmat4x2<T>::row_type operator* (
+	GLM_FUNC_DECL typename tmat4x2<T>::row_type operator* (
 		typename tmat4x2<T>::col_type const & v, 
 		tmat4x2<T> const & m);
 
 	template <typename T>
-	tmat3x2<T> operator* (
+	GLM_FUNC_DECL tmat3x2<T> operator* (
 		tmat4x2<T> const & m1, 
 		tmat3x4<T> const & m2);
 		
 	template <typename T>
-	tmat4x2<T> operator* (
+	GLM_FUNC_DECL tmat4x2<T> operator* (
 		tmat4x2<T> const & m1, 
 		tmat4x4<T> const & m2);
 		
 	template <typename T>
-	tmat2x3<T> operator* (
+	GLM_FUNC_DECL tmat2x3<T> operator* (
 		tmat4x3<T> const & m1, 
 		tmat2x4<T> const & m2);
 
 	template <typename T> 
-	tmat4x2<T> operator/ (
+	GLM_FUNC_DECL tmat4x2<T> operator/ (
 		tmat4x2<T> const & m, 
 		typename tmat4x2<T>::value_type const & s);
 
 	template <typename T> 
-	tmat4x2<T> operator/ (
+	GLM_FUNC_DECL tmat4x2<T> operator/ (
 		typename tmat4x2<T>::value_type const & s, 
 		tmat4x2<T> const & m);
 
 	// Unary constant operators
 	template <typename T> 
-	tmat4x2<T> const operator-  (
+	GLM_FUNC_DECL tmat4x2<T> const operator-  (
 		tmat4x2<T> const & m);
 
 	template <typename T> 
-	tmat4x2<T> const operator-- (
+	GLM_FUNC_DECL tmat4x2<T> const operator-- (
 		tmat4x2<T> const & m, 
 		int);
 
 	template <typename T> 
-	tmat4x2<T> const operator++ (
+	GLM_FUNC_DECL tmat4x2<T> const operator++ (
 		tmat4x2<T> const & m, 
 		int);
 } //namespace detail

glm/core/type_mat4x3.hpp

@@ -126,8 +126,8 @@ namespace detail
 		GLM_FUNC_DECL explicit tmat4x3(tmat3x4<T> 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> & operator=  (tmat4x3<T> const & m);
@@ -154,82 +154,82 @@ namespace detail
 
 	// Binary operators
 	template <typename T> 
-	tmat4x3<T> operator+ (
+	GLM_FUNC_DECL tmat4x3<T> operator+ (
 		tmat4x3<T> const & m, 
 		typename tmat4x3<T>::value_type const & s);
 
 	template <typename T> 
-	tmat4x3<T> operator+ (
+	GLM_FUNC_DECL tmat4x3<T> operator+ (
 		tmat4x3<T> const & m1, 
 		tmat4x3<T> const & m2);
 
 	template <typename T> 
-	tmat4x3<T> operator- (
+	GLM_FUNC_DECL tmat4x3<T> operator- (
 		tmat4x3<T> const & m, 
 		typename tmat4x3<T>::value_type const & s);
 
 	template <typename T> 
-	tmat4x3<T> operator- (
+	GLM_FUNC_DECL tmat4x3<T> operator- (
 		tmat4x3<T> const & m1, 
 		tmat4x3<T> const & m2);
 
 	template <typename T> 
-	tmat4x3<T> operator* (
+	GLM_FUNC_DECL tmat4x3<T> operator* (
 		tmat4x3<T> const & m, 
 		typename tmat4x3<T>::value_type const & s);
 
 	template <typename T> 
-	tmat4x3<T> operator* (
+	GLM_FUNC_DECL tmat4x3<T> operator* (
 		typename tmat4x3<T>::value_type const & s, 
 		tmat4x3<T> const & m);
 
 	template <typename T>
-	typename tmat4x3<T>::col_type operator* (
+	GLM_FUNC_DECL typename tmat4x3<T>::col_type operator* (
 		tmat4x3<T> const & m, 
 		typename tmat4x3<T>::row_type const & v);
 
 	template <typename T> 
-	typename tmat4x3<T>::row_type operator* (
+	GLM_FUNC_DECL typename tmat4x3<T>::row_type operator* (
 		typename tmat4x3<T>::col_type const & v, 
 		tmat4x3<T> const & m);
 
 	template <typename T> 
-	tmat2x3<T> operator* (
+	GLM_FUNC_DECL tmat2x3<T> operator* (
 		tmat4x3<T> const & m1, 
 		tmat2x4<T> const & m2);
 
 	template <typename T> 
-	tmat3x3<T> operator* (
+	GLM_FUNC_DECL tmat3x3<T> operator* (
 		tmat4x3<T> const & m1, 
 		tmat3x4<T> const & m2);
 		
 	template <typename T>
-	tmat4x3<T> operator* (
+	GLM_FUNC_DECL tmat4x3<T> operator* (
 		tmat4x3<T> const & m1, 
 		tmat4x4<T> const & m2);
 
 	template <typename T> 
-	tmat4x3<T> operator/ (
+	GLM_FUNC_DECL tmat4x3<T> operator/ (
 		tmat4x3<T> const & m, 
 		typename tmat4x3<T>::value_type const & s);
 
 	template <typename T> 
-	tmat4x3<T> operator/ (
+	GLM_FUNC_DECL tmat4x3<T> operator/ (
 		typename tmat4x3<T>::value_type const & s, 
 		tmat4x3<T> const & m);
 
 	// Unary constant operators
 	template <typename T> 
-	tmat4x3<T> const operator- (
+	GLM_FUNC_DECL tmat4x3<T> const operator- (
 		tmat4x3<T> const & m);
 
 	template <typename T> 
-	tmat4x3<T> const operator-- (
+	GLM_FUNC_DECL tmat4x3<T> const operator-- (
 		tmat4x3<T> const & m, 
 		int);
 
 	template <typename T> 
-	tmat4x3<T> const operator++ (
+	GLM_FUNC_DECL tmat4x3<T> const operator++ (
 		tmat4x3<T> const & m, 
 		int);
 }//namespace detail

glm/core/type_mat4x4.hpp

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

glm/core/type_vec2.hpp

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

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

@@ -69,77 +69,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> const & v);
+		GLM_FUNC_DECL tvec2();
+		GLM_FUNC_DECL tvec2(tvec2<half> 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> const & r);
+		GLM_FUNC_DECL tvec2(tref2<half> 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);			
+		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> 
-		explicit tvec2(tvec2<U> const & v);
+		GLM_FUNC_DECL explicit tvec2(tvec2<U> const & v);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U> 
-		explicit tvec2(tvec3<U> const & v);
+		GLM_FUNC_DECL explicit tvec2(tvec3<U> const & v);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U> 
-		explicit tvec2(tvec4<U> const & v);
+		GLM_FUNC_DECL explicit tvec2(tvec4<U> const & v);
 
 		//////////////////////////////////////
 		// Unary arithmetic operators
 
-		tvec2<half>& operator= (tvec2<half> const & v);
+		GLM_FUNC_DECL tvec2<half>& operator= (tvec2<half> const & v);
 
-		tvec2<half>& operator+=(half const & s);
-		tvec2<half>& operator+=(tvec2<half> const & v);
-		tvec2<half>& operator-=(half const & s);
-		tvec2<half>& operator-=(tvec2<half> const & v);
-		tvec2<half>& operator*=(half const & s);
-		tvec2<half>& operator*=(tvec2<half> const & v);
-		tvec2<half>& operator/=(half const & s);
-		tvec2<half>& operator/=(tvec2<half> const & v);
-		tvec2<half>& operator++();
-		tvec2<half>& operator--();
+		GLM_FUNC_DECL tvec2<half>& operator+=(half const & s);
+		GLM_FUNC_DECL tvec2<half>& operator+=(tvec2<half> const & v);
+		GLM_FUNC_DECL tvec2<half>& operator-=(half const & s);
+		GLM_FUNC_DECL tvec2<half>& operator-=(tvec2<half> const & v);
+		GLM_FUNC_DECL tvec2<half>& operator*=(half const & s);
+		GLM_FUNC_DECL tvec2<half>& operator*=(tvec2<half> const & v);
+		GLM_FUNC_DECL tvec2<half>& operator/=(half const & s);
+		GLM_FUNC_DECL tvec2<half>& operator/=(tvec2<half> const & v);
+		GLM_FUNC_DECL tvec2<half>& operator++();
+		GLM_FUNC_DECL tvec2<half>& operator--();
 
 		//////////////////////////////////////
 		// Swizzle operators
 
-		half swizzle(comp X) const;
-		tvec2<half> swizzle(comp X, comp Y) const;
-		tvec3<half> swizzle(comp X, comp Y, comp Z) const;
-		tvec4<half> swizzle(comp X, comp Y, comp Z, comp W) const;
-		tref2<half> swizzle(comp X, comp Y);
+		GLM_FUNC_DECL half swizzle(comp X) const;
+		GLM_FUNC_DECL tvec2<half> swizzle(comp X, comp Y) const;
+		GLM_FUNC_DECL tvec3<half> swizzle(comp X, comp Y, comp Z) const;
+		GLM_FUNC_DECL tvec4<half> swizzle(comp X, comp Y, comp Z, comp W) const;
+		GLM_FUNC_DECL tref2<half> swizzle(comp X, comp Y);
 	};
 
 	template <>
@@ -162,22 +162,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> const & v);
+		GLM_FUNC_DECL tvec3();
+		GLM_FUNC_DECL tvec3(tvec3<half> 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);
@@ -185,58 +185,58 @@ namespace detail
 		//////////////////////////////////////
 		// Swizzle constructors
 
-		tvec3(tref3<half> const & r);
+		GLM_FUNC_DECL tvec3(tref3<half> 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> 
-		explicit tvec3(tvec2<A> const & v, B const & s);
+		GLM_FUNC_DECL explicit tvec3(tvec2<A> 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> 
-		explicit tvec3(A const & s, tvec2<B> const & v);
+		GLM_FUNC_DECL explicit tvec3(A const & s, tvec2<B> const & v);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U> 
-		explicit tvec3(tvec3<U> const & v);
+		GLM_FUNC_DECL explicit tvec3(tvec3<U> const & v);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U> 
-		explicit tvec3(tvec4<U> const & v);
+		GLM_FUNC_DECL explicit tvec3(tvec4<U> const & v);
 
 		//////////////////////////////////////
 		// Unary arithmetic operators
 
-		tvec3<half>& operator= (tvec3<half> const & v);
+		GLM_FUNC_DECL tvec3<half>& operator= (tvec3<half> const & v);
 
-		tvec3<half>& operator+=(half const & s);
-		tvec3<half>& operator+=(tvec3<half> const & v);
-		tvec3<half>& operator-=(half const & s);
-		tvec3<half>& operator-=(tvec3<half> const & v);
-		tvec3<half>& operator*=(half const & s);
-		tvec3<half>& operator*=(tvec3<half> const & v);
-		tvec3<half>& operator/=(half const & s);
-		tvec3<half>& operator/=(tvec3<half> const & v);
-		tvec3<half>& operator++();
-		tvec3<half>& operator--();
+		GLM_FUNC_DECL tvec3<half>& operator+=(half const & s);
+		GLM_FUNC_DECL tvec3<half>& operator+=(tvec3<half> const & v);
+		GLM_FUNC_DECL tvec3<half>& operator-=(half const & s);
+		GLM_FUNC_DECL tvec3<half>& operator-=(tvec3<half> const & v);
+		GLM_FUNC_DECL tvec3<half>& operator*=(half const & s);
+		GLM_FUNC_DECL tvec3<half>& operator*=(tvec3<half> const & v);
+		GLM_FUNC_DECL tvec3<half>& operator/=(half const & s);
+		GLM_FUNC_DECL tvec3<half>& operator/=(tvec3<half> const & v);
+		GLM_FUNC_DECL tvec3<half>& operator++();
+		GLM_FUNC_DECL tvec3<half>& operator--();
 
 		//////////////////////////////////////
 		// Swizzle operators
 
-		half swizzle(comp X) const;
-		tvec2<half> swizzle(comp X, comp Y) const;
-		tvec3<half> swizzle(comp X, comp Y, comp Z) const;
-		tvec4<half> swizzle(comp X, comp Y, comp Z, comp W) const;
-		tref3<half> swizzle(comp X, comp Y, comp Z);
+		GLM_FUNC_DECL half swizzle(comp X) const;
+		GLM_FUNC_DECL tvec2<half> swizzle(comp X, comp Y) const;
+		GLM_FUNC_DECL tvec3<half> swizzle(comp X, comp Y, comp Z) const;
+		GLM_FUNC_DECL tvec4<half> swizzle(comp X, comp Y, comp Z, comp W) const;
+		GLM_FUNC_DECL tref3<half> swizzle(comp X, comp Y, comp Z);
 	};
 
 	template <>
@@ -259,22 +259,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
 
-		tvec4();
-		tvec4(tvec4<half> const & v);
+		GLM_FUNC_DECL tvec4();
+		GLM_FUNC_DECL tvec4(tvec4<half> 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, 
@@ -283,67 +283,67 @@ namespace detail
 		//////////////////////////////////////
 		// Swizzle constructors
 
-		tvec4(tref4<half> const & r);
+		GLM_FUNC_DECL tvec4(tref4<half> 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> 
-		explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
+		GLM_FUNC_DECL explicit tvec4(tvec2<A> 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> 
-		explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
+		GLM_FUNC_DECL explicit tvec4(A const & s1, tvec2<B> 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> 
-		explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
+		GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B> 
-		explicit tvec4(tvec3<A> const & v, B const & s);
+		GLM_FUNC_DECL explicit tvec4(tvec3<A> 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> 
-		explicit tvec4(A const & s, tvec3<B> const & v);
+		GLM_FUNC_DECL explicit tvec4(A const & s, tvec3<B> const & v);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B> 
-		explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
+		GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
 		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U> 
-		explicit tvec4(tvec4<U> const & v);
+		GLM_FUNC_DECL explicit tvec4(tvec4<U> const & v);
 
 		//////////////////////////////////////
 		// Unary arithmetic operators
 
-		tvec4<half>& operator= (tvec4<half> const & v);
+		GLM_FUNC_DECL tvec4<half>& operator= (tvec4<half> const & v);
 
-		tvec4<half>& operator+=(half const & s);
-		tvec4<half>& operator+=(tvec4<half> const & v);
-		tvec4<half>& operator-=(half const & s);
-		tvec4<half>& operator-=(tvec4<half> const & v);
-		tvec4<half>& operator*=(half const & s);
-		tvec4<half>& operator*=(tvec4<half> const & v);
-		tvec4<half>& operator/=(half const & s);
-		tvec4<half>& operator/=(tvec4<half> const & v);
-		tvec4<half>& operator++();
-		tvec4<half>& operator--();
+		GLM_FUNC_DECL tvec4<half>& operator+=(half const & s);
+		GLM_FUNC_DECL tvec4<half>& operator+=(tvec4<half> const & v);
+		GLM_FUNC_DECL tvec4<half>& operator-=(half const & s);
+		GLM_FUNC_DECL tvec4<half>& operator-=(tvec4<half> const & v);
+		GLM_FUNC_DECL tvec4<half>& operator*=(half const & s);
+		GLM_FUNC_DECL tvec4<half>& operator*=(tvec4<half> const & v);
+		GLM_FUNC_DECL tvec4<half>& operator/=(half const & s);
+		GLM_FUNC_DECL tvec4<half>& operator/=(tvec4<half> const & v);
+		GLM_FUNC_DECL tvec4<half>& operator++();
+		GLM_FUNC_DECL tvec4<half>& operator--();
 
 		//////////////////////////////////////
 		// Swizzle operators
 
-		half swizzle(comp X) const;
-		tvec2<half> swizzle(comp X, comp Y) const;
-		tvec3<half> swizzle(comp X, comp Y, comp Z) const;
-		tvec4<half> swizzle(comp X, comp Y, comp Z, comp W) const;
-		tref4<half> swizzle(comp X, comp Y, comp Z, comp W);
+		GLM_FUNC_DECL half swizzle(comp X) const;
+		GLM_FUNC_DECL tvec2<half> swizzle(comp X, comp Y) const;
+		GLM_FUNC_DECL tvec3<half> swizzle(comp X, comp Y, comp Z) const;
+		GLM_FUNC_DECL tvec4<half> swizzle(comp X, comp Y, comp Z, comp W) const;
+		GLM_FUNC_DECL tref4<half> swizzle(comp X, comp Y, comp Z, comp W);
 	};
 #endif//(GLM_COMPONENT == GLM_COMPONENT_CXX98)
 }
@@ -418,19 +418,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
@@ -444,7 +444,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