Deprecated list

See also Deprecated OpenGL API list.

File AbstractMaterialData.h

Use Magnum/Trade/MaterialData.h and the MaterialData class instead.

File Array.h

Use Magnum/Math/Vector3.h instead.

File BoolVector.h

Use Magnum/Math/BitVector.h and the Magnum::Math::BitVector class instead.

File CgltfImporter.h

Use MagnumPlugins/GltfImporter/GltfImporter.h and the Trade::GltfImporter class instead.

File CombineIndexedArrays.h

Use Magnum/MeshTools/Combine.h and Magnum::MeshTools::combineIndexedAttributes() instead.

File Conversion.h

Use Magnum/OvrIntegration/Integration.h instead.

File DistanceField.h

Use Magnum/TextureTools/DistanceFieldGL.h and the DistanceFieldGL class instead.

File DistanceFieldGlyphCache.h

Use Magnum/Text/DistanceFieldGlyphCacheGL.h and the DistanceFieldGlyphCacheGL class instead.

Member DOUBLE_EQUALITY_PRECISION

Use Magnum::Math::TypeTraits::epsilon() instead.

File Enums.h

All functionality in this header has been deprecated and moved elsewhere. Use headers corresponding to the suggested replacement APIs instead.

File FilterAttributes.h

Use Magnum/MeshTools/Filter.h instead.

File FlattenMeshHierarchy.h

Use Magnum/SceneTools/Hierarchy.h and the SceneTools::absoluteFieldTransformations2D() / SceneTools::absoluteFieldTransformations3D() functions instead.

File FlattenTransformationHierarchy.h

Use Magnum/SceneTools/Hierarchy.h and the SceneTools::absoluteFieldTransformations2D() / SceneTools::absoluteFieldTransformations3D() functions instead.

Member FLOAT_EQUALITY_PRECISION

Use Magnum::Math::TypeTraits::epsilon() instead.

File GlyphCache.h

Use Magnum/Text/GlyphCacheGL.h and the GlyphCacheGL class instead.

Member LONG_DOUBLE_EQUALITY_PRECISION

Use Magnum::Math::TypeTraits::epsilon() instead.

Class Magnum::Array1D<T>

Use Math::Vector or Containers::Array1 instead.

Class Magnum::Array2D<T>

Use Math::Vector2 or Containers::Array2 instead.

Class Magnum::Array3D<T>

Use Math::Vector3 or Containers::Array3 instead.

Class Magnum::Array<dimensions, T>

Use Math::Vector instead.

Member Magnum::Audio::AbstractImporter::Feature

Use ImporterFeature instead.

Member Magnum::Audio::AbstractImporter::Features

Use ImporterFeatures instead.

Member Magnum::Audio::DrFlacImporter::DrFlacImporter ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Audio::DrMp3Importer::DrMp3Importer ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Audio::DrWavImporter::DrWavImporter ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Audio::Faad2Importer::Faad2Importer ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Audio::StbVorbisImporter::StbVorbisImporter ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::BoolVector2

Use BitVector2 instead.

Member Magnum::BoolVector3

Use BitVector3 instead.

Member Magnum::BoolVector4

Use BitVector4 instead.

Member Magnum::BulletIntegration::DebugDraw::debugMode () const

Use mode() instead.

Member Magnum::compressedBlockDataSize (CompressedPixelFormat format)

Use compressedPixelFormatBlockDataSize() instead.

Member Magnum::compressedBlockSize (CompressedPixelFormat format)

Use compressedPixelFormatBlockSize() instead.

Member Magnum::DebugTools::bufferData (GL::Buffer&buffer, void*doxygenIsCrapAtOverloadResolution=nullptr)

Use non-templated bufferData() and Containers::arrayCast() instead

Member Magnum::DebugTools::bufferSubData (GL::Buffer&buffer, GLintptr offset, GLsizeiptr size, void*doxygenIsCrapAtOverloadResolution=nullptr)

Use non-templated bufferSubData() and Containers::arrayCast() instead

Member Magnum::DebugTools::GLFrameProfiler

Use FrameProfilerGL instead.

Class Magnum::DebugTools::Profiler

Obsolete, use FrameProfiler instead.

Member Magnum::DebugTools::textureSubImage (GL::Texture2D&texture, Int level, const Range2Di&range, GL::BufferImage2D&image, GL::BufferUsage usage)

As these APIs are mainly meant to be used for testing and verification, there's little point in having a variant that puts the data into a pixel buffer by creating a temporary framebuffer. Use textureSubImage(GL::Texture2D&, Int, const Range2Di&, Image2D&) instead or populate the buffer using GL::Framebuffer::read(const Range2Di&, GL::BufferImage2D&, GL::BufferUsage) on a non-temporary framebuffer.

Member Magnum::DebugTools::textureSubImage (GL::Texture2D&texture, Int level, const Range2Di&range, GL::BufferImage2D && image, GL::BufferUsage usage)

As these APIs are mainly meant to be used for testing and verification, there's little point in having a variant that puts the data into a buffer image by creating a temporary framebuffer. Use textureSubImage(GL::Texture2D&, Int, const Range2Di&, Image2D&&) instead or populate the buffer image directly using GL::Framebuffer::read(const Range2Di&, GL::BufferImage2D&&, GL::BufferUsage) on a non-temporary framebuffer.

Member Magnum::DebugTools::textureSubImage (GL::CubeMapTexture&texture, GL::CubeMapCoordinate coordinate, Int level, const Range2Di&range, GL::BufferImage2D&image, GL::BufferUsage usage)

As these APIs are mainly meant to be used for testing and verification, there's little point in having a variant that puts the data into a buffer image by creating a temporary framebuffer. Use textureSubImage(GL::CubeMapTexture&, GL::CubeMapCoordinate, Int, const Range2Di&, Image2D&) instead or populate the buffer image directly using GL::Framebuffer::read(const Range2Di&, GL::BufferImage2D&, GL::BufferUsage) on a non-temporary framebuffer.

Member Magnum::DebugTools::textureSubImage (GL::CubeMapTexture&texture, GL::CubeMapCoordinate coordinate, Int level, const Range2Di&range, GL::BufferImage2D && image, GL::BufferUsage usage)

As these APIs are mainly meant to be used for testing and verification, there's little point in having a variant that puts the data into a buffer image by creating a temporary framebuffer. Use textureSubImage(GL::CubeMapTexture&, GL::CubeMapCoordinate, Int, const Range2Di&, Image2D&) instead or populate the buffer image directly using GL::Framebuffer::read(const Range2Di&, GL::BufferImage2D&, GL::BufferUsage) on a non-temporary framebuffer.

Member Magnum::GL::AbstractShaderProgram::link (std::initializer_list<Containers::Reference<AbstractShaderProgram>> shaders)

Originally meant to batch multiple link operations together in a way that allowed the driver to perform the linking in multiple threads. Superseded by submitLink() and checkLink(), use either those or the zero-argument link() instead. See Asynchronous shader compilation and linking for more information.

Member Magnum::GL::Attribute<location, T>::HalfFloat

Use DataType::Half instead.

Member Magnum::GL::Attribute<location, T>::VectorCount

Use Vectors instead.

Member Magnum::GL::Attribute<location, T>::vectorSize () const

Use vectorStride() instead.

Member Magnum::GL::Context::supportedExtensions () const

Deprecated as it doesn't provide anything that extensionStrings(), Extension::extensions() and isExtensionSupported() wouldn't provide already and only causes extra overhead during context creation.

Member Magnum::GL::DebugOutput::setCallback (void(*callback)(Source, Type, UnsignedInt, Severity, const std::string&, const void*), const void*userParam=nullptr)

Use a Callback taking a Containers::StringView instead.

Member Magnum::GL::DynamicAttribute::HalfFloat

Use DataType::Half instead.

Member Magnum::GL::HalfFloat

Use PixelType::Half instead.

Member Magnum::GL::Mesh::draw (AbstractShaderProgram&shader)

Use AbstractShaderProgram::draw() instead.

Member Magnum::GL::Mesh::draw (AbstractShaderProgram && shader)

Use AbstractShaderProgram::draw() instead.

Member Magnum::GL::Mesh::draw (AbstractShaderProgram&shader, TransformFeedback&xfb, UnsignedInt stream=0)

Use AbstractShaderProgram::drawTransformFeedback() instead.

Member Magnum::GL::Mesh::draw (AbstractShaderProgram && shader, TransformFeedback&xfb, UnsignedInt stream=0)

Use AbstractShaderProgram::drawTransformFeedback() instead.

Member Magnum::GL::Mesh::indexTypeSize () const

Use meshIndexTypeSize() on the value returned from indexType() instead.

Member Magnum::GL::MeshView::draw (AbstractShaderProgram&shader, std::initializer_list<Containers::Reference<MeshView>> meshes)

Use AbstractShaderProgram::draw(const Containers::Iterable<MeshView>&) instead.

Member Magnum::GL::MeshView::draw (AbstractShaderProgram && shader, std::initializer_list<Containers::Reference<MeshView>> meshes)

Use AbstractShaderProgram::draw(const Containers::Iterable<MeshView>&) instead.

Member Magnum::GL::MeshView::draw (AbstractShaderProgram&shader)

Use AbstractShaderProgram::draw() instead.

Member Magnum::GL::MeshView::draw (AbstractShaderProgram && shader)

Use AbstractShaderProgram::draw() instead.

Member Magnum::GL::MeshView::draw (AbstractShaderProgram&shader, TransformFeedback&xfb, UnsignedInt stream=0)

Use AbstractShaderProgram::drawTransformFeedback() instead.

Member Magnum::GL::MeshView::draw (AbstractShaderProgram && shader, TransformFeedback&xfb, UnsignedInt stream=0)

Use AbstractShaderProgram::drawTransformFeedback() instead.

Member Magnum::GL::MeshView::draw (AbstractShaderProgram&shader, Containers::ArrayView<const Containers::Reference<MeshView>> meshes)

Use AbstractShaderProgram::draw(const Containers::Iterable<MeshView>&) instead.

Member Magnum::GL::MeshView::draw (AbstractShaderProgram && shader, Containers::ArrayView<const Containers::Reference<MeshView>> meshes)

Use AbstractShaderProgram::draw(const Containers::Iterable<MeshView>&) instead.

Member Magnum::GL::MeshView::setIndexRange (Int offset, UnsignedInt start, UnsignedInt end)

Use setIndexOffset(Int, UnsignedInt, UnsignedInt) instead.

Member Magnum::GL::MeshView::setIndexRange (Int offset)

Use setIndexOffset(Int) instead.

Member Magnum::GL::pixelSize (PixelFormat format, PixelType type)

Use pixelFormatSize() instead.

Member Magnum::GL::Shader::compile (std::initializer_list<Containers::Reference<Shader>> shaders)

Originally meant to batch multiple compile operations together in a way that allowed the driver to perform the compilation in multiple threads. Superseded by submitCompile() and checkCompile(), use either those or the zero-argument compile() instead. See Asynchronous shader compilation and linking for more information.

Member Magnum::ImGuiIntegration::Context::handleMouseMoveEvent (MouseMoveEvent&event)

Use handlePointerMoveEvent() with a corresponding PointerMoveEvent instance instead.

Member Magnum::ImGuiIntegration::Context::handleMousePressEvent (MouseEvent&event)

Use handlePointerPressEvent() with a corresponding PointerEvent instance instead.

Member Magnum::ImGuiIntegration::Context::handleMouseReleaseEvent (MouseEvent&event)

Use handlePointerReleaseEvent() with a corresponding PointerEvent instance instead.

Member Magnum::ImGuiIntegration::Context::handleMouseScrollEvent (MouseScrollEvent&event)

Use handleScrollEvent() with a corresponding ScrollEvent instance instead.

Member Magnum::ImGuiIntegration::imageButton (GL::Texture2D&texture, const Vector2&size, const Range2D&uvRange={{}, Vector2{1.0f}}, Int framePadding=-1, const Color4&backgroundColor={}, const Color4&tintColor=Color4{1.0f})

Using an implicit ID is no longer possible in newer ImGui. Use imageButton(const char*, GL::Texture2D&, const Vector2&, const Range2D&, const Color4&, const Color4&) instead.

Member Magnum::MaterialTools::DropUnconvertableAttributes

Use PhongToPbrMetallicRoughnessFlag::DropUnconvertibleAttributes instead.

Member Magnum::MaterialTools::FailOnUnconvertableAttributes

Use PhongToPbrMetallicRoughnessFlag::DropUnconvertibleAttributes instead.

Member Magnum::Math::angle (const Quaternion<T>&normalizedA, const Quaternion<T>&normalizedB)

This function historically returned a half-angle instead of the full angle, which is incorrect. Because fixing it would break all current uses of it, it's deprecated in favor of halfAngle(const Quaternion<T>&, const Quaternion<T>&), which returns the same value but is named appropriately. This function will get reintroduced with a correct output after enough time passes to avoid breaking existing code.

Member Magnum::Math::BoolVector

Use BitVector instead.

Member Magnum::Math::Color3<T>::fromSrgb (UnsignedInt srgb)

Use fromSrgbInt() instead.

Member Magnum::Math::Color4<T>::fromSrgb (UnsignedInt srgb, T a=Implementation::fullChannel<T>())

Use fromSrgbInt() instead.

Member Magnum::Math::Color4<T>::fromSrgbAlpha (UnsignedInt srgb)

Use fromSrgbAlphaInt() instead.

Member Magnum::Math::NoInit

Use Magnum::NoInit instead.

Member Magnum::Math::NoInitT

Use Magnum::NoInitT instead.

Member Magnum::MeshTools::combineIndexArrays (const std::vector<std::reference_wrapper<std::vector<UnsignedInt>>>&arrays)

Use combineIndexedAttributes() instead.

Member Magnum::MeshTools::combineIndexArrays (std::initializer_list<std::reference_wrapper<std::vector<UnsignedInt>>> arrays)

Use combineIndexedAttributes() instead.

Member Magnum::MeshTools::combineIndexArrays (const std::vector<UnsignedInt>&interleavedArrays, UnsignedInt stride)

Use combineIndexedAttributes() instead.

Member Magnum::MeshTools::combineIndexedArrays (const std::pair<const std::vector<UnsignedInt>&, std::vector<T>&>&... indexedArrays)

Use combineIndexedAttributes() instead.

Member Magnum::MeshTools::compile (const Trade::MeshData2D&meshData)

Use compile(const Trade::MeshData&, CompileFlags) instead.

Member Magnum::MeshTools::compile (const Trade::MeshData3D&meshData, CompileFlags flags={})

Use compile(const Trade::MeshData&, CompileFlags) instead.

Member Magnum::MeshTools::compressIndices (const std::vector<UnsignedInt>&indices)

Use compressIndices(const Containers::StridedArrayView1D<const UnsignedInt>&, MeshIndexType, Long) instead. The index range isn't returned anymore, use Math::minmax(const Containers::StridedArrayView1D<const T>&) to get it if needed.

Member Magnum::MeshTools::compressIndicesAs (const std::vector<UnsignedInt>&indices)

Use compressIndices(const Containers::StridedArrayView1D<const UnsignedInt>&, MeshIndexType, Long) instead.

Member Magnum::MeshTools::duplicate (const std::vector<UnsignedInt>&indices, const std::vector<T>&data)

Use duplicate(const Containers::StridedArrayView1D<const IndexType>&, const Containers::StridedArrayView1D<const T>&) or duplicateInto() instead.

Member Magnum::MeshTools::filterExceptAttributes (const Trade::MeshData&mesh, Containers::ArrayView<const UnsignedInt> attributes)

Use filterAttributes(const Trade::MeshData&, Containers::BitArrayView) instead.

Member Magnum::MeshTools::filterExceptAttributes (const Trade::MeshData&mesh, std::initializer_list<UnsignedInt> attributes)

Use filterAttributes(const Trade::MeshData&, Containers::BitArrayView) instead.

Member Magnum::MeshTools::filterOnlyAttributes (const Trade::MeshData&mesh, Containers::ArrayView<const UnsignedInt> attributes)

Use filterAttributes(const Trade::MeshData&, Containers::BitArrayView) instead.

Member Magnum::MeshTools::filterOnlyAttributes (const Trade::MeshData&mesh, std::initializer_list<UnsignedInt> attributes)

Use filterAttributes(const Trade::MeshData&, Containers::BitArrayView) instead.

Member Magnum::MeshTools::flipFaceWinding (std::vector<UnsignedInt>&indices)

Use flipFaceWindingInPlace(const Containers::StridedArrayView1D<UnsignedInt>&) instead.

Member Magnum::MeshTools::flipNormals (std::vector<UnsignedInt>&indices, std::vector<Vector3>&normals)

Use flipNormalsInPlace(const Containers::StridedArrayView1D<UnsignedInt>&, const Containers::StridedArrayView1D<Vector3>&) instead.

Member Magnum::MeshTools::flipNormals (std::vector<Vector3>&normals)

Use flipNormalsInPlace(const Containers::StridedArrayView1D<Vector3>&) instead.

Member Magnum::MeshTools::owned (const Trade::MeshData&mesh)

Use copy(const Trade::MeshData&) instead.

Member Magnum::MeshTools::owned (Trade::MeshData && mesh)

Use copy(Trade::MeshData&&) instead.

Member Magnum::MeshTools::removeDuplicates (std::vector<Vector>&data, typename Vector::Type epsilon=Math::TypeTraits<typename Vector::Type>::epsilon())

Use removeDuplicatesFuzzyInPlace() instead.

Member Magnum::MeshTools::subdivide (std::vector<UnsignedInt>&indices, std::vector<Vertex>&vertices, Interpolator interpolator)

Use subdivide(Containers::Array<IndexType>&, Containers::Array<Vertex>&vertices, Interpolator) or subdivideInPlace() instead.

Member Magnum::MeshTools::tipsify (std::vector<UnsignedInt>&indices, UnsignedInt vertexCount, std::size_t cacheSize)

Use tipsifyInPlace() instead.

Member Magnum::MeshTools::transform2D (const Trade::MeshData&mesh, const Matrix3&transformation, UnsignedInt id, InterleaveFlags flags)

Use transform2D(const Trade::MeshData&, const Matrix3&, UnsignedInt, Int, InterleaveFlags) instead.

Member Magnum::MeshTools::transform2D (Trade::MeshData && mesh, const Matrix3&transformation, UnsignedInt id, InterleaveFlags flags)

Use transform2D(Trade::MeshData&&, const Matrix3&, UnsignedInt, Int, InterleaveFlags) instead.

Member Magnum::MeshTools::transform3D (const Trade::MeshData&mesh, const Matrix4&transformation, UnsignedInt id, InterleaveFlags flags)

Use transform3D(const Trade::MeshData&, const Matrix4&, UnsignedInt, Int, InterleaveFlags) instead.

Member Magnum::MeshTools::transform3D (Trade::MeshData && mesh, const Matrix4&transformation, UnsignedInt id, InterleaveFlags flags)

Use transform3D(Trade::MeshData&&, const Matrix4&, UnsignedInt, Int, InterleaveFlags) instead.

Member Magnum::MeshTools::transformTextureCoordinates2D (const Trade::MeshData&mesh, const Matrix3&transformation, UnsignedInt id, InterleaveFlags flags)

Use transformTextureCoordinates2D(const Trade::MeshData&, const Matrix3&, UnsignedInt, Int, InterleaveFlags) instead.

Member Magnum::MeshTools::transformTextureCoordinates2D (Trade::MeshData && mesh, const Matrix3&transformation, UnsignedInt id, InterleaveFlags flags)

Use transformTextureCoordinates2D(Trade::MeshData&&, const Matrix3&, UnsignedInt, Int, InterleaveFlags) instead.

Member Magnum::operator<< (Debug&debug, const Array3D<T>&value)

Use Math::Vector3 instead.

Member Magnum::operator<< (Debug&debug, const Array1D<T>&value)

Use Math::Vector instead.

Member Magnum::operator<< (Debug&debug, const Array<dimensions, T>&value)

Use Math::Vector instead.

Member Magnum::operator<< (Debug&debug, const Array<dimensions, T>&value)

Use Math::Vector instead.

Member Magnum::operator<< (Debug&debug, const Array1D<T>&value)

Use Math::Vector instead.

Member Magnum::operator<< (Debug&debug, const Array2D<T>&value)

Use Math::Vector2 instead.

Member Magnum::operator<< (Debug&debug, const Array3D<T>&value)

Use Math::Vector3 instead.

Member Magnum::operator<< (Debug&debug, const Array2D<T>&value)

Use Math::Vector2 instead.

Member Magnum::pixelSize (PixelFormat format)

Use pixelFormatSize() instead.

Member Magnum::Platform::AbstractXApplication::InputEvent::Button

Use Pointer instead.

Member Magnum::Platform::AbstractXApplication::InputEvent::Buttons

Use Pointers instead.

Member Magnum::Platform::AbstractXApplication::InputEvent::buttons () const

Use KeyEvent::pointers() or PointerMoveEvent::pointers() instead.

Member Magnum::Platform::AbstractXApplication::InputEvent::Modifier

Use AbstractXApplication::Modifier instead.

Member Magnum::Platform::AbstractXApplication::InputEvent::Modifiers

Use AbstractXApplication::Modifiers instead.

Member Magnum::Platform::AbstractXApplication::KeyEvent::Key

Use AbstractXApplication::Key instead.

Class Magnum::Platform::AbstractXApplication::MouseEvent

Use PointerEvent, pointerPressEvent() and pointerReleaseEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::AbstractXApplication::MouseEvent::WheelDown

Implement scrollEvent() instead.

Member Magnum::Platform::AbstractXApplication::MouseEvent::WheelUp

Implement scrollEvent() instead.

Member Magnum::Platform::AbstractXApplication::mouseMoveEvent (MouseMoveEvent&event)

Use pointerMoveEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Class Magnum::Platform::AbstractXApplication::MouseMoveEvent

Use PointerMoveEvent and pointerMoveEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::AbstractXApplication::mousePressEvent (MouseEvent&event)

Use pointerPressEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::AbstractXApplication::mouseReleaseEvent (MouseEvent&event)

Use pointerReleaseEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Class Magnum::Platform::AndroidApplication::MouseEvent

Use PointerEvent, pointerPressEvent() and pointerReleaseEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Class Magnum::Platform::AndroidApplication::MouseMoveEvent

Use PointerMoveEvent and pointerMoveEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::AndroidApplication::mouseMoveEvent (MouseMoveEvent&event)

Use pointerMoveEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::AndroidApplication::mousePressEvent (MouseEvent&event)

Use pointerPressEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::AndroidApplication::mouseReleaseEvent (MouseEvent&event)

Use pointerReleaseEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::BasicScreen<Application>::MouseEvent

Use PointerEvent, pointerPressEvent() and pointerReleaseEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::BasicScreen<Application>::mouseMoveEvent (MouseMoveEvent&event)

Use pointerMoveEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::BasicScreen<Application>::MouseMoveEvent

Use PointerMoveEvent and pointerMoveEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::BasicScreen<Application>::mousePressEvent (MouseEvent&event)

Use pointerPressEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::BasicScreen<Application>::mouseReleaseEvent (MouseEvent&event)

Use pointerReleaseEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::BasicScreen<Application>::mouseScrollEvent (MouseScrollEvent&event)

Use scrollEvent() instead, which isn't semantically tied to just a mouse.

Member Magnum::Platform::BasicScreen<Application>::MouseScrollEvent

Use ScrollEvent and scrollEvent() instead, which isn't semantically tied to just a mouse.

Member Magnum::Platform::EmscriptenApplication::GLConfiguration::PreferLowPowerToHighPerformance

Use Flag::PowerPreferenceLowPower instead.

Member Magnum::Platform::EmscriptenApplication::InputEvent::Modifier

Use EmscriptenApplication::Modifier instead.

Member Magnum::Platform::EmscriptenApplication::InputEvent::Modifiers

Use EmscriptenApplication::Modifiers instead.

Member Magnum::Platform::EmscriptenApplication::KeyEvent::Key

Use EmscriptenApplication::Key instead.

Class Magnum::Platform::EmscriptenApplication::MouseEvent

Use PointerEvent, pointerPressEvent() and pointerReleaseEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::EmscriptenApplication::mouseMoveEvent (MouseMoveEvent&event)

Use pointerMoveEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Class Magnum::Platform::EmscriptenApplication::MouseMoveEvent

Use PointerMoveEvent and pointerMoveEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::EmscriptenApplication::mousePressEvent (MouseEvent&event)

Use pointerPressEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::EmscriptenApplication::mouseReleaseEvent (MouseEvent&event)

Use pointerReleaseEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::EmscriptenApplication::mouseScrollEvent (MouseScrollEvent&event)

Use scrollEvent() instead, which isn't semantically tied to just a mouse.

Class Magnum::Platform::EmscriptenApplication::MouseScrollEvent

Use ScrollEvent and scrollEvent() instead, which isn't semantically tied to just a mouse.

Member Magnum::Platform::GlfwApplication::Configuration::CursorMode

Use GlfwApplication::setCursor() instead.

Member Magnum::Platform::GlfwApplication::Configuration::cursorMode () const

Use GlfwApplication::cursor() instead.

Member Magnum::Platform::GlfwApplication::Configuration::Disabled

Use GlfwApplication::setCursor() with Cursor::HiddenLocked instead.

Member Magnum::Platform::GlfwApplication::Configuration::Floating

Use WindowFlag::AlwaysOnTop instead.

Member Magnum::Platform::GlfwApplication::Configuration::Hidden

Use GlfwApplication::setCursor() with Cursor::Hidden instead.

Member Magnum::Platform::GlfwApplication::Configuration::Normal

Use GlfwApplication::setCursor() with Cursor::Arrow (or any other) instead.

Member Magnum::Platform::GlfwApplication::Configuration::setCursorMode (CursorMode cursorMode)

Use GlfwApplication::setCursor() instead.

Member Magnum::Platform::GlfwApplication::InputEvent::Modifier

Use GlfwApplication::Modifier instead.

Member Magnum::Platform::GlfwApplication::InputEvent::Modifiers

Use GlfwApplication::Modifiers instead.

Member Magnum::Platform::GlfwApplication::KeyEvent::Key

Use GlfwApplication::Key instead.

Member Magnum::Platform::GlfwApplication::KeyEvent::keyName (GlfwApplication::Key key)

Use GlfwApplication::keyName() instead.

Class Magnum::Platform::GlfwApplication::MouseEvent

Use PointerEvent, pointerPressEvent() and pointerReleaseEvent() instead, which is a better abstraction for covering both mouse and touch input.

Member Magnum::Platform::GlfwApplication::mouseMoveEvent (MouseMoveEvent&event)

Use pointerMoveEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Class Magnum::Platform::GlfwApplication::MouseMoveEvent

Use PointerMoveEvent and pointerMoveEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::GlfwApplication::mousePressEvent (MouseEvent&event)

Use pointerPressEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::GlfwApplication::mouseReleaseEvent (MouseEvent&event)

Use pointerReleaseEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::GlfwApplication::mouseScrollEvent (MouseScrollEvent&event)

Use scrollEvent() instead, which isn't semantically tied to just a mouse.

Class Magnum::Platform::GlfwApplication::MouseScrollEvent

Use ScrollEvent and scrollEvent() instead, which isn't semantically tied to just a mouse.

Member Magnum::Platform::Sdl2Application::InputEvent::Modifier

Use Sdl2Application::Modifier instead.

Member Magnum::Platform::Sdl2Application::InputEvent::Modifiers

Use Sdl2Application::Modifiers instead.

Member Magnum::Platform::Sdl2Application::isMouseLocked () const

Use cursor() together with Cursor::HiddenLocked instead.

Member Magnum::Platform::Sdl2Application::KeyEvent::Key

Use Sdl2Application::Key instead.

Member Magnum::Platform::Sdl2Application::KeyEvent::keyName (Sdl2Application::Key key)

Use Sdl2Application::keyName() instead.

Class Magnum::Platform::Sdl2Application::MouseEvent

Use PointerEvent, pointerPressEvent() and pointerReleaseEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::Sdl2Application::mouseMoveEvent (MouseMoveEvent&event)

Use pointerMoveEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Class Magnum::Platform::Sdl2Application::MouseMoveEvent

Use PointerMoveEvent and pointerMoveEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::Sdl2Application::mousePressEvent (MouseEvent&event)

Use pointerPressEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::Sdl2Application::mouseReleaseEvent (MouseEvent&event)

Use pointerReleaseEvent() instead, which is a better abstraction for covering both mouse and touch / pen input.

Member Magnum::Platform::Sdl2Application::mouseScrollEvent (MouseScrollEvent&event)

Use scrollEvent() instead, which isn't semantically tied to just a mouse.

Class Magnum::Platform::Sdl2Application::MouseScrollEvent

Use ScrollEvent and scrollEvent() instead, which isn't semantically tied to just a mouse.

Member Magnum::Platform::Sdl2Application::multiGestureEvent (MultiGestureEvent&event)

The SDL event reports relative distance to previous finger positions instead of a relative diameter between multiple pressed fingers, making it practically useless for implementing pinch zoom. It additionally reports everything in normalized coordinates, thus the distance and rotation is only meaningful when the window is an exact square. Use the TwoFingerGesture helper instead and feed it with events coming from pointerPressEvent(), pointerReleaseEvent() and pointerMoveEvent().

Class Magnum::Platform::Sdl2Application::MultiGestureEvent

The SDL event reports relative distance to previous finger positions instead of a relative diameter between multiple pressed fingers, making it practically useless for implementing pinch zoom. It additionally reports everything in normalized coordinates, thus the distance and rotation is only meaningful when the window is an exact square. Use the TwoFingerGesture helper instead and feed it with events coming from pointerPressEvent(), pointerReleaseEvent() and pointerMoveEvent().

Member Magnum::Platform::Sdl2Application::setMinimalLoopPeriod (UnsignedInt milliseconds)

Use setMinimalLoopPeriod(Nanoseconds), which prevents unit mismatch errors, instead.

Member Magnum::Platform::Sdl2Application::setMouseLocked (bool enabled)

Use setCursor() together with Cursor::HiddenLocked instead.

Member Magnum::Primitives::capsule3DSolid (UnsignedInt hemisphereRings, UnsignedInt cylinderRings, UnsignedInt segments, Float halfLength, CapsuleTextureCoords textureCoords)

Use capsule3DSolid(UnsignedInt, UnsignedInt, UnsignedInt, Float, CapsuleFlags) instead.

Member Magnum::Primitives::CapsuleTextureCoords

Use CapsuleFlags instead.

Member Magnum::Primitives::circle2DSolid (UnsignedInt segments, CircleTextureCoords textureCoords)

Use circle2DSolid(UnsignedInt, Circle2DFlags) instead.

Member Magnum::Primitives::circle3DSolid (UnsignedInt segments, CircleTextureCoords textureCoords)

Use circle3DSolid(UnsignedInt, Circle3DFlags) instead.

Member Magnum::Primitives::CircleTextureCoords

Use Circle2DFlags or Circle3DFlags instead.

Member Magnum::Primitives::GenerateNormals

Use GridFlag::Normals instead.

Member Magnum::Primitives::GenerateTextureCoords

Use ConeFlag::TextureCoordinates instead.

Member Magnum::Primitives::GenerateTextureCoords

Use GridFlag::TextureCoordinates instead.

Member Magnum::Primitives::GenerateTextureCoords

Use CylinderFlag::TextureCoordinates instead.

Member Magnum::Primitives::planeSolid (PlaneTextureCoords textureCoords)

Use planeSolid(PlaneFlags) instead.

Member Magnum::Primitives::PlaneTextureCoords

Use PlaneFlags instead.

Member Magnum::Primitives::squareSolid (SquareTextureCoords textureCoords)

Use planeSolid(PlaneFlags) instead.

Member Magnum::Primitives::SquareTextureCoords

Use SquareFlags instead.

Member Magnum::Primitives::uvSphereSolid (UnsignedInt rings, UnsignedInt segments, UVSphereTextureCoords textureCoords)

Use uvSphereSolid(UnsignedInt, UnsignedInt, UVSphereFlags) instead.

Member Magnum::Primitives::UVSphereTextureCoords

Use UVSphereFlags instead.

Member Magnum::SceneTools::flattenMeshHierarchy2D (const Trade::SceneData&scene, const Matrix3&globalTransformation={})

Use absoluteFieldTransformations2D(const Trade::SceneData&, Trade::SceneField, const Matrix3&) with Trade::SceneField::Mesh together with Trade::SceneData::meshesMaterialsAsArray() instead.

Member Magnum::SceneTools::flattenMeshHierarchy2DInto (const Trade::SceneData&scene, const Containers::StridedArrayView1D<Matrix3>&transformations, const Matrix3&globalTransformation={})

Use absoluteFieldTransformations2DInto(const Trade::SceneData&, Trade::SceneField, const Containers::StridedArrayView1D<Matrix3>&, const Matrix3&) with Trade::SceneField::Mesh instead.

Member Magnum::SceneTools::flattenMeshHierarchy3D (const Trade::SceneData&scene, const Matrix4&globalTransformation={})

Use absoluteFieldTransformations3D(const Trade::SceneData&, Trade::SceneField, const Matrix4&) with Trade::SceneField::Mesh together with Trade::SceneData::meshesMaterialsAsArray() instead.

Member Magnum::SceneTools::flattenMeshHierarchy3DInto (const Trade::SceneData&scene, const Containers::StridedArrayView1D<Matrix4>&transformations, const Matrix4&globalTransformation={})

Use absoluteFieldTransformations3DInto(const Trade::SceneData&, Trade::SceneField, const Containers::StridedArrayView1D<Matrix4>&, const Matrix4&) with Trade::SceneField::Mesh instead.

Member Magnum::SceneTools::flattenTransformationHierarchy2D (const Trade::SceneData&scene, UnsignedInt fieldId, const Matrix3&globalTransformation={})

Use absoluteFieldTransformations2D(const Trade::SceneData&, UnsignedInt, const Matrix3&) instead.

Member Magnum::SceneTools::flattenTransformationHierarchy2D (const Trade::SceneData&scene, Trade::SceneField field, const Matrix3&globalTransformation={})

Use absoluteFieldTransformations2D(const Trade::SceneData&, Trade::SceneField, const Matrix3&) instead.

Member Magnum::SceneTools::flattenTransformationHierarchy2DInto (const Trade::SceneData&scene, UnsignedInt fieldId, const Containers::StridedArrayView1D<Matrix3>&transformations, const Matrix3&globalTransformation={})

Use absoluteFieldTransformations2DInto(const Trade::SceneData&, UnsignedInt, const Containers::StridedArrayView1D<Matrix3>&, const Matrix3&) instead.

Member Magnum::SceneTools::flattenTransformationHierarchy2DInto (const Trade::SceneData&scene, Trade::SceneField field, const Containers::StridedArrayView1D<Matrix3>&transformations, const Matrix3&globalTransformation={})

Use absoluteFieldTransformations2DInto(const Trade::SceneData&, Trade::SceneField, const Containers::StridedArrayView1D<Matrix3>&, const Matrix3&) instead.

Member Magnum::SceneTools::flattenTransformationHierarchy3D (const Trade::SceneData&scene, Trade::SceneField field, const Matrix4&globalTransformation={})

Use absoluteFieldTransformations3D(const Trade::SceneData&, Trade::SceneField, const Matrix4&) instead.

Member Magnum::SceneTools::flattenTransformationHierarchy3D (const Trade::SceneData&scene, UnsignedInt fieldId, const Matrix4&globalTransformation={})

Use absoluteFieldTransformations3D(const Trade::SceneData&, UnsignedInt, const Matrix4&) instead.

Member Magnum::SceneTools::flattenTransformationHierarchy3DInto (const Trade::SceneData&scene, UnsignedInt fieldId, const Containers::StridedArrayView1D<Matrix4>&transformations, const Matrix4&globalTransformation={})

Use absoluteFieldTransformations3DInto(const Trade::SceneData&, UnsignedInt, const Containers::StridedArrayView1D<Matrix4>&, const Matrix4&) instead.

Member Magnum::SceneTools::flattenTransformationHierarchy3DInto (const Trade::SceneData&scene, Trade::SceneField field, const Containers::StridedArrayView1D<Matrix4>&transformations, const Matrix4&globalTransformation={})

Use absoluteFieldTransformations3DInto(const Trade::SceneData&, Trade::SceneField, const Containers::StridedArrayView1D<Matrix4>&, const Matrix4&) instead.

Member Magnum::SceneTools::orderClusterParents (const Trade::SceneData&scene)

Use parentsBreadthFirst(const Trade::SceneData&) instead.

Member Magnum::SceneTools::orderClusterParentsInto (const Trade::SceneData&scene, const Containers::StridedArrayView1D<UnsignedInt>&mappingDestination, const Containers::StridedArrayView1D<Int>&parentDestination)

Use parentsBreadthFirstInto(const Trade::SceneData&, const Containers::StridedArrayView1D<UnsignedInt>&, const Containers::StridedArrayView1D<Int>&) instead.

Member Magnum::Shaders::DistanceFieldVector

Use DistanceFieldVectorGL instead.

Member Magnum::Shaders::DistanceFieldVector2D

Use DistanceFieldVectorGL2D instead.

Member Magnum::Shaders::DistanceFieldVector3D

Use DistanceFieldVectorGL3D instead.

Member Magnum::Shaders::DistanceFieldVectorGL<dimensions>::compile (Flags flags)

Use compile(const Configuration&) instead.

Member Magnum::Shaders::DistanceFieldVectorGL<dimensions>::compile (Flags flags, UnsignedInt materialCount, UnsignedInt drawCount)

Use compile(const Configuration&) instead.

Member Magnum::Shaders::DistanceFieldVectorGL<dimensions>::DistanceFieldVectorGL (Flags flags)

Use DistanceFieldVectorGL(const Configuration&) instead.

Member Magnum::Shaders::DistanceFieldVectorGL<dimensions>::DistanceFieldVectorGL (Flags flags, UnsignedInt materialCount, UnsignedInt drawCount)

Use DistanceFieldVectorGL(const Configuration&) instead.

Member Magnum::Shaders::Flat

Use FlatGL instead.

Member Magnum::Shaders::Flat2D

Use FlatGL2D instead.

Member Magnum::Shaders::Flat3D

Use FlatGL3D instead.

Member Magnum::Shaders::FlatGL<dimensions>::compile (Flags flags)

Use compile(const Configuration&) instead.

Member Magnum::Shaders::FlatGL<dimensions>::compile (Flags flags, UnsignedInt materialCount, UnsignedInt drawCount)

Use compile(const Configuration&) instead.

Member Magnum::Shaders::FlatGL<dimensions>::FlatGL (Flags flags)

Use FlatGL(const Configuration&) instead.

Member Magnum::Shaders::FlatGL<dimensions>::FlatGL (Flags flags, UnsignedInt materialCount, UnsignedInt drawCount)

Use FlatGL(const Configuration&) instead.

Member Magnum::Shaders::Generic

Use GenericGL instead.

Member Magnum::Shaders::Generic2D

Use GenericGL2D instead.

Member Magnum::Shaders::Generic3D

Use GenericGL3D instead.

Member Magnum::Shaders::MeshVisualizer

Use MeshVisualizerGL3D instead.

Member Magnum::Shaders::MeshVisualizer2D

Use MeshVisualizerGL2D instead.

Member Magnum::Shaders::MeshVisualizer3D

Use MeshVisualizerGL3D instead.

Member Magnum::Shaders::MeshVisualizerGL2D::compile (Flags flags)

Use compile(const Configuration&) instead.

Member Magnum::Shaders::MeshVisualizerGL2D::compile (Flags flags, UnsignedInt materialCount, UnsignedInt drawCount)

Use compile(const Configuration&) instead.

Member Magnum::Shaders::MeshVisualizerGL2D::MeshVisualizerGL2D (Flags flags)

Use MeshVisualizerGL2D(const Configuration&) instead.

Member Magnum::Shaders::MeshVisualizerGL2D::MeshVisualizerGL2D (Flags flags, UnsignedInt materialCount, UnsignedInt drawCount)

Use MeshVisualizerGL2D(const Configuration&) instead.

Member Magnum::Shaders::MeshVisualizerGL3D::compile (Flags flags)

Use compile(const Configuration&) instead.

Member Magnum::Shaders::MeshVisualizerGL3D::compile (Flags flags, UnsignedInt materialCount, UnsignedInt drawCount)

Use compile(const Configuration&) instead.

Member Magnum::Shaders::MeshVisualizerGL3D::MeshVisualizerGL3D ()

Use MeshVisualizerGL3D(const Configuration&) instead.

Member Magnum::Shaders::MeshVisualizerGL3D::MeshVisualizerGL3D (Flags flags)

Use MeshVisualizerGL3D(const Configuration&) instead.

Member Magnum::Shaders::MeshVisualizerGL3D::MeshVisualizerGL3D (Flags flags, UnsignedInt materialCount, UnsignedInt drawCount)

Use MeshVisualizerGL3D(const Configuration&) instead.

Member Magnum::Shaders::MeshVisualizerGL3D::setTransformationProjectionMatrix (const Matrix4&matrix)

Use setTransformationMatrix() and setProjectionMatrix() instead.

Member Magnum::Shaders::Phong

Use PhongGL instead.

Member Magnum::Shaders::PhongGL::compile (Flags flags, UnsignedInt lightCount=1)

Use compile(const Configuration&) instead.

Member Magnum::Shaders::PhongGL::compile (Flags flags, UnsignedInt lightCount, UnsignedInt materialCount, UnsignedInt drawCount)

Use compile(const Configuration&) instead.

Member Magnum::Shaders::PhongGL::PhongGL (Flags flags, UnsignedInt lightCount=1)

Use PhongGL(const Configuration&) instead.

Member Magnum::Shaders::PhongGL::PhongGL (Flags flags, UnsignedInt lightCount, UnsignedInt materialCount, UnsignedInt drawCount)

Use PhongGL(const Configuration&) instead.

Member Magnum::Shaders::PhongGL::setLightColor (UnsignedInt id, const Magnum::Color4&color)

Use setLightColor(UnsignedInt, const Magnum::Color3&) instead. The alpha channel isn't used in any way.

Member Magnum::Shaders::PhongGL::setLightColor (const Magnum::Color4&color)

Use setLightColors(std::initializer_list<Magnum::Color3>) with a single item instead — it's short enough to not warrant the existence of a dedicated overload. The alpha channel isn't used in any way.

Member Magnum::Shaders::PhongGL::setLightColors (Containers::ArrayView<const Magnum::Color4> colors)

Use setLightColors(Containers::ArrayView<const Magnum::Color3>) instead. The alpha channel isn't used in any way.

Member Magnum::Shaders::PhongGL::setLightColors (std::initializer_list<Magnum::Color4> colors)

Use setLightColors(std::initializer_list<Magnum::Color3>) instead. The alpha channel isn't used in any way.

Member Magnum::Shaders::PhongGL::setLightPosition (UnsignedInt id, const Vector3&position)

Use setLightPosition(UnsignedInt, const Vector4&) instead. This function sets the fourth component to

Member Magnum::Shaders::PhongGL::setLightPosition (const Vector3&position)

Use setLightPositions(std::initializer_list<Vector4>) with a single item instead — it's short enough to not warrant the existence of a dedicated overload. This function sets the fourth component to

Member Magnum::Shaders::PhongGL::setLightPositions (Containers::ArrayView<const Vector3> positions)

Use setLightPositions(Containers::ArrayView<const Vector4>) instead. This function sets the fourth component to

Member Magnum::Shaders::PhongGL::setLightPositions (std::initializer_list<Vector3> positions)

Use setLightPositions(std::initializer_list<Vector4>) instead. This function sets the fourth component to

Member Magnum::Shaders::Vector

Use VectorGL instead.

Member Magnum::Shaders::Vector2D

Use VectorGL2D instead.

Member Magnum::Shaders::Vector3D

Use VectorGL3D instead.

Member Magnum::Shaders::VectorGL<dimensions>::compile (Flags flags)

Use compile(const Configuration&) instead.

Member Magnum::Shaders::VectorGL<dimensions>::compile (Flags flags, UnsignedInt materialCount, UnsignedInt drawCount)

Use compile(const Configuration&) instead.

Member Magnum::Shaders::VectorGL<dimensions>::VectorGL (Flags flags)

Use VectorGL(const Configuration&) instead.

Member Magnum::Shaders::VectorGL<dimensions>::VectorGL (Flags flags, UnsignedInt materialCount, UnsignedInt drawCount)

Use VectorGL(const Configuration&) instead.

Member Magnum::Shaders::VertexColor

Use VertexColorGL instead.

Member Magnum::Shaders::VertexColor2D

Use VertexColorGL2D instead.

Member Magnum::Shaders::VertexColor3D

Use VertexColorGL3D instead.

Member Magnum::Shaders::VertexColorGL<dimensions>::compile (Flags flags)

Use compile(const Configuration&) instead.

Member Magnum::Shaders::VertexColorGL<dimensions>::compile (Flags flags, UnsignedInt drawCount)

Use compile(const Configuration&) instead.

Member Magnum::Shaders::VertexColorGL<dimensions>::VertexColorGL (Flags flags)

Use VertexColorGL(const Configuration&) instead.

Member Magnum::Shaders::VertexColorGL<dimensions>::VertexColorGL (Flags flags, UnsignedInt drawCount)

Use VertexColorGL(const Configuration&) instead.

Member Magnum::Text::AbstractFont::Feature

Use FontFeature instead.

Member Magnum::Text::AbstractFont::Features

Use FontFeatures instead.

Member Magnum::Text::AbstractFont::layout (const AbstractGlyphCache&cache, Float size, Containers::StringView text)

Use createShaper() and the AbstractShaper class instead.

Member Magnum::Text::AbstractFontConverter::Feature

Use FontConverterFeature instead.

Member Magnum::Text::AbstractFontConverter::Features

Use FontConverterFeatures instead.

Member Magnum::Text::AbstractGlyphCache::AbstractGlyphCache (const Vector2i&size, const Vector2i&padding=Vector2i{1})

Use AbstractGlyphCache(PixelFormat, const Vector2i&, const Vector2i&) instead.

Member Magnum::Text::AbstractGlyphCache::insert (UnsignedInt glyph, const Vector2i&offset, const Range2Di&rectangle)

Use setInvalidGlyph(), addFont() and addGlyph() instead.

Member Magnum::Text::AbstractGlyphCache::operator[] (UnsignedInt glyphId) const

Use glyph() instead.

Member Magnum::Text::AbstractGlyphCache::reserve (const std::vector<Vector2i>&sizes)

Use atlas() and TextureTools::AtlasLandfill::add() instead.

Member Magnum::Text::AbstractGlyphCache::setImage (const Vector2i&offset, const ImageView2D&image)

Copy the glyph data to slices of image() instead and call flushImage() afterwards.

Member Magnum::Text::AbstractGlyphCache::textureSize () const

Use size() instead.

Class Magnum::Text::AbstractLayouter

Use AbstractShaper returned from AbstractFont::createShaper() instead.

Class Magnum::Text::AbstractRenderer

Use Renderer or RendererGL instead, which expose a superset of the functionality through a more efficient interface. It doesn't distinguish between 2D and 3D anymore as the original implementation had two-component vertex positions in 3D as well. If you really need a third coordinate for transforming individual glyphs, use a custom Renderer vertex allocator.

Member Magnum::Text::DistanceFieldGlyphCache

Use DistanceFieldGlyphCacheGL instead.

Member Magnum::Text::DistanceFieldGlyphCacheGL::distanceFieldTextureSize () const

Use processedSize() instead.

Member Magnum::Text::DistanceFieldGlyphCacheGL::setDistanceFieldImage (const Vector2i&offset, const ImageView2D&image)

Use setProcessedImage() instead.

Member Magnum::Text::FreeTypeFont::FreeTypeFont ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Text::GlyphCache

Use GlyphCacheGL instead.

Member Magnum::Text::GlyphCacheGL::GlyphCacheGL (GL::TextureFormat internalFormat, const Vector2i&size, const Vector2i&padding=Vector2i{1})

Use GlyphCacheGL(PixelFormat, const Vector2i&, const Vector2i&) instead.

Member Magnum::Text::GlyphCacheGL::GlyphCacheGL (GL::TextureFormat internalFormat, const Vector2i&size, const Vector2i&processedSize, const Vector2i&padding)

Use GlyphCacheGL(PixelFormat, const Vector2i&, PixelFormat, const Vector2i&, const Vector2i&) instead.

Member Magnum::Text::GlyphCacheGL::GlyphCacheGL (const Vector2i&size, const Vector2i&padding=Vector2i{1})

Use GlyphCacheGL(PixelFormat, const Vector2i&, const Vector2i&) and explicitly pass the format instead.

Member Magnum::Text::GlyphCacheGL::GlyphCacheGL (const Vector2i&size, const Vector2i&processedSize, const Vector2i&padding)

Use GlyphCacheGL(PixelFormat, const Vector2i&, PixelFormat, const Vector2i&, const Vector2i&) and explicitly pass the format instead.

Member Magnum::Text::HarfBuzzFont::HarfBuzzFont ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Text::ImageDownload

Use GlyphCacheFeature::ProcessedImageDownload instead.

Member Magnum::Text::Renderer2D

Use Renderer or RendererGL instead, which expose a superset of the functionality through a more efficient interface. It doesn't distinguish between 2D and 3D anymore as the original implementation had two-component vertex positions in 3D as well. If you really need a third coordinate for transforming individual glyphs, use a custom Renderer vertex allocator.

Member Magnum::Text::Renderer3D

Use Renderer or RendererGL instead, which expose a superset of the functionality through a more efficient interface. It doesn't distinguish between 2D and 3D anymore as the original implementation had two-component vertex positions in 3D as well. If you really need a third coordinate for transforming individual glyphs, use a custom Renderer vertex allocator.

Member Magnum::Text::StbTrueTypeFont::StbTrueTypeFont ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::TextureTools::atlas (const Vector2i&atlasSize, const std::vector<Vector2i>&sizes, const Vector2i&padding={})

Use the AtlasLandfill class, which has a vastly better packing efficiency, supports incremental packing and doesn't force the caller to use a std::vector.

Member Magnum::TextureTools::atlasArrayPowerOfTwo (const Vector2i&layerSize, std::initializer_list<Vector2i> sizes)

Use atlasArrayPowerOfTwo(const Vector2i&, std::initializer_list<Vector2i>, const Containers::StridedArrayView1D<Vector3i>&) instead.

Member Magnum::TextureTools::atlasArrayPowerOfTwo (const Vector2i&layerSize, const Containers::StridedArrayView1D<const Vector2i>&sizes)

Use atlasArrayPowerOfTwo(const Vector2i&, const Containers::StridedArrayView1D<const Vector2i>&, const Containers::StridedArrayView1D<Vector3i>&) instead.

Member Magnum::TextureTools::DistanceField

Use DistanceFieldGL instead.

Member Magnum::Trade::AbstractImageConverter::exportToCompressedImage (const ImageView2D&image)

Use convert(const ImageView2D&) instead.

Member Magnum::Trade::AbstractImageConverter::exportToData (const ImageView2D&image)

Use convertToData(const ImageView2D&) instead.

Member Magnum::Trade::AbstractImageConverter::exportToData (const CompressedImageView2D&image)

Use convertToData(const CompressedImageView2D&) instead.

Member Magnum::Trade::AbstractImageConverter::exportToData (const ImageData2D&image)

Use convertToData(const ImageData2D&) instead.

Member Magnum::Trade::AbstractImageConverter::exportToFile (const CompressedImageView2D&image, const std::string&filename)

Use convertToFile(const CompressedImageView2D&, Containers::StringView) instead.

Member Magnum::Trade::AbstractImageConverter::exportToFile (const ImageView2D&image, const std::string&filename)

Use convertToFile(const ImageView2D&, Containers::StringView) instead.

Member Magnum::Trade::AbstractImageConverter::exportToFile (const ImageData2D&image, const std::string&filename)

Use convertToFile(const ImageData2D&, Containers::StringView) instead.

Member Magnum::Trade::AbstractImageConverter::exportToImage (const ImageView2D&image)

Use convert(const ImageView2D&) instead.

Member Magnum::Trade::AbstractImageConverter::Feature

Use ImageConverterFeature instead.

Member Magnum::Trade::AbstractImageConverter::Features

Use ImageConverterFeatures instead.

Member Magnum::Trade::AbstractImporter::doMesh2D (UnsignedInt id)

Implement doMesh() instead.

Member Magnum::Trade::AbstractImporter::doMesh2DCount () const

Implement doMeshCount() instead.

Member Magnum::Trade::AbstractImporter::doMesh2DForName (const std::string&name)

Implement doMeshForName() instead.

Member Magnum::Trade::AbstractImporter::doMesh2DName (UnsignedInt id)

Implement doMeshName() instead.

Member Magnum::Trade::AbstractImporter::doMesh3D (UnsignedInt id)

Implement doMesh() instead.

Member Magnum::Trade::AbstractImporter::doMesh3DCount () const

Implement doMeshCount() instead.

Member Magnum::Trade::AbstractImporter::doMesh3DForName (const std::string&name)

Implement doMeshForName() instead.

Member Magnum::Trade::AbstractImporter::doMesh3DName (UnsignedInt id)

Implement doMeshName() instead.

Member Magnum::Trade::AbstractImporter::doObject2D (UnsignedInt id)

Implement doScene() instead.

Member Magnum::Trade::AbstractImporter::doObject2DCount () const

Implement doObjectCount() instead.

Member Magnum::Trade::AbstractImporter::doObject2DForName (const std::string&name)

Implement doObjectForName() instead.

Member Magnum::Trade::AbstractImporter::doObject2DName (UnsignedInt id)

Implement doObjectName() instead.

Member Magnum::Trade::AbstractImporter::doObject3D (UnsignedInt id)

Implement doScene() instead.

Member Magnum::Trade::AbstractImporter::doObject3DCount () const

Implement doObjectCount() instead.

Member Magnum::Trade::AbstractImporter::doObject3DForName (const std::string&name)

Implement doObjectForName() instead.

Member Magnum::Trade::AbstractImporter::doObject3DName (UnsignedInt id)

Implement doObjectName() instead.

Member Magnum::Trade::AbstractImporter::doOpenData (Containers::ArrayView<const char> data)

Implement doOpenData(Containers::Array<char>&&, DataFlags) instead.

Member Magnum::Trade::AbstractImporter::Feature

Use ImporterFeature instead.

Member Magnum::Trade::AbstractImporter::Features

Use ImporterFeatures instead.

Member Magnum::Trade::AbstractImporter::mesh2D (UnsignedInt id)

Use mesh() instead.

Member Magnum::Trade::AbstractImporter::mesh2DCount () const

Use meshCount() instead.

Member Magnum::Trade::AbstractImporter::mesh2DForName (const std::string&name)

Use meshForName() instead.

Member Magnum::Trade::AbstractImporter::mesh2DName (UnsignedInt id)

Use meshName() instead.

Member Magnum::Trade::AbstractImporter::mesh3D (UnsignedInt id)

Use meshName() instead.

Member Magnum::Trade::AbstractImporter::mesh3DCount () const

Use meshCount() instead.

Member Magnum::Trade::AbstractImporter::mesh3DForName (const std::string&name)

Use meshForName() instead.

Member Magnum::Trade::AbstractImporter::mesh3DName (UnsignedInt id)

Use meshName() instead.

Member Magnum::Trade::AbstractImporter::object2D (UnsignedInt id)

Query object fields on the SceneData object returned from scene() instead, which is shared for both 2D and 3D objects.

Member Magnum::Trade::AbstractImporter::object2D (const std::string&name)

Query object fields on the SceneData object returned from scene() instead, which is shared for both 2D and 3D objects.

Member Magnum::Trade::AbstractImporter::object2DCount () const

Use objectCount() instead, which is shared for both 2D and 3D objects.

Member Magnum::Trade::AbstractImporter::object2DForName (const std::string&name)

Use objectForName() instead, which is shared for both 2D and 3D objects.

Member Magnum::Trade::AbstractImporter::object2DName (UnsignedInt id)

Use objectName() instead, which is shared for both 2D and 3D objects.

Member Magnum::Trade::AbstractImporter::object3D (const std::string&name)

Query object fields on the SceneData object returned from scene() instead, which is shared for both 2D and 3D objects.

Member Magnum::Trade::AbstractImporter::object3D (UnsignedInt id)

Query object fields on the SceneData object returned from scene() instead, which is shared for both 2D and 3D objects.

Member Magnum::Trade::AbstractImporter::object3DCount () const

Use objectCount() instead, which is shared for both 2D and 3D objects.

Member Magnum::Trade::AbstractImporter::object3DForName (const std::string&name)

Use objectForName() instead, which is shared for both 2D and 3D objects.

Member Magnum::Trade::AbstractImporter::object3DName (UnsignedInt id)

Use objectName() instead, which is shared for both 2D and 3D objects.

Member Magnum::Trade::AbstractMaterialData

Use MaterialData instead.

Member Magnum::Trade::AbstractSceneConverter::convertToFile (const std::string&filename, const MeshData&mesh)

Use convertToFile(const MeshData&, Containers::StringView) instead.

Member Magnum::Trade::AnimationData::trackTargetType (UnsignedInt id) const

Use trackTargetName() instead.

Member Magnum::Trade::AnimationTrackData::AnimationTrackData (AnimationTrackType type, AnimationTrackType resultType, AnimationTrackTarget targetName, UnsignedLong target, const Animation::TrackViewStorage<const Float>&view) noexcept

Use either the typed AnimationTrackData(AnimationTrackTarget, UnsignedLong, const Animation::TrackView<const Float, const V, R>&) constructor or the type-erased AnimationTrackData(AnimationTrackTarget, UnsignedLong, AnimationTrackType, AnimationTrackType, const Containers::StridedArrayView1D<const Float>&, const Containers::StridedArrayView1D<const void>&, Animation::Interpolation, Animation::Extrapolation, Animation::Extrapolation) etc. constructors instead.

Member Magnum::Trade::AnimationTrackData::AnimationTrackData (AnimationTrackType type, AnimationTrackTarget targetName, UnsignedLong target, const Animation::TrackViewStorage<const Float>&view) noexcept

Use either the typed AnimationTrackData(AnimationTrackTarget, UnsignedLong, const Animation::TrackView<const Float, const V, R>&) constructor or the type-erased AnimationTrackData(AnimationTrackTarget, UnsignedLong, AnimationTrackType, const Containers::StridedArrayView1D<const Float>&, const Containers::StridedArrayView1D<const void>&, Animation::Interpolation, Animation::Extrapolation, Animation::Extrapolation) etc. constructors instead.

Member Magnum::Trade::AnimationTrackTargetType

Use AnimationTrackTarget instead.

Member Magnum::Trade::AssimpImporter::AssimpImporter ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Trade::AssimpImporter::AssimpImporter (PluginManager::Manager<AbstractImporter>&manager)

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Trade::BasisImageConverter::BasisImageConverter (Format format=Format{})

Direct plugin instantiation isn't a supported use case anymore and thus it isn't possible to pass the format to the constructor. Instantiate through the plugin manager as BasisImageConverter or BasisKtxImageConverter or specify a *.basis or *.ktx2 extension to choose between the formats.

Member Magnum::Trade::BasisImageConverter::Format

Direct plugin instantiation isn't a supported use case anymore and thus it isn't possible to pass the format to BasisImageConverter(Format). Instantiate through the plugin manager as BasisImageConverter or BasisKtxImageConverter or specify a *.basis or *.ktx2 extension to choose between the formats.

Member Magnum::Trade::BasisImporter::BasisImporter ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Trade::BasisImporter::setTargetFormat (TargetFormat format)

Direct plugin instantiation isn't a supported use case anymore and thus it isn't possible to query the current format with an API. Set the format configuration option instead.

Member Magnum::Trade::BasisImporter::targetFormat () const

Direct plugin instantiation isn't a supported use case anymore and thus it isn't possible to query the current format with an API. Either check the format configuration option or compare the name under which was the plugin loaded in plugin() against the aliases listed above.

Member Magnum::Trade::BoolVector2

Use AnimationTrackType::BitVector2 instead.

Member Magnum::Trade::BoolVector3

Use AnimationTrackType::BitVector3 instead.

Member Magnum::Trade::BoolVector4

Use AnimationTrackType::BitVector4 instead.

Class Magnum::Trade::CgltfImporter

Use the GltfImporter plugin instead — this plugin is now just a differently named wrapper over it.

Member Magnum::Trade::ConvertCompressedData

Use ImageConverterFeature::ConvertCompressed2DToData instead.

Member Magnum::Trade::ConvertCompressedFile

Use ImageConverterFeature::ConvertCompressed2DToFile instead.

Member Magnum::Trade::ConvertCompressedImage

Use ImageConverterFeature::Convert2D instead. Since AbstractImageConverter::convert() is now capable of returning both uncompressed and compressed images, this feature is the same as ImageConverterFeature::Convert2D, as opposed to ImageConverterFeature::ConvertCompressed2D, which is about input images.

Member Magnum::Trade::ConvertCompressedLevels1DToData

Use ImageConverterFeature::ConvertCompressed1DToData together with Levels instead.

Member Magnum::Trade::ConvertCompressedLevels1DToFile

Use ImageConverterFeature::ConvertCompressed1DToFile together with Levels instead.

Member Magnum::Trade::ConvertCompressedLevels2DToData

Use ImageConverterFeature::ConvertCompressed2DToData together with Levels instead.

Member Magnum::Trade::ConvertCompressedLevels2DToFile

Use ImageConverterFeature::ConvertCompressed2DToFile together with Levels instead.

Member Magnum::Trade::ConvertCompressedLevels3DToData

Use ImageConverterFeature::ConvertCompressed3DToData together with Levels instead.

Member Magnum::Trade::ConvertCompressedLevels3DToFile

Use ImageConverterFeature::ConvertCompressed3DToFile together with Levels instead.

Member Magnum::Trade::ConvertData

Use ImageConverterFeature::Convert2DToData instead.

Member Magnum::Trade::ConvertFile

Use ImageConverterFeature::Convert2DToFile instead.

Member Magnum::Trade::ConvertImage

Use ImageConverterFeature::Convert2D instead.

Member Magnum::Trade::ConvertLevels1DToData

Use ImageConverterFeature::Convert1DToData together with Levels instead.

Member Magnum::Trade::ConvertLevels1DToFile

Use ImageConverterFeature::Convert1DToFile together with Levels instead.

Member Magnum::Trade::ConvertLevels2DToData

Use ImageConverterFeature::Convert2DToData together with Levels instead.

Member Magnum::Trade::ConvertLevels2DToFile

Use ImageConverterFeature::Convert2DToFile together with Levels instead.

Member Magnum::Trade::ConvertLevels3DToData

Use ImageConverterFeature::Convert3DToData together with Levels instead.

Member Magnum::Trade::ConvertLevels3DToFile

Use ImageConverterFeature::Convert3DToFile together with Levels instead.

Member Magnum::Trade::Cube

Use TextureType::CubeMap instead.

Member Magnum::Trade::Custom

Use animationTrackTargetCustom() and isAnimationTrackTargetCustom() instead.

Member Magnum::Trade::GltfImporter::GltfImporter ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Trade::GltfImporter::GltfImporter (PluginManager::Manager<AbstractImporter>&manager)

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Trade::IcoImporter::IcoImporter ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (CompressedPixelStorage storage, T format, const VectorTypeFor<dimensions, Int>&size, Containers::Array<char> && data, const void*importerState) noexcept

Use ImageData(CompressedPixelStorage, T, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>&size, DataFlags dataFlags, Containers::ArrayView<const void> data, const void*importerState) noexcept

Use ImageData(CompressedPixelFormat, const VectorTypeFor<dimensions, Int>&, DataFlags, Containers::ArrayView<const void>, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (CompressedPixelStorage storage, CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>&size, DataFlags dataFlags, Containers::ArrayView<const void> data, const void*importerState) noexcept

Use ImageData(CompressedPixelStorage, CompressedPixelFormat, const VectorTypeFor<dimensions, Int>&, DataFlags, Containers::ArrayView<const void>, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (PixelFormat format, const VectorTypeFor<dimensions, Int>&size, DataFlags dataFlags, Containers::ArrayView<const void> data, const void*importerState) noexcept

Use ImageData(PixelFormat, const VectorTypeFor<dimensions, Int>&, DataFlags, Containers::ArrayView<const void>, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (PixelStorage storage, PixelFormat format, UnsignedInt formatExtra, UnsignedInt pixelSize, const VectorTypeFor<dimensions, Int>&size, Containers::Array<char> && data, const void*importerState) noexcept

Use ImageData(PixelStorage, PixelFormat, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (PixelStorage storage, T format, const VectorTypeFor<dimensions, Int>&size, DataFlags dataFlags, Containers::ArrayView<const void> data, const void*importerState) noexcept

Use ImageData(PixelStorage, T, const VectorTypeFor<dimensions, Int>&, DataFlags, Containers::ArrayView<const void>, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (CompressedPixelStorage storage, T format, const VectorTypeFor<dimensions, Int>&size, DataFlags dataFlags, Containers::ArrayView<const void> data, const void*importerState) noexcept

Use ImageData(CompressedPixelStorage, T, const VectorTypeFor<dimensions, Int>&, DataFlags, Containers::ArrayView<const void>, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (PixelStorage storage, PixelFormat format, UnsignedInt formatExtra, UnsignedInt pixelSize, const VectorTypeFor<dimensions, Int>&size, DataFlags dataFlags, Containers::ArrayView<const void> data, const void*importerState) noexcept

Use ImageData(PixelStorage, PixelFormat, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&, DataFlags, Containers::ArrayView<const void>, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (PixelStorage storage, T format, U formatExtra, const VectorTypeFor<dimensions, Int>&size, DataFlags dataFlags, Containers::ArrayView<const void> data, const void*importerState) noexcept

Use ImageData(PixelStorage, T, U, const VectorTypeFor<dimensions, Int>&, DataFlags, Containers::ArrayView<const void>, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>&size, Containers::Array<char> && data, const void*importerState) noexcept

Use ImageData(CompressedPixelFormat, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (PixelStorage storage, UnsignedInt format, UnsignedInt formatExtra, UnsignedInt pixelSize, const VectorTypeFor<dimensions, Int>&size, DataFlags dataFlags, Containers::ArrayView<const void> data, const void*importerState) noexcept

Use ImageData(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&, DataFlags, Containers::ArrayView<const void>, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (PixelStorage storage, PixelFormat format, const VectorTypeFor<dimensions, Int>&size, Containers::Array<char> && data, const void*importerState) noexcept

Use ImageData(PixelStorage, PixelFormat, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (PixelStorage storage, PixelFormat format, const VectorTypeFor<dimensions, Int>&size, DataFlags dataFlags, Containers::ArrayView<const void> data, const void*importerState) noexcept

Use ImageData(PixelStorage, PixelFormat, const VectorTypeFor<dimensions, Int>&, DataFlags, Containers::ArrayView<const void>, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (PixelFormat format, const VectorTypeFor<dimensions, Int>&size, Containers::Array<char> && data, const void*importerState) noexcept

Use ImageData(PixelFormat, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (PixelStorage storage, UnsignedInt format, UnsignedInt formatExtra, UnsignedInt pixelSize, const VectorTypeFor<dimensions, Int>&size, Containers::Array<char> && data, const void*importerState) noexcept

Use ImageData(PixelStorage, UnsignedInt, UnsignedInt, UnsignedInt, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (PixelStorage storage, T format, U formatExtra, const VectorTypeFor<dimensions, Int>&size, Containers::Array<char> && data, const void*importerState) noexcept

Use ImageData(PixelStorage, T, U, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (PixelStorage storage, T format, const VectorTypeFor<dimensions, Int>&size, Containers::Array<char> && data, const void*importerState) noexcept

Use ImageData(PixelStorage, T, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::ImageData<dimensions>::ImageData (CompressedPixelStorage storage, CompressedPixelFormat format, const VectorTypeFor<dimensions, Int>&size, Containers::Array<char> && data, const void*importerState) noexcept

Use ImageData(CompressedPixelStorage, CompressedPixelFormat, const VectorTypeFor<dimensions, Int>&, Containers::Array<char>&&, ImageFlags<dimensions>, const void*) instead.

Member Magnum::Trade::Infinite

Use LightType::Directional instead.

Member Magnum::Trade::JpegImageConverter::JpegImageConverter ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Trade::JpegImporter::JpegImporter ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Trade::LightData::Type

Use LightType instead.

Member Magnum::Trade::MaterialData::Flag

The flags are no longer stored directly but generated on-the-fly from attribute data, which makes them less efficient than calling hasAttribute(), isDoubleSided() etc.

Member Magnum::Trade::MaterialData::flags () const

The flags are no longer stored directly but generated on-the-fly from attribute data, which makes them less efficient than calling hasAttribute(), isDoubleSided() etc.

Member Magnum::Trade::MaterialData::Flags

The flags are no longer stored directly but generated on-the-fly from attribute data, which makes them less efficient than calling hasAttribute(), isDoubleSided() etc.

Member Magnum::Trade::MaterialData::tryAttribute (Containers::StringView name) const

Use findAttribute(Containers::StringView) const instead.

Use findAttribute(Containers::StringView) const instead.

Member Magnum::Trade::MaterialData::tryAttribute (UnsignedInt layer, Containers::StringView name) const

Use findAttribute(UnsignedInt, Containers::StringView) const instead.

Use findAttribute(UnsignedInt, Containers::StringView) const instead.

Member Magnum::Trade::MaterialData::tryAttribute (Containers::StringView layer, Containers::StringView name) const

Use findAttribute(Containers::StringView, Containers::StringView) const instead.

Use findAttribute(Containers::StringView, Containers::StringView) const instead.

Member Magnum::Trade::MaterialData::tryAttribute (MaterialLayer layer, Containers::StringView name) const

Use findAttribute(MaterialLayer, Containers::StringView) const instead.

Use findAttribute(UnsignedInt, Containers::StringView) const instead.

Member Magnum::Trade::MaterialData::tryAttribute (Containers::StringView layer, MaterialAttribute name) const

Use findAttribute(Containers::StringView, MaterialAttribute) const instead.

Use findAttribute(Containers::StringView, MaterialAttribute) const instead.

Member Magnum::Trade::MaterialData::tryAttribute (MaterialAttribute name) const

Use findAttribute(MaterialAttribute) const instead.

Use findAttribute(MaterialAttribute) const instead.

Member Magnum::Trade::MaterialData::tryAttribute (MaterialLayer layer, MaterialAttribute name) const

Use findAttribute(MaterialLayer, MaterialAttribute) const instead.

Use findAttribute(UnsignedInt, MaterialAttribute) const instead.

Member Magnum::Trade::MaterialData::tryAttribute (UnsignedInt layer, MaterialAttribute name) const

Use findAttribute(UnsignedInt, MaterialAttribute) const instead.

Use findAttribute(UnsignedInt, MaterialAttribute) const instead.

Member Magnum::Trade::MaterialData::type () const

Use types() instead.

Member Magnum::Trade::MaterialLayerData<layer>::tryAttribute (Containers::StringView name) const

Use findAttribute(Containers::StringView) const instead.

Use findAttribute(Containers::StringView) const instead.

Member Magnum::Trade::MaterialLayerData<layer>::tryAttribute (MaterialAttribute name) const

Use findAttribute(MaterialAttribute) const instead.

Use findAttribute(MaterialAttribute) const instead.

Class Magnum::Trade::MeshData2D

Use MeshData instead.

Member Magnum::Trade::MeshData2D::MeshData2D (const MeshData&other)

Use MeshData directly instead.

Class Magnum::Trade::MeshData3D

Use MeshData instead.

Member Magnum::Trade::MeshData3D::MeshData3D (const MeshData&other)

Use MeshData directly instead.

Class Magnum::Trade::MeshObjectData2D

Use SceneData instead.

Member Magnum::Trade::MeshObjectData2D::MeshObjectData2D (std::vector<UnsignedInt> children, const Vector2&translation, const Complex&rotation, const Vector2&scaling, UnsignedInt instance, Int material, const void*importerState=nullptr)

Use MeshObjectData2D(std::vector<UnsignedInt>, const Vector2&, const Complex&, const Vector2&, UnsignedInt, Int, Int, const void*) instead.

Member Magnum::Trade::MeshObjectData2D::MeshObjectData2D (std::vector<UnsignedInt> children, const Matrix3&transformation, UnsignedInt instance, Int material, const void*importerState=nullptr)

Use MeshObjectData2D(std::vector<UnsignedInt>, const Matrix3&, UnsignedInt, Int, Int, const void*) instead.

Class Magnum::Trade::MeshObjectData3D

Use SceneData instead.

Member Magnum::Trade::MeshObjectData3D::MeshObjectData3D (std::vector<UnsignedInt> children, const Vector3&translation, const Quaternion&rotation, const Vector3&scaling, UnsignedInt instance, Int material, const void*importerState=nullptr)

Use MeshObjectData3D(std::vector<UnsignedInt>, const Vector3&, const Quaternion&, const Vector3&, UnsignedInt, Int, Int, const void*) instead.

Member Magnum::Trade::MeshObjectData3D::MeshObjectData3D (std::vector<UnsignedInt> children, const Matrix4&transformation, UnsignedInt instance, Int material, const void*importerState=nullptr)

Use MeshObjectData3D(std::vector<UnsignedInt>, const Matrix4&, UnsignedInt, Int, Int, const void*) instead.

Member Magnum::Trade::MiniExrImageConverter::MiniExrImageConverter ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Class Magnum::Trade::ObjectData2D

Use SceneData instead.

Class Magnum::Trade::ObjectData3D

Use SceneData instead.

Member Magnum::Trade::ObjectFlag2D

Use SceneData instead.

Member Magnum::Trade::ObjectFlag3D

Use SceneData instead.

Member Magnum::Trade::ObjectFlags2D

Use SceneData instead.

Member Magnum::Trade::ObjectFlags3D

Use SceneData instead.

Member Magnum::Trade::ObjectInstanceType2D

Use SceneData instead.

Member Magnum::Trade::ObjectInstanceType3D

Use SceneData instead.

Member Magnum::Trade::OpenGexImporter::OpenGexImporter ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Trade::OpenGexImporter::OpenGexImporter (PluginManager::Manager<AbstractImporter>&manager)

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Trade::operator<< (Debug&debug, ObjectInstanceType3D value)

Use SceneData instead.

Member Magnum::Trade::operator<< (Debug&debug, MaterialData::Flag value)

The flags are no longer stored directly but generated on-the-fly from attribute data, which makes them less efficient than calling MaterialData::hasAttribute(), MaterialData::isDoubleSided() etc.

Member Magnum::Trade::operator<< (Debug&debug, ObjectFlags2D value)

Use SceneData instead.

Member Magnum::Trade::operator<< (Debug&debug, ObjectFlag3D value)

Use SceneData instead.

Member Magnum::Trade::operator<< (Debug&debug, MaterialData::Flags value)

The flags are no longer stored directly but generated on-the-fly from attribute data, which makes them less efficient than calling MaterialData::hasAttribute(), MaterialData::isDoubleSided() etc.

The flags are no longer stored directly but generated on-the-fly from attribute data, which makes them less efficient than calling MaterialData::hasAttribute(), MaterialData::isDoubleSided(), PhongMaterialData::hasTextureTransformation(), PhongMaterialData::hasTextureCoordinates() etc.

Member Magnum::Trade::operator<< (Debug&debug, PhongMaterialData::Flag value)

The flags are no longer stored directly but generated on-the-fly from attribute data, which makes them less efficient than calling MaterialData::hasAttribute(), MaterialData::isDoubleSided(), PhongMaterialData::hasTextureTransformation(), PhongMaterialData::hasTextureCoordinates() etc.

Member Magnum::Trade::operator<< (Debug&debug, ObjectFlag2D value)

Use SceneData instead.

Member Magnum::Trade::operator<< (Debug&debug, MaterialData::Flags value)

The flags are no longer stored directly but generated on-the-fly from attribute data, which makes them less efficient than calling MaterialData::hasAttribute(), MaterialData::isDoubleSided() etc.

The flags are no longer stored directly but generated on-the-fly from attribute data, which makes them less efficient than calling MaterialData::hasAttribute(), MaterialData::isDoubleSided(), PhongMaterialData::hasTextureTransformation(), PhongMaterialData::hasTextureCoordinates() etc.

Member Magnum::Trade::operator<< (Debug&debug, PhongMaterialData::Flag value)

The flags are no longer stored directly but generated on-the-fly from attribute data, which makes them less efficient than calling MaterialData::hasAttribute(), MaterialData::isDoubleSided(), PhongMaterialData::hasTextureTransformation(), PhongMaterialData::hasTextureCoordinates() etc.

Member Magnum::Trade::operator<< (Debug&debug, MaterialData::Flags value)

The flags are no longer stored directly but generated on-the-fly from attribute data, which makes them less efficient than calling MaterialData::hasAttribute(), MaterialData::isDoubleSided(), PhongMaterialData::hasTextureTransformation(), PhongMaterialData::hasTextureCoordinates() etc.

Member Magnum::Trade::operator<< (Debug&debug, MaterialData::Flag value)

The flags are no longer stored directly but generated on-the-fly from attribute data, which makes them less efficient than calling MaterialData::hasAttribute(), MaterialData::isDoubleSided() etc.

Member Magnum::Trade::operator<< (Debug&debug, ObjectInstanceType2D value)

Use SceneData instead.

Member Magnum::Trade::operator<< (Debug&debug, ObjectFlags3D value)

Use SceneData instead.

Member Magnum::Trade::PhongMaterialData::ambientCoordinateSet () const

Use ambientTextureCoordinates() instead.

Member Magnum::Trade::PhongMaterialData::diffuseCoordinateSet () const

Use diffuseTextureCoordinates() instead.

Member Magnum::Trade::PhongMaterialData::Flag

The flags are no longer stored directly but generated on-the-fly from attribute data, which makes them less efficient than calling hasAttribute(), isDoubleSided(), hasTextureTransformation(), hasTextureCoordinates() etc.

Member Magnum::Trade::PhongMaterialData::Flags

The flags are no longer stored directly but generated on-the-fly from attribute data, which makes them less efficient than calling hasAttribute(), isDoubleSided(), hasTextureTransformation(), hasTextureCoordinates() etc.

Member Magnum::Trade::PhongMaterialData::flags () const

The flags are no longer stored directly but generated on-the-fly from attribute data, which makes them less efficient than calling hasAttribute(), isDoubleSided(), hasTextureTransformation(), hasTextureCoordinates() etc.

Member Magnum::Trade::PhongMaterialData::normalCoordinateSet () const

Use normalTextureCoordinates() instead.

Member Magnum::Trade::PhongMaterialData::PhongMaterialData (Flags flags, MaterialAlphaMode alphaMode, Float alphaMask, Float shininess, const void*importerState=nullptr) noexcept

Populate a MaterialData instance using MaterialData::MaterialData(MaterialTypes, Containers::Array<MaterialAttributeData>&&, const void*) instead. This class is not meant to be constructed directly anymore.

Member Magnum::Trade::PhongMaterialData::PhongMaterialData (Flags flags, const Color4&ambientColor, UnsignedInt ambientTexture, const Color4&diffuseColor, UnsignedInt diffuseTexture, const Color4&specularColor, UnsignedInt specularTexture, UnsignedInt normalTexture, const Matrix3&textureMatrix, MaterialAlphaMode alphaMode, Float alphaMask, Float shininess, const void*importerState=nullptr) noexcept

Populate a MaterialData instance using MaterialData::MaterialData(MaterialTypes, Containers::Array<MaterialAttributeData>&&, const void*) instead. This class is not meant to be constructed directly anymore.

Member Magnum::Trade::PhongMaterialData::PhongMaterialData (Flags flags, const Color4&ambientColor, UnsignedInt ambientTexture, UnsignedInt ambientTextureCoordinates, const Color4&diffuseColor, UnsignedInt diffuseTexture, UnsignedInt diffuseTextureCoordinates, const Color4&specularColor, UnsignedInt specularTexture, UnsignedInt specularTextureCoordinates, UnsignedInt normalTexture, UnsignedInt normalTextureCoordinates, const Matrix3&textureMatrix, MaterialAlphaMode alphaMode, Float alphaMask, Float shininess, const void*importerState=nullptr) noexcept

Populate a MaterialData instance using MaterialData::MaterialData(MaterialTypes, Containers::Array<MaterialAttributeData>&&, const void*) instead. This class is not meant to be constructed directly anymore.

Member Magnum::Trade::PhongMaterialData::specularCoordinateSet () const

Use specularTextureCoordinates() instead.

Member Magnum::Trade::PhongMaterialData::TextureCoordinateSets

Use Flag::TextureCoordinates instead.

Member Magnum::Trade::PhongMaterialData::textureMatrix () const

Because the material may now also define per-texture transformations, which take precedence over the common one, this value is misleading. Use either commonTextureMatrix() or separate ambientTextureMatrix(), diffuseTextureMatrix(), specularTextureMatrix() and normalTextureMatrix() accessors instead.

Member Magnum::Trade::PngImageConverter::PngImageConverter ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Trade::PngImporter::PngImporter ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Trade::SceneData::children2D () const

Use childrenFor() with -1 passed as the object argument.

Member Magnum::Trade::SceneData::children3D () const

Use childrenFor() with -1 passed as the object argument.

Member Magnum::Trade::SceneData::SceneData (std::vector<UnsignedInt> children2D, std::vector<UnsignedInt> children3D, const void*importerState=nullptr)

Use SceneData(SceneMappingType, UnsignedLong, Containers::Array<char>&&, Containers::Array<SceneFieldData>&&, const void*) instead.

Member Magnum::Trade::StanfordImporter::StanfordImporter ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Trade::StbImageConverter::Format

Direct plugin instantiation isn't a supported use case anymore and thus it isn't possible to pass the format to StbImageConverter(Format). Instantiate through the plugin manager through one of the aliases mentioned above or specify an appropriate extension to choose among the formats.

Member Magnum::Trade::StbImageConverter::StbImageConverter (Format format)

Direct plugin instantiation isn't a supported use case anymore and thus it isn't possible to pass the format to the constructor. Instantiate through the plugin manager through one of the aliases mentioned above or specify an appropriate extension to choose among the formats.

Member Magnum::Trade::StbImageImporter::StbImageImporter ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Trade::StlImporter::StlImporter ()

Direct plugin instantiation isn't a supported use case anymore, instantiate through the plugin manager instead.

Member Magnum::Trade::TextureData::Type

Use TextureType instead.

Class Magnum::Trade::TinyGltfImporter

Use the actually lightweight and more robust GltfImporter plugin instead.

Member Magnum::Vk::hasVkFormat (Magnum::VertexFormat format)

Use hasVertexFormat() instead.

Member Magnum::Vk::hasVkFormat (Magnum::PixelFormat format)

Use hasPixelFormat(Magnum::PixelFormat) instead.

Member Magnum::Vk::hasVkFormat (Magnum::CompressedPixelFormat format)

Use hasPixelFormat(Magnum::CompressedPixelFormat) instead.

Member Magnum::Vk::hasVkIndexType (Magnum::MeshIndexType type)

All generic index types are available in Vulkan.

Member Magnum::Vk::hasVkPrimitiveTopology (Magnum::MeshPrimitive primitive)

Use hasMeshPrimitive() instead.

Member Magnum::Vk::hasVkSamplerAddressMode (Magnum::SamplerWrapping wrapping)

All generic sampler wrapping modes are available in Vulkan.

Member Magnum::Vk::samplerWrapping (const Math::Vector<dimensions, Magnum::SamplerWrapping>&wrapping)

Use samplerWrapping() instead.

Member Magnum::Vk::vkFilter (Magnum::SamplerFilter filter)

Use samplerFilter() instead.

Member Magnum::Vk::vkFormat (Magnum::PixelFormat format)

Use pixelFormat(Magnum::PixelFormat) instead.

Member Magnum::Vk::vkFormat (Magnum::VertexFormat format)

Use vertexFormat() instead.

Member Magnum::Vk::vkFormat (Magnum::CompressedPixelFormat format)

Use pixelFormat(Magnum::CompressedPixelFormat) instead.

Member Magnum::Vk::vkIndexType (Magnum::MeshIndexType type)

Use meshIndexType() instead.

Member Magnum::Vk::vkPrimitiveTopology (Magnum::MeshPrimitive primitive)

Use meshPrimitive() instead.

Member Magnum::Vk::vkSamplerAddressMode (Magnum::SamplerWrapping wrapping)

Use samplerWrapping() instead.

Member Magnum::Vk::vkSamplerAddressMode (const Math::Vector<dimensions, Magnum::SamplerWrapping>&wrapping)

Use samplerWrapping() instead.

Member Magnum::Vk::vkSamplerMipmapMode (Magnum::SamplerMipmap mipmap)

Use samplerMipmap() instead.

Member MAGNUM_TARGET_DESKTOP_GLES

Use MAGNUM_TARGET_EGL instead.

Member MAGNUM_TARGET_GLES3

This macro is simply an inverse of MAGNUM_TARGET_GLES2, use that one instead.

Member MAGNUM_TARGET_HEADLESS

Use MAGNUM_TARGET_EGL instead.

Directory MagnumPlugins/CgltfImporter

Use the Trade::GltfImporter plugin instead.

Directory MagnumPlugins/TinyGltfImporter

Use the Trade::GltfImporter plugin instead.

File MeshData2D.h

Use Magnum/Trade/MeshData.h and the MeshData class instead.

File MeshData3D.h

Use Magnum/Trade/MeshData.h and the MeshData class instead.

File ObjectData2D.h

Use Magnum/Trade/SceneData.h and the SceneData class instead.

File ObjectData3D.h

Use Magnum/Trade/SceneData.h and the SceneData class instead.

File OrderClusterParents.h

Use Magnum/SceneTools/Hierarchy.h and the SceneTools::parentsBreadthFirst() function instead.

File Profiler.h

Obsolete, use Magnum/DebugTools/FrameProfiler.h and the Magnum::DebugTools::FrameProfiler class instead.

File Reference.h

Use Magnum/MeshTools/Copy.h instead.

File TinyGltfImporter.h

Use MagnumPlugins/GltfImporter/GltfImporter.h and the Trade::GltfImporter class instead.

File VertexColor.h

Use Magnum/Shaders/VertexColorGL.h, the VertexColorGL class and related typedefs instead.