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 Expressions.
22 *//*--------------------------------------------------------------------*/
23
24 #include "rsgExpression.hpp"
25 #include "rsgVariableManager.hpp"
26 #include "rsgBinaryOps.hpp"
27 #include "rsgBuiltinFunctions.hpp"
28 #include "rsgUtils.hpp"
29 #include "deMath.h"
30
31 using std::vector;
32
33 namespace rsg
34 {
35
36 namespace
37 {
38
39 class IsReadableEntry
40 {
41 public:
42 typedef ValueEntryIterator<IsReadableEntry> Iterator;
43
IsReadableEntry(deUint32 exprFlags)44 IsReadableEntry (deUint32 exprFlags)
45 : m_exprFlags(exprFlags)
46 {
47 }
48
operator ()(const ValueEntry * entry) const49 bool operator() (const ValueEntry* entry) const
50 {
51 if ((m_exprFlags & CONST_EXPR) && (entry->getVariable()->getStorage() != Variable::STORAGE_CONST))
52 return false;
53
54 return true;
55 }
56
57 private:
58 deUint32 m_exprFlags;
59 };
60
61 class IsReadableIntersectingEntry : public IsReadableEntry
62 {
63 public:
64 typedef ValueEntryIterator<IsReadableIntersectingEntry> Iterator;
65
IsReadableIntersectingEntry(ConstValueRangeAccess valueRange,deUint32 exprFlags)66 IsReadableIntersectingEntry (ConstValueRangeAccess valueRange, deUint32 exprFlags)
67 : IsReadableEntry (exprFlags)
68 , m_valueRange (valueRange)
69 {
70 }
71
operator ()(const ValueEntry * entry) const72 bool operator() (const ValueEntry* entry) const
73 {
74 if (!IsReadableEntry::operator()(entry))
75 return false;
76
77 if (entry->getValueRange().getType() != m_valueRange.getType())
78 return false;
79
80 if (!entry->getValueRange().intersects(m_valueRange))
81 return false;
82
83 return true;
84 }
85
86 private:
87 ConstValueRangeAccess m_valueRange;
88 };
89
90 class IsWritableIntersectingEntry : public IsWritableEntry
91 {
92 public:
93 typedef ValueEntryIterator<IsWritableIntersectingEntry> Iterator;
94
IsWritableIntersectingEntry(ConstValueRangeAccess valueRange)95 IsWritableIntersectingEntry (ConstValueRangeAccess valueRange)
96 : m_valueRange(valueRange)
97 {
98 }
99
operator ()(const ValueEntry * entry) const100 bool operator() (const ValueEntry* entry) const
101 {
102 return IsWritableEntry::operator()(entry) &&
103 entry->getVariable()->getType() == m_valueRange.getType() &&
104 entry->getValueRange().intersects(m_valueRange);
105 }
106
107 private:
108 ConstValueRangeAccess m_valueRange;
109 };
110
111 class IsWritableSupersetEntry : public IsWritableEntry
112 {
113 public:
114 typedef ValueEntryIterator<IsWritableSupersetEntry> Iterator;
115
IsWritableSupersetEntry(ConstValueRangeAccess valueRange)116 IsWritableSupersetEntry (ConstValueRangeAccess valueRange)
117 : m_valueRange(valueRange)
118 {
119 }
120
operator ()(const ValueEntry * entry) const121 bool operator() (const ValueEntry* entry) const
122 {
123 return IsWritableEntry()(entry) &&
124 entry->getVariable()->getType() == m_valueRange.getType() &&
125 entry->getValueRange().isSupersetOf(m_valueRange);
126 }
127
128 private:
129 ConstValueRangeAccess m_valueRange;
130 };
131
132 class IsSamplerEntry
133 {
134 public:
135 typedef ValueEntryIterator<IsSamplerEntry> Iterator;
136
IsSamplerEntry(VariableType::Type type)137 IsSamplerEntry (VariableType::Type type)
138 : m_type(type)
139 {
140 DE_ASSERT(m_type == VariableType::TYPE_SAMPLER_2D || m_type == VariableType::TYPE_SAMPLER_CUBE);
141 }
142
operator ()(const ValueEntry * entry) const143 bool operator() (const ValueEntry* entry) const
144 {
145 if (entry->getVariable()->getType() == VariableType(m_type, 1))
146 {
147 DE_ASSERT(entry->getVariable()->getStorage() == Variable::STORAGE_UNIFORM);
148 return true;
149 }
150 else
151 return false;
152 }
153
154 private:
155 VariableType::Type m_type;
156 };
157
getWeightedBool(de::Random & random,float trueWeight)158 inline bool getWeightedBool (de::Random& random, float trueWeight)
159 {
160 DE_ASSERT(de::inRange<float>(trueWeight, 0.0f, 1.0f));
161 return (random.getFloat() < trueWeight);
162 }
163
computeRandomValueRangeForInfElements(GeneratorState & state,ValueRangeAccess valueRange)164 void computeRandomValueRangeForInfElements (GeneratorState& state, ValueRangeAccess valueRange)
165 {
166 const VariableType& type = valueRange.getType();
167 de::Random& rnd = state.getRandom();
168
169 switch (type.getBaseType())
170 {
171 case VariableType::TYPE_BOOL:
172 // No need to handle bool as it will be false, true
173 break;
174
175 case VariableType::TYPE_INT:
176 for (int ndx = 0; ndx < type.getNumElements(); ndx++)
177 {
178 if (valueRange.getMin().component(ndx).asScalar() != Scalar::min<int>() ||
179 valueRange.getMax().component(ndx).asScalar() != Scalar::max<int>())
180 continue;
181
182 const int minIntVal = -16;
183 const int maxIntVal = 16;
184 const int maxRangeLen = maxIntVal - minIntVal;
185
186 int rangeLen = rnd.getInt(0, maxRangeLen);
187 int minVal = minIntVal + rnd.getInt(0, maxRangeLen-rangeLen);
188 int maxVal = minVal + rangeLen;
189
190 valueRange.getMin().component(ndx).asInt() = minVal;
191 valueRange.getMax().component(ndx).asInt() = maxVal;
192 }
193 break;
194
195 case VariableType::TYPE_FLOAT:
196 for (int ndx = 0; ndx < type.getNumElements(); ndx++)
197 {
198 if (valueRange.getMin().component(ndx).asScalar() != Scalar::min<float>() ||
199 valueRange.getMax().component(ndx).asScalar() != Scalar::max<float>())
200 continue;
201
202 const float step = 0.1f;
203 const int maxSteps = 320;
204 const float minFloatVal = -16.0f;
205
206 int rangeLen = rnd.getInt(0, maxSteps);
207 int minStep = rnd.getInt(0, maxSteps-rangeLen);
208
209 float minVal = minFloatVal + step*(float)minStep;
210 float maxVal = minVal + step*(float)rangeLen;
211
212 valueRange.getMin().component(ndx).asFloat() = minVal;
213 valueRange.getMax().component(ndx).asFloat() = maxVal;
214 }
215 break;
216
217 default:
218 DE_ASSERT(DE_FALSE);
219 throw Exception("computeRandomValueRangeForInfElements(): unsupported type");
220 }
221 }
222
setInfiniteRange(ValueRangeAccess valueRange)223 void setInfiniteRange (ValueRangeAccess valueRange)
224 {
225 const VariableType& type = valueRange.getType();
226
227 switch (type.getBaseType())
228 {
229 case VariableType::TYPE_BOOL:
230 for (int ndx = 0; ndx < type.getNumElements(); ndx++)
231 {
232 valueRange.getMin().component(ndx) = Scalar::min<bool>();
233 valueRange.getMax().component(ndx) = Scalar::max<bool>();
234 }
235 break;
236
237 case VariableType::TYPE_INT:
238 for (int ndx = 0; ndx < type.getNumElements(); ndx++)
239 {
240 valueRange.getMin().component(ndx) = Scalar::min<int>();
241 valueRange.getMax().component(ndx) = Scalar::max<int>();
242 }
243 break;
244
245 case VariableType::TYPE_FLOAT:
246 for (int ndx = 0; ndx < type.getNumElements(); ndx++)
247 {
248 valueRange.getMin().component(ndx) = Scalar::min<float>();
249 valueRange.getMax().component(ndx) = Scalar::max<float>();
250 }
251 break;
252
253 default:
254 DE_ASSERT(DE_FALSE);
255 throw Exception("setInfiniteRange(): unsupported type");
256 }
257 }
258
canAllocateVariable(const GeneratorState & state,const VariableType & type)259 bool canAllocateVariable (const GeneratorState& state, const VariableType& type)
260 {
261 DE_ASSERT(!type.isVoid());
262
263 if (state.getExpressionFlags() & NO_VAR_ALLOCATION)
264 return false;
265
266 if (state.getVariableManager().getNumAllocatedScalars() + type.getScalarSize() > state.getShaderParameters().maxCombinedVariableScalars)
267 return false;
268
269 return true;
270 }
271
getWeight(const GeneratorState & state,ConstValueRangeAccess valueRange)272 template <class T> float getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange) { return T::getWeight(state, valueRange); }
create(GeneratorState & state,ConstValueRangeAccess valueRange)273 template <class T> Expression* create (GeneratorState& state, ConstValueRangeAccess valueRange) { return new T(state, valueRange); }
274
275 struct ExpressionSpec
276 {
277 float (*getWeight) (const GeneratorState& state, ConstValueRangeAccess valueRange);
278 Expression* (*create) (GeneratorState& state, ConstValueRangeAccess valueRange);
279 };
280
281 static const ExpressionSpec s_expressionSpecs[] =
282 {
283 { getWeight<FloatLiteral>, create<FloatLiteral> },
284 { getWeight<IntLiteral>, create<IntLiteral> },
285 { getWeight<BoolLiteral>, create<BoolLiteral> },
286 { getWeight<ConstructorOp>, create<ConstructorOp> },
287 { getWeight<AssignOp>, create<AssignOp> },
288 { getWeight<VariableRead>, create<VariableRead> },
289 { getWeight<MulOp>, create<MulOp> },
290 { getWeight<AddOp>, create<AddOp> },
291 { getWeight<SubOp>, create<SubOp> },
292 { getWeight<LessThanOp>, create<LessThanOp> },
293 { getWeight<LessOrEqualOp>, create<LessOrEqualOp> },
294 { getWeight<GreaterThanOp>, create<GreaterThanOp> },
295 { getWeight<GreaterOrEqualOp>, create<GreaterOrEqualOp> },
296 { getWeight<EqualOp>, create<EqualOp> },
297 { getWeight<NotEqualOp>, create<NotEqualOp> },
298 { getWeight<SwizzleOp>, create<SwizzleOp> },
299 { getWeight<SinOp>, create<SinOp> },
300 { getWeight<CosOp>, create<CosOp> },
301 { getWeight<TanOp>, create<TanOp> },
302 { getWeight<AsinOp>, create<AsinOp> },
303 { getWeight<AcosOp>, create<AcosOp> },
304 { getWeight<AtanOp>, create<AtanOp> },
305 { getWeight<ExpOp>, create<ExpOp> },
306 { getWeight<LogOp>, create<LogOp> },
307 { getWeight<Exp2Op>, create<Exp2Op> },
308 { getWeight<Log2Op>, create<Log2Op> },
309 { getWeight<SqrtOp>, create<SqrtOp> },
310 { getWeight<InvSqrtOp>, create<InvSqrtOp> },
311 { getWeight<ParenOp>, create<ParenOp> },
312 { getWeight<TexLookup>, create<TexLookup> }
313 };
314
315 static const ExpressionSpec s_lvalueSpecs[] =
316 {
317 { getWeight<VariableWrite>, create<VariableWrite> }
318 };
319
320 #if !defined(DE_MAX)
321 # define DE_MAX(a, b) ((b) > (a) ? (b) : (a))
322 #endif
323
324 enum
325 {
326 MAX_EXPRESSION_SPECS = (int)DE_MAX(DE_LENGTH_OF_ARRAY(s_expressionSpecs), DE_LENGTH_OF_ARRAY(s_lvalueSpecs))
327 };
328
chooseExpression(GeneratorState & state,const ExpressionSpec * specs,int numSpecs,ConstValueRangeAccess valueRange)329 const ExpressionSpec* chooseExpression (GeneratorState& state, const ExpressionSpec* specs, int numSpecs, ConstValueRangeAccess valueRange)
330 {
331 float weights[MAX_EXPRESSION_SPECS];
332
333 DE_ASSERT(numSpecs <= (int)DE_LENGTH_OF_ARRAY(weights));
334
335 // Compute weights
336 for (int ndx = 0; ndx < numSpecs; ndx++)
337 weights[ndx] = specs[ndx].getWeight(state, valueRange);
338
339 // Choose
340 return &state.getRandom().chooseWeighted<const ExpressionSpec&>(specs, specs+numSpecs, weights);
341 }
342
343 } // anonymous
344
~Expression(void)345 Expression::~Expression (void)
346 {
347 }
348
createRandom(GeneratorState & state,ConstValueRangeAccess valueRange)349 Expression* Expression::createRandom (GeneratorState& state, ConstValueRangeAccess valueRange)
350 {
351 return chooseExpression(state, s_expressionSpecs, (int)DE_LENGTH_OF_ARRAY(s_expressionSpecs), valueRange)->create(state, valueRange);
352 }
353
createRandomLValue(GeneratorState & state,ConstValueRangeAccess valueRange)354 Expression* Expression::createRandomLValue (GeneratorState& state, ConstValueRangeAccess valueRange)
355 {
356 return chooseExpression(state, s_lvalueSpecs, (int)DE_LENGTH_OF_ARRAY(s_lvalueSpecs), valueRange)->create(state, valueRange);
357 }
358
FloatLiteral(GeneratorState & state,ConstValueRangeAccess valueRange)359 FloatLiteral::FloatLiteral (GeneratorState& state, ConstValueRangeAccess valueRange)
360 : m_value(VariableType::getScalarType(VariableType::TYPE_FLOAT))
361 {
362 float minVal = -10.0f;
363 float maxVal = +10.0f;
364 float step = 0.25f;
365
366 if (valueRange.getType() == VariableType(VariableType::TYPE_FLOAT, 1))
367 {
368 minVal = valueRange.getMin().component(0).asFloat();
369 maxVal = valueRange.getMax().component(0).asFloat();
370
371 if (Scalar::min<float>() == minVal)
372 minVal = -10.0f;
373
374 if (Scalar::max<float>() == maxVal)
375 maxVal = +10.0f;
376 }
377
378 int numSteps = (int)((maxVal-minVal)/step) + 1;
379
380 const float value = deFloatClamp(minVal + step*(float)state.getRandom().getInt(0, numSteps), minVal, maxVal);
381 ExecValueAccess access = m_value.getValue(VariableType::getScalarType(VariableType::TYPE_FLOAT));
382
383 for (int ndx = 0; ndx < EXEC_VEC_WIDTH; ndx++)
384 access.asFloat(ndx) = value;
385 }
386
getWeight(const GeneratorState & state,ConstValueRangeAccess valueRange)387 float FloatLiteral::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
388 {
389 DE_UNREF(state);
390 const VariableType& type = valueRange.getType();
391 if (type == VariableType(VariableType::TYPE_FLOAT, 1))
392 {
393 float minVal = valueRange.getMin().asFloat();
394 float maxVal = valueRange.getMax().asFloat();
395
396 if (Scalar::min<float>() == minVal && Scalar::max<float>() == maxVal)
397 return 0.1f;
398
399 // Weight based on value range length
400 float rangeLength = maxVal - minVal;
401
402 DE_ASSERT(rangeLength >= 0.0f);
403 return deFloatMax(0.1f, 1.0f - rangeLength);
404 }
405 else if (type.isVoid())
406 return unusedValueWeight;
407 else
408 return 0.0f;
409 }
410
tokenize(GeneratorState & state,TokenStream & str) const411 void FloatLiteral::tokenize (GeneratorState& state, TokenStream& str) const
412 {
413 DE_UNREF(state);
414 str << Token(m_value.getValue(VariableType::getScalarType(VariableType::TYPE_FLOAT)).asFloat(0));
415 }
416
IntLiteral(GeneratorState & state,ConstValueRangeAccess valueRange)417 IntLiteral::IntLiteral (GeneratorState& state, ConstValueRangeAccess valueRange)
418 : m_value(VariableType::getScalarType(VariableType::TYPE_INT))
419 {
420 int minVal = -16;
421 int maxVal = +16;
422
423 if (valueRange.getType() == VariableType(VariableType::TYPE_INT, 1))
424 {
425 minVal = valueRange.getMin().component(0).asInt();
426 maxVal = valueRange.getMax().component(0).asInt();
427
428 if (Scalar::min<int>() == minVal)
429 minVal = -16;
430
431 if (Scalar::max<int>() == maxVal)
432 maxVal = 16;
433 }
434
435 int value = state.getRandom().getInt(minVal, maxVal);
436 ExecValueAccess access = m_value.getValue(VariableType::getScalarType(VariableType::TYPE_INT));
437
438 for (int ndx = 0; ndx < EXEC_VEC_WIDTH; ndx++)
439 access.asInt(ndx) = value;
440 }
441
getWeight(const GeneratorState & state,ConstValueRangeAccess valueRange)442 float IntLiteral::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
443 {
444 DE_UNREF(state);
445 const VariableType& type = valueRange.getType();
446 if (type == VariableType(VariableType::TYPE_INT, 1))
447 {
448 int minVal = valueRange.getMin().asInt();
449 int maxVal = valueRange.getMax().asInt();
450
451 if (Scalar::min<int>() == minVal && Scalar::max<int>() == maxVal)
452 return 0.1f;
453
454 int rangeLength = maxVal - minVal;
455
456 DE_ASSERT(rangeLength >= 0);
457 return deFloatMax(0.1f, 1.0f - (float)rangeLength/4.0f);
458 }
459 else if (type.isVoid())
460 return unusedValueWeight;
461 else
462 return 0.0f;
463 }
464
tokenize(GeneratorState & state,TokenStream & str) const465 void IntLiteral::tokenize (GeneratorState& state, TokenStream& str) const
466 {
467 DE_UNREF(state);
468 str << Token(m_value.getValue(VariableType::getScalarType(VariableType::TYPE_INT)).asInt(0));
469 }
470
BoolLiteral(GeneratorState & state,ConstValueRangeAccess valueRange)471 BoolLiteral::BoolLiteral (GeneratorState& state, ConstValueRangeAccess valueRange)
472 : m_value(VariableType::getScalarType(VariableType::TYPE_BOOL))
473 {
474 int minVal = 0;
475 int maxVal = 1;
476
477 if (valueRange.getType() == VariableType(VariableType::TYPE_BOOL, 1))
478 {
479 minVal = valueRange.getMin().component(0).asBool() ? 1 : 0;
480 maxVal = valueRange.getMax().component(0).asBool() ? 1 : 0;
481 }
482
483 bool value = state.getRandom().getInt(minVal, maxVal) == 1;
484 ExecValueAccess access = m_value.getValue(VariableType::getScalarType(VariableType::TYPE_BOOL));
485
486 for (int ndx = 0; ndx < EXEC_VEC_WIDTH; ndx++)
487 access.asBool(ndx) = value;
488 }
489
getWeight(const GeneratorState & state,ConstValueRangeAccess valueRange)490 float BoolLiteral::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
491 {
492 DE_UNREF(state);
493 const VariableType& type = valueRange.getType();
494 if (type == VariableType(VariableType::TYPE_BOOL, 1))
495 return 0.5f;
496 else if (type.isVoid())
497 return unusedValueWeight;
498 else
499 return 0.0f;
500 }
501
tokenize(GeneratorState & state,TokenStream & str) const502 void BoolLiteral::tokenize (GeneratorState& state, TokenStream& str) const
503 {
504 DE_UNREF(state);
505 str << Token(m_value.getValue(VariableType::getScalarType(VariableType::TYPE_BOOL)).asBool(0));
506 }
507
508 namespace
509 {
510
511 // \note int-bool and float-bool conversions handled in a special way.
512 template <typename SrcType, typename DstType>
convert(SrcType src)513 inline DstType convert (SrcType src)
514 {
515 if (Scalar::min<SrcType>() == src)
516 return Scalar::min<DstType>().template as<DstType>();
517 else if (Scalar::max<SrcType>() == src)
518 return Scalar::max<DstType>().template as<DstType>();
519 else
520 return DstType(src);
521 }
522
523 // According to GLSL ES spec.
convert(float src)524 template <> inline bool convert<float, bool> (float src) { return src != 0.0f; }
convert(int src)525 template <> inline bool convert<int, bool> (int src) { return src != 0; }
convert(bool src)526 template <> inline bool convert<bool, bool> (bool src) { return src; }
convert(bool src)527 template <> inline float convert<bool, float> (bool src) { return src ? 1.0f : 0.0f; }
convert(bool src)528 template <> inline int convert<bool, int> (bool src) { return src ? 1 : 0; }
529
convert(float src)530 template <> inline int convert<float, int> (float src)
531 {
532 if (Scalar::min<float>() == src)
533 return Scalar::min<int>().as<int>();
534 else if (Scalar::max<float>() == src)
535 return Scalar::max<int>().as<int>();
536 else if (src > 0.0f)
537 return (int)deFloatFloor(src);
538 else
539 return (int)deFloatCeil(src);
540 }
541
542 template <typename SrcType, typename DstType>
convertValueRange(SrcType srcMin,SrcType srcMax,DstType & dstMin,DstType & dstMax)543 inline void convertValueRange (SrcType srcMin, SrcType srcMax, DstType& dstMin, DstType& dstMax)
544 {
545 dstMin = convert<SrcType, DstType>(srcMin);
546 dstMax = convert<SrcType, DstType>(srcMax);
547 }
548
549 template <>
convertValueRange(float srcMin,float srcMax,int & dstMin,int & dstMax)550 inline void convertValueRange<float, int> (float srcMin, float srcMax, int& dstMin, int& dstMax)
551 {
552 if (Scalar::min<float>() == srcMin)
553 dstMin = Scalar::min<int>().as<int>();
554 else
555 dstMin = (int)deFloatCeil(srcMin);
556
557 if (Scalar::max<float>() == srcMax)
558 dstMax = Scalar::max<int>().as<int>();
559 else
560 dstMax = (int)deFloatFloor(srcMax);
561 }
562
563 template <>
convertValueRange(float srcMin,float srcMax,bool & dstMin,bool & dstMax)564 inline void convertValueRange<float, bool> (float srcMin, float srcMax, bool& dstMin, bool& dstMax)
565 {
566 dstMin = srcMin > 0.0f;
567 dstMax = srcMax > 0.0f;
568 }
569
570 // \todo [pyry] More special cases?
571
572 // Returns whether it is possible to convert some SrcType value range to given DstType valueRange
573 template <typename SrcType, typename DstType>
isConversionOk(DstType min,DstType max)574 bool isConversionOk (DstType min, DstType max)
575 {
576 SrcType sMin, sMax;
577 convertValueRange(min, max, sMin, sMax);
578 return sMin <= sMax &&
579 de::inRange(convert<SrcType, DstType>(sMin), min, max) &&
580 de::inRange(convert<SrcType, DstType>(sMax), min, max);
581 }
582
583 // Work-around for non-deterministic float behavior
isConversionOk(float,float)584 template <> bool isConversionOk<float, float> (float, float) { return true; }
585
586 // \todo [2011-03-26 pyry] Provide this in ValueAccess?
587 template <typename T> T getValueAccessValue (ConstValueAccess access);
getValueAccessValue(ConstValueAccess access)588 template<> inline float getValueAccessValue<float> (ConstValueAccess access) { return access.asFloat(); }
getValueAccessValue(ConstValueAccess access)589 template<> inline int getValueAccessValue<int> (ConstValueAccess access) { return access.asInt(); }
getValueAccessValue(ConstValueAccess access)590 template<> inline bool getValueAccessValue<bool> (ConstValueAccess access) { return access.asBool(); }
591
592 template <typename T> T& getValueAccessValue (ValueAccess access);
getValueAccessValue(ValueAccess access)593 template<> inline float& getValueAccessValue<float> (ValueAccess access) { return access.asFloat(); }
getValueAccessValue(ValueAccess access)594 template<> inline int& getValueAccessValue<int> (ValueAccess access) { return access.asInt(); }
getValueAccessValue(ValueAccess access)595 template<> inline bool& getValueAccessValue<bool> (ValueAccess access) { return access.asBool(); }
596
597 template <typename SrcType, typename DstType>
isConversionOk(ConstValueRangeAccess valueRange)598 bool isConversionOk (ConstValueRangeAccess valueRange)
599 {
600 return isConversionOk<SrcType>(getValueAccessValue<DstType>(valueRange.getMin()), getValueAccessValue<DstType>(valueRange.getMax()));
601 }
602
603 template <typename SrcType, typename DstType>
convertValueRangeTempl(ConstValueRangeAccess src,ValueRangeAccess dst)604 void convertValueRangeTempl (ConstValueRangeAccess src, ValueRangeAccess dst)
605 {
606 DstType dMin, dMax;
607 convertValueRange(getValueAccessValue<SrcType>(src.getMin()), getValueAccessValue<SrcType>(src.getMax()), dMin, dMax);
608 getValueAccessValue<DstType>(dst.getMin()) = dMin;
609 getValueAccessValue<DstType>(dst.getMax()) = dMax;
610 }
611
612 template <typename SrcType, typename DstType>
convertExecValueTempl(ExecConstValueAccess src,ExecValueAccess dst)613 void convertExecValueTempl (ExecConstValueAccess src, ExecValueAccess dst)
614 {
615 for (int ndx = 0; ndx < EXEC_VEC_WIDTH; ndx++)
616 dst.as<DstType>(ndx) = convert<SrcType, DstType>(src.as<SrcType>(ndx));
617 }
618
619 typedef bool (*IsConversionOkFunc) (ConstValueRangeAccess);
620 typedef void (*ConvertValueRangeFunc) (ConstValueRangeAccess, ValueRangeAccess);
621 typedef void (*ConvertExecValueFunc) (ExecConstValueAccess, ExecValueAccess);
622
getBaseTypeConvNdx(VariableType::Type type)623 inline int getBaseTypeConvNdx (VariableType::Type type)
624 {
625 switch (type)
626 {
627 case VariableType::TYPE_FLOAT: return 0;
628 case VariableType::TYPE_INT: return 1;
629 case VariableType::TYPE_BOOL: return 2;
630 default: return -1;
631 }
632 }
633
isConversionOk(VariableType::Type srcType,VariableType::Type dstType,ConstValueRangeAccess valueRange)634 bool isConversionOk (VariableType::Type srcType, VariableType::Type dstType, ConstValueRangeAccess valueRange)
635 {
636 // [src][dst]
637 static const IsConversionOkFunc convTable[3][3] =
638 {
639 { isConversionOk<float, float>, isConversionOk<float, int>, isConversionOk<float, bool> },
640 { isConversionOk<int, float>, isConversionOk<int, int>, isConversionOk<int, bool> },
641 { isConversionOk<bool, float>, isConversionOk<bool, int>, isConversionOk<bool, bool> }
642 };
643 return convTable[getBaseTypeConvNdx(srcType)][getBaseTypeConvNdx(dstType)](valueRange);
644 }
645
convertValueRange(ConstValueRangeAccess src,ValueRangeAccess dst)646 void convertValueRange (ConstValueRangeAccess src, ValueRangeAccess dst)
647 {
648 // [src][dst]
649 static const ConvertValueRangeFunc convTable[3][3] =
650 {
651 { convertValueRangeTempl<float, float>, convertValueRangeTempl<float, int>, convertValueRangeTempl<float, bool> },
652 { convertValueRangeTempl<int, float>, convertValueRangeTempl<int, int>, convertValueRangeTempl<int, bool> },
653 { convertValueRangeTempl<bool, float>, convertValueRangeTempl<bool, int>, convertValueRangeTempl<bool, bool> }
654 };
655
656 convTable[getBaseTypeConvNdx(src.getType().getBaseType())][getBaseTypeConvNdx(dst.getType().getBaseType())](src, dst);
657 }
658
convertExecValue(ExecConstValueAccess src,ExecValueAccess dst)659 void convertExecValue (ExecConstValueAccess src, ExecValueAccess dst)
660 {
661 // [src][dst]
662 static const ConvertExecValueFunc convTable[3][3] =
663 {
664 { convertExecValueTempl<float, float>, convertExecValueTempl<float, int>, convertExecValueTempl<float, bool> },
665 { convertExecValueTempl<int, float>, convertExecValueTempl<int, int>, convertExecValueTempl<int, bool> },
666 { convertExecValueTempl<bool, float>, convertExecValueTempl<bool, int>, convertExecValueTempl<bool, bool> }
667 };
668
669 convTable[getBaseTypeConvNdx(src.getType().getBaseType())][getBaseTypeConvNdx(dst.getType().getBaseType())](src, dst);
670 }
671
672 } // anonymous
673
ConstructorOp(GeneratorState & state,ConstValueRangeAccess valueRange)674 ConstructorOp::ConstructorOp (GeneratorState& state, ConstValueRangeAccess valueRange)
675 : m_valueRange(valueRange)
676 {
677 if (valueRange.getType().isVoid())
678 {
679 // Use random range
680 const int maxScalars = 4; // We don't have to be able to assign this value to anywhere
681 m_valueRange = ValueRange(computeRandomType(state, maxScalars));
682 computeRandomValueRange(state, m_valueRange.asAccess());
683 }
684
685 // \todo [2011-03-26 pyry] Vector conversions
686 // int remainingDepth = state.getShaderParameters().maxExpressionDepth - state.getExpressionDepth();
687
688 const VariableType& type = m_valueRange.getType();
689 VariableType::Type baseType = type.getBaseType();
690 int numScalars = type.getNumElements();
691 int curScalarNdx = 0;
692
693 // \todo [2011-03-26 pyry] Separate op for struct constructors!
694 DE_ASSERT(type.isFloatOrVec() || type.isIntOrVec() || type.isBoolOrVec());
695
696 bool scalarConversions = state.getProgramParameters().useScalarConversions;
697
698 while (curScalarNdx < numScalars)
699 {
700 ConstValueRangeAccess comp = m_valueRange.asAccess().component(curScalarNdx);
701
702 if (scalarConversions)
703 {
704 int numInTypes = 0;
705 VariableType::Type inTypes[3];
706
707 if (isConversionOk(VariableType::TYPE_FLOAT, baseType, comp)) inTypes[numInTypes++] = VariableType::TYPE_FLOAT;
708 if (isConversionOk(VariableType::TYPE_INT, baseType, comp)) inTypes[numInTypes++] = VariableType::TYPE_INT;
709 if (isConversionOk(VariableType::TYPE_BOOL, baseType, comp)) inTypes[numInTypes++] = VariableType::TYPE_BOOL;
710
711 DE_ASSERT(numInTypes > 0); // At least nop conversion should be ok
712
713 // Choose random
714 VariableType::Type inType = state.getRandom().choose<VariableType::Type>(&inTypes[0], &inTypes[0] + numInTypes);
715
716 // Compute converted value range
717 ValueRange inValueRange(VariableType(inType, 1));
718 convertValueRange(comp, inValueRange);
719 m_inputValueRanges.push_back(inValueRange);
720
721 curScalarNdx += 1;
722 }
723 else
724 {
725 m_inputValueRanges.push_back(ValueRange(comp));
726 curScalarNdx += 1;
727 }
728 }
729 }
730
~ConstructorOp(void)731 ConstructorOp::~ConstructorOp (void)
732 {
733 for (vector<Expression*>::iterator i = m_inputExpressions.begin(); i != m_inputExpressions.end(); i++)
734 delete *i;
735 }
736
createNextChild(GeneratorState & state)737 Expression* ConstructorOp::createNextChild (GeneratorState& state)
738 {
739 int numChildren = (int)m_inputExpressions.size();
740 Expression* child = DE_NULL;
741
742 // \note Created in reverse order!
743 if (numChildren < (int)m_inputValueRanges.size())
744 {
745 const ValueRange& inValueRange = m_inputValueRanges[m_inputValueRanges.size()-1-numChildren];
746 child = Expression::createRandom(state, inValueRange);
747 try
748 {
749 m_inputExpressions.push_back(child);
750 }
751 catch (const std::exception&)
752 {
753 delete child;
754 throw;
755 }
756 }
757
758 return child;
759 }
760
getWeight(const GeneratorState & state,ConstValueRangeAccess valueRange)761 float ConstructorOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
762 {
763 if (valueRange.getType().isVoid())
764 return unusedValueWeight;
765
766 if (!valueRange.getType().isFloatOrVec() && !valueRange.getType().isIntOrVec() && !valueRange.getType().isBoolOrVec())
767 return 0.0f;
768
769 if (state.getExpressionDepth() + getTypeConstructorDepth(valueRange.getType()) > state.getShaderParameters().maxExpressionDepth)
770 return 0.0f;
771
772 return 1.0f;
773 }
774
tokenize(GeneratorState & state,TokenStream & str) const775 void ConstructorOp::tokenize (GeneratorState& state, TokenStream& str) const
776 {
777 const VariableType& type = m_valueRange.getType();
778 DE_ASSERT(type.getPrecision() == VariableType::PRECISION_NONE);
779 type.tokenizeShortType(str);
780
781 str << Token::LEFT_PAREN;
782
783 for (vector<Expression*>::const_reverse_iterator i = m_inputExpressions.rbegin(); i != m_inputExpressions.rend(); i++)
784 {
785 if (i != m_inputExpressions.rbegin())
786 str << Token::COMMA;
787 (*i)->tokenize(state, str);
788 }
789
790 str << Token::RIGHT_PAREN;
791 }
792
evaluate(ExecutionContext & evalCtx)793 void ConstructorOp::evaluate (ExecutionContext& evalCtx)
794 {
795 // Evaluate children
796 for (vector<Expression*>::reverse_iterator i = m_inputExpressions.rbegin(); i != m_inputExpressions.rend(); i++)
797 (*i)->evaluate(evalCtx);
798
799 // Compute value
800 const VariableType& type = m_valueRange.getType();
801 m_value.setStorage(type);
802
803 ExecValueAccess dst = m_value.getValue(type);
804 int curScalarNdx = 0;
805
806 for (vector<Expression*>::reverse_iterator i = m_inputExpressions.rbegin(); i != m_inputExpressions.rend(); i++)
807 {
808 ExecConstValueAccess src = (*i)->getValue();
809
810 for (int elemNdx = 0; elemNdx < src.getType().getNumElements(); elemNdx++)
811 convertExecValue(src.component(elemNdx), dst.component(curScalarNdx++));
812 }
813 }
814
AssignOp(GeneratorState & state,ConstValueRangeAccess valueRange)815 AssignOp::AssignOp (GeneratorState& state, ConstValueRangeAccess valueRange)
816 : m_valueRange (valueRange)
817 , m_lvalueExpr (DE_NULL)
818 , m_rvalueExpr (DE_NULL)
819 {
820 if (m_valueRange.getType().isVoid())
821 {
822 // Compute random value range
823 int maxScalars = state.getShaderParameters().maxCombinedVariableScalars - state.getVariableManager().getNumAllocatedScalars();
824 bool useRandomRange = !state.getVariableManager().hasEntry<IsWritableEntry>() || ((maxScalars > 0) && getWeightedBool(state.getRandom(), 0.1f));
825
826 if (useRandomRange)
827 {
828 DE_ASSERT(maxScalars > 0);
829 m_valueRange = ValueRange(computeRandomType(state, maxScalars));
830 computeRandomValueRange(state, m_valueRange.asAccess());
831 }
832 else
833 {
834 // Use value range from random entry
835 // \todo [2011-02-28 pyry] Give lower weight to entries without range? Choose subtype range?
836 const ValueEntry* entry = state.getRandom().choose<const ValueEntry*>(state.getVariableManager().getBegin<IsWritableEntry>(), state.getVariableManager().getEnd<IsWritableEntry>());
837 m_valueRange = ValueRange(entry->getValueRange());
838
839 computeRandomValueRangeForInfElements(state, m_valueRange.asAccess());
840
841 DE_ASSERT(state.getVariableManager().hasEntry(IsWritableIntersectingEntry(m_valueRange.asAccess())));
842 }
843 }
844
845 IsWritableIntersectingEntry::Iterator first = state.getVariableManager().getBegin(IsWritableIntersectingEntry(m_valueRange.asAccess()));
846 IsWritableIntersectingEntry::Iterator end = state.getVariableManager().getEnd(IsWritableIntersectingEntry(m_valueRange.asAccess()));
847
848 bool possiblyCreateVar = canAllocateVariable(state, m_valueRange.getType()) &&
849 (first == end || getWeightedBool(state.getRandom(), 0.5f));
850
851 if (!possiblyCreateVar)
852 {
853 // Find all possible valueranges matching given type and intersecting with valuerange
854 // \todo [pyry] Actually collect all ValueRanges, currently operates only on whole variables
855 DE_ASSERT(first != end);
856
857 // Try to select one closest to given range but bigger (eg. superset)
858 bool supersetExists = false;
859 for (IsWritableIntersectingEntry::Iterator i = first; i != end; i++)
860 {
861 if ((*i)->getValueRange().isSupersetOf(m_valueRange.asAccess()))
862 {
863 supersetExists = true;
864 break;
865 }
866 }
867
868 if (!supersetExists)
869 {
870 // Select some other range and compute intersection
871 // \todo [2011-02-03 pyry] Use some heuristics to select the range?
872 ConstValueRangeAccess selectedRange = state.getRandom().choose<const ValueEntry*>(first, end)->getValueRange();
873
874 ValueRange::computeIntersection(m_valueRange.asAccess(), m_valueRange.asAccess(), selectedRange);
875 }
876 }
877 }
878
~AssignOp(void)879 AssignOp::~AssignOp (void)
880 {
881 delete m_lvalueExpr;
882 delete m_rvalueExpr;
883 }
884
getWeight(const GeneratorState & state,ConstValueRangeAccess valueRange)885 float AssignOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
886 {
887 if (!valueRange.getType().isVoid() &&
888 !canAllocateVariable(state, valueRange.getType()) &&
889 !state.getVariableManager().hasEntry(IsWritableIntersectingEntry(valueRange)))
890 return 0.0f; // Would require creating a new variable
891
892 if (!valueRange.getType().isVoid() && state.getExpressionDepth() + getTypeConstructorDepth(valueRange.getType()) + 1 >= state.getShaderParameters().maxExpressionDepth)
893 return 0.0f;
894
895 if (valueRange.getType().isVoid() &&
896 !state.getVariableManager().hasEntry<IsWritableEntry>() &&
897 state.getVariableManager().getNumAllocatedScalars() >= state.getShaderParameters().maxCombinedVariableScalars)
898 return 0.0f; // Can not allocate a new entry
899
900 if (state.getExpressionDepth() == 0)
901 return 4.0f;
902 else
903 return 0.0f; // \todo [pyry] Fix assign ops
904 }
905
createNextChild(GeneratorState & state)906 Expression* AssignOp::createNextChild (GeneratorState& state)
907 {
908 if (m_lvalueExpr == DE_NULL)
909 {
910 // Construct lvalue
911 // \todo [2011-03-14 pyry] Proper l-value generation:
912 // - pure L-value part is generated first
913 // - variable valuerange is made unbound
914 // - R-value is generated
915 // - R-values in L-value are generated
916 m_lvalueExpr = Expression::createRandomLValue(state, m_valueRange.asAccess());
917 return m_lvalueExpr;
918 }
919 else if (m_rvalueExpr == DE_NULL)
920 {
921 // Construct value expr
922 m_rvalueExpr = Expression::createRandom(state, m_valueRange.asAccess());
923 return m_rvalueExpr;
924 }
925 else
926 return DE_NULL;
927 }
928
tokenize(GeneratorState & state,TokenStream & str) const929 void AssignOp::tokenize (GeneratorState& state, TokenStream& str) const
930 {
931 m_lvalueExpr->tokenize(state, str);
932 str << Token::EQUAL;
933 m_rvalueExpr->tokenize(state, str);
934 }
935
evaluate(ExecutionContext & evalCtx)936 void AssignOp::evaluate (ExecutionContext& evalCtx)
937 {
938 // Evaluate l-value
939 m_lvalueExpr->evaluate(evalCtx);
940
941 // Evaluate value
942 m_rvalueExpr->evaluate(evalCtx);
943 m_value.setStorage(m_valueRange.getType());
944 m_value.getValue(m_valueRange.getType()) = m_rvalueExpr->getValue().value();
945
946 // Assign
947 assignMasked(m_lvalueExpr->getLValue(), m_value.getValue(m_valueRange.getType()), evalCtx.getExecutionMask());
948 }
949
950 namespace
951 {
952
isShaderInOutSupportedType(const VariableType & type)953 inline bool isShaderInOutSupportedType (const VariableType& type)
954 {
955 // \todo [2011-03-11 pyry] Float arrays, structs?
956 return type.getBaseType() == VariableType::TYPE_FLOAT;
957 }
958
allocateNewVariable(GeneratorState & state,ConstValueRangeAccess valueRange)959 Variable* allocateNewVariable (GeneratorState& state, ConstValueRangeAccess valueRange)
960 {
961 Variable* variable = state.getVariableManager().allocate(valueRange.getType());
962
963 // Update value range
964 state.getVariableManager().setValue(variable, valueRange);
965
966 // Random storage \todo [pyry] Check that scalar count in uniform/input classes is not exceeded
967 static const Variable::Storage storages[] =
968 {
969 Variable::STORAGE_CONST,
970 Variable::STORAGE_UNIFORM,
971 Variable::STORAGE_LOCAL,
972 Variable::STORAGE_SHADER_IN
973 };
974 float weights[DE_LENGTH_OF_ARRAY(storages)];
975
976 // Dynamic vs. constant weight.
977 float dynWeight = computeDynamicRangeWeight(valueRange);
978 int numScalars = valueRange.getType().getScalarSize();
979 bool uniformOk = state.getVariableManager().getNumAllocatedUniformScalars() + numScalars <= state.getShaderParameters().maxUniformScalars;
980 bool shaderInOk = isShaderInOutSupportedType(valueRange.getType()) &&
981 (state.getVariableManager().getNumAllocatedShaderInVariables() + NUM_RESERVED_SHADER_INPUTS < state.getShaderParameters().maxInputVariables);
982
983 weights[0] = de::max(1.0f-dynWeight, 0.1f);
984 weights[1] = uniformOk ? dynWeight*0.5f : 0.0f;
985 weights[2] = dynWeight;
986 weights[3] = shaderInOk ? dynWeight*2.0f : 0.0f;
987
988 state.getVariableManager().setStorage(variable, state.getRandom().chooseWeighted<Variable::Storage>(&storages[0], &storages[DE_LENGTH_OF_ARRAY(storages)], &weights[0]));
989
990 return variable;
991 }
992
combineWeight(float curCombinedWeight,float partialWeight)993 inline float combineWeight (float curCombinedWeight, float partialWeight)
994 {
995 return curCombinedWeight * partialWeight;
996 }
997
computeEntryReadWeight(ConstValueRangeAccess entryValueRange,ConstValueRangeAccess readValueRange)998 float computeEntryReadWeight (ConstValueRangeAccess entryValueRange, ConstValueRangeAccess readValueRange)
999 {
1000 const VariableType& type = entryValueRange.getType();
1001 DE_ASSERT(type == readValueRange.getType());
1002
1003 float weight = 1.0f;
1004
1005 switch (type.getBaseType())
1006 {
1007 case VariableType::TYPE_FLOAT:
1008 {
1009 for (int elemNdx = 0; elemNdx < type.getNumElements(); elemNdx++)
1010 {
1011 float entryMin = entryValueRange.component(elemNdx).getMin().asFloat();
1012 float entryMax = entryValueRange.component(elemNdx).getMax().asFloat();
1013 float readMin = readValueRange.component(elemNdx).getMin().asFloat();
1014 float readMax = readValueRange.component(elemNdx).getMax().asFloat();
1015
1016 // Check for -inf..inf ranges - they don't bring down the weight.
1017 if (Scalar::min<float>() == entryMin && Scalar::max<float>() == entryMax)
1018 continue;
1019
1020 // Intersection to entry value range length ratio.
1021 float intersectionMin = deFloatMax(entryMin, readMin);
1022 float intersectionMax = deFloatMin(entryMax, readMax);
1023 float entryRangeLen = entryMax - entryMin;
1024 float readRangeLen = readMax - readMin;
1025 float intersectionLen = intersectionMax - intersectionMin;
1026 float entryRatio = (entryRangeLen > 0.0f) ? (intersectionLen / entryRangeLen) : 1.0f;
1027 float readRatio = (readRangeLen > 0.0f) ? (intersectionLen / readRangeLen) : 1.0f;
1028 float elementWeight = 0.5f*readRatio + 0.5f*entryRatio;
1029
1030 weight = combineWeight(weight, elementWeight);
1031 }
1032 break;
1033 }
1034
1035 case VariableType::TYPE_INT:
1036 {
1037 for (int elemNdx = 0; elemNdx < type.getNumElements(); elemNdx++)
1038 {
1039 int entryMin = entryValueRange.component(elemNdx).getMin().asInt();
1040 int entryMax = entryValueRange.component(elemNdx).getMax().asInt();
1041 int readMin = readValueRange.component(elemNdx).getMin().asInt();
1042 int readMax = readValueRange.component(elemNdx).getMax().asInt();
1043
1044 // Check for -inf..inf ranges - they don't bring down the weight.
1045 if (Scalar::min<int>() == entryMin && Scalar::max<int>() == entryMax)
1046 continue;
1047
1048 // Intersection to entry value range length ratio.
1049 int intersectionMin = deMax32(entryMin, readMin);
1050 int intersectionMax = deMin32(entryMax, readMax);
1051 deInt64 entryRangeLen = (deInt64)entryMax - (deInt64)entryMin;
1052 deInt64 readRangeLen = (deInt64)readMax - (deInt64)readMin;
1053 deInt64 intersectionLen = (deInt64)intersectionMax - (deInt64)intersectionMin;
1054 float entryRatio = (entryRangeLen > 0) ? ((float)intersectionLen / (float)entryRangeLen) : 1.0f;
1055 float readRatio = (readRangeLen > 0) ? ((float)intersectionLen / (float)readRangeLen) : 1.0f;
1056 float elementWeight = 0.5f*readRatio + 0.5f*entryRatio;
1057
1058 weight = combineWeight(weight, elementWeight);
1059 }
1060 break;
1061 }
1062
1063 case VariableType::TYPE_BOOL:
1064 {
1065 // \todo
1066 break;
1067 }
1068
1069
1070 case VariableType::TYPE_ARRAY:
1071 case VariableType::TYPE_STRUCT:
1072
1073 default:
1074 TCU_FAIL("Unsupported type");
1075 }
1076
1077 return deFloatMax(weight, 0.01f);
1078 }
1079
1080 } // anonymous
1081
VariableRead(GeneratorState & state,ConstValueRangeAccess valueRange)1082 VariableRead::VariableRead (GeneratorState& state, ConstValueRangeAccess valueRange)
1083 {
1084 if (valueRange.getType().isVoid())
1085 {
1086 IsReadableEntry filter = IsReadableEntry(state.getExpressionFlags());
1087 int maxScalars = state.getShaderParameters().maxCombinedVariableScalars - state.getVariableManager().getNumAllocatedScalars();
1088 bool useRandomRange = !state.getVariableManager().hasEntry(filter) || ((maxScalars > 0) && getWeightedBool(state.getRandom(), 0.5f));
1089
1090 if (useRandomRange)
1091 {
1092 // Allocate a new variable
1093 DE_ASSERT(maxScalars > 0);
1094 ValueRange newVarRange(computeRandomType(state, maxScalars));
1095 computeRandomValueRange(state, newVarRange.asAccess());
1096
1097 m_variable = allocateNewVariable(state, newVarRange.asAccess());
1098 }
1099 else
1100 {
1101 // Use random entry \todo [pyry] Handle -inf..inf ranges?
1102 m_variable = state.getRandom().choose<const ValueEntry*>(state.getVariableManager().getBegin(filter), state.getVariableManager().getEnd(filter))->getVariable();
1103 }
1104 }
1105 else
1106 {
1107 // Find variable that has value range that intersects with given range
1108 IsReadableIntersectingEntry::Iterator first = state.getVariableManager().getBegin(IsReadableIntersectingEntry(valueRange, state.getExpressionFlags()));
1109 IsReadableIntersectingEntry::Iterator end = state.getVariableManager().getEnd(IsReadableIntersectingEntry(valueRange, state.getExpressionFlags()));
1110
1111 const float createOnReadWeight = 0.5f;
1112 bool createVar = canAllocateVariable(state, valueRange.getType()) && (first == end || getWeightedBool(state.getRandom(), createOnReadWeight));
1113
1114 if (createVar)
1115 {
1116 m_variable = allocateNewVariable(state, valueRange);
1117 }
1118 else
1119 {
1120 // Copy value entries for computing weights.
1121 std::vector<const ValueEntry*> availableVars;
1122 std::vector<float> weights;
1123
1124 std::copy(first, end, std::inserter(availableVars, availableVars.begin()));
1125
1126 // Compute weights.
1127 weights.resize(availableVars.size());
1128 for (int ndx = 0; ndx < (int)availableVars.size(); ndx++)
1129 weights[ndx] = computeEntryReadWeight(availableVars[ndx]->getValueRange(), valueRange);
1130
1131 // Select.
1132 const ValueEntry* entry = state.getRandom().chooseWeighted<const ValueEntry*>(availableVars.begin(), availableVars.end(), weights.begin());
1133 m_variable = entry->getVariable();
1134
1135 // Compute intersection
1136 ValueRange intersection(m_variable->getType());
1137 ValueRange::computeIntersection(intersection, entry->getValueRange(), valueRange);
1138 state.getVariableManager().setValue(m_variable, intersection.asAccess());
1139 }
1140 }
1141 }
1142
VariableRead(const Variable * variable)1143 VariableRead::VariableRead (const Variable* variable)
1144 {
1145 m_variable = variable;
1146 }
1147
getWeight(const GeneratorState & state,ConstValueRangeAccess valueRange)1148 float VariableRead::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
1149 {
1150 if (valueRange.getType().isVoid())
1151 {
1152 if (state.getVariableManager().hasEntry(IsReadableEntry(state.getExpressionFlags())) ||
1153 state.getVariableManager().getNumAllocatedScalars() < state.getShaderParameters().maxCombinedVariableScalars)
1154 return unusedValueWeight;
1155 else
1156 return 0.0f;
1157 }
1158
1159 if (!canAllocateVariable(state, valueRange.getType()) &&
1160 !state.getVariableManager().hasEntry(IsReadableIntersectingEntry(valueRange, state.getExpressionFlags())))
1161 return 0.0f;
1162 else
1163 return 1.0f;
1164 }
1165
VariableWrite(GeneratorState & state,ConstValueRangeAccess valueRange)1166 VariableWrite::VariableWrite (GeneratorState& state, ConstValueRangeAccess valueRange)
1167 {
1168 DE_ASSERT(!valueRange.getType().isVoid());
1169
1170 // Find variable with range that is superset of given range
1171 IsWritableSupersetEntry::Iterator first = state.getVariableManager().getBegin(IsWritableSupersetEntry(valueRange));
1172 IsWritableSupersetEntry::Iterator end = state.getVariableManager().getEnd(IsWritableSupersetEntry(valueRange));
1173
1174 const float createOnAssignWeight = 0.1f; // Will essentially create an unused variable
1175 bool createVar = canAllocateVariable(state, valueRange.getType()) && (first == end || getWeightedBool(state.getRandom(), createOnAssignWeight));
1176
1177 if (createVar)
1178 {
1179 m_variable = state.getVariableManager().allocate(valueRange.getType());
1180 // \note Storage will be LOCAL
1181 }
1182 else
1183 {
1184 // Choose random
1185 DE_ASSERT(first != end);
1186 const ValueEntry* entry = state.getRandom().choose<const ValueEntry*>(first, end);
1187 m_variable = entry->getVariable();
1188 }
1189
1190 DE_ASSERT(m_variable);
1191
1192 // Reset value range.
1193 const ValueEntry* parentEntry = state.getVariableManager().getParentValue(m_variable);
1194 if (parentEntry)
1195 {
1196 // Use parent value range.
1197 state.getVariableManager().setValue(m_variable, parentEntry->getValueRange());
1198 }
1199 else
1200 {
1201 // Use infinite range.
1202 ValueRange infRange(m_variable->getType());
1203 setInfiniteRange(infRange);
1204
1205 state.getVariableManager().setValue(m_variable, infRange.asAccess());
1206 }
1207 }
1208
getWeight(const GeneratorState & state,ConstValueRangeAccess valueRange)1209 float VariableWrite::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
1210 {
1211 if (!canAllocateVariable(state, valueRange.getType()) &&
1212 !state.getVariableManager().hasEntry(IsWritableSupersetEntry(valueRange)))
1213 return 0.0f;
1214 else
1215 return 1.0f;
1216 }
1217
evaluate(ExecutionContext & evalCtx)1218 void VariableAccess::evaluate (ExecutionContext& evalCtx)
1219 {
1220 m_valueAccess = evalCtx.getValue(m_variable);
1221 }
1222
ParenOp(GeneratorState & state,ConstValueRangeAccess valueRange)1223 ParenOp::ParenOp (GeneratorState& state, ConstValueRangeAccess valueRange)
1224 : m_valueRange (valueRange)
1225 , m_child (DE_NULL)
1226 {
1227 DE_UNREF(state);
1228 }
1229
~ParenOp(void)1230 ParenOp::~ParenOp (void)
1231 {
1232 delete m_child;
1233 }
1234
createNextChild(GeneratorState & state)1235 Expression* ParenOp::createNextChild (GeneratorState& state)
1236 {
1237 if (m_child == DE_NULL)
1238 {
1239 m_child = Expression::createRandom(state, m_valueRange.asAccess());
1240 return m_child;
1241 }
1242 else
1243 return DE_NULL;
1244 }
1245
tokenize(GeneratorState & state,TokenStream & str) const1246 void ParenOp::tokenize (GeneratorState& state, TokenStream& str) const
1247 {
1248 str << Token::LEFT_PAREN;
1249 m_child->tokenize(state, str);
1250 str << Token::RIGHT_PAREN;
1251 }
1252
getWeight(const GeneratorState & state,ConstValueRangeAccess valueRange)1253 float ParenOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
1254 {
1255 if (valueRange.getType().isVoid())
1256 return state.getExpressionDepth() + 2 <= state.getShaderParameters().maxExpressionDepth ? unusedValueWeight : 0.0f;
1257 else
1258 {
1259 int requiredDepth = 1 + getConservativeValueExprDepth(state, valueRange);
1260 return state.getExpressionDepth() + requiredDepth <= state.getShaderParameters().maxExpressionDepth ? 1.0f : 0.0f;
1261 }
1262 }
1263
1264 const int swizzlePrecedence = 2;
1265
SwizzleOp(GeneratorState & state,ConstValueRangeAccess valueRange)1266 SwizzleOp::SwizzleOp (GeneratorState& state, ConstValueRangeAccess valueRange)
1267 : m_outValueRange (valueRange)
1268 , m_numInputElements (0)
1269 , m_child (DE_NULL)
1270 {
1271 DE_ASSERT(!m_outValueRange.getType().isVoid()); // \todo [2011-06-13 pyry] Void support
1272 DE_ASSERT(m_outValueRange.getType().isFloatOrVec() ||
1273 m_outValueRange.getType().isIntOrVec() ||
1274 m_outValueRange.getType().isBoolOrVec());
1275
1276 m_value.setStorage(m_outValueRange.getType());
1277
1278 int numOutputElements = m_outValueRange.getType().getNumElements();
1279
1280 // \note Swizzle works for vector types only.
1281 // \todo [2011-06-13 pyry] Use components multiple times.
1282 m_numInputElements = state.getRandom().getInt(deMax32(numOutputElements, 2), 4);
1283
1284 std::set<int> availableElements;
1285 for (int ndx = 0; ndx < m_numInputElements; ndx++)
1286 availableElements.insert(ndx);
1287
1288 // Randomize swizzle.
1289 for (int elemNdx = 0; elemNdx < (int)DE_LENGTH_OF_ARRAY(m_swizzle); elemNdx++)
1290 {
1291 if (elemNdx < numOutputElements)
1292 {
1293 int inElemNdx = state.getRandom().choose<int>(availableElements.begin(), availableElements.end());
1294 availableElements.erase(inElemNdx);
1295 m_swizzle[elemNdx] = (deUint8)inElemNdx;
1296 }
1297 else
1298 m_swizzle[elemNdx] = 0;
1299 }
1300 }
1301
~SwizzleOp(void)1302 SwizzleOp::~SwizzleOp (void)
1303 {
1304 delete m_child;
1305 }
1306
createNextChild(GeneratorState & state)1307 Expression* SwizzleOp::createNextChild (GeneratorState& state)
1308 {
1309 if (m_child)
1310 return DE_NULL;
1311
1312 // Compute input value range.
1313 VariableType inVarType = VariableType(m_outValueRange.getType().getBaseType(), m_numInputElements);
1314 ValueRange inValueRange = ValueRange(inVarType);
1315
1316 // Initialize all inputs to -inf..inf
1317 setInfiniteRange(inValueRange);
1318
1319 // Compute intersections.
1320 int numOutputElements = m_outValueRange.getType().getNumElements();
1321 for (int outElemNdx = 0; outElemNdx < numOutputElements; outElemNdx++)
1322 {
1323 int inElemNdx = m_swizzle[outElemNdx];
1324 ValueRange::computeIntersection(inValueRange.asAccess().component(inElemNdx), inValueRange.asAccess().component(inElemNdx), m_outValueRange.asAccess().component(outElemNdx));
1325 }
1326
1327 // Create child.
1328 state.pushPrecedence(swizzlePrecedence);
1329 m_child = Expression::createRandom(state, inValueRange.asAccess());
1330 state.popPrecedence();
1331
1332 return m_child;
1333 }
1334
tokenize(GeneratorState & state,TokenStream & str) const1335 void SwizzleOp::tokenize (GeneratorState& state, TokenStream& str) const
1336 {
1337 const char* rgbaSet[] = { "r", "g", "b", "a" };
1338 const char* xyzwSet[] = { "x", "y", "z", "w" };
1339 const char* stpqSet[] = { "s", "t", "p", "q" };
1340 const char** swizzleSet = DE_NULL;
1341
1342 switch (state.getRandom().getInt(0, 2))
1343 {
1344 case 0: swizzleSet = rgbaSet; break;
1345 case 1: swizzleSet = xyzwSet; break;
1346 case 2: swizzleSet = stpqSet; break;
1347 default: DE_ASSERT(DE_FALSE);
1348 }
1349
1350 std::string swizzleStr;
1351 for (int elemNdx = 0; elemNdx < m_outValueRange.getType().getNumElements(); elemNdx++)
1352 swizzleStr += swizzleSet[m_swizzle[elemNdx]];
1353
1354 m_child->tokenize(state, str);
1355 str << Token::DOT << Token(swizzleStr.c_str());
1356 }
1357
getWeight(const GeneratorState & state,ConstValueRangeAccess valueRange)1358 float SwizzleOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
1359 {
1360 if (!state.getProgramParameters().useSwizzle)
1361 return 0.0f;
1362
1363 if (state.getPrecedence() < swizzlePrecedence)
1364 return 0.0f;
1365
1366 if (!valueRange.getType().isFloatOrVec() &&
1367 !valueRange.getType().isIntOrVec() &&
1368 !valueRange.getType().isBoolOrVec())
1369 return 0.0f;
1370
1371 int availableLevels = state.getShaderParameters().maxExpressionDepth - state.getExpressionDepth();
1372
1373 // Swizzle + Constructor + Values
1374 if (availableLevels < 3)
1375 return 0.0f;
1376
1377 return 1.0f;
1378 }
1379
evaluate(ExecutionContext & execCtx)1380 void SwizzleOp::evaluate (ExecutionContext& execCtx)
1381 {
1382 m_child->evaluate(execCtx);
1383
1384 ExecConstValueAccess inValue = m_child->getValue();
1385 ExecValueAccess outValue = m_value.getValue(m_outValueRange.getType());
1386
1387 for (int outElemNdx = 0; outElemNdx < outValue.getType().getNumElements(); outElemNdx++)
1388 {
1389 int inElemNdx = m_swizzle[outElemNdx];
1390 outValue.component(outElemNdx) = inValue.component(inElemNdx).value();
1391 }
1392 }
1393
countSamplers(const VariableManager & varManager,VariableType::Type samplerType)1394 static int countSamplers (const VariableManager& varManager, VariableType::Type samplerType)
1395 {
1396 int numSamplers = 0;
1397
1398 IsSamplerEntry::Iterator i = varManager.getBegin(IsSamplerEntry(samplerType));
1399 IsSamplerEntry::Iterator end = varManager.getEnd(IsSamplerEntry(samplerType));
1400
1401 for (; i != end; i++)
1402 numSamplers += 1;
1403
1404 return numSamplers;
1405 }
1406
TexLookup(GeneratorState & state,ConstValueRangeAccess valueRange)1407 TexLookup::TexLookup (GeneratorState& state, ConstValueRangeAccess valueRange)
1408 : m_type (TYPE_LAST)
1409 , m_coordExpr (DE_NULL)
1410 , m_lodBiasExpr (DE_NULL)
1411 , m_valueType (VariableType::TYPE_FLOAT, 4)
1412 , m_value (m_valueType)
1413 {
1414 DE_ASSERT(valueRange.getType() == VariableType(VariableType::TYPE_FLOAT, 4));
1415 DE_UNREF(valueRange); // Texture output value range is constant.
1416
1417 // Select type.
1418 vector<Type> typeCandidates;
1419 if (state.getShaderParameters().useTexture2D)
1420 {
1421 typeCandidates.push_back(TYPE_TEXTURE2D);
1422 typeCandidates.push_back(TYPE_TEXTURE2D_LOD);
1423 typeCandidates.push_back(TYPE_TEXTURE2D_PROJ);
1424 typeCandidates.push_back(TYPE_TEXTURE2D_PROJ_LOD);
1425 }
1426
1427 if (state.getShaderParameters().useTextureCube)
1428 {
1429 typeCandidates.push_back(TYPE_TEXTURECUBE);
1430 typeCandidates.push_back(TYPE_TEXTURECUBE_LOD);
1431 }
1432
1433 m_type = state.getRandom().choose<Type>(typeCandidates.begin(), typeCandidates.end());
1434
1435 // Select or allocate sampler.
1436 VariableType::Type samplerType = VariableType::TYPE_LAST;
1437 switch (m_type)
1438 {
1439 case TYPE_TEXTURE2D:
1440 case TYPE_TEXTURE2D_LOD:
1441 case TYPE_TEXTURE2D_PROJ:
1442 case TYPE_TEXTURE2D_PROJ_LOD:
1443 samplerType = VariableType::TYPE_SAMPLER_2D;
1444 break;
1445
1446 case TYPE_TEXTURECUBE:
1447 case TYPE_TEXTURECUBE_LOD:
1448 samplerType = VariableType::TYPE_SAMPLER_CUBE;
1449 break;
1450
1451 default:
1452 DE_ASSERT(DE_FALSE);
1453 }
1454
1455 int sampler2DCount = countSamplers(state.getVariableManager(), VariableType::TYPE_SAMPLER_2D);
1456 int samplerCubeCount = countSamplers(state.getVariableManager(), VariableType::TYPE_SAMPLER_CUBE);
1457 bool canAllocSampler = sampler2DCount + samplerCubeCount < state.getShaderParameters().maxSamplers;
1458 bool hasSampler = samplerType == VariableType::TYPE_SAMPLER_2D ? (sampler2DCount > 0) : (samplerCubeCount > 0);
1459 bool allocSampler = !hasSampler || (canAllocSampler && state.getRandom().getBool());
1460
1461 if (allocSampler)
1462 {
1463 Variable* sampler = state.getVariableManager().allocate(VariableType(samplerType, 1));
1464 state.getVariableManager().setStorage(sampler, Variable::STORAGE_UNIFORM); // Samplers are always uniforms.
1465 m_sampler = sampler;
1466 }
1467 else
1468 m_sampler = state.getRandom().choose<const ValueEntry*>(state.getVariableManager().getBegin(IsSamplerEntry(samplerType)),
1469 state.getVariableManager().getEnd(IsSamplerEntry(samplerType)))->getVariable();
1470 }
1471
~TexLookup(void)1472 TexLookup::~TexLookup (void)
1473 {
1474 delete m_coordExpr;
1475 delete m_lodBiasExpr;
1476 }
1477
createNextChild(GeneratorState & state)1478 Expression* TexLookup::createNextChild (GeneratorState& state)
1479 {
1480 bool hasLodBias = m_type == TYPE_TEXTURE2D_LOD ||
1481 m_type == TYPE_TEXTURE2D_PROJ_LOD ||
1482 m_type == TYPE_TEXTURECUBE_LOD;
1483
1484 if (hasLodBias && !m_lodBiasExpr)
1485 {
1486 ValueRange lodRange(VariableType(VariableType::TYPE_FLOAT, 1));
1487 setInfiniteRange(lodRange); // Any value is valid.
1488
1489 m_lodBiasExpr = Expression::createRandom(state, lodRange.asAccess());
1490 return m_lodBiasExpr;
1491 }
1492
1493 if (!m_coordExpr)
1494 {
1495 if (m_type == TYPE_TEXTURECUBE || m_type == TYPE_TEXTURECUBE_LOD)
1496 {
1497 // Make sure major axis selection can be done.
1498 int majorAxisNdx = state.getRandom().getInt(0, 2);
1499
1500 ValueRange coordRange(VariableType(VariableType::TYPE_FLOAT, 3));
1501
1502 for (int ndx = 0; ndx < 3; ndx++)
1503 {
1504 if (ndx == majorAxisNdx)
1505 {
1506 bool neg = state.getRandom().getBool();
1507 coordRange.getMin().component(ndx) = neg ? -4.0f : 2.25f;
1508 coordRange.getMax().component(ndx) = neg ? -2.25f : 4.0f;
1509 }
1510 else
1511 {
1512 coordRange.getMin().component(ndx) = -2.0f;
1513 coordRange.getMax().component(ndx) = 2.0f;
1514 }
1515 }
1516
1517 m_coordExpr = Expression::createRandom(state, coordRange.asAccess());
1518 }
1519 else
1520 {
1521 bool isProj = m_type == TYPE_TEXTURE2D_PROJ || m_type == TYPE_TEXTURE2D_PROJ_LOD;
1522 int coordScalarSize = isProj ? 3 : 2;
1523
1524 ValueRange coordRange(VariableType(VariableType::TYPE_FLOAT, coordScalarSize));
1525 setInfiniteRange(coordRange); // Initialize base range with -inf..inf
1526
1527 if (isProj)
1528 {
1529 // w coordinate must be something sane, and not 0.
1530 bool neg = state.getRandom().getBool();
1531 coordRange.getMin().component(2) = neg ? -4.0f : 0.25f;
1532 coordRange.getMax().component(2) = neg ? -0.25f : 4.0f;
1533 }
1534
1535 m_coordExpr = Expression::createRandom(state, coordRange.asAccess());
1536 }
1537
1538 DE_ASSERT(m_coordExpr);
1539 return m_coordExpr;
1540 }
1541
1542 return DE_NULL; // Done.
1543 }
1544
tokenize(GeneratorState & state,TokenStream & str) const1545 void TexLookup::tokenize (GeneratorState& state, TokenStream& str) const
1546 {
1547 bool isVertex = state.getShader().getType() == Shader::TYPE_VERTEX;
1548
1549 if (state.getProgramParameters().version == VERSION_300)
1550 {
1551 switch (m_type)
1552 {
1553 case TYPE_TEXTURE2D: str << "texture"; break;
1554 case TYPE_TEXTURE2D_LOD: str << (isVertex ? "textureLod" : "texture"); break;
1555 case TYPE_TEXTURE2D_PROJ: str << "textureProj"; break;
1556 case TYPE_TEXTURE2D_PROJ_LOD: str << (isVertex ? "textureProjLod" : "textureProj"); break;
1557 case TYPE_TEXTURECUBE: str << "texture"; break;
1558 case TYPE_TEXTURECUBE_LOD: str << (isVertex ? "textureLod" : "texture"); break;
1559 default:
1560 DE_ASSERT(DE_FALSE);
1561 }
1562 }
1563 else
1564 {
1565 switch (m_type)
1566 {
1567 case TYPE_TEXTURE2D: str << "texture2D"; break;
1568 case TYPE_TEXTURE2D_LOD: str << (isVertex ? "texture2DLod" : "texture2D"); break;
1569 case TYPE_TEXTURE2D_PROJ: str << "texture2DProj"; break;
1570 case TYPE_TEXTURE2D_PROJ_LOD: str << (isVertex ? "texture2DProjLod" : "texture2DProj"); break;
1571 case TYPE_TEXTURECUBE: str << "textureCube"; break;
1572 case TYPE_TEXTURECUBE_LOD: str << (isVertex ? "textureCubeLod" : "textureCube"); break;
1573 default:
1574 DE_ASSERT(DE_FALSE);
1575 }
1576 }
1577
1578 str << Token::LEFT_PAREN;
1579 str << m_sampler->getName();
1580 str << Token::COMMA;
1581 m_coordExpr->tokenize(state, str);
1582
1583 if (m_lodBiasExpr)
1584 {
1585 str << Token::COMMA;
1586 m_lodBiasExpr->tokenize(state, str);
1587 }
1588
1589 str << Token::RIGHT_PAREN;
1590 }
1591
getWeight(const GeneratorState & state,ConstValueRangeAccess valueRange)1592 float TexLookup::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
1593 {
1594 if (state.getShaderParameters().texLookupBaseWeight <= 0.0f)
1595 return 0.0f;
1596
1597 int availableLevels = state.getShaderParameters().maxExpressionDepth - state.getExpressionDepth();
1598
1599 // Lookup + Constructor + Values
1600 if (availableLevels < 3)
1601 return 0.0f;
1602
1603 if (state.getExpressionFlags() & (CONST_EXPR|NO_VAR_ALLOCATION))
1604 return 0.0f;
1605
1606 if (valueRange.getType() != VariableType(VariableType::TYPE_FLOAT, 4))
1607 return 0.0f;
1608
1609 ValueRange texOutputRange(VariableType(VariableType::TYPE_FLOAT, 4));
1610 for (int ndx = 0; ndx < 4; ndx++)
1611 {
1612 texOutputRange.getMin().component(ndx) = 0.0f;
1613 texOutputRange.getMax().component(ndx) = 1.0f;
1614 }
1615
1616 if (!valueRange.isSupersetOf(texOutputRange.asAccess()))
1617 return 0.0f;
1618
1619 return state.getShaderParameters().texLookupBaseWeight;
1620 }
1621
evaluate(ExecutionContext & execCtx)1622 void TexLookup::evaluate (ExecutionContext& execCtx)
1623 {
1624 // Evaluate coord and bias.
1625 m_coordExpr->evaluate(execCtx);
1626 if (m_lodBiasExpr)
1627 m_lodBiasExpr->evaluate(execCtx);
1628
1629 ExecConstValueAccess coords = m_coordExpr->getValue();
1630 ExecValueAccess dst = m_value.getValue(m_valueType);
1631
1632 switch (m_type)
1633 {
1634 case TYPE_TEXTURE2D:
1635 {
1636 const Sampler2D& tex = execCtx.getSampler2D(m_sampler);
1637 for (int i = 0; i < EXEC_VEC_WIDTH; i++)
1638 {
1639 float s = coords.component(0).asFloat(i);
1640 float t = coords.component(1).asFloat(i);
1641 tcu::Vec4 p = tex.sample(s, t, 0.0f);
1642
1643 for (int comp = 0; comp < 4; comp++)
1644 dst.component(comp).asFloat(i) = p[comp];
1645 }
1646 break;
1647 }
1648
1649 case TYPE_TEXTURE2D_LOD:
1650 {
1651 ExecConstValueAccess lod = m_lodBiasExpr->getValue();
1652 const Sampler2D& tex = execCtx.getSampler2D(m_sampler);
1653 for (int i = 0; i < EXEC_VEC_WIDTH; i++)
1654 {
1655 float s = coords.component(0).asFloat(i);
1656 float t = coords.component(1).asFloat(i);
1657 float l = lod.component(0).asFloat(i);
1658 tcu::Vec4 p = tex.sample(s, t, l);
1659
1660 for (int comp = 0; comp < 4; comp++)
1661 dst.component(comp).asFloat(i) = p[comp];
1662 }
1663 break;
1664 }
1665
1666 case TYPE_TEXTURE2D_PROJ:
1667 {
1668 const Sampler2D& tex = execCtx.getSampler2D(m_sampler);
1669 for (int i = 0; i < EXEC_VEC_WIDTH; i++)
1670 {
1671 float s = coords.component(0).asFloat(i);
1672 float t = coords.component(1).asFloat(i);
1673 float w = coords.component(2).asFloat(i);
1674 tcu::Vec4 p = tex.sample(s/w, t/w, 0.0f);
1675
1676 for (int comp = 0; comp < 4; comp++)
1677 dst.component(comp).asFloat(i) = p[comp];
1678 }
1679 break;
1680 }
1681
1682 case TYPE_TEXTURE2D_PROJ_LOD:
1683 {
1684 ExecConstValueAccess lod = m_lodBiasExpr->getValue();
1685 const Sampler2D& tex = execCtx.getSampler2D(m_sampler);
1686 for (int i = 0; i < EXEC_VEC_WIDTH; i++)
1687 {
1688 float s = coords.component(0).asFloat(i);
1689 float t = coords.component(1).asFloat(i);
1690 float w = coords.component(2).asFloat(i);
1691 float l = lod.component(0).asFloat(i);
1692 tcu::Vec4 p = tex.sample(s/w, t/w, l);
1693
1694 for (int comp = 0; comp < 4; comp++)
1695 dst.component(comp).asFloat(i) = p[comp];
1696 }
1697 break;
1698 }
1699
1700 case TYPE_TEXTURECUBE:
1701 {
1702 const SamplerCube& tex = execCtx.getSamplerCube(m_sampler);
1703 for (int i = 0; i < EXEC_VEC_WIDTH; i++)
1704 {
1705 float s = coords.component(0).asFloat(i);
1706 float t = coords.component(1).asFloat(i);
1707 float r = coords.component(2).asFloat(i);
1708 tcu::Vec4 p = tex.sample(s, t, r, 0.0f);
1709
1710 for (int comp = 0; comp < 4; comp++)
1711 dst.component(comp).asFloat(i) = p[comp];
1712 }
1713 break;
1714 }
1715
1716 case TYPE_TEXTURECUBE_LOD:
1717 {
1718 ExecConstValueAccess lod = m_lodBiasExpr->getValue();
1719 const SamplerCube& tex = execCtx.getSamplerCube(m_sampler);
1720 for (int i = 0; i < EXEC_VEC_WIDTH; i++)
1721 {
1722 float s = coords.component(0).asFloat(i);
1723 float t = coords.component(1).asFloat(i);
1724 float r = coords.component(2).asFloat(i);
1725 float l = lod.component(0).asFloat(i);
1726 tcu::Vec4 p = tex.sample(s, t, r, l);
1727
1728 for (int comp = 0; comp < 4; comp++)
1729 dst.component(comp).asFloat(i) = p[comp];
1730 }
1731 break;
1732 }
1733
1734 default:
1735 DE_ASSERT(DE_FALSE);
1736 }
1737 }
1738
1739 } // rsg
1740