Extract Buffer::Usage enum out of Buffer class.

Buffer usage is used as parameter in many functions, e.g. in
*Framebuffer::read() and *Texture::image(), but they are rather seldom
used and including whole Buffer.h file just for one enum is just
overkill. The old Buffer::Usage is now alias to BufferUsage, it is
marked as deprecated and will be removed in future release.

src/AbstractFramebuffer.cpp

@@ -199,7 +199,7 @@ void AbstractFramebuffer::read(const Vector2i& offset, const Vector2i& size, Ima
 }
 
 #ifndef MAGNUM_TARGET_GLES2
-void AbstractFramebuffer::read(const Vector2i& offset, const Vector2i& size, BufferImage2D& image, Buffer::Usage usage) {
+void AbstractFramebuffer::read(const Vector2i& offset, const Vector2i& size, BufferImage2D& image, BufferUsage usage) {
     #ifndef MAGNUM_TARGET_GLES2
     bindInternal(FramebufferTarget::Read);
     #else

src/AbstractFramebuffer.h

@@ -31,7 +31,8 @@
 #include <Containers/EnumSet.h>
 
 #include "Math/Geometry/Rectangle.h"
-#include "Buffer.h"
+#include "Magnum.h"
+#include "OpenGL.h"
 
 namespace Magnum {
 
@@ -296,7 +297,7 @@ class MAGNUM_EXPORT AbstractFramebuffer {
          * information.
          * @requires_gles30 Pixel buffer objects are not available in OpenGL ES 2.0.
          */
-        void read(const Vector2i& offset, const Vector2i& size, BufferImage2D& image, Buffer::Usage usage);
+        void read(const Vector2i& offset, const Vector2i& size, BufferImage2D& image, BufferUsage usage);
         #endif
 
     #ifdef DOXYGEN_GENERATING_OUTPUT

src/AbstractTexture.cpp

@@ -24,7 +24,6 @@
 
 #include "AbstractTexture.h"
 
-#include "Buffer.h"
 #include "BufferImage.h"
 #include "ColorFormat.h"
 #include "Context.h"
@@ -1000,7 +999,7 @@ template void MAGNUM_EXPORT AbstractTexture::image<1>(GLenum, GLint, Image<1>&);
 template void MAGNUM_EXPORT AbstractTexture::image<2>(GLenum, GLint, Image<2>&);
 template void MAGNUM_EXPORT AbstractTexture::image<3>(GLenum, GLint, Image<3>&);
 
-template<UnsignedInt dimensions> void AbstractTexture::image(GLenum target, GLint level, BufferImage<dimensions>& image, Buffer::Usage usage) {
+template<UnsignedInt dimensions> void AbstractTexture::image(GLenum target, GLint level, BufferImage<dimensions>& image, BufferUsage usage) {
     const Math::Vector<dimensions, Int> size = DataHelper<dimensions>::imageSize(this, target, level);
     const std::size_t dataSize = size.product()*image.pixelSize();
     if(image.size() != size)
@@ -1010,9 +1009,9 @@ template<UnsignedInt dimensions> void AbstractTexture::image(GLenum target, GLin
     (this->*getImageImplementation)(target, level, image.format(), image.type(), dataSize, nullptr);
 }
 
-template void MAGNUM_EXPORT AbstractTexture::image<1>(GLenum, GLint, BufferImage<1>&, Buffer::Usage);
-template void MAGNUM_EXPORT AbstractTexture::image<2>(GLenum, GLint, BufferImage<2>&, Buffer::Usage);
-template void MAGNUM_EXPORT AbstractTexture::image<3>(GLenum, GLint, BufferImage<3>&, Buffer::Usage);
+template void MAGNUM_EXPORT AbstractTexture::image<1>(GLenum, GLint, BufferImage<1>&, BufferUsage);
+template void MAGNUM_EXPORT AbstractTexture::image<2>(GLenum, GLint, BufferImage<2>&, BufferUsage);
+template void MAGNUM_EXPORT AbstractTexture::image<3>(GLenum, GLint, BufferImage<3>&, BufferUsage);
 #endif
 #endif
 

src/AbstractTexture.h

@@ -29,9 +29,6 @@
  */
 
 #include "Array.h"
-#ifndef MAGNUM_TARGET_GLES2
-#include "Buffer.h"
-#endif
 #include "Color.h"
 #include "Sampler.h"
 
@@ -320,7 +317,7 @@ class MAGNUM_EXPORT AbstractTexture {
 
         #ifndef MAGNUM_TARGET_GLES
         template<UnsignedInt dimensions> void image(GLenum target, GLint level, Image<dimensions>& image);
-        template<UnsignedInt dimensions> void image(GLenum target, GLint level, BufferImage<dimensions>& image, Buffer::Usage usage);
+        template<UnsignedInt dimensions> void image(GLenum target, GLint level, BufferImage<dimensions>& image, BufferUsage usage);
         #endif
 
         GLenum _target;

src/Buffer.cpp

@@ -258,12 +258,12 @@ void Buffer::getSubDataImplementationDSA(const GLintptr offset, const GLsizeiptr
 }
 #endif
 
-void Buffer::dataImplementationDefault(GLsizeiptr size, const GLvoid* data, Buffer::Usage usage) {
+void Buffer::dataImplementationDefault(GLsizeiptr size, const GLvoid* data, BufferUsage usage) {
     glBufferData(GLenum(bindInternal(_targetHint)), size, data, GLenum(usage));
 }
 
 #ifndef MAGNUM_TARGET_GLES
-void Buffer::dataImplementationDSA(GLsizeiptr size, const GLvoid* data, Buffer::Usage usage) {
+void Buffer::dataImplementationDSA(GLsizeiptr size, const GLvoid* data, BufferUsage usage) {
     glNamedBufferDataEXT(_id, size, data, GLenum(usage));
 }
 #endif

src/Buffer.h

@@ -25,7 +25,7 @@
 */
 
 /** @file /Buffer.h
- * @brief Class Magnum::Buffer
+ * @brief Class @ref Magnum::Buffer, enum @ref Magnum::BufferUsage
  */
 
 #include <cstddef>
@@ -41,6 +41,85 @@
 
 namespace Magnum {
 
+/**
+ * @brief %Buffer usage
+ *
+ * @see @ref Buffer::setData(Containers::ArrayReference, BufferUsage)
+ */
+enum class BufferUsage: GLenum {
+    /**
+     * Set once by the application and used infrequently for drawing.
+     */
+    StreamDraw = GL_STREAM_DRAW,
+
+    #ifndef MAGNUM_TARGET_GLES2
+    /**
+     * Set once as output from an OpenGL command and used infequently
+     * for drawing.
+     * @requires_gles30 Only @ref Magnum::Buffer::Usage "Usage::StreamDraw"
+     *      is available in OpenGL ES 2.0.
+     */
+    StreamRead = GL_STREAM_READ,
+
+    /**
+     * Set once as output from an OpenGL command and used infrequently
+     * for drawing or copying to other buffers.
+     * @requires_gles30 Only @ref Magnum::Buffer::Usage "Usage::StreamDraw"
+     *      is available in OpenGL ES 2.0.
+     */
+    StreamCopy = GL_STREAM_COPY,
+    #endif
+
+    /**
+     * Set once by the application and used frequently for drawing.
+     */
+    StaticDraw = GL_STATIC_DRAW,
+
+    #ifndef MAGNUM_TARGET_GLES2
+    /**
+     * Set once as output from an OpenGL command and queried many
+     * times by the application.
+     * @requires_gles30 Only @ref Magnum::Buffer::Usage "Usage::StaticDraw"
+     *      is available in OpenGL ES 2.0.
+     */
+    StaticRead = GL_STATIC_READ,
+
+    /**
+     * Set once as output from an OpenGL command and used frequently
+     * for drawing or copying to other buffers.
+     * @requires_gles30 Only @ref Magnum::Buffer::Usage "Usage::StaticDraw"
+     *      is available in OpenGL ES 2.0.
+     */
+    StaticCopy = GL_STATIC_COPY,
+    #endif
+
+    /**
+     * Updated frequently by the application and used frequently
+     * for drawing or copying to other images.
+     */
+    DynamicDraw = GL_DYNAMIC_DRAW
+
+    #ifndef MAGNUM_TARGET_GLES2
+    ,
+
+    /**
+     * Updated frequently as output from OpenGL command and queried
+     * many times from the application.
+     * @requires_gles30 Only @ref Magnum::Buffer::Usage "Usage::DynamicDraw"
+     *      is available in OpenGL ES 2.0.
+     */
+    DynamicRead = GL_DYNAMIC_READ,
+
+    /**
+     * Updated frequently as output from OpenGL command and used
+     * frequently for drawing or copying to other images.
+     * @requires_gles30 Only @ref Magnum::Buffer::Usage "Usage::DynamicDraw"
+     *      is available in OpenGL ES 2.0.
+     */
+    DynamicCopy = GL_DYNAMIC_COPY
+    #endif
+};
+
 /**
 @brief %Buffer
 
@@ -227,84 +306,13 @@ class MAGNUM_EXPORT Buffer {
             #endif
         };
 
+        #ifdef MAGNUM_BUILD_DEPRECATED
         /**
-         * @brief %Buffer usage
-         *
-         * @see setData(GLsizeiptr, const GLvoid*, Usage)
+         * @copybrief BufferUsage
+         * @deprecated Use @ref Magnum::BufferUsage "BufferUsage" instead.
          */
-        enum class Usage: GLenum {
-            /**
-             * Set once by the application and used infrequently for drawing.
-             */
-            StreamDraw = GL_STREAM_DRAW,
-
-            #ifndef MAGNUM_TARGET_GLES2
-            /**
-             * Set once as output from an OpenGL command and used infequently
-             * for drawing.
-             * @requires_gles30 Only @ref Magnum::Buffer::Usage "Usage::StreamDraw"
-             *      is available in OpenGL ES 2.0.
-             */
-            StreamRead = GL_STREAM_READ,
-
-            /**
-             * Set once as output from an OpenGL command and used infrequently
-             * for drawing or copying to other buffers.
-             * @requires_gles30 Only @ref Magnum::Buffer::Usage "Usage::StreamDraw"
-             *      is available in OpenGL ES 2.0.
-             */
-            StreamCopy = GL_STREAM_COPY,
-            #endif
-
-            /**
-             * Set once by the application and used frequently for drawing.
-             */
-            StaticDraw = GL_STATIC_DRAW,
-
-            #ifndef MAGNUM_TARGET_GLES2
-            /**
-             * Set once as output from an OpenGL command and queried many
-             * times by the application.
-             * @requires_gles30 Only @ref Magnum::Buffer::Usage "Usage::StaticDraw"
-             *      is available in OpenGL ES 2.0.
-             */
-            StaticRead = GL_STATIC_READ,
-
-            /**
-             * Set once as output from an OpenGL command and used frequently
-             * for drawing or copying to other buffers.
-             * @requires_gles30 Only @ref Magnum::Buffer::Usage "Usage::StaticDraw"
-             *      is available in OpenGL ES 2.0.
-             */
-            StaticCopy = GL_STATIC_COPY,
-            #endif
-
-            /**
-             * Updated frequently by the application and used frequently
-             * for drawing or copying to other images.
-             */
-            DynamicDraw = GL_DYNAMIC_DRAW
-
-            #ifndef MAGNUM_TARGET_GLES2
-            ,
-
-            /**
-             * Updated frequently as output from OpenGL command and queried
-             * many times from the application.
-             * @requires_gles30 Only @ref Magnum::Buffer::Usage "Usage::DynamicDraw"
-             *      is available in OpenGL ES 2.0.
-             */
-            DynamicRead = GL_DYNAMIC_READ,
-
-            /**
-             * Updated frequently as output from OpenGL command and used
-             * frequently for drawing or copying to other images.
-             * @requires_gles30 Only @ref Magnum::Buffer::Usage "Usage::DynamicDraw"
-             *      is available in OpenGL ES 2.0.
-             */
-            DynamicCopy = GL_DYNAMIC_COPY
-            #endif
-        };
+        typedef BufferUsage Usage;
+        #endif
 
         #ifndef MAGNUM_TARGET_GLES3
         /**
@@ -643,7 +651,7 @@ class MAGNUM_EXPORT Buffer {
          * @see setTargetHint(), @fn_gl{BindBuffer} and @fn_gl{BufferData} or
          *      @fn_gl_extension{NamedBufferData,EXT,direct_state_access}
          */
-        Buffer& setData(Containers::ArrayReference<const void> data, Usage usage) {
+        Buffer& setData(Containers::ArrayReference<const void> data, BufferUsage usage) {
             (this->*dataImplementation)(data.size(), data, usage);
             return *this;
         }
@@ -667,13 +675,13 @@ class MAGNUM_EXPORT Buffer {
          *
          * @see setData(GLsizeiptr, const GLvoid*, Usage)
          */
-        template<class T> Buffer& setData(const std::vector<T>& data, Usage usage) {
+        template<class T> Buffer& setData(const std::vector<T>& data, BufferUsage usage) {
             setData({data.data(), data.size()}, usage);
             return *this;
         }
 
         /** @overload */
-        template<std::size_t size, class T> Buffer& setData(const std::array<T, size>& data, Usage usage) {
+        template<std::size_t size, class T> Buffer& setData(const std::array<T, size>& data, BufferUsage usage) {
             setData({data.data(), data.size()}, usage);
             return *this;
         }
@@ -905,10 +913,10 @@ class MAGNUM_EXPORT Buffer {
         static GetSubDataImplementation getSubDataImplementation;
         #endif
 
-        typedef void(Buffer::*DataImplementation)(GLsizeiptr, const GLvoid*, Usage);
-        void MAGNUM_LOCAL dataImplementationDefault(GLsizeiptr size, const GLvoid* data, Usage usage);
+        typedef void(Buffer::*DataImplementation)(GLsizeiptr, const GLvoid*, BufferUsage);
+        void MAGNUM_LOCAL dataImplementationDefault(GLsizeiptr size, const GLvoid* data, BufferUsage usage);
         #ifndef MAGNUM_TARGET_GLES
-        void MAGNUM_LOCAL dataImplementationDSA(GLsizeiptr size, const GLvoid* data, Usage usage);
+        void MAGNUM_LOCAL dataImplementationDSA(GLsizeiptr size, const GLvoid* data, BufferUsage usage);
         #endif
         static DataImplementation dataImplementation;
 

src/BufferImage.cpp

@@ -27,7 +27,7 @@
 namespace Magnum {
 
 #ifndef MAGNUM_TARGET_GLES2
-template<UnsignedInt dimensions> void BufferImage<dimensions>::setData(const typename DimensionTraits<Dimensions, Int>::VectorType& size, ColorFormat format, ColorType type, const void* data, Buffer::Usage usage) {
+template<UnsignedInt dimensions> void BufferImage<dimensions>::setData(const typename DimensionTraits<Dimensions, Int>::VectorType& size, ColorFormat format, ColorType type, const void* data, BufferUsage usage) {
     _format = format;
     _type = type;
     _size = size;

src/BufferImage.h

@@ -81,7 +81,7 @@ template<UnsignedInt dimensions> class MAGNUM_EXPORT BufferImage: public Abstrac
          *
          * @see Buffer::setData()
          */
-        void setData(const typename DimensionTraits<Dimensions, Int>::VectorType& size, ColorFormat format, ColorType type, const void* data, Buffer::Usage usage);
+        void setData(const typename DimensionTraits<Dimensions, Int>::VectorType& size, ColorFormat format, ColorType type, const void* data, BufferUsage usage);
 
     private:
         Math::Vector<Dimensions, Int> _size;

src/CubeMapTexture.h

@@ -155,7 +155,7 @@ class CubeMapTexture: public AbstractTexture {
          * information.
          * @requires_gl %Texture image queries are not available in OpenGL ES.
          */
-        void image(Coordinate coordinate, Int level, BufferImage2D& image, Buffer::Usage usage) {
+        void image(Coordinate coordinate, Int level, BufferImage2D& image, BufferUsage usage) {
             AbstractTexture::image<2>(GLenum(coordinate), level, image, usage);
         }
         #endif

src/DebugTools/ForceRenderer.cpp

@@ -79,10 +79,10 @@ template<UnsignedInt dimensions> ForceRenderer<dimensions>::ForceRenderer(SceneG
     Buffer* vertexBuffer = new Buffer(Buffer::Target::Array);
     Buffer* indexBuffer = new Buffer(Buffer::Target::ElementArray);
 
-    vertexBuffer->setData(positions, Buffer::Usage::StaticDraw);
+    vertexBuffer->setData(positions, BufferUsage::StaticDraw);
     ResourceManager::instance().set(this->vertexBuffer.key(), vertexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
 
-    indexBuffer->setData(indices, Buffer::Usage::StaticDraw);
+    indexBuffer->setData(indices, BufferUsage::StaticDraw);
     ResourceManager::instance().set(this->indexBuffer.key(), indexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
 
     Mesh* mesh = new Mesh;

src/DebugTools/Implementation/AbstractShapeRenderer.cpp

@@ -46,7 +46,7 @@ template<UnsignedInt dimensions> void create(typename MeshData<dimensions>::Type
 template<> void create<2>(Trade::MeshData2D& data, Resource<Mesh>& meshResource, Resource<Buffer>& vertexBufferResource, Resource<Buffer>& indexBufferResource) {
     /* Vertex buffer */
     Buffer* buffer = new Buffer(Buffer::Target::Array);
-    buffer->setData(data.positions(0), Buffer::Usage::StaticDraw);
+    buffer->setData(data.positions(0), BufferUsage::StaticDraw);
     ResourceManager::instance().set(vertexBufferResource.key(), buffer, ResourceDataState::Final, ResourcePolicy::Manual);
 
     /* Mesh configuration */
@@ -60,7 +60,7 @@ template<> void create<2>(Trade::MeshData2D& data, Resource<Mesh>& meshResource,
     if(data.isIndexed()) {
         CORRADE_INTERNAL_ASSERT(indexBufferResource.key() != ResourceKey());
         Buffer* indexBuffer = new Buffer(Buffer::Target::ElementArray);
-        MeshTools::compressIndices(*mesh, *indexBuffer, Buffer::Usage::StaticDraw, data.indices());
+        MeshTools::compressIndices(*mesh, *indexBuffer, BufferUsage::StaticDraw, data.indices());
         ResourceManager::instance().set(indexBufferResource.key(), indexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
     }
 }
@@ -68,7 +68,7 @@ template<> void create<2>(Trade::MeshData2D& data, Resource<Mesh>& meshResource,
 template<> void create<3>(Trade::MeshData3D& data, Resource<Mesh>& meshResource, Resource<Buffer>& vertexBufferResource, Resource<Buffer>& indexBufferResource) {
     /* Vertex buffer */
     Buffer* vertexBuffer = new Buffer(Buffer::Target::Array);
-    vertexBuffer->setData(data.positions(0), Buffer::Usage::StaticDraw);
+    vertexBuffer->setData(data.positions(0), BufferUsage::StaticDraw);
     ResourceManager::instance().set(vertexBufferResource.key(), vertexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
 
     /* Mesh configuration */
@@ -82,7 +82,7 @@ template<> void create<3>(Trade::MeshData3D& data, Resource<Mesh>& meshResource,
     if(data.isIndexed()) {
         CORRADE_INTERNAL_ASSERT(indexBufferResource.key() != ResourceKey());
         Buffer* indexBuffer = new Buffer(Buffer::Target::ElementArray);
-        MeshTools::compressIndices(*mesh, *indexBuffer, Buffer::Usage::StaticDraw, data.indices());
+        MeshTools::compressIndices(*mesh, *indexBuffer, BufferUsage::StaticDraw, data.indices());
         ResourceManager::instance().set(indexBufferResource.key(), indexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
     }
 }

src/DebugTools/ObjectRenderer.cpp

@@ -158,10 +158,10 @@ template<UnsignedInt dimensions> ObjectRenderer<dimensions>::ObjectRenderer(Scen
     Buffer* indexBuffer = new Buffer(Buffer::Target::ElementArray);
     Mesh* mesh = new Mesh;
 
-    MeshTools::interleave(*mesh, *vertexBuffer, Buffer::Usage::StaticDraw, Renderer<dimensions>::positions, Renderer<dimensions>::colors);
+    MeshTools::interleave(*mesh, *vertexBuffer, BufferUsage::StaticDraw, Renderer<dimensions>::positions, Renderer<dimensions>::colors);
     ResourceManager::instance().set(this->vertexBuffer.key(), vertexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
 
-    indexBuffer->setData(Renderer<dimensions>::indices, Buffer::Usage::StaticDraw);
+    indexBuffer->setData(Renderer<dimensions>::indices, BufferUsage::StaticDraw);
     ResourceManager::instance().set(this->indexBuffer.key(), indexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
 
     mesh->setPrimitive(Mesh::Primitive::Lines)

src/DefaultFramebuffer.cpp

@@ -24,11 +24,12 @@
 
 #include "DefaultFramebuffer.h"
 
-#include "Context.h"
+#include <Containers/Array.h>
 
+#include "Context.h"
+#include "Extensions.h"
 #include "Implementation/State.h"
 #include "Implementation/FramebufferState.h"
-#include "Extensions.h"
 
 namespace Magnum {
 

src/Magnum.h

@@ -475,6 +475,7 @@ template<class T> class Array1D;
 template<class T> class Array2D;
 template<class T> class Array3D;
 
+enum class BufferUsage: GLenum;
 class Buffer;
 
 #ifndef MAGNUM_TARGET_GLES2

src/MeshTools/CompressIndices.cpp

@@ -26,8 +26,10 @@
 
 #include <cstring>
 #include <algorithm>
+#include <Containers/Array.h>
 
 #include "Math/Functions.h"
+#include "Buffer.h"
 
 namespace Magnum { namespace MeshTools {
 
@@ -69,7 +71,7 @@ std::tuple<std::size_t, Mesh::IndexType, Containers::Array<char>> compressIndice
     return compressIndicesInternal(indices, *std::max_element(indices.begin(), indices.end()));
 }
 
-void compressIndices(Mesh& mesh, Buffer& buffer, Buffer::Usage usage, const std::vector<UnsignedInt>& indices) {
+void compressIndices(Mesh& mesh, Buffer& buffer, BufferUsage usage, const std::vector<UnsignedInt>& indices) {
     auto minmax = std::minmax_element(indices.begin(), indices.end());
 
     /** @todo Performance hint when range can be represented by smaller value? */

src/MeshTools/CompressIndices.h

@@ -30,7 +30,6 @@
 
 #include <tuple>
 
-#include "Buffer.h"
 #include "Mesh.h"
 
 #include "magnumMeshToolsVisibility.h"
@@ -72,7 +71,7 @@ Mesh::setIndexCount() and Mesh::setIndexBuffer() on your own.
 
 @see MeshTools::interleave()
 */
-void MAGNUM_MESHTOOLS_EXPORT compressIndices(Mesh& mesh, Buffer& buffer, Buffer::Usage usage, const std::vector<UnsignedInt>& indices);
+void MAGNUM_MESHTOOLS_EXPORT compressIndices(Mesh& mesh, Buffer& buffer, BufferUsage usage, const std::vector<UnsignedInt>& indices);
 
 }}
 

src/MeshTools/FullScreenTriangle.cpp

@@ -50,7 +50,7 @@ std::pair<Buffer*, Mesh> fullScreenTriangle() {
             Vector2(-1.0, -3.0),
             Vector2( 3.0,  1.0)
         };
-        buffer->setData(triangle, Buffer::Usage::StaticDraw);
+        buffer->setData(triangle, BufferUsage::StaticDraw);
         /** @todo Is it possible to attach moveable buffer here to avoid heap
            allocation? OTOH this is more effective in most (modern) cases */
         mesh.addVertexBuffer(*buffer, 0, AbstractShaderProgram::Attribute<0, Vector2>());

src/MeshTools/Interleave.h

@@ -61,7 +61,7 @@ class Interleave {
             return std::make_tuple(_attributeCount, _stride, std::move(data));
         }
 
-        template<class ...T> void operator()(Mesh& mesh, Buffer& buffer, Buffer::Usage usage, const T&... attributes) {
+        template<class ...T> void operator()(Mesh& mesh, Buffer& buffer, BufferUsage usage, const T&... attributes) {
             Containers::Array<char> data;
             std::tie(std::ignore, std::ignore, data) = operator()(attributes...);
 
@@ -70,7 +70,7 @@ class Interleave {
         }
 
         /* Specialization for only one attribute array */
-        template<class T> typename std::enable_if<!std::is_convertible<T, std::size_t>::value, void>::type operator()(Mesh& mesh, Buffer& buffer, Buffer::Usage usage, const T& attribute) {
+        template<class T> typename std::enable_if<!std::is_convertible<T, std::size_t>::value, void>::type operator()(Mesh& mesh, Buffer& buffer, BufferUsage usage, const T& attribute) {
             mesh.setVertexCount(attribute.size());
             buffer.setData(attribute, usage);
         }
@@ -202,7 +202,7 @@ mesh->setVertexCount(attribute.size());
 
 @see MeshTools::compressIndices()
 */
-template<class ...T> inline void interleave(Mesh& mesh, Buffer& buffer, Buffer::Usage usage, const T&... attributes) {
+template<class ...T> inline void interleave(Mesh& mesh, Buffer& buffer, BufferUsage usage, const T&... attributes) {
     return Implementation::Interleave()(mesh, buffer, usage, attributes...);
 }
 

src/MeshTools/Test/CompressIndicesTest.cpp

@@ -22,6 +22,7 @@
     DEALINGS IN THE SOFTWARE.
 */
 
+#include <Containers/Array.h>
 #include <TestSuite/Tester.h>
 #include <Utility/Endianness.h>
 

src/Test/BufferGLTest.cpp

@@ -86,19 +86,19 @@ void BufferGLTest::data() {
 
     /* Plain array */
     constexpr Int data[] = {2, 7, 5, 13, 25};
-    buffer.setData({data, 5}, Buffer::Usage::StaticDraw);
+    buffer.setData({data, 5}, BufferUsage::StaticDraw);
     MAGNUM_VERIFY_NO_ERROR();
     CORRADE_COMPARE(buffer.size(), 5*4);
 
     /* STL vector */
     std::vector<Int> data2{2, 7, 5, 13, 25};
-    buffer.setData(data2, Buffer::Usage::StaticDraw);
+    buffer.setData(data2, BufferUsage::StaticDraw);
     MAGNUM_VERIFY_NO_ERROR();
     CORRADE_COMPARE(buffer.size(), 5*4);
 
     /* STL array */
     std::array<Int, 5> data3{{2, 7, 5, 13, 25}};
-    buffer.setData(data3, Buffer::Usage::StaticDraw);
+    buffer.setData(data3, BufferUsage::StaticDraw);
     MAGNUM_VERIFY_NO_ERROR();
     CORRADE_COMPARE(buffer.size(), 5*4);
 
@@ -152,7 +152,7 @@ void BufferGLTest::map() {
     Buffer buffer;
 
     constexpr char data[] = {2, 7, 5, 13, 25};
-    buffer.setData(data, Buffer::Usage::StaticDraw);
+    buffer.setData(data, BufferUsage::StaticDraw);
 
     #ifndef MAGNUM_TARGET_GLES2
     char* contents = reinterpret_cast<char*>(buffer.map(Buffer::MapAccess::ReadWrite));
@@ -213,7 +213,7 @@ void BufferGLTest::mapRange() {
 
     constexpr char data[] = {2, 7, 5, 13, 25};
     Buffer buffer;
-    buffer.setData(data, Buffer::Usage::StaticDraw);
+    buffer.setData(data, BufferUsage::StaticDraw);
 
     char* contents = reinterpret_cast<char*>(buffer.map(1, 4, Buffer::MapFlag::Read|Buffer::MapFlag::Write));
     MAGNUM_VERIFY_NO_ERROR();
@@ -244,7 +244,7 @@ void BufferGLTest::mapRangeExplicitFlush() {
 
     constexpr char data[] = {2, 7, 5, 13, 25};
     Buffer buffer;
-    buffer.setData(data, Buffer::Usage::StaticDraw);
+    buffer.setData(data, BufferUsage::StaticDraw);
 
     /* Map, set byte, don't flush and unmap */
     char* contents = reinterpret_cast<char*>(buffer.map(1, 4, Buffer::MapFlag::Write|Buffer::MapFlag::FlushExplicit));
@@ -277,10 +277,10 @@ void BufferGLTest::mapRangeExplicitFlush() {
 void BufferGLTest::copy() {
     Buffer buffer1;
     constexpr char data[] = {2, 7, 5, 13, 25};
-    buffer1.setData(data, Buffer::Usage::StaticDraw);
+    buffer1.setData(data, BufferUsage::StaticDraw);
 
     Buffer buffer2;
-    buffer2.setData({nullptr, 5}, Buffer::Usage::StaticDraw);
+    buffer2.setData({nullptr, 5}, BufferUsage::StaticDraw);
 
     Buffer::copy(buffer1, buffer2, 1, 2, 3);
     MAGNUM_VERIFY_NO_ERROR();
@@ -303,7 +303,7 @@ void BufferGLTest::invalidate() {
 
     Buffer buffer;
     constexpr char data[] = {2, 7, 5, 13, 25};
-    buffer.setData(data, Buffer::Usage::StaticDraw);
+    buffer.setData(data, BufferUsage::StaticDraw);
 
     /* Just test that no errors are emitted */
 

src/Text/Renderer.cpp

@@ -191,7 +191,7 @@ std::pair<Containers::Array<unsigned char>, Mesh::IndexType> renderIndicesIntern
     return {std::move(indices), indexType};
 }
 
-std::tuple<Mesh, Rectangle> renderInternal(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text, Buffer& vertexBuffer, Buffer& indexBuffer, Buffer::Usage usage, Alignment alignment) {
+std::tuple<Mesh, Rectangle> renderInternal(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text, Buffer& vertexBuffer, Buffer& indexBuffer, BufferUsage usage, Alignment alignment) {
     /* Render vertices and upload them */
     std::vector<Vertex> vertices;
     Rectangle rectangle;
@@ -243,7 +243,7 @@ std::tuple<std::vector<Vector2>, std::vector<Vector2>, std::vector<UnsignedInt>,
     return std::make_tuple(std::move(positions), std::move(textureCoordinates), std::move(indices), rectangle);
 }
 
-template<UnsignedInt dimensions> std::tuple<Mesh, Rectangle> Renderer<dimensions>::render(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text, Buffer& vertexBuffer, Buffer& indexBuffer, Buffer::Usage usage, Alignment alignment) {
+template<UnsignedInt dimensions> std::tuple<Mesh, Rectangle> Renderer<dimensions>::render(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text, Buffer& vertexBuffer, Buffer& indexBuffer, BufferUsage usage, Alignment alignment) {
     /* Finalize mesh configuration and return the result */
     auto r = renderInternal(font, cache, size, text, vertexBuffer, indexBuffer, usage, alignment);
     Mesh& mesh = std::get<0>(r);
@@ -329,7 +329,7 @@ template<UnsignedInt dimensions> Renderer<dimensions>::Renderer(AbstractFont& fo
             typename Shaders::AbstractVector<dimensions>::TextureCoordinates());
 }
 
-void AbstractRenderer::reserve(const uint32_t glyphCount, const Buffer::Usage vertexBufferUsage, const Buffer::Usage indexBufferUsage) {
+void AbstractRenderer::reserve(const uint32_t glyphCount, const BufferUsage vertexBufferUsage, const BufferUsage indexBufferUsage) {
     _capacity = glyphCount;
 
     const UnsignedInt vertexCount = glyphCount*4;

src/Text/Renderer.h

@@ -95,7 +95,7 @@ class MAGNUM_TEXT_EXPORT AbstractRenderer {
          * Initially zero capacity is reserved.
          * @see @ref capacity()
          */
-        void reserve(UnsignedInt glyphCount, Buffer::Usage vertexBufferUsage, Buffer::Usage indexBufferUsage);
+        void reserve(UnsignedInt glyphCount, BufferUsage vertexBufferUsage, BufferUsage indexBufferUsage);
 
         /**
          * @brief Render text
@@ -250,7 +250,7 @@ template<UnsignedInt dimensions> class MAGNUM_TEXT_EXPORT Renderer: public Abstr
          * Returns mesh prepared for use with @ref Shaders::AbstractVector
          * subclasses and rectangle spanning the rendered text.
          */
-        static std::tuple<Mesh, Rectangle> render(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text, Buffer& vertexBuffer, Buffer& indexBuffer, Buffer::Usage usage, Alignment alignment = Alignment::LineLeft);
+        static std::tuple<Mesh, Rectangle> render(AbstractFont& font, const GlyphCache& cache, Float size, const std::string& text, Buffer& vertexBuffer, Buffer& indexBuffer, BufferUsage usage, Alignment alignment = Alignment::LineLeft);
 
         /**
          * @brief Constructor

src/Text/Test/RendererGLTest.cpp

@@ -169,7 +169,7 @@ void RendererGLTest::renderMesh() {
     Mesh mesh;
     Buffer vertexBuffer, indexBuffer;
     Rectangle bounds;
-    std::tie(mesh, bounds) = Text::Renderer3D::render(font, *static_cast<GlyphCache*>(nullptr), 0.25f, "abc", vertexBuffer, indexBuffer, Buffer::Usage::StaticDraw, Alignment::TopCenter);
+    std::tie(mesh, bounds) = Text::Renderer3D::render(font, *static_cast<GlyphCache*>(nullptr), 0.25f, "abc", vertexBuffer, indexBuffer, BufferUsage::StaticDraw, Alignment::TopCenter);
     MAGNUM_VERIFY_NO_ERROR();
 
     /* Alignment offset */
@@ -216,7 +216,7 @@ void RendererGLTest::mutableText() {
     CORRADE_COMPARE(renderer.rectangle(), Rectangle());
 
     /* Reserve some capacity */
-    renderer.reserve(4, Buffer::Usage::StaticDraw, Buffer::Usage::StaticDraw);
+    renderer.reserve(4, BufferUsage::StaticDraw, BufferUsage::StaticDraw);
     MAGNUM_VERIFY_NO_ERROR();
     CORRADE_COMPARE(renderer.capacity(), 4);
     /** @todo How to verify this on ES? */

src/Texture.h

@@ -339,7 +339,7 @@ template<UnsignedInt dimensions> class Texture: public AbstractTexture {
          * See image(Int, Image&) for more information.
          * @requires_gl %Texture image queries are not available in OpenGL ES.
          */
-        void image(Int level, BufferImage<dimensions>& image, Buffer::Usage usage) {
+        void image(Int level, BufferImage<dimensions>& image, BufferUsage usage) {
             AbstractTexture::image<dimensions>(_target, level, image, usage);
         }
         #endif

src/TextureTools/DistanceField.cpp

@@ -25,8 +25,10 @@
 #include "TextureTools/DistanceField.h"
 
 #include <Utility/Resource.h>
+
 #include "Math/Geometry/Rectangle.h"
 #include "AbstractShaderProgram.h"
+#include "Buffer.h"
 #include "Extensions.h"
 #include "Framebuffer.h"
 #include "Mesh.h"
@@ -189,7 +191,7 @@ void distanceField(Texture2D& input, Texture2D& output, const Rectanglei& rectan
             Vector2(-1.0, -3.0),
             Vector2( 3.0,  1.0)
         };
-        buffer.setData(triangle, Buffer::Usage::StaticDraw);
+        buffer.setData(triangle, BufferUsage::StaticDraw);
         mesh.addVertexBuffer(buffer, 0, DistanceFieldShader::Position());
     }