framework/randomshaders/rsgBinaryOps.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 Binary ops.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "rsgBinaryOps.hpp"
  25 #include "rsgVariableManager.hpp"
  26 #include "rsgUtils.hpp"
  27 #include "deMath.h"
  28
  29 using std::vector;
  30
  31 namespace rsg
  32 {
  33
  34 template <int Precedence, Associativity Assoc>
  35 BinaryOp<Precedence, Assoc>::BinaryOp (Token::Type operatorToken)
  36         : m_operator            (operatorToken)
  37         , m_leftValueRange      (m_type)
  38         , m_rightValueRange     (m_type)
  39         , m_leftValueExpr       (DE_NULL)
  40         , m_rightValueExpr      (DE_NULL)
  41 {
  42 }
  43
  44 template <int Precedence, Associativity Assoc>
  45 BinaryOp<Precedence, Assoc>::~BinaryOp (void)
  46 {
  47         delete m_leftValueExpr;
  48         delete m_rightValueExpr;
  49 }
  50
  51 template <int Precedence, Associativity Assoc>
  52 Expression* BinaryOp<Precedence, Assoc>::createNextChild (GeneratorState& state)
  53 {
  54         int leftPrec    = Assoc == ASSOCIATIVITY_LEFT ? Precedence : Precedence-1;
  55         int rightPrec   = Assoc == ASSOCIATIVITY_LEFT ? Precedence-1 : Precedence;
  56
  57         if (m_rightValueExpr == DE_NULL)
  58         {
  59                 state.pushPrecedence(rightPrec);
  60                 m_rightValueExpr = Expression::createRandom(state, m_rightValueRange.asAccess());
  61                 state.popPrecedence();
  62                 return m_rightValueExpr;
  63         }
  64         else if (m_leftValueExpr == DE_NULL)
  65         {
  66                 state.pushPrecedence(leftPrec);
  67                 m_leftValueExpr = Expression::createRandom(state, m_leftValueRange.asAccess());
  68                 state.popPrecedence();
  69                 return m_leftValueExpr;
  70         }
  71         else
  72                 return DE_NULL;
  73 }
  74
  75 template <int Precedence, Associativity Assoc>
  76 float BinaryOp<Precedence, Assoc>::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
  77 {
  78         if (state.getPrecedence() < Precedence)
  79                 return 0.0f;
  80
  81         int availableLevels = state.getShaderParameters().maxExpressionDepth - state.getExpressionDepth();
  82
  83         if (valueRange.getType().isVoid())
  84                 return availableLevels >= 2 ? unusedValueWeight : 0.0f;
  85
  86         if (availableLevels < getConservativeValueExprDepth(state, valueRange) + 1)
  87                 return 0.0f;
  88
  89         return 1.0f;
  90 }
  91
  92 template <int Precedence, Associativity Assoc>
  93 void BinaryOp<Precedence, Assoc>::tokenize (GeneratorState& state, TokenStream& str) const
  94 {
  95         m_leftValueExpr->tokenize(state, str);
  96         str << m_operator;
  97         m_rightValueExpr->tokenize(state, str);
  98 }
  99
 100 template <int Precedence, Associativity Assoc>
 101 void BinaryOp<Precedence, Assoc>::evaluate (ExecutionContext& execCtx)
 102 {
 103         m_leftValueExpr->evaluate(execCtx);
 104         m_rightValueExpr->evaluate(execCtx);
 105
 106         ExecConstValueAccess    leftVal         = m_leftValueExpr->getValue();
 107         ExecConstValueAccess    rightVal        = m_rightValueExpr->getValue();
 108         ExecValueAccess                 dst                     = m_value.getValue(m_type);
 109
 110         evaluate(dst, leftVal, rightVal);
 111 }
 112
 113 template <int Precedence, bool Float, bool Int, bool Bool, class ComputeValueRange, class EvaluateComp>
 114 BinaryVecOp<Precedence, Float, Int, Bool, ComputeValueRange, EvaluateComp>::BinaryVecOp (GeneratorState& state, Token::Type operatorToken, ConstValueRangeAccess inValueRange)
 115         : BinaryOp<Precedence, ASSOCIATIVITY_LEFT>(operatorToken)
 116 {
 117         ValueRange valueRange = inValueRange;
 118
 119         if (valueRange.getType().isVoid())
 120         {
 121                 int                                                     availableLevels = state.getShaderParameters().maxExpressionDepth - state.getExpressionDepth();
 122                 vector<VariableType::Type>      baseTypes;
 123
 124                 if (Float)      baseTypes.push_back(VariableType::TYPE_FLOAT);
 125                 if (Int)        baseTypes.push_back(VariableType::TYPE_INT);
 126                 if (Bool)       baseTypes.push_back(VariableType::TYPE_BOOL);
 127
 128                 VariableType::Type      baseType        = state.getRandom().choose<VariableType::Type>(baseTypes.begin(), baseTypes.end());
 129                 int                                     numElements     = state.getRandom().getInt(1, availableLevels >= 3 ? 4 : 1);
 130
 131                 valueRange = ValueRange(VariableType(baseType, numElements));
 132                 computeRandomValueRange(state, valueRange.asAccess());
 133         }
 134
 135         // Choose type, allocate storage for execution
 136         this->m_type = valueRange.getType();
 137         this->m_value.setStorage(this->m_type);
 138
 139         // Initialize storage for value ranges
 140         this->m_rightValueRange = ValueRange(this->m_type);
 141         this->m_leftValueRange  = ValueRange(this->m_type);
 142
 143         VariableType::Type baseType = this->m_type.getBaseType();
 144
 145         // Compute range for b that satisfies requested value range
 146         for (int elemNdx = 0; elemNdx < this->m_type.getNumElements(); elemNdx++)
 147         {
 148                 ConstValueRangeAccess   dst             = valueRange.asAccess().component(elemNdx);
 149                 ValueRangeAccess                a               = this->m_leftValueRange.asAccess().component(elemNdx); // \todo [2011-03-25 pyry] Commutative: randomize inputs
 150                 ValueRangeAccess                b               = this->m_rightValueRange.asAccess().component(elemNdx);
 151
 152                 // Just pass undefined ranges
 153                 if ((baseType == VariableType::TYPE_FLOAT || baseType == VariableType::TYPE_INT) && isUndefinedValueRange(dst))
 154                 {
 155                         a.getMin() = dst.getMin().value();
 156                         b.getMin() = dst.getMin().value();
 157                         a.getMax() = dst.getMax().value();
 158                         b.getMax() = dst.getMax().value();
 159                         continue;
 160                 }
 161
 162                 if (baseType == VariableType::TYPE_FLOAT)
 163                         ComputeValueRange()(state.getRandom(), dst.getMin().asFloat(), dst.getMax().asFloat(),
 164                                                                 a.getMin().asFloat(), a.getMax().asFloat(),
 165                                                                 b.getMin().asFloat(), b.getMax().asFloat());
 166                 else if (baseType == VariableType::TYPE_INT)
 167                         ComputeValueRange()(state.getRandom(), dst.getMin().asInt(), dst.getMax().asInt(),
 168                                                                 a.getMin().asInt(), a.getMax().asInt(),
 169                                                                 b.getMin().asInt(), b.getMax().asInt());
 170                 else
 171                 {
 172                         DE_ASSERT(baseType == VariableType::TYPE_BOOL);
 173                         ComputeValueRange()(state.getRandom(), dst.getMin().asBool(), dst.getMax().asBool(),
 174                                                                 a.getMin().asBool(), a.getMax().asBool(),
 175                                                                 b.getMin().asBool(), b.getMax().asBool());
 176                 }
 177         }
 178 }
 179
 180 template <int Precedence, bool Float, bool Int, bool Bool, class ComputeValueRange, class EvaluateComp>
 181 BinaryVecOp<Precedence, Float, Int, Bool, ComputeValueRange, EvaluateComp>::~BinaryVecOp (void)
 182 {
 183 }
 184
 185 template <int Precedence, bool Float, bool Int, bool Bool, class ComputeValueRange, class EvaluateComp>
 186 void BinaryVecOp<Precedence, Float, Int, Bool, ComputeValueRange, EvaluateComp>::evaluate (ExecValueAccess dst, ExecConstValueAccess a, ExecConstValueAccess b)
 187 {
 188         DE_ASSERT(dst.getType() == a.getType());
 189         DE_ASSERT(dst.getType() == b.getType());
 190         switch (dst.getType().getBaseType())
 191         {
 192                 case VariableType::TYPE_FLOAT:
 193                         for (int elemNdx = 0; elemNdx < dst.getType().getNumElements(); elemNdx++)
 194                         {
 195                                 for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
 196                                         dst.component(elemNdx).asFloat(compNdx) = EvaluateComp()(a.component(elemNdx).asFloat(compNdx), b.component(elemNdx).asFloat(compNdx));
 197                         }
 198                         break;
 199
 200                 case VariableType::TYPE_INT:
 201                         for (int elemNdx = 0; elemNdx < dst.getType().getNumElements(); elemNdx++)
 202                         {
 203                                 for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
 204                                         dst.component(elemNdx).asInt(compNdx) = EvaluateComp()(a.component(elemNdx).asInt(compNdx), b.component(elemNdx).asInt(compNdx));
 205                         }
 206                         break;
 207
 208                 default:
 209                         DE_ASSERT(DE_FALSE); // Invalid type for multiplication
 210         }
 211 }
 212
 213 void ComputeMulRange::operator() (de::Random& rnd, float dstMin, float dstMax, float& aMin, float& aMax, float& bMin, float& bMax) const
 214 {
 215         const float minScale     = 0.25f;
 216         const float maxScale     = 2.0f;
 217         const float subRangeStep = 0.25f;
 218         const float scaleStep    = 0.25f;
 219
 220         float scale             = getQuantizedFloat(rnd, minScale, maxScale, scaleStep);
 221         float scaledMin = dstMin/scale;
 222         float scaledMax = dstMax/scale;
 223
 224         // Quantize scaled value range if possible
 225         if (!quantizeFloatRange(scaledMin, scaledMax))
 226         {
 227                 // Fall back to 1.0 as a scale
 228                 scale           = 1.0f;
 229                 scaledMin       = dstMin;
 230                 scaledMax       = dstMax;
 231         }
 232
 233         float subRangeLen = getQuantizedFloat(rnd, 0.0f, scaledMax-scaledMin, subRangeStep);
 234         aMin = scaledMin + getQuantizedFloat(rnd, 0.0f, (scaledMax-scaledMin)-subRangeLen, subRangeStep);
 235         aMax = aMin + subRangeLen;
 236
 237         // Find scale range
 238         bMin = scale;
 239         bMax = scale;
 240         for (int i = 0; i < 5; i++)
 241         {
 242                 if (de::inBounds(aMin*(scale-(float)i*scaleStep), dstMin, dstMax) &&
 243                         de::inBounds(aMax*(scale-(float)i*scaleStep), dstMin, dstMax))
 244                         bMin = scale-(float)i*scaleStep;
 245
 246                 if (de::inBounds(aMin*(scale+(float)i*scaleStep), dstMin, dstMax) &&
 247                         de::inBounds(aMax*(scale+(float)i*scaleStep), dstMin, dstMax))
 248                         bMax = scale+(float)i*scaleStep;
 249         }
 250
 251         // Negative scale?
 252         if (rnd.getBool())
 253         {
 254                 std::swap(aMin, aMax);
 255                 std::swap(bMin, bMax);
 256                 aMin    *= -1.0f;
 257                 aMax    *= -1.0f;
 258                 bMin    *= -1.0f;
 259                 bMax    *= -1.0f;
 260         }
 261
 262 #if defined(DE_DEBUG)
 263         const float eps = 0.001f;
 264         DE_ASSERT(aMin <= aMax && bMin <= bMax);
 265         DE_ASSERT(de::inRange(aMin*bMin, dstMin-eps, dstMax+eps));
 266         DE_ASSERT(de::inRange(aMin*bMax, dstMin-eps, dstMax+eps));
 267         DE_ASSERT(de::inRange(aMax*bMin, dstMin-eps, dstMax+eps));
 268         DE_ASSERT(de::inRange(aMax*bMax, dstMin-eps, dstMax+eps));
 269 #endif
 270 }
 271
 272 void ComputeMulRange::operator() (de::Random& rnd, int dstMin, int dstMax, int& aMin, int& aMax, int& bMin, int& bMax) const
 273 {
 274         DE_UNREF(rnd);
 275         aMin    = dstMin;
 276         aMax    = dstMax;
 277         bMin    = 1;
 278         bMax    = 1;
 279 }
 280
 281 MulOp::MulOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 282         : MulBase(state, Token::MUL, valueRange)
 283 {
 284 }
 285
 286 float MulOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 287 {
 288         if (valueRange.getType().isVoid() ||
 289                 valueRange.getType().isFloatOrVec() ||
 290                 valueRange.getType().isIntOrVec())
 291                 return MulBase::getWeight(state, valueRange);
 292         else
 293                 return 0.0f;
 294 }
 295
 296 template <typename T>
 297 void ComputeAddRange::operator() (de::Random& random, T dstMin, T dstMax, T& aMin, T& aMax, T& bMin, T& bMax) const
 298 {
 299         struct GetRandom
 300         {
 301                 int             operator() (de::Random& rnd, int min, int max) const            { return rnd.getInt(min, max); }
 302                 float   operator() (de::Random& rnd, float min, float max) const        { return getQuantizedFloat(rnd, min, max, 0.5f); }
 303         };
 304
 305         T rangeLen              = dstMax-dstMin;
 306         T subRangeLen   = GetRandom()(random, T(0), rangeLen);
 307         T aOffset               = GetRandom()(random, T(-8), T(8));
 308
 309         aMin                    = dstMin+aOffset;
 310         aMax                    = aMin+subRangeLen;
 311
 312         bMin                    = -aOffset;
 313         bMax                    = -aOffset+(rangeLen-subRangeLen);
 314
 315 #if defined(DE_DEBUG)
 316         T eps = T(0.001);
 317         DE_ASSERT(aMin <= aMax && bMin <= bMax);
 318         DE_ASSERT(de::inRange(aMin+bMin, dstMin-eps, dstMax+eps));
 319         DE_ASSERT(de::inRange(aMin+bMax, dstMin-eps, dstMax+eps));
 320         DE_ASSERT(de::inRange(aMax+bMin, dstMin-eps, dstMax+eps));
 321         DE_ASSERT(de::inRange(aMax+bMax, dstMin-eps, dstMax+eps));
 322 #endif
 323 }
 324
 325 template <>
 326 void ComputeAddRange::operator()<bool> (de::Random&, bool, bool, bool&, bool&, bool&, bool&) const
 327 {
 328         DE_ASSERT(DE_FALSE);
 329 }
 330
 331 AddOp::AddOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 332         : AddBase(state, Token::PLUS, valueRange)
 333 {
 334 }
 335
 336 float AddOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 337 {
 338         if (valueRange.getType().isVoid() ||
 339                 valueRange.getType().isFloatOrVec() ||
 340                 valueRange.getType().isIntOrVec())
 341                 return AddBase::getWeight(state, valueRange);
 342         else
 343                 return 0.0f;
 344 }
 345
 346 template <typename T>
 347 void ComputeSubRange::operator() (de::Random& random, T dstMin, T dstMax, T& aMin, T& aMax, T& bMin, T& bMax) const
 348 {
 349         struct GetRandom
 350         {
 351                 int             operator() (de::Random& rnd, int min, int max) const            { return rnd.getInt(min, max); }
 352                 float   operator() (de::Random& rnd, float min, float max) const        { return getQuantizedFloat(rnd, min, max, 0.5f); }
 353         };
 354
 355         T rangeLen              = dstMax-dstMin;
 356         T subRangeLen   = GetRandom()(random, T(0), rangeLen);
 357         T aOffset               = GetRandom()(random, T(-8), T(8));
 358
 359         aMin                    = dstMin+aOffset;
 360         aMax                    = aMin+subRangeLen;
 361
 362         bMin                    = aOffset-(rangeLen-subRangeLen);
 363         bMax                    = aOffset;
 364
 365 #if defined(DE_DEBUG)
 366         T eps = T(0.001);
 367         DE_ASSERT(aMin <= aMax && bMin <= bMax);
 368         DE_ASSERT(de::inRange(aMin-bMin, dstMin-eps, dstMax+eps));
 369         DE_ASSERT(de::inRange(aMin-bMax, dstMin-eps, dstMax+eps));
 370         DE_ASSERT(de::inRange(aMax-bMin, dstMin-eps, dstMax+eps));
 371         DE_ASSERT(de::inRange(aMax-bMax, dstMin-eps, dstMax+eps));
 372 #endif
 373 }
 374
 375 template <>
 376 void ComputeSubRange::operator()<bool> (de::Random&, bool, bool, bool&, bool&, bool&, bool&) const
 377 {
 378         DE_ASSERT(DE_FALSE);
 379 }
 380
 381 SubOp::SubOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 382         : SubBase(state, Token::MINUS, valueRange)
 383 {
 384 }
 385
 386 float SubOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 387 {
 388         if (valueRange.getType().isVoid() ||
 389                 valueRange.getType().isFloatOrVec() ||
 390                 valueRange.getType().isIntOrVec())
 391                 return SubBase::getWeight(state, valueRange);
 392         else
 393                 return 0.0f;
 394 }
 395
 396 template <class ComputeValueRange, class EvaluateComp>
 397 RelationalOp<ComputeValueRange, EvaluateComp>::RelationalOp (GeneratorState& state, Token::Type operatorToken, ConstValueRangeAccess inValueRange)
 398         : BinaryOp<7, ASSOCIATIVITY_LEFT>(operatorToken)
 399 {
 400         ValueRange valueRange = inValueRange;
 401
 402         if (valueRange.getType().isVoid())
 403         {
 404                 valueRange = ValueRange(VariableType(VariableType::TYPE_BOOL, 1));
 405                 computeRandomValueRange(state, valueRange.asAccess());
 406         }
 407
 408         // Choose type, allocate storage for execution
 409         this->m_type = valueRange.getType();
 410         this->m_value.setStorage(this->m_type);
 411
 412         // Choose random input type
 413         VariableType::Type inBaseTypes[]        = { VariableType::TYPE_FLOAT, VariableType::TYPE_INT };
 414         VariableType::Type inBaseType           = state.getRandom().choose<VariableType::Type>(&inBaseTypes[0], &inBaseTypes[DE_LENGTH_OF_ARRAY(inBaseTypes)]);
 415
 416         // Initialize storage for input value ranges
 417         this->m_rightValueRange = ValueRange(VariableType(inBaseType, 1));
 418         this->m_leftValueRange  = ValueRange(VariableType(inBaseType, 1));
 419
 420         // Compute range for b that satisfies requested value range
 421         {
 422                 bool                                    dstMin  = valueRange.getMin().asBool();
 423                 bool                                    dstMax  = valueRange.getMax().asBool();
 424                 ValueRangeAccess                a               = this->m_leftValueRange.asAccess();
 425                 ValueRangeAccess                b               = this->m_rightValueRange.asAccess();
 426
 427                 if (inBaseType == VariableType::TYPE_FLOAT)
 428                         ComputeValueRange()(state.getRandom(), dstMin, dstMax,
 429                                                                 a.getMin().asFloat(), a.getMax().asFloat(),
 430                                                                 b.getMin().asFloat(), b.getMax().asFloat());
 431                 else if (inBaseType == VariableType::TYPE_INT)
 432                         ComputeValueRange()(state.getRandom(), dstMin, dstMax,
 433                                                                 a.getMin().asInt(), a.getMax().asInt(),
 434                                                                 b.getMin().asInt(), b.getMax().asInt());
 435         }
 436 }
 437
 438 template <class ComputeValueRange, class EvaluateComp>
 439 RelationalOp<ComputeValueRange, EvaluateComp>::~RelationalOp (void)
 440 {
 441 }
 442
 443 template <class ComputeValueRange, class EvaluateComp>
 444 void RelationalOp<ComputeValueRange, EvaluateComp>::evaluate (ExecValueAccess dst, ExecConstValueAccess a, ExecConstValueAccess b)
 445 {
 446         DE_ASSERT(a.getType() == b.getType());
 447         switch (a.getType().getBaseType())
 448         {
 449                 case VariableType::TYPE_FLOAT:
 450                         for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
 451                                 dst.asBool(compNdx) = EvaluateComp()(a.asFloat(compNdx), b.asFloat(compNdx));
 452                         break;
 453
 454                 case VariableType::TYPE_INT:
 455                         for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
 456                                 dst.asBool(compNdx) = EvaluateComp()(a.asInt(compNdx), b.asInt(compNdx));
 457                         break;
 458
 459                 default:
 460                         DE_ASSERT(DE_FALSE);
 461         }
 462 }
 463
 464 template <class ComputeValueRange, class EvaluateComp>
 465 float RelationalOp<ComputeValueRange, EvaluateComp>::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 466 {
 467         if (!state.getProgramParameters().useComparisonOps)
 468                 return 0.0f;
 469
 470         if (valueRange.getType().isVoid() ||
 471                 (valueRange.getType().getBaseType() == VariableType::TYPE_BOOL && valueRange.getType().getNumElements() == 1))
 472                 return BinaryOp<7, ASSOCIATIVITY_LEFT>::getWeight(state, valueRange);
 473         else
 474                 return 0.0f;
 475 }
 476
 477 namespace
 478 {
 479
 480 template <typename T>   T               getStep (void);
 481 template <> inline              float   getStep (void) { return 0.25f;  }
 482 template <> inline              int             getStep (void) { return 1;              }
 483
 484 } // anonymous
 485
 486 template <typename T>
 487 void ComputeLessThanRange::operator () (de::Random& rnd, bool dstMin, bool dstMax, T& aMin, T& aMax, T& bMin, T& bMax) const
 488 {
 489         struct GetRandom
 490         {
 491                 int             operator() (de::Random& random, int min, int max) const         { return random.getInt(min, max); }
 492                 float   operator() (de::Random& random, float min, float max) const     { return getQuantizedFloat(random, min, max, getStep<float>()); }
 493         };
 494
 495         // One random range
 496         T       rLen    = GetRandom()(rnd, T(0), T(8));
 497         T       rMin    = GetRandom()(rnd, T(-4), T(4));
 498         T       rMax    = rMin+rLen;
 499
 500         if (dstMin == false && dstMax == true)
 501         {
 502                 // Both values are possible, use same range for both inputs
 503                 aMin    = rMin;
 504                 aMax    = rMax;
 505                 bMin    = rMin;
 506                 bMax    = rMax;
 507         }
 508         else if (dstMin == true && dstMax == true)
 509         {
 510                 // Compute range that is less than rMin..rMax
 511                 T aLen = GetRandom()(rnd, T(0), T(8)-rLen);
 512
 513                 aMax    = rMin - getStep<T>();
 514                 aMin    = aMax - aLen;
 515
 516                 bMin    = rMin;
 517                 bMax    = rMax;
 518         }
 519         else
 520         {
 521                 // Compute range that is greater than or equal to rMin..rMax
 522                 T aLen = GetRandom()(rnd, T(0), T(8)-rLen);
 523
 524                 aMin    = rMax;
 525                 aMax    = aMin + aLen;
 526
 527                 bMin    = rMin;
 528                 bMax    = rMax;
 529         }
 530 }
 531
 532 LessThanOp::LessThanOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 533         : LessThanBase(state, Token::CMP_LT, valueRange)
 534 {
 535 }
 536
 537 float LessThanOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 538 {
 539         return LessThanBase::getWeight(state, valueRange);
 540 }
 541
 542 template <typename T>
 543 void ComputeLessOrEqualRange::operator () (de::Random& rnd, bool dstMin, bool dstMax, T& aMin, T& aMax, T& bMin, T& bMax) const
 544 {
 545         struct GetRandom
 546         {
 547                 int             operator() (de::Random& random, int min, int max) const         { return random.getInt(min, max); }
 548                 float   operator() (de::Random& random, float min, float max) const     { return getQuantizedFloat(random, min, max, getStep<float>()); }
 549         };
 550
 551         // One random range
 552         T       rLen    = GetRandom()(rnd, T(0), T(8));
 553         T       rMin    = GetRandom()(rnd, T(-4), T(4));
 554         T       rMax    = rMin+rLen;
 555
 556         if (dstMin == false && dstMax == true)
 557         {
 558                 // Both values are possible, use same range for both inputs
 559                 aMin    = rMin;
 560                 aMax    = rMax;
 561                 bMin    = rMin;
 562                 bMax    = rMax;
 563         }
 564         else if (dstMin == true && dstMax == true)
 565         {
 566                 // Compute range that is less than or equal to rMin..rMax
 567                 T aLen = GetRandom()(rnd, T(0), T(8)-rLen);
 568
 569                 aMax    = rMin;
 570                 aMin    = aMax - aLen;
 571
 572                 bMin    = rMin;
 573                 bMax    = rMax;
 574         }
 575         else
 576         {
 577                 // Compute range that is greater than rMin..rMax
 578                 T aLen = GetRandom()(rnd, T(0), T(8)-rLen);
 579
 580                 aMin    = rMax + getStep<T>();
 581                 aMax    = aMin + aLen;
 582
 583                 bMin    = rMin;
 584                 bMax    = rMax;
 585         }
 586 }
 587
 588 LessOrEqualOp::LessOrEqualOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 589         : LessOrEqualBase(state, Token::CMP_LE, valueRange)
 590 {
 591 }
 592
 593 float LessOrEqualOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 594 {
 595         return LessOrEqualBase::getWeight(state, valueRange);
 596 }
 597
 598 GreaterThanOp::GreaterThanOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 599         : GreaterThanBase(state, Token::CMP_GT, valueRange)
 600 {
 601 }
 602
 603 float GreaterThanOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 604 {
 605         return GreaterThanBase::getWeight(state, valueRange);
 606 }
 607
 608 GreaterOrEqualOp::GreaterOrEqualOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 609         : GreaterOrEqualBase(state, Token::CMP_GE, valueRange)
 610 {
 611 }
 612
 613 float GreaterOrEqualOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 614 {
 615         return GreaterOrEqualBase::getWeight(state, valueRange);
 616 }
 617
 618 namespace
 619 {
 620
 621 template <bool IsEqual, typename T>
 622 void computeEqualityValueRange (de::Random& rnd, bool dstMin, bool dstMax, T& aMin, T& aMax, T& bMin, T& bMax)
 623 {
 624         if (dstMin == false && dstMax == true)
 625                 ComputeLessThanRange()(rnd, false, true, aMin, aMax, bMin, bMax);
 626         else if (IsEqual && dstMin == false)
 627                 ComputeLessThanRange()(rnd, true, true, aMin, aMax, bMin, bMax);
 628         else if (!IsEqual && dstMin == true)
 629                 ComputeLessThanRange()(rnd, true, true, aMin, aMax, bMin, bMax);
 630         else
 631         {
 632                 // Must have exactly same values.
 633                 struct GetRandom
 634                 {
 635                         int             operator() (de::Random& random, int min, int max) const         { return random.getInt(min, max); }
 636                         float   operator() (de::Random& random, float min, float max) const     { return getQuantizedFloat(random, min, max, 0.5f); }
 637                 };
 638
 639                 T val = GetRandom()(rnd, T(-1), T(1));
 640
 641                 aMin    = val;
 642                 aMax    = val;
 643                 bMin    = val;
 644                 bMax    = val;
 645         }
 646 }
 647
 648 template <>
 649 void computeEqualityValueRange<true, bool> (de::Random& rnd, bool dstMin, bool dstMax, bool& aMin, bool& aMax, bool& bMin, bool& bMax)
 650 {
 651         if (dstMin == false && dstMax == true)
 652         {
 653                 aMin    = false;
 654                 aMax    = true;
 655                 bMin    = false;
 656                 bMax    = true;
 657         }
 658         else if (dstMin == false)
 659         {
 660                 DE_ASSERT(dstMax == false);
 661                 bool val = rnd.getBool();
 662
 663                 aMin    = val;
 664                 aMax    = val;
 665                 bMin    = !val;
 666                 bMax    = !val;
 667         }
 668         else
 669         {
 670                 DE_ASSERT(dstMin == true && dstMax == true);
 671                 bool val = rnd.getBool();
 672
 673                 aMin    = val;
 674                 aMax    = val;
 675                 bMin    = val;
 676                 bMax    = val;
 677         }
 678 }
 679
 680 template <>
 681 void computeEqualityValueRange<false, bool> (de::Random& rnd, bool dstMin, bool dstMax, bool& aMin, bool& aMax, bool& bMin, bool& bMax)
 682 {
 683         if (dstMin == false && dstMax == true)
 684                 computeEqualityValueRange<true>(rnd, dstMin, dstMax, aMin, aMax, bMin, bMax);
 685         else
 686                 computeEqualityValueRange<true>(rnd, !dstMin, !dstMax, aMin, aMax, bMin, bMax);
 687 }
 688
 689 } // anonymous
 690
 691 template <bool IsEqual>
 692 EqualityComparisonOp<IsEqual>::EqualityComparisonOp (GeneratorState& state, ConstValueRangeAccess inValueRange)
 693         : BinaryOp<8, ASSOCIATIVITY_LEFT>(IsEqual ? Token::CMP_EQ : Token::CMP_NE)
 694 {
 695         ValueRange valueRange = inValueRange;
 696
 697         if (valueRange.getType().isVoid())
 698         {
 699                 valueRange = ValueRange(VariableType(VariableType::TYPE_BOOL, 1));
 700                 computeRandomValueRange(state, valueRange.asAccess());
 701         }
 702
 703         // Choose type, allocate storage for execution
 704         this->m_type = valueRange.getType();
 705         this->m_value.setStorage(this->m_type);
 706
 707         // Choose random input type
 708         VariableType::Type inBaseTypes[]        = { VariableType::TYPE_FLOAT, VariableType::TYPE_INT };
 709         VariableType::Type inBaseType           = state.getRandom().choose<VariableType::Type>(&inBaseTypes[0], &inBaseTypes[DE_LENGTH_OF_ARRAY(inBaseTypes)]);
 710         int                                     availableLevels = state.getShaderParameters().maxExpressionDepth - state.getExpressionDepth();
 711         int                                     numElements             = state.getRandom().getInt(1, availableLevels >= 3 ? 4 : 1);
 712
 713         // Initialize storage for input value ranges
 714         this->m_rightValueRange = ValueRange(VariableType(inBaseType, numElements));
 715         this->m_leftValueRange  = ValueRange(VariableType(inBaseType, numElements));
 716
 717         // Compute range for b that satisfies requested value range
 718         for (int elementNdx = 0; elementNdx < numElements; elementNdx++)
 719         {
 720                 bool                                    dstMin  = valueRange.getMin().asBool();
 721                 bool                                    dstMax  = valueRange.getMax().asBool();
 722
 723                 ValueRangeAccess                a               = this->m_leftValueRange.asAccess().component(elementNdx);
 724                 ValueRangeAccess                b               = this->m_rightValueRange.asAccess().component(elementNdx);
 725
 726                 if (inBaseType == VariableType::TYPE_FLOAT)
 727                         computeEqualityValueRange<IsEqual>(state.getRandom(), dstMin, dstMax,
 728                                                                                            a.getMin().asFloat(), a.getMax().asFloat(),
 729                                                                                            b.getMin().asFloat(), b.getMax().asFloat());
 730                 else if (inBaseType == VariableType::TYPE_INT)
 731                         computeEqualityValueRange<IsEqual>(state.getRandom(), dstMin, dstMax,
 732                                                                                            a.getMin().asInt(), a.getMax().asInt(),
 733                                                                                            b.getMin().asInt(), b.getMax().asInt());
 734                 else
 735                 {
 736                         DE_ASSERT(inBaseType == VariableType::TYPE_BOOL);
 737                         computeEqualityValueRange<IsEqual>(state.getRandom(), dstMin, dstMax,
 738                                                                                            a.getMin().asBool(), a.getMax().asBool(),
 739                                                                                            b.getMin().asBool(), b.getMax().asBool());
 740                 }
 741         }
 742 }
 743
 744 template <bool IsEqual>
 745 float EqualityComparisonOp<IsEqual>::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 746 {
 747         if (!state.getProgramParameters().useComparisonOps)
 748                 return 0.0f;
 749
 750         // \todo [2011-06-13 pyry] Weight down cases that would force constant inputs.
 751
 752         if (valueRange.getType().isVoid() ||
 753                 (valueRange.getType().getBaseType() == VariableType::TYPE_BOOL && valueRange.getType().getNumElements() == 1))
 754                 return BinaryOp<8, ASSOCIATIVITY_LEFT>::getWeight(state, valueRange);
 755         else
 756                 return 0.0f;
 757 }
 758
 759 namespace
 760 {
 761
 762 template <bool IsEqual>
 763 struct EqualityCompare
 764 {
 765         template <typename T>
 766         static bool compare (T a, T b);
 767         static bool combine (bool a, bool b);
 768 };
 769
 770 template <>
 771 template <typename T>
 772 inline bool EqualityCompare<true>::compare      (T a, T b)                      { return a == b; }
 773
 774 template <>
 775 inline bool EqualityCompare<true>::combine      (bool a, bool b)        { return a && b; }
 776
 777 template <>
 778 template <typename T>
 779 inline bool EqualityCompare<false>::compare     (T a, T b)                      { return a != b; }
 780
 781 template <>
 782 inline bool EqualityCompare<false>::combine     (bool a, bool b)        { return a || b; }
 783
 784 } // anonymous
 785
 786 template <bool IsEqual>
 787 void EqualityComparisonOp<IsEqual>::evaluate (ExecValueAccess dst, ExecConstValueAccess a, ExecConstValueAccess b)
 788 {
 789         DE_ASSERT(a.getType() == b.getType());
 790
 791
 792         switch (a.getType().getBaseType())
 793         {
 794                 case VariableType::TYPE_FLOAT:
 795                         for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
 796                         {
 797                                 bool result = IsEqual ? true : false;
 798
 799                                 for (int elemNdx = 0; elemNdx < a.getType().getNumElements(); elemNdx++)
 800                                         result = EqualityCompare<IsEqual>::combine(result, EqualityCompare<IsEqual>::compare(a.component(elemNdx).asFloat(compNdx), b.component(elemNdx).asFloat(compNdx)));
 801
 802                                 dst.asBool(compNdx) = result;
 803                         }
 804                         break;
 805
 806                 case VariableType::TYPE_INT:
 807                         for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
 808                         {
 809                                 bool result = IsEqual ? true : false;
 810
 811                                 for (int elemNdx = 0; elemNdx < a.getType().getNumElements(); elemNdx++)
 812                                         result = EqualityCompare<IsEqual>::combine(result, EqualityCompare<IsEqual>::compare(a.component(elemNdx).asInt(compNdx), b.component(elemNdx).asInt(compNdx)));
 813
 814                                 dst.asBool(compNdx) = result;
 815                         }
 816                         break;
 817
 818                 case VariableType::TYPE_BOOL:
 819                         for (int compNdx = 0; compNdx < EXEC_VEC_WIDTH; compNdx++)
 820                         {
 821                                 bool result = IsEqual ? true : false;
 822
 823                                 for (int elemNdx = 0; elemNdx < a.getType().getNumElements(); elemNdx++)
 824                                         result = EqualityCompare<IsEqual>::combine(result, EqualityCompare<IsEqual>::compare(a.component(elemNdx).asBool(compNdx), b.component(elemNdx).asBool(compNdx)));
 825
 826                                 dst.asBool(compNdx) = result;
 827                         }
 828                         break;
 829
 830                 default:
 831                         DE_ASSERT(DE_FALSE);
 832         }
 833 }
 834
 835 EqualOp::EqualOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 836         : EqualityComparisonOp<true>(state, valueRange)
 837 {
 838 }
 839
 840 float EqualOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 841 {
 842         return EqualityComparisonOp<true>::getWeight(state, valueRange);
 843 }
 844
 845 NotEqualOp::NotEqualOp (GeneratorState& state, ConstValueRangeAccess valueRange)
 846         : EqualityComparisonOp<false>(state, valueRange)
 847 {
 848 }
 849
 850 float NotEqualOp::getWeight (const GeneratorState& state, ConstValueRangeAccess valueRange)
 851 {
 852         return EqualityComparisonOp<false>::getWeight(state, valueRange);
 853 }
 854
 855 } // rsg