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

copying.txt

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2005 - 2010 G-Truc Creation
+Copyright (c) 2005 - 2011 G-Truc Creation
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

doc/CMakeLists.txt

@@ -1,6 +1,6 @@
 set(NAME glm-doc)
 
-file(GLOB ROOT_TXT doxyfile ../*.txt)
+file(GLOB ROOT_TXT *.doxy ../*.txt)
 file(GLOB ROOT_CPP src/*.cpp)
 file(GLOB ROOT_XML src/*.xml)
 file(GLOB ROOT_XSL src/*.xsl)

doc/coreModules.doxy

@@ -0,0 +1,64 @@
+/*!
+	\defgroup core GLM Core
+	
+	\brief The core of GLM, which implements exactly and only the GLSL specification to the degree possible.
+	
+	The GLM core consists of \ref core_types "C++ types that mirror GLSL types",
+	\ref core_funcs "C++ functions that mirror the GLSL functions". It also includes 
+	\ref core_precision "a set of precision-based types" that can be used in the appropriate
+	functions. The C++ types are all based on a basic set of \ref core_template "template types".
+	
+	The best documentation for GLM Core is the current GLSL specification,
+	<a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.10.6.clean.pdf">version 4.1
+	(pdf file)</a>.
+	There are a few \ref pg_differences "differences" between GLM core and GLSL.
+**/
+
+
+/*!
+	\defgroup core_types Types
+	
+	\brief The standard types defined by the specification.
+	
+	These types are all typedefs of more generalized, template types. To see the definiton
+	of these template types, go to \ref core_template.
+	
+	\ingroup core
+**/
+
+/*!
+	\defgroup core_precision Precision types
+	
+	\brief Non-GLSL types that are used to define precision-based types.
+	
+	The GLSL language allows the user to define the precision of a particular variable.
+	In OpenGL's GLSL, these precision qualifiers have no effect; they are there for compatibility
+	with OpenGL ES's precision qualifiers, where they \em do have an effect.
+	
+	C++ has no language equivalent to precision qualifiers. So GLM provides the next-best thing:
+	a number of typedefs of the \ref core_template that use a particular precision.
+	
+	None of these types make any guarantees about the actual precision used.
+	
+	\ingroup core
+**/
+
+/*!
+	\defgroup core_template Template types
+	
+	\brief The generic template types used as the basis for the core types. 
+	
+	These types are all templates used to define the actual \ref core_types.
+	These templetes are implementation details of GLM types and should not be used explicitly.
+
+	\ingroup core
+**/
+
+/*!
+	\defgroup core_funcs Functions
+	
+	\brief The functions defined by the specification.
+
+	\ingroup core
+**/
+

doc/gtcModules.doxy

@@ -0,0 +1,108 @@
+/*!
+	\defgroup gtc GTC Extensions (Stable)
+	
+	\brief Functions and types that the GLSL specification doesn't define, but useful to have for a C++ program.
+	
+	GTC extensions aim to be stable. 
+	
+	Even if it's highly unrecommended, it's possible to include all the extensions at once by
+	including <glm/ext.hpp>. Otherwise, each extension needs to be included  a specific file.
+**/
+
+/*!
+	\defgroup gtc_half_float GLM_GTC_half_float: Half-precision floating-point based types and functions.
+	\ingroup gtc
+	
+	Defines the half-precision floating-point type, along with various typedefs for vectors and matrices.
+	<glm/gtc/half_float.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtc_matrix_access GLM_GTC_matrix_access: Access matrix rows and columns.
+	\ingroup gtc
+	
+	Defines functions to access rows or columns of a matrix easily.
+	<glm/gtc/matrix_access.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtc_matrix_integer GLM_GTC_matrix_integer: Integer matrix types.
+	\ingroup gtc
+	
+	Defines a number of matrices with integer types.
+	<glm/gtc/matrix_integer.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtc_matrix_inverse GLM_GTC_matrix_inverse: Additional matrix inverse function
+	\ingroup gtc
+	
+	Defines additional matrix inverting functions.
+	<glm/gtc/matrix_inverse.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtc_matrix_transform GLM_GTC_matrix_transform: Matrix transform functions.
+	\ingroup gtc
+	
+	\brief Defines functions that generate common transformation matrices.
+	
+	The matrices generated by this extension use standard OpenGL fixed-function
+	conventions. For example, the lookAt function generates a transform from world
+	space into the specific eye space that the projective matrix functions (
+	perspective, ortho, etc) are designed to expect. The OpenGL compatibility
+	specifications defines the particular layout of this eye space.
+	
+	<glm/gtc/matrix_transform.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtc_quaternion GLM_GTC_quaternion: Quaternion types and functions
+	\ingroup gtc
+	
+	\brief Defines a templated quaternion type and several quaternion operations.
+	
+	<glm/gtc/quaternion.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtc_type_precision GLM_GTC_type_precision: Vector and matrix types with defined precisions.
+	\ingroup gtc
+	
+	\brief Defines specific C++-based precision types.
+	
+	\ref core_precision defines types based on GLSL's precision qualifiers. This
+	extension defines types based on explicitly-sized C++ data types.
+	
+	<glm/gtc/type_precision.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtc_type_ptr GLM_GTC_type_ptr: Memory layout access.
+	\ingroup gtc
+	
+	\brief Used to get a pointer to the memory layout of a basic type.
+	
+	This extension defines an overloaded function, glm::value_ptr, which
+	takes any of the \ref core_template "core template types". It returns
+	a pointer to the memory layout of the object. Matrix types store their values
+	in column-major order.
+	
+	This is useful for uploading data to matrices or copying data to buffer objects.
+	
+	Example:
+	
+	\code
+#include <glm/glm.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+glm::vec3 aVector(3);
+glm::mat4 someMatrix(1.0);
+
+glUniform3fv(uniformLoc, 1, glm::value_ptr(aVector));
+glUniformMatrix4fv(uniformMatrixLoc, 1, GL_FALSE, glm::value_ptr(someMatrix));
+	\endcode
+	
+	<glm/gtc/type_ptr.hpp> need to be included to use these functionalities.
+**/
+

doc/gtxModules.doxy

@@ -0,0 +1,498 @@
+/*!
+	\defgroup gtx GTX Extensions (Experimental)
+	
+	\brief Functions and types that the GLSL specification doesn't define, but useful to have for a C++ program.
+	
+	Experimental extensions are useful functions and types, but the development of
+	their API and functionality is not necessarily stable. They can change substantially
+	between versions. Backwards compatibility is not much of an issue for them.
+	
+	Even if it's highly unrecommended, it's possible to include all the extensions at once by
+	including <glm/ext.hpp>. Otherwise, each extension needs to be included  a specific file.
+**/
+
+/*!
+	\defgroup gtx_associated_min_max GLM_GTX_associated_min_max: Associated Min/Max
+	\ingroup gtx
+	
+	\brief Min and max functions that return associated values not the compared onces.
+	<glm/gtx/associated_min_max.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_bit GLM_GTX_bit: Extended bitwise operations
+	\ingroup gtx
+	
+	\brief Allow to perform bit operations on integer values
+
+	<glm/gtx/bit.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_closest_point GLM_GTX_closest_point: Find closest point
+	\ingroup gtx
+	
+	\brief Find the point on a straight line which is the closet of a point.
+
+	<glm/gtx/closest_point.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_color_cast GLM_GTX_color_cast: Color conversion
+	\ingroup gtx
+	
+	\brief Conversion between two color types.
+
+	<glm/gtx/color_cast.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_color_space GLM_GTX_color_space: RGB to HSV conversion
+	\ingroup gtx
+	
+	\brief Related to RGB to HSV conversions and operations.
+
+	<glm/gtx/color_space.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_color_space_YCoCg GLM_GTX_color_space_YCoCg: RGB to YCoCg conversion
+	\ingroup gtx
+	
+	\brief RGB to YCoCg conversions and operations
+
+	<glm/gtx/color_space_YCoCg.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_compatibility GLM_GTX_compatibility: Cg and HLSL compatibility
+	\ingroup gtx
+	
+	\brief Provide functions to increase the compatibility with Cg and HLSL languages
+
+	<glm/gtx/compatibility.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_component_wise GLM_GTX_component_wise: Component wise
+	\ingroup gtx
+	
+	\brief Operations between components of a type
+
+	<glm/gtx/component_wise.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_epsilon GLM_GTX_epsilon: Epsilon comparison
+	\ingroup gtx
+	
+	\brief Comparison functions for a user defined epsilon values.
+
+	<glm/gtx/epsilon.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_euler_angles GLM_GTX_euler_angles: Matrix from euler angles
+	\ingroup gtx
+	
+	\brief Build matrices from Euler angles.
+
+	<glm/gtx/euler_angles.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_extend GLM_GTX_extend: Position extending 
+	\ingroup gtx
+	
+	\brief Extend a position from a source to a position at a defined length.
+
+	<glm/gtx/extend.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_extented_min_max GLM_GTX_extented_min_max: Extended min max
+	\ingroup gtx
+	
+	\brief Min and max functions for 3 to 4 parameters.
+
+	<glm/gtx/extented_min_max.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_fast_exponential GLM_GTX_fast_exponential: Fast exponentiation functions
+	\ingroup gtx
+	
+	\brief Fast but less accurate implementations of exponential based functions.
+
+	<glm/gtx/fast_exponential.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_fast_square_root GLM_GTX_fast_square_root: Fast square root functions
+	\ingroup gtx
+	
+	\brief Fast but less accurate implementations of square root based functions.
+
+	<glm/gtx/fast_square_root.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_fast_trigonometry GLM_GTX_fast_trigonometry: Fast trigonometric functions
+	\ingroup gtx
+	
+	\brief Fast but less accurate implementations of trigonometric functions.
+
+	<glm/gtx/fast_trigonometry.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_handed_coordinate_space GLM_GTX_handed_coordinate_space: Space Handedness
+	\ingroup gtx
+	
+	\brief To know if a set of three basis vectors defines a right or left-handed coordinate system.
+
+	<glm/gtx/handed_coordinate_system.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_inertia GLM_GTX_inertia: Intertial matrix
+	\ingroup gtx
+	
+	\brief Create inertia matrices
+
+	<glm/gtx/inertia.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_int_10_10_10_2 GLM_GTX_int_10_10_10_2: Packed integer
+	\ingroup gtx
+	
+	\brief Pack vector to 1010102 integers. Storage only.
+
+	<glm/gtx/int_10_10_10_2.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_integer GLM_GTX_integer: Extended integer functions
+	\ingroup gtx
+	
+	\brief Add support for integer for core functions
+
+	<glm/gtx/integer.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_intersect GLM_GTX_intersect: Intersection tests
+	\ingroup gtx
+	
+	\brief Add intersection functions
+
+	<glm/gtx/intersect.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_log_base GLM_GTX_log_base: Log with base
+	\ingroup gtx
+	
+	\brief Logarithm for any base. base can be a vector or a scalar.
+
+	<glm/gtx/log_base.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_matrix_cross_product GLM_GTX_matrix_cross_product: Cross product matrix form
+	\ingroup gtx
+	
+	\brief Build cross product matrices
+
+	<glm/gtx/matrix_cross_product.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_matrix_major_storage GLM_GTX_matrix_major_storage: Build matrix
+	\ingroup gtx
+	
+	\brief Build matrices with specific matrix order, row or column
+
+	<glm/gtx/matrix_major_storage.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_matrix_operation GLM_GTX_matrix_operation: Extended matrix operations
+	\ingroup gtx
+	
+	\brief Build diagonal matrices from vectors.
+
+	<glm/gtx/matrix_operation.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_matrix_query GLM_GTX_matrix_query: Query matrix properties
+	\ingroup gtx
+	
+	\brief Query to evaluate matrix properties
+
+	<glm/gtx/matrix_query.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_mixed_product GLM_GTX_mixed_producte: Mixed product
+	\ingroup gtx
+	
+	\brief Mixed product of 3 vectors.
+
+	<glm/gtx/mixed_product.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_multiple GLM_GTX_multiple: Multiples 
+	\ingroup gtx
+	
+	\brief Find the closest number of a number multiple of other number.
+
+	<glm/gtx/multiple.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_norm GLM_GTX_norm: Vector norm calculations
+	\ingroup gtx
+	
+	\brief Various way to compute vector norms.
+
+	<glm/gtx/norm.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_normal GLM_GTX_normal: Compute normals
+	\ingroup gtx
+	
+	\brief Compute the normal of a triangle.
+
+	<glm/gtx/normal.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_normalize_dot GLM_GTX_normalize_dot: Normalize dot product
+	\ingroup gtx
+	
+	\brief Dot product of vectors that need to be normalize with a single square root.
+
+	<glm/gtx/normalized_dot.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_number_precision GLM_GTX_number_precision: Number precision
+	\ingroup gtx
+	
+	\brief Defined size types.
+
+	<glm/gtx/number_precision.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_ocl_type GLM_GTX_ocl_type: OpenCL types
+	\ingroup gtx
+	
+	\brief OpenCL types.
+
+	<glm/gtx/ocl_type.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_optimum_pow GLM_GTX_optimum_pow: Optimum pow
+	\ingroup gtx
+	
+	\brief Integer exponentiation of power functions.
+
+	<glm/gtx/optimum_pow.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_orthonormalize GLM_GTX_orthonormalize: Orthonormalize
+	\ingroup gtx
+	
+	\brief Orthonormalize matrices.
+
+	<glm/gtx/orthonormalize.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_perpendicular GLM_GTX_perpendicular: Perpendicular
+	\ingroup gtx
+	
+	\brief Perpendicular of a vector from other one
+
+	<glm/gtx/perpendicular.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_polar_coordinates GLM_GTX_polar_coordinates: Polar coordinates
+	\ingroup gtx
+	
+	\brief Conversion from Euclidean space to polar space and revert.
+
+	<glm/gtx/polar_coordinates.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_projection GLM_GTX_projection: Projection
+	\ingroup gtx
+	
+	\brief Projection of a vector to other one
+
+	<glm/gtx/projection.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_quaternion GLM_GTX_quaternion: Extented quaternion types and functions
+	\ingroup gtx
+	
+	\brief Extented quaternion types and functions
+
+	<glm/gtx/quaternion.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_random GLM_GTX_random: Random
+	\ingroup gtx
+	
+	\brief Generate random number from various distribution methods
+
+	<glm/gtx/random.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_raw_data GLM_GTX_raw_data: Raw data
+	\ingroup gtx
+	
+	\brief Projection of a vector to other one
+
+	<glm/gtx/raw_data.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_reciprocal GLM_GTX_reciprocal: Reciprocal
+	\ingroup gtx
+	
+	\brief Define secant, cosecant and cotangent functions.
+
+	<glm/gtx/reciprocal.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_rotate_vector GLM_GTX_rotate_vector: Rotate vector
+	\ingroup gtx
+	
+	\brief Function to directly rotate a vector
+
+	<glm/gtx/rotate_vector.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_simd_mat4 GLM_GTX_simd_mat4: SIMD mat4 type and functions
+	\ingroup gtx
+	
+	\brief SIMD implementation of mat4 type.
+
+	<glm/gtx/simd_mat4.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_simd_vec4 GLM_GTX_simd_vec4: SIMD vec4 type and functions
+	\ingroup gtx
+	
+	\brief SIMD implementation of vec4 type.
+
+	<glm/gtx/simd_vec4.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_spline GLM_GTX_spline: Spline
+	\ingroup gtx
+	
+	\brief Spline functions
+
+	<glm/gtx/spline.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_string_cast GLM_GTX_string_cast: String cast
+	\ingroup gtx
+	
+	\brief Setup strings for GLM type values
+
+	<glm/gtx/string_cast.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_transform GLM_GTX_transform: Extented transformation matrices
+	\ingroup gtx
+	
+	\brief Add transformation matrices
+
+	<glm/gtx/transform.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_transform2 GLM_GTX_transform2: Extra transformation matrices
+	\ingroup gtx
+	
+	\brief Add extra transformation matrices
+
+	<glm/gtx/transform2.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_unsigned_int GLM_GTX_unsigned_int: Unsigned int
+	\ingroup gtx
+	
+	\brief Add support for unsigned integer for core functions
+
+	<glm/gtx/unsigned_int.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_vector_access GLM_GTX_vector_angle: Vector access
+	\ingroup gtx
+	
+	\brief Function to set values to vectors
+
+	<glm/gtx/vector_access.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_vector_angle GLM_GTX_vector_angle: Vector angle
+	\ingroup gtx
+	
+	\brief Compute angle between vectors
+
+	<glm/gtx/vector_angle.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_vector_query GLM_GTX_vector_query: Vector query
+	\ingroup gtx
+	
+	\brief Query informations of vector types
+
+	<glm/gtx/vector_query.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_verbose_operator GLM_GTX_verbose_operator: Verbose operator
+	\ingroup gtx
+	
+	\brief Use words to replace operators
+
+	<glm/gtx/verbose_operator.hpp> need to be included to use these functionalities.
+**/
+
+/*!
+	\defgroup gtx_wrap GLM_GTX_wrap: Texture coordinate wrap modes
+	\ingroup gtx
+	
+	\brief Wrapping mode of texture coordinates.
+
+	<glm/gtx/wrap.hpp> need to be included to use these functionalities.
+**/
+

doc/man.doxy

@@ -1,4 +1,4 @@
-# Doxyfile 1.6.2
+# Doxyfile 1.7.3
 
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project
@@ -25,13 +25,26 @@ DOXYFILE_ENCODING      = UTF-8
 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded 
 # by quotes) that should identify the project.
 
-PROJECT_NAME           = GLM
+PROJECT_NAME           = 
 
 # The PROJECT_NUMBER tag can be used to enter a project or revision number. 
 # This could be handy for archiving the generated documentation or 
 # if some version control system is used.
 
-PROJECT_NUMBER         = "Version 0.9.0"
+PROJECT_NUMBER         = 0.9.1
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer
+# a quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF          = 
+
+# With the PROJECT_LOGO tag one can specify an logo or icon that is 
+# included in the documentation. The maximum height of the logo should not 
+# exceed 55 pixels and the maximum width should not exceed 200 pixels. 
+# Doxygen will copy the logo to the output directory.
+
+PROJECT_LOGO           = D:/g-truc/git/ogl-math/doc/image/logo-mini.png
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
 # base path where the generated documentation will be put. 
@@ -57,7 +70,7 @@ CREATE_SUBDIRS         = NO
 # Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German, 
 # Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English 
 # messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, 
-# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak, 
+# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak, 
 # Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
 
 OUTPUT_LANGUAGE        = English
@@ -136,7 +149,7 @@ STRIP_FROM_PATH        = "C:/Documents and Settings/Groove/       "
 STRIP_FROM_INC_PATH    = 
 
 # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter 
-# (but less readable) file names. This can be useful is your file systems 
+# (but less readable) file names. This can be useful if your file system 
 # doesn't support long names like on DOS, Mac, or CD-ROM.
 
 SHORT_NAMES            = YES
@@ -217,15 +230,15 @@ OPTIMIZE_FOR_FORTRAN   = NO
 
 OPTIMIZE_OUTPUT_VHDL   = NO
 
-# Doxygen selects the parser to use depending on the extension of the files it parses. 
-# With this tag you can assign which parser to use for a given extension. 
-# Doxygen has a built-in mapping, but you can override or extend it using this tag. 
-# The format is ext=language, where ext is a file extension, and language is one of 
-# the parsers supported by doxygen: IDL, Java, Javascript, C#, C, C++, D, PHP, 
-# Objective-C, Python, Fortran, VHDL, C, C++. For instance to make doxygen treat 
-# .inc files as Fortran files (default is PHP), and .f files as C (default is Fortran), 
-# use: inc=Fortran f=C. Note that for custom extensions you also need to set
-# FILE_PATTERNS otherwise the files are not read by doxygen.
+# Doxygen selects the parser to use depending on the extension of the files it 
+# parses. With this tag you can assign which parser to use for a given extension. 
+# Doxygen has a built-in mapping, but you can override or extend it using this 
+# tag. The format is ext=language, where ext is a file extension, and language 
+# is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C, 
+# C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make 
+# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C 
+# (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions 
+# you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.
 
 EXTENSION_MAPPING      = 
 
@@ -233,7 +246,7 @@ EXTENSION_MAPPING      =
 # to include (a tag file for) the STL sources as input, then you should 
 # set this tag to YES in order to let doxygen match functions declarations and 
 # definitions whose arguments contain STL classes (e.g. func(std::string); v.s. 
-# func(std::string) {}). This also make the inheritance and collaboration 
+# func(std::string) {}). This also makes the inheritance and collaboration 
 # diagrams that involve STL classes more complete and accurate.
 
 BUILTIN_STL_SUPPORT    = NO
@@ -251,7 +264,7 @@ SIP_SUPPORT            = NO
 
 # For Microsoft's IDL there are propget and propput attributes to indicate getter 
 # and setter methods for a property. Setting this option to YES (the default) 
-# will make doxygen to replace the get and set methods by a property in the 
+# will make doxygen replace the get and set methods by a property in the 
 # documentation. This will only work if the methods are indeed getting or 
 # setting a simple type. If this is not the case, or you want to show the 
 # methods anyway, you should set this option to NO.
@@ -289,10 +302,10 @@ TYPEDEF_HIDES_STRUCT   = NO
 # For small to medium size projects (<1000 input files) the default value is 
 # probably good enough. For larger projects a too small cache size can cause 
 # doxygen to be busy swapping symbols to and from disk most of the time 
-# causing a significant performance penality. 
+# causing a significant performance penalty. 
 # If the system has enough physical memory increasing the cache will improve the 
 # performance by keeping more symbols in memory. Note that the value works on 
-# a logarithmic scale so increasing the size by one will rougly double the 
+# a logarithmic scale so increasing the size by one will roughly double the 
 # memory usage. The cache size is given by this formula: 
 # 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0, 
 # corresponding to a cache size of 2^16 = 65536 symbols
@@ -337,7 +350,7 @@ EXTRACT_LOCAL_METHODS  = NO
 # extracted and appear in the documentation as a namespace called 
 # 'anonymous_namespace{file}', where file will be replaced with the base 
 # name of the file that contains the anonymous namespace. By default 
-# anonymous namespace are hidden.
+# anonymous namespaces are hidden.
 
 EXTRACT_ANON_NSPACES   = NO
 
@@ -448,6 +461,15 @@ SORT_GROUP_NAMES       = NO
 
 SORT_BY_SCOPE_NAME     = YES
 
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
+# do proper type resolution of all parameters of a function it will reject a 
+# match between the prototype and the implementation of a member function even
+# if there is only one candidate or it is obvious which candidate to choose
+# by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen 
+# will still accept a match between prototype and implementation in such cases.
+
+STRICT_PROTO_MATCHING  = NO
+
 # The GENERATE_TODOLIST tag can be used to enable (YES) or 
 # disable (NO) the todo list. This list is created by putting \todo 
 # commands in the documentation.
@@ -478,10 +500,10 @@ GENERATE_DEPRECATEDLIST= YES
 ENABLED_SECTIONS       = 
 
 # The MAX_INITIALIZER_LINES tag determines the maximum number of lines 
-# the initial value of a variable or define consists of for it to appear in 
+# the initial value of a variable or macro consists of for it to appear in 
 # the documentation. If the initializer consists of more lines than specified 
 # here it will be hidden. Use a value of 0 to hide initializers completely. 
-# The appearance of the initializer of individual variables and defines in the 
+# The appearance of the initializer of individual variables and macros in the 
 # documentation can be controlled using \showinitializer or \hideinitializer 
 # command in the documentation regardless of this setting.
 
@@ -521,12 +543,12 @@ SHOW_NAMESPACES        = YES
 
 FILE_VERSION_FILTER    = 
 
-# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed by 
-# doxygen. The layout file controls the global structure of the generated output files 
-# in an output format independent way. The create the layout file that represents 
-# doxygen's defaults, run doxygen with the -l option. You can optionally specify a 
-# file name after the option, if omitted DoxygenLayout.xml will be used as the name 
-# of the layout file.
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed 
+# by doxygen. The layout file controls the global structure of the generated 
+# output files in an output format independent way. The create the layout file 
+# that represents doxygen's defaults, run doxygen with the -l option. 
+# You can optionally specify a file name after the option, if omitted 
+# DoxygenLayout.xml will be used as the name of the layout file.
 
 LAYOUT_FILE            = 
 
@@ -558,7 +580,7 @@ WARN_IF_UNDOCUMENTED   = YES
 
 WARN_IF_DOC_ERROR      = YES
 
-# This WARN_NO_PARAMDOC option can be abled to get warnings for 
+# The WARN_NO_PARAMDOC option can be enabled to get warnings for 
 # functions that are documented, but have no documentation for their parameters 
 # or return value. If set to NO (the default) doxygen will only warn about 
 # wrong or incomplete parameter documentation, but not about the absence of 
@@ -590,7 +612,8 @@ WARN_LOGFILE           =
 # directories like "/usr/src/myproject". Separate the files or directories 
 # with spaces.
 
-INPUT                  = ../glm
+INPUT                  = ../glm \
+                         .
 
 # This tag can be used to specify the character encoding of the source files 
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is 
@@ -604,10 +627,12 @@ INPUT_ENCODING         = UTF-8
 # FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
 # and *.h) to filter out the source-files in the directories. If left 
 # blank the following patterns are tested: 
-# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx 
-# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90
+# *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh 
+# *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py 
+# *.f90 *.f *.for *.vhd *.vhdl
 
-FILE_PATTERNS          = *.hpp
+FILE_PATTERNS          = *.hpp \
+                         *.doxy
 
 # The RECURSIVE tag can be used to turn specify whether or not subdirectories 
 # should be searched for input files as well. Possible values are YES and NO. 
@@ -622,7 +647,7 @@ RECURSIVE              = YES
 EXCLUDE                = 
 
 # The EXCLUDE_SYMLINKS tag can be used select whether or not files or 
-# directories that are symbolic links (a Unix filesystem feature) are excluded 
+# directories that are symbolic links (a Unix file system feature) are excluded 
 # from the input.
 
 EXCLUDE_SYMLINKS       = NO
@@ -641,7 +666,7 @@ EXCLUDE_PATTERNS       =
 # wildcard * is used, a substring. Examples: ANamespace, AClass, 
 # AClass::ANamespace, ANamespace::*Test
 
-EXCLUDE_SYMBOLS        = detail
+EXCLUDE_SYMBOLS        = 
 
 # The EXAMPLE_PATH tag can be used to specify one or more files or 
 # directories that contain example code fragments that are included (see 
@@ -683,8 +708,8 @@ INPUT_FILTER           =
 # basis.  Doxygen will compare the file name with each pattern and apply the 
 # filter if there is a match.  The filters are a list of the form: 
 # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further 
-# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER 
-# is applied to all files.
+# info on how filters are used. If FILTER_PATTERNS is empty or if 
+# non of the patterns match the file name, INPUT_FILTER is applied.
 
 FILTER_PATTERNS        = 
 
@@ -694,6 +719,14 @@ FILTER_PATTERNS        =
 
 FILTER_SOURCE_FILES    = NO
 
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file 
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any) 
+# and it is also possible to disable source filtering for a specific pattern 
+# using *.ext= (so without naming a filter). This option only has effect when 
+# FILTER_SOURCE_FILES is enabled.
+
+FILTER_SOURCE_PATTERNS = 
+
 #---------------------------------------------------------------------------
 # configuration options related to source browsing
 #---------------------------------------------------------------------------
@@ -814,6 +847,31 @@ HTML_FOOTER            =
 
 HTML_STYLESHEET        = 
 
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. 
+# Doxygen will adjust the colors in the stylesheet and background images 
+# according to this color. Hue is specified as an angle on a colorwheel, 
+# see http://en.wikipedia.org/wiki/Hue for more information. 
+# For instance the value 0 represents red, 60 is yellow, 120 is green, 
+# 180 is cyan, 240 is blue, 300 purple, and 360 is red again. 
+# The allowed range is 0 to 359.
+
+HTML_COLORSTYLE_HUE    = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of 
+# the colors in the HTML output. For a value of 0 the output will use 
+# grayscales only. A value of 255 will produce the most vivid colors.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to 
+# the luminance component of the colors in the HTML output. Values below 
+# 100 gradually make the output lighter, whereas values above 100 make 
+# the output darker. The value divided by 100 is the actual gamma applied, 
+# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2, 
+# and 100 does not change the gamma.
+
+HTML_COLORSTYLE_GAMMA  = 80
+
 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML 
 # page will contain the date and time when the page was generated. Setting 
 # this to NO can help when comparing the output of multiple runs.
@@ -842,7 +900,8 @@ HTML_DYNAMIC_SECTIONS  = NO
 # directory and running "make install" will install the docset in 
 # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find 
 # it at startup. 
-# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html for more information.
+# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html 
+# for more information.
 
 GENERATE_DOCSET        = NO
 
@@ -860,6 +919,16 @@ DOCSET_FEEDNAME        = "Doxygen generated docs"
 
 DOCSET_BUNDLE_ID       = org.doxygen.Project
 
+# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify 
+# the documentation publisher. This should be a reverse domain-name style 
+# string, e.g. com.mycompany.MyDocSet.documentation.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
+
+DOCSET_PUBLISHER_NAME  = Publisher
+
 # If the GENERATE_HTMLHELP tag is set to YES, additional index files 
 # will be generated that can be used as input for tools like the 
 # Microsoft HTML help workshop to generate a compiled HTML help file (.chm) 
@@ -904,10 +973,10 @@ BINARY_TOC             = NO
 
 TOC_EXPAND             = NO
 
-# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and QHP_VIRTUAL_FOLDER 
-# are set, an additional index file will be generated that can be used as input for 
-# Qt's qhelpgenerator to generate a Qt Compressed Help (.qch) of the generated 
-# HTML documentation.
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and 
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated 
+# that can be used as input for Qt's qhelpgenerator to generate a 
+# Qt Compressed Help (.qch) of the generated HTML documentation.
 
 GENERATE_QHP           = NO
 
@@ -929,20 +998,24 @@ QHP_NAMESPACE          = org.doxygen.Project
 
 QHP_VIRTUAL_FOLDER     = doc
 
-# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to add. 
-# For more information please see 
+# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to 
+# add. For more information please see 
 # http://doc.trolltech.com/qthelpproject.html#custom-filters
 
 QHP_CUST_FILTER_NAME   = 
 
-# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the custom filter to add.For more information please see 
-# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">Qt Help Project / Custom Filters</a>.
+# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the 
+# custom filter to add. For more information please see 
+# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters"> 
+# Qt Help Project / Custom Filters</a>.
 
 QHP_CUST_FILTER_ATTRS  = 
 
-# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this project's 
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this 
+# project's 
 # filter section matches. 
-# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">Qt Help Project / Filter Attributes</a>.
+# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes"> 
+# Qt Help Project / Filter Attributes</a>.
 
 QHP_SECT_FILTER_ATTRS  = 
 
@@ -976,8 +1049,10 @@ ECLIPSE_DOC_ID         = org.doxygen.Project
 
 DISABLE_INDEX          = NO
 
-# This tag can be used to set the number of enum values (range [1..20]) 
+# This tag can be used to set the number of enum values (range [0,1..20]) 
 # that doxygen will group on one line in the generated HTML documentation. 
+# Note that a value of 0 will completely suppress the enum values from
+# appearing in the overview section.
 
 ENUM_VALUES_PER_LINE   = 4
 
@@ -1002,6 +1077,11 @@ USE_INLINE_TREES       = NO
 
 TREEVIEW_WIDTH         = 250
 
+# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open 
+# links to external symbols imported via tag files in a separate window.
+
+EXT_LINKS_IN_WINDOW    = NO
+
 # Use this tag to change the font size of Latex formulas included 
 # as images in the HTML documentation. The default is 10. Note that 
 # when you change the font size after a successful doxygen run you need 
@@ -1010,6 +1090,34 @@ TREEVIEW_WIDTH         = 250
 
 FORMULA_FONTSIZE       = 10
 
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images 
+# generated for formulas are transparent PNGs. Transparent PNGs are 
+# not supported properly for IE 6.0, but are supported on all modern browsers. 
+# Note that when changing this option you need to delete any form_*.png files 
+# in the HTML output before the changes have effect.
+
+FORMULA_TRANSPARENT    = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax 
+# (see http://www.mathjax.org) which uses client side Javascript for the 
+# rendering instead of using prerendered bitmaps. Use this if you do not 
+# have LaTeX installed or if you want to formulas look prettier in the HTML 
+# output. When enabled you also need to install MathJax separately and 
+# configure the path to it using the MATHJAX_RELPATH option.
+
+USE_MATHJAX            = NO
+
+# When MathJax is enabled you need to specify the location relative to the 
+# HTML output directory using the MATHJAX_RELPATH option. The destination 
+# directory should contain the MathJax.js script. For instance, if the mathjax 
+# directory is located at the same level as the HTML output directory, then 
+# MATHJAX_RELPATH should be ../mathjax. The default value points to the
+# mathjax.org site, so you can quickly see the result without installing 
+# MathJax, but it is strongly recommended to install a local copy of MathJax 
+# before deployment.
+
+MATHJAX_RELPATH        = http://www.mathjax.org/mathjax
+
 # When the SEARCHENGINE tag is enabled doxygen will generate a search box 
 # for the HTML output. The underlying search engine uses javascript 
 # and DHTML and should work on any modern browser. Note that when using 
@@ -1025,7 +1133,7 @@ SEARCHENGINE           = NO
 # using Javascript. Doxygen will generate the search PHP script and index 
 # file to put on the web server. The advantage of the server 
 # based approach is that it scales better to large projects and allows 
-# full text search. The disadvances is that it is more difficult to setup 
+# full text search. The disadvantages are that it is more difficult to setup 
 # and does not have live searching capabilities.
 
 SERVER_BASED_SEARCH    = NO
@@ -1066,7 +1174,7 @@ MAKEINDEX_CMD_NAME     = makeindex
 COMPACT_LATEX          = NO
 
 # The PAPER_TYPE tag can be used to set the paper type that is used 
-# by the printer. Possible values are: a4, a4wide, letter, legal and 
+# by the printer. Possible values are: a4, letter, legal and 
 # executive. If left blank a4wide will be used.
 
 PAPER_TYPE             = a4wide
@@ -1320,15 +1428,15 @@ PREDEFINED             =
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then 
 # this tag can be used to specify a list of macro names that should be expanded. 
 # The macro definition that is found in the sources will be used. 
-# Use the PREDEFINED tag if you want to use a different macro definition.
+# Use the PREDEFINED tag if you want to use a different macro definition that
+# overrules the definition found in the source code.
 
 EXPAND_AS_DEFINED      = 
 
 # If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then 
-# doxygen's preprocessor will remove all function-like macros that are alone 
-# on a line, have an all uppercase name, and do not end with a semicolon. Such 
-# function macros are typically used for boiler-plate code, and will confuse 
-# the parser if not removed.
+# doxygen's preprocessor will remove all references to function-like macros 
+# that are alone on a line, have an all uppercase name, and do not end with a 
+# semicolon, because these will confuse the parser if not removed.
 
 SKIP_FUNCTION_MACROS   = YES
 
@@ -1382,9 +1490,8 @@ PERL_PATH              = /usr/bin/perl
 # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will 
 # generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base 
 # or super classes. Setting the tag to NO turns the diagrams off. Note that 
-# this option is superseded by the HAVE_DOT option below. This is only a 
-# fallback. It is recommended to install and use dot, since it yields more 
-# powerful graphs.
+# this option also works with HAVE_DOT disabled, but it is recommended to 
+# install and use dot, since it yields more powerful graphs.
 
 CLASS_DIAGRAMS         = YES
 
@@ -1410,11 +1517,18 @@ HIDE_UNDOC_RELATIONS   = YES
 
 HAVE_DOT               = NO
 
-# By default doxygen will write a font called FreeSans.ttf to the output 
-# directory and reference it in all dot files that doxygen generates. This 
-# font does not include all possible unicode characters however, so when you need 
-# these (or just want a differently looking font) you can specify the font name 
-# using DOT_FONTNAME. You need need to make sure dot is able to find the font, 
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is 
+# allowed to run in parallel. When set to 0 (the default) doxygen will 
+# base this on the number of processors available in the system. You can set it 
+# explicitly to a value larger than 0 to get control over the balance 
+# between CPU load and processing speed.
+
+DOT_NUM_THREADS        = 0
+
+# By default doxygen will write a font called Helvetica to the output 
+# directory and reference it in all dot files that doxygen generates. 
+# When you want a differently looking font you can specify the font name 
+# using DOT_FONTNAME. You need to make sure dot is able to find the font, 
 # which can be done by putting it in a standard location or by setting the 
 # DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory 
 # containing the font.
@@ -1494,7 +1608,7 @@ CALL_GRAPH             = YES
 CALLER_GRAPH           = YES
 
 # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen 
-# will graphical hierarchy of all classes instead of a textual one.
+# will generate a graphical hierarchy of all classes instead of a textual one.
 
 GRAPHICAL_HIERARCHY    = YES
 
@@ -1506,7 +1620,7 @@ GRAPHICAL_HIERARCHY    = YES
 DIRECTORY_GRAPH        = YES
 
 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images 
-# generated by dot. Possible values are png, jpg, or gif 
+# generated by dot. Possible values are png, svg, gif or svg. 
 # If left blank png will be used.
 
 DOT_IMAGE_FORMAT       = png
@@ -1522,6 +1636,12 @@ DOT_PATH               =
 
 DOTFILE_DIRS           = 
 
+# The MSCFILE_DIRS tag can be used to specify one or more directories that 
+# contain msc files that are included in the documentation (see the 
+# \mscfile command).
+
+MSCFILE_DIRS           = 
+
 # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of 
 # nodes that will be shown in the graph. If the number of nodes in a graph 
 # becomes larger than this value, doxygen will truncate the graph, which is 

doc/pages.doxy

@@ -0,0 +1,629 @@
+/*!
+	\mainpage OpenGL Mathematics
+	
+	OpenGL Mathematics (GLM) is a C++ mathematics library for graphics software based on the OpenGL Shading Language (GLSL) specification.
+ 
+	GLM provides classes and functions designed and implemented with the same naming conventions and functionalities than GLSL so that when a programmer knows GLSL, he knows GLM as well which makes it really easy to use.
+	 
+	This project isn't limited by GLSL features. An extension system, based on the GLSL extension conventions, provides extended capabilities: matrix transformations, quaternions, half-based types, random numbers, etc...
+	 
+	This library works perfectly with OpenGL but it also ensures interoperability with other third party libraries and SDK. It is a good candidate for software rendering (Raytracing / Rasterisation), image processing, physic simulations and any context that requires a simple and convenient mathematics library.
+	
+	\note The Doxygen-generated documentation will often state that a type or function
+	is defined in a namespace that is a child of the \link glm glm \endlink namespace.
+	Please ignore this; you can access all publicly available types as direct children
+	of the glm namespace.
+	
+	GLM is written as a platform independent library with no dependence and officially supports the following compilers:
+	1. GCC 3.4 and higher
+	2. LLVM 2.3 through GCC 4.2 front-end and higher
+	3. Visual Studio 2005 and higher
+	 
+	The source code is licenced under the <a href="http://www.opensource.org/licenses/mit-license.php">MIT licence</a>.
+	 
+	Thanks for contributing to the project by <a href="https://sourceforge.net/apps/trac/ogl-math/newticket">submitting tickets for bug reports and feature requests</a>. 
+	(SF.net account required). Any feedback is welcome at glm@g-truc.net.
+
+	\li \subpage pg_started 
+	\li \subpage pg_advanced
+	\li \subpage pg_differences
+	\li \subpage pg_deprecated
+	\li \subpage pg_issues
+	\li \subpage pg_faq
+	\li \subpage pg_samples
+	\li \subpage pg_reference
+**/
+
+/*!
+	\page pg_started Getting Started
+	
+	\section started_compiler Compiler Setup
+	
+	GLM is a header only library, there is nothing to build to use it which increases its cross platform capabilities.
+ 
+	To use GLM, a programmer only has to include <glm/glm.hpp>. This provides all the GLSL features implemented by GLM.
+	 
+	GLM makes heavy usages of C++ templates. This design may significantly increase the compile time for files that use GLM. Precompiled headers are recommended to avoid this issue.
+
+	\section started_sample Use Sample of GLM
+	\code
+#include <glm/glm.hpp>
+
+int foo()
+{
+	glm::vec4 Position = glm::vec4(glm::vec3(0.0), 1.0);
+	glm::mat4 Model = glm::mat4(1.0);
+	Model[4] = glm::vec4(1.0, 1.0, 0.0, 1.0);
+	glm::vec4 Transformed = Model * Position;
+	return 0;
+}
+	\endcode
+	
+	\section started_structure Library Structure
+	
+	GLM is arranged in 2 distinct segments. These are the GLM features based on the GLSL specification and a set of extensions.
+	Some extensions are stable and backward compatible (\ref gtc GTC \ref virtrev VIRTREV) but some are experimental (\ref gtx GTX) 
+	which means that they are not guarantee to be backward compatible from version to version.
+	
+	The \ref core "GLM" represents only what GLSL's core provides in terms of types and functions
+	(to the best of GLM's ability to replicate them). All that is needed to use the core
+	is to <tt>#include <glm/glm.hpp></tt>.
+	
+	\ref gtc "GTC extensions" are functions and types that add onto the core.
+	These are considered reasonably stable, with their APIs not changing much between
+	versions. Each core extension is included with a separated header file include. All
+	of the core extensions are in the "glm/gtc" directory.
+	
+	\ref gtx "GTX extensions" are functions and types that add onto the
+	core. Unlike GTC extensions, their APIs are not considered particularly stable, which
+	is why they are marked "experimental". Like GTC extensions, each experimental extension is included
+	with a separate header file.
+	
+	All the extensions can be included at once by default with <tt>#include <glm/ext.hpp></tt> 
+	but this is not recommanded as it will reduce compilation speed for many unused features.
+	
+	All of GLM is defined as direct children of the glm namespace, including extensions. 
+
+	To use a particular extension, simply include the extension header file. All
+	extension features are added to the glm namespace automatically.
+	
+	\code
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+ 
+int foo()
+{
+	glm::vec4 Position = glm::vec4(glm::vec3(0.0f), 1.0f);
+	glm::mat4 Model = glm::translate(
+		glm::mat4(1.0f), glm::vec3(1.0f));
+	glm::vec4 Transformed = Model * Position;
+	return 0;
+}
+	\endcode
+	
+	\section started_dependencies Dependencies
+	
+	When <glm/glm.hpp> is included, GLM provides all the GLSL features it implements in C++.
+ 
+	When an extension is included, all the dependent extensions will be included as well. All the extensions depend on GLM core. (<glm/glm.hpp>)
+	 
+	There is no dependence with external libraries or external headers like gl.h, gl3.h, glu.h or windows.h. However, if <boost/static_assert.hpp> is included, Boost static assert will be used throughout GLM code to provide compiled time errors.
+
+	\section started_interop OpenGL Interoperability
+	
+	It is often useful to get a vector type as an array of its base type. For example, the
+	OpenGL function <tt>glUniform3fv()</tt> takes an array instead of 3 individual values.
+	If the vector and matrix types were simple arrays, then one could pass them to the function
+	like so: <tt>glUniform3fv(loc, 1, glm::vec3(0))</tt>. However, this is not the case;
+	the vector and matrix types are C++ classes, not arrays.
+	
+	Instead, GLM provides a mechanism to get the content of a vector or matrix as
+	an array pointer. The \ref gtc_type_ptr extension provides this ability.
+
+	\code
+#include <glm/glm.hpp>
+#include <glm/gtc/type_ptr.hpp>
+ 
+void BindUniforms(GLuint uniVec, GLuint uniMat)
+{
+	glm::vec4 v(0.0f);
+	glm::mat4 m(1.0f);
+	...
+	glUniform3fv(uniVec, 1, glm::value_ptr(v));
+	glUniformMatrix4fv(uniMat, 1, GL_FALSE, glm::value_ptr(m));
+}
+	\endcode
+	
+	Notice that all matrix types are <em>column-major</em> rather than row-major. Hence the need to pass GL_FALSE to glUniformMatrix4fv.
+	 
+	Alternatively, the first element of the type can be dereferenced.
+	
+	\code
+#include <glm/glm.hpp>
+ 
+void BindUniforms(GLuint uniVec, GLuint uniMat)
+{
+	glm::vec4 v(0.0f);
+	glm::mat4 m(1.0f);
+	...
+	glUniform3fv(uniVec, 1, glm::value_ptr(&v[0]));
+	glUniformMatrix4fv(uniMat, 1, GL_FALSE, &m[0][0]);
+}
+	\endcode
+	
+	This method requires dereferencing the very first basic type of the object, not merely the first element. 
+	The [] operator on the matrix type returns a column vector; one must then access the first element of that column vector to get a pointer to the basic type.
+	
+	\note This operation could have been built into the base vector and matrix types and performed with a cast operator. 
+	However, this has some downsides. Implicit casts can cause unexpected and unwanted behavior.
+**/
+
+/*!
+	\page pg_advanced Advanced Usage
+	
+	\section advanced_swizzle Swizzle Operators
+	
+	A common feature of shader languages like GLSL is components swizzling. 
+	This involves being able to select which components of a vector are used and in what order. 
+	For example, "variable.x", "variable.xxy", "variable.zxyy" are examples of swizzling.
+
+	\code
+vec4 A;
+vec2 B;
+...
+B.yx = A.wy;
+B = A.xx;
+	\endcode
+	 
+	This functionally turns out to be really complicated to implement in C++ using the exact GLSL conventions. 
+	GLM provides 2 implementions this feature.
+	 
+	\subsection advanced_swizzle_macro Macro implementation
+	
+	The first implementation follows the GLSL convensions accurately. 
+	It uses macros to achieve this, which might generates name conflicts with system headers or third party libraries. 
+	Therefore, it is disabled by default. To enable this implementation, GLM_SWIZZLE must be defined before any inclusion of <glm/glm.hpp>. 
+	
+	\code
+#define GLM_SWIZZLE 
+#include <glm/glm.hpp>
+	\endcode
+	 
+	This implementation can be partially enabled by defining GLM_SWIZZLE_XYZW, GLM_SWIZZLE_RGBA or GLM_SWIZZLE_STQP. 
+	Each macro only enable a set of swizzling operators. For example we can only enable x,y,z,w and s,t,q,p operators using:
+
+	\code
+#define GLM_SWIZZLE_XYZW 
+#define GLM_SWIZZLE_STQP
+#include <glm/glm.hpp>
+	\endcode
+	 
+	\subsection advanced_swizzle_ext Extension implementation
+	
+	A safer way to do swizzling is to use the <glm/gtc/swizzle.hpp> extension. 
+	This extension provides the GLSL functionality, but uses a different syntax for it. 
+	Moreover, the swizzle extension also provides dynamic swizzling.
+	 
+	Static swizzling is resovled at compile-time. 
+	The swizzle mask ".xzyy" is as fixed as the type of a particular variable. 
+	Dynamic swizzling is resolved at runtime via function calls. 
+	Dynamic swizzling is more flexible, since one can choose the swizzle mask at runtime, but it runs slower. 
+	This performance issue is enhanced when \ref advanced_simd "SIMD instructions" are used.
+	
+	\code
+#include <glm/glm.hpp>
+#include <glm/gtc/swizzle.hpp>
+ 
+void foo()
+{
+	glm::vec4 ColorRGBA(1.0f, 0.5f, 0.0f, 1.0f);
+	...
+	// Dynamic swizzling (at run time, more flexible)
+	// l-value:
+	glm::vec4 ColorBGRA1 = 
+	glm::swizzle(ColorRGBA, glm::B, glm::G, glm::R, glm::A);
+	// r-value:
+	glm::swizzle(ColorRGBA, glm::B, glm::G, glm::R, glm::A) = ColorRGBA;
+	 
+	// Static swizzling (at build time, faster)
+	// l-value:
+	glm::vec4 ColorBGRA2 = 
+	glm::swizzle<glm::B, glm::G, glm::R, glm::A>(ColorRGBA);
+	// r-value:
+	glm::swizzle<glm::B, glm::G, glm::R, glm::A>(ColorRGBA) = ColorRGBA;
+}
+	\endcode
+	
+	\section advanced_notify Notification System
+	
+	GLM includes a notification system which can display some information at build time:
+	\li Compiler
+	\li Build model: 32bits or 64 bits
+	\li C++ version
+	\li Architecture: x86, SSE, AVX, etc.
+	\li Included extensions
+	\li etc.
+	 
+	This system is disable by default. To enable this system, define GLM_MESSAGES before any inclusion of <glm/glm.hpp>.
+	
+	\code
+#define GLM_MESSAGES
+#include <glm/glm.hpp>
+	\endcode
+	
+	\section advanced_inline Force Inline
+	
+	GLM's functions are defined in headers, so they are defined with C++'s "inline" delcaration. 
+	This does not require the compiler to inline them, however. 
+	If you want to force the compiler to inline the function, using whatever capabilities that the compiler provides to do so, 
+	you can define GLM_FORCE_INLINE before any inclusion of <glm/glm.hpp>.
+
+	\code
+#define GLM_FORCE_INLINE 
+#include <glm/glm.hpp>
+	\endcode
+	
+	\section advanced_simd SIMD support
+	
+	GLM provides some SIMD optimizations based on compiler intrinsics. 
+	These optimizations will be automatically utilized based on the build environment. 
+	These optimizations are mainly available through the extensions \ref gtx_simd_vec4 and \ref gtx_simd_mat4. 
+ 
+	A programmer can restrict or force instruction sets used for these optimizations using GLM_FORCE_SSE2 or GLM_FORCE_AVX. 
+	 
+	A programmer can discard the use of intrinsics by defining GLM_FORCE_PURE before any inclusion of <glm/glm.hpp>. 
+	If GLM_FORCE_PURE is defined, then including a SIMD extension will generate a build error.
+
+	\code
+#define GLM_FORCE_PURE
+#include <glm/glm.hpp>
+	\endcode
+
+	\section advanced_compatibility Compatibility
+	Compilers have some language extensions that GLM will automatically take advantage of them when they are enabled. 
+	The #define GLM_FORCE_CXX98 can switch off these extensions, forcing GLM to operate on pure C++98.
+
+	\code
+#define GLM_FORCE_CXX98 
+#include <glm/glm.hpp>
+	\endcode
+**/
+
+/*!
+	\page pg_deprecated Deprecated function replacements
+	
+	The OpenGL 3.0 specification deprecated some features, and most of these have been removed from the OpenGL 3.1 specfication and beyond. 
+	GLM provides some replacement functions. Many of these functions come from the \ref gtc_matrix_transform extension.
+	
+	\section deprecated_opengl OpenGL function replacements
+	
+	<dl>
+		<dt>glRotate[fd]</dt>
+		<dd>\link glm::gtc::matrix_transform::rotate glm::rotate \endlink</dd>
+		<dt>glScale[fd]</dt>
+		<dd>\link glm::gtc::matrix_transform::scale glm::scale \endlink</dd>
+		<dt>glTranslate[fd]</dt>
+		<dd>\link glm::gtc::matrix_transform::translate glm::translate \endlink</dd>
+		<dt>glLoadIdentity</dt>
+		<dd>The default constructor of all matrix types creates an identity matrix.</dd>
+		<dt>glMultMatrix[fd]</dt>
+		<dd>Per the GLSL specification, the multiplication operator is overloaded for all matrix types. Multiplying two matrices together will perform matrix multiplication.</dd>
+		<dt>glLoadTransposeMatrix[fd]</dt>
+		<dd>\link glm::core::function::matrix::transpose glm::transpose \endlink</dd>
+		<dt>glMultTransposeMatrix</dt>
+		<dd>Combine the last two.</dd>
+		<dt>glFrustum</dt>
+		<dd>\link glm::gtc::matrix_transform::frustum glm::frustum \endlink</dd>
+		<dt>glOrtho</dt>
+		<dd>\link glm::gtc::matrix_transform::ortho glm::ortho \endlink</dd>
+		<dt>gluLookAt</dt>
+		<dd>\link glm::gtc::matrix_transform::lookAt glm::lookAt \endlink</dd>
+	</dl>
+	
+	\section deprecated_glu GLU function replacements
+	
+	<dl>
+		<dt>gluOrtho2D</dt>
+		<dd>\link glm::gtc::matrix_transform::ortho glm::ortho \endlink</dd>
+		<dt>gluPerspective</dt>
+		<dd>\link glm::gtc::matrix_transform::perspective glm::perspective \endlink</dd>
+		<dt>gluProject</dt>
+		<dd>\link glm::gtc::matrix_transform::project glm::project \endlink</dd>
+		<dt>gluUnProject</dt>
+		<dd>\link glm::gtc::matrix_transform::unProject glm::unProject \endlink</dd>
+	</dl>
+**/
+
+/*!
+	\page pg_differences Differences between GLSL and GLM core
+	
+	GLM comes very close to replicating GLSL, but it is not exact. Here is a list of
+	differences between GLM and GLSL:
+	
+	<ul>
+		<li>
+		Precision qualifiers. In GLSL numeric types can have qualifiers that define
+		the precision of that type. While OpenGL's GLSL ignores these qualifiers, OpenGL
+		ES's version of GLSL uses them.
+		
+		C++ has no language equivalent to precision qualifiers. Instead, GLM provides
+		a set of typedefs for each kind of precision qualifier and type. These types can
+		be found in \ref core_precision "their own section".
+		
+		Functions that take types tend to be templated on those types, so they can 
+		take these qualified types just as well as the regular ones.
+		</li>
+	</ul>
+**/
+
+/*!
+	\page pg_faq FAQ
+	
+	\section faq1 Why does GLM follow GLSL specification and conventions?
+	
+	Following GLSL conventions is a really strict policy of GLM. GLM has been designed according to 
+	the idea that everyone writes their own math library with their own conventions. The idea is that 
+	brilliant developers (the OpenGL ARB) worked together and agreed to make GLSL. Following 
+	GLSL conventions is a way to find consensus. Moreover, basically when a developer knows 
+	GLSL, he knows GLM.
+	
+	\section faq2 Does GLM run GLSL programs?
+	
+	No, GLM is a C++ implementation of a subset of GLSL.
+	
+	\section faq3 Does a GLSL compiler build GLM codes?
+	
+	No, this is not what GLM intends to do!
+	
+	\section faq4 Should I use GTX extensions?
+	
+	\ref gtx are experimental. In GLM this means that these extensions might change from version to version without restriction. In practice, it doesn't really change except time to time. GTC extensions are stabled, tested and perfectly reliable in time. Many GTX extensions extend GTC extensions and provide a way to explore features and implementations before becoming stable by a promotion as GTC extensions. This is similar to how OpenGL extensions can be EXT or ARB extensions before becoming core functionality.
+	
+	In short, if you use a GTX extension, the API is much more likely to change from version to version than if you don't. But you should not feel too uncomfortable about using them.
+	
+	\section faq5 Where can I ask my questions?
+	
+	A good place is the OpenGL Toolkits forum on OpenGL.org:
+	http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=postlist&Board=10&page=1
+	
+	\section faq6 Where can I find the documentation of extensions?
+	
+	The Doxygen generated documentation includes a complete list of all extensions available. 
+	Explore this documentation to get a complete view of all GLM capabilities!
+	http://glm.g-truc.net/html/index.html
+	
+	\section faq7 Should I use 'using namespace glm;'?
+	
+	This is unwise. There is every chance that are that if 'using namespace glm;' is called, name collisions will happen. GLSL names for functions are fairly generic, so it is entirely likely that there is another function called, for example, \link glm::sqrt sqrt \endlink.
+	
+	If you need frequent use of particular types, you can bring them into the global
+	namespace with a 'using' declaration like this:
+	
+	/code
+	using glm::mat4;
+	
+	mat4 someVariable(3.0f);
+	/endcode
+	
+	\section faq8 Is GLM fast?
+	
+	GLM is mainly designed to be convenient; that's why it is written against GLSL specification.
+	
+	The <a href="http://en.wikipedia.org/wiki/Pareto_principle">80-20</a> rule suggests that 80% of a program's performance comes from 20% of its code. Therefore, one must first identify which 20% of the code is impacting the performance.
+	
+	In general, if one identifies certain math code to be a performance bottleneck, the only way to solve this is to write specialized code for those particular math needs. So no canned library solution would be suitable.
+	
+	That being said, GLM can provides some descent performances alternatives based on approximations or SIMD instructions.
+**/
+
+/*!
+	\page pg_samples Code Samples
+	
+	This series of samples only shows various GLM functionality.
+	
+	\section sample1 Compute a Triangle's Normal
+	
+	\code
+#include <glm/glm.hpp> // vec3 normalize cross
+ 
+glm::vec3 computeNormal(
+glm::vec3 const & a, 
+glm::vec3 const & b,
+glm::vec3 const & c)
+{
+	return glm::normalize(glm::cross(c - a, b - a));
+}
+	\endcode
+ 
+	A potentially faster, but less accurate alternative:
+	
+	\code
+#include <glm/glm.hpp> // vec3 cross
+#include <glm/gtx/fast_square_root.hpp> // fastNormalize
+ 
+glm::vec3 computeNormal(
+	glm::vec3 const & a, 
+	glm::vec3 const & b,
+	glm::vec3 const & c)
+{
+	return glm::fastNormalize(glm::cross(c - a, b - a));
+}
+	\endcode
+
+	\section sample2 Matrix Transform
+
+	\code
+#include <glm/glm.hpp> //vec3, vec4, ivec4, mat4
+#include <glm/gtc/matrix_transform.hpp> //translate, rotate, scale, perspective 
+#include <glm/gtc/type_ptr.hpp> //value_ptr
+ 
+void setUniformMVP(
+		GLuint Location, 
+		glm::vec3 const & Translate, 
+		glm::vec3 const & Rotate)
+{
+	glm::mat4 Projection =
+	glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.f);
+	glm::mat4 ViewTranslate = glm::translate(
+	glm::mat4(1.0f),
+	Translate);
+	glm::mat4 ViewRotateX = glm::rotate(
+	ViewTranslate,
+	Rotate.y, glm::vec3(-1.0f, 0.0f, 0.0f));
+	glm::mat4 View = glm::rotate(
+	ViewRotateX,
+	Rotate.x, glm::vec3(0.0f, 1.0f, 0.0f));
+	glm::mat4 Model = glm::scale(
+	glm::mat4(1.0f),
+	glm::vec3(0.5f));
+	glm::mat4 MVP = Projection * View * Model;
+	glUniformMatrix4fv(
+	Location, 1, GL_FALSE, glm::value_ptr(MVP));
+}
+	\endcode
+	
+	\section sample3 Vector Types
+	
+	\code	
+#include <glm/glm.hpp> //vec2
+#include <glm/gtc/type_precision.hpp> //hvec2, i8vec2, i32vec2
+std::size_t const VertexCount = 4;
+ 
+// Float quad geometry
+std::size_t const PositionSizeF32 = VertexCount * sizeof(glm::vec2);
+glm::vec2 const PositionDataF32[VertexCount] =
+{
+	glm::vec2(-1.0f,-1.0f),
+	glm::vec2( 1.0f,-1.0f),
+	glm::vec2( 1.0f, 1.0f),
+	glm::vec2(-1.0f, 1.0f)
+};
+
+// Half-float quad geometry
+std::size_t const PositionSizeF16 = VertexCount * sizeof(glm::hvec2);
+glm::hvec2 const PositionDataF16[VertexCount] =
+{
+	glm::hvec2(-1.0f, -1.0f),
+	glm::hvec2( 1.0f, -1.0f),
+	glm::hvec2( 1.0f, 1.0f),
+	glm::hvec2(-1.0f, 1.0f)
+};
+
+// 8 bits signed integer quad geometry
+std::size_t const PositionSizeI8 = VertexCount * sizeof(glm::i8vec2);
+glm::i8vec2 const PositionDataI8[VertexCount] =
+{
+	glm::i8vec2(-1,-1),
+	glm::i8vec2( 1,-1),
+	glm::i8vec2( 1, 1),
+	glm::i8vec2(-1, 1)
+};
+
+// 32 bits signed integer quad geometry
+std::size_t const PositionSizeI32 = VertexCount * sizeof(glm::i32vec2);
+glm::i32vec2 const PositionDataI32[VertexCount] =
+{
+	glm::i32vec2 (-1,-1),
+	glm::i32vec2 ( 1,-1),
+	glm::i32vec2 ( 1, 1),
+	glm::i32vec2 (-1, 1)
+};
+	\endcode
+
+	\section sample4 Lighting
+	
+	\code
+#include <glm/glm.hpp> // vec3 normalize reflect dot pow
+#include <glm/gtx/random.hpp> // vecRand3
+ 
+// vecRand3, generate a random and equiprobable normalized vec3
+ 
+glm::vec3 lighting(
+	intersection const & Intersection,
+	material const & Material,
+	light const & Light,
+	glm::vec3 const & View)
+{
+	glm::vec3 Color = glm::vec3(0.0f);
+	glm::vec3 LightVertor = glm::normalize(
+	Light.position() - Intersection.globalPosition() +
+	glm::vecRand3(0.0f, Light.inaccuracy());
+	
+	if(!shadow(
+		Intersection.globalPosition(),
+		Light.position(),
+		LightVertor))
+	{
+		float Diffuse = glm::dot(Intersection.normal(), LightVector);
+		if(Diffuse <= 0.0f)
+		return Color;
+		if(Material.isDiffuse())
+		Color += Light.color() * Material.diffuse() * Diffuse;
+		
+	if(Material.isSpecular())
+	{
+		glm::vec3 Reflect = glm::reflect(
+		-LightVector,
+		Intersection.normal());
+		float Dot = glm::dot(Reflect, View);
+		float Base = Dot > 0.0f ? Dot : 0.0f;
+		float Specular = glm::pow(Base, Material.exponent());
+		Color += Material.specular() * Specular;
+	}
+	return Color;
+}
+	\endcode
+	
+**/
+
+/*!
+	\page pg_issues Known Issues
+	
+	\section issue1 not Function
+	
+	The GLSL keyword not is also a keyword in C++. To prevent name collisions, the GLSL not 
+	function has been implemented with the name not_.
+	
+	\section issue2 Half Based Types
+	GLM supports half float number types through the extension GLM_GTC_half_float. This extension provides the types half, hvec*, hmat*x* and hquat*. 
+	 
+	Unfortunately, C++ 98 specification doesn’t support anonymous unions which limit hvec* vector components access to x, y, z and w.
+	 
+	However, Visual C++ does support anonymous unions if the language extensions are enabled (/Za to disable them). In this case GLM will automatically enables the support of all component names (x,y,z,w ; r,g,b,a ; s,t,p,q). 
+	 
+	To uniformalize the component access across types, GLM provides the define GLM_FORCE_ONLY_XYZW which will generates errors if component accesses are done using r,g,b,a or s,t,p,q.
+	
+	\code
+#define GLM_FORCE_ONLY_XYZW 
+#include <glm/glm.hpp>
+	\endcode
+**/
+
+/*!
+	\page pg_reference References
+	
+	OpenGL 4.1 core specification:
+	http://www.opengl.org/registry/doc/glspec41.core.20100725.pdf
+	 
+	GLSL 4.10 specification:
+			http://www.opengl.org/registry/doc/GLSLangSpec.4.10.6.clean.pdf
+	 
+	GLU 1.3 specification:
+			http://www.opengl.org/documentation/specs/glu/glu1_3.pdf
+	 
+	GLM HEAD snapshot:
+	http://ogl-math.git.sourceforge.net/git/gitweb.cgi?p=ogl-math/ogl-math;a=snapshot;h=HEAD;sf=tgz
+	 
+	GLM Trac, for bug report and feature request:
+		https://sourceforge.net/apps/trac/ogl-math
+	 
+	GLM website:
+		http://glm.g-truc.net
+	 
+	G-Truc Creation page:
+			http://www.g-truc.net/project-0016.html
+	 
+	The OpenGL Toolkits forum to ask questions about GLM:
+	http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=postlist&Board=10&page=1
+**/
+

doc/theme/doxygen.css

@@ -0,0 +1,822 @@
+/* The standard CSS for doxygen */
+
+body, table, div, p, dl 
+{
+	font-family: Lucida Grande, Verdana, Geneva, Arial, sans-serif;
+	font-size: 12px;
+}
+
+body
+{
+    background-color: #FFC080;
+	/*width:1024px;*/
+	margin-left:auto;
+	margin-right:auto;
+}
+
+/* @group Heading Levels */
+
+h1 
+{
+    color:#FF8000;
+	font-size: 150%;
+}
+
+h2 
+{
+    color:#FF8000;
+	font-size: 120%;
+}
+
+h3 {
+	font-size: 100%;
+}
+
+dt {
+	font-weight: bold;
+}
+
+div.multicol {
+	-moz-column-gap: 1em;
+	-webkit-column-gap: 1em;
+	-moz-column-count: 3;
+	-webkit-column-count: 3;
+}
+
+p.startli, p.startdd, p.starttd {
+	margin-top: 2px;
+}
+
+p.endli {
+	margin-bottom: 0px;
+}
+
+p.enddd {
+	margin-bottom: 4px;
+}
+
+p.endtd {
+	margin-bottom: 2px;
+}
+
+/* @end */
+
+caption {
+	font-weight: bold;
+}
+
+span.legend {
+        font-size: 70%;
+        text-align: center;
+}
+
+h3.version {
+        font-size: 90%;
+        text-align: center;
+}
+
+div.qindex, div.navtab{
+	background-color: #FFF8F0;
+	border: 0px solid #FF8000;
+	text-align: center;
+	margin: 2px;
+	padding: 2px;
+}
+
+div.qindex, div.navpath {
+	width: 100%;
+	line-height: 140%;
+}
+
+div.navtab {
+	margin-right: 15px;
+}
+
+/* @group Link Styling */
+
+a {
+	color: #000000;
+	font-weight: normal;
+	/*text-decoration: none;*/
+}
+
+.contents a:visited {
+	color: #606060;
+}
+/*
+.contents{
+	background-color: #FFF8F0;
+}
+*/
+a:hover {
+	text-decoration: underline;
+}
+
+a.qindex {
+	font-weight: bold;
+}
+
+a.qindexHL {
+	font-weight: bold;
+	background-color: #9CAFD4;
+	color: #ffffff;
+	border: 1px double #869DCA;
+}
+
+.contents a.qindexHL:visited {
+        color: #ffffff;
+}
+
+a.el {
+	font-weight: bold;
+}
+
+a.elRef {
+}
+
+a.code {
+	color: #4665A2;
+}
+
+a.codeRef {
+	color: #4665A2;
+}
+
+/* @end */
+
+dl.el {
+	margin-left: -1cm;
+}
+
+.fragment {
+	font-family: monospace, fixed;
+	font-size: 105%;
+}
+
+pre.fragment {
+	border: 0px solid #FF8000;
+	background-color: #FFF8F0;
+	padding: 4px 6px;
+	margin: 4px 8px 4px 2px;
+	overflow: auto;
+	word-wrap: break-word;
+	font-size:  9pt;
+	line-height: 125%;
+}
+
+div.ah {
+	background-color: black;
+	font-weight: bold;
+	color: #ffffff;
+	margin-bottom: 3px;
+	margin-top: 3px;
+	padding: 0.2em;
+	border: solid thin #333;
+	border-radius: 0.5em;
+	-webkit-border-radius: .5em;
+	-moz-border-radius: .5em;
+	box-shadow: 2px 2px 3px #999;
+	-webkit-box-shadow: 2px 2px 3px #999;
+	-moz-box-shadow: rgba(0, 0, 0, 0.15) 2px 2px 2px;
+	background-image: -webkit-gradient(linear, left top, left bottom, from(#eee), to(#000),color-stop(0.3, #444));
+	background-image: -moz-linear-gradient(center top, #eee 0%, #444 40%, #000);
+}
+
+div.groupHeader {
+	margin-left: 16px;
+	margin-top: 12px;
+	font-weight: bold;
+}
+
+div.groupText {
+	margin-left: 16px;
+	font-style: italic;
+}
+
+body {
+	background: white;
+	color: black;
+        margin: 0;
+}
+
+div.contents 
+{
+    background-color:#FFF8F0;
+	padding-top: 10px;
+	padding-left: 10px;
+	padding-right: 10px;
+}
+
+td.indexkey {
+	font-weight: bold;
+	border: 0px solid #C4CFE5;
+	margin: 2px 0px 2px 0;
+	padding: 4px 10px;
+}
+
+td.indexvalue {
+	border: 0px solid #C4CFE5;
+	padding: 2px 10px;
+	margin: 2px 0px;
+}
+
+tr.memlist {
+	background-color: #FFF8F0;
+}
+
+p.formulaDsp {
+	text-align: center;
+}
+
+img.formulaDsp {
+	
+}
+
+img.formulaInl {
+	vertical-align: middle;
+}
+
+div.center {
+	text-align: center;
+        margin-top: 0px;
+        margin-bottom: 0px;
+        padding: 0px;
+}
+
+div.center img {
+	border: 0px;
+}
+
+address.footer {
+	text-align: right;
+	padding-right: 12px;
+}
+
+img.footer {
+	border: 0px;
+	vertical-align: middle;
+}
+
+/* @group Code Colorization */
+
+span.keyword {
+	color: #008000
+}
+
+span.keywordtype {
+	color: #604020
+}
+
+span.keywordflow {
+	color: #e08000
+}
+
+span.comment {
+	color: #800000
+}
+
+span.preprocessor {
+	color: #806020
+}
+
+span.stringliteral {
+	color: #002080
+}
+
+span.charliteral {
+	color: #008080
+}
+
+span.vhdldigit { 
+	color: #ff00ff 
+}
+
+span.vhdlchar { 
+	color: #000000 
+}
+
+span.vhdlkeyword { 
+	color: #700070 
+}
+
+span.vhdllogic { 
+	color: #ff0000 
+}
+
+/* @end */
+
+/*
+.search {
+	color: #003399;
+	font-weight: bold;
+}
+
+form.search {
+	margin-bottom: 0px;
+	margin-top: 0px;
+}
+
+input.search {
+	font-size: 75%;
+	color: #000080;
+	font-weight: normal;
+	background-color: #e8eef2;
+}
+*/
+
+td.tiny {
+	font-size: 75%;
+}
+
+.dirtab {
+	padding: 4px;
+	border-collapse: collapse;
+	border: 0px solid #A3B4D7;
+}
+
+th.dirtab {
+	background: #EBEFF6;
+	font-weight: bold;
+}
+
+hr {
+	height: 0px;
+	border: none;
+	border-top: 0px solid #FF8000;
+}
+
+hr.footer {
+	height: 1px;
+}
+
+/* @group Member Descriptions */
+
+table.memberdecls {
+	border-spacing: 0px;
+	padding: 0px;
+}
+
+.mdescLeft, .mdescRight,
+.memItemLeft, .memItemRight,
+.memTemplItemLeft, .memTemplItemRight, .memTemplParams {
+	background-color: #FFFCF8;
+	border: none;
+	margin: 4px;
+	padding: 1px 0 0 8px;
+}
+
+.mdescLeft, .mdescRight {
+	padding: 0px 8px 4px 8px;
+	color: #000000;
+}
+
+.memItemLeft, .memItemRight, .memTemplParams {
+	border-top: 4px solid #FFFFFF;
+}
+
+.memItemLeft, .memTemplItemLeft {
+        white-space: nowrap;
+}
+
+.memTemplParams {
+	color: #404040;
+        white-space: nowrap;
+}
+
+/* @end */
+
+/* @group Member Details */
+
+/* Styles for detailed member documentation */
+
+.memtemplate {
+	font-size: 80%;
+	color: #4665A2;
+	font-weight: normal;
+	margin-left: 9px;
+}
+
+.memnav {
+	background-color: #EBEFF6;
+	border: 1px solid #A3B4D7;
+	text-align: center;
+	margin: 2px;
+	margin-right: 15px;
+	padding: 2px;
+}
+
+.memitem {
+	padding: 0;
+	margin-bottom: 10px;
+}
+
+.memname {
+        white-space: nowrap;
+        font-weight: bold;
+        margin-left: 6px;
+}
+
+.memproto {
+        border-top: 1px solid #FF8000;
+        border-left: 1px solid #FF8000;
+        border-right: 1px solid #FF8000;
+        padding: 6px 0px 6px 0px;
+        color: #253555;
+        font-weight: bold;
+        text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);
+        /* opera specific markup */
+        box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+        border-top-right-radius: 8px;
+        border-top-left-radius: 8px;
+        /* firefox specific markup */
+        -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px;
+        -moz-border-radius-topright: 8px;
+        -moz-border-radius-topleft: 8px;
+        /* webkit specific markup */
+        -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+        -webkit-border-top-right-radius: 8px;
+        -webkit-border-top-left-radius: 8px;
+        /*background-image:url('nav_f.png');*/
+        background-repeat:repeat-x;
+        background-color: #FFF8F0;
+
+}
+
+.memdoc {
+        border-bottom: 1px solid #FF8000;      
+        border-left: 1px solid #FF8000;      
+        border-right: 1px solid #FF8000; 
+        padding: 2px 5px;
+        background-color: #FFFFFF;
+        border-top-width: 0;
+        /* opera specific markup */
+        border-bottom-left-radius: 8px;
+        border-bottom-right-radius: 8px;
+        box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+        /* firefox specific markup */
+        -moz-border-radius-bottomleft: 8px;
+        -moz-border-radius-bottomright: 8px;
+        -moz-box-shadow: rgba(0, 0, 0, 0.15) 5px 5px 5px;
+        background-image: -moz-linear-gradient(center top, #FFFFFF 0%, #FFFFFF 60%, #FFF0E0 95%, #FFF8F0);
+        /* webkit specific markup */
+        -webkit-border-bottom-left-radius: 8px;
+        -webkit-border-bottom-right-radius: 8px;
+        -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+        background-image: -webkit-gradient(linear,center top,center bottom,from(#FFFFFF), color-stop(0.6,#FFFFFF), color-stop(0.60,#FFFFFF), color-stop(0.95,#FFF0E0), to(#FFF8F0));
+}
+
+.paramkey {
+	text-align: right;
+}
+
+.paramtype {
+	white-space: nowrap;
+}
+
+.paramname {
+	color: #602020;
+	white-space: nowrap;
+}
+.paramname em {
+	font-style: normal;
+}
+
+.params, .retval, .exception, .tparams {
+        border-spacing: 6px 2px;
+}       
+
+.params .paramname, .retval .paramname {
+        font-weight: bold;
+        vertical-align: top;
+}
+        
+.params .paramtype {
+        font-style: italic;
+        vertical-align: top;
+}       
+        
+.params .paramdir {
+        font-family: "courier new",courier,monospace;
+        vertical-align: top;
+}
+
+
+
+
+/* @end */
+
+/* @group Directory (tree) */
+
+/* for the tree view */
+
+.ftvtree {
+	font-family: sans-serif;
+	margin: 0px;
+}
+
+/* these are for tree view when used as main index */
+
+.directory {
+	font-size: 9pt;
+	font-weight: bold;
+	margin: 5px;
+}
+
+.directory h3 {
+	margin: 0px;
+	margin-top: 1em;
+	font-size: 11pt;
+}
+
+/*
+The following two styles can be used to replace the root node title
+with an image of your choice.  Simply uncomment the next two styles,
+specify the name of your image and be sure to set 'height' to the
+proper pixel height of your image.
+*/
+
+/*
+.directory h3.swap {
+	height: 61px;
+	background-repeat: no-repeat;
+	background-image: url("yourimage.gif");
+}
+.directory h3.swap span {
+	display: none;
+}
+*/
+
+.directory > h3 {
+	margin-top: 0;
+}
+
+.directory p {
+	margin: 0px;
+	white-space: nowrap;
+}
+
+.directory div {
+	display: none;
+	margin: 0px;
+}
+
+.directory img {
+	vertical-align: -30%;
+}
+
+/* these are for tree view when not used as main index */
+
+.directory-alt {
+	font-size: 100%;
+	font-weight: bold;
+}
+
+.directory-alt h3 {
+	margin: 0px;
+	margin-top: 1em;
+	font-size: 11pt;
+}
+
+.directory-alt > h3 {
+	margin-top: 0;
+}
+
+.directory-alt p {
+	margin: 0px;
+	white-space: nowrap;
+}
+
+.directory-alt div {
+	display: none;
+	margin: 0px;
+}
+
+.directory-alt img {
+	vertical-align: -30%;
+}
+
+/* @end */
+
+div.dynheader {
+        margin-top: 8px;
+}
+
+address {
+	font-style: normal;
+	color: #804000;
+}
+
+table.doxtable {
+	border-collapse:collapse;
+}
+
+table.doxtable td, table.doxtable th {
+	border: 1px solid #2D4068;
+	padding: 3px 7px 2px;
+}
+
+table.doxtable th {
+	background-color: #374F7F;
+	color: #FFFFFF;
+	font-size: 110%;
+	padding-bottom: 4px;
+	padding-top: 5px;
+	text-align:left;
+}
+
+.tabsearch {
+	top: 0px;
+	left: 10px;
+	height: 36px;
+	background-image: url('tab_b.png');
+	z-index: 101;
+	overflow: hidden;
+	font-size: 13px;
+}
+
+.navpath ul
+{
+	font-size: 11px;
+	background-image:url('tab_b.png');
+	background-repeat:repeat-x;
+	height:30px;
+	line-height:30px;
+	color:#8AA0CC;
+	border:solid 1px #C2CDE4;
+	overflow:hidden;
+	margin:0px;
+	padding:0px;
+}
+
+.navpath li
+{
+	list-style-type:none;
+	float:left;
+	padding-left:10px;
+	padding-right:15px;
+	background-image:url('bc_s.png');
+	background-repeat:no-repeat;
+	background-position:right;
+	color:#364D7C;
+}
+
+.navpath li.navelem a
+{
+	height:32px;
+	display:block;
+	text-decoration: none;
+	outline: none;
+}
+
+.navpath li.navelem a:hover
+{
+	color:#FF8000;
+}
+
+.navpath li.footer
+{
+        list-style-type:none;
+        float:right;
+        padding-left:10px;
+        padding-right:15px;
+        background-image:none;
+        background-repeat:no-repeat;
+        background-position:right;
+        color:#364D7C;
+        font-size: 8pt;
+}
+
+
+div.summary
+{
+	float: right;
+	font-size: 8pt;
+	padding-right: 5px;
+	width: 50%;
+	text-align: right;
+}       
+
+div.summary a
+{
+	white-space: nowrap;
+}
+
+div.ingroups
+{
+	font-size: 8pt;
+	padding-left: 5px;
+	width: 50%;
+	text-align: left;
+}
+
+div.ingroups a
+{
+	white-space: nowrap;
+}
+
+div.header
+{
+    /*background-image:url('nav_h.png');*/
+    background-repeat:repeat-x;
+    background-color: #FFF8F0;
+    margin:  0px;
+    border-bottom: 0px solid #FFC080;
+}
+
+div.headertitle
+{
+	padding: 5px 5px 5px 10px;
+}
+
+dl
+{
+        padding: 0 0 0 10px;
+}
+
+dl.note, dl.warning, dl.attention, dl.pre, dl.post, dl.invariant, dl.deprecated, dl.todo, dl.test, dl.bug
+{
+    border-color: #FF8000;
+    border-left:4px solid;
+    padding: 0 0 0 6px;
+}
+
+dl.note
+{
+        border-color: #D0D000;
+}
+
+dl.warning, dl.attention
+{
+        border-color: #FF0000;
+}
+
+dl.pre, dl.post, dl.invariant
+{
+        border-color: #00D000;
+}
+
+dl.deprecated
+{
+        border-color: #505050;
+}
+
+dl.todo
+{
+        border-color: #00C0E0;
+}
+
+dl.test
+{
+        border-color: #3030E0;
+}
+
+dl.bug
+{
+        border-color: #C08050;
+}
+
+#projectlogo
+{
+	text-align: center;
+	vertical-align: bottom;
+	border-collapse: separate;
+}
+ 
+#projectlogo img
+{ 
+	border: 0px none;
+}
+ 
+#projectname
+{
+	font: 300% arial,sans-serif;
+	margin: 0px;
+	padding: 0px;
+}
+    
+#projectbrief
+{
+	font: 120% arial,sans-serif;
+	margin: 0px;
+	padding: 0px;
+}
+
+#projectnumber
+{
+	font: 50% arial,sans-serif;
+	margin: 0px;
+	padding: 0px;
+}
+
+#titlearea
+{
+	padding: 0px;
+	margin: 0px;
+	width: 100%;
+	border-bottom: 0px solid #FF8000;
+}
+
+#top
+{
+    /*background-color:#000000;*/
+}

doc/theme/tabs.css

@@ -0,0 +1,62 @@
+.tabs, .tabs2, .tabs3 {
+    /*background-image: url('tab_b.png');*/
+    background-color:#FFF8F0;
+    width: 100%;
+    z-index: 101;
+    font-size: 13px;
+}
+
+.tabs2 {
+    font-size: 10px;
+}
+.tabs3 {
+    font-size: 9px;
+}
+
+.tablist {
+    margin: 0;
+    padding: 0;
+    display: table;
+}
+
+.tablist li {
+    float: left;
+    display: table-cell;
+    /*background-image: url('tab_b.png');*/
+    line-height: 36px;
+    list-style: none;
+}
+
+.tablist a {
+    display: block;
+    padding: 0 20px;
+    font-weight: bold;
+    /*background-image:url('tab_s.png');*/
+    background-repeat:no-repeat;
+    background-position:right;
+    color: #FF8000;
+    /*text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);*/
+    text-decoration: none;
+    outline: none;
+}
+
+.tabs3 .tablist a {
+    padding: 0 10px;
+}
+
+.tablist a:hover {
+    /*background-image: url('tab_h.png');*/
+    background-color:#FFFEFD;
+    background-repeat:repeat-x;
+    color: #FF8000;
+    /*text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0);*/
+    text-decoration:underline;
+}
+
+.tablist li.current a {
+    /*background-image: url('tab_a.png');*/
+    background-color:#FFFEFD;
+    background-repeat:repeat-x;
+    color: #FF8000;
+    /*text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0);*/
+}

doc/virtrevModules.doxy

@@ -0,0 +1,14 @@
+/*!
+	\defgroup virtrev VIRTREV Extensions
+	
+	\brief Extensions develop and maintain by Mathieu [matrem] Roumillac (http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showprofile&User=22660).
+**/
+
+/*!
+	\defgroup virtrev_xstream GLM_VIRTREV_xstream: xml like output
+	\ingroup virtrev
+	
+	\brief Streaming vector and matrix in a xml way.
+
+	Include <glm/virtrev/xstream.hpp> for this functionality.
+**/

glm/core/func_common.hpp

@@ -21,6 +21,9 @@ namespace glm
 	//! Define common functions from Section 8.3 of GLSL 1.30.8 specification. Included in glm namespace.
 	namespace common{
 
+	/// \addtogroup core_funcs
+	///@{
+
 	//! Returns x if x >= 0; otherwise, it returns -x. 
 	//! (From GLSL 1.30.08 specification, section 8.3)
 	template <typename genFIType> 
@@ -262,6 +265,8 @@ namespace glm
 	template <typename genType, typename genIType>
 	genType ldexp(genType const & x, genIType const & exp);
 
+	///@}
+
 	}//namespace common
 	}//namespace function
 	}//namespace core

glm/core/func_exponential.hpp

@@ -21,6 +21,9 @@ namespace glm
 	//! Define all exponential functions from Section 8.2 of GLSL 1.30.8 specification. Included in glm namespace.
 	namespace exponential{
 
+	/// \addtogroup core_funcs
+	///@{
+
 	//! Returns x raised to the y power. 
 	//! (From GLSL 1.30.08 specification, section 8.2)
 	template <typename genType> 
@@ -59,6 +62,8 @@ namespace glm
 	template <typename genType> 
 	genType inversesqrt(genType const & x);
 
+	///@}
+
 	}//namespace exponential
 	}//namespace function
 	}//namespace core

glm/core/func_geometric.hpp

@@ -21,6 +21,9 @@ namespace glm
 	//! Define all geometric functions from Section 8.4 of GLSL 1.30.8 specification. Included in glm namespace.
 	namespace geometric{
 
+	/// \addtogroup core_funcs
+	///@{
+
 	//! Returns the length of x, i.e., sqrt(x * x).
 	//! (From GLSL 1.30.08 specification, section 8.4)
 	template <typename genType> 
@@ -80,6 +83,8 @@ namespace glm
 		genType const & N, 
 		typename genType::value_type const & eta);
 
+	///@}
+
 	}//namespace geometric
 	}//namespace function
 	}//namespace core

glm/core/func_integer.hpp

@@ -21,6 +21,9 @@ namespace glm
 	//! Define integer functions from Section 8.8 of GLSL 4.00.8 specification. 
 	namespace integer{
 
+		/// \addtogroup core_funcs
+		///@{
+
 		//! Adds 32-bit unsigned integer x and y, returning the sum
 		//! modulo pow(2, 32). The value carry is set to 0 if the sum was
 		//! less than pow(2, 32), or to 1 otherwise.
@@ -128,6 +131,8 @@ namespace glm
 		template <typename T, template <typename> class C>
 		typename C<T>::signed_type findMSB(C<T> const & Value);
 
+		///@}
+
 	}//namespace integer
 	}//namespace function
 	}//namespace core

glm/core/func_matrix.hpp

@@ -21,6 +21,9 @@ namespace glm
 	//! Define all matrix functions from Section 8.5 of GLSL 1.30.8 specification. Included in glm namespace.
 	namespace matrix{
 
+	/// \addtogroup core_funcs
+	///@{
+
 	//! Multiply matrix x by matrix y component-wise, i.e., 
 	//! result[i][j] is the scalar product of x[i][j] and y[i][j].
 	//! (From GLSL 1.30.08 specification, section 8.5)
@@ -80,6 +83,8 @@ namespace glm
 	detail::tmat4x4<T> inverse(
 		detail::tmat4x4<T> const & m);
 
+	///@}
+
 	}//namespace matrix
 	}//namespace function
 	}//namespace core

glm/core/func_noise.hpp

@@ -21,6 +21,9 @@ namespace glm
 	// Define all noise functions from Section 8.9 of GLSL 1.30.8 specification. Included in glm namespace.
 	namespace noise{
 
+	/// \addtogroup core_funcs
+	///@{
+
 	// Returns a 1D noise value based on the input value x.
 	// From GLSL 1.30.08 specification, section 8.9.
 	template <typename genType>
@@ -41,6 +44,8 @@ namespace glm
 	template <typename genType>
 	detail::tvec4<typename genType::value_type> noise4(genType const & x);
 
+	///@}
+
 	}//namespace noise
 	}//namespace function
 	}//namespace core

glm/core/func_packing.hpp

@@ -21,6 +21,9 @@ namespace glm
 	//! Define packing functions from section 8.4 floating-point pack and unpack functions of GLSL 4.00.8 specification
 	namespace packing
 	{
+		/// \addtogroup core_funcs
+		///@{
+
 		detail::uint32 packUnorm2x16(detail::tvec2<detail::float32> const & v);
 		detail::uint32 packUnorm4x8(detail::tvec4<detail::float32> const & v);
 		detail::uint32 packSnorm4x8(detail::tvec4<detail::float32> const & v);
@@ -32,6 +35,8 @@ namespace glm
 		double packDouble2x32(detail::tvec2<detail::uint32> const & v);
 		detail::tvec2<detail::uint32> unpackDouble2x32(double const & v);
 
+		///@}
+
 	}//namespace packing
 	}//namespace function
 	}//namespace core

glm/core/func_trigonometric.hpp

@@ -23,6 +23,9 @@ namespace glm
 	//! Included in glm namespace.
 	namespace trigonometric{
 
+	/// \addtogroup core_funcs
+	///@{
+
 	//! Converts degrees to radians and returns the result.
 	//! (From GLSL 1.30.08 specification, section 8.1)
 	template <typename genType> 
@@ -111,6 +114,8 @@ namespace glm
 	template <typename genType> 
 	genType atanh(genType const & x);
 
+	///@}
+
 	}//namespace trigonometric
 	}//namespace function
 	}//namespace core

glm/core/func_vector_relational.hpp

@@ -24,6 +24,9 @@ namespace glm
 	//! Included in glm namespace.
 	namespace vector_relational
 	{
+		/// \addtogroup core_funcs
+		///@{
+
 		//! Returns the component-wise comparison result of x < y.
 		//! (From GLSL 1.30.08 specification, section 8.6)
 		template <typename T, template <typename> class vecType> 
@@ -183,6 +186,8 @@ namespace glm
 			return Result;
 		}
 
+		///@}
+
 	}//namespace vector_relational
 	}//namespace function
 	}//namespace core

glm/core/type.hpp

@@ -80,64 +80,79 @@ namespace type
 #else
 	//! 2 components vector of floating-point numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_vec2		vec2;
 
 	//! 3 components vector of floating-point numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_vec3		vec3;
 
 	//! 4 components vector of floating-point numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_vec4		vec4;
 
 	//! 2 columns of 2 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat2x2		mat2x2;
 
 	//! 2 columns of 3 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat2x3		mat2x3;
 
 	//! 2 columns of 4 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat2x4		mat2x4;
 
 	//! 3 columns of 2 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat3x2		mat3x2;
 
 	//! 3 columns of 3 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat3x3		mat3x3;
 
 	//! 3 columns of 4 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat3x4		mat3x4;
 
 	//! 4 columns of 2 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat4x2		mat4x2;
 
 	//! 4 columns of 3 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat4x3		mat4x3;
 
 	//! 4 columns of 4 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat4x4		mat4x4;
 
 #endif//GLM_PRECISION
 
 	//! 2 columns of 2 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef mat2x2							mat2;
 
 	//! 3 columns of 3 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef mat3x3							mat3;
 
 	//! 4 columns of 4 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef mat4x4							mat4;
 
 	//////////////////////////
@@ -158,14 +173,17 @@ namespace type
 #else
 	//! 2 components vector of signed integer numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_ivec2		ivec2;
 
 	//! 3 components vector of signed integer numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_ivec3		ivec3;
 
 	//! 4 components vector of signed integer numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_ivec4		ivec4;
 #endif//GLM_PRECISION
 
@@ -187,14 +205,17 @@ namespace type
 #else
 	//! 2 components vector of unsigned integer numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_uvec2		uvec2;
 
 	//! 3 components vector of unsigned integer numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_uvec3		uvec3;
 
 	//! 4 components vector of unsigned integer numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_uvec4		uvec4;
 #endif//GLM_PRECISION
 
@@ -203,14 +224,17 @@ namespace type
 
 	//! 2 components vector of boolean. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef detail::tvec2<bool>		bvec2;
 
 	//! 3 components vector of boolean. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef detail::tvec3<bool>		bvec3;
 
 	//! 4 components vector of boolean. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef detail::tvec4<bool>		bvec4;
 
 	//////////////////////////
@@ -218,62 +242,77 @@ namespace type
 
 	//! Vector of 2 double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tvec2<double>	dvec2;
 
 	//! Vector of 3 double-precision floating-point numbers.
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tvec3<double>	dvec3;
 
 	//! Vector of 4 double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tvec4<double>	dvec4;
 
 	//! 2 * 2 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat2x2<double>	dmat2;
 
 	//! 3 * 3 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat3x3<double>	dmat3;
 
 	//! 4 * 4 matrix of double-precision floating-point numbers.
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat4x4<double>	dmat4;
 
 	//! 2 * 2 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat2x2<double>	dmat2x2;
 
 	//! 2 * 3 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat2x3<double>	dmat2x3;
 
 	//! 2 * 4 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat2x4<double>	dmat2x4;
 
 	//! 3 * 2 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat3x2<double>	dmat3x2;
 
 	//! 3 * 3 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat3x3<double>	dmat3x3;
 
 	//! 3 * 4 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat3x4<double>	dmat3x4;
 
 	//! 4 * 2 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat4x2<double>	dmat4x2;
 
 	//! 4 * 3 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat4x3<double>	dmat4x3;
 
 	//! 4 * 4 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat4x4<double>	dmat4x4;
 
 }//namespace type

glm/core/type_float.hpp

@@ -38,16 +38,19 @@ namespace glm
 		typedef double				highp_float_t;
 
 		//! Low precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification
+		//! \ingroup core_precision
 		typedef lowp_float_t		lowp_float;
 		//! Medium precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification
+		//! \ingroup core_precision
 		typedef mediump_float_t		mediump_float;
 		//! High precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification
+		//! \ingroup core_precision
 		typedef highp_float_t		highp_float;
 	}
 	//namespace precision

glm/core/type_half.hpp

@@ -27,6 +27,8 @@ namespace glm
 		float toFloat32(hdata value);
 		hdata toFloat16(float const & value);
 
+		///16-bit floating point type.
+		/// \ingroup gtc_half_float
 		class thalf
 		{
 		public: 

glm/core/type_int.hpp

@@ -63,32 +63,39 @@ namespace glm
 	namespace core{
 	namespace type{
 
+	///namespace for precision stuff.
 	namespace precision
 	{
 		//! Low precision signed integer. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
 		typedef detail::lowp_int_t				lowp_int;
 		//! Medium precision signed integer. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
 		typedef detail::mediump_int_t			mediump_int;
 		//! High precision signed integer.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
 		typedef detail::highp_int_t				highp_int;
 
 		//! Low precision unsigned integer. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
 		typedef detail::lowp_uint_t				lowp_uint;
 		//! Medium precision unsigned integer. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
 		typedef detail::mediump_uint_t			mediump_uint;
 		//! High precision unsigned integer. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
 		typedef detail::highp_uint_t			highp_uint;
 	}
 	//namespace precision

glm/core/type_mat2x2.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 2 * 2 matrix of floating-point numbers.
+		//! \brief Template for 2 * 2 matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat2x2
 		{
@@ -222,16 +223,19 @@ namespace glm
 	namespace precision
 	{
 		//! 2 columns of 2 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat2x2<lowp_float>		lowp_mat2x2;
 		//! 2 columns of 2 components matrix of medium precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat2x2<mediump_float>	mediump_mat2x2;
 		//! 2 columns of 2 components matrix of high precision floating-point numbers. 
-		//! There is no garanty on the actual precision. 
+		//! There is no guarantee on the actual precision. 
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat2x2<highp_float>	highp_mat2x2;
 	}
 	//namespace precision

glm/core/type_mat2x3.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 2 columns and 3 rows matrix of floating-point numbers.
+		//! \brief Template for 2 columns and 3 rows matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat2x3
 		{
@@ -189,16 +190,19 @@ namespace glm
 	namespace precision
 	{
 		//! 2 columns of 3 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat2x3<lowp_float>		lowp_mat2x3;
 		//! 2 columns of 3 components matrix of medium precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat2x3<mediump_float>	mediump_mat2x3;
 		//! 2 columns of 3 components matrix of high precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat2x3<highp_float>	highp_mat2x3;
 	}
 	//namespace precision

glm/core/type_mat2x4.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 2 columns and 4 rows matrix of floating-point numbers.
+		//! Template for 2 columns and 4 rows matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat2x4
 		{
@@ -189,15 +190,15 @@ namespace glm
 	namespace precision
 	{
 		//! 2 columns of 4 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat2x4<lowp_float>		lowp_mat2x4;
 		//! 2 columns of 4 components matrix of medium precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat2x4<mediump_float>	mediump_mat2x4;
 		//! 2 columns of 4 components matrix of high precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat2x4<highp_float>	highp_mat2x4;
 	}

glm/core/type_mat3x2.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 3 columns and 2 rows matrix of floating-point numbers.
+		//! \brief Template for 3 columns and 2 rows matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat3x2
 		{
@@ -191,15 +192,15 @@ namespace glm
 	namespace precision
 	{
 		//! 3 columns of 2 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat3x2<lowp_float>		lowp_mat3x2;
 		//! 3 columns of 2 components matrix of medium precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat3x2<mediump_float>	mediump_mat3x2;
 		//! 3 columns of 2 components matrix of high precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat3x2<highp_float>	highp_mat3x2;
 	}

glm/core/type_mat3x3.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 3 * 3 matrix of floating-point numbers.
+		//! \brief Template for 3 * 3 matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat3x3
 		{
@@ -221,16 +222,19 @@ namespace glm
 	namespace precision
 	{
 		//! 3 columns of 3 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat3x3<lowp_float>		lowp_mat3x3;
 		//! 3 columns of 3 components matrix of medium precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat3x3<mediump_float>	mediump_mat3x3;
 		//! 3 columns of 3 components matrix of high precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat3x3<highp_float>	highp_mat3x3;
 	}
 	//namespace precision

glm/core/type_mat3x4.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 3 columns and 4 rows matrix of floating-point numbers.
+		//! \brief Template for 3 columns and 4 rows matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat3x4
 		{
@@ -191,15 +192,15 @@ namespace glm
 	namespace precision
 	{
 		//! 3 columns of 4 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat3x4<lowp_float>		lowp_mat3x4;
 		//! 3 columns of 4 components matrix of medium precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat3x4<mediump_float>	mediump_mat3x4;
 		//! 3 columns of 4 components matrix of high precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat3x4<highp_float>	highp_mat3x4;
 	}

glm/core/type_mat4x2.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 4 columns and 2 rows matrix of floating-point numbers.
+		//! \brief Template for 4 columns and 2 rows matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat4x2
 		{
@@ -193,16 +194,19 @@ namespace glm
 	namespace precision
 	{
 		//! 4 columns of 2 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x2<lowp_float>		lowp_mat4x2;
 		//! 4 columns of 2 components matrix of medium precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x2<mediump_float>	mediump_mat4x2;
 		//! 4 columns of 2 components matrix of high precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x2<highp_float>	highp_mat4x2;
 	}
 	//namespace precision

glm/core/type_mat4x3.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 4 columns and 3 rows matrix of floating-point numbers.
+		//! \brief Template for 4 columns and 3 rows matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat4x3
 		{
@@ -193,16 +194,19 @@ namespace glm
 	namespace precision
 	{
 		//! 4 columns of 3 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x3<lowp_float>		lowp_mat4x3;
 		//! 4 columns of 3 components matrix of medium precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x3<mediump_float>	mediump_mat4x3;
 		//! 4 columns of 3 components matrix of high precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x3<highp_float>	highp_mat4x3;
 	}
 	//namespace precision

glm/core/type_mat4x4.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 4 * 4 matrix of floating-point numbers.
+		//! \brief Template for 4 * 4 matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat4x4
 		{
@@ -221,16 +222,19 @@ namespace glm
 	namespace precision
 	{
 		//! 4 columns of 4 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x4<lowp_float>		lowp_mat4x4;
 		//! 4 columns of 4 components matrix of medium precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x4<mediump_float>	mediump_mat4x4;
 		//! 4 columns of 4 components matrix of high precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x4<highp_float>	highp_mat4x4;
 	}
 	//namespace precision

glm/core/type_vec2.hpp

@@ -32,6 +32,8 @@ namespace glm
 		template <typename T> struct tvec3;
 		template <typename T> struct tvec4;
 
+		//! The basic 2D vector type.
+		//! \ingroup core_template
 		template <typename T>
 		struct tvec2
 		{
@@ -203,42 +205,51 @@ namespace glm
 	namespace precision
 	{
 		//! 2 components vector of high precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<highp_float>		highp_vec2;
 		//! 2 components vector of medium precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<mediump_float>	mediump_vec2;
 		//! 2 components vector of low precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<lowp_float>		lowp_vec2;
 
 		//! 2 components vector of high precision signed integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<highp_int>		highp_ivec2;
 		//! 2 components vector of medium precision signed integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<mediump_int>		mediump_ivec2;
 		//! 2 components vector of low precision signed integer numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<lowp_int>			lowp_ivec2;
 	
 		//! 2 components vector of high precision unsigned integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<highp_uint>		highp_uvec2;
 		//! 2 components vector of medium precision unsigned integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<mediump_uint>		mediump_uvec2;
 		//! 2 components vector of low precision unsigned integer numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<lowp_uint>		lowp_uvec2;
 	}
 	//namespace precision

glm/core/type_vec3.hpp

@@ -31,6 +31,8 @@ namespace glm
 		template <typename T> struct tvec2;
 		template <typename T> struct tvec4;
 
+		//! Basic 3D vector type.
+		//! \ingroup core_template
 		template <typename T>
 		struct tvec3
 		{	
@@ -208,42 +210,51 @@ namespace glm
 	namespace precision
 	{
 		//! 3 components vector of high precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<highp_float>		highp_vec3;
 		//! 3 components vector of medium precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<mediump_float>	mediump_vec3;
 		//! 3 components vector of low precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<lowp_float>		lowp_vec3;
 
 		//! 3 components vector of high precision signed integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<highp_int>		highp_ivec3;
 		//! 3 components vector of medium precision signed integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<mediump_int>		mediump_ivec3;
 		//! 3 components vector of low precision signed integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<lowp_int>			lowp_ivec3;
 
 		//! 3 components vector of high precision unsigned integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<highp_uint>		highp_uvec3;
 		//! 3 components vector of medium precision unsigned integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<mediump_uint>		mediump_uvec3;
 		//! 3 components vector of low precision unsigned integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<lowp_uint>		lowp_uvec3;
 	}
 	//namespace precision

glm/core/type_vec4.hpp

@@ -32,6 +32,8 @@ namespace glm
 		template <typename T> struct tvec2;
 		template <typename T> struct tvec3;
 
+		///Basic 4D vector type.
+		//! \ingroup core_template
 		template <typename T>
 		struct tvec4
 		{
@@ -225,42 +227,51 @@ namespace glm
 	namespace precision
 	{
 		//! 4 components vector of high precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<highp_float>		highp_vec4;
 		//! 4 components vector of medium precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<mediump_float>	mediump_vec4;
 		//! 4 components vector of low precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<lowp_float>		lowp_vec4;
 
 		//! 4 components vector of high precision signed integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<highp_int>		highp_ivec4;
 		//! 4 components vector of medium precision signed integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<mediump_int>		mediump_ivec4;
 		//! 4 components vector of low precision signed integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<lowp_int>			lowp_ivec4;
 
 		//! 4 components vector of high precision unsigned integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<highp_uint>		highp_uvec4;
 		//! 4 components vector of medium precision unsigned integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<mediump_uint>		mediump_uvec4;
 		//! 4 components vector of low precision unsigned integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<lowp_uint>		lowp_uvec4;
 	}
 	//namespace precision

glm/glm.hpp

@@ -7,26 +7,6 @@
 // File    : glm/glm.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-/*! \mainpage OpenGL Mathematics
- *
- * OpenGL Mathematics (GLM) is a C++ mathematics library for 3D applications based on the OpenGL Shading Language (GLSL) specification. 
- *
- * GLM provides 3D programmers with math classes and functions that are similar to GLSL or any high level GPU programming language. The idea is to have a library that has identical naming conventions and functionalities than GLSL so that when developers know GLSL, they know how to use GLM.
- *
- * However, this project isn't limited by GLSL features. An extension system, based on the GLSL extension conventions, allows extended capabilities.
- *
- * This library can be used with OpenGL but also for software rendering (Raytracing / Rasterisation), image processing and as much contexts as a simple math library could be used for.
- *
- * GLM is written as a platform independent library and supports the following compilers: 
- * - GNU GCC 3.4 and higher 
- * - Microsoft Visual Studio 8.0 and higher
- * 
- * The source code is under the MIT licence.
- * 
- * Any feedback is welcome and can be sent to glm@g-truc.net.
- *
- */
-
 #ifndef glm_glm
 #define glm_glm
 
@@ -42,8 +22,8 @@
 
 //! TODO: to delete
 #define GLMvalType typename genType::value_type
-#define GLMcolType typename genType::col_type
-#define GLMrowType typename genType::row_type
+//#define GLMcolType typename genType::col_type
+//#define GLMrowType typename genType::row_type
 
 #include <cmath>
 #include <climits>
@@ -65,7 +45,7 @@ namespace glm
 		bool main_core();
 	}//namespace test
 
-	//! GLM core. Namespace that includes all the feature define by GLSL 1.30.8 specification. This namespace is included in glm namespace.
+	//! GLM core. Namespace that includes all the feature define by GLSL 4.10.6 specification. This namespace is included in glm namespace.
 	namespace core
 	{
 		//! Scalar, vectors and matrices 
@@ -87,9 +67,6 @@ namespace glm
 	//! The interface could change between releases.
 	namespace gtx{}
 
-	//! IMG extensions.
-	namespace img{}
-
 	//! VIRTREV extensions.
 	namespace img{}
 

glm/gtc/half_float.hpp

@@ -326,6 +326,9 @@ namespace glm
 	//! GLM_GTC_half_float extension: Add support for half precision floating-point types
 	namespace half_float
 	{
+		/// \addtogroup gtc_half_float
+		///@{
+
 		//! Type for half-precision floating-point numbers. 
 		//! From GLM_GTC_half_float extension.
 		typedef detail::thalf					half;
@@ -354,6 +357,8 @@ namespace glm
 		//! From GLM_GTC_half_float extension.
 		typedef detail::tmat4x4<detail::thalf>	hmat4;
 
+		///@}
+
 	}//namespace half_float
 	}//namespace gtc
 }//namespace glm

glm/gtc/matrix_access.hpp

@@ -25,6 +25,9 @@ namespace gtc{
 //! GLM_GTC_matrix_access extension: Set a column or a row of a matrix
 namespace matrix_access
 {
+	/// \addtogroup gtc_matrix_access
+	///@{
+
 	//! Get a specific row of a matrix.
 	//! From GLM_GTC_matrix_access extension.
 	template <typename genType> 
@@ -55,6 +58,8 @@ namespace matrix_access
 		int index, 
 		typename genType::col_type const & x);
 
+	///@}
+
 }//namespace matrix_access
 }//namespace gtc
 }//namespace glm

glm/gtc/matrix_integer.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTC_matrix_integer extension: Add integer matrices
 	namespace matrix_integer
 	{
+		/// \addtogroup gtc_matrix_integer
+		///@{
+
 		typedef detail::tmat2x2<highp_int>				highp_imat2;	//!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef detail::tmat3x3<highp_int>				highp_imat3;	//!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef detail::tmat4x4<highp_int>				highp_imat4;	//!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
@@ -201,6 +204,8 @@ namespace glm
 		typedef mediump_umat4x4							umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
 #endif//GLM_PRECISION
 
+		///@}
+
 	}//namespace matrix_integer
 	}//namespace gtc
 }//namespace glm

glm/gtc/matrix_inverse.hpp

@@ -25,6 +25,9 @@ namespace gtc{
 //! GLM_GTC_matrix_inverse extension: Inverse matrix functions
 namespace matrix_inverse
 {
+	/// \addtogroup gtc_matrix_inverse
+	///@{
+
 	//! Fast matrix inverse for affine matrix.
 	//! From GLM_GTC_matrix_inverse extension.
 	template <typename genType> 
@@ -36,6 +39,8 @@ namespace matrix_inverse
 	inline typename genType::value_type inverseTranspose(
 		genType const & m);
 
+	///@}
+
 }//namespace matrix_inverse
 }//namespace gtc
 }//namespace glm

glm/gtc/matrix_transform.hpp

@@ -31,6 +31,9 @@ namespace glm
 	//! GLM_GTC_matrix_transform extension: Add transformation matrices
 	namespace matrix_transform
 	{
+		/// \addtogroup gtc_matrix_transform
+		///@{
+
 		//! Builds a translation 4 * 4 matrix created from a vector of 3 components.
 		//! From GLM_GTC_matrix_transform extension.
 		template <typename T> 
@@ -149,6 +152,7 @@ namespace glm
 			detail::tvec3<T> const & center, 
 			detail::tvec3<T> const & up);
 
+		///@}
 	}//namespace matrix_transform
 	}//namespace gtc
 }//namespace glm

glm/gtc/quaternion.hpp

@@ -36,6 +36,7 @@ namespace glm
 	{
 		//! \brief Template for quaternion. 
 		//! From GLM_GTC_quaternion extension.
+		/// \ingroup gtc_quaternion
 		template <typename T> 
 		struct tquat// : public genType<T, tquat>
 		{
@@ -124,6 +125,9 @@ namespace glm
 	//! GLM_GTC_quaternion extension: Quaternion types and functions
     namespace quaternion
     {
+		/// \addtogroup gtc_quaternion
+		///@{
+
 		//! Returns the length of the quaternion x. 
 		//! From GLM_GTC_quaternion extension.
         template <typename T> 
@@ -218,6 +222,8 @@ namespace glm
 		//! From GLM_GTC_quaternion extension.
 		typedef detail::tquat<double>	dquat;
 
+		///@}
+
     }//namespace quaternion
     }//namespace gtc
 } //namespace glm

glm/gtc/type_precision.hpp

@@ -43,6 +43,9 @@ namespace glm
 		///////////////////////////
 		// Signed int vector types 
 
+		/// \addtogroup gtc_type_precision
+		///@{
+
 		typedef detail::int8						int8;         //!< \brief 8bit signed integer. (from GLM_GTC_type_precision extension)
 		typedef detail::int16						int16;        //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension)
 		typedef detail::int32						int32;        //!< \brief 32bit signed integer. (from GLM_GTC_type_precision extension)
@@ -210,6 +213,8 @@ namespace glm
 		typedef detail::tquat<f32>					f32quat;    //!< \brief Single-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
 		typedef detail::tquat<f64>					f64quat;    //!< \brief Double-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
 
+		///@}
+
 	}//namespace type_precision
 	}//namespace gtc
 }//namespace glm

glm/gtc/type_ptr.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTC_type_ptr extension: Get access to vectors & matrices value type address.
 	namespace type_ptr{
 
+		/// \addtogroup gtc_type_ptr
+		///@{
+
 		//! Get the const address of the vector content.
 		//! From GLM_GTC_type_ptr extension.
 		template<typename T>
@@ -291,6 +294,8 @@ namespace glm
 			return &(mat[0].x);
 		}
 
+		///@}
+
 	}//namespace type_ptr
 	}//namespace gtc
 }//namespace glm

glm/gtx/associated_min_max.hpp

@@ -32,6 +32,9 @@ namespace glm
 		//! GLM_GTX_associated_min_max extension: Min and max functions that return associated values not the compared onces.
 		namespace associated_min_max
 		{
+			/// \addtogroup gtx_associated_min_max
+			///@{
+
 			//! \brief Min comparison between 2 variables
 			template<typename genTypeT, typename genTypeU>
 			genTypeU associatedMin(
@@ -73,6 +76,7 @@ namespace glm
 				const genTypeT& y, const genTypeU& b, 
 				const genTypeT& z, const genTypeU& c, 
 				const genTypeT& w, const genTypeU& d);
+			///@}
 
 		}//namespace associated_min_max
 

glm/gtx/bit.hpp

@@ -34,6 +34,8 @@ namespace glm
 	{
 		using namespace gtc::half_float;
 
+		/// \addtogroup gtx_bit
+		///@{
 		//! Build a mask of 'count' bits
 		//! From GLM_GTX_bit extension.
 		template <typename genIType>
@@ -97,6 +99,7 @@ namespace glm
 		//! From GLM_GTX_bit extension.
 		template <typename genType>
 		genType bitRotateLeft(genType const & In, std::size_t Shift);
+		///@}
 
 	}//namespace bit
 	}//namespace gtx

glm/gtx/closest_point.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_closest_point extension: Find the point on a straight line which is the closet of a point.
 	namespace closest_point{
 
+	/// \addtogroup gtx_closest_point
+	///@{
+
 	//! Find the point on a straight line which is the closet of a point. 
 	//! From GLM_GTX_closest_point extension.
 	template <typename T> 
@@ -37,6 +40,7 @@ namespace glm
 		detail::tvec3<T> const & point, 
 		detail::tvec3<T> const & a, 
 		detail::tvec3<T> const & b);
+	///@}
 
 	}//namespace closest_point
 	}//namespace gtx

glm/gtx/color_cast.hpp

@@ -34,6 +34,9 @@ namespace glm
 	{
 		using namespace gtx::number_precision;
 
+		/// \addtogroup gtx_color_cast
+		///@{
+
 		//! Conversion of a floating value into a 8bit unsigned int value. 
 		//! From GLM_GTX_color_cast extension.
 		template <typename valType> gtc::type_precision::uint8 u8channel_cast(valType a);
@@ -97,6 +100,8 @@ namespace glm
 		template <typename T> gtc::type_precision::f64vec4 f64_argb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
 		template <typename T> gtc::type_precision::f64vec4 f64_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
 		template <typename T> gtc::type_precision::f64vec4 f64_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+
+		///@}
 	}//namespace color_space
 	}//namespace gtx
 }//namespace glm

glm/gtx/color_space.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_color_space extension: Related to RGB to HSV conversions and operations
     namespace color_space
     {
+		/// \addtogroup gtx_color_space
+		///@{
+
 		//! Converts a color from HSV color space to its color in RGB color space.
 		//! From GLM_GTX_color_space extension.
         template <typename valType> 
@@ -68,6 +71,8 @@ namespace glm
 		valType luminosity(
 			detail::tvec3<valType> const & color);
 
+		///@}
+		
 	}//namespace color_space
 	}//namespace gtx
 }//namespace glm

glm/gtx/color_space_YCoCg.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_color_space_YCoCg extension: RGB to YCoCg conversions and operations
     namespace color_space_YCoCg
     {
+		/// \addtogroup gtx_color_space_YCoCg
+		///@{
+
         //! Convert a color from RGB color space to YCoCg color space.
 		//! From GLM_GTX_color_space_YCoCg extension.
 		template <typename valType> 
@@ -56,6 +59,7 @@ namespace glm
 		detail::tvec3<valType> YCoCgR2rgb(
 			detail::tvec3<valType> const & YCoCgColor);
 
+		///@}
 	}//namespace color_space_YCoCg
 	}//namespace gtx
 }//namespace glm

glm/gtx/compatibility.hpp

@@ -38,6 +38,9 @@ namespace glm
 	//! GLM_GTX_compatibility extension: Provide functions to increase the compatibility with Cg and HLSL languages
 	namespace compatibility
 	{
+		/// \addtogroup gtx_compatibility
+		///@{
+
 		template <typename T> inline T lerp(T x, T y, T a){return mix(x, y, a);}																					//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
 		template <typename T> inline detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
 		template <typename T> inline detail::tvec3<T> lerp(const detail::tvec3<T>& x, const detail::tvec3<T>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
@@ -151,6 +154,8 @@ namespace glm
 		typedef detail::tmat4x3<double>		double4x3;		//!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
 		typedef detail::tmat4x4<double>		double4x4;		//!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
+		///@}
+
 	}//namespace compatibility
 	}//namespace gtx
 }//namespace glm

glm/gtx/component_wise.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_component_wise extension: Operations between components of a type
 	namespace component_wise
 	{
+		/// \addtogroup gtx_component_wise
+		///@{
+
 		//! Add all vector components together. 
 		//! From GLM_GTX_component_wise extension.
 		template <typename genType> 
@@ -54,6 +57,8 @@ namespace glm
 		typename genType::value_type compMax(
 			genType const & v);
 
+		///@}
+
 	}//namespace component_wise
 	}//namespace gtx
 }//namespace glm

glm/gtx/epsilon.hpp

@@ -29,9 +29,12 @@ namespace glm
 	}//namespace test
 
 	namespace gtx{
-	//! GLM_GTX_epsilon extension: Comparaison functions for a user defined epsilon values.
+	//! GLM_GTX_epsilon extension: Comparison functions for a user defined epsilon values.
 	namespace epsilon
 	{
+		/// \addtogroup gtx_epsilon
+		///@{
+
 		//! Returns the component-wise compare of |x - y| < epsilon.
 		//! From GLM_GTX_epsilon extension.
 		template <typename genTypeT, typename genTypeU> 
@@ -48,6 +51,8 @@ namespace glm
 			genTypeT const & y, 
 			genTypeU const & epsilon);
 
+		///@}
+
 	}//namespace epsilon
 	}//namespace gtx
 }//namespace glm

glm/gtx/euler_angles.hpp

@@ -29,9 +29,12 @@
 namespace glm
 {
     namespace gtx{
-	//! GLM_GTX_euler_angles extension: Build matrices from euler angles.
+	//! GLM_GTX_euler_angles extension: Build matrices from Euler angles.
 	namespace euler_angles
 	{
+		/// \addtogroup gtx_euler_angles
+		///@{
+
 		//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
 		//! From GLM_GTX_euler_angles extension.
 		template <typename valType> 
@@ -127,6 +130,8 @@ namespace glm
 		//! From GLM_GTX_euler_angles extension.
 		template <typename T> 
 		detail::tmat4x4<T> orientate4(detail::tvec3<T> const & angles);
+
+		///@}
 	}//namespace euler_angles
     }//namespace gtx
 }//namespace glm

glm/gtx/extend.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_extend extension: Extend a position from a source to a position at a defined length.
 	namespace extend
 	{
+		/// \addtogroup gtx_extend
+		///@{
+
 		//! Extends of Length the Origin position using the (Source - Origin) direction.
 		//! From GLM_GTX_extend extension.
 		template <typename genType> 
@@ -38,6 +41,8 @@ namespace glm
 			genType const & Source, 
 			typename genType::value_type const Length);
 
+		///@}
+
 	}//namespace extend
 	}//namespace gtx
 }//namespace glm

glm/gtx/extented_min_max.hpp

@@ -32,6 +32,9 @@ namespace glm
 	//! GLM_GTX_extented_min_max extension: Min and max functions for 3 to 4 parameters.
 	namespace extented_min_max
 	{
+		/// \addtogroup gtx_extented_min_max
+		///@{
+
 		//< Return the minimum component-wise values of 3 inputs 
 		//< From GLM_GTX_extented_min_max extension
 		template <typename T>
@@ -166,6 +169,8 @@ namespace glm
 			C<T> const & z, 
 			C<T> const & w);
 
+		///@}
+
 	}//namespace extented_min_max
 	}//namespace gtx
 }//namespace glm

glm/gtx/fast_exponential.hpp

@@ -33,6 +33,8 @@ namespace glm
 	namespace fast_exponential
 	{
 		using namespace gtc::half_float;
+		/// \addtogroup gtx_fast_exponential
+		///@{
 
 		//! Faster than the common pow function but less accurate.
 		//! From GLM_GTX_fast_exponential extension.
@@ -73,6 +75,8 @@ namespace glm
 		template <typename T> 
 		T fastLn(const T& x);
 
+		///@}
+
 	}//namespace fast_exponential
 	}//namespace gtx
 }//namespace glm

glm/gtx/fast_square_root.hpp

@@ -34,6 +34,9 @@ namespace glm
 	//! GLM_GTX_fast_square_root extension: Fast but less accurate implementations of square root based functions.
 	namespace fast_square_root
 	{
+		/// \addtogroup gtx_fast_square_root
+		///@{
+
 		//! Faster than the common sqrt function but less accurate.
 		//! From GLM_GTX_fast_square_root extension.
 		template <typename genType> 
@@ -59,6 +62,8 @@ namespace glm
 		template <typename genType> 
 		genType fastNormalize(genType const & x);
 
+		///@}
+
 	}//namespace fast_square_root
 	}//	namespace gtx
 }//namespace glm

glm/gtx/fast_trigonometry.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_fast_trigonometry extension: Fast but less accurate implementations of trigonometric functions.
     namespace fast_trigonometry
     {
+		/// \addtogroup gtx_fast_trigonometry
+		///@{
+
 		//! Faster than the common sin function but less accurate. 
 		//! Defined between -2pi and 2pi. 
 		//! From GLM_GTX_fast_trigonometry extension.
@@ -72,6 +75,8 @@ namespace glm
         template <typename T> 
 		T fastAtan(const T& angle);
 
+		///@}
+
     }//namespace fast_trigonometry
     }//namespace gtx
 }//namespace glm

glm/gtx/handed_coordinate_space.hpp

@@ -23,9 +23,12 @@
 namespace glm
 {
 	namespace gtx{
-	//! GLM_GTX_handed_coordinate_space extension: To know if a triedron is right or left handed
+	//! GLM_GTX_handed_coordinate_space extension: To know if a set of three basis vectors defines a right or left-handed coordinate system.
 	namespace handed_coordinate_space
 	{
+		/// \addtogroup gtx_handed_coordinate_space
+		///@{
+
 		//! Return if a trihedron right handed or not.
 		//! From GLM_GTX_handed_coordinate_space extension.
 		template <typename T> 
@@ -42,6 +45,8 @@ namespace glm
 			detail::tvec3<T> const & binormal, 
 			detail::tvec3<T> const & normal);
 
+		///@}
+
 	}//namespace handed_coordinate_space
 	}//namespace gtx
 }//namespace glm

glm/gtx/inertia.hpp

@@ -26,6 +26,9 @@ namespace glm
 	//! GLM_GTX_inertia extension: Create inertia matrices
 	namespace inertia
 	{
+		/// \addtogroup gtx_inertia
+		///@{
+
 		//! Build an inertia matrix for a box.
 		//! From GLM_GTX_inertia extension.
 		template <typename T> 
@@ -82,6 +85,8 @@ namespace glm
 			const T Mass, 
 			const T Radius);
 
+		///@}
+
 	}//namespace inertia
 	}//namespace gtx
 }//namespace glm

glm/gtx/int_10_10_10_2.hpp

@@ -29,10 +29,15 @@ namespace glm
 	{
 		using namespace gtx::raw_data;
 
+		/// \addtogroup gtx_int_10_10_10_2
+		///@{
+
 		//! From GLM_GTX_int_10_10_10_2 extension.
 		//! Cast a vec4 to an u_10_10_10_2.
 		dword uint10_10_10_2_cast(glm::vec4 const & v);
 
+		///@}
+
 	}//namespace integer
 	}//namespace gtx
 }//namespace glm

glm/gtx/integer.hpp

@@ -26,6 +26,9 @@ namespace glm
 	//! GLM_GTX_integer extension: Add support for integer for core functions
 	namespace integer
 	{
+		/// \addtogroup gtx_integer
+		///@{
+
 		//! Returns x raised to the y power. 
 		//! From GLM_GTX_integer extension.
 		int pow(int x, int y);
@@ -43,6 +46,8 @@ namespace glm
 		template <typename genType> 
 		genType factorial(genType const & x);
 
+		///@}
+
 	}//namespace integer
 	}//namespace gtx
 }//namespace glm

glm/gtx/intersect.hpp

@@ -32,7 +32,10 @@ namespace glm
 	//! GLM_GTX_intersect extension: Add intersection functions
 	namespace intersect
 	{
-        //! Compute the intersection of a ray and a triangle.
+		/// \addtogroup gtx_intersect
+		///@{
+
+		//! Compute the intersection of a ray and a triangle.
 		//! From GLM_GTX_intersect extension.
 		template <typename genType>
 		bool intersectRayTriangle(
@@ -64,6 +67,8 @@ namespace glm
 			genType const & center, typename genType::value_type radius,
 			genType & position, genType & normal);
 
+		///@}
+
 	}//namespace intersect
 }//namespace gtx
 }//namespace glm

glm/gtx/log_base.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_log_base extension: Logarithm for any base. base can be a vector or a scalar.
 	namespace log_base
 	{
+		/// \addtogroup gtx_log_base
+		///@{
+
 		//! Logarithm for any base.
 		//! From GLM_GTX_log_base.
 		template <typename genType> 
@@ -37,6 +40,8 @@ namespace glm
 			genType const & x, 
 			genType const & base);
 
+		///@}
+
 	}//namespace extend
 	}//namespace gtx
 }//namespace glm

glm/gtx/matrix_cross_product.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_matrix_cross_product: Build cross product matrices
 	namespace matrix_cross_product
 	{
+		/// \addtogroup gtx_matrix_cross_product
+		///@{
+
 		//! Build a cross product matrix.
 		//! From GLM_GTX_matrix_cross_product extension.
 		template <typename T> 
@@ -42,6 +45,8 @@ namespace glm
 		detail::tmat4x4<T> matrixCross4(
 			detail::tvec3<T> const & x);
 
+		///@}
+
 	}//namespace matrix_cross_product
 	}//namespace gtx
 }//namespace glm

glm/gtx/matrix_major_storage.hpp

@@ -23,9 +23,12 @@
 namespace glm
 {
 	namespace gtx{
-	//! GLM_GTX_matrix_cross_product: Build matrices with specific matrix order, row or column
+	//! GLM_GTX_matrix_major_storage: Build matrices with specific matrix order, row or column
 	namespace matrix_major_storage
 	{
+		/// \addtogroup gtx_matrix_major_storage
+		///@{
+
 		//! Build a row major matrix from row vectors.
 		//! From GLM_GTX_matrix_major_storage extension.
 		template <typename T> 
@@ -110,6 +113,8 @@ namespace glm
 		detail::tmat4x4<T> colMajor4(
 			const detail::tmat4x4<T>& m);
 
+		///@}
+		
 	}//namespace matrix_major_storage
 	}//namespace gtx
 }//namespace glm

glm/gtx/matrix_operation.hpp

@@ -27,9 +27,12 @@ namespace glm
 	}//namespace test
 
 	namespace gtx{
-	//! GLM_GTX_matrix_operation: Build cross product matrices
+	//! GLM_GTX_matrix_operation: Build diagonal matrices
 	namespace matrix_operation
 	{
+		/// \addtogroup gtx_matrix_operation
+		///@{
+
 		//! Build a diagonal matrix.
 		//! From GLM_GTX_matrix_operation extension.
 		template <typename valType> 
@@ -84,6 +87,8 @@ namespace glm
 		detail::tmat4x4<valType> diagonal4x4(
 			detail::tvec4<valType> const & v);
 
+		///@}
+
 	}//namespace matrix_operation
 	}//namespace gtx
 }//namespace glm

glm/gtx/matrix_query.hpp

@@ -27,9 +27,12 @@ namespace glm
 	}//namespace test
 
 	namespace gtx{
-	//! GLM_GTX_matrix_query: Query to evaluate matrices properties
+	//! GLM_GTX_matrix_query: Query to evaluate matrix properties
 	namespace matrix_query
 	{
+		/// \addtogroup gtx_matrix_query
+		///@{
+
 		//! Return if a matrix a null matrix.
 		//! From GLM_GTX_matrix_query extension.
 		template<typename T> 
@@ -86,6 +89,7 @@ namespace glm
 			const genType& m, 
 			const typename genType::value_type epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 
+		///@}
 	}//namespace matrix_query
 	}//namespace gtx
 }//namespace glm

glm/gtx/mixed_product.hpp

@@ -30,12 +30,17 @@ namespace glm
 	//! GLM_GTX_mixed_product extension: Mixed product of 3 vectors.
 	namespace mixed_product
 	{
+		/// \addtogroup gtx_mixed_product
+		///@{
+
 		//! \brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
 		template <typename valType> 
 		valType mixedProduct(
 			detail::tvec3<valType> const & v1, 
 			detail::tvec3<valType> const & v2, 
 			detail::tvec3<valType> const & v3);
+
+		///@}
 	}//namespace mixed_product
 	}//namespace gtx
 }//namespace glm

glm/gtx/multiple.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_multiple: Find the closest number of a number multiple of other number.
 	namespace multiple
 	{
+		/// \addtogroup gtx_multiple
+		///@{
+
 		//! Higher Multiple number of Source.
 		//! From GLM_GTX_multiple extension.
 		template <typename genType> 
@@ -44,6 +47,8 @@ namespace glm
 			genType const & Source, 
 			genType const & Multiple);
 
+		///@}
+
 	}//namespace multiple
 	}//namespace gtx
 }//namespace glm

glm/gtx/norm.hpp

@@ -32,9 +32,12 @@ namespace glm
 	}//namespace test
 
 	namespace gtx{
-	//! GLM_GTX_norm extension: Varius way to compute vector norms.
+	//! GLM_GTX_norm extension: Various way to compute vector norms.
 	namespace norm
 	{
+		/// \addtogroup gtx_norm
+		///@{
+
 		//! Returns the squared length of x.
 		//! From GLM_GTX_norm extension.
 		template <typename T> 
@@ -134,6 +137,8 @@ namespace glm
 			const detail::tvec3<T>& x,
 			unsigned int Depth);
 
+		///@}
+
 	}//namespace norm
 	}//namespace gtx
 }//namespace glm

glm/gtx/normal.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_normal extension: Compute the normal of a triangle.
     namespace normal
     {
+		/// \addtogroup gtx_normal
+		///@{
+
 		//! Computes triangle normal from triangle points. 
 		//! From GLM_GTX_normal extension.
         template <typename T> 
@@ -38,6 +41,8 @@ namespace glm
 			detail::tvec3<T> const & p2, 
 			detail::tvec3<T> const & p3);
 
+		///@}
+
     }//namespace normal
     }//namespace gtx
 }//namespace glm

glm/gtx/normalize_dot.hpp

@@ -30,6 +30,9 @@ namespace glm
 	{
 		using namespace gtx::fast_square_root;
 
+		/// \addtogroup gtx_normalize_dot
+		///@{
+
 		//! Normalize parameters and returns the dot product of x and y.
 		//! It's faster that dot(normalize(x), normalize(y)).
 		//! From GLM_GTX_normalize_dot extension.
@@ -46,6 +49,8 @@ namespace glm
 			genType const & x, 
 			genType const & y);
 
+		///@}
+
 	}//namespace normalize_dot
 	}//namespace gtx
 }//namespace glm

glm/gtx/number_precision.hpp

@@ -33,6 +33,9 @@ namespace number_precision
 	/////////////////////////////
 	// Unsigned int vector types 
 
+	/// \addtogroup gtx_number_precision
+	///@{
+
 	typedef u8			u8vec1;		//!< \brief 8bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
 	typedef u16			u16vec1;    //!< \brief 16bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
 	typedef u32			u32vec1;    //!< \brief 32bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
@@ -55,6 +58,7 @@ namespace number_precision
 	typedef f64			f64mat1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
 	typedef f64			f64mat1x1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
 
+	///@}
 }//namespace number_precision
 }//namespace gtx
 }//namespace glm

glm/gtx/ocl_type.hpp

@@ -28,6 +28,9 @@ namespace ocl_type
 	///////////////////////////
 	// Scalar types 
 
+	/// \addtogroup gtx_ocl_type
+	///@{
+
 	typedef detail::int8						cl_char;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
 	typedef detail::int16						cl_short;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
 	typedef detail::int32						cl_int;			//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
@@ -96,6 +99,8 @@ namespace ocl_type
 	//typedef detail::tvec4<detail::float16>		cl_half4;	//!< \brief Half-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
 	typedef detail::tvec4<detail::float32>		cl_float4;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
 
+	///@}
+
 }//namespace ocl_type
 }//namespace gtx
 }//namespace glm

glm/gtx/optimum_pow.hpp

@@ -27,9 +27,12 @@ namespace glm
 	}//namespace test
 
     namespace gtx{
-	//! GLM_GTX_optimum_pow extension: Integer exponenciation of power functions.
+	//! GLM_GTX_optimum_pow extension: Integer exponentiation of power functions.
     namespace optimum_pow
     {
+		/// \addtogroup gtx_optimum_pow
+		///@{
+
 		//! Returns x raised to the power of 2.
 		//! From GLM_GTX_optimum_pow extension.
         template <typename genType> 
@@ -61,6 +64,8 @@ namespace glm
 		//! From GLM_GTX_optimum_pow extension.
         detail::tvec4<bool> powOfTwo(const detail::tvec4<int>& x);
 
+		///@}
+
     }//namespace optimum_pow
     }//namespace gtx
 }//namespace glm

glm/gtx/orthonormalize.hpp

@@ -30,7 +30,10 @@ namespace glm
 	//! GLM_GTX_orthonormalize extension: Orthonormalize matrices.
     namespace orthonormalize
     {
-        //! Returns the orthonormalized matrix of m.
+		/// \addtogroup gtx_orthonormalize
+		///@{
+
+		//! Returns the orthonormalized matrix of m.
 		//! From GLM_GTX_orthonormalize extension.
 		template <typename T> 
 		detail::tmat3x3<T> orthonormalize(
@@ -43,6 +46,8 @@ namespace glm
 			const detail::tvec3<T>& x, 
 			const detail::tvec3<T>& y);
 
+		///@}
+
     }//namespace orthonormalize
     }//namespace gtx
 }//namespace glm

glm/gtx/perpendicular.hpp

@@ -32,7 +32,10 @@ namespace glm
 	//! GLM_GTX_perpendicular extension: Perpendicular of a vector from other one
     namespace perpendicular
     {
-        //! Projects x a perpendicular axis of Normal.
+		/// \addtogroup gtx_perpendicular
+		///@{
+
+		//! Projects x a perpendicular axis of Normal.
 		//! From GLM_GTX_perpendicular extension.
 		template <typename T> 
 		detail::tvec2<T> perp(
@@ -53,6 +56,9 @@ namespace glm
 			detail::tvec4<T> const & x, 
 			detail::tvec4<T> const & Normal);
 
+
+		///@}
+		
     }//namespace perpendicular
     }//namespace gtx
 }//namespace glm

glm/gtx/polar_coordinates.hpp

@@ -26,6 +26,9 @@ namespace glm
 	//! GLM_GTX_polar_coordinates extension: Conversion from Euclidean space to polar space and revert.
 	namespace polar_coordinates
 	{
+		/// \addtogroup gtx_polar_coordinates
+		///@{
+
 		//! Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude.
 		//! From GLM_GTX_polar_coordinates extension.
 		template <typename T> 
@@ -36,6 +39,8 @@ namespace glm
 		template <typename T> 
 		detail::tvec3<T> euclidean(const detail::tvec3<T>& polar);
 
+		///@}
+
 	}//namespace polar_coordinates
 	}//namespace gtx
 }//namespace glm

glm/gtx/projection.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_projection extension: Projection of a vector to other one
 	namespace projection
 	{
+		/// \addtogroup gtx_projection
+		///@{
+
 		//! Projects x on Normal.
 		//! From GLM_GTX_projection extension.
 		template <typename T> 
@@ -51,6 +54,8 @@ namespace glm
 			detail::tvec4<T> const & x, 
 			detail::tvec4<T> const & Normal);
 
+		///@}
+		
 	}//namespace projection
     }//namespace gtx
 }//namespace glm

glm/gtx/quaternion.hpp

@@ -33,7 +33,10 @@ namespace glm
     {
 		using namespace gtc::quaternion;
 
-        //! Compute a cross product between a quaternion and a vector. 
+		/// \addtogroup gtx_quaternion
+		///@{
+
+		//! Compute a cross product between a quaternion and a vector. 
 		//! From GLM_GTX_quaternion extension.
 		template <typename valType> 
 		detail::tvec3<valType> cross(
@@ -188,6 +191,8 @@ namespace glm
 		detail::tquat<valType> toQuat(
 			detail::tmat4x4<valType> const & x){return gtc::quaternion::quat_cast(x);}
 
+		///@}
+
     }//namespace quaternion
     }//namespace gtx
 } //namespace glm

glm/gtx/random.hpp

@@ -25,9 +25,12 @@
 
 namespace glm{
 namespace gtx{
-//! GLM_GTX_random extension: Generate random number from varius distribution methods
+//! GLM_GTX_random extension: Generate random number from various distribution methods
 namespace random
 {
+	/// \addtogroup gtx_random
+	///@{
+
 	//! Generate a random number in the interval [-1, 1], according a linear distribution.
 	//! From GLM_GTX_random extension.
     template <typename T> T signedRand1();
@@ -75,6 +78,7 @@ namespace random
     template <typename T> detail::tvec3<T> gaussRand3(const detail::tvec3<T>& mean, const detail::tvec3<T>& std_deviation);     //!< \brief Gererate 3 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
     template <typename T> detail::tvec4<T> gaussRand4(const detail::tvec4<T>& mean, const detail::tvec4<T>& std_deviation);     //!< \brief Gererate 4 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
 
+	///@}
 }//namespace random
 }//namespace gtx
 }//namespace glm

glm/gtx/raw_data.hpp

@@ -29,6 +29,9 @@ namespace gtx
     {
 		using namespace gtc::type_precision;
 
+		/// \addtogroup gtx_raw_data
+		///@{
+
 		//! Type for byte numbers. 
 		//! From GLM_GTX_raw_data extension.
 		typedef uint8		byte;
@@ -44,6 +47,8 @@ namespace gtx
 		//! Type for qword numbers. 
 		//! From GLM_GTX_raw_data extension.
 		typedef uint64		qword;
+
+		///@}
 	}
 }//namespace gtx
 }//namespace glm

glm/gtx/reciprocal.hpp

@@ -27,6 +27,9 @@ namespace glm
 	//! GLM_GTX_reciprocal extension: Define secant, cosecant and cotangent functions.
 	namespace reciprocal
 	{
+		/// \addtogroup gtx_reciprocal
+		///@{
+
 		//! Secant function. 
 		//! hypotenuse / adjacent or 1 / cos(x)
 		//! From GLM_GTX_reciprocal extension.
@@ -90,6 +93,8 @@ namespace glm
 		template <typename genType> 
 		genType acoth(genType const & x);
 
+		///@}
+
 	}//namespace reciprocal
 	}//namespace gtx
 }//namespace glm

glm/gtx/rotate_vector.hpp

@@ -29,14 +29,17 @@ namespace glm
 	{
 		using namespace transform;
 
-		//! Rotate a two dimentionnals vector.
+		/// \addtogroup gtx_rotate_vector
+		///@{
+
+		//! Rotate a two dimensional vector.
 		//! From GLM_GTX_rotate_vector extension.
 		template <typename T> 
 		detail::tvec2<T> rotate(
 			const detail::tvec2<T>& v, 
 			T angle);
 		
-		//! Rotate a three dimentionnals vector around an axis.
+		//! Rotate a three dimensional vector around an axis.
 		//! From GLM_GTX_rotate_vector extension.
 		template <typename T> 
 		detail::tvec3<T> rotate(
@@ -44,28 +47,28 @@ namespace glm
 			T angle, 
 			const detail::tvec3<T>& normal);
 		
-		//! Rotate a four dimentionnals vector around an axis.
+		//! Rotate a four dimensional vector around an axis.
 		//! From GLM_GTX_rotate_vector extension.
 		template <typename T> 
 		detail::tvec4<T> rotate(
 			const detail::tvec4<T>& v, T angle, 
 			const detail::tvec3<T>& normal);
 		
-		//! Rotate a three dimentionnals vector around the X axis.
+		//! Rotate a three dimensional vector around the X axis.
 		//! From GLM_GTX_rotate_vector extension.
 		template <typename T> 
 		detail::tvec3<T> rotateX(
 			const detail::tvec3<T>& v, 
 			T angle);
 
-		//! Rotate a three dimentionnals vector around the Y axis.
+		//! Rotate a three dimensional vector around the Y axis.
 		//! From GLM_GTX_rotate_vector extension.
 		template <typename T> 
 		detail::tvec3<T> rotateY(
 			const detail::tvec3<T>& v, 
 			T angle);
 		
-		//! Rotate a three dimentionnals vector around the Z axis.
+		//! Rotate a three dimensional vector around the Z axis.
 		//! From GLM_GTX_rotate_vector extension.
 		template <typename T> 
 		detail::tvec3<T> rotateZ(
@@ -79,14 +82,14 @@ namespace glm
 			const detail::tvec4<T>& v, 
 			T angle);
 		
-		//! Rotate a four dimentionnals vector around the X axis.
+		//! Rotate a four dimensional vector around the X axis.
 		//! From GLM_GTX_rotate_vector extension.
 		template <typename T> 
 		detail::tvec4<T> rotateY(
 			const detail::tvec4<T>& v, 
 			T angle);
 		
-		//! Rotate a four dimentionnals vector around the X axis. 
+		//! Rotate a four dimensional vector around the X axis. 
 		//! From GLM_GTX_rotate_vector extension.
 		template <typename T> 
 		detail::tvec4<T> rotateZ(
@@ -100,6 +103,8 @@ namespace glm
 			const detail::tvec3<T>& Normal, 
 			const detail::tvec3<T>& Up);
 
+		///@}
+		
 	}//namespace rotate_vector
 	}//namespace gtx
 }//namespace glm

glm/gtx/simd_mat4.hpp

@@ -32,6 +32,8 @@ namespace glm
 {
 	namespace detail
 	{
+		/// 4x4 Matrix implemented using SIMD SEE intrinsics.
+		/// \ingroup gtx_simd_mat4
 		GLM_ALIGN(16) struct fmat4x4SIMD
 		{
 			enum ctor{null};
@@ -129,11 +131,14 @@ namespace glm
 	}//namespace detail
 
 	namespace gtx{
-	//! GLM_GTX_simd_mat4 extension: SIMD implementation of vec4 type.
+	//! GLM_GTX_simd_mat4 extension: SIMD implementation of mat4 type.
 	namespace simd_mat4
 	{
 		typedef detail::fmat4x4SIMD simdMat4;
 
+		/// \addtogroup gtx_simd_mat4
+		///@{
+
 		//! Convert a simdMat4 to a mat4.
 		//! (From GLM_GTX_simd_mat4 extension)
 		detail::tmat4x4<float> mat4_cast(
@@ -169,6 +174,8 @@ namespace glm
 		detail::fmat4x4SIMD inverse(
 			detail::fmat4x4SIMD const & m);
 
+		///@}
+
 	}//namespace simd_mat4
 	}//namespace gtx
 }//namespace glm

glm/gtx/simd_vec4.hpp

@@ -32,6 +32,8 @@ namespace glm
 {
 	namespace detail
 	{
+		/// 4-dimensional vector implemented using SIMD SEE intrinsics.
+		/// \ingroup gtx_simd_vec4
 		GLM_ALIGN(4) struct fvec4SIMD
 		{
 			enum ctor{null};
@@ -117,6 +119,9 @@ namespace glm
 	{
 		typedef detail::fvec4SIMD simdVec4;
 
+		/// \addtogroup gtx_simd_vec4
+		///@{
+
 		//! Convert a simdVec4 to a vec4.
 		//! (From GLM_GTX_simd_vec4 extension)
 		detail::tvec4<float> vec4_cast(
@@ -460,6 +465,7 @@ namespace glm
 		detail::fvec4SIMD fastInversesqrt(
 			detail::fvec4SIMD const & x);
 
+		///@}
 	}//namespace simd_vec4
 	}//namespace gtx
 }//namespace glm

glm/gtx/spline.hpp

@@ -29,7 +29,10 @@ namespace glm
     {
 		using namespace gtx::optimum_pow;
 
-        //! Return a point from a catmull rom curve.
+		/// \addtogroup gtx_spline
+		///@{
+
+		//! Return a point from a catmull rom curve.
 		//! From GLM_GTX_spline extension.
 		template <typename genType> 
 		genType catmullRom(
@@ -59,6 +62,8 @@ namespace glm
 			const genType& v4, 
 			const GLMvalType& s);
 
+		///@}
+
 	}//namespace spline
     }//namespace gtx
 }//namespace glm

glm/gtx/string_cast.hpp

@@ -43,11 +43,16 @@ namespace glm
 		using namespace gtx::unsigned_int; 
 		using namespace gtx::quaternion; 
 
+		/// \addtogroup gtx_string_cast
+		///@{
+
 		//! Create a string from a GLM type value.
 		//! From GLM_GTX_string_cast extension.
 		template <typename genType> 
 		std::string to_string(genType const & x);
 
+		///@}
+
 	}//namespace string_cast
 	}//namespace gtx
 }//namespace glm

glm/gtx/transform.hpp

@@ -34,6 +34,9 @@ namespace glm
 	{
 		using namespace gtc::matrix_transform; 
 
+		/// \addtogroup gtx_transform
+		///@{
+
 		//! Builds a translation 4 * 4 matrix created from 3 scalars.
 		//! From GLM_GTX_transform extension.
 		template <typename T> 
@@ -94,6 +97,8 @@ namespace glm
 		detail::tmat4x4<T> scale(
 			detail::tvec3<T> const & v);
 
+		///@}
+
 	}//namespace transform
 	}//namespace gtx
 }//namespace glm

glm/gtx/transform2.hpp

@@ -34,6 +34,9 @@ namespace glm
 	{
 		using namespace gtx::transform;
 
+		/// \addtogroup gtx_transform2
+		///@{
+
 		//! Transforms a matrix with a shearing on X axis.
 		//! From GLM_GTX_transform2 extension.
 		template <typename T> 
@@ -109,6 +112,8 @@ namespace glm
 			valType scale, 
 			valType bias);
 
+		///@}
+
 	}//namespace transform2
     }//namespace gtx
 }//namespace glm

glm/gtx/unsigned_int.hpp

@@ -34,6 +34,9 @@ namespace glm
 	{
 		using namespace gtx::integer;
 
+		/// \addtogroup gtx_unsigned_int
+		///@{
+
 		//! 32bit signed integer. 
 		//! From GLM_GTX_unsigned_int extension.
 		typedef signed int					sint;
@@ -50,6 +53,8 @@ namespace glm
 		//! From GLM_GTX_unsigned_int extension.
 		uint mod(uint x, uint y);
 
+		///@}
+
 	}//namespace unsigned_int
 	}//namespace gtx
 }//namespace glm

glm/gtx/vec1.hpp

@@ -34,41 +34,41 @@ namespace glm
 		namespace precision
 		{
 			//! 1 component vector of high precision floating-point numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::highp_vec1_t			highp_vec1;
 			//! 1 component vector of medium precision floating-point numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::mediump_vec1_t			mediump_vec1;
 			//! 1 component vector of low precision floating-point numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::lowp_vec1_t				lowp_vec1;
 
 			//! 1 component vector of high precision signed integer numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::highp_ivec1_t			highp_ivec1;
 			//! 1 component vector of medium precision signed integer numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::mediump_ivec1_t			mediump_ivec1;
 			//! 1 component vector of low precision signed integer numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::lowp_ivec1_t			lowp_ivec1;
 
 			//! 1 component vector of high precision unsigned integer numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::highp_uvec1_t			highp_uvec1;
 			//! 1 component vector of medium precision unsigned integer numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::mediump_uvec1_t			mediump_uvec1;
 			//! 1 component vector of low precision unsigned integer numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::lowp_uvec1_t			lowp_uvec1;
 		}//namespace precision

glm/gtx/vector_access.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_vector_access extension: Function to set values to vectors
     namespace vector_access
     {
+		/// \addtogroup gtx_vector_access
+		///@{
+
 		//! Set values to a 2 components vector.
 		//! From GLM_GTX_vector_access extension.
         template <typename valType> 
@@ -57,6 +60,8 @@ namespace glm
 			valType const & z, 
 			valType const & w);
 
+		///@}
+
     }//namespace vector_access
     }//namespace gtx
 }//namespace glm

glm/gtx/vector_angle.hpp

@@ -37,6 +37,9 @@ namespace glm
 		using namespace quaternion;
 		using namespace epsilon;
 
+		/// \addtogroup gtx_vector_angle
+		///@{
+
 		//! Returns the absolute angle between x and y.
 		//! Parameters need to be normalized.
 		//! From GLM_GTX_vector_angle extension
@@ -61,6 +64,8 @@ namespace glm
 			vecType const & x,
 			vecType const & y,
 			detail::tvec3<typename vecType::value_type> const & ref);
+
+		///@}
     }//namespace vector_angle
     }//namespace gtx
 }//namespace glm

glm/gtx/vector_query.hpp

@@ -32,7 +32,10 @@ namespace glm
 	//! GLM_GTX_vector_query extension: Query informations of vector types
     namespace vector_query
     {
-        //! Check if two vectors are collinears.
+		/// \addtogroup gtx_vector_query
+		///@{
+
+		//! Check if two vectors are collinears.
 		//! From GLM_GTX_vector_query extensions.
 		template <typename genType> 
 		bool areCollinear(
@@ -86,6 +89,8 @@ namespace glm
 			const genType& v1, 
 			const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon());
 
+		///@}
+
     }//namespace vector_query
     }//namespace gtx
 }//namespace glm

glm/gtx/verbose_operator.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_verbose_operator extension: Use words to replace operators
 	namespace verbose_operator
 	{
+		/// \addtogroup gtx_verbose_operator
+		///@{
+
 		//! Addition of two values
 		//! From GLM_GTX_verbose_operator extension.
 		template <typename genTypeT, typename genTypeU> 
@@ -54,6 +57,8 @@ namespace glm
 		//! From GLM_GTX_verbose_operator extension.
 		template <typename genTypeT, typename genTypeU, typename genTypeV> 
 		genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV const & c);
+
+		///@}
 	}//namespace verbose_operator
 	}//namespace gtx
 }//namespace glm

glm/gtx/wrap.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_wrap: Wrapping mode using my texture samping.
 	namespace wrap
 	{
+		/// \addtogroup gtx_wrap
+		///@{
+
 		//! Simulate GL_CLAMP OpenGL wrap mode
 		//! From GLM_GTX_wrap extension.
 		template <typename genType> 
@@ -45,6 +48,8 @@ namespace glm
 		template <typename genType> 
 		genType mirrorRepeat(genType const & Texcoord);
 
+		///@}
+
 	}//namespace wrap
 	}//namespace gtx
 }//namespace glm