v811_spc009/external/deqp/framework/randomshaders/rsgExecutionContext.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 Shader Evaluation Context.
 *//*--------------------------------------------------------------------*/

#include "rsgExecutionContext.hpp"

namespace rsg
{

ExecMaskStorage::ExecMaskStorage (bool initVal)
{
	for (int i = 0; i < EXEC_VEC_WIDTH; i++)
		m_data[i].as<bool>() = initVal;
}

ExecValueAccess ExecMaskStorage::getValue (void)
{
	return ExecValueAccess(VariableType::getScalarType(VariableType::TYPE_BOOL), m_data);
}

ExecConstValueAccess ExecMaskStorage::getValue (void) const
{
	return ExecConstValueAccess(VariableType::getScalarType(VariableType::TYPE_BOOL), m_data);
}

ExecutionContext::ExecutionContext (const Sampler2DMap& samplers2D, const SamplerCubeMap& samplersCube)
	: m_samplers2D		(samplers2D)
	, m_samplersCube	(samplersCube)
{
	// Initialize execution mask to true
	ExecMaskStorage initVal(true);
	pushExecutionMask(initVal.getValue());
}

ExecutionContext::~ExecutionContext (void)
{
	for (VarValueMap::iterator i = m_varValues.begin(); i != m_varValues.end(); i++)
		delete i->second;
	m_varValues.clear();
}

ExecValueAccess ExecutionContext::getValue (const Variable* variable)
{
	ExecValueStorage* storage = m_varValues[variable];

	if (!storage)
	{
		storage = new ExecValueStorage(variable->getType());
		m_varValues[variable] = storage;
	}

	return storage->getValue(variable->getType());
}

const Sampler2D& ExecutionContext::getSampler2D (const Variable* sampler) const
{
	const ExecValueStorage* samplerVal = m_varValues.find(sampler)->second;

	int samplerNdx = samplerVal->getValue(sampler->getType()).asInt(0);

	return m_samplers2D.find(samplerNdx)->second;
}

const SamplerCube& ExecutionContext::getSamplerCube (const Variable* sampler) const
{
	const ExecValueStorage* samplerVal = m_varValues.find(sampler)->second;

	int samplerNdx = samplerVal->getValue(sampler->getType()).asInt(0);

	return m_samplersCube.find(samplerNdx)->second;
}

void ExecutionContext::andExecutionMask (ExecConstValueAccess value)
{
	ExecMaskStorage			tmp;
	ExecValueAccess			newValue	= tmp.getValue();
	ExecConstValueAccess	oldValue	= getExecutionMask();

	for (int i = 0; i < EXEC_VEC_WIDTH; i++)
		newValue.asBool(i) = oldValue.asBool(i) && value.asBool(i);

	pushExecutionMask(newValue);
}

void ExecutionContext::pushExecutionMask (ExecConstValueAccess value)
{
	ExecMaskStorage tmp;
	tmp.getValue() = value.value();
	m_execMaskStack.push_back(tmp);
}

void ExecutionContext::popExecutionMask (void)
{
	m_execMaskStack.pop_back();
}

ExecConstValueAccess ExecutionContext::getExecutionMask (void) const
{
	return m_execMaskStack[m_execMaskStack.size()-1].getValue();
}

void assignMasked (ExecValueAccess dst, ExecConstValueAccess src, ExecConstValueAccess mask)
{
	const VariableType& type = dst.getType();

	switch (type.getBaseType())
	{
		case VariableType::TYPE_ARRAY:
		{
			int numElems = type.getNumElements();
			for (int elemNdx = 0; elemNdx < numElems; elemNdx++)
				assignMasked(dst.arrayElement(elemNdx), src.arrayElement(elemNdx), mask);

			break;
		}

		case VariableType::TYPE_STRUCT:
		{
			int numMembers = (int)type.getMembers().size();
			for (int memberNdx = 0; memberNdx < numMembers; memberNdx++)
				assignMasked(dst.member(memberNdx), src.member(memberNdx), mask);

			break;
		}

		case VariableType::TYPE_FLOAT:
		case VariableType::TYPE_INT:
		case VariableType::TYPE_BOOL:
		case VariableType::TYPE_SAMPLER_2D:
		case VariableType::TYPE_SAMPLER_CUBE:
		{
			for (int elemNdx = 0; elemNdx < type.getNumElements(); elemNdx++)
			{
				ExecValueAccess			dstElem		= dst.component(elemNdx);
				ExecConstValueAccess	srcElem		= src.component(elemNdx);

				for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
				{
					if (mask.asBool(compNdx))
						dstElem.asScalar(compNdx) = srcElem.asScalar(compNdx);
				}
			}

			break;
		}

		default:
			DE_FATAL("Unsupported");
			break;
	}
}

} // rsg