diff --git a/src/SceneGraph/AbstractObject.h b/src/SceneGraph/AbstractObject.h
index 7c58ae068..662a56c07 100644
--- a/src/SceneGraph/AbstractObject.h
+++ b/src/SceneGraph/AbstractObject.h
@@ -79,6 +79,19 @@ template<std::uint8_t dimensions, class T = GLfloat> class AbstractObject
             return Corrade::Containers::LinkedList<AbstractFeature<dimensions, T>>::last();
         }
 
+        /**
+         * @brief %Scene object
+         * @return Root object which is also scene or `nullptr`, if the object
+         *      is not part of any scene.
+         *
+         * @todo Rename to scene() when I fully understand and fix covariant
+         *      return issues.
+         */
+        virtual AbstractObject<dimensions, T>* sceneObject() = 0;
+
+        /** @overload */
+        virtual const AbstractObject<dimensions, T>* sceneObject() const = 0;
+
         /** @{ @name Object transformation */
 
         /**
@@ -89,6 +102,48 @@ template<std::uint8_t dimensions, class T = GLfloat> class AbstractObject
         virtual typename DimensionTraits<dimensions, T>::MatrixType absoluteTransformationMatrix() const = 0;
 
         /*@}*/
+
+        /**
+         * @{ @name Transformation caching
+         *
+         * See @ref scenegraph-caching for more information.
+         */
+
+        /**
+         * @brief Whether absolute transformation is dirty
+         *
+         * Returns `true` if transformation of the object or any parent has
+         * changed since last call to setClean(), `false` otherwise.
+         *
+         * All objects are dirty by default.
+         *
+         * @see @ref scenegraph-caching
+         */
+        virtual bool isDirty() const = 0;
+
+        /**
+         * @brief Set object absolute transformation as dirty
+         *
+         * Calls AbstractFeature::markDirty() on all object features and
+         * recursively calls setDirty() on every child object which is not
+         * already dirty. If the object is already marked as dirty, the
+         * function does nothing.
+         * @see @ref scenegraph-caching, setClean(), isDirty()
+         */
+        virtual void setDirty() = 0;
+
+        /**
+         * @brief Clean object absolute transformation
+         *
+         * Calls AbstractFeature::clean() and/or AbstractFeature::cleanInverted()
+         * on all object features which have caching enabled and recursively
+         * calls setClean() on every parent which is not already clean. If the
+         * object is already clean, the function does nothing.
+         * @see @ref scenegraph-caching, setDirty(), isDirty()
+         */
+        virtual void setClean() = 0;
+
+        /*@}*/
 };
 
 /**
diff --git a/src/SceneGraph/Object.h b/src/SceneGraph/Object.h
index 73676b6f0..587f2f07d 100644
--- a/src/SceneGraph/Object.h
+++ b/src/SceneGraph/Object.h
@@ -188,49 +188,14 @@ template<class Transformation> class Object: public AbstractObject<Transformatio
 
         /*@}*/
 
-        /**
-         * @{ @name Transformation caching
-         *
-         * See @ref scenegraph-caching for more information.
-         */
-
-        /**
-         * @brief Whether absolute transformation is dirty
-         *
-         * Returns `true` if transformation of the object or any parent has
-         * changed since last call to setClean(), `false` otherwise.
-         *
-         * All objects are dirty by default.
-         *
-         * @see @ref scenegraph-caching
-         */
-        inline bool isDirty() const { return !!(flags & Flag::Dirty); }
-
-        /**
-         * @brief Set object absolute transformation as dirty
-         *
-         * Calls AbstractFeature::markDirty() on all object features and
-         * recursively calls setDirty() on every child object which is not
-         * already dirty. If the object is already marked as dirty, the
-         * function does nothing.
-         * @see @ref scenegraph-caching, setClean(), isDirty()
-         */
-        void setDirty();
-
-        /**
-         * @brief Clean object absolute transformation
-         *
-         * Calls AbstractFeature::clean() and/or AbstractFeature::cleanInverted()
-         * on all object features which have caching enabled and recursively
-         * calls setClean() on every parent which is not already clean. If the
-         * object is already clean, the function does nothing.
-         * @see @ref scenegraph-caching, setDirty(), isDirty()
-         */
-        void setClean();
-
-        /*@}*/
+        inline bool isDirty() const override { return !!(flags & Flag::Dirty); }
+        void setDirty() override;
+        void setClean() override;
 
     private:
+        Object<Transformation>* sceneObject() override;
+        const Object<Transformation>* sceneObject() const override;
+
         typedef Implementation::ObjectFlag Flag;
         typedef Implementation::ObjectFlags Flags;
         Flags flags;
diff --git a/src/SceneGraph/Object.hpp b/src/SceneGraph/Object.hpp
index dc54f42ca..092cc9c70 100644
--- a/src/SceneGraph/Object.hpp
+++ b/src/SceneGraph/Object.hpp
@@ -28,15 +28,23 @@
 namespace Magnum { namespace SceneGraph {
 
 template<class Transformation> Scene<Transformation>* Object<Transformation>::scene() {
+    return static_cast<Scene<Transformation>*>(sceneObject());
+}
+
+template<class Transformation> const Scene<Transformation>* Object<Transformation>::scene() const {
+    return static_cast<const Scene<Transformation>*>(sceneObject());
+}
+
+template<class Transformation> Object<Transformation>* Object<Transformation>::sceneObject() {
     Object<Transformation>* p(this);
     while(p && !p->isScene()) p = p->parent();
-    return static_cast<Scene<Transformation>*>(p);
+    return p;
 }
 
-template<class Transformation> const Scene<Transformation>* Object<Transformation>::scene() const {
+template<class Transformation> const Object<Transformation>* Object<Transformation>::sceneObject() const {
     const Object<Transformation>* p(this);
     while(p && !p->isScene()) p = p->parent();
-    return static_cast<const Scene<Transformation>*>(p);
+    return p;
 }
 
 template<class Transformation> Object<Transformation>* Object<Transformation>::setParent(Object<Transformation>* parent) {