ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Getting rid of <>, part 6: SceneGraph transformations.

pull/278/head
Vladimír Vondruš 13 years ago
parent
cfd405c32c
commit
346ea2feb6
25 changed files with 362 additions and 366 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 50
      src/SceneGraph/AbstractTransformation.h
  2. 30
      src/SceneGraph/AbstractTranslationRotation2D.h
  3. 36
      src/SceneGraph/AbstractTranslationRotation3D.h
  4. 36
      src/SceneGraph/AbstractTranslationRotationScaling2D.h
  5. 46
      src/SceneGraph/AbstractTranslationRotationScaling3D.h
  6. 58
      src/SceneGraph/DualComplexTransformation.h
  7. 58
      src/SceneGraph/DualQuaternionTransformation.h
  8. 53
      src/SceneGraph/MatrixTransformation2D.h
  9. 64
      src/SceneGraph/MatrixTransformation3D.h
  10. 4
      src/SceneGraph/Object.hpp
  11. 63
      src/SceneGraph/RigidMatrixTransformation2D.h
  12. 75
      src/SceneGraph/RigidMatrixTransformation3D.h
  13. 39
      src/SceneGraph/SceneGraph.h
  14. 2
      src/SceneGraph/Test/AnimableTest.cpp
  15. 6
      src/SceneGraph/Test/CameraTest.cpp
  16. 12
      src/SceneGraph/Test/DualComplexTransformationTest.cpp
  17. 12
      src/SceneGraph/Test/DualQuaternionTransformationTest.cpp
  18. 12
      src/SceneGraph/Test/MatrixTransformation2DTest.cpp
  19. 12
      src/SceneGraph/Test/MatrixTransformation3DTest.cpp
  20. 4
      src/SceneGraph/Test/ObjectTest.cpp
  21. 14
      src/SceneGraph/Test/RigidMatrixTransformation2DTest.cpp
  22. 14
      src/SceneGraph/Test/RigidMatrixTransformation3DTest.cpp
  23. 4
      src/SceneGraph/Test/SceneTest.cpp
  24. 16
      src/SceneGraph/instantiation.cpp
  25. 8
      src/Shapes/Test/ShapeTest.cpp

50
src/SceneGraph/AbstractTransformation.h
Unescape View File

@ -25,7 +25,7 @@
*/ */
/** @file /** @file
* @brief Class Magnum::SceneGraph::AbstractTransformation, enum Magnum::SceneGraph::TransformationType, alias Magnum::SceneGraph::AbstractTransformation2D, Magnum::SceneGraph::AbstractTransformation3D * @brief Class Magnum::SceneGraph::AbstractBasicTransformation, enum Magnum::SceneGraph::TransformationType, typedef Magnum::SceneGraph::AbstractTransformation2D, Magnum::SceneGraph::AbstractTransformation3D
*/ */
#include <vector> #include <vector>
@ -50,14 +50,10 @@ When subclassing, you have to:
- Implement all members listed in **Subclass implementation** group above - Implement all members listed in **Subclass implementation** group above
- Provide implicit (parameterless) constructor - Provide implicit (parameterless) constructor
@see @ref scenegraph, AbstractTransformation2D, AbstractTransformation3D @see @ref AbstractTransformation2D, @ref AbstractTransformation3D,
@ref scenegraph
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT template<UnsignedInt dimensions, class T> class MAGNUM_SCENEGRAPH_EXPORT AbstractBasicTransformation {
template<UnsignedInt dimensions, class T>
#else
template<UnsignedInt dimensions, class T = Float>
#endif
class MAGNUM_SCENEGRAPH_EXPORT AbstractTransformation {
public: public:
/** @brief Underlying floating-point type */ /** @brief Underlying floating-point type */
typedef T Type; typedef T Type;
@ -65,8 +61,8 @@ class MAGNUM_SCENEGRAPH_EXPORT AbstractTransformation {
/** @brief Dimension count */ /** @brief Dimension count */
static const UnsignedInt Dimensions = dimensions; static const UnsignedInt Dimensions = dimensions;
explicit AbstractTransformation(); explicit AbstractBasicTransformation();
virtual ~AbstractTransformation() = 0; virtual ~AbstractBasicTransformation() = 0;
#ifdef DOXYGEN_GENERATING_OUTPUT #ifdef DOXYGEN_GENERATING_OUTPUT
/** /**
@ -142,7 +138,7 @@ class MAGNUM_SCENEGRAPH_EXPORT AbstractTransformation {
* @brief Reset object transformation * @brief Reset object transformation
* @return Pointer to self (for method chaining) * @return Pointer to self (for method chaining)
*/ */
AbstractTransformation<dimensions, T>* resetTransformation() { AbstractBasicTransformation<dimensions, T>* resetTransformation() {
doResetTransformation(); doResetTransformation();
return this; return this;
} }
@ -165,39 +161,19 @@ enum class TransformationType: UnsignedByte {
Local = 0x01 Local = 0x01
}; };
#ifndef CORRADE_GCC46_COMPATIBILITY
/** /**
@brief Base for two-dimensional transformations @brief Base transformation for two-dimensional float scenes
Convenience alternative to <tt>%AbstractTransformation<2, T></tt>. See @see @ref AbstractTransformation3D
AbstractTransformation for more information.
@note Not available on GCC < 4.7. Use <tt>%AbstractTransformation<2, T></tt>
instead.
@see AbstractTransformation3D
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT typedef AbstractBasicTransformation<2, Float> AbstractTransformation2D;
template<class T = Float>
#else
template<class T>
#endif
using AbstractTransformation2D = AbstractTransformation<2, T>;
/** /**
@brief Base for three-dimensional transformations @brief Base transformation for three-dimensional float scenes
Convenience alternative to <tt>%AbstractTransformation<3, T></tt>. See @see @ref AbstractTransformation2D
AbstractTransformation for more information.
@note Not available on GCC < 4.7. Use <tt>%AbstractTransformation<3, T></tt>
instead.
@see AbstractTransformation2D
*/ */
#ifdef DOXYGEN_GENERATING_OUTPUT typedef AbstractBasicTransformation<3, Float> AbstractTransformation3D;
template<class T = Float>
#else
template<class T>
#endif
using AbstractTransformation3D = AbstractTransformation<3, T>;
#endif
}} }}

30
src/SceneGraph/AbstractTranslationRotation2D.h
Unescape View File

@ -25,7 +25,7 @@
*/ */
/** @file /** @file
* @brief Class Magnum::SceneGraph::AbstractTranslationRotation2D * @brief Class Magnum::SceneGraph::AbstractBasicTranslationRotation2D, typedef Magnum::SceneGraph::AbstractTranslationRotation2D
*/ */
#include "AbstractTransformation.h" #include "AbstractTransformation.h"
@ -33,18 +33,13 @@
namespace Magnum { namespace SceneGraph { namespace Magnum { namespace SceneGraph {
/** /**
@brief Base for two-dimensional transformations supporting translation and rotation @brief Base translation for two-dimensional scenes supporting translation and rotation
@see @ref scenegraph, AbstractTranslationRotation3D @see @ref AbstractTranslationRotation2D, @ref scenegraph, @ref AbstractBasicTranslationRotation3D
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT template<class T> class AbstractBasicTranslationRotation2D: public AbstractBasicTransformation<2, T> {
template<class T>
#else
template<class T = Float>
#endif
class AbstractTranslationRotation2D: public AbstractTransformation<2, T> {
public: public:
explicit AbstractTranslationRotation2D() = default; explicit AbstractBasicTranslationRotation2D() = default;
/** /**
* @brief Translate object * @brief Translate object
@ -54,7 +49,7 @@ class AbstractTranslationRotation2D: public AbstractTransformation<2, T> {
* *
* @see Vector2::xAxis(), Vector2::yAxis() * @see Vector2::xAxis(), Vector2::yAxis()
*/ */
AbstractTranslationRotation2D<T>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) { AbstractBasicTranslationRotation2D<T>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) {
doTranslate(vector, type); doTranslate(vector, type);
return this; return this;
} }
@ -65,15 +60,15 @@ class AbstractTranslationRotation2D: public AbstractTransformation<2, T> {
* @param type Transformation type * @param type Transformation type
* @return Pointer to self (for method chaining) * @return Pointer to self (for method chaining)
*/ */
AbstractTranslationRotation2D<T>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { AbstractBasicTranslationRotation2D<T>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
doRotate(angle, type); doRotate(angle, type);
return this; return this;
} }
/* Overloads to remove WTF-factor from method chaining order */ /* Overloads to remove WTF-factor from method chaining order */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
AbstractTranslationRotation2D<T>* resetTransformation() { AbstractBasicTranslationRotation2D<T>* resetTransformation() {
AbstractTransformation<2, T>::resetTransformation(); AbstractBasicTransformation<2, T>::resetTransformation();
return this; return this;
} }
#endif #endif
@ -90,6 +85,13 @@ class AbstractTranslationRotation2D: public AbstractTransformation<2, T> {
virtual void doRotate(Math::Rad<T> angle, TransformationType type) = 0; virtual void doRotate(Math::Rad<T> angle, TransformationType type) = 0;
}; };
/**
@brief Base transformation for two-dimensional float scenes supporting translation and rotation
@see @ref AbstractTranslationRotation3D
*/
typedef AbstractBasicTranslationRotation2D<Float> AbstractTranslationRotation2D;
}} }}
#endif #endif

36
src/SceneGraph/AbstractTranslationRotation3D.h
Unescape View File

@ -25,7 +25,7 @@
*/ */
/** @file /** @file
* @brief Class Magnum::SceneGraph::AbstractTranslationRotation3D * @brief Class Magnum::SceneGraph::AbstractBasicTranslationRotation3D, typedef Magnum::SceneGraph::AbstractTranslationRotation3D
*/ */
#include "AbstractTransformation.h" #include "AbstractTransformation.h"
@ -34,18 +34,13 @@
namespace Magnum { namespace SceneGraph { namespace Magnum { namespace SceneGraph {
/** /**
@brief Base for three-dimensional transformations supporting translation and rotation @brief Base translation for three-dimensional scenes supporting translation and rotation
@see @ref scenegraph, AbstractTranslationRotation2D @see @ref AbstractTranslationRotation3D @ref scenegraph, @ref AbstractBasicTranslationRotation2D
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT template<class T> class AbstractBasicTranslationRotation3D: public AbstractBasicTransformation<3, T> {
template<class T>
#else
template<class T = Float>
#endif
class AbstractTranslationRotation3D: public AbstractTransformation<3, T> {
public: public:
explicit AbstractTranslationRotation3D() = default; explicit AbstractBasicTranslationRotation3D() = default;
/** /**
* @brief Translate object * @brief Translate object
@ -55,7 +50,7 @@ class AbstractTranslationRotation3D: public AbstractTransformation<3, T> {
* *
* @see Vector3::xAxis(), Vector3::yAxis(), Vector3::zAxis() * @see Vector3::xAxis(), Vector3::yAxis(), Vector3::zAxis()
*/ */
AbstractTranslationRotation3D<T>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) { AbstractBasicTranslationRotation3D<T>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) {
doTranslate(vector, type); doTranslate(vector, type);
return this; return this;
} }
@ -70,7 +65,7 @@ class AbstractTranslationRotation3D: public AbstractTransformation<3, T> {
* @see rotateX(), rotateY(), rotateZ(), Vector3::xAxis(), * @see rotateX(), rotateY(), rotateZ(), Vector3::xAxis(),
* Vector3::yAxis(), Vector3::zAxis() * Vector3::yAxis(), Vector3::zAxis()
*/ */
AbstractTranslationRotation3D<T>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) { AbstractBasicTranslationRotation3D<T>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) {
doRotate(angle, normalizedAxis, type); doRotate(angle, normalizedAxis, type);
return this; return this;
} }
@ -84,7 +79,7 @@ class AbstractTranslationRotation3D: public AbstractTransformation<3, T> {
* In some implementations faster than calling * In some implementations faster than calling
* `rotate(angle, Vector3::xAxis())`. * `rotate(angle, Vector3::xAxis())`.
*/ */
AbstractTranslationRotation3D<T>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { AbstractBasicTranslationRotation3D<T>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
doRotateX(angle, type); doRotateX(angle, type);
return this; return this;
} }
@ -98,7 +93,7 @@ class AbstractTranslationRotation3D: public AbstractTransformation<3, T> {
* In some implementations faster than calling * In some implementations faster than calling
* `rotate(angle, Vector3::yAxis())`. * `rotate(angle, Vector3::yAxis())`.
*/ */
AbstractTranslationRotation3D<T>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { AbstractBasicTranslationRotation3D<T>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
doRotateX(angle, type); doRotateX(angle, type);
return this; return this;
} }
@ -112,15 +107,15 @@ class AbstractTranslationRotation3D: public AbstractTransformation<3, T> {
* In some implementations faster than calling * In some implementations faster than calling
* `rotate(angle, Vector3::zAxis())`. * `rotate(angle, Vector3::zAxis())`.
*/ */
AbstractTranslationRotation3D<T>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { AbstractBasicTranslationRotation3D<T>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
doRotateZ(angle, type); doRotateZ(angle, type);
return this; return this;
} }
/* Overloads to remove WTF-factor from method chaining order */ /* Overloads to remove WTF-factor from method chaining order */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
AbstractTranslationRotation3D<T>* resetTransformation() { AbstractBasicTranslationRotation3D<T>* resetTransformation() {
AbstractTransformation<3, T>::resetTransformation(); AbstractBasicTransformation<3, T>::resetTransformation();
return this; return this;
} }
#endif #endif
@ -164,6 +159,13 @@ class AbstractTranslationRotation3D: public AbstractTransformation<3, T> {
} }
}; };
/**
@brief Base transformation for three-dimensional float scenes supporting translation and rotation
@see @ref AbstractTranslationRotation2D
*/
typedef AbstractBasicTranslationRotation3D<Float> AbstractTranslationRotation3D;
}} }}
#endif #endif

36
src/SceneGraph/AbstractTranslationRotationScaling2D.h
Unescape View File

@ -25,7 +25,7 @@
*/ */
/** @file /** @file
* @brief Class Magnum::SceneGraph::AbstractTranslationRotationScaling2D * @brief Class Magnum::SceneGraph::AbstractBasicTranslationRotationScaling2D, typedef Magnum::SceneGraph::AbstractTranslationRotationScaling2D
*/ */
#include "AbstractTranslationRotation2D.h" #include "AbstractTranslationRotation2D.h"
@ -33,18 +33,13 @@
namespace Magnum { namespace SceneGraph { namespace Magnum { namespace SceneGraph {
/** /**
@brief Base for two-dimensional transformations supporting translation, rotation and scaling @brief Base transformation for two-dimensional scenes supporting translation, rotation and scaling
@see @ref scenegraph, AbstractTranslationRotationScaling2D @see @ref AbstractTranslationRotationScaling2D, @ref scenegraph, @ref AbstractBasicTranslationRotationScaling2D
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT template<class T> class AbstractBasicTranslationRotationScaling2D: public AbstractBasicTranslationRotation2D<T> {
template<class T>
#else
template<class T = Float>
#endif
class AbstractTranslationRotationScaling2D: public AbstractTranslationRotation2D<T> {
public: public:
explicit AbstractTranslationRotationScaling2D() = default; explicit AbstractBasicTranslationRotationScaling2D() = default;
/** /**
* @brief Scale object * @brief Scale object
@ -54,23 +49,23 @@ class AbstractTranslationRotationScaling2D: public AbstractTranslationRotation2D
* *
* @see Vector2::xScale(), Vector2::yScale() * @see Vector2::xScale(), Vector2::yScale()
*/ */
AbstractTranslationRotationScaling2D<T>* scale(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) { AbstractBasicTranslationRotationScaling2D<T>* scale(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) {
doScale(vector, type); doScale(vector, type);
return this; return this;
} }
/* Overloads to remove WTF-factor from method chaining order */ /* Overloads to remove WTF-factor from method chaining order */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
AbstractTranslationRotationScaling2D<T>* resetTransformation() { AbstractBasicTranslationRotationScaling2D<T>* resetTransformation() {
AbstractTranslationRotation2D<T>::resetTransformation(); AbstractBasicTranslationRotation2D<T>::resetTransformation();
return this; return this;
} }
AbstractTranslationRotationScaling2D<T>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) { AbstractBasicTranslationRotationScaling2D<T>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) {
AbstractTranslationRotation2D<T>::translate(vector, type); AbstractBasicTranslationRotation2D<T>::translate(vector, type);
return this; return this;
} }
AbstractTranslationRotationScaling2D<T>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { AbstractBasicTranslationRotationScaling2D<T>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
AbstractTranslationRotation2D<T>::rotate(angle, type); AbstractBasicTranslationRotation2D<T>::rotate(angle, type);
return this; return this;
} }
#endif #endif
@ -84,6 +79,13 @@ class AbstractTranslationRotationScaling2D: public AbstractTranslationRotation2D
virtual void doScale(const Math::Vector2<T>& vector, TransformationType type) = 0; virtual void doScale(const Math::Vector2<T>& vector, TransformationType type) = 0;
}; };
/**
@brief Base transformation for two-dimensional float scenes supporting translation, rotation and scaling
@see @ref AbstractTranslationRotationScaling3D
*/
typedef AbstractBasicTranslationRotationScaling2D<Float> AbstractTranslationRotationScaling2D;
}} }}
#endif #endif

46
src/SceneGraph/AbstractTranslationRotationScaling3D.h
Unescape View File

@ -25,7 +25,7 @@
*/ */
/** @file /** @file
* @brief Class Magnum::SceneGraph::AbstractTranslationRotationScaling3D * @brief Class Magnum::SceneGraph::AbstractBasicTranslationRotationScaling3D, typedef Magnum::SceneGraph::AbstractTranslationRotationScaling3D
*/ */
#include "AbstractTranslationRotation3D.h" #include "AbstractTranslationRotation3D.h"
@ -35,16 +35,11 @@ namespace Magnum { namespace SceneGraph {
/** /**
@brief Base for three-dimensional transformations supporting translation, rotation and scaling @brief Base for three-dimensional transformations supporting translation, rotation and scaling
@see @ref scenegraph, AbstractTranslationRotationScaling2D @see @ref AbstractTranslationRotationScaling3D, @ref scenegraph, @ref AbstractBasicTranslationRotationScaling2D
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT template<class T> class AbstractBasicTranslationRotationScaling3D: public AbstractBasicTranslationRotation3D<T> {
template<class T>
#else
template<class T = Float>
#endif
class AbstractTranslationRotationScaling3D: public AbstractTranslationRotation3D<T> {
public: public:
explicit AbstractTranslationRotationScaling3D() = default; explicit AbstractBasicTranslationRotationScaling3D() = default;
/** /**
* @brief Scale object * @brief Scale object
@ -54,35 +49,35 @@ class AbstractTranslationRotationScaling3D: public AbstractTranslationRotation3D
* *
* @see Vector3::xScale(), Vector3::yScale(), Vector3::zScale() * @see Vector3::xScale(), Vector3::yScale(), Vector3::zScale()
*/ */
AbstractTranslationRotationScaling3D<T>* scale(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) { AbstractBasicTranslationRotationScaling3D<T>* scale(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) {
doScale(vector, type); doScale(vector, type);
return this; return this;
} }
/* Overloads to remove WTF-factor from method chaining order */ /* Overloads to remove WTF-factor from method chaining order */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
AbstractTranslationRotationScaling3D<T>* resetTransformation() { AbstractBasicTranslationRotationScaling3D<T>* resetTransformation() {
AbstractTranslationRotation3D<T>::resetTransformation(); AbstractBasicTranslationRotation3D<T>::resetTransformation();
return this; return this;
} }
AbstractTranslationRotationScaling3D<T>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) { AbstractBasicTranslationRotationScaling3D<T>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) {
AbstractTranslationRotation3D<T>::translate(vector, type); AbstractBasicTranslationRotation3D<T>::translate(vector, type);
return this; return this;
} }
AbstractTranslationRotationScaling3D<T>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) { AbstractBasicTranslationRotationScaling3D<T>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) {
AbstractTranslationRotation3D<T>::rotate(angle, normalizedAxis, type); AbstractBasicTranslationRotation3D<T>::rotate(angle, normalizedAxis, type);
return this; return this;
} }
AbstractTranslationRotationScaling3D<T>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { AbstractBasicTranslationRotationScaling3D<T>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
AbstractTranslationRotation3D<T>::rotateX(angle, type); AbstractBasicTranslationRotation3D<T>::rotateX(angle, type);
return this; return this;
} }
AbstractTranslationRotationScaling3D<T>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { AbstractBasicTranslationRotationScaling3D<T>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
AbstractTranslationRotation3D<T>::rotateY(angle, type); AbstractBasicTranslationRotation3D<T>::rotateY(angle, type);
return this; return this;
} }
AbstractTranslationRotationScaling3D<T>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { AbstractBasicTranslationRotationScaling3D<T>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
AbstractTranslationRotation3D<T>::rotateZ(angle, type); AbstractBasicTranslationRotation3D<T>::rotateZ(angle, type);
return this; return this;
} }
#endif #endif
@ -96,6 +91,13 @@ class AbstractTranslationRotationScaling3D: public AbstractTranslationRotation3D
virtual void doScale(const Math::Vector3<T>& vector, TransformationType type) = 0; virtual void doScale(const Math::Vector3<T>& vector, TransformationType type) = 0;
}; };
/**
@brief Base transformation for three-dimensional float scenes supporting translation, rotation and scaling
@see @ref AbstractTranslationRotationScaling2D
*/
typedef AbstractBasicTranslationRotationScaling3D<Float> AbstractTranslationRotationScaling3D;
}} }}
#endif #endif

58
src/SceneGraph/DualComplexTransformation.h
Unescape View File

@ -25,7 +25,7 @@
*/ */
/** @file /** @file
* @brief Class Magnum::SceneGraph::DualComplexTransformation * @brief Class Magnum::SceneGraph::BasicDualComplexTransformation, typedef Magnum::SceneGraph::DualComplexTransformation
*/ */
#include "Math/DualComplex.h" #include "Math/DualComplex.h"
@ -39,14 +39,9 @@ namespace Magnum { namespace SceneGraph {
This class allows only rigid transformation (i.e. only rotation and This class allows only rigid transformation (i.e. only rotation and
translation). translation).
@see @ref scenegraph, Math::DualComplex, DualQuaternionTransformation @see @ref DualComplexTransformation, @ref scenegraph, Math::DualComplex, @ref BasicDualQuaternionTransformation
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT template<class T> class BasicDualComplexTransformation: public AbstractBasicTranslationRotation2D<T> {
template<class T>
#else
template<class T = Float>
#endif
class DualComplexTransformation: public AbstractTranslationRotation2D<T> {
public: public:
/** @brief Transformation type */ /** @brief Transformation type */
typedef Math::DualComplex<T> DataType; typedef Math::DualComplex<T> DataType;
@ -81,9 +76,9 @@ class DualComplexTransformation: public AbstractTranslationRotation2D<T> {
* the object subsequently. * the object subsequently.
* @see DualComplex::normalized() * @see DualComplex::normalized()
*/ */
Object<DualComplexTransformation<T>>* normalizeRotation() { Object<BasicDualComplexTransformation<T>>* normalizeRotation() {
setTransformationInternal(_transformation.normalized()); setTransformationInternal(_transformation.normalized());
return static_cast<Object<DualComplexTransformation<T>>*>(this); return static_cast<Object<BasicDualComplexTransformation<T>>*>(this);
} }
/** /**
@ -93,18 +88,18 @@ class DualComplexTransformation: public AbstractTranslationRotation2D<T> {
* Expects that the dual complex number is normalized. * Expects that the dual complex number is normalized.
* @see DualComplex::isNormalized() * @see DualComplex::isNormalized()
*/ */
Object<DualComplexTransformation<T>>* setTransformation(const Math::DualComplex<T>& transformation) { Object<BasicDualComplexTransformation<T>>* setTransformation(const Math::DualComplex<T>& transformation) {
CORRADE_ASSERT(transformation.isNormalized(), CORRADE_ASSERT(transformation.isNormalized(),
"SceneGraph::DualComplexTransformation::setTransformation(): the dual complex number is not normalized", "SceneGraph::DualComplexTransformation::setTransformation(): the dual complex number is not normalized",
static_cast<Object<DualComplexTransformation<T>>*>(this)); static_cast<Object<BasicDualComplexTransformation<T>>*>(this));
setTransformationInternal(transformation); setTransformationInternal(transformation);
return static_cast<Object<DualComplexTransformation<T>>*>(this); return static_cast<Object<BasicDualComplexTransformation<T>>*>(this);
} }
/** @copydoc AbstractTranslationRotationScaling2D::resetTransformation() */ /** @copydoc AbstractTranslationRotationScaling2D::resetTransformation() */
Object<DualComplexTransformation<T>>* resetTransformation() { Object<BasicDualComplexTransformation<T>>* resetTransformation() {
setTransformationInternal({}); setTransformationInternal({});
return static_cast<Object<DualComplexTransformation<T>>*>(this); return static_cast<Object<BasicDualComplexTransformation<T>>*>(this);
} }
/** /**
@ -116,21 +111,21 @@ class DualComplexTransformation: public AbstractTranslationRotation2D<T> {
* Expects that the dual complex number is normalized. * Expects that the dual complex number is normalized.
* @see DualComplex::isNormalized() * @see DualComplex::isNormalized()
*/ */
Object<DualComplexTransformation<T>>* transform(const Math::DualComplex<T>& transformation, TransformationType type = TransformationType::Global) { Object<BasicDualComplexTransformation<T>>* transform(const Math::DualComplex<T>& transformation, TransformationType type = TransformationType::Global) {
CORRADE_ASSERT(transformation.isNormalized(), CORRADE_ASSERT(transformation.isNormalized(),
"SceneGraph::DualComplexTransformation::transform(): the dual complex number is not normalized", "SceneGraph::DualComplexTransformation::transform(): the dual complex number is not normalized",
static_cast<Object<DualComplexTransformation<T>>*>(this)); static_cast<Object<BasicDualComplexTransformation<T>>*>(this));
transformInternal(transformation, type); transformInternal(transformation, type);
return static_cast<Object<DualComplexTransformation<T>>*>(this); return static_cast<Object<BasicDualComplexTransformation<T>>*>(this);
} }
/** /**
* @copydoc AbstractTranslationRotationScaling2D::translate() * @copydoc AbstractTranslationRotationScaling2D::translate()
* Same as calling transform() with DualComplex::translation(). * Same as calling transform() with DualComplex::translation().
*/ */
Object<DualComplexTransformation<T>>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) { Object<BasicDualComplexTransformation<T>>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) {
transformInternal(Math::DualComplex<T>::translation(vector), type); transformInternal(Math::DualComplex<T>::translation(vector), type);
return static_cast<Object<DualComplexTransformation<T>>*>(this); return static_cast<Object<BasicDualComplexTransformation<T>>*>(this);
} }
/** /**
@ -142,9 +137,9 @@ class DualComplexTransformation: public AbstractTranslationRotation2D<T> {
* Same as calling transform() with DualComplex::rotation(). * Same as calling transform() with DualComplex::rotation().
* @see normalizeRotation() * @see normalizeRotation()
*/ */
Object<DualComplexTransformation<T>>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { Object<BasicDualComplexTransformation<T>>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
transformInternal(Math::DualComplex<T>::rotation(angle), type); transformInternal(Math::DualComplex<T>::rotation(angle), type);
return static_cast<Object<DualComplexTransformation<T>>*>(this); return static_cast<Object<BasicDualComplexTransformation<T>>*>(this);
} }
/** /**
@ -153,14 +148,14 @@ class DualComplexTransformation: public AbstractTranslationRotation2D<T> {
* if you want to move it above all. * if you want to move it above all.
* @return Pointer to self (for method chaining) * @return Pointer to self (for method chaining)
*/ */
Object<DualComplexTransformation<T>>* move(Object<DualComplexTransformation<T>>* under) { Object<BasicDualComplexTransformation<T>>* move(Object<BasicDualComplexTransformation<T>>* under) {
static_cast<Object<DualComplexTransformation>*>(this)->Containers::template LinkedList<Object<DualComplexTransformation<T>>>::move(this, under); static_cast<Object<BasicDualComplexTransformation>*>(this)->Containers::template LinkedList<Object<BasicDualComplexTransformation<T>>>::move(this, under);
return static_cast<Object<DualComplexTransformation<T>>*>(this); return static_cast<Object<BasicDualComplexTransformation<T>>*>(this);
} }
protected: protected:
/* Allow construction only from Object */ /* Allow construction only from Object */
explicit DualComplexTransformation() = default; explicit BasicDualComplexTransformation() = default;
private: private:
void doResetTransformation() override final { resetTransformation(); } void doResetTransformation() override final { resetTransformation(); }
@ -178,9 +173,9 @@ class DualComplexTransformation: public AbstractTranslationRotation2D<T> {
/* Setting transformation is forbidden for the scene */ /* Setting transformation is forbidden for the scene */
/** @todo Assert for this? */ /** @todo Assert for this? */
/** @todo Do this in some common code so we don't need to include Object? */ /** @todo Do this in some common code so we don't need to include Object? */
if(!static_cast<Object<DualComplexTransformation<T>>*>(this)->isScene()) { if(!static_cast<Object<BasicDualComplexTransformation<T>>*>(this)->isScene()) {
_transformation = transformation; _transformation = transformation;
static_cast<Object<DualComplexTransformation<T>>*>(this)->setDirty(); static_cast<Object<BasicDualComplexTransformation<T>>*>(this)->setDirty();
} }
} }
@ -193,6 +188,13 @@ class DualComplexTransformation: public AbstractTranslationRotation2D<T> {
Math::DualComplex<T> _transformation; Math::DualComplex<T> _transformation;
}; };
/**
@brief Two-dimensional transformation for float scenes implemented using dual complex numbers
@see @ref DualQuaternionTransformation
*/
typedef BasicDualComplexTransformation<Float> DualComplexTransformation;
}} }}
#endif #endif

58
src/SceneGraph/DualQuaternionTransformation.h
Unescape View File

@ -25,7 +25,7 @@
*/ */
/** @file /** @file
* @brief Class Magnum::SceneGraph::DualQuaternionTransformation * @brief Class Magnum::SceneGraph::BasicDualQuaternionTransformation, typedef Magnum::SceneGraph::DualQuaternionTransformation
*/ */
#include "Math/DualQuaternion.h" #include "Math/DualQuaternion.h"
@ -39,14 +39,9 @@ namespace Magnum { namespace SceneGraph {
This class allows only rigid transformation (i.e. only rotation and This class allows only rigid transformation (i.e. only rotation and
translation). translation).
@see @ref scenegraph, Math::DualQuaternion, DualComplexTransformation @see @ref DualQuaternionTransformation @ref scenegraph, Math::DualQuaternion, @ref BasicDualComplexTransformation
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT template<class T> class BasicDualQuaternionTransformation: public AbstractBasicTranslationRotation3D<T> {
template<class T>
#else
template<class T = Float>
#endif
class DualQuaternionTransformation: public AbstractTranslationRotation3D<T> {
public: public:
/** @brief Underlying transformation type */ /** @brief Underlying transformation type */
typedef Math::DualQuaternion<T> DataType; typedef Math::DualQuaternion<T> DataType;
@ -83,9 +78,9 @@ class DualQuaternionTransformation: public AbstractTranslationRotation3D<T> {
* the object subsequently. * the object subsequently.
* @see DualQuaternion::normalized() * @see DualQuaternion::normalized()
*/ */
Object<DualQuaternionTransformation<T>>* normalizeRotation() { Object<BasicDualQuaternionTransformation<T>>* normalizeRotation() {
setTransformation(_transformation.normalized()); setTransformation(_transformation.normalized());
return static_cast<Object<DualQuaternionTransformation<T>>*>(this); return static_cast<Object<BasicDualQuaternionTransformation<T>>*>(this);
} }
/** /**
@ -95,18 +90,18 @@ class DualQuaternionTransformation: public AbstractTranslationRotation3D<T> {
* Expects that the dual quaternion is normalized. * Expects that the dual quaternion is normalized.
* @see DualQuaternion::isNormalized() * @see DualQuaternion::isNormalized()
*/ */
Object<DualQuaternionTransformation<T>>* setTransformation(const Math::DualQuaternion<T>& transformation) { Object<BasicDualQuaternionTransformation<T>>* setTransformation(const Math::DualQuaternion<T>& transformation) {
CORRADE_ASSERT(transformation.isNormalized(), CORRADE_ASSERT(transformation.isNormalized(),
"SceneGraph::DualQuaternionTransformation::setTransformation(): the dual quaternion is not normalized", "SceneGraph::DualQuaternionTransformation::setTransformation(): the dual quaternion is not normalized",
static_cast<Object<DualQuaternionTransformation<T>>*>(this)); static_cast<Object<BasicDualQuaternionTransformation<T>>*>(this));
setTransformationInternal(transformation); setTransformationInternal(transformation);
return static_cast<Object<DualQuaternionTransformation<T>>*>(this); return static_cast<Object<BasicDualQuaternionTransformation<T>>*>(this);
} }
/** @copydoc AbstractTranslationRotationScaling3D::resetTransformation() */ /** @copydoc AbstractTranslationRotationScaling3D::resetTransformation() */
Object<DualQuaternionTransformation<T>>* resetTransformation() { Object<BasicDualQuaternionTransformation<T>>* resetTransformation() {
setTransformation({}); setTransformation({});
return static_cast<Object<DualQuaternionTransformation<T>>*>(this); return static_cast<Object<BasicDualQuaternionTransformation<T>>*>(this);
} }
/** /**
@ -118,21 +113,21 @@ class DualQuaternionTransformation: public AbstractTranslationRotation3D<T> {
* Expects that the dual quaternion is normalized. * Expects that the dual quaternion is normalized.
* @see DualQuaternion::isNormalized() * @see DualQuaternion::isNormalized()
*/ */
Object<DualQuaternionTransformation<T>>* transform(const Math::DualQuaternion<T>& transformation, TransformationType type = TransformationType::Global) { Object<BasicDualQuaternionTransformation<T>>* transform(const Math::DualQuaternion<T>& transformation, TransformationType type = TransformationType::Global) {
CORRADE_ASSERT(transformation.isNormalized(), CORRADE_ASSERT(transformation.isNormalized(),
"SceneGraph::DualQuaternionTransformation::transform(): the dual quaternion is not normalized", "SceneGraph::DualQuaternionTransformation::transform(): the dual quaternion is not normalized",
static_cast<Object<DualQuaternionTransformation<T>>*>(this)); static_cast<Object<BasicDualQuaternionTransformation<T>>*>(this));
transformInternal(transformation, type); transformInternal(transformation, type);
return static_cast<Object<DualQuaternionTransformation<T>>*>(this); return static_cast<Object<BasicDualQuaternionTransformation<T>>*>(this);
} }
/** /**
* @copydoc AbstractTranslationRotationScaling3D::translate() * @copydoc AbstractTranslationRotationScaling3D::translate()
* Same as calling transform() with DualQuaternion::translation(). * Same as calling transform() with DualQuaternion::translation().
*/ */
Object<DualQuaternionTransformation<T>>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) { Object<BasicDualQuaternionTransformation<T>>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) {
transformInternal(Math::DualQuaternion<T>::translation(vector), type); transformInternal(Math::DualQuaternion<T>::translation(vector), type);
return static_cast<Object<DualQuaternionTransformation<T>>*>(this); return static_cast<Object<BasicDualQuaternionTransformation<T>>*>(this);
} }
/** /**
@ -146,27 +141,27 @@ class DualQuaternionTransformation: public AbstractTranslationRotation3D<T> {
* @see Vector3::xAxis(), Vector3::yAxis(), Vector3::zAxis(), * @see Vector3::xAxis(), Vector3::yAxis(), Vector3::zAxis(),
* normalizeRotation() * normalizeRotation()
*/ */
Object<DualQuaternionTransformation<T>>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) { Object<BasicDualQuaternionTransformation<T>>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) {
transformInternal(Math::DualQuaternion<T>::rotation(angle, normalizedAxis), type); transformInternal(Math::DualQuaternion<T>::rotation(angle, normalizedAxis), type);
return static_cast<Object<DualQuaternionTransformation<T>>*>(this); return static_cast<Object<BasicDualQuaternionTransformation<T>>*>(this);
} }
/* Overloads to remove WTF-factor from method chaining order */ /* Overloads to remove WTF-factor from method chaining order */
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
Object<DualQuaternionTransformation<T>>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { Object<BasicDualQuaternionTransformation<T>>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
return rotate(angle, Math::Vector3<T>::xAxis(), type); return rotate(angle, Math::Vector3<T>::xAxis(), type);
} }
Object<DualQuaternionTransformation<T>>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { Object<BasicDualQuaternionTransformation<T>>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
return rotate(angle, Math::Vector3<T>::yAxis(), type); return rotate(angle, Math::Vector3<T>::yAxis(), type);
} }
Object<DualQuaternionTransformation<T>>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { Object<BasicDualQuaternionTransformation<T>>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
return rotate(angle, Math::Vector3<T>::zAxis(), type); return rotate(angle, Math::Vector3<T>::zAxis(), type);
} }
#endif #endif
protected: protected:
/* Allow construction only from Object */ /* Allow construction only from Object */
explicit DualQuaternionTransformation() = default; explicit BasicDualQuaternionTransformation() = default;
private: private:
void doResetTransformation() override final { resetTransformation(); } void doResetTransformation() override final { resetTransformation(); }
@ -184,9 +179,9 @@ class DualQuaternionTransformation: public AbstractTranslationRotation3D<T> {
/* Setting transformation is forbidden for the scene */ /* Setting transformation is forbidden for the scene */
/** @todo Assert for this? */ /** @todo Assert for this? */
/** @todo Do this in some common code so we don't need to include Object? */ /** @todo Do this in some common code so we don't need to include Object? */
if(!static_cast<Object<DualQuaternionTransformation<T>>*>(this)->isScene()) { if(!static_cast<Object<BasicDualQuaternionTransformation<T>>*>(this)->isScene()) {
_transformation = transformation; _transformation = transformation;
static_cast<Object<DualQuaternionTransformation<T>>*>(this)->setDirty(); static_cast<Object<BasicDualQuaternionTransformation<T>>*>(this)->setDirty();
} }
} }
@ -199,6 +194,13 @@ class DualQuaternionTransformation: public AbstractTranslationRotation3D<T> {
Math::DualQuaternion<T> _transformation; Math::DualQuaternion<T> _transformation;
}; };
/**
@brief Three-dimensional transformation for float scenes implemented using dual quaternions
@see @ref DualComplexTransformation
*/
typedef BasicDualQuaternionTransformation<Float> DualQuaternionTransformation;
}} }}
#endif #endif

53
src/SceneGraph/MatrixTransformation2D.h
Unescape View File

@ -25,7 +25,7 @@
*/ */
/** @file /** @file
* @brief Class Magnum::SceneGraph::MatrixTransformation2D * @brief Class Magnum::SceneGraph::BasicMatrixTransformation2D, typedef Magnum::SceneGraph::MatrixTransformation2D
*/ */
#include "Math/Matrix3.h" #include "Math/Matrix3.h"
@ -38,14 +38,9 @@ namespace Magnum { namespace SceneGraph {
@brief Two-dimensional transformation implemented using matrices @brief Two-dimensional transformation implemented using matrices
Uses Math::Matrix3 as underlying type. Uses Math::Matrix3 as underlying type.
@see @ref scenegraph, RigidMatrixTransformation2D, MatrixTransformation3D @see @ref MatrixTransformation2D, @ref scenegraph, @ref RigidBasicMatrixTransformation2D, @ref BasicMatrixTransformation3D
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT template<class T> class BasicMatrixTransformation2D: public AbstractBasicTranslationRotationScaling2D<T> {
template<class T>
#else
template<class T = Float>
#endif
class MatrixTransformation2D: public AbstractTranslationRotationScaling2D<T> {
public: public:
/** @brief Underlying transformation type */ /** @brief Underlying transformation type */
typedef Math::Matrix3<T> DataType; typedef Math::Matrix3<T> DataType;
@ -76,16 +71,16 @@ class MatrixTransformation2D: public AbstractTranslationRotationScaling2D<T> {
* @brief Set transformation * @brief Set transformation
* @return Pointer to self (for method chaining) * @return Pointer to self (for method chaining)
*/ */
Object<MatrixTransformation2D<T>>* setTransformation(const Math::Matrix3<T>& transformation) { Object<BasicMatrixTransformation2D<T>>* setTransformation(const Math::Matrix3<T>& transformation) {
/* Setting transformation is forbidden for the scene */ /* Setting transformation is forbidden for the scene */
/** @todo Assert for this? */ /** @todo Assert for this? */
/** @todo Do this in some common code so we don't need to include Object? */ /** @todo Do this in some common code so we don't need to include Object? */
if(!static_cast<Object<MatrixTransformation2D<T>>*>(this)->isScene()) { if(!static_cast<Object<BasicMatrixTransformation2D<T>>*>(this)->isScene()) {
_transformation = transformation; _transformation = transformation;
static_cast<Object<MatrixTransformation2D<T>>*>(this)->setDirty(); static_cast<Object<BasicMatrixTransformation2D<T>>*>(this)->setDirty();
} }
return static_cast<Object<MatrixTransformation2D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation2D<T>>*>(this);
} }
/** /**
@ -94,43 +89,43 @@ class MatrixTransformation2D: public AbstractTranslationRotationScaling2D<T> {
* @param type Transformation type * @param type Transformation type
* @return Pointer to self (for method chaining) * @return Pointer to self (for method chaining)
*/ */
Object<MatrixTransformation2D<T>>* transform(const Math::Matrix3<T>& transformation, TransformationType type = TransformationType::Global) { Object<BasicMatrixTransformation2D<T>>* transform(const Math::Matrix3<T>& transformation, TransformationType type = TransformationType::Global) {
setTransformation(type == TransformationType::Global ? setTransformation(type == TransformationType::Global ?
transformation*_transformation : _transformation*transformation); transformation*_transformation : _transformation*transformation);
return static_cast<Object<MatrixTransformation2D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation2D<T>>*>(this);
} }
/** @copydoc AbstractTranslationRotationScaling2D::resetTransformation() */ /** @copydoc AbstractTranslationRotationScaling2D::resetTransformation() */
Object<MatrixTransformation2D<T>>* resetTransformation() { Object<BasicMatrixTransformation2D<T>>* resetTransformation() {
setTransformation({}); setTransformation({});
return static_cast<Object<MatrixTransformation2D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation2D<T>>*>(this);
} }
/** /**
* @copydoc AbstractTranslationRotationScaling2D::translate() * @copydoc AbstractTranslationRotationScaling2D::translate()
* Same as calling transform() with Matrix3::translation(). * Same as calling transform() with Matrix3::translation().
*/ */
Object<MatrixTransformation2D<T>>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) { Object<BasicMatrixTransformation2D<T>>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) {
transform(Math::Matrix3<T>::translation(vector), type); transform(Math::Matrix3<T>::translation(vector), type);
return static_cast<Object<MatrixTransformation2D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation2D<T>>*>(this);
} }
/** /**
* @copydoc AbstractTranslationRotationScaling2D::rotate() * @copydoc AbstractTranslationRotationScaling2D::rotate()
* Same as calling transform() with Matrix3::rotation(). * Same as calling transform() with Matrix3::rotation().
*/ */
Object<MatrixTransformation2D<T>>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { Object<BasicMatrixTransformation2D<T>>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
transform(Math::Matrix3<T>::rotation(angle), type); transform(Math::Matrix3<T>::rotation(angle), type);
return static_cast<Object<MatrixTransformation2D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation2D<T>>*>(this);
} }
/** /**
* @copydoc AbstractTranslationRotationScaling2D::scale() * @copydoc AbstractTranslationRotationScaling2D::scale()
* Same as calling transform() with Matrix3::scaling(). * Same as calling transform() with Matrix3::scaling().
*/ */
Object<MatrixTransformation2D<T>>* scale(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) { Object<BasicMatrixTransformation2D<T>>* scale(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) {
transform(Math::Matrix3<T>::scaling(vector), type); transform(Math::Matrix3<T>::scaling(vector), type);
return static_cast<Object<MatrixTransformation2D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation2D<T>>*>(this);
} }
/** /**
@ -142,9 +137,9 @@ class MatrixTransformation2D: public AbstractTranslationRotationScaling2D<T> {
* *
* Same as calling transform() with Matrix3::reflection(). * Same as calling transform() with Matrix3::reflection().
*/ */
Object<MatrixTransformation2D<T>>* reflect(const Math::Vector2<T>& normal, TransformationType type = TransformationType::Global) { Object<BasicMatrixTransformation2D<T>>* reflect(const Math::Vector2<T>& normal, TransformationType type = TransformationType::Global) {
transform(Math::Matrix3<T>::reflection(normal), type); transform(Math::Matrix3<T>::reflection(normal), type);
return static_cast<Object<MatrixTransformation2D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation2D<T>>*>(this);
} }
/** /**
@ -153,14 +148,14 @@ class MatrixTransformation2D: public AbstractTranslationRotationScaling2D<T> {
* if you want to move it above all. * if you want to move it above all.
* @return Pointer to self (for method chaining) * @return Pointer to self (for method chaining)
*/ */
Object<MatrixTransformation2D<T>>* move(Object<MatrixTransformation2D<T>>* under) { Object<BasicMatrixTransformation2D<T>>* move(Object<BasicMatrixTransformation2D<T>>* under) {
static_cast<Object<MatrixTransformation2D>*>(this)->Containers::template LinkedList<Object<MatrixTransformation2D<T>>>::move(this, under); static_cast<Object<BasicMatrixTransformation2D>*>(this)->Containers::template LinkedList<Object<BasicMatrixTransformation2D<T>>>::move(this, under);
return static_cast<Object<MatrixTransformation2D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation2D<T>>*>(this);
} }
protected: protected:
/* Allow construction only from Object */ /* Allow construction only from Object */
explicit MatrixTransformation2D() = default; explicit BasicMatrixTransformation2D() = default;
private: private:
void doResetTransformation() override final { resetTransformation(); } void doResetTransformation() override final { resetTransformation(); }
@ -180,6 +175,8 @@ class MatrixTransformation2D: public AbstractTranslationRotationScaling2D<T> {
Math::Matrix3<T> _transformation; Math::Matrix3<T> _transformation;
}; };
}} }}
#endif #endif

64
src/SceneGraph/MatrixTransformation3D.h
Unescape View File

@ -25,7 +25,7 @@
*/ */
/** @file /** @file
* @brief Class Magnum::SceneGraph::MatrixTransformation3D * @brief Class Magnum::SceneGraph::BasicMatrixTransformation3D, typedef Magnum::SceneGraph::MatrixTransformation3D
*/ */
#include "Math/Matrix4.h" #include "Math/Matrix4.h"
@ -38,14 +38,9 @@ namespace Magnum { namespace SceneGraph {
@brief Three-dimensional transformation implemented using matrices @brief Three-dimensional transformation implemented using matrices
Uses Math::Matrix4 as underlying type. Uses Math::Matrix4 as underlying type.
@see @ref scenegraph, RigidMatrixTransformation3D, MatrixTransformation2D @see @ref MatrixTransformation3D, @ref scenegraph, @ref BasicRigidMatrixTransformation3D, @ref BasicMatrixTransformation2D
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT template<class T> class BasicMatrixTransformation3D: public AbstractBasicTranslationRotationScaling3D<T> {
template<class T>
#else
template<class T = Float>
#endif
class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
public: public:
/** @brief Underlying transformation type */ /** @brief Underlying transformation type */
typedef Math::Matrix4<T> DataType; typedef Math::Matrix4<T> DataType;
@ -76,22 +71,22 @@ class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
* @brief Set transformation * @brief Set transformation
* @return Pointer to self (for method chaining) * @return Pointer to self (for method chaining)
*/ */
Object<MatrixTransformation3D<T>>* setTransformation(const Math::Matrix4<T>& transformation) { Object<BasicMatrixTransformation3D<T>>* setTransformation(const Math::Matrix4<T>& transformation) {
/* Setting transformation is forbidden for the scene */ /* Setting transformation is forbidden for the scene */
/** @todo Assert for this? */ /** @todo Assert for this? */
/** @todo Do this in some common code so we don't need to include Object? */ /** @todo Do this in some common code so we don't need to include Object? */
if(!static_cast<Object<MatrixTransformation3D<T>>*>(this)->isScene()) { if(!static_cast<Object<BasicMatrixTransformation3D<T>>*>(this)->isScene()) {
_transformation = transformation; _transformation = transformation;
static_cast<Object<MatrixTransformation3D<T>>*>(this)->setDirty(); static_cast<Object<BasicMatrixTransformation3D<T>>*>(this)->setDirty();
} }
return static_cast<Object<MatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation3D<T>>*>(this);
} }
/** @copydoc AbstractTranslationRotationScaling3D::resetTransformation() */ /** @copydoc AbstractTranslationRotationScaling3D::resetTransformation() */
Object<MatrixTransformation3D<T>>* resetTransformation() { Object<BasicMatrixTransformation3D<T>>* resetTransformation() {
setTransformation({}); setTransformation({});
return static_cast<Object<MatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation3D<T>>*>(this);
} }
/** /**
@ -100,28 +95,28 @@ class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
* @param type Transformation type * @param type Transformation type
* @return Pointer to self (for method chaining) * @return Pointer to self (for method chaining)
*/ */
Object<MatrixTransformation3D<T>>* transform(const Math::Matrix4<T>& transformation, TransformationType type = TransformationType::Global) { Object<BasicMatrixTransformation3D<T>>* transform(const Math::Matrix4<T>& transformation, TransformationType type = TransformationType::Global) {
setTransformation(type == TransformationType::Global ? setTransformation(type == TransformationType::Global ?
transformation*_transformation : _transformation*transformation); transformation*_transformation : _transformation*transformation);
return static_cast<Object<MatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation3D<T>>*>(this);
} }
/** /**
* @copydoc AbstractTranslationRotationScaling3D::translate() * @copydoc AbstractTranslationRotationScaling3D::translate()
* Same as calling transform() with Matrix4::translation(). * Same as calling transform() with Matrix4::translation().
*/ */
Object<MatrixTransformation3D<T>>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) { Object<BasicMatrixTransformation3D<T>>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) {
transform(Math::Matrix4<T>::translation(vector), type); transform(Math::Matrix4<T>::translation(vector), type);
return static_cast<Object<MatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation3D<T>>*>(this);
} }
/** /**
* @copydoc AbstractTranslationRotationScaling3D::rotate() * @copydoc AbstractTranslationRotationScaling3D::rotate()
* Same as calling transform() with Matrix4::rotation(). * Same as calling transform() with Matrix4::rotation().
*/ */
Object<MatrixTransformation3D<T>>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) { Object<BasicMatrixTransformation3D<T>>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) {
transform(Math::Matrix4<T>::rotation(angle, normalizedAxis), type); transform(Math::Matrix4<T>::rotation(angle, normalizedAxis), type);
return static_cast<Object<MatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation3D<T>>*>(this);
} }
/** /**
@ -132,9 +127,9 @@ class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
* *
* Same as calling transform() with Matrix4::rotationX(). * Same as calling transform() with Matrix4::rotationX().
*/ */
Object<MatrixTransformation3D<T>>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { Object<BasicMatrixTransformation3D<T>>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
transform(Math::Matrix4<T>::rotationX(angle), type); transform(Math::Matrix4<T>::rotationX(angle), type);
return static_cast<Object<MatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation3D<T>>*>(this);
} }
/** /**
@ -145,9 +140,9 @@ class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
* *
* Same as calling transform() with Matrix4::rotationY(). * Same as calling transform() with Matrix4::rotationY().
*/ */
Object<MatrixTransformation3D<T>>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { Object<BasicMatrixTransformation3D<T>>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
transform(Math::Matrix4<T>::rotationY(angle), type); transform(Math::Matrix4<T>::rotationY(angle), type);
return static_cast<Object<MatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation3D<T>>*>(this);
} }
/** /**
@ -158,18 +153,18 @@ class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
* *
* Same as calling transform() with Matrix4::rotationZ(). * Same as calling transform() with Matrix4::rotationZ().
*/ */
Object<MatrixTransformation3D<T>>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { Object<BasicMatrixTransformation3D<T>>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
transform(Math::Matrix4<T>::rotationZ(angle), type); transform(Math::Matrix4<T>::rotationZ(angle), type);
return static_cast<Object<MatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation3D<T>>*>(this);
} }
/** /**
* @copydoc AbstractTranslationRotationScaling3D::scale() * @copydoc AbstractTranslationRotationScaling3D::scale()
* Same as calling transform() with Matrix4::scaling(). * Same as calling transform() with Matrix4::scaling().
*/ */
Object<MatrixTransformation3D<T>>* scale(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) { Object<BasicMatrixTransformation3D<T>>* scale(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) {
transform(Math::Matrix4<T>::scaling(vector), type); transform(Math::Matrix4<T>::scaling(vector), type);
return static_cast<Object<MatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation3D<T>>*>(this);
} }
/** /**
@ -181,14 +176,14 @@ class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
* *
* Same as calling transform() with Matrix4::reflection(). * Same as calling transform() with Matrix4::reflection().
*/ */
Object<MatrixTransformation3D<T>>* reflect(const Math::Vector3<T>& normal, TransformationType type = TransformationType::Global) { Object<BasicMatrixTransformation3D<T>>* reflect(const Math::Vector3<T>& normal, TransformationType type = TransformationType::Global) {
transform(Math::Matrix4<T>::reflection(normal), type); transform(Math::Matrix4<T>::reflection(normal), type);
return static_cast<Object<MatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicMatrixTransformation3D<T>>*>(this);
} }
protected: protected:
/* Allow construction only from Object */ /* Allow construction only from Object */
explicit MatrixTransformation3D() = default; explicit BasicMatrixTransformation3D() = default;
private: private:
void doResetTransformation() override final { resetTransformation(); } void doResetTransformation() override final { resetTransformation(); }
@ -220,6 +215,13 @@ class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
Math::Matrix4<T> _transformation; Math::Matrix4<T> _transformation;
}; };
/**
@brief Three-dimensional transformation for float scenes implemented using matrices
@see @ref MatrixTransformation2D
*/
typedef BasicMatrixTransformation3D<Float> MatrixTransformation3D;
}} }}
#endif #endif

4
src/SceneGraph/Object.hpp
Unescape View File

@ -41,8 +41,8 @@ namespace Magnum { namespace SceneGraph {
template<UnsignedInt dimensions, class T> AbstractBasicObject<dimensions, T>::AbstractBasicObject() {} template<UnsignedInt dimensions, class T> AbstractBasicObject<dimensions, T>::AbstractBasicObject() {}
template<UnsignedInt dimensions, class T> AbstractBasicObject<dimensions, T>::~AbstractBasicObject() {} template<UnsignedInt dimensions, class T> AbstractBasicObject<dimensions, T>::~AbstractBasicObject() {}
template<UnsignedInt dimensions, class T> AbstractTransformation<dimensions, T>::AbstractTransformation() {} template<UnsignedInt dimensions, class T> AbstractBasicTransformation<dimensions, T>::AbstractBasicTransformation() {}
template<UnsignedInt dimensions, class T> AbstractTransformation<dimensions, T>::~AbstractTransformation() {} template<UnsignedInt dimensions, class T> AbstractBasicTransformation<dimensions, T>::~AbstractBasicTransformation() {}
template<class Transformation> Object<Transformation>::~Object() = default; template<class Transformation> Object<Transformation>::~Object() = default;

63
src/SceneGraph/RigidMatrixTransformation2D.h
Unescape View File

@ -25,7 +25,7 @@
*/ */
/** @file /** @file
* @brief Class Magnum::SceneGraph::RigidMatrixTransformation2D * @brief Class Magnum::SceneGraph::BasicRigidMatrixTransformation2D, typedef Magnum::SceneGraph::RigidMatrixTransformation2D
*/ */
#include "Math/Matrix3.h" #include "Math/Matrix3.h"
@ -38,17 +38,13 @@ namespace Magnum { namespace SceneGraph {
/** /**
@brief Two-dimensional rigid transformation implemented using matrices @brief Two-dimensional rigid transformation implemented using matrices
Unlike MatrixTransformation2D this class allows only rotation, reflection and Unlike BasicMatrixTransformation2D this class allows only rotation, reflection
translation (no scaling or setting arbitrary transformations). This allows to and translation (no scaling or setting arbitrary transformations). This allows
use Matrix3::invertedRigid() for faster computation of inverse transformations. to use Matrix3::invertedRigid() for faster computation of inverse
@see @ref scenegraph, RigidMatrixTransformation3D transformations.
@see @ref RigidMatrixTransformation2D, @ref scenegraph, @ref BasicRigidMatrixTransformation3D
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT template<class T> class BasicRigidMatrixTransformation2D: public AbstractBasicTranslationRotation2D<T> {
template<class T>
#else
template<class T = Float>
#endif
class RigidMatrixTransformation2D: public AbstractTranslationRotation2D<T> {
public: public:
/** @brief Underlying transformation type */ /** @brief Underlying transformation type */
typedef Math::Matrix3<T> DataType; typedef Math::Matrix3<T> DataType;
@ -84,11 +80,11 @@ class RigidMatrixTransformation2D: public AbstractTranslationRotation2D<T> {
* Normalizes the rotation part using Math::Algorithms::gramSchmidt() * Normalizes the rotation part using Math::Algorithms::gramSchmidt()
* to prevent rounding errors when rotating the object subsequently. * to prevent rounding errors when rotating the object subsequently.
*/ */
Object<RigidMatrixTransformation2D<T>>* normalizeRotation() { Object<BasicRigidMatrixTransformation2D<T>>* normalizeRotation() {
setTransformationInternal(Math::Matrix3<T>::from( setTransformationInternal(Math::Matrix3<T>::from(
Math::Algorithms::gramSchmidtOrthonormalize(_transformation.rotationScaling()), Math::Algorithms::gramSchmidtOrthonormalize(_transformation.rotationScaling()),
_transformation.translation())); _transformation.translation()));
return static_cast<Object<RigidMatrixTransformation2D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation2D<T>>*>(this);
} }
/** /**
@ -98,18 +94,18 @@ class RigidMatrixTransformation2D: public AbstractTranslationRotation2D<T> {
* Expects that the matrix represents rigid transformation. * Expects that the matrix represents rigid transformation.
* @see Matrix3::isRigidTransformation() * @see Matrix3::isRigidTransformation()
*/ */
Object<RigidMatrixTransformation2D<T>>* setTransformation(const Math::Matrix3<T>& transformation) { Object<BasicRigidMatrixTransformation2D<T>>* setTransformation(const Math::Matrix3<T>& transformation) {
CORRADE_ASSERT(transformation.isRigidTransformation(), CORRADE_ASSERT(transformation.isRigidTransformation(),
"SceneGraph::RigidMatrixTransformation2D::setTransformation(): the matrix doesn't represent rigid transformation", "SceneGraph::RigidMatrixTransformation2D::setTransformation(): the matrix doesn't represent rigid transformation",
static_cast<Object<RigidMatrixTransformation2D<T>>*>(this)); static_cast<Object<BasicRigidMatrixTransformation2D<T>>*>(this));
setTransformationInternal(transformation); setTransformationInternal(transformation);
return static_cast<Object<RigidMatrixTransformation2D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation2D<T>>*>(this);
} }
/** @copydoc AbstractTranslationRotationScaling2D::resetTransformation() */ /** @copydoc AbstractTranslationRotationScaling2D::resetTransformation() */
Object<RigidMatrixTransformation2D<T>>* resetTransformation() { Object<BasicRigidMatrixTransformation2D<T>>* resetTransformation() {
setTransformationInternal({}); setTransformationInternal({});
return static_cast<Object<RigidMatrixTransformation2D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation2D<T>>*>(this);
} }
/** /**
@ -121,21 +117,21 @@ class RigidMatrixTransformation2D: public AbstractTranslationRotation2D<T> {
* Expects that the matrix represents rigid transformation. * Expects that the matrix represents rigid transformation.
* @see Matrix3::isRigidTransformation() * @see Matrix3::isRigidTransformation()
*/ */
Object<RigidMatrixTransformation2D<T>>* transform(const Math::Matrix3<T>& transformation, TransformationType type = TransformationType::Global) { Object<BasicRigidMatrixTransformation2D<T>>* transform(const Math::Matrix3<T>& transformation, TransformationType type = TransformationType::Global) {
CORRADE_ASSERT(transformation.isRigidTransformation(), CORRADE_ASSERT(transformation.isRigidTransformation(),
"SceneGraph::RigidMatrixTransformation2D::transform(): the matrix doesn't represent rigid transformation", "SceneGraph::RigidMatrixTransformation2D::transform(): the matrix doesn't represent rigid transformation",
static_cast<Object<RigidMatrixTransformation2D<T>>*>(this)); static_cast<Object<BasicRigidMatrixTransformation2D<T>>*>(this));
transformInternal(transformation, type); transformInternal(transformation, type);
return static_cast<Object<RigidMatrixTransformation2D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation2D<T>>*>(this);
} }
/** /**
* @copydoc AbstractTranslationRotationScaling2D::translate() * @copydoc AbstractTranslationRotationScaling2D::translate()
* Same as calling transform() with Matrix3::translation(). * Same as calling transform() with Matrix3::translation().
*/ */
Object<RigidMatrixTransformation2D<T>>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) { Object<BasicRigidMatrixTransformation2D<T>>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) {
transformInternal(Math::Matrix3<T>::translation(vector), type); transformInternal(Math::Matrix3<T>::translation(vector), type);
return static_cast<Object<RigidMatrixTransformation2D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation2D<T>>*>(this);
} }
/** /**
@ -147,9 +143,9 @@ class RigidMatrixTransformation2D: public AbstractTranslationRotation2D<T> {
* Same as calling transform() with Matrix3::rotation(). * Same as calling transform() with Matrix3::rotation().
* @see normalizeRotation() * @see normalizeRotation()
*/ */
Object<RigidMatrixTransformation2D<T>>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { Object<BasicRigidMatrixTransformation2D<T>>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
transformInternal(Math::Matrix3<T>::rotation(angle), type); transformInternal(Math::Matrix3<T>::rotation(angle), type);
return static_cast<Object<RigidMatrixTransformation2D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation2D<T>>*>(this);
} }
/** /**
@ -161,9 +157,9 @@ class RigidMatrixTransformation2D: public AbstractTranslationRotation2D<T> {
* *
* Same as calling transform() with Matrix3::reflection(). * Same as calling transform() with Matrix3::reflection().
*/ */
Object<RigidMatrixTransformation2D<T>>* reflect(const Math::Vector2<T>& normal, TransformationType type = TransformationType::Global) { Object<BasicRigidMatrixTransformation2D<T>>* reflect(const Math::Vector2<T>& normal, TransformationType type = TransformationType::Global) {
transformInternal(Math::Matrix3<T>::reflection(normal), type); transformInternal(Math::Matrix3<T>::reflection(normal), type);
return static_cast<Object<RigidMatrixTransformation2D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation2D<T>>*>(this);
} }
/** /**
@ -172,14 +168,14 @@ class RigidMatrixTransformation2D: public AbstractTranslationRotation2D<T> {
* if you want to move it above all. * if you want to move it above all.
* @return Pointer to self (for method chaining) * @return Pointer to self (for method chaining)
*/ */
Object<RigidMatrixTransformation2D<T>>* move(Object<RigidMatrixTransformation2D<T>>* under) { Object<BasicRigidMatrixTransformation2D<T>>* move(Object<BasicRigidMatrixTransformation2D<T>>* under) {
static_cast<Object<RigidMatrixTransformation2D>*>(this)->Containers::template LinkedList<Object<RigidMatrixTransformation2D<T>>>::move(this, under); static_cast<Object<BasicRigidMatrixTransformation2D>*>(this)->Containers::template LinkedList<Object<BasicRigidMatrixTransformation2D<T>>>::move(this, under);
return static_cast<Object<RigidMatrixTransformation2D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation2D<T>>*>(this);
} }
protected: protected:
/* Allow construction only from Object */ /* Allow construction only from Object */
explicit RigidMatrixTransformation2D() = default; explicit BasicRigidMatrixTransformation2D() = default;
private: private:
void doResetTransformation() override final { resetTransformation(); } void doResetTransformation() override final { resetTransformation(); }
@ -197,9 +193,9 @@ class RigidMatrixTransformation2D: public AbstractTranslationRotation2D<T> {
/* Setting transformation is forbidden for the scene */ /* Setting transformation is forbidden for the scene */
/** @todo Assert for this? */ /** @todo Assert for this? */
/** @todo Do this in some common code so we don't need to include Object? */ /** @todo Do this in some common code so we don't need to include Object? */
if(!static_cast<Object<RigidMatrixTransformation2D<T>>*>(this)->isScene()) { if(!static_cast<Object<BasicRigidMatrixTransformation2D<T>>*>(this)->isScene()) {
_transformation = transformation; _transformation = transformation;
static_cast<Object<RigidMatrixTransformation2D<T>>*>(this)->setDirty(); static_cast<Object<BasicRigidMatrixTransformation2D<T>>*>(this)->setDirty();
} }
} }
@ -212,6 +208,7 @@ class RigidMatrixTransformation2D: public AbstractTranslationRotation2D<T> {
Math::Matrix3<T> _transformation; Math::Matrix3<T> _transformation;
}; };
}} }}
#endif #endif

75
src/SceneGraph/RigidMatrixTransformation3D.h
Unescape View File

@ -25,7 +25,7 @@
*/ */
/** @file /** @file
* @brief Class Magnum::SceneGraph::RigidMatrixTransformation3D * @brief Class Magnum::SceneGraph::BasicRigidMatrixTransformation3D, typedef Magnum::SceneGraph::RigidMatrixTransformation3D
*/ */
#include "Math/Matrix4.h" #include "Math/Matrix4.h"
@ -38,17 +38,13 @@ namespace Magnum { namespace SceneGraph {
/** /**
@brief Three-dimensional rigid transformation implemented using matrices @brief Three-dimensional rigid transformation implemented using matrices
Unlike MatrixTransformation3D this class allows only rotation, reflection and Unlike BasicMatrixTransformation3D this class allows only rotation, reflection
translation (no scaling or setting arbitrary transformations). This allows to and translation (no scaling or setting arbitrary transformations). This allows
use Matrix4::invertedRigid() for faster computation of inverse transformations. to use Matrix4::invertedRigid() for faster computation of inverse
@see @ref scenegraph, RigidMatrixTransformation2D transformations.
@see @ref RigidMatrixTransformation3D, @ref scenegraph, @ref BasicRigidMatrixTransformation2D
*/ */
#ifndef DOXYGEN_GENERATING_OUTPUT template<class T> class BasicRigidMatrixTransformation3D: public AbstractBasicTranslationRotation3D<T> {
template<class T>
#else
template<class T = Float>
#endif
class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
public: public:
/** @brief Underlying transformation type */ /** @brief Underlying transformation type */
typedef Math::Matrix4<T> DataType; typedef Math::Matrix4<T> DataType;
@ -84,11 +80,11 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
* Normalizes the rotation part using Math::Algorithms::gramSchmidt() * Normalizes the rotation part using Math::Algorithms::gramSchmidt()
* to prevent rounding errors when rotating the object subsequently. * to prevent rounding errors when rotating the object subsequently.
*/ */
Object<RigidMatrixTransformation3D<T>>* normalizeRotation() { Object<BasicRigidMatrixTransformation3D<T>>* normalizeRotation() {
setTransformation(Math::Matrix4<T>::from( setTransformation(Math::Matrix4<T>::from(
Math::Algorithms::gramSchmidtOrthonormalize(_transformation.rotationScaling()), Math::Algorithms::gramSchmidtOrthonormalize(_transformation.rotationScaling()),
_transformation.translation())); _transformation.translation()));
return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation3D<T>>*>(this);
} }
/** /**
@ -98,18 +94,18 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
* Expects that the matrix represents rigid transformation. * Expects that the matrix represents rigid transformation.
* @see Matrix4::isRigidTransformation() * @see Matrix4::isRigidTransformation()
*/ */
Object<RigidMatrixTransformation3D<T>>* setTransformation(const Math::Matrix4<T>& transformation) { Object<BasicRigidMatrixTransformation3D<T>>* setTransformation(const Math::Matrix4<T>& transformation) {
CORRADE_ASSERT(transformation.isRigidTransformation(), CORRADE_ASSERT(transformation.isRigidTransformation(),
"SceneGraph::RigidMatrixTransformation3D::setTransformation(): the matrix doesn't represent rigid transformation", "SceneGraph::RigidMatrixTransformation3D::setTransformation(): the matrix doesn't represent rigid transformation",
static_cast<Object<RigidMatrixTransformation3D<T>>*>(this)); static_cast<Object<BasicRigidMatrixTransformation3D<T>>*>(this));
setTransformationInternal(transformation); setTransformationInternal(transformation);
return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation3D<T>>*>(this);
} }
/** @copydoc AbstractTranslationRotationScaling3D::resetTransformation() */ /** @copydoc AbstractTranslationRotationScaling3D::resetTransformation() */
Object<RigidMatrixTransformation3D<T>>* resetTransformation() { Object<BasicRigidMatrixTransformation3D<T>>* resetTransformation() {
setTransformation({}); setTransformation({});
return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation3D<T>>*>(this);
} }
/** /**
@ -121,21 +117,21 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
* Expects that the matrix represents rigid transformation. * Expects that the matrix represents rigid transformation.
* @see Matrix4::isRigidTransformation() * @see Matrix4::isRigidTransformation()
*/ */
Object<RigidMatrixTransformation3D<T>>* transform(const Math::Matrix4<T>& transformation, TransformationType type = TransformationType::Global) { Object<BasicRigidMatrixTransformation3D<T>>* transform(const Math::Matrix4<T>& transformation, TransformationType type = TransformationType::Global) {
CORRADE_ASSERT(transformation.isRigidTransformation(), CORRADE_ASSERT(transformation.isRigidTransformation(),
"SceneGraph::RigidMatrixTransformation3D::transform(): the matrix doesn't represent rigid transformation", "SceneGraph::RigidMatrixTransformation3D::transform(): the matrix doesn't represent rigid transformation",
static_cast<Object<RigidMatrixTransformation3D<T>>*>(this)); static_cast<Object<BasicRigidMatrixTransformation3D<T>>*>(this));
transformInternal(transformation, type); transformInternal(transformation, type);
return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation3D<T>>*>(this);
} }
/** /**
* @copydoc AbstractTranslationRotationScaling3D::translate() * @copydoc AbstractTranslationRotationScaling3D::translate()
* Same as calling transform() with Matrix4::translation(). * Same as calling transform() with Matrix4::translation().
*/ */
Object<RigidMatrixTransformation3D<T>>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) { Object<BasicRigidMatrixTransformation3D<T>>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) {
transformInternal(Math::Matrix4<T>::translation(vector), type); transformInternal(Math::Matrix4<T>::translation(vector), type);
return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation3D<T>>*>(this);
} }
/** /**
@ -149,9 +145,9 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
* @see rotateX(), rotateY(), rotateZ(), Vector3::xAxis(), * @see rotateX(), rotateY(), rotateZ(), Vector3::xAxis(),
* Vector3::yAxis(), Vector3::zAxis(), normalizeRotation() * Vector3::yAxis(), Vector3::zAxis(), normalizeRotation()
*/ */
Object<RigidMatrixTransformation3D<T>>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) { Object<BasicRigidMatrixTransformation3D<T>>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) {
transformInternal(Math::Matrix4<T>::rotation(angle, normalizedAxis), type); transformInternal(Math::Matrix4<T>::rotation(angle, normalizedAxis), type);
return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation3D<T>>*>(this);
} }
/** /**
@ -163,9 +159,9 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
* Same as calling transform() with Matrix4::rotationX(). * Same as calling transform() with Matrix4::rotationX().
* @see normalizeRotation() * @see normalizeRotation()
*/ */
Object<RigidMatrixTransformation3D<T>>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { Object<BasicRigidMatrixTransformation3D<T>>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
transformInternal(Math::Matrix4<T>::rotationX(angle), type); transformInternal(Math::Matrix4<T>::rotationX(angle), type);
return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation3D<T>>*>(this);
} }
/** /**
@ -177,9 +173,9 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
* Same as calling transform() with Matrix4::rotationY(). * Same as calling transform() with Matrix4::rotationY().
* @see normalizeRotation() * @see normalizeRotation()
*/ */
Object<RigidMatrixTransformation3D<T>>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { Object<BasicRigidMatrixTransformation3D<T>>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
transformInternal(Math::Matrix4<T>::rotationY(angle), type); transformInternal(Math::Matrix4<T>::rotationY(angle), type);
return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation3D<T>>*>(this);
} }
/** /**
@ -191,9 +187,9 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
* Same as calling transform() with Matrix4::rotationZ(). * Same as calling transform() with Matrix4::rotationZ().
* @see normalizeRotation() * @see normalizeRotation()
*/ */
Object<RigidMatrixTransformation3D<T>>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) { Object<BasicRigidMatrixTransformation3D<T>>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
transformInternal(Math::Matrix4<T>::rotationZ(angle), type); transformInternal(Math::Matrix4<T>::rotationZ(angle), type);
return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation3D<T>>*>(this);
} }
/** /**
@ -205,14 +201,14 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
* *
* Same as calling transform() with Matrix4::reflection(). * Same as calling transform() with Matrix4::reflection().
*/ */
Object<RigidMatrixTransformation3D<T>>* reflect(const Math::Vector3<T>& normal, TransformationType type = TransformationType::Global) { Object<BasicRigidMatrixTransformation3D<T>>* reflect(const Math::Vector3<T>& normal, TransformationType type = TransformationType::Global) {
transformInternal(Math::Matrix4<T>::reflection(normal), type); transformInternal(Math::Matrix4<T>::reflection(normal), type);
return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this); return static_cast<Object<BasicRigidMatrixTransformation3D<T>>*>(this);
} }
protected: protected:
/* Allow construction only from Object */ /* Allow construction only from Object */
explicit RigidMatrixTransformation3D() = default; explicit BasicRigidMatrixTransformation3D() = default;
private: private:
void doResetTransformation() override final { resetTransformation(); } void doResetTransformation() override final { resetTransformation(); }
@ -242,9 +238,9 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
/* Setting transformation is forbidden for the scene */ /* Setting transformation is forbidden for the scene */
/** @todo Assert for this? */ /** @todo Assert for this? */
/** @todo Do this in some common code so we don't need to include Object? */ /** @todo Do this in some common code so we don't need to include Object? */
if(!static_cast<Object<RigidMatrixTransformation3D<T>>*>(this)->isScene()) { if(!static_cast<Object<BasicRigidMatrixTransformation3D<T>>*>(this)->isScene()) {
_transformation = transformation; _transformation = transformation;
static_cast<Object<RigidMatrixTransformation3D<T>>*>(this)->setDirty(); static_cast<Object<BasicRigidMatrixTransformation3D<T>>*>(this)->setDirty();
} }
} }
@ -257,6 +253,13 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
Math::Matrix4<T> _transformation; Math::Matrix4<T> _transformation;
}; };
/**
@brief Three-dimensional rigid transformation for float scenes implemented using matrices
@see @ref RigidMatrixTransformation2D
*/
typedef BasicRigidMatrixTransformation3D<Float> RigidMatrixTransformation3D;
}} }}
#endif #endif

39
src/SceneGraph/SceneGraph.h
Unescape View File

@ -64,16 +64,19 @@ typedef AbstractBasicObject<3, Float> AbstractObject3D;
enum class TransformationType: UnsignedByte; enum class TransformationType: UnsignedByte;
template<UnsignedInt dimensions, class T = Float> class AbstractTransformation; template<UnsignedInt dimensions, class> class AbstractBasicTransformation;
#ifndef CORRADE_GCC46_COMPATIBILITY typedef AbstractBasicTransformation<2, Float> AbstractTransformation2D;
template<class T = Float> using AbstractTransformation2D = AbstractTransformation<2, T>; typedef AbstractBasicTransformation<3, Float> AbstractTransformation3D;
template<class T = Float> using AbstractTransformation3D = AbstractTransformation<3, T>;
#endif template<class> class AbstractBasicTranslationRotation2D;
template<class> class AbstractBasicTranslationRotation3D;
typedef AbstractBasicTranslationRotation2D<Float> AbstractTranslationRotation2D;
typedef AbstractBasicTranslationRotation3D<Float> AbstractTranslationRotation3D;
template<class T = Float> class AbstractTranslationRotation2D; template<class> class AbstractBasicTranslationRotationScaling2D;
template<class T = Float> class AbstractTranslationRotation3D; template<class> class AbstractBasicTranslationRotationScaling3D;
template<class T = Float> class AbstractTranslationRotationScaling2D; typedef AbstractBasicTranslationRotationScaling2D<Float> AbstractTranslationRotationScaling2D;
template<class T = Float> class AbstractTranslationRotationScaling3D; typedef AbstractBasicTranslationRotationScaling3D<Float> AbstractTranslationRotationScaling3D;
template<UnsignedInt, class> class BasicAnimable; template<UnsignedInt, class> class BasicAnimable;
typedef BasicAnimable<2, Float> Animable2D; typedef BasicAnimable<2, Float> Animable2D;
@ -94,8 +97,10 @@ template<UnsignedInt, class> class BasicDrawable;
typedef BasicDrawable<2, Float> Drawable2D; typedef BasicDrawable<2, Float> Drawable2D;
typedef BasicDrawable<3, Float> Drawable3D; typedef BasicDrawable<3, Float> Drawable3D;
template<class T = Float> class DualComplexTransformation; template<class> class BasicDualComplexTransformation;
template<class T = Float> class DualQuaternionTransformation; template<class> class BasicDualQuaternionTransformation;
typedef BasicDualComplexTransformation<Float> DualComplexTransformation;
typedef BasicDualQuaternionTransformation<Float> DualQuaternionTransformation;
template<UnsignedInt dimensions, class Feature, class T> class BasicFeatureGroup; template<UnsignedInt dimensions, class Feature, class T> class BasicFeatureGroup;
#ifndef CORRADE_GCC46_COMPATIBILITY #ifndef CORRADE_GCC46_COMPATIBILITY
@ -111,13 +116,17 @@ template<UnsignedInt, class> class BasicDrawableGroup;
typedef BasicDrawableGroup<2, Float> DrawableGroup2D; typedef BasicDrawableGroup<2, Float> DrawableGroup2D;
typedef BasicDrawableGroup<3, Float> DrawableGroup3D; typedef BasicDrawableGroup<3, Float> DrawableGroup3D;
template<class T = Float> class MatrixTransformation2D; template<class> class BasicMatrixTransformation2D;
template<class T = Float> class MatrixTransformation3D; template<class> class BasicMatrixTransformation3D;
typedef BasicMatrixTransformation2D<Float> MatrixTransformation2D;
typedef BasicMatrixTransformation3D<Float> MatrixTransformation3D;
template<class Transformation> class Object; template<class Transformation> class Object;
template<class T = Float> class RigidMatrixTransformation2D; template<class> class BasicRigidMatrixTransformation2D;
template<class T = Float> class RigidMatrixTransformation3D; template<class> class BasicRigidMatrixTransformation3D;
typedef BasicRigidMatrixTransformation2D<Float> RigidMatrixTransformation2D;
typedef BasicRigidMatrixTransformation3D<Float> RigidMatrixTransformation3D;
template<class Transformation> class Scene; template<class Transformation> class Scene;
#endif #endif

2
src/SceneGraph/Test/AnimableTest.cpp
Unescape View File

@ -45,7 +45,7 @@ class AnimableTest: public TestSuite::Tester {
void debug(); void debug();
}; };
typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<>> Object3D; typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D> Object3D;
AnimableTest::AnimableTest() { AnimableTest::AnimableTest() {
addTests({&AnimableTest::state, addTests({&AnimableTest::state,

6
src/SceneGraph/Test/CameraTest.cpp
Unescape View File

@ -48,9 +48,9 @@ class CameraTest: public TestSuite::Tester {
void draw(); void draw();
}; };
typedef SceneGraph::Object<SceneGraph::MatrixTransformation2D<>> Object2D; typedef SceneGraph::Object<SceneGraph::MatrixTransformation2D> Object2D;
typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<>> Object3D; typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D> Object3D;
typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D<>> Scene3D; typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D> Scene3D;
CameraTest::CameraTest() { CameraTest::CameraTest() {
addTests({&CameraTest::fixAspectRatio, addTests({&CameraTest::fixAspectRatio,

12
src/SceneGraph/Test/DualComplexTransformationTest.cpp
Unescape View File

@ -30,8 +30,8 @@
namespace Magnum { namespace SceneGraph { namespace Test { namespace Magnum { namespace SceneGraph { namespace Test {
typedef Object<DualComplexTransformation<>> Object2D; typedef Object<DualComplexTransformation> Object2D;
typedef Scene<DualComplexTransformation<>> Scene2D; typedef Scene<DualComplexTransformation> Scene2D;
class DualComplexTransformationTest: public TestSuite::Tester { class DualComplexTransformationTest: public TestSuite::Tester {
public: public:
@ -67,24 +67,24 @@ DualComplexTransformationTest::DualComplexTransformationTest() {
void DualComplexTransformationTest::fromMatrix() { void DualComplexTransformationTest::fromMatrix() {
Matrix3 m = Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f}); Matrix3 m = Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f});
DualComplex c = DualComplex::rotation(Deg(17.0f))*DualComplex::translation({1.0f, -0.3f}); DualComplex c = DualComplex::rotation(Deg(17.0f))*DualComplex::translation({1.0f, -0.3f});
CORRADE_COMPARE(DualComplexTransformation<>::fromMatrix(m), c); CORRADE_COMPARE(DualComplexTransformation::fromMatrix(m), c);
} }
void DualComplexTransformationTest::toMatrix() { void DualComplexTransformationTest::toMatrix() {
DualComplex c = DualComplex::rotation(Deg(17.0f))*DualComplex::translation({1.0f, -0.3f}); DualComplex c = DualComplex::rotation(Deg(17.0f))*DualComplex::translation({1.0f, -0.3f});
Matrix3 m = Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f}); Matrix3 m = Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f});
CORRADE_COMPARE(DualComplexTransformation<>::toMatrix(c), m); CORRADE_COMPARE(DualComplexTransformation::toMatrix(c), m);
} }
void DualComplexTransformationTest::compose() { void DualComplexTransformationTest::compose() {
DualComplex parent = DualComplex::rotation(Deg(17.0f)); DualComplex parent = DualComplex::rotation(Deg(17.0f));
DualComplex child = DualComplex::translation({1.0f, -0.3f}); DualComplex child = DualComplex::translation({1.0f, -0.3f});
CORRADE_COMPARE(DualComplexTransformation<>::compose(parent, child), parent*child); CORRADE_COMPARE(DualComplexTransformation::compose(parent, child), parent*child);
} }
void DualComplexTransformationTest::inverted() { void DualComplexTransformationTest::inverted() {
DualComplex c = DualComplex::rotation(Deg(17.0f))*DualComplex::translation({1.0f, -0.3f}); DualComplex c = DualComplex::rotation(Deg(17.0f))*DualComplex::translation({1.0f, -0.3f});
CORRADE_COMPARE(DualComplexTransformation<>::inverted(c)*c, DualComplex()); CORRADE_COMPARE(DualComplexTransformation::inverted(c)*c, DualComplex());
} }
void DualComplexTransformationTest::setTransformation() { void DualComplexTransformationTest::setTransformation() {

12
src/SceneGraph/Test/DualQuaternionTransformationTest.cpp
Unescape View File

@ -30,8 +30,8 @@
namespace Magnum { namespace SceneGraph { namespace Test { namespace Magnum { namespace SceneGraph { namespace Test {
typedef Object<DualQuaternionTransformation<>> Object3D; typedef Object<DualQuaternionTransformation> Object3D;
typedef Scene<DualQuaternionTransformation<>> Scene3D; typedef Scene<DualQuaternionTransformation> Scene3D;
class DualQuaternionTransformationTest: public TestSuite::Tester { class DualQuaternionTransformationTest: public TestSuite::Tester {
public: public:
@ -67,24 +67,24 @@ DualQuaternionTransformationTest::DualQuaternionTransformationTest() {
void DualQuaternionTransformationTest::fromMatrix() { void DualQuaternionTransformationTest::fromMatrix() {
Matrix4 m = Matrix4::rotationX(Deg(17.0f))*Matrix4::translation({1.0f, -0.3f, 2.3f}); Matrix4 m = Matrix4::rotationX(Deg(17.0f))*Matrix4::translation({1.0f, -0.3f, 2.3f});
DualQuaternion q = DualQuaternion::rotation(Deg(17.0f), Vector3::xAxis())*DualQuaternion::translation({1.0f, -0.3f, 2.3f}); DualQuaternion q = DualQuaternion::rotation(Deg(17.0f), Vector3::xAxis())*DualQuaternion::translation({1.0f, -0.3f, 2.3f});
CORRADE_COMPARE(DualQuaternionTransformation<>::fromMatrix(m), q); CORRADE_COMPARE(DualQuaternionTransformation::fromMatrix(m), q);
} }
void DualQuaternionTransformationTest::toMatrix() { void DualQuaternionTransformationTest::toMatrix() {
DualQuaternion q = DualQuaternion::rotation(Deg(17.0f), Vector3::xAxis())*DualQuaternion::translation({1.0f, -0.3f, 2.3f}); DualQuaternion q = DualQuaternion::rotation(Deg(17.0f), Vector3::xAxis())*DualQuaternion::translation({1.0f, -0.3f, 2.3f});
Matrix4 m = Matrix4::rotationX(Deg(17.0f))*Matrix4::translation({1.0f, -0.3f, 2.3f}); Matrix4 m = Matrix4::rotationX(Deg(17.0f))*Matrix4::translation({1.0f, -0.3f, 2.3f});
CORRADE_COMPARE(DualQuaternionTransformation<>::toMatrix(q), m); CORRADE_COMPARE(DualQuaternionTransformation::toMatrix(q), m);
} }
void DualQuaternionTransformationTest::compose() { void DualQuaternionTransformationTest::compose() {
DualQuaternion parent = DualQuaternion::rotation(Deg(17.0f), Vector3::xAxis()); DualQuaternion parent = DualQuaternion::rotation(Deg(17.0f), Vector3::xAxis());
DualQuaternion child = DualQuaternion::translation({1.0f, -0.3f, 2.3f}); DualQuaternion child = DualQuaternion::translation({1.0f, -0.3f, 2.3f});
CORRADE_COMPARE(DualQuaternionTransformation<>::compose(parent, child), parent*child); CORRADE_COMPARE(DualQuaternionTransformation::compose(parent, child), parent*child);
} }
void DualQuaternionTransformationTest::inverted() { void DualQuaternionTransformationTest::inverted() {
DualQuaternion q = DualQuaternion::rotation(Deg(17.0f), Vector3::xAxis())*DualQuaternion::translation({1.0f, -0.3f, 2.3f}); DualQuaternion q = DualQuaternion::rotation(Deg(17.0f), Vector3::xAxis())*DualQuaternion::translation({1.0f, -0.3f, 2.3f});
CORRADE_COMPARE(DualQuaternionTransformation<>::inverted(q)*q, DualQuaternion()); CORRADE_COMPARE(DualQuaternionTransformation::inverted(q)*q, DualQuaternion());
} }
void DualQuaternionTransformationTest::setTransformation() { void DualQuaternionTransformationTest::setTransformation() {

12
src/SceneGraph/Test/MatrixTransformation2DTest.cpp
Unescape View File

@ -29,8 +29,8 @@
namespace Magnum { namespace SceneGraph { namespace Test { namespace Magnum { namespace SceneGraph { namespace Test {
typedef Object<MatrixTransformation2D<>> Object2D; typedef Object<MatrixTransformation2D> Object2D;
typedef Scene<MatrixTransformation2D<>> Scene2D; typedef Scene<MatrixTransformation2D> Scene2D;
class MatrixTransformation2DTest: public TestSuite::Tester { class MatrixTransformation2DTest: public TestSuite::Tester {
public: public:
@ -67,23 +67,23 @@ MatrixTransformation2DTest::MatrixTransformation2DTest() {
void MatrixTransformation2DTest::fromMatrix() { void MatrixTransformation2DTest::fromMatrix() {
Matrix3 m = Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f}); Matrix3 m = Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f});
CORRADE_COMPARE(MatrixTransformation2D<>::fromMatrix(m), m); CORRADE_COMPARE(MatrixTransformation2D::fromMatrix(m), m);
} }
void MatrixTransformation2DTest::toMatrix() { void MatrixTransformation2DTest::toMatrix() {
Matrix3 m = Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f}); Matrix3 m = Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f});
CORRADE_COMPARE(MatrixTransformation2D<>::toMatrix(m), m); CORRADE_COMPARE(MatrixTransformation2D::toMatrix(m), m);
} }
void MatrixTransformation2DTest::compose() { void MatrixTransformation2DTest::compose() {
Matrix3 parent = Matrix3::rotation(Deg(17.0f)); Matrix3 parent = Matrix3::rotation(Deg(17.0f));
Matrix3 child = Matrix3::translation({1.0f, -0.3f}); Matrix3 child = Matrix3::translation({1.0f, -0.3f});
CORRADE_COMPARE(MatrixTransformation2D<>::compose(parent, child), parent*child); CORRADE_COMPARE(MatrixTransformation2D::compose(parent, child), parent*child);
} }
void MatrixTransformation2DTest::inverted() { void MatrixTransformation2DTest::inverted() {
Matrix3 m = Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f}); Matrix3 m = Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f});
CORRADE_COMPARE(MatrixTransformation2D<>::inverted(m)*m, Matrix3()); CORRADE_COMPARE(MatrixTransformation2D::inverted(m)*m, Matrix3());
} }
void MatrixTransformation2DTest::setTransformation() { void MatrixTransformation2DTest::setTransformation() {

12
src/SceneGraph/Test/MatrixTransformation3DTest.cpp
Unescape View File

@ -29,8 +29,8 @@
namespace Magnum { namespace SceneGraph { namespace Test { namespace Magnum { namespace SceneGraph { namespace Test {
typedef Object<MatrixTransformation3D<>> Object3D; typedef Object<MatrixTransformation3D> Object3D;
typedef Scene<MatrixTransformation3D<>> Scene3D; typedef Scene<MatrixTransformation3D> Scene3D;
class MatrixTransformation3DTest: public TestSuite::Tester { class MatrixTransformation3DTest: public TestSuite::Tester {
public: public:
@ -67,23 +67,23 @@ MatrixTransformation3DTest::MatrixTransformation3DTest() {
void MatrixTransformation3DTest::fromMatrix() { void MatrixTransformation3DTest::fromMatrix() {
Matrix4 m = Matrix4::rotationX(Deg(17.0f))*Matrix4::translation({1.0f, -0.3f, 2.3f})*Matrix4::scaling({2.0f, 1.4f, -2.1f}); Matrix4 m = Matrix4::rotationX(Deg(17.0f))*Matrix4::translation({1.0f, -0.3f, 2.3f})*Matrix4::scaling({2.0f, 1.4f, -2.1f});
CORRADE_COMPARE(MatrixTransformation3D<>::fromMatrix(m), m); CORRADE_COMPARE(MatrixTransformation3D::fromMatrix(m), m);
} }
void MatrixTransformation3DTest::toMatrix() { void MatrixTransformation3DTest::toMatrix() {
Matrix4 m = Matrix4::rotationX(Deg(17.0f))*Matrix4::translation({1.0f, -0.3f, 2.3f})*Matrix4::scaling({2.0f, 1.4f, -2.1f}); Matrix4 m = Matrix4::rotationX(Deg(17.0f))*Matrix4::translation({1.0f, -0.3f, 2.3f})*Matrix4::scaling({2.0f, 1.4f, -2.1f});
CORRADE_COMPARE(MatrixTransformation3D<>::toMatrix(m), m); CORRADE_COMPARE(MatrixTransformation3D::toMatrix(m), m);
} }
void MatrixTransformation3DTest::compose() { void MatrixTransformation3DTest::compose() {
Matrix4 parent = Matrix4::rotationX(Deg(17.0f)); Matrix4 parent = Matrix4::rotationX(Deg(17.0f));
Matrix4 child = Matrix4::translation({1.0f, -0.3f, 2.3f}); Matrix4 child = Matrix4::translation({1.0f, -0.3f, 2.3f});
CORRADE_COMPARE(MatrixTransformation3D<>::compose(parent, child), parent*child); CORRADE_COMPARE(MatrixTransformation3D::compose(parent, child), parent*child);
} }
void MatrixTransformation3DTest::inverted() { void MatrixTransformation3DTest::inverted() {
Matrix4 m = Matrix4::rotationX(Deg(17.0f))*Matrix4::translation({1.0f, -0.3f, 2.3f})*Matrix4::scaling({2.0f, 1.4f, -2.1f}); Matrix4 m = Matrix4::rotationX(Deg(17.0f))*Matrix4::translation({1.0f, -0.3f, 2.3f})*Matrix4::scaling({2.0f, 1.4f, -2.1f});
CORRADE_COMPARE(MatrixTransformation3D<>::inverted(m)*m, Matrix4()); CORRADE_COMPARE(MatrixTransformation3D::inverted(m)*m, Matrix4());
} }
void MatrixTransformation3DTest::setTransformation() { void MatrixTransformation3DTest::setTransformation() {

4
src/SceneGraph/Test/ObjectTest.cpp
Unescape View File

@ -47,8 +47,8 @@ class ObjectTest: public TestSuite::Tester {
void setCleanListBulk(); void setCleanListBulk();
}; };
typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<>> Object3D; typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D> Object3D;
typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D<>> Scene3D; typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D> Scene3D;
class CachingObject: public Object3D, AbstractFeature3D { class CachingObject: public Object3D, AbstractFeature3D {
public: public:

14
src/SceneGraph/Test/RigidMatrixTransformation2DTest.cpp
Unescape View File

@ -30,8 +30,8 @@
namespace Magnum { namespace SceneGraph { namespace Test { namespace Magnum { namespace SceneGraph { namespace Test {
typedef Object<RigidMatrixTransformation2D<>> Object2D; typedef Object<RigidMatrixTransformation2D> Object2D;
typedef Scene<RigidMatrixTransformation2D<>> Scene2D; typedef Scene<RigidMatrixTransformation2D> Scene2D;
class RigidMatrixTransformation2DTest: public TestSuite::Tester { class RigidMatrixTransformation2DTest: public TestSuite::Tester {
public: public:
@ -69,27 +69,27 @@ RigidMatrixTransformation2DTest::RigidMatrixTransformation2DTest() {
void RigidMatrixTransformation2DTest::fromMatrix() { void RigidMatrixTransformation2DTest::fromMatrix() {
std::ostringstream o; std::ostringstream o;
Error::setOutput(&o); Error::setOutput(&o);
RigidMatrixTransformation2D<>::fromMatrix(Matrix3::scaling(Vector2(4.0f))); RigidMatrixTransformation2D::fromMatrix(Matrix3::scaling(Vector2(4.0f)));
CORRADE_COMPARE(o.str(), "SceneGraph::RigidMatrixTransformation2D::fromMatrix(): the matrix doesn't represent rigid transformation\n"); CORRADE_COMPARE(o.str(), "SceneGraph::RigidMatrixTransformation2D::fromMatrix(): the matrix doesn't represent rigid transformation\n");
Matrix3 m = Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f}); Matrix3 m = Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f});
CORRADE_COMPARE(RigidMatrixTransformation2D<>::fromMatrix(m), m); CORRADE_COMPARE(RigidMatrixTransformation2D::fromMatrix(m), m);
} }
void RigidMatrixTransformation2DTest::toMatrix() { void RigidMatrixTransformation2DTest::toMatrix() {
Matrix3 m = Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f}); Matrix3 m = Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f});
CORRADE_COMPARE(RigidMatrixTransformation2D<>::toMatrix(m), m); CORRADE_COMPARE(RigidMatrixTransformation2D::toMatrix(m), m);
} }
void RigidMatrixTransformation2DTest::compose() { void RigidMatrixTransformation2DTest::compose() {
Matrix3 parent = Matrix3::rotation(Deg(17.0f)); Matrix3 parent = Matrix3::rotation(Deg(17.0f));
Matrix3 child = Matrix3::translation({1.0f, -0.3f}); Matrix3 child = Matrix3::translation({1.0f, -0.3f});
CORRADE_COMPARE(RigidMatrixTransformation2D<>::compose(parent, child), parent*child); CORRADE_COMPARE(RigidMatrixTransformation2D::compose(parent, child), parent*child);
} }
void RigidMatrixTransformation2DTest::inverted() { void RigidMatrixTransformation2DTest::inverted() {
Matrix3 m = Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f}); Matrix3 m = Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f});
CORRADE_COMPARE(RigidMatrixTransformation2D<>::inverted(m)*m, Matrix3()); CORRADE_COMPARE(RigidMatrixTransformation2D::inverted(m)*m, Matrix3());
} }
void RigidMatrixTransformation2DTest::setTransformation() { void RigidMatrixTransformation2DTest::setTransformation() {

14
src/SceneGraph/Test/RigidMatrixTransformation3DTest.cpp
Unescape View File

@ -30,8 +30,8 @@
namespace Magnum { namespace SceneGraph { namespace Test { namespace Magnum { namespace SceneGraph { namespace Test {
typedef Object<RigidMatrixTransformation3D<>> Object3D; typedef Object<RigidMatrixTransformation3D> Object3D;
typedef Scene<RigidMatrixTransformation3D<>> Scene3D; typedef Scene<RigidMatrixTransformation3D> Scene3D;
class RigidMatrixTransformation3DTest: public TestSuite::Tester { class RigidMatrixTransformation3DTest: public TestSuite::Tester {
public: public:
@ -69,27 +69,27 @@ RigidMatrixTransformation3DTest::RigidMatrixTransformation3DTest() {
void RigidMatrixTransformation3DTest::fromMatrix() { void RigidMatrixTransformation3DTest::fromMatrix() {
std::ostringstream o; std::ostringstream o;
Error::setOutput(&o); Error::setOutput(&o);
RigidMatrixTransformation3D<>::fromMatrix(Matrix4::scaling(Vector3(4.0f))); RigidMatrixTransformation3D::fromMatrix(Matrix4::scaling(Vector3(4.0f)));
CORRADE_COMPARE(o.str(), "SceneGraph::RigidMatrixTransformation3D::fromMatrix(): the matrix doesn't represent rigid transformation\n"); CORRADE_COMPARE(o.str(), "SceneGraph::RigidMatrixTransformation3D::fromMatrix(): the matrix doesn't represent rigid transformation\n");
Matrix4 m = Matrix4::rotationX(Deg(17.0f))*Matrix4::translation({1.0f, -0.3f, 2.3f}); Matrix4 m = Matrix4::rotationX(Deg(17.0f))*Matrix4::translation({1.0f, -0.3f, 2.3f});
CORRADE_COMPARE(RigidMatrixTransformation3D<>::fromMatrix(m), m); CORRADE_COMPARE(RigidMatrixTransformation3D::fromMatrix(m), m);
} }
void RigidMatrixTransformation3DTest::toMatrix() { void RigidMatrixTransformation3DTest::toMatrix() {
Matrix4 m = Matrix4::rotationX(Deg(17.0f))*Matrix4::translation({1.0f, -0.3f, 2.3f}); Matrix4 m = Matrix4::rotationX(Deg(17.0f))*Matrix4::translation({1.0f, -0.3f, 2.3f});
CORRADE_COMPARE(RigidMatrixTransformation3D<>::toMatrix(m), m); CORRADE_COMPARE(RigidMatrixTransformation3D::toMatrix(m), m);
} }
void RigidMatrixTransformation3DTest::compose() { void RigidMatrixTransformation3DTest::compose() {
Matrix4 parent = Matrix4::rotationX(Deg(17.0f)); Matrix4 parent = Matrix4::rotationX(Deg(17.0f));
Matrix4 child = Matrix4::translation({1.0f, -0.3f, 2.3f}); Matrix4 child = Matrix4::translation({1.0f, -0.3f, 2.3f});
CORRADE_COMPARE(RigidMatrixTransformation3D<>::compose(parent, child), parent*child); CORRADE_COMPARE(RigidMatrixTransformation3D::compose(parent, child), parent*child);
} }
void RigidMatrixTransformation3DTest::inverted() { void RigidMatrixTransformation3DTest::inverted() {
Matrix4 m = Matrix4::rotationX(Deg(17.0f))*Matrix4::translation({1.0f, -0.3f, 2.3f}); Matrix4 m = Matrix4::rotationX(Deg(17.0f))*Matrix4::translation({1.0f, -0.3f, 2.3f});
CORRADE_COMPARE(RigidMatrixTransformation3D<>::inverted(m)*m, Matrix4()); CORRADE_COMPARE(RigidMatrixTransformation3D::inverted(m)*m, Matrix4());
} }
void RigidMatrixTransformation3DTest::setTransformation() { void RigidMatrixTransformation3DTest::setTransformation() {

4
src/SceneGraph/Test/SceneTest.cpp
Unescape View File

@ -37,8 +37,8 @@ class SceneTest: public TestSuite::Tester {
void parent(); void parent();
}; };
typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D<Float>> Scene3D; typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D> Scene3D;
typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<Float>> Object3D; typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D> Object3D;
SceneTest::SceneTest() { SceneTest::SceneTest() {
addTests({&SceneTest::transformation, addTests({&SceneTest::transformation,

16
src/SceneGraph/instantiation.cpp
Unescape View File

@ -39,8 +39,8 @@ namespace Magnum { namespace SceneGraph {
#ifndef DOXYGEN_GENERATING_OUTPUT #ifndef DOXYGEN_GENERATING_OUTPUT
template class AbstractBasicObject<2, Float>; template class AbstractBasicObject<2, Float>;
template class AbstractBasicObject<3, Float>; template class AbstractBasicObject<3, Float>;
template class AbstractTransformation<2, Float>; template class AbstractBasicTransformation<2, Float>;
template class AbstractTransformation<3, Float>; template class AbstractBasicTransformation<3, Float>;
template class MAGNUM_SCENEGRAPH_EXPORT AbstractBasicFeature<2, Float>; template class MAGNUM_SCENEGRAPH_EXPORT AbstractBasicFeature<2, Float>;
template class MAGNUM_SCENEGRAPH_EXPORT AbstractBasicFeature<3, Float>; template class MAGNUM_SCENEGRAPH_EXPORT AbstractBasicFeature<3, Float>;
@ -52,12 +52,12 @@ template class AbstractBasicCamera<3, Float>;
template class BasicCamera2D<Float>; template class BasicCamera2D<Float>;
template class BasicCamera3D<Float>; template class BasicCamera3D<Float>;
template class MAGNUM_SCENEGRAPH_EXPORT Object<DualComplexTransformation<Float>>; template class MAGNUM_SCENEGRAPH_EXPORT Object<BasicDualComplexTransformation<Float>>;
template class MAGNUM_SCENEGRAPH_EXPORT Object<DualQuaternionTransformation<Float>>; template class MAGNUM_SCENEGRAPH_EXPORT Object<BasicDualQuaternionTransformation<Float>>;
template class MAGNUM_SCENEGRAPH_EXPORT Object<MatrixTransformation2D<Float>>; template class MAGNUM_SCENEGRAPH_EXPORT Object<BasicMatrixTransformation2D<Float>>;
template class MAGNUM_SCENEGRAPH_EXPORT Object<MatrixTransformation3D<Float>>; template class MAGNUM_SCENEGRAPH_EXPORT Object<BasicMatrixTransformation3D<Float>>;
template class MAGNUM_SCENEGRAPH_EXPORT Object<RigidMatrixTransformation2D<Float>>; template class MAGNUM_SCENEGRAPH_EXPORT Object<BasicRigidMatrixTransformation2D<Float>>;
template class MAGNUM_SCENEGRAPH_EXPORT Object<RigidMatrixTransformation3D<Float>>; template class MAGNUM_SCENEGRAPH_EXPORT Object<BasicRigidMatrixTransformation3D<Float>>;
#endif #endif
}} }}

8
src/Shapes/Test/ShapeTest.cpp
Unescape View File

@ -44,10 +44,10 @@ class ShapeTest: public TestSuite::Tester {
void shapeGroup(); void shapeGroup();
}; };
typedef SceneGraph::Scene<SceneGraph::MatrixTransformation2D<>> Scene2D; typedef SceneGraph::Scene<SceneGraph::MatrixTransformation2D> Scene2D;
typedef SceneGraph::Object<SceneGraph::MatrixTransformation2D<>> Object2D; typedef SceneGraph::Object<SceneGraph::MatrixTransformation2D> Object2D;
typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D<>> Scene3D; typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D> Scene3D;
typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<>> Object3D; typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D> Object3D;
ShapeTest::ShapeTest() { ShapeTest::ShapeTest() {
addTests({&ShapeTest::clean, addTests({&ShapeTest::clean,

Write Preview
Loading…
Cancel
Save