Clean up doxygen documentation

glm/ext/matrix_clip_space.hpp

@@ -32,8 +32,9 @@ namespace glm
 
 	/// Creates a matrix for projecting two-dimensional coordinates onto the screen.
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
 	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top, T const& zNear, T const& zFar)
 	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluOrtho2D.xml">gluOrtho2D man page</a>
 	template<typename T>
@@ -43,8 +44,9 @@ namespace glm
 	/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
 	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
 	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH_ZO(
@@ -53,8 +55,9 @@ namespace glm
 	/// Creates a matrix for an orthographic parallel viewing volume using right-handed coordinates.
 	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
 	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH_NO(
@@ -63,8 +66,9 @@ namespace glm
 	/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
 	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
 	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH_ZO(
@@ -73,8 +77,9 @@ namespace glm
 	/// Creates a matrix for an orthographic parallel viewing volume, using right-handed coordinates.
 	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
 	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH_NO(
@@ -83,8 +88,9 @@ namespace glm
 	/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
 	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
 	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoZO(
@@ -93,8 +99,9 @@ namespace glm
 	/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
 	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
 	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoNO(
@@ -104,8 +111,9 @@ namespace glm
 	/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
 	/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
 	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH(
@@ -115,8 +123,9 @@ namespace glm
 	/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
 	/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
 	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH(
@@ -125,8 +134,9 @@ namespace glm
 	/// Creates a matrix for an orthographic parallel viewing volume, using the default handedness and default near and far clip planes definition.
 	/// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
 	/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
 	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glOrtho.xml">glOrtho man page</a>
 	template<typename T>
@@ -136,8 +146,8 @@ namespace glm
 	/// Creates a left handed frustum matrix.
 	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH_ZO(
 		T left, T right, T bottom, T top, T near, T far);
@@ -145,8 +155,8 @@ namespace glm
 	/// Creates a left handed frustum matrix.
 	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH_NO(
 		T left, T right, T bottom, T top, T near, T far);
@@ -154,8 +164,8 @@ namespace glm
 	/// Creates a right handed frustum matrix.
 	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH_ZO(
 		T left, T right, T bottom, T top, T near, T far);
@@ -163,8 +173,8 @@ namespace glm
 	/// Creates a right handed frustum matrix.
 	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH_NO(
 		T left, T right, T bottom, T top, T near, T far);
@@ -172,8 +182,8 @@ namespace glm
 	/// Creates a frustum matrix using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
 	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumZO(
 		T left, T right, T bottom, T top, T near, T far);
@@ -181,8 +191,8 @@ namespace glm
 	/// Creates a frustum matrix using left-handed coordinates if GLM_FORCE_LEFT_HANDED if defined or right-handed coordinates otherwise.
 	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumNO(
 		T left, T right, T bottom, T top, T near, T far);
@@ -191,8 +201,8 @@ namespace glm
 	/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
 	/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH(
 		T left, T right, T bottom, T top, T near, T far);
@@ -201,8 +211,8 @@ namespace glm
 	/// If GLM_FORCE_DEPTH_ZERO_TO_ONE is defined, the near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
 	/// Otherwise, the near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH(
 		T left, T right, T bottom, T top, T near, T far);
@@ -210,8 +220,8 @@ namespace glm
 	/// Creates a frustum matrix with default handedness, using the default handedness and default near and far clip planes definition.
 	/// To change default handedness use GLM_FORCE_LEFT_HANDED. To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
 	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glFrustum.xml">glFrustum man page</a>
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustum(
@@ -225,8 +235,9 @@ namespace glm
 	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_ZO(
 		T fovy, T aspect, T near, T far);
@@ -238,8 +249,9 @@ namespace glm
 	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_NO(
 		T fovy, T aspect, T near, T far);
@@ -251,8 +263,9 @@ namespace glm
 	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_ZO(
 		T fovy, T aspect, T near, T far);
@@ -264,8 +277,9 @@ namespace glm
 	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_NO(
 		T fovy, T aspect, T near, T far);
@@ -277,8 +291,9 @@ namespace glm
 	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveZO(
 		T fovy, T aspect, T near, T far);
@@ -290,8 +305,9 @@ namespace glm
 	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveNO(
 		T fovy, T aspect, T near, T far);
@@ -304,8 +320,9 @@ namespace glm
 	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH(
 		T fovy, T aspect, T near, T far);
@@ -318,8 +335,9 @@ namespace glm
 	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH(
 		T fovy, T aspect, T near, T far);
@@ -331,8 +349,9 @@ namespace glm
 	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluPerspective.xml">gluPerspective man page</a>
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspective(
@@ -346,8 +365,9 @@ namespace glm
 	/// @param height Height of the viewport
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_ZO(
 		T fov, T width, T height, T near, T far);
@@ -360,8 +380,9 @@ namespace glm
 	/// @param height Height of the viewport
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_NO(
 		T fov, T width, T height, T near, T far);
@@ -374,8 +395,9 @@ namespace glm
 	/// @param height Height of the viewport
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_ZO(
 		T fov, T width, T height, T near, T far);
@@ -388,8 +410,9 @@ namespace glm
 	/// @param height Height of the viewport
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_NO(
 		T fov, T width, T height, T near, T far);
@@ -402,8 +425,9 @@ namespace glm
 	/// @param height Height of the viewport
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovZO(
 		T fov, T width, T height, T near, T far);
@@ -416,8 +440,9 @@ namespace glm
 	/// @param height Height of the viewport
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovNO(
 		T fov, T width, T height, T near, T far);
@@ -431,8 +456,9 @@ namespace glm
 	/// @param height Height of the viewport
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH(
 		T fov, T width, T height, T near, T far);
@@ -446,8 +472,9 @@ namespace glm
 	/// @param height Height of the viewport
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH(
 		T fov, T width, T height, T near, T far);
@@ -460,8 +487,9 @@ namespace glm
 	/// @param height Height of the viewport
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFov(
 		T fov, T width, T height, T near, T far);
@@ -471,8 +499,9 @@ namespace glm
 	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
 	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveLH(
 		T fovy, T aspect, T near);
@@ -482,8 +511,9 @@ namespace glm
 	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
 	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveRH(
 		T fovy, T aspect, T near);
@@ -493,8 +523,9 @@ namespace glm
 	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
 	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspective(
 		T fovy, T aspect, T near);
@@ -504,8 +535,9 @@ namespace glm
 	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
 	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective(
 		T fovy, T aspect, T near);
@@ -516,8 +548,9 @@ namespace glm
 	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
 	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @param ep Epsilon
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
-	/// @see gtc_matrix_transform
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective(
 		T fovy, T aspect, T near, T ep);

glm/ext/matrix_projection.hpp

@@ -4,15 +4,15 @@
 /// @defgroup ext_matrix_projection GLM_EXT_matrix_projection
 /// @ingroup ext
 ///
-/// Include <glm/ext/matrix_projection.hpp> to use the features of this extension.
-///
-/// Defines functions that generate common transformation matrices.
+/// Functions that generate common projection 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.
+///
+/// Include <glm/ext/matrix_projection.hpp> to use the features of this extension.
 
 #pragma once
 

glm/ext/matrix_transform.hpp

@@ -39,7 +39,10 @@ namespace glm
 	///
 	/// @param m Input matrix multiplied by this translation matrix.
 	/// @param v Coordinates of a translation vector.
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
 	/// @code
 	/// #include <glm/glm.hpp>
 	/// #include <glm/gtc/matrix_transform.hpp>
@@ -63,7 +66,9 @@ namespace glm
 	/// @param m Input matrix multiplied by this rotation matrix.
 	/// @param angle Rotation angle expressed in radians.
 	/// @param axis Rotation axis, recommended to be normalized.
-	/// @tparam T Value type used to build the matrix. Supported: half, float or double.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	///
 	/// @see - rotate(mat<4, 4, T, Q> const& m, T angle, T x, T y, T z)
 	/// @see - rotate(T angle, vec<3, T, Q> const& v)
@@ -76,7 +81,9 @@ namespace glm
 	///
 	/// @param m Input matrix multiplied by this scale matrix.
 	/// @param v Ratio of scaling for each axis.
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommended), float or double.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	///
 	/// @see - scale(mat<4, 4, T, Q> const& m, T x, T y, T z)
 	/// @see - scale(vec<3, T, Q> const& v)
@@ -91,6 +98,9 @@ namespace glm
 	/// @param center Position where the camera is looking at
 	/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
 	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
 	/// @see - frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal)
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL mat<4, 4, T, Q> lookAtRH(
@@ -102,6 +112,9 @@ namespace glm
 	/// @param center Position where the camera is looking at
 	/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
 	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
 	/// @see - frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal)
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL mat<4, 4, T, Q> lookAtLH(
@@ -113,6 +126,9 @@ namespace glm
 	/// @param center Position where the camera is looking at
 	/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
 	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
+	///
 	/// @see - frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal) frustum(T const& left, T const& right, T const& bottom, T const& top, T const& nearVal, T const& farVal)
 	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluLookAt.xml">gluLookAt man page</a>
 	template<typename T, qualifier Q>

glm/ext/quaternion_common.hpp

@@ -34,7 +34,9 @@ namespace glm
 	/// @param x A quaternion
 	/// @param y A quaternion
 	/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1].
-	/// @tparam T Floating-point scalar types.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	///
 	/// @see - slerp(qua<T, Q> const& x, qua<T, Q> const& y, T const& a)
 	template<typename T, qualifier Q>
@@ -46,7 +48,9 @@ namespace glm
 	/// @param x A quaternion
 	/// @param y A quaternion
 	/// @param a Interpolation factor. The interpolation is defined in the range [0, 1].
-	/// @tparam T Floating-point scalar types.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL qua<T, Q> lerp(qua<T, Q> const& x, qua<T, Q> const& y, T a);
 
@@ -56,19 +60,23 @@ namespace glm
 	/// @param x A quaternion
 	/// @param y A quaternion
 	/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1].
-	/// @tparam T Floating-point scalar types.
+	///
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL qua<T, Q> slerp(qua<T, Q> const& x, qua<T, Q> const& y, T a);
 
 	/// Returns the q conjugate.
 	///
-	/// @tparam T Floating-point scalar types.
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL qua<T, Q> conjugate(qua<T, Q> const& q);
 
 	/// Returns the q inverse.
 	///
-	/// @tparam T Floating-point scalar types.
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL qua<T, Q> inverse(qua<T, Q> const& q);
 
@@ -80,7 +88,8 @@ namespace glm
 	///
 	/// /!\ When using compiler fast math, this function may fail.
 	///
-	/// @tparam T Floating-point scalar types.
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL vec<4, bool, Q> isnan(qua<T, Q> const& x);
 
@@ -90,7 +99,8 @@ namespace glm
 	/// otherwise, including for implementations with no infinity
 	/// representations.
 	///
-	/// @tparam T Floating-point scalar types.
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL vec<4, bool, Q> isinf(qua<T, Q> const& x);
 

glm/ext/quaternion_exponential.hpp

@@ -29,8 +29,6 @@ namespace glm
 	///
 	/// @tparam T A floating-point scalar type
 	/// @tparam Q A value from qualifier enum
-	///
-	/// @see ext_quaternion_exponential
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL qua<T, Q> exp(qua<T, Q> const& q);
 
@@ -38,8 +36,6 @@ namespace glm
 	///
 	/// @tparam T A floating-point scalar type
 	/// @tparam Q A value from qualifier enum
-	///
-	/// @see ext_quaternion_exponential
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL qua<T, Q> log(qua<T, Q> const& q);
 
@@ -47,8 +43,6 @@ namespace glm
 	///
 	/// @tparam T A floating-point scalar type
 	/// @tparam Q A value from qualifier enum
-	///
-	/// @see ext_quaternion_exponential
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL qua<T, Q> pow(qua<T, Q> const& q, T y);
 
@@ -56,8 +50,6 @@ namespace glm
 	///
 	/// @tparam T A floating-point scalar type
 	/// @tparam Q A value from qualifier enum
-	///
-	/// @see ext_quaternion_exponential
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL qua<T, Q> sqrt(qua<T, Q> const& q);
 

glm/ext/quaternion_relational.hpp

@@ -26,8 +26,6 @@ namespace glm
 	///
 	/// @tparam T Floating-point scalar types
 	/// @tparam Q Value from qualifier enum
-	///
-	/// @see ext_quaternion_relational
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL vec<4, bool, Q> equal(qua<T, Q> const& x, qua<T, Q> const& y);
 
@@ -35,8 +33,6 @@ namespace glm
 	///
 	/// @tparam T Floating-point scalar types
 	/// @tparam Q Value from qualifier enum
-	///
-	/// @see ext_quaternion_relational
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL vec<4, bool, Q> equal(qua<T, Q> const& x, qua<T, Q> const& y, T epsilon);
 
@@ -44,8 +40,6 @@ namespace glm
 	///
 	/// @tparam T Floating-point scalar types
 	/// @tparam Q Value from qualifier enum
-	///
-	/// @see ext_quaternion_relational
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL vec<4, bool, Q> notEqual(qua<T, Q> const& x, qua<T, Q> const& y);
 
@@ -53,8 +47,6 @@ namespace glm
 	///
 	/// @tparam T Floating-point scalar types
 	/// @tparam Q Value from qualifier enum
-	///
-	/// @see ext_quaternion_relational
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL vec<4, bool, Q> notEqual(qua<T, Q> const& x, qua<T, Q> const& y, T epsilon);
 

glm/ext/quaternion_transform.hpp

@@ -32,8 +32,6 @@ namespace glm
 	///
 	/// @tparam T Floating-point scalar types
 	/// @tparam Q Value from qualifier enum
-	///
-	/// @see ext_quaternion_transform
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL qua<T, Q> rotate(qua<T, Q> const& q, T const& angle, vec<3, T, Q> const& axis);
 	/// @}

glm/ext/quaternion_trigonometric.hpp

@@ -28,17 +28,15 @@ namespace glm
 
 	/// Returns the quaternion rotation angle.
 	///
-	/// @tparam T Floating-point scalar types.
-	///
-	/// @see ext_quaternion_trigonometric
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL T angle(qua<T, Q> const& x);
 
 	/// Returns the q rotation axis.
 	///
-	/// @tparam T Floating-point scalar types.
-	///
-	/// @see ext_quaternion_trigonometric
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL vec<3, T, Q> axis(qua<T, Q> const& x);
 
@@ -46,9 +44,9 @@ namespace glm
 	///
 	/// @param angle Angle expressed in radians.
 	/// @param axis Axis of the quaternion, must be normalized.
-	/// @tparam T Floating-point scalar types.
 	///
-	/// @see ext_quaternion_trigonometric
+	/// @tparam T A floating-point scalar type
+	/// @tparam Q A value from qualifier enum
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL qua<T, Q> angleAxis(T const& angle, vec<3, T, Q> const& axis);
 

glm/ext/scalar_relational.hpp

@@ -23,8 +23,6 @@ namespace glm
 	/// True if this expression is satisfied.
 	///
 	/// @tparam genType Floating-point or integer scalar types
-	///
-	/// @see ext_scalar_relational
 	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR bool equal(genType const& x, genType const& y, genType const& epsilon);
 
@@ -32,8 +30,6 @@ namespace glm
 	/// True if this expression is not satisfied.
 	///
 	/// @tparam genType Floating-point or integer scalar types
-	///
-	/// @see ext_scalar_relational
 	template<typename genType>
 	GLM_FUNC_DECL GLM_CONSTEXPR bool notEqual(genType const& x, genType const& y, genType const& epsilon);
 

glm/ext/vector_float1.hpp

@@ -9,6 +9,7 @@
 /// Include <glm/ext/vector_float1.hpp> to use the features of this extension.
 ///
 /// @see ext_vector_float1_precision extension.
+/// @see ext_vector_double1 extension.
 
 #pragma once
 
@@ -24,9 +25,6 @@ namespace glm
 	/// @{
 
 	/// 1 components vector of single-precision floating-point numbers.
-	///
-	/// @see ext_vector_float1_precision extension.
-	/// @see ext_vector_double1 extension.
 	typedef vec<1, float, defaultp>		vec1;
 
 	/// @}

glm/ext/vector_float1_precision.hpp

@@ -24,18 +24,12 @@ namespace glm
 	/// @{
 
 	/// 1 component vector of single-precision floating-point numbers using high precision arithmetic in term of ULPs.
-	///
-	/// @see ext_vector_float1
 	typedef vec<1, float, highp>		highp_vec1;
 
 	/// 1 component vector of single-precision floating-point numbers using medium precision arithmetic in term of ULPs.
-	///
-	/// @see ext_vector_float1
 	typedef vec<1, float, mediump>		mediump_vec1;
 
 	/// 1 component vector of single-precision floating-point numbers using low precision arithmetic in term of ULPs.
-	///
-	/// @see ext_vector_float1
 	typedef vec<1, float, lowp>			lowp_vec1;
 
 	/// @}

glm/ext/vector_relational.hpp

@@ -31,8 +31,6 @@ namespace glm
 	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
 	/// @tparam T Floating-point or integer scalar types
 	/// @tparam Q Value from qualifier enum
-	///
-	/// @see ext_vector_relational
 	template<length_t L, typename T, qualifier Q>
 	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> equal(vec<L, T, Q> const& x, vec<L, T, Q> const& y, T epsilon);
 
@@ -42,8 +40,6 @@ namespace glm
 	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
 	/// @tparam T Floating-point or integer scalar types
 	/// @tparam Q Value from qualifier enum
-	///
-	/// @see ext_vector_relational
 	template<length_t L, typename T, qualifier Q>
 	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> equal(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, T, Q> const& epsilon);
 
@@ -53,8 +49,6 @@ namespace glm
 	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
 	/// @tparam T Floating-point or integer scalar types
 	/// @tparam Q Value from qualifier enum
-	///
-	/// @see ext_vector_relational
 	template<length_t L, typename T, qualifier Q>
 	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> notEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, T epsilon);
 
@@ -64,8 +58,6 @@ namespace glm
 	/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
 	/// @tparam T Floating-point or integer scalar types
 	/// @tparam Q Value from qualifier enum
-	///
-	/// @see ext_vector_relational
 	template<length_t L, typename T, qualifier Q>
 	GLM_FUNC_DECL GLM_CONSTEXPR vec<L, bool, Q> notEqual(vec<L, T, Q> const& x, vec<L, T, Q> const& y, vec<L, T, Q> const& epsilon);