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
ExecMaskStorage(bool initVal)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
getValue(void)35 ExecValueAccess ExecMaskStorage::getValue(void)
36 {
37 return ExecValueAccess(VariableType::getScalarType(VariableType::TYPE_BOOL), m_data);
38 }
39
getValue(void) const40 ExecConstValueAccess ExecMaskStorage::getValue(void) const
41 {
42 return ExecConstValueAccess(VariableType::getScalarType(VariableType::TYPE_BOOL), m_data);
43 }
44
ExecutionContext(const Sampler2DMap & samplers2D,const SamplerCubeMap & samplersCube)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
~ExecutionContext(void)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
getValue(const Variable * variable)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
getSampler2D(const Variable * sampler) const74 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
getSamplerCube(const Variable * sampler) const83 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
andExecutionMask(ExecConstValueAccess value)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
pushExecutionMask(ExecConstValueAccess value)104 void ExecutionContext::pushExecutionMask(ExecConstValueAccess value)
105 {
106 ExecMaskStorage tmp;
107 tmp.getValue() = value.value();
108 m_execMaskStack.push_back(tmp);
109 }
110
popExecutionMask(void)111 void ExecutionContext::popExecutionMask(void)
112 {
113 m_execMaskStack.pop_back();
114 }
115
getExecutionMask(void) const116 ExecConstValueAccess ExecutionContext::getExecutionMask(void) const
117 {
118 return m_execMaskStack[m_execMaskStack.size() - 1].getValue();
119 }
120
assignMasked(ExecValueAccess dst,ExecConstValueAccess src,ExecConstValueAccess mask)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 } // namespace rsg
173