android-10.0.0_r47/s

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL Utilities
 * ---------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * 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.
 *
 *//*!
 * \file
 * \brief Draw call utilities.
 *//*--------------------------------------------------------------------*/

#include "gluDrawUtil.hpp"
#include "gluRenderContext.hpp"
#include "gluObjectWrapper.hpp"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"
#include "deInt32.h"
#include "deMemory.h"

#include <vector>
#include <set>
#include <iterator>

namespace glu
{
namespace
{

struct VertexAttributeDescriptor
{
	int							location;
	VertexComponentType			componentType;
	VertexComponentConversion	convert;
	int							numComponents;
	int							numElements;
	int							stride;				//!< Stride or 0 if using default stride.
	const void*					pointer;			//!< Pointer or offset.

	VertexAttributeDescriptor (int							location_,
							   VertexComponentType			componentType_,
							   VertexComponentConversion	convert_,
							   int							numComponents_,
							   int							numElements_,
							   int							stride_,
							   const void*					pointer_)
		: location		(location_)
		, componentType	(componentType_)
		, convert		(convert_)
		, numComponents	(numComponents_)
		, numElements	(numElements_)
		, stride		(stride_)
		, pointer		(pointer_)
	{
	}

	VertexAttributeDescriptor (void)
		: location		(0)
		, componentType	(VTX_COMP_TYPE_LAST)
		, convert		(VTX_COMP_CONVERT_LAST)
		, numComponents	(0)
		, numElements	(0)
		, stride		(0)
		, pointer		(0)
	{
	}
};

struct VertexBufferLayout
{
	int										size;
	std::vector<VertexAttributeDescriptor>	attributes;

	VertexBufferLayout (int size_ = 0)
		: size(size_)
	{
	}
};

struct VertexBufferDescriptor
{
	deUint32								buffer;
	std::vector<VertexAttributeDescriptor>	attributes;

	VertexBufferDescriptor (deUint32 buffer_ = 0)
		: buffer(buffer_)
	{
	}
};

class VertexBuffer : public Buffer
{
public:
	enum Type
	{
		TYPE_PLANAR = 0,	//!< Data for each vertex array resides in a separate contiguous block in buffer.
		TYPE_STRIDED,		//!< Vertex arrays are interleaved.

		TYPE_LAST
	};

									VertexBuffer		(const RenderContext& context, int numBindings, const VertexArrayBinding* bindings, Type type = TYPE_PLANAR);
									~VertexBuffer		(void);

	const VertexBufferDescriptor&	getDescriptor		(void) const { return m_layout; }

private:
									VertexBuffer		(const VertexBuffer& other);
	VertexBuffer&					operator=			(const VertexBuffer& other);

	VertexBufferDescriptor			m_layout;
};

class IndexBuffer : public Buffer
{
public:
									IndexBuffer			(const RenderContext& context, IndexType indexType, int numIndices, const void* indices);
									~IndexBuffer		(void);

private:
									IndexBuffer			(const IndexBuffer& other);
	IndexBuffer&					operator=			(const IndexBuffer& other);
};

static deUint32 getVtxCompGLType (VertexComponentType type)
{
	switch (type)
	{
		case VTX_COMP_UNSIGNED_INT8:	return GL_UNSIGNED_BYTE;
		case VTX_COMP_UNSIGNED_INT16:	return GL_UNSIGNED_SHORT;
		case VTX_COMP_UNSIGNED_INT32:	return GL_UNSIGNED_INT;
		case VTX_COMP_SIGNED_INT8:		return GL_BYTE;
		case VTX_COMP_SIGNED_INT16:		return GL_SHORT;
		case VTX_COMP_SIGNED_INT32:		return GL_INT;
		case VTX_COMP_FIXED:			return GL_FIXED;
		case VTX_COMP_HALF_FLOAT:		return GL_HALF_FLOAT;
		case VTX_COMP_FLOAT:			return GL_FLOAT;
		default:
			DE_ASSERT(false);
			return GL_NONE;
	}
}

static int getVtxCompSize (VertexComponentType type)
{
	switch (type)
	{
		case VTX_COMP_UNSIGNED_INT8:	return 1;
		case VTX_COMP_UNSIGNED_INT16:	return 2;
		case VTX_COMP_UNSIGNED_INT32:	return 4;
		case VTX_COMP_SIGNED_INT8:		return 1;
		case VTX_COMP_SIGNED_INT16:		return 2;
		case VTX_COMP_SIGNED_INT32:		return 4;
		case VTX_COMP_FIXED:			return 4;
		case VTX_COMP_HALF_FLOAT:		return 2;
		case VTX_COMP_FLOAT:			return 4;
		default:
			DE_ASSERT(false);
			return 0;
	}
}

static deUint32 getIndexGLType (IndexType type)
{
	switch (type)
	{
		case INDEXTYPE_UINT8:	return GL_UNSIGNED_BYTE;
		case INDEXTYPE_UINT16:	return GL_UNSIGNED_SHORT;
		case INDEXTYPE_UINT32:	return GL_UNSIGNED_INT;
		default:
			DE_ASSERT(false);
			return 0;
	}
}

static int getIndexSize (IndexType type)
{
	switch (type)
	{
		case INDEXTYPE_UINT8:	return 1;
		case INDEXTYPE_UINT16:	return 2;
		case INDEXTYPE_UINT32:	return 4;
		default:
			DE_ASSERT(false);
			return 0;
	}
}

static deUint32 getPrimitiveGLType (PrimitiveType type)
{
	switch (type)
	{
		case PRIMITIVETYPE_TRIANGLES:		return GL_TRIANGLES;
		case PRIMITIVETYPE_TRIANGLE_STRIP:	return GL_TRIANGLE_STRIP;
		case PRIMITIVETYPE_TRIANGLE_FAN:	return GL_TRIANGLE_FAN;
		case PRIMITIVETYPE_LINES:			return GL_LINES;
		case PRIMITIVETYPE_LINE_STRIP:		return GL_LINE_STRIP;
		case PRIMITIVETYPE_LINE_LOOP:		return GL_LINE_LOOP;
		case PRIMITIVETYPE_POINTS:			return GL_POINTS;
		case PRIMITIVETYPE_PATCHES:			return GL_PATCHES;
		default:
			DE_ASSERT(false);
			return 0;
	}
}

//! Lower named bindings to locations and eliminate bindings that are not used by program.
template<typename InputIter, typename OutputIter>
static OutputIter namedBindingsToProgramLocations (const glw::Functions& gl, deUint32 program, InputIter first, InputIter end, OutputIter out)
{
	for (InputIter cur = first; cur != end; ++cur)
	{
		const BindingPoint& binding = cur->binding;
		if (binding.type == BindingPoint::TYPE_NAME)
		{
			DE_ASSERT(binding.location >= 0);
			int location = gl.getAttribLocation(program, binding.name.c_str());
			if (location >= 0)
			{
				// Add binding.location as an offset to accommodate matrices.
				*out = VertexArrayBinding(BindingPoint(location + binding.location), cur->pointer);
				++out;
			}
		}
		else
		{
			*out = *cur;
			++out;
		}
	}

	return out;
}

static deUint32 getMinimumAlignment (const VertexArrayPointer& pointer)
{
	// \todo [2013-05-07 pyry] What is the actual min?
	DE_UNREF(pointer);
	return (deUint32)sizeof(float);
}

template<typename BindingIter>
static bool areVertexArrayLocationsValid (BindingIter first, BindingIter end)
{
	std::set<int> usedLocations;
	for (BindingIter cur = first; cur != end; ++cur)
	{
		const BindingPoint& binding = cur->binding;

		if (binding.type != BindingPoint::TYPE_LOCATION)
			return false;

		if (usedLocations.find(binding.location) != usedLocations.end())
			return false;

		usedLocations.insert(binding.location);
	}

	return true;
}

// \todo [2013-05-08 pyry] Buffer upload should try to match pointers to reduce dataset size.

static void appendAttributeNonStrided (VertexBufferLayout& layout, const VertexArrayBinding& va)
{
	const int	offset		= deAlign32(layout.size, getMinimumAlignment(va.pointer));
	const int	elementSize	= getVtxCompSize(va.pointer.componentType)*va.pointer.numComponents;
	const int	size		= elementSize*va.pointer.numElements;

	// Must be assigned to location at this point.
	DE_ASSERT(va.binding.type == BindingPoint::TYPE_LOCATION);

	layout.attributes.push_back(VertexAttributeDescriptor(va.binding.location,
														  va.pointer.componentType,
														  va.pointer.convert,
														  va.pointer.numComponents,
														  va.pointer.numElements,
														  0, // default stride
														  (const void*)(deUintptr)offset));
	layout.size = offset+size;
}

template<typename BindingIter>
static void computeNonStridedBufferLayout (VertexBufferLayout& layout, BindingIter first, BindingIter end)
{
	for (BindingIter iter = first; iter != end; ++iter)
		appendAttributeNonStrided(layout, *iter);
}

static void copyToLayout (void* dstBasePtr, const VertexAttributeDescriptor& dstVA, const VertexArrayPointer& srcPtr)
{
	DE_ASSERT(dstVA.componentType	== srcPtr.componentType &&
			  dstVA.numComponents	== srcPtr.numComponents &&
			  dstVA.numElements		== srcPtr.numElements);

	const int	elementSize			= getVtxCompSize(dstVA.componentType)*dstVA.numComponents;
	const bool	srcHasCustomStride	= srcPtr.stride != 0 && srcPtr.stride != elementSize;
	const bool	dstHasCustomStride	= dstVA.stride != 0 && dstVA.stride != elementSize;

	if (srcHasCustomStride || dstHasCustomStride)
	{
		const int	dstStride	= dstVA.stride != 0 ? dstVA.stride : elementSize;
		const int	srcStride	= srcPtr.stride != 0 ? srcPtr.stride : elementSize;

		for (int ndx = 0; ndx < dstVA.numElements; ndx++)
			deMemcpy((deUint8*)dstBasePtr + (deUintptr)dstVA.pointer + ndx*dstStride, (const deUint8*)srcPtr.data + ndx*srcStride, elementSize);
	}
	else
		deMemcpy((deUint8*)dstBasePtr + (deUintptr)dstVA.pointer, srcPtr.data, elementSize*dstVA.numElements);
}

void uploadBufferData (const glw::Functions& gl, deUint32 buffer, deUint32 usage, const VertexBufferLayout& layout, const VertexArrayPointer* srcArrays)
{
	// Create temporary data buffer for upload.
	std::vector<deUint8> localBuf(layout.size);

	for (int attrNdx = 0; attrNdx < (int)layout.attributes.size(); ++attrNdx)
		copyToLayout(&localBuf[0], layout.attributes[attrNdx], srcArrays[attrNdx]);

	gl.bindBuffer(GL_ARRAY_BUFFER, buffer);
	gl.bufferData(GL_ARRAY_BUFFER, (int)localBuf.size(), &localBuf[0], usage);
	gl.bindBuffer(GL_ARRAY_BUFFER, 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Uploading buffer data failed");
}

// VertexBuffer

VertexBuffer::VertexBuffer (const RenderContext& context, int numBindings, const VertexArrayBinding* bindings, Type type)
	: Buffer(context)
{
	const glw::Functions&	gl		= context.getFunctions();
	const deUint32			usage	= GL_STATIC_DRAW;
	VertexBufferLayout		layout;

	if (!areVertexArrayLocationsValid(bindings, bindings+numBindings))
		throw tcu::TestError("Invalid vertex array locations");

	if (type == TYPE_PLANAR)
		computeNonStridedBufferLayout(layout, bindings, bindings+numBindings);
	else
		throw tcu::InternalError("Strided layout is not yet supported");

	std::vector<VertexArrayPointer> srcPtrs(numBindings);
	for (int ndx = 0; ndx < numBindings; ndx++)
		srcPtrs[ndx] = bindings[ndx].pointer;

	DE_ASSERT(srcPtrs.size() == layout.attributes.size());
	if (!srcPtrs.empty())
		uploadBufferData(gl, m_object, usage, layout, &srcPtrs[0]);

	// Construct descriptor.
	m_layout.buffer		= m_object;
	m_layout.attributes	= layout.attributes;
}

VertexBuffer::~VertexBuffer (void)
{
}

// IndexBuffer

IndexBuffer::IndexBuffer (const RenderContext& context, IndexType indexType, int numIndices, const void* indices)
	: Buffer(context)
{
	const glw::Functions&	gl		= context.getFunctions();
	const deUint32			usage	= GL_STATIC_DRAW;

	gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_object);
	gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, numIndices*getIndexSize(indexType), indices, usage);
	gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Uploading index data failed");
}

IndexBuffer::~IndexBuffer (void)
{
}

static inline VertexAttributeDescriptor getUserPointerDescriptor (const VertexArrayBinding& vertexArray)
{
	DE_ASSERT(vertexArray.binding.type == BindingPoint::TYPE_LOCATION);

	return VertexAttributeDescriptor(vertexArray.binding.location,
									 vertexArray.pointer.componentType,
									 vertexArray.pointer.convert,
									 vertexArray.pointer.numComponents,
									 vertexArray.pointer.numElements,
									 vertexArray.pointer.stride,
									 vertexArray.pointer.data);
}

//! Setup VA according to allocation spec. Assumes that other state (VAO binding, buffer) is set already.
static void setVertexAttribPointer (const glw::Functions& gl, const VertexAttributeDescriptor& va)
{
	const bool		isIntType		= de::inRange<int>(va.componentType, VTX_COMP_UNSIGNED_INT8, VTX_COMP_SIGNED_INT32);
	const bool		isSpecialType	= de::inRange<int>(va.componentType, VTX_COMP_FIXED, VTX_COMP_FLOAT);
	const deUint32	compTypeGL		= getVtxCompGLType(va.componentType);

	DE_ASSERT(isIntType != isSpecialType); // Must be either int or special type.
	DE_ASSERT(isIntType || va.convert == VTX_COMP_CONVERT_NONE); // Conversion allowed only for special types.
	DE_UNREF(isSpecialType);

	gl.enableVertexAttribArray(va.location);

	if (isIntType && va.convert == VTX_COMP_CONVERT_NONE)
		gl.vertexAttribIPointer(va.location, va.numComponents, compTypeGL, va.stride, va.pointer);
	else
		gl.vertexAttribPointer(va.location, va.numComponents, compTypeGL, va.convert == VTX_COMP_CONVERT_NORMALIZE_TO_FLOAT ? GL_TRUE : GL_FALSE, va.stride, va.pointer);
}

//! Setup vertex buffer and attributes.
static void setVertexBufferAttributes (const glw::Functions& gl, const VertexBufferDescriptor& buffer)
{
	gl.bindBuffer(GL_ARRAY_BUFFER, buffer.buffer);

	for (std::vector<VertexAttributeDescriptor>::const_iterator vaIter = buffer.attributes.begin(); vaIter != buffer.attributes.end(); ++vaIter)
		setVertexAttribPointer(gl, *vaIter);

	gl.bindBuffer(GL_ARRAY_BUFFER, 0);
}

static void disableVertexArrays (const glw::Functions& gl, const std::vector<VertexArrayBinding>& bindings)
{
	for (std::vector<VertexArrayBinding>::const_iterator vaIter = bindings.begin(); vaIter != bindings.end(); ++vaIter)
	{
		DE_ASSERT(vaIter->binding.type == BindingPoint::TYPE_LOCATION);
		gl.disableVertexAttribArray(vaIter->binding.location);
	}
}

#if defined(DE_DEBUG)
static bool isProgramActive (const RenderContext& context, deUint32 program)
{
	// \todo [2013-05-08 pyry] Is this query broken?
/*	deUint32 activeProgram = 0;
	context.getFunctions().getIntegerv(GL_ACTIVE_PROGRAM, (int*)&activeProgram);
	GLU_EXPECT_NO_ERROR(context.getFunctions().getError(), "oh");
	return activeProgram == program;*/
	DE_UNREF(context);
	DE_UNREF(program);
	return true;
}

static bool isDrawCallValid (int numVertexArrays, const VertexArrayBinding* vertexArrays, const PrimitiveList& primitives)
{
	if (numVertexArrays < 0)
		return false;

	if ((primitives.indexType == INDEXTYPE_LAST) != (primitives.indices == 0))
		return false;

	if (primitives.numElements < 0)
		return false;

	if (!primitives.indices)
	{
		for (int ndx = 0; ndx < numVertexArrays; ndx++)
		{
			if (primitives.numElements > vertexArrays[ndx].pointer.numElements)
				return false;
		}
	}
	// \todo [2013-05-08 pyry] We could walk whole index array and determine index range

	return true;
}
#endif // DE_DEBUG

static inline void drawNonIndexed (const glw::Functions& gl, PrimitiveType type, int numElements)
{
	deUint32 mode = getPrimitiveGLType(type);
	gl.drawArrays(mode, 0, numElements);
}

static inline void drawIndexed (const glw::Functions& gl, PrimitiveType type, int numElements, IndexType indexType, const void* indexPtr)
{
	deUint32	mode		= getPrimitiveGLType(type);
	deUint32	indexGLType	= getIndexGLType(indexType);

	gl.drawElements(mode, numElements, indexGLType, indexPtr);
}

} // anonymous

void drawFromUserPointers (const RenderContext& context, deUint32 program, int numVertexArrays, const VertexArrayBinding* vertexArrays, const PrimitiveList& primitives, DrawUtilCallback* callback)
{
	const glw::Functions&				gl		= context.getFunctions();
	std::vector<VertexArrayBinding>		bindingsWithLocations;

	DE_ASSERT(isDrawCallValid(numVertexArrays, vertexArrays, primitives));
	DE_ASSERT(isProgramActive(context, program));

	// Lower bindings to locations.
	namedBindingsToProgramLocations(gl, program, vertexArrays, vertexArrays+numVertexArrays, std::inserter(bindingsWithLocations, bindingsWithLocations.begin()));

	TCU_CHECK(areVertexArrayLocationsValid(bindingsWithLocations.begin(), bindingsWithLocations.end()));

	// Set VA state.
	for (std::vector<VertexArrayBinding>::const_iterator vaIter = bindingsWithLocations.begin(); vaIter != bindingsWithLocations.end(); ++vaIter)
		setVertexAttribPointer(gl, getUserPointerDescriptor(*vaIter));

	if (callback)
		callback->beforeDrawCall();

	if (primitives.indices)
		drawIndexed(gl, primitives.type, primitives.numElements, primitives.indexType, primitives.indices);
	else
		drawNonIndexed(gl, primitives.type, primitives.numElements);

	if (callback)
		callback->afterDrawCall();

	// Disable attribute arrays or otherwise someone later on might get crash thanks to invalid pointers.
	disableVertexArrays(gl, bindingsWithLocations);
}

void drawFromBuffers (const RenderContext& context, deUint32 program, int numVertexArrays, const VertexArrayBinding* vertexArrays, const PrimitiveList& primitives, DrawUtilCallback* callback)
{
	const glw::Functions&				gl		= context.getFunctions();
	std::vector<VertexArrayBinding>		bindingsWithLocations;

	DE_ASSERT(isDrawCallValid(numVertexArrays, vertexArrays, primitives));
	DE_ASSERT(isProgramActive(context, program));

	// Lower bindings to locations.
	namedBindingsToProgramLocations(gl, program, vertexArrays, vertexArrays+numVertexArrays, std::inserter(bindingsWithLocations, bindingsWithLocations.begin()));

	TCU_CHECK(areVertexArrayLocationsValid(bindingsWithLocations.begin(), bindingsWithLocations.end()));

	// Create buffers for duration of draw call.
	{
		VertexBuffer vertexBuffer (context, (int)bindingsWithLocations.size(), (bindingsWithLocations.empty()) ? (DE_NULL) : (&bindingsWithLocations[0]));

		// Set state.
		setVertexBufferAttributes(gl, vertexBuffer.getDescriptor());

		if (primitives.indices)
		{
			IndexBuffer indexBuffer(context, primitives.indexType, primitives.numElements, primitives.indices);

			gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, *indexBuffer);

			if (callback)
				callback->beforeDrawCall();

			drawIndexed(gl, primitives.type, primitives.numElements, primitives.indexType, 0);

			if (callback)
				callback->afterDrawCall();

			gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
		}
		else
		{
			if (callback)
				callback->beforeDrawCall();

			drawNonIndexed(gl, primitives.type, primitives.numElements);

			if (callback)
				callback->afterDrawCall();
		}
	}

	// Disable attribute arrays or otherwise someone later on might get crash thanks to invalid pointers.
	for (std::vector<VertexArrayBinding>::const_iterator vaIter = bindingsWithLocations.begin(); vaIter != bindingsWithLocations.end(); ++vaIter)
		gl.disableVertexAttribArray(vaIter->binding.location);
}

void drawFromVAOBuffers (const RenderContext& context, deUint32 program, int numVertexArrays, const VertexArrayBinding* vertexArrays, const PrimitiveList& primitives, DrawUtilCallback* callback)
{
	const glw::Functions&	gl		= context.getFunctions();
	VertexArray				vao		(context);

	gl.bindVertexArray(*vao);
	drawFromBuffers(context, program, numVertexArrays, vertexArrays, primitives, callback);
	gl.bindVertexArray(0);
}

void draw (const RenderContext& context, deUint32 program, int numVertexArrays, const VertexArrayBinding* vertexArrays, const PrimitiveList& primitives, DrawUtilCallback* callback)
{
	const glu::ContextType ctxType = context.getType();

	if (isContextTypeGLCore(ctxType) || contextSupports(ctxType, ApiType::es(3,1)))
		drawFromVAOBuffers(context, program, numVertexArrays, vertexArrays, primitives, callback);
	else
	{
		DE_ASSERT(isContextTypeES(ctxType));
		drawFromUserPointers(context, program, numVertexArrays, vertexArrays, primitives, callback);
	}
}

} // glu