MatrixCore.hpp File Reference

Detailed Description

This file is part of the Lumina Graphics Framework.

Author

Lukas Kalbertodt lukas.nosp@m..kal.nosp@m.berto.nosp@m.dt@g.nosp@m.mail..nosp@m.com

Sebastian von Ohr

This file will define Matrix and various matrix functions. In most cases you should include Matrix.hpp instead, which provides additional helper functions (but has more dependencies). This file also depends on VectorCore.hpp!

Go to the source code of this file.

Classes
class	MatrixHelper< T >
	Helper struct for various algorithms. More...
struct	MatrixImpl< T, R, C >
	Helper class for common Matrix stuff. More...
struct	Matrix< T, R, C >
	Represents a RxC matrix with elements of type T. More...
struct	Matrix< T, N, N >

Typedefs
template<typename T , std::size_t N>
using	MatQ = Matrix< T, N, N >
template<std::size_t N>
using	MatQf = MatQ< float, N >
template<std::size_t N>
using	MatQi = MatQ< int, N >
using	Mat2f = MatQ< float, 2 >
using	Mat2i = MatQ< int, 2 >
using	Mat3f = MatQ< float, 3 >
using	Mat3i = MatQ< int, 3 >
using	Mat4f = MatQ< float, 4 >
using	Mat4i = MatQ< int, 4 >
using	Mat2x3f = Matrix< float, 2, 3 >
using	Mat2x4f = Matrix< float, 2, 4 >
using	Mat3x2f = Matrix< float, 3, 2 >
using	Mat3x4f = Matrix< float, 3, 4 >
using	Mat4x2f = Matrix< float, 4, 2 >
using	Mat4x3f = Matrix< float, 4, 3 >
using	Mat2x3i = Matrix< int, 2, 3 >
using	Mat2x4i = Matrix< int, 2, 4 >
using	Mat3x2i = Matrix< int, 3, 2 >
using	Mat3x4i = Matrix< int, 3, 4 >
using	Mat4x2i = Matrix< int, 4, 2 >
using	Mat4x3i = Matrix< int, 4, 3 >

Functions
template<typename Ta , typename Tb , std::size_t Ra, std::size_t CR, std::size_t Cb>
void	matrixMultiply (const Ta(&lh)[Ra][CR], const Tb(&rh)[CR][Cb], decltype(Ta(0)*Tb(0))(&out)[Ra][Cb])
	Mutiplies two matrices. More...
void	matrixMultiply (const float(&lh)[2][2], const float(&rh)[2][2], float(&out)[2][2])
void	matrixMultiply (const float(&lh)[3][3], const float(&rh)[3][3], float(&out)[3][3])
void	matrixMultiply (const float(&lh)[4][4], const float(&rh)[4][4], float(&out)[4][4])
template<typename T , std::size_t R, std::size_t C>
Matrix< T, R, C >	operator+ (const Matrix< T, R, C > &m)
template<typename T , std::size_t R, std::size_t C>
Matrix< T, R, C >	operator- (const Matrix< T, R, C > &m)
template<typename Ta , typename Tb , std::size_t R, std::size_t C>
Matrix< Ta, R, C > &	operator+= (Matrix< Ta, R, C > &lh, const Matrix< Tb, R, C > &rh)
template<typename Ta , typename Tb , std::size_t R, std::size_t C>
Matrix< Ta, R, C > &	operator-= (Matrix< Ta, R, C > &lh, const Matrix< Tb, R, C > &rh)
template<typename Ta , typename Tb , std::size_t R, std::size_t C>
Matrix< Ta, R, C > &	operator*= (Matrix< Ta, R, C > &lh, const Matrix< Tb, R, C > &rh)
template<typename Ta , typename Tb , std::size_t R, std::size_t C>
Matrix< Ta, R, C > &	operator*= (Matrix< Ta, R, C > &lh, Tb rh)
template<typename Ta , typename Tb , std::size_t R, std::size_t C>
Matrix< Ta, R, C > &	operator/= (Matrix< Ta, R, C > &lh, Tb rh)
template<typename Ta , typename Tb , std::size_t R, std::size_t C>
auto	operator* (const Matrix< Ta, R, C > &lh, Tb rh) -> Matrix< decltype(Ta(0)*Tb(0)), R, C >
template<typename Ta , typename Tb , std::size_t R, std::size_t C>
auto	operator* (Tb lh, const Matrix< Ta, R, C > &rh) -> Matrix< decltype(Ta(0)*Tb(0)), R, C >
template<typename Ta , typename Tb , std::size_t R, std::size_t C>
auto	operator/ (const Matrix< Ta, R, C > &lh, Tb rh) -> Matrix< decltype(Ta(0)/Tb(0)), R, C >
template<typename Ta , typename Tb , std::size_t R, std::size_t C>
auto	operator+ (const Matrix< Ta, R, C > &lh, const Matrix< Tb, R, C > &rh) -> Matrix< decltype(Ta(0)+Tb(0)), R, C >
template<typename Ta , typename Tb , std::size_t R, std::size_t C>
auto	operator- (const Matrix< Ta, R, C > &lh, const Matrix< Tb, R, C > &rh) -> Matrix< decltype(Ta(0)-Tb(0)), R, C >
template<typename Ta , typename Tb , std::size_t R, std::size_t C>
auto	operator* (const Matrix< Ta, R, C > &lh, const Matrix< Tb, R, C > &rh) -> Matrix< decltype(Ta(0)*Tb(0)), R, C >
template<typename Ta , typename Tb , std::size_t R, std::size_t C>
auto	operator* (const Matrix< Ta, R, C > &lh, Vector< Tb, C > rh) -> Vector< decltype(Ta(0)+Tb(0)), R >
template<typename Ta , typename Tb , std::size_t R, std::size_t C>
auto	operator* (Vector< Tb, R > lh, const Matrix< Ta, R, C > &rh) -> Vector< decltype(Ta(0)+Tb(0)), C >
template<typename Tdst , typename Tsrc >
Tdst	matrix_cast (const Tsrc &in)