More consistent naming for vertex and index buffers in love's code.

src/modules/graphics/Mesh.cpp

@@ -61,10 +61,10 @@ love::Type Mesh::type("Mesh", &Drawable::type);
 
 Mesh::Mesh(graphics::Graphics *gfx, const std::vector<AttribFormat> &vertexformat, const void *data, size_t datasize, PrimitiveType drawmode, vertex::Usage usage)
 	: vertexFormat(vertexformat)
-	, vbo(nullptr)
+	, vertexBuffer(nullptr)
 	, vertexCount(0)
 	, vertexStride(0)
-	, ibo(nullptr)
+	, indexBuffer(nullptr)
 	, useIndexBuffer(false)
 	, indexCount(0)
 	, indexDataType(INDEX_UINT16)
@@ -81,17 +81,17 @@ Mesh::Mesh(graphics::Graphics *gfx, const std::vector<AttribFormat> &vertexforma
 	if (vertexCount == 0)
 		throw love::Exception("Data size is too small for specified vertex attribute formats.");
 
-	vbo = gfx->newBuffer(datasize, data, BUFFER_VERTEX, usage, Buffer::MAP_EXPLICIT_RANGE_MODIFY | Buffer::MAP_READ);
+	vertexBuffer = gfx->newBuffer(datasize, data, BUFFER_VERTEX, usage, Buffer::MAP_EXPLICIT_RANGE_MODIFY | Buffer::MAP_READ);
 
 	vertexScratchBuffer = new char[vertexStride];
 }
 
 Mesh::Mesh(graphics::Graphics *gfx, const std::vector<AttribFormat> &vertexformat, int vertexcount, PrimitiveType drawmode, vertex::Usage usage)
 	: vertexFormat(vertexformat)
-	, vbo(nullptr)
+	, vertexBuffer(nullptr)
 	, vertexCount((size_t) vertexcount)
 	, vertexStride(0)
-	, ibo(nullptr)
+	, indexBuffer(nullptr)
 	, useIndexBuffer(false)
 	, indexCount(0)
 	, indexDataType(vertex::getIndexDataTypeFromMax(vertexcount))
@@ -107,20 +107,20 @@ Mesh::Mesh(graphics::Graphics *gfx, const std::vector<AttribFormat> &vertexforma
 
 	size_t buffersize = vertexCount * vertexStride;
 
-	vbo = gfx->newBuffer(buffersize, nullptr, BUFFER_VERTEX, usage, Buffer::MAP_EXPLICIT_RANGE_MODIFY | Buffer::MAP_READ);
+	vertexBuffer = gfx->newBuffer(buffersize, nullptr, BUFFER_VERTEX, usage, Buffer::MAP_EXPLICIT_RANGE_MODIFY | Buffer::MAP_READ);
 
 	// Initialize the buffer's contents to 0.
-	memset(vbo->map(), 0, buffersize);
-	vbo->setMappedRangeModified(0, vbo->getSize());
-	vbo->unmap();
+	memset(vertexBuffer->map(), 0, buffersize);
+	vertexBuffer->setMappedRangeModified(0, vertexBuffer->getSize());
+	vertexBuffer->unmap();
 
 	vertexScratchBuffer = new char[vertexStride];
 }
 
 Mesh::~Mesh()
 {
-	delete vbo;
-	delete ibo;
+	delete vertexBuffer;
+	delete indexBuffer;
 	delete vertexScratchBuffer;
 
 	for (const auto &attrib : attachedAttributes)
@@ -184,10 +184,10 @@ void Mesh::setVertex(size_t vertindex, const void *data, size_t datasize)
 	size_t offset = vertindex * vertexStride;
 	size_t size = std::min(datasize, vertexStride);
 
-	uint8 *bufferdata = (uint8 *) vbo->map();
+	uint8 *bufferdata = (uint8 *) vertexBuffer->map();
 	memcpy(bufferdata + offset, data, size);
 
-	vbo->setMappedRangeModified(offset, size);
+	vertexBuffer->setMappedRangeModified(offset, size);
 }
 
 size_t Mesh::getVertex(size_t vertindex, void *data, size_t datasize)
@@ -198,8 +198,8 @@ size_t Mesh::getVertex(size_t vertindex, void *data, size_t datasize)
 	size_t offset = vertindex * vertexStride;
 	size_t size = std::min(datasize, vertexStride);
 
-	// We're relying on vbo->map() returning read/write data... ew.
-	const uint8 *bufferdata = (const uint8 *) vbo->map();
+	// We're relying on map() returning read/write data... ew.
+	const uint8 *bufferdata = (const uint8 *) vertexBuffer->map();
 	memcpy(data, bufferdata + offset, size);
 
 	return size;
@@ -221,10 +221,10 @@ void Mesh::setVertexAttribute(size_t vertindex, int attribindex, const void *dat
 	size_t offset = vertindex * vertexStride + getAttributeOffset(attribindex);
 	size_t size = std::min(datasize, attributeSizes[attribindex]);
 
-	uint8 *bufferdata = (uint8 *) vbo->map();
+	uint8 *bufferdata = (uint8 *) vertexBuffer->map();
 	memcpy(bufferdata + offset, data, size);
 
-	vbo->setMappedRangeModified(offset, size);
+	vertexBuffer->setMappedRangeModified(offset, size);
 }
 
 size_t Mesh::getVertexAttribute(size_t vertindex, int attribindex, void *data, size_t datasize)
@@ -238,8 +238,8 @@ size_t Mesh::getVertexAttribute(size_t vertindex, int attribindex, void *data, s
 	size_t offset = vertindex * vertexStride + getAttributeOffset(attribindex);
 	size_t size = std::min(datasize, attributeSizes[attribindex]);
 
-	// We're relying on vbo->map() returning read/write data... ew.
-	const uint8 *bufferdata = (const uint8 *) vbo->map();
+	// We're relying on map() returning read/write data... ew.
+	const uint8 *bufferdata = (const uint8 *) vertexBuffer->map();
 	memcpy(data, bufferdata + offset, size);
 
 	return size;
@@ -363,21 +363,21 @@ bool Mesh::detachAttribute(const std::string &name)
 
 void *Mesh::mapVertexData()
 {
-	return vbo->map();
+	return vertexBuffer->map();
 }
 
 void Mesh::unmapVertexData(size_t modifiedoffset, size_t modifiedsize)
 {
-	vbo->setMappedRangeModified(modifiedoffset, modifiedsize);
-	vbo->unmap();
+	vertexBuffer->setMappedRangeModified(modifiedoffset, modifiedsize);
+	vertexBuffer->unmap();
 }
 
 void Mesh::flush()
 {
-	vbo->unmap();
+	vertexBuffer->unmap();
 
-	if (ibo != nullptr)
-		ibo->unmap();
+	if (indexBuffer != nullptr)
+		indexBuffer->unmap();
 }
 
 /**
@@ -406,25 +406,25 @@ void Mesh::setVertexMap(const std::vector<uint32> &map)
 	// Calculate the size in bytes of the index buffer data.
 	size_t size = map.size() * vertex::getIndexDataSize(datatype);
 
-	if (ibo && size > ibo->getSize())
+	if (indexBuffer && size > indexBuffer->getSize())
 	{
-		delete ibo;
-		ibo = nullptr;
+		delete indexBuffer;
+		indexBuffer = nullptr;
 	}
 
-	if (!ibo && size > 0)
+	if (!indexBuffer && size > 0)
 	{
 		auto gfx = Module::getInstance<graphics::Graphics>(Module::M_GRAPHICS);
-		ibo = gfx->newBuffer(size, nullptr, BUFFER_INDEX, vbo->getUsage(), Buffer::MAP_READ);
+		indexBuffer = gfx->newBuffer(size, nullptr, BUFFER_INDEX, vertexBuffer->getUsage(), Buffer::MAP_READ);
 	}
 
 	useIndexBuffer = true;
 	indexCount = map.size();
 
-	if (!ibo || indexCount == 0)
+	if (!indexBuffer || indexCount == 0)
 		return;
 
-	Buffer::Mapper ibomap(*ibo);
+	Buffer::Mapper ibomap(*indexBuffer);
 
 	// Fill the buffer with the index values from the vector.
 	switch (datatype)
@@ -443,24 +443,24 @@ void Mesh::setVertexMap(const std::vector<uint32> &map)
 
 void Mesh::setVertexMap(IndexDataType datatype, const void *data, size_t datasize)
 {
-	if (ibo && datasize > ibo->getSize())
+	if (indexBuffer && datasize > indexBuffer->getSize())
 	{
-		delete ibo;
-		ibo = nullptr;
+		delete indexBuffer;
+		indexBuffer = nullptr;
 	}
 
-	if (!ibo && datasize > 0)
+	if (!indexBuffer && datasize > 0)
 	{
 		auto gfx = Module::getInstance<graphics::Graphics>(Module::M_GRAPHICS);
-		ibo = gfx->newBuffer(datasize, nullptr, BUFFER_INDEX, vbo->getUsage(), Buffer::MAP_READ);
+		indexBuffer = gfx->newBuffer(datasize, nullptr, BUFFER_INDEX, vertexBuffer->getUsage(), Buffer::MAP_READ);
 	}
 
 	indexCount = datasize / vertex::getIndexDataSize(datatype);
 
-	if (!ibo || indexCount == 0)
+	if (!indexBuffer || indexCount == 0)
 		return;
 
-	Buffer::Mapper ibomap(*ibo);
+	Buffer::Mapper ibomap(*indexBuffer);
 	memcpy(ibomap.get(), data, datasize);
 
 	useIndexBuffer = true;
@@ -491,11 +491,11 @@ bool Mesh::getVertexMap(std::vector<uint32> &map) const
 	map.clear();
 	map.reserve(indexCount);
 
-	if (!ibo || indexCount == 0)
+	if (!indexBuffer || indexCount == 0)
 		return true;
 
 	// We unmap the buffer in Mesh::draw, Mesh::setVertexMap, and Mesh::flush.
-	void *buffer = ibo->map();
+	void *buffer = indexBuffer->map();
 
 	// Fill the vector from the buffer.
 	switch (indexDataType)
@@ -611,7 +611,7 @@ void Mesh::drawInstanced(Graphics *gfx, const Matrix4 &m, int instancecount)
 		if (attributeindex >= 0)
 		{
 			// Make sure the buffer isn't mapped (sends data to GPU if needed.)
-			mesh->vbo->unmap();
+			mesh->vertexBuffer->unmap();
 
 			const auto &formats = mesh->getVertexFormat();
 			const auto &format = formats[attrib.second.index];
@@ -622,7 +622,7 @@ void Mesh::drawInstanced(Graphics *gfx, const Matrix4 &m, int instancecount)
 			attributes.set(attributeindex, format.type, format.components, offset, stride, activebuffers, attrib.second.step);
 
 			// TODO: Ideally we want to reuse buffers with the same stride+step.
-			buffers.set(activebuffers, mesh->vbo, 0);
+			buffers.set(activebuffers, mesh->vertexBuffer, 0);
 			activebuffers++;
 		}
 	}
@@ -633,12 +633,12 @@ void Mesh::drawInstanced(Graphics *gfx, const Matrix4 &m, int instancecount)
 
 	Graphics::TempTransform transform(gfx, m);
 
-	if (useIndexBuffer && ibo != nullptr && indexCount > 0)
+	if (useIndexBuffer && indexBuffer != nullptr && indexCount > 0)
 	{
 		// Make sure the index buffer isn't mapped (sends data to GPU if needed.)
-		ibo->unmap();
+		indexBuffer->unmap();
 
-		Graphics::DrawIndexedCommand cmd(&attributes, &buffers, ibo);
+		Graphics::DrawIndexedCommand cmd(&attributes, &buffers, indexBuffer);
 
 		cmd.primitiveType = primitiveType;
 		cmd.indexType = indexDataType;

src/modules/graphics/Mesh.h

@@ -196,7 +196,7 @@ private:
 	std::unordered_map<std::string, AttachedAttribute> attachedAttributes;
 
 	// Vertex buffer, for the vertex data.
-	Buffer *vbo;
+	Buffer *vertexBuffer;
 	size_t vertexCount;
 	size_t vertexStride;
 
@@ -205,7 +205,7 @@ private:
 	char *vertexScratchBuffer;
 
 	// Index buffer, for the vertex map.
-	Buffer *ibo;
+	Buffer *indexBuffer;
 	bool useIndexBuffer;
 	size_t indexCount;
 	IndexDataType indexDataType;

src/modules/graphics/SpriteBatch.cpp

@@ -93,7 +93,7 @@ int SpriteBatch::add(Quad *quad, const Matrix4 &m, int index /*= -1*/)
 	const Vector2 *quadpositions = quad->getVertexPositions();
 	const Vector2 *quadtexcoords = quad->getVertexTexCoords();
 
-	// Always keep the VBO mapped when adding data (it'll be unmapped on draw.)
+	// Always keep the buffer mapped when adding data (it'll be unmapped on draw.)
 	size_t offset = (index == -1 ? next : index) * vertex_stride * 4;
 	auto verts = (XYf_STf_RGBAub *) ((uint8 *) array_buf->map() + offset);
 
@@ -139,7 +139,7 @@ int SpriteBatch::addLayer(int layer, Quad *quad, const Matrix4 &m, int index)
 	const Vector2 *quadpositions = quad->getVertexPositions();
 	const Vector2 *quadtexcoords = quad->getVertexTexCoords();
 
-	// Always keep the VBO mapped when adding data (it'll be unmapped on draw.)
+	// Always keep the buffer mapped when adding data (it'll be unmapped on draw.)
 	size_t offset = (index == -1 ? next : index) * vertex_stride * 4;
 	auto verts = (XYf_STPf_RGBAub *) ((uint8 *) array_buf->map() + offset);
 
@@ -328,7 +328,7 @@ void SpriteBatch::draw(Graphics *gfx, const Matrix4 &m)
 			Shader::current->checkMainTexture(texture);
 	}
 
-	// Make sure the VBO isn't mapped when we draw (sends data to GPU if needed.)
+	// Make sure the buffer isn't mapped when we draw (sends data to GPU if needed.)
 	array_buf->unmap();
 
 	Attributes attributes;
@@ -366,7 +366,7 @@ void SpriteBatch::draw(Graphics *gfx, const Matrix4 &m)
 		if (attributeindex >= 0)
 		{
 			// Make sure the buffer isn't mapped (sends data to GPU if needed.)
-			mesh->vbo->unmap();
+			mesh->vertexBuffer->unmap();
 
 			const auto &formats = mesh->getVertexFormat();
 			const auto &format = formats[it.second.index];
@@ -377,7 +377,7 @@ void SpriteBatch::draw(Graphics *gfx, const Matrix4 &m)
 			attributes.set(attributeindex, format.type, format.components, offset, stride, activebuffers);
 
 			// TODO: Ideally we want to reuse buffers with the same stride+step.
-			buffers.set(activebuffers, mesh->vbo, 0);
+			buffers.set(activebuffers, mesh->vertexBuffer, 0);
 			activebuffers++;
 		}
 	}

src/modules/graphics/Text.cpp

@@ -33,7 +33,7 @@ love::Type Text::type("Text", &Drawable::type);
 Text::Text(Font *font, const std::vector<Font::ColoredString> &text)
 	: font(font)
 	, vertexAttributes(Font::vertexFormat, 0)
-	, vbo(nullptr)
+	, vertex_buffer(nullptr)
 	, vert_offset(0)
 	, texture_cache_id((uint32) -1)
 {
@@ -42,40 +42,39 @@ Text::Text(Font *font, const std::vector<Font::ColoredString> &text)
 
 Text::~Text()
 {
-	delete vbo;
+	delete vertex_buffer;
 }
 
 void Text::uploadVertices(const std::vector<Font::GlyphVertex> &vertices, size_t vertoffset)
 {
 	size_t offset = vertoffset * sizeof(Font::GlyphVertex);
 	size_t datasize = vertices.size() * sizeof(Font::GlyphVertex);
-	uint8 *vbodata = nullptr;
 
 	// If we haven't created a VBO or the vertices are too big, make a new one.
-	if (datasize > 0 && (!vbo || (offset + datasize) > vbo->getSize()))
+	if (datasize > 0 && (!vertex_buffer || (offset + datasize) > vertex_buffer->getSize()))
 	{
 		// Make it bigger than necessary to reduce potential future allocations.
 		size_t newsize = size_t((offset + datasize) * 1.5);
 
-		if (vbo != nullptr)
-			newsize = std::max(size_t(vbo->getSize() * 1.5), newsize);
+		if (vertex_buffer != nullptr)
+			newsize = std::max(size_t(vertex_buffer->getSize() * 1.5), newsize);
 
 		auto gfx = Module::getInstance<Graphics>(Module::M_GRAPHICS);
-		Buffer *new_vbo = gfx->newBuffer(newsize, nullptr, BUFFER_VERTEX, vertex::USAGE_DYNAMIC, 0);
+		Buffer *new_buffer = gfx->newBuffer(newsize, nullptr, BUFFER_VERTEX, vertex::USAGE_DYNAMIC, 0);
 
-		if (vbo != nullptr)
-			vbo->copyTo(0, vbo->getSize(), new_vbo, 0);
+		if (vertex_buffer != nullptr)
+			vertex_buffer->copyTo(0, vertex_buffer->getSize(), new_buffer, 0);
 
-		delete vbo;
-		vbo = new_vbo;
+		delete vertex_buffer;
+		vertex_buffer = new_buffer;
 
-		vertexBuffers.set(0, vbo, 0);
+		vertexBuffers.set(0, vertex_buffer, 0);
 	}
 
-	if (vbo != nullptr && datasize > 0)
+	if (vertex_buffer != nullptr && datasize > 0)
 	{
-		vbodata = (uint8 *) vbo->map();
-		memcpy(vbodata + offset, &vertices[0], datasize);
+		uint8 *bufferdata = (uint8 *) vertex_buffer->map();
+		memcpy(bufferdata + offset, &vertices[0], datasize);
 		// We unmap when we draw, to avoid unnecessary full map()/unmap() calls.
 	}
 }
@@ -222,10 +221,10 @@ int Text::getWidth(int index) const
 {
 	if (index < 0)
 		index = std::max((int) text_data.size() - 1, 0);
-	
+
 	if (index >= (int) text_data.size())
 		return 0;
-	
+
 	return text_data[index].text_info.width;
 }
 
@@ -233,16 +232,16 @@ int Text::getHeight(int index) const
 {
 	if (index < 0)
 		index = std::max((int) text_data.size() - 1, 0);
-	
+
 	if (index >= (int) text_data.size())
 		return 0;
-	
+
 	return text_data[index].text_info.height;
 }
 
 void Text::draw(Graphics *gfx, const Matrix4 &m)
 {
-	if (vbo == nullptr || draw_commands.empty())
+	if (vertex_buffer == nullptr || draw_commands.empty())
 		return;
 
 	gfx->flushStreamDraws();
@@ -261,7 +260,7 @@ void Text::draw(Graphics *gfx, const Matrix4 &m)
 	for (const Font::DrawCommand &cmd : draw_commands)
 		totalverts = std::max(cmd.startvertex + cmd.vertexcount, totalverts);
 
-	vbo->unmap(); // Make sure all pending data is flushed to the GPU.
+	vertex_buffer->unmap(); // Make sure all pending data is flushed to the GPU.
 
 	Graphics::TempTransform transform(gfx, m);
 

src/modules/graphics/Text.h

@@ -88,7 +88,7 @@ private:
 	vertex::Attributes vertexAttributes;
 	vertex::Buffers vertexBuffers;
 
-	Buffer *vbo;
+	Buffer *vertex_buffer;
 
 	std::vector<Font::DrawCommand> draw_commands;