diff --git a/src/DebugTools/Implementation/AbstractShapeRenderer.h b/src/DebugTools/Implementation/AbstractShapeRenderer.h
index 4670c0d5d..a20134871 100644
--- a/src/DebugTools/Implementation/AbstractShapeRenderer.h
+++ b/src/DebugTools/Implementation/AbstractShapeRenderer.h
@@ -31,9 +31,15 @@
 #include "Shaders/Shaders.h"
 #include "Trade/Trade.h"
 
-namespace Magnum { namespace DebugTools { namespace Implementation {
+namespace Magnum {
 
-template<UnsignedInt dimensions> struct MeshData;
+namespace Physics { namespace Implementation {
+    template<UnsignedInt> struct AbstractShape;
+}}
+
+namespace DebugTools { namespace Implementation {
+
+template<UnsignedInt> struct MeshData;
 
 template<> struct MeshData<2> { typedef Trade::MeshData2D Type; };
 template<> struct MeshData<3> { typedef Trade::MeshData3D Type; };
diff --git a/src/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp b/src/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp
index daaa4673e..00ac739f6 100644
--- a/src/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp
+++ b/src/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp
@@ -31,12 +31,12 @@
 
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
-template<UnsignedInt dimensions> AxisAlignedBoxRenderer<dimensions>::AxisAlignedBoxRenderer(Physics::AxisAlignedBox<dimensions>& axisAlignedBox): axisAlignedBox(axisAlignedBox) {}
+template<UnsignedInt dimensions> AxisAlignedBoxRenderer<dimensions>::AxisAlignedBoxRenderer(const Physics::Implementation::AbstractShape<dimensions>* axisAlignedBox): axisAlignedBox(static_cast<const Physics::Implementation::Shape<Physics::AxisAlignedBox<dimensions>>*>(axisAlignedBox)->shape) {}
 
 template<UnsignedInt dimensions> void AxisAlignedBoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) {
     this->wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
-        DimensionTraits<dimensions>::MatrixType::translation((axisAlignedBox.transformedMin()+axisAlignedBox.transformedMax())/2)*
-        DimensionTraits<dimensions>::MatrixType::scaling(axisAlignedBox.transformedMax()-axisAlignedBox.transformedMin()))
+        DimensionTraits<dimensions>::MatrixType::translation((axisAlignedBox.min()+axisAlignedBox.max())/2)*
+        DimensionTraits<dimensions>::MatrixType::scaling(axisAlignedBox.max()-axisAlignedBox.min()))
         ->setColor(options->color())
         ->use();
     this->wireframeMesh->draw();
diff --git a/src/DebugTools/Implementation/AxisAlignedBoxRenderer.h b/src/DebugTools/Implementation/AxisAlignedBoxRenderer.h
index 9247fa2a1..fe59ca713 100644
--- a/src/DebugTools/Implementation/AxisAlignedBoxRenderer.h
+++ b/src/DebugTools/Implementation/AxisAlignedBoxRenderer.h
@@ -34,12 +34,12 @@ namespace Magnum { namespace DebugTools { namespace Implementation {
 
 template<UnsignedInt dimensions> class AxisAlignedBoxRenderer: public AbstractBoxRenderer<dimensions> {
     public:
-        AxisAlignedBoxRenderer(Physics::AxisAlignedBox<dimensions>& axisAlignedBox);
+        AxisAlignedBoxRenderer(const Physics::Implementation::AbstractShape<dimensions>* axisAlignedBox);
 
         void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) override;
 
     private:
-        Physics::AxisAlignedBox<dimensions>& axisAlignedBox;
+        const Physics::AxisAlignedBox<dimensions>& axisAlignedBox;
 };
 
 }}}
diff --git a/src/DebugTools/Implementation/BoxRenderer.cpp b/src/DebugTools/Implementation/BoxRenderer.cpp
index a39356a91..4b515883b 100644
--- a/src/DebugTools/Implementation/BoxRenderer.cpp
+++ b/src/DebugTools/Implementation/BoxRenderer.cpp
@@ -31,10 +31,10 @@
 
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
-template<UnsignedInt dimensions> BoxRenderer<dimensions>::BoxRenderer(Physics::Box<dimensions>& box): box(box) {}
+template<UnsignedInt dimensions> BoxRenderer<dimensions>::BoxRenderer(const Physics::Implementation::AbstractShape<dimensions>* box): box(static_cast<const Physics::Implementation::Shape<Physics::Box<dimensions>>*>(box)->shape) {}
 
 template<UnsignedInt dimensions> void BoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) {
-    this->wireframeShader->setTransformationProjectionMatrix(projectionMatrix*box.transformedTransformation())
+    this->wireframeShader->setTransformationProjectionMatrix(projectionMatrix*box.transformation())
         ->setColor(options->color())
         ->use();
     this->wireframeMesh->draw();
diff --git a/src/DebugTools/Implementation/BoxRenderer.h b/src/DebugTools/Implementation/BoxRenderer.h
index 90b459113..0f93b9a4a 100644
--- a/src/DebugTools/Implementation/BoxRenderer.h
+++ b/src/DebugTools/Implementation/BoxRenderer.h
@@ -34,12 +34,12 @@ namespace Magnum { namespace DebugTools { namespace Implementation {
 
 template<UnsignedInt dimensions> class BoxRenderer: public AbstractBoxRenderer<dimensions> {
     public:
-        BoxRenderer(Physics::Box<dimensions>& box);
+        BoxRenderer(const Physics::Implementation::AbstractShape<dimensions>* box);
 
         void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) override;
 
     private:
-        Physics::Box<dimensions>& box;
+        const Physics::Box<dimensions>& box;
 };
 
 }}}
diff --git a/src/DebugTools/Implementation/LineSegmentRenderer.cpp b/src/DebugTools/Implementation/LineSegmentRenderer.cpp
index 5ef695b9c..51fc909ad 100644
--- a/src/DebugTools/Implementation/LineSegmentRenderer.cpp
+++ b/src/DebugTools/Implementation/LineSegmentRenderer.cpp
@@ -26,7 +26,7 @@
 
 #include "Mesh.h"
 #include "DebugTools/ShapeRenderer.h"
-#include "Physics/Line.h"
+#include "Physics/LineSegment.h"
 #include "Primitives/Line.h"
 #include "Shaders/Flat.h"
 #include "Trade/MeshData2D.h"
@@ -50,13 +50,13 @@ namespace {
     template<> inline Trade::MeshData3D meshData<3>() { return Primitives::Line3D::wireframe(); }
 }
 
-template<UnsignedInt dimensions> LineSegmentRenderer<dimensions>::LineSegmentRenderer(Physics::Line<dimensions>& line): AbstractShapeRenderer<dimensions>(meshKey<dimensions>(), vertexBufferKey<dimensions>(), {}), line(line) {
+template<UnsignedInt dimensions> LineSegmentRenderer<dimensions>::LineSegmentRenderer(const Physics::Implementation::AbstractShape<dimensions>* line): AbstractShapeRenderer<dimensions>(meshKey<dimensions>(), vertexBufferKey<dimensions>(), {}), line(static_cast<const Physics::Implementation::Shape<Physics::LineSegment<dimensions>>*>(line)->shape) {
     if(!this->wireframeMesh) this->createResources(meshData<dimensions>());
 }
 
 template<UnsignedInt dimensions> void LineSegmentRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) {
     this->wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
-        Implementation::lineSegmentRendererTransformation<dimensions>(line.transformedA(), line.transformedB()))
+        Implementation::lineSegmentRendererTransformation<dimensions>(line.a(), line.b()))
         ->setColor(options->color())
         ->use();
     this->wireframeMesh->draw();
diff --git a/src/DebugTools/Implementation/LineSegmentRenderer.h b/src/DebugTools/Implementation/LineSegmentRenderer.h
index a67208825..2152cefd3 100644
--- a/src/DebugTools/Implementation/LineSegmentRenderer.h
+++ b/src/DebugTools/Implementation/LineSegmentRenderer.h
@@ -34,12 +34,12 @@ namespace Magnum { namespace DebugTools { namespace Implementation {
 
 template<UnsignedInt dimensions> class LineSegmentRenderer: public AbstractShapeRenderer<dimensions> {
     public:
-        LineSegmentRenderer(Physics::Line<dimensions>& line);
+        LineSegmentRenderer(const Physics::Implementation::AbstractShape<dimensions>* line);
 
         void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) override;
 
     private:
-        Physics::Line<dimensions>& line;
+        const Physics::LineSegment<dimensions>& line;
 };
 
 }}}
diff --git a/src/DebugTools/Implementation/PointRenderer.cpp b/src/DebugTools/Implementation/PointRenderer.cpp
index de84bcd2a..c1799ac64 100644
--- a/src/DebugTools/Implementation/PointRenderer.cpp
+++ b/src/DebugTools/Implementation/PointRenderer.cpp
@@ -48,14 +48,14 @@ namespace {
     template<> inline Trade::MeshData3D meshData<3>() { return Primitives::Crosshair3D::wireframe(); }
 }
 
-template<UnsignedInt dimensions> PointRenderer<dimensions>::PointRenderer(Physics::Point<dimensions>& point): AbstractShapeRenderer<dimensions>(meshKey<dimensions>(), vertexBufferKey<dimensions>(), {}), point(point) {
+template<UnsignedInt dimensions> PointRenderer<dimensions>::PointRenderer(const Physics::Implementation::AbstractShape<dimensions>* point): AbstractShapeRenderer<dimensions>(meshKey<dimensions>(), vertexBufferKey<dimensions>(), {}), point(static_cast<const Physics::Implementation::Shape<Physics::Point<dimensions>>*>(point)->shape) {
     if(!this->wireframeMesh) this->createResources(meshData<dimensions>());
 }
 
 template<UnsignedInt dimensions> void PointRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) {
     /* Half scale, because the point is 2x2(x2) */
     this->wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
-        DimensionTraits<dimensions>::MatrixType::translation(point.transformedPosition())*
+        DimensionTraits<dimensions>::MatrixType::translation(point.position())*
         DimensionTraits<dimensions>::MatrixType::scaling(typename DimensionTraits<dimensions>::VectorType(options->pointSize()/2)))
         ->setColor(options->color())
         ->use();
diff --git a/src/DebugTools/Implementation/PointRenderer.h b/src/DebugTools/Implementation/PointRenderer.h
index 4ac4c78c7..4aeea85b9 100644
--- a/src/DebugTools/Implementation/PointRenderer.h
+++ b/src/DebugTools/Implementation/PointRenderer.h
@@ -34,12 +34,12 @@ namespace Magnum { namespace DebugTools { namespace Implementation {
 
 template<UnsignedInt dimensions> class PointRenderer: public AbstractShapeRenderer<dimensions> {
     public:
-        PointRenderer(Physics::Point<dimensions>& point);
+        PointRenderer(const Physics::Implementation::AbstractShape<dimensions>* point);
 
         void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) override;
 
     private:
-        Physics::Point<dimensions>& point;
+        const Physics::Point<dimensions>& point;
 };
 
 }}}
diff --git a/src/DebugTools/Implementation/SphereRenderer.cpp b/src/DebugTools/Implementation/SphereRenderer.cpp
index a45bc12ee..859fe6120 100644
--- a/src/DebugTools/Implementation/SphereRenderer.cpp
+++ b/src/DebugTools/Implementation/SphereRenderer.cpp
@@ -37,12 +37,12 @@ AbstractSphereRenderer<2>::AbstractSphereRenderer(): AbstractShapeRenderer<2>("s
     if(!wireframeMesh) createResources(Primitives::Circle::wireframe(40));
 }
 
-template<UnsignedInt dimensions> SphereRenderer<dimensions>::SphereRenderer(Physics::Sphere<dimensions>& sphere): sphere(sphere) {}
+template<UnsignedInt dimensions> SphereRenderer<dimensions>::SphereRenderer(const Physics::Implementation::AbstractShape<dimensions>* sphere): sphere(static_cast<const Physics::Implementation::Shape<Physics::Sphere<dimensions>>*>(sphere)->shape) {}
 
 template<UnsignedInt dimensions> void SphereRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) {
     this->wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
-        DimensionTraits<dimensions>::MatrixType::translation(sphere.transformedPosition())*
-        DimensionTraits<dimensions>::MatrixType::scaling(typename DimensionTraits<dimensions>::VectorType(sphere.transformedRadius())))
+        DimensionTraits<dimensions>::MatrixType::translation(sphere.position())*
+        DimensionTraits<dimensions>::MatrixType::scaling(typename DimensionTraits<dimensions>::VectorType(sphere.radius())))
         ->setColor(options->color())
         ->use();
     this->wireframeMesh->draw();
diff --git a/src/DebugTools/Implementation/SphereRenderer.h b/src/DebugTools/Implementation/SphereRenderer.h
index e7cf52922..4822ee899 100644
--- a/src/DebugTools/Implementation/SphereRenderer.h
+++ b/src/DebugTools/Implementation/SphereRenderer.h
@@ -41,12 +41,12 @@ template<> class AbstractSphereRenderer<2>: public AbstractShapeRenderer<2> {
 
 template<UnsignedInt dimensions> class SphereRenderer: public AbstractSphereRenderer<dimensions> {
     public:
-        SphereRenderer(Physics::Sphere<dimensions>& sphere);
+        SphereRenderer(const Physics::Implementation::AbstractShape<dimensions>* sphere);
 
         void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) override;
 
     private:
-        Physics::Sphere<dimensions>& sphere;
+        const Physics::Sphere<dimensions>& sphere;
 };
 
 }}}
diff --git a/src/DebugTools/ShapeRenderer.cpp b/src/DebugTools/ShapeRenderer.cpp
index 7bf36b95c..fe02f6a56 100644
--- a/src/DebugTools/ShapeRenderer.cpp
+++ b/src/DebugTools/ShapeRenderer.cpp
@@ -25,14 +25,8 @@
 #include "ShapeRenderer.h"
 
 #include "ResourceManager.h"
-#include "Physics/AbstractShape.h"
-#include "Physics/AxisAlignedBox.h"
-#include "Physics/Box.h"
 #include "Physics/ObjectShape.h"
-#include "Physics/LineSegment.h"
-#include "Physics/Point.h"
 #include "Physics/ShapeGroup.h"
-#include "Physics/Sphere.h"
 #include "SceneGraph/AbstractCamera.h"
 
 #include "Implementation/AxisAlignedBoxRenderer.h"
@@ -45,51 +39,53 @@ namespace Magnum { namespace DebugTools {
 
 namespace Implementation {
 
-template<> void createDebugMesh(ShapeRenderer<2>* renderer, Physics::AbstractShape<2>* shape) {
+template<> void createDebugMesh(ShapeRenderer<2>* renderer, const Physics::Implementation::AbstractShape<2>* shape) {
     switch(shape->type()) {
-        case Physics::AbstractShape2D::Type::AxisAlignedBox:
-            renderer->renderers.push_back(new Implementation::AxisAlignedBoxRenderer<2>(*static_cast<Physics::AxisAlignedBox2D*>(shape)));
+        case Physics::AbstractObjectShape2D::Type::AxisAlignedBox:
+            renderer->renderers.push_back(new Implementation::AxisAlignedBoxRenderer<2>(shape));
             break;
-        case Physics::AbstractShape2D::Type::Box:
-            renderer->renderers.push_back(new Implementation::BoxRenderer<2>(*static_cast<Physics::Box2D*>(shape)));
+        case Physics::AbstractObjectShape2D::Type::Box:
+            renderer->renderers.push_back(new Implementation::BoxRenderer<2>(shape));
             break;
-        case Physics::AbstractShape2D::Type::LineSegment:
-            renderer->renderers.push_back(new Implementation::LineSegmentRenderer<2>(*static_cast<Physics::LineSegment2D*>(shape)));
+        case Physics::AbstractObjectShape2D::Type::LineSegment:
+            renderer->renderers.push_back(new Implementation::LineSegmentRenderer<2>(shape));
             break;
-        case Physics::AbstractShape2D::Type::Point:
-            renderer->renderers.push_back(new Implementation::PointRenderer<2>(*static_cast<Physics::Point2D*>(shape)));
+        case Physics::AbstractObjectShape2D::Type::Point:
+            renderer->renderers.push_back(new Implementation::PointRenderer<2>(shape));
             break;
-        case Physics::AbstractShape2D::Type::ShapeGroup: {
-            Physics::ShapeGroup2D* group = static_cast<Physics::ShapeGroup2D*>(shape);
-            if(group->first()) createDebugMesh(renderer, group->first());
-            if(group->second()) createDebugMesh(renderer, group->second());
+        case Physics::AbstractObjectShape2D::Type::ShapeGroup: {
+            const Physics::ShapeGroup2D& group =
+                static_cast<const Physics::Implementation::Shape<Physics::ShapeGroup2D>*>(shape)->shape;
+            for(std::size_t i = 0; i != group.size(); ++i)
+                createDebugMesh(renderer, Physics::Implementation::getAbstractShape(group, i));
         } break;
-        case Physics::AbstractShape2D::Type::Sphere:
-            renderer->renderers.push_back(new Implementation::SphereRenderer<2>(*static_cast<Physics::Sphere2D*>(shape)));
+        case Physics::AbstractObjectShape2D::Type::Sphere:
+            renderer->renderers.push_back(new Implementation::SphereRenderer<2>(shape));
             break;
         default:
             Warning() << "DebugTools::ShapeRenderer2D::createShapeRenderer(): type" << shape->type() << "not implemented";
     }
 }
 
-template<> void createDebugMesh(ShapeRenderer<3>* renderer, Physics::AbstractShape<3>* shape) {
+template<> void createDebugMesh(ShapeRenderer<3>* renderer, const Physics::Implementation::AbstractShape<3>* shape) {
     switch(shape->type()) {
-        case Physics::AbstractShape3D::Type::AxisAlignedBox:
-            renderer->renderers.push_back(new Implementation::AxisAlignedBoxRenderer<3>(*static_cast<Physics::AxisAlignedBox3D*>(shape)));
+        case Physics::AbstractObjectShape3D::Type::AxisAlignedBox:
+            renderer->renderers.push_back(new Implementation::AxisAlignedBoxRenderer<3>(shape));
             break;
-        case Physics::AbstractShape3D::Type::Box:
-            renderer->renderers.push_back(new Implementation::BoxRenderer<3>(*static_cast<Physics::Box3D*>(shape)));
+        case Physics::AbstractObjectShape3D::Type::Box:
+            renderer->renderers.push_back(new Implementation::BoxRenderer<3>(shape));
             break;
-        case Physics::AbstractShape3D::Type::LineSegment:
-            renderer->renderers.push_back(new Implementation::LineSegmentRenderer<3>(*static_cast<Physics::LineSegment3D*>(shape)));
+        case Physics::AbstractObjectShape3D::Type::LineSegment:
+            renderer->renderers.push_back(new Implementation::LineSegmentRenderer<3>(shape));
             break;
-        case Physics::AbstractShape3D::Type::Point:
-            renderer->renderers.push_back(new Implementation::PointRenderer<3>(*static_cast<Physics::Point3D*>(shape)));
+        case Physics::AbstractObjectShape3D::Type::Point:
+            renderer->renderers.push_back(new Implementation::PointRenderer<3>(shape));
             break;
-        case Physics::AbstractShape3D::Type::ShapeGroup: {
-            Physics::ShapeGroup3D* group = static_cast<Physics::ShapeGroup3D*>(shape);
-            if(group->first()) createDebugMesh(renderer, group->first());
-            if(group->second()) createDebugMesh(renderer, group->second());
+        case Physics::AbstractObjectShape3D::Type::ShapeGroup: {
+            const Physics::ShapeGroup3D& group =
+                static_cast<const Physics::Implementation::Shape<Physics::ShapeGroup3D>*>(shape)->shape;
+            for(std::size_t i = 0; i != group.size(); ++i)
+                createDebugMesh(renderer, Physics::Implementation::getAbstractShape(group, i));
         } break;
         default:
             Warning() << "DebugTools::ShapeRenderer3D::createShapeRenderer(): type" << shape->type() << "not implemented";
@@ -98,9 +94,8 @@ template<> void createDebugMesh(ShapeRenderer<3>* renderer, Physics::AbstractSha
 
 }
 
-template<UnsignedInt dimensions> ShapeRenderer<dimensions>::ShapeRenderer(Physics::ObjectShape<dimensions>* shape, ResourceKey options, SceneGraph::DrawableGroup<dimensions>* drawables): SceneGraph::Drawable<dimensions>(shape->object(), drawables), options(ResourceManager::instance()->get<ShapeRendererOptions>(options)) {
-    CORRADE_ASSERT(shape->shape() != nullptr, "DebugTools::ShapeRenderer: cannot create renderer for empty shape", );
-    Implementation::createDebugMesh(this, shape->shape());
+template<UnsignedInt dimensions> ShapeRenderer<dimensions>::ShapeRenderer(Physics::AbstractObjectShape<dimensions>* shape, ResourceKey options, SceneGraph::DrawableGroup<dimensions>* drawables): SceneGraph::Drawable<dimensions>(shape->object(), drawables), options(ResourceManager::instance()->get<ShapeRendererOptions>(options)) {
+    Implementation::createDebugMesh(this, Physics::Implementation::getAbstractShape(shape));
 }
 
 template<UnsignedInt dimensions> ShapeRenderer<dimensions>::~ShapeRenderer() {
diff --git a/src/DebugTools/ShapeRenderer.h b/src/DebugTools/ShapeRenderer.h
index d52d20af2..378babba9 100644
--- a/src/DebugTools/ShapeRenderer.h
+++ b/src/DebugTools/ShapeRenderer.h
@@ -32,6 +32,7 @@
 #include "Resource.h"
 #include "SceneGraph/Drawable.h"
 #include "Physics/Physics.h"
+#include "Physics/shapeImplementation.h"
 
 #include "magnumDebugToolsVisibility.h"
 
@@ -45,7 +46,7 @@ template<UnsignedInt> class ShapeRenderer;
 namespace Implementation {
     template<UnsignedInt> class AbstractShapeRenderer;
 
-    template<UnsignedInt dimensions> void createDebugMesh(ShapeRenderer<dimensions>* renderer, Physics::AbstractShape<dimensions>* shape);
+    template<UnsignedInt dimensions> void createDebugMesh(ShapeRenderer<dimensions>* renderer, const Physics::Implementation::AbstractShape<dimensions>* shape);
 }
 
 /**
@@ -138,7 +139,7 @@ new DebugTools::ShapeRenderer2D(shape, "red", debugDrawables);
 @see ShapeRenderer2D, ShapeRenderer3D
 */
 template<UnsignedInt dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ShapeRenderer: public SceneGraph::Drawable<dimensions> {
-    friend void Implementation::createDebugMesh<>(ShapeRenderer<dimensions>*, Physics::AbstractShape<dimensions>*);
+    friend void Implementation::createDebugMesh<>(ShapeRenderer<dimensions>*, const Physics::Implementation::AbstractShape<dimensions>*);
 
     public:
         /**
@@ -150,11 +151,10 @@ template<UnsignedInt dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ShapeRenderer: p
          * @param drawables Drawable group
          *
          * The renderer is automatically added to shape's object features,
-         * @p shape must be available for the whole lifetime of the renderer.
-         *
-         * @attention Passed object must have assigned shape.
+         * @p shape must be available for the whole lifetime of the renderer
+         * and if it is group, it must not change its internal structure.
          */
-        explicit ShapeRenderer(Physics::ObjectShape<dimensions>* shape, ResourceKey options = ResourceKey(), SceneGraph::DrawableGroup<dimensions>* drawables = nullptr);
+        explicit ShapeRenderer(Physics::AbstractObjectShape<dimensions>* shape, ResourceKey options = ResourceKey(), SceneGraph::DrawableGroup<dimensions>* drawables = nullptr);
 
         ~ShapeRenderer();