1 /*------------------------------------------------------------------------ 2 * Vulkan Conformance Tests 3 * ------------------------ 4 * 5 * Copyright (c) 2015 The Khronos Group Inc. 6 * Copyright (c) 2015 Samsung Electronics Co., Ltd. 7 * Copyright (c) 2016 The Android Open Source Project 8 * 9 * Licensed under the Apache License, Version 2.0 (the "License"); 10 * you may not use this file except in compliance with the License. 11 * You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 * 21 *//*! 22 * \file 23 * \brief Shader operators tests. 24 *//*--------------------------------------------------------------------*/ 25 26 #include "vktShaderRenderOperatorTests.hpp" 27 #include "vktShaderRender.hpp" 28 #include "tcuVectorUtil.hpp" 29 #include "deStringUtil.hpp" 30 31 #include <limits> 32 33 using namespace tcu; 34 using namespace glu; 35 36 namespace vkt 37 { 38 namespace sr 39 { 40 namespace 41 { 42 43 #if defined(abs) 44 # undef abs 45 #endif 46 47 using de::min; 48 using de::max; 49 using de::clamp; 50 51 // \note VS2013 gets confused without these 52 using tcu::asinh; 53 using tcu::acosh; 54 using tcu::atanh; 55 using tcu::exp2; 56 using tcu::log2; 57 using tcu::trunc; 58 59 inline bool logicalAnd (bool a, bool b) { return (a && b); } 60 inline bool logicalOr (bool a, bool b) { return (a || b); } 61 inline bool logicalXor (bool a, bool b) { return (a != b); } 62 63 // \note stdlib.h defines div() that is not compatible with the macros. 64 template<typename T> inline T div (T a, T b) { return a / b; } 65 66 template<typename T> inline T leftShift (T value, int amount) { return value << amount; } 67 68 inline deUint32 rightShift (deUint32 value, int amount) { return value >> amount; } 69 inline int rightShift (int value, int amount) { return (value >> amount) | (value >= 0 ? 0 : ~(~0U >> amount)); } // \note Arithmetic shift. 70 71 template<typename T, int Size> Vector<T, Size> leftShift (const Vector<T, Size>& value, const Vector<int, Size>& amount) 72 { 73 Vector<T, Size> result; 74 for (int i = 0; i < Size; i++) 75 result[i] = leftShift(value[i], amount[i]); 76 return result; 77 } 78 79 template<typename T, int Size> Vector<T, Size> rightShift (const Vector<T, Size>& value, const Vector<int, Size>& amount) 80 { 81 Vector<T, Size> result; 82 for (int i = 0; i < Size; i++) 83 result[i] = rightShift(value[i], amount[i]); 84 return result; 85 } 86 87 template<typename T, int Size> Vector<T, Size> leftShiftVecScalar (const Vector<T, Size>& value, int amount) { return leftShift(value, Vector<int, Size>(amount)); } 88 template<typename T, int Size> Vector<T, Size> rightShiftVecScalar (const Vector<T, Size>& value, int amount) { return rightShift(value, Vector<int, Size>(amount)); } 89 90 template<typename T, int Size> 91 inline Vector<T, Size> minVecScalar (const Vector<T, Size>& v, T s) 92 { 93 Vector<T, Size> res; 94 for (int i = 0; i < Size; i++) 95 res[i] = min(v[i], s); 96 return res; 97 } 98 99 template<typename T, int Size> 100 inline Vector<T, Size> maxVecScalar (const Vector<T, Size>& v, T s) 101 { 102 Vector<T, Size> res; 103 for (int i = 0; i < Size; i++) 104 res[i] = max(v[i], s); 105 return res; 106 } 107 108 template<typename T, int Size> 109 inline Vector<T, Size> clampVecScalarScalar (const Vector<T, Size>& v, T s0, T s1) 110 { 111 Vector<T, Size> res; 112 for (int i = 0; i < Size; i++) 113 res[i] = clamp(v[i], s0, s1); 114 return res; 115 } 116 117 template<typename T, int Size> 118 inline Vector<T, Size> mixVecVecScalar (const Vector<T, Size>& v0, const Vector<T, Size>& v1, T s) 119 { 120 Vector<T, Size> res; 121 for (int i = 0; i < Size; i++) 122 res[i] = mix(v0[i], v1[i], s); 123 return res; 124 } 125 126 template<typename T, int Size> 127 inline Vector<T, Size> stepScalarVec (T s, const Vector<T, Size>& v) 128 { 129 Vector<T, Size> res; 130 for (int i = 0; i < Size; i++) 131 res[i] = step(s, v[i]); 132 return res; 133 } 134 135 template<typename T, int Size> 136 inline Vector<T, Size> smoothStepScalarScalarVec (T s0, T s1, const Vector<T, Size>& v) 137 { 138 Vector<T, Size> res; 139 for (int i = 0; i < Size; i++) 140 res[i] = smoothStep(s0, s1, v[i]); 141 return res; 142 } 143 144 inline int addOne (int v) { return v + 1; }; 145 inline int subOne (int v) { return v - 1; }; 146 inline deUint32 addOne (deUint32 v) { return v + 1; }; 147 inline deUint32 subOne (deUint32 v) { return v - 1; }; 148 149 template<int Size> inline Vector<float, Size> addOne (const Vector<float, Size>& v) { return v + 1.0f; }; 150 template<int Size> inline Vector<float, Size> subOne (const Vector<float, Size>& v) { return v - 1.0f; }; 151 template<int Size> inline Vector<int, Size> addOne (const Vector<int, Size>& v) { return v + 1; }; 152 template<int Size> inline Vector<int, Size> subOne (const Vector<int, Size>& v) { return v - 1; }; 153 template<int Size> inline Vector<deUint32, Size> addOne (const Vector<deUint32, Size>& v) { return v + 1U; }; 154 template<int Size> inline Vector<deUint32, Size> subOne (const Vector<deUint32, Size>& v) { return (v.asInt() - 1).asUint(); }; 155 156 template<typename T> inline T selection (bool cond, T a, T b) { return cond ? a : b; }; 157 158 // Vec-scalar and scalar-vec binary operators. 159 160 // \note This one is done separately due to how the overloaded minus operator is implemented for vector-scalar operands. 161 template<int Size> inline Vector<deUint32, Size> subVecScalar (const Vector<deUint32, Size>& v, deUint32 s) { return (v.asInt() - (int)s).asUint(); }; 162 163 template<typename T, int Size> inline Vector<T, Size> addVecScalar (const Vector<T, Size>& v, T s) { return v + s; }; 164 template<typename T, int Size> inline Vector<T, Size> subVecScalar (const Vector<T, Size>& v, T s) { return v - s; }; 165 template<typename T, int Size> inline Vector<T, Size> mulVecScalar (const Vector<T, Size>& v, T s) { return v * s; }; 166 template<typename T, int Size> inline Vector<T, Size> divVecScalar (const Vector<T, Size>& v, T s) { return v / s; }; 167 template<typename T, int Size> inline Vector<T, Size> modVecScalar (const Vector<T, Size>& v, T s) { return mod(v, Vector<T, Size>(s)); }; 168 template<typename T, int Size> inline Vector<T, Size> bitwiseAndVecScalar (const Vector<T, Size>& v, T s) { return bitwiseAnd(v, Vector<T, Size>(s)); }; 169 template<typename T, int Size> inline Vector<T, Size> bitwiseOrVecScalar (const Vector<T, Size>& v, T s) { return bitwiseOr(v, Vector<T, Size>(s)); }; 170 template<typename T, int Size> inline Vector<T, Size> bitwiseXorVecScalar (const Vector<T, Size>& v, T s) { return bitwiseXor(v, Vector<T, Size>(s)); }; 171 172 template<typename T, int Size> inline Vector<T, Size> addScalarVec (T s, const Vector<T, Size>& v) { return s + v; }; 173 template<typename T, int Size> inline Vector<T, Size> subScalarVec (T s, const Vector<T, Size>& v) { return s - v; }; 174 template<typename T, int Size> inline Vector<T, Size> mulScalarVec (T s, const Vector<T, Size>& v) { return s * v; }; 175 template<typename T, int Size> inline Vector<T, Size> divScalarVec (T s, const Vector<T, Size>& v) { return s / v; }; 176 template<typename T, int Size> inline Vector<T, Size> modScalarVec (T s, const Vector<T, Size>& v) { return mod(Vector<T, Size>(s), v); }; 177 template<typename T, int Size> inline Vector<T, Size> bitwiseAndScalarVec (T s, const Vector<T, Size>& v) { return bitwiseAnd(Vector<T, Size>(s), v); }; 178 template<typename T, int Size> inline Vector<T, Size> bitwiseOrScalarVec (T s, const Vector<T, Size>& v) { return bitwiseOr(Vector<T, Size>(s), v); }; 179 template<typename T, int Size> inline Vector<T, Size> bitwiseXorScalarVec (T s, const Vector<T, Size>& v) { return bitwiseXor(Vector<T, Size>(s), v); }; 180 181 // Reference functions for specific sequence operations for the sequence operator tests. 182 183 // Reference for expression "in0, in2 + in1, in1 + in0" 184 inline Vec4 sequenceNoSideEffCase0 (const Vec4& in0, const Vec4& in1, const Vec4& in2) { DE_UNREF(in2); return in1 + in0; } 185 // Reference for expression "in0, in2 + in1, in1 + in0" 186 inline deUint32 sequenceNoSideEffCase1 (float in0, deUint32 in1, float in2) { DE_UNREF(in0); DE_UNREF(in2); return in1 + in1; } 187 // Reference for expression "in0 && in1, in0, ivec2(vec2(in0) + in2)" 188 inline IVec2 sequenceNoSideEffCase2 (bool in0, bool in1, const Vec2& in2) { DE_UNREF(in1); return IVec2((int)((float)in0 + in2.x()), (int)((float)in0 + in2.y())); } 189 // Reference for expression "in0 + vec4(in1), in2, in1" 190 inline IVec4 sequenceNoSideEffCase3 (const Vec4& in0, const IVec4& in1, const BVec4& in2) { DE_UNREF(in0); DE_UNREF(in2); return in1; } 191 // Reference for expression "in0++, in1 = in0 + in2, in2 = in1" 192 inline Vec4 sequenceSideEffCase0 (const Vec4& in0, const Vec4& in1, const Vec4& in2) { DE_UNREF(in1); return in0 + 1.0f + in2; } 193 // Reference for expression "in1++, in0 = float(in1), in1 = uint(in0 + in2)" 194 inline deUint32 sequenceSideEffCase1 (float in0, deUint32 in1, float in2) { DE_UNREF(in0); return (deUint32)(float(in1) + 1.0f + in2); } 195 // Reference for expression "in1 = in0, in2++, in2 = in2 + vec2(in1), ivec2(in2)" 196 inline IVec2 sequenceSideEffCase2 (bool in0, bool in1, const Vec2& in2) { DE_UNREF(in1); return (in2 + Vec2(1.0f) + Vec2((float)in0)).asInt(); } 197 // Reference for expression "in0 = in0 + vec4(in2), in1 = in1 + ivec4(in0), in1++" 198 inline IVec4 sequenceSideEffCase3 (const Vec4& in0, const IVec4& in1, const BVec4& in2) { return in1 + (in0 + Vec4((float)in2.x(), (float)in2.y(), (float)in2.z(), (float)in2.w())).asInt(); } 199 200 // ShaderEvalFunc-type wrappers for the above functions. 201 void evalSequenceNoSideEffCase0 (ShaderEvalContext& ctx) { ctx.color = sequenceNoSideEffCase0 (ctx.in[0].swizzle(1, 2, 3, 0), ctx.in[1].swizzle(3, 2, 1, 0), ctx.in[2].swizzle(0, 3, 2, 1)); } 202 void evalSequenceNoSideEffCase1 (ShaderEvalContext& ctx) { ctx.color.x() = (float)sequenceNoSideEffCase1 (ctx.in[0].z(), (deUint32)ctx.in[1].x(), ctx.in[2].y()); } 203 void evalSequenceNoSideEffCase2 (ShaderEvalContext& ctx) { ctx.color.yz() = sequenceNoSideEffCase2 (ctx.in[0].z() > 0.0f, ctx.in[1].x() > 0.0f, ctx.in[2].swizzle(2, 1)).asFloat(); } 204 void evalSequenceNoSideEffCase3 (ShaderEvalContext& ctx) { ctx.color = sequenceNoSideEffCase3 (ctx.in[0].swizzle(1, 2, 3, 0), ctx.in[1].swizzle(3, 2, 1, 0).asInt(), greaterThan(ctx.in[2].swizzle(0, 3, 2, 1), Vec4(0.0f, 0.0f, 0.0f, 0.0f))).asFloat(); } 205 void evalSequenceSideEffCase0 (ShaderEvalContext& ctx) { ctx.color = sequenceSideEffCase0 (ctx.in[0].swizzle(1, 2, 3, 0), ctx.in[1].swizzle(3, 2, 1, 0), ctx.in[2].swizzle(0, 3, 2, 1)); } 206 void evalSequenceSideEffCase1 (ShaderEvalContext& ctx) { ctx.color.x() = (float)sequenceSideEffCase1 (ctx.in[0].z(), (deUint32)ctx.in[1].x(), ctx.in[2].y()); } 207 void evalSequenceSideEffCase2 (ShaderEvalContext& ctx) { ctx.color.yz() = sequenceSideEffCase2 (ctx.in[0].z() > 0.0f, ctx.in[1].x() > 0.0f, ctx.in[2].swizzle(2, 1)).asFloat(); } 208 void evalSequenceSideEffCase3 (ShaderEvalContext& ctx) { ctx.color = sequenceSideEffCase3 (ctx.in[0].swizzle(1, 2, 3, 0), ctx.in[1].swizzle(3, 2, 1, 0).asInt(), greaterThan(ctx.in[2].swizzle(0, 3, 2, 1), Vec4(0.0f, 0.0f, 0.0f, 0.0f))).asFloat(); } 209 210 static std::string stringJoin (const std::vector<std::string>& elems, const std::string& delim) 211 { 212 std::string result; 213 for (int i = 0; i < (int)elems.size(); i++) 214 result += (i > 0 ? delim : "") + elems[i]; 215 return result; 216 } 217 218 static std::string twoValuedVec4 (const std::string& first, const std::string& second, const BVec4& firstMask) 219 { 220 std::vector<std::string> elems(4); 221 for (int i = 0; i < 4; i++) 222 elems[i] = firstMask[i] ? first : second; 223 224 return "vec4(" + stringJoin(elems, ", ") + ")"; 225 } 226 227 enum 228 { 229 MAX_INPUTS = 3 230 }; 231 232 enum PrecisionMask 233 { 234 PRECMASK_NA = 0, //!< Precision not applicable (booleans) 235 PRECMASK_MEDIUMP = (1<<PRECISION_MEDIUMP), 236 PRECMASK_HIGHP = (1<<PRECISION_HIGHP), 237 238 PRECMASK_ALL = PRECMASK_MEDIUMP | PRECMASK_HIGHP 239 }; 240 241 enum ValueType 242 { 243 VALUE_NONE = 0, 244 VALUE_FLOAT = (1<<0), // float scalar 245 VALUE_FLOAT_VEC = (1<<1), // float vector 246 VALUE_FLOAT_GENTYPE = (1<<2), // float scalar/vector 247 VALUE_VEC3 = (1<<3), // vec3 only 248 VALUE_MATRIX = (1<<4), // matrix 249 VALUE_BOOL = (1<<5), // boolean scalar 250 VALUE_BOOL_VEC = (1<<6), // boolean vector 251 VALUE_BOOL_GENTYPE = (1<<7), // boolean scalar/vector 252 VALUE_INT = (1<<8), // int scalar 253 VALUE_INT_VEC = (1<<9), // int vector 254 VALUE_INT_GENTYPE = (1<<10), // int scalar/vector 255 VALUE_UINT = (1<<11), // uint scalar 256 VALUE_UINT_VEC = (1<<12), // uint vector 257 VALUE_UINT_GENTYPE = (1<<13), // uint scalar/vector 258 259 // Shorthands. 260 F = VALUE_FLOAT, 261 FV = VALUE_FLOAT_VEC, 262 GT = VALUE_FLOAT_GENTYPE, 263 V3 = VALUE_VEC3, 264 M = VALUE_MATRIX, 265 B = VALUE_BOOL, 266 BV = VALUE_BOOL_VEC, 267 BGT = VALUE_BOOL_GENTYPE, 268 I = VALUE_INT, 269 IV = VALUE_INT_VEC, 270 IGT = VALUE_INT_GENTYPE, 271 U = VALUE_UINT, 272 UV = VALUE_UINT_VEC, 273 UGT = VALUE_UINT_GENTYPE 274 }; 275 276 static inline bool isScalarType (ValueType type) 277 { 278 return type == VALUE_FLOAT || type == VALUE_BOOL || type == VALUE_INT || type == VALUE_UINT; 279 } 280 281 static inline bool isFloatType (ValueType type) 282 { 283 return (type & (VALUE_FLOAT | VALUE_FLOAT_VEC | VALUE_FLOAT_GENTYPE)) != 0; 284 } 285 286 static inline bool isIntType (ValueType type) 287 { 288 return (type & (VALUE_INT | VALUE_INT_VEC | VALUE_INT_GENTYPE)) != 0; 289 } 290 291 static inline bool isUintType (ValueType type) 292 { 293 return (type & (VALUE_UINT | VALUE_UINT_VEC | VALUE_UINT_GENTYPE)) != 0; 294 } 295 296 static inline bool isBoolType (ValueType type) 297 { 298 return (type & (VALUE_BOOL | VALUE_BOOL_VEC | VALUE_BOOL_GENTYPE)) != 0; 299 } 300 301 struct Value 302 { 303 Value (ValueType valueType_, const float rangeMin_, const float rangeMax_) 304 : valueType (valueType_) 305 , rangeMin (rangeMin_) 306 , rangeMax (rangeMax_) 307 { 308 } 309 310 ValueType valueType; 311 float rangeMin; 312 float rangeMax; 313 }; 314 315 enum OperationType 316 { 317 FUNCTION = 0, 318 OPERATOR, 319 SIDE_EFFECT_OPERATOR // Test the side-effect (as opposed to the result) of a side-effect operator. 320 }; 321 322 struct BuiltinFuncInfo 323 { 324 BuiltinFuncInfo (const char* caseName_, 325 const char* shaderFuncName_, 326 ValueType outValue_, 327 Value input0_, Value input1_, 328 Value input2_, 329 const float resultScale_, 330 const float resultBias_, 331 deUint32 precisionMask_, 332 ShaderEvalFunc evalFuncScalar_, 333 ShaderEvalFunc evalFuncVec2_, 334 ShaderEvalFunc evalFuncVec3_, 335 ShaderEvalFunc evalFuncVec4_, 336 OperationType type_=FUNCTION, 337 bool isUnaryPrefix_=true) 338 : caseName (caseName_) 339 , shaderFuncName (shaderFuncName_) 340 , outValue (outValue_) 341 , input0 (input0_) 342 , input1 (input1_) 343 , input2 (input2_) 344 , resultScale (resultScale_) 345 , resultBias (resultBias_) 346 , referenceScale (resultScale_) 347 , referenceBias (resultBias_) 348 , precisionMask (precisionMask_) 349 , evalFuncScalar (evalFuncScalar_) 350 , evalFuncVec2 (evalFuncVec2_) 351 , evalFuncVec3 (evalFuncVec3_) 352 , evalFuncVec4 (evalFuncVec4_) 353 , type (type_) 354 , isUnaryPrefix (isUnaryPrefix_) 355 { 356 } 357 358 BuiltinFuncInfo (const char* caseName_, 359 const char* shaderFuncName_, 360 ValueType outValue_, 361 Value input0_, 362 Value input1_, 363 Value input2_, 364 const float resultScale_, 365 const float resultBias_, 366 const float referenceScale_, 367 const float referenceBias_, 368 deUint32 precisionMask_, 369 ShaderEvalFunc evalFuncScalar_, 370 ShaderEvalFunc evalFuncVec2_, 371 ShaderEvalFunc evalFuncVec3_, 372 ShaderEvalFunc evalFuncVec4_, 373 OperationType type_=FUNCTION, 374 bool isUnaryPrefix_=true) 375 : caseName (caseName_) 376 , shaderFuncName (shaderFuncName_) 377 , outValue (outValue_) 378 , input0 (input0_) 379 , input1 (input1_) 380 , input2 (input2_) 381 , resultScale (resultScale_) 382 , resultBias (resultBias_) 383 , referenceScale (referenceScale_) 384 , referenceBias (referenceBias_) 385 , precisionMask (precisionMask_) 386 , evalFuncScalar (evalFuncScalar_) 387 , evalFuncVec2 (evalFuncVec2_) 388 , evalFuncVec3 (evalFuncVec3_) 389 , evalFuncVec4 (evalFuncVec4_) 390 , type (type_) 391 , isUnaryPrefix (isUnaryPrefix_) 392 { 393 } 394 395 const char* caseName; //!< Name of case. 396 const char* shaderFuncName; //!< Name in shading language. 397 ValueType outValue; 398 Value input0; 399 Value input1; 400 Value input2; 401 float resultScale; 402 float resultBias; 403 float referenceScale; 404 float referenceBias; 405 deUint32 precisionMask; 406 ShaderEvalFunc evalFuncScalar; 407 ShaderEvalFunc evalFuncVec2; 408 ShaderEvalFunc evalFuncVec3; 409 ShaderEvalFunc evalFuncVec4; 410 OperationType type; 411 bool isUnaryPrefix; //!< Whether a unary operator is a prefix operator; redundant unless unary. 412 }; 413 414 static inline BuiltinFuncInfo BuiltinOperInfo (const char* caseName_, const char* shaderFuncName_, ValueType outValue_, Value input0_, Value input1_, Value input2_, const float resultScale_, const float resultBias_, deUint32 precisionMask_, ShaderEvalFunc evalFuncScalar_, ShaderEvalFunc evalFuncVec2_, ShaderEvalFunc evalFuncVec3_, ShaderEvalFunc evalFuncVec4_) 415 { 416 return BuiltinFuncInfo(caseName_, shaderFuncName_, outValue_, input0_, input1_, input2_, resultScale_, resultBias_, resultScale_, resultBias_, precisionMask_, evalFuncScalar_, evalFuncVec2_, evalFuncVec3_, evalFuncVec4_, OPERATOR); 417 } 418 419 // For postfix (unary) operators. 420 static inline BuiltinFuncInfo BuiltinPostOperInfo (const char* caseName_, const char* shaderFuncName_, ValueType outValue_, Value input0_, Value input1_, Value input2_, const float resultScale_, const float resultBias_, deUint32 precisionMask_, ShaderEvalFunc evalFuncScalar_, ShaderEvalFunc evalFuncVec2_, ShaderEvalFunc evalFuncVec3_, ShaderEvalFunc evalFuncVec4_) 421 { 422 return BuiltinFuncInfo(caseName_, shaderFuncName_, outValue_, input0_, input1_, input2_, resultScale_, resultBias_, resultScale_, resultBias_, precisionMask_, evalFuncScalar_, evalFuncVec2_, evalFuncVec3_, evalFuncVec4_, OPERATOR, false); 423 } 424 425 static inline BuiltinFuncInfo BuiltinSideEffOperInfo (const char* caseName_, const char* shaderFuncName_, ValueType outValue_, Value input0_, Value input1_, Value input2_, const float resultScale_, const float resultBias_, deUint32 precisionMask_, ShaderEvalFunc evalFuncScalar_, ShaderEvalFunc evalFuncVec2_, ShaderEvalFunc evalFuncVec3_, ShaderEvalFunc evalFuncVec4_) 426 { 427 return BuiltinFuncInfo(caseName_, shaderFuncName_, outValue_, input0_, input1_, input2_, resultScale_, resultBias_, resultScale_, resultBias_, precisionMask_, evalFuncScalar_, evalFuncVec2_, evalFuncVec3_, evalFuncVec4_, SIDE_EFFECT_OPERATOR); 428 } 429 430 // For postfix (unary) operators, testing side-effect. 431 static inline BuiltinFuncInfo BuiltinPostSideEffOperInfo (const char* caseName_, const char* shaderFuncName_, ValueType outValue_, Value input0_, Value input1_, Value input2_, const float resultScale_, const float resultBias_, deUint32 precisionMask_, ShaderEvalFunc evalFuncScalar_, ShaderEvalFunc evalFuncVec2_, ShaderEvalFunc evalFuncVec3_, ShaderEvalFunc evalFuncVec4_) 432 { 433 return BuiltinFuncInfo(caseName_, shaderFuncName_, outValue_, input0_, input1_, input2_, resultScale_, resultBias_, resultScale_, resultBias_, precisionMask_, evalFuncScalar_, evalFuncVec2_, evalFuncVec3_, evalFuncVec4_, SIDE_EFFECT_OPERATOR, false); 434 } 435 436 // BuiltinFuncGroup 437 438 struct BuiltinFuncGroup 439 { 440 BuiltinFuncGroup (const char* name_, const char* description_) : name(name_), description(description_) {} 441 BuiltinFuncGroup& operator<< (const BuiltinFuncInfo& info) { funcInfos.push_back(info); return *this; } 442 443 const char* name; 444 const char* description; 445 std::vector<BuiltinFuncInfo> funcInfos; 446 }; 447 448 static const char* s_inSwizzles[MAX_INPUTS][4] = 449 { 450 { "z", "wy", "zxy", "yzwx" }, 451 { "x", "yx", "yzx", "wzyx" }, 452 { "y", "zy", "wyz", "xwzy" } 453 }; 454 455 static const char* s_outSwizzles[] = { "x", "yz", "xyz", "xyzw" }; 456 457 static const BVec4 s_outSwizzleChannelMasks[] = 458 { 459 BVec4(true, false, false, false), 460 BVec4(false, true, true, false), 461 BVec4(true, true, true, false), 462 BVec4(true, true, true, true ) 463 }; 464 465 // OperatorShaderEvaluator 466 467 class OperatorShaderEvaluator : public ShaderEvaluator 468 { 469 public: 470 OperatorShaderEvaluator (const ShaderEvalFunc evalFunc, const float scale, const float bias, int resultScalarSize) 471 : m_evalFunc (evalFunc) 472 , m_resultScalarSize (resultScalarSize) 473 , m_evaluatedScale (scale) 474 , m_evaluatedBias (bias) 475 { 476 DE_ASSERT(de::inRange(resultScalarSize, 1, 4)); 477 } 478 479 virtual ~OperatorShaderEvaluator (void) 480 { 481 } 482 483 virtual void evaluate (ShaderEvalContext& ctx) const 484 { 485 m_evalFunc(ctx); 486 487 for (int channelNdx = 0; channelNdx < 4; channelNdx++) 488 if (s_outSwizzleChannelMasks[m_resultScalarSize - 1][channelNdx]) 489 ctx.color[channelNdx] = ctx.color[channelNdx] * m_evaluatedScale + m_evaluatedBias; 490 } 491 492 private: 493 const ShaderEvalFunc m_evalFunc; 494 const int m_resultScalarSize; 495 496 const float m_evaluatedScale; 497 const float m_evaluatedBias; 498 }; 499 500 // Concrete value. 501 502 struct ShaderValue 503 { 504 ShaderValue (DataType type_, const float rangeMin_, const float rangeMax_) 505 : type (type_) 506 , rangeMin (rangeMin_) 507 , rangeMax (rangeMax_) 508 { 509 } 510 511 ShaderValue (void) 512 : type (TYPE_LAST) 513 , rangeMin (0.0f) 514 , rangeMax (0.0f) 515 { 516 } 517 518 DataType type; 519 float rangeMin; 520 float rangeMax; 521 }; 522 523 struct ShaderDataSpec 524 { 525 ShaderDataSpec (void) 526 : resultScale (1.0f) 527 , resultBias (0.0f) 528 , referenceScale (1.0f) 529 , referenceBias (0.0f) 530 , precision (PRECISION_LAST) 531 , output (TYPE_LAST) 532 , numInputs (0) 533 { 534 } 535 536 float resultScale; 537 float resultBias; 538 float referenceScale; 539 float referenceBias; 540 Precision precision; 541 DataType output; 542 int numInputs; 543 ShaderValue inputs[MAX_INPUTS]; 544 }; 545 546 // ShaderOperatorInstance 547 548 class ShaderOperatorCaseInstance : public ShaderRenderCaseInstance 549 { 550 public: 551 ShaderOperatorCaseInstance (Context& context, 552 const bool isVertexCase, 553 const ShaderEvaluator& evaluator, 554 const UniformSetup& uniformSetup, 555 const ShaderDataSpec spec); 556 virtual ~ShaderOperatorCaseInstance (void); 557 558 private: 559 const ShaderDataSpec m_spec; 560 }; 561 562 ShaderOperatorCaseInstance::ShaderOperatorCaseInstance (Context& context, 563 const bool isVertexCase, 564 const ShaderEvaluator& evaluator, 565 const UniformSetup& uniformSetup, 566 const ShaderDataSpec spec) 567 : ShaderRenderCaseInstance (context, isVertexCase, evaluator, uniformSetup, DE_NULL, IMAGE_BACKING_MODE_REGULAR, 568 (isVertexCase ? 92 : GRID_SIZE_DEFAULT_FRAGMENT)) 569 , m_spec (spec) 570 { 571 // Setup the user attributes. 572 m_userAttribTransforms.resize(m_spec.numInputs); 573 for (int inputNdx = 0; inputNdx < m_spec.numInputs; inputNdx++) 574 { 575 const ShaderValue& v = m_spec.inputs[inputNdx]; 576 DE_ASSERT(v.type != TYPE_LAST); 577 578 const float rangeMin = v.rangeMin; 579 const float rangeMax = v.rangeMax; 580 const float scale = rangeMax - rangeMin; 581 const float minBias = rangeMin; 582 const float maxBias = rangeMax; 583 Mat4 attribMatrix; 584 585 for (int rowNdx = 0; rowNdx < 4; rowNdx++) 586 { 587 Vec4 row; 588 589 switch ((rowNdx + inputNdx) % 4) 590 { 591 case 0: row = Vec4(scale, 0.0f, 0.0f, minBias); break; 592 case 1: row = Vec4(0.0f, scale, 0.0f, minBias); break; 593 case 2: row = Vec4(-scale, 0.0f, 0.0f, maxBias); break; 594 case 3: row = Vec4(0.0f, -scale, 0.0f, maxBias); break; 595 default: DE_ASSERT(false); 596 } 597 598 attribMatrix.setRow(rowNdx, row); 599 } 600 601 m_userAttribTransforms[inputNdx] = attribMatrix; 602 603 const deUint32 location = 4u + inputNdx; 604 switch(inputNdx) 605 { 606 case 0: useAttribute(location, A_IN0); break; 607 case 1: useAttribute(location, A_IN1); break; 608 case 2: useAttribute(location, A_IN2); break; 609 case 3: useAttribute(location, A_IN3); break; 610 default: DE_ASSERT(false); 611 } 612 } 613 } 614 615 ShaderOperatorCaseInstance::~ShaderOperatorCaseInstance (void) 616 { 617 } 618 619 // ShaderOperatorCase 620 621 class ShaderOperatorCase : public ShaderRenderCase 622 { 623 public: 624 ShaderOperatorCase (tcu::TestContext& testCtx, 625 const char* caseName, 626 const char* description, 627 const bool isVertexCase, 628 const ShaderEvalFunc evalFunc, 629 const std::string& shaderOp, 630 const ShaderDataSpec& spec); 631 virtual ~ShaderOperatorCase (void); 632 633 virtual TestInstance* createInstance (Context& context) const; 634 635 protected: 636 void setupShaderData (void); 637 638 private: 639 ShaderOperatorCase (const ShaderOperatorCase&); // not allowed! 640 ShaderOperatorCase& operator= (const ShaderOperatorCase&); // not allowed! 641 642 const ShaderDataSpec m_spec; 643 const std::string m_shaderOp; 644 }; 645 646 ShaderOperatorCase::ShaderOperatorCase (tcu::TestContext& testCtx, 647 const char* caseName, 648 const char* description, 649 const bool isVertexCase, 650 const ShaderEvalFunc evalFunc, 651 const std::string& shaderOp, 652 const ShaderDataSpec& spec) 653 : ShaderRenderCase (testCtx, 654 caseName, 655 description, 656 isVertexCase, 657 new OperatorShaderEvaluator(evalFunc, spec.referenceScale, spec.referenceBias, getDataTypeScalarSize(spec.output)), 658 DE_NULL, 659 DE_NULL) 660 , m_spec (spec) 661 , m_shaderOp (shaderOp) 662 { 663 setupShaderData(); 664 } 665 666 TestInstance* ShaderOperatorCase::createInstance (Context& context) const 667 { 668 DE_ASSERT(m_evaluator != DE_NULL); 669 DE_ASSERT(m_uniformSetup != DE_NULL); 670 return new ShaderOperatorCaseInstance(context, m_isVertexCase, *m_evaluator, *m_uniformSetup, m_spec); 671 } 672 673 674 void ShaderOperatorCase::setupShaderData (void) 675 { 676 const char* precision = m_spec.precision != PRECISION_LAST ? getPrecisionName(m_spec.precision) : DE_NULL; 677 const char* inputPrecision[MAX_INPUTS]; 678 679 std::ostringstream vtx; 680 std::ostringstream frag; 681 std::ostringstream& op = m_isVertexCase ? vtx : frag; 682 683 std::string header = 684 "#version 310 es\n"; 685 686 vtx << header; 687 frag << header; 688 689 // Compute precision for inputs. 690 for (int inputNdx = 0; inputNdx < m_spec.numInputs; inputNdx++) 691 { 692 const bool isBoolVal = de::inRange<int>(m_spec.inputs[inputNdx].type, TYPE_BOOL, TYPE_BOOL_VEC4); 693 const bool isIntVal = de::inRange<int>(m_spec.inputs[inputNdx].type, TYPE_INT, TYPE_INT_VEC4); 694 const bool isUintVal = de::inRange<int>(m_spec.inputs[inputNdx].type, TYPE_UINT, TYPE_UINT_VEC4); 695 // \note Mediump interpolators are used for booleans, and highp for integers. 696 const Precision prec = isBoolVal ? PRECISION_MEDIUMP 697 : isIntVal || isUintVal ? PRECISION_HIGHP 698 : m_spec.precision; 699 inputPrecision[inputNdx] = getPrecisionName(prec); 700 } 701 702 // Attributes. 703 vtx << "layout(location = 0) in highp vec4 a_position;\n"; 704 for (int inputNdx = 0; inputNdx < m_spec.numInputs; inputNdx++) 705 vtx << "layout(location = " << 4 + inputNdx << ") in " << inputPrecision[inputNdx] << " vec4 a_in" << inputNdx << ";\n"; 706 707 // Color output. 708 frag << "layout(location = 0) out mediump vec4 o_color;\n"; 709 710 if (m_isVertexCase) 711 { 712 vtx << "layout(location = 0) out mediump vec4 v_color;\n"; 713 frag << "layout(location = 0) in mediump vec4 v_color;\n"; 714 } 715 else 716 { 717 for (int inputNdx = 0; inputNdx < m_spec.numInputs; inputNdx++) 718 { 719 vtx << "layout(location = " << inputNdx + 1 << ") out " << inputPrecision[inputNdx] << " vec4 v_in" << inputNdx << ";\n"; 720 frag << "layout(location = " << inputNdx + 1 << ") in " << inputPrecision[inputNdx] << " vec4 v_in" << inputNdx << ";\n"; 721 } 722 } 723 724 vtx << "\n"; 725 vtx << "void main()\n"; 726 vtx << "{\n"; 727 vtx << " gl_Position = a_position;\n"; 728 729 frag << "\n"; 730 frag << "void main()\n"; 731 frag << "{\n"; 732 733 // Expression inputs. 734 const std::string prefix = m_isVertexCase ? "a_" : "v_"; 735 for (int inputNdx = 0; inputNdx < m_spec.numInputs; inputNdx++) 736 { 737 const DataType inType = m_spec.inputs[inputNdx].type; 738 const int inSize = getDataTypeScalarSize(inType); 739 const bool isInt = de::inRange<int>(inType, TYPE_INT, TYPE_INT_VEC4); 740 const bool isUint = de::inRange<int>(inType, TYPE_UINT, TYPE_UINT_VEC4); 741 const bool isBool = de::inRange<int>(inType, TYPE_BOOL, TYPE_BOOL_VEC4); 742 const char* typeName = getDataTypeName(inType); 743 const char* swizzle = s_inSwizzles[inputNdx][inSize - 1]; 744 745 op << "\t"; 746 if (precision && !isBool) op << precision << " "; 747 748 op << typeName << " in" << inputNdx << " = "; 749 750 if (isBool) 751 { 752 if (inSize == 1) op << "("; 753 else op << "greaterThan("; 754 } 755 else if (isInt || isUint) 756 op << typeName << "("; 757 758 op << prefix << "in" << inputNdx << "." << swizzle; 759 760 if (isBool) 761 { 762 if (inSize == 1) op << " > 0.0)"; 763 else op << ", vec" << inSize << "(0.0))"; 764 } 765 else if (isInt || isUint) 766 op << ")"; 767 768 op << ";\n"; 769 } 770 771 // Result variable. 772 { 773 const char* outTypeName = getDataTypeName(m_spec.output); 774 const bool isBoolOut = de::inRange<int>(m_spec.output, TYPE_BOOL, TYPE_BOOL_VEC4); 775 776 op << "\t"; 777 if (precision && !isBoolOut) op << precision << " "; 778 op << outTypeName << " res = " << outTypeName << "(0.0);\n\n"; 779 } 780 781 // Expression. 782 op << "\t" << m_shaderOp << "\n\n"; 783 784 // Convert to color. 785 const bool isResFloatVec = de::inRange<int>(m_spec.output, TYPE_FLOAT, TYPE_FLOAT_VEC4); 786 const int outScalarSize = getDataTypeScalarSize(m_spec.output); 787 788 op << "\thighp vec4 color = vec4(0.0, 0.0, 0.0, 1.0);\n"; 789 op << "\tcolor." << s_outSwizzles[outScalarSize-1] << " = "; 790 791 if (!isResFloatVec && outScalarSize == 1) 792 op << "float(res)"; 793 else if (!isResFloatVec) 794 op << "vec" << outScalarSize << "(res)"; 795 else 796 op << "res"; 797 798 op << ";\n"; 799 800 // Scale & bias. 801 const float resultScale = m_spec.resultScale; 802 const float resultBias = m_spec.resultBias; 803 if ((resultScale != 1.0f) || (resultBias != 0.0f)) 804 { 805 op << "\tcolor = color"; 806 if (resultScale != 1.0f) op << " * " << twoValuedVec4(de::toString(resultScale), "1.0", s_outSwizzleChannelMasks[outScalarSize - 1]); 807 if (resultBias != 0.0f) op << " + " << twoValuedVec4(de::floatToString(resultBias, 2), "0.0", s_outSwizzleChannelMasks[outScalarSize - 1]); 808 op << ";\n"; 809 } 810 811 // .. 812 if (m_isVertexCase) 813 { 814 vtx << " v_color = color;\n"; 815 frag << " o_color = v_color;\n"; 816 } 817 else 818 { 819 for (int inputNdx = 0; inputNdx < m_spec.numInputs; inputNdx++) 820 vtx << " v_in" << inputNdx << " = a_in" << inputNdx << ";\n"; 821 frag << " o_color = color;\n"; 822 } 823 824 vtx << "}\n"; 825 frag << "}\n"; 826 827 m_vertShaderSource = vtx.str(); 828 m_fragShaderSource = frag.str(); 829 } 830 831 ShaderOperatorCase::~ShaderOperatorCase (void) 832 { 833 } 834 835 // Vector math functions. 836 template<typename T> inline T nop (T f) { return f; } 837 838 template <typename T, int Size> 839 Vector<T, Size> nop (const Vector<T, Size>& v) { return v; } 840 841 #define DECLARE_UNARY_GENTYPE_FUNCS(FUNC_NAME) \ 842 void eval_##FUNC_NAME##_float (ShaderEvalContext& c) { c.color.x() = FUNC_NAME(c.in[0].swizzle(2)).x(); } \ 843 void eval_##FUNC_NAME##_vec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1)); } \ 844 void eval_##FUNC_NAME##_vec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1)); } \ 845 void eval_##FUNC_NAME##_vec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0)); } 846 847 #define DECLARE_BINARY_GENTYPE_FUNCS(FUNC_NAME) \ 848 void eval_##FUNC_NAME##_float (ShaderEvalContext& c) { c.color.x() = FUNC_NAME(c.in[0].swizzle(2), c.in[1].swizzle(0)).x(); } \ 849 void eval_##FUNC_NAME##_vec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1), c.in[1].swizzle(1, 0)); } \ 850 void eval_##FUNC_NAME##_vec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1), c.in[1].swizzle(1, 2, 0)); } \ 851 void eval_##FUNC_NAME##_vec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0), c.in[1].swizzle(3, 2, 1, 0)); } 852 853 #define DECLARE_TERNARY_GENTYPE_FUNCS(FUNC_NAME) \ 854 void eval_##FUNC_NAME##_float (ShaderEvalContext& c) { c.color.x() = FUNC_NAME(c.in[0].swizzle(2), c.in[1].swizzle(0), c.in[2].swizzle(1)).x(); } \ 855 void eval_##FUNC_NAME##_vec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1), c.in[1].swizzle(1, 0), c.in[2].swizzle(2, 1)); } \ 856 void eval_##FUNC_NAME##_vec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1), c.in[1].swizzle(1, 2, 0), c.in[2].swizzle(3, 1, 2)); } \ 857 void eval_##FUNC_NAME##_vec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0), c.in[1].swizzle(3, 2, 1, 0), c.in[2].swizzle(0, 3, 2, 1)); } 858 859 #define DECLARE_UNARY_SCALAR_GENTYPE_FUNCS(FUNC_NAME) \ 860 void eval_##FUNC_NAME##_float (ShaderEvalContext& c) { c.color.x() = FUNC_NAME(c.in[0].swizzle(2)); } \ 861 void eval_##FUNC_NAME##_vec2 (ShaderEvalContext& c) { c.color.x() = FUNC_NAME(c.in[0].swizzle(3, 1)); } \ 862 void eval_##FUNC_NAME##_vec3 (ShaderEvalContext& c) { c.color.x() = FUNC_NAME(c.in[0].swizzle(2, 0, 1)); } \ 863 void eval_##FUNC_NAME##_vec4 (ShaderEvalContext& c) { c.color.x() = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0)); } 864 865 #define DECLARE_BINARY_SCALAR_GENTYPE_FUNCS(FUNC_NAME) \ 866 void eval_##FUNC_NAME##_float (ShaderEvalContext& c) { c.color.x() = FUNC_NAME(c.in[0].swizzle(2), c.in[1].swizzle(0)); } \ 867 void eval_##FUNC_NAME##_vec2 (ShaderEvalContext& c) { c.color.x() = FUNC_NAME(c.in[0].swizzle(3, 1), c.in[1].swizzle(1, 0)); } \ 868 void eval_##FUNC_NAME##_vec3 (ShaderEvalContext& c) { c.color.x() = FUNC_NAME(c.in[0].swizzle(2, 0, 1), c.in[1].swizzle(1, 2, 0)); } \ 869 void eval_##FUNC_NAME##_vec4 (ShaderEvalContext& c) { c.color.x() = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0), c.in[1].swizzle(3, 2, 1, 0)); } 870 871 #define DECLARE_BINARY_BOOL_FUNCS(FUNC_NAME) \ 872 void eval_##FUNC_NAME##_bool (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(c.in[0].z() > 0.0f, c.in[1].x() > 0.0f); } 873 874 #define DECLARE_UNARY_BOOL_GENTYPE_FUNCS(FUNC_NAME) \ 875 void eval_##FUNC_NAME##_bool (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(c.in[0].z() > 0.0f); } \ 876 void eval_##FUNC_NAME##_bvec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(greaterThan(c.in[0].swizzle(3, 1), Vec2(0.0f))).asFloat(); } \ 877 void eval_##FUNC_NAME##_bvec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(greaterThan(c.in[0].swizzle(2, 0, 1), Vec3(0.0f))).asFloat(); } \ 878 void eval_##FUNC_NAME##_bvec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(greaterThan(c.in[0].swizzle(1, 2, 3, 0), Vec4(0.0f))).asFloat(); } 879 880 #define DECLARE_TERNARY_BOOL_GENTYPE_FUNCS(FUNC_NAME) \ 881 void eval_##FUNC_NAME##_bool (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(c.in[0].z() > 0.0f, c.in[1].x() > 0.0f, c.in[2].y() > 0.0f); } \ 882 void eval_##FUNC_NAME##_bvec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(greaterThan(c.in[0].swizzle(3, 1), Vec2(0.0f)), greaterThan(c.in[1].swizzle(1, 0), Vec2(0.0f)), greaterThan(c.in[2].swizzle(2, 1), Vec2(0.0f))).asFloat(); } \ 883 void eval_##FUNC_NAME##_bvec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(greaterThan(c.in[0].swizzle(2, 0, 1), Vec3(0.0f)), greaterThan(c.in[1].swizzle(1, 2, 0), Vec3(0.0f)), greaterThan(c.in[2].swizzle(3, 1, 2), Vec3(0.0f))).asFloat(); } \ 884 void eval_##FUNC_NAME##_bvec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(greaterThan(c.in[0].swizzle(1, 2, 3, 0), Vec4(0.0f)), greaterThan(c.in[1].swizzle(3, 2, 1, 0), Vec4(0.0f)), greaterThan(c.in[2].swizzle(0, 3, 2, 1), Vec4(0.0f))).asFloat(); } 885 886 #define DECLARE_UNARY_INT_GENTYPE_FUNCS(FUNC_NAME) \ 887 void eval_##FUNC_NAME##_int (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME((int)c.in[0].z()); } \ 888 void eval_##FUNC_NAME##_ivec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1).asInt()).asFloat(); } \ 889 void eval_##FUNC_NAME##_ivec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1).asInt()).asFloat(); } \ 890 void eval_##FUNC_NAME##_ivec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0).asInt()).asFloat(); } 891 892 #define DECLARE_BINARY_INT_GENTYPE_FUNCS(FUNC_NAME) \ 893 void eval_##FUNC_NAME##_int (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME((int)c.in[0].z(), (int)c.in[1].x()); } \ 894 void eval_##FUNC_NAME##_ivec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1).asInt(), c.in[1].swizzle(1, 0).asInt()).asFloat(); } \ 895 void eval_##FUNC_NAME##_ivec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1).asInt(), c.in[1].swizzle(1, 2, 0).asInt()).asFloat(); } \ 896 void eval_##FUNC_NAME##_ivec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0).asInt(), c.in[1].swizzle(3, 2, 1, 0).asInt()).asFloat(); } 897 898 #define DECLARE_UNARY_UINT_GENTYPE_FUNCS(FUNC_NAME) \ 899 void eval_##FUNC_NAME##_uint (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME((deUint32)c.in[0].z()); } \ 900 void eval_##FUNC_NAME##_uvec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1).asUint()).asFloat(); } \ 901 void eval_##FUNC_NAME##_uvec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1).asUint()).asFloat(); } \ 902 void eval_##FUNC_NAME##_uvec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0).asUint()).asFloat(); } 903 904 #define DECLARE_BINARY_UINT_GENTYPE_FUNCS(FUNC_NAME) \ 905 void eval_##FUNC_NAME##_uint (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME((deUint32)c.in[0].z(), (deUint32)c.in[1].x()); } \ 906 void eval_##FUNC_NAME##_uvec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1).asUint(), c.in[1].swizzle(1, 0).asUint()).asFloat(); } \ 907 void eval_##FUNC_NAME##_uvec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1).asUint(), c.in[1].swizzle(1, 2, 0).asUint()).asFloat(); } \ 908 void eval_##FUNC_NAME##_uvec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0).asUint(), c.in[1].swizzle(3, 2, 1, 0).asUint()).asFloat(); } 909 910 #define DECLARE_TERNARY_INT_GENTYPE_FUNCS(FUNC_NAME) \ 911 void eval_##FUNC_NAME##_int (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME((int)c.in[0].z(), (int)c.in[1].x(), (int)c.in[2].y()); } \ 912 void eval_##FUNC_NAME##_ivec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1).asInt(), c.in[1].swizzle(1, 0).asInt(), c.in[2].swizzle(2, 1).asInt()).asFloat(); } \ 913 void eval_##FUNC_NAME##_ivec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1).asInt(), c.in[1].swizzle(1, 2, 0).asInt(), c.in[2].swizzle(3, 1, 2).asInt()).asFloat(); } \ 914 void eval_##FUNC_NAME##_ivec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0).asInt(), c.in[1].swizzle(3, 2, 1, 0).asInt(), c.in[2].swizzle(0, 3, 2, 1).asInt()).asFloat(); } 915 916 #define DECLARE_TERNARY_UINT_GENTYPE_FUNCS(FUNC_NAME) \ 917 void eval_##FUNC_NAME##_uint (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME((deUint32)c.in[0].z(), (deUint32)c.in[1].x(), (deUint32)c.in[2].y()); } \ 918 void eval_##FUNC_NAME##_uvec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1).asUint(), c.in[1].swizzle(1, 0).asUint(), c.in[2].swizzle(2, 1).asUint()).asFloat(); } \ 919 void eval_##FUNC_NAME##_uvec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1).asUint(), c.in[1].swizzle(1, 2, 0).asUint(), c.in[2].swizzle(3, 1, 2).asUint()).asFloat(); } \ 920 void eval_##FUNC_NAME##_uvec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0).asUint(), c.in[1].swizzle(3, 2, 1, 0).asUint(), c.in[2].swizzle(0, 3, 2, 1).asUint()).asFloat(); } 921 922 #define DECLARE_VEC_FLOAT_FUNCS(FUNC_NAME) \ 923 void eval_##FUNC_NAME##_vec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1), c.in[1].x()); } \ 924 void eval_##FUNC_NAME##_vec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1), c.in[1].x()); } \ 925 void eval_##FUNC_NAME##_vec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0), c.in[1].x()); } 926 927 #define DECLARE_VEC_FLOAT_FLOAT_FUNCS(FUNC_NAME) \ 928 void eval_##FUNC_NAME##_vec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1), c.in[1].x(), c.in[2].y()); } \ 929 void eval_##FUNC_NAME##_vec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1), c.in[1].x(), c.in[2].y()); } \ 930 void eval_##FUNC_NAME##_vec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0), c.in[1].x(), c.in[2].y()); } 931 932 #define DECLARE_VEC_VEC_FLOAT_FUNCS(FUNC_NAME) \ 933 void eval_##FUNC_NAME##_vec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1), c.in[1].swizzle(1, 0), c.in[2].y()); } \ 934 void eval_##FUNC_NAME##_vec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1), c.in[1].swizzle(1, 2, 0), c.in[2].y()); } \ 935 void eval_##FUNC_NAME##_vec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0), c.in[1].swizzle(3, 2, 1, 0), c.in[2].y()); } 936 937 #define DECLARE_FLOAT_FLOAT_VEC_FUNCS(FUNC_NAME) \ 938 void eval_##FUNC_NAME##_vec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].z(), c.in[1].x(), c.in[2].swizzle(2, 1)); } \ 939 void eval_##FUNC_NAME##_vec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].z(), c.in[1].x(), c.in[2].swizzle(3, 1, 2)); } \ 940 void eval_##FUNC_NAME##_vec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].z(), c.in[1].x(), c.in[2].swizzle(0, 3, 2, 1)); } 941 942 #define DECLARE_FLOAT_VEC_FUNCS(FUNC_NAME) \ 943 void eval_##FUNC_NAME##_vec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].z(), c.in[1].swizzle(1, 0)); } \ 944 void eval_##FUNC_NAME##_vec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].z(), c.in[1].swizzle(1, 2, 0)); } \ 945 void eval_##FUNC_NAME##_vec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].z(), c.in[1].swizzle(3, 2, 1, 0)); } 946 947 #define DECLARE_IVEC_INT_FUNCS(FUNC_NAME) \ 948 void eval_##FUNC_NAME##_ivec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1).asInt(), (int)c.in[1].x()).asFloat(); } \ 949 void eval_##FUNC_NAME##_ivec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1).asInt(), (int)c.in[1].x()).asFloat(); } \ 950 void eval_##FUNC_NAME##_ivec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0).asInt(), (int)c.in[1].x()).asFloat(); } 951 952 #define DECLARE_IVEC_INT_INT_FUNCS(FUNC_NAME) \ 953 void eval_##FUNC_NAME##_ivec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1).asInt(), (int)c.in[1].x(), (int)c.in[2].y()).asFloat(); } \ 954 void eval_##FUNC_NAME##_ivec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1).asInt(), (int)c.in[1].x(), (int)c.in[2].y()).asFloat(); } \ 955 void eval_##FUNC_NAME##_ivec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0).asInt(), (int)c.in[1].x(), (int)c.in[2].y()).asFloat(); } 956 957 #define DECLARE_INT_IVEC_FUNCS(FUNC_NAME) \ 958 void eval_##FUNC_NAME##_ivec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME((int)c.in[0].z(), c.in[1].swizzle(1, 0).asInt()).asFloat(); } \ 959 void eval_##FUNC_NAME##_ivec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME((int)c.in[0].z(), c.in[1].swizzle(1, 2, 0).asInt()).asFloat(); } \ 960 void eval_##FUNC_NAME##_ivec4 (ShaderEvalContext& c) { c.color = FUNC_NAME((int)c.in[0].z(), c.in[1].swizzle(3, 2, 1, 0).asInt()).asFloat(); } 961 962 #define DECLARE_UVEC_UINT_FUNCS(FUNC_NAME) \ 963 void eval_##FUNC_NAME##_uvec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1).asUint(), (deUint32)c.in[1].x()).asFloat(); } \ 964 void eval_##FUNC_NAME##_uvec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1).asUint(), (deUint32)c.in[1].x()).asFloat(); } \ 965 void eval_##FUNC_NAME##_uvec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0).asUint(), (deUint32)c.in[1].x()).asFloat(); } 966 967 #define DECLARE_UVEC_UINT_UINT_FUNCS(FUNC_NAME) \ 968 void eval_##FUNC_NAME##_uvec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1).asUint(), (deUint32)c.in[1].x(), (deUint32)c.in[2].y()).asFloat(); } \ 969 void eval_##FUNC_NAME##_uvec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1).asUint(), (deUint32)c.in[1].x(), (deUint32)c.in[2].y()).asFloat(); } \ 970 void eval_##FUNC_NAME##_uvec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0).asUint(), (deUint32)c.in[1].x(), (deUint32)c.in[2].y()).asFloat(); } 971 972 #define DECLARE_UINT_UVEC_FUNCS(FUNC_NAME) \ 973 void eval_##FUNC_NAME##_uvec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME((deUint32)c.in[0].z(), c.in[1].swizzle(1, 0).asUint()).asFloat(); } \ 974 void eval_##FUNC_NAME##_uvec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME((deUint32)c.in[0].z(), c.in[1].swizzle(1, 2, 0).asUint()).asFloat(); } \ 975 void eval_##FUNC_NAME##_uvec4 (ShaderEvalContext& c) { c.color = FUNC_NAME((deUint32)c.in[0].z(), c.in[1].swizzle(3, 2, 1, 0).asUint()).asFloat(); } 976 977 #define DECLARE_BINARY_INT_VEC_FUNCS(FUNC_NAME) \ 978 void eval_##FUNC_NAME##_ivec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1).asInt(), c.in[1].swizzle(1, 0).asInt()).asFloat(); } \ 979 void eval_##FUNC_NAME##_ivec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1).asInt(), c.in[1].swizzle(1, 2, 0).asInt()).asFloat(); } \ 980 void eval_##FUNC_NAME##_ivec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0).asInt(), c.in[1].swizzle(3, 2, 1, 0).asInt()).asFloat(); } 981 982 #define DECLARE_BINARY_UINT_VEC_FUNCS(FUNC_NAME) \ 983 void eval_##FUNC_NAME##_uvec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1).asUint(), c.in[1].swizzle(1, 0).asUint()).asFloat(); } \ 984 void eval_##FUNC_NAME##_uvec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1).asUint(), c.in[1].swizzle(1, 2, 0).asUint()).asFloat(); } \ 985 void eval_##FUNC_NAME##_uvec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0).asUint(), c.in[1].swizzle(3, 2, 1, 0).asUint()).asFloat(); } 986 987 #define DECLARE_UINT_INT_GENTYPE_FUNCS(FUNC_NAME) \ 988 void eval_##FUNC_NAME##_uint (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME((deUint32)c.in[0].z(), (int)c.in[1].x()); } \ 989 void eval_##FUNC_NAME##_uvec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1).asUint(), c.in[1].swizzle(1, 0).asInt()).asFloat(); } \ 990 void eval_##FUNC_NAME##_uvec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1).asUint(), c.in[1].swizzle(1, 2, 0).asInt()).asFloat(); } \ 991 void eval_##FUNC_NAME##_uvec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0).asUint(), c.in[1].swizzle(3, 2, 1, 0).asInt()).asFloat(); } 992 993 #define DECLARE_UVEC_INT_FUNCS(FUNC_NAME) \ 994 void eval_##FUNC_NAME##_uvec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1).asUint(), (int)c.in[1].x()).asFloat(); } \ 995 void eval_##FUNC_NAME##_uvec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1).asUint(), (int)c.in[1].x()).asFloat(); } \ 996 void eval_##FUNC_NAME##_uvec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0).asUint(), (int)c.in[1].x()).asFloat(); } 997 998 999 // Operators. 1000 1001 DECLARE_UNARY_GENTYPE_FUNCS(nop) 1002 DECLARE_UNARY_GENTYPE_FUNCS(negate) 1003 DECLARE_UNARY_GENTYPE_FUNCS(addOne) 1004 DECLARE_UNARY_GENTYPE_FUNCS(subOne) 1005 DECLARE_BINARY_GENTYPE_FUNCS(add) 1006 DECLARE_BINARY_GENTYPE_FUNCS(sub) 1007 DECLARE_BINARY_GENTYPE_FUNCS(mul) 1008 DECLARE_BINARY_GENTYPE_FUNCS(div) 1009 1010 void eval_selection_float (ShaderEvalContext& c) { c.color.x() = selection(c.in[0].z() > 0.0f, c.in[1].x(), c.in[2].y()); } 1011 void eval_selection_vec2 (ShaderEvalContext& c) { c.color.yz() = selection(c.in[0].z() > 0.0f, c.in[1].swizzle(1, 0), c.in[2].swizzle(2, 1)); } 1012 void eval_selection_vec3 (ShaderEvalContext& c) { c.color.xyz() = selection(c.in[0].z() > 0.0f, c.in[1].swizzle(1, 2, 0), c.in[2].swizzle(3, 1, 2)); } 1013 void eval_selection_vec4 (ShaderEvalContext& c) { c.color = selection(c.in[0].z() > 0.0f, c.in[1].swizzle(3, 2, 1, 0), c.in[2].swizzle(0, 3, 2, 1)); } 1014 1015 DECLARE_UNARY_INT_GENTYPE_FUNCS(nop) 1016 DECLARE_UNARY_INT_GENTYPE_FUNCS(negate) 1017 DECLARE_UNARY_INT_GENTYPE_FUNCS(addOne) 1018 DECLARE_UNARY_INT_GENTYPE_FUNCS(subOne) 1019 DECLARE_UNARY_INT_GENTYPE_FUNCS(bitwiseNot) 1020 DECLARE_BINARY_INT_GENTYPE_FUNCS(add) 1021 DECLARE_BINARY_INT_GENTYPE_FUNCS(sub) 1022 DECLARE_BINARY_INT_GENTYPE_FUNCS(mul) 1023 DECLARE_BINARY_INT_GENTYPE_FUNCS(div) 1024 DECLARE_BINARY_INT_GENTYPE_FUNCS(mod) 1025 DECLARE_BINARY_INT_GENTYPE_FUNCS(bitwiseAnd) 1026 DECLARE_BINARY_INT_GENTYPE_FUNCS(bitwiseOr) 1027 DECLARE_BINARY_INT_GENTYPE_FUNCS(bitwiseXor) 1028 1029 void eval_leftShift_int (ShaderEvalContext& c) { c.color.x() = (float)leftShift((int)c.in[0].z(), (int)c.in[1].x()); } 1030 DECLARE_BINARY_INT_VEC_FUNCS(leftShift) 1031 void eval_rightShift_int (ShaderEvalContext& c) { c.color.x() = (float)rightShift((int)c.in[0].z(), (int)c.in[1].x()); } 1032 DECLARE_BINARY_INT_VEC_FUNCS(rightShift) 1033 DECLARE_IVEC_INT_FUNCS(leftShiftVecScalar) 1034 DECLARE_IVEC_INT_FUNCS(rightShiftVecScalar) 1035 1036 void eval_selection_int (ShaderEvalContext& c) { c.color.x() = (float)selection(c.in[0].z() > 0.0f, (int)c.in[1].x(), (int)c.in[2].y()); } 1037 void eval_selection_ivec2 (ShaderEvalContext& c) { c.color.yz() = selection(c.in[0].z() > 0.0f, c.in[1].swizzle(1, 0).asInt(), c.in[2].swizzle(2, 1).asInt()).asFloat(); } 1038 void eval_selection_ivec3 (ShaderEvalContext& c) { c.color.xyz() = selection(c.in[0].z() > 0.0f, c.in[1].swizzle(1, 2, 0).asInt(), c.in[2].swizzle(3, 1, 2).asInt()).asFloat(); } 1039 void eval_selection_ivec4 (ShaderEvalContext& c) { c.color = selection(c.in[0].z() > 0.0f, c.in[1].swizzle(3, 2, 1, 0).asInt(), c.in[2].swizzle(0, 3, 2, 1).asInt()).asFloat(); } 1040 1041 DECLARE_UNARY_UINT_GENTYPE_FUNCS(nop) 1042 DECLARE_UNARY_UINT_GENTYPE_FUNCS(negate) 1043 DECLARE_UNARY_UINT_GENTYPE_FUNCS(bitwiseNot) 1044 DECLARE_UNARY_UINT_GENTYPE_FUNCS(addOne) 1045 DECLARE_UNARY_UINT_GENTYPE_FUNCS(subOne) 1046 DECLARE_BINARY_UINT_GENTYPE_FUNCS(add) 1047 DECLARE_BINARY_UINT_GENTYPE_FUNCS(sub) 1048 DECLARE_BINARY_UINT_GENTYPE_FUNCS(mul) 1049 DECLARE_BINARY_UINT_GENTYPE_FUNCS(div) 1050 DECLARE_BINARY_UINT_GENTYPE_FUNCS(mod) 1051 DECLARE_BINARY_UINT_GENTYPE_FUNCS(bitwiseAnd) 1052 DECLARE_BINARY_UINT_GENTYPE_FUNCS(bitwiseOr) 1053 DECLARE_BINARY_UINT_GENTYPE_FUNCS(bitwiseXor) 1054 1055 DECLARE_UINT_INT_GENTYPE_FUNCS(leftShift) 1056 DECLARE_UINT_INT_GENTYPE_FUNCS(rightShift) 1057 DECLARE_UVEC_INT_FUNCS(leftShiftVecScalar) 1058 DECLARE_UVEC_INT_FUNCS(rightShiftVecScalar) 1059 1060 void eval_selection_uint (ShaderEvalContext& c) { c.color.x() = (float)selection(c.in[0].z() > 0.0f, (deUint32)c.in[1].x(), (deUint32)c.in[2].y()); } 1061 void eval_selection_uvec2 (ShaderEvalContext& c) { c.color.yz() = selection(c.in[0].z() > 0.0f, c.in[1].swizzle(1, 0).asUint(), c.in[2].swizzle(2, 1).asUint()).asFloat(); } 1062 void eval_selection_uvec3 (ShaderEvalContext& c) { c.color.xyz() = selection(c.in[0].z() > 0.0f, c.in[1].swizzle(1, 2, 0).asUint(), c.in[2].swizzle(3, 1, 2).asUint()).asFloat(); } 1063 void eval_selection_uvec4 (ShaderEvalContext& c) { c.color = selection(c.in[0].z() > 0.0f, c.in[1].swizzle(3, 2, 1, 0).asUint(), c.in[2].swizzle(0, 3, 2, 1).asUint()).asFloat(); } 1064 1065 DECLARE_UNARY_BOOL_GENTYPE_FUNCS(boolNot) 1066 DECLARE_BINARY_BOOL_FUNCS(logicalAnd) 1067 DECLARE_BINARY_BOOL_FUNCS(logicalOr) 1068 DECLARE_BINARY_BOOL_FUNCS(logicalXor) 1069 1070 void eval_selection_bool (ShaderEvalContext& c) { c.color.x() = (float)selection(c.in[0].z() > 0.0f, c.in[1].x() > 0.0f, c.in[2].y() > 0.0f); } 1071 void eval_selection_bvec2 (ShaderEvalContext& c) { c.color.yz() = selection(c.in[0].z() > 0.0f, greaterThan(c.in[1].swizzle(1, 0), Vec2(0.0f, 0.0f)), greaterThan(c.in[2].swizzle(2, 1), Vec2(0.0f, 0.0f))).asFloat(); } 1072 void eval_selection_bvec3 (ShaderEvalContext& c) { c.color.xyz() = selection(c.in[0].z() > 0.0f, greaterThan(c.in[1].swizzle(1, 2, 0), Vec3(0.0f, 0.0f, 0.0f)), greaterThan(c.in[2].swizzle(3, 1, 2), Vec3(0.0f, 0.0f, 0.0f))).asFloat(); } 1073 void eval_selection_bvec4 (ShaderEvalContext& c) { c.color = selection(c.in[0].z() > 0.0f, greaterThan(c.in[1].swizzle(3, 2, 1, 0), Vec4(0.0f, 0.0f, 0.0f, 0.0f)), greaterThan(c.in[2].swizzle(0, 3, 2, 1), Vec4(0.0f, 0.0f, 0.0f, 0.0f))).asFloat(); } 1074 1075 DECLARE_VEC_FLOAT_FUNCS(addVecScalar) 1076 DECLARE_VEC_FLOAT_FUNCS(subVecScalar) 1077 DECLARE_VEC_FLOAT_FUNCS(mulVecScalar) 1078 DECLARE_VEC_FLOAT_FUNCS(divVecScalar) 1079 1080 DECLARE_FLOAT_VEC_FUNCS(addScalarVec) 1081 DECLARE_FLOAT_VEC_FUNCS(subScalarVec) 1082 DECLARE_FLOAT_VEC_FUNCS(mulScalarVec) 1083 DECLARE_FLOAT_VEC_FUNCS(divScalarVec) 1084 1085 DECLARE_IVEC_INT_FUNCS(addVecScalar) 1086 DECLARE_IVEC_INT_FUNCS(subVecScalar) 1087 DECLARE_IVEC_INT_FUNCS(mulVecScalar) 1088 DECLARE_IVEC_INT_FUNCS(divVecScalar) 1089 DECLARE_IVEC_INT_FUNCS(modVecScalar) 1090 DECLARE_IVEC_INT_FUNCS(bitwiseAndVecScalar) 1091 DECLARE_IVEC_INT_FUNCS(bitwiseOrVecScalar) 1092 DECLARE_IVEC_INT_FUNCS(bitwiseXorVecScalar) 1093 1094 DECLARE_INT_IVEC_FUNCS(addScalarVec) 1095 DECLARE_INT_IVEC_FUNCS(subScalarVec) 1096 DECLARE_INT_IVEC_FUNCS(mulScalarVec) 1097 DECLARE_INT_IVEC_FUNCS(divScalarVec) 1098 DECLARE_INT_IVEC_FUNCS(modScalarVec) 1099 DECLARE_INT_IVEC_FUNCS(bitwiseAndScalarVec) 1100 DECLARE_INT_IVEC_FUNCS(bitwiseOrScalarVec) 1101 DECLARE_INT_IVEC_FUNCS(bitwiseXorScalarVec) 1102 1103 DECLARE_UVEC_UINT_FUNCS(addVecScalar) 1104 DECLARE_UVEC_UINT_FUNCS(subVecScalar) 1105 DECLARE_UVEC_UINT_FUNCS(mulVecScalar) 1106 DECLARE_UVEC_UINT_FUNCS(divVecScalar) 1107 DECLARE_UVEC_UINT_FUNCS(modVecScalar) 1108 DECLARE_UVEC_UINT_FUNCS(bitwiseAndVecScalar) 1109 DECLARE_UVEC_UINT_FUNCS(bitwiseOrVecScalar) 1110 DECLARE_UVEC_UINT_FUNCS(bitwiseXorVecScalar) 1111 1112 DECLARE_UINT_UVEC_FUNCS(addScalarVec) 1113 DECLARE_UINT_UVEC_FUNCS(subScalarVec) 1114 DECLARE_UINT_UVEC_FUNCS(mulScalarVec) 1115 DECLARE_UINT_UVEC_FUNCS(divScalarVec) 1116 DECLARE_UINT_UVEC_FUNCS(modScalarVec) 1117 DECLARE_UINT_UVEC_FUNCS(bitwiseAndScalarVec) 1118 DECLARE_UINT_UVEC_FUNCS(bitwiseOrScalarVec) 1119 DECLARE_UINT_UVEC_FUNCS(bitwiseXorScalarVec) 1120 1121 // Built-in functions. 1122 1123 DECLARE_UNARY_GENTYPE_FUNCS(radians) 1124 DECLARE_UNARY_GENTYPE_FUNCS(degrees) 1125 DECLARE_UNARY_GENTYPE_FUNCS(sin) 1126 DECLARE_UNARY_GENTYPE_FUNCS(cos) 1127 DECLARE_UNARY_GENTYPE_FUNCS(tan) 1128 DECLARE_UNARY_GENTYPE_FUNCS(asin) 1129 DECLARE_UNARY_GENTYPE_FUNCS(acos) 1130 DECLARE_UNARY_GENTYPE_FUNCS(atan) 1131 DECLARE_BINARY_GENTYPE_FUNCS(atan2) 1132 DECLARE_UNARY_GENTYPE_FUNCS(sinh) 1133 DECLARE_UNARY_GENTYPE_FUNCS(cosh) 1134 DECLARE_UNARY_GENTYPE_FUNCS(tanh) 1135 DECLARE_UNARY_GENTYPE_FUNCS(asinh) 1136 DECLARE_UNARY_GENTYPE_FUNCS(acosh) 1137 DECLARE_UNARY_GENTYPE_FUNCS(atanh) 1138 1139 DECLARE_BINARY_GENTYPE_FUNCS(pow) 1140 DECLARE_UNARY_GENTYPE_FUNCS(exp) 1141 DECLARE_UNARY_GENTYPE_FUNCS(log) 1142 DECLARE_UNARY_GENTYPE_FUNCS(exp2) 1143 DECLARE_UNARY_GENTYPE_FUNCS(log2) 1144 DECLARE_UNARY_GENTYPE_FUNCS(sqrt) 1145 DECLARE_UNARY_GENTYPE_FUNCS(inverseSqrt) 1146 1147 DECLARE_UNARY_GENTYPE_FUNCS(abs) 1148 DECLARE_UNARY_GENTYPE_FUNCS(sign) 1149 DECLARE_UNARY_GENTYPE_FUNCS(floor) 1150 DECLARE_UNARY_GENTYPE_FUNCS(trunc) 1151 DECLARE_UNARY_GENTYPE_FUNCS(roundToEven) 1152 DECLARE_UNARY_GENTYPE_FUNCS(ceil) 1153 DECLARE_UNARY_GENTYPE_FUNCS(fract) 1154 DECLARE_BINARY_GENTYPE_FUNCS(mod) 1155 DECLARE_VEC_FLOAT_FUNCS(modVecScalar) 1156 DECLARE_BINARY_GENTYPE_FUNCS(min) 1157 DECLARE_VEC_FLOAT_FUNCS(minVecScalar) 1158 DECLARE_BINARY_INT_GENTYPE_FUNCS(min) 1159 DECLARE_IVEC_INT_FUNCS(minVecScalar) 1160 DECLARE_BINARY_UINT_GENTYPE_FUNCS(min) 1161 DECLARE_UVEC_UINT_FUNCS(minVecScalar) 1162 DECLARE_BINARY_GENTYPE_FUNCS(max) 1163 DECLARE_VEC_FLOAT_FUNCS(maxVecScalar) 1164 DECLARE_BINARY_INT_GENTYPE_FUNCS(max) 1165 DECLARE_IVEC_INT_FUNCS(maxVecScalar) 1166 DECLARE_BINARY_UINT_GENTYPE_FUNCS(max) 1167 DECLARE_UVEC_UINT_FUNCS(maxVecScalar) 1168 DECLARE_TERNARY_GENTYPE_FUNCS(clamp) 1169 DECLARE_VEC_FLOAT_FLOAT_FUNCS(clampVecScalarScalar) 1170 DECLARE_TERNARY_INT_GENTYPE_FUNCS(clamp) 1171 DECLARE_IVEC_INT_INT_FUNCS(clampVecScalarScalar) 1172 DECLARE_TERNARY_UINT_GENTYPE_FUNCS(clamp) 1173 DECLARE_UVEC_UINT_UINT_FUNCS(clampVecScalarScalar) 1174 DECLARE_TERNARY_GENTYPE_FUNCS(mix) 1175 DECLARE_VEC_VEC_FLOAT_FUNCS(mixVecVecScalar) 1176 DECLARE_BINARY_GENTYPE_FUNCS(step) 1177 DECLARE_FLOAT_VEC_FUNCS(stepScalarVec) 1178 DECLARE_TERNARY_GENTYPE_FUNCS(smoothStep) 1179 DECLARE_FLOAT_FLOAT_VEC_FUNCS(smoothStepScalarScalarVec) 1180 1181 DECLARE_UNARY_SCALAR_GENTYPE_FUNCS(length) 1182 DECLARE_BINARY_SCALAR_GENTYPE_FUNCS(distance) 1183 DECLARE_BINARY_SCALAR_GENTYPE_FUNCS(dot) 1184 void eval_cross_vec3 (ShaderEvalContext& c) { c.color.xyz() = cross(c.in[0].swizzle(2, 0, 1), c.in[1].swizzle(1, 2, 0)); } 1185 1186 DECLARE_UNARY_GENTYPE_FUNCS(normalize) 1187 DECLARE_TERNARY_GENTYPE_FUNCS(faceForward) 1188 DECLARE_BINARY_GENTYPE_FUNCS(reflect) 1189 1190 void eval_refract_float (ShaderEvalContext& c) { c.color.x() = refract(c.in[0].z(), c.in[1].x(), c.in[2].y()); } 1191 void eval_refract_vec2 (ShaderEvalContext& c) { c.color.yz() = refract(c.in[0].swizzle(3, 1), c.in[1].swizzle(1, 0), c.in[2].y()); } 1192 void eval_refract_vec3 (ShaderEvalContext& c) { c.color.xyz() = refract(c.in[0].swizzle(2, 0, 1), c.in[1].swizzle(1, 2, 0), c.in[2].y()); } 1193 void eval_refract_vec4 (ShaderEvalContext& c) { c.color = refract(c.in[0].swizzle(1, 2, 3, 0), c.in[1].swizzle(3, 2, 1, 0), c.in[2].y()); } 1194 1195 // Compare functions. 1196 1197 #define DECLARE_FLOAT_COMPARE_FUNCS(FUNC_NAME) \ 1198 void eval_##FUNC_NAME##_float (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(c.in[0].z(), c.in[1].x()); } \ 1199 void eval_##FUNC_NAME##_vec2 (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(c.in[0].swizzle(3, 1), c.in[1].swizzle(1, 0)); } \ 1200 void eval_##FUNC_NAME##_vec3 (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(c.in[0].swizzle(2, 0, 1), c.in[1].swizzle(1, 2, 0)); } \ 1201 void eval_##FUNC_NAME##_vec4 (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0), c.in[1].swizzle(3, 2, 1, 0)); } 1202 1203 #define DECLARE_FLOAT_CWISE_COMPARE_FUNCS(FUNC_NAME) \ 1204 void eval_##FUNC_NAME##_float (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(c.in[0].z(), c.in[1].x()); } \ 1205 DECLARE_FLOAT_VEC_CWISE_COMPARE_FUNCS(FUNC_NAME) 1206 1207 #define DECLARE_FLOAT_VEC_CWISE_COMPARE_FUNCS(FUNC_NAME) \ 1208 void eval_##FUNC_NAME##_vec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1), c.in[1].swizzle(1, 0)).asFloat(); } \ 1209 void eval_##FUNC_NAME##_vec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1), c.in[1].swizzle(1, 2, 0)).asFloat(); } \ 1210 void eval_##FUNC_NAME##_vec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0), c.in[1].swizzle(3, 2, 1, 0)).asFloat(); } 1211 1212 #define DECLARE_INT_COMPARE_FUNCS(FUNC_NAME) \ 1213 void eval_##FUNC_NAME##_int (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(chopToInt(c.in[0].z()), chopToInt(c.in[1].x())); } \ 1214 void eval_##FUNC_NAME##_ivec2 (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(chopToInt(c.in[0].swizzle(3, 1)), chopToInt(c.in[1].swizzle(1, 0))); } \ 1215 void eval_##FUNC_NAME##_ivec3 (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(chopToInt(c.in[0].swizzle(2, 0, 1)), chopToInt(c.in[1].swizzle(1, 2, 0))); } \ 1216 void eval_##FUNC_NAME##_ivec4 (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(chopToInt(c.in[0].swizzle(1, 2, 3, 0)), chopToInt(c.in[1].swizzle(3, 2, 1, 0))); } 1217 1218 #define DECLARE_INT_CWISE_COMPARE_FUNCS(FUNC_NAME) \ 1219 void eval_##FUNC_NAME##_int (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(chopToInt(c.in[0].z()), chopToInt(c.in[1].x())); } \ 1220 DECLARE_INT_VEC_CWISE_COMPARE_FUNCS(FUNC_NAME) 1221 1222 #define DECLARE_INT_VEC_CWISE_COMPARE_FUNCS(FUNC_NAME) \ 1223 void eval_##FUNC_NAME##_ivec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(chopToInt(c.in[0].swizzle(3, 1)), chopToInt(c.in[1].swizzle(1, 0))).asFloat(); } \ 1224 void eval_##FUNC_NAME##_ivec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(chopToInt(c.in[0].swizzle(2, 0, 1)), chopToInt(c.in[1].swizzle(1, 2, 0))).asFloat(); } \ 1225 void eval_##FUNC_NAME##_ivec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(chopToInt(c.in[0].swizzle(1, 2, 3, 0)), chopToInt(c.in[1].swizzle(3, 2, 1, 0))).asFloat(); } 1226 1227 #define DECLARE_UINT_COMPARE_FUNCS(FUNC_NAME) \ 1228 void eval_##FUNC_NAME##_uint (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME((deUint32)c.in[0].z(), (deUint32)c.in[1].x()); } \ 1229 void eval_##FUNC_NAME##_uvec2 (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(c.in[0].swizzle(3, 1).asUint(), c.in[1].swizzle(1, 0).asUint()); } \ 1230 void eval_##FUNC_NAME##_uvec3 (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(c.in[0].swizzle(2, 0, 1).asUint(), c.in[1].swizzle(1, 2, 0).asUint()); } \ 1231 void eval_##FUNC_NAME##_uvec4 (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0).asUint(), c.in[1].swizzle(3, 2, 1, 0).asUint()); } 1232 1233 #define DECLARE_UINT_CWISE_COMPARE_FUNCS(FUNC_NAME) \ 1234 DECLARE_UINT_SCALAR_CWISE_COMPARE_FUNCS(FUNC_NAME) \ 1235 void eval_##FUNC_NAME##_uvec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(c.in[0].swizzle(3, 1).asUint(), c.in[1].swizzle(1, 0).asUint()).asFloat(); } \ 1236 void eval_##FUNC_NAME##_uvec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(c.in[0].swizzle(2, 0, 1).asUint(), c.in[1].swizzle(1, 2, 0).asUint()).asFloat(); } \ 1237 void eval_##FUNC_NAME##_uvec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(c.in[0].swizzle(1, 2, 3, 0).asUint(), c.in[1].swizzle(3, 2, 1, 0).asUint()).asFloat(); } 1238 1239 #define DECLARE_UINT_SCALAR_CWISE_COMPARE_FUNCS(FUNC_NAME) \ 1240 void eval_##FUNC_NAME##_uint (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME((deUint32)c.in[0].z(), (deUint32)c.in[1].x()); } 1241 1242 #define DECLARE_BOOL_COMPARE_FUNCS(FUNC_NAME) \ 1243 void eval_##FUNC_NAME##_bool (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(c.in[0].z() > 0.0f, c.in[1].x() > 0.0f); } \ 1244 void eval_##FUNC_NAME##_bvec2 (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(greaterThan(c.in[0].swizzle(3, 1), Vec2(0.0f)), greaterThan(c.in[1].swizzle(1, 0), Vec2(0.0f))); } \ 1245 void eval_##FUNC_NAME##_bvec3 (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(greaterThan(c.in[0].swizzle(2, 0, 1), Vec3(0.0f)), greaterThan(c.in[1].swizzle(1, 2, 0), Vec3(0.0f))); } \ 1246 void eval_##FUNC_NAME##_bvec4 (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(greaterThan(c.in[0].swizzle(1, 2, 3, 0), Vec4(0.0f)), greaterThan(c.in[1].swizzle(3, 2, 1, 0), Vec4(0.0f))); } 1247 1248 #define DECLARE_BOOL_CWISE_COMPARE_FUNCS(FUNC_NAME) \ 1249 void eval_##FUNC_NAME##_bool (ShaderEvalContext& c) { c.color.x() = (float)FUNC_NAME(c.in[0].z() > 0.0f, c.in[1].x() > 0.0f); } \ 1250 DECLARE_BOOL_VEC_CWISE_COMPARE_FUNCS(FUNC_NAME) 1251 1252 #define DECLARE_BOOL_VEC_CWISE_COMPARE_FUNCS(FUNC_NAME) \ 1253 void eval_##FUNC_NAME##_bvec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(greaterThan(c.in[0].swizzle(3, 1), Vec2(0.0f)), greaterThan(c.in[1].swizzle(1, 0), Vec2(0.0f))).asFloat(); } \ 1254 void eval_##FUNC_NAME##_bvec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(greaterThan(c.in[0].swizzle(2, 0, 1), Vec3(0.0f)), greaterThan(c.in[1].swizzle(1, 2, 0), Vec3(0.0f))).asFloat(); } \ 1255 void eval_##FUNC_NAME##_bvec4 (ShaderEvalContext& c) { c.color = FUNC_NAME(greaterThan(c.in[0].swizzle(1, 2, 3, 0), Vec4(0.0f)), greaterThan(c.in[1].swizzle(3, 2, 1, 0), Vec4(0.0f))).asFloat(); } 1256 1257 DECLARE_FLOAT_COMPARE_FUNCS(allEqual) 1258 DECLARE_FLOAT_COMPARE_FUNCS(anyNotEqual) 1259 DECLARE_FLOAT_CWISE_COMPARE_FUNCS(lessThan) 1260 DECLARE_FLOAT_CWISE_COMPARE_FUNCS(lessThanEqual) 1261 DECLARE_FLOAT_CWISE_COMPARE_FUNCS(greaterThan) 1262 DECLARE_FLOAT_CWISE_COMPARE_FUNCS(greaterThanEqual) 1263 DECLARE_FLOAT_VEC_CWISE_COMPARE_FUNCS(equal) 1264 DECLARE_FLOAT_VEC_CWISE_COMPARE_FUNCS(notEqual) 1265 1266 DECLARE_INT_COMPARE_FUNCS(allEqual) 1267 DECLARE_INT_COMPARE_FUNCS(anyNotEqual) 1268 DECLARE_INT_CWISE_COMPARE_FUNCS(lessThan) 1269 DECLARE_INT_CWISE_COMPARE_FUNCS(lessThanEqual) 1270 DECLARE_INT_CWISE_COMPARE_FUNCS(greaterThan) 1271 DECLARE_INT_CWISE_COMPARE_FUNCS(greaterThanEqual) 1272 DECLARE_INT_VEC_CWISE_COMPARE_FUNCS(equal) 1273 DECLARE_INT_VEC_CWISE_COMPARE_FUNCS(notEqual) 1274 1275 DECLARE_UINT_COMPARE_FUNCS(allEqual) 1276 DECLARE_UINT_COMPARE_FUNCS(anyNotEqual) 1277 DECLARE_UINT_SCALAR_CWISE_COMPARE_FUNCS(lessThan) 1278 DECLARE_UINT_SCALAR_CWISE_COMPARE_FUNCS(lessThanEqual) 1279 DECLARE_UINT_SCALAR_CWISE_COMPARE_FUNCS(greaterThan) 1280 DECLARE_UINT_SCALAR_CWISE_COMPARE_FUNCS(greaterThanEqual) 1281 1282 DECLARE_BOOL_COMPARE_FUNCS(allEqual) 1283 DECLARE_BOOL_COMPARE_FUNCS(anyNotEqual) 1284 DECLARE_BOOL_VEC_CWISE_COMPARE_FUNCS(equal) 1285 DECLARE_BOOL_VEC_CWISE_COMPARE_FUNCS(notEqual) 1286 1287 // Boolean functions. 1288 1289 #define DECLARE_UNARY_SCALAR_BVEC_FUNCS(GLSL_NAME, FUNC_NAME) \ 1290 void eval_##GLSL_NAME##_bvec2 (ShaderEvalContext& c) { c.color.x() = float(FUNC_NAME(greaterThan(c.in[0].swizzle(3, 1), Vec2(0.0f)))); } \ 1291 void eval_##GLSL_NAME##_bvec3 (ShaderEvalContext& c) { c.color.x() = float(FUNC_NAME(greaterThan(c.in[0].swizzle(2, 0, 1), Vec3(0.0f)))); } \ 1292 void eval_##GLSL_NAME##_bvec4 (ShaderEvalContext& c) { c.color.x() = float(FUNC_NAME(greaterThan(c.in[0].swizzle(1, 2, 3, 0), Vec4(0.0f)))); } 1293 1294 #define DECLARE_UNARY_BVEC_BVEC_FUNCS(GLSL_NAME, FUNC_NAME) \ 1295 void eval_##GLSL_NAME##_bvec2 (ShaderEvalContext& c) { c.color.yz() = FUNC_NAME(greaterThan(c.in[0].swizzle(3, 1), Vec2(0.0f))).asFloat(); } \ 1296 void eval_##GLSL_NAME##_bvec3 (ShaderEvalContext& c) { c.color.xyz() = FUNC_NAME(greaterThan(c.in[0].swizzle(2, 0, 1), Vec3(0.0f))).asFloat(); } \ 1297 void eval_##GLSL_NAME##_bvec4 (ShaderEvalContext& c) { c.color.xyzw() = FUNC_NAME(greaterThan(c.in[0].swizzle(1, 2, 3, 0), Vec4(0.0f))).asFloat(); } 1298 1299 DECLARE_UNARY_SCALAR_BVEC_FUNCS(any, boolAny); 1300 DECLARE_UNARY_SCALAR_BVEC_FUNCS(all, boolAll); 1301 1302 // ShaderOperatorTests. 1303 1304 class ShaderOperatorTests : public tcu::TestCaseGroup 1305 { 1306 public: 1307 ShaderOperatorTests (tcu::TestContext& context); 1308 virtual ~ShaderOperatorTests (void); 1309 1310 virtual void init (void); 1311 1312 private: 1313 ShaderOperatorTests (const ShaderOperatorTests&); // not allowed! 1314 ShaderOperatorTests& operator= (const ShaderOperatorTests&); // not allowed! 1315 }; 1316 1317 ShaderOperatorTests::ShaderOperatorTests(tcu::TestContext& testCtx) 1318 : TestCaseGroup(testCtx, "operator", "Operator tests.") 1319 { 1320 } 1321 1322 ShaderOperatorTests::~ShaderOperatorTests (void) 1323 { 1324 } 1325 1326 void ShaderOperatorTests::init (void) 1327 { 1328 #define BOOL_FUNCS(FUNC_NAME) eval_##FUNC_NAME##_bool, DE_NULL, DE_NULL, DE_NULL 1329 1330 #define FLOAT_VEC_FUNCS(FUNC_NAME) DE_NULL, eval_##FUNC_NAME##_vec2, eval_##FUNC_NAME##_vec3, eval_##FUNC_NAME##_vec4 1331 #define INT_VEC_FUNCS(FUNC_NAME) DE_NULL, eval_##FUNC_NAME##_ivec2, eval_##FUNC_NAME##_ivec3, eval_##FUNC_NAME##_ivec4 1332 #define UINT_VEC_FUNCS(FUNC_NAME) DE_NULL, eval_##FUNC_NAME##_uvec2, eval_##FUNC_NAME##_uvec3, eval_##FUNC_NAME##_uvec4 1333 #define BOOL_VEC_FUNCS(FUNC_NAME) DE_NULL, eval_##FUNC_NAME##_bvec2, eval_##FUNC_NAME##_bvec3, eval_##FUNC_NAME##_bvec4 1334 1335 #define FLOAT_GENTYPE_FUNCS(FUNC_NAME) eval_##FUNC_NAME##_float, eval_##FUNC_NAME##_vec2, eval_##FUNC_NAME##_vec3, eval_##FUNC_NAME##_vec4 1336 #define INT_GENTYPE_FUNCS(FUNC_NAME) eval_##FUNC_NAME##_int, eval_##FUNC_NAME##_ivec2, eval_##FUNC_NAME##_ivec3, eval_##FUNC_NAME##_ivec4 1337 #define UINT_GENTYPE_FUNCS(FUNC_NAME) eval_##FUNC_NAME##_uint, eval_##FUNC_NAME##_uvec2, eval_##FUNC_NAME##_uvec3, eval_##FUNC_NAME##_uvec4 1338 #define BOOL_GENTYPE_FUNCS(FUNC_NAME) eval_##FUNC_NAME##_bool, eval_##FUNC_NAME##_bvec2, eval_##FUNC_NAME##_bvec3, eval_##FUNC_NAME##_bvec4 1339 1340 // Shorthands. 1341 Value notUsed = Value(VALUE_NONE, 0.0f, 0.0f); 1342 1343 std::vector<BuiltinFuncGroup> funcInfoGroups; 1344 1345 // Unary operators. 1346 funcInfoGroups.push_back( 1347 BuiltinFuncGroup("unary_operator", "Unary operator tests") 1348 << BuiltinOperInfo ("plus", "+", GT, Value(GT, -1.0f, 1.0f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(nop)) 1349 << BuiltinOperInfo ("plus", "+", IGT, Value(IGT, -5.0f, 5.0f), notUsed, notUsed, 0.1f, 0.5f, PRECMASK_ALL, INT_GENTYPE_FUNCS(nop)) 1350 << BuiltinOperInfo ("plus", "+", UGT, Value(UGT, 0.0f, 2e2f), notUsed, notUsed, 5e-3f, 0.0f, PRECMASK_ALL, UINT_GENTYPE_FUNCS(nop)) 1351 << BuiltinOperInfo ("minus", "-", GT, Value(GT, -1.0f, 1.0f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(negate)) 1352 << BuiltinOperInfo ("minus", "-", IGT, Value(IGT, -5.0f, 5.0f), notUsed, notUsed, 0.1f, 0.5f, PRECMASK_ALL, INT_GENTYPE_FUNCS(negate)) 1353 << BuiltinOperInfo ("minus", "-", UGT, Value(UGT, 0.0f, 4e9f), notUsed, notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_GENTYPE_FUNCS(negate)) 1354 << BuiltinOperInfo ("not", "!", B, Value(B, -1.0f, 1.0f), notUsed, notUsed, 1.0f, 0.0f, PRECMASK_NA, eval_boolNot_bool, DE_NULL, DE_NULL, DE_NULL) 1355 << BuiltinOperInfo ("bitwise_not", "~", IGT, Value(IGT, -1e5f, 1e5f), notUsed, notUsed, 5e-5f, 0.5f, PRECMASK_HIGHP, INT_GENTYPE_FUNCS(bitwiseNot)) 1356 << BuiltinOperInfo ("bitwise_not", "~", UGT, Value(UGT, 0.0f, 2e9f), notUsed, notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_GENTYPE_FUNCS(bitwiseNot)) 1357 1358 // Pre/post incr/decr side effect cases. 1359 << BuiltinSideEffOperInfo ("pre_increment_effect", "++", GT, Value(GT, -1.0f, 1.0f), notUsed, notUsed, 0.5f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(addOne)) 1360 << BuiltinSideEffOperInfo ("pre_increment_effect", "++", IGT, Value(IGT, -6.0f, 4.0f), notUsed, notUsed, 0.1f, 0.5f, PRECMASK_ALL, INT_GENTYPE_FUNCS(addOne)) 1361 << BuiltinSideEffOperInfo ("pre_increment_effect", "++", UGT, Value(UGT, 0.0f, 9.0f), notUsed, notUsed, 0.1f, 0.0f, PRECMASK_ALL, UINT_GENTYPE_FUNCS(addOne)) 1362 << BuiltinSideEffOperInfo ("pre_decrement_effect", "--", GT, Value(GT, -1.0f, 1.0f), notUsed, notUsed, 0.5f, 1.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(subOne)) 1363 << BuiltinSideEffOperInfo ("pre_decrement_effect", "--", IGT, Value(IGT, -4.0f, 6.0f), notUsed, notUsed, 0.1f, 0.5f, PRECMASK_ALL, INT_GENTYPE_FUNCS(subOne)) 1364 << BuiltinSideEffOperInfo ("pre_decrement_effect", "--", UGT, Value(UGT, 1.0f, 10.0f), notUsed, notUsed, 0.1f, 0.0f, PRECMASK_ALL, UINT_GENTYPE_FUNCS(subOne)) 1365 << BuiltinPostSideEffOperInfo ("post_increment_effect", "++", GT, Value(GT, -1.0f, 1.0f), notUsed, notUsed, 0.5f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(addOne)) 1366 << BuiltinPostSideEffOperInfo ("post_increment_effect", "++", IGT, Value(IGT, -6.0f, 4.0f), notUsed, notUsed, 0.1f, 0.5f, PRECMASK_ALL, INT_GENTYPE_FUNCS(addOne)) 1367 << BuiltinPostSideEffOperInfo ("post_increment_effect", "++", UGT, Value(UGT, 0.0f, 9.0f), notUsed, notUsed, 0.1f, 0.0f, PRECMASK_ALL, UINT_GENTYPE_FUNCS(addOne)) 1368 << BuiltinPostSideEffOperInfo ("post_decrement_effect", "--", GT, Value(GT, -1.0f, 1.0f), notUsed, notUsed, 0.5f, 1.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(subOne)) 1369 << BuiltinPostSideEffOperInfo ("post_decrement_effect", "--", IGT, Value(IGT, -4.0f, 6.0f), notUsed, notUsed, 0.1f, 0.5f, PRECMASK_ALL, INT_GENTYPE_FUNCS(subOne)) 1370 << BuiltinPostSideEffOperInfo ("post_decrement_effect", "--", UGT, Value(UGT, 1.0f, 10.0f), notUsed, notUsed, 0.1f, 0.0f, PRECMASK_ALL, UINT_GENTYPE_FUNCS(subOne)) 1371 1372 // Pre/post incr/decr result cases. 1373 << BuiltinOperInfo ("pre_increment_result", "++", GT, Value(GT, -1.0f, 1.0f), notUsed, notUsed, 0.5f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(addOne)) 1374 << BuiltinOperInfo ("pre_increment_result", "++", IGT, Value(IGT, -6.0f, 4.0f), notUsed, notUsed, 0.1f, 0.5f, PRECMASK_ALL, INT_GENTYPE_FUNCS(addOne)) 1375 << BuiltinOperInfo ("pre_increment_result", "++", UGT, Value(UGT, 0.0f, 9.0f), notUsed, notUsed, 0.1f, 0.0f, PRECMASK_ALL, UINT_GENTYPE_FUNCS(addOne)) 1376 << BuiltinOperInfo ("pre_decrement_result", "--", GT, Value(GT, -1.0f, 1.0f), notUsed, notUsed, 0.5f, 1.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(subOne)) 1377 << BuiltinOperInfo ("pre_decrement_result", "--", IGT, Value(IGT, -4.0f, 6.0f), notUsed, notUsed, 0.1f, 0.5f, PRECMASK_ALL, INT_GENTYPE_FUNCS(subOne)) 1378 << BuiltinOperInfo ("pre_decrement_result", "--", UGT, Value(UGT, 1.0f, 10.0f), notUsed, notUsed, 0.1f, 0.0f, PRECMASK_ALL, UINT_GENTYPE_FUNCS(subOne)) 1379 << BuiltinPostOperInfo ("post_increment_result", "++", GT, Value(GT, -1.0f, 1.0f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(nop)) 1380 << BuiltinPostOperInfo ("post_increment_result", "++", IGT, Value(IGT, -5.0f, 5.0f), notUsed, notUsed, 0.1f, 0.5f, PRECMASK_ALL, INT_GENTYPE_FUNCS(nop)) 1381 << BuiltinPostOperInfo ("post_increment_result", "++", UGT, Value(UGT, 0.0f, 9.0f), notUsed, notUsed, 0.1f, 0.0f, PRECMASK_ALL, UINT_GENTYPE_FUNCS(nop)) 1382 << BuiltinPostOperInfo ("post_decrement_result", "--", GT, Value(GT, -1.0f, 1.0f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(nop)) 1383 << BuiltinPostOperInfo ("post_decrement_result", "--", IGT, Value(IGT, -5.0f, 5.0f), notUsed, notUsed, 0.1f, 0.5f, PRECMASK_ALL, INT_GENTYPE_FUNCS(nop)) 1384 << BuiltinPostOperInfo ("post_decrement_result", "--", UGT, Value(UGT, 1.0f, 10.0f), notUsed, notUsed, 0.1f, 0.0f, PRECMASK_ALL, UINT_GENTYPE_FUNCS(nop)) 1385 ); 1386 1387 BuiltinFuncGroup binaryOpGroup("binary_operator", "Binary operator tests"); 1388 1389 // Normal binary operations and their corresponding assignment operations have lots in common; generate both in the following loop. 1390 1391 for (int binaryOperatorType = 0; binaryOperatorType <= 2; binaryOperatorType++) // 0: normal op test, 1: assignment op side-effect test, 2: assignment op result test 1392 { 1393 const bool isNormalOp = binaryOperatorType == 0; 1394 const bool isAssignEff = binaryOperatorType == 1; 1395 const bool isAssignRes = binaryOperatorType == 2; 1396 1397 DE_ASSERT(isNormalOp || isAssignEff || isAssignRes); 1398 DE_UNREF(isAssignRes); 1399 1400 const char* addName = isNormalOp ? "add" : isAssignEff ? "add_assign_effect" : "add_assign_result"; 1401 const char* subName = isNormalOp ? "sub" : isAssignEff ? "sub_assign_effect" : "sub_assign_result"; 1402 const char* mulName = isNormalOp ? "mul" : isAssignEff ? "mul_assign_effect" : "mul_assign_result"; 1403 const char* divName = isNormalOp ? "div" : isAssignEff ? "div_assign_effect" : "div_assign_result"; 1404 const char* modName = isNormalOp ? "mod" : isAssignEff ? "mod_assign_effect" : "mod_assign_result"; 1405 const char* andName = isNormalOp ? "bitwise_and" : isAssignEff ? "bitwise_and_assign_effect" : "bitwise_and_assign_result"; 1406 const char* orName = isNormalOp ? "bitwise_or" : isAssignEff ? "bitwise_or_assign_effect" : "bitwise_or_assign_result"; 1407 const char* xorName = isNormalOp ? "bitwise_xor" : isAssignEff ? "bitwise_xor_assign_effect" : "bitwise_xor_assign_result"; 1408 const char* leftShiftName = isNormalOp ? "left_shift" : isAssignEff ? "left_shift_assign_effect" : "left_shift_assign_result"; 1409 const char* rightShiftName = isNormalOp ? "right_shift" : isAssignEff ? "right_shift_assign_effect" : "right_shift_assign_result"; 1410 const char* addOp = isNormalOp ? "+" : "+="; 1411 const char* subOp = isNormalOp ? "-" : "-="; 1412 const char* mulOp = isNormalOp ? "*" : "*="; 1413 const char* divOp = isNormalOp ? "/" : "/="; 1414 const char* modOp = isNormalOp ? "%" : "%="; 1415 const char* andOp = isNormalOp ? "&" : "&="; 1416 const char* orOp = isNormalOp ? "|" : "|="; 1417 const char* xorOp = isNormalOp ? "^" : "^="; 1418 const char* leftShiftOp = isNormalOp ? "<<" : "<<="; 1419 const char* rightShiftOp = isNormalOp ? ">>" : ">>="; 1420 1421 // Pointer to appropriate OperInfo function. 1422 BuiltinFuncInfo (*operInfoFunc)(const char*, const char*, ValueType, Value, Value, Value, const float, const float, deUint32, ShaderEvalFunc, ShaderEvalFunc, ShaderEvalFunc, ShaderEvalFunc) = 1423 isAssignEff ? BuiltinSideEffOperInfo : BuiltinOperInfo; 1424 1425 DE_ASSERT(operInfoFunc != DE_NULL); 1426 1427 // The following cases will be added for each operator, precision and fundamental type (float, int, uint) combination, where applicable: 1428 // gentype <op> gentype 1429 // vector <op> scalar 1430 // For normal (non-assigning) operators only: 1431 // scalar <op> vector 1432 1433 // The add operator. 1434 1435 binaryOpGroup 1436 << operInfoFunc(addName, addOp, GT, Value(GT, -1.0f, 1.0f), Value(GT, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(add)) 1437 << operInfoFunc(addName, addOp, IGT, Value(IGT, -4.0f, 6.0f), Value(IGT, -6.0f, 5.0f), notUsed, 0.1f, 0.5f, PRECMASK_MEDIUMP, INT_GENTYPE_FUNCS(add)) 1438 << operInfoFunc(addName, addOp, IGT, Value(IGT, -2e9f, 2e9f), Value(IGT, -2e9f, 2e9f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_GENTYPE_FUNCS(add)) 1439 << operInfoFunc(addName, addOp, UGT, Value(UGT, 0.0f, 1e2f), Value(UGT, 0.0f, 1e2f), notUsed, 5e-3f, 0.0f, PRECMASK_MEDIUMP, UINT_GENTYPE_FUNCS(add)) 1440 << operInfoFunc(addName, addOp, UGT, Value(UGT, 0.0f, 4e9f), Value(UGT, 0.0f, 4e9f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_GENTYPE_FUNCS(add)) 1441 << operInfoFunc(addName, addOp, FV, Value(FV, -1.0f, 1.0f), Value(F, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_VEC_FUNCS(addVecScalar)) 1442 << operInfoFunc(addName, addOp, IV, Value(IV, -4.0f, 6.0f), Value(I, -6.0f, 5.0f), notUsed, 0.1f, 0.5f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(addVecScalar)) 1443 << operInfoFunc(addName, addOp, IV, Value(IV, -2e9f, 2e9f), Value(I, -2e9f, 2e9f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(addVecScalar)) 1444 << operInfoFunc(addName, addOp, UV, Value(UV, 0.0f, 1e2f), Value(U, 0.0f, 1e2f), notUsed, 5e-3f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(addVecScalar)) 1445 << operInfoFunc(addName, addOp, UV, Value(UV, 0.0f, 4e9f), Value(U, 0.0f, 4e9f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(addVecScalar)); 1446 1447 if (isNormalOp) 1448 binaryOpGroup 1449 << operInfoFunc(addName, addOp, FV, Value(F, -1.0f, 1.0f), Value(FV, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_VEC_FUNCS(addScalarVec)) 1450 << operInfoFunc(addName, addOp, IV, Value(I, -4.0f, 6.0f), Value(IV, -6.0f, 5.0f), notUsed, 0.1f, 0.5f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(addScalarVec)) 1451 << operInfoFunc(addName, addOp, IV, Value(I, -2e9f, 2e9f), Value(IV, -2e9f, 2e9f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(addScalarVec)) 1452 << operInfoFunc(addName, addOp, UV, Value(U, 0.0f, 1e2f), Value(UV, 0.0f, 1e2f), notUsed, 5e-3f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(addScalarVec)) 1453 << operInfoFunc(addName, addOp, UV, Value(U, 0.0f, 4e9f), Value(UV, 0.0f, 4e9f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(addScalarVec)); 1454 1455 // The subtract operator. 1456 1457 binaryOpGroup 1458 << operInfoFunc(subName, subOp, GT, Value(GT, -1.0f, 1.0f), Value(GT, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(sub)) 1459 << operInfoFunc(subName, subOp, IGT, Value(IGT, -4.0f, 6.0f), Value(IGT, -6.0f, 5.0f), notUsed, 0.1f, 0.5f, PRECMASK_MEDIUMP, INT_GENTYPE_FUNCS(sub)) 1460 << operInfoFunc(subName, subOp, IGT, Value(IGT, -2e9f, 2e9f), Value(IGT, -2e9f, 2e9f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_GENTYPE_FUNCS(sub)) 1461 << operInfoFunc(subName, subOp, UGT, Value(UGT, 1e2f, 2e2f), Value(UGT, 0.0f, 1e2f), notUsed, 5e-3f, 0.0f, PRECMASK_MEDIUMP, UINT_GENTYPE_FUNCS(sub)) 1462 << operInfoFunc(subName, subOp, UGT, Value(UGT, .5e9f, 3.7e9f), Value(UGT, 0.0f, 3.9e9f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_GENTYPE_FUNCS(sub)) 1463 << operInfoFunc(subName, subOp, FV, Value(FV, -1.0f, 1.0f), Value(F, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_VEC_FUNCS(subVecScalar)) 1464 << operInfoFunc(subName, subOp, IV, Value(IV, -4.0f, 6.0f), Value(I, -6.0f, 5.0f), notUsed, 0.1f, 0.5f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(subVecScalar)) 1465 << operInfoFunc(subName, subOp, IV, Value(IV, -2e9f, 2e9f), Value(I, -2e9f, 2e9f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(subVecScalar)) 1466 << operInfoFunc(subName, subOp, UV, Value(UV, 1e2f, 2e2f), Value(U, 0.0f, 1e2f), notUsed, 5e-3f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(subVecScalar)) 1467 << operInfoFunc(subName, subOp, UV, Value(UV, 0.0f, 4e9f), Value(U, 0.0f, 4e9f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(subVecScalar)); 1468 1469 if (isNormalOp) 1470 binaryOpGroup 1471 << operInfoFunc(subName, subOp, FV, Value(F, -1.0f, 1.0f), Value(FV, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_VEC_FUNCS(subScalarVec)) 1472 << operInfoFunc(subName, subOp, IV, Value(I, -4.0f, 6.0f), Value(IV, -6.0f, 5.0f), notUsed, 0.1f, 0.5f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(subScalarVec)) 1473 << operInfoFunc(subName, subOp, IV, Value(I, -2e9f, 2e9f), Value(IV, -2e9f, 2e9f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(subScalarVec)) 1474 << operInfoFunc(subName, subOp, UV, Value(U, 1e2f, 2e2f), Value(UV, 0.0f, 1e2f), notUsed, 5e-3f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(subScalarVec)) 1475 << operInfoFunc(subName, subOp, UV, Value(U, 0.0f, 4e9f), Value(UV, 0.0f, 4e9f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(subScalarVec)); 1476 1477 // The multiply operator. 1478 1479 binaryOpGroup 1480 << operInfoFunc(mulName, mulOp, GT, Value(GT, -1.0f, 1.0f), Value(GT, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(mul)) 1481 << operInfoFunc(mulName, mulOp, IGT, Value(IGT, -4.0f, 6.0f), Value(IGT, -6.0f, 5.0f), notUsed, 0.1f, 0.5f, PRECMASK_MEDIUMP, INT_GENTYPE_FUNCS(mul)) 1482 << operInfoFunc(mulName, mulOp, IGT, Value(IGT, -3e5f, 3e5f), Value(IGT, -3e4f, 3e4f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_GENTYPE_FUNCS(mul)) 1483 << operInfoFunc(mulName, mulOp, UGT, Value(UGT, 0.0f, 16.0f), Value(UGT, 0.0f, 16.0f), notUsed, 4e-3f, 0.0f, PRECMASK_MEDIUMP, UINT_GENTYPE_FUNCS(mul)) 1484 << operInfoFunc(mulName, mulOp, UGT, Value(UGT, 0.0f, 6e5f), Value(UGT, 0.0f, 6e4f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_GENTYPE_FUNCS(mul)) 1485 << operInfoFunc(mulName, mulOp, FV, Value(FV, -1.0f, 1.0f), Value(F, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_VEC_FUNCS(mulVecScalar)) 1486 << operInfoFunc(mulName, mulOp, IV, Value(IV, -4.0f, 6.0f), Value(I, -6.0f, 5.0f), notUsed, 0.1f, 0.5f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(mulVecScalar)) 1487 << operInfoFunc(mulName, mulOp, IV, Value(IV, -3e5f, 3e5f), Value(I, -3e4f, 3e4f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(mulVecScalar)) 1488 << operInfoFunc(mulName, mulOp, UV, Value(UV, 0.0f, 16.0f), Value(U, 0.0f, 16.0f), notUsed, 4e-3f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(mulVecScalar)) 1489 << operInfoFunc(mulName, mulOp, UV, Value(UV, 0.0f, 6e5f), Value(U, 0.0f, 6e4f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(mulVecScalar)); 1490 1491 if (isNormalOp) 1492 binaryOpGroup 1493 << operInfoFunc(mulName, mulOp, FV, Value(F, -1.0f, 1.0f), Value(FV, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_VEC_FUNCS(mulScalarVec)) 1494 << operInfoFunc(mulName, mulOp, IV, Value(I, -4.0f, 6.0f), Value(IV, -6.0f, 5.0f), notUsed, 0.1f, 0.5f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(mulScalarVec)) 1495 << operInfoFunc(mulName, mulOp, IV, Value(I, -3e5f, 3e5f), Value(IV, -3e4f, 3e4f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(mulScalarVec)) 1496 << operInfoFunc(mulName, mulOp, UV, Value(U, 0.0f, 16.0f), Value(UV, 0.0f, 16.0f), notUsed, 4e-3f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(mulScalarVec)) 1497 << operInfoFunc(mulName, mulOp, UV, Value(U, 0.0f, 6e5f), Value(UV, 0.0f, 6e4f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(mulScalarVec)); 1498 1499 // The divide operator. 1500 1501 binaryOpGroup 1502 << operInfoFunc(divName, divOp, GT, Value(GT, -1.0f, 1.0f), Value(GT, -2.0f, -0.5f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(div)) 1503 << operInfoFunc(divName, divOp, IGT, Value(IGT, 24.0f, 24.0f), Value(IGT, -4.0f, -1.0f), notUsed, 0.04f, 1.0f, PRECMASK_MEDIUMP, INT_GENTYPE_FUNCS(div)) 1504 << operInfoFunc(divName, divOp, IGT, Value(IGT, 40320.0f, 40320.0f), Value(IGT, -8.0f, -1.0f), notUsed, 1e-5f, 0.5f, PRECMASK_HIGHP, INT_GENTYPE_FUNCS(div)) 1505 << operInfoFunc(divName, divOp, UGT, Value(UGT, 0.0f, 24.0f), Value(UGT, 1.0f, 4.0f), notUsed, 0.04f, 0.0f, PRECMASK_MEDIUMP, UINT_GENTYPE_FUNCS(div)) 1506 << operInfoFunc(divName, divOp, UGT, Value(UGT, 0.0f, 40320.0f), Value(UGT, 1.0f, 8.0f), notUsed, 1e-5f, 0.0f, PRECMASK_HIGHP, UINT_GENTYPE_FUNCS(div)) 1507 << operInfoFunc(divName, divOp, FV, Value(FV, -1.0f, 1.0f), Value(F, -2.0f, -0.5f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_VEC_FUNCS(divVecScalar)) 1508 << operInfoFunc(divName, divOp, IV, Value(IV, 24.0f, 24.0f), Value(I, -4.0f, -1.0f), notUsed, 0.04f, 1.0f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(divVecScalar)) 1509 << operInfoFunc(divName, divOp, IV, Value(IV, 40320.0f, 40320.0f), Value(I, -8.0f, -1.0f), notUsed, 1e-5f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(divVecScalar)) 1510 << operInfoFunc(divName, divOp, UV, Value(UV, 0.0f, 24.0f), Value(U, 1.0f, 4.0f), notUsed, 0.04f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(divVecScalar)) 1511 << operInfoFunc(divName, divOp, UV, Value(UV, 0.0f, 40320.0f), Value(U, 1.0f, 8.0f), notUsed, 1e-5f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(divVecScalar)); 1512 1513 if (isNormalOp) 1514 binaryOpGroup 1515 << operInfoFunc(divName, divOp, FV, Value(F, -1.0f, 1.0f), Value(FV, -2.0f, -0.5f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_VEC_FUNCS(divScalarVec)) 1516 << operInfoFunc(divName, divOp, IV, Value(I, 24.0f, 24.0f), Value(IV, -4.0f, -1.0f), notUsed, 0.04f, 1.0f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(divScalarVec)) 1517 << operInfoFunc(divName, divOp, IV, Value(I, 40320.0f, 40320.0f), Value(IV, -8.0f, -1.0f), notUsed, 1e-5f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(divScalarVec)) 1518 << operInfoFunc(divName, divOp, UV, Value(U, 0.0f, 24.0f), Value(UV, 1.0f, 4.0f), notUsed, 0.04f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(divScalarVec)) 1519 << operInfoFunc(divName, divOp, UV, Value(U, 0.0f, 40320.0f), Value(UV, 1.0f, 8.0f), notUsed, 1e-5f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(divScalarVec)); 1520 1521 // The modulus operator. 1522 1523 binaryOpGroup 1524 << operInfoFunc(modName, modOp, IGT, Value(IGT, 0.0f, 6.0f), Value(IGT, 1.1f, 6.1f), notUsed, 0.25f, 0.5f, PRECMASK_MEDIUMP, INT_GENTYPE_FUNCS(mod)) 1525 << operInfoFunc(modName, modOp, IGT, Value(IGT, 0.0f, 14.0f), Value(IGT, 1.1f, 11.1f), notUsed, 0.1f, 0.5f, PRECMASK_HIGHP, INT_GENTYPE_FUNCS(mod)) 1526 << operInfoFunc(modName, modOp, UGT, Value(UGT, 0.0f, 6.0f), Value(UGT, 1.1f, 6.1f), notUsed, 0.25f, 0.0f, PRECMASK_MEDIUMP, UINT_GENTYPE_FUNCS(mod)) 1527 << operInfoFunc(modName, modOp, UGT, Value(UGT, 0.0f, 24.0f), Value(UGT, 1.1f, 11.1f), notUsed, 0.1f, 0.0f, PRECMASK_HIGHP, UINT_GENTYPE_FUNCS(mod)) 1528 << operInfoFunc(modName, modOp, IV, Value(IV, 0.0f, 6.0f), Value(I, 1.1f, 6.1f), notUsed, 0.25f, 0.5f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(modVecScalar)) 1529 << operInfoFunc(modName, modOp, IV, Value(IV, 0.0f, 6.0f), Value(I, 1.1f, 11.1f), notUsed, 0.1f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(modVecScalar)) 1530 << operInfoFunc(modName, modOp, UV, Value(UV, 0.0f, 6.0f), Value(U, 1.1f, 6.1f), notUsed, 0.25f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(modVecScalar)) 1531 << operInfoFunc(modName, modOp, UV, Value(UV, 0.0f, 24.0f), Value(U, 1.1f, 11.1f), notUsed, 0.1f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(modVecScalar)); 1532 1533 if (isNormalOp) 1534 binaryOpGroup 1535 << operInfoFunc(modName, modOp, IV, Value(I, 0.0f, 6.0f), Value(IV, 1.1f, 6.1f), notUsed, 0.25f, 0.5f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(modScalarVec)) 1536 << operInfoFunc(modName, modOp, IV, Value(I, 0.0f, 6.0f), Value(IV, 1.1f, 11.1f), notUsed, 0.1f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(modScalarVec)) 1537 << operInfoFunc(modName, modOp, UV, Value(U, 0.0f, 6.0f), Value(UV, 1.1f, 6.1f), notUsed, 0.25f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(modScalarVec)) 1538 << operInfoFunc(modName, modOp, UV, Value(U, 0.0f, 24.0f), Value(UV, 1.1f, 11.1f), notUsed, 0.1f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(modScalarVec)); 1539 1540 // The bitwise and operator. 1541 1542 binaryOpGroup 1543 << operInfoFunc(andName, andOp, IGT, Value(IGT, -16.0f, 16.0f), Value(IGT, -16.0f, 16.0f), notUsed, 0.03f, 0.5f, PRECMASK_MEDIUMP, INT_GENTYPE_FUNCS(bitwiseAnd)) 1544 << operInfoFunc(andName, andOp, IGT, Value(IGT, -2e9f, 2e9f), Value(IGT, -2e9f, 2e9f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_GENTYPE_FUNCS(bitwiseAnd)) 1545 << operInfoFunc(andName, andOp, UGT, Value(UGT, 0.0f, 32.0f), Value(UGT, 0.0f, 32.0f), notUsed, 0.03f, 0.0f, PRECMASK_MEDIUMP, UINT_GENTYPE_FUNCS(bitwiseAnd)) 1546 << operInfoFunc(andName, andOp, UGT, Value(UGT, 0.0f, 4e9f), Value(UGT, 0.0f, 4e9f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_GENTYPE_FUNCS(bitwiseAnd)) 1547 << operInfoFunc(andName, andOp, IV, Value(IV, -16.0f, 16.0f), Value(I, -16.0f, 16.0f), notUsed, 0.03f, 0.5f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(bitwiseAndVecScalar)) 1548 << operInfoFunc(andName, andOp, IV, Value(IV, -2e9f, 2e9f), Value(I, -2e9f, 2e9f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(bitwiseAndVecScalar)) 1549 << operInfoFunc(andName, andOp, UV, Value(UV, 0.0f, 32.0f), Value(U, 0.0f, 32.0f), notUsed, 0.03f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(bitwiseAndVecScalar)) 1550 << operInfoFunc(andName, andOp, UV, Value(UV, 0.0f, 4e9f), Value(U, 0.0f, 4e9f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(bitwiseAndVecScalar)); 1551 1552 if (isNormalOp) 1553 binaryOpGroup 1554 << operInfoFunc(andName, andOp, IV, Value(I, -16.0f, 16.0f), Value(IV, -16.0f, 16.0f), notUsed, 0.03f, 0.5f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(bitwiseAndScalarVec)) 1555 << operInfoFunc(andName, andOp, IV, Value(I, -2e9f, 2e9f), Value(IV, -2e9f, 2e9f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(bitwiseAndScalarVec)) 1556 << operInfoFunc(andName, andOp, UV, Value(U, 0.0f, 32.0f), Value(UV, 0.0f, 32.0f), notUsed, 0.03f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(bitwiseAndScalarVec)) 1557 << operInfoFunc(andName, andOp, UV, Value(U, 0.0f, 4e9f), Value(UV, 0.0f, 4e9f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(bitwiseAndScalarVec)); 1558 1559 // The bitwise or operator. 1560 1561 binaryOpGroup 1562 << operInfoFunc(orName, orOp, IGT, Value(IGT, -16.0f, 16.0f), Value(IGT, -16.0f, 16.0f), notUsed, 0.03f, 0.5f, PRECMASK_MEDIUMP, INT_GENTYPE_FUNCS(bitwiseOr)) 1563 << operInfoFunc(orName, orOp, IGT, Value(IGT, -2e9f, 2e9f), Value(IGT, -2e9f, 2e9f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_GENTYPE_FUNCS(bitwiseOr)) 1564 << operInfoFunc(orName, orOp, UGT, Value(UGT, 0.0f, 32.0f), Value(UGT, 0.0f, 32.0f), notUsed, 0.03f, 0.0f, PRECMASK_MEDIUMP, UINT_GENTYPE_FUNCS(bitwiseOr)) 1565 << operInfoFunc(orName, orOp, UGT, Value(UGT, 0.0f, 4e9f), Value(UGT, 0.0f, 4e9f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_GENTYPE_FUNCS(bitwiseOr)) 1566 << operInfoFunc(orName, orOp, IV, Value(IV, -16.0f, 16.0f), Value(I, -16.0f, 16.0f), notUsed, 0.03f, 0.5f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(bitwiseOrVecScalar)) 1567 << operInfoFunc(orName, orOp, IV, Value(IV, -2e9f, 2e9f), Value(I, -2e9f, 2e9f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(bitwiseOrVecScalar)) 1568 << operInfoFunc(orName, orOp, UV, Value(UV, 0.0f, 32.0f), Value(U, 0.0f, 32.0f), notUsed, 0.03f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(bitwiseOrVecScalar)) 1569 << operInfoFunc(orName, orOp, UV, Value(UV, 0.0f, 4e9f), Value(U, 0.0f, 4e9f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(bitwiseOrVecScalar)); 1570 1571 if (isNormalOp) 1572 binaryOpGroup 1573 << operInfoFunc(orName, orOp, IV, Value(I, -16.0f, 16.0f), Value(IV, -16.0f, 16.0f), notUsed, 0.03f, 0.5f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(bitwiseOrScalarVec)) 1574 << operInfoFunc(orName, orOp, IV, Value(I, -2e9f, 2e9f), Value(IV, -2e9f, 2e9f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(bitwiseOrScalarVec)) 1575 << operInfoFunc(orName, orOp, UV, Value(U, 0.0f, 32.0f), Value(UV, 0.0f, 32.0f), notUsed, 0.03f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(bitwiseOrScalarVec)) 1576 << operInfoFunc(orName, orOp, UV, Value(U, 0.0f, 4e9f), Value(UV, 0.0f, 4e9f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(bitwiseOrScalarVec)); 1577 1578 // The bitwise xor operator. 1579 1580 binaryOpGroup 1581 << operInfoFunc(xorName, xorOp, IGT, Value(IGT, -16.0f, 16.0f), Value(IGT, -16.0f, 16.0f), notUsed, 0.03f, 0.5f, PRECMASK_MEDIUMP, INT_GENTYPE_FUNCS(bitwiseXor)) 1582 << operInfoFunc(xorName, xorOp, IGT, Value(IGT, -2e9f, 2e9f), Value(IGT, -2e9f, 2e9f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_GENTYPE_FUNCS(bitwiseXor)) 1583 << operInfoFunc(xorName, xorOp, UGT, Value(UGT, 0.0f, 32.0f), Value(UGT, 0.0f, 32.0f), notUsed, 0.03f, 0.0f, PRECMASK_MEDIUMP, UINT_GENTYPE_FUNCS(bitwiseXor)) 1584 << operInfoFunc(xorName, xorOp, UGT, Value(UGT, 0.0f, 4e9f), Value(UGT, 0.0f, 4e9f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_GENTYPE_FUNCS(bitwiseXor)) 1585 << operInfoFunc(xorName, xorOp, IV, Value(IV, -16.0f, 16.0f), Value(I, -16.0f, 16.0f), notUsed, 0.03f, 0.5f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(bitwiseXorVecScalar)) 1586 << operInfoFunc(xorName, xorOp, IV, Value(IV, -2e9f, 2e9f), Value(I, -2e9f, 2e9f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(bitwiseXorVecScalar)) 1587 << operInfoFunc(xorName, xorOp, UV, Value(UV, 0.0f, 32.0f), Value(U, 0.0f, 32.0f), notUsed, 0.03f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(bitwiseXorVecScalar)) 1588 << operInfoFunc(xorName, xorOp, UV, Value(UV, 0.0f, 4e9f), Value(U, 0.0f, 4e9f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(bitwiseXorVecScalar)); 1589 1590 if (isNormalOp) 1591 binaryOpGroup 1592 << operInfoFunc(xorName, xorOp, IV, Value(I, -16.0f, 16.0f), Value(IV, -16.0f, 16.0f), notUsed, 0.03f, 0.5f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(bitwiseXorScalarVec)) 1593 << operInfoFunc(xorName, xorOp, IV, Value(I, -2e9f, 2e9f), Value(IV, -2e9f, 2e9f), notUsed, 4e-10f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(bitwiseXorScalarVec)) 1594 << operInfoFunc(xorName, xorOp, UV, Value(U, 0.0f, 32.0f), Value(UV, 0.0f, 32.0f), notUsed, 0.03f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(bitwiseXorScalarVec)) 1595 << operInfoFunc(xorName, xorOp, UV, Value(U, 0.0f, 4e9f), Value(UV, 0.0f, 4e9f), notUsed, 2e-10f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(bitwiseXorScalarVec)); 1596 1597 // The left shift operator. Second operand (shift amount) can be either int or uint, even for uint and int first operand, respectively. 1598 1599 for (int isSignedAmount = 0; isSignedAmount <= 1; isSignedAmount++) 1600 { 1601 ValueType gType = isSignedAmount == 0 ? UGT : IGT; 1602 ValueType sType = isSignedAmount == 0 ? U : I; 1603 binaryOpGroup 1604 << operInfoFunc(leftShiftName, leftShiftOp, IGT, Value(IGT, -7.0f, 7.0f), Value(gType, 0.0f, 4.0f), notUsed, 4e-3f, 0.5f, PRECMASK_MEDIUMP, INT_GENTYPE_FUNCS(leftShift)) 1605 << operInfoFunc(leftShiftName, leftShiftOp, IGT, Value(IGT, -7.0f, 7.0f), Value(gType, 0.0f, 27.0f), notUsed, 5e-10f, 0.5f, PRECMASK_HIGHP, INT_GENTYPE_FUNCS(leftShift)) 1606 << operInfoFunc(leftShiftName, leftShiftOp, UGT, Value(UGT, 0.0f, 7.0f), Value(gType, 0.0f, 5.0f), notUsed, 4e-3f, 0.0f, PRECMASK_MEDIUMP, UINT_GENTYPE_FUNCS(leftShift)) 1607 << operInfoFunc(leftShiftName, leftShiftOp, UGT, Value(UGT, 0.0f, 7.0f), Value(gType, 0.0f, 28.0f), notUsed, 5e-10f, 0.0f, PRECMASK_HIGHP, UINT_GENTYPE_FUNCS(leftShift)) 1608 << operInfoFunc(leftShiftName, leftShiftOp, IV, Value(IV, -7.0f, 7.0f), Value(sType, 0.0f, 4.0f), notUsed, 4e-3f, 0.5f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(leftShiftVecScalar)) 1609 << operInfoFunc(leftShiftName, leftShiftOp, IV, Value(IV, -7.0f, 7.0f), Value(sType, 0.0f, 27.0f), notUsed, 5e-10f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(leftShiftVecScalar)) 1610 << operInfoFunc(leftShiftName, leftShiftOp, UV, Value(UV, 0.0f, 7.0f), Value(sType, 0.0f, 5.0f), notUsed, 4e-3f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(leftShiftVecScalar)) 1611 << operInfoFunc(leftShiftName, leftShiftOp, UV, Value(UV, 0.0f, 7.0f), Value(sType, 0.0f, 28.0f), notUsed, 5e-10f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(leftShiftVecScalar)); 1612 } 1613 1614 // The right shift operator. Second operand (shift amount) can be either int or uint, even for uint and int first operand, respectively. 1615 1616 for (int isSignedAmount = 0; isSignedAmount <= 1; isSignedAmount++) 1617 { 1618 ValueType gType = isSignedAmount == 0 ? UGT : IGT; 1619 ValueType sType = isSignedAmount == 0 ? U : I; 1620 binaryOpGroup 1621 << operInfoFunc(rightShiftName, rightShiftOp, IGT, Value(IGT, -127.0f, 127.0f), Value(gType, 0.0f, 8.0f), notUsed, 4e-3f, 0.5f, PRECMASK_MEDIUMP, INT_GENTYPE_FUNCS(rightShift)) 1622 << operInfoFunc(rightShiftName, rightShiftOp, IGT, Value(IGT, -2e9f, 2e9f), Value(gType, 0.0f, 31.0f), notUsed, 5e-10f, 0.5f, PRECMASK_HIGHP, INT_GENTYPE_FUNCS(rightShift)) 1623 << operInfoFunc(rightShiftName, rightShiftOp, UGT, Value(UGT, 0.0f, 255.0f), Value(gType, 0.0f, 8.0f), notUsed, 4e-3f, 0.0f, PRECMASK_MEDIUMP, UINT_GENTYPE_FUNCS(rightShift)) 1624 << operInfoFunc(rightShiftName, rightShiftOp, UGT, Value(UGT, 0.0f, 4e9f), Value(gType, 0.0f, 31.0f), notUsed, 5e-10f, 0.0f, PRECMASK_HIGHP, UINT_GENTYPE_FUNCS(rightShift)) 1625 << operInfoFunc(rightShiftName, rightShiftOp, IV, Value(IV, -127.0f, 127.0f), Value(sType, 0.0f, 8.0f), notUsed, 4e-3f, 0.5f, PRECMASK_MEDIUMP, INT_VEC_FUNCS(rightShiftVecScalar)) 1626 << operInfoFunc(rightShiftName, rightShiftOp, IV, Value(IV, -2e9f, 2e9f), Value(sType, 0.0f, 31.0f), notUsed, 5e-10f, 0.5f, PRECMASK_HIGHP, INT_VEC_FUNCS(rightShiftVecScalar)) 1627 << operInfoFunc(rightShiftName, rightShiftOp, UV, Value(UV, 0.0f, 255.0f), Value(sType, 0.0f, 8.0f), notUsed, 4e-3f, 0.0f, PRECMASK_MEDIUMP, UINT_VEC_FUNCS(rightShiftVecScalar)) 1628 << operInfoFunc(rightShiftName, rightShiftOp, UV, Value(UV, 0.0f, 4e9f), Value(sType, 0.0f, 31.0f), notUsed, 5e-10f, 0.0f, PRECMASK_HIGHP, UINT_VEC_FUNCS(rightShiftVecScalar)); 1629 } 1630 } 1631 1632 // Rest of binary operators. 1633 1634 binaryOpGroup 1635 // Scalar relational operators. 1636 << BuiltinOperInfo("less", "<", B, Value(F, -1.0f, 1.0f), Value(F, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, eval_lessThan_float, DE_NULL, DE_NULL, DE_NULL) 1637 << BuiltinOperInfo("less", "<", B, Value(I, -5.0f, 5.0f), Value(I, -5.0f, 5.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, eval_lessThan_int, DE_NULL, DE_NULL, DE_NULL) 1638 << BuiltinOperInfo("less", "<", B, Value(U, 0.0f, 16.0f), Value(U, 0.0f, 16.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, eval_lessThan_uint, DE_NULL, DE_NULL, DE_NULL) 1639 << BuiltinOperInfo("less_or_equal", "<=", B, Value(F, -1.0f, 1.0f), Value(F, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, eval_lessThanEqual_float, DE_NULL, DE_NULL, DE_NULL) 1640 << BuiltinOperInfo("less_or_equal", "<=", B, Value(I, -5.0f, 5.0f), Value(I, -5.0f, 5.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, eval_lessThanEqual_int, DE_NULL, DE_NULL, DE_NULL) 1641 << BuiltinOperInfo("less_or_equal", "<=", B, Value(U, 0.0f, 16.0f), Value(U, 0.0f, 16.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, eval_lessThanEqual_uint, DE_NULL, DE_NULL, DE_NULL) 1642 << BuiltinOperInfo("greater", ">", B, Value(F, -1.0f, 1.0f), Value(F, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, eval_greaterThan_float, DE_NULL, DE_NULL, DE_NULL) 1643 << BuiltinOperInfo("greater", ">", B, Value(I, -5.0f, 5.0f), Value(I, -5.0f, 5.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, eval_greaterThan_int, DE_NULL, DE_NULL, DE_NULL) 1644 << BuiltinOperInfo("greater", ">", B, Value(U, 0.0f, 16.0f), Value(U, 0.0f, 16.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, eval_greaterThan_uint, DE_NULL, DE_NULL, DE_NULL) 1645 << BuiltinOperInfo("greater_or_equal", ">=", B, Value(F, -1.0f, 1.0f), Value(F, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, eval_greaterThanEqual_float, DE_NULL, DE_NULL, DE_NULL) 1646 << BuiltinOperInfo("greater_or_equal", ">=", B, Value(I, -5.0f, 5.0f), Value(I, -5.0f, 5.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, eval_greaterThanEqual_int, DE_NULL, DE_NULL, DE_NULL) 1647 << BuiltinOperInfo("greater_or_equal", ">=", B, Value(U, 0.0f, 16.0f), Value(U, 0.0f, 16.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, eval_greaterThanEqual_uint, DE_NULL, DE_NULL, DE_NULL) 1648 1649 // Equality comparison operators. 1650 << BuiltinOperInfo("equal", "==", B, Value(GT, -1.0f, 1.0f), Value(GT, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(allEqual)) 1651 << BuiltinOperInfo("equal", "==", B, Value(IGT, -5.5f, 4.7f), Value(IGT, -2.1f, 0.1f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, INT_GENTYPE_FUNCS(allEqual)) 1652 << BuiltinOperInfo("equal", "==", B, Value(UGT, 0.0f, 8.0f), Value(UGT, 3.5f, 4.5f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, UINT_GENTYPE_FUNCS(allEqual)) 1653 << BuiltinOperInfo("equal", "==", B, Value(BGT, -2.1f, 2.1f), Value(BGT, -1.1f, 3.0f), notUsed, 1.0f, 0.0f, PRECMASK_NA, BOOL_GENTYPE_FUNCS(allEqual)) 1654 << BuiltinOperInfo("not_equal", "!=", B, Value(GT, -1.0f, 1.0f), Value(GT, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(anyNotEqual)) 1655 << BuiltinOperInfo("not_equal", "!=", B, Value(IGT, -5.5f, 4.7f), Value(IGT, -2.1f, 0.1f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, INT_GENTYPE_FUNCS(anyNotEqual)) 1656 << BuiltinOperInfo("not_equal", "!=", B, Value(UGT, 0.0f, 8.0f), Value(UGT, 3.5f, 4.5f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, UINT_GENTYPE_FUNCS(anyNotEqual)) 1657 << BuiltinOperInfo("not_equal", "!=", B, Value(BGT, -2.1f, 2.1f), Value(BGT, -1.1f, 3.0f), notUsed, 1.0f, 0.0f, PRECMASK_NA, BOOL_GENTYPE_FUNCS(anyNotEqual)) 1658 1659 // Logical operators. 1660 << BuiltinOperInfo("logical_and", "&&", B, Value(B, -1.0f, 1.0f), Value(B, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_NA, BOOL_FUNCS(logicalAnd)) 1661 << BuiltinOperInfo("logical_or", "||", B, Value(B, -1.0f, 1.0f), Value(B, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_NA, BOOL_FUNCS(logicalOr)) 1662 << BuiltinOperInfo("logical_xor", "^^", B, Value(B, -1.0f, 1.0f), Value(B, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_NA, BOOL_FUNCS(logicalXor)); 1663 1664 funcInfoGroups.push_back(binaryOpGroup); 1665 1666 // Angle and Trigonometry Functions. 1667 funcInfoGroups.push_back( 1668 BuiltinFuncGroup("angle_and_trigonometry", "Angle and trigonometry function tests.") 1669 << BuiltinFuncInfo("radians", "radians", GT, Value(GT, -1.0f, 1.0f), notUsed, notUsed, 25.0f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(radians) ) 1670 << BuiltinFuncInfo("degrees", "degrees", GT, Value(GT, -1.0f, 1.0f), notUsed, notUsed, 0.04f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(degrees) ) 1671 << BuiltinFuncInfo("sin", "sin", GT, Value(GT, -5.0f, 5.0f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(sin) ) 1672 << BuiltinFuncInfo("sin2", "sin", GT, Value(GT, -1.5f, 1.5f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_MEDIUMP, FLOAT_GENTYPE_FUNCS(sin) ) 1673 << BuiltinFuncInfo("cos", "cos", GT, Value(GT, -5.0f, 5.0f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(cos) ) 1674 << BuiltinFuncInfo("cos2", "cos", GT, Value(GT, -1.5f, 1.5f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_MEDIUMP, FLOAT_GENTYPE_FUNCS(cos) ) 1675 << BuiltinFuncInfo("tan", "tan", GT, Value(GT, -5.0f, 5.0f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(tan) ) 1676 << BuiltinFuncInfo("tan2", "tan", GT, Value(GT, -1.5f, 5.5f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_MEDIUMP, FLOAT_GENTYPE_FUNCS(tan) ) 1677 << BuiltinFuncInfo("asin", "asin", GT, Value(GT, -1.0f, 1.0f), notUsed, notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(asin) ) 1678 << BuiltinFuncInfo("acos", "acos", GT, Value(GT, -1.0f, 1.0f), notUsed, notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(acos) ) 1679 << BuiltinFuncInfo("atan", "atan", GT, Value(GT, -4.0f, 4.0f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_HIGHP, FLOAT_GENTYPE_FUNCS(atan) ) 1680 << BuiltinFuncInfo("atan2", "atan", GT, Value(GT, -4.0f, 4.0f), Value(GT, 0.5f, 2.0f), notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(atan2) ) 1681 << BuiltinFuncInfo("sinh", "sinh", GT, Value(GT, -5.0f, 5.0f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(sinh) ) 1682 << BuiltinFuncInfo("sinh2", "sinh", GT, Value(GT, -1.5f, 1.5f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_MEDIUMP, FLOAT_GENTYPE_FUNCS(sinh) ) 1683 << BuiltinFuncInfo("cosh", "cosh", GT, Value(GT, -5.0f, 5.0f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(cosh) ) 1684 << BuiltinFuncInfo("cosh2", "cosh", GT, Value(GT, -1.5f, 1.5f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_MEDIUMP, FLOAT_GENTYPE_FUNCS(cosh) ) 1685 << BuiltinFuncInfo("tanh", "tanh", GT, Value(GT, -5.0f, 5.0f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(tanh) ) 1686 << BuiltinFuncInfo("tanh2", "tanh", GT, Value(GT, -1.5f, 5.5f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_MEDIUMP, FLOAT_GENTYPE_FUNCS(tanh) ) 1687 << BuiltinFuncInfo("asinh", "asinh", GT, Value(GT, -1.0f, 1.0f), notUsed, notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(asinh) ) 1688 << BuiltinFuncInfo("acosh", "acosh", GT, Value(GT, 1.0f, 2.2f), notUsed, notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(acosh) ) 1689 << BuiltinFuncInfo("atanh", "atanh", GT, Value(GT, -0.99f, 0.99f), notUsed, notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(atanh) ) 1690 ); 1691 1692 // Exponential Functions. 1693 funcInfoGroups.push_back( 1694 BuiltinFuncGroup("exponential", "Exponential function tests") 1695 << BuiltinFuncInfo("pow", "pow", GT, Value(GT, 0.1f, 8.0f), Value(GT, -4.0f, 2.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(pow) ) 1696 << BuiltinFuncInfo("exp", "exp", GT, Value(GT, -6.0f, 3.0f), notUsed, notUsed, 0.5f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(exp) ) 1697 << BuiltinFuncInfo("log", "log", GT, Value(GT, 0.1f, 10.0f), notUsed, notUsed, 0.5f, 0.3f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(log) ) 1698 << BuiltinFuncInfo("exp2", "exp2", GT, Value(GT, -7.0f, 2.0f), notUsed, notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(exp2) ) 1699 << BuiltinFuncInfo("log2", "log2", GT, Value(GT, 0.1f, 10.0f), notUsed, notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(log2) ) 1700 << BuiltinFuncInfo("sqrt", "sqrt", GT, Value(GT, 0.0f, 10.0f), notUsed, notUsed, 0.3f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(sqrt) ) 1701 << BuiltinFuncInfo("inversesqrt", "inversesqrt", GT, Value(GT, 0.5f, 10.0f), notUsed, notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(inverseSqrt) ) 1702 ); 1703 1704 // Common Functions. 1705 funcInfoGroups.push_back( 1706 BuiltinFuncGroup("common_functions", "Common function tests.") 1707 << BuiltinFuncInfo("abs", "abs", GT, Value(GT, -2.0f, 2.0f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(abs) ) 1708 << BuiltinFuncInfo("sign", "sign", GT, Value(GT, -1.5f, 1.5f), notUsed, notUsed, 0.3f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(sign) ) 1709 << BuiltinFuncInfo("floor", "floor", GT, Value(GT, -2.5f, 2.5f), notUsed, notUsed, 0.2f, 0.7f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(floor) ) 1710 << BuiltinFuncInfo("trunc", "trunc", GT, Value(GT, -2.5f, 2.5f), notUsed, notUsed, 0.2f, 0.7f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(trunc) ) 1711 << BuiltinFuncInfo("roundEven", "roundEven", GT, Value(GT, -2.5f, 2.5f), notUsed, notUsed, 0.2f, 0.7f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(roundToEven) ) 1712 << BuiltinFuncInfo("ceil", "ceil", GT, Value(GT, -2.5f, 2.5f), notUsed, notUsed, 0.2f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(ceil) ) 1713 << BuiltinFuncInfo("fract", "fract", GT, Value(GT, -1.5f, 1.5f), notUsed, notUsed, 0.8f, 0.1f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(fract) ) 1714 << BuiltinFuncInfo("mod", "mod", GT, Value(GT, -2.0f, 2.0f), Value(GT, 0.9f, 6.0f), notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(mod) ) 1715 << BuiltinFuncInfo("mod", "mod", GT, Value(FV, -2.0f, 2.0f), Value(F, 0.9f, 6.0f), notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_VEC_FUNCS(modVecScalar) ) 1716 << BuiltinFuncInfo("min", "min", GT, Value(GT, -1.0f, 1.0f), Value(GT, -1.0f, 1.0f), notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(min) ) 1717 << BuiltinFuncInfo("min", "min", GT, Value(FV, -1.0f, 1.0f), Value(F, -1.0f, 1.0f), notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_VEC_FUNCS(minVecScalar) ) 1718 << BuiltinFuncInfo("min", "min", IGT,Value(IGT, -4.0f, 4.0f), Value(IGT, -4.0f, 4.0f), notUsed, 0.125f, 0.5f, PRECMASK_ALL, INT_GENTYPE_FUNCS(min) ) 1719 << BuiltinFuncInfo("min", "min", IGT,Value(IV, -4.0f, 4.0f), Value(I, -4.0f, 4.0f), notUsed, 0.125f, 0.5f, PRECMASK_ALL, INT_VEC_FUNCS(minVecScalar) ) 1720 << BuiltinFuncInfo("min", "min", UGT,Value(UGT, 0.0f, 8.0f), Value(UGT, 0.0f, 8.0f), notUsed, 0.125f, 0.0f, PRECMASK_ALL, UINT_GENTYPE_FUNCS(min) ) 1721 << BuiltinFuncInfo("min", "min", UGT,Value(UV, 0.0f, 8.0f), Value(U, 0.0f, 8.0f), notUsed, 0.125f, 0.0f, PRECMASK_ALL, UINT_VEC_FUNCS(minVecScalar) ) 1722 << BuiltinFuncInfo("max", "max", GT, Value(GT, -1.0f, 1.0f), Value(GT, -1.0f, 1.0f), notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(max) ) 1723 << BuiltinFuncInfo("max", "max", GT, Value(FV, -1.0f, 1.0f), Value(F, -1.0f, 1.0f), notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_VEC_FUNCS(maxVecScalar) ) 1724 << BuiltinFuncInfo("max", "max", IGT,Value(IGT, -4.0f, 4.0f), Value(IGT, -4.0f, 4.0f), notUsed, 0.125f, 0.5f, PRECMASK_ALL, INT_GENTYPE_FUNCS(max) ) 1725 << BuiltinFuncInfo("max", "max", IGT,Value(IV, -4.0f, 4.0f), Value(I, -4.0f, 4.0f), notUsed, 0.125f, 0.5f, PRECMASK_ALL, INT_VEC_FUNCS(maxVecScalar) ) 1726 << BuiltinFuncInfo("max", "max", UGT,Value(UGT, 0.0f, 8.0f), Value(UGT, 0.0f, 8.0f), notUsed, 0.125f, 0.0f, PRECMASK_ALL, UINT_GENTYPE_FUNCS(max) ) 1727 << BuiltinFuncInfo("max", "max", UGT,Value(UV, 0.0f, 8.0f), Value(U, 0.0f, 8.0f), notUsed, 0.125f, 0.0f, PRECMASK_ALL, UINT_VEC_FUNCS(maxVecScalar) ) 1728 << BuiltinFuncInfo("clamp", "clamp", GT, Value(GT, -1.0f, 1.0f), Value(GT, -0.5f, 0.5f), Value(GT, 0.5f, 1.0f), 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(clamp) ) 1729 << BuiltinFuncInfo("clamp", "clamp", GT, Value(FV, -1.0f, 1.0f), Value(F, -0.5f, 0.5f), Value(F, 0.5f, 1.0f), 0.5f, 0.5f, PRECMASK_ALL, FLOAT_VEC_FUNCS(clampVecScalarScalar) ) 1730 << BuiltinFuncInfo("clamp", "clamp", IGT,Value(IGT, -4.0f, 4.0f), Value(IGT, -2.0f, 2.0f), Value(IGT, 2.0f, 4.0f), 0.125f, 0.5f, PRECMASK_ALL, INT_GENTYPE_FUNCS(clamp) ) 1731 << BuiltinFuncInfo("clamp", "clamp", IGT,Value(IV, -4.0f, 4.0f), Value(I, -2.0f, 2.0f), Value(I, 2.0f, 4.0f), 0.125f, 0.5f, PRECMASK_ALL, INT_VEC_FUNCS(clampVecScalarScalar) ) 1732 << BuiltinFuncInfo("clamp", "clamp", UGT,Value(UGT, 0.0f, 8.0f), Value(UGT, 2.0f, 6.0f), Value(UGT, 6.0f, 8.0f), 0.125f, 0.0f, PRECMASK_ALL, UINT_GENTYPE_FUNCS(clamp) ) 1733 << BuiltinFuncInfo("clamp", "clamp", UGT,Value(UV, 0.0f, 8.0f), Value(U, 2.0f, 6.0f), Value(U, 6.0f, 8.0f), 0.125f, 0.0f, PRECMASK_ALL, UINT_VEC_FUNCS(clampVecScalarScalar) ) 1734 << BuiltinFuncInfo("mix", "mix", GT, Value(GT, -1.0f, 1.0f), Value(GT, -1.0f, 1.0f), Value(GT, 0.0f, 1.0f), 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(mix) ) 1735 << BuiltinFuncInfo("mix", "mix", GT, Value(FV, -1.0f, 1.0f), Value(FV, -1.0f, 1.0f), Value(F, 0.0f, 1.0f), 0.5f, 0.5f, PRECMASK_ALL, FLOAT_VEC_FUNCS(mixVecVecScalar) ) 1736 << BuiltinFuncInfo("step", "step", GT, Value(GT, -1.0f, 1.0f), Value(GT, -1.0f, 0.0f), notUsed, 0.5f, 0.25f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(step) ) 1737 << BuiltinFuncInfo("step", "step", GT, Value(F, -1.0f, 1.0f), Value(FV, -1.0f, 0.0f), notUsed, 0.5f, 0.25f, PRECMASK_ALL, FLOAT_VEC_FUNCS(stepScalarVec) ) 1738 << BuiltinFuncInfo("smoothstep", "smoothstep", GT, Value(GT, -0.5f, 0.0f), Value(GT, 0.1f, 1.0f), Value(GT, -1.0f, 1.0f), 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(smoothStep) ) 1739 << BuiltinFuncInfo("smoothstep", "smoothstep", GT, Value(F, -0.5f, 0.0f), Value(F, 0.1f, 1.0f), Value(FV, -1.0f, 1.0f), 0.5f, 0.5f, PRECMASK_ALL, FLOAT_VEC_FUNCS(smoothStepScalarScalarVec) ) 1740 ); 1741 1742 // Geometric Functions. 1743 funcInfoGroups.push_back( 1744 BuiltinFuncGroup("geometric", "Geometric function tests.") 1745 << BuiltinFuncInfo("length", "length", F, Value(GT, -5.0f, 5.0f), notUsed, notUsed, 0.1f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(length) ) 1746 << BuiltinFuncInfo("distance", "distance", F, Value(GT, -5.0f, 5.0f), Value(GT, -5.0f, 5.0f), notUsed, 0.1f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(distance) ) 1747 << BuiltinFuncInfo("dot", "dot", F, Value(GT, -5.0f, 5.0f), Value(GT, -5.0f, 5.0f), notUsed, 0.1f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(dot) ) 1748 << BuiltinFuncInfo("cross", "cross", V3, Value(GT, -5.0f, 5.0f), Value(GT, -5.0f, 5.0f), notUsed, 0.1f, 0.5f, PRECMASK_ALL, DE_NULL, DE_NULL, eval_cross_vec3, DE_NULL ) 1749 << BuiltinFuncInfo("normalize", "normalize", GT, Value(GT, 0.1f, 4.0f), notUsed, notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(normalize) ) 1750 << BuiltinFuncInfo("faceforward", "faceforward", GT, Value(GT, -5.0f, 5.0f), Value(GT, -5.0f, 5.0f), Value(GT, -1.0f, 1.0f), 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(faceForward) ) 1751 << BuiltinFuncInfo("reflect", "reflect", GT, Value(GT, -0.8f, -0.5f), Value(GT, 0.5f, 0.8f), notUsed, 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(reflect) ) 1752 << BuiltinFuncInfo("refract", "refract", GT, Value(GT, -0.8f, 1.2f), Value(GT, -1.1f, 0.5f), Value(F, 0.2f, 1.5f), 0.5f, 0.5f, PRECMASK_ALL, FLOAT_GENTYPE_FUNCS(refract) ) 1753 ); 1754 1755 // Vector Relational Functions. 1756 funcInfoGroups.push_back( 1757 BuiltinFuncGroup("float_compare", "Floating point comparison tests.") 1758 << BuiltinFuncInfo("lessThan", "lessThan", BV, Value(FV, -1.0f, 1.0f), Value(FV, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_VEC_FUNCS(lessThan) ) 1759 << BuiltinFuncInfo("lessThanEqual", "lessThanEqual", BV, Value(FV, -1.0f, 1.0f), Value(FV, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_VEC_FUNCS(lessThanEqual) ) 1760 << BuiltinFuncInfo("greaterThan", "greaterThan", BV, Value(FV, -1.0f, 1.0f), Value(FV, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_VEC_FUNCS(greaterThan) ) 1761 << BuiltinFuncInfo("greaterThanEqual", "greaterThanEqual", BV, Value(FV, -1.0f, 1.0f), Value(FV, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_VEC_FUNCS(greaterThanEqual) ) 1762 << BuiltinFuncInfo("equal", "equal", BV, Value(FV, -1.0f, 1.0f), Value(FV, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_VEC_FUNCS(equal) ) 1763 << BuiltinFuncInfo("notEqual", "notEqual", BV, Value(FV, -1.0f, 1.0f), Value(FV, -1.0f, 1.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, FLOAT_VEC_FUNCS(notEqual) ) 1764 ); 1765 1766 funcInfoGroups.push_back( 1767 BuiltinFuncGroup("int_compare", "Integer comparison tests.") 1768 << BuiltinFuncInfo("lessThan", "lessThan", BV, Value(IV, -5.2f, 4.9f), Value(IV, -5.0f, 5.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, INT_VEC_FUNCS(lessThan) ) 1769 << BuiltinFuncInfo("lessThanEqual", "lessThanEqual", BV, Value(IV, -5.2f, 4.9f), Value(IV, -5.0f, 5.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, INT_VEC_FUNCS(lessThanEqual) ) 1770 << BuiltinFuncInfo("greaterThan", "greaterThan", BV, Value(IV, -5.2f, 4.9f), Value(IV, -5.0f, 5.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, INT_VEC_FUNCS(greaterThan) ) 1771 << BuiltinFuncInfo("greaterThanEqual", "greaterThanEqual", BV, Value(IV, -5.2f, 4.9f), Value(IV, -5.0f, 5.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, INT_VEC_FUNCS(greaterThanEqual) ) 1772 << BuiltinFuncInfo("equal", "equal", BV, Value(IV, -5.2f, 4.9f), Value(IV, -5.0f, 5.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, INT_VEC_FUNCS(equal) ) 1773 << BuiltinFuncInfo("notEqual", "notEqual", BV, Value(IV, -5.2f, 4.9f), Value(IV, -5.0f, 5.0f), notUsed, 1.0f, 0.0f, PRECMASK_ALL, INT_VEC_FUNCS(notEqual) ) 1774 ); 1775 1776 funcInfoGroups.push_back( 1777 BuiltinFuncGroup("bool_compare", "Boolean comparison tests.") 1778 << BuiltinFuncInfo("equal", "equal", BV, Value(BV, -5.2f, 4.9f), Value(BV, -5.0f, 5.0f), notUsed, 1.0f, 0.0f, PRECMASK_NA, BOOL_VEC_FUNCS(equal) ) 1779 << BuiltinFuncInfo("notEqual", "notEqual", BV, Value(BV, -5.2f, 4.9f), Value(BV, -5.0f, 5.0f), notUsed, 1.0f, 0.0f, PRECMASK_NA, BOOL_VEC_FUNCS(notEqual) ) 1780 << BuiltinFuncInfo("any", "any", B, Value(BV, -1.0f, 0.3f), notUsed, notUsed, 1.0f, 0.0f, PRECMASK_NA, BOOL_VEC_FUNCS(any) ) 1781 << BuiltinFuncInfo("all", "all", B, Value(BV, -0.3f, 1.0f), notUsed, notUsed, 1.0f, 0.0f, PRECMASK_NA, BOOL_VEC_FUNCS(all) ) 1782 << BuiltinFuncInfo("not", "not", BV, Value(BV, -1.0f, 1.0f), notUsed, notUsed, 1.0f, 0.0f, PRECMASK_NA, BOOL_VEC_FUNCS(boolNot) ) 1783 ); 1784 1785 static const ShaderType s_shaderTypes[] = 1786 { 1787 SHADERTYPE_VERTEX, 1788 SHADERTYPE_FRAGMENT 1789 }; 1790 1791 static const DataType s_floatTypes[] = 1792 { 1793 TYPE_FLOAT, 1794 TYPE_FLOAT_VEC2, 1795 TYPE_FLOAT_VEC3, 1796 TYPE_FLOAT_VEC4 1797 }; 1798 1799 static const DataType s_intTypes[] = 1800 { 1801 TYPE_INT, 1802 TYPE_INT_VEC2, 1803 TYPE_INT_VEC3, 1804 TYPE_INT_VEC4 1805 }; 1806 1807 static const DataType s_uintTypes[] = 1808 { 1809 TYPE_UINT, 1810 TYPE_UINT_VEC2, 1811 TYPE_UINT_VEC3, 1812 TYPE_UINT_VEC4 1813 }; 1814 1815 static const DataType s_boolTypes[] = 1816 { 1817 TYPE_BOOL, 1818 TYPE_BOOL_VEC2, 1819 TYPE_BOOL_VEC3, 1820 TYPE_BOOL_VEC4 1821 }; 1822 1823 for (int outerGroupNdx = 0; outerGroupNdx < (int)funcInfoGroups.size(); outerGroupNdx++) 1824 { 1825 // Create outer group. 1826 const BuiltinFuncGroup& outerGroupInfo = funcInfoGroups[outerGroupNdx]; 1827 TestCaseGroup* outerGroup = new TestCaseGroup(m_testCtx, outerGroupInfo.name, outerGroupInfo.description); 1828 addChild(outerGroup); 1829 1830 // Only create new group if name differs from previous one. 1831 TestCaseGroup* innerGroup = DE_NULL; 1832 1833 for (int funcInfoNdx = 0; funcInfoNdx < (int)outerGroupInfo.funcInfos.size(); funcInfoNdx++) 1834 { 1835 const BuiltinFuncInfo& funcInfo = outerGroupInfo.funcInfos[funcInfoNdx]; 1836 const char* shaderFuncName = funcInfo.shaderFuncName; 1837 const bool isBoolCase = (funcInfo.precisionMask == PRECMASK_NA); 1838 const bool isBoolOut = (funcInfo.outValue & (VALUE_BOOL | VALUE_BOOL_VEC | VALUE_BOOL_GENTYPE)) != 0; 1839 const bool isIntOut = (funcInfo.outValue & (VALUE_INT | VALUE_INT_VEC | VALUE_INT_GENTYPE)) != 0; 1840 const bool isUintOut = (funcInfo.outValue & (VALUE_UINT | VALUE_UINT_VEC | VALUE_UINT_GENTYPE)) != 0; 1841 const bool isFloatOut = !isBoolOut && !isIntOut && !isUintOut; 1842 1843 if (!innerGroup || (std::string(innerGroup->getName()) != funcInfo.caseName)) 1844 { 1845 std::string groupDesc = std::string("Built-in function ") + shaderFuncName + "() tests."; 1846 innerGroup = new TestCaseGroup(m_testCtx, funcInfo.caseName, groupDesc.c_str()); 1847 outerGroup->addChild(innerGroup); 1848 } 1849 1850 for (int inScalarSize = 1; inScalarSize <= 4; inScalarSize++) 1851 { 1852 const int outScalarSize = ((funcInfo.outValue == VALUE_FLOAT) || (funcInfo.outValue == VALUE_BOOL)) ? 1 : inScalarSize; 1853 const DataType outDataType = isFloatOut ? s_floatTypes[outScalarSize - 1] 1854 : isIntOut ? s_intTypes[outScalarSize - 1] 1855 : isUintOut ? s_uintTypes[outScalarSize - 1] 1856 : isBoolOut ? s_boolTypes[outScalarSize - 1] 1857 : TYPE_LAST; 1858 1859 ShaderEvalFunc evalFunc = DE_NULL; 1860 if (inScalarSize == 1) evalFunc = funcInfo.evalFuncScalar; 1861 else if (inScalarSize == 2) evalFunc = funcInfo.evalFuncVec2; 1862 else if (inScalarSize == 3) evalFunc = funcInfo.evalFuncVec3; 1863 else if (inScalarSize == 4) evalFunc = funcInfo.evalFuncVec4; 1864 else DE_ASSERT(false); 1865 1866 // Skip if no valid eval func. 1867 if (evalFunc == DE_NULL) 1868 continue; 1869 1870 for (int precision = PRECISION_MEDIUMP; precision < PRECISION_LAST; precision++) 1871 { 1872 if ((funcInfo.precisionMask & (1<<precision)) || 1873 (funcInfo.precisionMask == PRECMASK_NA && precision == PRECISION_MEDIUMP)) // use mediump interpolators for booleans 1874 { 1875 const char* precisionStr = getPrecisionName((Precision)precision); 1876 const std::string precisionPrefix = isBoolCase ? "" : (std::string(precisionStr) + "_"); 1877 1878 for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++) 1879 { 1880 const ShaderType shaderType = s_shaderTypes[shaderTypeNdx]; 1881 const char* shaderTypeName = getShaderTypeName(shaderType); 1882 const bool isVertexCase = (ShaderType)shaderType == SHADERTYPE_VERTEX; 1883 const bool isUnaryOp = (funcInfo.input1.valueType == VALUE_NONE); 1884 1885 // \note Data type names will be added to description and name in a following loop. 1886 std::string desc = std::string("Built-in function ") + shaderFuncName + "("; 1887 std::string name = precisionPrefix; 1888 1889 // Generate shader op. 1890 std::string shaderOp = std::string("res = "); 1891 1892 // Setup shader data info. 1893 ShaderDataSpec shaderSpec; 1894 shaderSpec.numInputs = 0; 1895 shaderSpec.precision = isBoolCase ? PRECISION_LAST : (Precision)precision; 1896 shaderSpec.output = outDataType; 1897 shaderSpec.resultScale = funcInfo.resultScale; 1898 shaderSpec.resultBias = funcInfo.resultBias; 1899 shaderSpec.referenceScale = funcInfo.referenceScale; 1900 shaderSpec.referenceBias = funcInfo.referenceBias; 1901 1902 if (funcInfo.type == OPERATOR) 1903 { 1904 if (isUnaryOp && funcInfo.isUnaryPrefix) 1905 shaderOp += shaderFuncName; 1906 } 1907 else if (funcInfo.type == FUNCTION) 1908 shaderOp += std::string(shaderFuncName) + "("; 1909 else // SIDE_EFFECT_OPERATOR 1910 shaderOp += "in0;\n\t"; 1911 1912 for (int inputNdx = 0; inputNdx < MAX_INPUTS; inputNdx++) 1913 { 1914 const Value& prevV = (inputNdx == 1) ? funcInfo.input0 : (inputNdx == 2) ? funcInfo.input1 : funcInfo.input2; 1915 const Value& v = (inputNdx == 0) ? funcInfo.input0 : (inputNdx == 1) ? funcInfo.input1 : funcInfo.input2; 1916 1917 if (v.valueType == VALUE_NONE) 1918 continue; // Skip unused input. 1919 1920 const int prevInScalarSize = isScalarType(prevV.valueType) ? 1 : inScalarSize; 1921 const DataType prevInDataType = isFloatType(prevV.valueType) ? s_floatTypes[prevInScalarSize - 1] 1922 : isIntType(prevV.valueType) ? s_intTypes[prevInScalarSize - 1] 1923 : isUintType(prevV.valueType) ? s_uintTypes[prevInScalarSize - 1] 1924 : isBoolType(prevV.valueType) ? s_boolTypes[prevInScalarSize - 1] 1925 : TYPE_LAST; 1926 1927 const int curInScalarSize = isScalarType(v.valueType) ? 1 : inScalarSize; 1928 const DataType curInDataType = isFloatType(v.valueType) ? s_floatTypes[curInScalarSize - 1] 1929 : isIntType(v.valueType) ? s_intTypes[curInScalarSize - 1] 1930 : isUintType(v.valueType) ? s_uintTypes[curInScalarSize - 1] 1931 : isBoolType(v.valueType) ? s_boolTypes[curInScalarSize - 1] 1932 : TYPE_LAST; 1933 1934 // Write input type(s) to case description and name. 1935 1936 if (inputNdx > 0) 1937 desc += ", "; 1938 1939 desc += getDataTypeName(curInDataType); 1940 1941 if (inputNdx == 0 || prevInDataType != curInDataType) // \note Only write input type to case name if different from previous input type (avoid overly long names). 1942 name += std::string("") + getDataTypeName(curInDataType) + "_"; 1943 1944 // Generate op input source. 1945 1946 if (funcInfo.type == OPERATOR || funcInfo.type == FUNCTION) 1947 { 1948 if (inputNdx != 0) 1949 { 1950 if (funcInfo.type == OPERATOR && !isUnaryOp) 1951 shaderOp += " " + std::string(shaderFuncName) + " "; 1952 else 1953 shaderOp += ", "; 1954 } 1955 1956 shaderOp += "in" + de::toString(inputNdx); 1957 1958 if (funcInfo.type == OPERATOR && isUnaryOp && !funcInfo.isUnaryPrefix) 1959 shaderOp += std::string(shaderFuncName); 1960 } 1961 else 1962 { 1963 DE_ASSERT(funcInfo.type == SIDE_EFFECT_OPERATOR); 1964 1965 if (inputNdx != 0 || (isUnaryOp && funcInfo.isUnaryPrefix)) 1966 shaderOp += std::string("") + (isUnaryOp ? "" : " ") + shaderFuncName + (isUnaryOp ? "" : " "); 1967 1968 shaderOp += inputNdx == 0 ? "res" : "in" + de::toString(inputNdx); // \note in0 has already been assigned to res, so start from in1. 1969 1970 if (isUnaryOp && !funcInfo.isUnaryPrefix) 1971 shaderOp += shaderFuncName; 1972 } 1973 1974 // Fill in shader info. 1975 shaderSpec.inputs[shaderSpec.numInputs++] = ShaderValue(curInDataType, v.rangeMin, v.rangeMax); 1976 } 1977 1978 if (funcInfo.type == FUNCTION) 1979 shaderOp += ")"; 1980 1981 shaderOp += ";"; 1982 1983 desc += ")."; 1984 name += shaderTypeName; 1985 1986 // Create the test case. 1987 innerGroup->addChild(new ShaderOperatorCase(m_testCtx, name.c_str(), desc.c_str(), isVertexCase, evalFunc, shaderOp, shaderSpec)); 1988 } 1989 } 1990 } 1991 } 1992 } 1993 } 1994 1995 // The ?: selection operator. 1996 1997 static const struct 1998 { 1999 const DataType type; // The type of "Y" and "Z" operands in "X ? Y : Z" (X is always bool). 2000 const ShaderEvalFunc evalFunc; 2001 } s_selectionInfo[] = 2002 { 2003 { TYPE_FLOAT, eval_selection_float }, 2004 { TYPE_FLOAT_VEC2, eval_selection_vec2 }, 2005 { TYPE_FLOAT_VEC3, eval_selection_vec3 }, 2006 { TYPE_FLOAT_VEC4, eval_selection_vec4 }, 2007 { TYPE_INT, eval_selection_int }, 2008 { TYPE_INT_VEC2, eval_selection_ivec2 }, 2009 { TYPE_INT_VEC3, eval_selection_ivec3 }, 2010 { TYPE_INT_VEC4, eval_selection_ivec4 }, 2011 { TYPE_UINT, eval_selection_uint }, 2012 { TYPE_UINT_VEC2, eval_selection_uvec2 }, 2013 { TYPE_UINT_VEC3, eval_selection_uvec3 }, 2014 { TYPE_UINT_VEC4, eval_selection_uvec4 }, 2015 { TYPE_BOOL, eval_selection_bool }, 2016 { TYPE_BOOL_VEC2, eval_selection_bvec2 }, 2017 { TYPE_BOOL_VEC3, eval_selection_bvec3 }, 2018 { TYPE_BOOL_VEC4, eval_selection_bvec4 } 2019 }; 2020 2021 TestCaseGroup* selectionGroup = new TestCaseGroup(m_testCtx, "selection", "Selection operator tests"); 2022 addChild(selectionGroup); 2023 2024 for (int typeNdx = 0; typeNdx < DE_LENGTH_OF_ARRAY(s_selectionInfo); typeNdx++) 2025 { 2026 const DataType curType = s_selectionInfo[typeNdx].type; 2027 const ShaderEvalFunc evalFunc = s_selectionInfo[typeNdx].evalFunc; 2028 const bool isBoolCase = isDataTypeBoolOrBVec(curType); 2029 const bool isFloatCase = isDataTypeFloatOrVec(curType); 2030 const bool isIntCase = isDataTypeIntOrIVec(curType); 2031 const bool isUintCase = isDataTypeUintOrUVec(curType); 2032 const char* dataTypeStr = getDataTypeName(curType); 2033 2034 DE_ASSERT(isBoolCase || isFloatCase || isIntCase || isUintCase); 2035 DE_UNREF(isIntCase); 2036 2037 for (int precision = (int)PRECISION_MEDIUMP; precision < (int)PRECISION_LAST; precision++) 2038 { 2039 if (isBoolCase && precision != PRECISION_MEDIUMP) // Use mediump interpolators for booleans. 2040 continue; 2041 2042 const char* precisionStr = getPrecisionName((Precision)precision); 2043 std::string precisionPrefix = isBoolCase ? "" : (std::string(precisionStr) + "_"); 2044 2045 for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++) 2046 { 2047 const ShaderType shaderType = s_shaderTypes[shaderTypeNdx]; 2048 const char* shaderTypeName = getShaderTypeName(shaderType); 2049 const bool isVertexCase = (ShaderType)shaderType == SHADERTYPE_VERTEX; 2050 2051 std::string name = precisionPrefix + dataTypeStr + "_" + shaderTypeName; 2052 2053 ShaderDataSpec shaderSpec; 2054 shaderSpec.numInputs = 3; 2055 shaderSpec.precision = isBoolCase ? PRECISION_LAST : (Precision)precision; 2056 shaderSpec.output = curType; 2057 shaderSpec.resultScale = (isBoolCase ? 1.0f : (isFloatCase ? 0.5f : (isUintCase ? 0.5f : 0.1f))); 2058 shaderSpec.resultBias = (isBoolCase ? 0.0f : (isFloatCase ? 0.5f : (isUintCase ? 0.0f : 0.5f))); 2059 shaderSpec.referenceScale = shaderSpec.resultScale; 2060 shaderSpec.referenceBias = shaderSpec.resultBias; 2061 2062 const float rangeMin = (isBoolCase ? -1.0f : (isFloatCase ? -1.0f : (isUintCase ? 0.0f : -5.0f))); 2063 const float rangeMax = (isBoolCase ? 1.0f : (isFloatCase ? 1.0f : (isUintCase ? 2.0f : 5.0f))); 2064 2065 shaderSpec.inputs[0] = ShaderValue(TYPE_BOOL, -1.0f, 1.0f); 2066 shaderSpec.inputs[1] = ShaderValue(curType, rangeMin, rangeMax); 2067 shaderSpec.inputs[2] = ShaderValue(curType, rangeMin, rangeMax); 2068 2069 selectionGroup->addChild(new ShaderOperatorCase(m_testCtx, name.c_str(), "", isVertexCase, evalFunc, "res = in0 ? in1 : in2;", shaderSpec)); 2070 } 2071 } 2072 } 2073 2074 // The sequence operator (comma). 2075 2076 TestCaseGroup* sequenceGroup = new TestCaseGroup(m_testCtx, "sequence", "Sequence operator tests"); 2077 addChild(sequenceGroup); 2078 2079 TestCaseGroup* sequenceNoSideEffGroup = new TestCaseGroup(m_testCtx, "no_side_effects", "Sequence tests without side-effects"); 2080 TestCaseGroup* sequenceSideEffGroup = new TestCaseGroup(m_testCtx, "side_effects", "Sequence tests with side-effects"); 2081 sequenceGroup->addChild(sequenceNoSideEffGroup); 2082 sequenceGroup->addChild(sequenceSideEffGroup); 2083 2084 static const struct 2085 { 2086 const bool containsSideEffects; 2087 const char* caseName; 2088 const char* expressionStr; 2089 const int numInputs; 2090 const DataType inputTypes[MAX_INPUTS]; 2091 const DataType resultType; 2092 const ShaderEvalFunc evalFunc; 2093 } s_sequenceCases[] = 2094 { 2095 { false, "vec4", "in0, in2 + in1, in1 + in0", 3, { TYPE_FLOAT_VEC4, TYPE_FLOAT_VEC4, TYPE_FLOAT_VEC4 }, TYPE_FLOAT_VEC4, evalSequenceNoSideEffCase0 }, 2096 { false, "float_uint", "in0 + in2, in1 + in1", 3, { TYPE_FLOAT, TYPE_UINT, TYPE_FLOAT }, TYPE_UINT, evalSequenceNoSideEffCase1 }, 2097 { false, "bool_vec2", "in0 && in1, in0, ivec2(vec2(in0) + in2)", 3, { TYPE_BOOL, TYPE_BOOL, TYPE_FLOAT_VEC2 }, TYPE_INT_VEC2, evalSequenceNoSideEffCase2 }, 2098 { false, "vec4_ivec4_bvec4", "in0 + vec4(in1), in2, in1", 3, { TYPE_FLOAT_VEC4, TYPE_INT_VEC4, TYPE_BOOL_VEC4 }, TYPE_INT_VEC4, evalSequenceNoSideEffCase3 }, 2099 2100 { true, "vec4", "in0++, in1 = in0 + in2, in2 = in1", 3, { TYPE_FLOAT_VEC4, TYPE_FLOAT_VEC4, TYPE_FLOAT_VEC4 }, TYPE_FLOAT_VEC4, evalSequenceSideEffCase0 }, 2101 { true, "float_uint", "in1++, in0 = float(in1), in1 = uint(in0 + in2)", 3, { TYPE_FLOAT, TYPE_UINT, TYPE_FLOAT }, TYPE_UINT, evalSequenceSideEffCase1 }, 2102 { true, "bool_vec2", "in1 = in0, in2++, in2 = in2 + vec2(in1), ivec2(in2)", 3, { TYPE_BOOL, TYPE_BOOL, TYPE_FLOAT_VEC2 }, TYPE_INT_VEC2, evalSequenceSideEffCase2 }, 2103 { true, "vec4_ivec4_bvec4", "in0 = in0 + vec4(in2), in1 = in1 + ivec4(in0), in1++", 3, { TYPE_FLOAT_VEC4, TYPE_INT_VEC4, TYPE_BOOL_VEC4 }, TYPE_INT_VEC4, evalSequenceSideEffCase3 } 2104 }; 2105 2106 for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(s_sequenceCases); caseNdx++) 2107 { 2108 for (int precision = (int)PRECISION_MEDIUMP; precision < (int)PRECISION_LAST; precision++) 2109 { 2110 for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++) 2111 { 2112 const ShaderType shaderType = s_shaderTypes[shaderTypeNdx]; 2113 const char* shaderTypeName = getShaderTypeName(shaderType); 2114 const bool isVertexCase = (ShaderType)shaderType == SHADERTYPE_VERTEX; 2115 2116 std::string name = std::string("") + getPrecisionName((Precision)precision) + "_" + s_sequenceCases[caseNdx].caseName + "_" + shaderTypeName; 2117 2118 ShaderDataSpec shaderSpec; 2119 shaderSpec.numInputs = s_sequenceCases[caseNdx].numInputs; 2120 shaderSpec.precision = (Precision)precision; 2121 shaderSpec.output = s_sequenceCases[caseNdx].resultType; 2122 shaderSpec.resultScale = 0.5f; 2123 shaderSpec.resultBias = 0.0f; 2124 shaderSpec.referenceScale = shaderSpec.resultScale; 2125 shaderSpec.referenceBias = shaderSpec.resultBias; 2126 2127 for (int inputNdx = 0; inputNdx < s_sequenceCases[caseNdx].numInputs; inputNdx++) 2128 { 2129 const DataType type = s_sequenceCases[caseNdx].inputTypes[inputNdx]; 2130 const float rangeMin = (isDataTypeFloatOrVec(type) ? -0.5f : (isDataTypeIntOrIVec(type) ? -2.0f : (isDataTypeUintOrUVec(type) ? 0.0f : -1.0f))); 2131 const float rangeMax = (isDataTypeFloatOrVec(type) ? 0.5f : (isDataTypeIntOrIVec(type) ? 2.0f : (isDataTypeUintOrUVec(type) ? 2.0f : 1.0f))); 2132 2133 shaderSpec.inputs[inputNdx] = ShaderValue(type, rangeMin, rangeMax); 2134 } 2135 2136 const std::string expression = std::string("") + "res = (" + s_sequenceCases[caseNdx].expressionStr + ");"; 2137 2138 TestCaseGroup* group = s_sequenceCases[caseNdx].containsSideEffects ? sequenceSideEffGroup : sequenceNoSideEffGroup; 2139 group->addChild(new ShaderOperatorCase(m_testCtx, name.c_str(), "", isVertexCase, s_sequenceCases[caseNdx].evalFunc, expression.c_str(), shaderSpec)); 2140 } 2141 } 2142 } 2143 } 2144 2145 } // anonymous 2146 2147 tcu::TestCaseGroup* createOperatorTests (tcu::TestContext& testCtx) 2148 { 2149 return new ShaderOperatorTests(testCtx); 2150 } 2151 2152 } // sr 2153 } // vkt 2154