src/OpenGL/libGLESv2/IndexDataManager.cpp - SwiftShader - Git at Google

 // Copyright 2016 The SwiftShader Authors. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //    http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 // IndexDataManager.cpp: Defines the IndexDataManager, a class that
 // runs the Buffer translation process for index buffers.

 #include "IndexDataManager.h"

 #include "Buffer.h"
 #include "common/debug.h"

 #include <string.h>
 #include <algorithm>

 namespace
 {
 	enum { INITIAL_INDEX_BUFFER_SIZE = 4096 * sizeof(GLuint) };
 }

 namespace es2
 {

 IndexDataManager::IndexDataManager()
 {
 	mStreamingBuffer = new StreamingIndexBuffer(INITIAL_INDEX_BUFFER_SIZE);

 	if(!mStreamingBuffer)
 	{
 		ERR("Failed to allocate the streaming index buffer.");
 	}
 }

 IndexDataManager::~IndexDataManager()
 {
 	delete mStreamingBuffer;
 }

 void copyIndices(GLenum type, const void *input, GLsizei count, void *output)
 {
 	if(type == GL_UNSIGNED_BYTE)
 	{
 		memcpy(output, input, count * sizeof(GLubyte));
 	}
 	else if(type == GL_UNSIGNED_INT)
 	{
 		memcpy(output, input, count * sizeof(GLuint));
 	}
 	else if(type == GL_UNSIGNED_SHORT)
 	{
 		memcpy(output, input, count * sizeof(GLushort));
 	}
 	else UNREACHABLE(type);
 }

 inline GLsizei getNumIndices(const std::vector<GLsizei>& restartIndices, size_t i, GLsizei count)
 {
 	return restartIndices.empty() ? count :
 	       ((i == 0) ? restartIndices[0] : ((i == restartIndices.size()) ? (count - restartIndices[i - 1] - 1) : (restartIndices[i] - restartIndices[i - 1] - 1)));
 }

 void copyIndices(GLenum mode, GLenum type, const std::vector<GLsizei>& restartIndices, const void *input, GLsizei count, void* output)
 {
 	size_t bytesPerIndex = 0;
 	const unsigned char* inPtr = static_cast<const unsigned char*>(input);
 	unsigned char* outPtr = static_cast<unsigned char*>(output);
 	switch(type)
 	{
 	case GL_UNSIGNED_BYTE:
 		bytesPerIndex = sizeof(GLubyte);
 		break;
 	case GL_UNSIGNED_INT:
 		bytesPerIndex = sizeof(GLuint);
 		break;
 	case GL_UNSIGNED_SHORT:
 		bytesPerIndex = sizeof(GLushort);
 		break;
 	default:
 		UNREACHABLE(type);
 	}

 	size_t numRestarts = restartIndices.size();
 	switch(mode)
 	{
 	case GL_TRIANGLES:
 	case GL_LINES:
 	case GL_POINTS:
 	{
 		GLsizei verticesPerPrimitive = (mode == GL_TRIANGLES) ? 3 : ((mode == GL_LINES) ? 2 : 1);
 		for(size_t i = 0; i <= numRestarts; ++i)
 		{
 			GLsizei numIndices = getNumIndices(restartIndices, i, count);
 			size_t numBytes = (numIndices / verticesPerPrimitive) * verticesPerPrimitive * bytesPerIndex;
 			if(numBytes > 0)
 			{
 				memcpy(outPtr, inPtr, numBytes);
 				outPtr += numBytes;
 			}
 			inPtr += (numIndices + 1) * bytesPerIndex;
 		}
 	}
 		break;
 	case GL_TRIANGLE_FAN:
 		for(size_t i = 0; i <= numRestarts; ++i)
 		{
 			GLsizei numIndices = getNumIndices(restartIndices, i, count);
 			GLsizei numTriangles = (numIndices - 2);
 			for(GLsizei tri = 0; tri < numTriangles; ++tri)
 			{
 				memcpy(outPtr, inPtr, bytesPerIndex);
 				outPtr += bytesPerIndex;
 				memcpy(outPtr, inPtr + ((tri + 1) * bytesPerIndex), bytesPerIndex + bytesPerIndex);
 				outPtr += bytesPerIndex + bytesPerIndex;
 			}
 			inPtr += (numIndices + 1) * bytesPerIndex;
 		}
 		break;
 	case GL_TRIANGLE_STRIP:
 		for(size_t i = 0; i <= numRestarts; ++i)
 		{
 			GLsizei numIndices = getNumIndices(restartIndices, i, count);
 			GLsizei numTriangles = (numIndices - 2);
 			for(GLsizei tri = 0; tri < numTriangles; ++tri)
 			{
 				if(tri & 1) // Reverse odd triangles
 				{
 					memcpy(outPtr, inPtr + ((tri + 1) * bytesPerIndex), bytesPerIndex);
 					outPtr += bytesPerIndex;
 					memcpy(outPtr, inPtr + ((tri + 0) * bytesPerIndex), bytesPerIndex);
 					outPtr += bytesPerIndex;
 					memcpy(outPtr, inPtr + ((tri + 2) * bytesPerIndex), bytesPerIndex);
 					outPtr += bytesPerIndex;
 				}
 				else
 				{
 					size_t numBytes = 3 * bytesPerIndex;
 					memcpy(outPtr, inPtr + (tri * bytesPerIndex), numBytes);
 					outPtr += numBytes;
 				}
 			}
 			inPtr += (numIndices + 1) * bytesPerIndex;
 		}
 		break;
 	case GL_LINE_LOOP:
 		for(size_t i = 0; i <= numRestarts; ++i)
 		{
 			GLsizei numIndices = getNumIndices(restartIndices, i, count);
 			if(numIndices >= 2)
 			{
 				GLsizei numLines = numIndices;
 				memcpy(outPtr, inPtr + (numIndices - 1) * bytesPerIndex, bytesPerIndex); // Last vertex
 				outPtr += bytesPerIndex;
 				memcpy(outPtr, inPtr, bytesPerIndex); // First vertex
 				outPtr += bytesPerIndex;
 				size_t bytesPerLine = 2 * bytesPerIndex;
 				for(GLsizei tri = 0; tri < (numLines - 1); ++tri)
 				{
 					memcpy(outPtr, inPtr + tri * bytesPerIndex, bytesPerLine);
 					outPtr += bytesPerLine;
 				}
 			}
 			inPtr += (numIndices + 1) * bytesPerIndex;
 		}
 		break;
 	case GL_LINE_STRIP:
 		for(size_t i = 0; i <= numRestarts; ++i)
 		{
 			GLsizei numIndices = getNumIndices(restartIndices, i, count);
 			GLsizei numLines = numIndices - 1;
 			size_t bytesPerLine = 2 * bytesPerIndex;
 			for(GLsizei tri = 0; tri < numLines; ++tri)
 			{
 				memcpy(outPtr, inPtr + tri * bytesPerIndex, bytesPerLine);
 				outPtr += bytesPerLine;
 			}
 			inPtr += (numIndices + 1) * bytesPerIndex;
 		}
 		break;
 	default:
 		UNREACHABLE(mode);
 		break;
 	}
 }

 template<class IndexType>
 void computeRange(const IndexType *indices, GLsizei count, GLuint *minIndex, GLuint *maxIndex, std::vector<GLsizei>* restartIndices)
 {
 	*maxIndex = 0;
 	*minIndex = MAX_ELEMENTS_INDICES;

 	for(GLsizei i = 0; i < count; i++)
 	{
 		if(restartIndices && indices[i] == IndexType(-1))
 		{
 			restartIndices->push_back(i);
 			continue;
 		}
 		if(*minIndex > indices[i]) *minIndex = indices[i];
 		if(*maxIndex < indices[i]) *maxIndex = indices[i];
 	}
 }

 void computeRange(GLenum type, const void *indices, GLsizei count, GLuint *minIndex, GLuint *maxIndex, std::vector<GLsizei>* restartIndices)
 {
 	if(type == GL_UNSIGNED_BYTE)
 	{
 		computeRange(static_cast<const GLubyte*>(indices), count, minIndex, maxIndex, restartIndices);
 	}
 	else if(type == GL_UNSIGNED_INT)
 	{
 		computeRange(static_cast<const GLuint*>(indices), count, minIndex, maxIndex, restartIndices);
 	}
 	else if(type == GL_UNSIGNED_SHORT)
 	{
 		computeRange(static_cast<const GLushort*>(indices), count, minIndex, maxIndex, restartIndices);
 	}
 	else UNREACHABLE(type);
 }

 int recomputePrimitiveCount(GLenum mode, GLsizei count, const std::vector<GLsizei>& restartIndices, unsigned int* primitiveCount)
 {
 	size_t numRestarts = restartIndices.size();
 	*primitiveCount = 0;

 	unsigned int countOffset = 0;
 	unsigned int vertexPerPrimitive = 0;

 	switch(mode)
 	{
 	case GL_TRIANGLES: // 3 vertex per primitive
 		++vertexPerPrimitive;
 	case GL_LINES: //  2 vertex per primitive
 		vertexPerPrimitive += 2;
 		for(size_t i = 0; i <= numRestarts; ++i)
 		{
 			unsigned int nbIndices = getNumIndices(restartIndices, i, count);
 			*primitiveCount += nbIndices / vertexPerPrimitive;
 		}
 		return vertexPerPrimitive;
 	case GL_TRIANGLE_FAN:
 	case GL_TRIANGLE_STRIP: // (N - 2) polygons, 3 vertex per primitive
 		++vertexPerPrimitive;
 		--countOffset;
 	case GL_LINE_STRIP: // (N - 1) polygons, 2 vertex per primitive
 		--countOffset;
 	case GL_LINE_LOOP: // N polygons, 2 vertex per primitive
 		vertexPerPrimitive += 2;
 		for(size_t i = 0; i <= numRestarts; ++i)
 		{
 			unsigned int nbIndices = getNumIndices(restartIndices, i, count);
 			*primitiveCount += (nbIndices >= vertexPerPrimitive) ? (nbIndices + countOffset) : 0;
 		}
 		return vertexPerPrimitive;
 	case GL_POINTS:
 		*primitiveCount = static_cast<unsigned int>(count - restartIndices.size());
 		return 1;
 	default:
 		UNREACHABLE(mode);
 		return -1;
 	}
 }

 GLenum IndexDataManager::prepareIndexData(GLenum mode, GLenum type, GLuint start, GLuint end, GLsizei count, Buffer *buffer, const void *indices, TranslatedIndexData *translated, bool primitiveRestart)
 {
 	if(!mStreamingBuffer)
 	{
 		return GL_OUT_OF_MEMORY;
 	}

 	intptr_t offset = reinterpret_cast<intptr_t>(indices);

 	if(buffer != NULL)
 	{
 		if(typeSize(type) * count + offset > static_cast<std::size_t>(buffer->size()))
 		{
 			return GL_INVALID_OPERATION;
 		}

 		indices = static_cast<const GLubyte*>(buffer->data()) + offset;
 	}

 	std::vector<GLsizei>* restartIndices = primitiveRestart ? new std::vector<GLsizei>() : nullptr;
 	computeRange(type, indices, count, &translated->minIndex, &translated->maxIndex, restartIndices);

 	StreamingIndexBuffer *streamingBuffer = mStreamingBuffer;

 	sw::Resource *staticBuffer = buffer ? buffer->getResource() : NULL;

 	if(restartIndices)
 	{
 		int vertexPerPrimitive = recomputePrimitiveCount(mode, count, *restartIndices, &translated->primitiveCount);
 		if(vertexPerPrimitive == -1)
 		{
 			delete restartIndices;
 			return GL_INVALID_ENUM;
 		}

 		size_t streamOffset = 0;
 		int convertCount = translated->primitiveCount * vertexPerPrimitive;

 		streamingBuffer->reserveSpace(convertCount * typeSize(type), type);
 		void *output = streamingBuffer->map(typeSize(type) * convertCount, &streamOffset);

 		if(output == NULL)
 		{
 			delete restartIndices;
 			ERR("Failed to map index buffer.");
 			return GL_OUT_OF_MEMORY;
 		}

 		copyIndices(mode, type, *restartIndices, indices, count, output);
 		streamingBuffer->unmap();

 		translated->indexBuffer = streamingBuffer->getResource();
 		translated->indexOffset = static_cast<unsigned int>(streamOffset);
 		delete restartIndices;
 	}
 	else if(staticBuffer)
 	{
 		translated->indexBuffer = staticBuffer;
 		translated->indexOffset = static_cast<unsigned int>(offset);
 	}
 	else
 	{
 		size_t streamOffset = 0;
 		int convertCount = count;

 		streamingBuffer->reserveSpace(convertCount * typeSize(type), type);
 		void *output = streamingBuffer->map(typeSize(type) * convertCount, &streamOffset);

 		if(output == NULL)
 		{
 			ERR("Failed to map index buffer.");
 			return GL_OUT_OF_MEMORY;
 		}

 		copyIndices(type, indices, convertCount, output);
 		streamingBuffer->unmap();

 		translated->indexBuffer = streamingBuffer->getResource();
 		translated->indexOffset = static_cast<unsigned int>(streamOffset);
 	}

 	if(translated->minIndex < start || translated->maxIndex > end)
 	{
 		ERR("glDrawRangeElements: out of range access. Range provided: [%d -> %d]. Range used: [%d -> %d].", start, end, translated->minIndex, translated->maxIndex);
 	}

 	return GL_NO_ERROR;
 }

 std::size_t IndexDataManager::typeSize(GLenum type)
 {
 	switch(type)
 	{
 	case GL_UNSIGNED_INT:   return sizeof(GLuint);
 	case GL_UNSIGNED_SHORT: return sizeof(GLushort);
 	case GL_UNSIGNED_BYTE:  return sizeof(GLubyte);
 	default: UNREACHABLE(type); return sizeof(GLushort);
 	}
 }

 StreamingIndexBuffer::StreamingIndexBuffer(size_t initialSize) : mIndexBuffer(NULL), mBufferSize(initialSize)
 {
 	if(initialSize > 0)
 	{
 		mIndexBuffer = new sw::Resource(initialSize + 16);

 		if(!mIndexBuffer)
 		{
 			ERR("Out of memory allocating an index buffer of size %u.", initialSize);
 		}
 	}

 	mWritePosition = 0;
 }

 StreamingIndexBuffer::~StreamingIndexBuffer()
 {
 	if(mIndexBuffer)
 	{
 		mIndexBuffer->destruct();
 	}
 }

 void *StreamingIndexBuffer::map(size_t requiredSpace, size_t *offset)
 {
 	void *mapPtr = NULL;

 	if(mIndexBuffer)
 	{
 		mapPtr = (char*)mIndexBuffer->lock(sw::PUBLIC) + mWritePosition;

 		if(!mapPtr)
 		{
 			ERR(" Lock failed");
 			return NULL;
 		}

 		*offset = mWritePosition;
 		mWritePosition += requiredSpace;
 	}

 	return mapPtr;
 }

 void StreamingIndexBuffer::unmap()
 {
 	if(mIndexBuffer)
 	{
 		mIndexBuffer->unlock();
 	}
 }

 void StreamingIndexBuffer::reserveSpace(size_t requiredSpace, GLenum type)
 {
 	if(requiredSpace > mBufferSize)
 	{
 		if(mIndexBuffer)
 		{
 			mIndexBuffer->destruct();
 			mIndexBuffer = 0;
 		}

 		mBufferSize = std::max(requiredSpace, 2 * mBufferSize);

 		mIndexBuffer = new sw::Resource(mBufferSize + 16);

 		if(!mIndexBuffer)
 		{
 			ERR("Out of memory allocating an index buffer of size %u.", mBufferSize);
 		}

 		mWritePosition = 0;
 	}
 	else if(mWritePosition + requiredSpace > mBufferSize)   // Recycle
 	{
 		if(mIndexBuffer)
 		{
 			mIndexBuffer->destruct();
 			mIndexBuffer = new sw::Resource(mBufferSize + 16);
 		}

 		mWritePosition = 0;
 	}
 }

 sw::Resource *StreamingIndexBuffer::getResource() const
 {
 	return mIndexBuffer;
 }

 }
	// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	// IndexDataManager.cpp: Defines the IndexDataManager, a class that
	// runs the Buffer translation process for index buffers.

	#include "IndexDataManager.h"

	#include "Buffer.h"
	#include "common/debug.h"

	#include <string.h>
	#include <algorithm>

	namespace
	{
	enum { INITIAL_INDEX_BUFFER_SIZE = 4096 * sizeof(GLuint) };
	}

	namespace es2
	{

	IndexDataManager::IndexDataManager()
	{
	mStreamingBuffer = new StreamingIndexBuffer(INITIAL_INDEX_BUFFER_SIZE);

	if(!mStreamingBuffer)
	{
	ERR("Failed to allocate the streaming index buffer.");
	}
	}

	IndexDataManager::~IndexDataManager()
	{
	delete mStreamingBuffer;
	}

	void copyIndices(GLenum type, const void input, GLsizei count, void output)
	{
	if(type == GL_UNSIGNED_BYTE)
	{
	memcpy(output, input, count * sizeof(GLubyte));
	}
	else if(type == GL_UNSIGNED_INT)
	{
	memcpy(output, input, count * sizeof(GLuint));
	}
	else if(type == GL_UNSIGNED_SHORT)
	{
	memcpy(output, input, count * sizeof(GLushort));
	}
	else UNREACHABLE(type);
	}

	inline GLsizei getNumIndices(const std::vector<GLsizei>& restartIndices, size_t i, GLsizei count)
	{
	return restartIndices.empty() ? count :
	((i == 0) ? restartIndices[0] : ((i == restartIndices.size()) ? (count - restartIndices[i - 1] - 1) : (restartIndices[i] - restartIndices[i - 1] - 1)));
	}

	void copyIndices(GLenum mode, GLenum type, const std::vector<GLsizei>& restartIndices, const void input, GLsizei count, void output)
	{
	size_t bytesPerIndex = 0;
	const unsigned char* inPtr = static_cast<const unsigned char*>(input);
	unsigned char* outPtr = static_cast<unsigned char*>(output);
	switch(type)
	{
	case GL_UNSIGNED_BYTE:
	bytesPerIndex = sizeof(GLubyte);
	break;
	case GL_UNSIGNED_INT:
	bytesPerIndex = sizeof(GLuint);
	break;
	case GL_UNSIGNED_SHORT:
	bytesPerIndex = sizeof(GLushort);
	break;
	default:
	UNREACHABLE(type);
	}

	size_t numRestarts = restartIndices.size();
	switch(mode)
	{
	case GL_TRIANGLES:
	case GL_LINES:
	case GL_POINTS:
	{
	GLsizei verticesPerPrimitive = (mode == GL_TRIANGLES) ? 3 : ((mode == GL_LINES) ? 2 : 1);
	for(size_t i = 0; i <= numRestarts; ++i)
	{
	GLsizei numIndices = getNumIndices(restartIndices, i, count);
	size_t numBytes = (numIndices / verticesPerPrimitive) * verticesPerPrimitive * bytesPerIndex;
	if(numBytes > 0)
	{
	memcpy(outPtr, inPtr, numBytes);
	outPtr += numBytes;
	}
	inPtr += (numIndices + 1) * bytesPerIndex;
	}
	}
	break;
	case GL_TRIANGLE_FAN:
	for(size_t i = 0; i <= numRestarts; ++i)
	{
	GLsizei numIndices = getNumIndices(restartIndices, i, count);
	GLsizei numTriangles = (numIndices - 2);
	for(GLsizei tri = 0; tri < numTriangles; ++tri)
	{
	memcpy(outPtr, inPtr, bytesPerIndex);
	outPtr += bytesPerIndex;
	memcpy(outPtr, inPtr + ((tri + 1) * bytesPerIndex), bytesPerIndex + bytesPerIndex);
	outPtr += bytesPerIndex + bytesPerIndex;
	}
	inPtr += (numIndices + 1) * bytesPerIndex;
	}
	break;
	case GL_TRIANGLE_STRIP:
	for(size_t i = 0; i <= numRestarts; ++i)
	{
	GLsizei numIndices = getNumIndices(restartIndices, i, count);
	GLsizei numTriangles = (numIndices - 2);
	for(GLsizei tri = 0; tri < numTriangles; ++tri)
	{
	if(tri & 1) // Reverse odd triangles
	{
	memcpy(outPtr, inPtr + ((tri + 1) * bytesPerIndex), bytesPerIndex);
	outPtr += bytesPerIndex;
	memcpy(outPtr, inPtr + ((tri + 0) * bytesPerIndex), bytesPerIndex);
	outPtr += bytesPerIndex;
	memcpy(outPtr, inPtr + ((tri + 2) * bytesPerIndex), bytesPerIndex);
	outPtr += bytesPerIndex;
	}
	else
	{
	size_t numBytes = 3 * bytesPerIndex;
	memcpy(outPtr, inPtr + (tri * bytesPerIndex), numBytes);
	outPtr += numBytes;
	}
	}
	inPtr += (numIndices + 1) * bytesPerIndex;
	}
	break;
	case GL_LINE_LOOP:
	for(size_t i = 0; i <= numRestarts; ++i)
	{
	GLsizei numIndices = getNumIndices(restartIndices, i, count);
	if(numIndices >= 2)
	{
	GLsizei numLines = numIndices;
	memcpy(outPtr, inPtr + (numIndices - 1) * bytesPerIndex, bytesPerIndex); // Last vertex
	outPtr += bytesPerIndex;
	memcpy(outPtr, inPtr, bytesPerIndex); // First vertex
	outPtr += bytesPerIndex;
	size_t bytesPerLine = 2 * bytesPerIndex;
	for(GLsizei tri = 0; tri < (numLines - 1); ++tri)
	{
	memcpy(outPtr, inPtr + tri * bytesPerIndex, bytesPerLine);
	outPtr += bytesPerLine;
	}
	}
	inPtr += (numIndices + 1) * bytesPerIndex;
	}
	break;
	case GL_LINE_STRIP:
	for(size_t i = 0; i <= numRestarts; ++i)
	{
	GLsizei numIndices = getNumIndices(restartIndices, i, count);
	GLsizei numLines = numIndices - 1;
	size_t bytesPerLine = 2 * bytesPerIndex;
	for(GLsizei tri = 0; tri < numLines; ++tri)
	{
	memcpy(outPtr, inPtr + tri * bytesPerIndex, bytesPerLine);
	outPtr += bytesPerLine;
	}
	inPtr += (numIndices + 1) * bytesPerIndex;
	}
	break;
	default:
	UNREACHABLE(mode);
	break;
	}
	}

	template<class IndexType>
	void computeRange(const IndexType indices, GLsizei count, GLuint minIndex, GLuint maxIndex, std::vector<GLsizei> restartIndices)
	{
	*maxIndex = 0;
	*minIndex = MAX_ELEMENTS_INDICES;

	for(GLsizei i = 0; i < count; i++)
	{
	if(restartIndices && indices[i] == IndexType(-1))
	{
	restartIndices->push_back(i);
	continue;
	}
	if(minIndex > indices[i]) minIndex = indices[i];
	if(maxIndex < indices[i]) maxIndex = indices[i];
	}
	}

	void computeRange(GLenum type, const void indices, GLsizei count, GLuint minIndex, GLuint maxIndex, std::vector<GLsizei> restartIndices)
	{
	if(type == GL_UNSIGNED_BYTE)
	{
	computeRange(static_cast<const GLubyte*>(indices), count, minIndex, maxIndex, restartIndices);
	}
	else if(type == GL_UNSIGNED_INT)
	{
	computeRange(static_cast<const GLuint*>(indices), count, minIndex, maxIndex, restartIndices);
	}
	else if(type == GL_UNSIGNED_SHORT)
	{
	computeRange(static_cast<const GLushort*>(indices), count, minIndex, maxIndex, restartIndices);
	}
	else UNREACHABLE(type);
	}

	int recomputePrimitiveCount(GLenum mode, GLsizei count, const std::vector<GLsizei>& restartIndices, unsigned int* primitiveCount)
	{
	size_t numRestarts = restartIndices.size();
	*primitiveCount = 0;

	unsigned int countOffset = 0;
	unsigned int vertexPerPrimitive = 0;

	switch(mode)
	{
	case GL_TRIANGLES: // 3 vertex per primitive
	++vertexPerPrimitive;
	case GL_LINES: // 2 vertex per primitive
	vertexPerPrimitive += 2;
	for(size_t i = 0; i <= numRestarts; ++i)
	{
	unsigned int nbIndices = getNumIndices(restartIndices, i, count);
	*primitiveCount += nbIndices / vertexPerPrimitive;
	}
	return vertexPerPrimitive;
	case GL_TRIANGLE_FAN:
	case GL_TRIANGLE_STRIP: // (N - 2) polygons, 3 vertex per primitive
	++vertexPerPrimitive;
	--countOffset;
	case GL_LINE_STRIP: // (N - 1) polygons, 2 vertex per primitive
	--countOffset;
	case GL_LINE_LOOP: // N polygons, 2 vertex per primitive
	vertexPerPrimitive += 2;
	for(size_t i = 0; i <= numRestarts; ++i)
	{
	unsigned int nbIndices = getNumIndices(restartIndices, i, count);
	*primitiveCount += (nbIndices >= vertexPerPrimitive) ? (nbIndices + countOffset) : 0;
	}
	return vertexPerPrimitive;
	case GL_POINTS:
	*primitiveCount = static_cast<unsigned int>(count - restartIndices.size());
	return 1;
	default:
	UNREACHABLE(mode);
	return -1;
	}
	}

	GLenum IndexDataManager::prepareIndexData(GLenum mode, GLenum type, GLuint start, GLuint end, GLsizei count, Buffer buffer, const void indices, TranslatedIndexData *translated, bool primitiveRestart)
	{
	if(!mStreamingBuffer)
	{
	return GL_OUT_OF_MEMORY;
	}

	intptr_t offset = reinterpret_cast<intptr_t>(indices);

	if(buffer != NULL)
	{
	if(typeSize(type) * count + offset > static_cast<std::size_t>(buffer->size()))
	{
	return GL_INVALID_OPERATION;
	}

	indices = static_cast<const GLubyte*>(buffer->data()) + offset;
	}

	std::vector<GLsizei>* restartIndices = primitiveRestart ? new std::vector<GLsizei>() : nullptr;
	computeRange(type, indices, count, &translated->minIndex, &translated->maxIndex, restartIndices);

	StreamingIndexBuffer *streamingBuffer = mStreamingBuffer;

	sw::Resource *staticBuffer = buffer ? buffer->getResource() : NULL;

	if(restartIndices)
	{
	int vertexPerPrimitive = recomputePrimitiveCount(mode, count, *restartIndices, &translated->primitiveCount);
	if(vertexPerPrimitive == -1)
	{
	delete restartIndices;
	return GL_INVALID_ENUM;
	}

	size_t streamOffset = 0;
	int convertCount = translated->primitiveCount * vertexPerPrimitive;

	streamingBuffer->reserveSpace(convertCount * typeSize(type), type);
	void output = streamingBuffer->map(typeSize(type) convertCount, &streamOffset);

	if(output == NULL)
	{
	delete restartIndices;
	ERR("Failed to map index buffer.");
	return GL_OUT_OF_MEMORY;
	}

	copyIndices(mode, type, *restartIndices, indices, count, output);
	streamingBuffer->unmap();

	translated->indexBuffer = streamingBuffer->getResource();
	translated->indexOffset = static_cast<unsigned int>(streamOffset);
	delete restartIndices;
	}
	else if(staticBuffer)
	{
	translated->indexBuffer = staticBuffer;
	translated->indexOffset = static_cast<unsigned int>(offset);
	}
	else
	{
	size_t streamOffset = 0;
	int convertCount = count;

	streamingBuffer->reserveSpace(convertCount * typeSize(type), type);
	void output = streamingBuffer->map(typeSize(type) convertCount, &streamOffset);

	if(output == NULL)
	{
	ERR("Failed to map index buffer.");
	return GL_OUT_OF_MEMORY;
	}

	copyIndices(type, indices, convertCount, output);
	streamingBuffer->unmap();

	translated->indexBuffer = streamingBuffer->getResource();
	translated->indexOffset = static_cast<unsigned int>(streamOffset);
	}

	if(translated->minIndex < start \|\| translated->maxIndex > end)
	{
	ERR("glDrawRangeElements: out of range access. Range provided: [%d -> %d]. Range used: [%d -> %d].", start, end, translated->minIndex, translated->maxIndex);
	}

	return GL_NO_ERROR;
	}

	std::size_t IndexDataManager::typeSize(GLenum type)
	{
	switch(type)
	{
	case GL_UNSIGNED_INT: return sizeof(GLuint);
	case GL_UNSIGNED_SHORT: return sizeof(GLushort);
	case GL_UNSIGNED_BYTE: return sizeof(GLubyte);
	default: UNREACHABLE(type); return sizeof(GLushort);
	}
	}

	StreamingIndexBuffer::StreamingIndexBuffer(size_t initialSize) : mIndexBuffer(NULL), mBufferSize(initialSize)
	{
	if(initialSize > 0)
	{
	mIndexBuffer = new sw::Resource(initialSize + 16);

	if(!mIndexBuffer)
	{
	ERR("Out of memory allocating an index buffer of size %u.", initialSize);
	}
	}

	mWritePosition = 0;
	}

	StreamingIndexBuffer::~StreamingIndexBuffer()
	{
	if(mIndexBuffer)
	{
	mIndexBuffer->destruct();
	}
	}

	void StreamingIndexBuffer::map(size_t requiredSpace, size_t offset)
	{
	void *mapPtr = NULL;

	if(mIndexBuffer)
	{
	mapPtr = (char*)mIndexBuffer->lock(sw::PUBLIC) + mWritePosition;

	if(!mapPtr)
	{
	ERR(" Lock failed");
	return NULL;
	}

	*offset = mWritePosition;
	mWritePosition += requiredSpace;
	}

	return mapPtr;
	}

	void StreamingIndexBuffer::unmap()
	{
	if(mIndexBuffer)
	{
	mIndexBuffer->unlock();
	}
	}

	void StreamingIndexBuffer::reserveSpace(size_t requiredSpace, GLenum type)
	{
	if(requiredSpace > mBufferSize)
	{
	if(mIndexBuffer)
	{
	mIndexBuffer->destruct();
	mIndexBuffer = 0;
	}

	mBufferSize = std::max(requiredSpace, 2 * mBufferSize);

	mIndexBuffer = new sw::Resource(mBufferSize + 16);

	if(!mIndexBuffer)
	{
	ERR("Out of memory allocating an index buffer of size %u.", mBufferSize);
	}

	mWritePosition = 0;
	}
	else if(mWritePosition + requiredSpace > mBufferSize) // Recycle
	{
	if(mIndexBuffer)
	{
	mIndexBuffer->destruct();
	mIndexBuffer = new sw::Resource(mBufferSize + 16);
	}

	mWritePosition = 0;
	}
	}

	sw::Resource *StreamingIndexBuffer::getResource() const
	{
	return mIndexBuffer;
	}

	}