mirror of https://github.com/mosra/magnum.git
Vladimír Vondruš
13 years ago
7 changed files with 408 additions and 1 deletions
@ -0,0 +1,35 @@
|
||||
/*
|
||||
This file is part of Magnum. |
||||
|
||||
Copyright © 2010, 2011, 2012, 2013 Vladimír Vondruš <mosra@centrum.cz> |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a |
||||
copy of this software and associated documentation files (the "Software"), |
||||
to deal in the Software without restriction, including without limitation |
||||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||||
and/or sell copies of the Software, and to permit persons to whom the |
||||
Software is furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included |
||||
in all copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||||
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||
DEALINGS IN THE SOFTWARE. |
||||
*/ |
||||
|
||||
#include "DualComplexTransformation.h" |
||||
|
||||
#include "Object.hpp" |
||||
|
||||
namespace Magnum { namespace SceneGraph { |
||||
|
||||
#ifndef DOXYGEN_GENERATING_OUTPUT |
||||
template class MAGNUM_SCENEGRAPH_EXPORT Object<DualComplexTransformation<>>; |
||||
#endif |
||||
|
||||
}} |
||||
@ -0,0 +1,185 @@
|
||||
#ifndef Magnum_SceneGraph_DualComplexTransformation_h |
||||
#define Magnum_SceneGraph_DualComplexTransformation_h |
||||
/*
|
||||
This file is part of Magnum. |
||||
|
||||
Copyright © 2010, 2011, 2012, 2013 Vladimír Vondruš <mosra@centrum.cz> |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a |
||||
copy of this software and associated documentation files (the "Software"), |
||||
to deal in the Software without restriction, including without limitation |
||||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||||
and/or sell copies of the Software, and to permit persons to whom the |
||||
Software is furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included |
||||
in all copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||||
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||
DEALINGS IN THE SOFTWARE. |
||||
*/ |
||||
|
||||
/** @file
|
||||
* @brief Class Magnum::SceneGraph::DualComplexTransformation |
||||
*/ |
||||
|
||||
#include "Math/DualComplex.h" |
||||
#include "AbstractTranslationRotation2D.h" |
||||
#include "Object.h" |
||||
|
||||
namespace Magnum { namespace SceneGraph { |
||||
|
||||
/**
|
||||
@brief Two-dimensional transformation implemented using dual complex numbers |
||||
|
||||
This class allows only rigid transformation (i.e. only rotation and |
||||
translation). |
||||
@see @ref scenegraph, Math::DualComplex, DualQuaternionTransformation |
||||
*/ |
||||
#ifndef DOXYGEN_GENERATING_OUTPUT |
||||
template<class T> |
||||
#else |
||||
template<class T = Float> |
||||
#endif |
||||
class DualComplexTransformation: public AbstractTranslationRotation2D<T> { |
||||
public: |
||||
/** @brief Transformation type */ |
||||
typedef Math::DualComplex<T> DataType; |
||||
|
||||
#ifndef DOXYGEN_GENERATING_OUTPUT |
||||
inline static Math::DualComplex<T> fromMatrix(const Math::Matrix3<T>& matrix) { |
||||
return Math::DualComplex<T>::fromMatrix(matrix); |
||||
} |
||||
|
||||
inline constexpr static Math::Matrix3<T> toMatrix(const Math::DualComplex<T>& transformation) { |
||||
return transformation.toMatrix(); |
||||
} |
||||
|
||||
inline static Math::DualComplex<T> compose(const Math::DualComplex<T>& parent, const Math::DualComplex<T>& child) { |
||||
return parent*child; |
||||
} |
||||
|
||||
inline static Math::DualComplex<T> inverted(const Math::DualComplex<T>& transformation) { |
||||
return transformation.invertedNormalized(); |
||||
} |
||||
|
||||
inline Math::DualComplex<T> transformation() const { |
||||
return _transformation; |
||||
} |
||||
#endif |
||||
|
||||
/**
|
||||
* @brief Normalize rotation part |
||||
* @return Pointer to self (for method chaining) |
||||
* |
||||
* Normalizes the rotation part to prevent rounding errors when rotating |
||||
* the object subsequently. |
||||
* @see DualComplex::normalized() |
||||
*/ |
||||
DualComplexTransformation<T>* normalizeRotation() { |
||||
setTransformationInternal(_transformation.normalized()); |
||||
return this; |
||||
} |
||||
|
||||
/**
|
||||
* @brief Set transformation |
||||
* @return Pointer to self (for method chaining) |
||||
* |
||||
* Expects that the dual complex number is normalized. |
||||
* @see DualComplex::isNormalized() |
||||
*/ |
||||
DualComplexTransformation<T>* setTransformation(const Math::DualComplex<T>& transformation) { |
||||
CORRADE_ASSERT(transformation.isNormalized(), |
||||
"SceneGraph::DualComplexTransformation::setTransformation(): the dual complex number is not normalized", this); |
||||
setTransformationInternal(transformation); |
||||
return this; |
||||
} |
||||
|
||||
inline DualComplexTransformation<T>* resetTransformation() override { |
||||
setTransformationInternal({}); |
||||
return this; |
||||
} |
||||
|
||||
/**
|
||||
* @brief Transform object |
||||
* @param transformation Transformation |
||||
* @param type Transformation type |
||||
* @return Pointer to self (for method chaining) |
||||
* |
||||
* Expects that the dual complex number is normalized. |
||||
* @see DualComplex::isNormalized() |
||||
*/ |
||||
inline DualComplexTransformation<T>* transform(const Math::DualComplex<T>& transformation, TransformationType type = TransformationType::Global) { |
||||
CORRADE_ASSERT(transformation.isNormalized(), |
||||
"SceneGraph::DualComplexTransformation::transform(): the dual complex number is not normalized", this); |
||||
transformInternal(transformation, type); |
||||
return this; |
||||
} |
||||
|
||||
/**
|
||||
* @copydoc AbstractTranslationRotationScaling2D::translate() |
||||
* Same as calling transform() with DualComplex::translation(). |
||||
*/ |
||||
inline DualComplexTransformation<T>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) override { |
||||
transformInternal(Math::DualComplex<T>::translation(vector), type); |
||||
return this; |
||||
} |
||||
|
||||
/**
|
||||
* @brief Rotate object |
||||
* @param angle Angle (counterclockwise) |
||||
* @param type Transformation type |
||||
* @return Pointer to self (for method chaining) |
||||
* |
||||
* Same as calling transform() with DualComplex::rotation(). |
||||
* @see normalizeRotation() |
||||
*/ |
||||
inline DualComplexTransformation<T>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) override { |
||||
transformInternal(Math::DualComplex<T>::rotation(angle), type); |
||||
return this; |
||||
} |
||||
|
||||
/**
|
||||
* @brief Move object in stacking order |
||||
* @param under Sibling object under which to move or `nullptr`, |
||||
* if you want to move it above all. |
||||
* @return Pointer to self (for method chaining) |
||||
*/ |
||||
inline DualComplexTransformation<T>* move(Object<DualComplexTransformation<T>>* under) { |
||||
static_cast<Object<DualComplexTransformation>*>(this)->Corrade::Containers::template LinkedList<Object<DualComplexTransformation<T>>>::move(this, under); |
||||
return this; |
||||
} |
||||
|
||||
protected: |
||||
/* Allow construction only from Object */ |
||||
inline explicit DualComplexTransformation() = default; |
||||
|
||||
private: |
||||
/* No assertions fired, for internal use */ |
||||
inline void setTransformationInternal(const Math::DualComplex<T>& transformation) { |
||||
/* Setting transformation is forbidden for the scene */ |
||||
/** @todo Assert for this? */ |
||||
/** @todo Do this in some common code so we don't need to include Object? */ |
||||
if(!static_cast<Object<DualComplexTransformation<T>>*>(this)->isScene()) { |
||||
_transformation = transformation; |
||||
static_cast<Object<DualComplexTransformation<T>>*>(this)->setDirty(); |
||||
} |
||||
} |
||||
|
||||
/* No assertions fired, for internal use */ |
||||
inline void transformInternal(const Math::DualComplex<T>& transformation, TransformationType type) { |
||||
setTransformation(type == TransformationType::Global ? |
||||
transformation*_transformation : _transformation*transformation); |
||||
} |
||||
|
||||
Math::DualComplex<T> _transformation; |
||||
}; |
||||
|
||||
}} |
||||
|
||||
#endif |
||||
@ -0,0 +1,180 @@
|
||||
/*
|
||||
This file is part of Magnum. |
||||
|
||||
Copyright © 2010, 2011, 2012, 2013 Vladimír Vondruš <mosra@centrum.cz> |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a |
||||
copy of this software and associated documentation files (the "Software"), |
||||
to deal in the Software without restriction, including without limitation |
||||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||||
and/or sell copies of the Software, and to permit persons to whom the |
||||
Software is furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included |
||||
in all copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||||
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||
DEALINGS IN THE SOFTWARE. |
||||
*/ |
||||
|
||||
#include <sstream> |
||||
#include <TestSuite/Tester.h> |
||||
|
||||
#include "SceneGraph/DualComplexTransformation.h" |
||||
#include "SceneGraph/Scene.h" |
||||
|
||||
namespace Magnum { namespace SceneGraph { namespace Test { |
||||
|
||||
typedef Object<DualComplexTransformation<>> Object2D; |
||||
typedef Scene<DualComplexTransformation<>> Scene2D; |
||||
|
||||
class DualComplexTransformationTest: public Corrade::TestSuite::Tester { |
||||
public: |
||||
explicit DualComplexTransformationTest(); |
||||
|
||||
void fromMatrix(); |
||||
void toMatrix(); |
||||
void compose(); |
||||
void inverted(); |
||||
|
||||
void setTransformation(); |
||||
void resetTransformation(); |
||||
void transform(); |
||||
void translate(); |
||||
void rotate(); |
||||
void normalizeRotation(); |
||||
}; |
||||
|
||||
DualComplexTransformationTest::DualComplexTransformationTest() { |
||||
addTests({&DualComplexTransformationTest::fromMatrix, |
||||
&DualComplexTransformationTest::toMatrix, |
||||
&DualComplexTransformationTest::compose, |
||||
&DualComplexTransformationTest::inverted, |
||||
|
||||
&DualComplexTransformationTest::setTransformation, |
||||
&DualComplexTransformationTest::resetTransformation, |
||||
&DualComplexTransformationTest::transform, |
||||
&DualComplexTransformationTest::translate, |
||||
&DualComplexTransformationTest::rotate, |
||||
&DualComplexTransformationTest::normalizeRotation}); |
||||
} |
||||
|
||||
void DualComplexTransformationTest::fromMatrix() { |
||||
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}); |
||||
CORRADE_COMPARE(DualComplexTransformation<>::fromMatrix(m), c); |
||||
} |
||||
|
||||
void DualComplexTransformationTest::toMatrix() { |
||||
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}); |
||||
CORRADE_COMPARE(DualComplexTransformation<>::toMatrix(c), m); |
||||
} |
||||
|
||||
void DualComplexTransformationTest::compose() { |
||||
DualComplex parent = DualComplex::rotation(Deg(17.0f)); |
||||
DualComplex child = DualComplex::translation({1.0f, -0.3f}); |
||||
CORRADE_COMPARE(DualComplexTransformation<>::compose(parent, child), parent*child); |
||||
} |
||||
|
||||
void DualComplexTransformationTest::inverted() { |
||||
DualComplex c = DualComplex::rotation(Deg(17.0f))*DualComplex::translation({1.0f, -0.3f}); |
||||
CORRADE_COMPARE(DualComplexTransformation<>::inverted(c)*c, DualComplex()); |
||||
} |
||||
|
||||
void DualComplexTransformationTest::setTransformation() { |
||||
Object2D o; |
||||
|
||||
/* Can't transform with non-rigid transformation */ |
||||
std::ostringstream out; |
||||
Error::setOutput(&out); |
||||
o.setTransformation(DualComplex({1.0f, 2.0f}, {})); |
||||
CORRADE_COMPARE(out.str(), "SceneGraph::DualComplexTransformation::setTransformation(): the dual complex number is not normalized\n"); |
||||
|
||||
/* Dirty after setting transformation */ |
||||
o.setClean(); |
||||
CORRADE_VERIFY(!o.isDirty()); |
||||
o.setTransformation(DualComplex::rotation(Deg(17.0f))); |
||||
CORRADE_VERIFY(o.isDirty()); |
||||
CORRADE_COMPARE(o.transformationMatrix(), Matrix3::rotation(Deg(17.0f))); |
||||
|
||||
/* Scene cannot be transformed */ |
||||
Scene2D s; |
||||
s.setClean(); |
||||
s.setTransformation(DualComplex::rotation(Deg(17.0f))); |
||||
CORRADE_VERIFY(!s.isDirty()); |
||||
CORRADE_COMPARE(s.transformationMatrix(), Matrix3()); |
||||
} |
||||
|
||||
void DualComplexTransformationTest::resetTransformation() { |
||||
Object2D o; |
||||
o.setTransformation(DualComplex::rotation(Deg(17.0f))); |
||||
CORRADE_VERIFY(o.transformationMatrix() != Matrix3()); |
||||
o.resetTransformation(); |
||||
CORRADE_COMPARE(o.transformationMatrix(), Matrix3()); |
||||
} |
||||
|
||||
void DualComplexTransformationTest::transform() { |
||||
{ |
||||
/* Can't transform with non-rigid transformation */ |
||||
Object2D o; |
||||
std::ostringstream out; |
||||
Error::setOutput(&out); |
||||
o.transform(DualComplex({1.0f, 2.0f}, {})); |
||||
CORRADE_COMPARE(out.str(), "SceneGraph::DualComplexTransformation::transform(): the dual complex number is not normalized\n"); |
||||
} { |
||||
Object2D o; |
||||
o.setTransformation(DualComplex::rotation(Deg(17.0f))); |
||||
o.transform(DualComplex::translation({1.0f, -0.3f})); |
||||
CORRADE_COMPARE(o.transformationMatrix(), Matrix3::translation({1.0f, -0.3f})*Matrix3::rotation(Deg(17.0f))); |
||||
} { |
||||
Object2D o; |
||||
o.setTransformation(DualComplex::rotation(Deg(17.0f))); |
||||
o.transform(DualComplex::translation({1.0f, -0.3f}), TransformationType::Local); |
||||
CORRADE_COMPARE(o.transformationMatrix(), Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f})); |
||||
} |
||||
} |
||||
|
||||
void DualComplexTransformationTest::translate() { |
||||
{ |
||||
Object2D o; |
||||
o.setTransformation(DualComplex::rotation(Deg(17.0f))); |
||||
o.translate({1.0f, -0.3f}); |
||||
CORRADE_COMPARE(o.transformationMatrix(), Matrix3::translation({1.0f, -0.3f})*Matrix3::rotation(Deg(17.0f))); |
||||
} { |
||||
Object2D o; |
||||
o.setTransformation(DualComplex::rotation(Deg(17.0f))); |
||||
o.translate({1.0f, -0.3f}, TransformationType::Local); |
||||
CORRADE_COMPARE(o.transformationMatrix(), Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f})); |
||||
} |
||||
} |
||||
|
||||
void DualComplexTransformationTest::rotate() { |
||||
{ |
||||
Object2D o; |
||||
o.setTransformation(DualComplex::translation({1.0f, -0.3f})); |
||||
o.rotate(Deg(17.0f)); |
||||
CORRADE_COMPARE(o.transformationMatrix(), Matrix3::rotation(Deg(17.0f))*Matrix3::translation({1.0f, -0.3f})); |
||||
} { |
||||
Object2D o; |
||||
o.setTransformation(DualComplex::translation({1.0f, -0.3f})); |
||||
o.rotate(Deg(17.0f), TransformationType::Local); |
||||
CORRADE_COMPARE(o.transformationMatrix(), Matrix3::translation({1.0f, -0.3f})*Matrix3::rotation(Deg(17.0f))); |
||||
} |
||||
} |
||||
|
||||
void DualComplexTransformationTest::normalizeRotation() { |
||||
Object2D o; |
||||
o.setTransformation(DualComplex::rotation(Deg(17.0f))); |
||||
o.normalizeRotation(); |
||||
CORRADE_COMPARE(o.transformationMatrix(), Matrix3::rotation(Deg(17.0f))); |
||||
} |
||||
|
||||
}}} |
||||
|
||||
CORRADE_TEST_MAIN(Magnum::SceneGraph::Test::DualComplexTransformationTest) |
||||
Loading…
Reference in new issue