file
Magnum.hForward declarations for the Magnum namespace.
Contents
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
 Multithreaded 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>
 Twocomponent float vector.
 using Vector3 = Math::Vector3<Float>
 Threecomponent float vector.
 using Vector4 = Math::Vector4<Float>
 Fourcomponent float vector.
 using Vector2ui = Math::Vector2<UnsignedInt>
 Twocomponent unsigned integer vector.
 using Vector3ui = Math::Vector3<UnsignedInt>
 Threecomponent unsigned integer vector.
 using Vector4ui = Math::Vector4<UnsignedInt>
 Fourcomponent unsigned integer vector.
 using Vector2i = Math::Vector2<Int>
 Twocomponent signed integer vector.
 using Vector3i = Math::Vector3<Int>
 Threecomponent signed integer vector.
 using Vector4i = Math::Vector4<Int>
 Fourcomponent signed integer vector.
 using Color3 = Math::Color3<Float>
 Threecomponent (RGB) float color.
 using Color4 = Math::Color4<Float>
 Fourcomponent (RGBA) float color.
 using Color3ub = Math::Color3<UnsignedByte>
 Threecomponent (RGB) unsigned byte color.
 using Color4ub = Math::Color4<UnsignedByte>
 Fourcomponent (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 twodimensional quadratic Bézier curve.
 using QuadraticBezier3D = Math::QuadraticBezier3D<Float>
 Float threedimensional quadratic Bézier curve.
 using CubicBezier2D = Math::CubicBezier2D<Float>
 Float twodimensional cubic Bézier curve.
 using CubicBezier3D = Math::CubicBezier3D<Float>
 Float threedimensional cubic Bézier curve.
 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.
Doubleprecision types
See Type system for more information.
 using Double = double
 Double (64bit)
 using Vector2d = Math::Vector2<Double>
 Twocomponent double vector.
 using Vector3d = Math::Vector3<Double>
 Threecomponent double vector.
 using Vector4d = Math::Vector4<Double>
 Fourcomponent 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 twodimensional quadratic Bézier curve.
 using QuadraticBezier3Dd = Math::QuadraticBezier3D<Float>
 Double threedimensional quadratic Bézier curve.
 using CubicBezier2Dd = Math::CubicBezier2D<Float>
 Double twodimensional cubic Bézier curve.
 using CubicBezier3Dd = Math::CubicBezier3D<Float>
 Double threedimensional cubic Bézier curve.
 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
Multithreaded build.
Defined if the library is built in a way that allows multiple threadlocal 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_
#define MAGNUM_TARGET_GLES3
OpenGL ES 3.0 target.
Defined if the engine is built for OpenGL ES 3.0. Implies also MAGNUM_
#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_
#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_
#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 platformspecific toolkits like CGL, GLX or WGL. Note that this might not be supported on all platforms, see Platform::
#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.