自学教程：C++ GLU_EXPECT_NO_ERROR函数代码示例

/** @brief Function prepares texture object with test's data. * *  @note The function may throw if unexpected error has occured. */void TextureCubeMapArrayETC2Support::prepareTexture(){	/* Shortcut for GL functionality */	const glw::Functions& gl = m_context.getRenderContext().getFunctions();	gl.activeTexture(GL_TEXTURE0);	GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture call failed.");	/* Texture creation and binding. */	gl.genTextures(1, &m_texture);	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures call failed.");	const glw::GLuint target = GL_TEXTURE_CUBE_MAP_ARRAY;	gl.bindTexture(target, m_texture);	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture call failed.");	/* Uploading texture. */	gl.compressedTexImage3D(target, 0, GL_COMPRESSED_RGB8_ETC2, RENDER_WIDTH, RENDER_HEIGHT, 6, 0,							s_compressed_RGB_texture_data_size, s_compressed_RGB_texture_data);	GLU_EXPECT_NO_ERROR(gl.getError(), "glCompressedTexImage3D call failed.");	gl.texParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);	gl.texParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);	gl.texParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);	gl.texParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri call failed.");}

/** Takes a texture ID, binds it to GL_TEXTURE_CUBE_MAP_ARRAY texture target and *  initializes an immutable texture storage of @param texture_size x @param texture_size *  x (@param n_elements * 6) resolution. * * @param texture_id                           ID to use for the initialization. * @param texture_size                         Width & height to use for each layer-face. * @param n_cubemaps                           Amount of cube-maps to initialize. * @param should_take_color_texture_properties true if m_color_internal_format, m_color_format, *                                             m_color_type should be used for texture storage *                                             initialization, false to use relevant m_depth_* *                                             fields. **/void TextureCubeMapArrayColorDepthAttachmentsTest::prepareImmutableTextureObject(	glw::GLuint texture_id, glw::GLuint texture_size, glw::GLuint n_cubemaps, bool should_take_color_texture_properties){	const glw::Functions& gl			  = m_context.getRenderContext().getFunctions();	glw::GLenum			  internal_format = GL_NONE;	/* Set internal_format accordingly to requested texture type */	if (true == should_take_color_texture_properties)	{		internal_format = m_color_internal_format;	}	else	{		internal_format = m_depth_internal_format;	}	/* Bind the texture object to GL_TEXTURE_CUBE_MAP_ARRAY texture target. */	gl.bindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, texture_id);	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() call failed.");	/* Initialize immutable texture storage as per description */	gl.texStorage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 1, /* n_mipmap_levels */					internal_format, texture_size, texture_size, n_cubemaps * 6 /* layer-faces per cube-map */);	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage3D() call failed.");}

/** Setup frame buffer: * 1 allocate texture storage for specified format and dimensions, * 2 bind framebuffer and attach texture to GL_COLOR_ATTACHMENT0 * 3 setup viewport to specified dimensions * * @param framebuffer_object_id FBO handle * @param color_texture_id      Texture handle * @param texture_format        Requested texture format, eg. GL_RGBA8 * @param texture_width         Requested texture width * @param texture_height        Requested texture height * * @return true  All operations succeded *         false In case of any error **/bool TestCaseBase::setupFramebufferWithTextureAsAttachment(glw::GLuint framebuffer_object_id,														   glw::GLuint color_texture_id, glw::GLenum texture_format,														   glw::GLuint texture_width, glw::GLuint texture_height) const{	const glw::Functions& gl = m_context.getRenderContext().getFunctions();	/* Allocate texture storage */	gl.bindTexture(GL_TEXTURE_2D, color_texture_id);	gl.texStorage2D(GL_TEXTURE_2D, 1 /* levels */, texture_format, texture_width, texture_height);	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not allocate texture storage!");	/* Setup framebuffer */	gl.bindFramebuffer(GL_FRAMEBUFFER, framebuffer_object_id);	gl.framebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, color_texture_id, 0 /* level */);	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not setup framebuffer!");	/* Setup viewport */	gl.viewport(0, 0, texture_width, texture_height);	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not setup viewport!");	/* Success */	return true;}

void ShaderMultiDrawElementsIndirectParametersTestCase::initChild(){	const Functions& gl = m_context.getRenderContext().getFunctions();	// Set expected result vector [x, y, red, green, blue]	m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.05f, 1.0f, 0.0f, 0.0f));	m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.15f, 1.0f, 0.0f, 0.0f));	m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.05f, 0.0f, 0.0f, 0.0f));	m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.15f, 0.0f, 0.0f, 0.0f));	m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -0.8f + 0.05f, 0.0f, 0.0f, 0.0f));	m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -0.8f + 0.15f, 0.0f, 0.0f, 0.0f));	m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -0.8f + 0.05f, 0.0f, 0.0f, 0.0f));	m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -0.8f + 0.15f, 0.0f, 1.0f, 0.0f));	m_resultPoints.push_back(ResultPoint(-0.8f + 0.05f, -1.0f + 0.05f, 0.0f, 0.0f, 0.0f));	m_resultPoints.push_back(ResultPoint(-0.8f + 0.05f, -1.0f + 0.15f, 0.0f, 0.0f, 1.0f));	m_resultPoints.push_back(ResultPoint(-0.8f + 0.15f, -1.0f + 0.05f, 0.0f, 0.0f, 0.0f));	m_resultPoints.push_back(ResultPoint(-0.8f + 0.15f, -1.0f + 0.15f, 0.0f, 0.0f, 0.0f));	const SDPDrawElementsIndirectCommand indirect[] = {		{ 4, 1, 0, 0, 0 }, { 3, 1, 3, 0, 1 }, { 3, 1, 0, 1, 0 },	};	// Setup indirect command buffer	gl.genBuffers(1, &m_drawIndirectBuffer);	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");	gl.bindBuffer(GL_DRAW_INDIRECT_BUFFER, m_drawIndirectBuffer);	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");	gl.bufferData(GL_DRAW_INDIRECT_BUFFER, 3 * sizeof(SDPDrawElementsIndirectCommand), indirect, GL_STATIC_DRAW);	GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");}

void ShaderAtomicCounterOpsTestBase::bindBuffers(){	const glw::Functions& gl = m_context.getRenderContext().getFunctions();	gl.bindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, m_atomicCounterBuffer);	GLU_EXPECT_NO_ERROR(gl.getError(), "bindBufferBase() call failed.");	gl.bindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 1, m_atomicCounterCallsBuffer);	GLU_EXPECT_NO_ERROR(gl.getError(), "bindBufferBase() call failed.");}

/** Verify rendered polygon anisotropy. * *  @param gl  OpenGL functions wrapper * *  @return Returns points value. Less points means better anisotropy (smoother strips). */GLuint TextureFilterAnisotropicDrawingTestCase::verifyScene(const glw::Functions& gl){	std::vector<GLubyte> pixels;	pixels.resize(32 * 8 * 4);	gl.readPixels(0, 23, 32, 8, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data());	GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels");	GLuint sum = 0;	GLubyte last	= 0;	GLubyte current = 0;	for (int j = 0; j < 8; ++j)	{		for (int i = 0; i < 32; ++i)		{			current = pixels[(i + j * 32) * 4];			if (i > 0)				sum += deAbs32((int)current - (int)last);			last = current;		}	}	return sum;}

void ShaderDrawElementsParametersTestCase::drawCommand(){	const Functions& gl = m_context.getRenderContext().getFunctions();	gl.drawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_SHORT, (GLvoid*)(2 * sizeof(GLushort)));	GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawElements");}

/** Releases existing color & depth cube-map texture array objects, generates new *  ones and configures them as per user-specified properties. * *  @param texture_width                    Size to use for each layer-face's width and height. *  @param n_cubemaps                       Number of cube-maps to initialize for the cube-map texture arrays. *  @param should_generate_mutable_textures true if the texture should be initialized as mutable, false otherwise. **/void TextureCubeMapArrayColorDepthAttachmentsTest::generateAndConfigureTextureObjects(	glw::GLuint texture_width, glw::GLuint n_cubemaps, bool should_generate_mutable_textures){	const glw::Functions& gl = m_context.getRenderContext().getFunctions();	/* Release any texture objects that may have already been initialized */	releaseAndDetachTextureObject(m_color_texture_id, true /* is_color_attachment */);	releaseAndDetachTextureObject(m_depth_texture_id, false /* is_color_attachment */);	/* Generate texture objects */	gl.genTextures(1, &m_color_texture_id);	gl.genTextures(1, &m_depth_texture_id);	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() call(s) failed");	/* Configure new textures' storage */	if (true == should_generate_mutable_textures)	{		prepareMutableTextureObject(m_color_texture_id, texture_width, n_cubemaps,									true /* should_take_color_texture_properties */);		prepareMutableTextureObject(m_depth_texture_id, texture_width, n_cubemaps,									false /* should_take_color_texture_properties */);	}	else	{		prepareImmutableTextureObject(m_color_texture_id, texture_width, n_cubemaps,									  true /* should_take_color_texture_properties */);		prepareImmutableTextureObject(m_depth_texture_id, texture_width, n_cubemaps,									  false /* should_take_color_texture_properties */);	}}

/** Reads read buffer's depth data (assuming it's of 32-bit FP resolution) *  and verifies its correctness. * *  @param texture_size Texture size *  @param n_layer      Index of the layer to verify. * *  @return true if the retrieved data was found correct, false otherwise. **/bool TextureCubeMapArrayColorDepthAttachmentsTest::verifyDepth32FData(const _texture_size& texture_size,																	  glw::GLuint		   n_layer){	/* Allocate buffer for the data we will retrieve from the implementation */	glw::GLfloat		  expected_value   = (glw::GLfloat)n_layer / 256.0f;	const glw::Functions& gl			   = m_context.getRenderContext().getFunctions();	bool				  result		   = false;	const glw::GLuint	 result_data_size = texture_size.m_size * texture_size.m_size;	glw::GLfloat*		  result_data	  = new glw::GLfloat[result_data_size];	DE_ASSERT(result_data != NULL);	/* Read the data */	gl.readPixels(0, /* x */				  0, /* y */				  texture_size.m_size, texture_size.m_size, m_depth_format, m_depth_type, result_data);	GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() call failed");	/* Verify image, expected value is layer index */	result = verifyImage<glw::GLfloat, 1>(texture_size.m_size, texture_size.m_size, &expected_value, result_data);	/* Release the buffer */	if (result_data != NULL)	{		delete[] result_data;		result_data = NULL;	}	return result;}

/** Retrieves compilation OR linking info log for a shader/program object with GLES id *  @param id. * *  @param is_compilation_info_log true if @param id is a GLES id of a shader object; *                                 false if it represents a program object. *  @param id                      GLES id of a shader OR a program object to *                                 retrieve info log for. * *  @return String instance containing the log.. **/std::string TestCaseBase::getInfoLog(LOG_TYPE log_type, glw::GLuint id){	const glw::Functions& gl = m_context.getRenderContext().getFunctions();	glw::GLint n_characters = 0;	/* Retrieve amount of characters needed to store the info log (terminator-inclusive) */	switch (log_type)	{	case LT_SHADER_OBJECT:		gl.getShaderiv(id, GL_INFO_LOG_LENGTH, &n_characters);		break;	case LT_PROGRAM_OBJECT:		gl.getProgramiv(id, GL_INFO_LOG_LENGTH, &n_characters);		break;	case LT_PIPELINE_OBJECT:		gl.getProgramPipelineiv(id, GL_INFO_LOG_LENGTH, &n_characters);		break;	default:		TCU_FAIL("Invalid parameter");	}	/* Check if everything is fine so far */	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not query info log length!");	/* Allocate buffer */	std::vector<char> result_vec(n_characters + 1);	/* Retrieve the info log */	switch (log_type)	{	case LT_SHADER_OBJECT:		gl.getShaderInfoLog(id, n_characters + 1, 0, &result_vec[0]);		break;	case LT_PROGRAM_OBJECT:		gl.getProgramInfoLog(id, n_characters + 1, 0, &result_vec[0]);		break;	case LT_PIPELINE_OBJECT:		gl.getProgramPipelineInfoLog(id, n_characters + 1, 0, &result_vec[0]);		break;	}	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not retrieve info log!");	return std::string(&result_vec[0]);}

/** Set contents of texture * * @param gl              GL functions * @param target          Texture target * @param level           Mipmap level * @param internal_format Format of data * @param width           Width of texture * @param height          Height of texture * @param depth           Depth of texture * @param format          Format of data * @param type            Type of data * @param data            Buffer with image data **/void texImage(const Functions& gl, GLenum target, GLint level, GLenum internal_format, GLuint width, GLuint height,			  GLuint depth, GLenum format, GLenum type, const GLvoid* data){	switch (target)	{	case GL_TEXTURE_2D:		gl.texImage2D(target, level, internal_format, width, height, 0 /* border */, format, type, data);		GLU_EXPECT_NO_ERROR(gl.getError(), "texImage");		break;	case GL_TEXTURE_2D_ARRAY:		gl.texImage3D(target, level, internal_format, width, height, depth, 0 /* border */, format, type, data);		GLU_EXPECT_NO_ERROR(gl.getError(), "texImage");		break;	default:		TCU_FAIL("Invalid enum");		break;	}}

/** Set contents of texture * * @param gl              GL functions * @param target          Texture target * @param level           Mipmap level * @param x               X offset * @param y               Y offset * @param z               Z offset * @param width           Width of texture * @param height          Height of texture * @param depth           Depth of texture * @param format          Format of data * @param type            Type of data * @param pixels          Buffer with image data **/void subImage(const Functions& gl, GLenum target, GLint level, GLint x, GLint y, GLint z, GLsizei width, GLsizei height,			  GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels){	switch (target)	{	case GL_TEXTURE_2D:		gl.texSubImage2D(target, level, x, y, width, height, format, type, pixels);		GLU_EXPECT_NO_ERROR(gl.getError(), "TexSubImage2D");		break;	case GL_TEXTURE_2D_ARRAY:		gl.texSubImage3D(target, level, x, y, z, width, height, depth, format, type, pixels);		GLU_EXPECT_NO_ERROR(gl.getError(), "TexSubImage3D");		break;	default:		TCU_FAIL("Invalid enum");		break;	}}

/** Executes test iteration. * *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. */tcu::TestNode::IterateResult MultisampleTextureSampleMaskiGettersTest::iterate(){	/* Get GL_MAX_SAMPLE_MASK_WORDS value */	const glw::Functions& gl							 = m_context.getRenderContext().getFunctions();	glw::GLint			  gl_max_sample_mask_words_value = 0;	gl.getIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &gl_max_sample_mask_words_value);	GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to retrieve GL_MAX_SAMPLE_MASK_WORDS value");	/* Iterate over valid index & mask values */	const glw::GLuint  valid_masks[] = { 0, 0xFFFFFFFF, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF };	const unsigned int n_valid_masks = sizeof(valid_masks) / sizeof(valid_masks[0]);	for (int index = 0; index < gl_max_sample_mask_words_value; ++index)	{		for (unsigned int n_mask = 0; n_mask < n_valid_masks; ++n_mask)		{			glw::GLint mask = valid_masks[n_mask];			/* Make sure a valid glSampleMaski() call does not result in an error */			gl.sampleMaski(index, mask);			GLU_EXPECT_NO_ERROR(gl.getError(), "A valid glSampleMaski() call resulted in an error");			/* Check the property value as reported by implementation */			glw::GLint int_value = -1;			gl.getIntegeri_v(GL_SAMPLE_MASK_VALUE, index, &int_value);			GLU_EXPECT_NO_ERROR(gl.getError(), "A valid glGetIntegeri_v() call resulted in an error");			if (int_value != mask)			{				TCU_FAIL("Invalid sample mask reported");			}		} /* for (all masks) */	}	 /* for (all valid index argument values) */	/* Test case passed */	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");	return STOP;}

/** Executes the test. * *  Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. *  Note the function throws exception should an error occur! * *  @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. **/tcu::TestCase::IterateResult TextureCubeMapArrayColorDepthAttachmentsTest::iterate(){	/* GL functions */	const glw::Functions& gl = m_context.getRenderContext().getFunctions();	/* Initialize all ES objects needed to run the test */	initTest();	/* Setup clear values */	gl.clearColor(0.0f /* red */, 0.0f /* green */, 0.0f /* blue */, 0.0f /* alpha */);	GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor() call failed.");	gl.clearDepthf(1.0f /* d */);	GLU_EXPECT_NO_ERROR(gl.getError(), "glClearDepthf() call failed.");	/* Enable depth test */	gl.enable(GL_DEPTH_TEST);	GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable() call failed");	/* Execute tests for each resolution */	for (_texture_size_vector::iterator texture_size_iterator = m_resolutions.begin(),										end_iterator		  = m_resolutions.end();		 end_iterator != texture_size_iterator; ++texture_size_iterator)	{		testNonLayeredRendering(*texture_size_iterator, false);		testNonLayeredRendering(*texture_size_iterator, true);		testLayeredRendering(*texture_size_iterator, false);		testLayeredRendering(*texture_size_iterator, true);	}	/* Test passes if there were no errors */	if ((0 != m_n_invalid_color_checks) || (0 != m_n_invalid_depth_checks))	{		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");	}	else	{		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");	}	/* Done */	return STOP;}

/** Drawing quads method using drawArrays. */bool MultiDrawElementsIndirectCountCase::draw(){	const Functions& gl = m_context.getRenderContext().getFunctions();	ProgramSources sources = makeVtxFragSources(c_vertShader, c_fragShader);	ShaderProgram  program(gl, sources);	if (!program.isOk())	{		m_testCtx.getLog() << tcu::TestLog::Message << "Shader build failed./n"						   << "Vertex: " << program.getShaderInfo(SHADERTYPE_VERTEX).infoLog << "/n"						   << "Fragment: " << program.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "/n"						   << "Program: " << program.getProgramInfo().infoLog << tcu::TestLog::EndMessage;		return false;	}	gl.useProgram(program.getProgram());	GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram");	gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);	gl.clear(GL_COLOR_BUFFER_BIT);	gl.enable(GL_BLEND);	gl.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);	gl.enableVertexAttribArray(0);	GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray");	gl.vertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);	GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer");	gl.multiDrawElementsIndirectCount(GL_TRIANGLE_STRIP, GL_UNSIGNED_SHORT, 0, 0, 2, 0);	GLU_EXPECT_NO_ERROR(gl.getError(), "glMultiDrawElementsIndirectCountARB");	gl.disableVertexAttribArray(0);	GLU_EXPECT_NO_ERROR(gl.getError(), "glDisableVertexAttribArray");	gl.disable(GL_BLEND);	return true;}

void ShaderMetamorphicVariant::render (const tcu::PixelBufferAccess& img, const std::string& vertexSrc, const std::string& fragmentSrc){	TestLog&				log		= m_testCtx.getLog();	const glw::Functions&	gl		= m_context.getRenderContext().getFunctions();	// Positions, shared between shaders	const float positions[] =	{		-1.0f,  1.0f,	// top-left		-1.0f, -1.0f,	// bottom-left		 1.0f, -1.0f,	// bottom-right		 1.0f,  1.0f,	// top-right	};	const deUint16 indices[] =	{		0, 1, 2,	// bottom-left triangle		0, 3, 2,	// top-right triangle	};	glu::VertexArrayBinding posBinding = glu::va::Float("coord2d", 2, 6, 0, &positions[0]);	const glu::ShaderProgram program(m_context.getRenderContext(), glu::makeVtxFragSources(vertexSrc, fragmentSrc));	log << program;	if (!program.isOk())		throw tcu::TestError("Compile failed");	// Set uniforms expected in GraphicsFuzz generated programs	gl.useProgram(program.getProgram());	// Uniform: injectionSwitch	int uniformLoc = gl.getUniformLocation(program.getProgram(), "injectionSwitch");	if (uniformLoc != -1)		gl.uniform2f(uniformLoc, 0.0f, 1.0f);	// Uniform: resolution	uniformLoc = gl.getUniformLocation(program.getProgram(), "resolution");	if (uniformLoc != -1)		gl.uniform2f(uniformLoc, glw::GLfloat(img.getWidth()), glw::GLfloat(img.getHeight()));	// Uniform: mouse	uniformLoc = gl.getUniformLocation(program.getProgram(), "mouse");	if (uniformLoc != -1)		gl.uniform2f(uniformLoc, 0.0f, 0.0f);	// Uniform: time	uniformLoc = gl.getUniformLocation(program.getProgram(), "time");	if (uniformLoc != -1)		gl.uniform1f(uniformLoc, 0.0f);	// Render two times to check nondeterministic renderings	glu::draw(m_context.getRenderContext(), program.getProgram(), 1, &posBinding, glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0]));	glu::readPixels(m_context.getRenderContext(), 0, 0, img);	GLU_EXPECT_NO_ERROR(gl.getError(), "Draw");}

void ShaderAtomicCounterOpsTestBase::ShaderPipeline::renderQuad(deqp::Context& context){	const glw::Functions& gl = context.getRenderContext().getFunctions();	deUint16 const quadIndices[] = { 0, 1, 2, 2, 1, 3 };	float const position[] = { -1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f };	glu::VertexArrayBinding vertexArrays[] = { glu::va::Float("inPosition", 2, 4, 0, position) };	this->use(context);	glu::PrimitiveList primitiveList = glu::pr::Patches(DE_LENGTH_OF_ARRAY(quadIndices), quadIndices);	glu::draw(context.getRenderContext(), this->getShaderProgram()->getProgram(), DE_LENGTH_OF_ARRAY(vertexArrays),			  vertexArrays, primitiveList);	GLU_EXPECT_NO_ERROR(gl.getError(), "glu::draw error");	gl.memoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);	GLU_EXPECT_NO_ERROR(gl.getError(), "glMemoryBarrier() error");}