framework/randomshaders/rsgProgramExecutor.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program Random Shader Generator
 * ----------------------------------------------------
 *
 * 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 Program Executor.
 *//*--------------------------------------------------------------------*/

#include "rsgProgramExecutor.hpp"
#include "rsgExecutionContext.hpp"
#include "rsgVariableValue.hpp"
#include "rsgUtils.hpp"
#include "tcuSurface.hpp"
#include "deMath.h"
#include "deString.h"

#include <set>
#include <string>
#include <map>

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

namespace rsg
{

class VaryingStorage
{
public:
							VaryingStorage		(const VariableType& type, int numVertices);
							~VaryingStorage		(void) {}

	ValueAccess				getValue			(const VariableType& type, int vtxNdx);
	ConstValueAccess		getValue			(const VariableType& type, int vtxNdx) const;

private:
	std::vector<Scalar>		m_value;
};

VaryingStorage::VaryingStorage (const VariableType& type, int numVertices)
	: m_value(type.getScalarSize()*numVertices)
{
}

ValueAccess VaryingStorage::getValue (const VariableType& type, int vtxNdx)
{
	return ValueAccess(type, &m_value[type.getScalarSize()*vtxNdx]);
}

ConstValueAccess VaryingStorage::getValue (const VariableType& type, int vtxNdx) const
{
	return ConstValueAccess(type, &m_value[type.getScalarSize()*vtxNdx]);
}

class VaryingStore
{
public:
							VaryingStore		(int numVertices);
							~VaryingStore		(void);

	VaryingStorage*			getStorage			(const VariableType& type, const char* name);

private:
	int											m_numVertices;
	std::map<std::string, VaryingStorage*>		m_values;
};

VaryingStore::VaryingStore (int numVertices)
	: m_numVertices(numVertices)
{
}

VaryingStore::~VaryingStore (void)
{
	for (map<string, VaryingStorage*>::iterator i = m_values.begin(); i != m_values.end(); i++)
		delete i->second;
	m_values.clear();
}

VaryingStorage* VaryingStore::getStorage (const VariableType& type, const char* name)
{
	VaryingStorage* storage = m_values[name];

	if (!storage)
	{
		storage = new VaryingStorage(type, m_numVertices);
		m_values[name] = storage;
	}

	return storage;
}

inline float interpolateVertexQuad (const tcu::Vec4& quad, float x, float y)
{
	float w00 = (1.0f-x)*(1.0f-y);
	float w01 = (1.0f-x)*y;
	float w10 = x*(1.0f-y);
	float w11 = x*y;
	return quad.x()*w00 + quad.y()*w10 + quad.z()*w01 + quad.w()*w11;
}

inline float interpolateVertex (float x0y0, float x1y1, float x, float y)
{
	return interpolateVertexQuad(tcu::Vec4(x0y0, (x0y0+x1y1)*0.5f, (x0y0+x1y1)*0.5f, x1y1), x, y);
}

inline float interpolateTri (float v0, float v1, float v2, float x, float y)
{
	return v0 + (v1-v0)*x + (v2-v0)*y;
}

inline float interpolateFragment (const tcu::Vec4& quad, float x, float y)
{
	if (x + y < 1.0f)
		return interpolateTri(quad.x(), quad.y(), quad.z(), x, y);
	else
		return interpolateTri(quad.w(), quad.z(), quad.y(), 1.0f-x, 1.0f-y);
}

template <int Stride>
void interpolateVertexInput (StridedValueAccess<Stride> dst, int dstComp, const ConstValueRangeAccess valueRange, float x, float y)
{
	TCU_CHECK(valueRange.getType().getBaseType() == VariableType::TYPE_FLOAT);
	int numElements = valueRange.getType().getNumElements();
	for (int elementNdx = 0; elementNdx < numElements; elementNdx++)
	{
		float xd, yd;
		getVertexInterpolationCoords(xd, yd, x, y, elementNdx);
		dst.component(elementNdx).asFloat(dstComp) = interpolateVertex(valueRange.getMin().component(elementNdx).asFloat(), valueRange.getMax().component(elementNdx).asFloat(), xd, yd);
	}
}

template <int Stride>
void interpolateFragmentInput (StridedValueAccess<Stride> dst, int dstComp, ConstValueAccess vtx0, ConstValueAccess vtx1, ConstValueAccess vtx2, ConstValueAccess vtx3, float x, float y)
{
	TCU_CHECK(dst.getType().getBaseType() == VariableType::TYPE_FLOAT);
	int numElements = dst.getType().getNumElements();
	for (int ndx = 0; ndx < numElements; ndx++)
		dst.component(ndx).asFloat(dstComp) = interpolateFragment(tcu::Vec4(vtx0.component(ndx).asFloat(), vtx1.component(ndx).asFloat(), vtx2.component(ndx).asFloat(), vtx3.component(ndx).asFloat()), x, y);
}

template <int Stride>
void copyVarying (ValueAccess dst, ConstStridedValueAccess<Stride> src, int compNdx)
{
	TCU_CHECK(dst.getType().getBaseType() == VariableType::TYPE_FLOAT);
	for (int elemNdx = 0; elemNdx < dst.getType().getNumElements(); elemNdx++)
		dst.component(elemNdx).asFloat() = src.component(elemNdx).asFloat(compNdx);
}

ProgramExecutor::ProgramExecutor (const tcu::PixelBufferAccess& dst, int gridWidth, int gridHeight)
	: m_dst			(dst)
	, m_gridWidth	(gridWidth)
	, m_gridHeight	(gridHeight)
{
}

ProgramExecutor::~ProgramExecutor (void)
{
}

void ProgramExecutor::setTexture (int samplerNdx, const tcu::Texture2D* texture, const tcu::Sampler& sampler)
{
	m_samplers2D[samplerNdx] = Sampler2D(texture, sampler);
}

void ProgramExecutor::setTexture (int samplerNdx, const tcu::TextureCube* texture, const tcu::Sampler& sampler)
{
	m_samplersCube[samplerNdx] = SamplerCube(texture, sampler);
}

inline tcu::IVec4 computeVertexIndices (float cellWidth, float cellHeight, int gridVtxWidth, int gridVtxHeight, int x, int y)
{
	DE_UNREF(gridVtxHeight);
	int x0 = (int)deFloatFloor((float)x / cellWidth);
	int y0 = (int)deFloatFloor((float)y / cellHeight);
	return tcu::IVec4(y0*gridVtxWidth + x0, y0*gridVtxWidth + x0 + 1, (y0+1)*gridVtxWidth + x0, (y0+1)*gridVtxWidth + x0 + 1);
}

inline tcu::Vec2 computeGridCellWeights (float cellWidth, float cellHeight, int x, int y)
{
	float gx = (x + 0.5f) / cellWidth;
	float gy = (y + 0.5f) / cellHeight;
	return tcu::Vec2(deFloatFrac(gx), deFloatFrac(gy));
}

inline tcu::RGBA toColor (tcu::Vec4 rgba)
{
	return tcu::RGBA(deClamp32(deRoundFloatToInt32(rgba.x()*255), 0, 255),
					 deClamp32(deRoundFloatToInt32(rgba.y()*255), 0, 255),
					 deClamp32(deRoundFloatToInt32(rgba.z()*255), 0, 255),
					 deClamp32(deRoundFloatToInt32(rgba.w()*255), 0, 255));
}

void ProgramExecutor::execute (const Shader& vertexShader, const Shader& fragmentShader, const vector<VariableValue>& uniformValues)
{
	int	gridVtxWidth	= m_gridWidth+1;
	int gridVtxHeight	= m_gridHeight+1;
	int numVertices		= gridVtxWidth*gridVtxHeight;

	VaryingStore varyingStore(numVertices);

	// Execute vertex shader
	{
		ExecutionContext	execCtx(m_samplers2D, m_samplersCube);
		int					numPackets	= numVertices + ((numVertices%EXEC_VEC_WIDTH) ? 1 : 0);

		const vector<ShaderInput*>& inputs	= vertexShader.getInputs();
		vector<const Variable*>		outputs;
		vertexShader.getOutputs(outputs);

		// Set uniform values
		for (vector<VariableValue>::const_iterator uniformIter = uniformValues.begin(); uniformIter != uniformValues.end(); uniformIter++)
			execCtx.getValue(uniformIter->getVariable()) = uniformIter->getValue().value();

		for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
		{
			int packetStart	= packetNdx*EXEC_VEC_WIDTH;
			int packetEnd	= deMin32((packetNdx+1)*EXEC_VEC_WIDTH, numVertices);

			// Compute values for vertex shader inputs
			for (vector<ShaderInput*>::const_iterator i = inputs.begin(); i != inputs.end(); i++)
			{
				const ShaderInput*	input	= *i;
				ExecValueAccess		access	= execCtx.getValue(input->getVariable());

				for (int vtxNdx = packetStart; vtxNdx < packetEnd; vtxNdx++)
				{
					int		y	= (vtxNdx/gridVtxWidth);
					int		x	= vtxNdx - y*gridVtxWidth;
					float	xf	= (float)x / (float)(gridVtxWidth-1);
					float	yf	= (float)y / (float)(gridVtxHeight-1);

					interpolateVertexInput(access, vtxNdx-packetStart, input->getValueRange(), xf, yf);
				}
			}

			// Execute vertex shader for packet
			vertexShader.execute(execCtx);

			// Store output values
			for (vector<const Variable*>::const_iterator i = outputs.begin(); i != outputs.end(); i++)
			{
				const Variable*			output	= *i;

				if (deStringEqual(output->getName(), "gl_Position"))
					continue; // Do not store position

				ExecConstValueAccess	access	= execCtx.getValue(output);
				VaryingStorage*			dst		= varyingStore.getStorage(output->getType(), output->getName());

				for (int vtxNdx = packetStart; vtxNdx < packetEnd; vtxNdx++)
				{
					ValueAccess varyingAccess = dst->getValue(output->getType(), vtxNdx);
					copyVarying(varyingAccess, access, vtxNdx-packetStart);
				}
			}
		}
	}

	// Execute fragment shader
	{
		ExecutionContext execCtx(m_samplers2D, m_samplersCube);

		// Assign uniform values
		for (vector<VariableValue>::const_iterator i = uniformValues.begin(); i != uniformValues.end(); i++)
			execCtx.getValue(i->getVariable()) = i->getValue().value();

		const vector<ShaderInput*>& inputs			= fragmentShader.getInputs();
		const Variable*				fragColorVar	= DE_NULL;
		vector<const Variable*>		outputs;

		// Find fragment shader output assigned to location 0. This is fragment color.
		fragmentShader.getOutputs(outputs);
		for (vector<const Variable*>::const_iterator i = outputs.begin(); i != outputs.end(); i++)
		{
			if ((*i)->getLayoutLocation() == 0)
			{
				fragColorVar = *i;
				break;
			}
		}
		TCU_CHECK(fragColorVar);

		int	width		= m_dst.getWidth();
		int height		= m_dst.getHeight();
		int numPackets	= (width*height)/EXEC_VEC_WIDTH + (((width*height)%EXEC_VEC_WIDTH) ? 1 : 0);

		float cellWidth		= (float)width	/ (float)m_gridWidth;
		float cellHeight	= (float)height	/ (float)m_gridHeight;

		for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
		{
			int packetStart	= packetNdx*EXEC_VEC_WIDTH;
			int packetEnd	= deMin32((packetNdx+1)*EXEC_VEC_WIDTH, width*height);

			// Interpolate varyings
			for (vector<ShaderInput*>::const_iterator i = inputs.begin(); i != inputs.end(); i++)
			{
				const ShaderInput*		input	= *i;
				ExecValueAccess			access	= execCtx.getValue(input->getVariable());
				const VariableType&		type	= input->getVariable()->getType();
				const VaryingStorage*	src		= varyingStore.getStorage(type, input->getVariable()->getName());

				// \todo [2011-03-08 pyry] Part of this could be pre-computed...
				for (int fragNdx = packetStart; fragNdx < packetEnd; fragNdx++)
				{
					int y = fragNdx/width;
					int x = fragNdx - y*width;
					tcu::IVec4	vtxIndices	= computeVertexIndices(cellWidth, cellHeight, gridVtxWidth, gridVtxHeight, x, y);
					tcu::Vec2	weights		= computeGridCellWeights(cellWidth, cellHeight, x, y);

					interpolateFragmentInput(access, fragNdx-packetStart,
											 src->getValue(type, vtxIndices.x()),
											 src->getValue(type, vtxIndices.y()),
											 src->getValue(type, vtxIndices.z()),
											 src->getValue(type, vtxIndices.w()),
											 weights.x(), weights.y());
				}
			}

			// Execute fragment shader
			fragmentShader.execute(execCtx);

			// Write resulting color
			ExecConstValueAccess colorValue = execCtx.getValue(fragColorVar);
			for (int fragNdx = packetStart; fragNdx < packetEnd; fragNdx++)
			{
				int			y		= fragNdx/width;
				int			x		= fragNdx - y*width;
				int			cNdx	= fragNdx-packetStart;
				tcu::Vec4	c		= tcu::Vec4(colorValue.component(0).asFloat(cNdx),
												colorValue.component(1).asFloat(cNdx),
												colorValue.component(2).asFloat(cNdx),
												colorValue.component(3).asFloat(cNdx));

				// \todo [2012-11-13 pyry] Reverse order.
				m_dst.setPixel(c, x, m_dst.getHeight()-y-1);
			}
		}
	}
}

} // rsg