Rename some internal buffer enums to better match what they do

src/modules/graphics/Buffer.cpp

@@ -33,8 +33,8 @@ Buffer::Buffer(Graphics *gfx, const Settings &settings, const std::vector<DataDe
 	: arrayLength(0)
 	, arrayStride(0)
 	, size(size)
-	, typeFlags(settings.typeFlags)
-	, usage(settings.usage)
+	, usageFlags(settings.usageFlags)
+	, dataUsage(settings.dataUsage)
 	, mapped(false)
 {
 	if (size == 0 && arraylength == 0)
@@ -46,11 +46,11 @@ Buffer::Buffer(Graphics *gfx, const Settings &settings, const std::vector<DataDe
 	const auto &caps = gfx->getCapabilities();
 	bool supportsGLSL3 = caps.features[Graphics::FEATURE_GLSL3];
 
-	bool indexbuffer = settings.typeFlags & TYPEFLAG_INDEX;
-	bool vertexbuffer = settings.typeFlags & TYPEFLAG_VERTEX;
-	bool texelbuffer = settings.typeFlags & TYPEFLAG_TEXEL;
-	bool storagebuffer = settings.typeFlags & TYPEFLAG_SHADER_STORAGE;
-	bool copydest = settings.typeFlags & TYPEFLAG_COPY_DEST;
+	bool indexbuffer = settings.usageFlags & BUFFERUSAGEFLAG_INDEX;
+	bool vertexbuffer = settings.usageFlags & BUFFERUSAGEFLAG_VERTEX;
+	bool texelbuffer = settings.usageFlags & BUFFERUSAGEFLAG_TEXEL;
+	bool storagebuffer = settings.usageFlags & BUFFERUSAGEFLAG_SHADER_STORAGE;
+	bool copydest = settings.usageFlags & BUFFERUSAGEFLAG_COPY_DEST;
 
 	if (!indexbuffer && !vertexbuffer && !texelbuffer && !storagebuffer)
 		throw love::Exception("Buffer must be created with at least one buffer type (index, vertex, texel, or shaderstorage).");
@@ -61,8 +61,8 @@ Buffer::Buffer(Graphics *gfx, const Settings &settings, const std::vector<DataDe
 	if (storagebuffer && !caps.features[Graphics::FEATURE_GLSL4])
 		throw love::Exception("Shader Storage buffers are not supported on this system (GLSL 4 support is necessary.)");
 
-	if (copydest && usage == BUFFERUSAGE_STREAM)
-		throw love::Exception("Buffers created with 'stream' usage cannot be a copy destination.");
+	if (copydest && dataUsage == BUFFERDATAUSAGE_STREAM)
+		throw love::Exception("Buffers created with 'stream' data usage cannot be used as a copy destination.");
 
 	size_t offset = 0;
 	size_t stride = 0;

src/modules/graphics/Buffer.h

@@ -55,17 +55,6 @@ public:
 		MAP_WRITE_INVALIDATE,
 	};
 
-	enum TypeFlags
-	{
-		TYPEFLAG_NONE = 0,
-		TYPEFLAG_VERTEX = 1 << BUFFERTYPE_VERTEX,
-		TYPEFLAG_INDEX = 1 << BUFFERTYPE_INDEX,
-		TYPEFLAG_TEXEL = 1 << BUFFERTYPE_TEXEL,
-		TYPEFLAG_SHADER_STORAGE = 1 << BUFFERTYPE_SHADER_STORAGE,
-		TYPEFLAG_COPY_SOURCE = 1 << BUFFERTYPE_COPY_SOURCE,
-		TYPEFLAG_COPY_DEST = 1 << BUFFERTYPE_COPY_DEST,
-	};
-
 	struct DataDeclaration
 	{
 		std::string name;
@@ -96,13 +85,13 @@ public:
 
 	struct Settings
 	{
-		TypeFlags typeFlags;
-		BufferUsage usage;
+		BufferUsageFlags usageFlags;
+		BufferDataUsage dataUsage;
 		bool zeroInitialize;
 
-		Settings(uint32 typeflags, BufferUsage usage)
-			: typeFlags((TypeFlags)typeflags)
-			, usage(usage)
+		Settings(uint32 usageflags, BufferDataUsage dataUsage)
+			: usageFlags((BufferUsageFlags)usageflags)
+			, dataUsage(dataUsage)
 			, zeroInitialize(false)
 		{}
 	};
@@ -111,8 +100,8 @@ public:
 	virtual ~Buffer();
 
 	size_t getSize() const { return size; }
-	TypeFlags getTypeFlags() const { return typeFlags; }
-	BufferUsage getUsage() const { return usage; }
+	BufferUsageFlags getUsageFlags() const { return usageFlags; }
+	BufferDataUsage getDataUsage() const { return dataUsage; }
 	bool isMapped() const { return mapped; }
 
 	size_t getArrayLength() const { return arrayLength; }
@@ -180,11 +169,11 @@ protected:
 	// The size of the buffer, in bytes.
 	size_t size;
 
-	// The type of the buffer object.
-	TypeFlags typeFlags;
+	// Bit flags describing how the buffer can be used.
+	BufferUsageFlags usageFlags;
 
 	// Usage hint. GL_[DYNAMIC, STATIC, STREAM]_DRAW.
-	BufferUsage usage;
+	BufferDataUsage dataUsage;
 
 	bool mapped;
 	

src/modules/graphics/Graphics.cpp

@@ -177,7 +177,7 @@ void Graphics::createQuadIndexBuffer()
 
 	size_t size = sizeof(uint16) * (LOVE_UINT16_MAX / 4) * 6;
 
-	Buffer::Settings settings(Buffer::TYPEFLAG_INDEX, BUFFERUSAGE_STATIC);
+	Buffer::Settings settings(BUFFERUSAGEFLAG_INDEX, BUFFERDATAUSAGE_STATIC);
 	quadIndexBuffer = newBuffer(settings, DATAFORMAT_UINT16, nullptr, size, 0);
 
 	Buffer::Mapper map(*quadIndexBuffer);
@@ -209,7 +209,7 @@ Video *Graphics::newVideo(love::video::VideoStream *stream, float dpiscale)
 	return new Video(this, stream, dpiscale);
 }
 
-love::graphics::SpriteBatch *Graphics::newSpriteBatch(Texture *texture, int size, BufferUsage usage)
+love::graphics::SpriteBatch *Graphics::newSpriteBatch(Texture *texture, int size, BufferDataUsage usage)
 {
 	return new SpriteBatch(this, texture, size, usage);
 }
@@ -300,12 +300,12 @@ Buffer *Graphics::newBuffer(const Buffer::Settings &settings, DataFormat format,
 	return newBuffer(settings, dataformat, data, size, arraylength);
 }
 
-Mesh *Graphics::newMesh(const std::vector<Buffer::DataDeclaration> &vertexformat, int vertexcount, PrimitiveType drawmode, BufferUsage usage)
+Mesh *Graphics::newMesh(const std::vector<Buffer::DataDeclaration> &vertexformat, int vertexcount, PrimitiveType drawmode, BufferDataUsage usage)
 {
 	return new Mesh(this, vertexformat, vertexcount, drawmode, usage);
 }
 
-Mesh *Graphics::newMesh(const std::vector<Buffer::DataDeclaration> &vertexformat, const void *data, size_t datasize, PrimitiveType drawmode, BufferUsage usage)
+Mesh *Graphics::newMesh(const std::vector<Buffer::DataDeclaration> &vertexformat, const void *data, size_t datasize, PrimitiveType drawmode, BufferDataUsage usage)
 {
 	return new Mesh(this, vertexformat, data, datasize, drawmode, usage);
 }
@@ -1044,10 +1044,10 @@ void Graphics::copyBuffer(Buffer *source, Buffer *dest, size_t sourceoffset, siz
 	if (!capabilities.features[FEATURE_COPY_BUFFER])
 		throw love::Exception("Buffer copying is not supported on this system.");
 
-	if (!(source->getTypeFlags() & Buffer::TYPEFLAG_COPY_SOURCE))
+	if (!(source->getUsageFlags() & BUFFERUSAGEFLAG_COPY_SOURCE))
 		throw love::Exception("Copy source buffer must be created with the copysource flag.");
 
-	if (!(dest->getTypeFlags() & Buffer::TYPEFLAG_COPY_DEST))
+	if (!(dest->getUsageFlags() & BUFFERUSAGEFLAG_COPY_DEST))
 		throw love::Exception("Copy destination buffer must be created with the copydest flag.");
 
 	Range sourcerange(sourceoffset, size);
@@ -1151,14 +1151,14 @@ Graphics::BatchedVertexData Graphics::requestBatchedDraw(const BatchedDrawComman
 			if (state.vb[i]->getSize() < buffersizes[i])
 			{
 				delete state.vb[i];
-				state.vb[i] = newStreamBuffer(BUFFERTYPE_VERTEX, buffersizes[i]);
+				state.vb[i] = newStreamBuffer(BUFFERUSAGE_VERTEX, buffersizes[i]);
 			}
 		}
 
 		if (state.indexBuffer->getSize() < buffersizes[2])
 		{
 			delete state.indexBuffer;
-			state.indexBuffer = newStreamBuffer(BUFFERTYPE_INDEX, buffersizes[2]);
+			state.indexBuffer = newStreamBuffer(BUFFERUSAGE_INDEX, buffersizes[2]);
 		}
 	}
 

src/modules/graphics/Graphics.h

@@ -432,7 +432,7 @@ public:
 	Font *newDefaultFont(int size, font::TrueTypeRasterizer::Hinting hinting);
 	Video *newVideo(love::video::VideoStream *stream, float dpiscale);
 
-	SpriteBatch *newSpriteBatch(Texture *texture, int size, BufferUsage usage);
+	SpriteBatch *newSpriteBatch(Texture *texture, int size, BufferDataUsage usage);
 	ParticleSystem *newParticleSystem(Texture *texture, int size);
 
 	Shader *newShader(const std::vector<std::string> &stagessource);
@@ -440,8 +440,8 @@ public:
 	virtual Buffer *newBuffer(const Buffer::Settings &settings, const std::vector<Buffer::DataDeclaration> &format, const void *data, size_t size, size_t arraylength) = 0;
 	virtual Buffer *newBuffer(const Buffer::Settings &settings, DataFormat format, const void *data, size_t size, size_t arraylength);
 
-	Mesh *newMesh(const std::vector<Buffer::DataDeclaration> &vertexformat, int vertexcount, PrimitiveType drawmode, BufferUsage usage);
-	Mesh *newMesh(const std::vector<Buffer::DataDeclaration> &vertexformat, const void *data, size_t datasize, PrimitiveType drawmode, BufferUsage usage);
+	Mesh *newMesh(const std::vector<Buffer::DataDeclaration> &vertexformat, int vertexcount, PrimitiveType drawmode, BufferDataUsage usage);
+	Mesh *newMesh(const std::vector<Buffer::DataDeclaration> &vertexformat, const void *data, size_t datasize, PrimitiveType drawmode, BufferDataUsage usage);
 	Mesh *newMesh(const std::vector<Mesh::BufferAttribute> &attributes, PrimitiveType drawmode);
 
 	Text *newText(Font *font, const std::vector<Font::ColoredString> &text = {});
@@ -930,7 +930,7 @@ protected:
 	ShaderStage *newShaderStage(ShaderStage::StageType stage, const std::string &source, const Shader::SourceInfo &info);
 	virtual ShaderStage *newShaderStageInternal(ShaderStage::StageType stage, const std::string &cachekey, const std::string &source, bool gles) = 0;
 	virtual Shader *newShaderInternal(ShaderStage *vertex, ShaderStage *pixel) = 0;
-	virtual StreamBuffer *newStreamBuffer(BufferType type, size_t size) = 0;
+	virtual StreamBuffer *newStreamBuffer(BufferUsage type, size_t size) = 0;
 
 	virtual void setRenderTargetsInternal(const RenderTargets &rts, int w, int h, int pixelw, int pixelh, bool hasSRGBtexture) = 0;
 

src/modules/graphics/Mesh.cpp

@@ -45,7 +45,7 @@ std::vector<Buffer::DataDeclaration> Mesh::getDefaultVertexFormat()
 
 love::Type Mesh::type("Mesh", &Drawable::type);
 
-Mesh::Mesh(graphics::Graphics *gfx, const std::vector<Buffer::DataDeclaration> &vertexformat, const void *data, size_t datasize, PrimitiveType drawmode, BufferUsage usage)
+Mesh::Mesh(graphics::Graphics *gfx, const std::vector<Buffer::DataDeclaration> &vertexformat, const void *data, size_t datasize, PrimitiveType drawmode, BufferDataUsage usage)
 	: primitiveType(drawmode)
 {
 	try
@@ -59,7 +59,7 @@ Mesh::Mesh(graphics::Graphics *gfx, const std::vector<Buffer::DataDeclaration> &
 
 	memcpy(vertexData, data, datasize);
 
-	Buffer::Settings settings(Buffer::TYPEFLAG_VERTEX, usage);
+	Buffer::Settings settings(BUFFERUSAGEFLAG_VERTEX, usage);
 	vertexBuffer.set(gfx->newBuffer(settings, vertexformat, vertexData, datasize, 0), Acquire::NORETAIN);
 
 	vertexCount = vertexBuffer->getArrayLength();
@@ -71,7 +71,7 @@ Mesh::Mesh(graphics::Graphics *gfx, const std::vector<Buffer::DataDeclaration> &
 	indexDataType = getIndexDataTypeFromMax(vertexCount);
 }
 
-Mesh::Mesh(graphics::Graphics *gfx, const std::vector<Buffer::DataDeclaration> &vertexformat, int vertexcount, PrimitiveType drawmode, BufferUsage usage)
+Mesh::Mesh(graphics::Graphics *gfx, const std::vector<Buffer::DataDeclaration> &vertexformat, int vertexcount, PrimitiveType drawmode, BufferDataUsage usage)
 	: vertexCount((size_t) vertexcount)
 	, indexDataType(getIndexDataTypeFromMax(vertexcount))
 	, primitiveType(drawmode)
@@ -79,7 +79,7 @@ Mesh::Mesh(graphics::Graphics *gfx, const std::vector<Buffer::DataDeclaration> &
 	if (vertexcount <= 0)
 		throw love::Exception("Invalid number of vertices (%d).", vertexcount);
 
-	Buffer::Settings settings(Buffer::TYPEFLAG_VERTEX, usage);
+	Buffer::Settings settings(BUFFERUSAGEFLAG_VERTEX, usage);
 	vertexBuffer.set(gfx->newBuffer(settings, vertexformat, nullptr, 0, vertexcount), Acquire::NORETAIN);
 
 	vertexStride = vertexBuffer->getArrayStride();
@@ -112,7 +112,7 @@ Mesh::Mesh(const std::vector<Mesh::BufferAttribute> &attributes, PrimitiveType d
 
 	for (const auto &attrib : attachedAttributes)
 	{
-		if ((attrib.buffer->getTypeFlags() & Buffer::TYPEFLAG_VERTEX) == 0)
+		if ((attrib.buffer->getUsageFlags() & BUFFERUSAGEFLAG_VERTEX) == 0)
 			throw love::Exception("Buffer must be created with vertex buffer support to be used as a Mesh vertex attribute.");
 
 		if (getAttachedAttributeIndex(attrib.name) != -1)
@@ -210,7 +210,7 @@ bool Mesh::isAttributeEnabled(const std::string &name) const
 
 void Mesh::attachAttribute(const std::string &name, Buffer *buffer, Mesh *mesh, const std::string &attachname, AttributeStep step)
 {
-	if ((buffer->getTypeFlags() & Buffer::TYPEFLAG_VERTEX) == 0)
+	if ((buffer->getUsageFlags() & BUFFERUSAGEFLAG_VERTEX) == 0)
 		throw love::Exception("Buffer must be created with vertex buffer support to be used as a Mesh vertex attribute.");
 
 	auto gfx = Module::getInstance<Graphics>(Module::M_GRAPHICS);
@@ -276,7 +276,7 @@ void Mesh::flush()
 {
 	if (vertexBuffer.get() && vertexData != nullptr && modifiedVertexData.isValid())
 	{
-		if (vertexBuffer->getUsage() == BUFFERUSAGE_STREAM)
+		if (vertexBuffer->getDataUsage() == BUFFERDATAUSAGE_STREAM)
 		{
 			vertexBuffer->fill(0, vertexBuffer->getSize(), vertexData);
 		}
@@ -327,8 +327,8 @@ void Mesh::setVertexMap(const std::vector<uint32> &map)
 	if (indexBuffer.get() == nullptr || size > indexBuffer->getSize() || indexBuffer->getDataMember(0).decl.format != dataformat)
 	{
 		auto gfx = Module::getInstance<graphics::Graphics>(Module::M_GRAPHICS);
-		auto usage = vertexBuffer.get() ? vertexBuffer->getUsage() : BUFFERUSAGE_DYNAMIC;
-		Buffer::Settings settings(Buffer::TYPEFLAG_INDEX, usage);
+		auto usage = vertexBuffer.get() ? vertexBuffer->getDataUsage() : BUFFERDATAUSAGE_DYNAMIC;
+		Buffer::Settings settings(BUFFERUSAGEFLAG_INDEX, usage);
 		indexBuffer.set(gfx->newBuffer(settings, dataformat, nullptr, size, 0), Acquire::NORETAIN);
 	}
 
@@ -360,8 +360,8 @@ void Mesh::setVertexMap(IndexDataType datatype, const void *data, size_t datasiz
 	if (indexBuffer.get() == nullptr || datasize > indexBuffer->getSize() || indexBuffer->getDataMember(0).decl.format != dataformat)
 	{
 		auto gfx = Module::getInstance<graphics::Graphics>(Module::M_GRAPHICS);
-		auto usage = vertexBuffer.get() ? vertexBuffer->getUsage() : BUFFERUSAGE_DYNAMIC;
-		Buffer::Settings settings(Buffer::TYPEFLAG_INDEX, usage);
+		auto usage = vertexBuffer.get() ? vertexBuffer->getDataUsage() : BUFFERDATAUSAGE_DYNAMIC;
+		Buffer::Settings settings(BUFFERUSAGEFLAG_INDEX, usage);
 		indexBuffer.set(gfx->newBuffer(settings, dataformat, nullptr, datasize, 0), Acquire::NORETAIN);
 	}
 
@@ -423,7 +423,7 @@ void Mesh::setIndexBuffer(Buffer *buffer)
 {
 	// Buffer constructor does the rest of the validation for index buffers
 	// (data member formats, etc.)
-	if (buffer != nullptr && (buffer->getTypeFlags() & Buffer::TYPEFLAG_INDEX) == 0)
+	if (buffer != nullptr && (buffer->getUsageFlags() & BUFFERUSAGEFLAG_INDEX) == 0)
 		throw love::Exception("setIndexBuffer requires a Buffer created as an index buffer.");
 
 	indexBuffer.set(buffer);

src/modules/graphics/Mesh.h

@@ -63,8 +63,8 @@ public:
 
 	static love::Type type;
 
-	Mesh(Graphics *gfx, const std::vector<Buffer::DataDeclaration> &vertexformat, const void *data, size_t datasize, PrimitiveType drawmode, BufferUsage usage);
-	Mesh(Graphics *gfx, const std::vector<Buffer::DataDeclaration> &vertexformat, int vertexcount, PrimitiveType drawmode, BufferUsage usage);
+	Mesh(Graphics *gfx, const std::vector<Buffer::DataDeclaration> &vertexformat, const void *data, size_t datasize, PrimitiveType drawmode, BufferDataUsage usage);
+	Mesh(Graphics *gfx, const std::vector<Buffer::DataDeclaration> &vertexformat, int vertexcount, PrimitiveType drawmode, BufferDataUsage usage);
 	Mesh(const std::vector<BufferAttribute> &attributes, PrimitiveType drawmode);
 
 	virtual ~Mesh();

src/modules/graphics/ParticleSystem.cpp

@@ -191,7 +191,7 @@ void ParticleSystem::createBuffers(size_t size)
 		auto gfx = Module::getInstance<Graphics>(Module::M_GRAPHICS);
 
 		size_t bytes = sizeof(Vertex) * size * 4;
-		Buffer::Settings settings(Buffer::TYPEFLAG_VERTEX, BUFFERUSAGE_STREAM);
+		Buffer::Settings settings(BUFFERUSAGEFLAG_VERTEX, BUFFERDATAUSAGE_STREAM);
 		auto decl = Buffer::getCommonFormatDeclaration(CommonFormat::XYf_STf_RGBAub);
 		buffer = gfx->newBuffer(settings, decl, nullptr, bytes, 0);
 	}

src/modules/graphics/SpriteBatch.cpp

@@ -40,7 +40,7 @@ namespace graphics
 
 love::Type SpriteBatch::type("SpriteBatch", &Drawable::type);
 
-SpriteBatch::SpriteBatch(Graphics *gfx, Texture *texture, int size, BufferUsage usage)
+SpriteBatch::SpriteBatch(Graphics *gfx, Texture *texture, int size, BufferDataUsage usage)
 	: texture(texture)
 	, size(size)
 	, next(0)
@@ -73,7 +73,7 @@ SpriteBatch::SpriteBatch(Graphics *gfx, Texture *texture, int size, BufferUsage
 
 	memset(vertex_data, 0, vertex_size);
 
-	Buffer::Settings settings(Buffer::TYPEFLAG_VERTEX, usage);
+	Buffer::Settings settings(BUFFERUSAGEFLAG_VERTEX, usage);
 	auto decl = Buffer::getCommonFormatDeclaration(vertex_format);
 
 	array_buf.set(gfx->newBuffer(settings, decl, nullptr, vertex_size, 0), Acquire::NORETAIN);
@@ -185,7 +185,7 @@ void SpriteBatch::flush()
 		size_t offset = modified_sprites.getOffset() * vertex_stride * 4;
 		size_t size = modified_sprites.getSize() * vertex_stride * 4;
 
-		if (array_buf->getUsage() == BUFFERUSAGE_STREAM)
+		if (array_buf->getDataUsage() == BUFFERDATAUSAGE_STREAM)
 			array_buf->fill(0, array_buf->getSize(), vertex_data);
 		else
 			array_buf->fill(offset, size, vertex_data + offset);
@@ -244,7 +244,7 @@ void SpriteBatch::setBufferSize(int newsize)
 		throw love::Exception("Out of memory.");
 
 	auto gfx = Module::getInstance<graphics::Graphics>(Module::M_GRAPHICS);
-	Buffer::Settings settings(array_buf->getTypeFlags(), array_buf->getUsage());
+	Buffer::Settings settings(array_buf->getUsageFlags(), array_buf->getDataUsage());
 	auto decl = Buffer::getCommonFormatDeclaration(vertex_format);
 
 	array_buf.set(gfx->newBuffer(settings, decl, nullptr, vertex_size, 0), Acquire::NORETAIN);
@@ -264,7 +264,7 @@ int SpriteBatch::getBufferSize() const
 
 void SpriteBatch::attachAttribute(const std::string &name, Buffer *buffer, Mesh *mesh)
 {
-	if ((buffer->getTypeFlags() & Buffer::TYPEFLAG_VERTEX) == 0)
+	if ((buffer->getUsageFlags() & BUFFERUSAGEFLAG_VERTEX) == 0)
 		throw love::Exception("GraphicsBuffer must be created with vertex buffer support to be used as a SpriteBatch vertex attribute.");
 
 	AttachedAttribute oldattrib = {};

src/modules/graphics/SpriteBatch.h

@@ -52,7 +52,7 @@ public:
 
 	static love::Type type;
 
-	SpriteBatch(Graphics *gfx, Texture *texture, int size, BufferUsage usage);
+	SpriteBatch(Graphics *gfx, Texture *texture, int size, BufferDataUsage usage);
 	virtual ~SpriteBatch();
 
 	int add(const Matrix4 &m, int index = -1);

src/modules/graphics/StreamBuffer.cpp

@@ -26,7 +26,7 @@ namespace love
 namespace graphics
 {
 
-StreamBuffer::StreamBuffer(BufferType mode, size_t size)
+StreamBuffer::StreamBuffer(BufferUsage mode, size_t size)
 	: bufferSize(size)
 	, frameGPUReadOffset(0)
 	, mode(mode)

src/modules/graphics/StreamBuffer.h

@@ -53,7 +53,7 @@ public:
 	virtual ~StreamBuffer() {}
 
 	size_t getSize() const { return bufferSize; }
-	BufferType getMode() const { return mode; }
+	BufferUsage getMode() const { return mode; }
 	size_t getUsableSize() const { return bufferSize - frameGPUReadOffset; }
 
 	virtual MapInfo map(size_t minsize) = 0;
@@ -64,11 +64,11 @@ public:
 
 protected:
 
-	StreamBuffer(BufferType mode, size_t size);
+	StreamBuffer(BufferUsage mode, size_t size);
 
 	size_t bufferSize;
 	size_t frameGPUReadOffset;
-	BufferType mode;
+	BufferUsage mode;
 
 }; // StreamBuffer
 

src/modules/graphics/Text.cpp

@@ -63,7 +63,7 @@ void Text::uploadVertices(const std::vector<Font::GlyphVertex> &vertices, size_t
 
 		auto gfx = Module::getInstance<Graphics>(Module::M_GRAPHICS);
 
-		Buffer::Settings settings(Buffer::TYPEFLAG_VERTEX, BUFFERUSAGE_DYNAMIC);
+		Buffer::Settings settings(BUFFERUSAGEFLAG_VERTEX, BUFFERDATAUSAGE_DYNAMIC);
 		auto decl = Buffer::getCommonFormatDeclaration(Font::vertexFormat);
 		Buffer *newbuffer = gfx->newBuffer(settings, decl, nullptr, newsize, 0);
 
@@ -279,7 +279,7 @@ void Text::draw(Graphics *gfx, const Matrix4 &m)
 		size_t offset = modifiedVertices.getOffset();
 		size_t size = modifiedVertices.getSize();
 
-		if (vertexBuffer->getUsage() == BUFFERUSAGE_STREAM)
+		if (vertexBuffer->getDataUsage() == BUFFERDATAUSAGE_STREAM)
 			vertexBuffer->fill(0, vertexBuffer->getSize(), vertexData);
 		else
 			vertexBuffer->fill(offset, size, vertexData + offset);

src/modules/graphics/opengl/Buffer.cpp

@@ -72,22 +72,22 @@ Buffer::Buffer(love::graphics::Graphics *gfx, const Settings &settings, const st
 	size = getSize();
 	arraylength = getArrayLength();
 
-	if (typeFlags & TYPEFLAG_TEXEL)
-		mapType = BUFFERTYPE_TEXEL;
-	else if (typeFlags & TYPEFLAG_VERTEX)
-		mapType = BUFFERTYPE_VERTEX;
-	else if (typeFlags & TYPEFLAG_INDEX)
-		mapType = BUFFERTYPE_INDEX;
-	else  if (typeFlags & TYPEFLAG_SHADER_STORAGE)
-		mapType = BUFFERTYPE_SHADER_STORAGE;
-	else if (typeFlags & TYPEFLAG_COPY_SOURCE)
-		mapType = BUFFERTYPE_COPY_SOURCE;
-	else if (typeFlags & TYPEFLAG_COPY_DEST)
-		mapType = BUFFERTYPE_COPY_DEST;
-
-	target = OpenGL::getGLBufferType(mapType);
-
-	if (usage == BUFFERUSAGE_STREAM)
+	if (usageFlags & BUFFERUSAGEFLAG_TEXEL)
+		mapUsage = BUFFERUSAGE_TEXEL;
+	else if (usageFlags & BUFFERUSAGEFLAG_VERTEX)
+		mapUsage = BUFFERUSAGE_VERTEX;
+	else if (usageFlags & BUFFERUSAGEFLAG_INDEX)
+		mapUsage = BUFFERUSAGE_INDEX;
+	else  if (usageFlags & BUFFERUSAGEFLAG_SHADER_STORAGE)
+		mapUsage = BUFFERUSAGE_SHADER_STORAGE;
+	else if (usageFlags & BUFFERUSAGEFLAG_COPY_SOURCE)
+		mapUsage = BUFFERUSAGE_COPY_SOURCE;
+	else if (usageFlags & BUFFERUSAGEFLAG_COPY_DEST)
+		mapUsage = BUFFERUSAGE_COPY_DEST;
+
+	target = OpenGL::getGLBufferType(mapUsage);
+
+	if (dataUsage == BUFFERDATAUSAGE_STREAM)
 		ownsMemoryMap = true;
 
 	std::vector<uint8> emptydata;
@@ -143,12 +143,14 @@ bool Buffer::load(const void *initialdata)
 		/* Clear the error buffer. */;
 
 	glGenBuffers(1, &buffer);
-	gl.bindBuffer(mapType, buffer);
+	gl.bindBuffer(mapUsage, buffer);
+
+	GLenum gldatausage = OpenGL::getGLBufferDataUsage(getDataUsage());
 
 	// initialdata can be null.
-	glBufferData(target, (GLsizeiptr) getSize(), initialdata, OpenGL::getGLBufferUsage(getUsage()));
+	glBufferData(target, (GLsizeiptr) getSize(), initialdata, gldatausage);
 
-	if (getTypeFlags() & TYPEFLAG_TEXEL)
+	if (getUsageFlags() & BUFFERUSAGEFLAG_TEXEL)
 	{
 		glGenTextures(1, &texture);
 		gl.bindBufferTextureToUnit(texture, 0, false, true);
@@ -204,7 +206,7 @@ void Buffer::unmap(size_t usedoffset, size_t usedsize)
 	mapped = false;
 
 	// Orphan optimization - see fill().
-	if (usage != BUFFERUSAGE_STATIC && mappedRange.first == 0 && mappedRange.getSize() == getSize())
+	if (dataUsage != BUFFERDATAUSAGE_STATIC && mappedRange.first == 0 && mappedRange.getSize() == getSize())
 	{
 		usedoffset = 0;
 		usedsize = getSize();
@@ -232,21 +234,21 @@ void Buffer::fill(size_t offset, size_t size, const void *data)
 	if (!Range(0, buffersize).contains(Range(offset, size)))
 		return;
 
-	GLenum glusage = OpenGL::getGLBufferUsage(usage);
+	GLenum gldatausage = OpenGL::getGLBufferDataUsage(dataUsage);
 
-	gl.bindBuffer(mapType, buffer);
+	gl.bindBuffer(mapUsage, buffer);
 
-	if (usage != BUFFERUSAGE_STATIC && size == buffersize)
+	if (dataUsage != BUFFERDATAUSAGE_STATIC && size == buffersize)
 	{
 		// "orphan" current buffer to avoid implicit synchronisation on the GPU:
 		// http://www.seas.upenn.edu/~pcozzi/OpenGLInsights/OpenGLInsights-AsynchronousBufferTransfers.pdf
-		gl.bindBuffer(mapType, buffer);
-		glBufferData(target, (GLsizeiptr) buffersize, nullptr, glusage);
+		gl.bindBuffer(mapUsage, buffer);
+		glBufferData(target, (GLsizeiptr) buffersize, nullptr, gldatausage);
 
 #if LOVE_WINDOWS
 		// TODO: Verify that this codepath is a useful optimization.
 		if (gl.getVendor() == OpenGL::VENDOR_INTEL)
-			glBufferData(target, (GLsizeiptr) buffersize, data, glusage);
+			glBufferData(target, (GLsizeiptr) buffersize, data, gldatausage);
 		else
 #endif
 			glBufferSubData(target, 0, (GLsizeiptr) buffersize, data);
@@ -259,8 +261,8 @@ void Buffer::fill(size_t offset, size_t size, const void *data)
 
 void Buffer::copyTo(love::graphics::Buffer *dest, size_t sourceoffset, size_t destoffset, size_t size)
 {
-	gl.bindBuffer(BUFFERTYPE_COPY_SOURCE, buffer);
-	gl.bindBuffer(BUFFERTYPE_COPY_DEST, ((Buffer *) dest)->buffer);
+	gl.bindBuffer(BUFFERUSAGE_COPY_SOURCE, buffer);
+	gl.bindBuffer(BUFFERUSAGE_COPY_DEST, ((Buffer *) dest)->buffer);
 
 	glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, sourceoffset, destoffset, size);
 }

src/modules/graphics/opengl/Buffer.h

@@ -65,7 +65,7 @@ private:
 	void unmapStatic(size_t offset, size_t size);
 	void unmapStream();
 
-	BufferType mapType = BUFFERTYPE_VERTEX;
+	BufferUsage mapUsage = BUFFERUSAGE_VERTEX;
 	GLenum target = 0;
 
 	// The buffer object identifier. Assigned by OpenGL.

src/modules/graphics/opengl/Graphics.cpp

@@ -140,7 +140,7 @@ const char *Graphics::getName() const
 	return "love.graphics.opengl";
 }
 
-love::graphics::StreamBuffer *Graphics::newStreamBuffer(BufferType type, size_t size)
+love::graphics::StreamBuffer *Graphics::newStreamBuffer(BufferUsage type, size_t size)
 {
 	return CreateStreamBuffer(type, size);
 }
@@ -333,46 +333,46 @@ bool Graphics::setMode(int width, int height, int pixelwidth, int pixelheight, b
 	{
 		// Initial sizes that should be good enough for most cases. It will
 		// resize to fit if needed, later.
-		batchedDrawState.vb[0] = CreateStreamBuffer(BUFFERTYPE_VERTEX, 1024 * 1024 * 1);
-		batchedDrawState.vb[1] = CreateStreamBuffer(BUFFERTYPE_VERTEX, 256  * 1024 * 1);
-		batchedDrawState.indexBuffer = CreateStreamBuffer(BUFFERTYPE_INDEX, sizeof(uint16) * LOVE_UINT16_MAX);
+		batchedDrawState.vb[0] = CreateStreamBuffer(BUFFERUSAGE_VERTEX, 1024 * 1024 * 1);
+		batchedDrawState.vb[1] = CreateStreamBuffer(BUFFERUSAGE_VERTEX, 256  * 1024 * 1);
+		batchedDrawState.indexBuffer = CreateStreamBuffer(BUFFERUSAGE_INDEX, sizeof(uint16) * LOVE_UINT16_MAX);
 	}
 
-	if (capabilities.features[FEATURE_TEXEL_BUFFER] && defaultBuffers[BUFFERTYPE_TEXEL].get() == nullptr)
+	if (capabilities.features[FEATURE_TEXEL_BUFFER] && defaultBuffers[BUFFERUSAGE_TEXEL].get() == nullptr)
 	{
-		Buffer::Settings settings(Buffer::TYPEFLAG_TEXEL, BUFFERUSAGE_STATIC);
+		Buffer::Settings settings(BUFFERUSAGEFLAG_TEXEL, BUFFERDATAUSAGE_STATIC);
 		std::vector<Buffer::DataDeclaration> format = {{"", DATAFORMAT_FLOAT_VEC4, 0}};
 
 		const float texel[] = {0.0f, 0.0f, 0.0f, 1.0f};
 
 		auto buffer = newBuffer(settings, format, texel, sizeof(texel), 1);
-		defaultBuffers[BUFFERTYPE_TEXEL].set(buffer, Acquire::NORETAIN);
+		defaultBuffers[BUFFERUSAGE_TEXEL].set(buffer, Acquire::NORETAIN);
 	}
 
-	if (capabilities.features[FEATURE_GLSL4] && defaultBuffers[BUFFERTYPE_SHADER_STORAGE].get() == nullptr)
+	if (capabilities.features[FEATURE_GLSL4] && defaultBuffers[BUFFERUSAGE_SHADER_STORAGE].get() == nullptr)
 	{
-		Buffer::Settings settings(Buffer::TYPEFLAG_SHADER_STORAGE, BUFFERUSAGE_STATIC);
+		Buffer::Settings settings(BUFFERUSAGEFLAG_SHADER_STORAGE, BUFFERDATAUSAGE_STATIC);
 		std::vector<Buffer::DataDeclaration> format = {{"", DATAFORMAT_FLOAT, 0}};
 
 		std::vector<float> data;
 		data.resize(Buffer::SHADER_STORAGE_BUFFER_MAX_STRIDE / 4);
 
 		auto buffer = newBuffer(settings, format, data.data(), data.size() * sizeof(float), data.size());
-		defaultBuffers[BUFFERTYPE_TEXEL].set(buffer, Acquire::NORETAIN);
+		defaultBuffers[BUFFERUSAGE_TEXEL].set(buffer, Acquire::NORETAIN);
 	}
 
 	// Load default resources before other Volatile.
-	for (int i = 0; i < BUFFERTYPE_MAX_ENUM; i++)
+	for (int i = 0; i < BUFFERUSAGE_MAX_ENUM; i++)
 	{
 		if (defaultBuffers[i].get())
 			((Buffer *) defaultBuffers[i].get())->loadVolatile();
 	}
 
-	if (defaultBuffers[BUFFERTYPE_TEXEL].get())
-		gl.setDefaultTexelBuffer((GLuint) defaultBuffers[BUFFERTYPE_TEXEL]->getTexelBufferHandle());
+	if (defaultBuffers[BUFFERUSAGE_TEXEL].get())
+		gl.setDefaultTexelBuffer((GLuint) defaultBuffers[BUFFERUSAGE_TEXEL]->getTexelBufferHandle());
 
-	if (defaultBuffers[BUFFERTYPE_SHADER_STORAGE].get())
-		gl.setDefaultStorageBuffer((GLuint) defaultBuffers[BUFFERTYPE_SHADER_STORAGE]->getHandle());
+	if (defaultBuffers[BUFFERUSAGE_SHADER_STORAGE].get())
+		gl.setDefaultStorageBuffer((GLuint) defaultBuffers[BUFFERUSAGE_SHADER_STORAGE]->getHandle());
 
 	// Reload all volatile objects.
 	if (!Volatile::loadAll())
@@ -494,7 +494,7 @@ void Graphics::draw(const DrawIndexedCommand &cmd)
 	GLenum glprimitivetype = OpenGL::getGLPrimitiveType(cmd.primitiveType);
 	GLenum gldatatype = OpenGL::getGLIndexDataType(cmd.indexType);
 
-	gl.bindBuffer(BUFFERTYPE_INDEX, cmd.indexBuffer->getHandle());
+	gl.bindBuffer(BUFFERUSAGE_INDEX, cmd.indexBuffer->getHandle());
 
 	if (cmd.instanceCount > 1)
 		glDrawElementsInstanced(glprimitivetype, cmd.indexCount, gldatatype, gloffset, cmd.instanceCount);
@@ -536,7 +536,7 @@ void Graphics::drawQuads(int start, int count, const VertexAttributes &attribute
 	gl.bindTextureToUnit(texture, 0, false);
 	gl.setCullMode(CULL_NONE);
 
-	gl.bindBuffer(BUFFERTYPE_INDEX, quadIndexBuffer->getHandle());
+	gl.bindBuffer(BUFFERUSAGE_INDEX, quadIndexBuffer->getHandle());
 
 	if (gl.isBaseVertexSupported())
 	{
@@ -1530,8 +1530,8 @@ void Graphics::initCapabilities()
 	capabilities.features[FEATURE_GLSL3] = GLAD_ES_VERSION_3_0 || gl.isCoreProfile();
 	capabilities.features[FEATURE_GLSL4] = GLAD_ES_VERSION_3_1 || (gl.isCoreProfile() && GLAD_VERSION_4_3);
 	capabilities.features[FEATURE_INSTANCING] = gl.isInstancingSupported();
-	capabilities.features[FEATURE_TEXEL_BUFFER] = gl.isBufferTypeSupported(BUFFERTYPE_TEXEL);
-	capabilities.features[FEATURE_COPY_BUFFER] = gl.isBufferTypeSupported(BUFFERTYPE_COPY_SOURCE);
+	capabilities.features[FEATURE_TEXEL_BUFFER] = gl.isBufferUsageSupported(BUFFERUSAGE_TEXEL);
+	capabilities.features[FEATURE_COPY_BUFFER] = gl.isBufferUsageSupported(BUFFERUSAGE_COPY_SOURCE);
 	static_assert(FEATURE_MAX_ENUM == 12, "Graphics::initCapabilities must be updated when adding a new graphics feature!");
 
 	capabilities.limits[LIMIT_POINT_SIZE] = gl.getMaxPointSize();

src/modules/graphics/opengl/Graphics.h

@@ -138,7 +138,7 @@ private:
 
 	love::graphics::ShaderStage *newShaderStageInternal(ShaderStage::StageType stage, const std::string &cachekey, const std::string &source, bool gles) override;
 	love::graphics::Shader *newShaderInternal(love::graphics::ShaderStage *vertex, love::graphics::ShaderStage *pixel) override;
-	love::graphics::StreamBuffer *newStreamBuffer(BufferType type, size_t size) override;
+	love::graphics::StreamBuffer *newStreamBuffer(BufferUsage type, size_t size) override;
 	void setRenderTargetsInternal(const RenderTargets &rts, int w, int h, int pixelw, int pixelh, bool hasSRGBtexture) override;
 	void initCapabilities() override;
 	void getAPIStats(int &shaderswitches) const override;
@@ -166,7 +166,7 @@ private:
 	size_t bufferMapMemorySize;
 
 	// Only needed for buffer types that can be bound to shaders.
-	StrongRef<love::graphics::Buffer> defaultBuffers[BUFFERTYPE_MAX_ENUM];
+	StrongRef<love::graphics::Buffer> defaultBuffers[BUFFERUSAGE_MAX_ENUM];
 
 	// [rendertarget][readable][srgb]
 	OptionalBool supportedFormats[PIXELFORMAT_MAX_ENUM][2][2][2];

src/modules/graphics/opengl/OpenGL.cpp

@@ -235,15 +235,15 @@ void OpenGL::setupContext()
 	glGetIntegerv(GL_CULL_FACE_MODE, &faceCull);
 	state.faceCullMode = faceCull;
 
-	for (int i = 0; i < (int) BUFFERTYPE_MAX_ENUM; i++)
+	for (int i = 0; i < (int) BUFFERUSAGE_MAX_ENUM; i++)
 	{
 		state.boundBuffers[i] = 0;
-		if (isBufferTypeSupported((BufferType) i))
-			glBindBuffer(getGLBufferType((BufferType) i), 0);
+		if (isBufferUsageSupported((BufferUsage) i))
+			glBindBuffer(getGLBufferType((BufferUsage) i), 0);
 	}
 
-	if (isBufferTypeSupported(BUFFERTYPE_SHADER_STORAGE))
-		state.boundIndexedBuffers[BUFFERTYPE_SHADER_STORAGE].resize(maxShaderStorageBufferBindings, 0);
+	if (isBufferUsageSupported(BUFFERUSAGE_SHADER_STORAGE))
+		state.boundIndexedBuffers[BUFFERUSAGE_SHADER_STORAGE].resize(maxShaderStorageBufferBindings, 0);
 
 	// Initialize multiple texture unit support for shaders.
 	for (int i = 0; i < TEXTURE_MAX_ENUM + 1; i++)
@@ -484,12 +484,12 @@ void OpenGL::initMaxValues()
 	else
 		maxTextureArrayLayers = 0;
 
-	if (isBufferTypeSupported(BUFFERTYPE_TEXEL))
+	if (isBufferUsageSupported(BUFFERUSAGE_TEXEL))
 		glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE, &maxTexelBufferSize);
 	else
 		maxTexelBufferSize = 0;
 
-	if (isBufferTypeSupported(BUFFERTYPE_SHADER_STORAGE))
+	if (isBufferUsageSupported(BUFFERUSAGE_SHADER_STORAGE))
 	{
 		glGetIntegerv(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &maxShaderStorageBufferSize);
 		glGetIntegerv(GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, &maxShaderStorageBufferBindings);
@@ -613,17 +613,17 @@ GLenum OpenGL::getGLPrimitiveType(PrimitiveType type)
 	return GL_ZERO;
 }
 
-GLenum OpenGL::getGLBufferType(BufferType type)
+GLenum OpenGL::getGLBufferType(BufferUsage usage)
 {
-	switch (type)
+	switch (usage)
 	{
-		case BUFFERTYPE_VERTEX: return GL_ARRAY_BUFFER;
-		case BUFFERTYPE_INDEX: return GL_ELEMENT_ARRAY_BUFFER;
-		case BUFFERTYPE_TEXEL: return GL_TEXTURE_BUFFER;
-		case BUFFERTYPE_SHADER_STORAGE: return GL_SHADER_STORAGE_BUFFER;
-		case BUFFERTYPE_COPY_SOURCE: return GL_COPY_READ_BUFFER;
-		case BUFFERTYPE_COPY_DEST: return GL_COPY_WRITE_BUFFER;
-		case BUFFERTYPE_MAX_ENUM: return GL_ZERO;
+		case BUFFERUSAGE_VERTEX: return GL_ARRAY_BUFFER;
+		case BUFFERUSAGE_INDEX: return GL_ELEMENT_ARRAY_BUFFER;
+		case BUFFERUSAGE_TEXEL: return GL_TEXTURE_BUFFER;
+		case BUFFERUSAGE_SHADER_STORAGE: return GL_SHADER_STORAGE_BUFFER;
+		case BUFFERUSAGE_COPY_SOURCE: return GL_COPY_READ_BUFFER;
+		case BUFFERUSAGE_COPY_DEST: return GL_COPY_WRITE_BUFFER;
+		case BUFFERUSAGE_MAX_ENUM: return GL_ZERO;
 	}
 
 	return GL_ZERO;
@@ -792,18 +792,18 @@ GLenum OpenGL::getGLVertexDataType(DataFormat format, int &components, GLboolean
 	return GL_ZERO;
 }
 
-GLenum OpenGL::getGLBufferUsage(BufferUsage usage)
+GLenum OpenGL::getGLBufferDataUsage(BufferDataUsage usage)
 {
 	switch (usage)
 	{
-		case BUFFERUSAGE_STREAM: return GL_STREAM_DRAW;
-		case BUFFERUSAGE_DYNAMIC: return GL_DYNAMIC_DRAW;
-		case BUFFERUSAGE_STATIC: return GL_STATIC_DRAW;
+		case BUFFERDATAUSAGE_STREAM: return GL_STREAM_DRAW;
+		case BUFFERDATAUSAGE_DYNAMIC: return GL_DYNAMIC_DRAW;
+		case BUFFERDATAUSAGE_STATIC: return GL_STATIC_DRAW;
 		default: return 0;
 	}
 }
 
-void OpenGL::bindBuffer(BufferType type, GLuint buffer)
+void OpenGL::bindBuffer(BufferUsage type, GLuint buffer)
 {
 	if (state.boundBuffers[type] != buffer)
 	{
@@ -816,7 +816,7 @@ void OpenGL::deleteBuffer(GLuint buffer)
 {
 	glDeleteBuffers(1, &buffer);
 
-	for (int i = 0; i < (int) BUFFERTYPE_MAX_ENUM; i++)
+	for (int i = 0; i < (int) BUFFERUSAGE_MAX_ENUM; i++)
 	{
 		if (state.boundBuffers[i] == buffer)
 			state.boundBuffers[i] = 0;
@@ -869,7 +869,7 @@ void OpenGL::setVertexAttributes(const VertexAttributes &attributes, const Buffe
 
 			const void *offsetpointer = reinterpret_cast<void*>(bufferinfo.offset + attrib.offsetFromVertex);
 
-			bindBuffer(BUFFERTYPE_VERTEX, (GLuint) bufferinfo.buffer->getHandle());
+			bindBuffer(BUFFERUSAGE_VERTEX, (GLuint) bufferinfo.buffer->getHandle());
 
 			if (intformat)
 				glVertexAttribIPointer(i, components, gltype, layout.stride, offsetpointer);
@@ -1165,7 +1165,7 @@ void OpenGL::bindTextureToUnit(Texture *texture, int textureunit, bool restorepr
 	bindTextureToUnit(textype, handle, textureunit, restoreprev, bindforedit);
 }
 
-void OpenGL::bindIndexedBuffer(GLuint buffer, BufferType type, int index)
+void OpenGL::bindIndexedBuffer(GLuint buffer, BufferUsage type, int index)
 {
 	auto &bindings = state.boundIndexedBuffers[type];
 	if (bindings.size() > (size_t) index && buffer != bindings[index])
@@ -1434,22 +1434,22 @@ bool OpenGL::isTextureTypeSupported(TextureType type) const
 	return false;
 }
 
-bool OpenGL::isBufferTypeSupported(BufferType type) const
+bool OpenGL::isBufferUsageSupported(BufferUsage usage) const
 {
-	switch (type)
+	switch (usage)
 	{
-	case BUFFERTYPE_VERTEX:
-	case BUFFERTYPE_INDEX:
+	case BUFFERUSAGE_VERTEX:
+	case BUFFERUSAGE_INDEX:
 		return true;
-	case BUFFERTYPE_TEXEL:
+	case BUFFERUSAGE_TEXEL:
 		// Not supported in ES until 3.2, which we don't support shaders for...
 		return GLAD_VERSION_3_1;
-	case BUFFERTYPE_SHADER_STORAGE:
+	case BUFFERUSAGE_SHADER_STORAGE:
 		return (GLAD_VERSION_4_3 && isCoreProfile()) || GLAD_ES_VERSION_3_1;
-	case BUFFERTYPE_COPY_SOURCE:
-	case BUFFERTYPE_COPY_DEST:
+	case BUFFERUSAGE_COPY_SOURCE:
+	case BUFFERUSAGE_COPY_DEST:
 		return GLAD_VERSION_3_1 || GLAD_ES_VERSION_3_0;
-	case BUFFERTYPE_MAX_ENUM:
+	case BUFFERUSAGE_MAX_ENUM:
 		return false;
 	}
 	return false;

src/modules/graphics/opengl/OpenGL.h

@@ -235,7 +235,7 @@ public:
 	 * NOTE: This does not account for multiple VAOs being used! Index buffer
 	 * bindings are per-VAO in OpenGL, but this doesn't know about that.
 	 **/
-	void bindBuffer(BufferType type, GLuint buffer);
+	void bindBuffer(BufferUsage type, GLuint buffer);
 
 	/**
 	 * glDeleteBuffers which updates our shadowed state.
@@ -341,7 +341,7 @@ public:
 
 	void bindBufferTextureToUnit(GLuint texture, int textureunit, bool restoreprev, bool bindforedit);
 
-	void bindIndexedBuffer(GLuint buffer, BufferType type, int index);
+	void bindIndexedBuffer(GLuint buffer, BufferUsage type, int index);
 
 	/**
 	 * Helper for deleting an OpenGL texture.
@@ -362,7 +362,7 @@ public:
 	bool rawTexStorage(TextureType target, int levels, PixelFormat pixelformat, bool &isSRGB, int width, int height, int depth = 1);
 
 	bool isTextureTypeSupported(TextureType type) const;
-	bool isBufferTypeSupported(BufferType type) const;
+	bool isBufferUsageSupported(BufferUsage usage) const;
 	bool isClampZeroOneTextureWrapSupported() const;
 	bool isPixelShaderHighpSupported() const;
 	bool isInstancingSupported() const;
@@ -433,10 +433,10 @@ public:
 	Vendor getVendor() const;
 
 	static GLenum getGLPrimitiveType(PrimitiveType type);
-	static GLenum getGLBufferType(BufferType type);
+	static GLenum getGLBufferType(BufferUsage usage);
 	static GLenum getGLIndexDataType(IndexDataType type);
 	static GLenum getGLVertexDataType(DataFormat format, int &components, GLboolean &normalized, bool &intformat);
-	static GLenum getGLBufferUsage(BufferUsage usage);
+	static GLenum getGLBufferDataUsage(BufferDataUsage usage);
 	static GLenum getGLTextureType(TextureType type);
 	static GLint getGLWrapMode(SamplerState::WrapMode wmode);
 	static GLint getGLCompareMode(CompareMode mode);
@@ -486,12 +486,12 @@ private:
 	// Tracked OpenGL state.
 	struct
 	{
-		GLuint boundBuffers[BUFFERTYPE_MAX_ENUM];
+		GLuint boundBuffers[BUFFERUSAGE_MAX_ENUM];
 
 		// Texture unit state (currently bound texture for each texture unit.)
 		std::vector<GLuint> boundTextures[TEXTURE_MAX_ENUM + 1];
 
-		std::vector<GLuint> boundIndexedBuffers[BUFFERTYPE_MAX_ENUM];
+		std::vector<GLuint> boundIndexedBuffers[BUFFERUSAGE_MAX_ENUM];
 
 		bool enableState[ENABLE_MAX_ENUM];
 

src/modules/graphics/opengl/Shader.cpp

@@ -315,7 +315,7 @@ void Shader::mapActiveUniforms()
 		}
 	}
 
-	if (gl.isBufferTypeSupported(BUFFERTYPE_SHADER_STORAGE))
+	if (gl.isBufferUsageSupported(BUFFERUSAGE_SHADER_STORAGE))
 	{
 		GLint numstoragebuffers = 0;
 		glGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_ACTIVE_RESOURCES, &numstoragebuffers);
@@ -586,7 +586,7 @@ void Shader::attach()
 		}
 
 		for (auto bufferbinding : activeStorageBufferBindings)
-			gl.bindIndexedBuffer(bufferbinding.buffer, BUFFERTYPE_SHADER_STORAGE, bufferbinding.bindingindex);
+			gl.bindIndexedBuffer(bufferbinding.buffer, BUFFERUSAGE_SHADER_STORAGE, bufferbinding.bindingindex);
 
 		// send any pending uniforms to the shader program.
 		for (const auto &p : pendingUniformUpdates)
@@ -816,9 +816,9 @@ void Shader::sendBuffers(const UniformInfo *info, love::graphics::Buffer **buffe
 	bool storagebinding = info->baseType == UNIFORM_STORAGEBUFFER;
 
 	if (texelbinding)
-		requiredtypeflags = Buffer::TYPEFLAG_TEXEL;
+		requiredtypeflags = BUFFERUSAGEFLAG_TEXEL;
 	else if (storagebinding)
-		requiredtypeflags = Buffer::TYPEFLAG_SHADER_STORAGE;
+		requiredtypeflags = BUFFERUSAGEFLAG_SHADER_STORAGE;
 
 	if (requiredtypeflags == 0)
 		return;
@@ -837,7 +837,7 @@ void Shader::sendBuffers(const UniformInfo *info, love::graphics::Buffer **buffe
 
 		if (buffer != nullptr)
 		{
-			if ((buffer->getTypeFlags() & requiredtypeflags) == 0)
+			if ((buffer->getUsageFlags() & requiredtypeflags) == 0)
 			{
 				if (internalUpdate)
 					continue;
@@ -915,7 +915,7 @@ void Shader::sendBuffers(const UniformInfo *info, love::graphics::Buffer **buffe
 				glbuffer = gl.getDefaultStorageBuffer();
 
 			if (shaderactive)
-				gl.bindIndexedBuffer(glbuffer, BUFFERTYPE_SHADER_STORAGE, bindingindex);
+				gl.bindIndexedBuffer(glbuffer, BUFFERUSAGE_SHADER_STORAGE, bindingindex);
 
 			int activeindex = storageBufferBindingIndexToActiveBinding[bindingindex];
 			if (activeindex >= 0)

src/modules/graphics/opengl/StreamBuffer.cpp

@@ -44,7 +44,7 @@ class StreamBufferClientMemory final : public love::graphics::StreamBuffer
 {
 public:
 
-	StreamBufferClientMemory(BufferType mode, size_t size)
+	StreamBufferClientMemory(BufferUsage mode, size_t size)
 		: love::graphics::StreamBuffer(mode, size)
 		, data(nullptr)
 	{
@@ -86,7 +86,7 @@ class StreamBufferSubDataOrphan final : public love::graphics::StreamBuffer, pub
 {
 public:
 
-	StreamBufferSubDataOrphan(BufferType mode, size_t size)
+	StreamBufferSubDataOrphan(BufferUsage mode, size_t size)
 		: love::graphics::StreamBuffer(mode, size)
 		, vbo(0)
 		, glMode(OpenGL::getGLBufferType(mode))
@@ -184,7 +184,7 @@ class StreamBufferSync : public love::graphics::StreamBuffer
 {
 public:
 
-	StreamBufferSync(BufferType type, size_t size)
+	StreamBufferSync(BufferUsage type, size_t size)
 		: love::graphics::StreamBuffer(type, size)
 		, frameIndex(0)
 		, syncs()
@@ -220,7 +220,7 @@ class StreamBufferMapSync final : public StreamBufferSync, public Volatile
 {
 public:
 
-	StreamBufferMapSync(BufferType type, size_t size)
+	StreamBufferMapSync(BufferUsage type, size_t size)
 		: StreamBufferSync(type, size)
 		, vbo(0)
 		, glMode(OpenGL::getGLBufferType(mode))
@@ -302,7 +302,7 @@ public:
 
 	// Coherent mapping is supposedly faster on intel/nvidia aside from a couple
 	// old nvidia GPUs.
-	StreamBufferPersistentMapSync(BufferType type, size_t size, bool coherent = true)
+	StreamBufferPersistentMapSync(BufferUsage type, size_t size, bool coherent = true)
 		: StreamBufferSync(type, size)
 		, vbo(0)
 		, glMode(OpenGL::getGLBufferType(mode))
@@ -393,7 +393,7 @@ class StreamBufferPinnedMemory final : public StreamBufferSync, public Volatile
 {
 public:
 
-	StreamBufferPinnedMemory(BufferType type, size_t size)
+	StreamBufferPinnedMemory(BufferUsage type, size_t size)
 		: StreamBufferSync(type, size)
 		, vbo(0)
 		, glMode(OpenGL::getGLBufferType(mode))
@@ -491,7 +491,7 @@ private:
 
 }; // StreamBufferPinnedMemory
 
-love::graphics::StreamBuffer *CreateStreamBuffer(BufferType mode, size_t size)
+love::graphics::StreamBuffer *CreateStreamBuffer(BufferUsage mode, size_t size)
 {
 	if (gl.isCoreProfile())
 	{

src/modules/graphics/opengl/StreamBuffer.h

@@ -29,7 +29,7 @@ namespace graphics
 namespace opengl
 {
 
-love::graphics::StreamBuffer *CreateStreamBuffer(BufferType mode, size_t size);
+love::graphics::StreamBuffer *CreateStreamBuffer(BufferUsage mode, size_t size);
 
 } // opengl
 } // graphics

src/modules/graphics/vertex.cpp

@@ -337,16 +337,16 @@ const char *getConstant(BuiltinVertexAttribute attrib)
 	return name;
 }
 
-STRINGMAP_BEGIN(BufferType, BUFFERTYPE_MAX_ENUM, bufferTypeName)
+STRINGMAP_BEGIN(BufferUsage, BUFFERUSAGE_MAX_ENUM, bufferUsageName)
 {
-	{ "vertex",        BUFFERTYPE_VERTEX         },
-	{ "index",         BUFFERTYPE_INDEX          },
-	{ "texel",         BUFFERTYPE_TEXEL          },
-	{ "shaderstorage", BUFFERTYPE_SHADER_STORAGE },
-	{ "copysource",    BUFFERTYPE_COPY_SOURCE    },
-	{ "copydest",      BUFFERTYPE_COPY_DEST      },
+	{ "vertex",        BUFFERUSAGE_VERTEX         },
+	{ "index",         BUFFERUSAGE_INDEX          },
+	{ "texel",         BUFFERUSAGE_TEXEL          },
+	{ "shaderstorage", BUFFERUSAGE_SHADER_STORAGE },
+	{ "copysource",    BUFFERUSAGE_COPY_SOURCE    },
+	{ "copydest",      BUFFERUSAGE_COPY_DEST      },
 }
-STRINGMAP_END(BufferType, BUFFERTYPE_MAX_ENUM, bufferTypeName)
+STRINGMAP_END(BufferUsage, BUFFERUSAGE_MAX_ENUM, bufferUsageName)
 
 STRINGMAP_BEGIN(IndexDataType, INDEX_MAX_ENUM, indexType)
 {
@@ -355,13 +355,13 @@ STRINGMAP_BEGIN(IndexDataType, INDEX_MAX_ENUM, indexType)
 }
 STRINGMAP_END(IndexDataType, INDEX_MAX_ENUM, indexType)
 
-STRINGMAP_BEGIN(BufferUsage, BUFFERUSAGE_MAX_ENUM, bufferUsage)
+STRINGMAP_BEGIN(BufferDataUsage, BUFFERDATAUSAGE_MAX_ENUM, bufferDataUsage)
 {
-	{ "stream",  BUFFERUSAGE_STREAM  },
-	{ "dynamic", BUFFERUSAGE_DYNAMIC },
-	{ "static",  BUFFERUSAGE_STATIC  },
+	{ "stream",  BUFFERDATAUSAGE_STREAM  },
+	{ "dynamic", BUFFERDATAUSAGE_DYNAMIC },
+	{ "static",  BUFFERDATAUSAGE_STATIC  },
 }
-STRINGMAP_END(BufferUsage, BUFFERUSAGE_MAX_ENUM, bufferUsage)
+STRINGMAP_END(BufferDataUsage, BUFFERDATAUSAGE_MAX_ENUM, bufferDataUsage)
 
 STRINGMAP_BEGIN(PrimitiveType, PRIMITIVE_MAX_ENUM, primitiveType)
 {

src/modules/graphics/vertex.h

@@ -54,15 +54,26 @@ enum BuiltinVertexAttributeFlags
 	ATTRIBFLAG_COLOR = 1 << ATTRIB_COLOR,
 };
 
-enum BufferType
+enum BufferUsage
+{
+	BUFFERUSAGE_VERTEX = 0,
+	BUFFERUSAGE_INDEX,
+	BUFFERUSAGE_TEXEL,
+	BUFFERUSAGE_SHADER_STORAGE,
+	BUFFERUSAGE_COPY_SOURCE,
+	BUFFERUSAGE_COPY_DEST,
+	BUFFERUSAGE_MAX_ENUM
+};
+
+enum BufferUsageFlags
 {
-	BUFFERTYPE_VERTEX = 0,
-	BUFFERTYPE_INDEX,
-	BUFFERTYPE_TEXEL,
-	BUFFERTYPE_SHADER_STORAGE,
-	BUFFERTYPE_COPY_SOURCE,
-	BUFFERTYPE_COPY_DEST,
-	BUFFERTYPE_MAX_ENUM
+	BUFFERUSAGEFLAG_NONE = 0,
+	BUFFERUSAGEFLAG_VERTEX = 1 << BUFFERUSAGE_VERTEX,
+	BUFFERUSAGEFLAG_INDEX = 1 << BUFFERUSAGE_INDEX,
+	BUFFERUSAGEFLAG_TEXEL = 1 << BUFFERUSAGE_TEXEL,
+	BUFFERUSAGEFLAG_SHADER_STORAGE = 1 << BUFFERUSAGE_SHADER_STORAGE,
+	BUFFERUSAGEFLAG_COPY_SOURCE = 1 << BUFFERUSAGE_COPY_SOURCE,
+	BUFFERUSAGEFLAG_COPY_DEST = 1 << BUFFERUSAGE_COPY_DEST,
 };
 
 enum IndexDataType
@@ -98,12 +109,12 @@ enum CullMode
 };
 
 // The expected usage pattern of buffer data.
-enum BufferUsage
+enum BufferDataUsage
 {
-	BUFFERUSAGE_STREAM,
-	BUFFERUSAGE_DYNAMIC,
-	BUFFERUSAGE_STATIC,
-	BUFFERUSAGE_MAX_ENUM
+	BUFFERDATAUSAGE_STREAM,
+	BUFFERDATAUSAGE_DYNAMIC,
+	BUFFERDATAUSAGE_STATIC,
+	BUFFERDATAUSAGE_MAX_ENUM
 };
 
 // Value types used when interfacing with the GPU (vertex and shader data).
@@ -381,9 +392,9 @@ void fillIndices(TriangleIndexMode mode, uint16 vertexStart, uint16 vertexCount,
 void fillIndices(TriangleIndexMode mode, uint32 vertexStart, uint32 vertexCount, uint32 *indices);
 
 STRINGMAP_DECLARE(BuiltinVertexAttribute);
-STRINGMAP_DECLARE(BufferType);
-STRINGMAP_DECLARE(IndexDataType);
 STRINGMAP_DECLARE(BufferUsage);
+STRINGMAP_DECLARE(IndexDataType);
+STRINGMAP_DECLARE(BufferDataUsage);
 STRINGMAP_DECLARE(PrimitiveType);
 STRINGMAP_DECLARE(AttributeStep);
 STRINGMAP_DECLARE(DataFormat);

src/modules/graphics/wrap_Buffer.cpp

@@ -373,11 +373,11 @@ static int w_Buffer_getFormat(lua_State *L)
 static int w_Buffer_isBufferType(lua_State *L)
 {
 	Buffer *t = luax_checkbuffer(L, 1);
-	BufferType buffertype = BUFFERTYPE_MAX_ENUM;
+	BufferUsage bufferusage = BUFFERUSAGE_MAX_ENUM;
 	const char *typestr = luaL_checkstring(L, 2);
-	if (!getConstant(typestr, buffertype))
-		return luax_enumerror(L, "buffer type", getConstants(buffertype), typestr);
-	luax_pushboolean(L, (t->getTypeFlags() & (1 << buffertype)) != 0);
+	if (!getConstant(typestr, bufferusage))
+		return luax_enumerror(L, "buffer type", getConstants(bufferusage), typestr);
+	luax_pushboolean(L, (t->getUsageFlags() & (1 << bufferusage)) != 0);
 	return 1;
 }
 

src/modules/graphics/wrap_Graphics.cpp

@@ -1325,7 +1325,7 @@ int w_newSpriteBatch(lua_State *L)
 
 	Texture *texture = luax_checktexture(L, 1);
 	int size = (int) luaL_optinteger(L, 2, 1000);
-	BufferUsage usage = BUFFERUSAGE_DYNAMIC;
+	BufferDataUsage usage = BUFFERDATAUSAGE_DYNAMIC;
 	if (lua_gettop(L) > 2)
 	{
 		const char *usagestr = luaL_checkstring(L, 3);
@@ -1488,7 +1488,7 @@ int w_validateShader(lua_State *L)
 	return 1;
 }
 
-static BufferUsage luax_optbufferusage(lua_State *L, int idx, BufferUsage def)
+static BufferDataUsage luax_optdatausage(lua_State *L, int idx, BufferDataUsage def)
 {
 	const char *usagestr = lua_isnoneornil(L, idx) ? nullptr : luaL_checkstring(L, idx);
 
@@ -1506,7 +1506,7 @@ static void luax_optbuffersettings(lua_State *L, int idx, Buffer::Settings &sett
 	luaL_checktype(L, idx, LUA_TTABLE);
 
 	lua_getfield(L, idx, "usage");
-	settings.usage = luax_optbufferusage(L, -1, settings.usage);
+	settings.dataUsage = luax_optdatausage(L, -1, settings.dataUsage);
 	lua_pop(L, 1);
 }
 
@@ -1664,18 +1664,18 @@ static Buffer *luax_newbuffer(lua_State *L, int idx, Buffer::Settings settings,
 
 int w_newBuffer(lua_State *L)
 {
-	Buffer::Settings settings(0, BUFFERUSAGE_DYNAMIC);
+	Buffer::Settings settings(0, BUFFERDATAUSAGE_DYNAMIC);
 
 	luaL_checktype(L, 3, LUA_TTABLE);
 
-	for (int i = 0; i < BUFFERTYPE_MAX_ENUM; i++)
+	for (int i = 0; i < BUFFERUSAGE_MAX_ENUM; i++)
 	{
-		BufferType buffertype = (BufferType) i;
+		BufferUsage bufferusage = (BufferUsage) i;
 		const char *tname = nullptr;
-		if (!getConstant(buffertype, tname))
+		if (!getConstant(bufferusage, tname))
 			continue;
 		if (luax_boolflag(L, 3, tname, false))
-			settings.typeFlags = (Buffer::TypeFlags)(settings.typeFlags | (1u << i));
+			settings.usageFlags = (BufferUsageFlags)(settings.usageFlags | (1u << i));
 	}
 
 	luax_optbuffersettings(L, 3, settings);
@@ -1692,7 +1692,7 @@ int w_newBuffer(lua_State *L)
 
 int w_newVertexBuffer(lua_State *L)
 {
-	Buffer::Settings settings(Buffer::TYPEFLAG_VERTEX, BUFFERUSAGE_DYNAMIC);
+	Buffer::Settings settings(BUFFERUSAGEFLAG_VERTEX, BUFFERDATAUSAGE_DYNAMIC);
 	luax_optbuffersettings(L, 3, settings);
 
 	std::vector<Buffer::DataDeclaration> format;
@@ -1707,7 +1707,7 @@ int w_newVertexBuffer(lua_State *L)
 
 int w_newIndexBuffer(lua_State *L)
 {
-	Buffer::Settings settings(Buffer::TYPEFLAG_INDEX, BUFFERUSAGE_DYNAMIC);
+	Buffer::Settings settings(BUFFERUSAGEFLAG_INDEX, BUFFERDATAUSAGE_DYNAMIC);
 	luax_optbuffersettings(L, 3, settings);
 
 	size_t arraylength = 0;
@@ -1799,7 +1799,7 @@ static Mesh *newStandardMesh(lua_State *L)
 	Mesh *t = nullptr;
 
 	PrimitiveType drawmode = luax_optmeshdrawmode(L, 2, PRIMITIVE_TRIANGLE_FAN);
-	BufferUsage usage = luax_optbufferusage(L, 3, BUFFERUSAGE_DYNAMIC);
+	BufferDataUsage usage = luax_optdatausage(L, 3, BUFFERDATAUSAGE_DYNAMIC);
 
 	std::vector<Buffer::DataDeclaration> format = Mesh::getDefaultVertexFormat();
 
@@ -1861,7 +1861,7 @@ static Mesh *newCustomMesh(lua_State *L)
 	std::vector<Buffer::DataDeclaration> vertexformat;
 
 	PrimitiveType drawmode = luax_optmeshdrawmode(L, 3, PRIMITIVE_TRIANGLE_FAN);
-	BufferUsage usage = luax_optbufferusage(L, 4, BUFFERUSAGE_DYNAMIC);
+	BufferDataUsage usage = luax_optdatausage(L, 4, BUFFERDATAUSAGE_DYNAMIC);
 
 	lua_rawgeti(L, 1, 1);
 	if (!lua_istable(L, -1))