Magnum namespace
Root namespace.
Base classes and typedefs.
This library is built as part of Magnum by default. To use this library with CMake, find the Magnum
package and link to the Magnum::Magnum
target:
find_package(Magnum REQUIRED) # ... target_link_libraries(your-app PRIVATE Magnum::Magnum)
Parts of this library are additionally available in a form of single-header libraries. See Downloading and building and Usage with CMake for more information.
Namespaces
- namespace Animation
- Keyframe-based animation.
- namespace Audio
- Audio playback.
- namespace BulletIntegration
- Integration with Bullet Physics.
- namespace DartIntegration
- Integration with DART Dynamic Animation and Robotics Toolkit.
- namespace DebugTools
- Debug tools.
- namespace EigenIntegration new in 2019.10
- Integration with Eigen.
- namespace GL
- OpenGL wrapping layer.
- namespace GlmIntegration
- Integration with OpenGL Mathematics (GLM)
- namespace ImGuiIntegration
- Integration with Dear ImGui.
- namespace MaterialTools new in Git master
- Material tools.
- namespace Math
- Math library.
- namespace MeshTools
- Mesh tools.
- namespace OpenDdl
- OpenDDL parser.
- namespace OvrIntegration
- Integration with the Oculus SDK (LibOVR)
- namespace Platform
- Platform-specific application and context creation.
- namespace Primitives
- Primitive library.
- namespace SceneGraph
- Scene graph library.
- namespace SceneTools new in Git master
- Scene tools.
- namespace Shaders
- Builtin shaders.
- namespace ShaderTools new in Git master
- Shader tools.
- namespace Text
- Text rendering.
- namespace TextureTools
- Texture tools.
- namespace Trade
- Data format exchange.
- namespace Ui
- UI library.
- namespace Vk
- Vulkan wrapping layer.
Classes
-
template<class T>class AbstractResourceLoader
- Base for resource loaders.
-
template<UnsignedInt dimensions, class T>class Array deprecated in Git master
- Array.
-
template<class T>class Array1D deprecated in Git master
- One-dimensional array.
-
template<class T>class Array2D deprecated in Git master
- Two-dimensional array.
-
template<class T>class Array3D deprecated in Git master
- Three-dimensional array.
-
template<UnsignedInt dimensions>class CompressedImage
- Compressed image.
-
template<UnsignedInt dimensions, class T>class CompressedImageView
- Compressed image view.
- class CompressedPixelStorage
- Compressed pixel storage parameters.
-
template<UnsignedInt dimensions, class T>struct DimensionTraits
- Matrix and vector specializations for given dimension count.
-
template<UnsignedInt dimensions>class Image
- Image.
-
template<UnsignedInt dimensions, class T>class ImageView
- Image view.
- struct NoAllocateT new in Git master
- No allocation tag type.
- class PixelStorage
- Pixel storage parameters.
-
template<class T, class U = T>class Resource
- Resource reference.
- class ResourceKey
- Key for accessing resource.
-
template<class... Types>class ResourceManager
- Resource manager.
- class Timeline
- Timeline.
Enums
- enum class InputFileCallbackPolicy: UnsignedByte { LoadTemporary, LoadPermanent, LoadPernament = LoadPermanent deprecated in 2019.10, Close } new in 2019.10
- Input file callback policy.
- enum class ImageFlag1D: UnsignedShort { } new in Git master
- 1D image layout flag
- enum class ImageFlag2D: UnsignedShort { Array = 1 << 0 } new in Git master
- 2D image layout flag
- enum class ImageFlag3D: UnsignedShort { Array = 1 << 0, CubeMap = 1 << 1 } new in Git master
- 3D image layout flag
- enum class MeshPrimitive: UnsignedInt { Points = 1, Lines, LineLoop, LineStrip, Triangles, TriangleStrip, TriangleFan, Instances new in 2020.06, Faces new in 2020.06, Edges new in 2020.06, Meshlets new in Git master }
- Mesh primitive type.
- enum class MeshIndexType: UnsignedInt { UnsignedByte = 1, UnsignedShort, UnsignedInt }
- Mesh index type.
- enum class PixelFormat: UnsignedInt { R8Unorm = 1, RG8Unorm, RGB8Unorm, RGBA8Unorm, R8Snorm, RG8Snorm, RGB8Snorm, RGBA8Snorm, R8Srgb new in 2019.10, RG8Srgb new in 2019.10, RGB8Srgb new in 2019.10, RGBA8Srgb new in 2019.10, R8UI, RG8UI, RGB8UI, RGBA8UI, R8I, RG8I, RGB8I, RGBA8I, R16Unorm, RG16Unorm, RGB16Unorm, RGBA16Unorm, R16Snorm, RG16Snorm, RGB16Snorm, RGBA16Snorm, R16UI, RG16UI, RGB16UI, RGBA16UI, R16I, RG16I, RGB16I, RGBA16I, R32UI, RG32UI, RGB32UI, RGBA32UI, R32I, RG32I, RGB32I, RGBA32I, R16F, RG16F, RGB16F, RGBA16F, R32F, RG32F, RGB32F, RGBA32F, Depth16Unorm new in Git master, Depth24Unorm new in Git master, Depth32F new in Git master, Stencil8UI new in Git master, Depth16UnormStencil8UI new in Git master, Depth24UnormStencil8UI new in Git master, Depth32FStencil8UI new in Git master }
- Format of pixel data.
- enum class CompressedPixelFormat: UnsignedInt { Bc1RGBUnorm = 1, Bc1RGBSrgb new in 2019.10, Bc1RGBAUnorm, Bc1RGBASrgb new in 2019.10, Bc2RGBAUnorm, Bc2RGBASrgb new in 2019.10, Bc3RGBAUnorm, Bc3RGBASrgb new in 2019.10, Bc4RUnorm new in 2019.10, Bc4RSnorm new in 2019.10, Bc5RGUnorm new in 2019.10, Bc5RGSnorm new in 2019.10, Bc6hRGBUfloat new in 2019.10, Bc6hRGBSfloat new in 2019.10, Bc7RGBAUnorm new in 2019.10, Bc7RGBASrgb new in 2019.10, EacR11Unorm new in 2019.10, EacR11Snorm new in 2019.10, EacRG11Unorm new in 2019.10, EacRG11Snorm new in 2019.10, Etc2RGB8Unorm new in 2019.10, Etc2RGB8Srgb new in 2019.10, Etc2RGB8A1Unorm new in 2019.10, Etc2RGB8A1Srgb new in 2019.10, Etc2RGBA8Unorm new in 2019.10, Etc2RGBA8Srgb new in 2019.10, Astc4x4RGBAUnorm new in 2019.10, Astc4x4RGBASrgb new in 2019.10, Astc4x4RGBAF new in 2019.10, Astc5x4RGBAUnorm new in 2019.10, Astc5x4RGBASrgb new in 2019.10, Astc5x4RGBAF new in 2019.10, Astc5x5RGBAUnorm new in 2019.10, Astc5x5RGBASrgb new in 2019.10, Astc5x5RGBAF new in 2019.10, Astc6x5RGBAUnorm new in 2019.10, Astc6x5RGBASrgb new in 2019.10, Astc6x5RGBAF new in 2019.10, Astc6x6RGBAUnorm new in 2019.10, Astc6x6RGBASrgb new in 2019.10, Astc6x6RGBAF new in 2019.10, Astc8x5RGBAUnorm new in 2019.10, Astc8x5RGBASrgb new in 2019.10, Astc8x5RGBAF new in 2019.10, Astc8x6RGBAUnorm new in 2019.10, Astc8x6RGBASrgb new in 2019.10, Astc8x6RGBAF new in 2019.10, Astc8x8RGBAUnorm new in 2019.10, Astc8x8RGBASrgb new in 2019.10, Astc8x8RGBAF new in 2019.10, Astc10x5RGBAUnorm new in 2019.10, Astc10x5RGBASrgb new in 2019.10, Astc10x5RGBAF new in 2019.10, Astc10x6RGBAUnorm new in 2019.10, Astc10x6RGBASrgb new in 2019.10, Astc10x6RGBAF new in 2019.10, Astc10x8RGBAUnorm new in 2019.10, Astc10x8RGBASrgb new in 2019.10, Astc10x8RGBAF new in 2019.10, Astc10x10RGBAUnorm new in 2019.10, Astc10x10RGBASrgb new in 2019.10, Astc10x10RGBAF new in 2019.10, Astc12x10RGBAUnorm new in 2019.10, Astc12x10RGBASrgb new in 2019.10, Astc12x10RGBAF new in 2019.10, Astc12x12RGBAUnorm new in 2019.10, Astc12x12RGBASrgb new in 2019.10, Astc12x12RGBAF new in 2019.10, Astc3x3x3RGBAUnorm new in 2019.10, Astc3x3x3RGBASrgb new in 2019.10, Astc3x3x3RGBAF new in 2019.10, Astc4x3x3RGBAUnorm new in 2019.10, Astc4x3x3RGBASrgb new in 2019.10, Astc4x3x3RGBAF new in 2019.10, Astc4x4x3RGBAUnorm new in 2019.10, Astc4x4x3RGBASrgb new in 2019.10, Astc4x4x3RGBAF new in 2019.10, Astc4x4x4RGBAUnorm new in 2019.10, Astc4x4x4RGBASrgb new in 2019.10, Astc4x4x4RGBAF new in 2019.10, Astc5x4x4RGBAUnorm new in 2019.10, Astc5x4x4RGBASrgb new in 2019.10, Astc5x4x4RGBAF new in 2019.10, Astc5x5x4RGBAUnorm new in 2019.10, Astc5x5x4RGBASrgb new in 2019.10, Astc5x5x4RGBAF new in 2019.10, Astc5x5x5RGBAUnorm new in 2019.10, Astc5x5x5RGBASrgb new in 2019.10, Astc5x5x5RGBAF new in 2019.10, Astc6x5x5RGBAUnorm new in 2019.10, Astc6x5x5RGBASrgb new in 2019.10, Astc6x5x5RGBAF new in 2019.10, Astc6x6x5RGBAUnorm new in 2019.10, Astc6x6x5RGBASrgb new in 2019.10, Astc6x6x5RGBAF new in 2019.10, Astc6x6x6RGBAUnorm new in 2019.10, Astc6x6x6RGBASrgb new in 2019.10, Astc6x6x6RGBAF new in 2019.10, PvrtcRGB2bppUnorm new in 2019.10, PvrtcRGB2bppSrgb new in 2019.10, PvrtcRGBA2bppUnorm new in 2019.10, PvrtcRGBA2bppSrgb new in 2019.10, PvrtcRGB4bppUnorm new in 2019.10, PvrtcRGB4bppSrgb new in 2019.10, PvrtcRGBA4bppUnorm new in 2019.10, PvrtcRGBA4bppSrgb new in 2019.10 }
- Format of compressed pixel data.
- enum class ResourceState: UnsignedByte { NotLoaded, NotLoadedFallback, Loading, LoadingFallback, NotFound, NotFoundFallback, Mutable, Final }
- Resource state.
- enum class ResourceDataState: UnsignedByte { Loading = UnsignedByte(ResourceState::Loading), NotFound = UnsignedByte(ResourceState::NotFound), Mutable = UnsignedByte(ResourceState::Mutable), Final = UnsignedByte(ResourceState::Final) }
- Resource data state.
- enum class ResourcePolicy: UnsignedByte { Resident, Manual, ReferenceCounted }
- Resource policy.
- enum class SamplerFilter: UnsignedInt { Nearest = 0, Linear }
- Texture sampler filtering.
- enum class SamplerMipmap: UnsignedInt { Base = 0, Nearest, Linear }
- Texture sampler mip level selection.
- enum class SamplerWrapping: UnsignedInt { Repeat = 0, MirroredRepeat, ClampToEdge, ClampToBorder, MirrorClampToEdge }
- Texture sampler wrapping.
- enum class VertexFormat: UnsignedInt { Float = 1, Half, Double, UnsignedByte, UnsignedByteNormalized, Byte, ByteNormalized, UnsignedShort, UnsignedShortNormalized, Short, ShortNormalized, UnsignedInt, Int, Vector2, Vector2h, Vector2d, Vector2ub, Vector2ubNormalized, Vector2b, Vector2bNormalized, Vector2us, Vector2usNormalized, Vector2s, Vector2sNormalized, Vector2ui, Vector2i, Vector3, Vector3h, Vector3d, Vector3ub, Vector3ubNormalized, Vector3b, Vector3bNormalized, Vector3us, Vector3usNormalized, Vector3s, Vector3sNormalized, Vector3ui, Vector3i, Vector4, Vector4h, Vector4d, Vector4ub, Vector4ubNormalized, Vector4b, Vector4bNormalized, Vector4us, Vector4usNormalized, Vector4s, Vector4sNormalized, Vector4ui, Vector4i, Matrix2x2, Matrix2x2h, Matrix2x2d, Matrix2x2bNormalized, Matrix2x2sNormalized, Matrix2x3, Matrix2x3h, Matrix2x3d, Matrix2x3bNormalized, Matrix2x3sNormalized, Matrix2x4, Matrix2x4h, Matrix2x4d, Matrix2x4bNormalized, Matrix2x4sNormalized, Matrix2x2bNormalizedAligned, Matrix2x3hAligned, Matrix2x3bNormalizedAligned, Matrix2x3sNormalizedAligned, Matrix3x2, Matrix3x2h, Matrix3x2d, Matrix3x2bNormalized, Matrix3x2sNormalized, Matrix3x3, Matrix3x3h, Matrix3x3d, Matrix3x3bNormalized, Matrix3x3sNormalized, Matrix3x4, Matrix3x4h, Matrix3x4d, Matrix3x4bNormalized, Matrix3x4sNormalized, Matrix3x2bNormalizedAligned, Matrix3x3hAligned, Matrix3x3bNormalizedAligned, Matrix3x3sNormalizedAligned, Matrix4x2, Matrix4x2h, Matrix4x2d, Matrix4x2bNormalized, Matrix4x2sNormalized, Matrix4x3, Matrix4x3h, Matrix4x3d, Matrix4x3bNormalized, Matrix4x3sNormalized, Matrix4x4, Matrix4x4h, Matrix4x4d, Matrix4x4bNormalized, Matrix4x4sNormalized, Matrix4x2bNormalizedAligned, Matrix4x3hAligned, Matrix4x3bNormalizedAligned, Matrix4x3sNormalizedAligned } new in 2020.06
- Vertex format.
Typedefs
-
template<UnsignedInt dimensions, class T>using VectorTypeFor = typename DimensionTraits<dimensions, T>::VectorType
- Vector type for given dimension count and type.
-
template<UnsignedInt dimensions, class T>using RangeTypeFor = typename DimensionTraits<dimensions, T>::RangeType
- Range type for given dimension count and type.
-
template<UnsignedInt dimensions, class T>using MatrixTypeFor = typename DimensionTraits<dimensions, T>::MatrixType
- Matrix type for given dimension count and type.
- using Image1D = Image<1>
- One-dimensional image.
- using Image2D = Image<2>
- Two-dimensional image.
- using Image3D = Image<3>
- Three-dimensional image.
- using CompressedImage1D = CompressedImage<1>
- One-dimensional compressed image.
- using CompressedImage2D = CompressedImage<2>
- Two-dimensional compressed image.
- using CompressedImage3D = CompressedImage<3>
- Three-dimensional compressed image.
-
using ImageFlags1D = Containers::
EnumSet <ImageFlag1D> new in Git master - 1D image layout flags
-
using ImageFlags2D = Containers::
EnumSet <ImageFlag2D> new in Git master - 2D image layout flags
-
using ImageFlags3D = Containers::
EnumSet <ImageFlag3D> new in Git master - 3D image layout flags
-
template<UnsignedInt dimensions>using ImageFlag = typename Implementation::ImageFlagTraits<dimensions>::Type new in Git master
- Image layout flag.
-
template<UnsignedInt dimensions>using ImageFlags = typename Implementation::ImageFlagTraits<dimensions>::SetType new in Git master
- Image layout flags.
-
template<UnsignedInt dimensions>using BasicImageView = ImageView<dimensions, const char> new in 2019.10
- Const image view.
- using ImageView1D = BasicImageView<1>
- One-dimensional image view.
- using ImageView2D = BasicImageView<2>
- Two-dimensional image view.
- using ImageView3D = BasicImageView<3>
- Three-dimensional image view.
-
template<UnsignedInt dimensions>using BasicMutableImageView = ImageView<dimensions, char> new in 2019.10
- Mutable image view.
- using MutableImageView1D = BasicMutableImageView<1> new in 2019.10
- One-dimensional mutable image view.
- using MutableImageView2D = BasicMutableImageView<2> new in 2019.10
- Two-dimensional mutable image view.
- using MutableImageView3D = BasicMutableImageView<3> new in 2019.10
- Three-dimensional mutable image view.
-
template<UnsignedInt dimensions>using BasicCompressedImageView = CompressedImageView<dimensions, const char> new in 2019.10
- Const compressed image view.
- using CompressedImageView1D = BasicCompressedImageView<1>
- One-dimensional compressed image view.
- using CompressedImageView2D = BasicCompressedImageView<2>
- Two-dimensional compressed image view.
- using CompressedImageView3D = BasicCompressedImageView<3>
- Three-dimensional compressed image view.
-
template<UnsignedInt dimensions>using BasicMutableCompressedImageView = CompressedImageView<dimensions, char> new in 2019.10
- Mutable compressed image view.
- using MutableCompressedImageView1D = BasicMutableCompressedImageView<1> new in 2019.10
- One-dimensional mutable compressed image view.
- using MutableCompressedImageView2D = BasicMutableCompressedImageView<2> new in 2019.10
- Two-dimensional mutable compressed image view.
- using MutableCompressedImageView3D = BasicMutableCompressedImageView<3> new in 2019.10
- Three-dimensional mutable compressed image view.
-
using Debug = Corrade::
Utility:: Debug - Alias for debug output.
-
using Warning = Corrade::
Utility:: Warning - Alias for warning output.
-
using Error = Corrade::
Utility:: Error - Alias for error output.
-
using Fatal = Corrade::
Utility:: Fatal - Alias for fatal output.
-
using DefaultInitT = Corrade::
DefaultInitT new in Git master - Default initialization tag type.
-
using NoInitT = Corrade::
NoInitT new in 2020.06 - No initialization tag type.
-
using NoCreateT = Corrade::
NoCreateT - No creation tag type.
Functions
-
template<UnsignedInt dimensions, class T>auto operator<<(Debug& debug, const Array<dimensions, T>& value) -> Debug& deprecated in Git master
- Debug output operator.
-
template<class T>auto operator<<(Debug& debug, const Array1D<T>& value) -> Debug& deprecated in Git master
- Debug output operator.
-
template<class T>auto operator<<(Debug& debug, const Array2D<T>& value) -> Debug& deprecated in Git master
- Debug output operator.
-
template<class T>auto operator<<(Debug& debug, const Array3D<T>& value) -> Debug& deprecated in Git master
- Debug output operator.
- auto operator<<(Debug& debug, InputFileCallbackPolicy value) -> Debug&
- Debug output operator.
- auto operator<<(Debug& debug, ImageFlag1D value) -> Debug&
- Debug output operator.
- auto operator<<(Debug& debug, ImageFlag2D value) -> Debug&
- Debug output operator.
- auto operator<<(Debug& debug, ImageFlag3D value) -> Debug&
- Debug output operator.
- auto operator<<(Debug& debug, ImageFlags1D value) -> Debug&
- Debug output operator.
- auto operator<<(Debug& debug, ImageFlags2D value) -> Debug&
- Debug output operator.
- auto operator<<(Debug& debug, ImageFlags3D value) -> Debug&
- Debug output operator.
- auto operator<<(Debug& debug, MeshPrimitive value) -> Debug&
- Debug output operator.
- auto isMeshPrimitiveImplementationSpecific(MeshPrimitive primitive) -> bool constexpr new in 2020.06
- Whether a MeshPrimitive value wraps an implementation-specific identifier.
-
template<class T>auto meshPrimitiveWrap(T implementationSpecific) -> MeshPrimitive constexpr new in 2020.06
- Wrap an implementation-specific mesh primitive identifier in MeshPrimitive.
-
template<class T = UnsignedInt>auto meshPrimitiveUnwrap(MeshPrimitive primitive) -> T constexpr new in 2020.06
- Unwrap an implementation-specific mesh primitive identifier from MeshPrimitive.
- auto operator<<(Debug& debug, MeshIndexType value) -> Debug&
- Debug output operator.
- auto isMeshIndexTypeImplementationSpecific(MeshIndexType type) -> bool constexpr new in Git master
- Whether a MeshIndexType value wraps an implementation-specific identifier.
-
template<class T>auto meshIndexTypeWrap(T implementationSpecific) -> MeshIndexType constexpr new in Git master
- Wrap an implementation-specific mesh index type identifier in MeshIndexType.
-
template<class T = UnsignedInt>auto meshIndexTypeUnwrap(MeshIndexType type) -> T constexpr new in Git master
- Unwrap an implementation-specific mesh index type identifier from MeshIndexType.
- auto meshIndexTypeSize(MeshIndexType type) -> UnsignedInt
- Size of given mesh index type.
- auto pixelFormatSize(PixelFormat format) -> UnsignedInt new in Git master
- Size of given pixel format.
- auto pixelFormatChannelFormat(PixelFormat format) -> PixelFormat new in Git master
- Channel format of given pixel format.
- auto pixelFormatChannelCount(PixelFormat format) -> UnsignedInt new in Git master
- Channel count of given pixel format.
- auto isPixelFormatNormalized(PixelFormat format) -> bool new in Git master
- Whether given pixel format is normalized.
- auto isPixelFormatIntegral(PixelFormat format) -> bool new in Git master
- Whether given pixel format is integral.
- auto isPixelFormatFloatingPoint(PixelFormat format) -> bool new in Git master
- Whether given pixel format is floating-point.
- auto isPixelFormatSrgb(PixelFormat format) -> bool new in Git master
- Whether given pixel format is sRGB.
- auto isPixelFormatDepthOrStencil(PixelFormat format) -> bool new in Git master
- Whether given pixel format is depth or stenil.
- auto pixelFormat(PixelFormat format, UnsignedInt channelCount, bool srgb) -> PixelFormat new in Git master
- Assemble a pixel format from parts.
- auto pixelSize(PixelFormat format) -> UnsignedInt deprecated in Git master
- Size of given pixel format.
- auto operator<<(Debug& debug, PixelFormat value) -> Debug&
- Debug output operator.
- auto isPixelFormatImplementationSpecific(PixelFormat format) -> bool constexpr
- Whether a PixelFormat value wraps an implementation-specific identifier.
-
template<class T>auto pixelFormatWrap(T implementationSpecific) -> PixelFormat constexpr
- Wrap an implementation-specific pixel format identifier in PixelFormat.
-
template<class T = UnsignedInt>auto pixelFormatUnwrap(PixelFormat format) -> T constexpr
- Unwrap an implementation-specific pixel format identifier from PixelFormat.
- auto compressedPixelFormatBlockSize(CompressedPixelFormat format) -> Vector3i new in Git master
- Block size of given compressed pixel format.
- auto compressedBlockSize(CompressedPixelFormat format) -> Vector3i deprecated in Git master
- Block size of given compressed pixel format.
- auto compressedPixelFormatBlockDataSize(CompressedPixelFormat format) -> UnsignedInt new in Git master
- Block data size of given compressed pixel format.
- auto compressedBlockDataSize(CompressedPixelFormat format) -> UnsignedInt deprecated in Git master
- Block data size of given compressed pixel format.
- auto isCompressedPixelFormatNormalized(CompressedPixelFormat format) -> bool new in Git master
- Whether given compressed pixel format is normalized.
- auto isCompressedPixelFormatFloatingPoint(CompressedPixelFormat format) -> bool new in Git master
- Whether given compressed pixel format is floating-point.
- auto isCompressedPixelFormatSrgb(CompressedPixelFormat format) -> bool new in Git master
- Whether given compressed pixel format is sRGB.
- auto operator<<(Debug& debug, CompressedPixelFormat value) -> Debug&
- Debug output operator.
- auto isCompressedPixelFormatImplementationSpecific(CompressedPixelFormat format) -> bool constexpr
- Whether a CompressedPixelFormat value wraps an implementation-specific identifier.
-
template<class T>auto compressedPixelFormatWrap(T implementationSpecific) -> CompressedPixelFormat constexpr
- Wrap an implementation-specific pixel format identifier in a CompressedPixelFormat.
-
template<class T = UnsignedInt>auto compressedPixelFormatUnwrap(CompressedPixelFormat format) -> T constexpr
- Unwrap an implementation-specific pixel format identifier from a CompressedPixelFormat.
- auto operator<<(Debug& debug, ResourceState value) -> Debug&
- Debug output operator.
- auto operator<<(Debug& debug, const ResourceKey& value) -> Debug&
- Debug output operator.
- auto operator<<(Debug& debug, SamplerFilter value) -> Debug&
- Debug output operator.
- auto operator<<(Debug& debug, SamplerMipmap value) -> Debug&
- Debug output operator.
- auto operator<<(Debug& debug, SamplerWrapping value) -> Debug&
- Debug output operator.
- auto operator<<(Debug& debug, VertexFormat value) -> Debug& new in 2020.06
- Debug output operator.
- auto isVertexFormatImplementationSpecific(VertexFormat format) -> bool constexpr new in 2020.06
- Whether a VertexFormat value wraps an implementation-specific identifier.
-
template<class T>auto vertexFormatWrap(T implementationSpecific) -> VertexFormat constexpr new in 2020.06
- Wrap an implementation-specific vertex format identifier in VertexFormat.
-
template<class T = UnsignedInt>auto vertexFormatUnwrap(VertexFormat format) -> T constexpr new in 2020.06
- Unwrap an implementation-specific vertex format identifier from VertexFormat.
- auto vertexFormatSize(VertexFormat format) -> UnsignedInt new in 2020.06
- Size of given vertex format.
- auto vertexFormatComponentFormat(VertexFormat format) -> VertexFormat new in 2020.06
- Component format of given vertex format.
- auto vertexFormatComponentCount(VertexFormat format) -> UnsignedInt new in 2020.06
- Component count of given vertex format.
- auto vertexFormatVectorCount(VertexFormat format) -> UnsignedInt new in 2020.06
- Vector count of given vertex format.
- auto vertexFormatVectorStride(VertexFormat format) -> UnsignedInt new in 2020.06
- Vector stride of given vertex format.
- auto isVertexFormatNormalized(VertexFormat format) -> bool new in 2020.06
- Whether given vertex format is normalized.
- auto vertexFormat(VertexFormat format, UnsignedInt componentCount, bool normalized) -> VertexFormat new in 2020.06
- Assemble a vertex format from parts.
- auto vertexFormat(VertexFormat format, UnsignedInt vectorCount, UnsignedInt componentCount, bool aligned) -> VertexFormat new in 2020.06
- Assemble a matrix vertex format from parts.
Variables
- DefaultInitT DefaultInit constexpr new in Git master
- Default initialization tag.
- NoInitT NoInit constexpr new in 2020.06
- No initialization tag.
- NoCreateT NoCreate constexpr
- No creation tag.
- NoAllocateT NoAllocate constexpr new in Git master
- No allocation tag.
Basic type definitions
See Math 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 BitVector2 = Math::
BitVector <2> new in Git master - Two-component vector of bits.
-
using BitVector3 = Math::
BitVector <3> new in Git master - Three-component vector of bits.
-
using BitVector4 = Math::
BitVector <4> new in Git master - Four-component vector of bits.
- using BoolVector2 = BitVector2 deprecated in Git master
- Two-component vector of bits.
- using BoolVector3 = BitVector3 deprecated in Git master
- Three-component vector of bits.
- using BoolVector4 = BitVector4 deprecated in Git master
- Four-component vector of bits.
-
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 Vector2ub = Math::
Vector2 <UnsignedByte> new in 2020.06 - Two-component unsigned byte vector.
-
using Vector3ub = Math::
Vector3 <UnsignedByte> new in 2020.06 - Three-component unsigned byte vector.
-
using Vector4ub = Math::
Vector4 <UnsignedByte> new in 2020.06 - Four-component unsigned byte vector.
-
using Vector2b = Math::
Vector2 <Byte> new in 2020.06 - Two-component signed byte vector.
-
using Vector3b = Math::
Vector3 <Byte> new in 2020.06 - Three-component signed byte vector.
-
using Vector4b = Math::
Vector4 <Byte> new in 2020.06 - Four-component signed byte vector.
-
using Vector2us = Math::
Vector2 <UnsignedShort> new in 2020.06 - Two-component unsigned short vector.
-
using Vector3us = Math::
Vector3 <UnsignedShort> new in 2020.06 - Three-component unsigned short vector.
-
using Vector4us = Math::
Vector4 <UnsignedShort> new in 2020.06 - Four-component unsigned short vector.
-
using Vector2s = Math::
Vector2 <Short> new in 2020.06 - Two-component signed short vector.
-
using Vector3s = Math::
Vector3 <Short> new in 2020.06 - Three-component signed short vector.
-
using Vector4s = Math::
Vector4 <Short> new in 2020.06 - Four-component signed short 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 ColorHsv = Math::
ColorHsv <Float> - HSV float color.
-
using Color3ub = Math::
Color3 <UnsignedByte> - Three-component (RGB) unsigned byte color.
-
using Color3us = Math::
Color3 <UnsignedShort> new in 2020.06 - Three-component (RGB) unsigned short color.
-
using Color4ub = Math::
Color4 <UnsignedByte> - Four-component (RGBA) unsigned byte color.
-
using Color4us = Math::
Color4 <UnsignedShort> new in 2020.06 - Four-component (RGB) unsigned short color.
-
using Matrix2x1 = Math::
Matrix2x1 <Float> new in Git master - Float matrix with 2 columns and 1 row.
-
using Matrix2x2 = Math::
Matrix2x2 <Float> - 2x2 float matrix
-
using Matrix2x3 = Math::
Matrix2x3 <Float> - Float matrix with 2 columns and 3 rows.
-
using Matrix2x4 = Math::
Matrix2x4 <Float> - Float matrix with 2 columns and 4 rows.
-
using Matrix3x1 = Math::
Matrix3x1 <Float> new in Git master - Float matrix with 3 columns and 1 row.
-
using Matrix3x2 = Math::
Matrix3x2 <Float> - Float matrix with 3 columns and 2 rows.
-
using Matrix3x3 = Math::
Matrix3x3 <Float> - 3x3 float matrix
-
using Matrix3x4 = Math::
Matrix3x4 <Float> - Float matrix with 3 columns and 4 rows.
-
using Matrix4x1 = Math::
Matrix4x1 <Float> new in Git master - Float matrix with 4 columns and 1 row.
-
using Matrix4x2 = Math::
Matrix4x2 <Float> - Float matrix with 4 columns and 2 rows.
-
using Matrix4x3 = Math::
Matrix4x3 <Float> - Float matrix with 4 columns and 3 rows.
-
using Matrix4x4 = Math::
Matrix4x4 <Float> - 4x4 float matrix
-
using Matrix3 = Math::
Matrix3 <Float> - 3x3 float transformation matrix
-
using Matrix4 = Math::
Matrix4 <Float> - 4x4 float transformation matrix
-
using Matrix2x2b = Math::
Matrix2x2 <Byte> new in 2020.06 - Signed byte matrix with 2 columns and 2 rows.
-
using Matrix2x3b = Math::
Matrix2x3 <Byte> new in 2020.06 - Signed byte matrix with 2 columns and 3 rows.
-
using Matrix2x4b = Math::
Matrix2x4 <Byte> new in 2020.06 - Signed byte matrix with 2 columns and 4 rows.
-
using Matrix3x2b = Math::
Matrix3x2 <Byte> new in 2020.06 - Signed byte matrix with 3 columns and 2 rows.
-
using Matrix3x3b = Math::
Matrix3x3 <Byte> new in 2020.06 - Signed byte matrix with 3 columns and 3 rows.
-
using Matrix3x4b = Math::
Matrix3x4 <Byte> new in 2020.06 - Signed byte matrix with 3 columns and 4 rows.
-
using Matrix4x2b = Math::
Matrix4x2 <Byte> new in 2020.06 - Signed byte matrix with 4 columns and 2 rows.
-
using Matrix4x3b = Math::
Matrix4x3 <Byte> new in 2020.06 - Signed byte matrix with 4 columns and 3 rows.
-
using Matrix4x4b = Math::
Matrix4x4 <Byte> new in 2020.06 - Signed byte matrix with 4 columns and 4 rows.
-
using Matrix2x2s = Math::
Matrix2x2 <Short> new in 2020.06 - Signed short matrix with 2 columns and 2 rows.
-
using Matrix2x3s = Math::
Matrix2x3 <Short> new in 2020.06 - Signed short matrix with 2 columns and 3 rows.
-
using Matrix2x4s = Math::
Matrix2x4 <Short> new in 2020.06 - Signed short matrix with 2 columns and 4 rows.
-
using Matrix3x2s = Math::
Matrix3x2 <Short> new in 2020.06 - Signed short matrix with 3 columns and 2 rows.
-
using Matrix3x3s = Math::
Matrix3x3 <Short> new in 2020.06 - Signed short matrix with 3 columns and 3 rows.
-
using Matrix3x4s = Math::
Matrix3x4 <Short> new in 2020.06 - Signed short matrix with 3 columns and 4 rows.
-
using Matrix4x2s = Math::
Matrix4x2 <Short> new in 2020.06 - Signed short matrix with 4 columns and 2 rows.
-
using Matrix4x3s = Math::
Matrix4x3 <Short> new in 2020.06 - Signed short matrix with 4 columns and 3 rows.
-
using Matrix4x4s = Math::
Matrix4x4 <Short> new in 2020.06 - Signed short matrix with 4 columns and 4 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> - One-dimensional float range.
-
using Range2D = Math::
Range2D <Float> - Two-dimensional float range.
-
using Range3D = Math::
Range3D <Float> - Three-dimensional float range.
-
using Range1Dui = Math::
Range1D <UnsignedInt> new in Git master - One-dimensional unsigned integer range.
-
using Range2Dui = Math::
Range2D <UnsignedInt> new in Git master - Two-dimensional unsigned integer range.
-
using Range3Dui = Math::
Range3D <UnsignedInt> new in Git master - Three-dimensional unsigned integer range.
-
using Range1Di = Math::
Range1D <Int> - One-dimensional signed integer range.
-
using Range2Di = Math::
Range2D <Int> - Two-dimensional signed integer range.
-
using Range3Di = Math::
Range3D <Int> - Three-dimensional signed integer range.
-
using Frustum = Math::
Frustum <Float> - Float frustum.
-
using Nanoseconds = Math::
Nanoseconds <Long> new in Git master - 64-bit signed integer nanoseconds
-
using Seconds = Math::
Seconds <Float> new in Git master - 32-bit float seconds
Half-precision types
These types are for storage and conversion from / to single-precision types, no arithmetic operations are implemented. See Math type system for more information, for performing arithmetic on these types use Math::
-
using Vector2h = Math::
Vector2 <Half> new in 2020.06 - Two-component half-float vector.
-
using Vector3h = Math::
Vector3 <Half> new in 2020.06 - Three-component half-float vector.
-
using Vector4h = Math::
Vector4 <Half> new in 2020.06 - Four-component half-float vector.
-
using Color3h = Math::
Color3 <Half> new in 2020.06 - Three-component (RGB) half-float color.
-
using Color4h = Math::
Color4 <Half> new in 2020.06 - Four-component (RGBA) half-float color.
-
using Matrix2x2h = Math::
Matrix2x2 <Half> new in 2020.06 - Half-float matrix with 2 columns and 2 rows.
-
using Matrix2x3h = Math::
Matrix2x3 <Half> new in 2020.06 - Half-float matrix with 2 columns and 3 rows.
-
using Matrix2x4h = Math::
Matrix2x4 <Half> new in 2020.06 - Half-float matrix with 2 columns and 4 rows.
-
using Matrix3x2h = Math::
Matrix3x2 <Half> new in 2020.06 - Half-float matrix with 3 columns and 2 rows.
-
using Matrix3x3h = Math::
Matrix3x3 <Half> new in 2020.06 - Half-float matrix with 3 columns and 3 rows.
-
using Matrix3x4h = Math::
Matrix3x4 <Half> new in 2020.06 - Half-float matrix with 3 columns and 4 rows.
-
using Matrix4x2h = Math::
Matrix4x2 <Half> new in 2020.06 - Half-float matrix with 4 columns and 2 rows.
-
using Matrix4x3h = Math::
Matrix4x3 <Half> new in 2020.06 - Half-float matrix with 4 columns and 3 rows.
-
using Matrix4x4h = Math::
Matrix4x4 <Half> new in 2020.06 - Half-float matrix with 4 columns and 4 rows.
-
using Degh = Math::
Deg <Half> new in Git master - Angle in half-float degrees.
-
using Radh = Math::
Rad <Half> new in Git master - Angle in half-float radians.
-
using Range1Dh = Math::
Range1D <Half> new in Git master - One-dimensional half-float range.
-
using Range2Dh = Math::
Range2D <Half> new in Git master - Two-dimensional half-float range.
-
using Range3Dh = Math::
Range3D <Half> new in Git master - Three-dimensional half-float range.
Double-precision types
See Math 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 Matrix2x1d = Math::
Matrix2x1 <Double> new in Git master - Double matrix with 2 columns and 1 row.
-
using Matrix2x2d = Math::
Matrix2x2 <Double> - 2x2 double matrix
-
using Matrix2x3d = Math::
Matrix2x3 <Double> - Double matrix with 2 columns and 3 rows.
-
using Matrix2x4d = Math::
Matrix2x4 <Double> - Double matrix with 2 columns and 4 rows.
-
using Matrix3x1d = Math::
Matrix3x1 <Double> new in Git master - Double matrix with 3 columns and 1 row.
-
using Matrix3x2d = Math::
Matrix3x2 <Double> - Double matrix with 3 columns and 2 rows.
-
using Matrix3x3d = Math::
Matrix3x3 <Double> - 3x3 double matrix
-
using Matrix3x4d = Math::
Matrix3x4 <Double> - Double matrix with 3 columns and 4 rows.
-
using Matrix4x1d = Math::
Matrix4x1 <Double> new in Git master - Double matrix with 4 columns and 1 row.
-
using Matrix4x2d = Math::
Matrix4x2 <Double> - Double matrix with 4 columns and 2 rows.
-
using Matrix4x3d = Math::
Matrix4x3 <Double> - Double matrix with 4 columns and 3 rows.
-
using Matrix4x4d = Math::
Matrix4x4 <Double> - 4x4 double matrix
-
using QuadraticBezier2Dd = Math::
QuadraticBezier2D <Double> - Double two-dimensional quadratic Bézier curve.
-
using QuadraticBezier3Dd = Math::
QuadraticBezier3D <Double> - Double three-dimensional quadratic Bézier curve.
-
using CubicBezier2Dd = Math::
CubicBezier2D <Double> - Double two-dimensional cubic Bézier curve.
-
using CubicBezier3Dd = Math::
CubicBezier3D <Double> - 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> - One-dimensional double range.
-
using Range2Dd = Math::
Range2D <Double> - Two-dimensional double range.
-
using Range3Dd = Math::
Range3D <Double> - Three-dimensional double range.
-
using Frustumd = Math::
Frustum <Double> - Double frustum.
Enum documentation
enum class Magnum::InputFileCallbackPolicy: UnsignedByte new in 2019.10
#include <Magnum/FileCallback.h>
Input file callback policy.
Enumerators | |
---|---|
LoadTemporary |
The requested file is used only during a call of given function and the memory view is not referenced anymore once the function exits. This can be the case for example when importing image data using Trade:: |
LoadPermanent |
The requested file may be used for loading most or all data in the next steps, so the importer expects the memory view to be valid for as long as data import functions are called on it, but at most until the data importer is destroyed, its close() function is called or another file is opened. This can be the case for example when importing mesh data using Trade:: |
LoadPernament | |
Close |
A file that has been previously loaded by this callback can be closed now (and its memory freed). This is just a hint, it's not required for the callback to close it. This policy is also only ever called with a file that was previously opened with the same callback, so it's possible to completely ignore it and just return the cached value. This can be the case for example when an importer is done parsing a text file into an internal representation and the original data are no longer needed (and, for example, other files need to be loaded and they could repurpose the unused memory). |
enum class Magnum::ImageFlag1D: UnsignedShort new in Git master
#include <Magnum/ImageFlags.h>
1D image layout flag
Used by Image1D, ImageView1D and Trade::
enum class Magnum::ImageFlag2D: UnsignedShort new in Git master
#include <Magnum/ImageFlags.h>
2D image layout flag
Used by Image2D, ImageView2D and Trade::
Enumerators | |
---|---|
Array |
The image is a 1D array instead of 2D. I.e., no filtering is done along the Y axis and mip levels don't shorten along the Y axis. Guaranteed to have the same value as ImageFlag3D:: |
enum class Magnum::ImageFlag3D: UnsignedShort new in Git master
#include <Magnum/ImageFlags.h>
3D image layout flag
Used by Image3D, ImageView3D and Trade::
Enumerators | |
---|---|
Array |
The image is a 2D array instead of 3D. I.e., no filtering is done along the Z axis and mip levels don't shorten along the Z axis. Guaranteed to have the same value as ImageFlag2D:: |
CubeMap |
The image is a cube map instead of 3D. I.e., there's exactly six square 2D faces in order (+X, -X, +Y, -Y, +Z, -Z), filtering is done on face edges, and mip levels don't shorten along the Z axis. If combined with ImageFlag3D:: |
enum class Magnum::MeshPrimitive: UnsignedInt
#include <Magnum/Mesh.h>
Mesh primitive type.
Can act also as a wrapper for implementation-specific mesh primitive types using meshPrimitiveWrap() and meshPrimitiveUnwrap(). Distinction between generic and implementation-specific primitive types can be done using isMeshPrimitiveImplementationSpecific().
In case of OpenGL, corresponds to GL::
In case of Vulkan, corresponds to Vk::
For D3D, corresponds to D3D_
Enumerators | |
---|---|
Points |
Single points. Corresponds to GL:: |
Lines |
Each pair of vertices defines a single line, lines aren't connected together. Corresponds to GL:: |
LineLoop |
Like MeshPrimitive:: Corresponds to GL:: |
LineStrip |
First two vertices define first line segment, each following vertex defines another segment. Corresponds to GL:: |
Triangles |
Each three vertices define one triangle. Corresponds to GL:: |
TriangleStrip |
First three vertices define first triangle, each following vertex defines another triangle. Corresponds to GL:: |
TriangleFan |
First vertex is center, each following vertex is connected to previous and center vertex. Corresponds to GL:: |
Instances new in 2020.06 |
Per-instance data. Has no direct mapping to GPU APIs, but can be used to annotate Trade:: |
Faces new in 2020.06 |
Per-face data. Can be used to annotate Trade:: |
Edges new in 2020.06 |
Per-edge data. Can be used to annotate Trade:: |
Meshlets new in Git master |
Meshlet data. Can be used to annotate Trade:: |
enum class Magnum::MeshIndexType: UnsignedInt
#include <Magnum/Mesh.h>
Mesh index type.
A counterpart to VertexFormat describing a mesh index type. Can act also as a wrapper for implementation-specific mesh index type valueus uing meshIndexTypeWrap() and meshIndexTypeUnwrap(). Distinction between generic and implementation-specific types can be done using isMeshIndexTypeImplementationSpecific().
In case of OpenGL, corresponds to GL::
In case of Vulkan, corresponds to Vk::
For D3D, corresponds to DXGI_
Enumerators | |
---|---|
UnsignedByte |
Corresponds to GL:: |
UnsignedShort |
Corresponds to GL:: |
UnsignedInt |
Corresponds to GL:: |
enum class Magnum::PixelFormat: UnsignedInt
#include <Magnum/PixelFormat.h>
Format of pixel data.
Can act also as a wrapper for implementation-specific pixel format values using pixelFormatWrap() and pixelFormatUnwrap(). Distinction between generic and implementation-specific formats can be done using isPixelFormatImplementationSpecific().
In case of OpenGL, corresponds to GL::
In case of Vulkan, corresponds to uncompressed Vk::
For D3D, corresponds to DXGI_
See also pixelFormatSize(), pixelFormatChannelFormat(), pixelFormatChannelCount(), isPixelFormatNormalized(), isPixelFormatIntegral(), isPixelFormatFloatingPoint(), isPixelFormatSrgb(), isPixelFormatDepthOrStencil() and pixelFormat() for querying various aspects of a format and assembling it from a set of singular properties.
enum class Magnum::CompressedPixelFormat: UnsignedInt
#include <Magnum/PixelFormat.h>
Format of compressed pixel data.
Can act also as a wrapper for implementation-specific pixel format values using compressedPixelFormatWrap() and compressedPixelFormatUnwrap(). Distinction between generic and implementation-specific formats can be done using isCompressedPixelFormatImplementationSpecific().
In case of OpenGL, corresponds to GL::
In case of Vulkan, corresponds to compressed Vk::
For D3D, corresponds to DXGI_
See also compressedPixelFormatBlockSize(), compressedPixelFormatBlockDataSize(), isCompressedPixelFormatNormalized(), isCompressedPixelFormatFloatingPoint() and isCompressedPixelFormatSrgb() for querying various aspect of a format.
enum class Magnum::ResourceState: UnsignedByte
#include <Magnum/Resource.h>
Resource state.
Enumerators | |
---|---|
NotLoaded |
The resource is not yet loaded (and no fallback is available). |
NotLoadedFallback |
The resource is not yet loaded and fallback resource is used instead. |
Loading |
The resource is currently loading (and no fallback is available). |
LoadingFallback |
The resource is currently loading and fallback resource is used instead. |
NotFound |
The resource was not found (and no fallback is available). |
NotFoundFallback |
The resource was not found and fallback resource is used instead. |
Mutable |
The resource is loaded, but can be changed by the manager at any time. |
Final |
The resource is loaded and won't be changed by the manager anymore. |
enum class Magnum::ResourceDataState: UnsignedByte
#include <Magnum/ResourceManager.h>
Resource data state.
Enumerators | |
---|---|
Loading |
The resource is currently loading. Parameter |
NotFound |
The resource was not found. Parameter |
Mutable |
The resource can be changed by the manager in the future. This is slower, as Resource needs to ask the manager for new version every time the data are accessed, but allows changing the data for e.g. debugging purposes. |
Final |
The resource cannot be changed by the manager in the future. This is faster, as Resource instances will ask for the data only one time, thus suitable for production code. |
enum class Magnum::ResourcePolicy: UnsignedByte
#include <Magnum/ResourceManager.h>
Resource policy.
Enumerators | |
---|---|
Resident |
The resource will stay resident for whole lifetime of resource manager. |
Manual |
The resource will be unloaded when manually calling ResourceManager:: |
ReferenceCounted |
The resource will be unloaded when last reference to it is gone. |
enum class Magnum::SamplerFilter: UnsignedInt
#include <Magnum/Sampler.h>
Texture sampler filtering.
In case of OpenGL, corresponds to GL::
In case of Vulkan, corresponds to Vk::
Enumerators | |
---|---|
Nearest |
Nearest neighbor filtering. Corresponds to GL:: |
Linear |
Linear interpolation filtering. Corresponds to GL:: |
enum class Magnum::SamplerMipmap: UnsignedInt
#include <Magnum/Sampler.h>
Texture sampler mip level selection.
In case of OpenGL, corresponds to GL::
In case of Vulkan, corresponds to Vk::
Enumerators | |
---|---|
Base |
Select base mip level Corresponds to GL:: |
Nearest |
Select nearest mip level. Corresponds to GL:: |
Linear |
Linear interpolation of nearest mip levels. Corresponds to GL:: |
enum class Magnum::SamplerWrapping: UnsignedInt
#include <Magnum/Sampler.h>
Texture sampler wrapping.
In case of OpenGL, corresponds to GL::
In case of Vulkan, corresponds to Vk::
Enumerators | |
---|---|
Repeat |
Repeat the texture. Corresponds to GL:: |
MirroredRepeat |
Repeat a mirrored texture. Corresponds to GL:: |
ClampToEdge |
Clamp to edge. Coordinates out of range will be clamped to the first / last column / row in given direction. Corresponds to GL:: |
ClampToBorder |
Clamp to border color. Coordinates out of range will be clamped to the border color. Corresponds to GL:: |
MirrorClampToEdge |
Mirror the texture once in negative coordinates and clamp to edge after that. Corresponds to GL:: |
enum class Magnum::VertexFormat: UnsignedInt new in 2020.06
#include <Magnum/VertexFormat.h>
Vertex format.
Like PixelFormat, but for mesh attributes — including double-precision formats and matrices. Can act also as a wrapper for implementation-specific vertex format values using vertexFormatWrap() and vertexFormatUnwrap(). Distinction between generic and implementation-specific formats can be done using isVertexFormatImplementationSpecific().
In case of OpenGL, corresponds to a tuple of GL::
In case of Vulkan, corresponds to Vk::
For D3D, corresponds to DXGI_
See also vertexFormatSize(), vertexFormatComponentFormat(), vertexFormatComponentCount(), vertexFormatVectorCount(), vertexFormatVectorStride(), isVertexFormatNormalized() and vertexFormat() for querying various aspects of a format and assembling it from a set of singular properties.
Typedef documentation
#include <Magnum/DimensionTraits.h>
template<UnsignedInt dimensions, class T>
using Magnum::VectorTypeFor = typename DimensionTraits<dimensions, T>::VectorType
Vector type for given dimension count and type.
Convenience alternative to typename DimensionTraits<dimensions, T>::VectorType
. See DimensionTraits::
#include <Magnum/DimensionTraits.h>
template<UnsignedInt dimensions, class T>
using Magnum::RangeTypeFor = typename DimensionTraits<dimensions, T>::RangeType
Range type for given dimension count and type.
Convenience alternative to typename DimensionTraits<dimensions, T>::RangeType
. See DimensionTraits::
#include <Magnum/DimensionTraits.h>
template<UnsignedInt dimensions, class T>
using Magnum::MatrixTypeFor = typename DimensionTraits<dimensions, T>::MatrixType
Matrix type for given dimension count and type.
Convenience alternative to typename DimensionTraits<dimensions, T>::MatrixType
. See DimensionTraits::
typedef Image<1> Magnum::Image1D
#include <Magnum/Image.h>
One-dimensional image.
typedef Image<2> Magnum::Image2D
#include <Magnum/Image.h>
Two-dimensional image.
typedef Image<3> Magnum::Image3D
#include <Magnum/Image.h>
Three-dimensional image.
typedef CompressedImage<1> Magnum::CompressedImage1D
#include <Magnum/Image.h>
One-dimensional compressed image.
typedef CompressedImage<2> Magnum::CompressedImage2D
#include <Magnum/Image.h>
Two-dimensional compressed image.
typedef CompressedImage<3> Magnum::CompressedImage3D
#include <Magnum/Image.h>
Three-dimensional compressed image.
typedef Containers::EnumSet <ImageFlag1D> Magnum::ImageFlags1D new in Git master
#include <Magnum/ImageFlags.h>
1D image layout flags
Used by Image1D, ImageView1D, Trade::
typedef Containers::EnumSet <ImageFlag2D> Magnum::ImageFlags2D new in Git master
#include <Magnum/ImageFlags.h>
2D image layout flags
Used by Image2D, ImageView2D, Trade::
typedef Containers::EnumSet <ImageFlag3D> Magnum::ImageFlags3D new in Git master
#include <Magnum/ImageFlags.h>
3D image layout flags
Used by Image3D, ImageView3D, Trade::
#include <Magnum/ImageFlags.h>
template<UnsignedInt dimensions>
using Magnum::ImageFlag = typename Implementation::ImageFlagTraits<dimensions>::Type new in Git master
Image layout flag.
Expands to ImageFlag1D, ImageFlag2D or ImageFlag3D based on dimension count.
#include <Magnum/ImageFlags.h>
template<UnsignedInt dimensions>
using Magnum::ImageFlags = typename Implementation::ImageFlagTraits<dimensions>::SetType new in Git master
Image layout flags.
Expands to ImageFlags1D, ImageFlags2D or ImageFlags3D based on dimension count.
#include <Magnum/ImageView.h>
template<UnsignedInt dimensions>
using Magnum::BasicImageView = ImageView<dimensions, const char> new in 2019.10
Const image view.
typedef BasicImageView<1> Magnum::ImageView1D
#include <Magnum/ImageView.h>
One-dimensional image view.
typedef BasicImageView<2> Magnum::ImageView2D
#include <Magnum/ImageView.h>
Two-dimensional image view.
typedef BasicImageView<3> Magnum::ImageView3D
#include <Magnum/ImageView.h>
Three-dimensional image view.
#include <Magnum/ImageView.h>
template<UnsignedInt dimensions>
using Magnum::BasicMutableImageView = ImageView<dimensions, char> new in 2019.10
Mutable image view.
typedef BasicMutableImageView<1> Magnum::MutableImageView1D new in 2019.10
#include <Magnum/ImageView.h>
One-dimensional mutable image view.
typedef BasicMutableImageView<2> Magnum::MutableImageView2D new in 2019.10
#include <Magnum/ImageView.h>
Two-dimensional mutable image view.
typedef BasicMutableImageView<3> Magnum::MutableImageView3D new in 2019.10
#include <Magnum/ImageView.h>
Three-dimensional mutable image view.
#include <Magnum/ImageView.h>
template<UnsignedInt dimensions>
using Magnum::BasicCompressedImageView = CompressedImageView<dimensions, const char> new in 2019.10
Const compressed image view.
typedef BasicCompressedImageView<1> Magnum::CompressedImageView1D
#include <Magnum/ImageView.h>
One-dimensional compressed image view.
typedef BasicCompressedImageView<2> Magnum::CompressedImageView2D
#include <Magnum/ImageView.h>
Two-dimensional compressed image view.
typedef BasicCompressedImageView<3> Magnum::CompressedImageView3D
#include <Magnum/ImageView.h>
Three-dimensional compressed image view.
#include <Magnum/ImageView.h>
template<UnsignedInt dimensions>
using Magnum::BasicMutableCompressedImageView = CompressedImageView<dimensions, char> new in 2019.10
Mutable compressed image view.
typedef BasicMutableCompressedImageView<1> Magnum::MutableCompressedImageView1D new in 2019.10
#include <Magnum/ImageView.h>
One-dimensional mutable compressed image view.
typedef BasicMutableCompressedImageView<2> Magnum::MutableCompressedImageView2D new in 2019.10
#include <Magnum/ImageView.h>
Two-dimensional mutable compressed image view.
typedef BasicMutableCompressedImageView<3> Magnum::MutableCompressedImageView3D new in 2019.10
#include <Magnum/ImageView.h>
Three-dimensional mutable compressed image view.
typedef Corrade::Utility::Debug Magnum::Debug
#include <Magnum/Magnum.h>
Alias for debug output.
A shorthand for the fully-qualified name in Corrade.
typedef Corrade::Utility::Warning Magnum::Warning
#include <Magnum/Magnum.h>
Alias for warning output.
A shorthand for the fully-qualified name in Corrade.
typedef Corrade::Utility::Error Magnum::Error
#include <Magnum/Magnum.h>
Alias for error output.
A shorthand for the fully-qualified name in Corrade.
typedef Corrade::Utility::Fatal Magnum::Fatal
#include <Magnum/Magnum.h>
Alias for fatal output.
A shorthand for the fully-qualified name in Corrade.
typedef Corrade::DefaultInitT Magnum::DefaultInitT new in Git master
#include <Magnum/Tags.h>
Default initialization tag type.
Used to distinguish construction with default initialization. The actual meaning of "default" may vary, see documentation of a particular API using this tag for a detailed behavior description.
typedef Corrade::NoInitT Magnum::NoInitT new in 2020.06
#include <Magnum/Tags.h>
No initialization tag type.
Used to distinguish construction with no initialization at all.
typedef Corrade::NoCreateT Magnum::NoCreateT
#include <Magnum/Tags.h>
No creation tag type.
Used to distinguish construction without creating the underlying OpenGL / Vulkan / ... object.
typedef std::uint8_t Magnum::UnsignedByte
#include <Magnum/Magnum.h>
Unsigned byte (8bit)
typedef std::int8_t Magnum::Byte
#include <Magnum/Magnum.h>
Signed byte (8bit)
typedef std::uint16_t Magnum::UnsignedShort
#include <Magnum/Magnum.h>
Unsigned short (16bit)
typedef std::int16_t Magnum::Short
#include <Magnum/Magnum.h>
Signed short (16bit)
typedef std::uint32_t Magnum::UnsignedInt
#include <Magnum/Magnum.h>
Unsigned int (32bit)
Equivalent to GLSL uint
.
typedef std::int32_t Magnum::Int
#include <Magnum/Magnum.h>
Signed int (32bit)
Equivalent to GLSL int
.
typedef std::uint64_t Magnum::UnsignedLong
#include <Magnum/Magnum.h>
Unsigned long (64bit)
typedef std::int64_t Magnum::Long
#include <Magnum/Magnum.h>
Signed long (64bit)
typedef Math::Half Magnum::Half
#include <Magnum/Magnum.h>
Half (16bit)
typedef Math::BitVector <2> Magnum::BitVector2 new in Git master
#include <Magnum/Magnum.h>
Two-component vector of bits.
Equivalent to GLSL bvec2
.
typedef Math::BitVector <3> Magnum::BitVector3 new in Git master
#include <Magnum/Magnum.h>
Three-component vector of bits.
Equivalent to GLSL bvec3
.
typedef Math::BitVector <4> Magnum::BitVector4 new in Git master
#include <Magnum/Magnum.h>
Four-component vector of bits.
Equivalent to GLSL bvec4
.
typedef BitVector2 Magnum::BoolVector2
#include <Magnum/Magnum.h>
Two-component vector of bits.
typedef BitVector3 Magnum::BoolVector3
#include <Magnum/Magnum.h>
Three-component vector of bits.
typedef BitVector4 Magnum::BoolVector4
#include <Magnum/Magnum.h>
Four-component vector of bits.
typedef Math::Vector2 <Float> Magnum::Vector2
#include <Magnum/Magnum.h>
Two-component float vector.
Equivalent to GLSL vec2
.
typedef Math::Vector3 <Float> Magnum::Vector3
#include <Magnum/Magnum.h>
Three-component float vector.
Equivalent to GLSL vec3
.
typedef Math::Vector4 <Float> Magnum::Vector4
#include <Magnum/Magnum.h>
Four-component float vector.
Equivalent to GLSL vec4
.
typedef Math::Vector2 <UnsignedByte> Magnum::Vector2ub new in 2020.06
#include <Magnum/Magnum.h>
Two-component unsigned byte vector.
typedef Math::Vector3 <UnsignedByte> Magnum::Vector3ub new in 2020.06
#include <Magnum/Magnum.h>
Three-component unsigned byte vector.
typedef Math::Vector4 <UnsignedByte> Magnum::Vector4ub new in 2020.06
#include <Magnum/Magnum.h>
Four-component unsigned byte vector.
typedef Math::Vector2 <Byte> Magnum::Vector2b new in 2020.06
#include <Magnum/Magnum.h>
Two-component signed byte vector.
typedef Math::Vector3 <Byte> Magnum::Vector3b new in 2020.06
#include <Magnum/Magnum.h>
Three-component signed byte vector.
typedef Math::Vector4 <Byte> Magnum::Vector4b new in 2020.06
#include <Magnum/Magnum.h>
Four-component signed byte vector.
typedef Math::Vector2 <UnsignedShort> Magnum::Vector2us new in 2020.06
#include <Magnum/Magnum.h>
Two-component unsigned short vector.
typedef Math::Vector3 <UnsignedShort> Magnum::Vector3us new in 2020.06
#include <Magnum/Magnum.h>
Three-component unsigned short vector.
typedef Math::Vector4 <UnsignedShort> Magnum::Vector4us new in 2020.06
#include <Magnum/Magnum.h>
Four-component unsigned short vector.
typedef Math::Vector2 <Short> Magnum::Vector2s new in 2020.06
#include <Magnum/Magnum.h>
Two-component signed short vector.
typedef Math::Vector3 <Short> Magnum::Vector3s new in 2020.06
#include <Magnum/Magnum.h>
Three-component signed short vector.
typedef Math::Vector4 <Short> Magnum::Vector4s new in 2020.06
#include <Magnum/Magnum.h>
Four-component signed short vector.
typedef Math::Vector2 <UnsignedInt> Magnum::Vector2ui
#include <Magnum/Magnum.h>
Two-component unsigned integer vector.
Equivalent to GLSL uvec2
.
typedef Math::Vector3 <UnsignedInt> Magnum::Vector3ui
#include <Magnum/Magnum.h>
Three-component unsigned integer vector.
Equivalent to GLSL uvec3
.
typedef Math::Vector4 <UnsignedInt> Magnum::Vector4ui
#include <Magnum/Magnum.h>
Four-component unsigned integer vector.
Equivalent to GLSL uvec4
.
typedef Math::Vector2 <Int> Magnum::Vector2i
#include <Magnum/Magnum.h>
Two-component signed integer vector.
Equivalent to GLSL ivec2
.
typedef Math::Vector3 <Int> Magnum::Vector3i
#include <Magnum/Magnum.h>
Three-component signed integer vector.
Equivalent to GLSL ivec3
.
typedef Math::Vector4 <Int> Magnum::Vector4i
#include <Magnum/Magnum.h>
Four-component signed integer vector.
Equivalent to GLSL ivec4
.
typedef Math::Color3 <Float> Magnum::Color3
#include <Magnum/Magnum.h>
Three-component (RGB) float color.
typedef Math::Color4 <Float> Magnum::Color4
#include <Magnum/Magnum.h>
Four-component (RGBA) float color.
typedef Math::ColorHsv <Float> Magnum::ColorHsv
#include <Magnum/Magnum.h>
HSV float color.
typedef Math::Color3 <UnsignedByte> Magnum::Color3ub
#include <Magnum/Magnum.h>
Three-component (RGB) unsigned byte color.
typedef Math::Color3 <UnsignedShort> Magnum::Color3us new in 2020.06
#include <Magnum/Magnum.h>
Three-component (RGB) unsigned short color.
typedef Math::Color4 <UnsignedByte> Magnum::Color4ub
#include <Magnum/Magnum.h>
Four-component (RGBA) unsigned byte color.
typedef Math::Color4 <UnsignedShort> Magnum::Color4us new in 2020.06
#include <Magnum/Magnum.h>
Four-component (RGB) unsigned short color.
typedef Math::Matrix2x1 <Float> Magnum::Matrix2x1 new in Git master
#include <Magnum/Magnum.h>
Float matrix with 2 columns and 1 row.
typedef Math::Matrix2x2 <Float> Magnum::Matrix2x2
#include <Magnum/Magnum.h>
2x2 float matrix
Equivalent to GLSL mat2x2
.
typedef Math::Matrix2x3 <Float> Magnum::Matrix2x3
#include <Magnum/Magnum.h>
Float matrix with 2 columns and 3 rows.
Equivalent to GLSL mat2x3
.
typedef Math::Matrix2x4 <Float> Magnum::Matrix2x4
#include <Magnum/Magnum.h>
Float matrix with 2 columns and 4 rows.
Equivalent to GLSL mat2x4
.
typedef Math::Matrix3x1 <Float> Magnum::Matrix3x1 new in Git master
#include <Magnum/Magnum.h>
Float matrix with 3 columns and 1 row.
typedef Math::Matrix3x2 <Float> Magnum::Matrix3x2
#include <Magnum/Magnum.h>
Float matrix with 3 columns and 2 rows.
Equivalent to GLSL mat3x2
.
typedef Math::Matrix3x3 <Float> Magnum::Matrix3x3
#include <Magnum/Magnum.h>
3x3 float matrix
Equivalent to GLSL mat3x3
. Note that this is different from Matrix3, which contains additional functions for transformations in 2D.
typedef Math::Matrix3x4 <Float> Magnum::Matrix3x4
#include <Magnum/Magnum.h>
Float matrix with 3 columns and 4 rows.
Equivalent to GLSL mat3x4
.
typedef Math::Matrix4x1 <Float> Magnum::Matrix4x1 new in Git master
#include <Magnum/Magnum.h>
Float matrix with 4 columns and 1 row.
typedef Math::Matrix4x2 <Float> Magnum::Matrix4x2
#include <Magnum/Magnum.h>
Float matrix with 4 columns and 2 rows.
Equivalent to GLSL mat2x4
.
typedef Math::Matrix4x3 <Float> Magnum::Matrix4x3
#include <Magnum/Magnum.h>
Float matrix with 4 columns and 3 rows.
Equivalent to GLSL mat4x3
.
typedef Math::Matrix4x4 <Float> Magnum::Matrix4x4
#include <Magnum/Magnum.h>
4x4 float matrix
Equivalent to GLSL mat4x4
. Note that this is different from Matrix4, which contains additional functions for transformations in 3D.
typedef Math::Matrix3 <Float> Magnum::Matrix3
#include <Magnum/Magnum.h>
3x3 float transformation matrix
Equivalent to GLSL mat3
.
typedef Math::Matrix4 <Float> Magnum::Matrix4
#include <Magnum/Magnum.h>
4x4 float transformation matrix
Equivalent to GLSL mat4
.
typedef Math::Matrix2x2 <Byte> Magnum::Matrix2x2b new in 2020.06
#include <Magnum/Magnum.h>
Signed byte matrix with 2 columns and 2 rows.
Storage only, in order to support matrices packed into 8-bit types. For performing arithmetic on this type use Math::
Note that this type doesn't have the columns four-byte aligned, which may negatively affect performance in some cases. For better alignment use Matrix2x4b and ignore the bottom two rows.
typedef Math::Matrix2x3 <Byte> Magnum::Matrix2x3b new in 2020.06
#include <Magnum/Magnum.h>
Signed byte matrix with 2 columns and 3 rows.
Storage only, in order to support matrices packed into 8-bit types. For performing arithmetic on this type use Math::
Note that this type doesn't have the columns four-byte aligned, which may negatively affect performance in some cases. For better alignment use Matrix2x4b and ignore the bottom row.
typedef Math::Matrix2x4 <Byte> Magnum::Matrix2x4b new in 2020.06
#include <Magnum/Magnum.h>
Signed byte matrix with 2 columns and 4 rows.
Storage only, in order to support matrices packed into 8-bit types. For performing arithmetic on this type use Math::
typedef Math::Matrix3x2 <Byte> Magnum::Matrix3x2b new in 2020.06
#include <Magnum/Magnum.h>
Signed byte matrix with 3 columns and 2 rows.
Storage only, in order to support matrices packed into 8-bit types. For performing arithmetic on this type use Math::
Note that this type doesn't have the columns four-byte aligned, which may negatively affect performance in some cases. For better alignment use Matrix3x4b and ignore the bottom two rows.
typedef Math::Matrix3x3 <Byte> Magnum::Matrix3x3b new in 2020.06
#include <Magnum/Magnum.h>
Signed byte matrix with 3 columns and 3 rows.
Storage only, in order to support matrices packed into 8-bit types. For performing arithmetic on this type use Math::
Note that this type doesn't have the columns four-byte aligned, which may negatively affect performance in some cases. For better alignment use Matrix3x4b and ignore the bottom row.
typedef Math::Matrix3x4 <Byte> Magnum::Matrix3x4b new in 2020.06
#include <Magnum/Magnum.h>
Signed byte matrix with 3 columns and 4 rows.
Storage only, in order to support matrices packed into 8-bit types. For performing arithmetic on this type use Math::
typedef Math::Matrix4x2 <Byte> Magnum::Matrix4x2b new in 2020.06
#include <Magnum/Magnum.h>
Signed byte matrix with 4 columns and 2 rows.
Storage only, in order to support matrices packed into 8-bit types. For performing arithmetic on this type use Math::
Note that this type doesn't have the columns four-byte aligned, which may negatively affect performance in some cases. For better alignment use Matrix4x4b and ignore the bottom two rows.
typedef Math::Matrix4x3 <Byte> Magnum::Matrix4x3b new in 2020.06
#include <Magnum/Magnum.h>
Signed byte matrix with 4 columns and 3 rows.
Storage only, in order to support matrices packed into 8-bit types. For performing arithmetic on this type use Math::
Note that this type doesn't have the columns four-byte aligned, which may negatively affect performance in some cases. For better alignment use Matrix4x4b and ignore the bottom row.
typedef Math::Matrix4x4 <Byte> Magnum::Matrix4x4b new in 2020.06
#include <Magnum/Magnum.h>
Signed byte matrix with 4 columns and 4 rows.
Storage only, in order to support matrices packed into 8-bit types. For performing arithmetic on this type use Math::
typedef Math::Matrix2x2 <Short> Magnum::Matrix2x2s new in 2020.06
#include <Magnum/Magnum.h>
Signed short matrix with 2 columns and 2 rows.
Storage only, in order to support matrices packed into 16-bit types. For performing arithmetic on this type use Math::
typedef Math::Matrix2x3 <Short> Magnum::Matrix2x3s new in 2020.06
#include <Magnum/Magnum.h>
Signed short matrix with 2 columns and 3 rows.
Storage only, in order to support matrices packed into 16-bit types. For performing arithmetic on this type use Math::
Note that this type doesn't have the columns four-byte aligned, which may negatively affect performance in some cases. For better alignment use Matrix2x4s and ignore the bottom row.
typedef Math::Matrix2x4 <Short> Magnum::Matrix2x4s new in 2020.06
#include <Magnum/Magnum.h>
Signed short matrix with 2 columns and 4 rows.
Storage only, in order to support matrices packed into 16-bit types. For performing arithmetic on this type use Math::
typedef Math::Matrix3x2 <Short> Magnum::Matrix3x2s new in 2020.06
#include <Magnum/Magnum.h>
Signed short matrix with 3 columns and 2 rows.
Storage only, in order to support matrices packed into 16-bit types. For performing arithmetic on this type use Math::
typedef Math::Matrix3x3 <Short> Magnum::Matrix3x3s new in 2020.06
#include <Magnum/Magnum.h>
Signed short matrix with 3 columns and 3 rows.
Storage only, in order to support matrices packed into 16-bit types. For performing arithmetic on this type use Math::
Note that this type doesn't have the columns four-byte aligned, which may negatively affect performance in some cases. For better alignment use Matrix3x4s and ignore the bottom row.
typedef Math::Matrix3x4 <Short> Magnum::Matrix3x4s new in 2020.06
#include <Magnum/Magnum.h>
Signed short matrix with 3 columns and 4 rows.
Storage only, in order to support matrices packed into 16-bit types. For performing arithmetic on this type use Math::
typedef Math::Matrix4x2 <Short> Magnum::Matrix4x2s new in 2020.06
#include <Magnum/Magnum.h>
Signed short matrix with 4 columns and 2 rows.
Storage only, in order to support matrices packed into 16-bit types. For performing arithmetic on this type use Math::
typedef Math::Matrix4x3 <Short> Magnum::Matrix4x3s new in 2020.06
#include <Magnum/Magnum.h>
Signed short matrix with 4 columns and 3 rows.
Storage only, in order to support matrices packed into 16-bit types. For performing arithmetic on this type use Math::
Note that this type doesn't have the columns four-byte aligned, which may negatively affect performance in some cases. For better alignment use Matrix4x4s and ignore the bottom row.
typedef Math::Matrix4x4 <Short> Magnum::Matrix4x4s new in 2020.06
#include <Magnum/Magnum.h>
Signed short matrix with 4 columns and 4 rows.
Storage only, in order to support matrices packed into 16-bit types. For performing arithmetic on this type use Math::
typedef Math::QuadraticBezier2D <Float> Magnum::QuadraticBezier2D
#include <Magnum/Magnum.h>
Float two-dimensional quadratic Bézier curve.
typedef Math::QuadraticBezier3D <Float> Magnum::QuadraticBezier3D
#include <Magnum/Magnum.h>
Float three-dimensional quadratic Bézier curve.
typedef Math::CubicBezier2D <Float> Magnum::CubicBezier2D
#include <Magnum/Magnum.h>
Float two-dimensional cubic Bézier curve.
typedef Math::CubicBezier3D <Float> Magnum::CubicBezier3D
#include <Magnum/Magnum.h>
Float three-dimensional cubic Bézier curve.
typedef Math::CubicHermite1D <Float> Magnum::CubicHermite1D
#include <Magnum/Magnum.h>
Float scalar cubic Hermite spline point.
typedef Math::CubicHermite2D <Float> Magnum::CubicHermite2D
#include <Magnum/Magnum.h>
Float two-dimensional cubic Hermite spline point.
typedef Math::CubicHermite3D <Float> Magnum::CubicHermite3D
#include <Magnum/Magnum.h>
Float three-dimensional cubic Hermite spline point.
typedef Math::CubicHermiteComplex <Float> Magnum::CubicHermiteComplex
#include <Magnum/Magnum.h>
Float cubic Hermite spline complex number.
typedef Math::CubicHermiteQuaternion <Float> Magnum::CubicHermiteQuaternion
#include <Magnum/Magnum.h>
Float cubic Hermite spline quaternion.
typedef Math::Complex <Float> Magnum::Complex
#include <Magnum/Magnum.h>
Float complex number.
typedef Math::DualComplex <Float> Magnum::DualComplex
#include <Magnum/Magnum.h>
Float dual complex number.
typedef Math::Quaternion <Float> Magnum::Quaternion
#include <Magnum/Magnum.h>
Float quaternion.
typedef Math::DualQuaternion <Float> Magnum::DualQuaternion
#include <Magnum/Magnum.h>
Float dual quaternion.
typedef Math::Constants <Float> Magnum::Constants
#include <Magnum/Magnum.h>
Float constants.
typedef Math::Deg <Float> Magnum::Deg
#include <Magnum/Magnum.h>
Angle in float degrees.
typedef Math::Rad <Float> Magnum::Rad
#include <Magnum/Magnum.h>
Angle in float radians.
typedef Math::Range1D <Float> Magnum::Range1D
#include <Magnum/Magnum.h>
One-dimensional float range.
typedef Math::Range2D <Float> Magnum::Range2D
#include <Magnum/Magnum.h>
Two-dimensional float range.
typedef Math::Range3D <Float> Magnum::Range3D
#include <Magnum/Magnum.h>
Three-dimensional float range.
typedef Math::Range1D <UnsignedInt> Magnum::Range1Dui new in Git master
#include <Magnum/Magnum.h>
One-dimensional unsigned integer range.
typedef Math::Range2D <UnsignedInt> Magnum::Range2Dui new in Git master
#include <Magnum/Magnum.h>
Two-dimensional unsigned integer range.
typedef Math::Range3D <UnsignedInt> Magnum::Range3Dui new in Git master
#include <Magnum/Magnum.h>
Three-dimensional unsigned integer range.
typedef Math::Range1D <Int> Magnum::Range1Di
#include <Magnum/Magnum.h>
One-dimensional signed integer range.
typedef Math::Range2D <Int> Magnum::Range2Di
#include <Magnum/Magnum.h>
Two-dimensional signed integer range.
typedef Math::Range3D <Int> Magnum::Range3Di
#include <Magnum/Magnum.h>
Three-dimensional signed integer range.
typedef Math::Frustum <Float> Magnum::Frustum
#include <Magnum/Magnum.h>
Float frustum.
typedef Math::Nanoseconds <Long> Magnum::Nanoseconds new in Git master
#include <Magnum/Magnum.h>
64-bit signed integer nanoseconds
typedef Math::Seconds <Float> Magnum::Seconds new in Git master
#include <Magnum/Magnum.h>
32-bit float seconds
typedef Math::Vector2 <Half> Magnum::Vector2h new in 2020.06
#include <Magnum/Magnum.h>
Two-component half-float vector.
typedef Math::Vector3 <Half> Magnum::Vector3h new in 2020.06
#include <Magnum/Magnum.h>
Three-component half-float vector.
typedef Math::Vector4 <Half> Magnum::Vector4h new in 2020.06
#include <Magnum/Magnum.h>
Four-component half-float vector.
typedef Math::Color3 <Half> Magnum::Color3h new in 2020.06
#include <Magnum/Magnum.h>
Three-component (RGB) half-float color.
typedef Math::Color4 <Half> Magnum::Color4h new in 2020.06
#include <Magnum/Magnum.h>
Four-component (RGBA) half-float color.
typedef Math::Matrix2x2 <Half> Magnum::Matrix2x2h new in 2020.06
#include <Magnum/Magnum.h>
Half-float matrix with 2 columns and 2 rows.
typedef Math::Matrix2x3 <Half> Magnum::Matrix2x3h new in 2020.06
#include <Magnum/Magnum.h>
Half-float matrix with 2 columns and 3 rows.
Note that this type doesn't have the columns four-byte aligned, which may negatively affect performance in some cases. For better alignment use Matrix2x4h and ignore the bottom row.
typedef Math::Matrix2x4 <Half> Magnum::Matrix2x4h new in 2020.06
#include <Magnum/Magnum.h>
Half-float matrix with 2 columns and 4 rows.
typedef Math::Matrix3x2 <Half> Magnum::Matrix3x2h new in 2020.06
#include <Magnum/Magnum.h>
Half-float matrix with 3 columns and 2 rows.
typedef Math::Matrix3x3 <Half> Magnum::Matrix3x3h new in 2020.06
#include <Magnum/Magnum.h>
Half-float matrix with 3 columns and 3 rows.
Note that this type doesn't have the columns four-byte aligned, which may negatively affect performance in some cases. For better alignment use Matrix3x4h and ignore the bottom row.
typedef Math::Matrix3x4 <Half> Magnum::Matrix3x4h new in 2020.06
#include <Magnum/Magnum.h>
Half-float matrix with 3 columns and 4 rows.
typedef Math::Matrix4x2 <Half> Magnum::Matrix4x2h new in 2020.06
#include <Magnum/Magnum.h>
Half-float matrix with 4 columns and 2 rows.
typedef Math::Matrix4x3 <Half> Magnum::Matrix4x3h new in 2020.06
#include <Magnum/Magnum.h>
Half-float matrix with 4 columns and 3 rows.
Note that this type doesn't have the columns four-byte aligned, which may negatively affect performance in some cases. For better alignment use Matrix4x4h and ignore the bottom row.
typedef Math::Matrix4x4 <Half> Magnum::Matrix4x4h new in 2020.06
#include <Magnum/Magnum.h>
Half-float matrix with 4 columns and 4 rows.
typedef Math::Deg <Half> Magnum::Degh new in Git master
#include <Magnum/Magnum.h>
Angle in half-float degrees.
typedef Math::Rad <Half> Magnum::Radh new in Git master
#include <Magnum/Magnum.h>
Angle in half-float radians.
typedef Math::Range1D <Half> Magnum::Range1Dh new in Git master
#include <Magnum/Magnum.h>
One-dimensional half-float range.
typedef Math::Range2D <Half> Magnum::Range2Dh new in Git master
#include <Magnum/Magnum.h>
Two-dimensional half-float range.
typedef Math::Range3D <Half> Magnum::Range3Dh new in Git master
#include <Magnum/Magnum.h>
Three-dimensional half-float range.
typedef Math::Vector2 <Double> Magnum::Vector2d
#include <Magnum/Magnum.h>
Two-component double vector.
Equivalent to GLSL dvec2
.
typedef Math::Vector3 <Double> Magnum::Vector3d
#include <Magnum/Magnum.h>
Three-component double vector.
Equivalent to GLSL dvec3
.
typedef Math::Vector4 <Double> Magnum::Vector4d
#include <Magnum/Magnum.h>
Four-component double vector.
Equivalent to GLSL dvec4
.
typedef Math::Matrix3 <Double> Magnum::Matrix3d
#include <Magnum/Magnum.h>
3x3 double transformation matrix
Equivalent to GLSL dmat3
.
typedef Math::Matrix4 <Double> Magnum::Matrix4d
#include <Magnum/Magnum.h>
4x4 double transformation matrix
Equivalent to GLSL dmat4
.
typedef Math::Matrix2x1 <Double> Magnum::Matrix2x1d new in Git master
#include <Magnum/Magnum.h>
Double matrix with 2 columns and 1 row.
typedef Math::Matrix2x2 <Double> Magnum::Matrix2x2d
#include <Magnum/Magnum.h>
2x2 double matrix
Equivalent to GLSL dmat2x2
.
typedef Math::Matrix2x3 <Double> Magnum::Matrix2x3d
#include <Magnum/Magnum.h>
Double matrix with 2 columns and 3 rows.
Equivalent to GLSL dmat2x3
.
typedef Math::Matrix2x4 <Double> Magnum::Matrix2x4d
#include <Magnum/Magnum.h>
Double matrix with 2 columns and 4 rows.
Equivalent to GLSL dmat2x4
.
typedef Math::Matrix3x1 <Double> Magnum::Matrix3x1d new in Git master
#include <Magnum/Magnum.h>
Double matrix with 3 columns and 1 row.
typedef Math::Matrix3x2 <Double> Magnum::Matrix3x2d
#include <Magnum/Magnum.h>
Double matrix with 3 columns and 2 rows.
Equivalent to GLSL dmat3x2
.
typedef Math::Matrix3x3 <Double> Magnum::Matrix3x3d
#include <Magnum/Magnum.h>
3x3 double matrix
Equivalent to GLSL dmat3x3
. Note that this is different from Matrix3d, which contains additional functions for transformations in 2D.
typedef Math::Matrix3x4 <Double> Magnum::Matrix3x4d
#include <Magnum/Magnum.h>
Double matrix with 3 columns and 4 rows.
Equivalent to GLSL dmat3x4
.
typedef Math::Matrix4x1 <Double> Magnum::Matrix4x1d new in Git master
#include <Magnum/Magnum.h>
Double matrix with 4 columns and 1 row.
typedef Math::Matrix4x2 <Double> Magnum::Matrix4x2d
#include <Magnum/Magnum.h>
Double matrix with 4 columns and 2 rows.
Equivalent to GLSL dmat4x2
.
typedef Math::Matrix4x3 <Double> Magnum::Matrix4x3d
#include <Magnum/Magnum.h>
Double matrix with 4 columns and 3 rows.
Equivalent to GLSL dmat4x3
.
typedef Math::Matrix4x4 <Double> Magnum::Matrix4x4d
#include <Magnum/Magnum.h>
4x4 double matrix
Equivalent to GLSL dmat4x4
. Note that this is different from Matrix4d, which contains additional functions for transformations in 3D.
typedef Math::QuadraticBezier2D <Double> Magnum::QuadraticBezier2Dd
#include <Magnum/Magnum.h>
Double two-dimensional quadratic Bézier curve.
typedef Math::QuadraticBezier3D <Double> Magnum::QuadraticBezier3Dd
#include <Magnum/Magnum.h>
Double three-dimensional quadratic Bézier curve.
typedef Math::CubicBezier2D <Double> Magnum::CubicBezier2Dd
#include <Magnum/Magnum.h>
Double two-dimensional cubic Bézier curve.
typedef Math::CubicBezier3D <Double> Magnum::CubicBezier3Dd
#include <Magnum/Magnum.h>
Double three-dimensional cubic Bézier curve.
typedef Math::CubicHermite1D <Double> Magnum::CubicHermite1Dd
#include <Magnum/Magnum.h>
Double scalar cubic Hermite spline point.
typedef Math::CubicHermite2D <Double> Magnum::CubicHermite2Dd
#include <Magnum/Magnum.h>
Double two-dimensional cubic Hermite spline point.
typedef Math::CubicHermite3D <Double> Magnum::CubicHermite3Dd
#include <Magnum/Magnum.h>
Double three-dimensional cubic Hermite spline point.
typedef Math::CubicHermiteComplex <Double> Magnum::CubicHermiteComplexd
#include <Magnum/Magnum.h>
Double cubic Hermite spline complex number.
typedef Math::CubicHermiteQuaternion <Double> Magnum::CubicHermiteQuaterniond
#include <Magnum/Magnum.h>
Double cubic Hermite spline quaternion.
typedef Math::Complex <Double> Magnum::Complexd
#include <Magnum/Magnum.h>
Double complex number.
typedef Math::DualComplex <Double> Magnum::DualComplexd
#include <Magnum/Magnum.h>
Double dual complex number.
typedef Math::Quaternion <Double> Magnum::Quaterniond
#include <Magnum/Magnum.h>
Double quaternion.
typedef Math::DualQuaternion <Double> Magnum::DualQuaterniond
#include <Magnum/Magnum.h>
Double dual quaternion.
typedef Math::Constants <Double> Magnum::Constantsd
#include <Magnum/Magnum.h>
Double constants.
typedef Math::Deg <Double> Magnum::Degd
#include <Magnum/Magnum.h>
Angle in double degrees.
typedef Math::Rad <Double> Magnum::Radd
#include <Magnum/Magnum.h>
Angle in double radians.
typedef Math::Range1D <Double> Magnum::Range1Dd
#include <Magnum/Magnum.h>
One-dimensional double range.
typedef Math::Range2D <Double> Magnum::Range2Dd
#include <Magnum/Magnum.h>
Two-dimensional double range.
typedef Math::Range3D <Double> Magnum::Range3Dd
#include <Magnum/Magnum.h>
Three-dimensional double range.
typedef Math::Frustum <Double> Magnum::Frustumd
#include <Magnum/Magnum.h>
Double frustum.
Function documentation
#include <Magnum/Array.h>
template<UnsignedInt dimensions, class T>
Debug& Magnum:: operator<<(Debug& debug,
const Array<dimensions, T>& value)
Debug output operator.
#include <Magnum/Array.h>
template<class T>
Debug& Magnum:: operator<<(Debug& debug,
const Array1D<T>& value)
Debug output operator.
#include <Magnum/Array.h>
template<class T>
Debug& Magnum:: operator<<(Debug& debug,
const Array2D<T>& value)
Debug output operator.
#include <Magnum/Array.h>
template<class T>
Debug& Magnum:: operator<<(Debug& debug,
const Array3D<T>& value)
Debug output operator.
Debug& Magnum:: operator<<(Debug& debug,
InputFileCallbackPolicy value)
#include <Magnum/FileCallback.h>
Debug output operator.
Debug& Magnum:: operator<<(Debug& debug,
ImageFlag1D value)
#include <Magnum/ImageFlags.h>
Debug output operator.
Debug& Magnum:: operator<<(Debug& debug,
ImageFlag2D value)
#include <Magnum/ImageFlags.h>
Debug output operator.
Debug& Magnum:: operator<<(Debug& debug,
ImageFlag3D value)
#include <Magnum/ImageFlags.h>
Debug output operator.
Debug& Magnum:: operator<<(Debug& debug,
ImageFlags1D value)
#include <Magnum/ImageFlags.h>
Debug output operator.
Debug& Magnum:: operator<<(Debug& debug,
ImageFlags2D value)
#include <Magnum/ImageFlags.h>
Debug output operator.
Debug& Magnum:: operator<<(Debug& debug,
ImageFlags3D value)
#include <Magnum/ImageFlags.h>
Debug output operator.
Debug& Magnum:: operator<<(Debug& debug,
MeshPrimitive value)
#include <Magnum/Mesh.h>
Debug output operator.
bool Magnum:: isMeshPrimitiveImplementationSpecific(MeshPrimitive primitive) constexpr new in 2020.06
#include <Magnum/Mesh.h>
Whether a MeshPrimitive value wraps an implementation-specific identifier.
Returns true
if value of primitive
has its highest bit set, false
otherwise. Use meshPrimitiveWrap() and meshPrimitiveUnwrap() to wrap/unwrap an implementation-specific indentifier to/from MeshPrimitive.
#include <Magnum/Mesh.h>
template<class T>
MeshPrimitive Magnum:: meshPrimitiveWrap(T implementationSpecific) constexpr new in 2020.06
Wrap an implementation-specific mesh primitive identifier in MeshPrimitive.
Sets the highest bit on implementationSpecific
to mark it as implementation-specific. Expects that implementationSpecific
fits into the remaining 31 bits. Use meshPrimitiveUnwrap() for the inverse operation.
#include <Magnum/Mesh.h>
template<class T = UnsignedInt>
T Magnum:: meshPrimitiveUnwrap(MeshPrimitive primitive) constexpr new in 2020.06
Unwrap an implementation-specific mesh primitive identifier from MeshPrimitive.
Unsets the highest bit from primitive
to extract the implementation-specific value. Expects that primitive
has it set. Use meshPrimitiveWrap() for the inverse operation.
Debug& Magnum:: operator<<(Debug& debug,
MeshIndexType value)
#include <Magnum/Mesh.h>
Debug output operator.
bool Magnum:: isMeshIndexTypeImplementationSpecific(MeshIndexType type) constexpr new in Git master
#include <Magnum/Mesh.h>
Whether a MeshIndexType value wraps an implementation-specific identifier.
Returns true
if value of type
has its highest bit set, false
otherwise. Use meshIndexTypeWrap() and meshIndexTypeUnwrap() to wrap/unwrap an implementation-specific indentifier to/from MeshIndexType.
#include <Magnum/Mesh.h>
template<class T>
MeshIndexType Magnum:: meshIndexTypeWrap(T implementationSpecific) constexpr new in Git master
Wrap an implementation-specific mesh index type identifier in MeshIndexType.
Sets the highest bit on implementationSpecific
to mark it as implementation-specific. Expects that implementationSpecific
fits into the remaining 31 bits. Use meshIndexTypeUnwrap() for the inverse operation.
#include <Magnum/Mesh.h>
template<class T = UnsignedInt>
T Magnum:: meshIndexTypeUnwrap(MeshIndexType type) constexpr new in Git master
Unwrap an implementation-specific mesh index type identifier from MeshIndexType.
Unsets the highest bit from type
to extract the implementation-specific value. Expects that type
has it set. Use meshIndexTypeWrap() for the inverse operation.
UnsignedInt Magnum:: meshIndexTypeSize(MeshIndexType type)
#include <Magnum/Mesh.h>
Size of given mesh index type.
UnsignedInt Magnum:: pixelFormatSize(PixelFormat format) new in Git master
#include <Magnum/PixelFormat.h>
Size of given pixel format.
Expects that the pixel format is not implementation-specific.
PixelFormat Magnum:: pixelFormatChannelFormat(PixelFormat format) new in Git master
#include <Magnum/PixelFormat.h>
Channel format of given pixel format.
Returns for example PixelFormat::1
. Expects that the pixel format is not implementation-specific and not a depth/stencil format.
UnsignedInt Magnum:: pixelFormatChannelCount(PixelFormat format) new in Git master
#include <Magnum/PixelFormat.h>
Channel count of given pixel format.
Returns for example 1
for PixelFormat::3
for PixelFormat::
bool Magnum:: isPixelFormatNormalized(PixelFormat format) new in Git master
#include <Magnum/PixelFormat.h>
Whether given pixel format is normalized.
Returns true
for *Unorm
, *Snorm
and *Srgb
formats, false
otherwise. In particular, floating-point formats are not treated as normalized, even though for example they might commonly have values only in the range (or in the signed range). Expects that the pixel format is not implementation-specific and not a depth/stencil format.
For any pixel format, exactly one of isPixelFormatNormalized(), isPixelFormatIntegral() and isPixelFormatFloatingPoint() returns true
.
bool Magnum:: isPixelFormatIntegral(PixelFormat format) new in Git master
#include <Magnum/PixelFormat.h>
Whether given pixel format is integral.
Returns true
for *UI
and *I
formats, false
otherwise. In particular, normalized integer formats are not treated as integer. Expects that the pixel format is not implementation-specific and not a depth/stencil format.
For any pixel format, exactly one of isPixelFormatNormalized(), isPixelFormatIntegral() and isPixelFormatFloatingPoint() returns true
.
bool Magnum:: isPixelFormatFloatingPoint(PixelFormat format) new in Git master
#include <Magnum/PixelFormat.h>
Whether given pixel format is floating-point.
Returns true
for *F
formats, false
otherwise. In particular, normalized integer formats are not treated as floating-point, even though they get expanded to the or floating-point range in shaders. Expects that the pixel format is not implementation-specific and not a depth/stencil format.
For any pixel format, exactly one of isPixelFormatNormalized(), isPixelFormatIntegral() and isPixelFormatFloatingPoint() returns true
.
bool Magnum:: isPixelFormatSrgb(PixelFormat format) new in Git master
#include <Magnum/PixelFormat.h>
Whether given pixel format is sRGB.
Returns true
for *Srgb
formats, false
otherwise. If this function returns true
, isPixelFormatNormalized() also returns true
. Expects that the pixel format is not implementation-specific and not a depth/stencil format.
bool Magnum:: isPixelFormatDepthOrStencil(PixelFormat format) new in Git master
#include <Magnum/PixelFormat.h>
Whether given pixel format is depth or stenil.
Returns true
for Depth*
, Stencil*
and combined depth/stencil formats, false
otherwise. Expects that the pixel format is not implementation-specific.
PixelFormat Magnum:: pixelFormat(PixelFormat format,
UnsignedInt channelCount,
bool srgb) new in Git master
#include <Magnum/PixelFormat.h>
Assemble a pixel format from parts.
Converts format
to a new format with desired channel count and normalization. Expects that the pixel format is not implementation-specific and not a depth/stencil format, channelCount
is 1
, 2
, 3
or 4
and srgb
is true
only for 8-bit integer formats.
Example usage — picking a three or four-channel format corresponding to a grayscale or grayscale + alpha format:
PixelFormat grayscaleFormat = …; PixelFormat rgbFormat = pixelFormat( grayscaleFormat, pixelFormatChannelCount(grayscaleFormat) == 2 ? 4 : 3, isPixelFormatSrgb(grayscaleFormat));
UnsignedInt Magnum:: pixelSize(PixelFormat format)
#include <Magnum/PixelFormat.h>
Size of given pixel format.
Debug& Magnum:: operator<<(Debug& debug,
PixelFormat value)
#include <Magnum/PixelFormat.h>
Debug output operator.
bool Magnum:: isPixelFormatImplementationSpecific(PixelFormat format) constexpr
#include <Magnum/PixelFormat.h>
Whether a PixelFormat value wraps an implementation-specific identifier.
Returns true
if value of format
has its highest bit set, false
otherwise. Use pixelFormatWrap() and pixelFormatUnwrap() to wrap/unwrap an implementation-specific indentifier to/from PixelFormat.
#include <Magnum/PixelFormat.h>
template<class T>
PixelFormat Magnum:: pixelFormatWrap(T implementationSpecific) constexpr
Wrap an implementation-specific pixel format identifier in PixelFormat.
Sets the highest bit on implementationSpecific
to mark it as implementation-specific. Expects that implementationSpecific
fits into the remaining 31 bits. Use pixelFormatUnwrap() for the inverse operation.
#include <Magnum/PixelFormat.h>
template<class T = UnsignedInt>
T Magnum:: pixelFormatUnwrap(PixelFormat format) constexpr
Unwrap an implementation-specific pixel format identifier from PixelFormat.
Unsets the highest bit from format
to extract the implementation-specific value. Expects that format
has it set. Use pixelFormatWrap() for the inverse operation.
Vector3i Magnum:: compressedPixelFormatBlockSize(CompressedPixelFormat format) new in Git master
#include <Magnum/PixelFormat.h>
Block size of given compressed pixel format.
For 2D formats the Z dimension is always 1. Expects that the pixel format is not implementation-specific.
Vector3i Magnum:: compressedBlockSize(CompressedPixelFormat format)
#include <Magnum/PixelFormat.h>
Block size of given compressed pixel format.
UnsignedInt Magnum:: compressedPixelFormatBlockDataSize(CompressedPixelFormat format) new in Git master
#include <Magnum/PixelFormat.h>
Block data size of given compressed pixel format.
Byte size of each compressed block. Expects that the pixel format is not implementation-specific.
UnsignedInt Magnum:: compressedBlockDataSize(CompressedPixelFormat format)
#include <Magnum/PixelFormat.h>
Block data size of given compressed pixel format.
bool Magnum:: isCompressedPixelFormatNormalized(CompressedPixelFormat format) new in Git master
#include <Magnum/PixelFormat.h>
Whether given compressed pixel format is normalized.
Returns true
for *Unorm
, *Snorm
and *Srgb
formats, false
otherwise. In particular, floating-point formats are not treated as normalized, even though for example they might commonly have values only in the range (or in the signed range). Expects that the pixel format is not implementation-specific.
For any compressed pixel format, exactly one of isCompressedPixelFormatNormalized() and isCompressedPixelFormatFloatingPoint() returns true
.
bool Magnum:: isCompressedPixelFormatFloatingPoint(CompressedPixelFormat format) new in Git master
#include <Magnum/PixelFormat.h>
Whether given compressed pixel format is floating-point.
Returns true
for *F
formats, false
otherwise. In particular, normalized integer formats are not treated as floating-point, even though they get expanded to the or floating-point range in shaders. Expects that the pixel format is not implementation-specific.
For any compressed pixel format, exactly one of isCompressedPixelFormatNormalized() and isCompressedPixelFormatFloatingPoint() returns true
.
bool Magnum:: isCompressedPixelFormatSrgb(CompressedPixelFormat format) new in Git master
#include <Magnum/PixelFormat.h>
Whether given compressed pixel format is sRGB.
Returns true
for *Srgb
formats, false
otherwise. If this function returns true
, isCompressedPixelFormatNormalized() also returns true
. Expects that the pixel format is not implementation-specific.
Debug& Magnum:: operator<<(Debug& debug,
CompressedPixelFormat value)
#include <Magnum/PixelFormat.h>
Debug output operator.
bool Magnum:: isCompressedPixelFormatImplementationSpecific(CompressedPixelFormat format) constexpr
#include <Magnum/PixelFormat.h>
Whether a CompressedPixelFormat value wraps an implementation-specific identifier.
Returns true
if value of format
has its highest bit set, false
otherwise. Use compressedPixelFormatWrap() and compressedPixelFormatUnwrap() to wrap/unwrap an implementation-specific indentifier to/from CompressedPixelFormat.
#include <Magnum/PixelFormat.h>
template<class T>
CompressedPixelFormat Magnum:: compressedPixelFormatWrap(T implementationSpecific) constexpr
Wrap an implementation-specific pixel format identifier in a CompressedPixelFormat.
Sets the highest bit on implementationSpecific
to mark it as implementation-specific. Expects that implementationSpecific
fits into the remaining 31 bits. Use compressedPixelFormatUnwrap() for the inverse operation.
#include <Magnum/PixelFormat.h>
template<class T = UnsignedInt>
T Magnum:: compressedPixelFormatUnwrap(CompressedPixelFormat format) constexpr
Unwrap an implementation-specific pixel format identifier from a CompressedPixelFormat.
Unsets the highest bit from format
to extract the implementation-specific value. Expects that format
has it set. Use compressedPixelFormatWrap() for the inverse operation.
Debug& Magnum:: operator<<(Debug& debug,
ResourceState value)
#include <Magnum/Resource.h>
Debug output operator.
Debug& Magnum:: operator<<(Debug& debug,
const ResourceKey& value)
#include <Magnum/Resource.h>
Debug output operator.
Debug& Magnum:: operator<<(Debug& debug,
SamplerFilter value)
#include <Magnum/Sampler.h>
Debug output operator.
Debug& Magnum:: operator<<(Debug& debug,
SamplerMipmap value)
#include <Magnum/Sampler.h>
Debug output operator.
Debug& Magnum:: operator<<(Debug& debug,
SamplerWrapping value)
#include <Magnum/Sampler.h>
Debug output operator.
Debug& Magnum:: operator<<(Debug& debug,
VertexFormat value) new in 2020.06
#include <Magnum/VertexFormat.h>
Debug output operator.
bool Magnum:: isVertexFormatImplementationSpecific(VertexFormat format) constexpr new in 2020.06
#include <Magnum/VertexFormat.h>
Whether a VertexFormat value wraps an implementation-specific identifier.
Returns true
if value of format
has its highest bit set, false
otherwise. Use vertexFormatWrap() and vertexFormatUnwrap() to wrap/unwrap an implementation-specific indentifier to/from VertexFormat.
#include <Magnum/VertexFormat.h>
template<class T>
VertexFormat Magnum:: vertexFormatWrap(T implementationSpecific) constexpr new in 2020.06
Wrap an implementation-specific vertex format identifier in VertexFormat.
Sets the highest bit on implementationSpecific
to mark it as implementation-specific. Expects that implementationSpecific
fits into the remaining 31 bits. Use vertexFormatUnwrap() for the inverse operation.
#include <Magnum/VertexFormat.h>
template<class T = UnsignedInt>
T Magnum:: vertexFormatUnwrap(VertexFormat format) constexpr new in 2020.06
Unwrap an implementation-specific vertex format identifier from VertexFormat.
Unsets the highest bit from format
to extract the implementation-specific value. Expects that format
has it set. Use vertexFormatWrap() for the inverse operation.
UnsignedInt Magnum:: vertexFormatSize(VertexFormat format) new in 2020.06
#include <Magnum/VertexFormat.h>
Size of given vertex format.
To get size of a single component, call this function on a result of vertexFormatComponentFormat(). Expects that the vertex format is not implementation-specific.
VertexFormat Magnum:: vertexFormatComponentFormat(VertexFormat format) new in 2020.06
#include <Magnum/VertexFormat.h>
Component format of given vertex format.
The function also removes the normalization aspect from the format — use isVertexFormatNormalized() to query that. Returns for example VertexFormat::1
; calling isVertexFormatNormalized() on the returned value will always give false
. Expects that the vertex format is not implementation-specific.
UnsignedInt Magnum:: vertexFormatComponentCount(VertexFormat format) new in 2020.06
#include <Magnum/VertexFormat.h>
Component count of given vertex format.
Returns 1
for scalar formats and e.g. 3
for VertexFormat::
UnsignedInt Magnum:: vertexFormatVectorCount(VertexFormat format) new in 2020.06
#include <Magnum/VertexFormat.h>
Vector count of given vertex format.
Returns 1
for scalar and vector formats and e.g. 3
for VertexFormat::
UnsignedInt Magnum:: vertexFormatVectorStride(VertexFormat format) new in 2020.06
#include <Magnum/VertexFormat.h>
Vector stride of given vertex format.
Returns type size for scalar and vector formats and e.g. 8
for VertexFormat::6
for VertexFormat::
bool Magnum:: isVertexFormatNormalized(VertexFormat format) new in 2020.06
#include <Magnum/VertexFormat.h>
Whether given vertex format is normalized.
Returns true
for *Normalized
formats, false
otherwise. In particular, floating-point formats are not treated as normalized, even though for example colors might commonly have values only in the range (or normals in the range). Expects that the vertex format is not implementation-specific.
VertexFormat Magnum:: vertexFormat(VertexFormat format,
UnsignedInt componentCount,
bool normalized) new in 2020.06
#include <Magnum/VertexFormat.h>
Assemble a vertex format from parts.
Converts format
to a new format of desired component count and normalization. Expects that componentCount
is 1
, 2
, 3
or 4
and normalized
is true
only for 8- and 16-bit integer formats. Expects that the vertex format is not implementation-specific.
Example usage — picking a format for four-component tangents to match an existing (three-component) vertex normal format:
VertexFormat normalFormat = …; VertexFormat tangentFormat = vertexFormat( normalFormat, 4, isVertexFormatNormalized(normalFormat));
VertexFormat Magnum:: vertexFormat(VertexFormat format,
UnsignedInt vectorCount,
UnsignedInt componentCount,
bool aligned) new in 2020.06
#include <Magnum/VertexFormat.h>
Assemble a matrix vertex format from parts.
Converts format
to a new format of desired component and vertex count and normalization. Expects that both vectorCount
and componentCount
is either 2
, 3
or 4
, and format
is floating-point or 8-/16-bit signed integer. Expects that the vertex format is not implementation-specific.
Variable documentation
DefaultInitT Magnum::DefaultInit constexpr new in Git master
#include <Magnum/Tags.h>
Default initialization tag.
Use for construction with default initialization. The actual meaning of "default" may vary, see documentation of a particular API using this tag for a detailed behavior description.
NoInitT Magnum::NoInit constexpr new in 2020.06
#include <Magnum/Tags.h>
No initialization tag.
Use for construction with no initialization at all.
NoCreateT Magnum::NoCreate constexpr
#include <Magnum/Tags.h>
No creation tag.
Use for construction without creating the underlying OpenGL / Vulkan / ... object. Note that calling anything on objects created this way is not defined (and not checked or guarded in any way) and may result in crashes. If you want delayed object creation with safety checks (however with some extra memory overhead), wrap the objects in an Corrade::
NoAllocateT Magnum::NoAllocate constexpr new in Git master
#include <Magnum/Tags.h>
No allocation tag.
Use for construction without allocating memory.