mirror of https://github.com/mosra/magnum.git
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.
470 lines
20 KiB
470 lines
20 KiB
/* |
|
Magnum::Math |
|
— a graphics-focused vector math library |
|
|
|
https://doc.magnum.graphics/magnum/namespaceMagnum_1_1Math.html |
|
https://doc.magnum.graphics/magnum/namespaceMagnum_1_1EigenIntegration.html |
|
https://doc.magnum.graphics/magnum/namespaceMagnum_1_1GlmIntegration.html |
|
|
|
Depends on CorradePair.h. |
|
|
|
This is a single-header library generated from the Magnum project. With the |
|
goal being easy integration, it's deliberately free of all comments to keep |
|
the file size small. More info, changelogs and full docs here: |
|
|
|
- Project homepage — https://magnum.graphics/magnum/ |
|
- Documentation — https://doc.magnum.graphics/ |
|
- GitHub project page — https://github.com/mosra/magnum |
|
- GitHub Singles repository — https://github.com/mosra/magnum-singles |
|
|
|
The library has a separate non-inline implementation part, enable it *just |
|
once* like this: |
|
|
|
#define MAGNUM_MATH_IMPLEMENTATION |
|
#include <MagnumMath.hpp> |
|
|
|
If you need the deinlined symbols to be exported from a shared library, |
|
`#define MAGNUM_EXPORT` as appropriate. The STL compatibility bits for time |
|
types are included as well --- opt-in with |
|
`#define MAGNUM_MATH_STL_COMPATIBILITY` before including the file. Contents |
|
of the GlmIntegration and EigenIntegration libraries can be opted in by |
|
specifying either `#define MAGNUM_MATH_GLM_INTEGRATION` or |
|
`#define MAGNUM_MATH_EIGEN_INTEGRATION` before including the file. |
|
Including it multiple times with different macros defined works as well. |
|
|
|
v2020.06-3290-g454e9 (2025-04-11) |
|
- New Color4::premultiplied() and unpremultiplied() APIs |
|
- Include guard for the implementation part to prevent double definitions |
|
- Cleanup and unification of SFINAE code, it's now done in template args |
|
as that's simpler for the compiler |
|
v2020.06-3125-g632a2 (2025-01-07) |
|
- New Nanoseconds and Seconds types along with _nsec, _usec, _msec and |
|
_sec literals and opt-in std::chrono compatibility |
|
- Literals are now in inline AngleLiterals, ColorLiterals, HalfLiterals |
|
and TimeLiterals subnamespaces to allow for more fine-grained inclusion |
|
- Most const Vector APIs are now constexpr as well |
|
- The _rgbf and _rgbaf literals are now constexpr |
|
- Vector and [Rectangular]Matrix instances can are now constexpr |
|
constructible directly from plain C arrays of matching sizes |
|
- Added Quaternion::rotation() from two vectors |
|
- Added Quaternion::xyzw() and wxyz() for conversion to a Vector4 |
|
- Bezier APIs now use the leaf Vector2 / Vector3 types instead of the |
|
base Vector type |
|
- New Matrix2x1, Matrix3x1, Matrix4x1, Matrix2x1d, Matrix3x1d and |
|
Matrix4x1d typedefs for single-row matrices |
|
- Removed dependency on <utility> in favor of CorradePair.h, which |
|
reduces the preprocessed size by about 500 lines, and enables constexpr |
|
usage in various new places |
|
- Updated Eigen integration to work with MSVC 2022 17.10+ |
|
v2020.06-2544-g3e435 (2023-09-11) |
|
- Fixes to the Utility::swap() helper to avoid ambiguity with std::swap() |
|
v2020.06-2502-gfa079385b (2023-08-28) |
|
- New Range1Dui, Range2Dui, Range3Dui, Degh, Radh, Range1Dh, Range2Dh and |
|
Range3Dh typedefs |
|
- New binomialCoefficient(), popcount() and fmod() APIs |
|
- Added r() and g() accessors to Vector2 and rg() to Vector3 |
|
- New Color3::fromLinearRgbInt(), toLinearRgbInt() and |
|
Color4::fromLinearRgbaInt(), toLinearRgbaInt() for converting a color |
|
from/to a packed 24-/32-bit representation without a sRGB conversion; |
|
integer-taking fromSrgb() and fromSrgbAlpha() is now renamed to |
|
fromSrgbInt() and fromSrgbAlphaInt() for consistency |
|
- Added an off-center Matrix3::projection() and |
|
Matrix4::orthographicProjection() overloads |
|
- New Matrix4::orthographicProjectionNear(), orthographicProjectionFar(), |
|
perspectiveProjectionNear(), perspectiveProjectionFar() accessors |
|
- Added Quaternion::reflection() and reflectVector() APIs which perform |
|
a reflection with a quaternion instead of a rotation |
|
- Ability to create a DualQuaternion from a rotation quaternion and a |
|
translation vector |
|
- angle() for Quaternion is now called halfAngle() because that's what it |
|
returns, angle() will be eventually reintroduced again but returning |
|
the correct value |
|
- Convenience Distance::pointPoint() and pointPointSquared(), |
|
Intersection::pointCircle() and pointSphere() APIs as a more |
|
self-documenting way of using (a - b).length() or dot() |
|
- New Intersection::rayRange() API |
|
- Conversion between Eigen::AlignedBox and Range |
|
- Added unary operator+ to all math classes |
|
- Matrices can now created from matrices of different sizes with a custom |
|
value on new diagonal elements |
|
- data() accessors of all classes now return sized array references |
|
instead of pointers |
|
- Fixed Matrix4::normalMatrix() to behave correctly in presence of a |
|
reflection |
|
- BoolVector is renamed to BitVector and has new set() and reset() APIs |
|
- 64-bit integers and long doubles are no longer compiled away on |
|
Emscripten |
|
- Fixed QuadraticBezier2Dd, QuadraticBezier3Dd, CubicBezier2Dd and |
|
CubicBezier3Dd typedefs to be actually doubles |
|
- Compatibility with C++20 which removes the <ciso646> header |
|
v2020.06-0-gfac6f4da2 (2020-06-27) |
|
- Various fixes for Clang-CL compatibility |
|
- Expanding the APIs to work with Half and long double types |
|
- Magnum::Math::NoInit is now Magnum::NoInit |
|
- Minor changes for faster performance of dot() and cross() in Debug |
|
- Added reflect() and refract() functions |
|
- slerp() / slerpShortestPath() falls back to linear interpolation for |
|
quaternions that are close together, instead or always returning the |
|
first |
|
- Added Quaternion::toEuler() |
|
- Added transformVector() to DualComplex and DualQuaternion to have the |
|
the same set of APIs as with Matrix3 / Matrix4 |
|
- Mutable access to Frustum planes |
|
- Fixed implicit conversion of std::pair to Range*D |
|
- New BoolVector[234], 8-/16-bit and half-float vector and matrix |
|
convenience typedefs |
|
v2019.10-0-g8412e8f99 (2019-10-24) |
|
- New IsScalar, IsVector, IsIntegral, IsFloatingPoint type traits, |
|
correct handling of Deg and Rad types in all APIs |
|
- Guaranteed NaN handling semantic in min()/max()/minmax() APIs |
|
- Using a GCC compiler builtin in sincos() |
|
- swizzle() is replaced with gather() and scatter() |
|
- Added Matrix::{cofactor,comatrix,adjugate}(), Matrix4::normalMatrix() |
|
- New Matrix4::perspectiveProjection() overload taking corner positions |
|
- Handling also Eigen::Ref types; EigenIntegration::eigenCast() is now |
|
just EigenIntegration::cast() |
|
v2019.01-241-g93686746a (2019-04-03) |
|
- Initial release |
|
|
|
Generated from Corrade {{revision:corrade/src}}, |
|
Magnum {{revision:magnum/src}} and |
|
Magnum Integration {{revision:magnum-integration/src}}, {{stats:loc}} / {{stats:preprocessed}} LoC |
|
*/ |
|
|
|
#include "base.h" |
|
// {{includes}} |
|
|
|
#if (!defined(CORRADE_ASSERT) || !defined(CORRADE_CONSTEXPR_ASSERT) || !defined(CORRADE_INTERNAL_ASSERT_OUTPUT) || !defined(CORRADE_INTERNAL_ASSERT_UNREACHABLE)) && !defined(NDEBUG) |
|
#include <cassert> |
|
#endif |
|
|
|
/* Combined copyrights because the tool isn't able to merge those on its own: |
|
|
|
Copyright © 2016, 2018, 2020 Jonathan Hale <squareys@googlemail.com> |
|
|
|
*/ |
|
|
|
/* We're taking stuff from integration as well */ |
|
#pragma ACME path ../../../magnum-integration/src |
|
#pragma ACME revision magnum-integration/src echo "$(git describe --long --match 'v*' --abbrev=4) ($(date -d @$(git log -1 --format=%at) +%Y-%m-%d))" |
|
|
|
/* CORRADE_DEBUG_ASSERT, CORRADE_CONSTEXPR_DEBUG_ASSERT, |
|
CORRADE_INTERNAL_DEBUG_ASSERT_OUTPUT and |
|
CORRADE_INTERNAL_DEBUG_ASSERT_UNREACHABLE are used, wrapping the #include |
|
<cassert> above. When enabling additional asserts, be sure to update them |
|
above as well-- without the _DEBUG variants, as they just delegate to the |
|
non-debug version of the macro. */ |
|
#include "singles/assert.h" |
|
#pragma ACME forget CORRADE_ASSERT |
|
#pragma ACME forget CORRADE_DEBUG_ASSERT |
|
#pragma ACME forget CORRADE_CONSTEXPR_ASSERT |
|
#pragma ACME forget CORRADE_CONSTEXPR_DEBUG_ASSERT |
|
#pragma ACME forget CORRADE_INTERNAL_ASSERT_OUTPUT |
|
#pragma ACME forget CORRADE_INTERNAL_DEBUG_ASSERT_OUTPUT |
|
#pragma ACME forget CORRADE_INTERNAL_ASSERT_UNREACHABLE |
|
#pragma ACME forget CORRADE_INTERNAL_DEBUG_ASSERT_UNREACHABLE |
|
|
|
/* Disable strict weak ordering helpers as they're non-essential. The |
|
StrictWeakOrdering.h header isn't included either. */ |
|
#pragma ACME enable MAGNUM_NO_MATH_STRICT_WEAK_ORDERING |
|
|
|
/* We don't need everything from configure.h here */ |
|
#pragma ACME enable Corrade_configure_h |
|
#pragma ACME enable Magnum_configure_h |
|
#if defined(_MSC_VER) && _MSC_VER < 1920 |
|
#define CORRADE_MSVC2017_COMPATIBILITY |
|
#endif |
|
#if defined(_MSC_VER) && _MSC_VER < 1910 |
|
#define CORRADE_MSVC2015_COMPATIBILITY |
|
#endif |
|
#ifdef _WIN32 |
|
#define CORRADE_TARGET_WINDOWS |
|
#endif |
|
#ifdef __EMSCRIPTEN__ |
|
#define CORRADE_TARGET_EMSCRIPTEN |
|
#endif |
|
#ifdef __ANDROID__ |
|
#define CORRADE_TARGET_ANDROID |
|
#endif |
|
|
|
#ifdef __GNUC__ |
|
#define CORRADE_TARGET_GCC |
|
#endif |
|
#ifdef __clang__ |
|
#define CORRADE_TARGET_CLANG |
|
#endif |
|
#if defined(__clang__) && defined(_MSC_VER) |
|
#define CORRADE_TARGET_CLANG_CL |
|
#endif |
|
#ifdef _MSC_VER |
|
#define CORRADE_TARGET_MSVC |
|
#endif |
|
/* Needed by TypeTraits::equal() */ |
|
#if defined(CORRADE_TARGET_MSVC) || (defined(CORRADE_TARGET_ANDROID) && !__LP64__) || defined(CORRADE_TARGET_EMSCRIPTEN) || (defined(CORRADE_TARGET_APPLE) && !defined(CORRADE_TARGET_IOS) && defined(CORRADE_TARGET_ARM)) |
|
#define CORRADE_LONG_DOUBLE_SAME_AS_DOUBLE |
|
#endif |
|
|
|
/* Our own subset of visibility macros */ |
|
#pragma ACME enable Magnum_visibility_h |
|
#pragma ACME enable Corrade_Utility_VisibilityMacros_h |
|
#ifndef MAGNUM_EXPORT |
|
#define MAGNUM_EXPORT |
|
#endif |
|
|
|
/* CorradePair.h is a dependency */ |
|
#pragma ACME noexpand CorradePair.h |
|
#pragma ACME enable Corrade_Containers_Pair_h |
|
#include "CorradePair.h" |
|
|
|
/* A semi-verbatim copy of Utility/StlMath.h because otherwise the includes |
|
don't stay in the correct place. */ |
|
#ifndef Corrade_Utility_StlMath_h |
|
#define Corrade_Utility_StlMath_h |
|
#ifdef _GLIBCXX_USE_STD_SPEC_FUNCS |
|
#undef _GLIBCXX_USE_STD_SPEC_FUNCS |
|
#define _GLIBCXX_USE_STD_SPEC_FUNCS 0 |
|
#endif |
|
#include <cmath> |
|
#endif |
|
#pragma ACME enable Corrade_Utility_StlMath_h |
|
/* Our own subset of Containers.h and Magnum.h, need just CORRADE_HAS_TYPE from |
|
Utility/TypeTraits.h */ |
|
#pragma ACME enable Corrade_Containers_Containers_h |
|
#pragma ACME enable Corrade_Utility_TypeTraits_h |
|
#pragma ACME enable Magnum_Magnum_h |
|
#include "Magnum/Math/Math.h" |
|
#ifndef MagnumMath_hpp |
|
#define MagnumMath_hpp |
|
|
|
#define CORRADE_HAS_TYPE(className, ...) \ |
|
template<class U> class className { \ |
|
template<class T> static char get(T&&, __VA_ARGS__* = nullptr); \ |
|
static short get(...); \ |
|
public: \ |
|
enum: bool { value = sizeof(get(std::declval<U>())) == sizeof(char) }; \ |
|
} |
|
|
|
namespace Magnum { |
|
|
|
using namespace Corrade; |
|
|
|
typedef Math::Half Half; |
|
typedef Math::BitVector<2> BitVector2; |
|
typedef Math::BitVector<3> BitVector3; |
|
typedef Math::BitVector<4> BitVector4; |
|
typedef Math::Vector2<Float> Vector2; |
|
typedef Math::Vector3<Float> Vector3; |
|
typedef Math::Vector4<Float> Vector4; |
|
typedef Math::Vector2<UnsignedByte> Vector2ub; |
|
typedef Math::Vector3<UnsignedByte> Vector3ub; |
|
typedef Math::Vector4<UnsignedByte> Vector4ub; |
|
typedef Math::Vector2<Byte> Vector2b; |
|
typedef Math::Vector3<Byte> Vector3b; |
|
typedef Math::Vector4<Byte> Vector4b; |
|
typedef Math::Vector2<UnsignedShort> Vector2us; |
|
typedef Math::Vector3<UnsignedShort> Vector3us; |
|
typedef Math::Vector4<UnsignedShort> Vector4us; |
|
typedef Math::Vector2<Short> Vector2s; |
|
typedef Math::Vector3<Short> Vector3s; |
|
typedef Math::Vector4<Short> Vector4s; |
|
typedef Math::Vector2<UnsignedInt> Vector2ui; |
|
typedef Math::Vector3<UnsignedInt> Vector3ui; |
|
typedef Math::Vector4<UnsignedInt> Vector4ui; |
|
typedef Math::Vector2<Int> Vector2i; |
|
typedef Math::Vector3<Int> Vector3i; |
|
typedef Math::Vector4<Int> Vector4i; |
|
typedef Math::Color3<Float> Color3; |
|
typedef Math::Color4<Float> Color4; |
|
typedef Math::Color3<UnsignedByte> Color3ub; |
|
typedef Math::Color4<UnsignedByte> Color4ub; |
|
typedef Math::Color3<UnsignedShort> Color3us; |
|
typedef Math::Color4<UnsignedShort> Color4us; |
|
typedef Math::Matrix3<Float> Matrix3; |
|
typedef Math::Matrix4<Float> Matrix4; |
|
typedef Math::Matrix2x1<Float> Matrix2x1; |
|
typedef Math::Matrix2x2<Float> Matrix2x2; |
|
typedef Math::Matrix2x3<Float> Matrix2x3; |
|
typedef Math::Matrix2x4<Float> Matrix2x4; |
|
typedef Math::Matrix3x1<Float> Matrix3x1; |
|
typedef Math::Matrix3x2<Float> Matrix3x2; |
|
typedef Math::Matrix3x3<Float> Matrix3x3; |
|
typedef Math::Matrix3x4<Float> Matrix3x4; |
|
typedef Math::Matrix4x1<Float> Matrix4x1; |
|
typedef Math::Matrix4x2<Float> Matrix4x2; |
|
typedef Math::Matrix4x3<Float> Matrix4x3; |
|
typedef Math::Matrix4x4<Float> Matrix4x4; |
|
typedef Math::Matrix2x2<Byte> Matrix2x2b; |
|
typedef Math::Matrix2x3<Byte> Matrix2x3b; |
|
typedef Math::Matrix2x4<Byte> Matrix2x4b; |
|
typedef Math::Matrix3x2<Byte> Matrix3x2b; |
|
typedef Math::Matrix3x3<Byte> Matrix3x3b; |
|
typedef Math::Matrix3x4<Byte> Matrix3x4b; |
|
typedef Math::Matrix4x2<Byte> Matrix4x2b; |
|
typedef Math::Matrix4x3<Byte> Matrix4x3b; |
|
typedef Math::Matrix4x4<Byte> Matrix4x4b; |
|
typedef Math::Matrix2x2<Short> Matrix2x2s; |
|
typedef Math::Matrix2x3<Short> Matrix2x3s; |
|
typedef Math::Matrix2x4<Short> Matrix2x4s; |
|
typedef Math::Matrix3x2<Short> Matrix3x2s; |
|
typedef Math::Matrix3x3<Short> Matrix3x3s; |
|
typedef Math::Matrix3x4<Short> Matrix3x4s; |
|
typedef Math::Matrix4x2<Short> Matrix4x2s; |
|
typedef Math::Matrix4x3<Short> Matrix4x3s; |
|
typedef Math::Matrix4x4<Short> Matrix4x4s; |
|
typedef Math::QuadraticBezier2D<Float> QuadraticBezier2D; |
|
typedef Math::QuadraticBezier3D<Float> QuadraticBezier3D; |
|
typedef Math::CubicBezier2D<Float> CubicBezier2D; |
|
typedef Math::CubicBezier3D<Float> CubicBezier3D; |
|
typedef Math::CubicHermite1D<Float> CubicHermite1D; |
|
typedef Math::CubicHermite2D<Float> CubicHermite2D; |
|
typedef Math::CubicHermite3D<Float> CubicHermite3D; |
|
typedef Math::CubicHermiteComplex<Float> CubicHermiteComplex; |
|
typedef Math::CubicHermiteQuaternion<Float> CubicHermiteQuaternion; |
|
typedef Math::Complex<Float> Complex; |
|
typedef Math::DualComplex<Float> DualComplex; |
|
typedef Math::Quaternion<Float> Quaternion; |
|
typedef Math::DualQuaternion<Float> DualQuaternion; |
|
typedef Math::Constants<Float> Constants; |
|
typedef Math::Deg<Float> Deg; |
|
typedef Math::Rad<Float> Rad; |
|
typedef Math::Range1D<Float> Range1D; |
|
typedef Math::Range2D<Float> Range2D; |
|
typedef Math::Range3D<Float> Range3D; |
|
typedef Math::Range1D<UnsignedInt> Range1Dui; |
|
typedef Math::Range2D<UnsignedInt> Range2Dui; |
|
typedef Math::Range3D<UnsignedInt> Range3Dui; |
|
typedef Math::Range1D<Int> Range1Di; |
|
typedef Math::Range2D<Int> Range2Di; |
|
typedef Math::Range3D<Int> Range3Di; |
|
typedef Math::Frustum<Float> Frustum; |
|
typedef Math::Nanoseconds<Long> Nanoseconds; |
|
typedef Math::Seconds<Float> Seconds; |
|
typedef Math::Vector2<Half> Vector2h; |
|
typedef Math::Vector3<Half> Vector3h; |
|
typedef Math::Vector4<Half> Vector4h; |
|
typedef Math::Color3<Half> Color3h; |
|
typedef Math::Color4<Half> Color4h; |
|
typedef Math::Matrix2x2<Half> Matrix2x2h; |
|
typedef Math::Matrix2x3<Half> Matrix2x3h; |
|
typedef Math::Matrix2x4<Half> Matrix2x4h; |
|
typedef Math::Matrix3x2<Half> Matrix3x2h; |
|
typedef Math::Matrix3x3<Half> Matrix3x3h; |
|
typedef Math::Matrix3x4<Half> Matrix3x4h; |
|
typedef Math::Matrix4x2<Half> Matrix4x2h; |
|
typedef Math::Matrix4x3<Half> Matrix4x3h; |
|
typedef Math::Matrix4x4<Half> Matrix4x4h; |
|
typedef Math::Deg<Half> Degh; |
|
typedef Math::Rad<Half> Radh; |
|
typedef Math::Range1D<Half> Range1Dh; |
|
typedef Math::Range2D<Half> Range2Dh; |
|
typedef Math::Range3D<Half> Range3Dh; |
|
typedef Math::Vector2<Double> Vector2d; |
|
typedef Math::Vector3<Double> Vector3d; |
|
typedef Math::Vector4<Double> Vector4d; |
|
typedef Math::Matrix3<Double> Matrix3d; |
|
typedef Math::Matrix4<Double> Matrix4d; |
|
typedef Math::Matrix2x1<Double> Matrix2x1d; |
|
typedef Math::Matrix2x2<Double> Matrix2x2d; |
|
typedef Math::Matrix2x3<Double> Matrix2x3d; |
|
typedef Math::Matrix2x4<Double> Matrix2x4d; |
|
typedef Math::Matrix3x1<Double> Matrix3x1d; |
|
typedef Math::Matrix3x2<Double> Matrix3x2d; |
|
typedef Math::Matrix3x3<Double> Matrix3x3d; |
|
typedef Math::Matrix3x4<Double> Matrix3x4d; |
|
typedef Math::Matrix4x1<Double> Matrix4x1d; |
|
typedef Math::Matrix4x2<Double> Matrix4x2d; |
|
typedef Math::Matrix4x3<Double> Matrix4x3d; |
|
typedef Math::Matrix4x4<Double> Matrix4x4d; |
|
typedef Math::QuadraticBezier2D<Double> QuadraticBezier2Dd; |
|
typedef Math::QuadraticBezier3D<Double> QuadraticBezier3Dd; |
|
typedef Math::CubicBezier2D<Double> CubicBezier2Dd; |
|
typedef Math::CubicBezier3D<Double> CubicBezier3Dd; |
|
typedef Math::CubicHermite1D<Double> CubicHermite1Dd; |
|
typedef Math::CubicHermite2D<Double> CubicHermite2Dd; |
|
typedef Math::CubicHermite3D<Double> CubicHermite3Dd; |
|
typedef Math::CubicHermiteComplex<Double> CubicHermiteComplexd; |
|
typedef Math::CubicHermiteQuaternion<Double> CubicHermiteQuaterniond; |
|
typedef Math::Complex<Double> Complexd; |
|
typedef Math::DualComplex<Double> DualComplexd; |
|
typedef Math::Quaternion<Double> Quaterniond; |
|
typedef Math::DualQuaternion<Double> DualQuaterniond; |
|
typedef Math::Constants<Double> Constantsd; |
|
typedef Math::Deg<Double> Degd; |
|
typedef Math::Rad<Double> Radd; |
|
typedef Math::Range1D<Double> Range1Dd; |
|
typedef Math::Range2D<Double> Range2Dd; |
|
typedef Math::Range3D<Double> Range3Dd; |
|
typedef Math::Frustum<Double> Frustumd; |
|
|
|
} |
|
|
|
#endif |
|
#include "Magnum/Magnum.h" |
|
#include "Magnum/Math/Angle.h" |
|
#include "Magnum/Math/Bezier.h" |
|
#include "Magnum/Math/BitVector.h" |
|
#include "Magnum/Math/Color.h" |
|
#include "Magnum/Math/Complex.h" |
|
#include "Magnum/Math/Constants.h" |
|
#include "Magnum/Math/CubicHermite.h" |
|
#include "Magnum/Math/Distance.h" |
|
#include "Magnum/Math/Dual.h" |
|
#include "Magnum/Math/DualComplex.h" |
|
#include "Magnum/Math/DualQuaternion.h" |
|
#include "Magnum/Math/Frustum.h" |
|
#include "Magnum/Math/Functions.h" |
|
#include "Magnum/Math/Half.h" |
|
#include "Magnum/Math/Intersection.h" |
|
#include "Magnum/Math/Matrix.h" |
|
#include "Magnum/Math/Matrix3.h" |
|
#include "Magnum/Math/Matrix4.h" |
|
#include "Magnum/Math/Packing.h" |
|
#include "Magnum/Math/Quaternion.h" |
|
#include "Magnum/Math/Range.h" |
|
#include "Magnum/Math/RectangularMatrix.h" |
|
#include "Magnum/Math/Swizzle.h" |
|
#include "Magnum/Math/Tags.h" |
|
#include "Magnum/Math/Time.h" |
|
#include "Magnum/Math/TypeTraits.h" |
|
#include "Magnum/Math/Unit.h" |
|
#include "Magnum/Math/Vector.h" |
|
#include "Magnum/Math/Vector2.h" |
|
#include "Magnum/Math/Vector3.h" |
|
#include "Magnum/Math/Vector4.h" |
|
#include "Magnum/Math/Algorithms/GaussJordan.h" |
|
#include "Magnum/Math/Algorithms/GramSchmidt.h" |
|
#include "Magnum/Math/Algorithms/KahanSum.h" |
|
#include "Magnum/Math/Algorithms/Qr.h" |
|
//#include "Magnum/Math/Algorithms/Svd.h" // TODO needs Optional and Triple |
|
#ifdef MAGNUM_MATH_STL_COMPATIBILITY |
|
// {{includes}} |
|
#include "Magnum/Math/TimeStl.h" |
|
#endif |
|
#ifdef MAGNUM_MATH_GLM_INTEGRATION |
|
// {{includes}} |
|
#include "Magnum/GlmIntegration/Integration.h" |
|
#include "Magnum/GlmIntegration/GtcIntegration.h" |
|
#include "Magnum/GlmIntegration/GtxIntegration.h" |
|
#endif |
|
#ifdef MAGNUM_MATH_EIGEN_INTEGRATION |
|
// {{includes}} |
|
#include "Magnum/EigenIntegration/Integration.h" |
|
// TODO: DynamicMatrixIntegration (separate library because of StridedArrayView) |
|
#include "Magnum/EigenIntegration/GeometryIntegration.h" |
|
#endif |
|
/* The extra guard has to be here to prevent double definitions in cases like |
|
|
|
#define MAGNUM_MATH_IMPLEMENTATION |
|
#include <MagnumMath.hpp> |
|
#include <MagnumMathBatch.hpp> |
|
|
|
where MagnumMathBatch.hpp contains `#include <MagnumMath.hpp>` again. Note |
|
that even the stb_* libs don't handle this -- including them twice with the |
|
implementation macro defined *will* lead to double definitions. */ |
|
#if defined(MAGNUM_MATH_IMPLEMENTATION) && !defined(MagnumMath_hpp_implementation) |
|
#define MagnumMath_hpp_implementation |
|
// {{ includes }} |
|
#include "Magnum/Math/Functions.cpp" |
|
#include "Magnum/Math/Packing.cpp" |
|
/* Time.cpp is just debug output operators, not included */ |
|
#endif
|
|
|