- Improved API documentation #668

glm/detail/func_common.hpp

@@ -6,6 +6,8 @@
 /// @defgroup core_func_common Common functions
 /// @ingroup core
 /// 
+/// Include <glm/common.hpp> to use these core features.
+///
 /// These all operate component-wise. The description is per component.
 
 #pragma once

glm/detail/func_exponential.hpp

@@ -6,6 +6,8 @@
 /// @defgroup core_func_exponential Exponential functions
 /// @ingroup core
 /// 
+/// Include <glm/exponential.hpp> to use these core features.
+///
 /// These all operate component-wise. The description is per component.
 
 #pragma once

glm/detail/func_geometric.hpp

@@ -6,6 +6,8 @@
 /// @defgroup core_func_geometric Geometric functions
 /// @ingroup core
 /// 
+/// Include <glm/geometric.hpp> to use these core features.
+///
 /// These operate on vectors as vectors, not component-wise.
 
 #pragma once

glm/detail/func_integer.hpp

@@ -6,6 +6,8 @@
 /// @defgroup core_func_integer Integer functions
 /// @ingroup core
 /// 
+/// Include <glm/integer.hpp> to use these core features.
+///
 /// These all operate component-wise. The description is per component. 
 /// The notation [a, b] means the set of bits from bit-number a through bit-number 
 /// b, inclusive. The lowest-order bit is bit 0.

glm/detail/func_matrix.hpp

@@ -6,6 +6,8 @@
 /// @defgroup core_func_matrix Matrix functions
 /// @ingroup core
 /// 
+/// Include <glm/matrix.hpp> to use these core features.
+///
 /// For each of the following built-in matrix functions, there is both a 
 /// single-qualifier floating point version, where all arguments and return values 
 /// are single qualifier, and a double-qualifier floating version, where all 

glm/detail/func_packing.hpp

@@ -7,6 +7,8 @@
 /// @defgroup core_func_packing Floating-Point Pack and Unpack Functions
 /// @ingroup core
 ///
+/// Include <glm/packing.hpp> to use these core features.
+///
 /// These functions do not operate component-wise, rather as described in each case.
 
 #pragma once

glm/detail/func_trigonometric.hpp

@@ -6,6 +6,8 @@
 /// @defgroup core_func_trigonometric Angle and Trigonometry Functions
 /// @ingroup core
 /// 
+/// Include <glm/trigonometric.hpp> to use these core features.
+///
 /// Function parameters specified as angle are assumed to be in units of radians. 
 /// In no case will any of these functions result in a divide by zero error. If 
 /// the divisor of a ratio is 0, then results will be undefined.

glm/detail/func_vector_relational.hpp

@@ -6,6 +6,8 @@
 /// @defgroup core_func_vector_relational Vector Relational Functions
 /// @ingroup core
 /// 
+/// Include <glm/relational.hpp> to use these core features.
+///
 /// Relational and equality operators (<, <=, >, >=, ==, !=) are defined to 
 /// operate on scalars and produce scalar Boolean results. For vector results, 
 /// use the following built-in functions. 

glm/ext.hpp

@@ -40,7 +40,6 @@
 #include "./gtc/color_space.hpp"
 #include "./gtc/constants.hpp"
 #include "./gtc/epsilon.hpp"
-#include "./gtc/functions.hpp"
 #include "./gtc/integer.hpp"
 #include "./gtc/matrix_access.hpp"
 #include "./gtc/matrix_integer.hpp"
@@ -77,6 +76,7 @@
 #include "./gtx/fast_exponential.hpp"
 #include "./gtx/fast_square_root.hpp"
 #include "./gtx/fast_trigonometry.hpp"
+#include "./gtx/functions.hpp"
 #include "./gtx/gradient_paint.hpp"
 #include "./gtx/handed_coordinate_space.hpp"
 #include "./gtx/integer.hpp"

glm/gtc/bitfield.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtc_bitfield GLM_GTC_bitfield
 /// @ingroup gtc
 /// 
-/// @brief Allow to perform bit operations on integer values
+/// Include <glm/gtc/bitfield.hpp> to use the features of this extension.
 /// 
-/// <glm/gtc/bitfield.hpp> need to be included to use these functionalities.
+/// Allow to perform bit operations on integer values
 
 #include "../detail/setup.hpp"
 

glm/gtc/color_space.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtc_color_space GLM_GTC_color_space
 /// @ingroup gtc
 ///
-/// @brief Allow to perform bit operations on integer values
+/// Include <glm/gtc/color_space.hpp> to use the features of this extension.
 ///
-/// <glm/gtc/color_space.hpp> need to be included to use these functionalities.
+/// Allow to perform bit operations on integer values
 
 #pragma once
 

glm/gtc/constants.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtc_constants GLM_GTC_constants
 /// @ingroup gtc
 ///
-/// @brief Provide a list of constants and precomputed useful values.
+/// Include <glm/gtc/constants.hpp> to use the features of this extension.
 /// 
-/// <glm/gtc/constants.hpp> need to be included to use these features.
+/// Provide a list of constants and precomputed useful values.
 
 #pragma once
 

glm/gtc/epsilon.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtc_epsilon GLM_GTC_epsilon
 /// @ingroup gtc
 ///
-/// @brief Comparison functions for a user defined epsilon values.
+/// Include <glm/gtc/epsilon.hpp> to use the features of this extension.
 /// 
-/// <glm/gtc/epsilon.hpp> need to be included to use these functionalities.
+/// Comparison functions for a user defined epsilon values.
 
 #pragma once
 

glm/gtc/integer.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtc_integer GLM_GTC_integer
 /// @ingroup gtc
 ///
-/// @brief Allow to perform bit operations on integer values
+/// Include <glm/gtc/integer.hpp> to use the features of this extension.
 ///
-/// <glm/gtc/integer.hpp> need to be included to use these functionalities.
+/// @brief Allow to perform bit operations on integer values
 
 #pragma once
 

glm/gtc/matrix_access.hpp

@@ -6,8 +6,9 @@
 /// @defgroup gtc_matrix_access GLM_GTC_matrix_access
 /// @ingroup gtc
 ///
+/// Include <glm/gtc/matrix_access.hpp> to use the features of this extension.
+///
 /// Defines functions to access rows or columns of a matrix easily.
-/// <glm/gtc/matrix_access.hpp> need to be included to use these functionalities.
 
 #pragma once
 

glm/gtc/matrix_integer.hpp

@@ -6,8 +6,9 @@
 /// @defgroup gtc_matrix_integer GLM_GTC_matrix_integer
 /// @ingroup gtc
 ///
+/// Include <glm/gtc/matrix_integer.hpp> to use the features of this extension.
+///
 /// Defines a number of matrices with integer types.
-/// <glm/gtc/matrix_integer.hpp> need to be included to use these functionalities.
 
 #pragma once
 

glm/gtc/matrix_inverse.hpp

@@ -6,8 +6,9 @@
 /// @defgroup gtc_matrix_inverse GLM_GTC_matrix_inverse
 /// @ingroup gtc
 ///
+/// Include <glm/gtc/matrix_integer.hpp> to use the features of this extension.
+///
 /// Defines additional matrix inverting functions.
-/// <glm/gtc/matrix_inverse.hpp> need to be included to use these functionalities.
 
 #pragma once
 

glm/gtc/matrix_transform.hpp

@@ -8,15 +8,15 @@
 /// @defgroup gtc_matrix_transform GLM_GTC_matrix_transform
 /// @ingroup gtc
 ///
-/// @brief Defines functions that generate common transformation matrices.
+/// Include <glm/gtc/matrix_transform.hpp> to use the features of this extension.
+///
+/// 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.
 
 #pragma once
 

glm/gtc/noise.hpp

@@ -6,12 +6,13 @@
 /// @defgroup gtc_noise GLM_GTC_noise
 /// @ingroup gtc
 ///
+/// Include <glm/gtc/noise.hpp> to use the features of this extension.
+///
 /// Defines 2D, 3D and 4D procedural noise functions 
 /// Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise": 
 /// https://github.com/ashima/webgl-noise 
 /// Following Stefan Gustavson's paper "Simplex noise demystified": 
 /// http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
-/// <glm/gtc/noise.hpp> need to be included to use these functionalities.
 
 #pragma once
 

glm/gtc/packing.hpp

@@ -6,10 +6,10 @@
 /// @defgroup gtc_packing GLM_GTC_packing
 /// @ingroup gtc
 ///
-/// @brief This extension provides a set of function to convert vertors to packed
-/// formats.
+/// Include <glm/gtc/packing.hpp> to use the features of this extension.
 ///
-/// <glm/gtc/packing.hpp> need to be included to use these features.
+/// This extension provides a set of function to convert vertors to packed
+/// formats.
 
 #pragma once
 

glm/gtc/quaternion.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtc_quaternion GLM_GTC_quaternion
 /// @ingroup gtc
 ///
-/// @brief Defines a templated quaternion type and several quaternion operations.
+/// Include <glm/gtc/quaternion.hpp> to use the features of this extension.
 ///
-/// <glm/gtc/quaternion.hpp> need to be included to use these functionalities.
+/// Defines a templated quaternion type and several quaternion operations.
 
 #pragma once
 

glm/gtc/random.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtc_random GLM_GTC_random
 /// @ingroup gtc
 ///
-/// @brief Generate random number from various distribution methods.
+/// Include <glm/gtc/random.hpp> to use the features of this extension.
 ///
-/// <glm/gtc/random.hpp> need to be included to use these functionalities.
+/// Generate random number from various distribution methods.
 
 #pragma once
 

glm/gtc/reciprocal.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtc_reciprocal GLM_GTC_reciprocal
 /// @ingroup gtc
 ///
-/// @brief Define secant, cosecant and cotangent functions.
+/// Include <glm/gtc/reciprocal.hpp> to use the features of this extension.
 ///
-/// <glm/gtc/reciprocal.hpp> need to be included to use these features.
+/// Define secant, cosecant and cotangent functions.
 
 #pragma once
 

glm/gtc/round.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtc_round GLM_GTC_round
 /// @ingroup gtc
 ///
-/// @brief rounding value to specific boundings
+/// Include <glm/gtc/round.hpp> to use the features of this extension.
 ///
-/// <glm/gtc/round.hpp> need to be included to use these functionalities.
+/// Rounding value to specific boundings
 
 #pragma once
 

glm/gtc/type_aligned.hpp

@@ -6,8 +6,9 @@
 /// @defgroup gtc_type_aligned GLM_GTC_type_aligned
 /// @ingroup gtc
 ///
-/// @brief Aligned types.
-/// <glm/gtc/type_aligned.hpp> need to be included to use these features.
+/// Include <glm/gtc/type_aligned.hpp> to use the features of this extension.
+///
+/// Aligned types allowing SIMD optimizations of vectors and matrices types
 
 #pragma once
 

glm/gtc/type_precision.hpp

@@ -7,12 +7,12 @@
 /// @defgroup gtc_type_precision GLM_GTC_type_precision
 /// @ingroup gtc
 ///
-/// @brief Defines specific C++-based qualifier types.
+/// Include <glm/gtc/type_precision.hpp> to use the features of this extension.
+///
+/// Defines specific C++-based qualifier types.
 /// 
 /// @ref core_precision defines types based on GLSL's qualifier 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.
 
 #pragma once
 

glm/gtc/type_ptr.hpp

@@ -7,7 +7,9 @@
 /// @defgroup gtc_type_ptr GLM_GTC_type_ptr
 /// @ingroup gtc
 ///
-/// @brief Handles the interaction between pointers and vector, matrix types.
+/// Include <glm/gtc/type_ptr.hpp> to use the features of this extension.
+///
+/// Handles the interaction between pointers and vector, matrix types.
 ///
 /// This extension defines an overloaded function, glm::value_ptr, which
 /// takes any of the \ref core_template "core template types". It returns
@@ -28,7 +30,7 @@
 /// glUniformMatrix4fv(uniformMatrixLoc, 1, GL_FALSE, glm::value_ptr(someMatrix));
 /// @endcode
 ///
-/// <glm/gtc/type_ptr.hpp> need to be included to use these functionalities.
+/// <glm/gtc/type_ptr.hpp> need to be included to use the features of this extension.
 
 #pragma once
 

glm/gtc/ulp.hpp

@@ -6,10 +6,11 @@
 /// @defgroup gtc_ulp GLM_GTC_ulp
 /// @ingroup gtc
 ///
-/// @brief Allow the measurement of the accuracy of a function against a reference 
+/// Include <glm/gtc/ulp.hpp> to use the features of this extension.
+///
+/// Allow the measurement of the accuracy of a function against a reference 
 /// implementation. This extension works on floating-point data and provide results 
 /// in ULP.
-/// <glm/gtc/ulp.hpp> need to be included to use these features.
 
 #pragma once
 

glm/gtc/vec1.hpp

@@ -6,8 +6,9 @@
 /// @defgroup gtc_vec1 GLM_GTC_vec1
 /// @ingroup gtc
 ///
-/// @brief Add vec1, ivec1, uvec1 and bvec1 types.
-/// <glm/gtc/vec1.hpp> need to be included to use these functionalities.
+/// Include <glm/gtc/vec1.hpp> to use the features of this extension.
+/// 
+/// Add vec1, ivec1, uvec1 and bvec1 types.
 
 #pragma once
 

glm/gtx/associated_min_max.hpp

@@ -7,8 +7,9 @@
 /// @defgroup gtx_associated_min_max GLM_GTX_associated_min_max
 /// @ingroup gtx
 ///
+/// Include <glm/gtx/associated_min_max.hpp> to use the features of this extension.
+/// 
 /// @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.
 
 #pragma once
 

glm/gtx/bit.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_bit GLM_GTX_bit
 /// @ingroup gtx
 ///
-/// @brief Allow to perform bit operations on integer values
+/// Include <glm/gtx/bit.hpp> to use the features of this extension.
 /// 
-/// <glm/gtx/bit.hpp> need to be included to use these functionalities.
+/// Allow to perform bit operations on integer values
 
 #pragma once
 

glm/gtx/closest_point.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_closest_point GLM_GTX_closest_point
 /// @ingroup gtx
 ///
-/// @brief Find the point on a straight line which is the closet of a point.
+/// Include <glm/gtx/closest_point.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/closest_point.hpp> need to be included to use these functionalities.
+/// Find the point on a straight line which is the closet of a point.
 
 #pragma once
 

glm/gtx/color_encoding.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtx_color_encoding GLM_GTX_color_encoding
 /// @ingroup gtx
 ///
-/// @brief Allow to perform bit operations on integer values
+/// Include <glm/gtx/color_encoding.hpp> to use the features of this extension.
 ///
-/// <glm/gtc/color_encoding.hpp> need to be included to use these functionalities.
+/// @brief Allow to perform bit operations on integer values
 
 #pragma once
 

glm/gtx/color_space.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_color_space GLM_GTX_color_space
 /// @ingroup gtx
 ///
-/// @brief Related to RGB to HSV conversions and operations.
+/// Include <glm/gtx/color_space.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/color_space.hpp> need to be included to use these functionalities.
+/// Related to RGB to HSV conversions and operations.
 
 #pragma once
 

glm/gtx/color_space_YCoCg.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_color_space_YCoCg GLM_GTX_color_space_YCoCg
 /// @ingroup gtx
 ///
-/// @brief RGB to YCoCg conversions and operations
+/// Include <glm/gtx/color_space_YCoCg.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/color_space_YCoCg.hpp> need to be included to use these functionalities.
+/// RGB to YCoCg conversions and operations
 
 #pragma once
 

glm/gtx/common.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_common GLM_GTX_common
 /// @ingroup gtx
 ///
-/// @brief Provide functions to increase the compatibility with Cg and HLSL languages
+/// Include <glm/gtx/common.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/common.hpp> need to be included to use these functionalities.
+/// @brief Provide functions to increase the compatibility with Cg and HLSL languages
 
 #pragma once
 

glm/gtx/compatibility.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_compatibility GLM_GTX_compatibility
 /// @ingroup gtx
 ///
-/// @brief Provide functions to increase the compatibility with Cg and HLSL languages
+/// Include <glm/gtx/compatibility.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/compatibility.hpp> need to be included to use these functionalities.
+/// Provide functions to increase the compatibility with Cg and HLSL languages
 
 #pragma once
 

glm/gtx/component_wise.hpp

@@ -8,9 +8,9 @@
 /// @defgroup gtx_component_wise GLM_GTX_component_wise
 /// @ingroup gtx
 ///
-/// @brief Operations between components of a type
+/// Include <glm/gtx/component_wise.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/component_wise.hpp> need to be included to use these functionalities.
+/// Operations between components of a type
 
 #pragma once
 

glm/gtx/dual_quaternion.hpp

@@ -9,9 +9,9 @@
 /// @defgroup gtx_dual_quaternion GLM_GTX_dual_quaternion
 /// @ingroup gtx
 ///
-/// @brief Defines a templated dual-quaternion type and several dual-quaternion operations.
+/// Include <glm/gtx/dual_quaternion.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/dual_quaternion.hpp> need to be included to use these functionalities.
+/// Defines a templated dual-quaternion type and several dual-quaternion operations.
 
 #pragma once
 

glm/gtx/euler_angles.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_euler_angles GLM_GTX_euler_angles
 /// @ingroup gtx
 ///
-/// @brief Build matrices from Euler angles.
+/// Include <glm/gtx/euler_angles.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/euler_angles.hpp> need to be included to use these functionalities.
+/// Build matrices from Euler angles.
 
 #pragma once
 

glm/gtx/extend.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_extend GLM_GTX_extend
 /// @ingroup gtx
 ///
-/// @brief Extend a position from a source to a position at a defined length.
+/// Include <glm/gtx/extend.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/extend.hpp> need to be included to use these functionalities.
+/// Extend a position from a source to a position at a defined length.
 
 #pragma once
 

glm/gtx/extended_min_max.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_extented_min_max GLM_GTX_extented_min_max
 /// @ingroup gtx
 ///
-/// Min and max functions for 3 to 4 parameters.
+/// Include <glm/gtx/extented_min_max.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/extented_min_max.hpp> need to be included to use these functionalities.
+/// Min and max functions for 3 to 4 parameters.
 
 #pragma once
 

glm/gtx/exterior_product.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtx_exterior_product GLM_GTX_exterior_product
 /// @ingroup gtx
 ///
-/// @brief Allow to perform bit operations on integer values
+/// Include <glm/gtx/exterior_product.hpp> to use the features of this extension.
 /// 
-/// <glm/gtc/bitfield.hpp> need to be included to use these functionalities.
+/// @brief Allow to perform bit operations on integer values
 
 #pragma once
 

glm/gtx/fast_exponential.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtx_fast_exponential GLM_GTX_fast_exponential
 /// @ingroup gtx
 ///
-/// @brief Fast but less accurate implementations of exponential based functions.
+/// Include <glm/gtx/fast_exponential.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/fast_exponential.hpp> need to be included to use these functionalities.
+/// Fast but less accurate implementations of exponential based functions.
 
 #pragma once
 

glm/gtx/fast_square_root.hpp

@@ -6,11 +6,11 @@
 /// @defgroup gtx_fast_square_root GLM_GTX_fast_square_root
 /// @ingroup gtx
 ///
-/// @brief Fast but less accurate implementations of square root based functions.
+/// Include <glm/gtx/fast_square_root.hpp> to use the features of this extension.
+///
+/// Fast but less accurate implementations of square root based functions.
 /// - Sqrt optimisation based on Newton's method, 
 /// www.gamedev.net/community/forums/topic.asp?topic id=139956
-///
-/// <glm/gtx/fast_square_root.hpp> need to be included to use these functionalities.
 
 #pragma once
 

glm/gtx/fast_trigonometry.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_fast_trigonometry GLM_GTX_fast_trigonometry
 /// @ingroup gtx
 ///
-/// @brief Fast but less accurate implementations of trigonometric functions.
+/// Include <glm/gtx/fast_trigonometry.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/fast_trigonometry.hpp> need to be included to use these functionalities.
+/// Fast but less accurate implementations of trigonometric functions.
 
 #pragma once
 

glm/gtx/functions.hpp

@@ -1,15 +1,15 @@
-/// @ref gtc_functions
-/// @file glm/gtc/functions.hpp
+/// @ref gtx_functions
+/// @file glm/gtx/functions.hpp
 /// 
 /// @see core (dependence)
 /// @see gtc_quaternion (dependence)
 ///
-/// @defgroup gtc_functions GLM_GTC_functions
-/// @ingroup gtc
+/// @defgroup gtx_functions GLM_GTX_functions
+/// @ingroup gtx
 ///
-/// @brief List of useful common functions.
+/// Include <glm/gtx/functions.hpp> to use the features of this extension.
 /// 
-/// <glm/gtc/functions.hpp> need to be included to use these functionalities.
+/// List of useful common functions.
 
 #pragma once
 
@@ -19,12 +19,12 @@
 #include "../detail/type_vec2.hpp"
 
 #if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
-#	pragma message("GLM: GLM_GTC_functions extension included")
+#	pragma message("GLM: GLM_GTX_functions extension included")
 #endif
 
 namespace glm
 {
-	/// @addtogroup gtc_functions
+	/// @addtogroup gtx_functions
 	/// @{
 
 	/// 1D gauss function

glm/gtx/functions.inl

@@ -1,5 +1,5 @@
-/// @ref gtc_functions
-/// @file glm/gtc/functions.inl
+/// @ref gtx_functions
+/// @file glm/gtx/functions.inl
 
 #include "../detail/func_exponential.hpp"
 

glm/gtx/gradient_paint.hpp

@@ -7,8 +7,9 @@
 /// @defgroup gtx_gradient_paint GLM_GTX_gradient_paint
 /// @ingroup gtx
 ///
-/// @brief Functions that return the color of procedural gradient for specific coordinates.
-/// <glm/gtx/gradient_paint.hpp> need to be included to use these functionalities.
+/// Include <glm/gtx/gradient_paint.hpp> to use the features of this extension.
+///
+/// Functions that return the color of procedural gradient for specific coordinates.
 
 #pragma once
 

glm/gtx/handed_coordinate_space.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_handed_coordinate_space GLM_GTX_handed_coordinate_space
 /// @ingroup gtx
 ///
-/// @brief To know if a set of three basis vectors defines a right or left-handed coordinate system.
+/// Include <glm/gtx/handed_coordinate_system.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/handed_coordinate_system.hpp> need to be included to use these functionalities.
+/// To know if a set of three basis vectors defines a right or left-handed coordinate system.
 
 #pragma once
 

glm/gtx/hash.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_hash GLM_GTX_hash
 /// @ingroup gtx
 ///
-/// @brief Add std::hash support for glm types
+/// Include <glm/gtx/hash.hpp> to use the features of this extension.
 /// 
-/// <glm/gtx/hash.hpp> need to be included to use these functionalities.
+/// Add std::hash support for glm types
 
 #pragma once
 

glm/gtx/hash.inl

@@ -8,7 +8,7 @@
 ///
 /// @brief Add std::hash support for glm types
 ///
-/// <glm/gtx/hash.inl> need to be included to use these functionalities.
+/// <glm/gtx/hash.inl> need to be included to use the features of this extension.
 
 namespace glm {
 namespace detail

glm/gtx/integer.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_integer GLM_GTX_integer
 /// @ingroup gtx
 ///
-/// @brief Add support for integer for core functions
+/// Include <glm/gtx/integer.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/integer.hpp> need to be included to use these functionalities.
+/// Add support for integer for core functions
 
 #pragma once
 

glm/gtx/intersect.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtx_intersect GLM_GTX_intersect
 /// @ingroup gtx
 ///
-/// @brief Add intersection functions
+/// Include <glm/gtx/intersect.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/intersect.hpp> need to be included to use these functionalities.
+/// Add intersection functions
 
 #pragma once
 

glm/gtx/io.hpp

@@ -9,13 +9,13 @@
 /// @defgroup gtx_io GLM_GTX_io
 /// @ingroup gtx
 ///
-/// @brief std::[w]ostream support for glm types
+/// Include <glm/gtx/io.hpp> to use the features of this extension.
+/// 
+/// std::[w]ostream support for glm types
 ///
 /// std::[w]ostream support for glm types + qualifier/width/etc. manipulators
 /// based on howard hinnant's std::chrono io proposal
 /// [http://home.roadrunner.com/~hinnant/bloomington/chrono_io.html]
-///
-/// <glm/gtx/io.hpp> needs to be included to use these functionalities.
 
 #pragma once
 

glm/gtx/log_base.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_log_base GLM_GTX_log_base
 /// @ingroup gtx
 ///
-/// @brief Logarithm for any base. base can be a vector or a scalar.
+/// Include <glm/gtx/log_base.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/log_base.hpp> need to be included to use these functionalities.
+/// Logarithm for any base. base can be a vector or a scalar.
 
 #pragma once
 

glm/gtx/matrix_cross_product.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtx_matrix_cross_product GLM_GTX_matrix_cross_product
 /// @ingroup gtx
 ///
-/// @brief Build cross product matrices
+/// Include <glm/gtx/matrix_cross_product.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/matrix_cross_product.hpp> need to be included to use these functionalities.
+/// Build cross product matrices
 
 #pragma once
 

glm/gtx/matrix_decompose.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_matrix_decompose GLM_GTX_matrix_decompose
 /// @ingroup gtx
 ///
-/// @brief Decomposes a model matrix to translations, rotation and scale components
+/// Include <glm/gtx/matrix_decompose.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/matrix_decompose.hpp> need to be included to use these functionalities.
+/// Decomposes a model matrix to translations, rotation and scale components
 
 #pragma once
 

glm/gtx/matrix_factorisation.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_matrix_factorisation GLM_GTX_matrix_factorisation
 /// @ingroup gtx
 ///
-/// @brief Functions to factor matrices in various forms
+/// Include <glm/gtx/matrix_factorisation.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/matrix_factorisation.hpp> need to be included to use these functionalities.
+/// Functions to factor matrices in various forms
 
 #pragma once
 

glm/gtx/matrix_interpolation.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtx_matrix_interpolation GLM_GTX_matrix_interpolation
 /// @ingroup gtx
 ///
-/// @brief Allows to directly interpolate two exiciting matrices.
+/// Include <glm/gtx/matrix_interpolation.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/matrix_interpolation.hpp> need to be included to use these functionalities.
+/// Allows to directly interpolate two exiciting matrices.
 
 #pragma once
 

glm/gtx/matrix_major_storage.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtx_matrix_major_storage GLM_GTX_matrix_major_storage
 /// @ingroup gtx
 ///
-/// @brief Build matrices with specific matrix order, row or column
+/// Include <glm/gtx/matrix_major_storage.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/matrix_major_storage.hpp> need to be included to use these functionalities.
+/// Build matrices with specific matrix order, row or column
 
 #pragma once
 

glm/gtx/matrix_operation.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_matrix_operation GLM_GTX_matrix_operation
 /// @ingroup gtx
 ///
-/// @brief Build diagonal matrices from vectors.
+/// Include <glm/gtx/matrix_operation.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/matrix_operation.hpp> need to be included to use these functionalities.
+/// Build diagonal matrices from vectors.
 
 #pragma once
 

glm/gtx/matrix_query.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtx_matrix_query GLM_GTX_matrix_query
 /// @ingroup gtx
 ///
-/// @brief Query to evaluate matrix properties
+/// Include <glm/gtx/matrix_query.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/matrix_query.hpp> need to be included to use these functionalities.
+/// Query to evaluate matrix properties
 
 #pragma once
 

glm/gtx/matrix_transform_2d.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtx_matrix_transform_2d GLM_GTX_matrix_transform_2d
 /// @ingroup gtx
 ///
-/// @brief Defines functions that generate common 2d transformation matrices.
+/// Include <glm/gtx/matrix_transform_2d.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/matrix_transform_2d.hpp> need to be included to use these functionalities.
+/// Defines functions that generate common 2d transformation matrices.
 
 #pragma once
 

glm/gtx/mixed_product.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_mixed_product GLM_GTX_mixed_producte
 /// @ingroup gtx
 ///
-/// @brief Mixed product of 3 vectors.
+/// Include <glm/gtx/mixed_product.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/mixed_product.hpp> need to be included to use these functionalities.
+/// Mixed product of 3 vectors.
 
 #pragma once
 

glm/gtx/norm.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtx_norm GLM_GTX_norm
 /// @ingroup gtx
 ///
-/// @brief Various ways to compute vector norms.
+/// Include <glm/gtx/norm.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/norm.hpp> need to be included to use these functionalities.
+/// Various ways to compute vector norms.
 
 #pragma once
 

glm/gtx/normal.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtx_normal GLM_GTX_normal
 /// @ingroup gtx
 ///
-/// @brief Compute the normal of a triangle.
+/// Include <glm/gtx/normal.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/normal.hpp> need to be included to use these functionalities.
+/// Compute the normal of a triangle.
 
 #pragma once
 

glm/gtx/normalize_dot.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtx_normalize_dot GLM_GTX_normalize_dot
 /// @ingroup gtx
 ///
-/// @brief Dot product of vectors that need to be normalize with a single square root.
+/// Include <glm/gtx/normalized_dot.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/normalized_dot.hpp> need to be included to use these functionalities.
+/// Dot product of vectors that need to be normalize with a single square root.
 
 #pragma once
 

glm/gtx/number_precision.hpp

@@ -8,9 +8,9 @@
 /// @defgroup gtx_number_precision GLM_GTX_number_precision
 /// @ingroup gtx
 ///
-/// @brief Defined size types.
+/// Include <glm/gtx/number_precision.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/number_precision.hpp> need to be included to use these functionalities.
+/// Defined size types.
 
 #pragma once
 

glm/gtx/optimum_pow.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_optimum_pow GLM_GTX_optimum_pow
 /// @ingroup gtx
 ///
-/// @brief Integer exponentiation of power functions.
+/// Include <glm/gtx/optimum_pow.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/optimum_pow.hpp> need to be included to use these functionalities.
+/// Integer exponentiation of power functions.
 
 #pragma once
 

glm/gtx/orthonormalize.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtx_orthonormalize GLM_GTX_orthonormalize
 /// @ingroup gtx
 ///
-/// @brief Orthonormalize matrices.
+/// Include <glm/gtx/orthonormalize.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/orthonormalize.hpp> need to be included to use these functionalities.
+/// Orthonormalize matrices.
 
 #pragma once
 

glm/gtx/perpendicular.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtx_perpendicular GLM_GTX_perpendicular
 /// @ingroup gtx
 ///
-/// @brief Perpendicular of a vector from other one
+/// Include <glm/gtx/perpendicular.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/perpendicular.hpp> need to be included to use these functionalities.
+/// Perpendicular of a vector from other one
 
 #pragma once
 

glm/gtx/polar_coordinates.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_polar_coordinates GLM_GTX_polar_coordinates
 /// @ingroup gtx
 ///
-/// @brief Conversion from Euclidean space to polar space and revert.
+/// Include <glm/gtx/polar_coordinates.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/polar_coordinates.hpp> need to be included to use these functionalities.
+/// Conversion from Euclidean space to polar space and revert.
 
 #pragma once
 

glm/gtx/projection.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_projection GLM_GTX_projection
 /// @ingroup gtx
 ///
-/// @brief Projection of a vector to other one
+/// Include <glm/gtx/projection.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/projection.hpp> need to be included to use these functionalities.
+/// Projection of a vector to other one
 
 #pragma once
 

glm/gtx/quaternion.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtx_quaternion GLM_GTX_quaternion
 /// @ingroup gtx
 ///
-/// @brief Extented quaternion types and functions
+/// Include <glm/gtx/quaternion.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/quaternion.hpp> need to be included to use these functionalities.
+/// Extented quaternion types and functions
 
 #pragma once
 

glm/gtx/range.hpp

@@ -5,10 +5,10 @@
 /// @defgroup gtx_range GLM_GTX_range
 /// @ingroup gtx
 ///
-/// @brief Defines begin and end for vectors and matrices. Useful for range-based for loop.
-/// The range is defined over the elements, not over columns or rows (e.g. mat4 has 16 elements).
+/// Include <glm/gtx/range.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/range.hpp> need to be included to use these functionalities.
+/// Defines begin and end for vectors and matrices. Useful for range-based for loop.
+/// The range is defined over the elements, not over columns or rows (e.g. mat4 has 16 elements).
 
 #pragma once
 

glm/gtx/raw_data.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_raw_data GLM_GTX_raw_data
 /// @ingroup gtx
 ///
-/// @brief Projection of a vector to other one
+/// Include <glm/gtx/raw_data.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/raw_data.hpp> need to be included to use these functionalities.
+/// Projection of a vector to other one
 
 #pragma once
 

glm/gtx/rotate_normalized_axis.hpp

@@ -8,9 +8,9 @@
 /// @defgroup gtx_rotate_normalized_axis GLM_GTX_rotate_normalized_axis
 /// @ingroup gtx
 ///
-/// @brief Quaternions and matrices rotations around normalized axis.
+/// Include <glm/gtx/rotate_normalized_axis.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/rotate_normalized_axis.hpp> need to be included to use these functionalities.
+/// Quaternions and matrices rotations around normalized axis.
 
 #pragma once
 

glm/gtx/rotate_vector.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtx_rotate_vector GLM_GTX_rotate_vector
 /// @ingroup gtx
 ///
-/// @brief Function to directly rotate a vector
+/// Include <glm/gtx/rotate_vector.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/rotate_vector.hpp> need to be included to use these functionalities.
+/// Function to directly rotate a vector
 
 #pragma once
 

glm/gtx/scalar_multiplication.hpp

@@ -2,7 +2,9 @@
 /// @file glm/gtx/scalar_multiplication.hpp
 /// @author Joshua Moerman
 ///
-/// @brief Enables scalar multiplication for all types
+/// Include <glm/gtx/scalar_multiplication.hpp> to use the features of this extension.
+///
+/// Enables scalar multiplication for all types
 ///
 /// Since GLSL is very strict about types, the following (often used) combinations do not work:
 ///    double * vec4

glm/gtx/scalar_relational.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_scalar_relational GLM_GTX_scalar_relational
 /// @ingroup gtx
 ///
-/// @brief Extend a position from a source to a position at a defined length.
+/// Include <glm/gtx/scalar_relational.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/scalar_relational.hpp> need to be included to use these functionalities.
+/// Extend a position from a source to a position at a defined length.
 
 #pragma once
 

glm/gtx/spline.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_spline GLM_GTX_spline
 /// @ingroup gtx
 ///
-/// @brief Spline functions
+/// Include <glm/gtx/spline.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/spline.hpp> need to be included to use these functionalities.
+/// Spline functions
 
 #pragma once
 

glm/gtx/std_based_type.hpp

@@ -7,8 +7,9 @@
 /// @defgroup gtx_std_based_type GLM_GTX_std_based_type
 /// @ingroup gtx
 ///
-/// @brief Adds vector types based on STL value types.
-/// <glm/gtx/std_based_type.hpp> need to be included to use these functionalities.
+/// Include <glm/gtx/std_based_type.hpp> to use the features of this extension.
+///
+/// Adds vector types based on STL value types.
 
 #pragma once
 

glm/gtx/string_cast.hpp

@@ -8,9 +8,10 @@
 /// @defgroup gtx_string_cast GLM_GTX_string_cast
 /// @ingroup gtx
 ///
-/// @brief Setup strings for GLM type values
+/// Include <glm/gtx/string_cast.hpp> to use the features of this extension.
+///
+/// Setup strings for GLM type values
 ///
-/// <glm/gtx/string_cast.hpp> need to be included to use these functionalities.
 /// This extension is not supported with CUDA
 
 #pragma once

glm/gtx/transform.hpp

@@ -9,9 +9,9 @@
 /// @defgroup gtx_transform GLM_GTX_transform
 /// @ingroup gtx
 ///
-/// @brief Add transformation matrices
+/// Include <glm/gtx/transform.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/transform.hpp> need to be included to use these functionalities.
+/// Add transformation matrices
 
 #pragma once
 

glm/gtx/transform2.hpp

@@ -7,9 +7,9 @@
 /// @defgroup gtx_transform2 GLM_GTX_transform2
 /// @ingroup gtx
 ///
-/// @brief Add extra transformation matrices
+/// Include <glm/gtx/transform2.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/transform2.hpp> need to be included to use these functionalities.
+/// Add extra transformation matrices
 
 #pragma once
 

glm/gtx/type_aligned.hpp

@@ -7,11 +7,11 @@
 /// @defgroup gtx_type_aligned GLM_GTX_type_aligned
 /// @ingroup gtx
 ///
-/// @brief Defines aligned types.
+/// Include <glm/gtx/type_aligned.hpp> to use the features of this extension.
+///
+/// Defines aligned types.
 ///
 /// @ref core_precision defines aligned types.
-///
-/// <glm/gtx/type_aligned.hpp> need to be included to use these functionalities.
 
 #pragma once
 

glm/gtx/type_trait.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_type_trait GLM_GTX_type_trait
 /// @ingroup gtx
 ///
-/// @brief Defines traits for each type.
+/// Include <glm/gtx/type_trait.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/type_trait.hpp> need to be included to use these functionalities.
+/// Defines traits for each type.
 
 #pragma once
 

glm/gtx/vec_swizzle.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_vec_swizzle GLM_GTX_vec_swizzle
 /// @ingroup gtx
 ///
-/// @brief Functions to perform swizzle operation.
+/// Include <glm/gtx/vec_swizzle.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/vec_swizzle.hpp> need to be included to use these functionalities.
+/// Functions to perform swizzle operation.
 
 #pragma once
 

glm/gtx/vector_angle.hpp

@@ -8,9 +8,9 @@
 /// @defgroup gtx_vector_angle GLM_GTX_vector_angle
 /// @ingroup gtx
 ///
-/// @brief Compute angle between vectors
+/// Include <glm/gtx/vector_angle.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/vector_angle.hpp> need to be included to use these functionalities.
+/// Compute angle between vectors
 
 #pragma once
 

glm/gtx/vector_query.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_vector_query GLM_GTX_vector_query
 /// @ingroup gtx
 ///
-/// @brief Query informations of vector types
+/// Include <glm/gtx/vector_query.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/vector_query.hpp> need to be included to use these functionalities.
+/// Query informations of vector types
 
 #pragma once
 

glm/gtx/wrap.hpp

@@ -6,9 +6,9 @@
 /// @defgroup gtx_wrap GLM_GTX_wrap
 /// @ingroup gtx
 ///
-/// @brief Wrapping mode of texture coordinates.
+/// Include <glm/gtx/wrap.hpp> to use the features of this extension.
 ///
-/// <glm/gtx/wrap.hpp> need to be included to use these functionalities.
+/// Wrapping mode of texture coordinates.
 
 #pragma once
 

manual.md

@@ -29,23 +29,22 @@
 + [4.2. GLM_GTC_color_space](#section4_2)
 + [4.3. GLM_GTC_constants](#section4_3)
 + [4.4. GLM_GTC_epsilon](#section4_4)
-+ [4.5. GLM_GTC_functions](#section4_5)
-+ [4.6. GLM_GTC_integer](#section4_6)
-+ [4.7. GLM_GTC_matrix_access](#section4_7)
-+ [4.8. GLM_GTC_matrix_integer](#section4_8)
-+ [4.9. GLM_GTC_matrix_inverse](#section4_9)
-+ [4.10. GLM_GTC_matrix_transform](#section4_10)
-+ [4.11. GLM_GTC_noise](#section4_11)
-+ [4.12. GLM_GTC_packing](#section4_12)
-+ [4.13. GLM_GTC_quaternion](#section4_13)
-+ [4.14. GLM_GTC_random](#section4_14)
-+ [4.15. GLM_GTC_reciprocal](#section4_15)
-+ [4.16. GLM_GTC_round](#section4_16)
-+ [4.17. GLM_GTC_type_alignment](#section4_17)
-+ [4.18. GLM_GTC_type_precision](#section4_18)
-+ [4.19. GLM_GTC_type_ptr](#section4_19)
-+ [4.20. GLM_GTC_ulp](#section4_20)
-+ [4.21. GLM_GTC_vec1](#section4_21)
++ [4.5. GLM_GTC_integer](#section4_5)
++ [4.6. GLM_GTC_matrix_access](#section4_6)
++ [4.7. GLM_GTC_matrix_integer](#section4_7)
++ [4.8. GLM_GTC_matrix_inverse](#section4_8)
++ [4.9. GLM_GTC_matrix_transform](#section4_9)
++ [4.10. GLM_GTC_noise](#section4_10)
++ [4.11. GLM_GTC_packing](#section4_11)
++ [4.12. GLM_GTC_quaternion](#section4_12)
++ [4.13. GLM_GTC_random](#section4_13)
++ [4.14. GLM_GTC_reciprocal](#section4_14)
++ [4.15. GLM_GTC_round](#section4_15)
++ [4.16. GLM_GTC_type_alignment](#section4_16)
++ [4.17. GLM_GTC_type_precision](#section4_17)
++ [4.18. GLM_GTC_type_ptr](#section4_18)
++ [4.19. GLM_GTC_ulp](#section4_19)
++ [4.20. GLM_GTC_vec1](#section4_20)
 + [5. OpenGL interoperability](#section5)
 + [5.1. GLM Replacements for deprecated OpenGL functions](#section5_1)
 + [5.2. GLM Replacements for GPU functions](#section5_2)
@@ -578,37 +577,31 @@ Approximate equality comparisons for floating-point numbers, possibly with a use
 
 <glm/gtc/epsilon.hpp> need to be included to use these features.
 
-### <a name="section4_5"></a> 4.5. GLM\_GTC\_functions
-
-Useful functions.
-
-&lt;glm/gtc/functions.hpp&gt; need to be included to use these features.
-
-### <a name="section4_6"></a> 4.6. GLM\_GTC\_integer
+### <a name="section4_5"></a> 4.5. GLM\_GTC\_integer
 
 Integer variants of core GLM functions.
 
 &lt;glm/gtc/integer.hpp&gt; need to be included to use these features.
 
-### <a name="section4_7"></a> 4.7. GLM\_GTC\_matrix\_access
+### <a name="section4_6"></a> 4.6. GLM\_GTC\_matrix\_access
 
 Functions to conveniently access the individual rows or columns of a matrix.
 
 &lt;glm/gtc/matrix\_access.hpp&gt; need to be included to use these features.
 
-### <a name="section4_8"></a> 4.8. GLM\_GTC\_matrix\_integer
+### <a name="section4_7"></a> 4.7. GLM\_GTC\_matrix\_integer
 
 Integer matrix types similar to the core floating-point matrices.  Some operations (such as inverse and determinant) are not supported.
 
 &lt;glm/gtc/matrix\_integer.hpp&gt; need to be included to use these features.
 
-### <a name="section4_9"></a> 4.9. GLM\_GTC\_matrix\_inverse
+### <a name="section4_8"></a> 4.8. GLM\_GTC\_matrix\_inverse
 
 Additional matrix inverse functions.
 
 &lt;glm/gtc/matrix\_inverse.hpp&gt; need to be included to use these features.
 
-### <a name="section4_10"></a> 4.10. GLM\_GTC\_matrix\_transform
+### <a name="section4_9"></a> 4.9. GLM\_GTC\_matrix\_transform
 
 Matrix transformation functions that follow the OpenGL fixed-function conventions.
 
@@ -619,7 +612,7 @@ projective matrix functions (***perspective***, ***ortho***, etc) are designed t
 
 &lt;glm/gtc/matrix\_transform.hpp&gt; need to be included to use these features.
 
-### <a name="section4_11"></a> 4.11. GLM\_GTC\_noise
+### <a name="section4_10"></a> 4.10. GLM\_GTC\_noise
 
 Define 2D, 3D and 4D procedural noise functions.
 
@@ -627,53 +620,53 @@ Define 2D, 3D and 4D procedural noise functions.
 
 ![](/doc/manual/noise-simplex1.jpg)
 
-Figure 4.11.1: glm::simplex(glm::vec2(x / 16.f, y / 16.f));
+Figure 4.10.1: glm::simplex(glm::vec2(x / 16.f, y / 16.f));
 
 ![](/doc/manual/noise-simplex2.jpg)
 
-Figure 4.11.2: glm::simplex(glm::vec3(x / 16.f, y / 16.f, 0.5f));
+Figure 4.10.2: glm::simplex(glm::vec3(x / 16.f, y / 16.f, 0.5f));
 
 ![](/doc/manual/noise-simplex3.jpg)
 
-Figure 4.11.3: glm::simplex(glm::vec4(x / 16.f, y / 16.f, 0.5f, 0.5f));
+Figure 4.10.3: glm::simplex(glm::vec4(x / 16.f, y / 16.f, 0.5f, 0.5f));
 
 ![](/doc/manual/noise-perlin1.jpg)
 
-Figure 4.11.4: glm::perlin(glm::vec2(x / 16.f, y / 16.f));
+Figure 4.10.4: glm::perlin(glm::vec2(x / 16.f, y / 16.f));
 
 ![](/doc/manual/noise-perlin2.jpg)
 
-Figure 4.11.5: glm::perlin(glm::vec3(x / 16.f, y / 16.f, 0.5f));
+Figure 4.10.5: glm::perlin(glm::vec3(x / 16.f, y / 16.f, 0.5f));
 
 ![](/doc/manual/noise-perlin3.jpg)
 
-Figure 4.11.6: glm::perlin(glm::vec4(x / 16.f, y / 16.f, 0.5f, 0.5f)));
+Figure 4.10.6: glm::perlin(glm::vec4(x / 16.f, y / 16.f, 0.5f, 0.5f)));
 
 ![](/doc/manual/noise-perlin4.png)
 
-Figure 4.11.7: glm::perlin(glm::vec2(x / 16.f, y / 16.f), glm::vec2(2.0f));
+Figure 4.10.7: glm::perlin(glm::vec2(x / 16.f, y / 16.f), glm::vec2(2.0f));
 
 ![](/doc/manual/noise-perlin5.png)
 
-Figure 4.11.8: glm::perlin(glm::vec3(x / 16.f, y / 16.f, 0.5f), glm::vec3(2.0f));
+Figure 4.10.8: glm::perlin(glm::vec3(x / 16.f, y / 16.f, 0.5f), glm::vec3(2.0f));
 
 ![](/doc/manual/noise-perlin6.png)
 
-Figure 4.11.9: glm::perlin(glm::vec4(x / 16.f, y / 16.f, glm::vec2(0.5f)), glm::vec4(2.0f));
+Figure 4.10.9: glm::perlin(glm::vec4(x / 16.f, y / 16.f, glm::vec2(0.5f)), glm::vec4(2.0f));
 
-### <a name="section4_12"></a> 4.12. GLM\_GTC\_packing
+### <a name="section4_11"></a> 4.11. GLM\_GTC\_packing
 
 Convert scalar and vector types to and from packed formats, saving space at the cost of precision. However, packing a value into a format that it was previously unpacked from is guaranteed to be lossless.
 
 &lt;glm/gtc/packing.hpp&gt; need to be included to use these features.
 
-### <a name="section4_13"></a> 4.13. GLM\_GTC\_quaternion
+### <a name="section4_12"></a> 4.12. GLM\_GTC\_quaternion
 
 Quaternions and operations upon thereof.
 
 &lt;glm/gtc/quaternion.hpp&gt; need to be included to use these features.
 
-### <a name="section4_14"></a> 4.14. GLM\_GTC\_random
+### <a name="section4_13"></a> 4.13. GLM\_GTC\_random
 
 Probability distributions in up to four dimensions.
 
@@ -681,47 +674,47 @@ Probability distributions in up to four dimensions.
 
 ![](/doc/manual/random-linearrand.png)
 
-Figure 4.14.1: glm::vec4(glm::linearRand(glm::vec2(-1), glm::vec2(1)), 0, 1);
+Figure 4.13.1: glm::vec4(glm::linearRand(glm::vec2(-1), glm::vec2(1)), 0, 1);
 
 ![](/doc/manual/random-circularrand.png)
 
-Figure 4.14.2: glm::vec4(glm::circularRand(1.0f), 0, 1);
+Figure 4.13.2: glm::vec4(glm::circularRand(1.0f), 0, 1);
 
 ![](/doc/manual/random-sphericalrand.png)
 
-Figure 4.14.3: glm::vec4(glm::sphericalRand(1.0f), 1);
+Figure 4.13.3: glm::vec4(glm::sphericalRand(1.0f), 1);
 
 ![](/doc/manual/random-diskrand.png)
 
-Figure 4.14.4: glm::vec4(glm::diskRand(1.0f), 0, 1);
+Figure 4.13.4: glm::vec4(glm::diskRand(1.0f), 0, 1);
 
 ![](/doc/manual/random-ballrand.png)
 
-Figure 4.14.5: glm::vec4(glm::ballRand(1.0f), 1);
+Figure 4.13.5: glm::vec4(glm::ballRand(1.0f), 1);
 
 ![](/doc/manual/random-gaussrand.png)
 
-Figure 4.14.6: glm::vec4(glm::gaussRand(glm::vec3(0), glm::vec3(1)), 1);
+Figure 4.13.6: glm::vec4(glm::gaussRand(glm::vec3(0), glm::vec3(1)), 1);
 
-### <a name="section4_15"></a> 4.15. GLM\_GTC\_reciprocal
+### <a name="section4_14"></a> 4.14. GLM\_GTC\_reciprocal
 
 Reciprocal trigonometric functions (e.g. secant, cosecant, tangent).
 
-&lt;glm/gtc/reciprocal.hpp&gt; need to be included to use these functionalities.
+&lt;glm/gtc/reciprocal.hpp&gt; need to be included to use the features of this extension.
 
-### <a name="section4_16"></a> 4.16. GLM\_GTC\_round
+### <a name="section4_15"></a> 4.15. GLM\_GTC\_round
 
 Various rounding operations and common special cases thereof.
 
-&lt;glm/gtc/round.hpp&gt; need to be included to use these functionalities.
+&lt;glm/gtc/round.hpp&gt; need to be included to use the features of this extension.
 
-### <a name="section4_17"></a> 4.17. GLM\_GTC\_type\_aligned
+### <a name="section4_16"></a> 4.16. GLM\_GTC\_type\_aligned
 
 Aligned vector types.
 
-&lt;glm/gtc/type\_aligned.hpp&gt; need to be included to use these functionalities.
+&lt;glm/gtc/type\_aligned.hpp&gt; need to be included to use the features of this extension.
 
-### <a name="section4_18"></a> 4.18. GLM\_GTC\_type\_precision
+### <a name="section4_17"></a> 4.17. GLM\_GTC\_type\_precision
 
 Vector and matrix types with defined precisions, e.g. i8vec4, which is a 4D vector of signed 8-bit integers.
 
@@ -787,9 +780,9 @@ Available defines for 64-bit floating-point types (glm::f64vec\*, glm::f64mat\*,
 * GLM\_PRECISION\_MEDIUMP\_FLOAT64: Medium precision
 * GLM\_PRECISION\_HIGHP\_FLOAT64: High precision (default)
 
-&lt;glm/gtc/type\_precision.hpp&gt; need to be included to use these functionalities.
+&lt;glm/gtc/type\_precision.hpp&gt; need to be included to use the features of this extension.
 
-### <a name="section4_19"></a> 4.19. GLM\_GTC\_type\_ptr
+### <a name="section4_18"></a> 4.18. GLM\_GTC\_type\_ptr
 
 Facilitate interactions between pointers to basic types (e.g. float*) and GLM types (e.g. mat4).
 
@@ -827,13 +820,13 @@ implicit cast in this example. However cast operators may produce programs runni
 
 &lt;glm/gtc/type\_ptr.hpp&gt; need to be included to use these features.
 
-### <a name="section4_20"></a> 4.20. GLM\_GTC\_ulp
+### <a name="section4_19"></a> 4.19. GLM\_GTC\_ulp
 
 Measure a function's accuracy given a reference implementation of it. This extension works on floating-point data and provides results in [ULP](http://ljk.imag.fr/membres/Carine.Lucas/TPScilab/JMMuller/ulp-toms.pdf).
 
 &lt;glm/gtc/ulp.hpp&gt; need to be included to use these features.
 
-### <a name="section4_21"></a> 4.21. GLM\_GTC\_vec1
+### <a name="section4_20"></a> 4.20. GLM\_GTC\_vec1
 
 Add \*vec1 types.
 

readme.md

@@ -67,6 +67,7 @@ glm::mat4 camera(float Translate, glm::vec2 const& Rotate)
 - No more default initialization of vector, matrix and quaternion types
 - Added lowp variant of GTC_color_space convertLinearToSRGB #419
 - Replaced the manual by a markdown version #458
+- Improved API documentation #668
 - Optimized GTC_packing implementation
 - Optimized GTC_noise functions
 - Optimized GTC_color_space HSV to RGB conversions

test/gtc/CMakeLists.txt

@@ -2,7 +2,6 @@ glmCreateTestGTC(gtc_bitfield)
 glmCreateTestGTC(gtc_color_space)
 glmCreateTestGTC(gtc_constants)
 glmCreateTestGTC(gtc_epsilon)
-glmCreateTestGTC(gtc_functions)
 glmCreateTestGTC(gtc_integer)
 glmCreateTestGTC(gtc_matrix_access)
 glmCreateTestGTC(gtc_matrix_integer)

test/gtx/CMakeLists.txt

@@ -14,6 +14,7 @@ glmCreateTestGTC(gtx_exterior_product)
 glmCreateTestGTC(gtx_fast_exponential)
 glmCreateTestGTC(gtx_fast_square_root)
 glmCreateTestGTC(gtx_fast_trigonometry)
+glmCreateTestGTC(gtx_functions)
 glmCreateTestGTC(gtx_gradient_paint)
 glmCreateTestGTC(gtx_handed_coordinate_space)
 glmCreateTestGTC(gtx_integer)

test/gtx/gtx_functions.cpp

@@ -1,4 +1,4 @@
-#include <glm/gtc/functions.hpp>
+#include <glm/gtx/functions.hpp>
 #include <vector>
 
 int test_gauss_1d()