Magnum/Magnum.h file

Forward declarations and basic types for the Magnum namespace.

Namespaces

namespace Magnum
Root namespace.
namespace Magnum::Math
Math library.

Defines

#define MAGNUM_BUILD_DEPRECATED
Build with deprecated API included.
#define MAGNUM_BUILD_STATIC
Static library build.
#define MAGNUM_BUILD_MULTITHREADED
Multi-threaded build.
#define MAGNUM_TARGET_GL
OpenGL interoperability.
#define MAGNUM_TARGET_GLES
OpenGL ES target.
#define MAGNUM_TARGET_GLES2
OpenGL ES 2.0 target.
#define MAGNUM_TARGET_GLES3
OpenGL ES 3.0 target.
#define MAGNUM_TARGET_DESKTOP_GLES
Desktop emulation of OpenGL ES target.
#define MAGNUM_TARGET_WEBGL
WebGL target.
#define MAGNUM_TARGET_HEADLESS
Headless target.
#define MAGNUM_TARGET_VK
Vulkan interoperability.

Basic type definitions

See Type system for more information.

using UnsignedByte = std::uint8_t
Unsigned byte (8bit)
using Byte = std::int8_t
Signed byte (8bit)
using UnsignedShort = std::uint16_t
Unsigned short (16bit)
using Short = std::int16_t
Signed short (16bit)
using UnsignedInt = std::uint32_t
Unsigned int (32bit)
using Int = std::int32_t
Signed int (32bit)
using UnsignedLong = std::uint64_t
Unsigned long (64bit)
using Long = std::int64_t
Signed long (64bit)
using Float = float
Float (32bit)
using Half = Math::Half
Half (16bit)
using Vector2 = Math::Vector2<Float>
Two-component float vector.
using Vector3 = Math::Vector3<Float>
Three-component float vector.
using Vector4 = Math::Vector4<Float>
Four-component float vector.
using Vector2ui = Math::Vector2<UnsignedInt>
Two-component unsigned integer vector.
using Vector3ui = Math::Vector3<UnsignedInt>
Three-component unsigned integer vector.
using Vector4ui = Math::Vector4<UnsignedInt>
Four-component unsigned integer vector.
using Vector2i = Math::Vector2<Int>
Two-component signed integer vector.
using Vector3i = Math::Vector3<Int>
Three-component signed integer vector.
using Vector4i = Math::Vector4<Int>
Four-component signed integer vector.
using Color3 = Math::Color3<Float>
Three-component (RGB) float color.
using Color4 = Math::Color4<Float>
Four-component (RGBA) float color.
using Color3ub = Math::Color3<UnsignedByte>
Three-component (RGB) unsigned byte color.
using Color4ub = Math::Color4<UnsignedByte>
Four-component (RGBA) unsigned byte color.
using Matrix3 = Math::Matrix3<Float>
3x3 float transformation matrix
using Matrix4 = Math::Matrix4<Float>
4x4 float transformation matrix
using Matrix2x2 = Math::Matrix2x2<Float>
2x2 float matrix
using Matrix3x3 = Math::Matrix3x3<Float>
3x3 float matrix
using Matrix4x4 = Math::Matrix4x4<Float>
4x4 float matrix
using Matrix2x3 = Math::Matrix2x3<Float>
Float matrix with 2 columns and 3 rows.
using Matrix3x2 = Math::Matrix3x2<Float>
Float matrix with 3 columns and 2 rows.
using Matrix2x4 = Math::Matrix2x4<Float>
Float matrix with 2 columns and 4 rows.
using Matrix4x2 = Math::Matrix4x2<Float>
Float matrix with 4 columns and 2 rows.
using Matrix3x4 = Math::Matrix3x4<Float>
Float matrix with 3 columns and 4 rows.
using Matrix4x3 = Math::Matrix4x3<Float>
Float matrix with 4 columns and 3 rows.
using QuadraticBezier2D = Math::QuadraticBezier2D<Float>
Float two-dimensional quadratic Bézier curve.
using QuadraticBezier3D = Math::QuadraticBezier3D<Float>
Float three-dimensional quadratic Bézier curve.
using CubicBezier2D = Math::CubicBezier2D<Float>
Float two-dimensional cubic Bézier curve.
using CubicBezier3D = Math::CubicBezier3D<Float>
Float three-dimensional cubic Bézier curve.
using CubicHermite1D = Math::CubicHermite1D<Float>
Float scalar cubic Hermite spline point.
using CubicHermite2D = Math::CubicHermite2D<Float>
Float two-dimensional cubic Hermite spline point.
using CubicHermite3D = Math::CubicHermite3D<Float>
Float three-dimensional cubic Hermite spline point.
using CubicHermiteComplex = Math::CubicHermiteComplex<Float>
Float cubic Hermite spline complex number.
using CubicHermiteQuaternion = Math::CubicHermiteQuaternion<Float>
Float cubic Hermite spline quaternion.
using Complex = Math::Complex<Float>
Float complex number.
using DualComplex = Math::DualComplex<Float>
Float dual complex number.
using Quaternion = Math::Quaternion<Float>
Float quaternion.
using DualQuaternion = Math::DualQuaternion<Float>
Float dual quaternion.
using Constants = Math::Constants<Float>
Float constants.
using Deg = Math::Deg<Float>
Angle in float degrees.
using Rad = Math::Rad<Float>
Angle in float radians.
using Range1D = Math::Range1D<Float>
Float 1D range.
using Range2D = Math::Range2D<Float>
Float 2D range.
using Range3D = Math::Range3D<Float>
Float 3D range.
using Range1Di = Math::Range1D<Int>
Signed integer 1D range.
using Range2Di = Math::Range2D<Int>
Signed integer 2D range.
using Range3Di = Math::Range3D<Int>
Signed integer 3D range.
using Frustum = Math::Frustum<Float>
Float frustum.

Double-precision types

See Type system for more information.

using Double = double
Double (64bit)
using Vector2d = Math::Vector2<Double>
Two-component double vector.
using Vector3d = Math::Vector3<Double>
Three-component double vector.
using Vector4d = Math::Vector4<Double>
Four-component double vector.
using Matrix3d = Math::Matrix3<Double>
3x3 double transformation matrix
using Matrix4d = Math::Matrix4<Double>
4x4 double transformation matrix
using Matrix2x2d = Math::Matrix2x2<Double>
2x2 double matrix
using Matrix3x3d = Math::Matrix3x3<Double>
3x3 double matrix
using Matrix4x4d = Math::Matrix4x4<Double>
4x4 double matrix
using Matrix2x3d = Math::Matrix2x3<Double>
Double matrix with 2 columns and 3 rows.
using Matrix3x2d = Math::Matrix3x2<Double>
Double matrix with 3 columns and 2 rows.
using Matrix2x4d = Math::Matrix2x4<Double>
Double matrix with 2 columns and 4 rows.
using Matrix4x2d = Math::Matrix4x2<Double>
Double matrix with 4 columns and 2 rows.
using Matrix3x4d = Math::Matrix3x4<Double>
Double matrix with 3 columns and 4 rows.
using Matrix4x3d = Math::Matrix4x3<Double>
Double matrix with 4 columns and 3 rows.
using QuadraticBezier2Dd = Math::QuadraticBezier2D<Float>
Double two-dimensional quadratic Bézier curve.
using QuadraticBezier3Dd = Math::QuadraticBezier3D<Float>
Double three-dimensional quadratic Bézier curve.
using CubicBezier2Dd = Math::CubicBezier2D<Float>
Double two-dimensional cubic Bézier curve.
using CubicBezier3Dd = Math::CubicBezier3D<Float>
Double three-dimensional cubic Bézier curve.
using CubicHermite1Dd = Math::CubicHermite1D<Double>
Double scalar cubic Hermite spline point.
using CubicHermite2Dd = Math::CubicHermite2D<Double>
Double two-dimensional cubic Hermite spline point.
using CubicHermite3Dd = Math::CubicHermite3D<Double>
Double three-dimensional cubic Hermite spline point.
using CubicHermiteComplexd = Math::CubicHermiteComplex<Double>
Double cubic Hermite spline complex number.
using CubicHermiteQuaterniond = Math::CubicHermiteQuaternion<Double>
Double cubic Hermite spline quaternion.
using Complexd = Math::Complex<Double>
Double complex number.
using DualComplexd = Math::DualComplex<Double>
Double dual complex number.
using Quaterniond = Math::Quaternion<Double>
Double quaternion.
using DualQuaterniond = Math::DualQuaternion<Double>
Double dual quaternion.
using Constantsd = Math::Constants<Double>
Double constants.
using Degd = Math::Deg<Double>
Angle in double degrees.
using Radd = Math::Rad<Double>
Angle in double radians.
using Range1Dd = Math::Range1D<Double>
Double 1D range.
using Range2Dd = Math::Range2D<Double>
Double 2D range.
using Range3Dd = Math::Range3D<Double>
Double 3D range.
using Frustumd = Math::Frustum<Double>
Double frustum.

Define documentation

#define MAGNUM_BUILD_DEPRECATED

Build with deprecated API included.

Defined if the library contains deprecated API (which will be removed in the future). To preserve backward compatibility, Magnum is by default built with deprecated API included.

#define MAGNUM_BUILD_STATIC

Static library build.

Defined if built as static libraries. Default are shared libraries.

#define MAGNUM_BUILD_MULTITHREADED

Multi-threaded build.

Defined if the library is built in a way that allows multiple thread-local Magnum contexts. Enabled by default.

#define MAGNUM_TARGET_GL

OpenGL interoperability.

Defined if the engine is built with OpenGL interoperability enabled — extra APIs in various libraries interacting with the GL library. Enabled by default in case the GL library is built.

#define MAGNUM_TARGET_GLES

OpenGL ES target.

Defined if the engine is built for OpenGL ES 3.0 or OpenGL ES 2.0.

#define MAGNUM_TARGET_GLES2

OpenGL ES 2.0 target.

Defined if the engine is built for OpenGL ES 2.0. Implies also MAGNUM_TARGET_GLES.

#define MAGNUM_TARGET_GLES3

OpenGL ES 3.0 target.

Defined if the engine is built for OpenGL ES 3.0. Implies also MAGNUM_TARGET_GLES.

#define MAGNUM_TARGET_DESKTOP_GLES

Desktop emulation of OpenGL ES target.

Defined if the engine is built for OpenGL ES 3.0 or OpenGL ES 2.0 emulated within standard desktop OpenGL. Implies also MAGNUM_TARGET_GLES.

#define MAGNUM_TARGET_WEBGL

WebGL target.

Defined if the engine is built for WebGL (using Emscripten). WebGL is nearly equivalent to OpenGL ES 2.0, thus in most cases you don't need to treat it differently, but there are some specific restrictions and features which you might want to be aware of. Implies also MAGNUM_TARGET_GLES and MAGNUM_TARGET_GLES2.

#define MAGNUM_TARGET_HEADLESS

Headless target.

Defined if the engine is built for use on a headless machine (without any graphical desktop environment). Basically it means that EGL with no display attachment is being used everywhere instead of platform-specific toolkits like CGL, GLX or WGL. Note that this might not be supported on all platforms, see Platform::WindowlessEglApplication for more information.

#define MAGNUM_TARGET_VK

Vulkan interoperability.

Defined if the engine is built with Vulkan interoperability enabled — extra APIs in various libraries interacting with the Vk library. Enabled by default in case the Vk library is built.