modules/glshared/glsTextureBufferCase.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL (ES) Module
 * -----------------------------------------------
 *
 * 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 Texture buffer test case
 *//*--------------------------------------------------------------------*/

#include "glsTextureBufferCase.hpp"

#include "tcuFormatUtil.hpp"
#include "tcuImageCompare.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuStringTemplate.hpp"
#include "tcuSurface.hpp"
#include "tcuTestLog.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuResultCollector.hpp"

#include "rrRenderer.hpp"
#include "rrShaders.hpp"

#include "gluObjectWrapper.hpp"
#include "gluPixelTransfer.hpp"
#include "gluShaderProgram.hpp"
#include "gluShaderUtil.hpp"
#include "gluStrUtil.hpp"
#include "gluTexture.hpp"
#include "gluTextureUtil.hpp"

#include "glwEnums.hpp"
#include "glwFunctions.hpp"

#include "deRandom.hpp"
#include "deStringUtil.hpp"
#include "deUniquePtr.hpp"

#include "deMemory.h"
#include "deString.h"
#include "deMath.h"

#include <sstream>
#include <string>
#include <vector>

using tcu::TestLog;

using std::map;
using std::string;
using std::vector;

using namespace deqp::gls::TextureBufferCaseUtil;

namespace deqp
{
namespace gls
{
namespace
{

enum
{
	MAX_VIEWPORT_WIDTH	= 256,
	MAX_VIEWPORT_HEIGHT	= 256,
	MIN_VIEWPORT_WIDTH	= 64,
	MIN_VIEWPORT_HEIGHT	= 64,
};

deUint8 extend2BitsToByte (deUint8 bits)
{
	DE_ASSERT((bits & (~0x03u)) == 0);

	return (deUint8)(bits | (bits << 2) | (bits << 4) | (bits << 6));
}

void genRandomCoords (de::Random rng, vector<deUint8>& coords, size_t offset, size_t size)
{
	const deUint8 bits		= 2;
	const deUint8 bitMask	= deUint8((0x1u << bits) - 1);

	coords.resize(size);

	for (int i = 0; i < (int)size; i++)
	{
		const deUint8 xBits = deUint8(rng.getUint32() & bitMask);
		coords[i] = extend2BitsToByte(xBits);
	}

	// Fill indices with nice quad
	{
		const deUint8 indices[] =
		{
			extend2BitsToByte(0x0u),
			extend2BitsToByte(0x1u),
			extend2BitsToByte(0x2u),
			extend2BitsToByte(0x3u)
		};

		for (int i = 0; i < DE_LENGTH_OF_ARRAY(indices); i++)
		{
			const deUint8	index	= indices[i];
			const size_t	posX	= (size_t(index) * 2) + 0;
			const size_t	posY	= (size_t(index) * 2) + 1;

			if (posX >= offset && posX < offset+size)
				coords[posX - offset] = ((i % 2) == 0 ? extend2BitsToByte(0x0u) : extend2BitsToByte(0x3u));

			if (posY >= offset && posY < offset+size)
				coords[posY - offset] = ((i / 2) == 1 ? extend2BitsToByte(0x3u) : extend2BitsToByte(0x0u));
		}
	}

	// Fill beginning of buffer
	{
		const deUint8 indices[] =
		{
			extend2BitsToByte(0x0u),
			extend2BitsToByte(0x3u),
			extend2BitsToByte(0x1u),

			extend2BitsToByte(0x1u),
			extend2BitsToByte(0x2u),
			extend2BitsToByte(0x0u),

			extend2BitsToByte(0x0u),
			extend2BitsToByte(0x2u),
			extend2BitsToByte(0x1u),

			extend2BitsToByte(0x1u),
			extend2BitsToByte(0x3u),
			extend2BitsToByte(0x0u)
		};

		for (int i = (int)offset; i < DE_LENGTH_OF_ARRAY(indices) && i < (int)(offset + size); i++)
			coords[i-offset] = indices[i];
	}
}

class CoordVertexShader : public rr::VertexShader
{
public:
	CoordVertexShader (void)
		: rr::VertexShader(1, 1)
	{
		m_inputs[0].type	= rr::GENERICVECTYPE_FLOAT;
		m_outputs[0].type	= rr::GENERICVECTYPE_FLOAT;
	}

	void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
	{
		for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
		{
			rr::VertexPacket* const		packet		= packets[packetNdx];
			tcu::Vec4					position;

			readVertexAttrib(position, inputs[0], packet->instanceNdx, packet->vertexNdx);

			packet->outputs[0]	= tcu::Vec4(1.0f);
			packet->position	= tcu::Vec4(2.0f * (position.x() - 0.5f), 2.0f * (position.y() - 0.5f), 0.0f, 1.0f);
		}
	}
};

class TextureVertexShader : public rr::VertexShader
{
public:
	TextureVertexShader (const tcu::ConstPixelBufferAccess& texture)
		: rr::VertexShader	(1, 1)
		, m_texture			(texture)
	{
		m_inputs[0].type	= rr::GENERICVECTYPE_FLOAT;
		m_outputs[0].type	= rr::GENERICVECTYPE_FLOAT;
	}

	void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
	{
		for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
		{
			rr::VertexPacket* const		packet		= packets[packetNdx];
			tcu::Vec4					position;
			tcu::Vec4					texelValue;

			readVertexAttrib(position, inputs[0], packet->instanceNdx, packet->vertexNdx);

			texelValue	= tcu::Vec4(m_texture.getPixel(de::clamp<int>((deRoundFloatToInt32(position.x() * 4) + 4) * (deRoundFloatToInt32(position.y() * 4) + 4), 0, m_texture.getWidth()-1), 0));

			packet->outputs[0]	= texelValue;
			packet->position	= tcu::Vec4(2.0f * (position.x() - 0.5f), 2.0f * (position.y() - 0.5f), 0.0f, 1.0f);
		}
	}

private:
	const tcu::ConstPixelBufferAccess m_texture;
};

class CoordFragmentShader : public rr::FragmentShader
{
public:
	CoordFragmentShader (void)
		: rr::FragmentShader (1, 1)
	{
		m_inputs[0].type	= rr::GENERICVECTYPE_FLOAT;
		m_outputs[0].type	= rr::GENERICVECTYPE_FLOAT;
	}


	void shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
	{
		for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
		{
			rr::FragmentPacket&	packet		= packets[packetNdx];

			const tcu::Vec4		vtxColor0	= rr::readVarying<float>(packet, context, 0, 0);
			const tcu::Vec4		vtxColor1	= rr::readVarying<float>(packet, context, 0, 1);
			const tcu::Vec4		vtxColor2	= rr::readVarying<float>(packet, context, 0, 2);
			const tcu::Vec4		vtxColor3	= rr::readVarying<float>(packet, context, 0, 3);

			const tcu::Vec4		color0		= vtxColor0;
			const tcu::Vec4		color1		= vtxColor1;
			const tcu::Vec4		color2		= vtxColor2;
			const tcu::Vec4		color3		= vtxColor3;

			rr::writeFragmentOutput(context, packetNdx, 0, 0, tcu::Vec4(color0.x() * color0.w(), color0.y() * color0.w(), color0.z() * color0.w(), 1.0f));
			rr::writeFragmentOutput(context, packetNdx, 1, 0, tcu::Vec4(color1.x() * color1.w(), color1.y() * color1.w(), color1.z() * color1.w(), 1.0f));
			rr::writeFragmentOutput(context, packetNdx, 2, 0, tcu::Vec4(color2.x() * color2.w(), color2.y() * color2.w(), color2.z() * color2.w(), 1.0f));
			rr::writeFragmentOutput(context, packetNdx, 3, 0, tcu::Vec4(color3.x() * color3.w(), color3.y() * color3.w(), color3.z() * color3.w(), 1.0f));
		}
	}
};

class TextureFragmentShader : public rr::FragmentShader
{
public:
	TextureFragmentShader (const tcu::ConstPixelBufferAccess& texture)
		: rr::FragmentShader	(1, 1)
		, m_texture				(texture)
	{
		m_inputs[0].type	= rr::GENERICVECTYPE_FLOAT;
		m_outputs[0].type	= rr::GENERICVECTYPE_FLOAT;
	}

	void shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
	{
		for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
		{
			rr::FragmentPacket&	packet		= packets[packetNdx];

			const tcu::IVec2	position0	= packet.position + tcu::IVec2(0, 0);
			const tcu::IVec2	position1	= packet.position + tcu::IVec2(1, 0);
			const tcu::IVec2	position2	= packet.position + tcu::IVec2(0, 1);
			const tcu::IVec2	position3	= packet.position + tcu::IVec2(1, 1);

			const tcu::Vec4		texColor0	= m_texture.getPixel(de::clamp((position0.x() * position0.y()), 0, m_texture.getWidth()-1), 0);
			const tcu::Vec4		texColor1	= m_texture.getPixel(de::clamp((position1.x() * position1.y()), 0, m_texture.getWidth()-1), 0);
			const tcu::Vec4		texColor2	= m_texture.getPixel(de::clamp((position2.x() * position2.y()), 0, m_texture.getWidth()-1), 0);
			const tcu::Vec4		texColor3	= m_texture.getPixel(de::clamp((position3.x() * position3.y()), 0, m_texture.getWidth()-1), 0);

			const tcu::Vec4		vtxColor0	= rr::readVarying<float>(packet, context, 0, 0);
			const tcu::Vec4		vtxColor1	= rr::readVarying<float>(packet, context, 0, 1);
			const tcu::Vec4		vtxColor2	= rr::readVarying<float>(packet, context, 0, 2);
			const tcu::Vec4		vtxColor3	= rr::readVarying<float>(packet, context, 0, 3);

			const tcu::Vec4		color0		= 0.5f * (vtxColor0 + texColor0);
			const tcu::Vec4		color1		= 0.5f * (vtxColor1 + texColor1);
			const tcu::Vec4		color2		= 0.5f * (vtxColor2 + texColor2);
			const tcu::Vec4		color3		= 0.5f * (vtxColor3 + texColor3);

			rr::writeFragmentOutput(context, packetNdx, 0, 0, tcu::Vec4(color0.x() * color0.w(), color0.y() * color0.w(), color0.z() * color0.w(), 1.0f));
			rr::writeFragmentOutput(context, packetNdx, 1, 0, tcu::Vec4(color1.x() * color1.w(), color1.y() * color1.w(), color1.z() * color1.w(), 1.0f));
			rr::writeFragmentOutput(context, packetNdx, 2, 0, tcu::Vec4(color2.x() * color2.w(), color2.y() * color2.w(), color2.z() * color2.w(), 1.0f));
			rr::writeFragmentOutput(context, packetNdx, 3, 0, tcu::Vec4(color3.x() * color3.w(), color3.y() * color3.w(), color3.z() * color3.w(), 1.0f));
		}
	}

private:
	const tcu::ConstPixelBufferAccess m_texture;
};

string generateVertexShaderTemplate (RenderBits renderBits)
{
	std::ostringstream stream;

	stream <<
		"${VERSION_HEADER}\n";

	if (renderBits & RENDERBITS_AS_VERTEX_TEXTURE)
		stream << "${TEXTURE_BUFFER_EXT}";

	stream <<
		"${VTX_INPUT} layout(location = 0) ${HIGHP} vec2 i_coord;\n"
		"${VTX_OUTPUT} ${HIGHP} vec4 v_color;\n";

	if (renderBits & RENDERBITS_AS_VERTEX_TEXTURE)
	{
		stream <<
			"uniform ${HIGHP} samplerBuffer u_vtxSampler;\n";
	}

	stream <<
		"\n"
		"void main (void)\n"
		"{\n";

	if (renderBits & RENDERBITS_AS_VERTEX_TEXTURE)
		stream << "\tv_color = texelFetch(u_vtxSampler, clamp((int(round(i_coord.x * 4.0)) + 4) * (int(round(i_coord.y * 4.0)) + 4), 0, textureSize(u_vtxSampler)-1));\n";
	else
		stream << "\tv_color = vec4(1.0);\n";

	stream <<
		"\tgl_Position = vec4(2.0 * (i_coord - vec2(0.5)), 0.0, 1.0);\n"
		"}\n";

	return stream.str();
}

string generateFragmentShaderTemplate (RenderBits renderBits)
{
	std::ostringstream stream;

	stream <<
		"${VERSION_HEADER}\n";

	if (renderBits & RENDERBITS_AS_FRAGMENT_TEXTURE)
		stream << "${TEXTURE_BUFFER_EXT}";

	stream <<
		"${FRAG_OUTPUT} layout(location = 0) ${HIGHP} vec4 dEQP_FragColor;\n"
		"${FRAG_INPUT} ${HIGHP} vec4 v_color;\n";

	if (renderBits & RENDERBITS_AS_FRAGMENT_TEXTURE)
		stream << "uniform ${HIGHP} samplerBuffer u_fragSampler;\n";

	stream <<
		"\n"
		"void main (void)\n"
		"{\n";

	if (renderBits & RENDERBITS_AS_FRAGMENT_TEXTURE)
		stream << "\t${HIGHP} vec4 color = 0.5 * (v_color + texelFetch(u_fragSampler, clamp(int(gl_FragCoord.x) * int(gl_FragCoord.y), 0, textureSize(u_fragSampler)-1)));\n";
	else
		stream << "\t${HIGHP} vec4 color = v_color;\n";

	stream <<
		"\tdEQP_FragColor = vec4(color.xyz * color.w, 1.0);\n"
		"}\n";

	return stream.str();
}

string specializeShader (const string& shaderTemplateString, glu::GLSLVersion glslVersion)
{
	const tcu::StringTemplate	shaderTemplate(shaderTemplateString);
	map<string, string>			parameters;

	parameters["VERSION_HEADER"]		= glu::getGLSLVersionDeclaration(glslVersion);
	parameters["VTX_OUTPUT"]			= "out";
	parameters["VTX_INPUT"]				= "in";
	parameters["FRAG_INPUT"]			= "in";
	parameters["FRAG_OUTPUT"]			= "out";
	parameters["HIGHP"]					= (glslVersion == glu::GLSL_VERSION_330 ? "" : "highp");
	parameters["TEXTURE_BUFFER_EXT"]	= (glslVersion == glu::GLSL_VERSION_330 ? "" : "#extension GL_EXT_texture_buffer : enable\n");

	return shaderTemplate.specialize(parameters);
}

glu::ShaderProgram* createRenderProgram (glu::RenderContext&	renderContext,
										 RenderBits				renderBits)
{
	const string				vertexShaderTemplate	= generateVertexShaderTemplate(renderBits);
	const string				fragmentShaderTemplate	= generateFragmentShaderTemplate(renderBits);

	const glu::GLSLVersion		glslVersion				= glu::getContextTypeGLSLVersion(renderContext.getType());

	const string				vertexShaderSource		= specializeShader(vertexShaderTemplate, glslVersion);
	const string				fragmentShaderSource	= specializeShader(fragmentShaderTemplate, glslVersion);

	glu::ShaderProgram* const	program					= new glu::ShaderProgram(renderContext, glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));

	return program;
}

void logModifications (TestLog& log, ModifyBits modifyBits)
{
	tcu::ScopedLogSection section(log, "Modify Operations", "Modify Operations");

	const struct
	{
		ModifyBits	bit;
		const char*	str;
	} bitInfos[] =
	{
		{ MODIFYBITS_BUFFERDATA,			"Recreate buffer data with glBufferData()."			},
		{ MODIFYBITS_BUFFERSUBDATA,			"Modify texture buffer with glBufferSubData()."		},
		{ MODIFYBITS_MAPBUFFER_WRITE,		"Map buffer write-only and rewrite data."			},
		{ MODIFYBITS_MAPBUFFER_READWRITE,	"Map buffer readw-write check and rewrite data."	}
	};

	DE_ASSERT(modifyBits != 0);

	for (int infoNdx = 0; infoNdx < DE_LENGTH_OF_ARRAY(bitInfos); infoNdx++)
	{
		if (modifyBits & bitInfos[infoNdx].bit)
			log << TestLog::Message << bitInfos[infoNdx].str << TestLog::EndMessage;
	}
}

void modifyBufferData (TestLog&				log,
					   de::Random&			rng,
					   glu::TextureBuffer&	texture)
{
	vector<deUint8> data;

	genRandomCoords(rng, data, 0, texture.getBufferSize());

	log << TestLog::Message << "BufferData, Size: " << data.size() << TestLog::EndMessage;

	{
		// replace getRefBuffer with a new buffer
		de::ArrayBuffer<deUint8> buffer(&(data[0]), data.size());
		texture.getRefBuffer().swap(buffer);
	}

	texture.upload();
}

void modifyBufferSubData (TestLog&				log,
						  de::Random&			rng,
						  const glw::Functions&	gl,
						  glu::TextureBuffer&	texture)
{
	const size_t				minSize		= 4*16;
	const size_t				size		= de::max<size_t>(minSize, size_t((float)(texture.getSize() != 0 ? texture.getSize() : texture.getBufferSize()) * (0.7f + 0.3f * rng.getFloat())));
	const size_t				minOffset	= texture.getOffset();
	const size_t				offset		= minOffset + (rng.getUint32() % (texture.getBufferSize() - (size + minOffset)));
	vector<deUint8>				data;

	genRandomCoords(rng, data, offset, size);

	log << TestLog::Message << "BufferSubData, Offset: " << offset << ", Size: " << size << TestLog::EndMessage;

	gl.bindBuffer(GL_TEXTURE_BUFFER, texture.getGLBuffer());
	gl.bufferSubData(GL_TEXTURE_BUFFER, (glw::GLsizei)offset, (glw::GLsizei)data.size(), &(data[0]));
	gl.bindBuffer(GL_TEXTURE_BUFFER, 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to update data with glBufferSubData()");

	deMemcpy((deUint8*)texture.getRefBuffer().getPtr() + offset, &(data[0]), int(data.size()));
}

void modifyMapWrite (TestLog&				log,
					 de::Random&			rng,
					 const glw::Functions&	gl,
					 glu::TextureBuffer&	texture)
{
	const size_t				minSize		= 4*16;
	const size_t				size		= de::max<size_t>(minSize, size_t((float)(texture.getSize() != 0 ? texture.getSize() : texture.getBufferSize()) * (0.7f + 0.3f * rng.getFloat())));
	const size_t				minOffset	= texture.getOffset();
	const size_t				offset		= minOffset + (rng.getUint32() % (texture.getBufferSize() - (size + minOffset)));
	vector<deUint8>				data;

	genRandomCoords(rng, data, offset, size);

	log << TestLog::Message << "glMapBufferRange, Write Only, Offset: " << offset << ", Size: " << size << TestLog::EndMessage;

	gl.bindBuffer(GL_TEXTURE_BUFFER, texture.getGLBuffer());
	{
		deUint8* ptr = (deUint8*)gl.mapBufferRange(GL_TEXTURE_BUFFER, (glw::GLsizei)offset, (glw::GLsizei)size, GL_MAP_WRITE_BIT);

		GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange()");
		TCU_CHECK(ptr);

		for (int i = 0; i < (int)data.size(); i++)
			ptr[i] = data[i];

		TCU_CHECK(gl.unmapBuffer(GL_TEXTURE_BUFFER));
	}
	gl.bindBuffer(GL_TEXTURE_BUFFER, 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to update data with glMapBufferRange()");

	deMemcpy((deUint8*)texture.getRefBuffer().getPtr()+offset, &(data[0]), int(data.size()));
}

void modifyMapReadWrite (TestLog&				log,
						 tcu::ResultCollector&	resultCollector,
						 de::Random&			rng,
						 const glw::Functions&	gl,
						 glu::TextureBuffer&	texture)
{
	const size_t				minSize		= 4*16;
	const size_t				size		= de::max<size_t>(minSize, size_t((float)(texture.getSize() != 0 ? texture.getSize() : texture.getBufferSize()) * (0.7f + 0.3f * rng.getFloat())));
	const size_t				minOffset	= texture.getOffset();
	const size_t				offset		= minOffset + (rng.getUint32() % (texture.getBufferSize() - (size + minOffset)));
	deUint8* const				refPtr		= (deUint8*)texture.getRefBuffer().getPtr() + offset;
	vector<deUint8>				data;

	genRandomCoords(rng, data, offset, size);

	log << TestLog::Message << "glMapBufferRange, Read Write, Offset: " << offset << ", Size: " << size << TestLog::EndMessage;

	gl.bindBuffer(GL_TEXTURE_BUFFER, texture.getGLBuffer());
	{
		size_t			invalidBytes	= 0;
		deUint8* const	ptr				= (deUint8*)gl.mapBufferRange(GL_TEXTURE_BUFFER, (glw::GLsizei)offset, (glw::GLsizei)size, GL_MAP_WRITE_BIT|GL_MAP_READ_BIT);

		GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange()");
		TCU_CHECK(ptr);

		for (int i = 0; i < (int)data.size(); i++)
		{
			if (ptr[i] != refPtr[i])
			{
				if (invalidBytes < 24)
					log << TestLog::Message << "Invalid byte in mapped buffer. " << tcu::Format::Hex<2>(data[i]).toString() << " at " << i << ", expected " << tcu::Format::Hex<2>(refPtr[i]).toString() << TestLog::EndMessage;

				invalidBytes++;
			}

			ptr[i] = data[i];
		}

		TCU_CHECK(gl.unmapBuffer(GL_TEXTURE_BUFFER));

		if (invalidBytes > 0)
		{
			log << TestLog::Message << "Total of " << invalidBytes << " invalid bytes." << TestLog::EndMessage;
			resultCollector.fail("Invalid data in mapped buffer");
		}
	}

	gl.bindBuffer(GL_TEXTURE_BUFFER, 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to update data with glMapBufferRange()");

	for (int i = 0; i < (int)data.size(); i++)
		refPtr[i] = data[i];
}

void modify (TestLog&						log,
			 tcu::ResultCollector&			resultCollector,
			 glu::RenderContext&			renderContext,
			 ModifyBits						modifyBits,
			 de::Random&					rng,
			 glu::TextureBuffer&			texture)
{
	const tcu::ScopedLogSection modifySection(log, "Modifying Texture buffer", "Modifying Texture Buffer");

	logModifications(log, modifyBits);

	if (modifyBits & MODIFYBITS_BUFFERDATA)
		modifyBufferData(log, rng, texture);

	if (modifyBits & MODIFYBITS_BUFFERSUBDATA)
		modifyBufferSubData(log, rng, renderContext.getFunctions(), texture);

	if (modifyBits & MODIFYBITS_MAPBUFFER_WRITE)
		modifyMapWrite(log, rng, renderContext.getFunctions(), texture);

	if (modifyBits & MODIFYBITS_MAPBUFFER_READWRITE)
		modifyMapReadWrite(log, resultCollector, rng, renderContext.getFunctions(), texture);
}

void renderGL (glu::RenderContext&		renderContext,
			   RenderBits				renderBits,
			   deUint32					coordSeed,
			   int						triangleCount,
			   glu::ShaderProgram&		program,
			   glu::TextureBuffer&		texture)
{
	const glw::Functions&	gl			= renderContext.getFunctions();
	const glu::VertexArray	vao			(renderContext);
	const glu::Buffer		coordBuffer	(renderContext);

	gl.useProgram(program.getProgram());
	gl.bindVertexArray(*vao);

	gl.enableVertexAttribArray(0);

	if (renderBits & RENDERBITS_AS_VERTEX_ARRAY)
	{
		gl.bindBuffer(GL_ARRAY_BUFFER, texture.getGLBuffer());
		gl.vertexAttribPointer(0, 2, GL_UNSIGNED_BYTE, true, 0, DE_NULL);
	}
	else
	{
		de::Random		rng(coordSeed);
		vector<deUint8> coords;

		genRandomCoords(rng, coords, 0, 256*2);

		gl.bindBuffer(GL_ARRAY_BUFFER, *coordBuffer);
		gl.bufferData(GL_ARRAY_BUFFER, (glw::GLsizei)coords.size(), &(coords[0]), GL_STREAM_DRAW);
		gl.vertexAttribPointer(0, 2, GL_UNSIGNED_BYTE, true, 0, DE_NULL);
	}

	if (renderBits & RENDERBITS_AS_VERTEX_TEXTURE)
	{
		const deInt32 location = gl.getUniformLocation(program.getProgram(), "u_vtxSampler");

		gl.activeTexture(GL_TEXTURE0);
		gl.bindTexture(GL_TEXTURE_BUFFER, texture.getGLTexture());
		gl.uniform1i(location, 0);
	}

	if (renderBits & RENDERBITS_AS_FRAGMENT_TEXTURE)
	{
		const deInt32 location = gl.getUniformLocation(program.getProgram(), "u_fragSampler");

		gl.activeTexture(GL_TEXTURE1);
		gl.bindTexture(GL_TEXTURE_BUFFER, texture.getGLTexture());
		gl.uniform1i(location, 1);
		gl.activeTexture(GL_TEXTURE0);
	}

	if (renderBits & RENDERBITS_AS_INDEX_ARRAY)
	{
		gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, texture.getGLBuffer());
		gl.drawElements(GL_TRIANGLES, triangleCount * 3, GL_UNSIGNED_BYTE, DE_NULL);
		gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
	}
	else
		gl.drawArrays(GL_TRIANGLES, 0, triangleCount * 3);

	if (renderBits & RENDERBITS_AS_FRAGMENT_TEXTURE)
	{
		gl.activeTexture(GL_TEXTURE1);
		gl.bindTexture(GL_TEXTURE_BUFFER, 0);
	}

	if (renderBits & RENDERBITS_AS_VERTEX_TEXTURE)
	{
		gl.activeTexture(GL_TEXTURE0);
		gl.bindTexture(GL_TEXTURE_BUFFER, 0);
	}

	gl.bindBuffer(GL_ARRAY_BUFFER, 0);
	gl.disableVertexAttribArray(0);

	gl.bindVertexArray(0);
	gl.useProgram(0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Rendering failed");
}

void renderReference (RenderBits					renderBits,
					  deUint32						coordSeed,
					  int							triangleCount,
					  const glu::TextureBuffer&		texture,
					  int							maxTextureBufferSize,
					  const tcu::PixelBufferAccess&	target)
{
	const tcu::ConstPixelBufferAccess	effectiveAccess			= glu::getTextureBufferEffectiveRefTexture(texture, maxTextureBufferSize);

	const CoordVertexShader				coordVertexShader;
	const TextureVertexShader			textureVertexShader		(effectiveAccess);
	const rr::VertexShader* const		vertexShader			= (renderBits & RENDERBITS_AS_VERTEX_TEXTURE ? static_cast<const rr::VertexShader*>(&textureVertexShader) : &coordVertexShader);

	const CoordFragmentShader			coordFragmmentShader;
	const TextureFragmentShader			textureFragmentShader	(effectiveAccess);
	const rr::FragmentShader* const		fragmentShader			= (renderBits & RENDERBITS_AS_FRAGMENT_TEXTURE ? static_cast<const rr::FragmentShader*>(&textureFragmentShader) : &coordFragmmentShader);

	const rr::Renderer					renderer;
	const rr::RenderState				renderState(rr::ViewportState(rr::WindowRectangle(0, 0, target.getWidth(), target.getHeight())));
	const rr::RenderTarget				renderTarget(rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(target));

	const rr::Program					program(vertexShader, fragmentShader);

	rr::VertexAttrib					vertexAttribs[1];
	vector<deUint8>						coords;

	if (renderBits & RENDERBITS_AS_VERTEX_ARRAY)
	{
		vertexAttribs[0].type			= rr::VERTEXATTRIBTYPE_NONPURE_UNORM8;
		vertexAttribs[0].size			= 2;
		vertexAttribs[0].pointer		= texture.getRefBuffer().getPtr();
	}
	else
	{
		de::Random rng(coordSeed);

		genRandomCoords(rng, coords, 0, 256*2);

		vertexAttribs[0].type			= rr::VERTEXATTRIBTYPE_NONPURE_UNORM8;
		vertexAttribs[0].size			= 2;
		vertexAttribs[0].pointer		= &(coords[0]);
	}

	if (renderBits & RENDERBITS_AS_INDEX_ARRAY)
	{
		const rr::PrimitiveList	primitives(rr::PRIMITIVETYPE_TRIANGLES, triangleCount * 3, rr::DrawIndices(texture.getRefBuffer().getPtr(), rr::INDEXTYPE_UINT8));
		const rr::DrawCommand	cmd(renderState, renderTarget, program, 1, vertexAttribs, primitives);

		renderer.draw(cmd);
	}
	else
	{
		const rr::PrimitiveList	primitives(rr::PRIMITIVETYPE_TRIANGLES, triangleCount * 3, 0);
		const rr::DrawCommand	cmd(renderState, renderTarget, program, 1, vertexAttribs, primitives);

		renderer.draw(cmd);
	}
}

void logRendering (TestLog& log, RenderBits renderBits)
{
	const struct
	{
		RenderBits	bit;
		const char*	str;
	} bitInfos[] =
	{
		{ RENDERBITS_AS_VERTEX_ARRAY,		"vertex array"		},
		{ RENDERBITS_AS_INDEX_ARRAY,		"index array"		},
		{ RENDERBITS_AS_VERTEX_TEXTURE,		"vertex texture"	},
		{ RENDERBITS_AS_FRAGMENT_TEXTURE,	"fragment texture"	}
	};

	std::ostringstream	stream;
	vector<const char*> usedAs;

	DE_ASSERT(renderBits != 0);

	for (int infoNdx = 0; infoNdx < DE_LENGTH_OF_ARRAY(bitInfos); infoNdx++)
	{
		if (renderBits & bitInfos[infoNdx].bit)
			usedAs.push_back(bitInfos[infoNdx].str);
	}

	stream << "Render using texture buffer as ";

	for (int asNdx = 0; asNdx < (int)usedAs.size(); asNdx++)
	{
		if (asNdx+1 == (int)usedAs.size() && (int)usedAs.size() > 1)
			stream << " and ";
		else if (asNdx > 0)
			stream << ", ";

		stream << usedAs[asNdx];
	}

	stream << ".";

	log << TestLog::Message << stream.str() << TestLog::EndMessage;
}

void render (TestLog&						log,
			 glu::RenderContext&			renderContext,
			 RenderBits						renderBits,
			 de::Random&					rng,
			 glu::ShaderProgram&			program,
			 glu::TextureBuffer&			texture,
			 const tcu::PixelBufferAccess&	target)
{
	const tcu::ScopedLogSection	renderSection			(log, "Render Texture buffer", "Render Texture Buffer");
	const int					triangleCount			= 8;
	const deUint32				coordSeed				= rng.getUint32();
	int							maxTextureBufferSize	= 0;

	renderContext.getFunctions().getIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE, &maxTextureBufferSize);
	GLU_EXPECT_NO_ERROR(renderContext.getFunctions().getError(), "query GL_MAX_TEXTURE_BUFFER_SIZE");
	DE_ASSERT(maxTextureBufferSize > 0); // checked in init()

	logRendering(log, renderBits);

	renderGL(renderContext, renderBits, coordSeed, triangleCount, program, texture);
	renderReference(renderBits, coordSeed, triangleCount, texture, maxTextureBufferSize, target);
}

void verifyScreen (TestLog&								log,
				   tcu::ResultCollector&				resultCollector,
				   glu::RenderContext&					renderContext,
				   const tcu::ConstPixelBufferAccess&	referenceTarget)
{
	const tcu::ScopedLogSection	verifySection	(log, "Verify screen contents", "Verify screen contents");
	tcu::Surface				screen			(referenceTarget.getWidth(), referenceTarget.getHeight());

	glu::readPixels(renderContext, 0, 0, screen.getAccess());

	if (!tcu::fuzzyCompare(log, "Result of rendering", "Result of rendering", referenceTarget, screen.getAccess(), 0.05f, tcu::COMPARE_LOG_RESULT))
		resultCollector.fail("Rendering failed");
}

void logImplementationInfo (TestLog& log, glu::RenderContext& renderContext)
{
	const tcu::ScopedLogSection		section	(log, "Implementation Values", "Implementation Values");
	de::UniquePtr<glu::ContextInfo>	info	(glu::ContextInfo::create(renderContext));
	const glw::Functions&			gl		= renderContext.getFunctions();

	if (glu::contextSupports(renderContext.getType(), glu::ApiType(3, 3, glu::PROFILE_CORE)))
	{
		deInt32 maxTextureSize = 0;

		gl.getIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE, &maxTextureSize);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE)");

		log << TestLog::Message << "GL_MAX_TEXTURE_BUFFER_SIZE : " <<  maxTextureSize << TestLog::EndMessage;
	}
	else if (glu::contextSupports(renderContext.getType(), glu::ApiType(3, 1, glu::PROFILE_ES)) && info->isExtensionSupported("GL_EXT_texture_buffer"))
	{
		{
			deInt32 maxTextureSize = 0;

			gl.getIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE, &maxTextureSize);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE_EXT)");

			log << TestLog::Message << "GL_MAX_TEXTURE_BUFFER_SIZE_EXT : " <<  maxTextureSize << TestLog::EndMessage;
		}

		{
			deInt32 textureBufferAlignment = 0;

			gl.getIntegerv(GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT, &textureBufferAlignment);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv(GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT)");

			log << TestLog::Message << "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT : " <<  textureBufferAlignment << TestLog::EndMessage;
		}
	}
	else
		DE_ASSERT(DE_FALSE);
}

void logTextureInfo (TestLog&	log,
					 deUint32	format,
					 size_t		bufferSize,
					 size_t		offset,
					 size_t		size)
{
	const tcu::ScopedLogSection	section(log, "Texture Info", "Texture Info");

	log << TestLog::Message << "Texture format : " << glu::getTextureFormatStr(format) << TestLog::EndMessage;
	log << TestLog::Message << "Buffer size : " << bufferSize << TestLog::EndMessage;

	if (offset != 0 || size != 0)
	{
		log << TestLog::Message << "Buffer range offset: " << offset << TestLog::EndMessage;
		log << TestLog::Message << "Buffer range size: " << size << TestLog::EndMessage;
	}
}

void runTests (tcu::TestContext&	testCtx,
			   glu::RenderContext&	renderContext,
			   de::Random&			rng,
			   deUint32				format,
			   size_t				bufferSize,
			   size_t				offset,
			   size_t				size,
			   RenderBits			preRender,
			   glu::ShaderProgram*	preRenderProgram,
			   ModifyBits			modifyType,
			   RenderBits			postRender,
			   glu::ShaderProgram*	postRenderProgram)
{
	const tcu::RenderTarget	renderTarget	(renderContext.getRenderTarget());
	const glw::Functions&	gl				= renderContext.getFunctions();

	const int				width			= de::min<int>(renderTarget.getWidth(), MAX_VIEWPORT_WIDTH);
	const int				height			= de::min<int>(renderTarget.getHeight(), MAX_VIEWPORT_HEIGHT);
	const tcu::Vec4			clearColor		(0.25f, 0.5f, 0.75f, 1.0f);

	TestLog&				log				= testCtx.getLog();
	tcu::ResultCollector	resultCollector	(log);

	logImplementationInfo(log, renderContext);
	logTextureInfo(log, format, bufferSize, offset, size);

	{
		tcu::Surface			referenceTarget	(width, height);
		vector<deUint8>			bufferData;

		genRandomCoords(rng, bufferData, 0, bufferSize);

		for (deUint8 i = 0; i < 4; i++)
		{
			const deUint8 val = extend2BitsToByte(i);

			if (val >= offset && val < offset + size)
			{
				bufferData[val*2 + 0] = (i / 2 == 0 ? extend2BitsToByte(0x2u) : extend2BitsToByte(0x01u));
				bufferData[val*2 + 1] = (i % 2 == 0 ? extend2BitsToByte(0x2u) : extend2BitsToByte(0x01u));
			}
		}

		{
			glu::TextureBuffer texture (renderContext, format, bufferSize, offset, size, &(bufferData[0]));

			TCU_CHECK_MSG(width >= MIN_VIEWPORT_WIDTH || height >= MIN_VIEWPORT_HEIGHT, "Too small viewport");

			DE_ASSERT(preRender == 0 || preRenderProgram);
			DE_ASSERT(postRender == 0 || postRenderProgram);

			gl.viewport(0, 0, width, height);
			gl.clearColor(clearColor.x(), clearColor.y(), clearColor.z(), clearColor.w());
			gl.clear(GL_COLOR_BUFFER_BIT);
			GLU_EXPECT_NO_ERROR(gl.getError(), "Screen setup failed");

			tcu::clear(referenceTarget.getAccess(), clearColor);

			texture.upload();

			if (preRender != 0)
				render(log, renderContext, preRender, rng, *preRenderProgram, texture, referenceTarget.getAccess());

			if (modifyType != 0)
				modify(log, resultCollector, renderContext, modifyType, rng, texture);

			if (postRender != 0)
				render(log, renderContext, postRender, rng, *postRenderProgram, texture, referenceTarget.getAccess());
		}

		verifyScreen(log, resultCollector, renderContext, referenceTarget.getAccess());

		resultCollector.setTestContextResult(testCtx);
	}
}

} // anonymous

TextureBufferCase::TextureBufferCase (tcu::TestContext&		testCtx,
									  glu::RenderContext&	renderCtx,
									  deUint32				format,
									  size_t				bufferSize,
									  size_t				offset,
									  size_t				size,
									  RenderBits			preRender,
									  ModifyBits			modify,
									  RenderBits			postRender,
									  const char*			name,
									  const char*			description)
	: tcu::TestCase				(testCtx, name, description)
	, m_renderCtx				(renderCtx)
	, m_format					(format)
	, m_bufferSize				(bufferSize)
	, m_offset					(offset)
	, m_size					(size)

	, m_preRender				(preRender)
	, m_modify					(modify)
	, m_postRender				(postRender)

	, m_preRenderProgram		(DE_NULL)
	, m_postRenderProgram		(DE_NULL)
{
}

TextureBufferCase::~TextureBufferCase (void)
{
	TextureBufferCase::deinit();
}

void TextureBufferCase::init (void)
{
	de::UniquePtr<glu::ContextInfo> info (glu::ContextInfo::create(m_renderCtx));

	if (!glu::contextSupports(m_renderCtx.getType(), glu::ApiType(3, 3, glu::PROFILE_CORE))
		&& !(glu::contextSupports(m_renderCtx.getType(), glu::ApiType(3, 1, glu::PROFILE_ES)) && info->isExtensionSupported("GL_EXT_texture_buffer")))
		throw tcu::NotSupportedError("Texture buffers not supported", "", __FILE__, __LINE__);

	{
		const int maxTextureBufferSize = info->getInt(GL_MAX_TEXTURE_BUFFER_SIZE);
		if (maxTextureBufferSize <= 0)
			TCU_THROW(NotSupportedError, "GL_MAX_TEXTURE_BUFFER_SIZE > 0 required");
	}

	if (m_preRender != 0)
	{
		TestLog&					log			= m_testCtx.getLog();
		const char* const			sectionName	= (m_postRender != 0 ? "Primary render program" : "Render program");
		const tcu::ScopedLogSection	section		(log, sectionName, sectionName);

		m_preRenderProgram = createRenderProgram(m_renderCtx, m_preRender);
		m_testCtx.getLog() << (*m_preRenderProgram);

		TCU_CHECK(m_preRenderProgram->isOk());
	}

	if (m_postRender != 0)
	{
		// Reusing program
		if (m_preRender == m_postRender)
		{
			m_postRenderProgram = m_preRenderProgram;
		}
		else
		{
			TestLog&					log			= m_testCtx.getLog();
			const char* const			sectionName	= (m_preRender!= 0 ? "Secondary render program" : "Render program");
			const tcu::ScopedLogSection	section		(log, sectionName, sectionName);

			m_postRenderProgram = createRenderProgram(m_renderCtx, m_postRender);
			m_testCtx.getLog() << (*m_postRenderProgram);

			TCU_CHECK(m_postRenderProgram->isOk());
		}
	}
}

void TextureBufferCase::deinit (void)
{
	if (m_preRenderProgram == m_postRenderProgram)
		m_postRenderProgram = DE_NULL;

	delete m_preRenderProgram;
	m_preRenderProgram = DE_NULL;

	delete m_postRenderProgram;
	m_postRenderProgram = DE_NULL;
}

tcu::TestCase::IterateResult TextureBufferCase::iterate (void)
{
	de::Random	rng		(deInt32Hash(deStringHash(getName())));
	size_t		offset;

	if (m_offset != 0)
	{
		const glw::Functions&	gl			= m_renderCtx.getFunctions();
		deInt32					alignment	= 0;

		gl.getIntegerv(GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT, &alignment);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv(GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT)");

		offset = m_offset * alignment;
	}
	else
		offset = 0;

	runTests(m_testCtx, m_renderCtx, rng, m_format, m_bufferSize, offset, m_size, m_preRender, m_preRenderProgram, m_modify, m_postRender, m_postRenderProgram);

	return STOP;
}

} // gls
} // deqp