tdm::projective Namespace Reference

Classes
struct	axis_angle

Functions
template<typename T >
mat4< T >	rotate (const vec3< T > &axis, T radians, handedness h=handedness::right)
template<typename T >
mat4< T >	rotate (const mat4< T > &m, const vec3< T > &axis, T radians, handedness h=handedness::right)
template<typename T >
mat4< T >	rotate (T xRadians, T yRadians, T zRadians, handedness h=handedness::right)
template<typename T >
mat4< T >	rotate (const mat4< T > &m, T xRadians, T yRadians, T zRadians, handedness h=handedness::right)
template<typename T >
mat4< T >	rotate (const vec3< T > &radians, handedness h=handedness::right)
template<typename T >
mat4< T >	rotate (const mat4< T > &m, const vec3< T > &radians, handedness h=handedness::right)
template<dim_t L, typename T >
mat< L+1, L+1, T >	scale (const vec< L, T > &factors)
template<dim_t L, typename T >
mat< L+1, L+1, T >	scale (const mat< L+1, L+1, T > &m, const vec< L, T > &factors)
template<dim_t L, typename T >
mat< L+1, L+1, T >	scale (T factor)
template<dim_t L, typename T >
mat< L, L, T >	scale (const mat< L, L, T > &m, T factor)
template<dim_t L, typename T >
mat< L+1, L+1, T >	translate (const vec< L, T > &position)
template<dim_t L, typename T >
mat< L+1, L+1, T >	translate (const mat< L+1, L+1, T > &m, const vec< L, T > &position)
template<typename T >
axis_angle< T >	xyz2AxisAngle (T xRadians, T yRadians, T zRadians, handedness h=handedness::right)
template<typename T >
axis_angle< T >	xyz2AxisAngle (const vec3< T > &radians, handedness h=handedness::right)

Function Documentation

rotate() [1/6]

template<typename T >

mat4< T > tdm::projective::rotate ( const mat4< T > &  m, const vec3< T > &  axis, T  radians, handedness  h = handedness::right  )

inline

                                                                                                        {
    return m * rotate(axis, radians, h);
}

rotate() [2/6]

template<typename T >

mat4< T > tdm::projective::rotate ( const mat4< T > &  m, const vec3< T > &  radians, handedness  h = handedness::right  )

inline

                                                                                                {
    return m * rotate(radians[0], radians[1], radians[2], h);
}

rotate() [3/6]

template<typename T >

mat4< T > tdm::projective::rotate ( const mat4< T > &  m, T  xRadians, T  yRadians, T  zRadians, handedness  h = handedness::right  )

inline

                                                                                                            {
    return m * rotate(xRadians, yRadians, zRadians, h);
}

rotate() [4/6]

template<typename T >

mat4< T > tdm::projective::rotate ( const vec3< T > &  axis, T  radians, handedness  h = handedness::right  )

inline

                                                                                      {
    const T c = std::cos(radians);
    const T s = std::sin(radians) * static_cast<T>(h);
    const T one_minus_c = static_cast<T>(1) - c;
    const vec3<T> n = normalize(axis);
    return mat4<T>{n[0] * n[0] * one_minus_c + c,
                   n[1] * n[0] * one_minus_c - n[2] * s,
                   n[2] * n[0] * one_minus_c + n[1] * s,
                   static_cast<T>(0),
                   n[0] * n[1] * one_minus_c + n[2] * s,
                   n[1] * n[1] * one_minus_c + c,
                   n[2] * n[1] * one_minus_c - n[0] * s,
                   static_cast<T>(0),
                   n[0] * n[2] * one_minus_c - n[1] * s,
                   n[1] * n[2] * one_minus_c + n[0] * s,
                   n[2] * n[2] * one_minus_c + c,
                   static_cast<T>(0),
                   static_cast<T>(0),
                   static_cast<T>(0),
                   static_cast<T>(0),
                   static_cast<T>(1)};
}

rotate() [5/6]

template<typename T >

mat4< T > tdm::projective::rotate ( const vec3< T > &  radians, handedness  h = handedness::right  )

inline

                                                                              {
    return rotate(radians[0], radians[1], radians[2], h);
}

rotate() [6/6]

template<typename T >

mat4< T > tdm::projective::rotate ( T  xRadians, T  yRadians, T  zRadians, handedness  h = handedness::right  )

inline

                                                                                          {
    const T sx = std::sin(xRadians) * static_cast<T>(h);
    const T sy = std::sin(yRadians) * static_cast<T>(h);
    const T sz = std::sin(zRadians) * static_cast<T>(h);
    const T cx = std::cos(xRadians);
    const T cy = std::cos(yRadians);
    const T cz = std::cos(zRadians);
    auto rx = mat4<T>::identity();
    rx(1, 1) = cx;
    rx(1, 2) = sx;
    rx(2, 1) = -sx;
    rx(2, 2) = cx;
    auto ry = mat4<T>::identity();
    ry(0, 0) = cy;
    ry(0, 2) = -sy;
    ry(2, 0) = sy;
    ry(2, 2) = cy;
    auto rz = mat4<T>::identity();
    rz(0, 0) = cz;
    rz(0, 1) = sz;
    rz(1, 0) = -sz;
    rz(1, 1) = cz;
    return rx * ry * rz;
}

scale() [1/4]

template<dim_t L, typename T >

mat< L+1, L+1, T > tdm::projective::scale ( const mat< L+1, L+1, T > &  m, const vec< L, T > &  factors  )

inline

                                                                                           {
    return m * scale(factors);
}

scale() [2/4]

template<dim_t L, typename T >

mat< L, L, T > tdm::projective::scale ( const mat< L, L, T > &  m, T  factor  )

inline

                                                           {
    return scale(m, vec<L - 1, T>{factor});
}

scale() [3/4]

template<dim_t L, typename T >

mat< L+1, L+1, T > tdm::projective::scale ( const vec< L, T > &  factors )

inline

                                                            {
    vec<L + 1, T> diagonal{static_cast<T>(1)};
    factors.apply([&diagonal](const T& value, dim_t i) {
                diagonal[i] = value;
            });
    return mat<L + 1, L + 1, T>::diagonal(diagonal);
}

scale() [4/4]

template<dim_t L, typename T >

mat< L+1, L+1, T > tdm::projective::scale ( T  factor )

inline

                                            {
    return scale(vec<L, T>{factor});
}

translate() [1/2]

template<dim_t L, typename T >

mat< L+1, L+1, T > tdm::projective::translate ( const mat< L+1, L+1, T > &  m, const vec< L, T > &  position  )

inline

                                                                                                {
    return m * translate(position);
}

translate() [2/2]

template<dim_t L, typename T >

mat< L+1, L+1, T > tdm::projective::translate ( const vec< L, T > &  position )

inline

                                                                 {
    auto m = mat<L + 1, L + 1, T>::identity();
    position.apply([&m](const T& value, dim_t i) {
                m(L, i) = value;
            });
    return m;
}

xyz2AxisAngle() [1/2]

template<typename T >

axis_angle< T > tdm::projective::xyz2AxisAngle	(	const vec3< T > &	radians,
		handedness	h = handedness::right
	)

                                                                                    {
    return xyz2AxisAngle(radians[0], radians[1], radians[2], h);
}

xyz2AxisAngle() [2/2]

template<typename T >

axis_angle< T > tdm::projective::xyz2AxisAngle	(	T	xRadians,
		T	yRadians,
		T	zRadians,
		handedness	h = handedness::right
	)

                                                                                                {
    const mat4<T> m = rotate(xRadians, yRadians, zRadians, h);
    const T radians = std::acos((trace(m.template submat<3, 3>(0, 0)) - static_cast<T>(1)) / static_cast<T>(2));
    const T factor = static_cast<T>(1) / (static_cast<T>(2) * std::sin(radians));
    const T x = factor * (m(2, 1) - m(1, 2));
    const T y = factor * (m(0, 2) - m(2, 0));
    const T z = factor * (m(1, 0) - m(0, 1));
    return {{x, y, z}, radians};
}