DebugTools: preparation for ability to render also solid shapes.

src/DebugTools/Implementation/AbstractBoxRenderer.cpp

@@ -32,11 +32,11 @@
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
 AbstractBoxRenderer<2>::AbstractBoxRenderer(): AbstractShapeRenderer<2>("box2d", "box2d-vertices", {}) {
-    if(!mesh) this->createResources(Primitives::Square::wireframe());
+    if(!wireframeMesh) this->createResources(Primitives::Square::wireframe());
 }
 
 AbstractBoxRenderer<3>::AbstractBoxRenderer(): AbstractShapeRenderer<3>("box3d", "box3d-vertices", "box3d-indices") {
-    if(!mesh) this->createResources(Primitives::Cube::wireframe());
+    if(!wireframeMesh) this->createResources(Primitives::Cube::wireframe());
 }
 
 template class AbstractBoxRenderer<2>;

src/DebugTools/Implementation/AbstractShapeRenderer.cpp

@@ -90,19 +90,19 @@ template<> void create<3>(Trade::MeshData3D& data, Resource<Mesh>& meshResource,
 }
 
 template<UnsignedInt dimensions> AbstractShapeRenderer<dimensions>::AbstractShapeRenderer(ResourceKey meshKey, ResourceKey vertexBufferKey, ResourceKey indexBufferKey) {
-    shader = ResourceManager::instance()->get<AbstractShaderProgram, Shaders::FlatShader<dimensions>>(shaderKey<dimensions>());
-    mesh = ResourceManager::instance()->get<Mesh>(meshKey);
+    wireframeShader = ResourceManager::instance()->get<AbstractShaderProgram, Shaders::FlatShader<dimensions>>(shaderKey<dimensions>());
+    wireframeMesh = ResourceManager::instance()->get<Mesh>(meshKey);
     vertexBuffer = ResourceManager::instance()->get<Buffer>(vertexBufferKey);
     indexBuffer = ResourceManager::instance()->get<Buffer>(indexBufferKey);
 
-    if(!shader) ResourceManager::instance()->set<AbstractShaderProgram>(shaderKey<dimensions>(),
+    if(!wireframeShader) ResourceManager::instance()->set<AbstractShaderProgram>(shaderKey<dimensions>(),
         new Shaders::FlatShader<dimensions>, ResourceDataState::Final, ResourcePolicy::Resident);
 }
 
 template<UnsignedInt dimensions> AbstractShapeRenderer<dimensions>::~AbstractShapeRenderer() {}
 
 template<UnsignedInt dimensions> void AbstractShapeRenderer<dimensions>::createResources(typename MeshData<dimensions>::Type data) {
-    create<dimensions>(data, this->mesh, this->vertexBuffer, this->indexBuffer);
+    create<dimensions>(data, this->wireframeMesh, this->vertexBuffer, this->indexBuffer);
 }
 
 template class AbstractShapeRenderer<2>;

src/DebugTools/Implementation/AbstractShapeRenderer.h

@@ -49,8 +49,8 @@ template<UnsignedInt dimensions> class AbstractShapeRenderer {
         /* Call only if the mesh resource isn't already present */
         void createResources(typename MeshData<dimensions>::Type data);
 
-        Resource<AbstractShaderProgram, Shaders::FlatShader<dimensions>> shader;
-        Resource<Mesh> mesh;
+        Resource<AbstractShaderProgram, Shaders::FlatShader<dimensions>> wireframeShader;
+        Resource<Mesh> wireframeMesh;
 
     private:
         Resource<Buffer> indexBuffer, vertexBuffer;

src/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp

@@ -34,12 +34,12 @@ namespace Magnum { namespace DebugTools { namespace Implementation {
 template<UnsignedInt dimensions> AxisAlignedBoxRenderer<dimensions>::AxisAlignedBoxRenderer(Physics::AxisAlignedBox<dimensions>& axisAlignedBox): axisAlignedBox(axisAlignedBox) {}
 
 template<UnsignedInt dimensions> void AxisAlignedBoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) {
-    this->shader->setTransformationProjectionMatrix(projectionMatrix*
+    this->wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
         DimensionTraits<dimensions>::MatrixType::translation((axisAlignedBox.transformedMin()+axisAlignedBox.transformedMax())/2)*
         DimensionTraits<dimensions>::MatrixType::scaling(axisAlignedBox.transformedMax()-axisAlignedBox.transformedMin()))
         ->setColor(options->color())
         ->use();
-    this->mesh->draw();
+    this->wireframeMesh->draw();
 }
 
 template class AxisAlignedBoxRenderer<2>;

src/DebugTools/Implementation/BoxRenderer.cpp

@@ -34,10 +34,10 @@ namespace Magnum { namespace DebugTools { namespace Implementation {
 template<UnsignedInt dimensions> BoxRenderer<dimensions>::BoxRenderer(Physics::Box<dimensions>& box): box(box) {}
 
 template<UnsignedInt dimensions> void BoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) {
-    this->shader->setTransformationProjectionMatrix(projectionMatrix*box.transformedTransformation())
+    this->wireframeShader->setTransformationProjectionMatrix(projectionMatrix*box.transformedTransformation())
         ->setColor(options->color())
         ->use();
-    this->mesh->draw();
+    this->wireframeMesh->draw();
 }
 
 template class BoxRenderer<2>;

src/DebugTools/Implementation/LineSegmentRenderer.cpp

@@ -51,15 +51,15 @@ namespace {
 }
 
 template<UnsignedInt dimensions> LineSegmentRenderer<dimensions>::LineSegmentRenderer(Physics::Line<dimensions>& line): AbstractShapeRenderer<dimensions>(meshKey<dimensions>(), vertexBufferKey<dimensions>(), {}), line(line) {
-    if(!this->mesh) this->createResources(meshData<dimensions>());
+    if(!this->wireframeMesh) this->createResources(meshData<dimensions>());
 }
 
 template<UnsignedInt dimensions> void LineSegmentRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) {
-    this->shader->setTransformationProjectionMatrix(projectionMatrix*
+    this->wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
         Implementation::lineSegmentRendererTransformation<dimensions>(line.transformedA(), line.transformedB()))
         ->setColor(options->color())
         ->use();
-    this->mesh->draw();
+    this->wireframeMesh->draw();
 }
 
 template class LineSegmentRenderer<2>;

src/DebugTools/Implementation/PointRenderer.cpp

@@ -49,17 +49,17 @@ namespace {
 }
 
 template<UnsignedInt dimensions> PointRenderer<dimensions>::PointRenderer(Physics::Point<dimensions>& point): AbstractShapeRenderer<dimensions>(meshKey<dimensions>(), vertexBufferKey<dimensions>(), {}), point(point) {
-    if(!this->mesh) this->createResources(meshData<dimensions>());
+    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->shader->setTransformationProjectionMatrix(projectionMatrix*
+    this->wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
         DimensionTraits<dimensions>::MatrixType::translation(point.transformedPosition())*
         DimensionTraits<dimensions>::MatrixType::scaling(typename DimensionTraits<dimensions>::VectorType(options->pointSize()/2)))
         ->setColor(options->color())
         ->use();
-    this->mesh->draw();
+    this->wireframeMesh->draw();
 }
 
 template class PointRenderer<2>;

src/DebugTools/Implementation/SphereRenderer.cpp

@@ -34,18 +34,18 @@
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
 AbstractSphereRenderer<2>::AbstractSphereRenderer(): AbstractShapeRenderer<2>("sphere2d", "sphere2d-vertices", {}) {
-    if(!mesh) this->createResources(Primitives::Circle::wireframe(40));
+    if(!wireframeMesh) createResources(Primitives::Circle::wireframe(40));
 }
 
 template<UnsignedInt dimensions> SphereRenderer<dimensions>::SphereRenderer(Physics::Sphere<dimensions>& sphere): sphere(sphere) {}
 
 template<UnsignedInt dimensions> void SphereRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) {
-    this->shader->setTransformationProjectionMatrix(projectionMatrix*
+    this->wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
         DimensionTraits<dimensions>::MatrixType::translation(sphere.transformedPosition())*
         DimensionTraits<dimensions>::MatrixType::scaling(typename DimensionTraits<dimensions>::VectorType(sphere.transformedRadius())))
         ->setColor(options->color())
         ->use();
-    this->mesh->draw();
+    this->wireframeMesh->draw();
 }
 
 template class SphereRenderer<2>;

src/DebugTools/ShapeRenderer.h

@@ -57,7 +57,31 @@ See ShapeRenderer documentation for more information.
 */
 class ShapeRendererOptions {
     public:
-        inline constexpr ShapeRendererOptions(): _color(1.0f), _pointSize(0.25f) {}
+        /**
+         * @brief Shape rendering mode
+         *
+         * @see setRenderMode()
+         */
+        enum class RenderMode: UnsignedByte {
+            Wireframe,
+            Solid
+        };
+
+        inline constexpr ShapeRendererOptions(): _color(1.0f), _pointSize(0.25f), _renderMode(RenderMode::Wireframe) {}
+
+        /** @brief Shape rendering mode */
+        inline constexpr RenderMode renderMode() const { return _renderMode; }
+
+        /**
+         * @brief Set shape rendering mode
+         * @return Pointer to self (for method chaining)
+         *
+         * Default is @ref RenderMode "RenderMode::Wireframe".
+         */
+        inline ShapeRendererOptions* setRenderMode(RenderMode mode) {
+            _renderMode = mode;
+            return this;
+        }
 
         /** @brief Color of rendered shape */
         inline constexpr Color4<> color() const { return _color; }
@@ -91,6 +115,7 @@ class ShapeRendererOptions {
     private:
         Color4<> _color;
         Float _pointSize;
+        RenderMode _renderMode;
 };
 
 /**