Added spearate functions to use both nagative one and zero near clip plans #680

glm/gtc/matrix_transform.hpp

@@ -57,8 +57,7 @@ namespace glm
 	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glTranslate.xml">glTranslate man page</a> 
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL mat<4, 4, T, Q> translate(
-		mat<4, 4, T, Q> const& m,
+		mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v);
-		vec<3, T, Q> const& v);
 
 	/// Builds a rotation 4 * 4 matrix created from an axis vector and an angle. 
 	/// 
@@ -72,9 +71,7 @@ namespace glm
 	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glRotate.xml">glRotate man page</a> 
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL mat<4, 4, T, Q> rotate(
-		mat<4, 4, T, Q> const& m,
+		mat<4, 4, T, Q> const& m, T angle, vec<3, T, Q> const& axis);
-		T angle,
-		vec<3, T, Q> const& axis);
 
 	/// Builds a scale 4 * 4 matrix created from 3 scalars. 
 	/// 
@@ -87,51 +84,7 @@ namespace glm
 	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glScale.xml">glScale man page</a> 
 	template<typename T, qualifier Q>
 	GLM_FUNC_DECL mat<4, 4, T, Q> scale(
-		mat<4, 4, T, Q> const& m,
+		mat<4, 4, T, Q> const& m, vec<3, T, Q> const& v);
-		vec<3, T, Q> const& v);
-
-	/// Creates a matrix for an orthographic parallel viewing volume, using the default handedness.
-	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-	/// @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>
-	GLM_FUNC_DECL mat<4, 4, T, defaultp> ortho(
-		T left,
-		T right,
-		T bottom,
-		T top,
-		T zNear,
-		T zFar);
-
-	/// Creates a matrix for an orthographic parallel viewing volume, using left-handedness.
-	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-	/// @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(
-		T left,
-		T right,
-		T bottom,
-		T top,
-		T zNear,
-		T zFar);
-
-	/// Creates a matrix for an orthographic parallel viewing volume, using right-handedness.
-	///
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-	/// @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(
-		T left,
-		T right,
-		T bottom,
-		T top,
-		T zNear,
-		T zFar);
 
 	/// Creates a matrix for projecting two-dimensional coordinates onto the screen.
 	///
@@ -141,52 +94,294 @@ namespace glm
 	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluOrtho2D.xml">gluOrtho2D man page</a> 
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> ortho(
-		T left,
+		T left, T right, T bottom, T top);
-		T right,
-		T bottom,
-		T top);
 
-	/// Creates a frustum matrix with default handedness.
+	/// 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	/// @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(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	/// @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(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	/// @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(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	/// @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(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	/// @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(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	/// @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(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// Creates a matrix for an orthographic parallel viewing volume, using left-handed coordinates.
+	/// 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	/// @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(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// Creates a matrix for an orthographic parallel viewing volume, using right-handed coordinates.
+	/// 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	/// @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(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	/// @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>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> ortho(
+		T left, T right, T bottom, T top, T zNear, T zFar);
+
+	/// 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	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);
+
+	/// 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	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);
+
+	/// 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	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);
+
+	/// 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	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);
+
+	/// 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumZO(
+		T left, T right, T bottom, T top, T near, T far);
+
+	/// 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumNO(
+		T left, T right, T bottom, T top, T near, T far);
+
+	/// Creates a left handed frustum matrix.
+	/// 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH(
+		T left, T right, T bottom, T top, T near, T far);
+
+	/// Creates a right handed frustum matrix.
+	/// 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH(
+		T left, T right, T bottom, T top, T near, T far);
+
+	/// 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 recommanded), float or double.
 	/// @see gtc_matrix_transform
 	/// @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(
-		T left,
+		T left, T right, T bottom, T top, T near, T far);
-		T right,
-		T bottom,
-		T top,
-		T near,
-		T far);
 
-	/// Creates a left handed frustum matrix.
+
+	/// Creates a matrix for a right handed, symetric perspective-view frustum.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
 	/// 
+	/// @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).
+	/// @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 recommanded), float or double.
 	/// @see gtc_matrix_transform
 	template<typename T>
-	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumLH(
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_ZO(
-		T left,
+		T fovy, T aspect, T near, T far);
-		T right,
-		T bottom,
-		T top,
-		T near,
-		T far);
 
-	/// Creates a right handed frustum matrix.
+	/// Creates a matrix for a right handed, symetric perspective-view frustum.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
 	/// 
+	/// @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).
+	/// @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 recommanded), float or double.
 	/// @see gtc_matrix_transform
 	template<typename T>
-	GLM_FUNC_DECL mat<4, 4, T, defaultp> frustumRH(
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH_NO(
-		T left,
+		T fovy, T aspect, T near, T far);
-		T right,
-		T bottom,
-		T top,
-		T near,
-		T far);
 
-	/// Creates a matrix for a symetric perspective-view frustum based on the default handedness.
+	/// Creates a matrix for a left handed, symetric perspective-view frustum.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	/// 
+	/// @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).
+	/// @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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_ZO(
+		T fovy, T aspect, T near, T far);
+
+	/// Creates a matrix for a left handed, symetric perspective-view frustum.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	/// 
+	/// @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).
+	/// @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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH_NO(
+		T fovy, T aspect, T near, T far);
+
+	/// Creates a matrix for a symetric perspective-view frustum 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)
+	/// 
+	/// @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).
+	/// @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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveZO(
+		T fovy, T aspect, T near, T far);
+
+	/// Creates a matrix for a symetric perspective-view frustum 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)
+	/// 
+	/// @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).
+	/// @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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveNO(
+		T fovy, T aspect, T near, T far);
+
+	/// Creates a matrix for a right handed, symetric perspective-view frustum.
+	/// 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)
+	/// 
+	/// @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).
+	/// @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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH(
+		T fovy, T aspect, T near, T far);
+
+	/// Creates a matrix for a left handed, symetric perspective-view frustum.
+	/// 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)
+	/// 
+	/// @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).
+	/// @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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH(
+		T fovy, T aspect, T near, T far);
+
+	/// Creates a matrix for a symetric perspective-view frustum based on 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.
 	/// 
 	/// @param fovy Specifies the field of view angle 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).
@@ -197,42 +392,10 @@ namespace glm
 	/// @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(
-		T fovy,
+		T fovy, T aspect, T near, T far);
-		T aspect,
-		T near,
-		T far);
 
-	/// Creates a matrix for a right handed, symetric perspective-view frustum.
+	/// Builds a perspective projection matrix based on a field of view using right-handed coordinates.
-	/// 
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
-	/// @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).
-	/// @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 recommanded), float or double.
-	/// @see gtc_matrix_transform
-	template<typename T>
-	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveRH(
-		T fovy,
-		T aspect,
-		T near,
-		T far);
-
-	/// Creates a matrix for a left handed, symetric perspective-view frustum.
-	/// 
-	/// @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).
-	/// @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 recommanded), float or double.
-	/// @see gtc_matrix_transform
-	template<typename T>
-	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveLH(
-		T fovy,
-		T aspect,
-		T near,
-		T far);
-
-	/// Builds a perspective projection matrix based on a field of view and the default handedness.
 	/// 
 	/// @param fov Expressed in radians.
 	/// @param width Width of the viewport
@@ -242,14 +405,82 @@ namespace glm
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
 	template<typename T>
-	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFov(
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_ZO(
-		T fov,
+		T fov, T width, T height, T near, T far);
-		T width,
+
-		T height,
+	/// Builds a perspective projection matrix based on a field of view using right-handed coordinates.
-		T near,
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
-		T far);
+	/// 
+	/// @param fov Expressed in radians.
+	/// @param width Width 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 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH_NO(
+		T fov, T width, T height, T near, T far);
+
+	/// Builds a perspective projection matrix based on a field of view 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)
+	/// 
+	/// @param fov Expressed in radians.
+	/// @param width Width 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 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_ZO(
+		T fov, T width, T height, T near, T far);
+
+	/// Builds a perspective projection matrix based on a field of view using left-handed coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	/// 
+	/// @param fov Expressed in radians.
+	/// @param width Width 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 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH_NO(
+		T fov, T width, T height, T near, T far);
+
+	/// Builds a perspective projection matrix based on a field of view 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)
+	/// 
+	/// @param fov Expressed in radians.
+	/// @param width Width 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 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovZO(
+		T fov, T width, T height, T near, T far);
+
+	/// Builds a perspective projection matrix based on a field of view 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)
+	/// 
+	/// @param fov Expressed in radians.
+	/// @param width Width 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 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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovNO(
+		T fov, T width, T height, T near, T far);
 
 	/// Builds a right handed perspective projection matrix based on a field of view.
+	/// 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)
 	/// 
 	/// @param fov Expressed in radians.
 	/// @param width Width of the viewport
@@ -260,13 +491,11 @@ namespace glm
 	/// @see gtc_matrix_transform
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovRH(
-		T fov,
+		T fov, T width, T height, T near, T far);
-		T width,
-		T height,
-		T near,
-		T far);
 
 	/// Builds a left handed perspective projection matrix based on a field of view.
+	/// 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)
 	/// 
 	/// @param fov Expressed in radians.
 	/// @param width Width of the viewport
@@ -277,22 +506,21 @@ namespace glm
 	/// @see gtc_matrix_transform
 	template<typename T>
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFovLH(
-		T fov,
+		T fov, T width, T height, T near, T far);
-		T width,
-		T height,
-		T near,
-		T far);
 
-	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite with default handedness.
+	/// Builds a perspective projection matrix based on a field of view and 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.
 	/// 
-	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param fov 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 width Width 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 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 recommanded), float or double.
 	/// @see gtc_matrix_transform
 	template<typename T>
-	GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspective(
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> perspectiveFov(
-		T fovy, T aspect, T near);
+		T fov, T width, T height, T near, T far);
 
 	/// Creates a matrix for a left handed, symmetric perspective-view frustum with far plane at infinite.
 	///
@@ -316,6 +544,17 @@ namespace glm
 	GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspectiveRH(
 		T fovy, T aspect, T near);
 
+	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite with default handedness.
+	///
+	/// @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 recommanded), float or double.
+	/// @see gtc_matrix_transform
+	template<typename T>
+	GLM_FUNC_DECL mat<4, 4, T, defaultp> infinitePerspective(
+		T fovy, T aspect, T near);
+
 	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
 	/// 
 	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
@@ -340,6 +579,39 @@ namespace glm
 		T fovy, T aspect, T near, T ep);
 
 	/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	/// 
+	/// @param obj Specify the object coordinates.
+	/// @param model Specifies the current modelview matrix
+	/// @param proj Specifies the current projection matrix
+	/// @param viewport Specifies the current viewport
+	/// @return Return the computed window coordinates.
+	/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
+	/// @tparam U Currently supported: Floating-point types and integer types.
+	/// @see gtc_matrix_transform
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluProject.xml">gluProject man page</a> 
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> projectZO(
+		vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
+
+	/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	/// 
+	/// @param obj Specify the object coordinates.
+	/// @param model Specifies the current modelview matrix
+	/// @param proj Specifies the current projection matrix
+	/// @param viewport Specifies the current viewport
+	/// @return Return the computed window coordinates.
+	/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
+	/// @tparam U Currently supported: Floating-point types and integer types.
+	/// @see gtc_matrix_transform
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluProject.xml">gluProject man page</a> 
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> projectNO(
+		vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
+
+	/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates using default near and far clip planes definition.
+	/// To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
 	/// 
 	/// @param obj Specify the object coordinates.
 	/// @param model Specifies the current modelview matrix
@@ -352,12 +624,42 @@ namespace glm
 	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluProject.xml">gluProject man page</a> 
 	template<typename T, typename U, qualifier Q>
 	GLM_FUNC_DECL vec<3, T, Q> project(
-		vec<3, T, Q> const& obj,
+		vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
-		mat<4, 4, T, Q> const& model,
-		mat<4, 4, T, Q> const& proj,
-		vec<4, U, Q> const& viewport);
 
 	/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of 0 and +1 respectively. (Direct3D clip volume definition)
+	///
+	/// @param win Specify the window coordinates to be mapped.
+	/// @param model Specifies the modelview matrix
+	/// @param proj Specifies the projection matrix
+	/// @param viewport Specifies the viewport
+	/// @return Returns the computed object coordinates.
+	/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
+	/// @tparam U Currently supported: Floating-point types and integer types.
+	/// @see gtc_matrix_transform
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluUnProject.xml">gluUnProject man page</a> 
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> unProjectZO(
+		vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
+
+	/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
+	/// The near and far clip planes correspond to z normalized device coordinates of -1 and +1 respectively. (OpenGL clip volume definition)
+	///
+	/// @param win Specify the window coordinates to be mapped.
+	/// @param model Specifies the modelview matrix
+	/// @param proj Specifies the projection matrix
+	/// @param viewport Specifies the viewport
+	/// @return Returns the computed object coordinates.
+	/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
+	/// @tparam U Currently supported: Floating-point types and integer types.
+	/// @see gtc_matrix_transform
+	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluUnProject.xml">gluUnProject man page</a> 
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_DECL vec<3, T, Q> unProjectNO(
+		vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
+
+	/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates using default near and far clip planes definition.
+	/// To change default near and far clip planes definition use GLM_FORCE_DEPTH_ZERO_TO_ONE.
 	///
 	/// @param win Specify the window coordinates to be mapped.
 	/// @param model Specifies the modelview matrix
@@ -370,10 +672,7 @@ namespace glm
 	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluUnProject.xml">gluUnProject man page</a> 
 	template<typename T, typename U, qualifier Q>
 	GLM_FUNC_DECL vec<3, T, Q> unProject(
-		vec<3, T, Q> const& win,
+		vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport);
-		mat<4, 4, T, Q> const& model,
-		mat<4, 4, T, Q> const& proj,
-		vec<4, U, Q> const& viewport);
 
 	/// Define a picking region
 	///
@@ -386,9 +685,29 @@ namespace glm
 	/// @see <a href="https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluPickMatrix.xml">gluPickMatrix man page</a> 
 	template<typename T, qualifier Q, typename U>
 	GLM_FUNC_DECL mat<4, 4, T, Q> pickMatrix(
-		vec<2, T, Q> const& center,
+		vec<2, T, Q> const& center, vec<2, T, Q> const& delta, vec<4, U, Q> const& viewport);
-		vec<2, T, Q> const& delta,
+
-		vec<4, U, Q> const& viewport);
+	/// Build a right handed look at view matrix.
+	///
+	/// @param eye Position of the camera
+	/// @param center Position where the camera is looking at
+	/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
+	/// @see gtc_matrix_transform
+	/// @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(
+		vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up);
+
+	/// Build a left handed look at view matrix.
+	///
+	/// @param eye Position of the camera
+	/// @param center Position where the camera is looking at
+	/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
+	/// @see gtc_matrix_transform
+	/// @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(
+		vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up);
 
 	/// Build a look at view matrix based on the default handedness.
 	///
@@ -400,35 +719,7 @@ namespace glm
 	/// @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_FUNC_DECL mat<4, 4, T, Q> lookAt(
-		vec<3, T, Q> const& eye,
+		vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up);
-		vec<3, T, Q> const& center,
-		vec<3, T, Q> const& up);
-
-	/// Build a right handed look at view matrix.
-	///
-	/// @param eye Position of the camera
-	/// @param center Position where the camera is looking at
-	/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
-	/// @see gtc_matrix_transform
-	/// @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(
-		vec<3, T, Q> const& eye,
-		vec<3, T, Q> const& center,
-		vec<3, T, Q> const& up);
-
-	/// Build a left handed look at view matrix.
-	///
-	/// @param eye Position of the camera
-	/// @param center Position where the camera is looking at
-	/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
-	/// @see gtc_matrix_transform
-	/// @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(
-		vec<3, T, Q> const& eye,
-		vec<3, T, Q> const& center,
-		vec<3, T, Q> const& up);
 
 	/// @}
 }//namespace glm

glm/gtc/matrix_transform.inl

@@ -97,280 +97,481 @@ namespace glm
 	}
 
 	template<typename T>
-	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> ortho
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> ortho(T left, T right, T bottom, T top)
-	(
-		T left, T right,
-		T bottom, T top,
-		T zNear, T zFar
-	)
-	{
-#		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
-			return orthoLH(left, right, bottom, top, zNear, zFar);
-#		else
-			return orthoRH(left, right, bottom, top, zNear, zFar);
-#		endif
-	}
-
-	template<typename T>
-	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoLH
-	(
-		T left, T right,
-		T bottom, T top,
-		T zNear, T zFar
-	)
-	{
-		mat<4, 4, T, defaultp> Result(1);
-		Result[0][0] = static_cast<T>(2) / (right - left);
-		Result[1][1] = static_cast<T>(2) / (top - bottom);
-		Result[3][0] = - (right + left) / (right - left);
-		Result[3][1] = - (top + bottom) / (top - bottom);
-
-#		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
-			Result[2][2] = static_cast<T>(1) / (zFar - zNear);
-			Result[3][2] = - zNear / (zFar - zNear);
-#		else
-			Result[2][2] = static_cast<T>(2) / (zFar - zNear);
-			Result[3][2] = - (zFar + zNear) / (zFar - zNear);
-#		endif
-
-		return Result;
-	}
-
-	template<typename T>
-	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoRH
-	(
-		T left, T right,
-		T bottom, T top,
-		T zNear, T zFar
-	)
-	{
-		mat<4, 4, T, defaultp> Result(1);
-		Result[0][0] = static_cast<T>(2) / (right - left);
-		Result[1][1] = static_cast<T>(2) / (top - bottom);
-		Result[3][0] = - (right + left) / (right - left);
-		Result[3][1] = - (top + bottom) / (top - bottom);
-
-#		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
-			Result[2][2] = - static_cast<T>(1) / (zFar - zNear);
-			Result[3][2] = - zNear / (zFar - zNear);
-#		else
-			Result[2][2] = - static_cast<T>(2) / (zFar - zNear);
-			Result[3][2] = - (zFar + zNear) / (zFar - zNear);
-#		endif
-
-		return Result;
-	}
-
-	template<typename T>
-	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> ortho
-	(
-		T left, T right,
-		T bottom, T top
-	)
 	{
 		mat<4, 4, T, defaultp> Result(static_cast<T>(1));
 		Result[0][0] = static_cast<T>(2) / (right - left);
 		Result[1][1] = static_cast<T>(2) / (top - bottom);
-		Result[2][2] = - static_cast<T>(1);
 		Result[3][0] = - (right + left) / (right - left);
 		Result[3][1] = - (top + bottom) / (top - bottom);
 		return Result;
 	}
 
 	template<typename T>
-	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustum
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoLH_ZO(T left, T right, T bottom, T top, T zNear, T zFar)
-	(
+	{
-		T left, T right,
+		mat<4, 4, T, defaultp> Result(1);
-		T bottom, T top,
+		Result[0][0] = static_cast<T>(2) / (right - left);
-		T nearVal, T farVal
+		Result[1][1] = static_cast<T>(2) / (top - bottom);
-	)
+		Result[2][2] = static_cast<T>(1) / (zFar - zNear);
+		Result[3][0] = - (right + left) / (right - left);
+		Result[3][1] = - (top + bottom) / (top - bottom);
+		Result[3][2] = - zNear / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoLH_NO(T left, T right, T bottom, T top, T zNear, T zFar)
+	{
+		mat<4, 4, T, defaultp> Result(1);
+		Result[0][0] = static_cast<T>(2) / (right - left);
+		Result[1][1] = static_cast<T>(2) / (top - bottom);
+		Result[2][2] = static_cast<T>(2) / (zFar - zNear);
+		Result[3][0] = - (right + left) / (right - left);
+		Result[3][1] = - (top + bottom) / (top - bottom);
+		Result[3][2] = - (zFar + zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoRH_ZO(T left, T right, T bottom, T top, T zNear, T zFar)
+	{
+		mat<4, 4, T, defaultp> Result(1);
+		Result[0][0] = static_cast<T>(2) / (right - left);
+		Result[1][1] = static_cast<T>(2) / (top - bottom);
+		Result[2][2] = - static_cast<T>(1) / (zFar - zNear);
+		Result[3][0] = - (right + left) / (right - left);
+		Result[3][1] = - (top + bottom) / (top - bottom);
+		Result[3][2] = - zNear / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoRH_NO(T left, T right, T bottom, T top, T zNear, T zFar)
+	{
+		mat<4, 4, T, defaultp> Result(1);
+		Result[0][0] = static_cast<T>(2) / (right - left);
+		Result[1][1] = static_cast<T>(2) / (top - bottom);
+		Result[2][2] = - static_cast<T>(2) / (zFar - zNear);
+		Result[3][0] = - (right + left) / (right - left);
+		Result[3][1] = - (top + bottom) / (top - bottom);
+		Result[3][2] = - (zFar + zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoZO(T left, T right, T bottom, T top, T zNear, T zFar)
 	{
 #		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
-			return frustumLH(left, right, bottom, top, nearVal, farVal);
+			return orthoLH_ZO(left, right, bottom, top, zNear, zFar);
 #		else
-			return frustumRH(left, right, bottom, top, nearVal, farVal);
+			return orthoRH_ZO(left, right, bottom, top, zNear, zFar);
 #		endif
 	}
 
 	template<typename T>
-	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumLH
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoNO(T left, T right, T bottom, T top, T zNear, T zFar)
-	(
+	{
-		T left, T right,
+#		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
-		T bottom, T top,
+			return orthoLH_NO(left, right, bottom, top, zNear, zFar);
-		T nearVal, T farVal
+#		else
-	)
+			return orthoRH_NO(left, right, bottom, top, zNear, zFar);
+#		endif
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoLH(T left, T right, T bottom, T top, T zNear, T zFar)
+	{
+#		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
+			return orthoLH_ZO(left, right, bottom, top, zNear, zFar);
+#		else
+			return orthoLH_NO(left, right, bottom, top, zNear, zFar);
+#		endif
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> orthoRH(T left, T right, T bottom, T top, T zNear, T zFar)
+	{
+#		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
+			return orthoRH_ZO(left, right, bottom, top, zNear, zFar);
+#		else
+			return orthoRH_NO(left, right, bottom, top, zNear, zFar);
+#		endif
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> ortho(T left, T right, T bottom, T top, T zNear, T zFar)
+	{
+#		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
+			return orthoLH_ZO(left, right, bottom, top, zNear, zFar);
+#		elif GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_NEGATIVE_ONE_TO_ONE
+			return orthoLH_NO(left, right, bottom, top, zNear, zFar);
+#		elif GLM_COORDINATE_SYSTEM == GLM_RIGHT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
+			return orthoRH_ZO(left, right, bottom, top, zNear, zFar);
+#		elif GLM_COORDINATE_SYSTEM == GLM_RIGHT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_NEGATIVE_ONE_TO_ONE
+			return orthoRH_NO(left, right, bottom, top, zNear, zFar);
+#		endif
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumLH_ZO(T left, T right, T bottom, T top, T nearVal, T farVal)
 	{
 		mat<4, 4, T, defaultp> Result(0);
 		Result[0][0] = (static_cast<T>(2) * nearVal) / (right - left);
 		Result[1][1] = (static_cast<T>(2) * nearVal) / (top - bottom);
 		Result[2][0] = (right + left) / (right - left);
 		Result[2][1] = (top + bottom) / (top - bottom);
-		Result[2][3] = static_cast<T>(1);
-
-#		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
 		Result[2][2] = farVal / (farVal - nearVal);
+		Result[2][3] = static_cast<T>(1);
 		Result[3][2] = -(farVal * nearVal) / (farVal - nearVal);
-#		else
-			Result[2][2] = (farVal + nearVal) / (farVal - nearVal);
-			Result[3][2] = - (static_cast<T>(2) * farVal * nearVal) / (farVal - nearVal);
-#		endif
-
 		return Result;
 	}
 
 	template<typename T>
-	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumRH
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumLH_NO(T left, T right, T bottom, T top, T nearVal, T farVal)
-	(
-		T left, T right,
-		T bottom, T top,
-		T nearVal, T farVal
-	)
 	{
 		mat<4, 4, T, defaultp> Result(0);
 		Result[0][0] = (static_cast<T>(2) * nearVal) / (right - left);
 		Result[1][1] = (static_cast<T>(2) * nearVal) / (top - bottom);
 		Result[2][0] = (right + left) / (right - left);
 		Result[2][1] = (top + bottom) / (top - bottom);
-		Result[2][3] = static_cast<T>(-1);
+		Result[2][2] = (farVal + nearVal) / (farVal - nearVal);
-
+		Result[2][3] = static_cast<T>(1);
-#		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
-			Result[2][2] = farVal / (nearVal - farVal);
-			Result[3][2] = -(farVal * nearVal) / (farVal - nearVal);
-#		else
-			Result[2][2] = - (farVal + nearVal) / (farVal - nearVal);
 		Result[3][2] = - (static_cast<T>(2) * farVal * nearVal) / (farVal - nearVal);
-#		endif
-
 		return Result;
 	}
 
 	template<typename T>
-	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspective(T fovy, T aspect, T zNear, T zFar)
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumRH_ZO(T left, T right, T bottom, T top, T nearVal, T farVal)
+	{
+		mat<4, 4, T, defaultp> Result(0);
+		Result[0][0] = (static_cast<T>(2) * nearVal) / (right - left);
+		Result[1][1] = (static_cast<T>(2) * nearVal) / (top - bottom);
+		Result[2][0] = (right + left) / (right - left);
+		Result[2][1] = (top + bottom) / (top - bottom);
+		Result[2][2] = farVal / (nearVal - farVal);
+		Result[2][3] = static_cast<T>(-1);
+		Result[3][2] = -(farVal * nearVal) / (farVal - nearVal);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumRH_NO(T left, T right, T bottom, T top, T nearVal, T farVal)
+	{
+		mat<4, 4, T, defaultp> Result(0);
+		Result[0][0] = (static_cast<T>(2) * nearVal) / (right - left);
+		Result[1][1] = (static_cast<T>(2) * nearVal) / (top - bottom);
+		Result[2][0] = (right + left) / (right - left);
+		Result[2][1] = (top + bottom) / (top - bottom);
+		Result[2][2] = - (farVal + nearVal) / (farVal - nearVal);
+		Result[2][3] = static_cast<T>(-1);
+		Result[3][2] = - (static_cast<T>(2) * farVal * nearVal) / (farVal - nearVal);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumZO(T left, T right, T bottom, T top, T nearVal, T farVal)
 	{
 #		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
-			return perspectiveLH(fovy, aspect, zNear, zFar);
+			return frustumLH_ZO(left, right, bottom, top, nearVal, farVal);
 #		else
-			return perspectiveRH(fovy, aspect, zNear, zFar);
+			return frustumRH_ZO(left, right, bottom, top, nearVal, farVal);
+#		endif
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumNO(T left, T right, T bottom, T top, T nearVal, T farVal)
+	{
+#		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
+			return frustumLH_NO(left, right, bottom, top, nearVal, farVal);
+#		else
+			return frustumRH_NO(left, right, bottom, top, nearVal, farVal);
+#		endif
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumLH(T left, T right, T bottom, T top, T nearVal, T farVal)
+	{
+#		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
+			return frustumLH_ZO(left, right, bottom, top, nearVal, farVal);
+#		else
+			return frustumLH_NO(left, right, bottom, top, nearVal, farVal);
+#		endif
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustumRH(T left, T right, T bottom, T top, T nearVal, T farVal)
+	{
+#		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
+			return frustumRH_ZO(left, right, bottom, top, nearVal, farVal);
+#		else
+			return frustumRH_NO(left, right, bottom, top, nearVal, farVal);
+#		endif
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> frustum(T left, T right, T bottom, T top, T nearVal, T farVal)
+	{
+#		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
+			return frustumLH_ZO(left, right, bottom, top, nearVal, farVal);
+#		elif GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_NEGATIVE_ONE_TO_ONE
+			return frustumLH_NO(left, right, bottom, top, nearVal, farVal);
+#		elif GLM_COORDINATE_SYSTEM == GLM_RIGHT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
+			return frustumRH_ZO(left, right, bottom, top, nearVal, farVal);
+#		elif GLM_COORDINATE_SYSTEM == GLM_RIGHT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_NEGATIVE_ONE_TO_ONE
+			return frustumRH_NO(left, right, bottom, top, nearVal, farVal);
+#		endif
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveRH_ZO(T fovy, T aspect, T zNear, T zFar)
+	{
+		assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
+
+		T const tanHalfFovy = tan(fovy / static_cast<T>(2));
+
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
+		Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
+		Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
+		Result[2][2] = zFar / (zNear - zFar);
+		Result[2][3] = - static_cast<T>(1);
+		Result[3][2] = -(zFar * zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveRH_NO(T fovy, T aspect, T zNear, T zFar)
+	{
+		assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
+
+		T const tanHalfFovy = tan(fovy / static_cast<T>(2));
+
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
+		Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
+		Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
+		Result[2][2] = - (zFar + zNear) / (zFar - zNear);
+		Result[2][3] = - static_cast<T>(1);
+		Result[3][2] = - (static_cast<T>(2) * zFar * zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveLH_ZO(T fovy, T aspect, T zNear, T zFar)
+	{
+		assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
+
+		T const tanHalfFovy = tan(fovy / static_cast<T>(2));
+		
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
+		Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
+		Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
+		Result[2][2] = zFar / (zFar - zNear);
+		Result[2][3] = static_cast<T>(1);
+		Result[3][2] = -(zFar * zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveLH_NO(T fovy, T aspect, T zNear, T zFar)
+	{
+		assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
+
+		T const tanHalfFovy = tan(fovy / static_cast<T>(2));
+		
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
+		Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
+		Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
+		Result[2][2] = (zFar + zNear) / (zFar - zNear);
+		Result[2][3] = static_cast<T>(1);
+		Result[3][2] = - (static_cast<T>(2) * zFar * zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveZO(T fovy, T aspect, T zNear, T zFar)
+	{
+#		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
+			return perspectiveLH_ZO(fovy, aspect, zNear, zFar);
+#		else
+			return perspectiveRH_ZO(fovy, aspect, zNear, zFar);
+#		endif
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveNO(T fovy, T aspect, T zNear, T zFar)
+	{
+#		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
+			return perspectiveLH_NO(fovy, aspect, zNear, zFar);
+#		else
+			return perspectiveRH_NO(fovy, aspect, zNear, zFar);
+#		endif
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveLH(T fovy, T aspect, T zNear, T zFar)
+	{
+#		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
+			return perspectiveLH_ZO(fovy, aspect, zNear, zFar);
+#		else
+			return perspectiveLH_NO(fovy, aspect, zNear, zFar);
 #		endif
 	}
 
 	template<typename T>
 	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveRH(T fovy, T aspect, T zNear, T zFar)
 	{
-		assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
-
-		T const tanHalfFovy = tan(fovy / static_cast<T>(2));
-
-		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
-		Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
-		Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
-		Result[2][3] = - static_cast<T>(1);
-
 #		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
-			Result[2][2] = zFar / (zNear - zFar);
+			return perspectiveRH_ZO(fovy, aspect, zNear, zFar);
-			Result[3][2] = -(zFar * zNear) / (zFar - zNear);
 #		else
-			Result[2][2] = - (zFar + zNear) / (zFar - zNear);
+			return perspectiveRH_NO(fovy, aspect, zNear, zFar);
-			Result[3][2] = - (static_cast<T>(2) * zFar * zNear) / (zFar - zNear);
 #		endif
-
-		return Result;
 	}
 
 	template<typename T>
-	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveLH(T fovy, T aspect, T zNear, T zFar)
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspective(T fovy, T aspect, T zNear, T zFar)
 	{
-		assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
+#		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
+			return perspectiveLH_ZO(fovy, aspect, zNear, zFar);
+#		elif GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_NEGATIVE_ONE_TO_ONE
+			return perspectiveLH_NO(fovy, aspect, zNear, zFar);
+#		elif GLM_COORDINATE_SYSTEM == GLM_RIGHT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
+			return perspectiveRH_ZO(fovy, aspect, zNear, zFar);
+#		elif GLM_COORDINATE_SYSTEM == GLM_RIGHT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_NEGATIVE_ONE_TO_ONE
+			return perspectiveRH_NO(fovy, aspect, zNear, zFar);
+#		endif
+	}
 
-		T const tanHalfFovy = tan(fovy / static_cast<T>(2));
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovRH_ZO(T fov, T width, T height, T zNear, T zFar)
+	{
+		assert(width > static_cast<T>(0));
+		assert(height > static_cast<T>(0));
+		assert(fov > static_cast<T>(0));
+	
+		T const rad = fov;
+		T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
+		T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
 
 		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
-		Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
+		Result[0][0] = w;
-		Result[1][1] = static_cast<T>(1) / (tanHalfFovy);
+		Result[1][1] = h;
-		Result[2][3] = static_cast<T>(1);
+		Result[2][2] = zFar / (zNear - zFar);
-
+		Result[2][3] = - static_cast<T>(1);
-#		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
-			Result[2][2] = zFar / (zFar - zNear);
 		Result[3][2] = -(zFar * zNear) / (zFar - zNear);
-#		else
-			Result[2][2] = (zFar + zNear) / (zFar - zNear);
-			Result[3][2] = - (static_cast<T>(2) * zFar * zNear) / (zFar - zNear);
-#		endif
-
 		return Result;
 	}
 
 	template<typename T>
-	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFov(T fov, T width, T height, T zNear, T zFar)
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovRH_NO(T fov, T width, T height, T zNear, T zFar)
+	{
+		assert(width > static_cast<T>(0));
+		assert(height > static_cast<T>(0));
+		assert(fov > static_cast<T>(0));
+	
+		T const rad = fov;
+		T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
+		T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
+
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
+		Result[0][0] = w;
+		Result[1][1] = h;
+		Result[2][2] = - (zFar + zNear) / (zFar - zNear);
+		Result[2][3] = - static_cast<T>(1);
+		Result[3][2] = - (static_cast<T>(2) * zFar * zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovLH_ZO(T fov, T width, T height, T zNear, T zFar)
+	{
+		assert(width > static_cast<T>(0));
+		assert(height > static_cast<T>(0));
+		assert(fov > static_cast<T>(0));
+	
+		T const rad = fov;
+		T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
+		T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
+
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
+		Result[0][0] = w;
+		Result[1][1] = h;
+		Result[2][2] = zFar / (zFar - zNear);
+		Result[2][3] = static_cast<T>(1);
+		Result[3][2] = -(zFar * zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovLH_NO(T fov, T width, T height, T zNear, T zFar)
+	{
+		assert(width > static_cast<T>(0));
+		assert(height > static_cast<T>(0));
+		assert(fov > static_cast<T>(0));
+	
+		T const rad = fov;
+		T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
+		T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
+
+		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
+		Result[0][0] = w;
+		Result[1][1] = h;
+		Result[2][2] = (zFar + zNear) / (zFar - zNear);
+		Result[2][3] = static_cast<T>(1);
+		Result[3][2] = - (static_cast<T>(2) * zFar * zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovZO(T fov, T width, T height, T zNear, T zFar)
 	{
 #		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
-			return perspectiveFovLH(fov, width, height, zNear, zFar);
+			return perspectiveFovLH_ZO(fov, width, height, zNear, zFar);
 #		else
-			return perspectiveFovRH(fov, width, height, zNear, zFar);
+			return perspectiveFovRH_ZO(fov, width, height, zNear, zFar);
+#		endif
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovNO(T fov, T width, T height, T zNear, T zFar)
+	{
+#		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
+			return perspectiveFovLH_NO(fov, width, height, zNear, zFar);
+#		else
+			return perspectiveFovRH_NO(fov, width, height, zNear, zFar);
+#		endif
+	}
+
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovLH(T fov, T width, T height, T zNear, T zFar)
+	{
+#		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
+			return perspectiveFovLH_ZO(fov, width, height, zNear, zFar);
+#		else
+			return perspectiveFovLH_NO(fov, width, height, zNear, zFar);
 #		endif
 	}
 
 	template<typename T>
 	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovRH(T fov, T width, T height, T zNear, T zFar)
 	{
-		assert(width > static_cast<T>(0));
-		assert(height > static_cast<T>(0));
-		assert(fov > static_cast<T>(0));
-	
-		T const rad = fov;
-		T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
-		T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
-
-		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
-		Result[0][0] = w;
-		Result[1][1] = h;
-		Result[2][3] = - static_cast<T>(1);
-
 #		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
-			Result[2][2] = zFar / (zNear - zFar);
+			return perspectiveFovRH_ZO(fov, width, height, zNear, zFar);
-			Result[3][2] = -(zFar * zNear) / (zFar - zNear);
 #		else
-			Result[2][2] = - (zFar + zNear) / (zFar - zNear);
+			return perspectiveFovRH_NO(fov, width, height, zNear, zFar);
-			Result[3][2] = - (static_cast<T>(2) * zFar * zNear) / (zFar - zNear);
 #		endif
-
-		return Result;
 	}
 
 	template<typename T>
-	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFovLH(T fov, T width, T height, T zNear, T zFar)
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> perspectiveFov(T fov, T width, T height, T zNear, T zFar)
 	{
-		assert(width > static_cast<T>(0));
+#		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
-		assert(height > static_cast<T>(0));
+			return perspectiveFovLH_ZO(fov, width, height, zNear, zFar);
-		assert(fov > static_cast<T>(0));
+#		elif GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_NEGATIVE_ONE_TO_ONE
-	
+			return perspectiveFovLH_NO(fov, width, height, zNear, zFar);
-		T const rad = fov;
+#		elif GLM_COORDINATE_SYSTEM == GLM_RIGHT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
-		T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
+			return perspectiveFovRH_ZO(fov, width, height, zNear, zFar);
-		T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
+#		elif GLM_COORDINATE_SYSTEM == GLM_RIGHT_HANDED && GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_NEGATIVE_ONE_TO_ONE
-
+			return perspectiveFovRH_NO(fov, width, height, zNear, zFar);
-		mat<4, 4, T, defaultp> Result(static_cast<T>(0));
-		Result[0][0] = w;
-		Result[1][1] = h;
-		Result[2][3] = static_cast<T>(1);
-
-#		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
-			Result[2][2] = zFar / (zFar - zNear);
-			Result[3][2] = -(zFar * zNear) / (zFar - zNear);
-#		else
-			Result[2][2] = (zFar + zNear) / (zFar - zNear);
-			Result[3][2] = - (static_cast<T>(2) * zFar * zNear) / (zFar - zNear);
-#		endif
-
-		return Result;
-	}
-
-	template<typename T>
-	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> infinitePerspective(T fovy, T aspect, T zNear)
-	{
-#		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
-			return infinitePerspectiveLH(fovy, aspect, zNear);
-#		else
-			return infinitePerspectiveRH(fovy, aspect, zNear);
 #		endif
 	}
 
@@ -410,6 +611,16 @@ namespace glm
 		return Result;
 	}
 
+	template<typename T>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> infinitePerspective(T fovy, T aspect, T zNear)
+	{
+#		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
+			return infinitePerspectiveLH(fovy, aspect, zNear);
+#		else
+			return infinitePerspectiveRH(fovy, aspect, zNear);
+#		endif
+	}
+
 	// Infinite projection matrix: http://www.terathon.com/gdc07_lengyel.pdf
 	template<typename T>
 	GLM_FUNC_QUALIFIER mat<4, 4, T, defaultp> tweakedInfinitePerspective(T fovy, T aspect, T zNear, T ep)
@@ -436,25 +647,16 @@ namespace glm
 	}
 
 	template<typename T, typename U, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<3, T, Q> project
+	GLM_FUNC_QUALIFIER vec<3, T, Q> projectZO(vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport)
-	(
-		vec<3, T, Q> const& obj,
-		mat<4, 4, T, Q> const& model,
-		mat<4, 4, T, Q> const& proj,
-		vec<4, U, Q> const& viewport
-	)
 	{
 		vec<4, T, Q> tmp = vec<4, T, Q>(obj, static_cast<T>(1));
 		tmp = model * tmp;
 		tmp = proj * tmp;
 
 		tmp /= tmp.w;
-#		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
 		tmp.x = tmp.x * static_cast<T>(0.5) + static_cast<T>(0.5);
 		tmp.y = tmp.y * static_cast<T>(0.5) + static_cast<T>(0.5);
-#		else
+
-			tmp = tmp * static_cast<T>(0.5) + static_cast<T>(0.5);
-#		endif
 		tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]);
 		tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]);
 
@@ -462,25 +664,40 @@ namespace glm
 	}
 
 	template<typename T, typename U, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<3, T, Q> unProject
+	GLM_FUNC_QUALIFIER vec<3, T, Q> projectNO(vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport)
-	(
+	{
-		vec<3, T, Q> const& win,
+		vec<4, T, Q> tmp = vec<4, T, Q>(obj, static_cast<T>(1));
-		mat<4, 4, T, Q> const& model,
+		tmp = model * tmp;
-		mat<4, 4, T, Q> const& proj,
+		tmp = proj * tmp;
-		vec<4, U, Q> const& viewport
+
-	)
+		tmp /= tmp.w;
+		tmp = tmp * static_cast<T>(0.5) + static_cast<T>(0.5);
+		tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]);
+		tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]);
+
+		return vec<3, T, Q>(tmp);
+	}
+
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> project(vec<3, T, Q> const& obj, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport)
+	{
+#		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
+			return projectZO(obj, model, proj, viewport);
+#		else
+			return projectNO(obj, model, proj, viewport);
+#		endif
+	}
+
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> unProjectZO(vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport)
 	{
 		mat<4, 4, T, Q> Inverse = inverse(proj * model);
 
 		vec<4, T, Q> tmp = vec<4, T, Q>(win, T(1));
 		tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]);
 		tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]);
-#		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
 		tmp.x = tmp.x * static_cast<T>(2) - static_cast<T>(1);
 		tmp.y = tmp.y * static_cast<T>(2) - static_cast<T>(1);
-#		else
-			tmp = tmp * static_cast<T>(2) - static_cast<T>(1);
-#		endif
 
 		vec<4, T, Q> obj = Inverse * tmp;
 		obj /= obj.w;
@@ -488,6 +705,32 @@ namespace glm
 		return vec<3, T, Q>(obj);
 	}
 
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> unProjectNO(vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport)
+	{
+		mat<4, 4, T, Q> Inverse = inverse(proj * model);
+
+		vec<4, T, Q> tmp = vec<4, T, Q>(win, T(1));
+		tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]);
+		tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]);
+		tmp = tmp * static_cast<T>(2) - static_cast<T>(1);
+
+		vec<4, T, Q> obj = Inverse * tmp;
+		obj /= obj.w;
+
+		return vec<3, T, Q>(obj);
+	}
+
+	template<typename T, typename U, qualifier Q>
+	GLM_FUNC_QUALIFIER vec<3, T, Q> unProject(vec<3, T, Q> const& win, mat<4, 4, T, Q> const& model, mat<4, 4, T, Q> const& proj, vec<4, U, Q> const& viewport)
+	{
+#		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
+			return unProjectZO(win, model, proj, viewport);
+#		else
+			return unProjectNO(win, model, proj, viewport);
+#		endif
+	}
+
 	template<typename T, qualifier Q, typename U>
 	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> pickMatrix(vec<2, T, Q> const& center, vec<2, T, Q> const& delta, vec<4, U, Q> const& viewport)
 	{
@@ -508,22 +751,7 @@ namespace glm
 	}
 
 	template<typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> lookAt(vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up)
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> lookAtRH(vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up)
-	{
-#		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
-			return lookAtLH(eye, center, up);
-#		else
-			return lookAtRH(eye, center, up);
-#		endif
-	}
-
-	template<typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> lookAtRH
-	(
-		vec<3, T, Q> const& eye,
-		vec<3, T, Q> const& center,
-		vec<3, T, Q> const& up
-	)
 	{
 		vec<3, T, Q> const f(normalize(center - eye));
 		vec<3, T, Q> const s(normalize(cross(f, up)));
@@ -546,12 +774,7 @@ namespace glm
 	}
 
 	template<typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> lookAtLH
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> lookAtLH(vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up)
-	(
-		vec<3, T, Q> const& eye,
-		vec<3, T, Q> const& center,
-		vec<3, T, Q> const& up
-	)
 	{
 		vec<3, T, Q> const f(normalize(center - eye));
 		vec<3, T, Q> const s(normalize(cross(up, f)));
@@ -572,4 +795,14 @@ namespace glm
 		Result[3][2] = -dot(f, eye);
 		return Result;
 	}
+
+	template<typename T, qualifier Q>
+	GLM_FUNC_QUALIFIER mat<4, 4, T, Q> lookAt(vec<3, T, Q> const& eye, vec<3, T, Q> const& center, vec<3, T, Q> const& up)
+	{
+#		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
+			return lookAtLH(eye, center, up);
+#		else
+			return lookAtRH(eye, center, up);
+#		endif
+	}
 }//namespace glm

readme.md

@@ -67,6 +67,7 @@ glm::mat4 camera(float Translate, glm::vec2 const& Rotate)
 - Added EXT_vector_relational: openBounded and closeBounded
 - Added EXT_vec1: *vec1 types
 - Added GTX_texture: levels function
+- Added spearate functions to use both nagative one and zero near clip plans #680
 
 #### Improvements:
 - No more default initialization of vector, matrix and quaternion types