Merge branch '0.9.1' of ssh://ogl-math.git.sourceforge.net/gitroot/ogl-math/ogl-math into 0.9.1

glm/core/func_integer.inl

@@ -274,7 +274,7 @@ namespace glm
 				Result |= (1 << (sizeof(genIUType) * 8 - 1)) & (1 << (Offset + Bits - 1));
 
 			genIUType Mask = 0;
-			for(std::size_t Bit = Offset; Bit < Bits; ++Bit)
+			for(int Bit = Offset; Bit < Bits; ++Bit)
 				Mask |= (1 << Bit);
 
 			return Result | ((Mask & Value) >> Offset);
@@ -339,7 +339,7 @@ namespace glm
 				return Base;
 
 			genIUType Mask = 0;
-			for(std::size_t Bit = Offset; Bit < Offset + Bits; ++Bit)
+			for(int Bit = Offset; Bit < Offset + Bits; ++Bit)
 				Mask |= (1 << Bit);
 
 			return (Base & ~Mask) | (Insert & Mask);

glm/core/setup.hpp

@@ -401,21 +401,4 @@
 #	endif
 #endif//GLM_MESSAGE
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Precision
-
-#define GLM_PRECISION_NONE			0x00000000
-
-#define GLM_PRECISION_LOWP_FLOAT	0x00000011
-#define GLM_PRECISION_MEDIUMP_FLOAT	0x00000012
-#define GLM_PRECISION_HIGHP_FLOAT	0x00000013	
-
-#define GLM_PRECISION_LOWP_INT		0x00001100
-#define GLM_PRECISION_MEDIUMP_INT	0x00001200
-#define GLM_PRECISION_HIGHP_INT		0x00001300
-
-#define GLM_PRECISION_LOWP_UINT		0x00110000
-#define GLM_PRECISION_MEDIUMP_UINT	0x00120000
-#define GLM_PRECISION_HIGHP_UINT	0x00130000	
-
 #endif//glm_setup

glm/core/type.hpp

@@ -38,7 +38,7 @@ namespace type
 	//////////////////////////
 	// Float definition
 
-#if(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_HIGHP_FLOAT)
+#if(defined(GLM_PRECISION_HIGHP_FLOAT))
 	typedef precision::highp_vec2		vec2;
 	typedef precision::highp_vec3		vec3;
 	typedef precision::highp_vec4		vec4;
@@ -51,7 +51,7 @@ namespace type
 	typedef precision::highp_mat4x2		mat4x2;
 	typedef precision::highp_mat4x3		mat4x3;
 	typedef precision::highp_mat4x4		mat4x4;
-#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_MEDIUMP_FLOAT)
+#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
 	typedef precision::mediump_vec2		vec2;
 	typedef precision::mediump_vec3		vec3;
 	typedef precision::mediump_vec4		vec4;
@@ -64,7 +64,7 @@ namespace type
 	typedef precision::mediump_mat4x2	mat4x2;
 	typedef precision::mediump_mat4x3	mat4x3;
 	typedef precision::mediump_mat4x4	mat4x4;
-#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_LOWP_FLOAT)
+#elif(defined(GLM_PRECISION_LOWP_FLOAT))
 	typedef precision::lowp_vec2			vec2;
 	typedef precision::lowp_vec3			vec3;
 	typedef precision::lowp_vec4			vec4;
@@ -158,15 +158,15 @@ namespace type
 	//////////////////////////
 	// Signed integer definition
 
-#if(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_HIGHP_INT)
+#if(defined(GLM_PRECISION_HIGHP_INT))
 	typedef precision::highp_ivec2			ivec2;
 	typedef precision::highp_ivec3			ivec3;
 	typedef precision::highp_ivec4			ivec4;
-#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_MEDIUMP_INT)
+#elif(defined(GLM_PRECISION_MEDIUMP_INT))
 	typedef precision::mediump_ivec2		ivec2;
 	typedef precision::mediump_ivec3		ivec3;
 	typedef precision::mediump_ivec4		ivec4;
-#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_LOWP_INT)
+#elif(defined(GLM_PRECISION_LOWP_INT))
 	typedef precision::lowp_ivec2			ivec2;
 	typedef precision::lowp_ivec3			ivec3;
 	typedef precision::lowp_ivec4			ivec4;
@@ -190,15 +190,15 @@ namespace type
 	//////////////////////////
 	// Unsigned integer definition
 
-#if(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_HIGHP_UINT)
+#if(defined(GLM_PRECISION_HIGHP_UINT))
 	typedef precision::highp_uvec2			uvec2;
 	typedef precision::highp_uvec3			uvec3;
 	typedef precision::highp_uvec4			uvec4;
-#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_MEDIUMP_UINT)
+#elif(defined(GLM_PRECISION_MEDIUMP_UINT))
 	typedef precision::mediump_uvec2		uvec2;
 	typedef precision::mediump_uvec3		uvec3;
 	typedef precision::mediump_uvec4		uvec4;
-#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_LOWP_UINT)
+#elif(defined(GLM_PRECISION_LOWP_UINT))
 	typedef precision::lowp_uvec2			uvec2;
 	typedef precision::lowp_uvec3			uvec3;
 	typedef precision::lowp_uvec4			uvec4;

glm/core/type_float.hpp

@@ -46,7 +46,7 @@ namespace glm
 		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification
 		//! \ingroup core_precision
-		typedef mediump_float_t		mediump_float;
+		typedef mediump_float_t	mediump_float;
 		//! High precision floating-point numbers.
 		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification
@@ -55,18 +55,17 @@ namespace glm
 	}
 	//namespace precision
 
-#ifndef GLM_PRECISION 
-	typedef precision::mediump_float		float_t;
-#elif(GLM_PRECISION & GLM_PRECISION_HIGHP_FLOAT)
-	typedef precision::highp_float			float_t;
-#elif(GLM_PRECISION & GLM_PRECISION_MEDIUMP_FLOAT)
-	typedef precision::mediump_float		float_t;
-#elif(GLM_PRECISION & GLM_PRECISION_LOWP_FLOAT)
-	typedef precision::lowp_float			float_t;
+#if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef precision::mediump_float				float_t;
+#elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef precision::highp_float				float_t;
+#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef precision::mediump_float				float_t;
+#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef precision::lowp_float					float_t;
 #else
-	#	pragma message("GLM message: Precisson undefined for float numbers.");
-	typedef precision::mediump_float		float_t;
-#endif//GLM_PRECISION
+#	error "GLM error: multiple default precision requested for floating-point types"
+#endif
 
 	}//namespace type
 	}//namespace core

glm/core/type_int.hpp

@@ -54,7 +54,7 @@ namespace glm
 		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification.
 		//! \ingroup core_precision
-		typedef detail::mediump_int_t			mediump_int;
+		typedef detail::mediump_int_t				mediump_int;
 		//! High precision signed integer.
 		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification.
@@ -75,35 +75,33 @@ namespace glm
 		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification.
 		//! \ingroup core_precision
-		typedef detail::highp_uint_t			highp_uint;
+		typedef detail::highp_uint_t				highp_uint;
 	}
 	//namespace precision
 
-#ifndef GLM_PRECISION 
+#if(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
 	typedef precision::mediump_int				int_t;
-#elif(GLM_PRECISION & GLM_PRECISION_HIGHP_INT)
-	typedef precision::highp_int				int_t;
-#elif(GLM_PRECISION & GLM_PRECISION_MEDIUMP_INT)
+#elif(defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
+	typedef precision::highp_int					int_t;
+#elif(!defined(GLM_PRECISION_HIGHP_INT) && defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
 	typedef precision::mediump_int				int_t;
-#elif(GLM_PRECISION & GLM_PRECISION_LOWP_INT)
+#elif(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && defined(GLM_PRECISION_LOWP_INT))
 	typedef precision::lowp_int					int_t;
 #else
-	typedef precision::mediump_int							int_t;
-#	pragma message("GLM message: Precisson undefined for signed integer number.");
-#endif//GLM_PRECISION
+#	error "GLM error: multiple default precision requested for signed interger types"
+#endif
 
-#ifndef GLM_PRECISION 
+#if(!defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
 	typedef precision::mediump_uint				uint_t;
-#elif(GLM_PRECISION & GLM_PRECISION_HIGHP_UINT)
-	typedef precision::highp_uint				uint_t;
-#elif(GLM_PRECISION & GLM_PRECISION_MEDIUMP_UINT)
+#elif(defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
+	typedef precision::highp_uint					uint_t;
+#elif(!defined(GLM_PRECISION_HIGHP_UINT) && defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
 	typedef precision::mediump_uint				uint_t;
-#elif(GLM_PRECISION & GLM_PRECISION_LOWP_UINT)
-	typedef precision::lowp_uint				uint_t;
+#elif(!defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && defined(GLM_PRECISION_LOWP_UINT))
+	typedef precision::lowp_uint					uint_t;
 #else
-	typedef precision::mediump_uint				uint_t;
-#	pragma message("GLM message: Precisson undefined for unsigned integer number.");
-#endif//GLM_PRECISION
+#	error "GLM error: multiple default precision requested for unsigned interger types"
+#endif
 
 	//! Unsigned integer. 
 	//! From GLSL 1.30.8 specification section 4.1.3 Integers.

glm/gtc/matrix_integer.hpp

@@ -117,11 +117,10 @@ namespace glm
 		typedef detail::tmat4x3<lowp_uint>				lowp_umat4x3; //!< \brief Low-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef detail::tmat4x4<lowp_uint>				lowp_umat4x4; //!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
 
-#if(defined(GLM_PRECISION) && (GLM_PRECISION & GLM_PRECISION_HIGHP_INT))
+#if(defined(GLM_PRECISION_HIGHP_INT))
 		typedef highp_imat2								imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef highp_imat3								imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef highp_imat4								imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-
 		typedef highp_imat2x2							imat2x2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef highp_imat2x3							imat2x3; //!< \brief Signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef highp_imat2x4							imat2x4; //!< \brief Signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
@@ -131,8 +130,7 @@ namespace glm
 		typedef highp_imat4x2							imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef highp_imat4x3							imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef highp_imat4x4							imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-
-#elif(defined(GLM_PRECISION) && (GLM_PRECISION & GLM_PRECISION_LOWP_INT))
+#elif(defined(GLM_PRECISION_LOWP_INT))
 		typedef lowp_imat2								imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef lowp_imat3								imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef lowp_imat4								imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
@@ -145,8 +143,7 @@ namespace glm
 		typedef lowp_imat4x2							imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef lowp_imat4x3							imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef lowp_imat4x4							imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-
-#else //if(defined(GLM_PRECISION) && (GLM_PRECISION & GLM_PRECISION_MEDIUMP_INT))
+#else //if(defined(GLM_PRECISION_MEDIUMP_INT))
 		typedef mediump_imat2							imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef mediump_imat3							imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef mediump_imat4							imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
@@ -161,7 +158,7 @@ namespace glm
 		typedef mediump_imat4x4							imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
 #endif//GLM_PRECISION
 
-#if(defined(GLM_PRECISION) && (GLM_PRECISION & GLM_PRECISION_HIGHP_UINT))
+#if(defined(GLM_PRECISION_HIGHP_UINT))
 		typedef highp_umat2								umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef highp_umat3								umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef highp_umat4								umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
@@ -174,8 +171,7 @@ namespace glm
 		typedef highp_umat4x2							umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef highp_umat4x3							umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef highp_umat4x4							umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-
-#elif(defined(GLM_PRECISION) && (GLM_PRECISION & GLM_PRECISION_LOWP_UINT))
+#elif(defined(GLM_PRECISION_LOWP_UINT))
 		typedef lowp_umat2								umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef lowp_umat3								umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef lowp_umat4								umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
@@ -188,8 +184,7 @@ namespace glm
 		typedef lowp_umat4x2							umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef lowp_umat4x3							umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef lowp_umat4x4							umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-
-#else //if(defined(GLM_PRECISION) && (GLM_PRECISION & GLM_PRECISION_MEDIUMP_UINT))
+#else //if(defined(GLM_PRECISION_MEDIUMP_UINT))
 		typedef mediump_umat2							umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef mediump_umat3							umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef mediump_umat4							umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)

glm/gtc/matrix_transform.inl

@@ -359,7 +359,7 @@ namespace matrix_transform
 
 		// Translate and scale the picked region to the entire window
 		Result = translate(Result, Temp);
-		return scale(Result, T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1));
+		return scale(Result, detail::tvec3<T>(T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1)));
 	}
 
     template <typename T> 

glm/gtx/vec1.hpp

@@ -80,11 +80,11 @@ namespace glm
 		//! From GLM_GTX_vec1 extension.
 		typedef detail::tvec1<bool>	bvec1;
 
-#if(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_HIGHP_FLOAT)
+#if(defined(GLM_PRECISION_HIGHP_FLOAT))
 		typedef precision::highp_vec1			vec1;
-#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_MEDIUMP_FLOAT)
+#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
 		typedef precision::mediump_vec1			vec1;
-#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_LOWP_FLOAT)
+#elif(defined(GLM_PRECISION_LOWP_FLOAT))
 		typedef precision::lowp_vec1			vec1;
 #else
 		//! 1 component vector of floating-point numbers.
@@ -92,11 +92,11 @@ namespace glm
 		typedef precision::mediump_vec1			vec1;
 #endif//GLM_PRECISION
 
-#if(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_HIGHP_INT)
+#if(defined(GLM_PRECISION_HIGHP_INT))
 		typedef precision::highp_ivec1			ivec1;
-#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_MEDIUMP_INT)
+#elif(defined(GLM_PRECISION_MEDIUMP_INT))
 		typedef precision::mediump_ivec1		ivec1;
-#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_LOWP_INT)
+#elif(defined(GLM_PRECISION_LOWP_INT))
 		typedef precision::lowp_ivec1			ivec1;
 #else
 		//! 1 component vector of signed integer numbers. 
@@ -104,11 +104,11 @@ namespace glm
 		typedef precision::mediump_ivec1		ivec1;
 #endif//GLM_PRECISION
 
-#if(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_HIGHP_UINT)
+#if(defined(GLM_PRECISION_HIGHP_UINT))
 		typedef precision::highp_uvec1			uvec1;
-#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_MEDIUMP_UINT)
+#elif(defined(GLM_PRECISION_MEDIUMP_UINT))
 		typedef precision::mediump_uvec1		uvec1;
-#elif(defined(GLM_PRECISION) && GLM_PRECISION & GLM_PRECISION_LOWP_UINT)
+#elif(defined(GLM_PRECISION_LOWP_UINT))
 		typedef precision::lowp_uvec1			uvec1;
 #else
 		//! 1 component vector of unsigned integer numbers. 

test/core/core_type_mat4x4.cpp

@@ -8,6 +8,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #define GLM_MESSAGES
+#define GLM_PRECISION_HIGHP_FLOAT
 #include <glm/glm.hpp>
 #include <cstdio>
 

test/gtc/CMakeLists.txt

@@ -1,2 +1,9 @@
-glmCreateTestGTC(gtc-integer-matrix)
-glmCreateTestGTC(gtc-swizzle)
+glmCreateTestGTC(gtc_half_float)
+glmCreateTestGTC(gtc_matrix_access)
+glmCreateTestGTC(gtc_matrix_integer)
+glmCreateTestGTC(gtc_matrix_inverse)
+glmCreateTestGTC(gtc_matrix_transform)
+glmCreateTestGTC(gtc_quaternion)
+glmCreateTestGTC(gtc_swizzle)
+glmCreateTestGTC(gtc_type_precision)
+glmCreateTestGTC(gtc_type_ptr)

test/gtc/gtc_half_float.cpp

@@ -0,0 +1,19 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-09-16
+// Updated : 2010-09-16
+// Licence : This source is under MIT licence
+// File    : test/gtc/matrix_transform.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#define GLM_MESSAGES
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+int main()
+{
+	int Failed = 0;
+
+	return Failed;
+}

test/gtc/gtc_matrix_access.cpp

@@ -0,0 +1,19 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-09-16
+// Updated : 2010-09-16
+// Licence : This source is under MIT licence
+// File    : test/gtc/matrix_transform.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#define GLM_MESSAGES
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+int main()
+{
+	int Failed = 0;
+
+	return Failed;
+}

test/gtc/gtc-integer-matrix.cpp → test/gtc/gtc_matrix_integer.cpp

@@ -4,26 +4,16 @@
 // Created : 2010-09-16
 // Updated : 2010-09-16
 // Licence : This source is under MIT licence
-// File    : test/gtx/simd-mat4.cpp
+// File    : test/gtc/matrix_integer.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #define GLM_MESSAGES
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_integer.hpp>
 
-int test_int_matrix()
-{
-	{
-		glm::mediump_uint A(0);
-	}
-
-	return 0;
-}
-
 int main()
 {
 	int Failed = 0;
-	Failed += test_int_matrix();
 
 	return Failed;
 }

test/gtc/gtc_matrix_inverse.cpp

@@ -0,0 +1,19 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-09-16
+// Updated : 2010-09-16
+// Licence : This source is under MIT licence
+// File    : test/gtc/matrix_transform.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#define GLM_MESSAGES
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+int main()
+{
+	int Failed = 0;
+
+	return Failed;
+}

test/gtc/gtc_matrix_transform.cpp

@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-09-16
+// Updated : 2010-09-16
+// Licence : This source is under MIT licence
+// File    : test/gtc/matrix_transform.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#define GLM_MESSAGES
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+int main()
+{
+	int Failed = 0;
+	
+	glm::mat4 Pick = glm::pickMatrix(glm::vec2(1, 2), glm::vec2(3, 4), glm::ivec4(0, 0, 320, 240));
+
+	return Failed;
+}

test/gtc/gtc_quaternion.cpp

@@ -0,0 +1,19 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-09-16
+// Updated : 2010-09-16
+// Licence : This source is under MIT licence
+// File    : test/gtc/matrix_transform.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#define GLM_MESSAGES
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+int main()
+{
+	int Failed = 0;
+
+	return Failed;
+}

test/gtc/gtc-swizzle.cpp → test/gtc/gtc_swizzle.cpp

@@ -4,7 +4,7 @@
 // Created : 2010-09-16
 // Updated : 2010-09-16
 // Licence : This source is under MIT licence
-// File    : test/gtx/simd-mat4.cpp
+// File    : test/gtc/swizzle.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #define GLM_MESSAGES

test/gtc/gtc_type_precision.cpp

@@ -0,0 +1,19 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-09-16
+// Updated : 2010-09-16
+// Licence : This source is under MIT licence
+// File    : test/gtc/matrix_transform.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#define GLM_MESSAGES
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+int main()
+{
+	int Failed = 0;
+
+	return Failed;
+}

test/gtc/gtc_type_ptr.cpp

@@ -0,0 +1,19 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-09-16
+// Updated : 2010-09-16
+// Licence : This source is under MIT licence
+// File    : test/gtc/matrix_transform.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#define GLM_MESSAGES
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+int main()
+{
+	int Failed = 0;
+
+	return Failed;
+}