Magnum::SceneGraph namespace

Scene graph library.

Managing object hierarchy, transformations and interactions.

This library is built if MAGNUM_WITH_SCENEGRAPH is enabled when building Magnum. To use this library with CMake, request the SceneGraph component of the Magnum package and link to the Magnum::SceneGraph target:

find_package(Magnum REQUIRED SceneGraph)

# ...
target_link_libraries(your-app PRIVATE Magnum::SceneGraph)

See Downloading and building, Usage with CMake and Using the scene graph for more information.

Classes

template<class T>
class AbstractBasicTranslationRotation2D
Base transformation for two-dimensional scenes supporting translation and rotation.
template<class T>
class AbstractBasicTranslationRotation3D
Base transformation for three-dimensional scenes supporting translation and rotation.
template<class T>
class AbstractBasicTranslationRotationScaling2D
Base transformation for two-dimensional scenes supporting translation, rotation and scaling.
template<class T>
class AbstractBasicTranslationRotationScaling3D
Base transformation for three-dimensional scenes supporting translation, rotation and scaling.
template<UnsignedInt dimensions, class T>
class AbstractFeature
Base for object features.
template<UnsignedInt dimensions, class T>
class AbstractFeatureGroup
Base for group of features.
template<UnsignedInt dimensions, class Derived, class T>
class AbstractGroupedFeature
Base for grouped features.
template<UnsignedInt dimensions, class T>
class AbstractObject
Base for objects.
template<UnsignedInt dimensions, class T>
class AbstractTransformation
Base for transformations.
template<UnsignedInt dimensions, class T, class TranslationType = T>
class AbstractTranslation
Base transformation for two-dimensional scenes supporting translation.
template<UnsignedInt dimensions, class T>
class Animable
Animable.
template<UnsignedInt dimensions, class T>
class AnimableGroup
Group of animables.
template<class T>
class BasicDualComplexTransformation
Two-dimensional transformation implemented using dual complex numbers.
template<class T>
class BasicDualQuaternionTransformation
Three-dimensional transformation implemented using dual quaternions.
template<class T>
class BasicMatrixTransformation2D
Two-dimensional transformation implemented using matrices.
template<class T>
class BasicMatrixTransformation3D
Three-dimensional transformation implemented using matrices.
template<class T>
class BasicRigidMatrixTransformation2D
Two-dimensional rigid transformation implemented using matrices.
template<class T>
class BasicRigidMatrixTransformation3D
Three-dimensional rigid transformation implemented using matrices.
template<class T>
class BasicTranslationRotationScalingTransformation2D
Two-dimensional transformation implemented using translation, rotation and scaling.
template<class T>
class BasicTranslationRotationScalingTransformation3D
Three-dimensional transformation implemented using translation, rotation and scaling.
template<UnsignedInt dimensions, class T>
class Camera
Camera.
template<UnsignedInt dimensions, class T>
class Drawable
Drawable.
template<UnsignedInt dimensions, class Feature, class T>
class FeatureGroup
Group of features.
template<class Transformation>
class Object
Object.
template<class Transformation>
class Scene
Scene.
template<UnsignedInt dimensions, class T, class TranslationType = T>
class TranslationTransformation
Translation-only transformation.

Enums

enum class CachedTransformation: UnsignedByte { Absolute = 1 << 0, InvertedAbsolute = 1 << 1 }
Which transformation to cache in given feature.
enum class AnimationState: UnsignedByte { Stopped, Paused, Running }
Animation state.
enum class AspectRatioPolicy: UnsignedByte { NotPreserved, Extend, Clip }
Camera aspect ratio policy.

Typedefs

using CachedTransformations = Containers::EnumSet<CachedTransformation>
Which transformations to cache in this feature.
template<class T>
using AbstractBasicFeature2D = AbstractFeature<2, T>
Base feature for two-dimensional scenes.
using AbstractFeature2D = AbstractBasicFeature2D<Float>
Base feature for two-dimensional float scenes.
template<class T>
using AbstractBasicFeature3D = AbstractFeature<3, T>
Base feature for three-dimensional scenes.
using AbstractFeature3D = AbstractBasicFeature3D<Float>
Base feature for three-dimensional float scenes.
template<class Derived, class T>
using AbstractBasicGroupedFeature2D = AbstractGroupedFeature<2, Derived, T>
Base grouped feature for two-dimensional scenes.
template<class Derived>
using AbstractGroupedFeature2D = AbstractBasicGroupedFeature2D<Derived, Float>
Base grouped feature for two-dimensional float scenes.
template<class Derived, class T>
using AbstractBasicGroupedFeature3D = AbstractGroupedFeature<3, Derived, T>
Base grouped feature for three-dimensional scenes.
template<class Derived>
using AbstractGroupedFeature3D = AbstractBasicGroupedFeature3D<Derived, Float>
Base grouped feature for three-dimensional float scenes.
template<class T>
using AbstractBasicObject2D = AbstractObject<2, T>
Base object for two-dimensional scenes.
using AbstractObject2D = AbstractBasicObject2D<Float>
Base object for two-dimensional float scenes.
template<class T>
using AbstractBasicObject3D = AbstractObject<3, T>
Base object for three-dimensional scenes.
using AbstractObject3D = AbstractBasicObject3D<Float>
Base object for three-dimensional float scenes.
template<class T>
using AbstractBasicTransformation2D = AbstractTransformation<2, T>
Base transformation for two-dimensional scenes.
using AbstractTransformation2D = AbstractBasicTransformation2D<Float>
Base transformation for two-dimensional float scenes.
template<class T>
using AbstractBasicTransformation3D = AbstractTransformation<3, T>
Base transformation for three-dimensional scenes.
using AbstractTransformation3D = AbstractBasicTransformation3D<Float>
Base transformation for three-dimensional float scenes.
template<class T, class TranslationType = T>
using AbstractBasicTranslation2D = AbstractTranslation<2, T, TranslationType>
Base transformation for two-dimensional scenes supporting translation.
using AbstractTranslation2D = AbstractBasicTranslation2D<Float>
Base transformation for two-dimensional float scenes supporting translation.
template<class T, class TranslationType = T>
using AbstractBasicTranslation3D = AbstractTranslation<3, T, TranslationType>
Base transformation for three-dimensional scenes supporting translation.
using AbstractTranslation3D = AbstractBasicTranslation3D<Float>
Base transformation for three-dimensional float scenes supporting translation.
using AbstractTranslationRotation2D = AbstractBasicTranslationRotation2D<Float>
Base transformation for two-dimensional float scenes supporting translation and rotation.
using AbstractTranslationRotation3D = AbstractBasicTranslationRotation3D<Float>
Base transformation for three-dimensional float scenes supporting translation and rotation.
using AbstractTranslationRotationScaling2D = AbstractBasicTranslationRotationScaling2D<Float>
Base transformation for two-dimensional float scenes supporting translation, rotation and scaling.
using AbstractTranslationRotationScaling3D = AbstractBasicTranslationRotationScaling3D<Float>
Base transformation for three-dimensional float scenes supporting translation, rotation and scaling.
template<class T>
using BasicAnimable2D = Animable<2, T>
Animable for two-dimensional scenes.
using Animable2D = BasicAnimable2D<Float>
Animable for two-dimensional float scenes.
template<class T>
using BasicAnimable3D = Animable<3, T>
Animable for three-dimensional scenes.
using Animable3D = BasicAnimable3D<Float>
Animable for three-dimensional float scenes.
template<class T>
using BasicAnimableGroup2D = AnimableGroup<2, T>
Animable group for two-dimensional scenes.
using AnimableGroup2D = BasicAnimableGroup2D<Float>
Animable group for two-dimensional float scenes.
template<class T>
using BasicAnimableGroup3D = AnimableGroup<3, T>
Animable group for three-dimensional scenes.
using AnimableGroup3D = BasicAnimableGroup3D<Float>
Animable group for three-dimensional float scenes.
template<class T>
using BasicCamera2D = Camera<2, T>
Camera for two-dimensional scenes.
using Camera2D = BasicCamera2D<Float>
Camera for two-dimensional float scenes.
template<class T>
using BasicCamera3D = Camera<3, T>
Camera for three-dimensional scenes.
using Camera3D = BasicCamera3D<Float>
Camera for three-dimensional float scenes.
template<class T>
using BasicDrawable2D = Drawable<2, T>
Drawable for two-dimensional scenes.
using Drawable2D = BasicDrawable2D<Float>
Drawable for two-dimensional float scenes.
template<class T>
using BasicDrawable3D = Drawable<3, T>
Drawable for three-dimensional scenes.
using Drawable3D = BasicDrawable3D<Float>
Drawable for three-dimensional float scenes.
template<UnsignedInt dimensions, class T>
using DrawableGroup = FeatureGroup<dimensions, Drawable<dimensions, T>, T>
Group of drawables.
template<class T>
using BasicDrawableGroup2D = DrawableGroup<2, T>
Group of drawables for two-dimensional scenes.
using DrawableGroup2D = BasicDrawableGroup2D<Float>
Group of drawables for two-dimensional float scenes.
template<class T>
using BasicDrawableGroup3D = DrawableGroup<3, T>
Group of drawables for three-dimensional scenes.
using DrawableGroup3D = BasicDrawableGroup3D<Float>
Group of drawables for three-dimensional float scenes.
using DualComplexTransformation = BasicDualComplexTransformation<Float>
Two-dimensional transformation for float scenes implemented using dual complex numbers.
using DualQuaternionTransformation = BasicDualQuaternionTransformation<Float>
Three-dimensional transformation for float scenes implemented using dual quaternions.
template<class Feature, class T>
using BasicFeatureGroup2D = FeatureGroup<2, Feature, T>
Base feature group for two-dimensional scenes.
template<class Feature>
using FeatureGroup2D = BasicFeatureGroup2D<Feature, Float>
Base feature group for two-dimensional float scenes.
template<class Feature, class T>
using BasicFeatureGroup3D = FeatureGroup<3, Feature, T>
Base feature group for three-dimensional scenes.
template<class Feature>
using FeatureGroup3D = BasicFeatureGroup3D<Feature, Float>
Base feature group for three-dimensional float scenes.
using MatrixTransformation2D = BasicMatrixTransformation2D<Float>
Two-dimensional transformation for float scenes implemented using matrices.
using MatrixTransformation3D = BasicMatrixTransformation3D<Float>
Three-dimensional transformation for float scenes implemented using matrices.
using RigidMatrixTransformation2D = BasicRigidMatrixTransformation2D<Float>
Two-dimensional rigid transformation for float scenes implemented using matrices.
using RigidMatrixTransformation3D = BasicRigidMatrixTransformation3D<Float>
Three-dimensional rigid transformation for float scenes implemented using matrices.
using TranslationRotationScalingTransformation2D = BasicTranslationRotationScalingTransformation2D<Float>
Two-dimensional transformation for float scenes implemented using translation, rotation and scaling.
using TranslationRotationScalingTransformation3D = BasicTranslationRotationScalingTransformation3D<Float>
Three-dimensional transformation for float scenes implemented using translation, rotation and scaling.
template<class T, class TranslationType = T>
using BasicTranslationTransformation2D = TranslationTransformation<2, T, TranslationType>
Base transformation for two-dimensional scenes supporting translation.
using TranslationTransformation2D = BasicTranslationTransformation2D<Float>
Base transformation for two-dimensional float scenes supporting translation.
template<class T, class TranslationType = T>
using BasicTranslationTransformation3D = TranslationTransformation<3, T, TranslationType>
Base transformation for three-dimensional scenes supporting translation.
using TranslationTransformation3D = BasicTranslationTransformation3D<Float>
Base transformation for three-dimensional float scenes supporting translation.

Functions

auto operator<<(Debug& debug, AnimationState value) -> Debug&
Debug output operator.

Enum documentation

enum class Magnum::SceneGraph::CachedTransformation: UnsignedByte
#include <Magnum/SceneGraph/AbstractFeature.h>

Which transformation to cache in given feature.

Enumerators
Absolute

Absolute transformation is cached.

If enabled, AbstractFeature::clean() is called when cleaning object.
InvertedAbsolute

Inverted absolute transformation is cached.

If enabled, AbstractFeature::cleanInverted() is called when cleaning object.

enum class Magnum::SceneGraph::AnimationState: UnsignedByte
#include <Magnum/SceneGraph/Animable.h>

Animation state.

Enumerators
Stopped

The animation is stopped. The animation will be started from the beginning when state is changed to AnimationState::Running.
Paused

The animation is stopped. The animation will continue from paused position when state is changed to AnimationState::Running.
Running

The animation is running.

enum class Magnum::SceneGraph::AspectRatioPolicy: UnsignedByte
#include <Magnum/SceneGraph/Camera.h>

Camera aspect ratio policy.

Enumerators
NotPreserved

Don't preserve aspect ratio (default)
Extend

Extend on larger side of view
Clip

Clip on smaller side of view

Typedef documentation

#include <Magnum/SceneGraph/AbstractFeature.h>
template<class T>
using Magnum::SceneGraph::AbstractBasicFeature2D = AbstractFeature<2, T>

Base feature for two-dimensional scenes.

Convenience alternative to AbstractFeature<2, T>. See AbstractFeature for more information.

typedef AbstractBasicFeature2D<Float> Magnum::SceneGraph::AbstractFeature2D
#include <Magnum/SceneGraph/AbstractFeature.h>

Base feature for two-dimensional float scenes.

#include <Magnum/SceneGraph/AbstractFeature.h>
template<class T>
using Magnum::SceneGraph::AbstractBasicFeature3D = AbstractFeature<3, T>

Base feature for three-dimensional scenes.

Convenience alternative to AbstractFeature<3, T>. See AbstractFeature for more information.

typedef AbstractBasicFeature3D<Float> Magnum::SceneGraph::AbstractFeature3D
#include <Magnum/SceneGraph/AbstractFeature.h>

Base feature for three-dimensional float scenes.

#include <Magnum/SceneGraph/AbstractGroupedFeature.h>
template<class Derived, class T>
using Magnum::SceneGraph::AbstractBasicGroupedFeature2D = AbstractGroupedFeature<2, Derived, T>

Base grouped feature for two-dimensional scenes.

Convenience alternative to AbstractGroupedFeature<2, Derived, T>. See AbstractGroupedFeature for more information.

#include <Magnum/SceneGraph/AbstractGroupedFeature.h>
template<class Derived>
using Magnum::SceneGraph::AbstractGroupedFeature2D = AbstractBasicGroupedFeature2D<Derived, Float>

Base grouped feature for two-dimensional float scenes.

Convenience alternative to AbstractBasicGroupedFeature2D<Derived, Float>. See AbstractGroupedFeature for more information.

#include <Magnum/SceneGraph/AbstractGroupedFeature.h>
template<class Derived, class T>
using Magnum::SceneGraph::AbstractBasicGroupedFeature3D = AbstractGroupedFeature<3, Derived, T>

Base grouped feature for three-dimensional scenes.

Convenience alternative to AbstractGroupedFeature<3, Derived, T>. See AbstractGroupedFeature for more information.

#include <Magnum/SceneGraph/AbstractGroupedFeature.h>
template<class Derived>
using Magnum::SceneGraph::AbstractGroupedFeature3D = AbstractBasicGroupedFeature3D<Derived, Float>

Base grouped feature for three-dimensional float scenes.

Convenience alternative to AbstractBasicGroupedFeature3D<Derived, Float>. See AbstractGroupedFeature for more information.

#include <Magnum/SceneGraph/AbstractObject.h>
template<class T>
using Magnum::SceneGraph::AbstractBasicObject2D = AbstractObject<2, T>

Base object for two-dimensional scenes.

Convenience alternative to AbstractObject<2, T>. See AbstractObject for more information.

typedef AbstractBasicObject2D<Float> Magnum::SceneGraph::AbstractObject2D
#include <Magnum/SceneGraph/AbstractObject.h>

Base object for two-dimensional float scenes.

#include <Magnum/SceneGraph/AbstractObject.h>
template<class T>
using Magnum::SceneGraph::AbstractBasicObject3D = AbstractObject<3, T>

Base object for three-dimensional scenes.

Convenience alternative to AbstractObject<3, T>. See AbstractObject for more information.

typedef AbstractBasicObject3D<Float> Magnum::SceneGraph::AbstractObject3D
#include <Magnum/SceneGraph/AbstractObject.h>

Base object for three-dimensional float scenes.

#include <Magnum/SceneGraph/AbstractTransformation.h>
template<class T>
using Magnum::SceneGraph::AbstractBasicTransformation2D = AbstractTransformation<2, T>

Base transformation for two-dimensional scenes.

Convenience alternative to AbstractTransformation<2, T>. See AbstractTransformation for more information.

typedef AbstractBasicTransformation2D<Float> Magnum::SceneGraph::AbstractTransformation2D
#include <Magnum/SceneGraph/AbstractTransformation.h>

Base transformation for two-dimensional float scenes.

#include <Magnum/SceneGraph/AbstractTransformation.h>
template<class T>
using Magnum::SceneGraph::AbstractBasicTransformation3D = AbstractTransformation<3, T>

Base transformation for three-dimensional scenes.

Convenience alternative to AbstractTransformation<3, T>. See AbstractTransformation for more information.

typedef AbstractBasicTransformation3D<Float> Magnum::SceneGraph::AbstractTransformation3D
#include <Magnum/SceneGraph/AbstractTransformation.h>

Base transformation for three-dimensional float scenes.

#include <Magnum/SceneGraph/AbstractTranslation.h>
template<class T, class TranslationType = T>
using Magnum::SceneGraph::AbstractBasicTranslation2D = AbstractTranslation<2, T, TranslationType>

Base transformation for two-dimensional scenes supporting translation.

Convenience alternative to AbstractTranslation<2, T, TranslationType>. See AbstractTranslation for more information.

typedef AbstractBasicTranslation2D<Float> Magnum::SceneGraph::AbstractTranslation2D
#include <Magnum/SceneGraph/AbstractTranslation.h>

Base transformation for two-dimensional float scenes supporting translation.

#include <Magnum/SceneGraph/AbstractTranslation.h>
template<class T, class TranslationType = T>
using Magnum::SceneGraph::AbstractBasicTranslation3D = AbstractTranslation<3, T, TranslationType>

Base transformation for three-dimensional scenes supporting translation.

Convenience alternative to AbstractTranslation<3, T, TranslationType>. See AbstractTranslation for more information.

typedef AbstractBasicTranslation3D<Float> Magnum::SceneGraph::AbstractTranslation3D
#include <Magnum/SceneGraph/AbstractTranslation.h>

Base transformation for three-dimensional float scenes supporting translation.

typedef AbstractBasicTranslationRotation2D<Float> Magnum::SceneGraph::AbstractTranslationRotation2D
#include <Magnum/SceneGraph/AbstractTranslationRotation2D.h>

Base transformation for two-dimensional float scenes supporting translation and rotation.

typedef AbstractBasicTranslationRotation3D<Float> Magnum::SceneGraph::AbstractTranslationRotation3D
#include <Magnum/SceneGraph/AbstractTranslationRotation3D.h>

Base transformation for three-dimensional float scenes supporting translation and rotation.

typedef AbstractBasicTranslationRotationScaling2D<Float> Magnum::SceneGraph::AbstractTranslationRotationScaling2D
#include <Magnum/SceneGraph/AbstractTranslationRotationScaling2D.h>

Base transformation for two-dimensional float scenes supporting translation, rotation and scaling.

typedef AbstractBasicTranslationRotationScaling3D<Float> Magnum::SceneGraph::AbstractTranslationRotationScaling3D
#include <Magnum/SceneGraph/AbstractTranslationRotationScaling3D.h>

Base transformation for three-dimensional float scenes supporting translation, rotation and scaling.

#include <Magnum/SceneGraph/Animable.h>
template<class T>
using Magnum::SceneGraph::BasicAnimable2D = Animable<2, T>

Animable for two-dimensional scenes.

Convenience alternative to Animable<2, T>. See Animable for more information.

typedef BasicAnimable2D<Float> Magnum::SceneGraph::Animable2D
#include <Magnum/SceneGraph/Animable.h>

Animable for two-dimensional float scenes.

#include <Magnum/SceneGraph/Animable.h>
template<class T>
using Magnum::SceneGraph::BasicAnimable3D = Animable<3, T>

Animable for three-dimensional scenes.

Convenience alternative to Animable<3, T>. See Animable for more information.

typedef BasicAnimable3D<Float> Magnum::SceneGraph::Animable3D
#include <Magnum/SceneGraph/Animable.h>

Animable for three-dimensional float scenes.

#include <Magnum/SceneGraph/AnimableGroup.h>
template<class T>
using Magnum::SceneGraph::BasicAnimableGroup2D = AnimableGroup<2, T>

Animable group for two-dimensional scenes.

Convenience alternative to AnimableGroup<2, T>. See Animable for more information.

typedef BasicAnimableGroup2D<Float> Magnum::SceneGraph::AnimableGroup2D
#include <Magnum/SceneGraph/AnimableGroup.h>

Animable group for two-dimensional float scenes.

#include <Magnum/SceneGraph/AnimableGroup.h>
template<class T>
using Magnum::SceneGraph::BasicAnimableGroup3D = AnimableGroup<3, T>

Animable group for three-dimensional scenes.

Convenience alternative to AnimableGroup<3, T>. See Animable for more information.

typedef BasicAnimableGroup3D<Float> Magnum::SceneGraph::AnimableGroup3D
#include <Magnum/SceneGraph/AnimableGroup.h>

Animable group for three-dimensional float scenes.

#include <Magnum/SceneGraph/Camera.h>
template<class T>
using Magnum::SceneGraph::BasicCamera2D = Camera<2, T>

Camera for two-dimensional scenes.

Convenience alternative to Camera<2, T>. See Camera for more information.

typedef BasicCamera2D<Float> Magnum::SceneGraph::Camera2D
#include <Magnum/SceneGraph/Camera.h>

Camera for two-dimensional float scenes.

#include <Magnum/SceneGraph/Camera.h>
template<class T>
using Magnum::SceneGraph::BasicCamera3D = Camera<3, T>

Camera for three-dimensional scenes.

Convenience alternative to Camera<3, T>. See Camera for more information.

typedef BasicCamera3D<Float> Magnum::SceneGraph::Camera3D
#include <Magnum/SceneGraph/Camera.h>

Camera for three-dimensional float scenes.

#include <Magnum/SceneGraph/Drawable.h>
template<class T>
using Magnum::SceneGraph::BasicDrawable2D = Drawable<2, T>

Drawable for two-dimensional scenes.

Convenience alternative to Drawable<2, T>. See Drawable for more information.

typedef BasicDrawable2D<Float> Magnum::SceneGraph::Drawable2D
#include <Magnum/SceneGraph/Drawable.h>

Drawable for two-dimensional float scenes.

#include <Magnum/SceneGraph/Drawable.h>
template<class T>
using Magnum::SceneGraph::BasicDrawable3D = Drawable<3, T>

Drawable for three-dimensional scenes.

Convenience alternative to Drawable<3, T>. See Drawable for more information.

typedef BasicDrawable3D<Float> Magnum::SceneGraph::Drawable3D
#include <Magnum/SceneGraph/Drawable.h>

Drawable for three-dimensional float scenes.

#include <Magnum/SceneGraph/Drawable.h>
template<UnsignedInt dimensions, class T>
using Magnum::SceneGraph::DrawableGroup = FeatureGroup<dimensions, Drawable<dimensions, T>, T>

Group of drawables.

See Drawable for more information.

#include <Magnum/SceneGraph/Drawable.h>
template<class T>
using Magnum::SceneGraph::BasicDrawableGroup2D = DrawableGroup<2, T>

Group of drawables for two-dimensional scenes.

Convenience alternative to DrawableGroup<2, T>. See Drawable for more information.

typedef BasicDrawableGroup2D<Float> Magnum::SceneGraph::DrawableGroup2D
#include <Magnum/SceneGraph/Drawable.h>

Group of drawables for two-dimensional float scenes.

#include <Magnum/SceneGraph/Drawable.h>
template<class T>
using Magnum::SceneGraph::BasicDrawableGroup3D = DrawableGroup<3, T>

Group of drawables for three-dimensional scenes.

Convenience alternative to DrawableGroup<3, T>. See Drawable for more information.

typedef BasicDrawableGroup3D<Float> Magnum::SceneGraph::DrawableGroup3D
#include <Magnum/SceneGraph/Drawable.h>

Group of drawables for three-dimensional float scenes.

typedef BasicDualComplexTransformation<Float> Magnum::SceneGraph::DualComplexTransformation
#include <Magnum/SceneGraph/DualComplexTransformation.h>

Two-dimensional transformation for float scenes implemented using dual complex numbers.

typedef BasicDualQuaternionTransformation<Float> Magnum::SceneGraph::DualQuaternionTransformation
#include <Magnum/SceneGraph/DualQuaternionTransformation.h>

Three-dimensional transformation for float scenes implemented using dual quaternions.

#include <Magnum/SceneGraph/FeatureGroup.h>
template<class Feature, class T>
using Magnum::SceneGraph::BasicFeatureGroup2D = FeatureGroup<2, Feature, T>

Base feature group for two-dimensional scenes.

Convenience alternative to FeatureGroup<2, Feature, T>. See AbstractGroupedFeature for more information.

#include <Magnum/SceneGraph/FeatureGroup.h>
template<class Feature>
using Magnum::SceneGraph::FeatureGroup2D = BasicFeatureGroup2D<Feature, Float>

Base feature group for two-dimensional float scenes.

Convenience alternative to BasicFeatureGroup2D<Feature, Float>. See AbstractGroupedFeature for more information.

#include <Magnum/SceneGraph/FeatureGroup.h>
template<class Feature, class T>
using Magnum::SceneGraph::BasicFeatureGroup3D = FeatureGroup<3, Feature, T>

Base feature group for three-dimensional scenes.

Convenience alternative to FeatureGroup<3, Feature, T>. See AbstractGroupedFeature for more information.

#include <Magnum/SceneGraph/FeatureGroup.h>
template<class Feature>
using Magnum::SceneGraph::FeatureGroup3D = BasicFeatureGroup3D<Feature, Float>

Base feature group for three-dimensional float scenes.

Convenience alternative to BasicFeatureGroup3D<Feature, Float>. See AbstractGroupedFeature for more information.

typedef BasicMatrixTransformation2D<Float> Magnum::SceneGraph::MatrixTransformation2D
#include <Magnum/SceneGraph/MatrixTransformation2D.h>

Two-dimensional transformation for float scenes implemented using matrices.

typedef BasicMatrixTransformation3D<Float> Magnum::SceneGraph::MatrixTransformation3D
#include <Magnum/SceneGraph/MatrixTransformation3D.h>

Three-dimensional transformation for float scenes implemented using matrices.

typedef BasicRigidMatrixTransformation2D<Float> Magnum::SceneGraph::RigidMatrixTransformation2D
#include <Magnum/SceneGraph/RigidMatrixTransformation2D.h>

Two-dimensional rigid transformation for float scenes implemented using matrices.

typedef BasicRigidMatrixTransformation3D<Float> Magnum::SceneGraph::RigidMatrixTransformation3D
#include <Magnum/SceneGraph/RigidMatrixTransformation3D.h>

Three-dimensional rigid transformation for float scenes implemented using matrices.

typedef BasicTranslationRotationScalingTransformation2D<Float> Magnum::SceneGraph::TranslationRotationScalingTransformation2D
#include <Magnum/SceneGraph/TranslationRotationScalingTransformation2D.h>

Two-dimensional transformation for float scenes implemented using translation, rotation and scaling.

typedef BasicTranslationRotationScalingTransformation3D<Float> Magnum::SceneGraph::TranslationRotationScalingTransformation3D
#include <Magnum/SceneGraph/TranslationRotationScalingTransformation3D.h>

Three-dimensional transformation for float scenes implemented using translation, rotation and scaling.

#include <Magnum/SceneGraph/TranslationTransformation.h>
template<class T, class TranslationType = T>
using Magnum::SceneGraph::BasicTranslationTransformation2D = TranslationTransformation<2, T, TranslationType>

Base transformation for two-dimensional scenes supporting translation.

Convenience alternative to TranslationTransformation<2, T, TranslationType>. See TranslationTransformation for more information.

typedef BasicTranslationTransformation2D<Float> Magnum::SceneGraph::TranslationTransformation2D
#include <Magnum/SceneGraph/TranslationTransformation.h>

Base transformation for two-dimensional float scenes supporting translation.

#include <Magnum/SceneGraph/TranslationTransformation.h>
template<class T, class TranslationType = T>
using Magnum::SceneGraph::BasicTranslationTransformation3D = TranslationTransformation<3, T, TranslationType>

Base transformation for three-dimensional scenes supporting translation.

Convenience alternative to TranslationTransformation<3, T, TranslationType>. See TranslationTransformation for more information.

typedef BasicTranslationTransformation3D<Float> Magnum::SceneGraph::TranslationTransformation3D
#include <Magnum/SceneGraph/TranslationTransformation.h>

Base transformation for three-dimensional float scenes supporting translation.

Function documentation

Debug& Magnum::SceneGraph::operator<<(Debug& debug, AnimationState value)
#include <Magnum/SceneGraph/Animable.h>

Debug output operator.