DebugTools: adapted ShapeRenderer to Physics changes.

Now using const reference to the shape instead of non-const one, also
removed some duplicated code and unneeded includes from the switch,
these operations are done in renderer implementations themselves.

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; };

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::translation((axisAlignedBox.min()+axisAlignedBox.max())/2)*
-        DimensionTraits<dimensions>::MatrixType::scaling(axisAlignedBox.transformedMax()-axisAlignedBox.transformedMin()))
+        DimensionTraits<dimensions>::MatrixType::scaling(axisAlignedBox.max()-axisAlignedBox.min()))
         ->setColor(options->color())
         ->use();
     this->wireframeMesh->draw();

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;
 };
 
 }}}

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();

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;
 };
 
 }}}

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();

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;
 };
 
 }}}

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();

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;
 };
 
 }}}

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::translation(sphere.position())*
-        DimensionTraits<dimensions>::MatrixType::scaling(typename DimensionTraits<dimensions>::VectorType(sphere.transformedRadius())))
+        DimensionTraits<dimensions>::MatrixType::scaling(typename DimensionTraits<dimensions>::VectorType(sphere.radius())))
         ->setColor(options->color())
         ->use();
     this->wireframeMesh->draw();

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;
 };
 
 }}}

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:
+        case Physics::AbstractObjectShape2D::Type::AxisAlignedBox:
-            renderer->renderers.push_back(new Implementation::AxisAlignedBoxRenderer<2>(*static_cast<Physics::AxisAlignedBox2D*>(shape)));
+            renderer->renderers.push_back(new Implementation::AxisAlignedBoxRenderer<2>(shape));
             break;
-        case Physics::AbstractShape2D::Type::Box:
+        case Physics::AbstractObjectShape2D::Type::Box:
-            renderer->renderers.push_back(new Implementation::BoxRenderer<2>(*static_cast<Physics::Box2D*>(shape)));
+            renderer->renderers.push_back(new Implementation::BoxRenderer<2>(shape));
             break;
-        case Physics::AbstractShape2D::Type::LineSegment:
+        case Physics::AbstractObjectShape2D::Type::LineSegment:
-            renderer->renderers.push_back(new Implementation::LineSegmentRenderer<2>(*static_cast<Physics::LineSegment2D*>(shape)));
+            renderer->renderers.push_back(new Implementation::LineSegmentRenderer<2>(shape));
             break;
-        case Physics::AbstractShape2D::Type::Point:
+        case Physics::AbstractObjectShape2D::Type::Point:
-            renderer->renderers.push_back(new Implementation::PointRenderer<2>(*static_cast<Physics::Point2D*>(shape)));
+            renderer->renderers.push_back(new Implementation::PointRenderer<2>(shape));
             break;
-        case Physics::AbstractShape2D::Type::ShapeGroup: {
+        case Physics::AbstractObjectShape2D::Type::ShapeGroup: {
-            Physics::ShapeGroup2D* group = static_cast<Physics::ShapeGroup2D*>(shape);
+            const Physics::ShapeGroup2D& group =
-            if(group->first()) createDebugMesh(renderer, group->first());
+                static_cast<const Physics::Implementation::Shape<Physics::ShapeGroup2D>*>(shape)->shape;
-            if(group->second()) createDebugMesh(renderer, group->second());
+            for(std::size_t i = 0; i != group.size(); ++i)
+                createDebugMesh(renderer, Physics::Implementation::getAbstractShape(group, i));
         } break;
-        case Physics::AbstractShape2D::Type::Sphere:
+        case Physics::AbstractObjectShape2D::Type::Sphere:
-            renderer->renderers.push_back(new Implementation::SphereRenderer<2>(*static_cast<Physics::Sphere2D*>(shape)));
+            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:
+        case Physics::AbstractObjectShape3D::Type::AxisAlignedBox:
-            renderer->renderers.push_back(new Implementation::AxisAlignedBoxRenderer<3>(*static_cast<Physics::AxisAlignedBox3D*>(shape)));
+            renderer->renderers.push_back(new Implementation::AxisAlignedBoxRenderer<3>(shape));
             break;
-        case Physics::AbstractShape3D::Type::Box:
+        case Physics::AbstractObjectShape3D::Type::Box:
-            renderer->renderers.push_back(new Implementation::BoxRenderer<3>(*static_cast<Physics::Box3D*>(shape)));
+            renderer->renderers.push_back(new Implementation::BoxRenderer<3>(shape));
             break;
-        case Physics::AbstractShape3D::Type::LineSegment:
+        case Physics::AbstractObjectShape3D::Type::LineSegment:
-            renderer->renderers.push_back(new Implementation::LineSegmentRenderer<3>(*static_cast<Physics::LineSegment3D*>(shape)));
+            renderer->renderers.push_back(new Implementation::LineSegmentRenderer<3>(shape));
             break;
-        case Physics::AbstractShape3D::Type::Point:
+        case Physics::AbstractObjectShape3D::Type::Point:
-            renderer->renderers.push_back(new Implementation::PointRenderer<3>(*static_cast<Physics::Point3D*>(shape)));
+            renderer->renderers.push_back(new Implementation::PointRenderer<3>(shape));
             break;
-        case Physics::AbstractShape3D::Type::ShapeGroup: {
+        case Physics::AbstractObjectShape3D::Type::ShapeGroup: {
-            Physics::ShapeGroup3D* group = static_cast<Physics::ShapeGroup3D*>(shape);
+            const Physics::ShapeGroup3D& group =
-            if(group->first()) createDebugMesh(renderer, group->first());
+                static_cast<const Physics::Implementation::Shape<Physics::ShapeGroup3D>*>(shape)->shape;
-            if(group->second()) createDebugMesh(renderer, group->second());
+            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)) {
+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)) {
-    CORRADE_ASSERT(shape->shape() != nullptr, "DebugTools::ShapeRenderer: cannot create renderer for empty shape", );
+    Implementation::createDebugMesh(this, Physics::Implementation::getAbstractShape(shape));
-    Implementation::createDebugMesh(this, shape->shape());
 }
 
 template<UnsignedInt dimensions> ShapeRenderer<dimensions>::~ShapeRenderer() {

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.
+         * @p shape must be available for the whole lifetime of the renderer
-         *
+         * and if it is group, it must not change its internal structure.
-         * @attention Passed object must have assigned shape.
          */
-        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();