modules/glshared/glsRandomShaderProgram.cpp - third_party/vulkan-cts - Git at Google

 /*-------------------------------------------------------------------------
  * 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 sglr-rsg adaptation.
  *//*--------------------------------------------------------------------*/

 #include "glsRandomShaderProgram.hpp"
 #include "rsgShader.hpp"

 namespace deqp
 {
 namespace gls
 {

 using std::vector;

 static rr::GenericVecType mapToGenericVecType (const rsg::VariableType& varType)
 {
 	if (varType.isFloatOrVec())
 		return rr::GENERICVECTYPE_FLOAT;
 	else if (varType.isIntOrVec())
 		return rr::GENERICVECTYPE_INT32;
 	else
 	{
 		DE_ASSERT(false);
 		return rr::GENERICVECTYPE_LAST;
 	}
 }

 static glu::DataType mapToBasicType (const rsg::VariableType& varType)
 {
 	if (varType.isFloatOrVec() || varType.isIntOrVec() || varType.isBoolOrVec())
 	{
 		const glu::DataType		scalarType		= varType.isFloatOrVec()	? glu::TYPE_FLOAT	:
 												  varType.isIntOrVec()		? glu::TYPE_INT		:
 												  varType.isBoolOrVec()		? glu::TYPE_BOOL	: glu::TYPE_LAST;
 		const int				numComps		= varType.getNumElements();

 		DE_ASSERT(de::inRange(numComps, 1, 4));
 		return glu::DataType(scalarType + numComps - 1);
 	}
 	else if (varType.getBaseType() == rsg::VariableType::TYPE_SAMPLER_2D)
 		return glu::TYPE_SAMPLER_2D;
 	else if (varType.getBaseType() == rsg::VariableType::TYPE_SAMPLER_CUBE)
 		return glu::TYPE_SAMPLER_CUBE;
 	else
 	{
 		DE_ASSERT(false);
 		return glu::TYPE_LAST;
 	}
 }

 static void generateProgramDeclaration (sglr::pdec::ShaderProgramDeclaration& decl, const rsg::Shader& vertexShader, const rsg::Shader& fragmentShader, int numUnifiedUniforms, const rsg::ShaderInput* const* unifiedUniforms)
 {
 	decl << sglr::pdec::VertexSource(vertexShader.getSource())
 		 << sglr::pdec::FragmentSource(fragmentShader.getSource());

 	for (vector<rsg::ShaderInput*>::const_iterator vtxInIter = vertexShader.getInputs().begin(); vtxInIter != vertexShader.getInputs().end(); ++vtxInIter)
 	{
 		const rsg::ShaderInput*	vertexInput	= *vtxInIter;
 		decl << sglr::pdec::VertexAttribute(vertexInput->getVariable()->getName(), mapToGenericVecType(vertexInput->getVariable()->getType()));
 	}

 	for (vector<rsg::ShaderInput*>::const_iterator fragInIter = fragmentShader.getInputs().begin(); fragInIter != fragmentShader.getInputs().end(); ++fragInIter)
 	{
 		const rsg::ShaderInput*	fragInput	= *fragInIter;
 		decl << sglr::pdec::VertexToFragmentVarying(mapToGenericVecType(fragInput->getVariable()->getType()));
 	}

 	for (int uniformNdx = 0; uniformNdx < numUnifiedUniforms; uniformNdx++)
 	{
 		const rsg::ShaderInput*	uniform	= unifiedUniforms[uniformNdx];
 		decl << sglr::pdec::Uniform(uniform->getVariable()->getName(), mapToBasicType(uniform->getVariable()->getType()));
 	}

 	decl << sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT);
 }

 static sglr::pdec::ShaderProgramDeclaration generateProgramDeclaration (const rsg::Shader& vertexShader, const rsg::Shader& fragmentShader, int numUnifiedUniforms, const rsg::ShaderInput* const* unifiedUniforms)
 {
 	sglr::pdec::ShaderProgramDeclaration decl;
 	generateProgramDeclaration(decl, vertexShader, fragmentShader, numUnifiedUniforms, unifiedUniforms);
 	return decl;
 }

 static const rsg::Variable* findShaderOutputByName (const rsg::Shader& shader, const char* name)
 {
 	vector<const rsg::Variable*> outputs;
 	shader.getOutputs(outputs);

 	for (vector<const rsg::Variable*>::const_iterator iter = outputs.begin(); iter != outputs.end(); ++iter)
 	{
 		if (deStringEqual((*iter)->getName(), name))
 			return *iter;
 	}

 	return DE_NULL;
 }

 static const rsg::Variable* findShaderOutputByLocation (const rsg::Shader& shader, int location)
 {
 	vector<const rsg::Variable*> outputs;
 	shader.getOutputs(outputs);

 	for (vector<const rsg::Variable*>::const_iterator iter = outputs.begin(); iter != outputs.end(); iter++)
 	{
 		if ((*iter)->getLayoutLocation() == location)
 			return *iter;
 	}

 	return DE_NULL;
 }

 RandomShaderProgram::RandomShaderProgram (const rsg::Shader& vertexShader, const rsg::Shader& fragmentShader, int numUnifiedUniforms, const rsg::ShaderInput* const* unifiedUniforms)
 	: sglr::ShaderProgram	(generateProgramDeclaration(vertexShader, fragmentShader, numUnifiedUniforms, unifiedUniforms))
 	, m_vertexShader		(vertexShader)
 	, m_fragmentShader		(fragmentShader)
 	, m_numUnifiedUniforms	(numUnifiedUniforms)
 	, m_unifiedUniforms		(unifiedUniforms)
 	, m_positionVar			(findShaderOutputByName(vertexShader, "gl_Position"))
 	, m_fragColorVar		(findShaderOutputByLocation(fragmentShader, 0))
 	, m_execCtx				(m_sampler2DMap, m_samplerCubeMap)
 {
 	TCU_CHECK_INTERNAL(m_positionVar && m_positionVar->getType().getBaseType() == rsg::VariableType::TYPE_FLOAT && m_positionVar->getType().getNumElements() == 4);
 	TCU_CHECK_INTERNAL(m_fragColorVar && m_fragColorVar->getType().getBaseType() == rsg::VariableType::TYPE_FLOAT && m_fragColorVar->getType().getNumElements() == 4);

 	// Build list of vertex outputs.
 	for (vector<rsg::ShaderInput*>::const_iterator fragInIter = fragmentShader.getInputs().begin(); fragInIter != fragmentShader.getInputs().end(); ++fragInIter)
 	{
 		const rsg::ShaderInput*	fragInput		= *fragInIter;
 		const rsg::Variable*	vertexOutput	= findShaderOutputByName(vertexShader, fragInput->getVariable()->getName());

 		TCU_CHECK_INTERNAL(vertexOutput);
 		m_vertexOutputs.push_back(vertexOutput);
 	}
 }

 void RandomShaderProgram::refreshUniforms (void) const
 {
 	DE_ASSERT(m_numUnifiedUniforms == (int)m_uniforms.size());

 	for (int uniformNdx = 0; uniformNdx < m_numUnifiedUniforms; uniformNdx++)
 	{
 		const rsg::Variable*		uniformVar	= m_unifiedUniforms[uniformNdx]->getVariable();
 		const rsg::VariableType&	uniformType	= uniformVar->getType();
 		const sglr::UniformSlot&	uniformSlot	= m_uniforms[uniformNdx];

 		m_execCtx.getValue(uniformVar) = rsg::ConstValueAccess(uniformType, (const rsg::Scalar*)&uniformSlot.value).value();
 	}
 }

 void RandomShaderProgram::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
 {
 	// \todo [2013-12-13 pyry] Do only when necessary.
 	refreshUniforms();

 	int packetOffset = 0;

 	while (packetOffset < numPackets)
 	{
 		const int	numToExecute	= de::min(numPackets-packetOffset, (int)rsg::EXEC_VEC_WIDTH);

 		// Fetch attributes.
 		for (int attribNdx = 0; attribNdx < (int)m_vertexShader.getInputs().size(); ++attribNdx)
 		{
 			const rsg::Variable*		attribVar		= m_vertexShader.getInputs()[attribNdx]->getVariable();
 			const rsg::VariableType&	attribType		= attribVar->getType();
 			const int					numComponents	= attribType.getNumElements();
 			rsg::ExecValueAccess		access			= m_execCtx.getValue(attribVar);

 			DE_ASSERT(attribType.isFloatOrVec() && de::inRange(numComponents, 1, 4));

 			for (int ndx = 0; ndx < numToExecute; ndx++)
 			{
 				const int				packetNdx	= ndx+packetOffset;
 				const rr::VertexPacket*	packet		= packets[packetNdx];
 				const tcu::Vec4			attribValue	= rr::readVertexAttribFloat(inputs[attribNdx], packet->instanceNdx, packet->vertexNdx);

 										access.component(0).asFloat(ndx) = attribValue[0];
 				if (numComponents >= 2)	access.component(1).asFloat(ndx) = attribValue[1];
 				if (numComponents >= 3)	access.component(2).asFloat(ndx) = attribValue[2];
 				if (numComponents >= 4)	access.component(3).asFloat(ndx) = attribValue[3];
 			}
 		}

 		m_vertexShader.execute(m_execCtx);

 		// Store position
 		{
 			const rsg::ExecConstValueAccess	access	= m_execCtx.getValue(m_positionVar);

 			for (int ndx = 0; ndx < numToExecute; ndx++)
 			{
 				const int			packetNdx	= ndx+packetOffset;
 				rr::VertexPacket*	packet		= packets[packetNdx];

 				packet->position[0] = access.component(0).asFloat(ndx);
 				packet->position[1] = access.component(1).asFloat(ndx);
 				packet->position[2] = access.component(2).asFloat(ndx);
 				packet->position[3] = access.component(3).asFloat(ndx);
 			}
 		}

 		// Other varyings
 		for (int varNdx = 0; varNdx < (int)m_vertexOutputs.size(); varNdx++)
 		{
 			const rsg::Variable*			var				= m_vertexOutputs[varNdx];
 			const rsg::VariableType&		varType			= var->getType();
 			const int						numComponents	= varType.getNumElements();
 			const rsg::ExecConstValueAccess	access			= m_execCtx.getValue(var);

 			DE_ASSERT(varType.isFloatOrVec() && de::inRange(numComponents, 1, 4));

 			for (int ndx = 0; ndx < numToExecute; ndx++)
 			{
 				const int				packetNdx	= ndx+packetOffset;
 				rr::VertexPacket* const	packet		= packets[packetNdx];
 				float* const			dst			= packet->outputs[varNdx].getAccess<float>();

 										dst[0] = access.component(0).asFloat(ndx);
 				if (numComponents >= 2) dst[1] = access.component(1).asFloat(ndx);
 				if (numComponents >= 3) dst[2] = access.component(2).asFloat(ndx);
 				if (numComponents >= 4) dst[3] = access.component(3).asFloat(ndx);
 			}
 		}

 		packetOffset += numToExecute;
 	}
 }

 void RandomShaderProgram::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
 {
 	const rsg::ExecConstValueAccess	fragColorAccess	= m_execCtx.getValue(m_fragColorVar);
 	int								packetOffset	= 0;

 	DE_STATIC_ASSERT(rsg::EXEC_VEC_WIDTH % rr::NUM_FRAGMENTS_PER_PACKET == 0);

 	while (packetOffset < numPackets)
 	{
 		const int	numPacketsToExecute	= de::min(numPackets-packetOffset, (int)rsg::EXEC_VEC_WIDTH / (int)rr::NUM_FRAGMENTS_PER_PACKET);

 		// Interpolate varyings.
 		for (int varNdx = 0; varNdx < (int)m_fragmentShader.getInputs().size(); ++varNdx)
 		{
 			const rsg::Variable*		var				= m_fragmentShader.getInputs()[varNdx]->getVariable();
 			const rsg::VariableType&	varType			= var->getType();
 			const int					numComponents	= varType.getNumElements();
 			rsg::ExecValueAccess		access			= m_execCtx.getValue(var);

 			DE_ASSERT(varType.isFloatOrVec() && de::inRange(numComponents, 1, 4));

 			for (int packetNdx = 0; packetNdx < numPacketsToExecute; packetNdx++)
 			{
 				const rr::FragmentPacket&	packet		= packets[packetOffset+packetNdx];

 				for (int fragNdx = 0; fragNdx < rr::NUM_FRAGMENTS_PER_PACKET; fragNdx++)
 				{
 					const tcu::Vec4		varValue	= rr::readVarying<float>(packet, context, varNdx, fragNdx);
 					const int			dstNdx		= packetNdx*rr::NUM_FRAGMENTS_PER_PACKET + fragNdx;

 											access.component(0).asFloat(dstNdx) = varValue[0];
 					if (numComponents >= 2)	access.component(1).asFloat(dstNdx) = varValue[1];
 					if (numComponents >= 3)	access.component(2).asFloat(dstNdx) = varValue[2];
 					if (numComponents >= 4)	access.component(3).asFloat(dstNdx) = varValue[3];
 				}
 			}
 		}

 		m_fragmentShader.execute(m_execCtx);

 		// Store color
 		for (int packetNdx = 0; packetNdx < numPacketsToExecute; packetNdx++)
 		{
 			for (int fragNdx = 0; fragNdx < rr::NUM_FRAGMENTS_PER_PACKET; fragNdx++)
 			{
 				const int		srcNdx	= packetNdx*rr::NUM_FRAGMENTS_PER_PACKET + fragNdx;
 				const tcu::Vec4 color	(fragColorAccess.component(0).asFloat(srcNdx),
 										 fragColorAccess.component(1).asFloat(srcNdx),
 										 fragColorAccess.component(2).asFloat(srcNdx),
 										 fragColorAccess.component(3).asFloat(srcNdx));

 				rr::writeFragmentOutput(context, packetOffset+packetNdx, fragNdx, 0, color);
 			}
 		}

 		packetOffset += numPacketsToExecute;
 	}
 }

 } // gls
 } // deqp
	/*-------------------------------------------------------------------------
	* 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 sglr-rsg adaptation.
	//--------------------------------------------------------------------*/

	#include "glsRandomShaderProgram.hpp"
	#include "rsgShader.hpp"

	namespace deqp
	{
	namespace gls
	{

	using std::vector;

	static rr::GenericVecType mapToGenericVecType (const rsg::VariableType& varType)
	{
	if (varType.isFloatOrVec())
	return rr::GENERICVECTYPE_FLOAT;
	else if (varType.isIntOrVec())
	return rr::GENERICVECTYPE_INT32;
	else
	{
	DE_ASSERT(false);
	return rr::GENERICVECTYPE_LAST;
	}
	}

	static glu::DataType mapToBasicType (const rsg::VariableType& varType)
	{
	if (varType.isFloatOrVec() \|\| varType.isIntOrVec() \|\| varType.isBoolOrVec())
	{
	const glu::DataType scalarType = varType.isFloatOrVec() ? glu::TYPE_FLOAT :
	varType.isIntOrVec() ? glu::TYPE_INT :
	varType.isBoolOrVec() ? glu::TYPE_BOOL : glu::TYPE_LAST;
	const int numComps = varType.getNumElements();

	DE_ASSERT(de::inRange(numComps, 1, 4));
	return glu::DataType(scalarType + numComps - 1);
	}
	else if (varType.getBaseType() == rsg::VariableType::TYPE_SAMPLER_2D)
	return glu::TYPE_SAMPLER_2D;
	else if (varType.getBaseType() == rsg::VariableType::TYPE_SAMPLER_CUBE)
	return glu::TYPE_SAMPLER_CUBE;
	else
	{
	DE_ASSERT(false);
	return glu::TYPE_LAST;
	}
	}

	static void generateProgramDeclaration (sglr::pdec::ShaderProgramDeclaration& decl, const rsg::Shader& vertexShader, const rsg::Shader& fragmentShader, int numUnifiedUniforms, const rsg::ShaderInput* const* unifiedUniforms)
	{
	decl << sglr::pdec::VertexSource(vertexShader.getSource())
	<< sglr::pdec::FragmentSource(fragmentShader.getSource());

	for (vector<rsg::ShaderInput*>::const_iterator vtxInIter = vertexShader.getInputs().begin(); vtxInIter != vertexShader.getInputs().end(); ++vtxInIter)
	{
	const rsg::ShaderInput* vertexInput = *vtxInIter;
	decl << sglr::pdec::VertexAttribute(vertexInput->getVariable()->getName(), mapToGenericVecType(vertexInput->getVariable()->getType()));
	}

	for (vector<rsg::ShaderInput*>::const_iterator fragInIter = fragmentShader.getInputs().begin(); fragInIter != fragmentShader.getInputs().end(); ++fragInIter)
	{
	const rsg::ShaderInput* fragInput = *fragInIter;
	decl << sglr::pdec::VertexToFragmentVarying(mapToGenericVecType(fragInput->getVariable()->getType()));
	}

	for (int uniformNdx = 0; uniformNdx < numUnifiedUniforms; uniformNdx++)
	{
	const rsg::ShaderInput* uniform = unifiedUniforms[uniformNdx];
	decl << sglr::pdec::Uniform(uniform->getVariable()->getName(), mapToBasicType(uniform->getVariable()->getType()));
	}

	decl << sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT);
	}

	static sglr::pdec::ShaderProgramDeclaration generateProgramDeclaration (const rsg::Shader& vertexShader, const rsg::Shader& fragmentShader, int numUnifiedUniforms, const rsg::ShaderInput* const* unifiedUniforms)
	{
	sglr::pdec::ShaderProgramDeclaration decl;
	generateProgramDeclaration(decl, vertexShader, fragmentShader, numUnifiedUniforms, unifiedUniforms);
	return decl;
	}

	static const rsg::Variable* findShaderOutputByName (const rsg::Shader& shader, const char* name)
	{
	vector<const rsg::Variable*> outputs;
	shader.getOutputs(outputs);

	for (vector<const rsg::Variable*>::const_iterator iter = outputs.begin(); iter != outputs.end(); ++iter)
	{
	if (deStringEqual((*iter)->getName(), name))
	return *iter;
	}

	return DE_NULL;
	}

	static const rsg::Variable* findShaderOutputByLocation (const rsg::Shader& shader, int location)
	{
	vector<const rsg::Variable*> outputs;
	shader.getOutputs(outputs);

	for (vector<const rsg::Variable*>::const_iterator iter = outputs.begin(); iter != outputs.end(); iter++)
	{
	if ((*iter)->getLayoutLocation() == location)
	return *iter;
	}

	return DE_NULL;
	}

	RandomShaderProgram::RandomShaderProgram (const rsg::Shader& vertexShader, const rsg::Shader& fragmentShader, int numUnifiedUniforms, const rsg::ShaderInput* const* unifiedUniforms)
	: sglr::ShaderProgram (generateProgramDeclaration(vertexShader, fragmentShader, numUnifiedUniforms, unifiedUniforms))
	, m_vertexShader (vertexShader)
	, m_fragmentShader (fragmentShader)
	, m_numUnifiedUniforms (numUnifiedUniforms)
	, m_unifiedUniforms (unifiedUniforms)
	, m_positionVar (findShaderOutputByName(vertexShader, "gl_Position"))
	, m_fragColorVar (findShaderOutputByLocation(fragmentShader, 0))
	, m_execCtx (m_sampler2DMap, m_samplerCubeMap)
	{
	TCU_CHECK_INTERNAL(m_positionVar && m_positionVar->getType().getBaseType() == rsg::VariableType::TYPE_FLOAT && m_positionVar->getType().getNumElements() == 4);
	TCU_CHECK_INTERNAL(m_fragColorVar && m_fragColorVar->getType().getBaseType() == rsg::VariableType::TYPE_FLOAT && m_fragColorVar->getType().getNumElements() == 4);

	// Build list of vertex outputs.
	for (vector<rsg::ShaderInput*>::const_iterator fragInIter = fragmentShader.getInputs().begin(); fragInIter != fragmentShader.getInputs().end(); ++fragInIter)
	{
	const rsg::ShaderInput* fragInput = *fragInIter;
	const rsg::Variable* vertexOutput = findShaderOutputByName(vertexShader, fragInput->getVariable()->getName());

	TCU_CHECK_INTERNAL(vertexOutput);
	m_vertexOutputs.push_back(vertexOutput);
	}
	}

	void RandomShaderProgram::refreshUniforms (void) const
	{
	DE_ASSERT(m_numUnifiedUniforms == (int)m_uniforms.size());

	for (int uniformNdx = 0; uniformNdx < m_numUnifiedUniforms; uniformNdx++)
	{
	const rsg::Variable* uniformVar = m_unifiedUniforms[uniformNdx]->getVariable();
	const rsg::VariableType& uniformType = uniformVar->getType();
	const sglr::UniformSlot& uniformSlot = m_uniforms[uniformNdx];

	m_execCtx.getValue(uniformVar) = rsg::ConstValueAccess(uniformType, (const rsg::Scalar*)&uniformSlot.value).value();
	}
	}

	void RandomShaderProgram::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
	{
	// \todo [2013-12-13 pyry] Do only when necessary.
	refreshUniforms();

	int packetOffset = 0;

	while (packetOffset < numPackets)
	{
	const int numToExecute = de::min(numPackets-packetOffset, (int)rsg::EXEC_VEC_WIDTH);

	// Fetch attributes.
	for (int attribNdx = 0; attribNdx < (int)m_vertexShader.getInputs().size(); ++attribNdx)
	{
	const rsg::Variable* attribVar = m_vertexShader.getInputs()[attribNdx]->getVariable();
	const rsg::VariableType& attribType = attribVar->getType();
	const int numComponents = attribType.getNumElements();
	rsg::ExecValueAccess access = m_execCtx.getValue(attribVar);

	DE_ASSERT(attribType.isFloatOrVec() && de::inRange(numComponents, 1, 4));

	for (int ndx = 0; ndx < numToExecute; ndx++)
	{
	const int packetNdx = ndx+packetOffset;
	const rr::VertexPacket* packet = packets[packetNdx];
	const tcu::Vec4 attribValue = rr::readVertexAttribFloat(inputs[attribNdx], packet->instanceNdx, packet->vertexNdx);

	access.component(0).asFloat(ndx) = attribValue[0];
	if (numComponents >= 2) access.component(1).asFloat(ndx) = attribValue[1];
	if (numComponents >= 3) access.component(2).asFloat(ndx) = attribValue[2];
	if (numComponents >= 4) access.component(3).asFloat(ndx) = attribValue[3];
	}
	}

	m_vertexShader.execute(m_execCtx);

	// Store position
	{
	const rsg::ExecConstValueAccess access = m_execCtx.getValue(m_positionVar);

	for (int ndx = 0; ndx < numToExecute; ndx++)
	{
	const int packetNdx = ndx+packetOffset;
	rr::VertexPacket* packet = packets[packetNdx];

	packet->position[0] = access.component(0).asFloat(ndx);
	packet->position[1] = access.component(1).asFloat(ndx);
	packet->position[2] = access.component(2).asFloat(ndx);
	packet->position[3] = access.component(3).asFloat(ndx);
	}
	}

	// Other varyings
	for (int varNdx = 0; varNdx < (int)m_vertexOutputs.size(); varNdx++)
	{
	const rsg::Variable* var = m_vertexOutputs[varNdx];
	const rsg::VariableType& varType = var->getType();
	const int numComponents = varType.getNumElements();
	const rsg::ExecConstValueAccess access = m_execCtx.getValue(var);

	DE_ASSERT(varType.isFloatOrVec() && de::inRange(numComponents, 1, 4));

	for (int ndx = 0; ndx < numToExecute; ndx++)
	{
	const int packetNdx = ndx+packetOffset;
	rr::VertexPacket* const packet = packets[packetNdx];
	float* const dst = packet->outputs[varNdx].getAccess<float>();

	dst[0] = access.component(0).asFloat(ndx);
	if (numComponents >= 2) dst[1] = access.component(1).asFloat(ndx);
	if (numComponents >= 3) dst[2] = access.component(2).asFloat(ndx);
	if (numComponents >= 4) dst[3] = access.component(3).asFloat(ndx);
	}
	}

	packetOffset += numToExecute;
	}
	}

	void RandomShaderProgram::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
	{
	const rsg::ExecConstValueAccess fragColorAccess = m_execCtx.getValue(m_fragColorVar);
	int packetOffset = 0;

	DE_STATIC_ASSERT(rsg::EXEC_VEC_WIDTH % rr::NUM_FRAGMENTS_PER_PACKET == 0);

	while (packetOffset < numPackets)
	{
	const int numPacketsToExecute = de::min(numPackets-packetOffset, (int)rsg::EXEC_VEC_WIDTH / (int)rr::NUM_FRAGMENTS_PER_PACKET);

	// Interpolate varyings.
	for (int varNdx = 0; varNdx < (int)m_fragmentShader.getInputs().size(); ++varNdx)
	{
	const rsg::Variable* var = m_fragmentShader.getInputs()[varNdx]->getVariable();
	const rsg::VariableType& varType = var->getType();
	const int numComponents = varType.getNumElements();
	rsg::ExecValueAccess access = m_execCtx.getValue(var);

	DE_ASSERT(varType.isFloatOrVec() && de::inRange(numComponents, 1, 4));

	for (int packetNdx = 0; packetNdx < numPacketsToExecute; packetNdx++)
	{
	const rr::FragmentPacket& packet = packets[packetOffset+packetNdx];

	for (int fragNdx = 0; fragNdx < rr::NUM_FRAGMENTS_PER_PACKET; fragNdx++)
	{
	const tcu::Vec4 varValue = rr::readVarying<float>(packet, context, varNdx, fragNdx);
	const int dstNdx = packetNdx*rr::NUM_FRAGMENTS_PER_PACKET + fragNdx;

	access.component(0).asFloat(dstNdx) = varValue[0];
	if (numComponents >= 2) access.component(1).asFloat(dstNdx) = varValue[1];
	if (numComponents >= 3) access.component(2).asFloat(dstNdx) = varValue[2];
	if (numComponents >= 4) access.component(3).asFloat(dstNdx) = varValue[3];
	}
	}
	}

	m_fragmentShader.execute(m_execCtx);

	// Store color
	for (int packetNdx = 0; packetNdx < numPacketsToExecute; packetNdx++)
	{
	for (int fragNdx = 0; fragNdx < rr::NUM_FRAGMENTS_PER_PACKET; fragNdx++)
	{
	const int srcNdx = packetNdx*rr::NUM_FRAGMENTS_PER_PACKET + fragNdx;
	const tcu::Vec4 color (fragColorAccess.component(0).asFloat(srcNdx),
	fragColorAccess.component(1).asFloat(srcNdx),
	fragColorAccess.component(2).asFloat(srcNdx),
	fragColorAccess.component(3).asFloat(srcNdx));

	rr::writeFragmentOutput(context, packetOffset+packetNdx, fragNdx, 0, color);
	}
	}

	packetOffset += numPacketsToExecute;
	}
	}

	} // gls
	} // deqp