/*-------------------------------------------------------------------------
|
* 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
|
