anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Clean up doxygen documentation

Browse Source
master
Christophe Riccio ago%!(EXTRA string=7 years)
parent 0e3c9f0d7d
commit a0c47aced6
12 changed files with 163 additions and 144 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 201
      glm/ext/matrix_clip_space.hpp
  2. 6
      glm/ext/matrix_projection.hpp
  3. 22
      glm/ext/matrix_transform.hpp
  4. 24
      glm/ext/quaternion_common.hpp
  5. 8
      glm/ext/quaternion_exponential.hpp
  6. 8
      glm/ext/quaternion_relational.hpp
  7. 2
      glm/ext/quaternion_transform.hpp
  8. 14
      glm/ext/quaternion_trigonometric.hpp
  9. 4
      glm/ext/scalar_relational.hpp
  10. 4
      glm/ext/vector_float1.hpp
  11. 6
      glm/ext/vector_float1_precision.hpp
  12. 8
      glm/ext/vector_relational.hpp

201
glm/ext/matrix_clip_space.hpp
Unescape View File

@ -32,8 +32,9 @@ namespace glm
/// Creates a matrix for projecting two-dimensional coordinates onto the screen. /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @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 - 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> /// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluOrtho2D.xml">gluOrtho2D man page</a>
template<typename T> template<typename T>
@ -43,8 +44,9 @@ namespace glm
/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates. /// 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) /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @tparam Q A value from qualifier enum
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH_ZO( 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. /// 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) /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @tparam Q A value from qualifier enum
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH_NO( 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. /// 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) /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @tparam Q A value from qualifier enum
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH_ZO( 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. /// 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) /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @tparam Q A value from qualifier enum
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH_NO( 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. /// 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) /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @tparam Q A value from qualifier enum
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoZO( 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. /// 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) /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @tparam Q A value from qualifier enum
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoNO( 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) /// 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) /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @tparam Q A value from qualifier enum
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoLH( 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) /// 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) /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @tparam Q A value from qualifier enum
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) /// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top)
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> orthoRH( 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. /// 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. /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @tparam Q A value from qualifier enum
///
/// @see - glm::ortho(T const& left, T const& right, T const& bottom, T const& top) /// @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> /// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glOrtho.xml">glOrtho man page</a>
template<typename T> template<typename T>
@ -136,8 +146,8 @@ namespace glm
/// Creates a left handed frustum matrix. /// 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) /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @tparam Q A value from qualifier enum
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH_ZO( GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH_ZO(
T left, T right, T bottom, T top, T near, T far); T left, T right, T bottom, T top, T near, T far);
@ -145,8 +155,8 @@ namespace glm
/// Creates a left handed frustum matrix. /// 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) /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @tparam Q A value from qualifier enum
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH_NO( GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH_NO(
T left, T right, T bottom, T top, T near, T far); T left, T right, T bottom, T top, T near, T far);
@ -154,8 +164,8 @@ namespace glm
/// Creates a right handed frustum matrix. /// 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) /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @tparam Q A value from qualifier enum
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH_ZO( GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH_ZO(
T left, T right, T bottom, T top, T near, T far); T left, T right, T bottom, T top, T near, T far);
@ -163,8 +173,8 @@ namespace glm
/// Creates a right handed frustum matrix. /// 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) /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @tparam Q A value from qualifier enum
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH_NO( GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH_NO(
T left, T right, T bottom, T top, T near, T far); 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. /// 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) /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @tparam Q A value from qualifier enum
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumZO( GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumZO(
T left, T right, T bottom, T top, T near, T far); 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. /// 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) /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @tparam Q A value from qualifier enum
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumNO( GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumNO(
T left, T right, T bottom, T top, T near, T far); 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) /// 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) /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @tparam Q A value from qualifier enum
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH( GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH(
T left, T right, T bottom, T top, T near, T far); 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) /// 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) /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @tparam Q A value from qualifier enum
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH( GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH(
T left, T right, T bottom, T top, T near, T far); 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. /// 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. /// 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. /// @tparam T A floating-point scalar type
/// @see gtc_matrix_transform /// @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> /// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glFrustum.xml">glFrustum man page</a>
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> frustum( 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 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 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). /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_ZO( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_ZO(
T fovy, T aspect, T near, T far); 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 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 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). /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_NO( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_NO(
T fovy, T aspect, T near, T far); 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 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 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). /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_ZO( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_ZO(
T fovy, T aspect, T near, T far); 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 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 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). /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_NO( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_NO(
T fovy, T aspect, T near, T far); 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 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 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). /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveZO( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveZO(
T fovy, T aspect, T near, T far); 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 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 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). /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveNO( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveNO(
T fovy, T aspect, T near, T far); 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 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 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). /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH(
T fovy, T aspect, T near, T far); 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 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 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). /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH(
T fovy, T aspect, T near, T far); 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 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 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). /// @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> /// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluPerspective.xml">gluPerspective man page</a>
template<typename T> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspective( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspective(
@ -346,8 +365,9 @@ namespace glm
/// @param height Height of the viewport /// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @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). /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_ZO( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_ZO(
T fov, T width, T height, T near, T far); T fov, T width, T height, T near, T far);
@ -360,8 +380,9 @@ namespace glm
/// @param height Height of the viewport /// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @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). /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_NO( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_NO(
T fov, T width, T height, T near, T far); T fov, T width, T height, T near, T far);
@ -374,8 +395,9 @@ namespace glm
/// @param height Height of the viewport /// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @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). /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_ZO( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_ZO(
T fov, T width, T height, T near, T far); T fov, T width, T height, T near, T far);
@ -388,8 +410,9 @@ namespace glm
/// @param height Height of the viewport /// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @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). /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_NO( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_NO(
T fov, T width, T height, T near, T far); T fov, T width, T height, T near, T far);
@ -402,8 +425,9 @@ namespace glm
/// @param height Height of the viewport /// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @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). /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovZO( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovZO(
T fov, T width, T height, T near, T far); T fov, T width, T height, T near, T far);
@ -416,8 +440,9 @@ namespace glm
/// @param height Height of the viewport /// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @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). /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovNO( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovNO(
T fov, T width, T height, T near, T far); T fov, T width, T height, T near, T far);
@ -431,8 +456,9 @@ namespace glm
/// @param height Height of the viewport /// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @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). /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH(
T fov, T width, T height, T near, T far); T fov, T width, T height, T near, T far);
@ -446,8 +472,9 @@ namespace glm
/// @param height Height of the viewport /// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @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). /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH(
T fov, T width, T height, T near, T far); T fov, T width, T height, T near, T far);
@ -460,8 +487,9 @@ namespace glm
/// @param height Height of the viewport /// @param height Height of the viewport
/// @param near Specifies the distance from the viewer to the near clipping plane (always positive). /// @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). /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFov( GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFov(
T fov, T width, T height, T near, T far); 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 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 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 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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveLH( GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveLH(
T fovy, T aspect, T near); 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 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 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 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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveRH( GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveRH(
T fovy, T aspect, T near); 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 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 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 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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspective( GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspective(
T fovy, T aspect, T near); 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 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 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 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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective( GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective(
T fovy, T aspect, T near); 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 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 near Specifies the distance from the viewer to the near clipping plane (always positive).
/// @param ep Epsilon /// @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> template<typename T>
GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective( GLM_FUNC_DECL mat<4, 4, T, defaultp> tweakedInfinitePerspective(
T fovy, T aspect, T near, T ep); T fovy, T aspect, T near, T ep);

6
glm/ext/matrix_projection.hpp
Unescape View File

@ -4,15 +4,15 @@
/// @defgroup ext_matrix_projection GLM_EXT_matrix_projection /// @defgroup ext_matrix_projection GLM_EXT_matrix_projection
/// @ingroup ext /// @ingroup ext
/// ///
/// Include <glm/ext/matrix_projection.hpp> to use the features of this extension. /// Functions that generate common projection transformation matrices.
///
/// Defines functions that generate common transformation matrices.
/// ///
/// The matrices generated by this extension use standard OpenGL fixed-function /// The matrices generated by this extension use standard OpenGL fixed-function
/// conventions. For example, the lookAt function generates a transform from world /// conventions. For example, the lookAt function generates a transform from world
/// space into the specific eye space that the projective matrix functions /// space into the specific eye space that the projective matrix functions
/// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility /// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility
/// specifications defines the particular layout of this eye space. /// specifications defines the particular layout of this eye space.
///
/// Include <glm/ext/matrix_projection.hpp> to use the features of this extension.
#pragma once #pragma once

22
glm/ext/matrix_transform.hpp
Unescape View File

@ -39,7 +39,10 @@ namespace glm
/// ///
/// @param m Input matrix multiplied by this translation matrix. /// @param m Input matrix multiplied by this translation matrix.
/// @param v Coordinates of a translation vector. /// @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 /// @code
/// #include <glm/glm.hpp> /// #include <glm/glm.hpp>
/// #include <glm/gtc/matrix_transform.hpp> /// #include <glm/gtc/matrix_transform.hpp>
@ -63,7 +66,9 @@ namespace glm
/// @param m Input matrix multiplied by this rotation matrix. /// @param m Input matrix multiplied by this rotation matrix.
/// @param angle Rotation angle expressed in radians. /// @param angle Rotation angle expressed in radians.
/// @param axis Rotation axis, recommended to be normalized. /// @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(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) /// @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 m Input matrix multiplied by this scale matrix.
/// @param v Ratio of scaling for each axis. /// @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(mat<4, 4, T, Q> const& m, T x, T y, T z)
/// @see - scale(vec<3, T, Q> const& v) /// @see - scale(vec<3, T, Q> const& v)
@ -91,6 +98,9 @@ namespace glm
/// @param center Position where the camera is looking at /// @param center Position where the camera is looking at
/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1) /// @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 - 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> template<typename T, qualifier Q>
GLM_FUNC_DECL mat<4, 4, T, Q> lookAtRH( 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 center Position where the camera is looking at
/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1) /// @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 - 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> template<typename T, qualifier Q>
GLM_FUNC_DECL mat<4, 4, T, Q> lookAtLH( 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 center Position where the camera is looking at
/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1) /// @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 - 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> /// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluLookAt.xml">gluLookAt man page</a>
template<typename T, qualifier Q> template<typename T, qualifier Q>

24
glm/ext/quaternion_common.hpp
Unescape View File

@ -34,7 +34,9 @@ namespace glm
/// @param x A quaternion /// @param x A quaternion
/// @param y A quaternion /// @param y A quaternion
/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1]. /// @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) /// @see - slerp(qua<T, Q> const& x, qua<T, Q> const& y, T const& a)
template<typename T, qualifier Q> template<typename T, qualifier Q>
@ -46,7 +48,9 @@ namespace glm
/// @param x A quaternion /// @param x A quaternion
/// @param y A quaternion /// @param y A quaternion
/// @param a Interpolation factor. The interpolation is defined in the range [0, 1]. /// @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> template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> lerp(qua<T, Q> const& x, qua<T, Q> const& y, T a); 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 x A quaternion
/// @param y A quaternion /// @param y A quaternion
/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1]. /// @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> template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> slerp(qua<T, Q> const& x, qua<T, Q> const& y, T a); GLM_FUNC_DECL qua<T, Q> slerp(qua<T, Q> const& x, qua<T, Q> const& y, T a);
/// Returns the q conjugate. /// 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> template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> conjugate(qua<T, Q> const& q); GLM_FUNC_DECL qua<T, Q> conjugate(qua<T, Q> const& q);
/// Returns the q inverse. /// 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> template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> inverse(qua<T, Q> const& 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. /// /!\ 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> template<typename T, qualifier Q>
GLM_FUNC_DECL vec<4, bool, Q> isnan(qua<T, Q> const& x); 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 /// otherwise, including for implementations with no infinity
/// representations. /// 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> template<typename T, qualifier Q>
GLM_FUNC_DECL vec<4, bool, Q> isinf(qua<T, Q> const& x); GLM_FUNC_DECL vec<4, bool, Q> isinf(qua<T, Q> const& x);

8
glm/ext/quaternion_exponential.hpp
Unescape View File

@ -29,8 +29,6 @@ namespace glm
/// ///
/// @tparam T A floating-point scalar type /// @tparam T A floating-point scalar type
/// @tparam Q A value from qualifier enum /// @tparam Q A value from qualifier enum
///
/// @see ext_quaternion_exponential
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> exp(qua<T, Q> const& 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 T A floating-point scalar type
/// @tparam Q A value from qualifier enum /// @tparam Q A value from qualifier enum
///
/// @see ext_quaternion_exponential
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> log(qua<T, Q> const& 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 T A floating-point scalar type
/// @tparam Q A value from qualifier enum /// @tparam Q A value from qualifier enum
///
/// @see ext_quaternion_exponential
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> pow(qua<T, Q> const& q, T y); 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 T A floating-point scalar type
/// @tparam Q A value from qualifier enum /// @tparam Q A value from qualifier enum
///
/// @see ext_quaternion_exponential
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL qua<T, Q> sqrt(qua<T, Q> const& q); GLM_FUNC_DECL qua<T, Q> sqrt(qua<T, Q> const& q);

8
glm/ext/quaternion_relational.hpp
Unescape View File

@ -26,8 +26,6 @@ namespace glm
/// ///
/// @tparam T Floating-point scalar types /// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum /// @tparam Q Value from qualifier enum
///
/// @see ext_quaternion_relational
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL vec<4, bool, Q> equal(qua<T, Q> const& x, qua<T, Q> const& y); 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 T Floating-point scalar types
/// @tparam Q Value from qualifier enum /// @tparam Q Value from qualifier enum
///
/// @see ext_quaternion_relational
template<typename T, qualifier Q> 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); 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 T Floating-point scalar types
/// @tparam Q Value from qualifier enum /// @tparam Q Value from qualifier enum
///
/// @see ext_quaternion_relational
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_DECL vec<4, bool, Q> notEqual(qua<T, Q> const& x, qua<T, Q> const& y); 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 T Floating-point scalar types
/// @tparam Q Value from qualifier enum /// @tparam Q Value from qualifier enum
///
/// @see ext_quaternion_relational
template<typename T, qualifier Q> 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_FUNC_DECL vec<4, bool, Q> notEqual(qua<T, Q> const& x, qua<T, Q> const& y, T epsilon);

2
glm/ext/quaternion_transform.hpp
Unescape View File

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

14
glm/ext/quaternion_trigonometric.hpp
Unescape View File

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

4
glm/ext/scalar_relational.hpp
Unescape View File

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

4
glm/ext/vector_float1.hpp
Unescape View File

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

6
glm/ext/vector_float1_precision.hpp
Unescape View File

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

8
glm/ext/vector_relational.hpp
Unescape View File

@ -31,8 +31,6 @@ namespace glm
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector /// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point or integer scalar types /// @tparam T Floating-point or integer scalar types
/// @tparam Q Value from qualifier enum /// @tparam Q Value from qualifier enum
///
/// @see ext_vector_relational
template<length_t L, typename T, qualifier Q> 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); 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 L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point or integer scalar types /// @tparam T Floating-point or integer scalar types
/// @tparam Q Value from qualifier enum /// @tparam Q Value from qualifier enum
///
/// @see ext_vector_relational
template<length_t L, typename T, qualifier Q> 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); 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 L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point or integer scalar types /// @tparam T Floating-point or integer scalar types
/// @tparam Q Value from qualifier enum /// @tparam Q Value from qualifier enum
///
/// @see ext_vector_relational
template<length_t L, typename T, qualifier Q> 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); 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 L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point or integer scalar types /// @tparam T Floating-point or integer scalar types
/// @tparam Q Value from qualifier enum /// @tparam Q Value from qualifier enum
///
/// @see ext_vector_relational
template<length_t L, typename T, qualifier Q> 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); 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);

Write Preview
Loading…
Cancel
Save