Separate implementation from declaration as stated in the coding standard
This commit is contained in:
rexy712
parent
bbcdd15a11
commit
0efe16a204
@ -75,15 +75,9 @@ namespace math::detail{
|
||||
protected:
|
||||
T* m_data = nullptr;
|
||||
public:
|
||||
constexpr mat_ref_obj(T* d, size_type i):
|
||||
m_data(d+i){}
|
||||
|
||||
constexpr T& operator[](size_type i){
|
||||
return m_data[i*R];
|
||||
}
|
||||
constexpr const T& operator[](size_type i)const{
|
||||
return m_data[i*R];
|
||||
}
|
||||
constexpr mat_ref_obj(T* d, size_type i);
|
||||
constexpr T& operator[](size_type i);
|
||||
constexpr const T& operator[](size_type i)const;
|
||||
};
|
||||
|
||||
template<typename T, size_t W, size_t H>
|
||||
@ -107,102 +101,58 @@ namespace math::detail{
|
||||
|
||||
protected:
|
||||
template<size_type... Ss>
|
||||
constexpr matrix_base(std::integer_sequence<size_type,Ss...>):
|
||||
m_data{Ss...}{}
|
||||
constexpr matrix_base(std::integer_sequence<size_type,Ss...>);
|
||||
|
||||
public:
|
||||
//Default construct as identity when square, zero otherwise
|
||||
constexpr matrix_base():
|
||||
matrix_base(typename detail::default_initialization_matrix<Columns,Rows>::tuple{}){}
|
||||
constexpr matrix_base();
|
||||
|
||||
//Range initializing constructors
|
||||
constexpr explicit matrix_base(zero_initialize_t):
|
||||
m_data{}{}
|
||||
constexpr explicit matrix_base(no_initialize_t){}
|
||||
constexpr explicit matrix_base(detail::zero_initialize_t);
|
||||
constexpr explicit matrix_base(detail::no_initialize_t);
|
||||
template<typename U = void>
|
||||
constexpr explicit matrix_base(id_initialize_t):
|
||||
matrix_base()
|
||||
{
|
||||
static_assert(Columns == Rows, "Identity initialization only supported on square matrices");
|
||||
}
|
||||
constexpr explicit matrix_base(detail::id_initialize_t);
|
||||
|
||||
//Value initializing constructors
|
||||
constexpr explicit matrix_base(value_type v){
|
||||
for(size_type i = 0;i < Columns*Rows;++i)
|
||||
m_data[i] = v;
|
||||
}
|
||||
constexpr explicit matrix_base(value_type v);
|
||||
template<typename... Args>
|
||||
constexpr explicit matrix_base(Args&&... args):
|
||||
m_data{std::forward<Args>(args)...}{}
|
||||
constexpr explicit matrix_base(Args&&... args);
|
||||
|
||||
//Copying constructors
|
||||
constexpr matrix_base(const matrix_base&) = default;
|
||||
constexpr matrix_base(matrix_base&&) = default;
|
||||
template<typename U>
|
||||
constexpr matrix_base(const matrix_base<U,Columns,Rows>& m){
|
||||
using mat = decltype(m);
|
||||
for(typename mat::size_type i = 0;i < mat::Columns*mat::Rows;++i)
|
||||
m_data[i] = m.get(i);
|
||||
}
|
||||
constexpr matrix_base(const matrix_base<U,Columns,Rows>& m);
|
||||
~matrix_base() = default;
|
||||
|
||||
//Assignement
|
||||
template<typename U>
|
||||
constexpr matrix_base& operator=(const matrix_base<U,Columns,Rows>& m){
|
||||
using mat = decltype(m);
|
||||
for(typename mat::size_type i = 0;i < mat::Columns*mat::Rows;++i)
|
||||
m_data[i] = m.get(i);
|
||||
return *this;
|
||||
}
|
||||
constexpr matrix_base& operator=(const matrix_base<U,Columns,Rows>& m);
|
||||
constexpr matrix_base& operator=(const matrix_base&) = default;
|
||||
constexpr matrix_base& operator=(matrix_base&&) = default;
|
||||
|
||||
|
||||
//Getters/Setters
|
||||
constexpr auto operator[](size_type x){
|
||||
return detail::mat_ref_obj<value_type,Rows>{m_data, x};
|
||||
}
|
||||
constexpr auto operator[](size_type x)const{
|
||||
return detail::mat_ref_obj<const value_type,Rows>{m_data, x};
|
||||
}
|
||||
constexpr reference get(size_type x, size_type y){
|
||||
return m_data[x+(y*Rows)];
|
||||
}
|
||||
constexpr const_reference get(size_type x, size_type y)const{
|
||||
return m_data[x+(y*Rows)];
|
||||
}
|
||||
constexpr reference get(size_type i){
|
||||
return m_data[i];
|
||||
}
|
||||
constexpr const_reference get(size_type i)const{
|
||||
return m_data[i];
|
||||
}
|
||||
constexpr auto operator[](size_type x);
|
||||
constexpr auto operator[](size_type x)const;
|
||||
constexpr reference get(size_type x, size_type y);
|
||||
constexpr const_reference get(size_type x, size_type y)const;
|
||||
constexpr reference get(size_type i);
|
||||
constexpr const_reference get(size_type i)const;
|
||||
|
||||
constexpr size_type columns()const{
|
||||
return Columns;
|
||||
}
|
||||
constexpr size_type rows()const{
|
||||
return Rows;
|
||||
}
|
||||
constexpr size_type size()const{
|
||||
return Columns*Rows;
|
||||
}
|
||||
constexpr size_type columns()const;
|
||||
constexpr size_type rows()const;
|
||||
constexpr size_type size()const;
|
||||
|
||||
constexpr pointer raw(){
|
||||
return m_data;
|
||||
}
|
||||
constexpr const_pointer raw()const{
|
||||
return m_data;
|
||||
}
|
||||
constexpr operator pointer(){
|
||||
return m_data;
|
||||
}
|
||||
constexpr operator const_pointer()const{
|
||||
return m_data;
|
||||
}
|
||||
constexpr pointer raw();
|
||||
constexpr const_pointer raw()const;
|
||||
constexpr operator pointer();
|
||||
constexpr operator const_pointer()const;
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#include "matrix.tpp"
|
||||
|
||||
#endif
|
||||
|
||||
147
include/detail/matrix.tpp
Normal file
147
include/detail/matrix.tpp
Normal file
@ -0,0 +1,147 @@
|
||||
/**
|
||||
This file is a part of the rexy/r0nk/atlas project
|
||||
Copyright (C) 2020 rexy712
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef REXY_DETAIL_MATRIX_TPP
|
||||
#define REXY_DETAIL_MATRIX_TPP
|
||||
|
||||
#include <cstdlib> //size_t
|
||||
#include <utility> //integer_sequence
|
||||
|
||||
namespace math::detail{
|
||||
|
||||
template<typename T, size_t R>
|
||||
constexpr mat_ref_obj<T,R>::mat_ref_obj(T* d, size_type i):
|
||||
m_data(d+i){}
|
||||
|
||||
template<typename T, size_t R>
|
||||
constexpr T& mat_ref_obj<T,R>::operator[](size_type i){
|
||||
return m_data[i*R];
|
||||
}
|
||||
template<typename T, size_t R>
|
||||
constexpr const T& mat_ref_obj<T,R>::operator[](size_type i)const{
|
||||
return m_data[i*R];
|
||||
}
|
||||
|
||||
template<typename T, size_t W, size_t H>
|
||||
template<typename matrix_base<T,W,H>::size_type... Ss>
|
||||
constexpr matrix_base<T,W,H>::matrix_base(std::integer_sequence<size_type,Ss...>):
|
||||
m_data{Ss...}{}
|
||||
|
||||
template<typename T, size_t W, size_t H>
|
||||
constexpr matrix_base<T,W,H>::matrix_base():
|
||||
matrix_base(typename detail::default_initialization_matrix<Columns,Rows>::tuple{}){}
|
||||
|
||||
template<typename T, size_t W, size_t H>
|
||||
constexpr matrix_base<T,W,H>::matrix_base(detail::zero_initialize_t):
|
||||
m_data{}{}
|
||||
template<typename T, size_t W, size_t H>
|
||||
constexpr matrix_base<T,W,H>::matrix_base(detail::no_initialize_t){}
|
||||
template<typename T, size_t W, size_t H>
|
||||
template<typename U>
|
||||
constexpr matrix_base<T,W,H>::matrix_base(detail::id_initialize_t):
|
||||
matrix_base()
|
||||
{
|
||||
static_assert(Columns == Rows, "Identity initialization only supported on square matrices");
|
||||
}
|
||||
|
||||
template<typename T, size_t W, size_t H>
|
||||
constexpr matrix_base<T,W,H>::matrix_base(value_type v){
|
||||
for(size_type i = 0;i < Columns*Rows;++i)
|
||||
m_data[i] = v;
|
||||
}
|
||||
template<typename T, size_t W, size_t H>
|
||||
template<typename... Args>
|
||||
constexpr matrix_base<T,W,H>::matrix_base(Args&&... args):
|
||||
m_data{std::forward<Args>(args)...}{}
|
||||
|
||||
template<typename T, size_t W, size_t H>
|
||||
template<typename U>
|
||||
constexpr matrix_base<T,W,H>::matrix_base(const matrix_base<U,Columns,Rows>& m){
|
||||
using mat = decltype(m);
|
||||
for(typename mat::size_type i = 0;i < mat::Columns*mat::Rows;++i)
|
||||
m_data[i] = m.get(i);
|
||||
}
|
||||
|
||||
template<typename T, size_t W, size_t H>
|
||||
template<typename U>
|
||||
constexpr matrix_base<T,W,H>& matrix_base<T,W,H>::operator=(const matrix_base<U,Columns,Rows>& m){
|
||||
using mat = decltype(m);
|
||||
for(typename mat::size_type i = 0;i < mat::Columns*mat::Rows;++i)
|
||||
m_data[i] = m.get(i);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
template<typename T, size_t W, size_t H>
|
||||
constexpr auto matrix_base<T,W,H>::operator[](size_type x){
|
||||
return detail::mat_ref_obj<value_type,Rows>{m_data, x};
|
||||
}
|
||||
template<typename T, size_t W, size_t H>
|
||||
constexpr auto matrix_base<T,W,H>::operator[](size_type x)const{
|
||||
return detail::mat_ref_obj<const value_type,Rows>{m_data, x};
|
||||
}
|
||||
template<typename T, size_t W, size_t H>
|
||||
constexpr auto matrix_base<T,W,H>::get(size_type x, size_type y) -> reference{
|
||||
return m_data[x+(y*Rows)];
|
||||
}
|
||||
template<typename T, size_t W, size_t H>
|
||||
constexpr auto matrix_base<T,W,H>::get(size_type x, size_type y)const -> const_reference{
|
||||
return m_data[x+(y*Rows)];
|
||||
}
|
||||
template<typename T, size_t W, size_t H>
|
||||
constexpr auto matrix_base<T,W,H>::get(size_type i) -> reference{
|
||||
return m_data[i];
|
||||
}
|
||||
template<typename T, size_t W, size_t H>
|
||||
constexpr auto matrix_base<T,W,H>::get(size_type i)const -> const_reference{
|
||||
return m_data[i];
|
||||
}
|
||||
|
||||
template<typename T, size_t W, size_t H>
|
||||
constexpr auto matrix_base<T,W,H>::columns()const -> size_type{
|
||||
return Columns;
|
||||
}
|
||||
template<typename T, size_t W, size_t H>
|
||||
constexpr auto matrix_base<T,W,H>::rows()const -> size_type{
|
||||
return Rows;
|
||||
}
|
||||
template<typename T, size_t W, size_t H>
|
||||
constexpr auto matrix_base<T,W,H>::size()const -> size_type{
|
||||
return Columns*Rows;
|
||||
}
|
||||
|
||||
template<typename T, size_t W, size_t H>
|
||||
constexpr auto matrix_base<T,W,H>::raw() -> pointer{
|
||||
return m_data;
|
||||
}
|
||||
template<typename T, size_t W, size_t H>
|
||||
constexpr auto matrix_base<T,W,H>::raw()const -> const_pointer{
|
||||
return m_data;
|
||||
}
|
||||
template<typename T, size_t W, size_t H>
|
||||
constexpr matrix_base<T,W,H>::operator pointer(){
|
||||
return m_data;
|
||||
}
|
||||
template<typename T, size_t W, size_t H>
|
||||
constexpr matrix_base<T,W,H>::operator const_pointer()const{
|
||||
return m_data;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
155
include/mat.hpp
155
include/mat.hpp
@ -21,8 +21,7 @@
|
||||
|
||||
#include <cstdlib> //size_t
|
||||
#include <utility> //integer_sequence
|
||||
#include <type_traits> //decay_t
|
||||
#include <cmath> //sin, cos
|
||||
#include <type_traits> //decay_t, is_same, integral_constant
|
||||
#include "detail/math.hpp"
|
||||
#include "detail/matrix.hpp"
|
||||
|
||||
@ -61,21 +60,9 @@ namespace math{
|
||||
using detail::matrix_base<T,3,3>::matrix_base;
|
||||
using detail::matrix_base<T,3,3>::operator=;
|
||||
|
||||
template<typename U = void>
|
||||
static constexpr matrix rotation(value_type angle){
|
||||
value_type c = std::cos(angle);
|
||||
value_type s = std::sin(angle);
|
||||
return rotation(s, c);
|
||||
}
|
||||
template<typename U = void>
|
||||
static constexpr matrix rotation(value_type sin, value_type cos){
|
||||
return matrix(cos, -sin, 0,
|
||||
sin, cos, 0,
|
||||
0, 0, 1);
|
||||
}
|
||||
static constexpr matrix rotation(value_type angle_x, value_type angle_y, value_type angle_z){
|
||||
//TODO
|
||||
}
|
||||
static matrix rotation(value_type angle);
|
||||
static constexpr matrix rotation(value_type sin, value_type cos);
|
||||
static constexpr matrix rotation(value_type angle_x, value_type angle_y, value_type angle_z);
|
||||
};
|
||||
|
||||
namespace detail{
|
||||
@ -110,118 +97,40 @@ namespace math{
|
||||
template<typename M1, typename M2>
|
||||
using enable_if_eq_matrix = std::enable_if_t<are_same_size_matrix<M1,M2>::value,int>;
|
||||
|
||||
}
|
||||
|
||||
template<typename T, typename U, size_t W, size_t H>
|
||||
constexpr bool operator==(const matrix<T,W,H>& left, const matrix<U,W,H> right){
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
if(left.get(i) != right.get(i))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
template<typename T, typename U, size_t W, size_t H>
|
||||
constexpr bool operator!=(const matrix<T,W,H>& left, const matrix<U,W,H> right){
|
||||
return !(left == right);
|
||||
}
|
||||
template<typename T, typename U, size_t W, size_t H>
|
||||
constexpr bool operator==(const matrix<T,W,H>& left, const matrix<U,W,H> right);
|
||||
template<typename T, typename U, size_t W, size_t H>
|
||||
constexpr bool operator!=(const matrix<T,W,H>& left, const matrix<U,W,H> right);
|
||||
|
||||
template<typename T, typename U, size_t R1, size_t C1, size_t C2>
|
||||
constexpr auto operator*(const matrix<T,C1,R1>& left, const matrix<U,C2,C1>& right){
|
||||
using res_t = decltype(std::declval<T>() * std::declval<U>());
|
||||
matrix<res_t,C2,R1> res(no_initialize);
|
||||
size_t index = 0;
|
||||
for(size_t i = 0;i < right.rows();++i){
|
||||
for(size_t j = 0;j < left.rows();++j){
|
||||
for(size_t k = 0;k < left.columns();++k){
|
||||
res.get(index) += left[j][k] * right[i][k];
|
||||
}
|
||||
++index;
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr auto operator*(const matrix<T,C,R>& left, U&& right){
|
||||
using res_t = decltype(std::declval<T>() * std::declval<U>());
|
||||
matrix<res_t,C,R> res(no_initialize);
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
res.get(i) = left.get(i) * std::forward<U>(right);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr auto operator/(const matrix<T,C,R>& left, U&& right){
|
||||
using res_t = decltype(std::declval<T>() / std::declval<U>());
|
||||
matrix<res_t,C,R> res(no_initialize);
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
res.get(i) = left.get(i) / std::forward<U>(right);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr auto operator+(const matrix<T,C,R>& left, const matrix<U,C,R>& right){
|
||||
using res_t = decltype(std::declval<T>() + std::declval<U>());
|
||||
matrix<res_t,C,R> res(no_initialize);
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
res.get(i) = left.get(i) + right.get(i);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr auto operator-(const matrix<T,C,R>& left, const matrix<U,C,R>& right){
|
||||
using res_t = decltype(std::declval<T>() - std::declval<U>());
|
||||
matrix<res_t,C,R> res(no_initialize);
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
res.get(i) = left.get(i) - right.get(i);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr auto operator-(const matrix<T,C,R>& left){
|
||||
using res_t = decltype(std::declval<T>() - std::declval<U>());
|
||||
matrix<res_t,C,R> res(no_initialize);
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
res.get(i) = -left.get(i);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
template<typename T, typename U, size_t R1, size_t C1, size_t C2>
|
||||
constexpr auto operator*(const matrix<T,C1,R1>& left, const matrix<U,C2,C1>& right);
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr auto operator*(const matrix<T,C,R>& left, U&& right);
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr auto operator/(const matrix<T,C,R>& left, U&& right);
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr auto operator+(const matrix<T,C,R>& left, const matrix<U,C,R>& right);
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr auto operator-(const matrix<T,C,R>& left, const matrix<U,C,R>& right);
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr auto operator-(const matrix<T,C,R>& left);
|
||||
|
||||
template<typename T, typename U, size_t R1, size_t C1, size_t C2>
|
||||
constexpr decltype(auto) operator*=(matrix<T,C1,R1>& left, const matrix<U,C2,C1>& right);
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr decltype(auto) operator*=(matrix<T,C,R>& left, U&& right);
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr decltype(auto) operator/=(matrix<T,C,R>& left, U&& right);
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr decltype(auto) operator+=(matrix<T,C,R>& left, const matrix<U,C,R>& right);
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr decltype(auto) operator-=(matrix<T,C,R>& left, const matrix<U,C,R>& right);
|
||||
|
||||
template<typename T, typename U, size_t R1, size_t C1, size_t C2>
|
||||
constexpr decltype(auto) operator*=(matrix<T,C1,R1>& left, const matrix<U,C2,C1>& right){
|
||||
//have to evaluate entire expression first since matrix multiplication depends on reusing many elements
|
||||
//cannot be expression templatized, TODO
|
||||
return (left = (left * right));
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr decltype(auto) operator*=(matrix<T,C,R>& left, U&& right){
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
left.get(i) = left.get(i) * std::forward<U>(right);
|
||||
}
|
||||
return left;
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr decltype(auto) operator/=(matrix<T,C,R>& left, U&& right){
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
left.get(i) = left.get(i) / std::forward<U>(right);
|
||||
}
|
||||
return left;
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr decltype(auto) operator+=(matrix<T,C,R>& left, const matrix<U,C,R>& right){
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
left.get(i) = left.get(i) + right.get(i);
|
||||
}
|
||||
return left;
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr decltype(auto) operator-=(matrix<T,C,R>& left, const matrix<U,C,R>& right){
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
left.get(i) = left.get(i) - right.get(i);
|
||||
}
|
||||
return left;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#include "mat.tpp"
|
||||
|
||||
#endif
|
||||
|
||||
157
include/mat.tpp
Normal file
157
include/mat.tpp
Normal file
@ -0,0 +1,157 @@
|
||||
/**
|
||||
This file is a part of the rexy/r0nk/atlas project
|
||||
Copyright (C) 2020 rexy712
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef REXY_MAT_TPP
|
||||
#define REXY_MAT_TPP
|
||||
|
||||
#include <cstdlib> //size_t
|
||||
#include <cmath> //sin, cos
|
||||
#include <type_traits> //decay_t, declval
|
||||
|
||||
namespace math{
|
||||
|
||||
template<typename T>
|
||||
matrix<T,3,3> matrix<T,3,3>::rotation(value_type angle){
|
||||
value_type c = std::cos(angle);
|
||||
value_type s = std::sin(angle);
|
||||
return rotation(s, c);
|
||||
}
|
||||
template<typename T>
|
||||
constexpr matrix<T,3,3> matrix<T,3,3>::rotation(value_type sin, value_type cos){
|
||||
return matrix(cos, -sin, 0,
|
||||
sin, cos, 0,
|
||||
0, 0, 1);
|
||||
}
|
||||
template<typename T>
|
||||
constexpr matrix<T,3,3> matrix<T,3,3>::rotation(value_type angle_x, value_type angle_y, value_type angle_z){
|
||||
//TODO
|
||||
}
|
||||
|
||||
template<typename T, typename U, size_t W, size_t H>
|
||||
constexpr bool operator==(const matrix<T,W,H>& left, const matrix<U,W,H> right){
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
if(left.get(i) != right.get(i))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
template<typename T, typename U, size_t W, size_t H>
|
||||
constexpr bool operator!=(const matrix<T,W,H>& left, const matrix<U,W,H> right){
|
||||
return !(left == right);
|
||||
}
|
||||
|
||||
template<typename T, typename U, size_t R1, size_t C1, size_t C2>
|
||||
constexpr auto operator*(const matrix<T,C1,R1>& left, const matrix<U,C2,C1>& right){
|
||||
using res_t = decltype(std::declval<T>() * std::declval<U>());
|
||||
matrix<res_t,C2,R1> res(no_initialize);
|
||||
size_t index = 0;
|
||||
for(size_t i = 0;i < right.rows();++i){
|
||||
for(size_t j = 0;j < left.rows();++j){
|
||||
for(size_t k = 0;k < left.columns();++k){
|
||||
res.get(index) += left[j][k] * right[i][k];
|
||||
}
|
||||
++index;
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr auto operator*(const matrix<T,C,R>& left, U&& right){
|
||||
using res_t = decltype(std::declval<T>() * std::declval<U>());
|
||||
matrix<res_t,C,R> res(no_initialize);
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
res.get(i) = left.get(i) * std::forward<U>(right);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr auto operator/(const matrix<T,C,R>& left, U&& right){
|
||||
using res_t = decltype(std::declval<T>() / std::declval<U>());
|
||||
matrix<res_t,C,R> res(no_initialize);
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
res.get(i) = left.get(i) / std::forward<U>(right);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr auto operator+(const matrix<T,C,R>& left, const matrix<U,C,R>& right){
|
||||
using res_t = decltype(std::declval<T>() + std::declval<U>());
|
||||
matrix<res_t,C,R> res(no_initialize);
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
res.get(i) = left.get(i) + right.get(i);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr auto operator-(const matrix<T,C,R>& left, const matrix<U,C,R>& right){
|
||||
using res_t = decltype(std::declval<T>() - std::declval<U>());
|
||||
matrix<res_t,C,R> res(no_initialize);
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
res.get(i) = left.get(i) - right.get(i);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr auto operator-(const matrix<T,C,R>& left){
|
||||
using res_t = decltype(std::declval<T>() - std::declval<U>());
|
||||
matrix<res_t,C,R> res(no_initialize);
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
res.get(i) = -left.get(i);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
template<typename T, typename U, size_t R1, size_t C1, size_t C2>
|
||||
constexpr decltype(auto) operator*=(matrix<T,C1,R1>& left, const matrix<U,C2,C1>& right){
|
||||
//have to evaluate entire expression first since matrix multiplication depends on reusing many elements
|
||||
//cannot be expression templatized, TODO
|
||||
return (left = (left * right));
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr decltype(auto) operator*=(matrix<T,C,R>& left, U&& right){
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
left.get(i) = left.get(i) * std::forward<U>(right);
|
||||
}
|
||||
return left;
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr decltype(auto) operator/=(matrix<T,C,R>& left, U&& right){
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
left.get(i) = left.get(i) / std::forward<U>(right);
|
||||
}
|
||||
return left;
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr decltype(auto) operator+=(matrix<T,C,R>& left, const matrix<U,C,R>& right){
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
left.get(i) = left.get(i) + right.get(i);
|
||||
}
|
||||
return left;
|
||||
}
|
||||
template<typename T, typename U, size_t C, size_t R>
|
||||
constexpr decltype(auto) operator-=(matrix<T,C,R>& left, const matrix<U,C,R>& right){
|
||||
for(size_t i = 0;i < left.size();++i){
|
||||
left.get(i) = left.get(i) - right.get(i);
|
||||
}
|
||||
return left;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -4,6 +4,7 @@
|
||||
|
||||
#include "render.hpp"
|
||||
#include "game_state.hpp"
|
||||
#include "mat.hpp"
|
||||
|
||||
// 0 | 1 | 2
|
||||
// ---------
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user