DebugTools: using new type aliases in whole DebugTools namespace.

src/DebugTools/DebugTools.h

@@ -19,13 +19,13 @@
  * @brief Forward declarations for Magnum::DebugTools namespace
  */
 
-#include <cstdint>
+#include "Types.h"
 
 namespace Magnum { namespace DebugTools {
 
 /** @todoc Remove `ifndef` when Doxygen is sane again */
 #ifndef DOXYGEN_GENERATING_OUTPUT
-template<std::uint8_t> class ObjectRenderer;
+template<UnsignedInt> class ObjectRenderer;
 typedef ObjectRenderer<2> ObjectRenderer2D;
 typedef ObjectRenderer<3> ObjectRenderer3D;
 class ObjectRendererOptions;
@@ -33,7 +33,7 @@ class ObjectRendererOptions;
 class Profiler;
 class ResourceManager;
 
-template<std::uint8_t> class ShapeRenderer;
+template<UnsignedInt> class ShapeRenderer;
 typedef ShapeRenderer<2> ShapeRenderer2D;
 typedef ShapeRenderer<3> ShapeRenderer3D;
 class ShapeRendererOptions;

src/DebugTools/Implementation/AbstractBoxRenderer.h

@@ -24,7 +24,7 @@
 
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
-template<std::uint8_t dimensions> class AbstractBoxRenderer;
+template<UnsignedInt dimensions> class AbstractBoxRenderer;
 
 template<> class AbstractBoxRenderer<2>: public AbstractShapeRenderer<2> {
     public:

src/DebugTools/Implementation/AbstractShapeRenderer.cpp

@@ -28,11 +28,11 @@ namespace Magnum { namespace DebugTools { namespace Implementation {
 
 namespace {
 
-template<std::uint8_t dimensions> ResourceKey shaderKey();
+template<UnsignedInt dimensions> ResourceKey shaderKey();
 template<> inline ResourceKey shaderKey<2>() { return ResourceKey("FlatShader2D"); }
 template<> inline ResourceKey shaderKey<3>() { return ResourceKey("FlatShader3D"); }
 
-template<std::uint8_t dimensions> void create(typename MeshData<dimensions>::Type&, Resource<Mesh>&, Resource<Buffer>&, Resource<Buffer>&);
+template<UnsignedInt dimensions> void create(typename MeshData<dimensions>::Type&, Resource<Mesh>&, Resource<Buffer>&, Resource<Buffer>&);
 
 template<> void create<2>(Trade::MeshData2D& data, Resource<Mesh>& meshResource, Resource<Buffer>& vertexBufferResource, Resource<Buffer>& indexBufferResource) {
     /* Vertex buffer */
@@ -80,7 +80,7 @@ template<> void create<3>(Trade::MeshData3D& data, Resource<Mesh>& meshResource,
 
 }
 
-template<std::uint8_t dimensions> AbstractShapeRenderer<dimensions>::AbstractShapeRenderer(ResourceKey meshKey, ResourceKey vertexBufferKey, ResourceKey indexBufferKey) {
+template<UnsignedInt dimensions> AbstractShapeRenderer<dimensions>::AbstractShapeRenderer(ResourceKey meshKey, ResourceKey vertexBufferKey, ResourceKey indexBufferKey) {
     shader = ResourceManager::instance()->get<AbstractShaderProgram, Shaders::FlatShader<dimensions>>(shaderKey<dimensions>());
     mesh = ResourceManager::instance()->get<Mesh>(meshKey);
     vertexBuffer = ResourceManager::instance()->get<Buffer>(vertexBufferKey);
@@ -90,9 +90,9 @@ template<std::uint8_t dimensions> AbstractShapeRenderer<dimensions>::AbstractSha
         new Shaders::FlatShader<dimensions>, ResourceDataState::Final, ResourcePolicy::Resident);
 }
 
-template<std::uint8_t dimensions> AbstractShapeRenderer<dimensions>::~AbstractShapeRenderer() {}
+template<UnsignedInt dimensions> AbstractShapeRenderer<dimensions>::~AbstractShapeRenderer() {}
 
-template<std::uint8_t dimensions> void AbstractShapeRenderer<dimensions>::createResources(typename MeshData<dimensions>::Type data) {
+template<UnsignedInt dimensions> void AbstractShapeRenderer<dimensions>::createResources(typename MeshData<dimensions>::Type data) {
     create<dimensions>(data, this->mesh, this->vertexBuffer, this->indexBuffer);
 }
 

src/DebugTools/Implementation/AbstractShapeRenderer.h

@@ -24,12 +24,12 @@
 
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
-template<std::uint8_t dimensions> struct MeshData;
+template<UnsignedInt dimensions> struct MeshData;
 
 template<> struct MeshData<2> { typedef Trade::MeshData2D Type; };
 template<> struct MeshData<3> { typedef Trade::MeshData3D Type; };
 
-template<std::uint8_t dimensions> class AbstractShapeRenderer {
+template<UnsignedInt dimensions> class AbstractShapeRenderer {
     public:
         AbstractShapeRenderer(ResourceKey mesh, ResourceKey vertexBuffer, ResourceKey indexBuffer);
         virtual ~AbstractShapeRenderer();

src/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp

@@ -22,9 +22,9 @@
 
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
-template<std::uint8_t dimensions> AxisAlignedBoxRenderer<dimensions>::AxisAlignedBoxRenderer(Physics::AxisAlignedBox<dimensions>& axisAlignedBox): axisAlignedBox(axisAlignedBox) {}
+template<UnsignedInt dimensions> AxisAlignedBoxRenderer<dimensions>::AxisAlignedBoxRenderer(Physics::AxisAlignedBox<dimensions>& axisAlignedBox): axisAlignedBox(axisAlignedBox) {}
 
-template<std::uint8_t dimensions> void AxisAlignedBoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) {
+template<UnsignedInt dimensions> void AxisAlignedBoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) {
     /* Half scale, because the box is 2x2(x2) */
     typename DimensionTraits<dimensions>::MatrixType transformation =
         DimensionTraits<dimensions>::MatrixType::translation((axisAlignedBox.transformedMin()+axisAlignedBox.transformedMax())/2)*

src/DebugTools/Implementation/AxisAlignedBoxRenderer.h

@@ -23,7 +23,7 @@
 
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
-template<std::uint8_t dimensions> class AxisAlignedBoxRenderer: public AbstractBoxRenderer<dimensions> {
+template<UnsignedInt dimensions> class AxisAlignedBoxRenderer: public AbstractBoxRenderer<dimensions> {
     public:
         AxisAlignedBoxRenderer(Physics::AxisAlignedBox<dimensions>& axisAlignedBox);
 

src/DebugTools/Implementation/BoxRenderer.cpp

@@ -22,9 +22,9 @@
 
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
-template<std::uint8_t dimensions> BoxRenderer<dimensions>::BoxRenderer(Physics::Box<dimensions>& box): box(box) {}
+template<UnsignedInt dimensions> BoxRenderer<dimensions>::BoxRenderer(Physics::Box<dimensions>& box): box(box) {}
 
-template<std::uint8_t dimensions> void BoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) {
+template<UnsignedInt dimensions> void BoxRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) {
     /* Half scale, because the box is 2x2(x2) */
     this->shader->setTransformationProjectionMatrix(projectionMatrix*box.transformedTransformation()*
         DimensionTraits<dimensions>::MatrixType::scaling(typename DimensionTraits<dimensions>::VectorType(0.5f)))

src/DebugTools/Implementation/BoxRenderer.h

@@ -23,7 +23,7 @@
 
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
-template<std::uint8_t dimensions> class BoxRenderer: public AbstractBoxRenderer<dimensions> {
+template<UnsignedInt dimensions> class BoxRenderer: public AbstractBoxRenderer<dimensions> {
     public:
         BoxRenderer(Physics::Box<dimensions>& box);
 

src/DebugTools/Implementation/PointRenderer.cpp

@@ -26,24 +26,24 @@
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
 namespace {
-    template<std::uint8_t dimensions> ResourceKey meshKey();
+    template<UnsignedInt dimensions> ResourceKey meshKey();
     template<> inline ResourceKey meshKey<2>() { return ResourceKey("point2d"); }
     template<> inline ResourceKey meshKey<3>() { return ResourceKey("point3d"); }
 
-    template<std::uint8_t dimensions> ResourceKey vertexBufferKey();
+    template<UnsignedInt dimensions> ResourceKey vertexBufferKey();
     template<> inline ResourceKey vertexBufferKey<2>() { return ResourceKey("point2d-vertices"); }
     template<> inline ResourceKey vertexBufferKey<3>() { return ResourceKey("point3d-vertices"); }
 
-    template<std::uint8_t dimensions> typename MeshData<dimensions>::Type meshData();
+    template<UnsignedInt dimensions> typename MeshData<dimensions>::Type meshData();
     template<> inline Trade::MeshData2D meshData<2>() { return Primitives::Crosshair2D::wireframe(); }
     template<> inline Trade::MeshData3D meshData<3>() { return Primitives::Crosshair3D::wireframe(); }
 }
 
-template<std::uint8_t dimensions> PointRenderer<dimensions>::PointRenderer(Physics::Point<dimensions>& point): AbstractShapeRenderer<dimensions>(meshKey<dimensions>(), vertexBufferKey<dimensions>(), {}), point(point) {
+template<UnsignedInt dimensions> PointRenderer<dimensions>::PointRenderer(Physics::Point<dimensions>& point): AbstractShapeRenderer<dimensions>(meshKey<dimensions>(), vertexBufferKey<dimensions>(), {}), point(point) {
     if(!this->mesh) this->createResources(meshData<dimensions>());
 }
 
-template<std::uint8_t dimensions> void PointRenderer<dimensions>::draw(Resource<ShapeRendererOptions>& options, const typename DimensionTraits<dimensions>::MatrixType& projectionMatrix) {
+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->shader->setTransformationProjectionMatrix(projectionMatrix*
         DimensionTraits<dimensions>::MatrixType::translation(point.transformedPosition())*

src/DebugTools/Implementation/PointRenderer.h

@@ -23,7 +23,7 @@
 
 namespace Magnum { namespace DebugTools { namespace Implementation {
 
-template<std::uint8_t dimensions> class PointRenderer: public AbstractShapeRenderer<dimensions> {
+template<UnsignedInt dimensions> class PointRenderer: public AbstractShapeRenderer<dimensions> {
     public:
         PointRenderer(Physics::Point<dimensions>& point);
 

src/DebugTools/ObjectRenderer.cpp

@@ -25,7 +25,7 @@ namespace Magnum { namespace DebugTools {
 
 namespace {
 
-template<std::uint8_t> struct Renderer;
+template<UnsignedInt> struct Renderer;
 
 template<> struct Renderer<2> {
     inline static ResourceKey shader() { return {"VertexColorShader2D"}; }
@@ -35,7 +35,7 @@ template<> struct Renderer<2> {
 
     static const std::array<Vector2, 8> positions;
     static const std::array<Color3<>, 8> colors;
-    static const std::array<std::uint8_t, 12> indices;
+    static const std::array<UnsignedByte, 12> indices;
 };
 
 const std::array<Vector2, 8> Renderer<2>::positions{{
@@ -62,7 +62,7 @@ const std::array<Color3<>, 8> Renderer<2>::colors{{
     {0.0f, 1.0f, 0.0f},
 }};
 
-const std::array<std::uint8_t, 12> Renderer<2>::indices{{
+const std::array<UnsignedByte, 12> Renderer<2>::indices{{
     0, 1,
     1, 2, /* X axis */
     1, 3,
@@ -117,7 +117,7 @@ const std::array<Color3<>, 12> Renderer<3>::colors{{
     {0.0f, 0.0f, 1.0f}
 }};
 
-const std::array<std::uint8_t, 18> Renderer<3>::indices{{
+const std::array<UnsignedByte, 18> Renderer<3>::indices{{
     0, 1,
     1, 2,  /* X axis */
     1, 3,
@@ -133,7 +133,7 @@ const std::array<std::uint8_t, 18> Renderer<3>::indices{{
 
 }
 
-template<std::uint8_t dimensions> ObjectRenderer<dimensions>::ObjectRenderer(SceneGraph::AbstractObject<dimensions>* object, ResourceKey options, SceneGraph::DrawableGroup<dimensions>* drawables): SceneGraph::Drawable<dimensions>(object, drawables), options(ResourceManager::instance()->get<ObjectRendererOptions>(options)) {
+template<UnsignedInt dimensions> ObjectRenderer<dimensions>::ObjectRenderer(SceneGraph::AbstractObject<dimensions>* object, ResourceKey options, SceneGraph::DrawableGroup<dimensions>* drawables): SceneGraph::Drawable<dimensions>(object, drawables), options(ResourceManager::instance()->get<ObjectRendererOptions>(options)) {
     /* Shader */
     shader = ResourceManager::instance()->get<AbstractShaderProgram, Shaders::VertexColorShader<dimensions>>(Renderer<dimensions>::shader());
     if(!shader) ResourceManager::instance()->set<AbstractShaderProgram>(shader.key(),
@@ -165,7 +165,7 @@ template<std::uint8_t dimensions> ObjectRenderer<dimensions>::ObjectRenderer(Sce
     ResourceManager::instance()->set<Mesh>(this->mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
 }
 
-template<std::uint8_t dimensions> void ObjectRenderer<dimensions>::draw(const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions>* camera) {
+template<UnsignedInt dimensions> void ObjectRenderer<dimensions>::draw(const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions>* camera) {
     shader->setTransformationProjectionMatrix(camera->projectionMatrix()*transformationMatrix*DimensionTraits<dimensions>::MatrixType::scaling(typename DimensionTraits<dimensions>::VectorType(options->size())))
         ->use();
 

src/DebugTools/ObjectRenderer.h

@@ -37,7 +37,7 @@ class ObjectRendererOptions {
         inline constexpr ObjectRendererOptions(): _size(1.0f) {}
 
         /** @brief Size of the rendered axes */
-        inline constexpr GLfloat size() const { return _size; }
+        inline constexpr Float size() const { return _size; }
 
         /**
          * @brief Set size of the rendered axes
@@ -45,13 +45,13 @@ class ObjectRendererOptions {
          *
          * Default is `1.0f`.
          */
-        inline ObjectRendererOptions* setSize(GLfloat size) {
+        inline ObjectRendererOptions* setSize(Float size) {
             _size = size;
             return this;
         }
 
     private:
-        GLfloat _size;
+        Float _size;
 };
 
 /**
@@ -75,7 +75,7 @@ new DebugTools::ObjectRenderer2D(object, "my", debugDrawables);
 
 @see ObjectRenderer2D, ObjectRenderer3D
 */
-template<std::uint8_t dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ObjectRenderer: public SceneGraph::Drawable<dimensions> {
+template<UnsignedInt dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ObjectRenderer: public SceneGraph::Drawable<dimensions> {
     public:
         /**
          * @brief Constructor
@@ -90,8 +90,8 @@ template<std::uint8_t dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ObjectRenderer:
         explicit ObjectRenderer(SceneGraph::AbstractObject<dimensions>* object, ResourceKey options = ResourceKey(), SceneGraph::DrawableGroup<dimensions>* drawables = nullptr);
 
     protected:
-        /** @todoc Remove GLfloat when Doxygen properly treats this as override */
-        void draw(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, GLfloat>* camera) override;
+        /** @todoc Remove Float when Doxygen properly treats this as override */
+        void draw(const typename DimensionTraits<dimensions, Float>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, Float>* camera) override;
 
     private:
         Resource<ObjectRendererOptions> options;

src/DebugTools/Profiler.h

@@ -24,6 +24,7 @@
 #include <string>
 #include <vector>
 
+#include "Types.h"
 #include "magnumDebugToolsVisibility.h"
 
 namespace Magnum { namespace DebugTools {
@@ -95,7 +96,7 @@ class MAGNUM_DEBUGTOOLS_EXPORT Profiler {
          *
          * @see otherSection, addSection(), start(Section)
          */
-        typedef std::uint32_t Section;
+        typedef UnsignedInt Section;
 
         /**
          * @brief Default section

src/DebugTools/ShapeRenderer.cpp

@@ -78,16 +78,16 @@ template<> void createDebugMesh(ShapeRenderer<3>* renderer, Physics::AbstractSha
 }
 #endif
 
-template<std::uint8_t 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)) {
+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<std::uint8_t dimensions> ShapeRenderer<dimensions>::~ShapeRenderer() {
+template<UnsignedInt dimensions> ShapeRenderer<dimensions>::~ShapeRenderer() {
     for(auto i: renderers) delete i;
 }
 
-template<std::uint8_t dimensions> void ShapeRenderer<dimensions>::draw(const typename DimensionTraits<dimensions>::MatrixType&, SceneGraph::AbstractCamera<dimensions>* camera) {
+template<UnsignedInt dimensions> void ShapeRenderer<dimensions>::draw(const typename DimensionTraits<dimensions>::MatrixType&, SceneGraph::AbstractCamera<dimensions>* camera) {
     typename DimensionTraits<dimensions>::MatrixType projectionMatrix = camera->projectionMatrix()*camera->cameraMatrix();
     for(auto i: renderers) i->draw(options, projectionMatrix);
 }

src/DebugTools/ShapeRenderer.h

@@ -30,14 +30,14 @@ namespace Magnum { namespace DebugTools {
 
 /** @todoc Remove `ifndef` when Doxygen is sane again */
 #ifndef DOXYGEN_GENERATING_OUTPUT
-template<std::uint8_t> class ShapeRenderer;
+template<UnsignedInt> class ShapeRenderer;
 #endif
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 namespace Implementation {
-    template<std::uint8_t> class AbstractShapeRenderer;
+    template<UnsignedInt> class AbstractShapeRenderer;
 
-    template<std::uint8_t dimensions> void createDebugMesh(ShapeRenderer<dimensions>* renderer, Physics::AbstractShape<dimensions>* shape);
+    template<UnsignedInt dimensions> void createDebugMesh(ShapeRenderer<dimensions>* renderer, Physics::AbstractShape<dimensions>* shape);
 }
 #endif
 
@@ -65,7 +65,7 @@ class ShapeRendererOptions {
         }
 
         /** @brief Point size */
-        inline constexpr GLfloat pointSize() const { return _pointSize; }
+        inline constexpr Float pointSize() const { return _pointSize; }
 
         /**
          * @brief Set point size
@@ -74,14 +74,14 @@ class ShapeRendererOptions {
          * Size of rendered crosshairs, representing Physics::Point shapes.
          * Default is `0.25f`.
          */
-        inline ShapeRendererOptions* setPointSize(GLfloat size) {
+        inline ShapeRendererOptions* setPointSize(Float size) {
             _pointSize = size;
             return this;
         }
 
     private:
         Color3<> _color;
-        GLfloat _pointSize;
+        Float _pointSize;
 };
 
 /**
@@ -105,7 +105,7 @@ new DebugTools::ShapeRenderer2D(shape, "red", debugDrawables);
 
 @see ShapeRenderer2D, ShapeRenderer3D
 */
-template<std::uint8_t dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ShapeRenderer: public SceneGraph::Drawable<dimensions> {
+template<UnsignedInt dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ShapeRenderer: public SceneGraph::Drawable<dimensions> {
     #ifndef DOXYGEN_GENERATING_OUTPUT
     friend void Implementation::createDebugMesh<>(ShapeRenderer<dimensions>*, Physics::AbstractShape<dimensions>*);
     #endif
@@ -129,8 +129,8 @@ template<std::uint8_t dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ShapeRenderer:
         ~ShapeRenderer();
 
     protected:
-        /** @todoc Remove GLfloat when Doxygen properly treats this as override */
-        void draw(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, GLfloat>* camera) override;
+        /** @todoc Remove Float when Doxygen properly treats this as override */
+        void draw(const typename DimensionTraits<dimensions, Float>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, Float>* camera) override;
 
     private:
         Resource<ShapeRendererOptions> options;