DebugTools: common mesh building implementation for all shape renderers.

src/DebugTools/Implementation/AbstractBoxRenderer.cpp

@@ -15,73 +15,22 @@
 
 #include "AbstractBoxRenderer.h"
 
-#include "Buffer.h"
-#include "DebugTools/ResourceManager.h"
-#include "MeshTools/CompressIndices.h"
 #include "Primitives/Cube.h"
 #include "Primitives/Square.h"
-#include "Shaders/FlatShader.h"
 #include "Trade/MeshData2D.h"
 #include "Trade/MeshData3D.h"
 
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
-AbstractBoxRenderer<2>::AbstractBoxRenderer() {
-    /* Shader */
-    shader = ResourceManager::instance()->get<AbstractShaderProgram, Shaders::FlatShader2D>("FlatShader2D");
-    if(!shader) ResourceManager::instance()->set<AbstractShaderProgram>(shader.key(),
-        new Shaders::FlatShader2D, ResourceDataState::Final, ResourcePolicy::Resident);
-
-    /* Mesh and vertex buffer */
-    mesh = ResourceManager::instance()->get<Mesh>("box2d");
-    buffer = ResourceManager::instance()->get<Buffer>("box2d");
-    if(mesh) return;
-
-    /* Create the mesh */
-    Trade::MeshData2D square = Primitives::Square::wireframe();
-    Buffer* buffer = new Buffer(Buffer::Target::Array);
-    Mesh* mesh = new Mesh;
-
-    buffer->setData(*square.positions(0), Buffer::Usage::StaticDraw);
-    ResourceManager::instance()->set(this->buffer.key(), buffer, ResourceDataState::Final, ResourcePolicy::Manual);
-
-    mesh->setPrimitive(square.primitive())
-        ->setVertexCount(square.positions(0)->size())
-        ->addVertexBuffer(buffer, 0, Shaders::FlatShader2D::Position());
-    ResourceManager::instance()->set(this->mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
+AbstractBoxRenderer<2>::AbstractBoxRenderer(): AbstractShapeRenderer<2>("box2d", "box2d-vertices", "box2d-indices") {
+    if(!mesh) this->createResources(Primitives::Square::wireframe());
 }
 
-AbstractBoxRenderer<3>::AbstractBoxRenderer() {
-    /* Shader */
-    shader = ResourceManager::instance()->get<AbstractShaderProgram, Shaders::FlatShader3D>("FlatShader3D");
-    if(!shader) ResourceManager::instance()->set<AbstractShaderProgram>(shader.key(),
-        new Shaders::FlatShader3D, ResourceDataState::Final, ResourcePolicy::Resident);
-
-    /* Mesh and vertex buffer */
-    mesh = ResourceManager::instance()->get<Mesh>("box3d");
-    vertexBuffer = ResourceManager::instance()->get<Buffer>("box3d-vertices");
-    indexBuffer = ResourceManager::instance()->get<Buffer>("box3d-indices");
-    if(mesh) return;
-
-    /* Create the mesh */
-    Trade::MeshData3D cube = Primitives::Cube::wireframe();
-    Buffer* vertexBuffer = new Buffer(Buffer::Target::Array);
-    Buffer* indexBuffer = new Buffer(Buffer::Target::ElementArray);
-    Mesh* mesh = new Mesh;
-
-    vertexBuffer->setData(*cube.positions(0), Buffer::Usage::StaticDraw);
-    ResourceManager::instance()->set(this->vertexBuffer.key(), vertexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
-
-    MeshTools::compressIndices(mesh, indexBuffer, Buffer::Usage::StaticDraw, *cube.indices());
-    ResourceManager::instance()->set(this->indexBuffer.key(), indexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
-
-    mesh->setPrimitive(cube.primitive())
-        ->setVertexCount(cube.positions(0)->size())
-        ->addVertexBuffer(vertexBuffer, 0, Shaders::FlatShader3D::Position());
-    ResourceManager::instance()->set<Mesh>(this->mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
+AbstractBoxRenderer<3>::AbstractBoxRenderer(): AbstractShapeRenderer<3>("box3d", "box3d-vertices", "box3d-indices") {
+    if(!mesh) this->createResources(Primitives::Cube::wireframe());
 }
 
-AbstractBoxRenderer<2>::~AbstractBoxRenderer() {}
-AbstractBoxRenderer<3>::~AbstractBoxRenderer() {}
+template class AbstractBoxRenderer<2>;
+template class AbstractBoxRenderer<3>;
 
 }}}

src/DebugTools/Implementation/AbstractBoxRenderer.h

@@ -24,30 +24,16 @@
 
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
-template<std::uint8_t dimensions> class AbstractBoxRenderer {};
+template<std::uint8_t dimensions> class AbstractBoxRenderer;
 
 template<> class AbstractBoxRenderer<2>: public AbstractShapeRenderer<2> {
     public:
         AbstractBoxRenderer();
-
-        ~AbstractBoxRenderer();
-
-    protected:
-        Resource<Mesh> mesh;
-        Resource<AbstractShaderProgram, Shaders::FlatShader2D> shader;
-        Resource<Buffer> buffer;
 };
 
 template<> class AbstractBoxRenderer<3>: public AbstractShapeRenderer<3> {
     public:
         AbstractBoxRenderer();
-
-        ~AbstractBoxRenderer();
-
-    protected:
-        Resource<Mesh> mesh;
-        Resource<AbstractShaderProgram, Shaders::FlatShader3D> shader;
-        Resource<Buffer> vertexBuffer, indexBuffer;
 };
 
 }}}

src/DebugTools/Implementation/AbstractShapeRenderer.cpp

@@ -16,14 +16,84 @@
 #include "AbstractShapeRenderer.h"
 
 #include "AbstractShaderProgram.h"
+#include "Buffer.h"
 #include "Mesh.h"
 #include "DebugTools/ResourceManager.h"
+#include "MeshTools/CompressIndices.h"
 #include "Shaders/FlatShader.h"
+#include "Trade/MeshData2D.h"
+#include "Trade/MeshData3D.h"
 
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
+namespace {
+
+template<std::uint8_t dimensions> ResourceKey shaderName();
+template<> inline ResourceKey shaderName<2>() { return ResourceKey("FlatShader2D"); }
+template<> inline ResourceKey shaderName<3>() { return ResourceKey("FlatShader3D"); }
+
+template<std::uint8_t dimensions> void create(typename MeshData<dimensions>::Type&, Resource<Mesh>&, Resource<Buffer>&, Resource<Buffer>&);
+
+template<> void create<2>(Trade::MeshData2D& data, Resource<Mesh>& meshResource, Resource<Buffer>& indexBufferResource, Resource<Buffer>& vertexBufferResource) {
+    /* Vertex buffer */
+    Buffer* buffer = new Buffer(Buffer::Target::Array);
+    buffer->setData(*data.positions(0), Buffer::Usage::StaticDraw);
+    ResourceManager::instance()->set(vertexBufferResource.key(), buffer, ResourceDataState::Final, ResourcePolicy::Manual);
+
+    /* Mesh configuration */
+    Mesh* mesh = new Mesh;
+    mesh->setPrimitive(data.primitive())
+        ->setVertexCount(data.positions(0)->size())
+        ->addVertexBuffer(buffer, 0, Shaders::FlatShader2D::Position());
+    ResourceManager::instance()->set(meshResource.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
+
+    /* Index buffer, if present */
+    if(data.indices()) {
+        Buffer* indexBuffer = new Buffer(Buffer::Target::ElementArray);
+        MeshTools::compressIndices(mesh, indexBuffer, Buffer::Usage::StaticDraw, *data.indices());
+        ResourceManager::instance()->set(indexBufferResource.key(), indexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
+    }
+}
+
+template<> void create<3>(Trade::MeshData3D& data, Resource<Mesh>& meshResource, Resource<Buffer>& indexBufferResource, Resource<Buffer>& vertexBufferResource) {
+    /* Vertex buffer */
+    Buffer* vertexBuffer = new Buffer(Buffer::Target::Array);
+    vertexBuffer->setData(*data.positions(0), Buffer::Usage::StaticDraw);
+    ResourceManager::instance()->set(vertexBufferResource.key(), vertexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
+
+    /* Mesh configuration */
+    Mesh* mesh = new Mesh;
+    mesh->setPrimitive(data.primitive())
+        ->setVertexCount(data.positions(0)->size())
+        ->addVertexBuffer(vertexBuffer, 0, Shaders::FlatShader3D::Position());
+    ResourceManager::instance()->set(meshResource.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
+
+    /* Index buffer, if needed */
+    if(data.indices()) {
+        Buffer* indexBuffer = new Buffer(Buffer::Target::ElementArray);
+        MeshTools::compressIndices(mesh, indexBuffer, Buffer::Usage::StaticDraw, *data.indices());
+        ResourceManager::instance()->set(indexBufferResource.key(), indexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
+    }
+}
+
+}
+
+template<std::uint8_t dimensions> AbstractShapeRenderer<dimensions>::AbstractShapeRenderer(ResourceKey meshKey, ResourceKey vertexBufferKey, ResourceKey indexBufferKey) {
+    shader = ResourceManager::instance()->get<AbstractShaderProgram, Shaders::FlatShader<dimensions>>(shaderName<dimensions>());
+    mesh = ResourceManager::instance()->get<Mesh>(meshKey);
+    vertexBuffer = ResourceManager::instance()->get<Buffer>(vertexBufferKey);
+    indexBuffer = ResourceManager::instance()->get<Buffer>(indexBufferKey);
+
+    if(!shader) ResourceManager::instance()->set<AbstractShaderProgram>(shaderName<dimensions>(),
+        new Shaders::FlatShader<dimensions>, ResourceDataState::Final, ResourcePolicy::Resident);
+}
+
 template<std::uint8_t dimensions> AbstractShapeRenderer<dimensions>::~AbstractShapeRenderer() {}
 
+template<std::uint8_t dimensions> void AbstractShapeRenderer<dimensions>::createResources(typename MeshData<dimensions>::Type data) {
+    create<dimensions>(data, this->mesh, this->vertexBuffer, this->indexBuffer);
+}
+
 template class AbstractShapeRenderer<2>;
 template class AbstractShapeRenderer<3>;
 

src/DebugTools/Implementation/AbstractShapeRenderer.h

@@ -16,16 +16,35 @@
 */
 
 #include "DimensionTraits.h"
-#include "SceneGraph/SceneGraph.h"
+#include "Resource.h"
 #include "DebugTools/DebugTools.h"
+#include "SceneGraph/SceneGraph.h"
+#include "Shaders/Shaders.h"
+#include "Trade/Trade.h"
 
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
+template<std::uint8_t dimensions> struct MeshData;
+
+template<> struct MeshData<2> { typedef Trade::MeshData2D Type; };
+template<> struct MeshData<3> { typedef Trade::MeshData3D Type; };
+
 template<std::uint8_t dimensions> class AbstractShapeRenderer {
     public:
+        AbstractShapeRenderer(ResourceKey mesh, ResourceKey vertexBuffer, ResourceKey indexBuffer);
         virtual ~AbstractShapeRenderer();
 
         virtual void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions>* camera) = 0;
+
+    protected:
+        /* 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;
+
+    private:
+        Resource<Buffer> indexBuffer, vertexBuffer;
 };
 
 }}}

src/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp

@@ -23,6 +23,8 @@
 
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
+template<std::uint8_t dimensions> AxisAlignedBoxRenderer<dimensions>::AxisAlignedBoxRenderer(Physics::AxisAlignedBox<dimensions>& axisAlignedBox): axisAlignedBox(axisAlignedBox) {}
+
 template<std::uint8_t dimensions> void AxisAlignedBoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType&, typename SceneGraph::AbstractCamera<dimensions>* camera) {
     /* Half scale, because the box is 2x2(x2) */
     typename DimensionTraits<dimensions>::MatrixType transformation =

src/DebugTools/Implementation/AxisAlignedBoxRenderer.h

@@ -25,7 +25,7 @@ namespace Magnum { namespace DebugTools { namespace Implementation {
 
 template<std::uint8_t dimensions> class AxisAlignedBoxRenderer: public AbstractBoxRenderer<dimensions> {
     public:
-        inline AxisAlignedBoxRenderer(Physics::AxisAlignedBox<dimensions>& axisAlignedBox): axisAlignedBox(axisAlignedBox) {}
+        AxisAlignedBoxRenderer(Physics::AxisAlignedBox<dimensions>& axisAlignedBox);
 
         void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& transformation, typename SceneGraph::AbstractCamera<dimensions>* camera) override;
 

src/DebugTools/Implementation/BoxRenderer.cpp

@@ -23,6 +23,8 @@
 
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
+template<std::uint8_t dimensions> BoxRenderer<dimensions>::BoxRenderer(Physics::Box<dimensions>& box): box(box) {}
+
 template<std::uint8_t dimensions> void BoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType&, typename SceneGraph::AbstractCamera<dimensions>* camera) {
     this->shader->setTransformationProjectionMatrix(camera->projectionMatrix()*camera->cameraMatrix()*box.transformedTransformation()*
         DimensionTraits<dimensions>::MatrixType::scaling(typename DimensionTraits<dimensions>::VectorType(0.5f)))

src/DebugTools/Implementation/BoxRenderer.h

@@ -25,7 +25,7 @@ namespace Magnum { namespace DebugTools { namespace Implementation {
 
 template<std::uint8_t dimensions> class BoxRenderer: public AbstractBoxRenderer<dimensions> {
     public:
-        inline BoxRenderer(Physics::Box<dimensions>& box): box(box) {}
+        BoxRenderer(Physics::Box<dimensions>& box);
 
         void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& transformation, typename SceneGraph::AbstractCamera<dimensions>* camera) override;