ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

DebugTools: prefix private member variables with underscore. 

Fixes MSVC 2015 variable shadowing warnings. Fortunately no bug caused
by these.
pull/110/head
Vladimír Vondruš 11 years ago
parent
2e778f235b
commit
8b6ff33476
8 changed files with 98 additions and 98 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 30
      src/Magnum/DebugTools/ForceRenderer.cpp
  2. 12
      src/Magnum/DebugTools/ForceRenderer.h
  3. 24
      src/Magnum/DebugTools/ObjectRenderer.cpp
  4. 8
      src/Magnum/DebugTools/ObjectRenderer.h
  5. 66
      src/Magnum/DebugTools/Profiler.cpp
  6. 18
      src/Magnum/DebugTools/Profiler.h
  7. 34
      src/Magnum/DebugTools/ShapeRenderer.cpp
  8. 4
      src/Magnum/DebugTools/ShapeRenderer.h

30
src/Magnum/DebugTools/ForceRenderer.cpp
Unescape View File

@ -56,26 +56,26 @@ constexpr std::array<UnsignedByte, 6> indices{{
} }
template<UnsignedInt dimensions> ForceRenderer<dimensions>::ForceRenderer(SceneGraph::AbstractObject<dimensions, Float>& object, const VectorTypeFor<dimensions, Float>& forcePosition, const VectorTypeFor<dimensions, Float>& force, ResourceKey options, SceneGraph::DrawableGroup<dimensions, Float>* drawables): SceneGraph::Drawable<dimensions, Float>(object, drawables), forcePosition(forcePosition), force(force), options(ResourceManager::instance().get<ForceRendererOptions>(options)) { template<UnsignedInt dimensions> ForceRenderer<dimensions>::ForceRenderer(SceneGraph::AbstractObject<dimensions, Float>& object, const VectorTypeFor<dimensions, Float>& forcePosition, const VectorTypeFor<dimensions, Float>& force, ResourceKey options, SceneGraph::DrawableGroup<dimensions, Float>* drawables): SceneGraph::Drawable<dimensions, Float>(object, drawables), _forcePosition(forcePosition), _force(force), _options(ResourceManager::instance().get<ForceRendererOptions>(options)) {
/* Shader */ /* Shader */
shader = ResourceManager::instance().get<AbstractShaderProgram, Shaders::Flat<dimensions>>(shaderKey<dimensions>()); _shader = ResourceManager::instance().get<AbstractShaderProgram, Shaders::Flat<dimensions>>(shaderKey<dimensions>());
if(!shader) ResourceManager::instance().set<AbstractShaderProgram>(shader.key(), new Shaders::Flat<dimensions>); if(!_shader) ResourceManager::instance().set<AbstractShaderProgram>(_shader.key(), new Shaders::Flat<dimensions>);
/* Mesh and vertex buffer */ /* Mesh and vertex buffer */
mesh = ResourceManager::instance().get<Mesh>("force"); _mesh = ResourceManager::instance().get<Mesh>("force");
vertexBuffer = ResourceManager::instance().get<Buffer>("force-vertices"); _vertexBuffer = ResourceManager::instance().get<Buffer>("force-vertices");
indexBuffer = ResourceManager::instance().get<Buffer>("force-indices"); _indexBuffer = ResourceManager::instance().get<Buffer>("force-indices");
if(mesh) return; if(_mesh) return;
/* Create the mesh */ /* Create the mesh */
Buffer* vertexBuffer = new Buffer{Buffer::TargetHint::Array}; Buffer* vertexBuffer = new Buffer{Buffer::TargetHint::Array};
Buffer* indexBuffer = new Buffer{Buffer::TargetHint::ElementArray}; Buffer* indexBuffer = new Buffer{Buffer::TargetHint::ElementArray};
vertexBuffer->setData(positions, BufferUsage::StaticDraw); _vertexBuffer->setData(positions, BufferUsage::StaticDraw);
ResourceManager::instance().set(this->vertexBuffer.key(), vertexBuffer, ResourceDataState::Final, ResourcePolicy::Manual); ResourceManager::instance().set(_vertexBuffer.key(), vertexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
indexBuffer->setData(indices, BufferUsage::StaticDraw); _indexBuffer->setData(indices, BufferUsage::StaticDraw);
ResourceManager::instance().set(this->indexBuffer.key(), indexBuffer, ResourceDataState::Final, ResourcePolicy::Manual); ResourceManager::instance().set(_indexBuffer.key(), indexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
Mesh* mesh = new Mesh; Mesh* mesh = new Mesh;
mesh->setPrimitive(MeshPrimitive::Lines) mesh->setPrimitive(MeshPrimitive::Lines)
@ -83,16 +83,16 @@ template<UnsignedInt dimensions> ForceRenderer<dimensions>::ForceRenderer(SceneG
.addVertexBuffer(*vertexBuffer, 0, .addVertexBuffer(*vertexBuffer, 0,
typename Shaders::Flat<dimensions>::Position(Shaders::Flat<dimensions>::Position::Components::Two)) typename Shaders::Flat<dimensions>::Position(Shaders::Flat<dimensions>::Position::Components::Two))
.setIndexBuffer(*indexBuffer, 0, Mesh::IndexType::UnsignedByte, 0, positions.size()); .setIndexBuffer(*indexBuffer, 0, Mesh::IndexType::UnsignedByte, 0, positions.size());
ResourceManager::instance().set(this->mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual); ResourceManager::instance().set(_mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
} }
/* To avoid deleting pointers to incomplete type on destruction of Resource members */ /* To avoid deleting pointers to incomplete type on destruction of Resource members */
template<UnsignedInt dimensions> ForceRenderer<dimensions>::~ForceRenderer() = default; template<UnsignedInt dimensions> ForceRenderer<dimensions>::~ForceRenderer() = default;
template<UnsignedInt dimensions> void ForceRenderer<dimensions>::draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::Camera<dimensions, Float>& camera) { template<UnsignedInt dimensions> void ForceRenderer<dimensions>::draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::Camera<dimensions, Float>& camera) {
shader->setTransformationProjectionMatrix(camera.projectionMatrix()*Implementation::forceRendererTransformation<dimensions>(transformationMatrix.transformPoint(forcePosition), force)*MatrixTypeFor<dimensions, Float>::scaling(VectorTypeFor<dimensions, Float>{options->scale()})) _shader->setTransformationProjectionMatrix(camera.projectionMatrix()*Implementation::forceRendererTransformation<dimensions>(transformationMatrix.transformPoint(_forcePosition), _force)*MatrixTypeFor<dimensions, Float>::scaling(VectorTypeFor<dimensions, Float>{_options->scale()}))
.setColor(options->color()); .setColor(_options->color());
mesh->draw(*shader); _mesh->draw(*_shader);
} }
template class ForceRenderer<2>; template class ForceRenderer<2>;

12
src/Magnum/DebugTools/ForceRenderer.h
Unescape View File

@ -131,13 +131,13 @@ template<UnsignedInt dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ForceRenderer: p
private: private:
void draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::Camera<dimensions, Float>& camera) override; void draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::Camera<dimensions, Float>& camera) override;
const VectorTypeFor<dimensions, Float> forcePosition; const VectorTypeFor<dimensions, Float> _forcePosition;
const VectorTypeFor<dimensions, Float>& force; const VectorTypeFor<dimensions, Float>& _force;
Resource<ForceRendererOptions> options; Resource<ForceRendererOptions> _options;
Resource<AbstractShaderProgram, Shaders::Flat<dimensions>> shader; Resource<AbstractShaderProgram, Shaders::Flat<dimensions>> _shader;
Resource<Mesh> mesh; Resource<Mesh> _mesh;
Resource<Buffer> vertexBuffer, indexBuffer; Resource<Buffer> _vertexBuffer, _indexBuffer;
}; };
/** @brief Two-dimensional force renderer */ /** @brief Two-dimensional force renderer */

24
src/Magnum/DebugTools/ObjectRenderer.cpp
Unescape View File

@ -144,16 +144,16 @@ const std::array<UnsignedByte, 18> Renderer<3>::indices{{
} }
template<UnsignedInt dimensions> ObjectRenderer<dimensions>::ObjectRenderer(SceneGraph::AbstractObject<dimensions, Float>& object, ResourceKey options, SceneGraph::DrawableGroup<dimensions, Float>* drawables): SceneGraph::Drawable<dimensions, Float>(object, drawables), options(ResourceManager::instance().get<ObjectRendererOptions>(options)) { template<UnsignedInt dimensions> ObjectRenderer<dimensions>::ObjectRenderer(SceneGraph::AbstractObject<dimensions, Float>& object, ResourceKey options, SceneGraph::DrawableGroup<dimensions, Float>* drawables): SceneGraph::Drawable<dimensions, Float>{object, drawables}, _options{ResourceManager::instance().get<ObjectRendererOptions>(options)} {
/* Shader */ /* Shader */
shader = ResourceManager::instance().get<AbstractShaderProgram, Shaders::VertexColor<dimensions>>(Renderer<dimensions>::shader()); _shader = ResourceManager::instance().get<AbstractShaderProgram, Shaders::VertexColor<dimensions>>(Renderer<dimensions>::shader());
if(!shader) ResourceManager::instance().set<AbstractShaderProgram>(shader.key(), new Shaders::VertexColor<dimensions>); if(!_shader) ResourceManager::instance().set<AbstractShaderProgram>(_shader.key(), new Shaders::VertexColor<dimensions>);
/* Mesh and vertex buffer */ /* Mesh and vertex buffer */
mesh = ResourceManager::instance().get<Mesh>(Renderer<dimensions>::mesh()); _mesh = ResourceManager::instance().get<Mesh>(Renderer<dimensions>::mesh());
vertexBuffer = ResourceManager::instance().get<Buffer>(Renderer<dimensions>::vertexBuffer()); _vertexBuffer = ResourceManager::instance().get<Buffer>(Renderer<dimensions>::vertexBuffer());
indexBuffer = ResourceManager::instance().get<Buffer>(Renderer<dimensions>::indexBuffer()); _indexBuffer = ResourceManager::instance().get<Buffer>(Renderer<dimensions>::indexBuffer());
if(mesh) return; if(_mesh) return;
/* Create the mesh */ /* Create the mesh */
Buffer* vertexBuffer = new Buffer{Buffer::TargetHint::Array}; Buffer* vertexBuffer = new Buffer{Buffer::TargetHint::Array};
@ -161,10 +161,10 @@ template<UnsignedInt dimensions> ObjectRenderer<dimensions>::ObjectRenderer(Scen
Mesh* mesh = new Mesh; Mesh* mesh = new Mesh;
vertexBuffer->setData(MeshTools::interleave(Renderer<dimensions>::positions, Renderer<dimensions>::colors), BufferUsage::StaticDraw); vertexBuffer->setData(MeshTools::interleave(Renderer<dimensions>::positions, Renderer<dimensions>::colors), BufferUsage::StaticDraw);
ResourceManager::instance().set(this->vertexBuffer.key(), vertexBuffer, ResourceDataState::Final, ResourcePolicy::Manual); ResourceManager::instance().set(_vertexBuffer.key(), vertexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
indexBuffer->setData(Renderer<dimensions>::indices, BufferUsage::StaticDraw); indexBuffer->setData(Renderer<dimensions>::indices, BufferUsage::StaticDraw);
ResourceManager::instance().set(this->indexBuffer.key(), indexBuffer, ResourceDataState::Final, ResourcePolicy::Manual); ResourceManager::instance().set(_indexBuffer.key(), indexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
mesh->setPrimitive(MeshPrimitive::Lines) mesh->setPrimitive(MeshPrimitive::Lines)
.setCount(Renderer<dimensions>::indices.size()) .setCount(Renderer<dimensions>::indices.size())
@ -172,15 +172,15 @@ template<UnsignedInt dimensions> ObjectRenderer<dimensions>::ObjectRenderer(Scen
typename Shaders::VertexColor<dimensions>::Position(), typename Shaders::VertexColor<dimensions>::Position(),
typename Shaders::VertexColor<dimensions>::Color()) typename Shaders::VertexColor<dimensions>::Color())
.setIndexBuffer(*indexBuffer, 0, Mesh::IndexType::UnsignedByte, 0, Renderer<dimensions>::positions.size()); .setIndexBuffer(*indexBuffer, 0, Mesh::IndexType::UnsignedByte, 0, Renderer<dimensions>::positions.size());
ResourceManager::instance().set<Mesh>(this->mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual); ResourceManager::instance().set<Mesh>(_mesh.key(), _mesh, ResourceDataState::Final, ResourcePolicy::Manual);
} }
/* To avoid deleting pointers to incomplete type on destruction of Resource members */ /* To avoid deleting pointers to incomplete type on destruction of Resource members */
template<UnsignedInt dimensions> ObjectRenderer<dimensions>::~ObjectRenderer() = default; template<UnsignedInt dimensions> ObjectRenderer<dimensions>::~ObjectRenderer() = default;
template<UnsignedInt dimensions> void ObjectRenderer<dimensions>::draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::Camera<dimensions, Float>& camera) { template<UnsignedInt dimensions> void ObjectRenderer<dimensions>::draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::Camera<dimensions, Float>& camera) {
shader->setTransformationProjectionMatrix(camera.projectionMatrix()*transformationMatrix*MatrixTypeFor<dimensions, Float>::scaling(VectorTypeFor<dimensions, Float>{options->size()})); _shader->setTransformationProjectionMatrix(camera.projectionMatrix()*transformationMatrix*MatrixTypeFor<dimensions, Float>::scaling(VectorTypeFor<dimensions, Float>{_options->size()}));
mesh->draw(*shader); _mesh->draw(*_shader);
} }
template class ObjectRenderer<2>; template class ObjectRenderer<2>;

8
src/Magnum/DebugTools/ObjectRenderer.h
Unescape View File

@ -103,10 +103,10 @@ template<UnsignedInt dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ObjectRenderer:
private: private:
void draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::Camera<dimensions, Float>& camera) override; void draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::Camera<dimensions, Float>& camera) override;
Resource<ObjectRendererOptions> options; Resource<ObjectRendererOptions> _options;
Resource<AbstractShaderProgram, Shaders::VertexColor<dimensions>> shader; Resource<AbstractShaderProgram, Shaders::VertexColor<dimensions>> _shader;
Resource<Mesh> mesh; Resource<Mesh> _mesh;
Resource<Buffer> vertexBuffer, indexBuffer; Resource<Buffer> _vertexBuffer, _indexBuffer;
}; };
/** @brief Two-dimensional object renderer */ /** @brief Two-dimensional object renderer */

66
src/Magnum/DebugTools/Profiler.cpp
Unescape View File

@ -37,88 +37,88 @@ using namespace std::chrono;
namespace Magnum { namespace DebugTools { namespace Magnum { namespace DebugTools {
Profiler::Section Profiler::addSection(const std::string& name) { Profiler::Section Profiler::addSection(const std::string& name) {
CORRADE_ASSERT(!enabled, "Profiler: cannot add section when profiling is enabled", 0); CORRADE_ASSERT(!_enabled, "Profiler: cannot add section when profiling is enabled", 0);
sections.push_back(name); _sections.push_back(name);
return sections.size()-1; return _sections.size()-1;
} }
void Profiler::setMeasureDuration(std::size_t frames) { void Profiler::setMeasureDuration(std::size_t frames) {
CORRADE_ASSERT(!enabled, "Profiler: cannot set measure duration when profiling is enabled", ); CORRADE_ASSERT(!_enabled, "Profiler: cannot set measure duration when profiling is enabled", );
measureDuration = frames; _measureDuration = frames;
} }
void Profiler::enable() { void Profiler::enable() {
enabled = true; _enabled = true;
frameData.assign(measureDuration*sections.size(), high_resolution_clock::duration::zero()); _frameData.assign(_measureDuration*_sections.size(), high_resolution_clock::duration::zero());
totalData.assign(sections.size(), high_resolution_clock::duration::zero()); _totalData.assign(_sections.size(), high_resolution_clock::duration::zero());
frameCount = 0; _frameCount = 0;
} }
void Profiler::disable() { void Profiler::disable() {
enabled = false; _enabled = false;
} }
void Profiler::start(Section section) { void Profiler::start(Section section) {
if(!enabled) return; if(!_enabled) return;
CORRADE_ASSERT(section < sections.size(), "Profiler: unknown section passed to start()", ); CORRADE_ASSERT(section < _sections.size(), "Profiler: unknown section passed to start()", );
save(); save();
currentSection = section; _currentSection = section;
} }
void Profiler::stop() { void Profiler::stop() {
if(!enabled) return; if(!_enabled) return;
save(); save();
previousTime = high_resolution_clock::time_point(); _previousTime = high_resolution_clock::time_point();
} }
void Profiler::save() { void Profiler::save() {
auto now = high_resolution_clock::now(); auto now = high_resolution_clock::now();
/* If the profiler is already running, add time to given section */ /* If the profiler is already running, add time to given section */
if(previousTime != high_resolution_clock::time_point()) if(_previousTime != high_resolution_clock::time_point())
frameData[currentFrame*sections.size()+currentSection] += now-previousTime; _frameData[_currentFrame*_sections.size()+_currentSection] += now-_previousTime;
/* Set current time as previous for next section */ /* Set current time as previous for next section */
previousTime = now; _previousTime = now;
} }
void Profiler::nextFrame() { void Profiler::nextFrame() {
if(!enabled) return; if(!_enabled) return;
/* Next frame index */ /* Next frame index */
std::size_t nextFrame = (currentFrame+1) % measureDuration; std::size_t nextFrame = (_currentFrame+1) % _measureDuration;
/* Add times of current frame to total */ /* Add times of current frame to total */
for(std::size_t i = 0; i != sections.size(); ++i) for(std::size_t i = 0; i != _sections.size(); ++i)
totalData[i] += frameData[currentFrame*sections.size()+i]; _totalData[i] += _frameData[_currentFrame*_sections.size()+i];
/* Subtract times of next frame from total and erase them */ /* Subtract times of next frame from total and erase them */
for(std::size_t i = 0; i != sections.size(); ++i) { for(std::size_t i = 0; i != _sections.size(); ++i) {
totalData[i] -= frameData[nextFrame*sections.size()+i]; _totalData[i] -= _frameData[nextFrame*_sections.size()+i];
frameData[nextFrame*sections.size()+i] = high_resolution_clock::duration::zero(); _frameData[nextFrame*_sections.size()+i] = high_resolution_clock::duration::zero();
} }
/* Advance to next frame */ /* Advance to next frame */
currentFrame = nextFrame; _currentFrame = nextFrame;
if(frameCount < measureDuration) ++frameCount; if(_frameCount < _measureDuration) ++_frameCount;
} }
void Profiler::printStatistics() { void Profiler::printStatistics() {
if(!enabled) return; if(!_enabled) return;
std::vector<std::size_t> totalSorted(sections.size()); std::vector<std::size_t> totalSorted(_sections.size());
std::iota(totalSorted.begin(), totalSorted.end(), 0); std::iota(totalSorted.begin(), totalSorted.end(), 0);
std::sort(totalSorted.begin(), totalSorted.end(), [this](std::size_t i, std::size_t j){return totalData[i] > totalData[j];}); std::sort(totalSorted.begin(), totalSorted.end(), [this](std::size_t i, std::size_t j){return _totalData[i] > _totalData[j];});
Debug() << "Statistics for last" << measureDuration << "frames:"; Debug() << "Statistics for last" << _measureDuration << "frames:";
for(std::size_t i = 0; i != sections.size(); ++i) for(std::size_t i = 0; i != _sections.size(); ++i)
Debug() << " " << sections[totalSorted[i]] << duration_cast<microseconds>(totalData[totalSorted[i]]).count()/frameCount << u8"µs"; Debug() << " " << _sections[totalSorted[i]] << duration_cast<microseconds>(_totalData[totalSorted[i]]).count()/_frameCount << u8"µs";
} }
}} }}

18
src/Magnum/DebugTools/Profiler.h
Unescape View File

@ -115,7 +115,7 @@ class MAGNUM_DEBUGTOOLS_EXPORT Profiler {
*/ */
static const Section otherSection = 0; static const Section otherSection = 0;
explicit Profiler(): enabled(false), measureDuration(60), currentFrame(0), frameCount(0), sections{"Other"}, currentSection(otherSection) {} explicit Profiler(): _enabled(false), _measureDuration(60), _currentFrame(0), _frameCount(0), _sections{"Other"}, _currentSection(otherSection) {}
/** /**
* @brief Set measure duration * @brief Set measure duration
@ -140,7 +140,7 @@ class MAGNUM_DEBUGTOOLS_EXPORT Profiler {
* If the profiling is not enabled, calls to @ref start() and * If the profiling is not enabled, calls to @ref start() and
* @ref stop() have no effect. * @ref stop() have no effect.
*/ */
bool isEnabled() { return enabled; } bool isEnabled() { return _enabled; }
/** /**
* @brief Enable profiling * @brief Enable profiling
@ -201,13 +201,13 @@ class MAGNUM_DEBUGTOOLS_EXPORT Profiler {
private: private:
void save(); void save();
bool enabled; bool _enabled;
std::size_t measureDuration, currentFrame, frameCount; std::size_t _measureDuration, _currentFrame, _frameCount;
std::vector<std::string> sections; std::vector<std::string> _sections;
std::vector<std::chrono::high_resolution_clock::duration> frameData; std::vector<std::chrono::high_resolution_clock::duration> _frameData;
std::vector<std::chrono::high_resolution_clock::duration> totalData; std::vector<std::chrono::high_resolution_clock::duration> _totalData;
std::chrono::high_resolution_clock::time_point previousTime; std::chrono::high_resolution_clock::time_point _previousTime;
Section currentSection; Section _currentSection;
}; };
}} }}

34
src/Magnum/DebugTools/ShapeRenderer.cpp
Unescape View File

@ -45,26 +45,26 @@ namespace Implementation {
template<> void createDebugMesh(ShapeRenderer<2>& renderer, const Shapes::Implementation::AbstractShape<2>& shape) { template<> void createDebugMesh(ShapeRenderer<2>& renderer, const Shapes::Implementation::AbstractShape<2>& shape) {
switch(shape.type()) { switch(shape.type()) {
case Shapes::AbstractShape2D::Type::AxisAlignedBox: case Shapes::AbstractShape2D::Type::AxisAlignedBox:
renderer.renderers.push_back(new Implementation::AxisAlignedBoxRenderer<2>(shape)); renderer._renderers.push_back(new Implementation::AxisAlignedBoxRenderer<2>(shape));
break; break;
case Shapes::AbstractShape2D::Type::Box: case Shapes::AbstractShape2D::Type::Box:
renderer.renderers.push_back(new Implementation::BoxRenderer<2>(shape)); renderer._renderers.push_back(new Implementation::BoxRenderer<2>(shape));
break; break;
case Shapes::AbstractShape2D::Type::LineSegment: case Shapes::AbstractShape2D::Type::LineSegment:
renderer.renderers.push_back(new Implementation::LineSegmentRenderer<2>(shape)); renderer._renderers.push_back(new Implementation::LineSegmentRenderer<2>(shape));
break; break;
case Shapes::AbstractShape2D::Type::Point: case Shapes::AbstractShape2D::Type::Point:
renderer.renderers.push_back(new Implementation::PointRenderer<2>(shape)); renderer._renderers.push_back(new Implementation::PointRenderer<2>(shape));
break; break;
case Shapes::AbstractShape2D::Type::Sphere: case Shapes::AbstractShape2D::Type::Sphere:
case Shapes::AbstractShape2D::Type::InvertedSphere: /* Isn't publicly subclassed, but shouldn't matter */ case Shapes::AbstractShape2D::Type::InvertedSphere: /* Isn't publicly subclassed, but shouldn't matter */
renderer.renderers.push_back(new Implementation::SphereRenderer<2>(shape)); renderer._renderers.push_back(new Implementation::SphereRenderer<2>(shape));
break; break;
case Shapes::AbstractShape2D::Type::Capsule: case Shapes::AbstractShape2D::Type::Capsule:
renderer.renderers.push_back(new Implementation::CapsuleRenderer<2>(shape)); renderer._renderers.push_back(new Implementation::CapsuleRenderer<2>(shape));
break; break;
case Shapes::AbstractShape2D::Type::Cylinder: case Shapes::AbstractShape2D::Type::Cylinder:
renderer.renderers.push_back(new Implementation::CylinderRenderer<2>(shape)); renderer._renderers.push_back(new Implementation::CylinderRenderer<2>(shape));
break; break;
case Shapes::AbstractShape2D::Type::Composition: { case Shapes::AbstractShape2D::Type::Composition: {
const Shapes::Composition2D& composition = const Shapes::Composition2D& composition =
@ -80,26 +80,26 @@ template<> void createDebugMesh(ShapeRenderer<2>& renderer, const Shapes::Implem
template<> void createDebugMesh(ShapeRenderer<3>& renderer, const Shapes::Implementation::AbstractShape<3>& shape) { template<> void createDebugMesh(ShapeRenderer<3>& renderer, const Shapes::Implementation::AbstractShape<3>& shape) {
switch(shape.type()) { switch(shape.type()) {
case Shapes::AbstractShape3D::Type::AxisAlignedBox: case Shapes::AbstractShape3D::Type::AxisAlignedBox:
renderer.renderers.push_back(new Implementation::AxisAlignedBoxRenderer<3>(shape)); renderer._renderers.push_back(new Implementation::AxisAlignedBoxRenderer<3>(shape));
break; break;
case Shapes::AbstractShape3D::Type::Box: case Shapes::AbstractShape3D::Type::Box:
renderer.renderers.push_back(new Implementation::BoxRenderer<3>(shape)); renderer._renderers.push_back(new Implementation::BoxRenderer<3>(shape));
break; break;
case Shapes::AbstractShape3D::Type::LineSegment: case Shapes::AbstractShape3D::Type::LineSegment:
renderer.renderers.push_back(new Implementation::LineSegmentRenderer<3>(shape)); renderer._renderers.push_back(new Implementation::LineSegmentRenderer<3>(shape));
break; break;
case Shapes::AbstractShape3D::Type::Point: case Shapes::AbstractShape3D::Type::Point:
renderer.renderers.push_back(new Implementation::PointRenderer<3>(shape)); renderer._renderers.push_back(new Implementation::PointRenderer<3>(shape));
break; break;
case Shapes::AbstractShape3D::Type::Sphere: case Shapes::AbstractShape3D::Type::Sphere:
case Shapes::AbstractShape3D::Type::InvertedSphere: /* Isn't publicly subclassed, but shouldn't matter */ case Shapes::AbstractShape3D::Type::InvertedSphere: /* Isn't publicly subclassed, but shouldn't matter */
renderer.renderers.push_back(new Implementation::SphereRenderer<3>(shape)); renderer._renderers.push_back(new Implementation::SphereRenderer<3>(shape));
break; break;
case Shapes::AbstractShape3D::Type::Capsule: case Shapes::AbstractShape3D::Type::Capsule:
renderer.renderers.push_back(new Implementation::CapsuleRenderer<3>(shape)); renderer._renderers.push_back(new Implementation::CapsuleRenderer<3>(shape));
break; break;
case Shapes::AbstractShape3D::Type::Cylinder: case Shapes::AbstractShape3D::Type::Cylinder:
renderer.renderers.push_back(new Implementation::CylinderRenderer<3>(shape)); renderer._renderers.push_back(new Implementation::CylinderRenderer<3>(shape));
break; break;
case Shapes::AbstractShape3D::Type::Composition: { case Shapes::AbstractShape3D::Type::Composition: {
const Shapes::Composition3D& composition = const Shapes::Composition3D& composition =
@ -114,17 +114,17 @@ template<> void createDebugMesh(ShapeRenderer<3>& renderer, const Shapes::Implem
} }
template<UnsignedInt dimensions> ShapeRenderer<dimensions>::ShapeRenderer(Shapes::AbstractShape<dimensions>& shape, ResourceKey options, SceneGraph::DrawableGroup<dimensions, Float>* drawables): SceneGraph::Drawable<dimensions, Float>(shape.object(), drawables), options(ResourceManager::instance().get<ShapeRendererOptions>(options)) { template<UnsignedInt dimensions> ShapeRenderer<dimensions>::ShapeRenderer(Shapes::AbstractShape<dimensions>& shape, ResourceKey options, SceneGraph::DrawableGroup<dimensions, Float>* drawables): SceneGraph::Drawable<dimensions, Float>(shape.object(), drawables), _options(ResourceManager::instance().get<ShapeRendererOptions>(options)) {
Implementation::createDebugMesh(*this, Shapes::Implementation::getAbstractShape(shape)); Implementation::createDebugMesh(*this, Shapes::Implementation::getAbstractShape(shape));
} }
template<UnsignedInt dimensions> ShapeRenderer<dimensions>::~ShapeRenderer() { template<UnsignedInt dimensions> ShapeRenderer<dimensions>::~ShapeRenderer() {
for(auto i: renderers) delete i; for(auto i: _renderers) delete i;
} }
template<UnsignedInt dimensions> void ShapeRenderer<dimensions>::draw(const MatrixTypeFor<dimensions, Float>&, SceneGraph::Camera<dimensions, Float>& camera) { template<UnsignedInt dimensions> void ShapeRenderer<dimensions>::draw(const MatrixTypeFor<dimensions, Float>&, SceneGraph::Camera<dimensions, Float>& camera) {
const MatrixTypeFor<dimensions, Float> projectionMatrix = camera.projectionMatrix()*camera.cameraMatrix(); const MatrixTypeFor<dimensions, Float> projectionMatrix = camera.projectionMatrix()*camera.cameraMatrix();
for(auto i: renderers) i->draw(options, projectionMatrix); for(auto i: _renderers) i->draw(_options, projectionMatrix);
} }
template class ShapeRenderer<2>; template class ShapeRenderer<2>;

4
src/Magnum/DebugTools/ShapeRenderer.h
Unescape View File

@ -163,8 +163,8 @@ template<UnsignedInt dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ShapeRenderer: p
private: private:
void draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::Camera<dimensions, Float>& camera) override; void draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::Camera<dimensions, Float>& camera) override;
Resource<ShapeRendererOptions> options; Resource<ShapeRendererOptions> _options;
std::vector<Implementation::AbstractShapeRenderer<dimensions>*> renderers; std::vector<Implementation::AbstractShapeRenderer<dimensions>*> _renderers;
}; };
/** @brief Two-dimensional shape renderer */ /** @brief Two-dimensional shape renderer */

Write Preview
Loading…
Cancel
Save