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
Split 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 = ResourceManager::instance().get<AbstractShaderProgram, Shaders::Flat<dimensions>>(shaderKey<dimensions>());
if(!shader) ResourceManager::instance().set<AbstractShaderProgram>(shader.key(), new Shaders::Flat<dimensions>);
_shader = ResourceManager::instance().get<AbstractShaderProgram, Shaders::Flat<dimensions>>(shaderKey<dimensions>());
if(!_shader) ResourceManager::instance().set<AbstractShaderProgram>(_shader.key(), new Shaders::Flat<dimensions>);
/* Mesh and vertex buffer */
mesh = ResourceManager::instance().get<Mesh>("force");
vertexBuffer = ResourceManager::instance().get<Buffer>("force-vertices");
indexBuffer = ResourceManager::instance().get<Buffer>("force-indices");
if(mesh) return;
_mesh = ResourceManager::instance().get<Mesh>("force");
_vertexBuffer = ResourceManager::instance().get<Buffer>("force-vertices");
_indexBuffer = ResourceManager::instance().get<Buffer>("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<UnsignedInt dimensions> ForceRenderer<dimensions>::ForceRenderer(SceneG
.addVertexBuffer(*vertexBuffer, 0,
typename Shaders::Flat<dimensions>::Position(Shaders::Flat<dimensions>::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<UnsignedInt dimensions> ForceRenderer<dimensions>::~ForceRenderer() = default;
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()}))
.setColor(options->color());
mesh->draw(*shader);
_shader->setTransformationProjectionMatrix(camera.projectionMatrix()*Implementation::forceRendererTransformation<dimensions>(transformationMatrix.transformPoint(_forcePosition), _force)*MatrixTypeFor<dimensions, Float>::scaling(VectorTypeFor<dimensions, Float>{_options->scale()}))
.setColor(_options->color());
_mesh->draw(*_shader);
}
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:
void draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::Camera<dimensions, Float>& camera) override;
const VectorTypeFor<dimensions, Float> forcePosition;
const VectorTypeFor<dimensions, Float>& force;
const VectorTypeFor<dimensions, Float> _forcePosition;
const VectorTypeFor<dimensions, Float>& _force;
Resource<ForceRendererOptions> options;
Resource<AbstractShaderProgram, Shaders::Flat<dimensions>> shader;
Resource<Mesh> mesh;
Resource<Buffer> vertexBuffer, indexBuffer;
Resource<ForceRendererOptions> _options;
Resource<AbstractShaderProgram, Shaders::Flat<dimensions>> _shader;
Resource<Mesh> _mesh;
Resource<Buffer> _vertexBuffer, _indexBuffer;
};
/** @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 = ResourceManager::instance().get<AbstractShaderProgram, Shaders::VertexColor<dimensions>>(Renderer<dimensions>::shader());
if(!shader) ResourceManager::instance().set<AbstractShaderProgram>(shader.key(), new Shaders::VertexColor<dimensions>);
_shader = ResourceManager::instance().get<AbstractShaderProgram, Shaders::VertexColor<dimensions>>(Renderer<dimensions>::shader());
if(!_shader) ResourceManager::instance().set<AbstractShaderProgram>(_shader.key(), new Shaders::VertexColor<dimensions>);
/* Mesh and vertex buffer */
mesh = ResourceManager::instance().get<Mesh>(Renderer<dimensions>::mesh());
vertexBuffer = ResourceManager::instance().get<Buffer>(Renderer<dimensions>::vertexBuffer());
indexBuffer = ResourceManager::instance().get<Buffer>(Renderer<dimensions>::indexBuffer());
if(mesh) return;
_mesh = ResourceManager::instance().get<Mesh>(Renderer<dimensions>::mesh());
_vertexBuffer = ResourceManager::instance().get<Buffer>(Renderer<dimensions>::vertexBuffer());
_indexBuffer = ResourceManager::instance().get<Buffer>(Renderer<dimensions>::indexBuffer());
if(_mesh) return;
/* Create the mesh */
Buffer* vertexBuffer = new Buffer{Buffer::TargetHint::Array};
@ -161,10 +161,10 @@ template<UnsignedInt dimensions> ObjectRenderer<dimensions>::ObjectRenderer(Scen
Mesh* mesh = new Mesh;
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);
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<dimensions>::indices.size())
@ -172,15 +172,15 @@ template<UnsignedInt dimensions> ObjectRenderer<dimensions>::ObjectRenderer(Scen
typename Shaders::VertexColor<dimensions>::Position(),
typename Shaders::VertexColor<dimensions>::Color())
.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 */
template<UnsignedInt dimensions> ObjectRenderer<dimensions>::~ObjectRenderer() = default;
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()}));
mesh->draw(*shader);
_shader->setTransformationProjectionMatrix(camera.projectionMatrix()*transformationMatrix*MatrixTypeFor<dimensions, Float>::scaling(VectorTypeFor<dimensions, Float>{_options->size()}));
_mesh->draw(*_shader);
}
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:
void draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::Camera<dimensions, Float>& camera) override;
Resource<ObjectRendererOptions> options;
Resource<AbstractShaderProgram, Shaders::VertexColor<dimensions>> shader;
Resource<Mesh> mesh;
Resource<Buffer> vertexBuffer, indexBuffer;
Resource<ObjectRendererOptions> _options;
Resource<AbstractShaderProgram, Shaders::VertexColor<dimensions>> _shader;
Resource<Mesh> _mesh;
Resource<Buffer> _vertexBuffer, _indexBuffer;
};
/** @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 {
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<std::size_t> totalSorted(sections.size());
std::vector<std::size_t> 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<microseconds>(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<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;
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<std::string> sections;
std::vector<std::chrono::high_resolution_clock::duration> frameData;
std::vector<std::chrono::high_resolution_clock::duration> totalData;
std::chrono::high_resolution_clock::time_point previousTime;
Section currentSection;
bool _enabled;
std::size_t _measureDuration, _currentFrame, _frameCount;
std::vector<std::string> _sections;
std::vector<std::chrono::high_resolution_clock::duration> _frameData;
std::vector<std::chrono::high_resolution_clock::duration> _totalData;
std::chrono::high_resolution_clock::time_point _previousTime;
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) {
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<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));
}
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) {
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>;

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

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

Write Preview
Loading…
Cancel
Save