src/third_party/angle/src/libANGLE/renderer/d3d/IndexDataManager.cpp - cobalt - Git at Google

 //
 // Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //

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

 #include "libANGLE/renderer/d3d/IndexDataManager.h"

 #include "common/utilities.h"
 #include "libANGLE/Buffer.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/d3d/BufferD3D.h"
 #include "libANGLE/renderer/d3d/IndexBuffer.h"

 namespace rx
 {

 namespace
 {

 template <typename InputT, typename DestT>
 void ConvertIndexArray(const void *input,
                        GLenum sourceType,
                        void *output,
                        GLenum destinationType,
                        GLsizei count,
                        bool usePrimitiveRestartFixedIndex)
 {
     const InputT *in = static_cast<const InputT *>(input);
     DestT *out       = static_cast<DestT *>(output);

     if (usePrimitiveRestartFixedIndex)
     {
         InputT srcRestartIndex = static_cast<InputT>(gl::GetPrimitiveRestartIndex(sourceType));
         DestT destRestartIndex = static_cast<DestT>(gl::GetPrimitiveRestartIndex(destinationType));
         for (GLsizei i = 0; i < count; i++)
         {
             out[i] = (in[i] == srcRestartIndex ? destRestartIndex : static_cast<DestT>(in[i]));
         }
     }
     else
     {
         for (GLsizei i = 0; i < count; i++)
         {
             out[i] = static_cast<DestT>(in[i]);
         }
     }
 }

 void ConvertIndices(GLenum sourceType,
                     GLenum destinationType,
                     const void *input,
                     GLsizei count,
                     void *output,
                     bool usePrimitiveRestartFixedIndex)
 {
     if (sourceType == destinationType)
     {
         const gl::Type &typeInfo = gl::GetTypeInfo(destinationType);
         memcpy(output, input, count * typeInfo.bytes);
         return;
     }

     if (sourceType == GL_UNSIGNED_BYTE)
     {
         ASSERT(destinationType == GL_UNSIGNED_SHORT);
         ConvertIndexArray<GLubyte, GLushort>(input, sourceType, output, destinationType, count,
                                              usePrimitiveRestartFixedIndex);
     }
     else if (sourceType == GL_UNSIGNED_SHORT)
     {
         ASSERT(destinationType == GL_UNSIGNED_INT);
         ConvertIndexArray<GLushort, GLuint>(input, sourceType, output, destinationType, count,
                                             usePrimitiveRestartFixedIndex);
     }
     else
         UNREACHABLE();
 }

 gl::Error StreamInIndexBuffer(IndexBufferInterface *buffer,
                               const void *data,
                               unsigned int count,
                               GLenum srcType,
                               GLenum dstType,
                               bool usePrimitiveRestartFixedIndex,
                               unsigned int *offset)
 {
     const gl::Type &dstTypeInfo = gl::GetTypeInfo(dstType);

     if (count > (std::numeric_limits<unsigned int>::max() >> dstTypeInfo.bytesShift))
     {
         return gl::Error(GL_OUT_OF_MEMORY,
                          "Reserving %u indices of %u bytes each exceeds the maximum buffer size.",
                          count, dstTypeInfo.bytes);
     }

     unsigned int bufferSizeRequired = count << dstTypeInfo.bytesShift;
     gl::Error error                 = buffer->reserveBufferSpace(bufferSizeRequired, dstType);
     if (error.isError())
     {
         return error;
     }

     void *output = nullptr;
     error        = buffer->mapBuffer(bufferSizeRequired, &output, offset);
     if (error.isError())
     {
         return error;
     }

     ConvertIndices(srcType, dstType, data, count, output, usePrimitiveRestartFixedIndex);

     error = buffer->unmapBuffer();
     if (error.isError())
     {
         return error;
     }

     return gl::NoError();
 }

 }  // anonymous namespace

 IndexDataManager::IndexDataManager(BufferFactoryD3D *factory, RendererClass rendererClass)
     : mFactory(factory),
       mRendererClass(rendererClass),
       mStreamingBufferShort(nullptr),
       mStreamingBufferInt(nullptr)
 {
 }

 IndexDataManager::~IndexDataManager()
 {
     SafeDelete(mStreamingBufferShort);
     SafeDelete(mStreamingBufferInt);
 }

 bool IndexDataManager::usePrimitiveRestartWorkaround(bool primitiveRestartFixedIndexEnabled,
                                                      GLenum type)
 {
     // We should never have to deal with primitive restart workaround issue with GL_UNSIGNED_INT
     // indices, since we restrict it via MAX_ELEMENT_INDEX.
     return (!primitiveRestartFixedIndexEnabled && type == GL_UNSIGNED_SHORT &&
             mRendererClass == RENDERER_D3D11);
 }

 bool IndexDataManager::isStreamingIndexData(bool primitiveRestartWorkaround,
                                             GLenum srcType,
                                             gl::Buffer *glBuffer)
 {
     BufferD3D *buffer = glBuffer ? GetImplAs<BufferD3D>(glBuffer) : nullptr;

     // Case 1: the indices are passed by pointer, which forces the streaming of index data
     if (glBuffer == nullptr)
     {
         return true;
     }

     const GLenum dstType = (srcType == GL_UNSIGNED_INT || primitiveRestartWorkaround)
                                ? GL_UNSIGNED_INT
                                : GL_UNSIGNED_SHORT;

     // Case 2a: the buffer can be used directly
     if (buffer->supportsDirectBinding() && dstType == srcType)
     {
         return false;
     }

     // Case 2b: use a static translated copy or fall back to streaming
     StaticIndexBufferInterface *staticBuffer = buffer->getStaticIndexBuffer();
     if (staticBuffer == nullptr)
     {
         return true;
     }

     if ((staticBuffer->getBufferSize() != 0) && (staticBuffer->getIndexType() != dstType))
     {
         return true;
     }

     return false;
 }

 // This function translates a GL-style indices into DX-style indices, with their description
 // returned in translated.
 // GL can specify vertex data in immediate mode (pointer to CPU array of indices), which is not
 // possible in DX and requires streaming (Case 1). If the GL indices are specified with a buffer
 // (Case 2), in a format supported by DX (subcase a) then all is good.
 // When we have a buffer with an unsupported format (subcase b) then we need to do some translation:
 // we will start by falling back to streaming, and after a while will start using a static
 // translated copy of the index buffer.
 gl::Error IndexDataManager::prepareIndexData(GLenum srcType,
                                              GLsizei count,
                                              gl::Buffer *glBuffer,
                                              const void *indices,
                                              TranslatedIndexData *translated,
                                              bool primitiveRestartFixedIndexEnabled)
 {
     // Avoid D3D11's primitive restart index value
     // see http://msdn.microsoft.com/en-us/library/windows/desktop/bb205124(v=vs.85).aspx
     bool hasPrimitiveRestartIndex =
         translated->indexRange.vertexIndexCount < static_cast<size_t>(count) ||
         translated->indexRange.end == gl::GetPrimitiveRestartIndex(srcType);
     bool primitiveRestartWorkaround =
         usePrimitiveRestartWorkaround(primitiveRestartFixedIndexEnabled, srcType) &&
         hasPrimitiveRestartIndex;

     // We should never have to deal with MAX_UINT indices, since we restrict it via
     // MAX_ELEMENT_INDEX.
     ASSERT(!(mRendererClass == RENDERER_D3D11 && !primitiveRestartFixedIndexEnabled &&
              hasPrimitiveRestartIndex && srcType == GL_UNSIGNED_INT));

     const GLenum dstType = (srcType == GL_UNSIGNED_INT || primitiveRestartWorkaround)
                                ? GL_UNSIGNED_INT
                                : GL_UNSIGNED_SHORT;

     const gl::Type &srcTypeInfo = gl::GetTypeInfo(srcType);
     const gl::Type &dstTypeInfo = gl::GetTypeInfo(dstType);

     BufferD3D *buffer = glBuffer ? GetImplAs<BufferD3D>(glBuffer) : nullptr;

     translated->indexType                 = dstType;
     translated->srcIndexData.srcBuffer    = buffer;
     translated->srcIndexData.srcIndices   = indices;
     translated->srcIndexData.srcIndexType = srcType;
     translated->srcIndexData.srcCount     = count;

     // Case 1: the indices are passed by pointer, which forces the streaming of index data
     if (glBuffer == nullptr)
     {
         translated->storage = nullptr;
         return streamIndexData(indices, count, srcType, dstType, primitiveRestartFixedIndexEnabled,
                                translated);
     }

     // Case 2: the indices are already in a buffer
     unsigned int offset = static_cast<unsigned int>(reinterpret_cast<uintptr_t>(indices));
     ASSERT(srcTypeInfo.bytes * static_cast<unsigned int>(count) + offset <= buffer->getSize());

     bool offsetAligned;
     switch (srcType)
     {
         case GL_UNSIGNED_BYTE:
             offsetAligned = (offset % sizeof(GLubyte) == 0);
             break;
         case GL_UNSIGNED_SHORT:
             offsetAligned = (offset % sizeof(GLushort) == 0);
             break;
         case GL_UNSIGNED_INT:
             offsetAligned = (offset % sizeof(GLuint) == 0);
             break;
         default:
             UNREACHABLE();
             offsetAligned = false;
     }

     // Case 2a: the buffer can be used directly
     if (offsetAligned && buffer->supportsDirectBinding() && dstType == srcType)
     {
         translated->storage     = buffer;
         translated->indexBuffer = nullptr;
         translated->serial      = buffer->getSerial();
         translated->startIndex  = (offset >> srcTypeInfo.bytesShift);
         translated->startOffset = offset;
         return gl::NoError();
     }
     else
     {
         translated->storage = nullptr;
     }

     // Case 2b: use a static translated copy or fall back to streaming
     StaticIndexBufferInterface *staticBuffer = buffer->getStaticIndexBuffer();

     bool staticBufferInitialized = staticBuffer && staticBuffer->getBufferSize() != 0;
     bool staticBufferUsable =
         staticBuffer && offsetAligned && staticBuffer->getIndexType() == dstType;

     if (staticBufferInitialized && !staticBufferUsable)
     {
         buffer->invalidateStaticData();
         staticBuffer = nullptr;
     }

     if (staticBuffer == nullptr || !offsetAligned)
     {
         const uint8_t *bufferData = nullptr;
         gl::Error error           = buffer->getData(&bufferData);
         if (error.isError())
         {
             return error;
         }
         ASSERT(bufferData != nullptr);

         error = streamIndexData(bufferData + offset, count, srcType, dstType,
                                 primitiveRestartFixedIndexEnabled, translated);
         if (error.isError())
         {
             return error;
         }
         buffer->promoteStaticUsage(count << srcTypeInfo.bytesShift);
     }
     else
     {
         if (!staticBufferInitialized)
         {
             const uint8_t *bufferData = nullptr;
             gl::Error error           = buffer->getData(&bufferData);
             if (error.isError())
             {
                 return error;
             }
             ASSERT(bufferData != nullptr);

             unsigned int convertCount =
                 static_cast<unsigned int>(buffer->getSize()) >> srcTypeInfo.bytesShift;
             error = StreamInIndexBuffer(staticBuffer, bufferData, convertCount, srcType, dstType,
                                         primitiveRestartFixedIndexEnabled, nullptr);
             if (error.isError())
             {
                 return error;
             }
         }
         ASSERT(offsetAligned && staticBuffer->getIndexType() == dstType);

         translated->indexBuffer = staticBuffer->getIndexBuffer();
         translated->serial      = staticBuffer->getSerial();
         translated->startIndex  = (offset >> srcTypeInfo.bytesShift);
         translated->startOffset = (offset >> srcTypeInfo.bytesShift) << dstTypeInfo.bytesShift;
     }

     return gl::NoError();
 }

 gl::Error IndexDataManager::streamIndexData(const void *data,
                                             unsigned int count,
                                             GLenum srcType,
                                             GLenum dstType,
                                             bool usePrimitiveRestartFixedIndex,
                                             TranslatedIndexData *translated)
 {
     const gl::Type &dstTypeInfo = gl::GetTypeInfo(dstType);

     IndexBufferInterface *indexBuffer = nullptr;
     gl::Error error                   = getStreamingIndexBuffer(dstType, &indexBuffer);
     if (error.isError())
     {
         return error;
     }
     ASSERT(indexBuffer != nullptr);

     unsigned int offset;
     StreamInIndexBuffer(indexBuffer, data, count, srcType, dstType, usePrimitiveRestartFixedIndex,
                         &offset);

     translated->indexBuffer = indexBuffer->getIndexBuffer();
     translated->serial      = indexBuffer->getSerial();
     translated->startIndex  = (offset >> dstTypeInfo.bytesShift);
     translated->startOffset = offset;

     return gl::NoError();
 }

 gl::Error IndexDataManager::getStreamingIndexBuffer(GLenum destinationIndexType,
                                                     IndexBufferInterface **outBuffer)
 {
     ASSERT(outBuffer);
     if (destinationIndexType == GL_UNSIGNED_INT)
     {
         if (!mStreamingBufferInt)
         {
             mStreamingBufferInt = new StreamingIndexBufferInterface(mFactory);
             gl::Error error =
                 mStreamingBufferInt->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_INT);
             if (error.isError())
             {
                 SafeDelete(mStreamingBufferInt);
                 return error;
             }
         }

         *outBuffer = mStreamingBufferInt;
         return gl::NoError();
     }
     else
     {
         ASSERT(destinationIndexType == GL_UNSIGNED_SHORT);

         if (!mStreamingBufferShort)
         {
             mStreamingBufferShort = new StreamingIndexBufferInterface(mFactory);
             gl::Error error = mStreamingBufferShort->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE,
                                                                         GL_UNSIGNED_SHORT);
             if (error.isError())
             {
                 SafeDelete(mStreamingBufferShort);
                 return error;
             }
         }

         *outBuffer = mStreamingBufferShort;
         return gl::NoError();
     }
 }
 }
	//
	// Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.
	//

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

	#include "libANGLE/renderer/d3d/IndexDataManager.h"

	#include "common/utilities.h"
	#include "libANGLE/Buffer.h"
	#include "libANGLE/formatutils.h"
	#include "libANGLE/renderer/d3d/BufferD3D.h"
	#include "libANGLE/renderer/d3d/IndexBuffer.h"

	namespace rx
	{

	namespace
	{

	template <typename InputT, typename DestT>
	void ConvertIndexArray(const void *input,
	GLenum sourceType,
	void *output,
	GLenum destinationType,
	GLsizei count,
	bool usePrimitiveRestartFixedIndex)
	{
	const InputT in = static_cast<const InputT >(input);
	DestT out = static_cast<DestT >(output);

	if (usePrimitiveRestartFixedIndex)
	{
	InputT srcRestartIndex = static_cast<InputT>(gl::GetPrimitiveRestartIndex(sourceType));
	DestT destRestartIndex = static_cast<DestT>(gl::GetPrimitiveRestartIndex(destinationType));
	for (GLsizei i = 0; i < count; i++)
	{
	out[i] = (in[i] == srcRestartIndex ? destRestartIndex : static_cast<DestT>(in[i]));
	}
	}
	else
	{
	for (GLsizei i = 0; i < count; i++)
	{
	out[i] = static_cast<DestT>(in[i]);
	}
	}
	}

	void ConvertIndices(GLenum sourceType,
	GLenum destinationType,
	const void *input,
	GLsizei count,
	void *output,
	bool usePrimitiveRestartFixedIndex)
	{
	if (sourceType == destinationType)
	{
	const gl::Type &typeInfo = gl::GetTypeInfo(destinationType);
	memcpy(output, input, count * typeInfo.bytes);
	return;
	}

	if (sourceType == GL_UNSIGNED_BYTE)
	{
	ASSERT(destinationType == GL_UNSIGNED_SHORT);
	ConvertIndexArray<GLubyte, GLushort>(input, sourceType, output, destinationType, count,
	usePrimitiveRestartFixedIndex);
	}
	else if (sourceType == GL_UNSIGNED_SHORT)
	{
	ASSERT(destinationType == GL_UNSIGNED_INT);
	ConvertIndexArray<GLushort, GLuint>(input, sourceType, output, destinationType, count,
	usePrimitiveRestartFixedIndex);
	}
	else
	UNREACHABLE();
	}

	gl::Error StreamInIndexBuffer(IndexBufferInterface *buffer,
	const void *data,
	unsigned int count,
	GLenum srcType,
	GLenum dstType,
	bool usePrimitiveRestartFixedIndex,
	unsigned int *offset)
	{
	const gl::Type &dstTypeInfo = gl::GetTypeInfo(dstType);

	if (count > (std::numeric_limits<unsigned int>::max() >> dstTypeInfo.bytesShift))
	{
	return gl::Error(GL_OUT_OF_MEMORY,
	"Reserving %u indices of %u bytes each exceeds the maximum buffer size.",
	count, dstTypeInfo.bytes);
	}

	unsigned int bufferSizeRequired = count << dstTypeInfo.bytesShift;
	gl::Error error = buffer->reserveBufferSpace(bufferSizeRequired, dstType);
	if (error.isError())
	{
	return error;
	}

	void *output = nullptr;
	error = buffer->mapBuffer(bufferSizeRequired, &output, offset);
	if (error.isError())
	{
	return error;
	}

	ConvertIndices(srcType, dstType, data, count, output, usePrimitiveRestartFixedIndex);

	error = buffer->unmapBuffer();
	if (error.isError())
	{
	return error;
	}

	return gl::NoError();
	}

	} // anonymous namespace

	IndexDataManager::IndexDataManager(BufferFactoryD3D *factory, RendererClass rendererClass)
	: mFactory(factory),
	mRendererClass(rendererClass),
	mStreamingBufferShort(nullptr),
	mStreamingBufferInt(nullptr)
	{
	}

	IndexDataManager::~IndexDataManager()
	{
	SafeDelete(mStreamingBufferShort);
	SafeDelete(mStreamingBufferInt);
	}

	bool IndexDataManager::usePrimitiveRestartWorkaround(bool primitiveRestartFixedIndexEnabled,
	GLenum type)
	{
	// We should never have to deal with primitive restart workaround issue with GL_UNSIGNED_INT
	// indices, since we restrict it via MAX_ELEMENT_INDEX.
	return (!primitiveRestartFixedIndexEnabled && type == GL_UNSIGNED_SHORT &&
	mRendererClass == RENDERER_D3D11);
	}

	bool IndexDataManager::isStreamingIndexData(bool primitiveRestartWorkaround,
	GLenum srcType,
	gl::Buffer *glBuffer)
	{
	BufferD3D *buffer = glBuffer ? GetImplAs<BufferD3D>(glBuffer) : nullptr;

	// Case 1: the indices are passed by pointer, which forces the streaming of index data
	if (glBuffer == nullptr)
	{
	return true;
	}

	const GLenum dstType = (srcType == GL_UNSIGNED_INT \|\| primitiveRestartWorkaround)
	? GL_UNSIGNED_INT
	: GL_UNSIGNED_SHORT;

	// Case 2a: the buffer can be used directly
	if (buffer->supportsDirectBinding() && dstType == srcType)
	{
	return false;
	}

	// Case 2b: use a static translated copy or fall back to streaming
	StaticIndexBufferInterface *staticBuffer = buffer->getStaticIndexBuffer();
	if (staticBuffer == nullptr)
	{
	return true;
	}

	if ((staticBuffer->getBufferSize() != 0) && (staticBuffer->getIndexType() != dstType))
	{
	return true;
	}

	return false;
	}

	// This function translates a GL-style indices into DX-style indices, with their description
	// returned in translated.
	// GL can specify vertex data in immediate mode (pointer to CPU array of indices), which is not
	// possible in DX and requires streaming (Case 1). If the GL indices are specified with a buffer
	// (Case 2), in a format supported by DX (subcase a) then all is good.
	// When we have a buffer with an unsupported format (subcase b) then we need to do some translation:
	// we will start by falling back to streaming, and after a while will start using a static
	// translated copy of the index buffer.
	gl::Error IndexDataManager::prepareIndexData(GLenum srcType,
	GLsizei count,
	gl::Buffer *glBuffer,
	const void *indices,
	TranslatedIndexData *translated,
	bool primitiveRestartFixedIndexEnabled)
	{
	// Avoid D3D11's primitive restart index value
	// see http://msdn.microsoft.com/en-us/library/windows/desktop/bb205124(v=vs.85).aspx
	bool hasPrimitiveRestartIndex =
	translated->indexRange.vertexIndexCount < static_cast<size_t>(count) \|\|
	translated->indexRange.end == gl::GetPrimitiveRestartIndex(srcType);
	bool primitiveRestartWorkaround =
	usePrimitiveRestartWorkaround(primitiveRestartFixedIndexEnabled, srcType) &&
	hasPrimitiveRestartIndex;

	// We should never have to deal with MAX_UINT indices, since we restrict it via
	// MAX_ELEMENT_INDEX.
	ASSERT(!(mRendererClass == RENDERER_D3D11 && !primitiveRestartFixedIndexEnabled &&
	hasPrimitiveRestartIndex && srcType == GL_UNSIGNED_INT));

	const GLenum dstType = (srcType == GL_UNSIGNED_INT \|\| primitiveRestartWorkaround)
	? GL_UNSIGNED_INT
	: GL_UNSIGNED_SHORT;

	const gl::Type &srcTypeInfo = gl::GetTypeInfo(srcType);
	const gl::Type &dstTypeInfo = gl::GetTypeInfo(dstType);

	BufferD3D *buffer = glBuffer ? GetImplAs<BufferD3D>(glBuffer) : nullptr;

	translated->indexType = dstType;
	translated->srcIndexData.srcBuffer = buffer;
	translated->srcIndexData.srcIndices = indices;
	translated->srcIndexData.srcIndexType = srcType;
	translated->srcIndexData.srcCount = count;

	// Case 1: the indices are passed by pointer, which forces the streaming of index data
	if (glBuffer == nullptr)
	{
	translated->storage = nullptr;
	return streamIndexData(indices, count, srcType, dstType, primitiveRestartFixedIndexEnabled,
	translated);
	}

	// Case 2: the indices are already in a buffer
	unsigned int offset = static_cast<unsigned int>(reinterpret_cast<uintptr_t>(indices));
	ASSERT(srcTypeInfo.bytes * static_cast<unsigned int>(count) + offset <= buffer->getSize());

	bool offsetAligned;
	switch (srcType)
	{
	case GL_UNSIGNED_BYTE:
	offsetAligned = (offset % sizeof(GLubyte) == 0);
	break;
	case GL_UNSIGNED_SHORT:
	offsetAligned = (offset % sizeof(GLushort) == 0);
	break;
	case GL_UNSIGNED_INT:
	offsetAligned = (offset % sizeof(GLuint) == 0);
	break;
	default:
	UNREACHABLE();
	offsetAligned = false;
	}

	// Case 2a: the buffer can be used directly
	if (offsetAligned && buffer->supportsDirectBinding() && dstType == srcType)
	{
	translated->storage = buffer;
	translated->indexBuffer = nullptr;
	translated->serial = buffer->getSerial();
	translated->startIndex = (offset >> srcTypeInfo.bytesShift);
	translated->startOffset = offset;
	return gl::NoError();
	}
	else
	{
	translated->storage = nullptr;
	}

	// Case 2b: use a static translated copy or fall back to streaming
	StaticIndexBufferInterface *staticBuffer = buffer->getStaticIndexBuffer();

	bool staticBufferInitialized = staticBuffer && staticBuffer->getBufferSize() != 0;
	bool staticBufferUsable =
	staticBuffer && offsetAligned && staticBuffer->getIndexType() == dstType;

	if (staticBufferInitialized && !staticBufferUsable)
	{
	buffer->invalidateStaticData();
	staticBuffer = nullptr;
	}

	if (staticBuffer == nullptr \|\| !offsetAligned)
	{
	const uint8_t *bufferData = nullptr;
	gl::Error error = buffer->getData(&bufferData);
	if (error.isError())
	{
	return error;
	}
	ASSERT(bufferData != nullptr);

	error = streamIndexData(bufferData + offset, count, srcType, dstType,
	primitiveRestartFixedIndexEnabled, translated);
	if (error.isError())
	{
	return error;
	}
	buffer->promoteStaticUsage(count << srcTypeInfo.bytesShift);
	}
	else
	{
	if (!staticBufferInitialized)
	{
	const uint8_t *bufferData = nullptr;
	gl::Error error = buffer->getData(&bufferData);
	if (error.isError())
	{
	return error;
	}
	ASSERT(bufferData != nullptr);

	unsigned int convertCount =
	static_cast<unsigned int>(buffer->getSize()) >> srcTypeInfo.bytesShift;
	error = StreamInIndexBuffer(staticBuffer, bufferData, convertCount, srcType, dstType,
	primitiveRestartFixedIndexEnabled, nullptr);
	if (error.isError())
	{
	return error;
	}
	}
	ASSERT(offsetAligned && staticBuffer->getIndexType() == dstType);

	translated->indexBuffer = staticBuffer->getIndexBuffer();
	translated->serial = staticBuffer->getSerial();
	translated->startIndex = (offset >> srcTypeInfo.bytesShift);
	translated->startOffset = (offset >> srcTypeInfo.bytesShift) << dstTypeInfo.bytesShift;
	}

	return gl::NoError();
	}

	gl::Error IndexDataManager::streamIndexData(const void *data,
	unsigned int count,
	GLenum srcType,
	GLenum dstType,
	bool usePrimitiveRestartFixedIndex,
	TranslatedIndexData *translated)
	{
	const gl::Type &dstTypeInfo = gl::GetTypeInfo(dstType);

	IndexBufferInterface *indexBuffer = nullptr;
	gl::Error error = getStreamingIndexBuffer(dstType, &indexBuffer);
	if (error.isError())
	{
	return error;
	}
	ASSERT(indexBuffer != nullptr);

	unsigned int offset;
	StreamInIndexBuffer(indexBuffer, data, count, srcType, dstType, usePrimitiveRestartFixedIndex,
	&offset);

	translated->indexBuffer = indexBuffer->getIndexBuffer();
	translated->serial = indexBuffer->getSerial();
	translated->startIndex = (offset >> dstTypeInfo.bytesShift);
	translated->startOffset = offset;

	return gl::NoError();
	}

	gl::Error IndexDataManager::getStreamingIndexBuffer(GLenum destinationIndexType,
	IndexBufferInterface **outBuffer)
	{
	ASSERT(outBuffer);
	if (destinationIndexType == GL_UNSIGNED_INT)
	{
	if (!mStreamingBufferInt)
	{
	mStreamingBufferInt = new StreamingIndexBufferInterface(mFactory);
	gl::Error error =
	mStreamingBufferInt->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE, GL_UNSIGNED_INT);
	if (error.isError())
	{
	SafeDelete(mStreamingBufferInt);
	return error;
	}
	}

	*outBuffer = mStreamingBufferInt;
	return gl::NoError();
	}
	else
	{
	ASSERT(destinationIndexType == GL_UNSIGNED_SHORT);

	if (!mStreamingBufferShort)
	{
	mStreamingBufferShort = new StreamingIndexBufferInterface(mFactory);
	gl::Error error = mStreamingBufferShort->reserveBufferSpace(INITIAL_INDEX_BUFFER_SIZE,
	GL_UNSIGNED_SHORT);
	if (error.isError())
	{
	SafeDelete(mStreamingBufferShort);
	return error;
	}
	}

	*outBuffer = mStreamingBufferShort;
	return gl::NoError();
	}
	}
	}