SceneGraph: euclidean transformation using matrices.

Allows for faster computation of inverted transformations.

src/SceneGraph/CMakeLists.txt

@@ -1,6 +1,8 @@
 set(MagnumSceneGraph_SRCS
     Animable.cpp
-    Camera.cpp)
+    Camera.cpp
+    EuclideanMatrixTransformation2D.cpp
+    EuclideanMatrixTransformation3D.cpp)
 set(MagnumSceneGraph_HEADERS
     AbstractCamera.h
     AbstractCamera.hpp
@@ -20,6 +22,8 @@ set(MagnumSceneGraph_HEADERS
     Camera3D.h
     Camera3D.hpp
     Drawable.h
+    EuclideanMatrixTransformation2D.h
+    EuclideanMatrixTransformation3D.h
     FeatureGroup.h
     MatrixTransformation2D.h
     MatrixTransformation3D.h

src/SceneGraph/EuclideanMatrixTransformation2D.cpp

@@ -0,0 +1,26 @@
+/*
+    Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
+
+    This file is part of Magnum.
+
+    Magnum is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License version 3
+    only, as published by the Free Software Foundation.
+
+    Magnum is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+    GNU Lesser General Public License version 3 for more details.
+*/
+
+#include "EuclideanMatrixTransformation2D.h"
+
+#include "Object.hpp"
+
+namespace Magnum { namespace SceneGraph {
+
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template class MAGNUM_SCENEGRAPH_EXPORT Object<EuclideanMatrixTransformation2D<>>;
+#endif
+
+}}

src/SceneGraph/EuclideanMatrixTransformation2D.h

@@ -0,0 +1,138 @@
+#ifndef Magnum_SceneGraph_EuclideanMatrixTransformation2D_h
+#define Magnum_SceneGraph_EuclideanMatrixTransformation2D_h
+/*
+    Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
+
+    This file is part of Magnum.
+
+    Magnum is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License version 3
+    only, as published by the Free Software Foundation.
+
+    Magnum is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+    GNU Lesser General Public License version 3 for more details.
+*/
+
+/** @file
+ * @brief Class Magnum::SceneGraph::EuclideanMatrixTransformation2D
+ */
+
+#include "Math/Matrix3.h"
+#include "AbstractTranslationRotation2D.h"
+#include "Object.h"
+
+namespace Magnum { namespace SceneGraph {
+
+/**
+@brief Two-dimensional euclidean transformation implemented using matrices
+
+Unlike MatrixTransformation2D this class allows only rotation, reflection and
+translation (no scaling or setting arbitrary transformations). This allows to
+use Matrix3::invertedEuclidean() for faster computation of inverse
+transformations.
+@see @ref scenegraph, EuclideanMatrixTransformation3D
+*/
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<class T>
+#else
+template<class T = GLfloat>
+#endif
+class EuclideanMatrixTransformation2D: public AbstractTranslationRotation2D<T> {
+    public:
+        /** @brief Transformation matrix type */
+        typedef typename DimensionTraits<2, T>::MatrixType DataType;
+
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        inline constexpr static Math::Matrix3<T> fromMatrix(const Math::Matrix3<T>& matrix) {
+            return matrix;
+        }
+
+        inline constexpr static Math::Matrix3<T> toMatrix(const Math::Matrix3<T>& transformation) {
+            return transformation;
+        }
+
+        inline static Math::Matrix3<T> compose(const Math::Matrix3<T>& parent, const Math::Matrix3<T>& child) {
+            return parent*child;
+        }
+
+        inline static Math::Matrix3<T> inverted(const Math::Matrix3<T>& transformation) {
+            return transformation.invertedEuclidean();
+        }
+
+        inline Math::Matrix3<T> transformation() const {
+            return _transformation;
+        }
+        #endif
+
+        /**
+         * @brief Reset transformation to default
+         * @return Pointer to self (for method chaining)
+         */
+        inline EuclideanMatrixTransformation2D<T>* resetTransformation() {
+            setTransformation({});
+            return this;
+        }
+
+        /** @copydoc AbstractTranslationRotation2D::translate() */
+        inline EuclideanMatrixTransformation2D<T>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) override {
+            transform(Math::Matrix3<T>::translation(vector), type);
+            return this;
+        }
+
+        /** @copydoc AbstractTranslationRotation2D::rotate() */
+        inline EuclideanMatrixTransformation2D<T>* rotate(T angle, TransformationType type = TransformationType::Global) override {
+            transform(Math::Matrix3<T>::rotation(angle), type);
+            return this;
+        }
+
+        /**
+         * @brief Reflect object
+         * @param normal    Normal of the line through which to reflect
+         *      (normalized)
+         * @param type      Transformation type
+         * @return Pointer to self (for method chaining)
+         */
+        inline EuclideanMatrixTransformation2D<T>* reflect(const Math::Vector2<T>& normal, TransformationType type = TransformationType::Global) {
+            transform(Math::Matrix3<T>::reflection(normal), 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 EuclideanMatrixTransformation2D<T>* move(Object<EuclideanMatrixTransformation2D<T>>* under) {
+            static_cast<Object<EuclideanMatrixTransformation2D>*>(this)->Corrade::Containers::LinkedList<Object<EuclideanMatrixTransformation2D<T>>>::move(this, under);
+            return this;
+        }
+
+    protected:
+        /* Allow construction only from Object */
+        inline explicit EuclideanMatrixTransformation2D() = default;
+
+    private:
+        inline void setTransformation(const Math::Matrix3<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<EuclideanMatrixTransformation2D<T>>*>(this)->isScene()) {
+                _transformation = transformation;
+                static_cast<Object<EuclideanMatrixTransformation2D<T>>*>(this)->setDirty();
+            }
+        }
+
+        inline void transform(const Math::Matrix3<T>& transformation, TransformationType type) {
+            setTransformation(type == TransformationType::Global ?
+                transformation*_transformation : _transformation*transformation);
+        }
+
+        Math::Matrix3<T> _transformation;
+};
+
+}}
+
+#endif

src/SceneGraph/EuclideanMatrixTransformation3D.cpp

@@ -0,0 +1,26 @@
+/*
+    Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
+
+    This file is part of Magnum.
+
+    Magnum is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License version 3
+    only, as published by the Free Software Foundation.
+
+    Magnum is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+    GNU Lesser General Public License version 3 for more details.
+*/
+
+#include "EuclideanMatrixTransformation3D.h"
+
+#include "Object.hpp"
+
+namespace Magnum { namespace SceneGraph {
+
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template class MAGNUM_SCENEGRAPH_EXPORT Object<EuclideanMatrixTransformation3D<>>;
+#endif
+
+}}

src/SceneGraph/EuclideanMatrixTransformation3D.h

@@ -0,0 +1,168 @@
+#ifndef Magnum_SceneGraph_EuclideanMatrixTransformation3D_h
+#define Magnum_SceneGraph_EuclideanMatrixTransformation3D_h
+/*
+    Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
+
+    This file is part of Magnum.
+
+    Magnum is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License version 3
+    only, as published by the Free Software Foundation.
+
+    Magnum is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+    GNU Lesser General Public License version 3 for more details.
+*/
+
+/** @file
+ * @brief Class Magnum::SceneGraph::EuclideanMatrixTransformation3D
+ */
+
+#include "Math/Matrix4.h"
+#include "AbstractTranslationRotation3D.h"
+#include "Object.h"
+
+namespace Magnum { namespace SceneGraph {
+
+/**
+@brief Three-dimensional euclidean transformation implemented using matrices
+
+Unlike MatrixTransformation3D this class allows only rotation, reflection and
+translation (no scaling or setting arbitrary transformations). This allows to
+use Matrix4::invertedEuclidean() for faster computation of inverse
+transformations.
+@see @ref scenegraph, EuclideanMatrixTransformation2D
+*/
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<class T>
+#else
+template<class T = GLfloat>
+#endif
+class EuclideanMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
+    public:
+        /** @brief Transformation matrix type */
+        typedef typename DimensionTraits<3, T>::MatrixType DataType;
+
+        #ifndef DOXYGEN_GENERATING_OUTPUT
+        inline constexpr static Math::Matrix4<T> fromMatrix(const Math::Matrix4<T>& matrix) {
+            return matrix;
+        }
+
+        inline constexpr static Math::Matrix4<T> toMatrix(const Math::Matrix4<T>& transformation) {
+            return transformation;
+        }
+
+        inline static Math::Matrix4<T> compose(const Math::Matrix4<T>& parent, const Math::Matrix4<T>& child) {
+            return parent*child;
+        }
+
+        inline static Math::Matrix4<T> inverted(const Math::Matrix4<T>& transformation) {
+            return transformation.invertedEuclidean();
+        }
+
+        inline Math::Matrix4<T> transformation() const {
+            return _transformation;
+        }
+        #endif
+
+        /**
+         * @brief Reset transformation to default
+         * @return Pointer to self (for method chaining)
+         */
+        inline EuclideanMatrixTransformation3D<T>* resetTransformation() {
+            setTransformation({});
+            return this;
+        }
+
+        /** @copydoc AbstractTranslationRotation3D::translate() */
+        inline EuclideanMatrixTransformation3D<T>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) override {
+            transform(Math::Matrix4<T>::translation(vector), type);
+            return this;
+        }
+
+        /** @copydoc AbstractTranslationRotation3D::rotate() */
+        inline EuclideanMatrixTransformation3D<T>* rotate(T angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) override {
+            transform(Math::Matrix4<T>::rotation(angle, normalizedAxis), type);
+            return this;
+        }
+
+        /**
+         * @brief Rotate object around X axis
+         * @param angle             Angle in radians, counterclockwise
+         * @param type              Transformation type
+         * @return Pointer to self (for method chaining)
+         *
+         * @see deg(), rad()
+         */
+        inline EuclideanMatrixTransformation3D<T>* rotateX(T angle, TransformationType type = TransformationType::Global) override {
+            transform(Math::Matrix4<T>::rotationX(angle), type);
+            return this;
+        }
+
+        /**
+         * @brief Rotate object around Y axis
+         * @param angle             Angle in radians, counterclockwise
+         * @param type              Transformation type
+         * @return Pointer to self (for method chaining)
+         *
+         * @see deg(), rad()
+         */
+        inline EuclideanMatrixTransformation3D<T>* rotateY(T angle, TransformationType type = TransformationType::Global) override {
+            transform(Math::Matrix4<T>::rotationY(angle), type);
+            return this;
+        }
+
+        /**
+         * @brief Rotate object around Z axis
+         * @param angle             Angle in radians, counterclockwise
+         * @param type              Transformation type
+         * @return Pointer to self (for method chaining)
+         *
+         * @see deg(), rad()
+         */
+        inline EuclideanMatrixTransformation3D<T>* rotateZ(T angle, TransformationType type = TransformationType::Global) override {
+            transform(Math::Matrix4<T>::rotationZ(angle), type);
+            return this;
+        }
+
+        /**
+         * @brief Reflect object
+         * @param normal    Normal of the plane through which to reflect
+         *      (normalized)
+         * @param type      Transformation type
+         * @return Pointer to self (for method chaining)
+         *
+         * Same as calling transform() with Matrix4::reflection().
+         */
+        inline EuclideanMatrixTransformation3D<T>* reflect(const Math::Vector3<T>& normal, TransformationType type = TransformationType::Global) {
+            transform(Math::Matrix4<T>::reflection(normal), type);
+            return this;
+        }
+
+    protected:
+        /* Allow construction only from Object */
+        inline explicit EuclideanMatrixTransformation3D() = default;
+
+    private:
+        inline void setTransformation(const Math::Matrix4<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<EuclideanMatrixTransformation3D<T>>*>(this)->isScene()) {
+                _transformation = transformation;
+                static_cast<Object<EuclideanMatrixTransformation3D<T>>*>(this)->setDirty();
+            }
+        }
+
+        inline void transform(const Math::Matrix4<T>& transformation, TransformationType type) {
+            setTransformation(type == TransformationType::Global ?
+                transformation*_transformation : _transformation*transformation);
+        }
+
+        Math::Matrix4<T> _transformation;
+};
+
+}}
+
+#endif

src/SceneGraph/MatrixTransformation2D.h

@@ -29,7 +29,7 @@ namespace Magnum { namespace SceneGraph {
 @brief Two-dimensional transformation implemented using matrices
 
 Uses Math::Matrix3 as underlying type.
-@see @ref scenegraph, MatrixTransformation3D
+@see @ref scenegraph, EuclideanMatrixTransformation2D, MatrixTransformation3D
 */
 #ifndef DOXYGEN_GENERATING_OUTPUT
 template<class T>

src/SceneGraph/MatrixTransformation3D.h

@@ -29,7 +29,7 @@ namespace Magnum { namespace SceneGraph {
 @brief Three-dimensional transformation implemented using matrices
 
 Uses Math::Matrix4 as underlying type.
-@see @ref scenegraph, MatrixTransformation2D
+@see @ref scenegraph, EuclideanMatrixTransformation3D, MatrixTransformation2D
 */
 #ifndef DOXYGEN_GENERATING_OUTPUT
 template<class T>

src/SceneGraph/Object.h

@@ -73,6 +73,8 @@ avoid linker errors. See @ref compilation-speedup-hpp for more information.
 
  - @ref MatrixTransformation2D "Object<MatrixTransformation2D<GLfloat>>"
  - @ref MatrixTransformation3D "Object<MatrixTransformation3D<GLfloat>>"
+ - @ref EuclideanMatrixTransformation2D "Object<EuclideanMatrixTransformation2D<GLfloat>>"
+ - @ref EuclideanMatrixTransformation3D "Object<EuclideanMatrixTransformation3D<GLfloat>>"
 
 @see Scene, AbstractFeature, AbstractTransformation
 */

src/SceneGraph/SceneGraph.h

@@ -89,6 +89,9 @@ template<class T = GLfloat> using Drawable2D = Drawable<2, T>;
 template<class T = GLfloat> using Drawable3D = Drawable<3, T>;
 #endif
 
+template<class T = GLfloat> class EuclideanMatrixTransformation2D;
+template<class T = GLfloat> class EuclideanMatrixTransformation3D;
+
 template<std::uint8_t dimensions, class Feature, class T = GLfloat> class FeatureGroup;
 #ifndef CORRADE_GCC46_COMPATIBILITY
 template<class Feature, class T = GLfloat> using FeatureGroup2D = FeatureGroup<2, Feature, T>;