Using latest android branch of LÖVE (6d14516b05c9) that now syncs with default (woooo!)

jni/love/src/modules/graphics/opengl/GLBuffer.cpp

@@ -0,0 +1,343 @@
+/**
+ * Copyright (c) 2006-2015 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#include "GLBuffer.h"
+
+#include "common/Exception.h"
+
+#include <cstdlib>
+#include <cstring>
+#include <algorithm>
+#include <limits>
+
+namespace love
+{
+namespace graphics
+{
+namespace opengl
+{
+
+GLBuffer::GLBuffer(size_t size, const void *data, GLenum target, GLenum usage)
+	: is_bound(false)
+	, is_mapped(false)
+	, size(size)
+	, target(target)
+	, usage(usage)
+	, vbo(0)
+	, memory_map(nullptr)
+{
+	try
+	{
+		memory_map = new char[size];
+	}
+	catch (std::bad_alloc &)
+	{
+		throw love::Exception("Out of memory.");
+	}
+
+	if (data != nullptr)
+		memcpy(memory_map, data, size);
+
+	bool ok = load(data != nullptr);
+
+	if (!ok)
+	{
+		delete[] memory_map;
+		throw love::Exception("Could not load VBO.");
+	}
+}
+
+GLBuffer::~GLBuffer()
+{
+	if (vbo != 0)
+		unload();
+
+	delete[] memory_map;
+}
+
+void *GLBuffer::map()
+{
+	if (is_mapped)
+		return memory_map;
+
+	is_mapped = true;
+
+	return memory_map;
+}
+
+void GLBuffer::unmapStatic(size_t offset, size_t size)
+{
+	// Upload the mapped data to the buffer.
+	glBufferSubData(getTarget(), (GLintptr) offset, (GLsizeiptr) size, memory_map + offset);
+}
+
+void GLBuffer::unmapStream()
+{
+	// "orphan" current buffer to avoid implicit synchronisation on the GPU:
+	// http://www.seas.upenn.edu/~pcozzi/OpenGLInsights/OpenGLInsights-AsynchronousBufferTransfers.pdf
+	glBufferData(getTarget(), (GLsizeiptr) getSize(), nullptr,    getUsage());
+	glBufferData(getTarget(), (GLsizeiptr) getSize(), memory_map, getUsage());
+}
+
+void GLBuffer::unmap(size_t usedOffset, size_t usedSize)
+{
+	if (!is_mapped)
+		return;
+
+	usedOffset = std::min(usedOffset, getSize());
+	usedSize = std::min(usedSize, getSize() - usedOffset);
+
+	// VBO::bind is a no-op when the VBO is mapped, so we have to make sure it's
+	// bound here.
+	if (!is_bound)
+	{
+		glBindBuffer(getTarget(), vbo);
+		is_bound = true;
+	}
+
+	switch (getUsage())
+	{
+	case GL_STATIC_DRAW:
+		unmapStatic(usedOffset, usedSize);
+		break;
+	case GL_STREAM_DRAW:
+		unmapStream();
+		break;
+	case GL_DYNAMIC_DRAW:
+	default:
+		// It's probably more efficient to treat it like a streaming buffer if
+		// more than a third of its contents have been modified during the map().
+		if (usedSize >= getSize() / 3)
+			unmapStream();
+		else
+			unmapStatic(usedOffset, usedSize);
+		break;
+	}
+
+	is_mapped = false;
+}
+
+void GLBuffer::bind()
+{
+	if (!is_mapped)
+	{
+		glBindBuffer(getTarget(), vbo);
+		is_bound = true;
+	}
+}
+
+void GLBuffer::unbind()
+{
+	if (is_bound)
+		glBindBuffer(getTarget(), 0);
+
+	is_bound = false;
+}
+
+void GLBuffer::fill(size_t offset, size_t size, const void *data)
+{
+	memcpy(memory_map + offset, data, size);
+
+	if (!is_mapped)
+		glBufferSubData(getTarget(), (GLintptr) offset, (GLsizeiptr) size, data);
+}
+
+const void *GLBuffer::getPointer(size_t offset) const
+{
+	return BUFFER_OFFSET(offset);
+}
+
+bool GLBuffer::loadVolatile()
+{
+	return load(true);
+}
+
+void GLBuffer::unloadVolatile()
+{
+	unload();
+}
+
+bool GLBuffer::load(bool restore)
+{
+	glGenBuffers(1, &vbo);
+
+	GLBuffer::Bind bind(*this);
+
+	// Copy the old buffer only if 'restore' was requested.
+	const GLvoid *src = restore ? memory_map : nullptr;
+
+	// Note that if 'src' is '0', no data will be copied.
+	glBufferData(getTarget(), (GLsizeiptr) getSize(), src, getUsage());
+
+	return true;
+}
+
+void GLBuffer::unload()
+{
+	is_mapped = false;
+
+	glDeleteBuffers(1, &vbo);
+	vbo = 0;
+}
+
+
+// QuadIndices
+
+size_t QuadIndices::maxSize = 0;
+size_t QuadIndices::elementSize = 0;
+size_t QuadIndices::objectCount = 0;
+GLBuffer *QuadIndices::indexBuffer = nullptr;
+
+QuadIndices::QuadIndices(size_t size)
+	: size(size)
+{
+	// The upper limit is the maximum of GLuint divided by six (the number
+	// of indices per size) and divided by the size of GLuint. This guarantees
+	// no overflows when calculating the array size in bytes.
+	if (size == 0 || size > ((GLuint) -1) / 6 / sizeof(GLuint))
+		throw love::Exception("Invalid number of quads.");
+
+	// Create a new / larger buffer if needed.
+	if (indexBuffer == nullptr || size > maxSize)
+	{
+		GLBuffer *newbuffer = nullptr;
+
+		// Depending on the size, a switch to int and more memory is needed.
+		GLenum targettype = getType(size);
+		size_t elemsize = (targettype == GL_UNSIGNED_SHORT) ? sizeof(GLushort) : sizeof(GLuint);
+
+		size_t buffersize = elemsize * 6 * size;
+
+		// Create may throw out-of-memory exceptions.
+		// QuadIndices will propagate the exception and keep the old GLBuffer.
+		try
+		{
+			newbuffer = new GLBuffer(buffersize, nullptr, GL_ELEMENT_ARRAY_BUFFER, GL_STATIC_DRAW);
+		}
+		catch (std::bad_alloc &)
+		{
+			throw love::Exception("Out of memory.");
+		}
+
+		// Allocation of the new GLBuffer succeeded.
+		// The old GLBuffer can now be deleted.
+		delete indexBuffer;
+		indexBuffer = newbuffer;
+		maxSize = size;
+		elementSize = elemsize;
+
+		switch (targettype)
+		{
+		case GL_UNSIGNED_SHORT:
+			fill<GLushort>();
+			break;
+		case GL_UNSIGNED_INT:
+			fill<GLuint>();
+			break;
+		}
+	}
+
+	objectCount++;
+}
+
+QuadIndices::QuadIndices(const QuadIndices &other)
+	: size(other.size)
+{
+	objectCount++;
+}
+
+QuadIndices &QuadIndices::operator = (const QuadIndices &other)
+{
+	size = other.size;
+	return *this;
+}
+
+QuadIndices::~QuadIndices()
+{
+	--objectCount;
+
+	// Delete the buffer if we were the last living QuadIndices object.
+	if (objectCount <= 0)
+	{
+		delete indexBuffer;
+		indexBuffer = nullptr;
+	}
+}
+
+size_t QuadIndices::getSize() const
+{
+	return size;
+}
+
+size_t QuadIndices::getIndexCount(size_t elements) const
+{
+	return elements * 6;
+}
+
+GLenum QuadIndices::getType(size_t s) const
+{
+	// Calculates if unsigned short is big enough to hold all the vertex indices.
+	static const GLenum types[] = {GL_UNSIGNED_SHORT, GL_UNSIGNED_INT};
+	return types[s * 4 > std::numeric_limits<GLushort>::max()];
+	// if buffer-size > max(GLushort) then GL_UNSIGNED_INT else GL_UNSIGNED_SHORT
+}
+
+size_t QuadIndices::getElementSize()
+{
+	return elementSize;
+}
+
+GLBuffer *QuadIndices::getBuffer() const
+{
+	return indexBuffer;
+}
+
+const void *QuadIndices::getPointer(size_t offset) const
+{
+	return indexBuffer->getPointer(offset);
+}
+
+template <typename T>
+void QuadIndices::fill()
+{
+	GLBuffer::Bind bind(*indexBuffer);
+	GLBuffer::Mapper mapper(*indexBuffer);
+
+	T *indices = (T *) mapper.get();
+
+	// 0----2
+	// |  / |
+	// | /  |
+	// 1----3
+	for (size_t i = 0; i < maxSize; ++i)
+	{
+		indices[i*6+0] = T(i * 4 + 0);
+		indices[i*6+1] = T(i * 4 + 1);
+		indices[i*6+2] = T(i * 4 + 2);
+
+		indices[i*6+3] = T(i * 4 + 2);
+		indices[i*6+4] = T(i * 4 + 1);
+		indices[i*6+5] = T(i * 4 + 3);
+	}
+}
+
+} // opengl
+} // graphics
+} // love