diff --git a/src/SceneGraph/AbstractTransformation.h b/src/SceneGraph/AbstractTransformation.h
index 1717d576f..5f828a7a1 100644
--- a/src/SceneGraph/AbstractTransformation.h
+++ b/src/SceneGraph/AbstractTransformation.h
@@ -142,7 +142,18 @@ class MAGNUM_SCENEGRAPH_EXPORT AbstractTransformation {
          * @brief Reset object transformation
          * @return Pointer to self (for method chaining)
          */
-        virtual AbstractTransformation<dimensions, T>* resetTransformation() = 0;
+        AbstractTransformation<dimensions, T>* resetTransformation() {
+            doResetTransformation();
+            return this;
+        }
+
+    #ifdef DOXYGEN_GENERATING_OUTPUT
+    protected:
+    #else
+    private:
+    #endif
+        /** @brief Polymorphic implementation for resetTransformation() */
+        virtual void doResetTransformation() = 0;
 };
 
 /** @brief Transformation type */
diff --git a/src/SceneGraph/AbstractTranslationRotation2D.h b/src/SceneGraph/AbstractTranslationRotation2D.h
index d301fb155..1d1e48560 100644
--- a/src/SceneGraph/AbstractTranslationRotation2D.h
+++ b/src/SceneGraph/AbstractTranslationRotation2D.h
@@ -54,7 +54,10 @@ class AbstractTranslationRotation2D: public AbstractTransformation<2, T> {
          *
          * @see Vector2::xAxis(), Vector2::yAxis()
          */
-        virtual AbstractTranslationRotation2D<T>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) = 0;
+        AbstractTranslationRotation2D<T>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) {
+            doTranslate(vector, type);
+            return this;
+        }
 
         /**
          * @brief Rotate object
@@ -62,12 +65,29 @@ class AbstractTranslationRotation2D: public AbstractTransformation<2, T> {
          * @param type      Transformation type
          * @return Pointer to self (for method chaining)
          */
-        virtual AbstractTranslationRotation2D<T>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) = 0;
+        AbstractTranslationRotation2D<T>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
+            doRotate(angle, type);
+            return this;
+        }
 
         /* Overloads to remove WTF-factor from method chaining order */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        AbstractTranslationRotation2D<T>* resetTransformation() override = 0;
+        AbstractTranslationRotation2D<T>* resetTransformation() {
+            AbstractTransformation<2, T>::resetTransformation();
+            return this;
+        }
         #endif
+
+    #ifdef DOXYGEN_GENERATING_OUTPUT
+    protected:
+    #else
+    private:
+    #endif
+        /** @brief Polymorphic implementation for translate() */
+        virtual void doTranslate(const Math::Vector2<T>& vector, TransformationType type) = 0;
+
+        /** @brief Polymorphic implementation for rotate() */
+        virtual void doRotate(Math::Rad<T> angle, TransformationType type) = 0;
 };
 
 }}
diff --git a/src/SceneGraph/AbstractTranslationRotation3D.h b/src/SceneGraph/AbstractTranslationRotation3D.h
index a8355eebd..c3853efa1 100644
--- a/src/SceneGraph/AbstractTranslationRotation3D.h
+++ b/src/SceneGraph/AbstractTranslationRotation3D.h
@@ -55,7 +55,10 @@ class AbstractTranslationRotation3D: public AbstractTransformation<3, T> {
          *
          * @see Vector3::xAxis(), Vector3::yAxis(), Vector3::zAxis()
          */
-        virtual AbstractTranslationRotation3D<T>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) = 0;
+        AbstractTranslationRotation3D<T>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) {
+            doTranslate(vector, type);
+            return this;
+        }
 
         /**
          * @brief Rotate object
@@ -67,7 +70,10 @@ class AbstractTranslationRotation3D: public AbstractTransformation<3, T> {
          * @see rotateX(), rotateY(), rotateZ(), Vector3::xAxis(),
          *      Vector3::yAxis(), Vector3::zAxis()
          */
-        virtual AbstractTranslationRotation3D<T>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) = 0;
+        AbstractTranslationRotation3D<T>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) {
+            doRotate(angle, normalizedAxis, type);
+            return this;
+        }
 
         /**
          * @brief Rotate object around X axis
@@ -78,8 +84,9 @@ class AbstractTranslationRotation3D: public AbstractTransformation<3, T> {
          * In some implementations faster than calling
          * `rotate(angle, Vector3::xAxis())`.
          */
-        virtual AbstractTranslationRotation3D<T>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
-            return rotate(angle, Math::Vector3<T>::xAxis(), type);
+        AbstractTranslationRotation3D<T>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
+            doRotateX(angle, type);
+            return this;
         }
 
         /**
@@ -91,8 +98,9 @@ class AbstractTranslationRotation3D: public AbstractTransformation<3, T> {
          * In some implementations faster than calling
          * `rotate(angle, Vector3::yAxis())`.
          */
-        virtual AbstractTranslationRotation3D<T>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
-            return rotate(angle, Math::Vector3<T>::yAxis(), type);
+        AbstractTranslationRotation3D<T>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
+            doRotateX(angle, type);
+            return this;
         }
 
         /**
@@ -104,14 +112,56 @@ class AbstractTranslationRotation3D: public AbstractTransformation<3, T> {
          * In some implementations faster than calling
          * `rotate(angle, Vector3::zAxis())`.
          */
-        virtual AbstractTranslationRotation3D<T>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
-            return rotate(angle, Math::Vector3<T>::zAxis(), type);
+        AbstractTranslationRotation3D<T>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
+            doRotateZ(angle, type);
+            return this;
         }
 
         /* Overloads to remove WTF-factor from method chaining order */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        AbstractTranslationRotation3D<T>* resetTransformation() override = 0;
+        AbstractTranslationRotation3D<T>* resetTransformation() {
+            AbstractTransformation<2, T>::resetTransformation();
+            return this;
+        }
         #endif
+
+    #ifdef DOXYGEN_GENERATING_OUTPUT
+    protected:
+    #else
+    private:
+    #endif
+        /** @brief Polymorphic implementation for translate() */
+        virtual void doTranslate(const Math::Vector3<T>& vector, TransformationType type) = 0;
+
+        /** @brief Polymorphic implementation for rotate() */
+        virtual void doRotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type) = 0;
+
+        /**
+         * @brief Polymorphic implementation for rotateX()
+         *
+         * Default implementation calls rotate() with Math::Vector3::xAxis().
+         */
+        virtual void doRotateX(Math::Rad<T> angle, TransformationType type) {
+            rotate(angle, Math::Vector3<T>::xAxis(), type);
+        }
+
+        /**
+         * @brief Polymorphic implementation for rotateY()
+         *
+         * Default implementation calls rotate() with Math::Vector3::yAxis().
+         */
+        virtual void doRotateY(Math::Rad<T> angle, TransformationType type) {
+            rotate(angle, Math::Vector3<T>::yAxis(), type);
+        }
+
+        /**
+         * @brief Polymorphic implementation for rotateZ()
+         *
+         * Default implementation calls rotate() with Math::Vector3::zAxis().
+         */
+        virtual void doRotateZ(Math::Rad<T> angle, TransformationType type) {
+            rotate(angle, Math::Vector3<T>::zAxis(), type);
+        }
 };
 
 }}
diff --git a/src/SceneGraph/AbstractTranslationRotationScaling2D.h b/src/SceneGraph/AbstractTranslationRotationScaling2D.h
index 448b4617f..5f2f5cc40 100644
--- a/src/SceneGraph/AbstractTranslationRotationScaling2D.h
+++ b/src/SceneGraph/AbstractTranslationRotationScaling2D.h
@@ -54,14 +54,34 @@ class AbstractTranslationRotationScaling2D: public AbstractTranslationRotation2D
          *
          * @see Vector2::xScale(), Vector2::yScale()
          */
-        virtual AbstractTranslationRotationScaling2D<T>* scale(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) = 0;
+        AbstractTranslationRotationScaling2D<T>* scale(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) {
+            doScale(vector, type);
+            return this;
+        }
 
         /* Overloads to remove WTF-factor from method chaining order */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        AbstractTranslationRotationScaling2D<T>* resetTransformation() override = 0;
-        AbstractTranslationRotationScaling2D<T>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) = 0;
-        AbstractTranslationRotationScaling2D<T>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) = 0;
+        AbstractTranslationRotationScaling2D<T>* resetTransformation() {
+            AbstractTranslationRotation2D<T>::resetTransformation();
+            return this;
+        }
+        AbstractTranslationRotationScaling2D<T>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) {
+            AbstractTranslationRotation2D<T>::translate(vector, type);
+            return this;
+        }
+        AbstractTranslationRotationScaling2D<T>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
+            AbstractTranslationRotation2D<T>::rotate(angle, type);
+            return this;
+        }
         #endif
+
+    #ifdef DOXYGEN_GENERATING_OUTPUT
+    protected:
+    #else
+    private:
+    #endif
+        /** @brief Polymorphic implementation for scale() */
+        virtual void doScale(const Math::Vector2<T>& vector, TransformationType type) = 0;
 };
 
 }}
diff --git a/src/SceneGraph/AbstractTranslationRotationScaling3D.h b/src/SceneGraph/AbstractTranslationRotationScaling3D.h
index f201b40c2..2852632c4 100644
--- a/src/SceneGraph/AbstractTranslationRotationScaling3D.h
+++ b/src/SceneGraph/AbstractTranslationRotationScaling3D.h
@@ -54,17 +54,46 @@ class AbstractTranslationRotationScaling3D: public AbstractTranslationRotation3D
          *
          * @see Vector3::xScale(), Vector3::yScale(), Vector3::zScale()
          */
-        virtual AbstractTranslationRotationScaling3D<T>* scale(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) = 0;
+        AbstractTranslationRotationScaling3D<T>* scale(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) {
+            doScale(vector, type);
+            return this;
+        }
 
         /* Overloads to remove WTF-factor from method chaining order */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        AbstractTranslationRotationScaling3D<T>* resetTransformation() override = 0;
-        AbstractTranslationRotationScaling3D<T>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) = 0;
-        AbstractTranslationRotationScaling3D<T>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) = 0;
-        AbstractTranslationRotationScaling3D<T>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) = 0;
-        AbstractTranslationRotationScaling3D<T>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) = 0;
-        AbstractTranslationRotationScaling3D<T>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) override = 0;
+        AbstractTranslationRotationScaling3D<T>* resetTransformation() {
+            AbstractTranslationRotation3D<T>::resetTransformation();
+            return this;
+        }
+        AbstractTranslationRotationScaling3D<T>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) {
+            AbstractTranslationRotation3D<T>::translate(vector, type);
+            return this;
+        }
+        AbstractTranslationRotationScaling3D<T>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) {
+            AbstractTranslationRotation3D<T>::rotate(angle, normalizedAxis, type);
+            return this;
+        }
+        AbstractTranslationRotationScaling3D<T>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
+            AbstractTranslationRotation3D<T>::rotateX(angle, type);
+            return this;
+        }
+        AbstractTranslationRotationScaling3D<T>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
+            AbstractTranslationRotation3D<T>::rotateY(angle, type);
+            return this;
+        }
+        AbstractTranslationRotationScaling3D<T>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
+            AbstractTranslationRotation3D<T>::rotateZ(angle, type);
+            return this;
+        }
         #endif
+
+    #ifdef DOXYGEN_GENERATING_OUTPUT
+    protected:
+    #else
+    private:
+    #endif
+        /** @brief Polymorphic implementation for scale() */
+        virtual void doScale(const Math::Vector3<T>& vector, TransformationType type) = 0;
 };
 
 }}
diff --git a/src/SceneGraph/DualComplexTransformation.h b/src/SceneGraph/DualComplexTransformation.h
index 2a963dfd5..8cd00b8ff 100644
--- a/src/SceneGraph/DualComplexTransformation.h
+++ b/src/SceneGraph/DualComplexTransformation.h
@@ -81,9 +81,9 @@ class DualComplexTransformation: public AbstractTranslationRotation2D<T> {
          * the object subsequently.
          * @see DualComplex::normalized()
          */
-        DualComplexTransformation<T>* normalizeRotation() {
+        Object<DualComplexTransformation<T>>* normalizeRotation() {
             setTransformationInternal(_transformation.normalized());
-            return this;
+            return static_cast<Object<DualComplexTransformation<T>>*>(this);
         }
 
         /**
@@ -93,16 +93,18 @@ class DualComplexTransformation: public AbstractTranslationRotation2D<T> {
          * Expects that the dual complex number is normalized.
          * @see DualComplex::isNormalized()
          */
-        DualComplexTransformation<T>* setTransformation(const Math::DualComplex<T>& transformation) {
+        Object<DualComplexTransformation<T>>* setTransformation(const Math::DualComplex<T>& transformation) {
             CORRADE_ASSERT(transformation.isNormalized(),
-                "SceneGraph::DualComplexTransformation::setTransformation(): the dual complex number is not normalized", this);
+                "SceneGraph::DualComplexTransformation::setTransformation(): the dual complex number is not normalized",
+                static_cast<Object<DualComplexTransformation<T>>*>(this));
             setTransformationInternal(transformation);
-            return this;
+            return static_cast<Object<DualComplexTransformation<T>>*>(this);
         }
 
-        DualComplexTransformation<T>* resetTransformation() override {
+        /** @copydoc AbstractTranslationRotationScaling2D::resetTransformation() */
+        Object<DualComplexTransformation<T>>* resetTransformation() {
             setTransformationInternal({});
-            return this;
+            return static_cast<Object<DualComplexTransformation<T>>*>(this);
         }
 
         /**
@@ -114,20 +116,21 @@ class DualComplexTransformation: public AbstractTranslationRotation2D<T> {
          * Expects that the dual complex number is normalized.
          * @see DualComplex::isNormalized()
          */
-        DualComplexTransformation<T>* transform(const Math::DualComplex<T>& transformation, TransformationType type = TransformationType::Global) {
+        Object<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);
+                "SceneGraph::DualComplexTransformation::transform(): the dual complex number is not normalized",
+                static_cast<Object<DualComplexTransformation<T>>*>(this));
             transformInternal(transformation, type);
-            return this;
+            return static_cast<Object<DualComplexTransformation<T>>*>(this);
         }
 
         /**
          * @copydoc AbstractTranslationRotationScaling2D::translate()
          * Same as calling transform() with DualComplex::translation().
          */
-        DualComplexTransformation<T>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) override {
+        Object<DualComplexTransformation<T>>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) {
             transformInternal(Math::DualComplex<T>::translation(vector), type);
-            return this;
+            return static_cast<Object<DualComplexTransformation<T>>*>(this);
         }
 
         /**
@@ -139,9 +142,9 @@ class DualComplexTransformation: public AbstractTranslationRotation2D<T> {
          * Same as calling transform() with DualComplex::rotation().
          * @see normalizeRotation()
          */
-        DualComplexTransformation<T>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) override {
+        Object<DualComplexTransformation<T>>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
             transformInternal(Math::DualComplex<T>::rotation(angle), type);
-            return this;
+            return static_cast<Object<DualComplexTransformation<T>>*>(this);
         }
 
         /**
@@ -150,9 +153,9 @@ class DualComplexTransformation: public AbstractTranslationRotation2D<T> {
          *      if you want to move it above all.
          * @return Pointer to self (for method chaining)
          */
-        DualComplexTransformation<T>* move(Object<DualComplexTransformation<T>>* under) {
+        Object<DualComplexTransformation<T>>* move(Object<DualComplexTransformation<T>>* under) {
             static_cast<Object<DualComplexTransformation>*>(this)->Containers::template LinkedList<Object<DualComplexTransformation<T>>>::move(this, under);
-            return this;
+            return static_cast<Object<DualComplexTransformation<T>>*>(this);
         }
 
     protected:
@@ -160,6 +163,16 @@ class DualComplexTransformation: public AbstractTranslationRotation2D<T> {
         explicit DualComplexTransformation() = default;
 
     private:
+        void doResetTransformation() override final { resetTransformation(); }
+
+        void doTranslate(const Math::Vector2<T>& vector, TransformationType type) override final {
+            translate(vector, type);
+        }
+
+        void doRotate(Math::Rad<T> angle, TransformationType type) override final {
+            doRotate(angle, type);
+        }
+
         /* No assertions fired, for internal use */
         void setTransformationInternal(const Math::DualComplex<T>& transformation) {
             /* Setting transformation is forbidden for the scene */
diff --git a/src/SceneGraph/DualQuaternionTransformation.h b/src/SceneGraph/DualQuaternionTransformation.h
index 2bcf86d27..03d3e59b9 100644
--- a/src/SceneGraph/DualQuaternionTransformation.h
+++ b/src/SceneGraph/DualQuaternionTransformation.h
@@ -83,9 +83,9 @@ class DualQuaternionTransformation: public AbstractTranslationRotation3D<T> {
          * the object subsequently.
          * @see DualQuaternion::normalized()
          */
-        DualQuaternionTransformation<T>* normalizeRotation() {
+        Object<DualQuaternionTransformation<T>>* normalizeRotation() {
             setTransformation(_transformation.normalized());
-            return this;
+            return static_cast<Object<DualQuaternionTransformation<T>>*>(this);
         }
 
         /**
@@ -95,16 +95,18 @@ class DualQuaternionTransformation: public AbstractTranslationRotation3D<T> {
          * Expects that the dual quaternion is normalized.
          * @see DualQuaternion::isNormalized()
          */
-        DualQuaternionTransformation<T>* setTransformation(const Math::DualQuaternion<T>& transformation) {
+        Object<DualQuaternionTransformation<T>>* setTransformation(const Math::DualQuaternion<T>& transformation) {
             CORRADE_ASSERT(transformation.isNormalized(),
-                "SceneGraph::DualQuaternionTransformation::setTransformation(): the dual quaternion is not normalized", this);
+                "SceneGraph::DualQuaternionTransformation::setTransformation(): the dual quaternion is not normalized",
+                static_cast<Object<DualQuaternionTransformation<T>>*>(this));
             setTransformationInternal(transformation);
-            return this;
+            return static_cast<Object<DualQuaternionTransformation<T>>*>(this);
         }
 
-        DualQuaternionTransformation<T>* resetTransformation() override {
+        /** @copydoc AbstractTranslationRotationScaling3D::resetTransformation() */
+        Object<DualQuaternionTransformation<T>>* resetTransformation() {
             setTransformation({});
-            return this;
+            return static_cast<Object<DualQuaternionTransformation<T>>*>(this);
         }
 
         /**
@@ -116,20 +118,21 @@ class DualQuaternionTransformation: public AbstractTranslationRotation3D<T> {
          * Expects that the dual quaternion is normalized.
          * @see DualQuaternion::isNormalized()
          */
-        DualQuaternionTransformation<T>* transform(const Math::DualQuaternion<T>& transformation, TransformationType type = TransformationType::Global) {
+        Object<DualQuaternionTransformation<T>>* transform(const Math::DualQuaternion<T>& transformation, TransformationType type = TransformationType::Global) {
             CORRADE_ASSERT(transformation.isNormalized(),
-                "SceneGraph::DualQuaternionTransformation::transform(): the dual quaternion is not normalized", this);
+                "SceneGraph::DualQuaternionTransformation::transform(): the dual quaternion is not normalized",
+                static_cast<Object<DualQuaternionTransformation<T>>*>(this));
             transformInternal(transformation, type);
-            return this;
+            return static_cast<Object<DualQuaternionTransformation<T>>*>(this);
         }
 
         /**
          * @copydoc AbstractTranslationRotationScaling3D::translate()
          * Same as calling transform() with DualQuaternion::translation().
          */
-        DualQuaternionTransformation<T>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) override {
+        Object<DualQuaternionTransformation<T>>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) {
             transformInternal(Math::DualQuaternion<T>::translation(vector), type);
-            return this;
+            return static_cast<Object<DualQuaternionTransformation<T>>*>(this);
         }
 
         /**
@@ -143,24 +146,21 @@ class DualQuaternionTransformation: public AbstractTranslationRotation3D<T> {
          * @see Vector3::xAxis(), Vector3::yAxis(), Vector3::zAxis(),
          *      normalizeRotation()
          */
-        DualQuaternionTransformation<T>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) override {
+        Object<DualQuaternionTransformation<T>>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) {
             transformInternal(Math::DualQuaternion<T>::rotation(angle, normalizedAxis), type);
-            return this;
+            return static_cast<Object<DualQuaternionTransformation<T>>*>(this);
         }
 
         /* Overloads to remove WTF-factor from method chaining order */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        DualQuaternionTransformation<T>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) override {
-            AbstractTranslationRotation3D<T>::rotateX(angle, type);
-            return this;
+        Object<DualQuaternionTransformation<T>>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
+            return rotate(angle, Math::Vector3<T>::xAxis(), type);
         }
-        DualQuaternionTransformation<T>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) override {
-            AbstractTranslationRotation3D<T>::rotateY(angle, type);
-            return this;
+        Object<DualQuaternionTransformation<T>>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
+            return rotate(angle, Math::Vector3<T>::yAxis(), type);
         }
-        DualQuaternionTransformation<T>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) override {
-            AbstractTranslationRotation3D<T>::rotateZ(angle, type);
-            return this;
+        Object<DualQuaternionTransformation<T>>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
+            return rotate(angle, Math::Vector3<T>::zAxis(), type);
         }
         #endif
 
@@ -169,6 +169,16 @@ class DualQuaternionTransformation: public AbstractTranslationRotation3D<T> {
         explicit DualQuaternionTransformation() = default;
 
     private:
+        void doResetTransformation() override final { resetTransformation(); }
+
+        void doTranslate(const Math::Vector3<T>& vector, TransformationType type) override final {
+            translate(vector, type);
+        }
+
+        void doRotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type) override final {
+            rotate(angle, normalizedAxis, type);
+        }
+
         /* No assertions fired, for internal use */
         void setTransformationInternal(const Math::DualQuaternion<T>& transformation) {
             /* Setting transformation is forbidden for the scene */
diff --git a/src/SceneGraph/MatrixTransformation2D.h b/src/SceneGraph/MatrixTransformation2D.h
index 46242c577..4f82dab87 100644
--- a/src/SceneGraph/MatrixTransformation2D.h
+++ b/src/SceneGraph/MatrixTransformation2D.h
@@ -76,7 +76,7 @@ class MatrixTransformation2D: public AbstractTranslationRotationScaling2D<T> {
          * @brief Set transformation
          * @return Pointer to self (for method chaining)
          */
-        MatrixTransformation2D<T>* setTransformation(const Math::Matrix3<T>& transformation) {
+        Object<MatrixTransformation2D<T>>* 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? */
@@ -85,7 +85,7 @@ class MatrixTransformation2D: public AbstractTranslationRotationScaling2D<T> {
                 static_cast<Object<MatrixTransformation2D<T>>*>(this)->setDirty();
             }
 
-            return this;
+            return static_cast<Object<MatrixTransformation2D<T>>*>(this);
         }
 
         /**
@@ -94,42 +94,43 @@ class MatrixTransformation2D: public AbstractTranslationRotationScaling2D<T> {
          * @param type              Transformation type
          * @return Pointer to self (for method chaining)
          */
-        MatrixTransformation2D<T>* transform(const Math::Matrix3<T>& transformation, TransformationType type = TransformationType::Global) {
+        Object<MatrixTransformation2D<T>>* transform(const Math::Matrix3<T>& transformation, TransformationType type = TransformationType::Global) {
             setTransformation(type == TransformationType::Global ?
                 transformation*_transformation : _transformation*transformation);
-            return this;
+            return static_cast<Object<MatrixTransformation2D<T>>*>(this);
         }
 
-        MatrixTransformation2D<T>* resetTransformation() override {
+        /** @copydoc AbstractTranslationRotationScaling2D::resetTransformation() */
+        Object<MatrixTransformation2D<T>>* resetTransformation() {
             setTransformation({});
-            return this;
+            return static_cast<Object<MatrixTransformation2D<T>>*>(this);
         }
 
         /**
          * @copydoc AbstractTranslationRotationScaling2D::translate()
          * Same as calling transform() with Matrix3::translation().
          */
-        MatrixTransformation2D<T>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) override {
+        Object<MatrixTransformation2D<T>>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) {
             transform(Math::Matrix3<T>::translation(vector), type);
-            return this;
+            return static_cast<Object<MatrixTransformation2D<T>>*>(this);
         }
 
         /**
          * @copydoc AbstractTranslationRotationScaling2D::rotate()
          * Same as calling transform() with Matrix3::rotation().
          */
-        MatrixTransformation2D<T>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) override {
+        Object<MatrixTransformation2D<T>>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
             transform(Math::Matrix3<T>::rotation(angle), type);
-            return this;
+            return static_cast<Object<MatrixTransformation2D<T>>*>(this);
         }
 
         /**
          * @copydoc AbstractTranslationRotationScaling2D::scale()
          * Same as calling transform() with Matrix3::scaling().
          */
-        MatrixTransformation2D<T>* scale(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) override {
+        Object<MatrixTransformation2D<T>>* scale(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) {
             transform(Math::Matrix3<T>::scaling(vector), type);
-            return this;
+            return static_cast<Object<MatrixTransformation2D<T>>*>(this);
         }
 
         /**
@@ -141,9 +142,9 @@ class MatrixTransformation2D: public AbstractTranslationRotationScaling2D<T> {
          *
          * Same as calling transform() with Matrix3::reflection().
          */
-        MatrixTransformation2D<T>* reflect(const Math::Vector2<T>& normal, TransformationType type = TransformationType::Global) {
+        Object<MatrixTransformation2D<T>>* reflect(const Math::Vector2<T>& normal, TransformationType type = TransformationType::Global) {
             transform(Math::Matrix3<T>::reflection(normal), type);
-            return this;
+            return static_cast<Object<MatrixTransformation2D<T>>*>(this);
         }
 
         /**
@@ -152,9 +153,9 @@ class MatrixTransformation2D: public AbstractTranslationRotationScaling2D<T> {
          *      if you want to move it above all.
          * @return Pointer to self (for method chaining)
          */
-        MatrixTransformation2D<T>* move(Object<MatrixTransformation2D<T>>* under) {
+        Object<MatrixTransformation2D<T>>* move(Object<MatrixTransformation2D<T>>* under) {
             static_cast<Object<MatrixTransformation2D>*>(this)->Containers::template LinkedList<Object<MatrixTransformation2D<T>>>::move(this, under);
-            return this;
+            return static_cast<Object<MatrixTransformation2D<T>>*>(this);
         }
 
     protected:
@@ -162,6 +163,20 @@ class MatrixTransformation2D: public AbstractTranslationRotationScaling2D<T> {
         explicit MatrixTransformation2D() = default;
 
     private:
+        void doResetTransformation() override final { resetTransformation(); }
+
+        void doTranslate(const Math::Vector2<T>& vector, TransformationType type) override final {
+            translate(vector, type);
+        }
+
+        void doRotate(Math::Rad<T> angle, TransformationType type) override final {
+            doRotate(angle, type);
+        }
+
+        void doScale(const Math::Vector2<T>& vector, TransformationType type) override final {
+            scale(vector, type);
+        }
+
         Math::Matrix3<T> _transformation;
 };
 
diff --git a/src/SceneGraph/MatrixTransformation3D.h b/src/SceneGraph/MatrixTransformation3D.h
index 08c42853c..2c3527eef 100644
--- a/src/SceneGraph/MatrixTransformation3D.h
+++ b/src/SceneGraph/MatrixTransformation3D.h
@@ -76,7 +76,7 @@ class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
          * @brief Set transformation
          * @return Pointer to self (for method chaining)
          */
-        MatrixTransformation3D<T>* setTransformation(const Math::Matrix4<T>& transformation) {
+        Object<MatrixTransformation3D<T>>* 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? */
@@ -85,12 +85,13 @@ class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
                 static_cast<Object<MatrixTransformation3D<T>>*>(this)->setDirty();
             }
 
-            return this;
+            return static_cast<Object<MatrixTransformation3D<T>>*>(this);
         }
 
-        MatrixTransformation3D<T>* resetTransformation() override {
+        /** @copydoc AbstractTranslationRotationScaling3D::resetTransformation() */
+        Object<MatrixTransformation3D<T>>* resetTransformation() {
             setTransformation({});
-            return this;
+            return static_cast<Object<MatrixTransformation3D<T>>*>(this);
         }
 
         /**
@@ -99,28 +100,28 @@ class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
          * @param type              Transformation type
          * @return Pointer to self (for method chaining)
          */
-        MatrixTransformation3D<T>* transform(const Math::Matrix4<T>& transformation, TransformationType type = TransformationType::Global) {
+        Object<MatrixTransformation3D<T>>* transform(const Math::Matrix4<T>& transformation, TransformationType type = TransformationType::Global) {
             setTransformation(type == TransformationType::Global ?
                 transformation*_transformation : _transformation*transformation);
-            return this;
+            return static_cast<Object<MatrixTransformation3D<T>>*>(this);
         }
 
         /**
          * @copydoc AbstractTranslationRotationScaling3D::translate()
          * Same as calling transform() with Matrix4::translation().
          */
-        MatrixTransformation3D<T>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) override {
+        Object<MatrixTransformation3D<T>>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) {
             transform(Math::Matrix4<T>::translation(vector), type);
-            return this;
+            return static_cast<Object<MatrixTransformation3D<T>>*>(this);
         }
 
         /**
          * @copydoc AbstractTranslationRotationScaling3D::rotate()
          * Same as calling transform() with Matrix4::rotation().
          */
-        MatrixTransformation3D<T>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) override {
+        Object<MatrixTransformation3D<T>>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) {
             transform(Math::Matrix4<T>::rotation(angle, normalizedAxis), type);
-            return this;
+            return static_cast<Object<MatrixTransformation3D<T>>*>(this);
         }
 
         /**
@@ -131,9 +132,9 @@ class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
          *
          * Same as calling transform() with Matrix4::rotationX().
          */
-        MatrixTransformation3D<T>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) override {
+        Object<MatrixTransformation3D<T>>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
             transform(Math::Matrix4<T>::rotationX(angle), type);
-            return this;
+            return static_cast<Object<MatrixTransformation3D<T>>*>(this);
         }
 
         /**
@@ -144,9 +145,9 @@ class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
          *
          * Same as calling transform() with Matrix4::rotationY().
          */
-        MatrixTransformation3D<T>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) override {
+        Object<MatrixTransformation3D<T>>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
             transform(Math::Matrix4<T>::rotationY(angle), type);
-            return this;
+            return static_cast<Object<MatrixTransformation3D<T>>*>(this);
         }
 
         /**
@@ -157,18 +158,18 @@ class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
          *
          * Same as calling transform() with Matrix4::rotationZ().
          */
-        MatrixTransformation3D<T>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) override {
+        Object<MatrixTransformation3D<T>>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
             transform(Math::Matrix4<T>::rotationZ(angle), type);
-            return this;
+            return static_cast<Object<MatrixTransformation3D<T>>*>(this);
         }
 
         /**
          * @copydoc AbstractTranslationRotationScaling3D::scale()
          * Same as calling transform() with Matrix4::scaling().
          */
-        MatrixTransformation3D<T>* scale(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) override {
+        Object<MatrixTransformation3D<T>>* scale(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) {
             transform(Math::Matrix4<T>::scaling(vector), type);
-            return this;
+            return static_cast<Object<MatrixTransformation3D<T>>*>(this);
         }
 
         /**
@@ -180,9 +181,9 @@ class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
          *
          * Same as calling transform() with Matrix4::reflection().
          */
-        MatrixTransformation3D<T>* reflect(const Math::Vector3<T>& normal, TransformationType type = TransformationType::Global) {
+        Object<MatrixTransformation3D<T>>* reflect(const Math::Vector3<T>& normal, TransformationType type = TransformationType::Global) {
             transform(Math::Matrix4<T>::reflection(normal), type);
-            return this;
+            return static_cast<Object<MatrixTransformation3D<T>>*>(this);
         }
 
     protected:
@@ -190,6 +191,32 @@ class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
         explicit MatrixTransformation3D() = default;
 
     private:
+        void doResetTransformation() override final { resetTransformation(); }
+
+        void doTranslate(const Math::Vector3<T>& vector, TransformationType type) override final {
+            translate(vector, type);
+        }
+
+        void doRotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type) override final {
+            rotate(angle, normalizedAxis, type);
+        }
+
+        void doRotateX(Math::Rad<T> angle, TransformationType type) override final {
+            rotateX(angle, type);
+        }
+
+        void doRotateY(Math::Rad<T> angle, TransformationType type) override final {
+            rotateY(angle, type);
+        }
+
+        void doRotateZ(Math::Rad<T> angle, TransformationType type) override final {
+            rotateZ(angle, type);
+        }
+
+        void doScale(const Math::Vector3<T>& vector, TransformationType type) override final {
+            scale(vector, type);
+        }
+
         Math::Matrix4<T> _transformation;
 };
 
diff --git a/src/SceneGraph/RigidMatrixTransformation2D.h b/src/SceneGraph/RigidMatrixTransformation2D.h
index 0dc794349..74dd96428 100644
--- a/src/SceneGraph/RigidMatrixTransformation2D.h
+++ b/src/SceneGraph/RigidMatrixTransformation2D.h
@@ -84,11 +84,11 @@ class RigidMatrixTransformation2D: public AbstractTranslationRotation2D<T> {
          * Normalizes the rotation part using Math::Algorithms::gramSchmidt()
          * to prevent rounding errors when rotating the object subsequently.
          */
-        RigidMatrixTransformation2D<T>* normalizeRotation() {
+        Object<RigidMatrixTransformation2D<T>>* normalizeRotation() {
             setTransformationInternal(Math::Matrix3<T>::from(
                 Math::Algorithms::gramSchmidtOrthonormalize(_transformation.rotationScaling()),
                 _transformation.translation()));
-            return this;
+            return static_cast<Object<RigidMatrixTransformation2D<T>>*>(this);
         }
 
         /**
@@ -98,16 +98,18 @@ class RigidMatrixTransformation2D: public AbstractTranslationRotation2D<T> {
          * Expects that the matrix represents rigid transformation.
          * @see Matrix3::isRigidTransformation()
          */
-        RigidMatrixTransformation2D<T>* setTransformation(const Math::Matrix3<T>& transformation) {
+        Object<RigidMatrixTransformation2D<T>>* setTransformation(const Math::Matrix3<T>& transformation) {
             CORRADE_ASSERT(transformation.isRigidTransformation(),
-                "SceneGraph::RigidMatrixTransformation2D::setTransformation(): the matrix doesn't represent rigid transformation", this);
+                "SceneGraph::RigidMatrixTransformation2D::setTransformation(): the matrix doesn't represent rigid transformation",
+                static_cast<Object<RigidMatrixTransformation2D<T>>*>(this));
             setTransformationInternal(transformation);
-            return this;
+            return static_cast<Object<RigidMatrixTransformation2D<T>>*>(this);
         }
 
-        RigidMatrixTransformation2D<T>* resetTransformation() override {
+        /** @copydoc AbstractTranslationRotationScaling2D::resetTransformation() */
+        Object<RigidMatrixTransformation2D<T>>* resetTransformation() {
             setTransformationInternal({});
-            return this;
+            return static_cast<Object<RigidMatrixTransformation2D<T>>*>(this);
         }
 
         /**
@@ -119,20 +121,21 @@ class RigidMatrixTransformation2D: public AbstractTranslationRotation2D<T> {
          * Expects that the matrix represents rigid transformation.
          * @see Matrix3::isRigidTransformation()
          */
-        RigidMatrixTransformation2D<T>* transform(const Math::Matrix3<T>& transformation, TransformationType type = TransformationType::Global) {
+        Object<RigidMatrixTransformation2D<T>>* transform(const Math::Matrix3<T>& transformation, TransformationType type = TransformationType::Global) {
             CORRADE_ASSERT(transformation.isRigidTransformation(),
-                "SceneGraph::RigidMatrixTransformation2D::transform(): the matrix doesn't represent rigid transformation", this);
+                "SceneGraph::RigidMatrixTransformation2D::transform(): the matrix doesn't represent rigid transformation",
+                static_cast<Object<RigidMatrixTransformation2D<T>>*>(this));
             transformInternal(transformation, type);
-            return this;
+            return static_cast<Object<RigidMatrixTransformation2D<T>>*>(this);
         }
 
         /**
          * @copydoc AbstractTranslationRotationScaling2D::translate()
          * Same as calling transform() with Matrix3::translation().
          */
-        RigidMatrixTransformation2D<T>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) override {
+        Object<RigidMatrixTransformation2D<T>>* translate(const Math::Vector2<T>& vector, TransformationType type = TransformationType::Global) {
             transformInternal(Math::Matrix3<T>::translation(vector), type);
-            return this;
+            return static_cast<Object<RigidMatrixTransformation2D<T>>*>(this);
         }
 
         /**
@@ -144,9 +147,9 @@ class RigidMatrixTransformation2D: public AbstractTranslationRotation2D<T> {
          * Same as calling transform() with Matrix3::rotation().
          * @see normalizeRotation()
          */
-        RigidMatrixTransformation2D<T>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) override {
+        Object<RigidMatrixTransformation2D<T>>* rotate(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
             transformInternal(Math::Matrix3<T>::rotation(angle), type);
-            return this;
+            return static_cast<Object<RigidMatrixTransformation2D<T>>*>(this);
         }
 
         /**
@@ -158,9 +161,9 @@ class RigidMatrixTransformation2D: public AbstractTranslationRotation2D<T> {
          *
          * Same as calling transform() with Matrix3::reflection().
          */
-        RigidMatrixTransformation2D<T>* reflect(const Math::Vector2<T>& normal, TransformationType type = TransformationType::Global) {
+        Object<RigidMatrixTransformation2D<T>>* reflect(const Math::Vector2<T>& normal, TransformationType type = TransformationType::Global) {
             transformInternal(Math::Matrix3<T>::reflection(normal), type);
-            return this;
+            return static_cast<Object<RigidMatrixTransformation2D<T>>*>(this);
         }
 
         /**
@@ -169,9 +172,9 @@ class RigidMatrixTransformation2D: public AbstractTranslationRotation2D<T> {
          *      if you want to move it above all.
          * @return Pointer to self (for method chaining)
          */
-        RigidMatrixTransformation2D<T>* move(Object<RigidMatrixTransformation2D<T>>* under) {
+        Object<RigidMatrixTransformation2D<T>>* move(Object<RigidMatrixTransformation2D<T>>* under) {
             static_cast<Object<RigidMatrixTransformation2D>*>(this)->Containers::template LinkedList<Object<RigidMatrixTransformation2D<T>>>::move(this, under);
-            return this;
+            return static_cast<Object<RigidMatrixTransformation2D<T>>*>(this);
         }
 
     protected:
@@ -179,6 +182,16 @@ class RigidMatrixTransformation2D: public AbstractTranslationRotation2D<T> {
         explicit RigidMatrixTransformation2D() = default;
 
     private:
+        void doResetTransformation() override final { resetTransformation(); }
+
+        void doTranslate(const Math::Vector2<T>& vector, TransformationType type) override final {
+            translate(vector, type);
+        }
+
+        void doRotate(Math::Rad<T> angle, TransformationType type) override final {
+            doRotate(angle, type);
+        }
+
         /* No assertions fired, for internal use */
         void setTransformationInternal(const Math::Matrix3<T>& transformation) {
             /* Setting transformation is forbidden for the scene */
diff --git a/src/SceneGraph/RigidMatrixTransformation3D.h b/src/SceneGraph/RigidMatrixTransformation3D.h
index 7ca937c71..1d13702e4 100644
--- a/src/SceneGraph/RigidMatrixTransformation3D.h
+++ b/src/SceneGraph/RigidMatrixTransformation3D.h
@@ -84,11 +84,11 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
          * Normalizes the rotation part using Math::Algorithms::gramSchmidt()
          * to prevent rounding errors when rotating the object subsequently.
          */
-        RigidMatrixTransformation3D<T>* normalizeRotation() {
+        Object<RigidMatrixTransformation3D<T>>* normalizeRotation() {
             setTransformation(Math::Matrix4<T>::from(
                 Math::Algorithms::gramSchmidtOrthonormalize(_transformation.rotationScaling()),
                 _transformation.translation()));
-            return this;
+            return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this);
         }
 
         /**
@@ -98,16 +98,18 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
          * Expects that the matrix represents rigid transformation.
          * @see Matrix4::isRigidTransformation()
          */
-        RigidMatrixTransformation3D<T>* setTransformation(const Math::Matrix4<T>& transformation) {
+        Object<RigidMatrixTransformation3D<T>>* setTransformation(const Math::Matrix4<T>& transformation) {
             CORRADE_ASSERT(transformation.isRigidTransformation(),
-                "SceneGraph::RigidMatrixTransformation3D::setTransformation(): the matrix doesn't represent rigid transformation", this);
+                "SceneGraph::RigidMatrixTransformation3D::setTransformation(): the matrix doesn't represent rigid transformation",
+                static_cast<Object<RigidMatrixTransformation3D<T>>*>(this));
             setTransformationInternal(transformation);
-            return this;
+            return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this);
         }
 
-        RigidMatrixTransformation3D<T>* resetTransformation() override {
+        /** @copydoc AbstractTranslationRotationScaling3D::resetTransformation() */
+        Object<RigidMatrixTransformation3D<T>>* resetTransformation() {
             setTransformation({});
-            return this;
+            return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this);
         }
 
         /**
@@ -119,20 +121,21 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
          * Expects that the matrix represents rigid transformation.
          * @see Matrix4::isRigidTransformation()
          */
-        RigidMatrixTransformation3D<T>* transform(const Math::Matrix4<T>& transformation, TransformationType type = TransformationType::Global) {
+        Object<RigidMatrixTransformation3D<T>>* transform(const Math::Matrix4<T>& transformation, TransformationType type = TransformationType::Global) {
             CORRADE_ASSERT(transformation.isRigidTransformation(),
-                "SceneGraph::RigidMatrixTransformation3D::transform(): the matrix doesn't represent rigid transformation", this);
+                "SceneGraph::RigidMatrixTransformation3D::transform(): the matrix doesn't represent rigid transformation",
+                static_cast<Object<RigidMatrixTransformation3D<T>>*>(this));
             transformInternal(transformation, type);
-            return this;
+            return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this);
         }
 
         /**
          * @copydoc AbstractTranslationRotationScaling3D::translate()
          * Same as calling transform() with Matrix4::translation().
          */
-        RigidMatrixTransformation3D<T>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) override {
+        Object<RigidMatrixTransformation3D<T>>* translate(const Math::Vector3<T>& vector, TransformationType type = TransformationType::Global) {
             transformInternal(Math::Matrix4<T>::translation(vector), type);
-            return this;
+            return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this);
         }
 
         /**
@@ -146,9 +149,9 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
          * @see rotateX(), rotateY(), rotateZ(), Vector3::xAxis(),
          *      Vector3::yAxis(), Vector3::zAxis(), normalizeRotation()
          */
-        RigidMatrixTransformation3D<T>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) override {
+        Object<RigidMatrixTransformation3D<T>>* rotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type = TransformationType::Global) {
             transformInternal(Math::Matrix4<T>::rotation(angle, normalizedAxis), type);
-            return this;
+            return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this);
         }
 
         /**
@@ -160,9 +163,9 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
          * Same as calling transform() with Matrix4::rotationX().
          * @see normalizeRotation()
          */
-        RigidMatrixTransformation3D<T>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) override {
+        Object<RigidMatrixTransformation3D<T>>* rotateX(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
             transformInternal(Math::Matrix4<T>::rotationX(angle), type);
-            return this;
+            return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this);
         }
 
         /**
@@ -174,9 +177,9 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
          * Same as calling transform() with Matrix4::rotationY().
          * @see normalizeRotation()
          */
-        RigidMatrixTransformation3D<T>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) override {
+        Object<RigidMatrixTransformation3D<T>>* rotateY(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
             transformInternal(Math::Matrix4<T>::rotationY(angle), type);
-            return this;
+            return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this);
         }
 
         /**
@@ -188,9 +191,9 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
          * Same as calling transform() with Matrix4::rotationZ().
          * @see normalizeRotation()
          */
-        RigidMatrixTransformation3D<T>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) override {
+        Object<RigidMatrixTransformation3D<T>>* rotateZ(Math::Rad<T> angle, TransformationType type = TransformationType::Global) {
             transformInternal(Math::Matrix4<T>::rotationZ(angle), type);
-            return this;
+            return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this);
         }
 
         /**
@@ -202,9 +205,9 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
          *
          * Same as calling transform() with Matrix4::reflection().
          */
-        RigidMatrixTransformation3D<T>* reflect(const Math::Vector3<T>& normal, TransformationType type = TransformationType::Global) {
+        Object<RigidMatrixTransformation3D<T>>* reflect(const Math::Vector3<T>& normal, TransformationType type = TransformationType::Global) {
             transformInternal(Math::Matrix4<T>::reflection(normal), type);
-            return this;
+            return static_cast<Object<RigidMatrixTransformation3D<T>>*>(this);
         }
 
     protected:
@@ -212,6 +215,28 @@ class RigidMatrixTransformation3D: public AbstractTranslationRotation3D<T> {
         explicit RigidMatrixTransformation3D() = default;
 
     private:
+        void doResetTransformation() override final { resetTransformation(); }
+
+        void doTranslate(const Math::Vector3<T>& vector, TransformationType type) override final {
+            translate(vector, type);
+        }
+
+        void doRotate(Math::Rad<T> angle, const Math::Vector3<T>& normalizedAxis, TransformationType type) override final {
+            rotate(angle, normalizedAxis, type);
+        }
+
+        void doRotateX(Math::Rad<T> angle, TransformationType type) override final {
+            rotateX(angle, type);
+        }
+
+        void doRotateY(Math::Rad<T> angle, TransformationType type) override final {
+            rotateY(angle, type);
+        }
+
+        void doRotateZ(Math::Rad<T> angle, TransformationType type) override final {
+            rotateZ(angle, type);
+        }
+
         /* No assertions fired, for internal use */
         void setTransformationInternal(const Math::Matrix4<T>& transformation) {
             /* Setting transformation is forbidden for the scene */