Detailed Description

Functions for generating and converting between different types of transformations.

This library has a few different ways of representing 3-dimensional rotations specifically:

An axis-angle pair
An axis-angle pair is just as the name implies: it's a rotation around a given axis. It can be represented by three scalars (the axis) and a fourth scalar (the angle) or by a vec3 (the axis) and a scalar (the angle). All functions which take an axis-angle pair as their arguments assume the axis is normalized and the angle is measured in radians counter-clockwise around the axis.
An axis-angle vector
An axis-angle vector is just an axis-angle pair grouped together into a single vec4. The first three components make up the axis and the fourth component represents the angle.
A rotation vector
There are a couple ways to think about a rotation vector. It's represented by three separate scalars or a single vec3. You could imagine it as a more-compact version of an axis-angle pair; its direction represents the axis of rotation and its magnitude the angle (again, radians counter-clockwise around the axis). You could also imagine it as the composite of three separate rotations with each component representing an angle of rotation around the corresponding principal axis. Rotation vectors are most useful when rotations need to be interpolated and/or multiplied, such as when representing angular velocity.
A rotation quaternion
A rotation quaternion is a little more complicated. It's a four-component composite type (a quat). It's kind of like an axis-angle vector, but the entire vector is assumed to be normalized instead of just the axis. This is achieved by multiplying the normalized axis by sin(angle/2) and storing cos(angle/2) instead of the angle itself in the fourth component. Rotation quaternions are best used when representing an orientation in 3-dimensional space or when composing multiple rotations into one. Since they're defined by trigonometric functions, computationally expensive trigonometry isn't needed when using them to rotate vectors or when generating rotation matrices.
A rotation matrix
A rotation matrix is just a specific type of transformation matrix that can rotate vectors using matrix multiplication. It's useful for composing with other types of transformation matrices.

Functions
template<typename T >
vec4< decltype(tue::math::sin(std::declval< T >)))>	tue::transform::axis_angle (const T &x, const T &y, const T &z) noexcept
	Converts a rotation vector to an axis-angle vector. More...

template<typename T >
vec4< decltype(tue::math::sin(std::declval< T >)))>	tue::transform::axis_angle (const vec3< T > &v) noexcept
	Converts a rotation vector to an axis-angle vector. More...

template<typename T >
constexpr vec3< decltype(tue::math::sin(std::declval< T >)))>	tue::transform::rotation_vec (const T &axis_x, const T &axis_y, const T &axis_z, const T &angle) noexcept
	Converts an axis-angle pair to a rotation vector. More...

template<typename T >
constexpr vec3< decltype(tue::math::sin(std::declval< T >)))>	tue::transform::rotation_vec (const vec3< T > &axis, const T &angle) noexcept
	Converts an axis-angle pair to a rotation vector. More...

template<typename T >
constexpr vec3< decltype(tue::math::sin(std::declval< T >)))>	tue::transform::rotation_vec (const vec4< T > &v) noexcept
	Converts an axis-angle vector to a rotation vector. More...

template<typename T >
quat< decltype(tue::math::sin(std::declval< T >)))>	tue::transform::rotation_quat (const T &axis_x, const T &axis_y, const T &axis_z, const T &angle) noexcept
	Converts an axis-angle pair to a rotation quaternion. More...

template<typename T >
quat< decltype(tue::math::sin(std::declval< T >)))>	tue::transform::rotation_quat (const vec3< T > &axis, const T &angle) noexcept
	Converts an axis-angle pair to a rotation quaternion. More...

template<typename T >
quat< decltype(tue::math::sin(std::declval< T >)))>	tue::transform::rotation_quat (const vec4< T > &v) noexcept
	Converts an axis-angle vector to a rotation quaternion. More...

template<typename T >
quat< decltype(tue::math::sin(std::declval< T >)))>	tue::transform::rotation_quat (const T &x, const T &y, const T &z) noexcept
	Converts a rotation vector to a rotation quaternion. More...

template<typename T >
quat< decltype(tue::math::sin(std::declval< T >)))>	tue::transform::rotation_quat (const vec3< T > &v) noexcept
	Converts a rotation vector to a rotation quaternion. More...

template<typename T , int C = 4, int R = 4>
constexpr std::enable_if_t<(C >=2 &&R >=3), mat< T, C, R > >	tue::transform::translation_mat (const T &x, const T &y) noexcept
	Computes a 2D translation matrix. More...

template<typename T , int C = 4, int R = 4>
constexpr std::enable_if_t<(C >=2 &&R >=3), mat< T, C, R > >	tue::transform::translation_mat (const vec2< T > &v) noexcept
	Computes a 2D translation matrix. More...

template<typename T , int C = 4, int R = 4>
constexpr std::enable_if_t<(C >=3 &&R >=4), mat< T, C, R > >	tue::transform::translation_mat (const T &x, const T &y, const T &z) noexcept
	Computes a 3D translation matrix. More...

template<typename T , int C = 4, int R = 4>
constexpr std::enable_if_t<(C >=3 &&R >=4), mat< T, C, R > >	tue::transform::translation_mat (const vec3< T > &v) noexcept
	Computes a 3D translation matrix. More...

template<typename T , int C = 4, int R = 4>
std::enable_if_t< (C >=2 &&R >=2), mat< decltype(tue::math::sin(std::declval< T >))), C, R > >	tue::transform::rotation_mat (const T &angle) noexcept
	Computes a 2D rotation matrix. More...

template<typename T , int C = 4, int R = 4>
std::enable_if_t< (C >=3 &&R >=3), mat< decltype(tue::math::sin(std::declval< T >))), C, R > >	tue::transform::rotation_mat (const T &axis_x, const T &axis_y, const T &axis_z, const T &angle) noexcept
	Computes a 3D rotation matrix from an axis-angle pair. More...

template<typename T , int C = 4, int R = 4>
std::enable_if_t< (C >=3 &&R >=3), mat< decltype(tue::math::sin(std::declval< T >))), C, R > >	tue::transform::rotation_mat (const vec3< T > &axis, const T &angle) noexcept
	Computes a 3D rotation matrix from an axis-angle pair. More...

template<typename T , int C = 4, int R = 4>
std::enable_if_t< (C >=3 &&R >=3), mat< decltype(tue::math::sin(std::declval< T >))), C, R > >	tue::transform::rotation_mat (const vec4< T > &v) noexcept
	Computes a 3D rotation matrix from an axis-angle vector. More...

template<typename T , int C = 4, int R = 4>
std::enable_if_t< (C >=3 &&R >=3), mat< decltype(tue::math::sin(std::declval< T >))), C, R > >	tue::transform::rotation_mat (const T &x, const T &y, const T &z) noexcept
	Computes a 3D rotation matrix from a rotation vector. More...

template<typename T , int C = 4, int R = 4>
std::enable_if_t< (C >=3 &&R >=3), mat< decltype(tue::math::sin(std::declval< T >))), C, R > >	tue::transform::rotation_mat (const vec3< T > &v) noexcept
	Computes a 3D rotation matrix from a rotation vector. More...

template<typename T , int C = 4, int R = 4>
constexpr std::enable_if_t< (C >=3 &&R >=3), mat< decltype(tue::math::sin(std::declval< T >))), C, R > >	tue::transform::rotation_mat (const quat< T > &q) noexcept
	Computes a 3D rotation matrix from a rotation quaternion. More...

template<typename T , int C = 4, int R = 4>
constexpr std::enable_if_t<(C >=2 &&R >=2), mat< T, C, R > >	tue::transform::scale_mat (const T &x, const T &y) noexcept
	Computes a 2D scale matrix. More...

template<typename T , int C = 4, int R = 4>
constexpr std::enable_if_t<(C >=2 &&R >=2), mat< T, C, R > >	tue::transform::scale_mat (const vec2< T > &v) noexcept
	Computes a 2D scale matrix. More...

template<typename T , int C = 4, int R = 4>
constexpr std::enable_if_t<(C >=3 &&R >=3), mat< T, C, R > >	tue::transform::scale_mat (const T &x, const T &y, const T &z) noexcept
	Computes a 3D scale matrix. More...

template<typename T , int C = 4, int R = 4>
constexpr std::enable_if_t<(C >=3 &&R >=3), mat< T, C, R > >	tue::transform::scale_mat (const vec3< T > &v) noexcept
	Computes a 3D scale matrix. More...

template<typename T , int C = 4, int R = 4>
std::enable_if_t< (C >=4 &&R >=4), mat< decltype(tue::math::sin(std::declval< T >))), C, R > >	tue::transform::perspective_mat (const T &fovy, const T &aspect, const T &n, const T &f) noexcept
	Computes a 3D perspective matrix. More...

template<typename T , int C = 4, int R = 4>
constexpr std::enable_if_t< (C >=3 &&R >=4), mat< decltype(tue::math::recip(std::declval< T >))), C, R > >	tue::transform::ortho_mat (const T &width, const T &height, const T &n, const T &f) noexcept
	Computes an orthographic projection matrix. More...

Function Documentation

template<typename T >

vec4<decltype(tue::math::sin(std::declval<T>)))> tue::transform::axis_angle	(	const T &	x,
		const T &	y,
		const T &	z
	)

inlinenoexcept

Converts a rotation vector to an axis-angle vector.

If the rotation vector's length is 0, returns (0, 0, 1, 0).

Template Parameters

T	The rotation vector's component type.

Parameters

x	The rotation vector's first component.
y	The rotation vector's second component.
z	The rotation vector's third component.

Returns: The axis-angle vector.

template<typename T >

vec4<decltype(tue::math::sin(std::declval<T>)))> tue::transform::axis_angle ( const vec3< T > & v )

inlinenoexcept

Converts a rotation vector to an axis-angle vector.

If the rotation vector's length is 0, returns (0, 0, 1, 0).

Template Parameters

T	The rotation vector's component type.

Parameters

v	The rotation vector.

Returns: The axis-angle vector.

template<typename T >

constexpr vec3<decltype(tue::math::sin(std::declval<T>)))> tue::transform::rotation_vec	(	const T &	axis_x,
		const T &	axis_y,
		const T &	axis_z,
		const T &	angle
	)

inlinenoexcept

Converts an axis-angle pair to a rotation vector.

This function assumes the axis is normalized.

Template Parameters

T	The axis-angle component type.

Parameters

axis_x	The axis' first component.
axis_y	The axis' second component.
axis_z	The axis' third component.
angle	The angle.

Returns: The rotation vector.

template<typename T >

constexpr vec3<decltype(tue::math::sin(std::declval<T>)))> tue::transform::rotation_vec	(	const vec3< T > &	axis,
		const T &	angle
	)

inlinenoexcept

Converts an axis-angle pair to a rotation vector.

This function assumes the axis is normalized.

Template Parameters

T	The axis-angle component type.

Parameters

axis	The axis.
angle	The angle.

Returns: The rotation vector.

template<typename T >

constexpr vec3<decltype(tue::math::sin(std::declval<T>)))> tue::transform::rotation_vec ( const vec4< T > & v )

inlinenoexcept

Converts an axis-angle vector to a rotation vector.

This function assumes the axis is normalized.

Template Parameters

T	The axis-angle component type.

Parameters

v	The axis-angle vector.

Returns: The rotation vector.

template<typename T >

quat<decltype(tue::math::sin(std::declval<T>)))> tue::transform::rotation_quat	(	const T &	axis_x,
		const T &	axis_y,
		const T &	axis_z,
		const T &	angle
	)

inlinenoexcept

Converts an axis-angle pair to a rotation quaternion.

This function assumes the axis is normalized.

Template Parameters

T	The axis-angle component type.

Parameters

axis_x	The axis' first component.
axis_y	The axis' second component.
axis_z	The axis' third component.
angle	The angle.

Returns: The rotation quaternion.

template<typename T >

quat<decltype(tue::math::sin(std::declval<T>)))> tue::transform::rotation_quat	(	const vec3< T > &	axis,
		const T &	angle
	)

inlinenoexcept

Converts an axis-angle pair to a rotation quaternion.

This function assumes the axis is normalized.

Template Parameters

T	The axis-angle component type.

Parameters

axis	The axis.
angle	The angle.

Returns: The rotation quaternion.

template<typename T >

quat<decltype(tue::math::sin(std::declval<T>)))> tue::transform::rotation_quat ( const vec4< T > & v )

inlinenoexcept

Converts an axis-angle vector to a rotation quaternion.

This function assumes the axis is normalized.

Template Parameters

T	The axis-angle component type.

Parameters

v	The axis-angle vector.

Returns: The rotation quaternion.

template<typename T >

quat<decltype(tue::math::sin(std::declval<T>)))> tue::transform::rotation_quat	(	const T &	x,
		const T &	y,
		const T &	z
	)

inlinenoexcept

Converts a rotation vector to a rotation quaternion.

If the rotation vector's length is 0, returns (0, 0, 0, 1).

Template Parameters

T	The rotation vector's component type.

Parameters

x	The rotation vector's first component.
y	The rotation vector's second component.
z	The rotation vector's third component.

Returns: The rotation quaternion.

template<typename T >

quat<decltype(tue::math::sin(std::declval<T>)))> tue::transform::rotation_quat ( const vec3< T > & v )

inlinenoexcept

Converts a rotation vector to a rotation quaternion.

If the rotation vector's length is 0, returns (0, 0, 0, 1).

Template Parameters

T	The rotation vector's component type.

Parameters

v	The rotation vector.

Returns: The rotation quaternion.

template<typename T , int C = 4, int R = 4>

constexpr std::enable_if_t<(C >= 2 && R >= 3), mat<T, C, R> > tue::transform::translation_mat	(	const T &	x,
		const T &	y
	)

inlinenoexcept

Computes a 2D translation matrix.

The returned matrix might be the transpose of what you expect from other libraries. This library generally prefers compound transformations be written from left-to-right instead of right-to-left.

Template Parameters

T	The type of parameters `x` and `y`.
C	The column count of the returned matrix. Must be 2, 3, or 4. Defaults to 4.
R	The row count of the returned matrix. Must be 3 or 4. Defaults to 4.

Parameters

x	The translation along the `x` axis.
y	The translation along the `y` axis.

Returns: A 2D translation matrix. Values beyond the requested matrix dimensions are truncated.

[              1,               0,  0,  0 ]
[              0,               1,  0,  0 ]
[ R == 3 ? x : 0,  R == 3 ? y : 0,  1,  0 ]
[ R == 4 ? x : 0,  R == 4 ? y : 0,  0,  1 ]

template<typename T , int C = 4, int R = 4>

constexpr std::enable_if_t<(C >= 2 && R >= 3), mat<T, C, R> > tue::transform::translation_mat ( const vec2< T > & v )

inlinenoexcept

Computes a 2D translation matrix.

The returned matrix might be the transpose of what you expect from other libraries. This library generally prefers compound transformations be written from left-to-right instead of right-to-left.

Template Parameters

T	The component type of `v`.
C	The column count of the returned matrix. Must be 2, 3, or 4. Defaults to 4.
R	The row count of the returned matrix. Must be 3 or 4. Defaults to 4.

Parameters

v	The translation vector.

Returns: A 2D translation matrix. Values beyond the requested matrix dimensions are truncated.

[                 1,                  0,  0,  0 ]
[                 0,                  1,  0,  0 ]
[ R == 3 ? v[0] : 0,  R == 3 ? v[1] : 0,  1,  0 ]
[ R == 4 ? v[0] : 0,  R == 4 ? v[1] : 0,  0,  1 ]

template<typename T , int C = 4, int R = 4>

constexpr std::enable_if_t<(C >= 3 && R >= 4), mat<T, C, R> > tue::transform::translation_mat	(	const T &	x,
		const T &	y,
		const T &	z
	)

inlinenoexcept

Computes a 3D translation matrix.

The returned matrix might be the transpose of what you expect from other libraries. This library generally prefers compound transformations be written from left-to-right instead of right-to-left.

Template Parameters

T	The type of parameters `x`, `y`, and `z`.
C	The column count of the returned matrix. Must be 3 or 4. Defaults to 4.
R	The row count of the returned matrix. Must be 4. Defaults to 4.

Parameters

x	The translation along the `x` axis.
y	The translation along the `y` axis.
z	The translation along the `z` axis.

Returns: A 3D translation matrix. Values beyond the requested matrix dimensions are truncated.

[ 1,  0,  0,  0 ]
[ 0,  1,  0,  0 ]
[ 0,  0,  1,  0 ]
[ x,  y,  z,  1 ]

template<typename T , int C = 4, int R = 4>

constexpr std::enable_if_t<(C >= 3 && R >= 4), mat<T, C, R> > tue::transform::translation_mat ( const vec3< T > & v )

inlinenoexcept

Computes a 3D translation matrix.

The returned matrix might be the transpose of what you expect from other libraries. This library generally prefers compound transformations be written from left-to-right instead of right-to-left.

Template Parameters

T	The component type of `v`.
C	The column count of the returned matrix. Must be 3 or 4. Defaults to 4.
R	The row count of the returned matrix. Must be 4. Defaults to 4.

Parameters

v	The translation vector.

Returns: A 3D translation matrix. Values beyond the requested matrix dimensions are truncated.

[   1 ,    0 ,    0 ,  0 ]
[   0 ,    1 ,    0 ,  0 ]
[   0 ,    0 ,    1 ,  0 ]
[ v[0],  v[1],  v[2],  1 ]

template<typename T , int C = 4, int R = 4>

std::enable_if_t< (C >= 2 && R >= 2), mat<decltype(tue::math::sin(std::declval<T>))), C, R> > tue::transform::rotation_mat ( const T & angle )

inlinenoexcept

Computes a 2D rotation matrix.

The returned matrix might be the transpose of what you expect from other libraries. This library generally prefers compound transformations be written from left-to-right instead of right-to-left.

Template Parameters

T	The type of parameter `angle`.
C	The column count of the returned matrix. Must be 2, 3, or 4. Defaults to 4.
R	The row count of the returned matrix. Must be 2, 3, or 4. Defaults to 4.

Parameters

angle The rotation (measured in radians counter-clockwise).

Returns: A 2D rotation matrix. Values beyond the requested matrix dimensions are truncated.

[  cos(angle),  sin(angle),  0,  0 ]
[ -sin(angle),  cos(angle),  0,  0 ]
[           0,           0,  1,  0 ]
[           0,           0,  0,  1 ]

template<typename T , int C = 4, int R = 4>

std::enable_if_t< (C >= 3 && R >= 3), mat<decltype(tue::math::sin(std::declval<T>))), C, R> > tue::transform::rotation_mat	(	const T &	axis_x,
		const T &	axis_y,
		const T &	axis_z,
		const T &	angle
	)

inlinenoexcept

Computes a 3D rotation matrix from an axis-angle pair.

This function assumes the axis is normalized.
The returned matrix might be the transpose of what you expect from other libraries. This library generally prefers compound transformations be written from left-to-right instead of right-to-left.

Template Parameters

T	The axis-angle component type.
C	The column count of the returned matrix. Must be 3 or 4. Defaults to 4.
R	The row count of the returned matrix. Must be 3 or 4. Defaults to 4.

Parameters

axis_x	The axis' first component.
axis_y	The axis' second component.
axis_z	The axis' third component.
angle	The angle.

Returns: A 3D rotation matrix. Values beyond the requested matrix dimensions are truncated.

// Where x, y, and z make the axis of rotation
// and s and c are sin(angle) and cos(angle).
[ xx(1-c) +  c,  xy(1-c) + zs,  xz(1-c) - ys,  0 ]
[ xy(1-c) - zs,  yy(1-c) +  c,  yz(1-c) - xs,  0 ]
[ xz(1-c) + ys,  yz(1-c) - xs,  zz(1-c) +  c,  0 ]
[            0,             0,             0,  1 ]

template<typename T , int C = 4, int R = 4>

std::enable_if_t< (C >= 3 && R >= 3), mat<decltype(tue::math::sin(std::declval<T>))), C, R> > tue::transform::rotation_mat	(	const vec3< T > &	axis,
		const T &	angle
	)

inlinenoexcept

Computes a 3D rotation matrix from an axis-angle pair.

This function assumes the axis is normalized.
The returned matrix might be the transpose of what you expect from other libraries. This library generally prefers compound transformations be written from left-to-right instead of right-to-left.

Template Parameters

T	The axis-angle component type.
C	The column count of the returned matrix. Must be 3 or 4. Defaults to 4.
R	The row count of the returned matrix. Must be 3 or 4. Defaults to 4.

Parameters

axis	The axis.
angle	The angle.

Returns: A 3D rotation matrix. Values beyond the requested matrix dimensions are truncated.

// Where x, y, and z make the axis of rotation
// and s and c are sin(angle) and cos(angle).
[ xx(1-c) +  c,  xy(1-c) + zs,  xz(1-c) - ys,  0 ]
[ xy(1-c) - zs,  yy(1-c) +  c,  yz(1-c) - xs,  0 ]
[ xz(1-c) + ys,  yz(1-c) - xs,  zz(1-c) +  c,  0 ]
[            0,             0,             0,  1 ]

template<typename T , int C = 4, int R = 4>

std::enable_if_t< (C >= 3 && R >= 3), mat<decltype(tue::math::sin(std::declval<T>))), C, R> > tue::transform::rotation_mat ( const vec4< T > & v )

inlinenoexcept

Computes a 3D rotation matrix from an axis-angle vector.

This function assumes the axis is normalized.
The returned matrix might be the transpose of what you expect from other libraries. This library generally prefers compound transformations be written from left-to-right instead of right-to-left.

Template Parameters

T	The axis-angle component type.
C	The column count of the returned matrix. Must be 3 or 4. Defaults to 4.
R	The row count of the returned matrix. Must be 3 or 4. Defaults to 4.

Parameters

v	The axis-angle vector.

Returns: A 3D rotation matrix. Values beyond the requested matrix dimensions are truncated.

// Where x, y, and z make the axis of rotation
// and s and c are sin(v[3]) and cos(v[3]).
[ xx(1-c) +  c,  xy(1-c) + zs,  xz(1-c) - ys,  0 ]
[ xy(1-c) - zs,  yy(1-c) +  c,  yz(1-c) - xs,  0 ]
[ xz(1-c) + ys,  yz(1-c) - xs,  zz(1-c) +  c,  0 ]
[            0,             0,             0,  1 ]

template<typename T , int C = 4, int R = 4>

std::enable_if_t< (C >= 3 && R >= 3), mat<decltype(tue::math::sin(std::declval<T>))), C, R> > tue::transform::rotation_mat	(	const T &	x,
		const T &	y,
		const T &	z
	)

inlinenoexcept

Computes a 3D rotation matrix from a rotation vector.

The returned matrix might be the transpose of what you expect from other libraries. This library generally prefers compound transformations be written from left-to-right instead of right-to-left.

Template Parameters

T	The rotation vector's component type.
C	The column count of the returned matrix. Must be 3 or 4. Defaults to 4.
R	The row count of the returned matrix. Must be 3 or 4. Defaults to 4.

Parameters

x	The rotation vector's first component.
y	The rotation vector's second component.
z	The rotation vector's third component.

Returns: A 3D rotation matrix.

return tue::transform::rotation_mat<T, C, R>(

tue::transform::axis_angle(x, y, z));

template<typename T , int C = 4, int R = 4>

std::enable_if_t< (C >= 3 && R >= 3), mat<decltype(tue::math::sin(std::declval<T>))), C, R> > tue::transform::rotation_mat ( const vec3< T > & v )

inlinenoexcept

Computes a 3D rotation matrix from a rotation vector.

The returned matrix might be the transpose of what you expect from other libraries. This library generally prefers compound transformations be written from left-to-right instead of right-to-left.

Template Parameters

T	The rotation vector's component type.
C	The column count of the returned matrix. Must be 3 or 4. Defaults to 4.
R	The row count of the returned matrix. Must be 3 or 4. Defaults to 4.

Parameters

v	The rotation vector.

Returns: A 3D rotation matrix.

return tue::transform::rotation_mat<T, C, R>(

tue::transform::axis_angle(v));

template<typename T , int C = 4, int R = 4>

constexpr std::enable_if_t< (C >= 3 && R >= 3), mat<decltype(tue::math::sin(std::declval<T>))), C, R> > tue::transform::rotation_mat ( const quat< T > & q )

inlinenoexcept

Computes a 3D rotation matrix from a rotation quaternion.

This function assumes the quaternion is normalized.
The returned matrix might be the transpose of what you expect from other libraries. This library generally prefers compound transformations be written from left-to-right instead of right-to-left.

Template Parameters

T	The rotation quaternion's component type.
C	The column count of the returned matrix. Must be 3 or 4. Defaults to 4.
R	The row count of the returned matrix. Must be 3 or 4. Defaults to 4.

Parameters

q	The rotation quaternion.

Returns: A 3D rotation matrix. Values beyond the requested matrix dimensions are truncated.

// Where x, y, z, and w are the components of the rotation
// quaternion.
[ 1 - 2yy - 2zz,      2xy + 2zw,      2xz - 2yw,  0 ]
[     2xy - 2zw,  1 - 2xx - 2zz,      2yz + 2xw,  0 ]
[     2xz + 2yw,      2yz - 2xw,  1 - 2xx - 2yy,  0 ]
[             0,              0,              0,  1 ]

template<typename T , int C = 4, int R = 4>

constexpr std::enable_if_t<(C >= 2 && R >= 2), mat<T, C, R> > tue::transform::scale_mat	(	const T &	x,
		const T &	y
	)

inlinenoexcept

Computes a 2D scale matrix.

Template Parameters

T	The type of parameters `x` and `y`.
C	The column count of the returned matrix. Must be 2, 3, or 4. Defaults to 4.
R	The row count of the returned matrix. Must be 2, 3, or 4. Defaults to 4.

Parameters

x	The scale along the `x` axis.
y	The scale along the `y` axis.

Returns: A 2D scale matrix. Values beyond the requested matrix dimensions are truncated.

[ x,  0,  0,  0 ]
[ 0,  y,  0,  0 ]
[ 0,  0,  1,  0 ]
[ 0,  0,  0,  1 ]

template<typename T , int C = 4, int R = 4>

constexpr std::enable_if_t<(C >= 2 && R >= 2), mat<T, C, R> > tue::transform::scale_mat ( const vec2< T > & v )

inlinenoexcept

Computes a 2D scale matrix.

Template Parameters

T	The component type of `v`.
C	The column count of the returned matrix. Must be 2, 3, or 4. Defaults to 4.
R	The row count of the returned matrix. Must be 2, 3, or 4. Defaults to 4.

Parameters

v	The scale vector.

Returns: A 2D scale matrix. Values beyond the requested matrix dimensions are truncated.

[ v[0],    0 ,  0,  0 ]
[   0 ,  v[1],  0,  0 ]
[   0 ,    0 ,  1,  0 ]
[   0 ,    0 ,  0,  1 ]

template<typename T , int C = 4, int R = 4>

constexpr std::enable_if_t<(C >= 3 && R >= 3), mat<T, C, R> > tue::transform::scale_mat	(	const T &	x,
		const T &	y,
		const T &	z
	)

inlinenoexcept

Computes a 3D scale matrix.

Template Parameters

T	The type of parameters `x`, `y`, and `z`.
C	The column count of the returned matrix. Must be 3 or 4. Defaults to 4.
R	The row count of the returned matrix. Must be 3 or 4. Defaults to 4.

Parameters

x	The scale along the `x` axis.
y	The scale along the `y` axis.
z	The scale along the `z` axis.

Returns: A 3D scale matrix. Values beyond the requested matrix dimensions are truncated.

[ x,  0,  0,  0 ]
[ 0,  y,  0,  0 ]
[ 0,  0,  z,  0 ]
[ 0,  0,  0,  1 ]

template<typename T , int C = 4, int R = 4>

constexpr std::enable_if_t<(C >= 3 && R >= 3), mat<T, C, R> > tue::transform::scale_mat ( const vec3< T > & v )

inlinenoexcept

Computes a 3D scale matrix.

Template Parameters

T	The component type of `v`.
C	The column count of the returned matrix. Must be 3 or 4. Defaults to 4.
R	The row count of the returned matrix. Must be 3 or 4. Defaults to 4.

Parameters

v	The scale vector.

Returns: A 3D scale matrix. Values beyond the requested matrix dimensions are truncated.

[ v[0],    0 ,    0 ,  0 ]
[   0 ,  v[1],    0 ,  0 ]
[   0 ,    0 ,  v[2],  0 ]
[   0 ,    0 ,    0 ,  1 ]

template<typename T , int C = 4, int R = 4>

std::enable_if_t< (C >= 4 && R >= 4), mat<decltype(tue::math::sin(std::declval<T>))), C, R> > tue::transform::perspective_mat	(	const T &	fovy,
		const T &	aspect,
		const T &	n,
		const T &	f
	)

inlinenoexcept

Computes a 3D perspective matrix.

The returned matrix might be the transpose of what you expect from other libraries. This library generally prefers compound transformations be written from left-to-right instead of right-to-left.

Template Parameters

T	The type of all four parameters.
C	The column count of the returned matrix. Must be 4. Defaults to 4.
R	The row count of the returned matrix. Must be 4. Defaults to 4.

Parameters

fovy	The vertical field of view (measured in radians).
aspect	The aspect ratio (width / height).
n	The distance to the near view plane.
f	The distance to the far view plane.

Returns: A 3D perspective matrix.

// Where s and c are sin(fovy/2) and cos(fovy/2)
[ c/s/aspect,    0,            0,   0 ]
[          0,  c/s,            0,   0 ]
[          0,    0,  (n+f)/(n-f),  -1 ]
[          0,    0,  (2nf)/(n-f),   0 ]

template<typename T , int C = 4, int R = 4>

constexpr std::enable_if_t< (C >= 3 && R >= 4), mat<decltype(tue::math::recip(std::declval<T>))), C, R> > tue::transform::ortho_mat	(	const T &	width,
		const T &	height,
		const T &	n,
		const T &	f
	)

inlinenoexcept

Computes an orthographic projection matrix.

The returned matrix might be the transpose of what you expect from other libraries. This library generally prefers compound transformations be written from left-to-right instead of right-to-left.

Template Parameters

T	The type of all four parameters.
C	The column count of the returned matrix. Must be 3 or 4. Defaults to 4.
R	The row count of the returned matrix. Must be 4. Defaults to 4.

Parameters

width	The orthographic projection width.
height	The orthographic projection height.
n	The distance to the near view plane.
f	The distance to the far view plane.

Returns: An orthographic projection matrix.

[ 2/width,         0,            0,  0 ]
[       0,  2/height,            0,  0 ]
[       0,         0,    (2)/(n-f),  0 ]
[       0,         0,  (n+f)/(n-f),  1 ]