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

DebugTools: adapted ShapeRenderer to Physics changes. 

Now using const reference to the shape instead of non-const one, also
removed some duplicated code and unneeded includes from the switch,
these operations are done in renderer implementations themselves.
pull/278/head
Vladimír Vondruš 13 years ago
parent
d9bc507e00
commit
2cceafed3c
13 changed files with 69 additions and 68 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. 10
      src/DebugTools/Implementation/AbstractShapeRenderer.h
  2. 6
      src/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp
  3. 4
      src/DebugTools/Implementation/AxisAlignedBoxRenderer.h
  4. 4
      src/DebugTools/Implementation/BoxRenderer.cpp
  5. 4
      src/DebugTools/Implementation/BoxRenderer.h
  6. 6
      src/DebugTools/Implementation/LineSegmentRenderer.cpp
  7. 4
      src/DebugTools/Implementation/LineSegmentRenderer.h
  8. 4
      src/DebugTools/Implementation/PointRenderer.cpp
  9. 4
      src/DebugTools/Implementation/PointRenderer.h
  10. 6
      src/DebugTools/Implementation/SphereRenderer.cpp
  11. 4
      src/DebugTools/Implementation/SphereRenderer.h
  12. 69
      src/DebugTools/ShapeRenderer.cpp
  13. 12
      src/DebugTools/ShapeRenderer.h

10
src/DebugTools/Implementation/AbstractShapeRenderer.h
Unescape View File

@ -31,9 +31,15 @@
#include "Shaders/Shaders.h"
#include "Trade/Trade.h"
namespace Magnum { namespace DebugTools { namespace Implementation {
namespace Magnum {
template<UnsignedInt dimensions> struct MeshData;
namespace Physics { namespace Implementation {
template<UnsignedInt> struct AbstractShape;
}}
namespace DebugTools { namespace Implementation {
template<UnsignedInt> struct MeshData;
template<> struct MeshData<2> { typedef Trade::MeshData2D Type; };
template<> struct MeshData<3> { typedef Trade::MeshData3D Type; };

6
src/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp
Unescape View File

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

4
src/DebugTools/Implementation/AxisAlignedBoxRenderer.h
Unescape View File

@ -34,12 +34,12 @@ namespace Magnum { namespace DebugTools { namespace Implementation {
template<UnsignedInt dimensions> class AxisAlignedBoxRenderer: public AbstractBoxRenderer<dimensions> {
public:
AxisAlignedBoxRenderer(Physics::AxisAlignedBox<dimensions>& axisAlignedBox);
AxisAlignedBoxRenderer(const Physics::Implementation::AbstractShape<dimensions>* axisAlignedBox);
void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) override;
private:
Physics::AxisAlignedBox<dimensions>& axisAlignedBox;
const Physics::AxisAlignedBox<dimensions>& axisAlignedBox;
};
}}}

4
src/DebugTools/Implementation/BoxRenderer.cpp
Unescape View File

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

4
src/DebugTools/Implementation/BoxRenderer.h
Unescape View File

@ -34,12 +34,12 @@ namespace Magnum { namespace DebugTools { namespace Implementation {
template<UnsignedInt dimensions> class BoxRenderer: public AbstractBoxRenderer<dimensions> {
public:
BoxRenderer(Physics::Box<dimensions>& box);
BoxRenderer(const Physics::Implementation::AbstractShape<dimensions>* box);
void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) override;
private:
Physics::Box<dimensions>& box;
const Physics::Box<dimensions>& box;
};
}}}

6
src/DebugTools/Implementation/LineSegmentRenderer.cpp
Unescape View File

@ -26,7 +26,7 @@
#include "Mesh.h"
#include "DebugTools/ShapeRenderer.h"
#include "Physics/Line.h"
#include "Physics/LineSegment.h"
#include "Primitives/Line.h"
#include "Shaders/Flat.h"
#include "Trade/MeshData2D.h"
@ -50,13 +50,13 @@ namespace {
template<> inline Trade::MeshData3D meshData<3>() { return Primitives::Line3D::wireframe(); }
}
template<UnsignedInt dimensions> LineSegmentRenderer<dimensions>::LineSegmentRenderer(Physics::Line<dimensions>& line): AbstractShapeRenderer<dimensions>(meshKey<dimensions>(), vertexBufferKey<dimensions>(), {}), line(line) {
template<UnsignedInt dimensions> LineSegmentRenderer<dimensions>::LineSegmentRenderer(const Physics::Implementation::AbstractShape<dimensions>* line): AbstractShapeRenderer<dimensions>(meshKey<dimensions>(), vertexBufferKey<dimensions>(), {}), line(static_cast<const Physics::Implementation::Shape<Physics::LineSegment<dimensions>>*>(line)->shape) {
if(!this->wireframeMesh) this->createResources(meshData<dimensions>());
}
template<UnsignedInt dimensions> void LineSegmentRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) {
this->wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
Implementation::lineSegmentRendererTransformation<dimensions>(line.transformedA(), line.transformedB()))
Implementation::lineSegmentRendererTransformation<dimensions>(line.a(), line.b()))
->setColor(options->color())
->use();
this->wireframeMesh->draw();

4
src/DebugTools/Implementation/LineSegmentRenderer.h
Unescape View File

@ -34,12 +34,12 @@ namespace Magnum { namespace DebugTools { namespace Implementation {
template<UnsignedInt dimensions> class LineSegmentRenderer: public AbstractShapeRenderer<dimensions> {
public:
LineSegmentRenderer(Physics::Line<dimensions>& line);
LineSegmentRenderer(const Physics::Implementation::AbstractShape<dimensions>* line);
void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) override;
private:
Physics::Line<dimensions>& line;
const Physics::LineSegment<dimensions>& line;
};
}}}

4
src/DebugTools/Implementation/PointRenderer.cpp
Unescape View File

@ -48,14 +48,14 @@ namespace {
template<> inline Trade::MeshData3D meshData<3>() { return Primitives::Crosshair3D::wireframe(); }
}
template<UnsignedInt dimensions> PointRenderer<dimensions>::PointRenderer(Physics::Point<dimensions>& point): AbstractShapeRenderer<dimensions>(meshKey<dimensions>(), vertexBufferKey<dimensions>(), {}), point(point) {
template<UnsignedInt dimensions> PointRenderer<dimensions>::PointRenderer(const Physics::Implementation::AbstractShape<dimensions>* point): AbstractShapeRenderer<dimensions>(meshKey<dimensions>(), vertexBufferKey<dimensions>(), {}), point(static_cast<const Physics::Implementation::Shape<Physics::Point<dimensions>>*>(point)->shape) {
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->wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
DimensionTraits<dimensions>::MatrixType::translation(point.transformedPosition())*
DimensionTraits<dimensions>::MatrixType::translation(point.position())*
DimensionTraits<dimensions>::MatrixType::scaling(typename DimensionTraits<dimensions>::VectorType(options->pointSize()/2)))
->setColor(options->color())
->use();

4
src/DebugTools/Implementation/PointRenderer.h
Unescape View File

@ -34,12 +34,12 @@ namespace Magnum { namespace DebugTools { namespace Implementation {
template<UnsignedInt dimensions> class PointRenderer: public AbstractShapeRenderer<dimensions> {
public:
PointRenderer(Physics::Point<dimensions>& point);
PointRenderer(const Physics::Implementation::AbstractShape<dimensions>* point);
void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) override;
private:
Physics::Point<dimensions>& point;
const Physics::Point<dimensions>& point;
};
}}}

6
src/DebugTools/Implementation/SphereRenderer.cpp
Unescape View File

@ -37,12 +37,12 @@ AbstractSphereRenderer<2>::AbstractSphereRenderer(): AbstractShapeRenderer<2>("s
if(!wireframeMesh) createResources(Primitives::Circle::wireframe(40));
}
template<UnsignedInt dimensions> SphereRenderer<dimensions>::SphereRenderer(Physics::Sphere<dimensions>& sphere): sphere(sphere) {}
template<UnsignedInt dimensions> SphereRenderer<dimensions>::SphereRenderer(const Physics::Implementation::AbstractShape<dimensions>* sphere): sphere(static_cast<const Physics::Implementation::Shape<Physics::Sphere<dimensions>>*>(sphere)->shape) {}
template<UnsignedInt dimensions> void SphereRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) {
this->wireframeShader->setTransformationProjectionMatrix(projectionMatrix*
DimensionTraits<dimensions>::MatrixType::translation(sphere.transformedPosition())*
DimensionTraits<dimensions>::MatrixType::scaling(typename DimensionTraits<dimensions>::VectorType(sphere.transformedRadius())))
DimensionTraits<dimensions>::MatrixType::translation(sphere.position())*
DimensionTraits<dimensions>::MatrixType::scaling(typename DimensionTraits<dimensions>::VectorType(sphere.radius())))
->setColor(options->color())
->use();
this->wireframeMesh->draw();

4
src/DebugTools/Implementation/SphereRenderer.h
Unescape View File

@ -41,12 +41,12 @@ template<> class AbstractSphereRenderer<2>: public AbstractShapeRenderer<2> {
template<UnsignedInt dimensions> class SphereRenderer: public AbstractSphereRenderer<dimensions> {
public:
SphereRenderer(Physics::Sphere<dimensions>& sphere);
SphereRenderer(const Physics::Implementation::AbstractShape<dimensions>* sphere);
void draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) override;
private:
Physics::Sphere<dimensions>& sphere;
const Physics::Sphere<dimensions>& sphere;
};
}}}

69
src/DebugTools/ShapeRenderer.cpp
Unescape View File

@ -25,14 +25,8 @@
#include "ShapeRenderer.h"
#include "ResourceManager.h"
#include "Physics/AbstractShape.h"
#include "Physics/AxisAlignedBox.h"
#include "Physics/Box.h"
#include "Physics/ObjectShape.h"
#include "Physics/LineSegment.h"
#include "Physics/Point.h"
#include "Physics/ShapeGroup.h"
#include "Physics/Sphere.h"
#include "SceneGraph/AbstractCamera.h"
#include "Implementation/AxisAlignedBoxRenderer.h"
@ -45,51 +39,53 @@ namespace Magnum { namespace DebugTools {
namespace Implementation {
template<> void createDebugMesh(ShapeRenderer<2>* renderer, Physics::AbstractShape<2>* shape) {
template<> void createDebugMesh(ShapeRenderer<2>* renderer, const Physics::Implementation::AbstractShape<2>* shape) {
switch(shape->type()) {
case Physics::AbstractShape2D::Type::AxisAlignedBox:
renderer->renderers.push_back(new Implementation::AxisAlignedBoxRenderer<2>(*static_cast<Physics::AxisAlignedBox2D*>(shape)));
case Physics::AbstractObjectShape2D::Type::AxisAlignedBox:
renderer->renderers.push_back(new Implementation::AxisAlignedBoxRenderer<2>(shape));
break;
case Physics::AbstractShape2D::Type::Box:
renderer->renderers.push_back(new Implementation::BoxRenderer<2>(*static_cast<Physics::Box2D*>(shape)));
case Physics::AbstractObjectShape2D::Type::Box:
renderer->renderers.push_back(new Implementation::BoxRenderer<2>(shape));
break;
case Physics::AbstractShape2D::Type::LineSegment:
renderer->renderers.push_back(new Implementation::LineSegmentRenderer<2>(*static_cast<Physics::LineSegment2D*>(shape)));
case Physics::AbstractObjectShape2D::Type::LineSegment:
renderer->renderers.push_back(new Implementation::LineSegmentRenderer<2>(shape));
break;
case Physics::AbstractShape2D::Type::Point:
renderer->renderers.push_back(new Implementation::PointRenderer<2>(*static_cast<Physics::Point2D*>(shape)));
case Physics::AbstractObjectShape2D::Type::Point:
renderer->renderers.push_back(new Implementation::PointRenderer<2>(shape));
break;
case Physics::AbstractShape2D::Type::ShapeGroup: {
Physics::ShapeGroup2D* group = static_cast<Physics::ShapeGroup2D*>(shape);
if(group->first()) createDebugMesh(renderer, group->first());
if(group->second()) createDebugMesh(renderer, group->second());
case Physics::AbstractObjectShape2D::Type::ShapeGroup: {
const Physics::ShapeGroup2D& group =
static_cast<const Physics::Implementation::Shape<Physics::ShapeGroup2D>*>(shape)->shape;
for(std::size_t i = 0; i != group.size(); ++i)
createDebugMesh(renderer, Physics::Implementation::getAbstractShape(group, i));
} break;
case Physics::AbstractShape2D::Type::Sphere:
renderer->renderers.push_back(new Implementation::SphereRenderer<2>(*static_cast<Physics::Sphere2D*>(shape)));
case Physics::AbstractObjectShape2D::Type::Sphere:
renderer->renderers.push_back(new Implementation::SphereRenderer<2>(shape));
break;
default:
Warning() << "DebugTools::ShapeRenderer2D::createShapeRenderer(): type" << shape->type() << "not implemented";
}
}
template<> void createDebugMesh(ShapeRenderer<3>* renderer, Physics::AbstractShape<3>* shape) {
template<> void createDebugMesh(ShapeRenderer<3>* renderer, const Physics::Implementation::AbstractShape<3>* shape) {
switch(shape->type()) {
case Physics::AbstractShape3D::Type::AxisAlignedBox:
renderer->renderers.push_back(new Implementation::AxisAlignedBoxRenderer<3>(*static_cast<Physics::AxisAlignedBox3D*>(shape)));
case Physics::AbstractObjectShape3D::Type::AxisAlignedBox:
renderer->renderers.push_back(new Implementation::AxisAlignedBoxRenderer<3>(shape));
break;
case Physics::AbstractShape3D::Type::Box:
renderer->renderers.push_back(new Implementation::BoxRenderer<3>(*static_cast<Physics::Box3D*>(shape)));
case Physics::AbstractObjectShape3D::Type::Box:
renderer->renderers.push_back(new Implementation::BoxRenderer<3>(shape));
break;
case Physics::AbstractShape3D::Type::LineSegment:
renderer->renderers.push_back(new Implementation::LineSegmentRenderer<3>(*static_cast<Physics::LineSegment3D*>(shape)));
case Physics::AbstractObjectShape3D::Type::LineSegment:
renderer->renderers.push_back(new Implementation::LineSegmentRenderer<3>(shape));
break;
case Physics::AbstractShape3D::Type::Point:
renderer->renderers.push_back(new Implementation::PointRenderer<3>(*static_cast<Physics::Point3D*>(shape)));
case Physics::AbstractObjectShape3D::Type::Point:
renderer->renderers.push_back(new Implementation::PointRenderer<3>(shape));
break;
case Physics::AbstractShape3D::Type::ShapeGroup: {
Physics::ShapeGroup3D* group = static_cast<Physics::ShapeGroup3D*>(shape);
if(group->first()) createDebugMesh(renderer, group->first());
if(group->second()) createDebugMesh(renderer, group->second());
case Physics::AbstractObjectShape3D::Type::ShapeGroup: {
const Physics::ShapeGroup3D& group =
static_cast<const Physics::Implementation::Shape<Physics::ShapeGroup3D>*>(shape)->shape;
for(std::size_t i = 0; i != group.size(); ++i)
createDebugMesh(renderer, Physics::Implementation::getAbstractShape(group, i));
} break;
default:
Warning() << "DebugTools::ShapeRenderer3D::createShapeRenderer(): type" << shape->type() << "not implemented";
@ -98,9 +94,8 @@ template<> void createDebugMesh(ShapeRenderer<3>* renderer, Physics::AbstractSha
}
template<UnsignedInt dimensions> ShapeRenderer<dimensions>::ShapeRenderer(Physics::ObjectShape<dimensions>* shape, ResourceKey options, SceneGraph::DrawableGroup<dimensions>* drawables): SceneGraph::Drawable<dimensions>(shape->object(), drawables), options(ResourceManager::instance()->get<ShapeRendererOptions>(options)) {
CORRADE_ASSERT(shape->shape() != nullptr, "DebugTools::ShapeRenderer: cannot create renderer for empty shape", );
Implementation::createDebugMesh(this, shape->shape());
template<UnsignedInt dimensions> ShapeRenderer<dimensions>::ShapeRenderer(Physics::AbstractObjectShape<dimensions>* shape, ResourceKey options, SceneGraph::DrawableGroup<dimensions>* drawables): SceneGraph::Drawable<dimensions>(shape->object(), drawables), options(ResourceManager::instance()->get<ShapeRendererOptions>(options)) {
Implementation::createDebugMesh(this, Physics::Implementation::getAbstractShape(shape));
}
template<UnsignedInt dimensions> ShapeRenderer<dimensions>::~ShapeRenderer() {

12
src/DebugTools/ShapeRenderer.h
Unescape View File

@ -32,6 +32,7 @@
#include "Resource.h"
#include "SceneGraph/Drawable.h"
#include "Physics/Physics.h"
#include "Physics/shapeImplementation.h"
#include "magnumDebugToolsVisibility.h"
@ -45,7 +46,7 @@ template<UnsignedInt> class ShapeRenderer;
namespace Implementation {
template<UnsignedInt> class AbstractShapeRenderer;
template<UnsignedInt dimensions> void createDebugMesh(ShapeRenderer<dimensions>* renderer, Physics::AbstractShape<dimensions>* shape);
template<UnsignedInt dimensions> void createDebugMesh(ShapeRenderer<dimensions>* renderer, const Physics::Implementation::AbstractShape<dimensions>* shape);
}
/**
@ -138,7 +139,7 @@ new DebugTools::ShapeRenderer2D(shape, "red", debugDrawables);
@see ShapeRenderer2D, ShapeRenderer3D
*/
template<UnsignedInt dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ShapeRenderer: public SceneGraph::Drawable<dimensions> {
friend void Implementation::createDebugMesh<>(ShapeRenderer<dimensions>*, Physics::AbstractShape<dimensions>*);
friend void Implementation::createDebugMesh<>(ShapeRenderer<dimensions>*, const Physics::Implementation::AbstractShape<dimensions>*);
public:
/**
@ -150,11 +151,10 @@ template<UnsignedInt dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ShapeRenderer: p
* @param drawables Drawable group
*
* The renderer is automatically added to shape's object features,
* @p shape must be available for the whole lifetime of the renderer.
*
* @attention Passed object must have assigned shape.
* @p shape must be available for the whole lifetime of the renderer
* and if it is group, it must not change its internal structure.
*/
explicit ShapeRenderer(Physics::ObjectShape<dimensions>* shape, ResourceKey options = ResourceKey(), SceneGraph::DrawableGroup<dimensions>* drawables = nullptr);
explicit ShapeRenderer(Physics::AbstractObjectShape<dimensions>* shape, ResourceKey options = ResourceKey(), SceneGraph::DrawableGroup<dimensions>* drawables = nullptr);
~ShapeRenderer();

Write Preview
Loading…
Cancel
Save