From 8b6ff334764afb5e4dca19621692100e8fef5a9d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Fri, 11 Sep 2015 17:44:36 +0200 Subject: [PATCH] DebugTools: prefix private member variables with underscore. Fixes MSVC 2015 variable shadowing warnings. Fortunately no bug caused by these. --- src/Magnum/DebugTools/ForceRenderer.cpp | 30 +++++------ src/Magnum/DebugTools/ForceRenderer.h | 12 ++--- src/Magnum/DebugTools/ObjectRenderer.cpp | 24 ++++----- src/Magnum/DebugTools/ObjectRenderer.h | 8 +-- src/Magnum/DebugTools/Profiler.cpp | 66 ++++++++++++------------ src/Magnum/DebugTools/Profiler.h | 18 +++---- src/Magnum/DebugTools/ShapeRenderer.cpp | 34 ++++++------ src/Magnum/DebugTools/ShapeRenderer.h | 4 +- 8 files changed, 98 insertions(+), 98 deletions(-) diff --git a/src/Magnum/DebugTools/ForceRenderer.cpp b/src/Magnum/DebugTools/ForceRenderer.cpp index f537e6276..2857e55fb 100644 --- a/src/Magnum/DebugTools/ForceRenderer.cpp +++ b/src/Magnum/DebugTools/ForceRenderer.cpp @@ -56,26 +56,26 @@ constexpr std::array indices{{ } -template ForceRenderer::ForceRenderer(SceneGraph::AbstractObject& object, const VectorTypeFor& forcePosition, const VectorTypeFor& force, ResourceKey options, SceneGraph::DrawableGroup* drawables): SceneGraph::Drawable(object, drawables), forcePosition(forcePosition), force(force), options(ResourceManager::instance().get(options)) { +template ForceRenderer::ForceRenderer(SceneGraph::AbstractObject& object, const VectorTypeFor& forcePosition, const VectorTypeFor& force, ResourceKey options, SceneGraph::DrawableGroup* drawables): SceneGraph::Drawable(object, drawables), _forcePosition(forcePosition), _force(force), _options(ResourceManager::instance().get(options)) { /* Shader */ - shader = ResourceManager::instance().get>(shaderKey()); - if(!shader) ResourceManager::instance().set(shader.key(), new Shaders::Flat); + _shader = ResourceManager::instance().get>(shaderKey()); + if(!_shader) ResourceManager::instance().set(_shader.key(), new Shaders::Flat); /* Mesh and vertex buffer */ - mesh = ResourceManager::instance().get("force"); - vertexBuffer = ResourceManager::instance().get("force-vertices"); - indexBuffer = ResourceManager::instance().get("force-indices"); - if(mesh) return; + _mesh = ResourceManager::instance().get("force"); + _vertexBuffer = ResourceManager::instance().get("force-vertices"); + _indexBuffer = ResourceManager::instance().get("force-indices"); + if(_mesh) return; /* Create the mesh */ Buffer* vertexBuffer = new Buffer{Buffer::TargetHint::Array}; Buffer* indexBuffer = new Buffer{Buffer::TargetHint::ElementArray}; - vertexBuffer->setData(positions, BufferUsage::StaticDraw); - ResourceManager::instance().set(this->vertexBuffer.key(), vertexBuffer, ResourceDataState::Final, ResourcePolicy::Manual); + _vertexBuffer->setData(positions, BufferUsage::StaticDraw); + ResourceManager::instance().set(_vertexBuffer.key(), vertexBuffer, ResourceDataState::Final, ResourcePolicy::Manual); - indexBuffer->setData(indices, BufferUsage::StaticDraw); - ResourceManager::instance().set(this->indexBuffer.key(), indexBuffer, ResourceDataState::Final, ResourcePolicy::Manual); + _indexBuffer->setData(indices, BufferUsage::StaticDraw); + ResourceManager::instance().set(_indexBuffer.key(), indexBuffer, ResourceDataState::Final, ResourcePolicy::Manual); Mesh* mesh = new Mesh; mesh->setPrimitive(MeshPrimitive::Lines) @@ -83,16 +83,16 @@ template ForceRenderer::ForceRenderer(SceneG .addVertexBuffer(*vertexBuffer, 0, typename Shaders::Flat::Position(Shaders::Flat::Position::Components::Two)) .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 */ template ForceRenderer::~ForceRenderer() = default; template void ForceRenderer::draw(const MatrixTypeFor& transformationMatrix, SceneGraph::Camera& camera) { - shader->setTransformationProjectionMatrix(camera.projectionMatrix()*Implementation::forceRendererTransformation(transformationMatrix.transformPoint(forcePosition), force)*MatrixTypeFor::scaling(VectorTypeFor{options->scale()})) - .setColor(options->color()); - mesh->draw(*shader); + _shader->setTransformationProjectionMatrix(camera.projectionMatrix()*Implementation::forceRendererTransformation(transformationMatrix.transformPoint(_forcePosition), _force)*MatrixTypeFor::scaling(VectorTypeFor{_options->scale()})) + .setColor(_options->color()); + _mesh->draw(*_shader); } template class ForceRenderer<2>; diff --git a/src/Magnum/DebugTools/ForceRenderer.h b/src/Magnum/DebugTools/ForceRenderer.h index 5162e6884..e0a8ea369 100644 --- a/src/Magnum/DebugTools/ForceRenderer.h +++ b/src/Magnum/DebugTools/ForceRenderer.h @@ -131,13 +131,13 @@ template class MAGNUM_DEBUGTOOLS_EXPORT ForceRenderer: p private: void draw(const MatrixTypeFor& transformationMatrix, SceneGraph::Camera& camera) override; - const VectorTypeFor forcePosition; - const VectorTypeFor& force; + const VectorTypeFor _forcePosition; + const VectorTypeFor& _force; - Resource options; - Resource> shader; - Resource mesh; - Resource vertexBuffer, indexBuffer; + Resource _options; + Resource> _shader; + Resource _mesh; + Resource _vertexBuffer, _indexBuffer; }; /** @brief Two-dimensional force renderer */ diff --git a/src/Magnum/DebugTools/ObjectRenderer.cpp b/src/Magnum/DebugTools/ObjectRenderer.cpp index deca905c3..141bec456 100644 --- a/src/Magnum/DebugTools/ObjectRenderer.cpp +++ b/src/Magnum/DebugTools/ObjectRenderer.cpp @@ -144,16 +144,16 @@ const std::array Renderer<3>::indices{{ } -template ObjectRenderer::ObjectRenderer(SceneGraph::AbstractObject& object, ResourceKey options, SceneGraph::DrawableGroup* drawables): SceneGraph::Drawable(object, drawables), options(ResourceManager::instance().get(options)) { +template ObjectRenderer::ObjectRenderer(SceneGraph::AbstractObject& object, ResourceKey options, SceneGraph::DrawableGroup* drawables): SceneGraph::Drawable{object, drawables}, _options{ResourceManager::instance().get(options)} { /* Shader */ - shader = ResourceManager::instance().get>(Renderer::shader()); - if(!shader) ResourceManager::instance().set(shader.key(), new Shaders::VertexColor); + _shader = ResourceManager::instance().get>(Renderer::shader()); + if(!_shader) ResourceManager::instance().set(_shader.key(), new Shaders::VertexColor); /* Mesh and vertex buffer */ - mesh = ResourceManager::instance().get(Renderer::mesh()); - vertexBuffer = ResourceManager::instance().get(Renderer::vertexBuffer()); - indexBuffer = ResourceManager::instance().get(Renderer::indexBuffer()); - if(mesh) return; + _mesh = ResourceManager::instance().get(Renderer::mesh()); + _vertexBuffer = ResourceManager::instance().get(Renderer::vertexBuffer()); + _indexBuffer = ResourceManager::instance().get(Renderer::indexBuffer()); + if(_mesh) return; /* Create the mesh */ Buffer* vertexBuffer = new Buffer{Buffer::TargetHint::Array}; @@ -161,10 +161,10 @@ template ObjectRenderer::ObjectRenderer(Scen Mesh* mesh = new Mesh; vertexBuffer->setData(MeshTools::interleave(Renderer::positions, Renderer::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::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) .setCount(Renderer::indices.size()) @@ -172,15 +172,15 @@ template ObjectRenderer::ObjectRenderer(Scen typename Shaders::VertexColor::Position(), typename Shaders::VertexColor::Color()) .setIndexBuffer(*indexBuffer, 0, Mesh::IndexType::UnsignedByte, 0, Renderer::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 */ template ObjectRenderer::~ObjectRenderer() = default; template void ObjectRenderer::draw(const MatrixTypeFor& transformationMatrix, SceneGraph::Camera& camera) { - shader->setTransformationProjectionMatrix(camera.projectionMatrix()*transformationMatrix*MatrixTypeFor::scaling(VectorTypeFor{options->size()})); - mesh->draw(*shader); + _shader->setTransformationProjectionMatrix(camera.projectionMatrix()*transformationMatrix*MatrixTypeFor::scaling(VectorTypeFor{_options->size()})); + _mesh->draw(*_shader); } template class ObjectRenderer<2>; diff --git a/src/Magnum/DebugTools/ObjectRenderer.h b/src/Magnum/DebugTools/ObjectRenderer.h index 99d98a801..45d97a53b 100644 --- a/src/Magnum/DebugTools/ObjectRenderer.h +++ b/src/Magnum/DebugTools/ObjectRenderer.h @@ -103,10 +103,10 @@ template class MAGNUM_DEBUGTOOLS_EXPORT ObjectRenderer: private: void draw(const MatrixTypeFor& transformationMatrix, SceneGraph::Camera& camera) override; - Resource options; - Resource> shader; - Resource mesh; - Resource vertexBuffer, indexBuffer; + Resource _options; + Resource> _shader; + Resource _mesh; + Resource _vertexBuffer, _indexBuffer; }; /** @brief Two-dimensional object renderer */ diff --git a/src/Magnum/DebugTools/Profiler.cpp b/src/Magnum/DebugTools/Profiler.cpp index a0e592a91..a80c426ee 100644 --- a/src/Magnum/DebugTools/Profiler.cpp +++ b/src/Magnum/DebugTools/Profiler.cpp @@ -37,88 +37,88 @@ using namespace std::chrono; namespace Magnum { namespace DebugTools { Profiler::Section Profiler::addSection(const std::string& name) { - CORRADE_ASSERT(!enabled, "Profiler: cannot add section when profiling is enabled", 0); - sections.push_back(name); - return sections.size()-1; + CORRADE_ASSERT(!_enabled, "Profiler: cannot add section when profiling is enabled", 0); + _sections.push_back(name); + return _sections.size()-1; } void Profiler::setMeasureDuration(std::size_t frames) { - CORRADE_ASSERT(!enabled, "Profiler: cannot set measure duration when profiling is enabled", ); - measureDuration = frames; + CORRADE_ASSERT(!_enabled, "Profiler: cannot set measure duration when profiling is enabled", ); + _measureDuration = frames; } void Profiler::enable() { - enabled = true; - frameData.assign(measureDuration*sections.size(), high_resolution_clock::duration::zero()); - totalData.assign(sections.size(), high_resolution_clock::duration::zero()); - frameCount = 0; + _enabled = true; + _frameData.assign(_measureDuration*_sections.size(), high_resolution_clock::duration::zero()); + _totalData.assign(_sections.size(), high_resolution_clock::duration::zero()); + _frameCount = 0; } void Profiler::disable() { - enabled = false; + _enabled = false; } void Profiler::start(Section section) { - if(!enabled) return; - CORRADE_ASSERT(section < sections.size(), "Profiler: unknown section passed to start()", ); + if(!_enabled) return; + CORRADE_ASSERT(section < _sections.size(), "Profiler: unknown section passed to start()", ); save(); - currentSection = section; + _currentSection = section; } void Profiler::stop() { - if(!enabled) return; + if(!_enabled) return; save(); - previousTime = high_resolution_clock::time_point(); + _previousTime = high_resolution_clock::time_point(); } void Profiler::save() { auto now = high_resolution_clock::now(); /* If the profiler is already running, add time to given section */ - if(previousTime != high_resolution_clock::time_point()) - frameData[currentFrame*sections.size()+currentSection] += now-previousTime; + if(_previousTime != high_resolution_clock::time_point()) + _frameData[_currentFrame*_sections.size()+_currentSection] += now-_previousTime; /* Set current time as previous for next section */ - previousTime = now; + _previousTime = now; } void Profiler::nextFrame() { - if(!enabled) return; + if(!_enabled) return; /* Next frame index */ - std::size_t nextFrame = (currentFrame+1) % measureDuration; + std::size_t nextFrame = (_currentFrame+1) % _measureDuration; /* Add times of current frame to total */ - for(std::size_t i = 0; i != sections.size(); ++i) - totalData[i] += frameData[currentFrame*sections.size()+i]; + for(std::size_t i = 0; i != _sections.size(); ++i) + _totalData[i] += _frameData[_currentFrame*_sections.size()+i]; /* Subtract times of next frame from total and erase them */ - for(std::size_t i = 0; i != sections.size(); ++i) { - totalData[i] -= frameData[nextFrame*sections.size()+i]; - frameData[nextFrame*sections.size()+i] = high_resolution_clock::duration::zero(); + for(std::size_t i = 0; i != _sections.size(); ++i) { + _totalData[i] -= _frameData[nextFrame*_sections.size()+i]; + _frameData[nextFrame*_sections.size()+i] = high_resolution_clock::duration::zero(); } /* Advance to next frame */ - currentFrame = nextFrame; + _currentFrame = nextFrame; - if(frameCount < measureDuration) ++frameCount; + if(_frameCount < _measureDuration) ++_frameCount; } void Profiler::printStatistics() { - if(!enabled) return; + if(!_enabled) return; - std::vector totalSorted(sections.size()); + std::vector totalSorted(_sections.size()); 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:"; - for(std::size_t i = 0; i != sections.size(); ++i) - Debug() << " " << sections[totalSorted[i]] << duration_cast(totalData[totalSorted[i]]).count()/frameCount << u8"µs"; + Debug() << "Statistics for last" << _measureDuration << "frames:"; + for(std::size_t i = 0; i != _sections.size(); ++i) + Debug() << " " << _sections[totalSorted[i]] << duration_cast(_totalData[totalSorted[i]]).count()/_frameCount << u8"µs"; } }} diff --git a/src/Magnum/DebugTools/Profiler.h b/src/Magnum/DebugTools/Profiler.h index c16a286a6..4f08c6606 100644 --- a/src/Magnum/DebugTools/Profiler.h +++ b/src/Magnum/DebugTools/Profiler.h @@ -115,7 +115,7 @@ class MAGNUM_DEBUGTOOLS_EXPORT Profiler { */ 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 @@ -140,7 +140,7 @@ class MAGNUM_DEBUGTOOLS_EXPORT Profiler { * If the profiling is not enabled, calls to @ref start() and * @ref stop() have no effect. */ - bool isEnabled() { return enabled; } + bool isEnabled() { return _enabled; } /** * @brief Enable profiling @@ -201,13 +201,13 @@ class MAGNUM_DEBUGTOOLS_EXPORT Profiler { private: void save(); - bool enabled; - std::size_t measureDuration, currentFrame, frameCount; - std::vector sections; - std::vector frameData; - std::vector totalData; - std::chrono::high_resolution_clock::time_point previousTime; - Section currentSection; + bool _enabled; + std::size_t _measureDuration, _currentFrame, _frameCount; + std::vector _sections; + std::vector _frameData; + std::vector _totalData; + std::chrono::high_resolution_clock::time_point _previousTime; + Section _currentSection; }; }} diff --git a/src/Magnum/DebugTools/ShapeRenderer.cpp b/src/Magnum/DebugTools/ShapeRenderer.cpp index 6e1d28b73..a815417ba 100644 --- a/src/Magnum/DebugTools/ShapeRenderer.cpp +++ b/src/Magnum/DebugTools/ShapeRenderer.cpp @@ -45,26 +45,26 @@ namespace Implementation { template<> void createDebugMesh(ShapeRenderer<2>& renderer, const Shapes::Implementation::AbstractShape<2>& shape) { switch(shape.type()) { case Shapes::AbstractShape2D::Type::AxisAlignedBox: - renderer.renderers.push_back(new Implementation::AxisAlignedBoxRenderer<2>(shape)); + renderer._renderers.push_back(new Implementation::AxisAlignedBoxRenderer<2>(shape)); break; case Shapes::AbstractShape2D::Type::Box: - renderer.renderers.push_back(new Implementation::BoxRenderer<2>(shape)); + renderer._renderers.push_back(new Implementation::BoxRenderer<2>(shape)); break; case Shapes::AbstractShape2D::Type::LineSegment: - renderer.renderers.push_back(new Implementation::LineSegmentRenderer<2>(shape)); + renderer._renderers.push_back(new Implementation::LineSegmentRenderer<2>(shape)); break; case Shapes::AbstractShape2D::Type::Point: - renderer.renderers.push_back(new Implementation::PointRenderer<2>(shape)); + renderer._renderers.push_back(new Implementation::PointRenderer<2>(shape)); break; case Shapes::AbstractShape2D::Type::Sphere: 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; case Shapes::AbstractShape2D::Type::Capsule: - renderer.renderers.push_back(new Implementation::CapsuleRenderer<2>(shape)); + renderer._renderers.push_back(new Implementation::CapsuleRenderer<2>(shape)); break; case Shapes::AbstractShape2D::Type::Cylinder: - renderer.renderers.push_back(new Implementation::CylinderRenderer<2>(shape)); + renderer._renderers.push_back(new Implementation::CylinderRenderer<2>(shape)); break; case Shapes::AbstractShape2D::Type::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) { switch(shape.type()) { case Shapes::AbstractShape3D::Type::AxisAlignedBox: - renderer.renderers.push_back(new Implementation::AxisAlignedBoxRenderer<3>(shape)); + renderer._renderers.push_back(new Implementation::AxisAlignedBoxRenderer<3>(shape)); break; case Shapes::AbstractShape3D::Type::Box: - renderer.renderers.push_back(new Implementation::BoxRenderer<3>(shape)); + renderer._renderers.push_back(new Implementation::BoxRenderer<3>(shape)); break; case Shapes::AbstractShape3D::Type::LineSegment: - renderer.renderers.push_back(new Implementation::LineSegmentRenderer<3>(shape)); + renderer._renderers.push_back(new Implementation::LineSegmentRenderer<3>(shape)); break; case Shapes::AbstractShape3D::Type::Point: - renderer.renderers.push_back(new Implementation::PointRenderer<3>(shape)); + renderer._renderers.push_back(new Implementation::PointRenderer<3>(shape)); break; case Shapes::AbstractShape3D::Type::Sphere: 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; case Shapes::AbstractShape3D::Type::Capsule: - renderer.renderers.push_back(new Implementation::CapsuleRenderer<3>(shape)); + renderer._renderers.push_back(new Implementation::CapsuleRenderer<3>(shape)); break; case Shapes::AbstractShape3D::Type::Cylinder: - renderer.renderers.push_back(new Implementation::CylinderRenderer<3>(shape)); + renderer._renderers.push_back(new Implementation::CylinderRenderer<3>(shape)); break; case Shapes::AbstractShape3D::Type::Composition: { const Shapes::Composition3D& composition = @@ -114,17 +114,17 @@ template<> void createDebugMesh(ShapeRenderer<3>& renderer, const Shapes::Implem } -template ShapeRenderer::ShapeRenderer(Shapes::AbstractShape& shape, ResourceKey options, SceneGraph::DrawableGroup* drawables): SceneGraph::Drawable(shape.object(), drawables), options(ResourceManager::instance().get(options)) { +template ShapeRenderer::ShapeRenderer(Shapes::AbstractShape& shape, ResourceKey options, SceneGraph::DrawableGroup* drawables): SceneGraph::Drawable(shape.object(), drawables), _options(ResourceManager::instance().get(options)) { Implementation::createDebugMesh(*this, Shapes::Implementation::getAbstractShape(shape)); } template ShapeRenderer::~ShapeRenderer() { - for(auto i: renderers) delete i; + for(auto i: _renderers) delete i; } template void ShapeRenderer::draw(const MatrixTypeFor&, SceneGraph::Camera& camera) { const MatrixTypeFor 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>; diff --git a/src/Magnum/DebugTools/ShapeRenderer.h b/src/Magnum/DebugTools/ShapeRenderer.h index 025913aca..e7370d35b 100644 --- a/src/Magnum/DebugTools/ShapeRenderer.h +++ b/src/Magnum/DebugTools/ShapeRenderer.h @@ -163,8 +163,8 @@ template class MAGNUM_DEBUGTOOLS_EXPORT ShapeRenderer: p private: void draw(const MatrixTypeFor& transformationMatrix, SceneGraph::Camera& camera) override; - Resource options; - std::vector*> renderers; + Resource _options; + std::vector*> _renderers; }; /** @brief Two-dimensional shape renderer */