ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1288 Commits
21 Branches
19 Tags
70 MiB
Tree: 5f19343bee
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5f19343bee'
${ noResults }
magnum/src/Math/Vector.h

414 lines
17 KiB
Raw Normal View History Unescape

New namespace Magnum::Math.
16 years ago
#ifndef Magnum_Math_Vector_h
#define Magnum_Math_Vector_h
Template vector class.
16 years ago
/*
Happy New Year.
15 years ago
Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
Template vector class.
16 years ago
This file is part of Magnum.
Magnum is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License version 3
only, as published by the Free Software Foundation.
Magnum 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 Lesser General Public License version 3 for more details.
*/
/** @file
New namespace Magnum::Math.
16 years ago
* @brief Class Magnum::Math::Vector
Template vector class.
16 years ago
*/
Adapted to Corrade changes. Optimalizations in Corrade::TestSuite and Corrade::Utility::Debug leaded to significant reduction of compilation time - on my machine it was ~5:38 before with building of unit tests enabled, now only ~5:00.
14 years ago
#include <Utility/Assert.h>
New base for matrices and vectors: RectangularMatrix. Currently moved only non-square functionality from Matrix there. Also static constant members such as row/column count and size are now lowercase, as they are variables, not types.
14 years ago
#include "RectangularMatrix.h"
Use fuzzy compare also for Vector.
16 years ago
New namespace Magnum::Math.
16 years ago
namespace Magnum { namespace Math {
Template vector class.
16 years ago
Support for storing matrices and vectors in configuration.
14 years ago
/**
@brief %Vector
Have first letter of static constants uppercase, like previously. Lowecase didn't prove to be better, because Doxygen cannot implicitly link to it and it collides with non-type template parameters and private variables.
14 years ago
@tparam size %Vector size
@tparam T Data type
Support for storing matrices and vectors in configuration.
14 years ago
Doc: brief introduction to matrix and vector classes. DDD - documentation driven development. Not all advertised features are available right now, but they will come.
14 years ago
See @ref matrix-vector for brief introduction.
Support for storing matrices and vectors in configuration.
14 years ago
@configurationvalueref{Magnum::Math::Vector}
*/
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
template<std::size_t size, class T> class Vector: public RectangularMatrix<1, size, T> {
Template vector class.
16 years ago
public:
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
const static std::size_t Size = size; /**< @brief %Vector size */
"constexpr"-ized Matrix and Vector classes. It should improve performance, because what can be computed at compile time is now computed at compile time. In addition these things have been changed or improved: * Removed constructors from T*, as they cannot be AFAIK written using constexpr functions only and they only do unnecessary data copying most of the time. The functionality is now provided using static functions Matrix*::from() and Vector*::from() which returns either const or non-const reference to original data, so no copy is performed. These functions also have explicit warning about unsafe operations. * Defaulted copy constructors and assignment operators, using "default initialization" for arrays instead of memsetting it with zeros. It should behave the same and this way we don't need any memcpy(), memset() etc. from <cstring>, which is good.
14 years ago
Documented Matrix and Vector algorithms.
14 years ago
/**
* @brief Dot product
*
* @f[
Minor code cleanup.
14 years ago
* a \cdot b = \sum_{i=0}^{n-1} a_ib_i
Documented Matrix and Vector algorithms.
14 years ago
* @f]
Renamed Vector::lengthSquared() to parameterless Vector::dot(). It's now less confusing ("length squared" looks like it's even heavier than length), but on the other hand it's not so obvious that these two functions come together.
14 years ago
* @see dot() const
Documented Matrix and Vector algorithms.
14 years ago
*/
Swapped size and type template parameters in Vector and Matrix. Long-standing TODO. It is better to have size first, because it is more significant than type (e.g. because there are Vector4<T> specializations and not VectorT<4> specializations). It is also IMHO easier for user to distinguish/read the type than before: Vector<float, 4> -> Vector4<float> // before Vector<4, float> -> Vector4<float> // now
14 years ago
static T dot(const Vector<size, T>& a, const Vector<size, T>& b) {
Vector dot product is now static function instead of operator*(). operator* is used in GLSL for element-wise multiplication, be compatible with that.
14 years ago
T out(0);
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
for(std::size_t i = 0; i != size; ++i)
Vector dot product is now static function instead of operator*(). operator* is used in GLSL for element-wise multiplication, be compatible with that.
14 years ago
out += a[i]*b[i];
return out;
}
Documented Matrix and Vector algorithms.
14 years ago
/**
Doc++
14 years ago
* @brief Angle between normalized vectors (in radians)
Documented Matrix and Vector algorithms.
14 years ago
*
Doc++ * Added math equations to Quaternion, Vector and Matrix method documentation. * Removed confusing Quat*=Quat operator overload, as it isn't exactly clear from which side the non-commutative multiplication is done: Quaternion a; a *= b; // eh? a = a*b; // okay! For similar reason this operator wasn't present in RectangularMatrix either. * Unified documentation of expected vector/quaternion normalization state. Now it is not "assumed" but "expected", because failing to do so results in assertion failure.
14 years ago
* Expects that both vectors are normalized. @f[
Minor code cleanup.
14 years ago
* \theta = acos \left( \frac{a \cdot b}{|a| \cdot |b|} \right)
Documented Matrix and Vector algorithms.
14 years ago
* @f]
*/
Vector::angle(): reflect normalization requirement in parameter names. Will be more intuitive when IDE autocompletion kicks in.
14 years ago
inline static T angle(const Vector<size, T>& normalizedA, const Vector<size, T>& normalizedB) {
CORRADE_ASSERT(MathTypeTraits<T>::equals(normalizedA.dot(), T(1)) && MathTypeTraits<T>::equals(normalizedB.dot(), T(1)),
Documentation clarification, assertion update. Don't yell at the user all the time.
14 years ago
"Math::Vector::angle(): vectors must be normalized", std::numeric_limits<T>::quiet_NaN());
Vector::angle(): reflect normalization requirement in parameter names. Will be more intuitive when IDE autocompletion kicks in.
14 years ago
return std::acos(dot(normalizedA, normalizedB));
Function for angle between vectors.
16 years ago
}
Math: linear interpolation of two Vectors.
14 years ago
/**
* @brief Linear interpolation of two vectors
* @param a First vector
* @param b Second vector
* @param t Interpolation phase (from range @f$ [0; 1] @f$)
*
* The interpolation is done as in following: @f[
* v_{LERP} = (1 - t) \boldsymbol v_A + t \boldsymbol v_B
* @f]
*/
inline static Vector<size, T> lerp(const Vector<size, T>& a, const Vector<size, T>& b, T t) {
return (T(1) - t)*a + t*b;
}
Template vector class.
16 years ago
/** @brief Default constructor */
Marking all constructors explicit, except for matrix and vector classes. It prevents unwanted implicit conversions from e.g. nullptr to Camera, Vector2 to Physics::Point etc. By making all the constructors explicit it is easier to routinely add the keyword to all new classes instead of thinking about cases when to add and when not to.
14 years ago
inline constexpr /*implicit*/ Vector() {}
Template vector class.
16 years ago
Added some @todos.
14 years ago
/** @todo Creating Vector from combination of vector and scalar types */
Finally "initializer-list" constructor for Vector. It's not actually initializer list, because it is only for variable-length types, which is unusable here. Variadic templates do better job here.
14 years ago
/**
* @brief Initializer-list constructor
* @param first First value
* @param next Next values
*/
Doc: some workarounds for Doxygen C++11 support etc.
14 years ago
#ifndef DOXYGEN_GENERATING_OUTPUT
Marking all constructors explicit, except for matrix and vector classes. It prevents unwanted implicit conversions from e.g. nullptr to Camera, Vector2 to Physics::Point etc. By making all the constructors explicit it is easier to routinely add the keyword to all new classes instead of thinking about cases when to add and when not to.
14 years ago
template<class ...U> inline constexpr /*implicit*/ Vector(T first, U... next): RectangularMatrix<1, size, T>(first, next...) {}
Doc: some workarounds for Doxygen C++11 support etc.
14 years ago
#else
Marking all constructors explicit, except for matrix and vector classes. It prevents unwanted implicit conversions from e.g. nullptr to Camera, Vector2 to Physics::Point etc. By making all the constructors explicit it is easier to routinely add the keyword to all new classes instead of thinking about cases when to add and when not to.
14 years ago
template<class ...U> inline constexpr /*implicit*/ Vector(T first, U... next);
Doc: some workarounds for Doxygen C++11 support etc.
14 years ago
#endif
Finally "initializer-list" constructor for Vector. It's not actually initializer list, because it is only for variable-length types, which is unusable here. Variadic templates do better job here.
14 years ago
Possiblity for constructing Vector from one value, like in GLSL. Marked the constructor as explicit, because we don't want mistakes like this to happen: Matrix4::rotation(1.0f, deg(3.0f)); // oops, swapped axis and angle! Instead, when calling such constructor, the type must be said explicitly (initializer-list is forbidden, too): Matrix4::rotation(deg(3.0f), Vector3(1.0f)); // okay
14 years ago
/**
* @brief Constructor
* @param value Value for all fields
*/
Disable non-constexpr one-parameter constructor for Vector<1, T>. It was clashing with the default "initializer-list" constructor, which is constexpr. This constructor is also explicit, which makes it impossible to e.g. return Vector<1, T> from function without explicitly specifying name , while for Vector<2, T> it works: return {1, 2}; // works for Vector<2, int> return {1}; // doesn't work for Vector<1, int>
14 years ago
#ifndef DOXYGEN_GENERATING_OUTPUT
template<class U> inline explicit Vector(typename std::enable_if<std::is_same<T, U>::value && size != 1, U>::type value) {
#else
Possiblity for constructing Vector from one value, like in GLSL. Marked the constructor as explicit, because we don't want mistakes like this to happen: Matrix4::rotation(1.0f, deg(3.0f)); // oops, swapped axis and angle! Instead, when calling such constructor, the type must be said explicitly (initializer-list is forbidden, too): Matrix4::rotation(deg(3.0f), Vector3(1.0f)); // okay
14 years ago
inline explicit Vector(T value) {
Disable non-constexpr one-parameter constructor for Vector<1, T>. It was clashing with the default "initializer-list" constructor, which is constexpr. This constructor is also explicit, which makes it impossible to e.g. return Vector<1, T> from function without explicitly specifying name , while for Vector<2, T> it works: return {1, 2}; // works for Vector<2, int> return {1}; // doesn't work for Vector<1, int>
14 years ago
#endif
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
for(std::size_t i = 0; i != size; ++i)
New base for matrices and vectors: RectangularMatrix. Currently moved only non-square functionality from Matrix there. Also static constant members such as row/column count and size are now lowercase, as they are variables, not types.
14 years ago
(*this)[i] = value;
Possiblity for constructing Vector from one value, like in GLSL. Marked the constructor as explicit, because we don't want mistakes like this to happen: Matrix4::rotation(1.0f, deg(3.0f)); // oops, swapped axis and angle! Instead, when calling such constructor, the type must be said explicitly (initializer-list is forbidden, too): Matrix4::rotation(deg(3.0f), Vector3(1.0f)); // okay
14 years ago
}
Template vector class.
16 years ago
/** @brief Copy constructor */
New base for matrices and vectors: RectangularMatrix. Currently moved only non-square functionality from Matrix there. Also static constant members such as row/column count and size are now lowercase, as they are variables, not types.
14 years ago
inline constexpr Vector(const RectangularMatrix<1, size, T>& other): RectangularMatrix<1, size, T>(other) {}
Template vector class.
16 years ago
/** @brief Value at given position */
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
inline T& operator[](std::size_t pos) { return RectangularMatrix<1, size, T>::_data[pos]; }
inline constexpr T operator[](std::size_t pos) const { return RectangularMatrix<1, size, T>::_data[pos]; } /**< @overload */
Template vector class.
16 years ago
Component-wise comparison for Vector class.
14 years ago
/**
* @brief Component-wise less than
* @return `True` if all components are smaller than their
* counterparts in @p other, `false` otherwise
*/
inline bool operator<(const Vector<size, T>& other) const {
for(std::size_t i = 0; i != size; ++i)
if((*this)[i] >= other[i]) return false;
return true;
}
/**
* @brief Component-wise less than or equal
* @return `True` if all components are smaller than or equal to their
* counterparts in @p other, `false` otherwise
*/
inline bool operator<=(const Vector<size, T>& other) const {
for(std::size_t i = 0; i != size; ++i)
if((*this)[i] > other[i]) return false;
return true;
}
/**
* @brief Component-wise greater than or equal
* @return `True` if all components are larger than or equal to their
* counterparts in @p other, `false` otherwise
*/
inline bool operator>=(const Vector<size, T>& other) const {
for(std::size_t i = 0; i != size; ++i)
if((*this)[i] < other[i]) return false;
return true;
}
/**
* @brief Component-wise greater than
* @return `True` if all components are larger than their
* counterparts in @p other, `false` otherwise
*/
inline bool operator>(const Vector<size, T>& other) const {
for(std::size_t i = 0; i != size; ++i)
if((*this)[i] <= other[i]) return false;
return true;
}
Added component-wise multiplication and division to Vector.
14 years ago
/**
* @brief Multiply vector component-wise and assign
*
Doc++
14 years ago
* The computation is done in-place. @f[
* \boldsymbol a_i = \boldsymbol a_i \boldsymbol b_i
* @f]
Added component-wise multiplication and division to Vector.
14 years ago
*/
Math: ability to multiply and divide Vector with other of arbitrary type.
14 years ago
template<class U> Vector<size, T>& operator*=(const Vector<size, U>& other) {
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
for(std::size_t i = 0; i != size; ++i)
Added component-wise multiplication and division to Vector.
14 years ago
(*this)[i] *= other[i];
return *this;
}
/**
Doc++
14 years ago
* @brief Multiply vector component-wise
Added component-wise multiplication and division to Vector.
14 years ago
*
Doc++
14 years ago
* @see operator*=(const Vector<size, U>&)
Added component-wise multiplication and division to Vector.
14 years ago
*/
Doc++
14 years ago
template<class U> inline Vector<size, T> operator*(const Vector<size, U>& other) const {
return Vector<size, T>(*this)*=other;
Added component-wise multiplication and division to Vector.
14 years ago
}
/**
* @brief Divide vector component-wise and assign
*
Doc++
14 years ago
* The computation is done in-place. @f[
* \boldsymbol a_i = \frac{\boldsymbol a_i}{\boldsymbol b_i}
* @f]
Added component-wise multiplication and division to Vector.
14 years ago
*/
Math: ability to multiply and divide Vector with other of arbitrary type.
14 years ago
template<class U> Vector<size, T>& operator/=(const Vector<size, U>& other) {
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
for(std::size_t i = 0; i != size; ++i)
Added component-wise multiplication and division to Vector.
14 years ago
(*this)[i] /= other[i];
return *this;
}
Doc++
14 years ago
/**
* @brief Divide vector component-wise
*
* @see operator/=(const Vector<size, U>&)
*/
template<class U> inline Vector<size, T> operator/(const Vector<size, U>& other) const {
return Vector<size, T>(*this)/=other;
}
Added Vector::lengthSquared() function. The name is a little bit misleading, but it is for more efficient vector length comparisons.
14 years ago
/**
Renamed Vector::lengthSquared() to parameterless Vector::dot(). It's now less confusing ("length squared" looks like it's even heavier than length), but on the other hand it's not so obvious that these two functions come together.
14 years ago
* @brief Dot product of the vector
Added Vector::lengthSquared() function. The name is a little bit misleading, but it is for more efficient vector length comparisons.
14 years ago
*
Renamed Vector::lengthSquared() to parameterless Vector::dot(). It's now less confusing ("length squared" looks like it's even heavier than length), but on the other hand it's not so obvious that these two functions come together.
14 years ago
* Should be used instead of length() for comparing vector length with
Doc++ * Added math equations to Quaternion, Vector and Matrix method documentation. * Removed confusing Quat*=Quat operator overload, as it isn't exactly clear from which side the non-commutative multiplication is done: Quaternion a; a *= b; // eh? a = a*b; // okay! For similar reason this operator wasn't present in RectangularMatrix either. * Unified documentation of expected vector/quaternion normalization state. Now it is not "assumed" but "expected", because failing to do so results in assertion failure.
14 years ago
* other values, because it doesn't compute the square root. @f[
Math: Quaternion has dot product too! Original lengthSquared() renamed to parameterless dot(), it is now consistent with what Vector has. Also updated related Vector documentation.
14 years ago
* a \cdot a = \sum_{i=0}^{n-1} a_i^2
Doc++ * Added math equations to Quaternion, Vector and Matrix method documentation. * Removed confusing Quat*=Quat operator overload, as it isn't exactly clear from which side the non-commutative multiplication is done: Quaternion a; a *= b; // eh? a = a*b; // okay! For similar reason this operator wasn't present in RectangularMatrix either. * Unified documentation of expected vector/quaternion normalization state. Now it is not "assumed" but "expected", because failing to do so results in assertion failure.
14 years ago
* @f]
Renamed Vector::lengthSquared() to parameterless Vector::dot(). It's now less confusing ("length squared" looks like it's even heavier than length), but on the other hand it's not so obvious that these two functions come together.
14 years ago
* @see dot(const Vector<size, T>&, const Vector<size, T>&)
Added Vector::lengthSquared() function. The name is a little bit misleading, but it is for more efficient vector length comparisons.
14 years ago
*/
Renamed Vector::lengthSquared() to parameterless Vector::dot(). It's now less confusing ("length squared" looks like it's even heavier than length), but on the other hand it's not so obvious that these two functions come together.
14 years ago
inline T dot() const {
return dot(*this, *this);
Template vector class.
16 years ago
}
Added Vector::lengthSquared() function. The name is a little bit misleading, but it is for more efficient vector length comparisons.
14 years ago
/**
Renamed Vector::lengthSquared() to parameterless Vector::dot(). It's now less confusing ("length squared" looks like it's even heavier than length), but on the other hand it's not so obvious that these two functions come together.
14 years ago
* @brief %Vector length
Added Vector::lengthSquared() function. The name is a little bit misleading, but it is for more efficient vector length comparisons.
14 years ago
*
Math: Quaternion has dot product too! Original lengthSquared() renamed to parameterless dot(), it is now consistent with what Vector has. Also updated related Vector documentation.
14 years ago
* @f[
* |a| = \sqrt{a \cdot a}
* @f]
Renamed Vector::lengthSquared() to parameterless Vector::dot(). It's now less confusing ("length squared" looks like it's even heavier than length), but on the other hand it's not so obvious that these two functions come together.
14 years ago
* @see dot() const
Added Vector::lengthSquared() function. The name is a little bit misleading, but it is for more efficient vector length comparisons.
14 years ago
*/
Renamed Vector::lengthSquared() to parameterless Vector::dot(). It's now less confusing ("length squared" looks like it's even heavier than length), but on the other hand it's not so obvious that these two functions come together.
14 years ago
inline T length() const {
return std::sqrt(dot());
Added Vector::lengthSquared() function. The name is a little bit misleading, but it is for more efficient vector length comparisons.
14 years ago
}
Template vector class.
16 years ago
/** @brief Normalized vector (of length 1) */
Swapped size and type template parameters in Vector and Matrix. Long-standing TODO. It is better to have size first, because it is more significant than type (e.g. because there are Vector4<T> specializations and not VectorT<4> specializations). It is also IMHO easier for user to distinguish/read the type than before: Vector<float, 4> -> Vector4<float> // before Vector<4, float> -> Vector4<float> // now
14 years ago
inline Vector<size, T> normalized() const {
Template vector class.
16 years ago
return *this/length();
}
Math: function for projecting vector onto another.
14 years ago
/**
Doc++ * Added math equations to Quaternion, Vector and Matrix method documentation. * Removed confusing Quat*=Quat operator overload, as it isn't exactly clear from which side the non-commutative multiplication is done: Quaternion a; a *= b; // eh? a = a*b; // okay! For similar reason this operator wasn't present in RectangularMatrix either. * Unified documentation of expected vector/quaternion normalization state. Now it is not "assumed" but "expected", because failing to do so results in assertion failure.
14 years ago
* @brief %Vector projected onto another
Math: function for projecting vector onto another.
14 years ago
*
Doc++ * Added math equations to Quaternion, Vector and Matrix method documentation. * Removed confusing Quat*=Quat operator overload, as it isn't exactly clear from which side the non-commutative multiplication is done: Quaternion a; a *= b; // eh? a = a*b; // okay! For similar reason this operator wasn't present in RectangularMatrix either. * Unified documentation of expected vector/quaternion normalization state. Now it is not "assumed" but "expected", because failing to do so results in assertion failure.
14 years ago
* Returns vector projected onto line defined by @p other. @f[
* \boldsymbol a_1 = \frac{\boldsymbol a \cdot \boldsymbol b}{\boldsymbol b \cdot \boldsymbol b} \boldsymbol b
* @f]
Math: function for projecting vector onto another.
14 years ago
*/
inline Vector<size, T> projected(const Vector<size, T>& other) const {
return other*dot(*this, other)/other.dot();
}
Added Vector::sum(), so product() has a friend.
14 years ago
/** @brief Sum of values in the vector */
T sum() const {
T out(0);
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
for(std::size_t i = 0; i != size; ++i)
Added Vector::sum(), so product() has a friend.
14 years ago
out += (*this)[i];
return out;
}
Math: function to compute product of all values in the vector. Is this mathematic operation at all?
14 years ago
/** @brief Product of values in the vector */
T product() const {
Added Vector::sum(), so product() has a friend.
14 years ago
T out(1);
Math: function to compute product of all values in the vector. Is this mathematic operation at all?
14 years ago
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
for(std::size_t i = 0; i != size; ++i)
Forced exclusive use of bracket operators in Matrix and Vector. Removed functions at(), set() and add(), everything (and more) can be now done using operator[]. Accessing matrix elements is now done through column vectors, e.g.: Matrix4 a; a.at(row, col); // before a[col][row]; // now Note that because operator[] on Matrix returns column vector (there is nothing like row vector), the parameter "order" is now swapped.
14 years ago
out *= (*this)[i];
Math: function to compute product of all values in the vector. Is this mathematic operation at all?
14 years ago
return out;
}
Added Vector::min() and Vector::max().
14 years ago
/** @brief Minimal value in the vector */
T min() const {
T out((*this)[0]);
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
for(std::size_t i = 1; i != size; ++i)
Added Vector::min() and Vector::max().
14 years ago
out = std::min(out, (*this)[i]);
return out;
}
/** @brief Maximal value in the vector */
T max() const {
T out((*this)[0]);
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
for(std::size_t i = 1; i != size; ++i)
Added Vector::min() and Vector::max().
14 years ago
out = std::max(out, (*this)[i]);
return out;
}
Math: function to compute product of all values in the vector. Is this mathematic operation at all?
14 years ago
Fixed matrix multiplication in RectangularMatrix subclasses. Now all possible cases are properly handled (row vector * column vector, column vector * row vector, ...). All operators taking arbitrary type as argument (element-wise multiplication) now have std::enable_if only for numerical types.
14 years ago
#ifndef DOXYGEN_GENERATING_OUTPUT
/* Reimplementation of functions to return correct type */
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
template<std::size_t otherCols> inline RectangularMatrix<otherCols, size, T> operator*(const RectangularMatrix<otherCols, 1, T>& other) const {
Fixed matrix multiplication in RectangularMatrix subclasses. Now all possible cases are properly handled (row vector * column vector, column vector * row vector, ...). All operators taking arbitrary type as argument (element-wise multiplication) now have std::enable_if only for numerical types.
14 years ago
return RectangularMatrix<1, size, T>::operator*(other);
}
New base for matrices and vectors: RectangularMatrix. Currently moved only non-square functionality from Matrix there. Also static constant members such as row/column count and size are now lowercase, as they are variables, not types.
14 years ago
MAGNUM_RECTANGULARMATRIX_SUBCLASS_IMPLEMENTATION(1, size, Vector<size, T>)
Moved add/subtract operators from Vector to RectangularMatrix.
14 years ago
MAGNUM_RECTANGULARMATRIX_SUBCLASS_OPERATOR_IMPLEMENTATION(1, size, Vector<size, T>)
Fixed matrix multiplication in RectangularMatrix subclasses. Now all possible cases are properly handled (row vector * column vector, column vector * row vector, ...). All operators taking arbitrary type as argument (element-wise multiplication) now have std::enable_if only for numerical types.
14 years ago
#endif
New base for matrices and vectors: RectangularMatrix. Currently moved only non-square functionality from Matrix there. Also static constant members such as row/column count and size are now lowercase, as they are variables, not types.
14 years ago
Template vector class.
16 years ago
private:
New base for matrices and vectors: RectangularMatrix. Currently moved only non-square functionality from Matrix there. Also static constant members such as row/column count and size are now lowercase, as they are variables, not types.
14 years ago
/* Hiding unused things from RectangularMatrix */
Have first letter of static constants uppercase, like previously. Lowecase didn't prove to be better, because Doxygen cannot implicitly link to it and it collides with non-type template parameters and private variables.
14 years ago
using RectangularMatrix<1, size, T>::Cols;
using RectangularMatrix<1, size, T>::Rows;
New base for matrices and vectors: RectangularMatrix. Currently moved only non-square functionality from Matrix there. Also static constant members such as row/column count and size are now lowercase, as they are variables, not types.
14 years ago
using RectangularMatrix<1, size, T>::operator[];
using RectangularMatrix<1, size, T>::operator();
Template vector class.
16 years ago
};
Added number*Vector and number/Vector operators.
14 years ago
#ifndef DOXYGEN_GENERATING_OUTPUT
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
template<std::size_t size, class T, class U> inline typename std::enable_if<std::is_arithmetic<U>::value, Vector<size, T>>::type operator*(U number, const Vector<size, T>& vector) {
Moved multiplication and division from Vector to RectangularMatrix.
14 years ago
return number*RectangularMatrix<1, size, T>(vector);
Added number*Vector and number/Vector operators.
14 years ago
}
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
template<std::size_t size, class T, class U> inline typename std::enable_if<std::is_arithmetic<U>::value, Vector<size, T>>::type operator/(U number, const Vector<size, T>& vector) {
Moved multiplication and division from Vector to RectangularMatrix.
14 years ago
return number/RectangularMatrix<1, size, T>(vector);
Added number*Vector and number/Vector operators.
14 years ago
}
Moved multiplication and division from Vector to RectangularMatrix.
14 years ago
#endif
Added number*Vector and number/Vector operators.
14 years ago
New crossreferenced @debugoperator alias.
14 years ago
/** @debugoperator{Magnum::Math::Vector} */
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
template<std::size_t size, class T> Corrade::Utility::Debug operator<<(Corrade::Utility::Debug debug, const Vector<size, T>& value) {
Custom @debugoperator command instead of hiding the functions. Uses @relates, so the operator is tied to related class.
14 years ago
debug << "Vector(";
debug.setFlag(Corrade::Utility::Debug::SpaceAfterEachValue, false);
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
for(std::size_t i = 0; i != size; ++i) {
Custom @debugoperator command instead of hiding the functions. Uses @relates, so the operator is tied to related class.
14 years ago
if(i != 0) debug << ", ";
Added NumericType and FloatingPointType to Math::MathTypeTraits. NumericType is corresponding numeric type with size at least the same as int. It is used in debug operators for Matrix and Vector to prevent printing chars as characters. If the type isn't already floating-point, FloatingPointType is corresponding larger type with sufficient size for normalization of given integral type. Also updated type traits for long types, they are now subclassed either from int or long long based on sizeof(long).
14 years ago
debug << typename MathTypeTraits<T>::NumericType(value[i]);
Custom @debugoperator command instead of hiding the functions. Uses @relates, so the operator is tied to related class.
14 years ago
}
debug << ')';
debug.setFlag(Corrade::Utility::Debug::SpaceAfterEachValue, true);
return debug;
}
Explicit template instantiation for common matrix and vector functions. Common types used in OpenGL have now explicit template instantiation for debug operators and configuration value parsers/readers.
14 years ago
/* Explicit instantiation for types used in OpenGL */
#ifndef DOXYGEN_GENERATING_OUTPUT
extern template Corrade::Utility::Debug MAGNUM_EXPORT operator<<(Corrade::Utility::Debug, const Vector<2, float>&);
extern template Corrade::Utility::Debug MAGNUM_EXPORT operator<<(Corrade::Utility::Debug, const Vector<3, float>&);
extern template Corrade::Utility::Debug MAGNUM_EXPORT operator<<(Corrade::Utility::Debug, const Vector<4, float>&);
extern template Corrade::Utility::Debug MAGNUM_EXPORT operator<<(Corrade::Utility::Debug, const Vector<2, int>&);
extern template Corrade::Utility::Debug MAGNUM_EXPORT operator<<(Corrade::Utility::Debug, const Vector<3, int>&);
extern template Corrade::Utility::Debug MAGNUM_EXPORT operator<<(Corrade::Utility::Debug, const Vector<4, int>&);
extern template Corrade::Utility::Debug MAGNUM_EXPORT operator<<(Corrade::Utility::Debug, const Vector<2, unsigned int>&);
extern template Corrade::Utility::Debug MAGNUM_EXPORT operator<<(Corrade::Utility::Debug, const Vector<3, unsigned int>&);
extern template Corrade::Utility::Debug MAGNUM_EXPORT operator<<(Corrade::Utility::Debug, const Vector<4, unsigned int>&);
#ifndef MAGNUM_TARGET_GLES
extern template Corrade::Utility::Debug MAGNUM_EXPORT operator<<(Corrade::Utility::Debug, const Vector<2, double>&);
extern template Corrade::Utility::Debug MAGNUM_EXPORT operator<<(Corrade::Utility::Debug, const Vector<3, double>&);
extern template Corrade::Utility::Debug MAGNUM_EXPORT operator<<(Corrade::Utility::Debug, const Vector<4, double>&);
#endif
#endif
Support for printing Matrix and Vector to debug output. Added tests for Matrix3, Vector2 just to be sure that debug output works also there.
15 years ago
#ifndef DOXYGEN_GENERATING_OUTPUT
Replaced clutter in Vector and Matrix subclasses with a macro. Each function which returned e.g. Vector<size, T> was in subclasses overloaded with function returning e.g. Vector3<T>, so the user is able to use subclass-specific functions. It was nightmare to maintain and it cluttered the documentation a lot.
14 years ago
#define MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(Type, size) \
inline constexpr static Type<T>& from(T* data) { \
return *reinterpret_cast<Type<T>*>(data); \
} \
inline constexpr static const Type<T>& from(const T* data) { \
return *reinterpret_cast<const Type<T>*>(data); \
Ability to construct Vector from another of different type.
14 years ago
} \
Vector function and operator reimplementation also for Color.
14 years ago
template<class U> inline constexpr static Type<T> from(const Math::Vector<size, U>& other) { \
return Math::Vector<size, T>::from(other); \
Math: linear interpolation of two Vectors.
14 years ago
} \
inline static const Type<T> lerp(const Math::Vector<size, T>& a, const Math::Vector<size, T>& b, T t) { \
return Math::Vector<size, T>::lerp(a, b, t); \
Replaced clutter in Vector and Matrix subclasses with a macro. Each function which returned e.g. Vector<size, T> was in subclasses overloaded with function returning e.g. Vector3<T>, so the user is able to use subclass-specific functions. It was nightmare to maintain and it cluttered the documentation a lot.
14 years ago
} \
\
inline Type<T>& operator=(const Type<T>& other) { \
Vector function and operator reimplementation also for Color.
14 years ago
Math::Vector<size, T>::operator=(other); \
Replaced clutter in Vector and Matrix subclasses with a macro. Each function which returned e.g. Vector<size, T> was in subclasses overloaded with function returning e.g. Vector3<T>, so the user is able to use subclass-specific functions. It was nightmare to maintain and it cluttered the documentation a lot.
14 years ago
return *this; \
} \
\
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
template<std::size_t otherCols> inline Math::RectangularMatrix<otherCols, size, T> operator*(const Math::RectangularMatrix<otherCols, 1, T>& other) const { \
Fixed matrix multiplication in RectangularMatrix subclasses. Now all possible cases are properly handled (row vector * column vector, column vector * row vector, ...). All operators taking arbitrary type as argument (element-wise multiplication) now have std::enable_if only for numerical types.
14 years ago
return Math::Vector<size, T>::operator*(other); \
} \
Math: ability to multiply and divide Vector with other of arbitrary type.
14 years ago
template<class U> inline Type<T> operator*(const Math::Vector<size, U>& other) const { \
Vector function and operator reimplementation also for Color.
14 years ago
return Math::Vector<size, T>::operator*(other); \
Added component-wise multiplication and division to Vector.
14 years ago
} \
Math: ability to multiply and divide Vector with other of arbitrary type.
14 years ago
template<class U> inline Type<T>& operator*=(const Math::Vector<size, U>& other) { \
Vector function and operator reimplementation also for Color.
14 years ago
Math::Vector<size, T>::operator*=(other); \
Added component-wise multiplication and division to Vector.
14 years ago
return *this; \
} \
Math: ability to multiply and divide Vector with other of arbitrary type.
14 years ago
template<class U> inline Type<T> operator/(const Math::Vector<size, U>& other) const { \
Vector function and operator reimplementation also for Color.
14 years ago
return Math::Vector<size, T>::operator/(other); \
Added component-wise multiplication and division to Vector.
14 years ago
} \
Math: ability to multiply and divide Vector with other of arbitrary type.
14 years ago
template<class U> inline Type<T>& operator/=(const Math::Vector<size, U>& other) { \
Vector function and operator reimplementation also for Color.
14 years ago
Math::Vector<size, T>::operator/=(other); \
Added component-wise multiplication and division to Vector.
14 years ago
return *this; \
Replaced clutter in Vector and Matrix subclasses with a macro. Each function which returned e.g. Vector<size, T> was in subclasses overloaded with function returning e.g. Vector3<T>, so the user is able to use subclass-specific functions. It was nightmare to maintain and it cluttered the documentation a lot.
14 years ago
} \
\
Math: return proper type from Vector::projected() in subclasses.
14 years ago
inline Type<T> normalized() const { return Math::Vector<size, T>::normalized(); } \
inline Type<T> projected(const Math::Vector<size, T>& other) const { \
return Math::Vector<size, T>::projected(other); \
}
Added number*Vector and number/Vector operators.
14 years ago
#define MAGNUM_VECTOR_SUBCLASS_OPERATOR_IMPLEMENTATION(Type, size) \
Fixed matrix multiplication in RectangularMatrix subclasses. Now all possible cases are properly handled (row vector * column vector, column vector * row vector, ...). All operators taking arbitrary type as argument (element-wise multiplication) now have std::enable_if only for numerical types.
14 years ago
template<class T, class U> inline typename std::enable_if<std::is_arithmetic<U>::value, Type<T>>::type operator*(U number, const Type<T>& vector) { \
Vector function and operator reimplementation also for Color.
14 years ago
return number*Math::Vector<size, T>(vector); \
Added number*Vector and number/Vector operators.
14 years ago
} \
Fixed matrix multiplication in RectangularMatrix subclasses. Now all possible cases are properly handled (row vector * column vector, column vector * row vector, ...). All operators taking arbitrary type as argument (element-wise multiplication) now have std::enable_if only for numerical types.
14 years ago
template<class T, class U> inline typename std::enable_if<std::is_arithmetic<U>::value, Type<T>>::type operator/(U number, const Type<T>& vector) { \
Vector function and operator reimplementation also for Color.
14 years ago
return number/Math::Vector<size, T>(vector); \
Added number*Vector and number/Vector operators.
14 years ago
}
Support for printing Matrix and Vector to debug output. Added tests for Matrix3, Vector2 just to be sure that debug output works also there.
15 years ago
#endif
New namespace Magnum::Math.
16 years ago
}}
Template vector class.
16 years ago
Support for storing matrices and vectors in configuration.
14 years ago
namespace Corrade { namespace Utility {
/** @configurationvalue{Magnum::Math::Vector} */
Pedantic: using std::size_t instead of size_t from C compat headers.
14 years ago
template<std::size_t size, class T> struct ConfigurationValue<Magnum::Math::Vector<size, T>>: public ConfigurationValue<Magnum::Math::RectangularMatrix<1, size, T>> {};
Support for storing matrices and vectors in configuration.
14 years ago
}}
Template vector class.
16 years ago
#endif