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 FloatLiteral::FloatLiteral (float customValue)
 388         : m_value(VariableType::getScalarType(VariableType::TYPE_FLOAT))
 389 {
 390         // This constructor is required to handle corner case in which comparision
 391         // of two same floats produced different results - this was resolved by
 392         // adding FloatLiteral containing epsilon to one of values
 393         ExecValueAccess access  = m_value.getValue(VariableType::getScalarType(VariableType::TYPE_FLOAT));
 394
 395         for (int ndx = 0; ndx < EXEC_VEC_WIDTH; ndx++)
 396                 access.asFloat(ndx) = customValue;
 397 }
 398
 399 float FloatLiteral::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 400 {
 401         DE_UNREF(state);
 402         const VariableType& type = valueRange.getType();
 403         if (type == VariableType(VariableType::TYPE_FLOAT, 1))
 404         {
 405                 float minVal = valueRange.getMin().asFloat();
 406                 float maxVal = valueRange.getMax().asFloat();
 407
 408                 if (Scalar::min<float>() == minVal && Scalar::max<float>() == maxVal)
 409                         return 0.1f;
 410
 411                 // Weight based on value range length
 412                 float rangeLength = maxVal - minVal;
 413
 414                 DE_ASSERT(rangeLength >= 0.0f);
 415                 return deFloatMax(0.1f, 1.0f - rangeLength);
 416         }
 417         else if (type.isVoid())
 418                 return unusedValueWeight;
 419         else
 420                 return 0.0f;
 421 }
 422
 423 void FloatLiteral::tokenize (GeneratorState& state, TokenStream& str) const
 424 {
 425         DE_UNREF(state);
 426         str << Token(m_value.getValue(VariableType::getScalarType(VariableType::TYPE_FLOAT)).asFloat(0));
 427 }
 428
 429 IntLiteral::IntLiteral (GeneratorState& state, ConstValueRangeAccess valueRange)
 430         : m_value(VariableType::getScalarType(VariableType::TYPE_INT))
 431 {
 432         int minVal = -16;
 433         int maxVal = +16;
 434
 435         if (valueRange.getType() == VariableType(VariableType::TYPE_INT, 1))
 436         {
 437                 minVal = valueRange.getMin().component(0).asInt();
 438                 maxVal = valueRange.getMax().component(0).asInt();
 439
 440                 if (Scalar::min<int>() == minVal)
 441                         minVal = -16;
 442
 443                 if (Scalar::max<int>() == maxVal)
 444                         maxVal = 16;
 445         }
 446
 447         int                             value   = state.getRandom().getInt(minVal, maxVal);
 448         ExecValueAccess access  = m_value.getValue(VariableType::getScalarType(VariableType::TYPE_INT));
 449
 450         for (int ndx = 0; ndx < EXEC_VEC_WIDTH; ndx++)
 451                 access.asInt(ndx) = value;
 452 }
 453
 454 float IntLiteral::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 455 {
 456         DE_UNREF(state);
 457         const VariableType& type = valueRange.getType();
 458         if (type == VariableType(VariableType::TYPE_INT, 1))
 459         {
 460                 int minVal = valueRange.getMin().asInt();
 461                 int maxVal = valueRange.getMax().asInt();
 462
 463                 if (Scalar::min<int>() == minVal && Scalar::max<int>() == maxVal)
 464                         return 0.1f;
 465
 466                 int rangeLength = maxVal - minVal;
 467
 468                 DE_ASSERT(rangeLength >= 0);
 469                 return deFloatMax(0.1f, 1.0f - (float)rangeLength/4.0f);
 470         }
 471         else if (type.isVoid())
 472                 return unusedValueWeight;
 473         else
 474                 return 0.0f;
 475 }
 476
 477 void IntLiteral::tokenize (GeneratorState& state, TokenStream& str) const
 478 {
 479         DE_UNREF(state);
 480         str << Token(m_value.getValue(VariableType::getScalarType(VariableType::TYPE_INT)).asInt(0));
 481 }
 482
 483 BoolLiteral::BoolLiteral (GeneratorState& state, ConstValueRangeAccess valueRange)
 484         : m_value(VariableType::getScalarType(VariableType::TYPE_BOOL))
 485 {
 486         int minVal = 0;
 487         int maxVal = 1;
 488
 489         if (valueRange.getType() == VariableType(VariableType::TYPE_BOOL, 1))
 490         {
 491                 minVal = valueRange.getMin().component(0).asBool() ? 1 : 0;
 492                 maxVal = valueRange.getMax().component(0).asBool() ? 1 : 0;
 493         }
 494
 495         bool                    value   = state.getRandom().getInt(minVal, maxVal) == 1;
 496         ExecValueAccess access  = m_value.getValue(VariableType::getScalarType(VariableType::TYPE_BOOL));
 497
 498         for (int ndx = 0; ndx < EXEC_VEC_WIDTH; ndx++)
 499                 access.asBool(ndx) = value;
 500 }
 501
 502 BoolLiteral::BoolLiteral (bool customValue)
 503         : m_value(VariableType::getScalarType(VariableType::TYPE_BOOL))
 504 {
 505         // This constructor is required to handle corner case in which comparision
 506         // of two same floats produced different results - this was resolved by
 507         // adding FloatLiteral containing epsilon to one of values
 508         ExecValueAccess access  = m_value.getValue(VariableType::getScalarType(VariableType::TYPE_BOOL));
 509
 510         for (int ndx = 0; ndx < EXEC_VEC_WIDTH; ndx++)
 511                 access.asBool(ndx) = customValue;
 512 }
 513
 514
 515 float BoolLiteral::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 516 {
 517         DE_UNREF(state);
 518         const VariableType& type = valueRange.getType();
 519         if (type == VariableType(VariableType::TYPE_BOOL, 1))
 520                 return 0.5f;
 521         else if (type.isVoid())
 522                 return unusedValueWeight;
 523         else
 524                 return 0.0f;
 525 }
 526
 527 void BoolLiteral::tokenize (GeneratorState& state, TokenStream& str) const
 528 {
 529         DE_UNREF(state);
 530         str << Token(m_value.getValue(VariableType::getScalarType(VariableType::TYPE_BOOL)).asBool(0));
 531 }
 532
 533 namespace
 534 {
 535
 536 // \note int-bool and float-bool conversions handled in a special way.
 537 template <typename SrcType, typename DstType>
 538 inline DstType convert (SrcType src)
 539 {
 540         if (Scalar::min<SrcType>() == src)
 541                 return Scalar::min<DstType>().template as<DstType>();
 542         else if (Scalar::max<SrcType>() == src)
 543                 return Scalar::max<DstType>().template as<DstType>();
 544         else
 545                 return DstType(src);
 546 }
 547
 548 // According to GLSL ES spec.
 549 template <> inline bool         convert<float, bool>    (float src)     { return src != 0.0f;                                   }
 550 template <> inline bool         convert<int, bool>              (int src)       { return src != 0;                                              }
 551 template <> inline bool         convert<bool, bool>             (bool src)      { return src;                                                   }
 552 template <> inline float        convert<bool, float>    (bool src)      { return src ? 1.0f : 0.0f;                             }
 553 template <> inline int          convert<bool, int>              (bool src)      { return src ? 1 : 0;                                   }
 554
 555 template <> inline int convert<float, int> (float src)
 556 {
 557         if (Scalar::min<float>() == src)
 558                 return Scalar::min<int>().as<int>();
 559         else if (Scalar::max<float>() == src)
 560                 return Scalar::max<int>().as<int>();
 561         else if (src > 0.0f)
 562                 return (int)deFloatFloor(src);
 563         else
 564                 return (int)deFloatCeil(src);
 565 }
 566
 567 template <typename SrcType, typename DstType>
 568 inline void convertValueRange (SrcType srcMin, SrcType srcMax, DstType& dstMin, DstType& dstMax)
 569 {
 570         dstMin = convert<SrcType, DstType>(srcMin);
 571         dstMax = convert<SrcType, DstType>(srcMax);
 572 }
 573
 574 template <>
 575 inline void convertValueRange<float, int> (float srcMin, float srcMax, int& dstMin, int& dstMax)
 576 {
 577         if (Scalar::min<float>() == srcMin)
 578                 dstMin = Scalar::min<int>().as<int>();
 579         else
 580                 dstMin = (int)deFloatCeil(srcMin);
 581
 582         if (Scalar::max<float>() == srcMax)
 583                 dstMax = Scalar::max<int>().as<int>();
 584         else
 585                 dstMax = (int)deFloatFloor(srcMax);
 586 }
 587
 588 template <>
 589 inline void convertValueRange<float, bool> (float srcMin, float srcMax, bool& dstMin, bool& dstMax)
 590 {
 591         dstMin = srcMin > 0.0f;
 592         dstMax = srcMax > 0.0f;
 593 }
 594
 595 // \todo [pyry] More special cases?
 596
 597 // Returns whether it is possible to convert some SrcType value range to given DstType valueRange
 598 template <typename SrcType, typename DstType>
 599 bool isConversionOk (DstType min, DstType max)
 600 {
 601         SrcType sMin, sMax;
 602         convertValueRange(min, max, sMin, sMax);
 603         return sMin <= sMax &&
 604                    de::inRange(convert<SrcType, DstType>(sMin), min, max) &&
 605                    de::inRange(convert<SrcType, DstType>(sMax), min, max);
 606 }
 607
 608 // Work-around for non-deterministic float behavior
 609 template <> bool isConversionOk<float, float> (float, float) { return true; }
 610
 611 // \todo [2011-03-26 pyry] Provide this in ValueAccess?
 612 template <typename T>   T                               getValueAccessValue                     (ConstValueAccess access);
 613 template<>                              inline float    getValueAccessValue<float>      (ConstValueAccess access) { return access.asFloat();    }
 614 template<>                              inline int              getValueAccessValue<int>        (ConstValueAccess access) { return access.asInt();              }
 615 template<>                              inline bool             getValueAccessValue<bool>       (ConstValueAccess access) { return access.asBool();             }
 616
 617 template <typename T>   T&                              getValueAccessValue                     (ValueAccess access);
 618 template<>                              inline float&   getValueAccessValue<float>      (ValueAccess access) { return access.asFloat();         }
 619 template<>                              inline int&             getValueAccessValue<int>        (ValueAccess access) { return access.asInt();           }
 620 template<>                              inline bool&    getValueAccessValue<bool>       (ValueAccess access) { return access.asBool();          }
 621
 622 template <typename SrcType, typename DstType>
 623 bool isConversionOk (ConstValueRangeAccess valueRange)
 624 {
 625         return isConversionOk<SrcType>(getValueAccessValue<DstType>(valueRange.getMin()), getValueAccessValue<DstType>(valueRange.getMax()));
 626 }
 627
 628 template <typename SrcType, typename DstType>
 629 void convertValueRangeTempl (ConstValueRangeAccess src, ValueRangeAccess dst)
 630 {
 631         DstType dMin, dMax;
 632         convertValueRange(getValueAccessValue<SrcType>(src.getMin()), getValueAccessValue<SrcType>(src.getMax()), dMin, dMax);
 633         getValueAccessValue<DstType>(dst.getMin()) = dMin;
 634         getValueAccessValue<DstType>(dst.getMax()) = dMax;
 635 }
 636
 637 template <typename SrcType, typename DstType>
 638 void convertExecValueTempl (ExecConstValueAccess src, ExecValueAccess dst)
 639 {
 640         for (int ndx = 0; ndx < EXEC_VEC_WIDTH; ndx++)
 641                 dst.as<DstType>(ndx) = convert<SrcType, DstType>(src.as<SrcType>(ndx));
 642 }
 643
 644 typedef bool (*IsConversionOkFunc)              (ConstValueRangeAccess);
 645 typedef void (*ConvertValueRangeFunc)   (ConstValueRangeAccess, ValueRangeAccess);
 646 typedef void (*ConvertExecValueFunc)    (ExecConstValueAccess, ExecValueAccess);
 647
 648 inline int getBaseTypeConvNdx (VariableType::Type type)
 649 {
 650         switch (type)
 651         {
 652                 case VariableType::TYPE_FLOAT:  return 0;
 653                 case VariableType::TYPE_INT:    return 1;
 654                 case VariableType::TYPE_BOOL:   return 2;
 655                 default:                                                return -1;
 656         }
 657 }
 658
 659 bool isConversionOk (VariableType::Type srcType, VariableType::Type dstType, ConstValueRangeAccess valueRange)
 660 {
 661         // [src][dst]
 662         static const IsConversionOkFunc convTable[3][3] =
 663         {
 664                 { isConversionOk<float, float>, isConversionOk<float,   int>,   isConversionOk<float,   bool>   },
 665                 { isConversionOk<int,   float>, isConversionOk<int,             int>,   isConversionOk<int,             bool>   },
 666                 { isConversionOk<bool,  float>, isConversionOk<bool,    int>,   isConversionOk<bool,    bool>   }
 667         };
 668         return convTable[getBaseTypeConvNdx(srcType)][getBaseTypeConvNdx(dstType)](valueRange);
 669 }
 670
 671 void convertValueRange (ConstValueRangeAccess src, ValueRangeAccess dst)
 672 {
 673         // [src][dst]
 674         static const ConvertValueRangeFunc convTable[3][3] =
 675         {
 676                 { convertValueRangeTempl<float, float>, convertValueRangeTempl<float,   int>,   convertValueRangeTempl<float,   bool>   },
 677                 { convertValueRangeTempl<int,   float>, convertValueRangeTempl<int,             int>,   convertValueRangeTempl<int,             bool>   },
 678                 { convertValueRangeTempl<bool,  float>, convertValueRangeTempl<bool,    int>,   convertValueRangeTempl<bool,    bool>   }
 679         };
 680
 681         convTable[getBaseTypeConvNdx(src.getType().getBaseType())][getBaseTypeConvNdx(dst.getType().getBaseType())](src, dst);
 682 }
 683
 684 void convertExecValue (ExecConstValueAccess src, ExecValueAccess dst)
 685 {
 686         // [src][dst]
 687         static const ConvertExecValueFunc convTable[3][3] =
 688         {
 689                 { convertExecValueTempl<float,  float>, convertExecValueTempl<float,    int>,   convertExecValueTempl<float,    bool>   },
 690                 { convertExecValueTempl<int,    float>, convertExecValueTempl<int,              int>,   convertExecValueTempl<int,              bool>   },
 691                 { convertExecValueTempl<bool,   float>, convertExecValueTempl<bool,             int>,   convertExecValueTempl<bool,             bool>   }
 692         };
 693
 694         convTable[getBaseTypeConvNdx(src.getType().getBaseType())][getBaseTypeConvNdx(dst.getType().getBaseType())](src, dst);
 695 }
 696
 697 } // anonymous
 698
 699 ConstructorOp::ConstructorOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 700         : m_valueRange(valueRange)
 701 {
 702         if (valueRange.getType().isVoid())
 703         {
 704                 // Use random range
 705                 const int maxScalars = 4; // We don't have to be able to assign this value to anywhere
 706                 m_valueRange = ValueRange(computeRandomType(state, maxScalars));
 707                 computeRandomValueRange(state, m_valueRange.asAccess());
 708         }
 709
 710         // \todo [2011-03-26 pyry] Vector conversions
 711 //      int                                             remainingDepth  = state.getShaderParameters().maxExpressionDepth - state.getExpressionDepth();
 712
 713         const VariableType&             type                    = m_valueRange.getType();
 714         VariableType::Type              baseType                = type.getBaseType();
 715         int                                             numScalars              = type.getNumElements();
 716         int                                             curScalarNdx    = 0;
 717
 718         // \todo [2011-03-26 pyry] Separate op for struct constructors!
 719         DE_ASSERT(type.isFloatOrVec() || type.isIntOrVec() || type.isBoolOrVec());
 720
 721         bool scalarConversions = state.getProgramParameters().useScalarConversions;
 722
 723         while (curScalarNdx < numScalars)
 724         {
 725                 ConstValueRangeAccess comp = m_valueRange.asAccess().component(curScalarNdx);
 726
 727                 if (scalarConversions)
 728                 {
 729                         int                                     numInTypes = 0;
 730                         VariableType::Type      inTypes[3];
 731
 732                         if (isConversionOk(VariableType::TYPE_FLOAT, baseType, comp))   inTypes[numInTypes++] = VariableType::TYPE_FLOAT;
 733                         if (isConversionOk(VariableType::TYPE_INT, baseType, comp))             inTypes[numInTypes++] = VariableType::TYPE_INT;
 734                         if (isConversionOk(VariableType::TYPE_BOOL, baseType, comp))    inTypes[numInTypes++] = VariableType::TYPE_BOOL;
 735
 736                         DE_ASSERT(numInTypes > 0); // At least nop conversion should be ok
 737
 738                         // Choose random
 739                         VariableType::Type inType = state.getRandom().choose<VariableType::Type>(&inTypes[0], &inTypes[0] + numInTypes);
 740
 741                         // Compute converted value range
 742                         ValueRange inValueRange(VariableType(inType, 1));
 743                         convertValueRange(comp, inValueRange);
 744                         m_inputValueRanges.push_back(inValueRange);
 745
 746                         curScalarNdx += 1;
 747                 }
 748                 else
 749                 {
 750                         m_inputValueRanges.push_back(ValueRange(comp));
 751                         curScalarNdx += 1;
 752                 }
 753         }
 754 }
 755
 756 ConstructorOp::~ConstructorOp (void)
 757 {
 758         for (vector<Expression*>::iterator i = m_inputExpressions.begin(); i != m_inputExpressions.end(); i++)
 759                 delete *i;
 760 }
 761
 762 Expression* ConstructorOp::createNextChild (GeneratorState& state)
 763 {
 764         int                                     numChildren     = (int)m_inputExpressions.size();
 765         Expression*                     child           = DE_NULL;
 766
 767         // \note Created in reverse order!
 768         if (numChildren < (int)m_inputValueRanges.size())
 769         {
 770                 const ValueRange& inValueRange = m_inputValueRanges[m_inputValueRanges.size()-1-numChildren];
 771                 child = Expression::createRandom(state, inValueRange);
 772                 try
 773                 {
 774                         m_inputExpressions.push_back(child);
 775                 }
 776                 catch (const std::exception&)
 777                 {
 778                         delete child;
 779                         throw;
 780                 }
 781         }
 782
 783         return child;
 784 }
 785
 786 float ConstructorOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 787 {
 788         if (valueRange.getType().isVoid())
 789                 return unusedValueWeight;
 790
 791         if (!valueRange.getType().isFloatOrVec() && !valueRange.getType().isIntOrVec() && !valueRange.getType().isBoolOrVec())
 792                 return 0.0f;
 793
 794         if (state.getExpressionDepth() + getTypeConstructorDepth(valueRange.getType()) > state.getShaderParameters().maxExpressionDepth)
 795                 return 0.0f;
 796
 797         return 1.0f;
 798 }
 799
 800 void ConstructorOp::tokenize (GeneratorState& state, TokenStream& str) const
 801 {
 802         const VariableType& type = m_valueRange.getType();
 803         DE_ASSERT(type.getPrecision() == VariableType::PRECISION_NONE);
 804         type.tokenizeShortType(str);
 805
 806         str << Token::LEFT_PAREN;
 807
 808         for (vector<Expression*>::const_reverse_iterator i = m_inputExpressions.rbegin(); i != m_inputExpressions.rend(); i++)
 809         {
 810                 if (i != m_inputExpressions.rbegin())
 811                         str << Token::COMMA;
 812                 (*i)->tokenize(state, str);
 813         }
 814
 815         str << Token::RIGHT_PAREN;
 816 }
 817
 818 void ConstructorOp::evaluate (ExecutionContext& evalCtx)
 819 {
 820         // Evaluate children
 821         for (vector<Expression*>::reverse_iterator i = m_inputExpressions.rbegin(); i != m_inputExpressions.rend(); i++)
 822                 (*i)->evaluate(evalCtx);
 823
 824         // Compute value
 825         const VariableType& type = m_valueRange.getType();
 826         m_value.setStorage(type);
 827
 828         ExecValueAccess dst                             = m_value.getValue(type);
 829         int                             curScalarNdx    = 0;
 830
 831         for (vector<Expression*>::reverse_iterator i = m_inputExpressions.rbegin(); i != m_inputExpressions.rend(); i++)
 832         {
 833                 ExecConstValueAccess src = (*i)->getValue();
 834
 835                 for (int elemNdx = 0; elemNdx < src.getType().getNumElements(); elemNdx++)
 836                         convertExecValue(src.component(elemNdx), dst.component(curScalarNdx++));
 837         }
 838 }
 839
 840 AssignOp::AssignOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 841         : m_valueRange  (valueRange)
 842         , m_lvalueExpr  (DE_NULL)
 843         , m_rvalueExpr  (DE_NULL)
 844 {
 845         if (m_valueRange.getType().isVoid())
 846         {
 847                 // Compute random value range
 848                 int             maxScalars              = state.getShaderParameters().maxCombinedVariableScalars - state.getVariableManager().getNumAllocatedScalars();
 849                 bool    useRandomRange  = !state.getVariableManager().hasEntry<IsWritableEntry>() || ((maxScalars > 0) && getWeightedBool(state.getRandom(), 0.1f));
 850
 851                 if (useRandomRange)
 852                 {
 853                         DE_ASSERT(maxScalars > 0);
 854                         m_valueRange = ValueRange(computeRandomType(state, maxScalars));
 855                         computeRandomValueRange(state, m_valueRange.asAccess());
 856                 }
 857                 else
 858                 {
 859                         // Use value range from random entry
 860                         // \todo [2011-02-28 pyry] Give lower weight to entries without range? Choose subtype range?
 861                         const ValueEntry* entry = state.getRandom().choose<const ValueEntry*>(state.getVariableManager().getBegin<IsWritableEntry>(), state.getVariableManager().getEnd<IsWritableEntry>());
 862                         m_valueRange = ValueRange(entry->getValueRange());
 863
 864                         computeRandomValueRangeForInfElements(state, m_valueRange.asAccess());
 865
 866                         DE_ASSERT(state.getVariableManager().hasEntry(IsWritableIntersectingEntry(m_valueRange.asAccess())));
 867                 }
 868         }
 869
 870         IsWritableIntersectingEntry::Iterator first     = state.getVariableManager().getBegin(IsWritableIntersectingEntry(m_valueRange.asAccess()));
 871         IsWritableIntersectingEntry::Iterator end       = state.getVariableManager().getEnd(IsWritableIntersectingEntry(m_valueRange.asAccess()));
 872
 873         bool possiblyCreateVar = canAllocateVariable(state, m_valueRange.getType()) &&
 874                                                          (first == end || getWeightedBool(state.getRandom(), 0.5f));
 875
 876         if (!possiblyCreateVar)
 877         {
 878                 // Find all possible valueranges matching given type and intersecting with valuerange
 879                 // \todo [pyry] Actually collect all ValueRanges, currently operates only on whole variables
 880                 DE_ASSERT(first != end);
 881
 882                 // Try to select one closest to given range but bigger (eg. superset)
 883                 bool supersetExists = false;
 884                 for (IsWritableIntersectingEntry::Iterator i = first; i != end; i++)
 885                 {
 886                         if ((*i)->getValueRange().isSupersetOf(m_valueRange.asAccess()))
 887                         {
 888                                 supersetExists = true;
 889                                 break;
 890                         }
 891                 }
 892
 893                 if (!supersetExists)
 894                 {
 895                         // Select some other range and compute intersection
 896                         // \todo [2011-02-03 pyry] Use some heuristics to select the range?
 897                         ConstValueRangeAccess selectedRange = state.getRandom().choose<const ValueEntry*>(first, end)->getValueRange();
 898
 899                         ValueRange::computeIntersection(m_valueRange.asAccess(), m_valueRange.asAccess(), selectedRange);
 900                 }
 901         }
 902 }
 903
 904 AssignOp::~AssignOp (void)
 905 {
 906         delete m_lvalueExpr;
 907         delete m_rvalueExpr;
 908 }
 909
 910 float AssignOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 911 {
 912         if (!valueRange.getType().isVoid() &&
 913                 !canAllocateVariable(state, valueRange.getType()) &&
 914                 !state.getVariableManager().hasEntry(IsWritableIntersectingEntry(valueRange)))
 915                 return 0.0f; // Would require creating a new variable
 916
 917         if (!valueRange.getType().isVoid() && state.getExpressionDepth() + getTypeConstructorDepth(valueRange.getType()) + 1 >= state.getShaderParameters().maxExpressionDepth)
 918                 return 0.0f;
 919
 920         if (valueRange.getType().isVoid() &&
 921                 !state.getVariableManager().hasEntry<IsWritableEntry>() &&
 922                 state.getVariableManager().getNumAllocatedScalars() >= state.getShaderParameters().maxCombinedVariableScalars)
 923                 return 0.0f; // Can not allocate a new entry
 924
 925         if (state.getExpressionDepth() == 0)
 926                 return 4.0f;
 927         else
 928                 return 0.0f; // \todo [pyry] Fix assign ops
 929 }
 930
 931 Expression* AssignOp::createNextChild (GeneratorState& state)
 932 {
 933         if (m_lvalueExpr == DE_NULL)
 934         {
 935                 // Construct lvalue
 936                 // \todo [2011-03-14 pyry] Proper l-value generation:
 937                 //  - pure L-value part is generated first
 938                 //  - variable valuerange is made unbound
 939                 //  - R-value is generated
 940                 //  - R-values in L-value are generated
 941                 m_lvalueExpr = Expression::createRandomLValue(state, m_valueRange.asAccess());
 942                 return m_lvalueExpr;
 943         }
 944         else if (m_rvalueExpr == DE_NULL)
 945         {
 946                 // Construct value expr
 947                 m_rvalueExpr = Expression::createRandom(state, m_valueRange.asAccess());
 948                 return m_rvalueExpr;
 949         }
 950         else
 951                 return DE_NULL;
 952 }
 953
 954 void AssignOp::tokenize (GeneratorState& state, TokenStream& str) const
 955 {
 956         m_lvalueExpr->tokenize(state, str);
 957         str << Token::EQUAL;
 958         m_rvalueExpr->tokenize(state, str);
 959 }
 960
 961 void AssignOp::evaluate (ExecutionContext& evalCtx)
 962 {
 963         // Evaluate l-value
 964         m_lvalueExpr->evaluate(evalCtx);
 965
 966         // Evaluate value
 967         m_rvalueExpr->evaluate(evalCtx);
 968         m_value.setStorage(m_valueRange.getType());
 969         m_value.getValue(m_valueRange.getType()) = m_rvalueExpr->getValue().value();
 970
 971         // Assign
 972         assignMasked(m_lvalueExpr->getLValue(), m_value.getValue(m_valueRange.getType()), evalCtx.getExecutionMask());
 973 }
 974
 975 namespace
 976 {
 977
 978 inline bool isShaderInOutSupportedType (const VariableType& type)
 979 {
 980         // \todo [2011-03-11 pyry] Float arrays, structs?
 981         return type.getBaseType() == VariableType::TYPE_FLOAT;
 982 }
 983
 984 Variable* allocateNewVariable (GeneratorState& state, ConstValueRangeAccess valueRange)
 985 {
 986         Variable* variable = state.getVariableManager().allocate(valueRange.getType());
 987
 988         // Update value range
 989         state.getVariableManager().setValue(variable, valueRange);
 990
 991         // Random storage \todo [pyry] Check that scalar count in uniform/input classes is not exceeded
 992         static const Variable::Storage storages[] =
 993         {
 994                 Variable::STORAGE_CONST,
 995                 Variable::STORAGE_UNIFORM,
 996                 Variable::STORAGE_LOCAL,
 997                 Variable::STORAGE_SHADER_IN
 998         };
 999         float weights[DE_LENGTH_OF_ARRAY(storages)];
1000
1001         // Dynamic vs. constant weight.
1002         float   dynWeight       = computeDynamicRangeWeight(valueRange);
1003         int             numScalars      = valueRange.getType().getScalarSize();
1004         bool    uniformOk       = state.getVariableManager().getNumAllocatedUniformScalars() + numScalars <= state.getShaderParameters().maxUniformScalars;
1005         bool    shaderInOk      = isShaderInOutSupportedType(valueRange.getType()) &&
1006                                                   (state.getVariableManager().getNumAllocatedShaderInVariables() + NUM_RESERVED_SHADER_INPUTS < state.getShaderParameters().maxInputVariables);
1007
1008         weights[0] = de::max(1.0f-dynWeight, 0.1f);
1009         weights[1] = uniformOk ? dynWeight*0.5f : 0.0f;
1010         weights[2] = dynWeight;
1011         weights[3] = shaderInOk ? dynWeight*2.0f : 0.0f;
1012
1013         state.getVariableManager().setStorage(variable, state.getRandom().chooseWeighted<Variable::Storage>(&storages[0], &storages[DE_LENGTH_OF_ARRAY(storages)], &weights[0]));
1014
1015         return variable;
1016 }
1017
1018 inline float combineWeight (float curCombinedWeight, float partialWeight)
1019 {
1020         return curCombinedWeight * partialWeight;
1021 }
1022
1023 float computeEntryReadWeight (ConstValueRangeAccess entryValueRange, ConstValueRangeAccess readValueRange)
1024 {
1025         const VariableType& type = entryValueRange.getType();
1026         DE_ASSERT(type == readValueRange.getType());
1027
1028         float weight = 1.0f;
1029
1030         switch (type.getBaseType())
1031         {
1032                 case VariableType::TYPE_FLOAT:
1033                 {
1034                         for (int elemNdx = 0; elemNdx < type.getNumElements(); elemNdx++)
1035                         {
1036                                 float entryMin  = entryValueRange.component(elemNdx).getMin().asFloat();
1037                                 float entryMax  = entryValueRange.component(elemNdx).getMax().asFloat();
1038                                 float readMin   = readValueRange.component(elemNdx).getMin().asFloat();
1039                                 float readMax   = readValueRange.component(elemNdx).getMax().asFloat();
1040
1041                                 // Check for -inf..inf ranges - they don't bring down the weight.
1042                                 if (Scalar::min<float>() == entryMin && Scalar::max<float>() == entryMax)
1043                                         continue;
1044
1045                                 // Intersection to entry value range length ratio.
1046                                 float intersectionMin           = deFloatMax(entryMin, readMin);
1047                                 float intersectionMax           = deFloatMin(entryMax, readMax);
1048                                 float entryRangeLen                     = entryMax - entryMin;
1049                                 float readRangeLen                      = readMax - readMin;
1050                                 float intersectionLen           = intersectionMax - intersectionMin;
1051                                 float entryRatio                        = (entryRangeLen        > 0.0f) ? (intersectionLen / entryRangeLen)     : 1.0f;
1052                                 float readRatio                         = (readRangeLen         > 0.0f) ? (intersectionLen / readRangeLen)      : 1.0f;
1053                                 float elementWeight                     = 0.5f*readRatio + 0.5f*entryRatio;
1054
1055                                 weight = combineWeight(weight, elementWeight);
1056                         }
1057                         break;
1058                 }
1059
1060                 case VariableType::TYPE_INT:
1061                 {
1062                         for (int elemNdx = 0; elemNdx < type.getNumElements(); elemNdx++)
1063                         {
1064                                 int entryMin    = entryValueRange.component(elemNdx).getMin().asInt();
1065                                 int entryMax    = entryValueRange.component(elemNdx).getMax().asInt();
1066                                 int readMin             = readValueRange.component(elemNdx).getMin().asInt();
1067                                 int readMax             = readValueRange.component(elemNdx).getMax().asInt();
1068
1069                                 // Check for -inf..inf ranges - they don't bring down the weight.
1070                                 if (Scalar::min<int>() == entryMin && Scalar::max<int>() == entryMax)
1071                                         continue;
1072
1073                                 // Intersection to entry value range length ratio.
1074                                 int             intersectionMin                 = deMax32(entryMin, readMin);
1075                                 int             intersectionMax                 = deMin32(entryMax, readMax);
1076                                 deInt64 entryRangeLen                   = (deInt64)entryMax - (deInt64)entryMin;
1077                                 deInt64 readRangeLen                    = (deInt64)readMax - (deInt64)readMin;
1078                                 deInt64 intersectionLen                 = (deInt64)intersectionMax - (deInt64)intersectionMin;
1079                                 float   entryRatio                              = (entryRangeLen        > 0) ? ((float)intersectionLen / (float)entryRangeLen)  : 1.0f;
1080                                 float   readRatio                               = (readRangeLen         > 0) ? ((float)intersectionLen / (float)readRangeLen)   : 1.0f;
1081                                 float   elementWeight                   = 0.5f*readRatio + 0.5f*entryRatio;
1082
1083                                 weight = combineWeight(weight, elementWeight);
1084                         }
1085                         break;
1086                 }
1087
1088                 case VariableType::TYPE_BOOL:
1089                 {
1090                         // \todo
1091                         break;
1092                 }
1093
1094
1095                 case VariableType::TYPE_ARRAY:
1096                 case VariableType::TYPE_STRUCT:
1097
1098                 default:
1099                         TCU_FAIL("Unsupported type");
1100         }
1101
1102         return deFloatMax(weight, 0.01f);
1103 }
1104
1105 } // anonymous
1106
1107 VariableRead::VariableRead (GeneratorState& state, ConstValueRangeAccess valueRange)
1108 {
1109         if (valueRange.getType().isVoid())
1110         {
1111                 IsReadableEntry filter                  = IsReadableEntry(state.getExpressionFlags());
1112                 int                             maxScalars              = state.getShaderParameters().maxCombinedVariableScalars - state.getVariableManager().getNumAllocatedScalars();
1113                 bool                    useRandomRange  = !state.getVariableManager().hasEntry(filter) || ((maxScalars > 0) && getWeightedBool(state.getRandom(), 0.5f));
1114
1115                 if (useRandomRange)
1116                 {
1117                         // Allocate a new variable
1118                         DE_ASSERT(maxScalars > 0);
1119                         ValueRange newVarRange(computeRandomType(state, maxScalars));
1120                         computeRandomValueRange(state, newVarRange.asAccess());
1121
1122                         m_variable = allocateNewVariable(state, newVarRange.asAccess());
1123                 }
1124                 else
1125                 {
1126                         // Use random entry \todo [pyry] Handle -inf..inf ranges?
1127                         m_variable = state.getRandom().choose<const ValueEntry*>(state.getVariableManager().getBegin(filter), state.getVariableManager().getEnd(filter))->getVariable();
1128                 }
1129         }
1130         else
1131         {
1132                 // Find variable that has value range that intersects with given range
1133                 IsReadableIntersectingEntry::Iterator   first   = state.getVariableManager().getBegin(IsReadableIntersectingEntry(valueRange, state.getExpressionFlags()));
1134                 IsReadableIntersectingEntry::Iterator   end             = state.getVariableManager().getEnd(IsReadableIntersectingEntry(valueRange, state.getExpressionFlags()));
1135
1136                 const float     createOnReadWeight              = 0.5f;
1137                 bool            createVar                               = canAllocateVariable(state, valueRange.getType()) && (first == end || getWeightedBool(state.getRandom(), createOnReadWeight));
1138
1139                 if (createVar)
1140                 {
1141                         m_variable = allocateNewVariable(state, valueRange);
1142                 }
1143                 else
1144                 {
1145                         // Copy value entries for computing weights.
1146                         std::vector<const ValueEntry*>  availableVars;
1147                         std::vector<float>                              weights;
1148
1149                         std::copy(first, end, std::inserter(availableVars, availableVars.begin()));
1150
1151                         // Compute weights.
1152                         weights.resize(availableVars.size());
1153                         for (int ndx = 0; ndx < (int)availableVars.size(); ndx++)
1154                                 weights[ndx] = computeEntryReadWeight(availableVars[ndx]->getValueRange(), valueRange);
1155
1156                         // Select.
1157                         const ValueEntry* entry = state.getRandom().chooseWeighted<const ValueEntry*>(availableVars.begin(), availableVars.end(), weights.begin());
1158                         m_variable = entry->getVariable();
1159
1160                         // Compute intersection
1161                         ValueRange intersection(m_variable->getType());
1162                         ValueRange::computeIntersection(intersection, entry->getValueRange(), valueRange);
1163                         state.getVariableManager().setValue(m_variable, intersection.asAccess());
1164                 }
1165         }
1166 }
1167
1168 VariableRead::VariableRead (const Variable* variable)
1169 {
1170         m_variable = variable;
1171 }
1172
1173 float VariableRead::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
1174 {
1175         if (valueRange.getType().isVoid())
1176         {
1177                 if (state.getVariableManager().hasEntry(IsReadableEntry(state.getExpressionFlags())) ||
1178                         state.getVariableManager().getNumAllocatedScalars() < state.getShaderParameters().maxCombinedVariableScalars)
1179                         return unusedValueWeight;
1180                 else
1181                         return 0.0f;
1182         }
1183
1184         if (!canAllocateVariable(state, valueRange.getType()) &&
1185                 !state.getVariableManager().hasEntry(IsReadableIntersectingEntry(valueRange, state.getExpressionFlags())))
1186                 return 0.0f;
1187         else
1188                 return 1.0f;
1189 }
1190
1191 VariableWrite::VariableWrite (GeneratorState& state, ConstValueRangeAccess valueRange)
1192 {
1193         DE_ASSERT(!valueRange.getType().isVoid());
1194
1195         // Find variable with range that is superset of given range
1196         IsWritableSupersetEntry::Iterator       first   = state.getVariableManager().getBegin(IsWritableSupersetEntry(valueRange));
1197         IsWritableSupersetEntry::Iterator       end             = state.getVariableManager().getEnd(IsWritableSupersetEntry(valueRange));
1198
1199         const float     createOnAssignWeight    = 0.1f; // Will essentially create an unused variable
1200         bool            createVar                               = canAllocateVariable(state, valueRange.getType()) && (first == end || getWeightedBool(state.getRandom(), createOnAssignWeight));
1201
1202         if (createVar)
1203         {
1204                 m_variable = state.getVariableManager().allocate(valueRange.getType());
1205                 // \note Storage will be LOCAL
1206         }
1207         else
1208         {
1209                 // Choose random
1210                 DE_ASSERT(first != end);
1211                 const ValueEntry* entry = state.getRandom().choose<const ValueEntry*>(first, end);
1212                 m_variable = entry->getVariable();
1213         }
1214
1215         DE_ASSERT(m_variable);
1216
1217         // Reset value range.
1218         const ValueEntry* parentEntry = state.getVariableManager().getParentValue(m_variable);
1219         if (parentEntry)
1220         {
1221                 // Use parent value range.
1222                 state.getVariableManager().setValue(m_variable, parentEntry->getValueRange());
1223         }
1224         else
1225         {
1226                 // Use infinite range.
1227                 ValueRange infRange(m_variable->getType());
1228                 setInfiniteRange(infRange);
1229
1230                 state.getVariableManager().setValue(m_variable, infRange.asAccess());
1231         }
1232 }
1233
1234 float VariableWrite::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
1235 {
1236         if (!canAllocateVariable(state, valueRange.getType()) &&
1237                 !state.getVariableManager().hasEntry(IsWritableSupersetEntry(valueRange)))
1238                 return 0.0f;
1239         else
1240                 return 1.0f;
1241 }
1242
1243 void VariableAccess::evaluate (ExecutionContext& evalCtx)
1244 {
1245         m_valueAccess = evalCtx.getValue(m_variable);
1246 }
1247
1248 ParenOp::ParenOp (GeneratorState& state, ConstValueRangeAccess valueRange)
1249         : m_valueRange  (valueRange)
1250         , m_child               (DE_NULL)
1251 {
1252         DE_UNREF(state);
1253 }
1254
1255 ParenOp::~ParenOp (void)
1256 {
1257         delete m_child;
1258 }
1259
1260 Expression* ParenOp::createNextChild (GeneratorState& state)
1261 {
1262         if (m_child == DE_NULL)
1263         {
1264                 m_child = Expression::createRandom(state, m_valueRange.asAccess());
1265                 return m_child;
1266         }
1267         else
1268                 return DE_NULL;
1269 }
1270
1271 void ParenOp::tokenize (GeneratorState& state, TokenStream& str) const
1272 {
1273         str << Token::LEFT_PAREN;
1274         m_child->tokenize(state, str);
1275         str << Token::RIGHT_PAREN;
1276 }
1277
1278 void ParenOp::setChild(Expression* expression)
1279 {
1280         m_child = expression;
1281 }
1282
1283 float ParenOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
1284 {
1285         if (valueRange.getType().isVoid())
1286                 return state.getExpressionDepth() + 2 <= state.getShaderParameters().maxExpressionDepth ? unusedValueWeight : 0.0f;
1287         else
1288         {
1289                 int requiredDepth = 1 + getConservativeValueExprDepth(state, valueRange);
1290                 return state.getExpressionDepth() + requiredDepth <= state.getShaderParameters().maxExpressionDepth ? 1.0f : 0.0f;
1291         }
1292 }
1293
1294 const int swizzlePrecedence = 2;
1295
1296 SwizzleOp::SwizzleOp (GeneratorState& state, ConstValueRangeAccess valueRange)
1297         : m_outValueRange               (valueRange)
1298         , m_numInputElements    (0)
1299         , m_child                               (DE_NULL)
1300 {
1301         DE_ASSERT(!m_outValueRange.getType().isVoid()); // \todo [2011-06-13 pyry] Void support
1302         DE_ASSERT(m_outValueRange.getType().isFloatOrVec()      ||
1303                           m_outValueRange.getType().isIntOrVec()        ||
1304                           m_outValueRange.getType().isBoolOrVec());
1305
1306         m_value.setStorage(m_outValueRange.getType());
1307
1308         int numOutputElements   = m_outValueRange.getType().getNumElements();
1309
1310         // \note Swizzle works for vector types only.
1311         // \todo [2011-06-13 pyry] Use components multiple times.
1312         m_numInputElements              = state.getRandom().getInt(deMax32(numOutputElements, 2), 4);
1313
1314         std::set<int> availableElements;
1315         for (int ndx = 0; ndx < m_numInputElements; ndx++)
1316                 availableElements.insert(ndx);
1317
1318         // Randomize swizzle.
1319         for (int elemNdx = 0; elemNdx < (int)DE_LENGTH_OF_ARRAY(m_swizzle); elemNdx++)
1320         {
1321                 if (elemNdx < numOutputElements)
1322                 {
1323                         int inElemNdx = state.getRandom().choose<int>(availableElements.begin(), availableElements.end());
1324                         availableElements.erase(inElemNdx);
1325                         m_swizzle[elemNdx] = (deUint8)inElemNdx;
1326                 }
1327                 else
1328                         m_swizzle[elemNdx] = 0;
1329         }
1330 }
1331
1332 SwizzleOp::~SwizzleOp (void)
1333 {
1334         delete m_child;
1335 }
1336
1337 Expression* SwizzleOp::createNextChild (GeneratorState& state)
1338 {
1339         if (m_child)
1340                 return DE_NULL;
1341
1342         // Compute input value range.
1343         VariableType    inVarType               = VariableType(m_outValueRange.getType().getBaseType(), m_numInputElements);
1344         ValueRange              inValueRange    = ValueRange(inVarType);
1345
1346         // Initialize all inputs to -inf..inf
1347         setInfiniteRange(inValueRange);
1348
1349         // Compute intersections.
1350         int numOutputElements = m_outValueRange.getType().getNumElements();
1351         for (int outElemNdx = 0; outElemNdx < numOutputElements; outElemNdx++)
1352         {
1353                 int inElemNdx = m_swizzle[outElemNdx];
1354                 ValueRange::computeIntersection(inValueRange.asAccess().component(inElemNdx), inValueRange.asAccess().component(inElemNdx), m_outValueRange.asAccess().component(outElemNdx));
1355         }
1356
1357         // Create child.
1358         state.pushPrecedence(swizzlePrecedence);
1359         m_child = Expression::createRandom(state, inValueRange.asAccess());
1360         state.popPrecedence();
1361
1362         return m_child;
1363 }
1364
1365 void SwizzleOp::tokenize (GeneratorState& state, TokenStream& str) const
1366 {
1367         const char*             rgbaSet[]       = { "r", "g", "b", "a" };
1368         const char*             xyzwSet[]       = { "x", "y", "z", "w" };
1369         const char*             stpqSet[]       = { "s", "t", "p", "q" };
1370         const char**    swizzleSet      = DE_NULL;
1371
1372         switch (state.getRandom().getInt(0, 2))
1373         {
1374                 case 0: swizzleSet = rgbaSet; break;
1375                 case 1: swizzleSet = xyzwSet; break;
1376                 case 2: swizzleSet = stpqSet; break;
1377                 default: DE_ASSERT(DE_FALSE);
1378         }
1379
1380         std::string swizzleStr;
1381         for (int elemNdx = 0; elemNdx < m_outValueRange.getType().getNumElements(); elemNdx++)
1382                 swizzleStr += swizzleSet[m_swizzle[elemNdx]];
1383
1384         m_child->tokenize(state, str);
1385         str << Token::DOT << Token(swizzleStr.c_str());
1386 }
1387
1388 float SwizzleOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
1389 {
1390         if (!state.getProgramParameters().useSwizzle)
1391                 return 0.0f;
1392
1393         if (state.getPrecedence() < swizzlePrecedence)
1394                 return 0.0f;
1395
1396         if (!valueRange.getType().isFloatOrVec()        &&
1397                 !valueRange.getType().isIntOrVec()              &&
1398                 !valueRange.getType().isBoolOrVec())
1399                 return 0.0f;
1400
1401         int availableLevels = state.getShaderParameters().maxExpressionDepth - state.getExpressionDepth();
1402
1403         // Swizzle + Constructor + Values
1404         if (availableLevels < 3)
1405                 return 0.0f;
1406
1407         return 1.0f;
1408 }
1409
1410 void SwizzleOp::evaluate (ExecutionContext& execCtx)
1411 {
1412         m_child->evaluate(execCtx);
1413
1414         ExecConstValueAccess    inValue         = m_child->getValue();
1415         ExecValueAccess                 outValue        = m_value.getValue(m_outValueRange.getType());
1416
1417         for (int outElemNdx = 0; outElemNdx < outValue.getType().getNumElements(); outElemNdx++)
1418         {
1419                 int inElemNdx = m_swizzle[outElemNdx];
1420                 outValue.component(outElemNdx) = inValue.component(inElemNdx).value();
1421         }
1422 }
1423
1424 static int countSamplers (const VariableManager& varManager, VariableType::Type samplerType)
1425 {
1426         int numSamplers = 0;
1427
1428         IsSamplerEntry::Iterator        i               = varManager.getBegin(IsSamplerEntry(samplerType));
1429         IsSamplerEntry::Iterator        end             = varManager.getEnd(IsSamplerEntry(samplerType));
1430
1431         for (; i != end; i++)
1432                 numSamplers += 1;
1433
1434         return numSamplers;
1435 }
1436
1437 TexLookup::TexLookup (GeneratorState& state, ConstValueRangeAccess valueRange)
1438         : m_type                        (TYPE_LAST)
1439         , m_coordExpr           (DE_NULL)
1440         , m_lodBiasExpr         (DE_NULL)
1441         , m_valueType           (VariableType::TYPE_FLOAT, 4)
1442         , m_value                       (m_valueType)
1443 {
1444         DE_ASSERT(valueRange.getType() == VariableType(VariableType::TYPE_FLOAT, 4));
1445         DE_UNREF(valueRange); // Texture output value range is constant.
1446
1447         // Select type.
1448         vector<Type> typeCandidates;
1449         if (state.getShaderParameters().useTexture2D)
1450         {
1451                 typeCandidates.push_back(TYPE_TEXTURE2D);
1452                 typeCandidates.push_back(TYPE_TEXTURE2D_LOD);
1453                 typeCandidates.push_back(TYPE_TEXTURE2D_PROJ);
1454                 typeCandidates.push_back(TYPE_TEXTURE2D_PROJ_LOD);
1455         }
1456
1457         if (state.getShaderParameters().useTextureCube)
1458         {
1459                 typeCandidates.push_back(TYPE_TEXTURECUBE);
1460                 typeCandidates.push_back(TYPE_TEXTURECUBE_LOD);
1461         }
1462
1463         m_type = state.getRandom().choose<Type>(typeCandidates.begin(), typeCandidates.end());
1464
1465         // Select or allocate sampler.
1466         VariableType::Type samplerType = VariableType::TYPE_LAST;
1467         switch (m_type)
1468         {
1469                 case TYPE_TEXTURE2D:
1470                 case TYPE_TEXTURE2D_LOD:
1471                 case TYPE_TEXTURE2D_PROJ:
1472                 case TYPE_TEXTURE2D_PROJ_LOD:
1473                         samplerType = VariableType::TYPE_SAMPLER_2D;
1474                         break;
1475
1476                 case TYPE_TEXTURECUBE:
1477                 case TYPE_TEXTURECUBE_LOD:
1478                         samplerType = VariableType::TYPE_SAMPLER_CUBE;
1479                         break;
1480
1481                 default:
1482                         DE_ASSERT(DE_FALSE);
1483         }
1484
1485         int             sampler2DCount          = countSamplers(state.getVariableManager(), VariableType::TYPE_SAMPLER_2D);
1486         int             samplerCubeCount        = countSamplers(state.getVariableManager(), VariableType::TYPE_SAMPLER_CUBE);
1487         bool    canAllocSampler         = sampler2DCount + samplerCubeCount < state.getShaderParameters().maxSamplers;
1488         bool    hasSampler                      = samplerType == VariableType::TYPE_SAMPLER_2D ? (sampler2DCount > 0) : (samplerCubeCount > 0);
1489         bool    allocSampler            = !hasSampler || (canAllocSampler && state.getRandom().getBool());
1490
1491         if (allocSampler)
1492         {
1493                 Variable* sampler = state.getVariableManager().allocate(VariableType(samplerType, 1));
1494                 state.getVariableManager().setStorage(sampler, Variable::STORAGE_UNIFORM); // Samplers are always uniforms.
1495                 m_sampler = sampler;
1496         }
1497         else
1498                 m_sampler = state.getRandom().choose<const ValueEntry*>(state.getVariableManager().getBegin(IsSamplerEntry(samplerType)),
1499                                                                                                                             state.getVariableManager().getEnd(IsSamplerEntry(samplerType)))->getVariable();
1500 }
1501
1502 TexLookup::~TexLookup (void)
1503 {
1504         delete m_coordExpr;
1505         delete m_lodBiasExpr;
1506 }
1507
1508 Expression* TexLookup::createNextChild (GeneratorState& state)
1509 {
1510         bool hasLodBias         = m_type == TYPE_TEXTURE2D_LOD ||
1511                                                   m_type == TYPE_TEXTURE2D_PROJ_LOD ||
1512                                                   m_type == TYPE_TEXTURECUBE_LOD;
1513
1514         if (hasLodBias && !m_lodBiasExpr)
1515         {
1516                 ValueRange lodRange(VariableType(VariableType::TYPE_FLOAT, 1));
1517                 setInfiniteRange(lodRange); // Any value is valid.
1518
1519                 m_lodBiasExpr = Expression::createRandom(state, lodRange.asAccess());
1520                 return m_lodBiasExpr;
1521         }
1522
1523         if (!m_coordExpr)
1524         {
1525                 if (m_type == TYPE_TEXTURECUBE || m_type == TYPE_TEXTURECUBE_LOD)
1526                 {
1527                         // Make sure major axis selection can be done.
1528                         int majorAxisNdx = state.getRandom().getInt(0, 2);
1529
1530                         ValueRange coordRange(VariableType(VariableType::TYPE_FLOAT, 3));
1531
1532                         for (int ndx = 0; ndx < 3; ndx++)
1533                         {
1534                                 if (ndx == majorAxisNdx)
1535                                 {
1536                                         bool neg = state.getRandom().getBool();
1537                                         coordRange.getMin().component(ndx) = neg ? -4.0f        : 2.25f;
1538                                         coordRange.getMax().component(ndx) = neg ? -2.25f       : 4.0f;
1539                                 }
1540                                 else
1541                                 {
1542                                         coordRange.getMin().component(ndx) = -2.0f;
1543                                         coordRange.getMax().component(ndx) =  2.0f;
1544                                 }
1545                         }
1546
1547                         m_coordExpr = Expression::createRandom(state, coordRange.asAccess());
1548                 }
1549                 else
1550                 {
1551                         bool    isProj                          = m_type == TYPE_TEXTURE2D_PROJ || m_type == TYPE_TEXTURE2D_PROJ_LOD;
1552                         int             coordScalarSize         = isProj ? 3 : 2;
1553
1554                         ValueRange coordRange(VariableType(VariableType::TYPE_FLOAT, coordScalarSize));
1555                         setInfiniteRange(coordRange); // Initialize base range with -inf..inf
1556
1557                         if (isProj)
1558                         {
1559                                 // w coordinate must be something sane, and not 0.
1560                                 bool neg = state.getRandom().getBool();
1561                                 coordRange.getMin().component(2) = neg ? -4.0f  : 0.25f;
1562                                 coordRange.getMax().component(2) = neg ? -0.25f : 4.0f;
1563                         }
1564
1565                         m_coordExpr = Expression::createRandom(state, coordRange.asAccess());
1566                 }
1567
1568                 DE_ASSERT(m_coordExpr);
1569                 return m_coordExpr;
1570         }
1571
1572         return DE_NULL; // Done.
1573 }
1574
1575 void TexLookup::tokenize (GeneratorState& state, TokenStream& str) const
1576 {
1577         bool isVertex = state.getShader().getType() == Shader::TYPE_VERTEX;
1578
1579         if (state.getProgramParameters().version == VERSION_300)
1580         {
1581                 switch (m_type)
1582                 {
1583                         case TYPE_TEXTURE2D:                    str << "texture";                                                                               break;
1584                         case TYPE_TEXTURE2D_LOD:                str << (isVertex ? "textureLod" : "texture");                   break;
1585                         case TYPE_TEXTURE2D_PROJ:               str << "textureProj";                                                                   break;
1586                         case TYPE_TEXTURE2D_PROJ_LOD:   str << (isVertex ? "textureProjLod" : "textureProj");   break;
1587                         case TYPE_TEXTURECUBE:                  str << "texture";                                                                               break;
1588                         case TYPE_TEXTURECUBE_LOD:              str << (isVertex ? "textureLod" : "texture");                   break;
1589                         default:
1590                                 DE_ASSERT(DE_FALSE);
1591                 }
1592         }
1593         else
1594         {
1595                 switch (m_type)
1596                 {
1597                         case TYPE_TEXTURE2D:                    str << "texture2D";                                                                                     break;
1598                         case TYPE_TEXTURE2D_LOD:                str << (isVertex ? "texture2DLod" : "texture2D");                       break;
1599                         case TYPE_TEXTURE2D_PROJ:               str << "texture2DProj";                                                                         break;
1600                         case TYPE_TEXTURE2D_PROJ_LOD:   str << (isVertex ? "texture2DProjLod" : "texture2DProj");       break;
1601                         case TYPE_TEXTURECUBE:                  str << "textureCube";                                                                           break;
1602                         case TYPE_TEXTURECUBE_LOD:              str << (isVertex ? "textureCubeLod" : "textureCube");           break;
1603                         default:
1604                                 DE_ASSERT(DE_FALSE);
1605                 }
1606         }
1607
1608         str << Token::LEFT_PAREN;
1609         str << m_sampler->getName();
1610         str << Token::COMMA;
1611         m_coordExpr->tokenize(state, str);
1612
1613         if (m_lodBiasExpr)
1614         {
1615                 str << Token::COMMA;
1616                 m_lodBiasExpr->tokenize(state, str);
1617         }
1618
1619         str << Token::RIGHT_PAREN;
1620 }
1621
1622 float TexLookup::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
1623 {
1624         if (state.getShaderParameters().texLookupBaseWeight <= 0.0f)
1625                 return 0.0f;
1626
1627         int availableLevels = state.getShaderParameters().maxExpressionDepth - state.getExpressionDepth();
1628
1629         // Lookup + Constructor + Values
1630         if (availableLevels < 3)
1631                 return 0.0f;
1632
1633         if (state.getExpressionFlags() & (CONST_EXPR|NO_VAR_ALLOCATION))
1634                 return 0.0f;
1635
1636         if (valueRange.getType() != VariableType(VariableType::TYPE_FLOAT, 4))
1637                 return 0.0f;
1638
1639         ValueRange texOutputRange(VariableType(VariableType::TYPE_FLOAT, 4));
1640         for (int ndx = 0; ndx < 4; ndx++)
1641         {
1642                 texOutputRange.getMin().component(ndx) = 0.0f;
1643                 texOutputRange.getMax().component(ndx) = 1.0f;
1644         }
1645
1646         if (!valueRange.isSupersetOf(texOutputRange.asAccess()))
1647                 return 0.0f;
1648
1649         return state.getShaderParameters().texLookupBaseWeight;
1650 }
1651
1652 void TexLookup::evaluate (ExecutionContext& execCtx)
1653 {
1654         // Evaluate coord and bias.
1655         m_coordExpr->evaluate(execCtx);
1656         if (m_lodBiasExpr)
1657                 m_lodBiasExpr->evaluate(execCtx);
1658
1659         ExecConstValueAccess    coords  = m_coordExpr->getValue();
1660         ExecValueAccess                 dst             = m_value.getValue(m_valueType);
1661
1662         switch (m_type)
1663         {
1664                 case TYPE_TEXTURE2D:
1665                 {
1666                         const Sampler2D& tex = execCtx.getSampler2D(m_sampler);
1667                         for (int i = 0; i < EXEC_VEC_WIDTH; i++)
1668                         {
1669                                 float           s       = coords.component(0).asFloat(i);
1670                                 float           t       = coords.component(1).asFloat(i);
1671                                 tcu::Vec4       p       = tex.sample(s, t, 0.0f);
1672
1673                                 for (int comp = 0; comp < 4; comp++)
1674                                         dst.component(comp).asFloat(i) = p[comp];
1675                         }
1676                         break;
1677                 }
1678
1679                 case TYPE_TEXTURE2D_LOD:
1680                 {
1681                         ExecConstValueAccess    lod             = m_lodBiasExpr->getValue();
1682                         const Sampler2D&                tex             = execCtx.getSampler2D(m_sampler);
1683                         for (int i = 0; i < EXEC_VEC_WIDTH; i++)
1684                         {
1685                                 float           s       = coords.component(0).asFloat(i);
1686                                 float           t       = coords.component(1).asFloat(i);
1687                                 float           l       = lod.component(0).asFloat(i);
1688                                 tcu::Vec4       p       = tex.sample(s, t, l);
1689
1690                                 for (int comp = 0; comp < 4; comp++)
1691                                         dst.component(comp).asFloat(i) = p[comp];
1692                         }
1693                         break;
1694                 }
1695
1696                 case TYPE_TEXTURE2D_PROJ:
1697                 {
1698                         const Sampler2D& tex = execCtx.getSampler2D(m_sampler);
1699                         for (int i = 0; i < EXEC_VEC_WIDTH; i++)
1700                         {
1701                                 float           s       = coords.component(0).asFloat(i);
1702                                 float           t       = coords.component(1).asFloat(i);
1703                                 float           w       = coords.component(2).asFloat(i);
1704                                 tcu::Vec4       p       = tex.sample(s/w, t/w, 0.0f);
1705
1706                                 for (int comp = 0; comp < 4; comp++)
1707                                         dst.component(comp).asFloat(i) = p[comp];
1708                         }
1709                         break;
1710                 }
1711
1712                 case TYPE_TEXTURE2D_PROJ_LOD:
1713                 {
1714                         ExecConstValueAccess    lod             = m_lodBiasExpr->getValue();
1715                         const Sampler2D&                tex             = execCtx.getSampler2D(m_sampler);
1716                         for (int i = 0; i < EXEC_VEC_WIDTH; i++)
1717                         {
1718                                 float           s       = coords.component(0).asFloat(i);
1719                                 float           t       = coords.component(1).asFloat(i);
1720                                 float           w       = coords.component(2).asFloat(i);
1721                                 float           l       = lod.component(0).asFloat(i);
1722                                 tcu::Vec4       p       = tex.sample(s/w, t/w, l);
1723
1724                                 for (int comp = 0; comp < 4; comp++)
1725                                         dst.component(comp).asFloat(i) = p[comp];
1726                         }
1727                         break;
1728                 }
1729
1730                 case TYPE_TEXTURECUBE:
1731                 {
1732                         const SamplerCube& tex = execCtx.getSamplerCube(m_sampler);
1733                         for (int i = 0; i < EXEC_VEC_WIDTH; i++)
1734                         {
1735                                 float           s       = coords.component(0).asFloat(i);
1736                                 float           t       = coords.component(1).asFloat(i);
1737                                 float           r       = coords.component(2).asFloat(i);
1738                                 tcu::Vec4       p       = tex.sample(s, t, r, 0.0f);
1739
1740                                 for (int comp = 0; comp < 4; comp++)
1741                                         dst.component(comp).asFloat(i) = p[comp];
1742                         }
1743                         break;
1744                 }
1745
1746                 case TYPE_TEXTURECUBE_LOD:
1747                 {
1748                         ExecConstValueAccess    lod             = m_lodBiasExpr->getValue();
1749                         const SamplerCube&              tex             = execCtx.getSamplerCube(m_sampler);
1750                         for (int i = 0; i < EXEC_VEC_WIDTH; i++)
1751                         {
1752                                 float           s       = coords.component(0).asFloat(i);
1753                                 float           t       = coords.component(1).asFloat(i);
1754                                 float           r       = coords.component(2).asFloat(i);
1755                                 float           l       = lod.component(0).asFloat(i);
1756                                 tcu::Vec4       p       = tex.sample(s, t, r, l);
1757
1758                                 for (int comp = 0; comp < 4; comp++)
1759                                         dst.component(comp).asFloat(i) = p[comp];
1760                         }
1761                         break;
1762                 }
1763
1764                 default:
1765                         DE_ASSERT(DE_FALSE);
1766         }
1767 }
1768
1769 } // rsg