|
|
|
|
#ifndef Magnum_Math_Vector4_h
|
|
|
|
|
#define Magnum_Math_Vector4_h
|
|
|
|
|
/*
|
|
|
|
|
Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
* @brief Class Magnum::Math::Vector4
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "Vector3.h"
|
|
|
|
|
|
|
|
|
|
namespace Magnum { namespace Math {
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
@brief Four-component vector
|
|
|
|
|
@tparam T Data type
|
|
|
|
|
|
|
|
|
|
See @ref matrix-vector for brief introduction. See also Point3D for
|
|
|
|
|
homogeneous three-dimensional coordinates.
|
|
|
|
|
@see Magnum::Vector4, Magnum::Vector4i, Magnum::Vector4ui
|
|
|
|
|
@configurationvalueref{Magnum::Math::Vector4}
|
|
|
|
|
*/
|
|
|
|
|
template<class T> class Vector4: public Vector<4, T> {
|
|
|
|
|
public:
|
|
|
|
|
/** @copydoc Vector::Vector() */
|
|
|
|
|
inline constexpr /*implicit*/ Vector4() {}
|
|
|
|
|
|
|
|
|
|
/** @copydoc Vector::Vector(T) */
|
|
|
|
|
inline constexpr explicit Vector4(T value): Vector<4, T>(value) {}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @brief Constructor
|
|
|
|
|
*
|
|
|
|
|
* @f[
|
|
|
|
|
* \boldsymbol v = (x, y, z, w)^T
|
|
|
|
|
* @f]
|
|
|
|
|
*/
|
|
|
|
|
inline constexpr /*implicit*/ Vector4(T x, T y, T z, T w): Vector<4, T>(x, y, z, w) {}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @brief Constructor
|
|
|
|
|
*
|
|
|
|
|
* @f[
|
|
|
|
|
* \boldsymbol v = (v_x, v_y, v_z, w)^T
|
|
|
|
|
* @f]
|
|
|
|
|
*/
|
|
|
|
|
inline constexpr /*implicit*/ Vector4(const Vector3<T>& xyz, T w): Vector<4, T>(xyz[0], xyz[1], xyz[2], w) {}
|
|
|
|
|
|
|
|
|
|
/** @copydoc Vector::Vector(const Vector<size, U>&) */
|
|
|
|
|
template<class U> inline constexpr explicit Vector4(const Vector<4, U>& other): Vector<4, T>(other) {}
|
|
|
|
|
|
|
|
|
|
/** @brief Copy constructor */
|
Math: matrix/vector rework, part 2: matrix as array of column vectors.
Overall architecture is simplififed with this change and also it's not
needed to use reinterpret_cast in matrix internals anymore, thus there
is no need for operator() and [][] works now always as expected without
any risk of GCC misoptimizations.
On the other side, constructing matrix from list of elements is not
possible anymore. You have to specify the elements as list of
column vectors, which might be less convenient to write, but it helps to
distinguish what is column and what is row:
Matrix<2, int> a(1, 2, // before
3, 4);
Matrix<2, int> a(Vector<2, int>(1, 2), // now
Vector<2, int>(3, 4));
For some matrix specializations (i.e. Matrix3 and Matrix4) it is
possible to use list-initialization instead of explicit type
specification:
Matrix<3, int>({1, 2, 3},
{4, 5, 6},
{7, 8, 9});
I didn't yet figure out how to properly implement the general
(constexpr) constructor to also take lists, so it's a bit ugly for now.
Matrix operations are now done column-wise, which should help with
future SIMD implementations, documentation is also updated accordingly.
I also removed forgotten remains of matrix/matrix operator*=(), which
can be confusing, as the multiplication is not commutative. Why it is
not present is explained in d9c900f076f2f87c7b7ba3f37a3179c0c0e4a02c.
13 years ago
|
|
|
inline constexpr Vector4(const Vector<4, T>& other): Vector<4, T>(other) {}
|
|
|
|
|
|
|
|
|
|
inline T& x() { return (*this)[0]; } /**< @brief X component */
|
|
|
|
|
inline constexpr T x() const { return (*this)[0]; } /**< @overload */
|
|
|
|
|
inline T& y() { return (*this)[1]; } /**< @brief Y component */
|
|
|
|
|
inline constexpr T y() const { return (*this)[1]; } /**< @overload */
|
|
|
|
|
inline T& z() { return (*this)[2]; } /**< @brief Z component */
|
|
|
|
|
inline constexpr T z() const { return (*this)[2]; } /**< @overload */
|
|
|
|
|
inline T& w() { return (*this)[3]; } /**< @brief W component */
|
|
|
|
|
inline constexpr T w() const { return (*this)[3]; } /**< @overload */
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @brief XYZ part of the vector
|
|
|
|
|
* @return First three components of the vector
|
|
|
|
|
*
|
|
|
|
|
* @see swizzle()
|
|
|
|
|
*/
|
|
|
|
|
inline Vector3<T>& xyz() { return Vector3<T>::from(Vector<4, T>::data()); }
|
|
|
|
|
inline constexpr Vector3<T> xyz() const { return Vector3<T>::from(Vector<4, T>::data()); } /**< @overload */
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @brief XY part of the vector
|
|
|
|
|
* @return First two components of the vector
|
|
|
|
|
*
|
|
|
|
|
* @see swizzle()
|
|
|
|
|
*/
|
|
|
|
|
inline Vector2<T>& xy() { return Vector2<T>::from(Vector<4, T>::data()); }
|
|
|
|
|
inline constexpr Vector2<T> xy() const { return Vector2<T>::from(Vector<4, T>::data()); } /**< @overload */
|
|
|
|
|
|
|
|
|
|
MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(Vector4, 4)
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
MAGNUM_VECTOR_SUBCLASS_OPERATOR_IMPLEMENTATION(Vector4, 4)
|
|
|
|
|
|
|
|
|
|
/** @debugoperator{Magnum::Math::Vector4} */
|
|
|
|
|
template<class T> inline Corrade::Utility::Debug operator<<(Corrade::Utility::Debug debug, const Vector4<T>& value) {
|
|
|
|
|
return debug << static_cast<const Vector<4, T>&>(value);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}}
|
|
|
|
|
|
|
|
|
|
namespace Corrade { namespace Utility {
|
|
|
|
|
/** @configurationvalue{Magnum::Math::Vector4} */
|
|
|
|
|
template<class T> struct ConfigurationValue<Magnum::Math::Vector4<T>>: public ConfigurationValue<Magnum::Math::Vector<4, T>> {};
|
|
|
|
|
}}
|
|
|
|
|
|
|
|
|
|
#endif
|
