framework/randomshaders/rsgExecutionContext.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program Random Shader Generator
   3  * ----------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Shader Evaluation Context.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "rsgExecutionContext.hpp"
  25
  26 namespace rsg
  27 {
  28
  29 ExecMaskStorage::ExecMaskStorage (bool initVal)
  30 {
  31         for (int i = 0; i < EXEC_VEC_WIDTH; i++)
  32                 m_data[i].as<bool>() = initVal;
  33 }
  34
  35 ExecValueAccess ExecMaskStorage::getValue (void)
  36 {
  37         return ExecValueAccess(VariableType::getScalarType(VariableType::TYPE_BOOL), m_data);
  38 }
  39
  40 ExecConstValueAccess ExecMaskStorage::getValue (void) const
  41 {
  42         return ExecConstValueAccess(VariableType::getScalarType(VariableType::TYPE_BOOL), m_data);
  43 }
  44
  45 ExecutionContext::ExecutionContext (const Sampler2DMap& samplers2D, const SamplerCubeMap& samplersCube)
  46         : m_samplers2D          (samplers2D)
  47         , m_samplersCube        (samplersCube)
  48 {
  49         // Initialize execution mask to true
  50         ExecMaskStorage initVal(true);
  51         pushExecutionMask(initVal.getValue());
  52 }
  53
  54 ExecutionContext::~ExecutionContext (void)
  55 {
  56         for (VarValueMap::iterator i = m_varValues.begin(); i != m_varValues.end(); i++)
  57                 delete i->second;
  58         m_varValues.clear();
  59 }
  60
  61 ExecValueAccess ExecutionContext::getValue (const Variable* variable)
  62 {
  63         ExecValueStorage* storage = m_varValues[variable];
  64
  65         if (!storage)
  66         {
  67                 storage = new ExecValueStorage(variable->getType());
  68                 m_varValues[variable] = storage;
  69         }
  70
  71         return storage->getValue(variable->getType());
  72 }
  73
  74 const Sampler2D& ExecutionContext::getSampler2D (const Variable* sampler) const
  75 {
  76         const ExecValueStorage* samplerVal = m_varValues.find(sampler)->second;
  77
  78         int samplerNdx = samplerVal->getValue(sampler->getType()).asInt(0);
  79
  80         return m_samplers2D.find(samplerNdx)->second;
  81 }
  82
  83 const SamplerCube& ExecutionContext::getSamplerCube (const Variable* sampler) const
  84 {
  85         const ExecValueStorage* samplerVal = m_varValues.find(sampler)->second;
  86
  87         int samplerNdx = samplerVal->getValue(sampler->getType()).asInt(0);
  88
  89         return m_samplersCube.find(samplerNdx)->second;
  90 }
  91
  92 void ExecutionContext::andExecutionMask (ExecConstValueAccess value)
  93 {
  94         ExecMaskStorage                 tmp;
  95         ExecValueAccess                 newValue        = tmp.getValue();
  96         ExecConstValueAccess    oldValue        = getExecutionMask();
  97
  98         for (int i = 0; i < EXEC_VEC_WIDTH; i++)
  99                 newValue.asBool(i) = oldValue.asBool(i) && value.asBool(i);
 100
 101         pushExecutionMask(newValue);
 102 }
 103
 104 void ExecutionContext::pushExecutionMask (ExecConstValueAccess value)
 105 {
 106         ExecMaskStorage tmp;
 107         tmp.getValue() = value.value();
 108         m_execMaskStack.push_back(tmp);
 109 }
 110
 111 void ExecutionContext::popExecutionMask (void)
 112 {
 113         m_execMaskStack.pop_back();
 114 }
 115
 116 ExecConstValueAccess ExecutionContext::getExecutionMask (void) const
 117 {
 118         return m_execMaskStack[m_execMaskStack.size()-1].getValue();
 119 }
 120
 121 void assignMasked (ExecValueAccess dst, ExecConstValueAccess src, ExecConstValueAccess mask)
 122 {
 123         const VariableType& type = dst.getType();
 124
 125         switch (type.getBaseType())
 126         {
 127                 case VariableType::TYPE_ARRAY:
 128                 {
 129                         int numElems = type.getNumElements();
 130                         for (int elemNdx = 0; elemNdx < numElems; elemNdx++)
 131                                 assignMasked(dst.arrayElement(elemNdx), src.arrayElement(elemNdx), mask);
 132
 133                         break;
 134                 }
 135
 136                 case VariableType::TYPE_STRUCT:
 137                 {
 138                         int numMembers = (int)type.getMembers().size();
 139                         for (int memberNdx = 0; memberNdx < numMembers; memberNdx++)
 140                                 assignMasked(dst.member(memberNdx), src.member(memberNdx), mask);
 141
 142                         break;
 143                 }
 144
 145                 case VariableType::TYPE_FLOAT:
 146                 case VariableType::TYPE_INT:
 147                 case VariableType::TYPE_BOOL:
 148                 case VariableType::TYPE_SAMPLER_2D:
 149                 case VariableType::TYPE_SAMPLER_CUBE:
 150                 {
 151                         for (int elemNdx = 0; elemNdx < type.getNumElements(); elemNdx++)
 152                         {
 153                                 ExecValueAccess                 dstElem         = dst.component(elemNdx);
 154                                 ExecConstValueAccess    srcElem         = src.component(elemNdx);
 155
 156                                 for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
 157                                 {
 158                                         if (mask.asBool(compNdx))
 159                                                 dstElem.asScalar(compNdx) = srcElem.asScalar(compNdx);
 160                                 }
 161                         }
 162
 163                         break;
 164                 }
 165
 166                 default:
 167                         DE_FATAL("Unsupported");
 168                         break;
 169         }
 170 }
 171
 172 } // rsg