framework/randomshaders/rsgExpression.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 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
  44         IsReadableEntry (deUint32 exprFlags)
  45                 : m_exprFlags(exprFlags)
  46         {
  47         }
  48
  49         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
  66         IsReadableIntersectingEntry (ConstValueRangeAccess valueRange, deUint32 exprFlags)
  67                 : IsReadableEntry       (exprFlags)
  68                 , m_valueRange          (valueRange)
  69         {
  70         }
  71
  72         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
  95         IsWritableIntersectingEntry (ConstValueRangeAccess valueRange)
  96                 : m_valueRange(valueRange)
  97         {
  98         }
  99
 100         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
 116         IsWritableSupersetEntry (ConstValueRangeAccess valueRange)
 117                 : m_valueRange(valueRange)
 118         {
 119         }
 120
 121         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
 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
 143         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
 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
 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
 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
 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
 272 template <class T> float                getWeight       (const GeneratorState& state, ConstValueRangeAccess valueRange) { return T::getWeight(state, 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
 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
 345 Expression::~Expression (void)
 346 {
 347 }
 348
 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
 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
 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
 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
 411 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
 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
 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
 465 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
 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
 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
 502 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>
 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.
 524 template <> inline bool         convert<float, bool>    (float src)     { return src != 0.0f;                                   }
 525 template <> inline bool         convert<int, bool>              (int src)       { return src != 0;                                              }
 526 template <> inline bool         convert<bool, bool>             (bool src)      { return src;                                                   }
 527 template <> inline float        convert<bool, float>    (bool src)      { return src ? 1.0f : 0.0f;                             }
 528 template <> inline int          convert<bool, int>              (bool src)      { return src ? 1 : 0;                                   }
 529
 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>
 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 <>
 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 <>
 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>
 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
 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);
 588 template<>                              inline float    getValueAccessValue<float>      (ConstValueAccess access) { return access.asFloat();    }
 589 template<>                              inline int              getValueAccessValue<int>        (ConstValueAccess access) { return access.asInt();              }
 590 template<>                              inline bool             getValueAccessValue<bool>       (ConstValueAccess access) { return access.asBool();             }
 591
 592 template <typename T>   T&                              getValueAccessValue                     (ValueAccess access);
 593 template<>                              inline float&   getValueAccessValue<float>      (ValueAccess access) { return access.asFloat();         }
 594 template<>                              inline int&             getValueAccessValue<int>        (ValueAccess access) { return access.asInt();           }
 595 template<>                              inline bool&    getValueAccessValue<bool>       (ValueAccess access) { return access.asBool();          }
 596
 597 template <typename SrcType, typename DstType>
 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>
 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>
 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
 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
 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
 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
 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
 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
 731 ConstructorOp::~ConstructorOp (void)
 732 {
 733         for (vector<Expression*>::iterator i = m_inputExpressions.begin(); i != m_inputExpressions.end(); i++)
 734                 delete *i;
 735 }
 736
 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
 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
 775 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
 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
 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
 879 AssignOp::~AssignOp (void)
 880 {
 881         delete m_lvalueExpr;
 882         delete m_rvalueExpr;
 883 }
 884
 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
 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
 929 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
 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
 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
 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
 993 inline float combineWeight (float curCombinedWeight, float partialWeight)
 994 {
 995         return curCombinedWeight * partialWeight;
 996 }
 997
 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
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
1143 VariableRead::VariableRead (const Variable* variable)
1144 {
1145         m_variable = variable;
1146 }
1147
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
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
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
1218 void VariableAccess::evaluate (ExecutionContext& evalCtx)
1219 {
1220         m_valueAccess = evalCtx.getValue(m_variable);
1221 }
1222
1223 ParenOp::ParenOp (GeneratorState& state, ConstValueRangeAccess valueRange)
1224         : m_valueRange  (valueRange)
1225         , m_child               (DE_NULL)
1226 {
1227         DE_UNREF(state);
1228 }
1229
1230 ParenOp::~ParenOp (void)
1231 {
1232         delete m_child;
1233 }
1234
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
1246 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
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
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
1302 SwizzleOp::~SwizzleOp (void)
1303 {
1304         delete m_child;
1305 }
1306
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
1335 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
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
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
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
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
1472 TexLookup::~TexLookup (void)
1473 {
1474         delete m_coordExpr;
1475         delete m_lodBiasExpr;
1476 }
1477
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
1545 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
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
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