1 /*------------------------------------------------------------------------- 2 * OpenGL Conformance Test Suite 3 * ----------------------------- 4 * 5 * Copyright (c) 2014-2016 The Khronos Group Inc. 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 */ /*! 20 * \file 21 * \brief 22 */ /*-------------------------------------------------------------------*/ 23 24 #include "es31cShaderBitfieldOperationTests.hpp" 25 #include "deMath.h" 26 #include "deRandom.hpp" 27 #include "deString.h" 28 #include "deStringUtil.hpp" 29 #include "gluContextInfo.hpp" 30 #include "gluDrawUtil.hpp" 31 #include "gluPixelTransfer.hpp" 32 #include "gluShaderProgram.hpp" 33 #include "glw.h" 34 #include "glwFunctions.hpp" 35 #include "tcuCommandLine.hpp" 36 #include "tcuStringTemplate.hpp" 37 #include "tcuSurface.hpp" 38 #include "tcuTestLog.hpp" 39 40 namespace glcts 41 { 42 43 using tcu::TestLog; 44 using std::string; 45 using std::vector; 46 using glcts::Context; 47 48 static std::string specializeVersion(const std::string& source, glu::GLSLVersion version, const char* testStatement) 49 { 50 DE_ASSERT(version == glu::GLSL_VERSION_310_ES || version >= glu::GLSL_VERSION_430); 51 std::map<std::string, std::string> args; 52 args["VERSION_DECL"] = glu::getGLSLVersionDeclaration(version); 53 args["TEST_STATEMENT"] = testStatement; 54 return tcu::StringTemplate(source.c_str()).specialize(args); 55 } 56 57 struct Data 58 { 59 Data() 60 { 61 memset(this, 0, sizeof *this); 62 } 63 Data(Data const& init) 64 { 65 memcpy(this, &init, sizeof *this); 66 } 67 68 GLuint inUvec4[4]; 69 GLint inIvec4[4]; 70 GLfloat inVec4[4]; 71 72 GLuint in2Uvec4[4]; 73 GLint in2Ivec4[4]; 74 GLfloat in2Vec4[4]; 75 76 GLint offset; 77 GLint bits; 78 GLint padding[2]; 79 80 GLuint outUvec4[4]; 81 GLint outIvec4[4]; 82 GLfloat outVec4[4]; 83 84 GLuint out2Uvec4[4]; 85 GLint out2Ivec4[4]; 86 GLfloat out2Vec4[4]; 87 }; 88 89 struct Uvec4 : public Data 90 { 91 Uvec4(GLuint x = 0, GLuint y = 0, GLuint z = 0, GLuint w = 0) 92 { 93 inUvec4[0] = x; 94 inUvec4[1] = y; 95 inUvec4[2] = z; 96 inUvec4[3] = w; 97 } 98 }; 99 100 struct Ivec4 : public Data 101 { 102 Ivec4(GLint x = 0, GLint y = 0, GLint z = 0, GLint w = 0) 103 { 104 inIvec4[0] = x; 105 inIvec4[1] = y; 106 inIvec4[2] = z; 107 inIvec4[3] = w; 108 } 109 }; 110 111 struct Vec4 : public Data 112 { 113 Vec4(GLfloat x = 0.0f, GLfloat y = 0.0f, GLfloat z = 0.0f, GLfloat w = 0.0f) 114 { 115 inVec4[0] = x; 116 inVec4[1] = y; 117 inVec4[2] = z; 118 inVec4[3] = w; 119 } 120 }; 121 122 class ShaderBitfieldOperationCase : public TestCase 123 { 124 public: 125 ShaderBitfieldOperationCase(Context& context, const char* name, const char* description, 126 glu::GLSLVersion glslVersion, Data const& data, char const* testStatement); 127 ~ShaderBitfieldOperationCase(); 128 129 IterateResult iterate(); 130 131 protected: 132 glu::GLSLVersion m_glslVersion; 133 Data m_data; 134 std::string m_testStatement; 135 136 virtual bool test(Data const* data) = 0; 137 }; 138 139 ShaderBitfieldOperationCase::ShaderBitfieldOperationCase(Context& context, const char* name, const char* description, 140 glu::GLSLVersion glslVersion, Data const& data, 141 char const* testStatement) 142 : TestCase(context, name, description), m_glslVersion(glslVersion), m_data(data), m_testStatement(testStatement) 143 { 144 DE_ASSERT(glslVersion == glu::GLSL_VERSION_310_ES || glslVersion >= glu::GLSL_VERSION_430); 145 } 146 147 ShaderBitfieldOperationCase::~ShaderBitfieldOperationCase() 148 { 149 } 150 151 ShaderBitfieldOperationCase::IterateResult ShaderBitfieldOperationCase::iterate() 152 { 153 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 154 bool isOk = true; 155 156 GLuint data; 157 gl.genBuffers(1, &data); 158 gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, data); 159 gl.bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(Data), &m_data, GL_STATIC_DRAW); 160 gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, data); 161 162 char const* css = "${VERSION_DECL}\n" 163 "\n" 164 "layout(local_size_x = 1) in;\n" 165 "\n" 166 "layout(binding = 0, std430) buffer Data {\n" 167 " uvec4 inUvec4;\n" 168 " ivec4 inIvec4;\n" 169 " vec4 inVec4;\n" 170 "\n" 171 " uvec4 in2Uvec4;\n" 172 " ivec4 in2Ivec4;\n" 173 " vec4 in2Vec4;\n" 174 "\n" 175 " int offset;\n" 176 " int bits;\n" 177 "\n" 178 " uvec4 outUvec4;\n" 179 " ivec4 outIvec4;\n" 180 " vec4 outVec4;\n" 181 "\n" 182 " uvec4 out2Uvec4;\n" 183 " ivec4 out2Ivec4;\n" 184 " vec4 out2Vec4;\n" 185 "};\n" 186 "\n" 187 "void main()\n" 188 "{\n" 189 " ${TEST_STATEMENT};\n" 190 "}\n"; 191 192 GLuint cs = gl.createShader(GL_COMPUTE_SHADER); 193 std::string csString = specializeVersion(css, m_glslVersion, m_testStatement.c_str()); 194 char const* strings[1] = { csString.c_str() }; 195 gl.shaderSource(cs, 1, strings, 0); 196 gl.compileShader(cs); 197 GLint compileSuccess = 0; 198 gl.getShaderiv(cs, GL_COMPILE_STATUS, &compileSuccess); 199 if (!compileSuccess) 200 { 201 TCU_FAIL("Compile failed"); 202 } 203 204 GLuint pgm = gl.createProgram(); 205 gl.attachShader(pgm, cs); 206 gl.linkProgram(pgm); 207 GLint linkSuccess = 0; 208 gl.getProgramiv(pgm, GL_LINK_STATUS, &linkSuccess); 209 if (!linkSuccess) 210 { 211 gl.deleteShader(cs); 212 TCU_FAIL("Link failed"); 213 } 214 215 gl.useProgram(pgm); 216 217 gl.dispatchCompute(1, 1, 1); 218 219 Data const* results = (Data const*)gl.mapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, sizeof(Data), GL_MAP_READ_BIT); 220 isOk = test(results); 221 gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER); 222 223 gl.useProgram(0); 224 gl.deleteProgram(pgm); 225 gl.deleteShader(cs); 226 227 gl.deleteBuffers(1, &data); 228 229 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, isOk ? "Pass" : "Fail"); 230 return STOP; 231 } 232 233 class ShaderBitfieldOperationCaseFrexp : public ShaderBitfieldOperationCase 234 { 235 public: 236 ShaderBitfieldOperationCaseFrexp(Context& context, const char* name, glu::GLSLVersion glslVersion, Data const& data, 237 int components, char const* testStatement) 238 : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, testStatement), m_components(components) 239 { 240 } 241 242 private: 243 int m_components; 244 245 virtual bool test(Data const* data) 246 { 247 for (int i = 0; i < m_components; ++i) 248 { 249 if (data->inVec4[i] == 0.0) 250 { 251 if (data->outVec4[i] != 0.0 || data->outIvec4[i] != 0) 252 { 253 return false; 254 } 255 } 256 else if (deFloatAbs(data->outVec4[i]) < 0.5 || deFloatAbs(data->outVec4[i]) >= 1.0) 257 { 258 return false; 259 } 260 261 float result = data->outVec4[i] * deFloatPow(2.0, (float)data->outIvec4[i]); 262 if (deFloatAbs(result - data->inVec4[i]) > 0.0001f) 263 { 264 return false; 265 } 266 } 267 return true; 268 } 269 }; 270 271 class ShaderBitfieldOperationCaseFrexpFloat : public ShaderBitfieldOperationCaseFrexp 272 { 273 public: 274 ShaderBitfieldOperationCaseFrexpFloat(Context& context, const char* name, glu::GLSLVersion glslVersion, 275 Data const& data) 276 : ShaderBitfieldOperationCaseFrexp(context, name, glslVersion, data, 1, 277 "outVec4.x = frexp(inVec4.x, outIvec4.x)") 278 { 279 } 280 }; 281 282 class ShaderBitfieldOperationCaseFrexpVec2 : public ShaderBitfieldOperationCaseFrexp 283 { 284 public: 285 ShaderBitfieldOperationCaseFrexpVec2(Context& context, const char* name, glu::GLSLVersion glslVersion, 286 Data const& data) 287 : ShaderBitfieldOperationCaseFrexp(context, name, glslVersion, data, 2, 288 "outVec4.xy = frexp(inVec4.xy, outIvec4.xy)") 289 { 290 } 291 }; 292 293 class ShaderBitfieldOperationCaseFrexpVec3 : public ShaderBitfieldOperationCaseFrexp 294 { 295 public: 296 ShaderBitfieldOperationCaseFrexpVec3(Context& context, const char* name, glu::GLSLVersion glslVersion, 297 Data const& data) 298 : ShaderBitfieldOperationCaseFrexp(context, name, glslVersion, data, 3, 299 "outVec4.xyz = frexp(inVec4.xyz, outIvec4.xyz)") 300 { 301 } 302 }; 303 304 class ShaderBitfieldOperationCaseFrexpVec4 : public ShaderBitfieldOperationCaseFrexp 305 { 306 public: 307 ShaderBitfieldOperationCaseFrexpVec4(Context& context, const char* name, glu::GLSLVersion glslVersion, 308 Data const& data) 309 : ShaderBitfieldOperationCaseFrexp(context, name, glslVersion, data, 4, "outVec4 = frexp(inVec4, outIvec4)") 310 { 311 } 312 }; 313 314 class ShaderBitfieldOperationCaseLdexp : public ShaderBitfieldOperationCase 315 { 316 public: 317 ShaderBitfieldOperationCaseLdexp(Context& context, const char* name, glu::GLSLVersion glslVersion, Data const& data, 318 int components, char const* testStatement) 319 : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, testStatement), m_components(components) 320 { 321 } 322 323 private: 324 int m_components; 325 326 virtual bool test(Data const* data) 327 { 328 for (int i = 0; i < m_components; ++i) 329 { 330 float expected = deFloatLdExp(data->inVec4[i], data->inIvec4[i]); 331 if (deFloatAbs(expected - data->outVec4[i]) > 0.0001f) 332 { 333 return false; 334 } 335 } 336 return true; 337 } 338 }; 339 340 class ShaderBitfieldOperationCaseLdexpFloat : public ShaderBitfieldOperationCaseLdexp 341 { 342 public: 343 ShaderBitfieldOperationCaseLdexpFloat(Context& context, const char* name, glu::GLSLVersion glslVersion, 344 Data const& data, Data const& exp) 345 : ShaderBitfieldOperationCaseLdexp(context, name, glslVersion, data, 1, 346 "outVec4.x = ldexp(inVec4.x, inIvec4.x)") 347 { 348 m_data.inIvec4[0] = exp.inIvec4[0]; 349 } 350 }; 351 352 class ShaderBitfieldOperationCaseLdexpVec2 : public ShaderBitfieldOperationCaseLdexp 353 { 354 public: 355 ShaderBitfieldOperationCaseLdexpVec2(Context& context, const char* name, glu::GLSLVersion glslVersion, 356 Data const& data, Data const& exp) 357 : ShaderBitfieldOperationCaseLdexp(context, name, glslVersion, data, 2, 358 "outVec4.xy = ldexp(inVec4.xy, inIvec4.xy)") 359 { 360 m_data.inIvec4[0] = exp.inIvec4[0]; 361 m_data.inIvec4[1] = exp.inIvec4[1]; 362 } 363 }; 364 365 class ShaderBitfieldOperationCaseLdexpVec3 : public ShaderBitfieldOperationCaseLdexp 366 { 367 public: 368 ShaderBitfieldOperationCaseLdexpVec3(Context& context, const char* name, glu::GLSLVersion glslVersion, 369 Data const& data, Data const& exp) 370 : ShaderBitfieldOperationCaseLdexp(context, name, glslVersion, data, 3, 371 "outVec4.xyz = ldexp(inVec4.xyz, inIvec4.xyz)") 372 { 373 m_data.inIvec4[0] = exp.inIvec4[0]; 374 m_data.inIvec4[1] = exp.inIvec4[1]; 375 m_data.inIvec4[2] = exp.inIvec4[2]; 376 } 377 }; 378 379 class ShaderBitfieldOperationCaseLdexpVec4 : public ShaderBitfieldOperationCaseLdexp 380 { 381 public: 382 ShaderBitfieldOperationCaseLdexpVec4(Context& context, const char* name, glu::GLSLVersion glslVersion, 383 Data const& data, Data const& exp) 384 : ShaderBitfieldOperationCaseLdexp(context, name, glslVersion, data, 4, "outVec4 = ldexp(inVec4, inIvec4)") 385 { 386 m_data.inIvec4[0] = exp.inIvec4[0]; 387 m_data.inIvec4[1] = exp.inIvec4[1]; 388 m_data.inIvec4[2] = exp.inIvec4[2]; 389 m_data.inIvec4[3] = exp.inIvec4[3]; 390 } 391 }; 392 393 class ShaderBitfieldOperationCasePackUnorm : public ShaderBitfieldOperationCase 394 { 395 public: 396 ShaderBitfieldOperationCasePackUnorm(Context& context, const char* name, glu::GLSLVersion glslVersion, 397 Data const& data) 398 : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, "outUvec4.x = packUnorm4x8(inVec4)") 399 { 400 } 401 402 private: 403 virtual bool test(Data const* data) 404 { 405 GLuint expected = 406 ((int(data->inVec4[0] * 255.0 + 0.5) & 0xFF) << 0) | ((int(data->inVec4[1] * 255.0 + 0.5) & 0xFF) << 8) | 407 ((int(data->inVec4[2] * 255.0 + 0.5) & 0xFF) << 16) | ((int(data->inVec4[3] * 255.0 + 0.5) & 0xFF) << 24); 408 if (expected != data->outUvec4[0]) 409 { 410 return false; 411 } 412 return true; 413 } 414 }; 415 416 class ShaderBitfieldOperationCasePackSnorm : public ShaderBitfieldOperationCase 417 { 418 public: 419 ShaderBitfieldOperationCasePackSnorm(Context& context, const char* name, glu::GLSLVersion glslVersion, 420 Data const& data) 421 : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, "outUvec4.x = packSnorm4x8(inVec4)") 422 { 423 } 424 425 private: 426 virtual bool test(Data const* data) 427 { 428 GLuint expected = ((int(deFloatFloor(data->inVec4[0] * 127.0f + 0.5f)) & 0xFF) << 0) | 429 ((int(deFloatFloor(data->inVec4[1] * 127.0f + 0.5f)) & 0xFF) << 8) | 430 ((int(deFloatFloor(data->inVec4[2] * 127.0f + 0.5f)) & 0xFF) << 16) | 431 ((int(deFloatFloor(data->inVec4[3] * 127.0f + 0.5f)) & 0xFF) << 24); 432 if (expected != data->outUvec4[0]) 433 { 434 return false; 435 } 436 return true; 437 } 438 }; 439 440 class ShaderBitfieldOperationCaseUnpackUnorm : public ShaderBitfieldOperationCase 441 { 442 public: 443 ShaderBitfieldOperationCaseUnpackUnorm(Context& context, const char* name, glu::GLSLVersion glslVersion, 444 Data const& data) 445 : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, "outVec4 = unpackUnorm4x8(inUvec4.x)") 446 { 447 } 448 449 private: 450 virtual bool test(Data const* data) 451 { 452 GLfloat x = float((data->inUvec4[0] >> 0) & 0xFF) / 255.0f; 453 if (deFloatAbs(data->outVec4[0] - x) > 0.0001f) 454 { 455 return false; 456 } 457 GLfloat y = float((data->inUvec4[0] >> 8) & 0xFF) / 255.0f; 458 if (deFloatAbs(data->outVec4[1] - y) > 0.0001f) 459 { 460 return false; 461 } 462 GLfloat z = float((data->inUvec4[0] >> 16) & 0xFF) / 255.0f; 463 if (deFloatAbs(data->outVec4[2] - z) > 0.0001f) 464 { 465 return false; 466 } 467 GLfloat w = float((data->inUvec4[0] >> 24) & 0xFF) / 255.0f; 468 if (deFloatAbs(data->outVec4[3] - w) > 0.0001f) 469 { 470 return false; 471 } 472 473 return true; 474 } 475 }; 476 477 class ShaderBitfieldOperationCaseUnpackSnorm : public ShaderBitfieldOperationCase 478 { 479 public: 480 ShaderBitfieldOperationCaseUnpackSnorm(Context& context, const char* name, glu::GLSLVersion glslVersion, 481 Data const& data) 482 : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, "outVec4 = unpackSnorm4x8(inUvec4.x)") 483 { 484 } 485 486 private: 487 virtual bool test(Data const* data) 488 { 489 GLfloat x = float((signed char)((data->inUvec4[0] >> 0) & 0xFF)) / 127.0f; 490 x = de::clamp<GLfloat>(x, -1.0f, 1.0f); 491 if (deFloatAbs(data->outVec4[0] - x) > 0.0001f) 492 { 493 return false; 494 } 495 GLfloat y = float((signed char)((data->inUvec4[0] >> 8) & 0xFF)) / 127.0f; 496 y = de::clamp<GLfloat>(y, -1.0f, 1.0f); 497 if (deFloatAbs(data->outVec4[1] - y) > 0.0001f) 498 { 499 return false; 500 } 501 GLfloat z = float((signed char)((data->inUvec4[0] >> 16) & 0xFF)) / 127.0f; 502 z = de::clamp<GLfloat>(z, -1.0f, 1.0f); 503 if (deFloatAbs(data->outVec4[2] - z) > 0.0001f) 504 { 505 return false; 506 } 507 GLfloat w = float((signed char)((data->inUvec4[0] >> 24) & 0xFF)) / 127.0f; 508 w = de::clamp<GLfloat>(w, -1.0f, 1.0f); 509 if (deFloatAbs(data->outVec4[3] - w) > 0.0001f) 510 { 511 return false; 512 } 513 514 return true; 515 } 516 }; 517 518 class ShaderBitfieldOperationCaseBitfieldExtractUint : public ShaderBitfieldOperationCase 519 { 520 public: 521 ShaderBitfieldOperationCaseBitfieldExtractUint(Context& context, const char* name, glu::GLSLVersion glslVersion, 522 Data const& data, int offset, int bits, int components, 523 char const* testStatement) 524 : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, testStatement), m_components(components) 525 { 526 if (offset + bits > 32) 527 { 528 offset -= (offset + bits) - 32; 529 } 530 m_data.offset = offset; 531 m_data.bits = bits; 532 } 533 534 private: 535 int m_components; 536 537 virtual bool test(Data const* data) 538 { 539 for (int i = 0; i < m_components; ++i) 540 { 541 GLuint expected = 542 (data->inUvec4[i] >> data->offset) & (data->bits == 32 ? 0xFFFFFFFF : ((1 << data->bits) - 1)); 543 if (data->outUvec4[i] != expected) 544 { 545 return false; 546 } 547 } 548 return true; 549 } 550 }; 551 552 class ShaderBitfieldOperationCaseBitfieldExtractUint1 : public ShaderBitfieldOperationCaseBitfieldExtractUint 553 { 554 public: 555 ShaderBitfieldOperationCaseBitfieldExtractUint1(Context& context, const char* name, glu::GLSLVersion glslVersion, 556 Data const& data, int offset, int bits) 557 : ShaderBitfieldOperationCaseBitfieldExtractUint(context, name, glslVersion, data, offset, bits, 1, 558 "outUvec4.x = bitfieldExtract(inUvec4.x, offset, bits)") 559 { 560 } 561 }; 562 563 class ShaderBitfieldOperationCaseBitfieldExtractUint2 : public ShaderBitfieldOperationCaseBitfieldExtractUint 564 { 565 public: 566 ShaderBitfieldOperationCaseBitfieldExtractUint2(Context& context, const char* name, glu::GLSLVersion glslVersion, 567 Data const& data, int offset, int bits) 568 : ShaderBitfieldOperationCaseBitfieldExtractUint(context, name, glslVersion, data, offset, bits, 2, 569 "outUvec4.xy = bitfieldExtract(inUvec4.xy, offset, bits)") 570 { 571 } 572 }; 573 574 class ShaderBitfieldOperationCaseBitfieldExtractUint3 : public ShaderBitfieldOperationCaseBitfieldExtractUint 575 { 576 public: 577 ShaderBitfieldOperationCaseBitfieldExtractUint3(Context& context, const char* name, glu::GLSLVersion glslVersion, 578 Data const& data, int offset, int bits) 579 : ShaderBitfieldOperationCaseBitfieldExtractUint(context, name, glslVersion, data, offset, bits, 3, 580 "outUvec4.xyz = bitfieldExtract(inUvec4.xyz, offset, bits)") 581 { 582 } 583 }; 584 585 class ShaderBitfieldOperationCaseBitfieldExtractUint4 : public ShaderBitfieldOperationCaseBitfieldExtractUint 586 { 587 public: 588 ShaderBitfieldOperationCaseBitfieldExtractUint4(Context& context, const char* name, glu::GLSLVersion glslVersion, 589 Data const& data, int offset, int bits) 590 : ShaderBitfieldOperationCaseBitfieldExtractUint(context, name, glslVersion, data, offset, bits, 4, 591 "outUvec4 = bitfieldExtract(inUvec4, offset, bits)") 592 { 593 } 594 }; 595 596 class ShaderBitfieldOperationCaseBitfieldExtractInt : public ShaderBitfieldOperationCase 597 { 598 public: 599 ShaderBitfieldOperationCaseBitfieldExtractInt(Context& context, const char* name, glu::GLSLVersion glslVersion, 600 Data const& data, int offset, int bits, int components, 601 char const* testStatement) 602 : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, testStatement), m_components(components) 603 { 604 if (offset + bits > 32) 605 { 606 offset -= (offset + bits) - 32; 607 } 608 m_data.offset = offset; 609 m_data.bits = bits; 610 } 611 612 private: 613 int m_components; 614 615 virtual bool test(Data const* data) 616 { 617 for (int i = 0; i < m_components; ++i) 618 { 619 GLint expected = data->inIvec4[i] << (32 - (data->offset + data->bits)); 620 expected >>= 32 - data->bits; 621 if (data->outIvec4[i] != expected) 622 { 623 return false; 624 } 625 } 626 return true; 627 } 628 }; 629 630 class ShaderBitfieldOperationCaseBitfieldExtractInt1 : public ShaderBitfieldOperationCaseBitfieldExtractInt 631 { 632 public: 633 ShaderBitfieldOperationCaseBitfieldExtractInt1(Context& context, const char* name, glu::GLSLVersion glslVersion, 634 Data const& data, int offset, int bits) 635 : ShaderBitfieldOperationCaseBitfieldExtractInt(context, name, glslVersion, data, offset, bits, 1, 636 "outIvec4.x = bitfieldExtract(inIvec4.x, offset, bits)") 637 { 638 } 639 }; 640 641 class ShaderBitfieldOperationCaseBitfieldExtractInt2 : public ShaderBitfieldOperationCaseBitfieldExtractInt 642 { 643 public: 644 ShaderBitfieldOperationCaseBitfieldExtractInt2(Context& context, const char* name, glu::GLSLVersion glslVersion, 645 Data const& data, int offset, int bits) 646 : ShaderBitfieldOperationCaseBitfieldExtractInt(context, name, glslVersion, data, offset, bits, 2, 647 "outIvec4.xy = bitfieldExtract(inIvec4.xy, offset, bits)") 648 { 649 } 650 }; 651 652 class ShaderBitfieldOperationCaseBitfieldExtractInt3 : public ShaderBitfieldOperationCaseBitfieldExtractInt 653 { 654 public: 655 ShaderBitfieldOperationCaseBitfieldExtractInt3(Context& context, const char* name, glu::GLSLVersion glslVersion, 656 Data const& data, int offset, int bits) 657 : ShaderBitfieldOperationCaseBitfieldExtractInt(context, name, glslVersion, data, offset, bits, 3, 658 "outIvec4.xyz = bitfieldExtract(inIvec4.xyz, offset, bits)") 659 { 660 } 661 }; 662 663 class ShaderBitfieldOperationCaseBitfieldExtractInt4 : public ShaderBitfieldOperationCaseBitfieldExtractInt 664 { 665 public: 666 ShaderBitfieldOperationCaseBitfieldExtractInt4(Context& context, const char* name, glu::GLSLVersion glslVersion, 667 Data const& data, int offset, int bits) 668 : ShaderBitfieldOperationCaseBitfieldExtractInt(context, name, glslVersion, data, offset, bits, 4, 669 "outIvec4 = bitfieldExtract(inIvec4, offset, bits)") 670 { 671 } 672 }; 673 674 class ShaderBitfieldOperationCaseBitfieldInsertUint : public ShaderBitfieldOperationCase 675 { 676 public: 677 ShaderBitfieldOperationCaseBitfieldInsertUint(Context& context, const char* name, glu::GLSLVersion glslVersion, 678 Data const& data, Data const& insert, int offset, int bits, 679 int components, char const* testStatement) 680 : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, testStatement), m_components(components) 681 { 682 for (int i = 0; i < components; ++i) 683 { 684 m_data.in2Uvec4[i] = insert.inUvec4[i]; 685 } 686 if (offset + bits > 32) 687 { 688 offset -= (offset + bits) - 32; 689 } 690 m_data.offset = offset; 691 m_data.bits = bits; 692 } 693 694 private: 695 int m_components; 696 697 virtual bool test(Data const* data) 698 { 699 for (int i = 0; i < m_components; ++i) 700 { 701 GLuint mask = (data->bits == 32) ? ~0u : (1 << data->bits) - 1; 702 GLuint expected = 703 (data->inUvec4[i] & ~(mask << data->offset)) | ((data->in2Uvec4[i] & mask) << data->offset); 704 if (data->outUvec4[i] != expected) 705 { 706 return false; 707 } 708 } 709 return true; 710 } 711 }; 712 713 class ShaderBitfieldOperationCaseBitfieldInsertUint1 : public ShaderBitfieldOperationCaseBitfieldInsertUint 714 { 715 public: 716 ShaderBitfieldOperationCaseBitfieldInsertUint1(Context& context, const char* name, glu::GLSLVersion glslVersion, 717 Data const& data, Data const& insert, int offset, int bits) 718 : ShaderBitfieldOperationCaseBitfieldInsertUint( 719 context, name, glslVersion, data, insert, offset, bits, 1, 720 "outUvec4.x = bitfieldInsert(inUvec4.x, in2Uvec4.x, offset, bits)") 721 { 722 } 723 }; 724 725 class ShaderBitfieldOperationCaseBitfieldInsertUint2 : public ShaderBitfieldOperationCaseBitfieldInsertUint 726 { 727 public: 728 ShaderBitfieldOperationCaseBitfieldInsertUint2(Context& context, const char* name, glu::GLSLVersion glslVersion, 729 Data const& data, Data const& insert, int offset, int bits) 730 : ShaderBitfieldOperationCaseBitfieldInsertUint( 731 context, name, glslVersion, data, insert, offset, bits, 2, 732 "outUvec4.xy = bitfieldInsert(inUvec4.xy, in2Uvec4.xy, offset, bits)") 733 { 734 } 735 }; 736 737 class ShaderBitfieldOperationCaseBitfieldInsertUint3 : public ShaderBitfieldOperationCaseBitfieldInsertUint 738 { 739 public: 740 ShaderBitfieldOperationCaseBitfieldInsertUint3(Context& context, const char* name, glu::GLSLVersion glslVersion, 741 Data const& data, Data const& insert, int offset, int bits) 742 : ShaderBitfieldOperationCaseBitfieldInsertUint( 743 context, name, glslVersion, data, insert, offset, bits, 3, 744 "outUvec4.xyz = bitfieldInsert(inUvec4.xyz, in2Uvec4.xyz, offset, bits)") 745 { 746 } 747 }; 748 749 class ShaderBitfieldOperationCaseBitfieldInsertUint4 : public ShaderBitfieldOperationCaseBitfieldInsertUint 750 { 751 public: 752 ShaderBitfieldOperationCaseBitfieldInsertUint4(Context& context, const char* name, glu::GLSLVersion glslVersion, 753 Data const& data, Data const& insert, int offset, int bits) 754 : ShaderBitfieldOperationCaseBitfieldInsertUint(context, name, glslVersion, data, insert, offset, bits, 4, 755 "outUvec4 = bitfieldInsert(inUvec4, in2Uvec4, offset, bits)") 756 { 757 } 758 }; 759 760 class ShaderBitfieldOperationCaseBitfieldInsertInt : public ShaderBitfieldOperationCase 761 { 762 public: 763 ShaderBitfieldOperationCaseBitfieldInsertInt(Context& context, const char* name, glu::GLSLVersion glslVersion, 764 Data const& data, Data const& insert, int offset, int bits, 765 int components, char const* testStatement) 766 : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, testStatement), m_components(components) 767 { 768 for (int i = 0; i < components; ++i) 769 { 770 m_data.in2Ivec4[i] = insert.inIvec4[i]; 771 } 772 if (offset + bits > 32) 773 { 774 offset -= (offset + bits) - 32; 775 } 776 m_data.offset = offset; 777 m_data.bits = bits; 778 } 779 780 private: 781 int m_components; 782 783 virtual bool test(Data const* data) 784 { 785 for (int i = 0; i < m_components; ++i) 786 { 787 GLuint mask = (data->bits == 32) ? ~0u : (1 << data->bits) - 1; 788 GLint expected = 789 (data->inIvec4[i] & ~(mask << data->offset)) | ((data->in2Ivec4[i] & mask) << data->offset); 790 if (data->outIvec4[i] != expected) 791 { 792 return false; 793 } 794 } 795 return true; 796 } 797 }; 798 799 class ShaderBitfieldOperationCaseBitfieldInsertInt1 : public ShaderBitfieldOperationCaseBitfieldInsertInt 800 { 801 public: 802 ShaderBitfieldOperationCaseBitfieldInsertInt1(Context& context, const char* name, glu::GLSLVersion glslVersion, 803 Data const& data, Data const& insert, int offset, int bits) 804 : ShaderBitfieldOperationCaseBitfieldInsertInt( 805 context, name, glslVersion, data, insert, offset, bits, 1, 806 "outIvec4.x = bitfieldInsert(inIvec4.x, in2Ivec4.x, offset, bits)") 807 { 808 } 809 }; 810 811 class ShaderBitfieldOperationCaseBitfieldInsertInt2 : public ShaderBitfieldOperationCaseBitfieldInsertInt 812 { 813 public: 814 ShaderBitfieldOperationCaseBitfieldInsertInt2(Context& context, const char* name, glu::GLSLVersion glslVersion, 815 Data const& data, Data const& insert, int offset, int bits) 816 : ShaderBitfieldOperationCaseBitfieldInsertInt( 817 context, name, glslVersion, data, insert, offset, bits, 2, 818 "outIvec4.xy = bitfieldInsert(inIvec4.xy, in2Ivec4.xy, offset, bits)") 819 { 820 } 821 }; 822 823 class ShaderBitfieldOperationCaseBitfieldInsertInt3 : public ShaderBitfieldOperationCaseBitfieldInsertInt 824 { 825 public: 826 ShaderBitfieldOperationCaseBitfieldInsertInt3(Context& context, const char* name, glu::GLSLVersion glslVersion, 827 Data const& data, Data const& insert, int offset, int bits) 828 : ShaderBitfieldOperationCaseBitfieldInsertInt( 829 context, name, glslVersion, data, insert, offset, bits, 3, 830 "outIvec4.xyz = bitfieldInsert(inIvec4.xyz, in2Ivec4.xyz, offset, bits)") 831 { 832 } 833 }; 834 835 class ShaderBitfieldOperationCaseBitfieldInsertInt4 : public ShaderBitfieldOperationCaseBitfieldInsertInt 836 { 837 public: 838 ShaderBitfieldOperationCaseBitfieldInsertInt4(Context& context, const char* name, glu::GLSLVersion glslVersion, 839 Data const& data, Data const& insert, int offset, int bits) 840 : ShaderBitfieldOperationCaseBitfieldInsertInt(context, name, glslVersion, data, insert, offset, bits, 4, 841 "outIvec4 = bitfieldInsert(inIvec4, in2Ivec4, offset, bits)") 842 { 843 } 844 }; 845 846 typedef GLuint (*UnaryUFunc)(GLuint input); 847 typedef GLint (*UnaryIFunc)(GLint input); 848 849 static GLuint bitfieldReverse(GLuint input) 850 { 851 GLuint result = 0; 852 for (int i = 0; i < 32; ++i) 853 { 854 result >>= 1; 855 result |= (input & 0x80000000); 856 input <<= 1; 857 } 858 return result; 859 } 860 861 static GLuint bitCount(GLuint input) 862 { 863 GLuint result = 0; 864 while (input) 865 { 866 if (input & 1) 867 { 868 result += 1; 869 } 870 input >>= 1; 871 } 872 return result; 873 } 874 875 static GLuint findLSB(GLuint input) 876 { 877 if (!input) 878 { 879 return -1; 880 } 881 for (GLuint result = 0;; ++result) 882 { 883 if (input & 1) 884 { 885 return result; 886 } 887 input >>= 1; 888 } 889 } 890 891 static GLuint findMSBU(GLuint input) 892 { 893 if (!input) 894 { 895 return -1; 896 } 897 for (GLuint result = 31;; --result) 898 { 899 if (input & 0x80000000) 900 { 901 return result; 902 } 903 input <<= 1; 904 } 905 } 906 907 static GLint findMSBI(GLint input) 908 { 909 if (input == 0 || input == -1) 910 { 911 return -1; 912 } 913 else if (input > 0) 914 { 915 for (GLuint result = 31;; --result) 916 { 917 if (input & 0x80000000) 918 { 919 return result; 920 } 921 input <<= 1; 922 } 923 } 924 else 925 { 926 for (GLuint result = 31;; --result) 927 { 928 if (!(input & 0x80000000)) 929 { 930 return result; 931 } 932 input <<= 1; 933 } 934 } 935 } 936 937 class ShaderBitfieldOperationCaseUnaryUint : public ShaderBitfieldOperationCase 938 { 939 public: 940 ShaderBitfieldOperationCaseUnaryUint(Context& context, const char* name, glu::GLSLVersion glslVersion, 941 char const* funcName, UnaryUFunc func, Data const& data, int components, 942 char const* testStatement) 943 : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, testStatement) 944 , m_components(components) 945 , m_func(func) 946 { 947 size_t pos = m_testStatement.find("func"); 948 m_testStatement.replace(pos, 4, funcName); 949 } 950 951 private: 952 int m_components; 953 UnaryUFunc m_func; 954 955 virtual bool test(Data const* data) 956 { 957 for (int i = 0; i < m_components; ++i) 958 { 959 GLuint expected = m_func(data->inUvec4[i]); 960 GLuint output = data->outUvec4[i]; 961 if (m_func == (UnaryUFunc)glcts::bitCount || m_func == (UnaryUFunc)glcts::findLSB || 962 m_func == (UnaryUFunc)glcts::findMSBU || m_func == (UnaryUFunc)glcts::findMSBI) 963 { 964 /* The built-in bitCount, findLSB and findMSB functions 965 * return a lowp int, which can be encoded with as little 966 * as 9 bits. Since findLSB and findMSB can return negative 967 * values (namely, -1), we cannot compare the value directly 968 * against a (32-bit) GLuint. 969 */ 970 GLuint output_9bits = output & 0x1ff; 971 GLuint sign_extend = output_9bits & 0x100 ? 0xfffffe00 : 0; 972 output = output_9bits | sign_extend; 973 } 974 975 if (output != expected) 976 { 977 return false; 978 } 979 } 980 return true; 981 } 982 }; 983 984 class ShaderBitfieldOperationCaseUnaryUint1 : public ShaderBitfieldOperationCaseUnaryUint 985 { 986 public: 987 ShaderBitfieldOperationCaseUnaryUint1(Context& context, const char* name, glu::GLSLVersion glslVersion, 988 char const* funcName, UnaryUFunc func, Data const& data) 989 : ShaderBitfieldOperationCaseUnaryUint(context, name, glslVersion, funcName, func, data, 1, 990 "outUvec4.x = uint(func(inUvec4.x))") 991 { 992 } 993 }; 994 995 class ShaderBitfieldOperationCaseUnaryUint2 : public ShaderBitfieldOperationCaseUnaryUint 996 { 997 public: 998 ShaderBitfieldOperationCaseUnaryUint2(Context& context, const char* name, glu::GLSLVersion glslVersion, 999 char const* funcName, UnaryUFunc func, Data const& data) 1000 : ShaderBitfieldOperationCaseUnaryUint(context, name, glslVersion, funcName, func, data, 2, 1001 "outUvec4.xy = uvec2(func(inUvec4.xy))") 1002 { 1003 } 1004 }; 1005 1006 class ShaderBitfieldOperationCaseUnaryUint3 : public ShaderBitfieldOperationCaseUnaryUint 1007 { 1008 public: 1009 ShaderBitfieldOperationCaseUnaryUint3(Context& context, const char* name, glu::GLSLVersion glslVersion, 1010 char const* funcName, UnaryUFunc func, Data const& data) 1011 : ShaderBitfieldOperationCaseUnaryUint(context, name, glslVersion, funcName, func, data, 3, 1012 "outUvec4.xyz = uvec3(func(inUvec4.xyz))") 1013 { 1014 } 1015 }; 1016 1017 class ShaderBitfieldOperationCaseUnaryUint4 : public ShaderBitfieldOperationCaseUnaryUint 1018 { 1019 public: 1020 ShaderBitfieldOperationCaseUnaryUint4(Context& context, const char* name, glu::GLSLVersion glslVersion, 1021 char const* funcName, UnaryUFunc func, Data const& data) 1022 : ShaderBitfieldOperationCaseUnaryUint(context, name, glslVersion, funcName, func, data, 4, 1023 "outUvec4 = uvec4(func(inUvec4))") 1024 { 1025 } 1026 }; 1027 1028 class ShaderBitfieldOperationCaseUnaryInt : public ShaderBitfieldOperationCase 1029 { 1030 public: 1031 ShaderBitfieldOperationCaseUnaryInt(Context& context, const char* name, glu::GLSLVersion glslVersion, 1032 char const* funcName, UnaryIFunc func, Data const& data, int components, 1033 char const* testStatement) 1034 : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, testStatement) 1035 , m_components(components) 1036 , m_func(func) 1037 { 1038 size_t pos = m_testStatement.find("func"); 1039 m_testStatement.replace(pos, 4, funcName); 1040 } 1041 1042 private: 1043 int m_components; 1044 UnaryIFunc m_func; 1045 1046 virtual bool test(Data const* data) 1047 { 1048 for (int i = 0; i < m_components; ++i) 1049 { 1050 GLint expected = m_func(data->inIvec4[i]); 1051 if (data->outIvec4[i] != expected) 1052 { 1053 return false; 1054 } 1055 } 1056 return true; 1057 } 1058 }; 1059 1060 class ShaderBitfieldOperationCaseUnaryInt1 : public ShaderBitfieldOperationCaseUnaryInt 1061 { 1062 public: 1063 ShaderBitfieldOperationCaseUnaryInt1(Context& context, const char* name, glu::GLSLVersion glslVersion, 1064 char const* funcName, UnaryIFunc func, Data const& data) 1065 : ShaderBitfieldOperationCaseUnaryInt(context, name, glslVersion, funcName, func, data, 1, 1066 "outIvec4.x = func(inIvec4.x)") 1067 { 1068 } 1069 }; 1070 1071 class ShaderBitfieldOperationCaseUnaryInt2 : public ShaderBitfieldOperationCaseUnaryInt 1072 { 1073 public: 1074 ShaderBitfieldOperationCaseUnaryInt2(Context& context, const char* name, glu::GLSLVersion glslVersion, 1075 char const* funcName, UnaryIFunc func, Data const& data) 1076 : ShaderBitfieldOperationCaseUnaryInt(context, name, glslVersion, funcName, func, data, 2, 1077 "outIvec4.xy = func(inIvec4.xy)") 1078 { 1079 } 1080 }; 1081 1082 class ShaderBitfieldOperationCaseUnaryInt3 : public ShaderBitfieldOperationCaseUnaryInt 1083 { 1084 public: 1085 ShaderBitfieldOperationCaseUnaryInt3(Context& context, const char* name, glu::GLSLVersion glslVersion, 1086 char const* funcName, UnaryIFunc func, Data const& data) 1087 : ShaderBitfieldOperationCaseUnaryInt(context, name, glslVersion, funcName, func, data, 3, 1088 "outIvec4.xyz = func(inIvec4.xyz)") 1089 { 1090 } 1091 }; 1092 1093 class ShaderBitfieldOperationCaseUnaryInt4 : public ShaderBitfieldOperationCaseUnaryInt 1094 { 1095 public: 1096 ShaderBitfieldOperationCaseUnaryInt4(Context& context, const char* name, glu::GLSLVersion glslVersion, 1097 char const* funcName, UnaryIFunc func, Data const& data) 1098 : ShaderBitfieldOperationCaseUnaryInt(context, name, glslVersion, funcName, func, data, 4, 1099 "outIvec4 = func(inIvec4)") 1100 { 1101 } 1102 }; 1103 1104 typedef GLuint (*BinaryUFunc)(GLuint input, GLuint input2, GLuint& output2); 1105 typedef GLint (*BinaryIFunc)(GLint input, GLint input2, GLint& output2); 1106 1107 static GLuint uaddCarry(GLuint input, GLuint input2, GLuint& output2) 1108 { 1109 GLuint result = input + input2; 1110 output2 = (input > result) ? 1 : 0; 1111 return result; 1112 } 1113 1114 static GLuint usubBorrow(GLuint input, GLuint input2, GLuint& output2) 1115 { 1116 output2 = (input2 > input) ? 1 : 0; 1117 return input - input2; 1118 } 1119 1120 static GLuint umulExtended(GLuint input, GLuint input2, GLuint& output2) 1121 { 1122 GLuint64 result = static_cast<GLuint64>(input) * static_cast<GLuint64>(input2); 1123 output2 = GLuint(result & 0xFFFFFFFF); 1124 return GLuint(result >> 32); 1125 } 1126 1127 static GLint imulExtended(GLint input, GLint input2, GLint& output2) 1128 { 1129 GLint64 result = static_cast<GLint64>(input) * static_cast<GLint64>(input2); 1130 output2 = GLint(result & 0xFFFFFFFF); 1131 return GLint(result >> 32); 1132 } 1133 1134 class ShaderBitfieldOperationCaseBinaryUint : public ShaderBitfieldOperationCase 1135 { 1136 public: 1137 ShaderBitfieldOperationCaseBinaryUint(Context& context, const char* name, glu::GLSLVersion glslVersion, 1138 char const* testStatement, BinaryUFunc func, Data const& input, 1139 Data const& input2, int components) 1140 : ShaderBitfieldOperationCase(context, name, "", glslVersion, input, testStatement) 1141 , m_components(components) 1142 , m_func(func) 1143 { 1144 for (int i = 0; i < components; ++i) 1145 { 1146 m_data.in2Uvec4[i] = input2.inUvec4[i]; 1147 } 1148 } 1149 1150 private: 1151 int m_components; 1152 BinaryUFunc m_func; 1153 1154 virtual bool test(Data const* data) 1155 { 1156 for (int i = 0; i < m_components; ++i) 1157 { 1158 GLuint expected2 = 0; 1159 GLuint expected = m_func(data->inUvec4[i], data->in2Uvec4[i], expected2); 1160 if (data->outUvec4[i] != expected || data->out2Uvec4[i] != expected2) 1161 { 1162 return false; 1163 } 1164 } 1165 return true; 1166 } 1167 }; 1168 1169 class ShaderBitfieldOperationCaseBinaryUint1 : public ShaderBitfieldOperationCaseBinaryUint 1170 { 1171 public: 1172 ShaderBitfieldOperationCaseBinaryUint1(Context& context, const char* name, glu::GLSLVersion glslVersion, 1173 char const* testStatement, BinaryUFunc func, Data const& input, 1174 Data const& input2) 1175 : ShaderBitfieldOperationCaseBinaryUint(context, name, glslVersion, testStatement, func, input, input2, 1) 1176 { 1177 } 1178 }; 1179 1180 class ShaderBitfieldOperationCaseBinaryUint2 : public ShaderBitfieldOperationCaseBinaryUint 1181 { 1182 public: 1183 ShaderBitfieldOperationCaseBinaryUint2(Context& context, const char* name, glu::GLSLVersion glslVersion, 1184 char const* testStatement, BinaryUFunc func, Data const& input, 1185 Data const& input2) 1186 : ShaderBitfieldOperationCaseBinaryUint(context, name, glslVersion, testStatement, func, input, input2, 2) 1187 { 1188 } 1189 }; 1190 1191 class ShaderBitfieldOperationCaseBinaryUint3 : public ShaderBitfieldOperationCaseBinaryUint 1192 { 1193 public: 1194 ShaderBitfieldOperationCaseBinaryUint3(Context& context, const char* name, glu::GLSLVersion glslVersion, 1195 char const* testStatement, BinaryUFunc func, Data const& input, 1196 Data const& input2) 1197 : ShaderBitfieldOperationCaseBinaryUint(context, name, glslVersion, testStatement, func, input, input2, 3) 1198 { 1199 } 1200 }; 1201 1202 class ShaderBitfieldOperationCaseBinaryUint4 : public ShaderBitfieldOperationCaseBinaryUint 1203 { 1204 public: 1205 ShaderBitfieldOperationCaseBinaryUint4(Context& context, const char* name, glu::GLSLVersion glslVersion, 1206 char const* testStatement, BinaryUFunc func, Data const& input, 1207 Data const& input2) 1208 : ShaderBitfieldOperationCaseBinaryUint(context, name, glslVersion, testStatement, func, input, input2, 4) 1209 { 1210 } 1211 }; 1212 1213 class ShaderBitfieldOperationCaseBinaryInt : public ShaderBitfieldOperationCase 1214 { 1215 public: 1216 ShaderBitfieldOperationCaseBinaryInt(Context& context, const char* name, glu::GLSLVersion glslVersion, 1217 char const* testStatement, BinaryIFunc func, Data const& input, 1218 Data const& input2, int components) 1219 : ShaderBitfieldOperationCase(context, name, "", glslVersion, input, testStatement) 1220 , m_components(components) 1221 , m_func(func) 1222 { 1223 for (int i = 0; i < components; ++i) 1224 { 1225 m_data.in2Ivec4[i] = input2.inIvec4[i]; 1226 } 1227 } 1228 1229 private: 1230 int m_components; 1231 BinaryIFunc m_func; 1232 1233 virtual bool test(Data const* data) 1234 { 1235 for (int i = 0; i < m_components; ++i) 1236 { 1237 GLint expected2 = 0; 1238 GLint expected = m_func(data->inIvec4[i], data->in2Ivec4[i], expected2); 1239 if (data->outIvec4[i] != expected || data->out2Ivec4[i] != expected2) 1240 { 1241 return false; 1242 } 1243 } 1244 return true; 1245 } 1246 }; 1247 1248 class ShaderBitfieldOperationCaseBinaryInt1 : public ShaderBitfieldOperationCaseBinaryInt 1249 { 1250 public: 1251 ShaderBitfieldOperationCaseBinaryInt1(Context& context, const char* name, glu::GLSLVersion glslVersion, 1252 char const* testStatement, BinaryIFunc func, Data const& input, 1253 Data const& input2) 1254 : ShaderBitfieldOperationCaseBinaryInt(context, name, glslVersion, testStatement, func, input, input2, 1) 1255 { 1256 } 1257 }; 1258 1259 class ShaderBitfieldOperationCaseBinaryInt2 : public ShaderBitfieldOperationCaseBinaryInt 1260 { 1261 public: 1262 ShaderBitfieldOperationCaseBinaryInt2(Context& context, const char* name, glu::GLSLVersion glslVersion, 1263 char const* testStatement, BinaryIFunc func, Data const& input, 1264 Data const& input2) 1265 : ShaderBitfieldOperationCaseBinaryInt(context, name, glslVersion, testStatement, func, input, input2, 2) 1266 { 1267 } 1268 }; 1269 1270 class ShaderBitfieldOperationCaseBinaryInt3 : public ShaderBitfieldOperationCaseBinaryInt 1271 { 1272 public: 1273 ShaderBitfieldOperationCaseBinaryInt3(Context& context, const char* name, glu::GLSLVersion glslVersion, 1274 char const* testStatement, BinaryIFunc func, Data const& input, 1275 Data const& input2) 1276 : ShaderBitfieldOperationCaseBinaryInt(context, name, glslVersion, testStatement, func, input, input2, 3) 1277 { 1278 } 1279 }; 1280 1281 class ShaderBitfieldOperationCaseBinaryInt4 : public ShaderBitfieldOperationCaseBinaryInt 1282 { 1283 public: 1284 ShaderBitfieldOperationCaseBinaryInt4(Context& context, const char* name, glu::GLSLVersion glslVersion, 1285 char const* testStatement, BinaryIFunc func, Data const& input, 1286 Data const& input2) 1287 : ShaderBitfieldOperationCaseBinaryInt(context, name, glslVersion, testStatement, func, input, input2, 4) 1288 { 1289 } 1290 }; 1291 1292 ShaderBitfieldOperationTests::ShaderBitfieldOperationTests(Context& context, glu::GLSLVersion glslVersion) 1293 : TestCaseGroup(context, "shader_bitfield_operation", "Shader Bitfield Operation tests"), m_glslVersion(glslVersion) 1294 { 1295 } 1296 1297 ShaderBitfieldOperationTests::~ShaderBitfieldOperationTests(void) 1298 { 1299 } 1300 1301 void ShaderBitfieldOperationTests::init(void) 1302 { 1303 de::Random rnd(m_context.getTestContext().getCommandLine().getBaseSeed()); 1304 1305 // shader_bitfield_operation.frexp 1306 tcu::TestCaseGroup* frexpGroup = new tcu::TestCaseGroup(m_testCtx, "frexp", ""); 1307 addChild(frexpGroup); 1308 frexpGroup->addChild(new ShaderBitfieldOperationCaseFrexpFloat(m_context, "float_zero", m_glslVersion, Vec4(0.0))); 1309 for (int i = 0; i < ITERATIONS; ++i) 1310 { 1311 std::stringstream ss; 1312 ss << "float_" << i; 1313 frexpGroup->addChild(new ShaderBitfieldOperationCaseFrexpFloat(m_context, ss.str().c_str(), m_glslVersion, 1314 Vec4(rnd.getFloat()))); 1315 } 1316 frexpGroup->addChild( 1317 new ShaderBitfieldOperationCaseFrexpVec2(m_context, "vec2_zero", m_glslVersion, Vec4(0.0, 0.0))); 1318 for (int i = 0; i < ITERATIONS; ++i) 1319 { 1320 std::stringstream ss; 1321 ss << "vec2_" << i; 1322 frexpGroup->addChild(new ShaderBitfieldOperationCaseFrexpVec2(m_context, ss.str().c_str(), m_glslVersion, 1323 Vec4(rnd.getFloat(), -rnd.getFloat()))); 1324 } 1325 frexpGroup->addChild( 1326 new ShaderBitfieldOperationCaseFrexpVec3(m_context, "vec3_zero", m_glslVersion, Vec4(0.0, 0.0, 0.0))); 1327 for (int i = 0; i < ITERATIONS; ++i) 1328 { 1329 std::stringstream ss; 1330 ss << "vec3_" << i; 1331 frexpGroup->addChild(new ShaderBitfieldOperationCaseFrexpVec3( 1332 m_context, ss.str().c_str(), m_glslVersion, Vec4(rnd.getFloat(), -rnd.getFloat(), rnd.getFloat()))); 1333 } 1334 frexpGroup->addChild( 1335 new ShaderBitfieldOperationCaseFrexpVec4(m_context, "vec4_zero", m_glslVersion, Vec4(0.0, 0.0, 0.0, 0.0))); 1336 for (int i = 0; i < ITERATIONS; ++i) 1337 { 1338 std::stringstream ss; 1339 ss << "vec4_" << i; 1340 frexpGroup->addChild(new ShaderBitfieldOperationCaseFrexpVec4( 1341 m_context, ss.str().c_str(), m_glslVersion, 1342 Vec4(rnd.getFloat(), -rnd.getFloat(), rnd.getFloat(), -rnd.getFloat()))); 1343 } 1344 1345 // shader_bitfield_operation.ldexp 1346 tcu::TestCaseGroup* ldexpGroup = new tcu::TestCaseGroup(m_testCtx, "ldexp", ""); 1347 addChild(ldexpGroup); 1348 ldexpGroup->addChild( 1349 new ShaderBitfieldOperationCaseLdexpFloat(m_context, "float_zero", m_glslVersion, Vec4(0.0), Ivec4(0))); 1350 for (int i = 0; i < ITERATIONS; ++i) 1351 { 1352 std::stringstream ss; 1353 ss << "float_" << i; 1354 ldexpGroup->addChild(new ShaderBitfieldOperationCaseLdexpFloat(m_context, ss.str().c_str(), m_glslVersion, 1355 Vec4(rnd.getFloat()), Ivec4(rnd.getInt(-8, 8)))); 1356 } 1357 ldexpGroup->addChild( 1358 new ShaderBitfieldOperationCaseLdexpVec2(m_context, "vec2_zero", m_glslVersion, Vec4(0.0, 0.0), Ivec4(0, 0))); 1359 for (int i = 0; i < ITERATIONS; ++i) 1360 { 1361 std::stringstream ss; 1362 ss << "vec2_" << i; 1363 ldexpGroup->addChild(new ShaderBitfieldOperationCaseLdexpVec2(m_context, ss.str().c_str(), m_glslVersion, 1364 Vec4(rnd.getFloat(), -rnd.getFloat()), 1365 Ivec4(rnd.getInt(-8, 8), rnd.getInt(-8, 8)))); 1366 } 1367 ldexpGroup->addChild(new ShaderBitfieldOperationCaseLdexpVec3(m_context, "vec3_zero", m_glslVersion, 1368 Vec4(0.0, 0.0, 0.0), Ivec4(0, 0, 0))); 1369 for (int i = 0; i < ITERATIONS; ++i) 1370 { 1371 std::stringstream ss; 1372 ss << "vec3_" << i; 1373 ldexpGroup->addChild(new ShaderBitfieldOperationCaseLdexpVec3( 1374 m_context, ss.str().c_str(), m_glslVersion, Vec4(rnd.getFloat(), -rnd.getFloat(), rnd.getFloat()), 1375 Ivec4(rnd.getInt(-8, 8), rnd.getInt(-8, 8), rnd.getInt(-8, 8)))); 1376 } 1377 ldexpGroup->addChild(new ShaderBitfieldOperationCaseLdexpVec4(m_context, "vec4_zero", m_glslVersion, 1378 Vec4(0.0, 0.0, 0.0, 0.0), Ivec4(0, 0, 0, 0))); 1379 for (int i = 0; i < ITERATIONS; ++i) 1380 { 1381 std::stringstream ss; 1382 ss << "vec4_" << i; 1383 ldexpGroup->addChild(new ShaderBitfieldOperationCaseLdexpVec4( 1384 m_context, ss.str().c_str(), m_glslVersion, 1385 Vec4(rnd.getFloat(), -rnd.getFloat(), rnd.getFloat(), -rnd.getFloat()), 1386 Ivec4(rnd.getInt(-8, 8), rnd.getInt(-8, 8), rnd.getInt(-8, 8), rnd.getInt(-8, 8)))); 1387 } 1388 1389 // shader_bitfield_operation.packUnorm4x8 1390 tcu::TestCaseGroup* packUnormGroup = new tcu::TestCaseGroup(m_testCtx, "packUnorm4x8", ""); 1391 addChild(packUnormGroup); 1392 for (int i = 0; i < ITERATIONS; ++i) 1393 { 1394 std::stringstream ss; 1395 ss << i; 1396 packUnormGroup->addChild(new ShaderBitfieldOperationCasePackUnorm( 1397 m_context, ss.str().c_str(), m_glslVersion, 1398 Vec4(rnd.getFloat(), rnd.getFloat(), rnd.getFloat(), rnd.getFloat()))); 1399 } 1400 1401 // shader_bitfield_operation.packSnorm4x8 1402 tcu::TestCaseGroup* packSnormGroup = new tcu::TestCaseGroup(m_testCtx, "packSnorm4x8", ""); 1403 addChild(packSnormGroup); 1404 for (int i = 0; i < ITERATIONS; ++i) 1405 { 1406 std::stringstream ss; 1407 ss << i; 1408 packSnormGroup->addChild(new ShaderBitfieldOperationCasePackSnorm( 1409 m_context, ss.str().c_str(), m_glslVersion, 1410 Vec4(rnd.getFloat(), -rnd.getFloat(), rnd.getFloat(), -rnd.getFloat()))); 1411 } 1412 1413 // shader_bitfield_operation.unpackUnorm4x8 1414 tcu::TestCaseGroup* unpackUnormGroup = new tcu::TestCaseGroup(m_testCtx, "unpackUnorm4x8", ""); 1415 addChild(unpackUnormGroup); 1416 for (int i = 0; i < ITERATIONS; ++i) 1417 { 1418 std::stringstream ss; 1419 ss << i; 1420 unpackUnormGroup->addChild(new ShaderBitfieldOperationCaseUnpackUnorm(m_context, ss.str().c_str(), 1421 m_glslVersion, Uvec4(rnd.getUint32()))); 1422 } 1423 1424 // shader_bitfield_operation.unpackSnorm4x8 1425 tcu::TestCaseGroup* unpackSnormGroup = new tcu::TestCaseGroup(m_testCtx, "unpackSnorm4x8", ""); 1426 addChild(unpackSnormGroup); 1427 for (int i = 0; i < ITERATIONS; ++i) 1428 { 1429 std::stringstream ss; 1430 ss << i; 1431 unpackSnormGroup->addChild(new ShaderBitfieldOperationCaseUnpackSnorm(m_context, ss.str().c_str(), 1432 m_glslVersion, Uvec4(rnd.getUint32()))); 1433 } 1434 1435 // shader_bitfield_operation.bitfieldExtract 1436 tcu::TestCaseGroup* bitfieldExtractGroup = new tcu::TestCaseGroup(m_testCtx, "bitfieldExtract", ""); 1437 addChild(bitfieldExtractGroup); 1438 for (int i = 0; i < ITERATIONS; ++i) 1439 { 1440 std::stringstream ss; 1441 ss << "uint_" << i; 1442 bitfieldExtractGroup->addChild(new ShaderBitfieldOperationCaseBitfieldExtractUint1( 1443 m_context, ss.str().c_str(), m_glslVersion, Uvec4(rnd.getUint32()), rnd.getInt(0, 31), rnd.getInt(1, 32))); 1444 } 1445 for (int i = 0; i < ITERATIONS; ++i) 1446 { 1447 std::stringstream ss; 1448 ss << "uvec2_" << i; 1449 bitfieldExtractGroup->addChild(new ShaderBitfieldOperationCaseBitfieldExtractUint2( 1450 m_context, ss.str().c_str(), m_glslVersion, Uvec4(rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31), 1451 rnd.getInt(1, 32))); 1452 } 1453 for (int i = 0; i < ITERATIONS; ++i) 1454 { 1455 std::stringstream ss; 1456 ss << "uvec3_" << i; 1457 bitfieldExtractGroup->addChild(new ShaderBitfieldOperationCaseBitfieldExtractUint3( 1458 m_context, ss.str().c_str(), m_glslVersion, Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), 1459 rnd.getInt(0, 31), rnd.getInt(1, 32))); 1460 } 1461 for (int i = 0; i < ITERATIONS; ++i) 1462 { 1463 std::stringstream ss; 1464 ss << "uvec4_" << i; 1465 bitfieldExtractGroup->addChild(new ShaderBitfieldOperationCaseBitfieldExtractUint4( 1466 m_context, ss.str().c_str(), m_glslVersion, 1467 Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31), 1468 rnd.getInt(1, 32))); 1469 } 1470 1471 for (int i = 0; i < ITERATIONS; ++i) 1472 { 1473 std::stringstream ss; 1474 ss << "int_" << i; 1475 bitfieldExtractGroup->addChild(new ShaderBitfieldOperationCaseBitfieldExtractInt1( 1476 m_context, ss.str().c_str(), m_glslVersion, Ivec4(rnd.getUint32()), rnd.getInt(0, 31), rnd.getInt(1, 32))); 1477 } 1478 for (int i = 0; i < ITERATIONS; ++i) 1479 { 1480 std::stringstream ss; 1481 ss << "ivec2_" << i; 1482 bitfieldExtractGroup->addChild(new ShaderBitfieldOperationCaseBitfieldExtractInt2( 1483 m_context, ss.str().c_str(), m_glslVersion, Ivec4(rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31), 1484 rnd.getInt(1, 32))); 1485 } 1486 for (int i = 0; i < ITERATIONS; ++i) 1487 { 1488 std::stringstream ss; 1489 ss << "ivec3_" << i; 1490 bitfieldExtractGroup->addChild(new ShaderBitfieldOperationCaseBitfieldExtractInt3( 1491 m_context, ss.str().c_str(), m_glslVersion, Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), 1492 rnd.getInt(0, 31), rnd.getInt(1, 32))); 1493 } 1494 for (int i = 0; i < ITERATIONS; ++i) 1495 { 1496 std::stringstream ss; 1497 ss << "ivec4_" << i; 1498 bitfieldExtractGroup->addChild(new ShaderBitfieldOperationCaseBitfieldExtractInt4( 1499 m_context, ss.str().c_str(), m_glslVersion, 1500 Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31), 1501 rnd.getInt(1, 32))); 1502 } 1503 1504 // shader_bitfield_operation.bitfieldInsert 1505 tcu::TestCaseGroup* bitfieldInsertGroup = new tcu::TestCaseGroup(m_testCtx, "bitfieldInsert", ""); 1506 addChild(bitfieldInsertGroup); 1507 for (int i = 0; i < ITERATIONS; ++i) 1508 { 1509 std::stringstream ss; 1510 ss << "uint_" << i; 1511 bitfieldInsertGroup->addChild(new ShaderBitfieldOperationCaseBitfieldInsertUint1( 1512 m_context, ss.str().c_str(), m_glslVersion, Uvec4(rnd.getUint32()), Uvec4(rnd.getUint32()), 1513 rnd.getInt(0, 31), rnd.getInt(1, 32))); 1514 } 1515 for (int i = 0; i < ITERATIONS; ++i) 1516 { 1517 std::stringstream ss; 1518 ss << "uvec2_" << i; 1519 bitfieldInsertGroup->addChild(new ShaderBitfieldOperationCaseBitfieldInsertUint2( 1520 m_context, ss.str().c_str(), m_glslVersion, Uvec4(rnd.getUint32(), rnd.getUint32()), 1521 Uvec4(rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31), rnd.getInt(1, 32))); 1522 } 1523 for (int i = 0; i < ITERATIONS; ++i) 1524 { 1525 std::stringstream ss; 1526 ss << "uvec3_" << i; 1527 bitfieldInsertGroup->addChild(new ShaderBitfieldOperationCaseBitfieldInsertUint3( 1528 m_context, ss.str().c_str(), m_glslVersion, Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), 1529 Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31), rnd.getInt(1, 32))); 1530 } 1531 for (int i = 0; i < ITERATIONS; ++i) 1532 { 1533 std::stringstream ss; 1534 ss << "uvec4_" << i; 1535 bitfieldInsertGroup->addChild(new ShaderBitfieldOperationCaseBitfieldInsertUint4( 1536 m_context, ss.str().c_str(), m_glslVersion, 1537 Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), 1538 Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31), 1539 rnd.getInt(1, 32))); 1540 } 1541 1542 for (int i = 0; i < ITERATIONS; ++i) 1543 { 1544 std::stringstream ss; 1545 ss << "int_" << i; 1546 bitfieldInsertGroup->addChild(new ShaderBitfieldOperationCaseBitfieldInsertInt1( 1547 m_context, ss.str().c_str(), m_glslVersion, Ivec4(rnd.getUint32()), Ivec4(rnd.getUint32()), 1548 rnd.getInt(0, 31), rnd.getInt(1, 32))); 1549 } 1550 for (int i = 0; i < ITERATIONS; ++i) 1551 { 1552 std::stringstream ss; 1553 ss << "ivec2_" << i; 1554 bitfieldInsertGroup->addChild(new ShaderBitfieldOperationCaseBitfieldInsertInt2( 1555 m_context, ss.str().c_str(), m_glslVersion, Ivec4(rnd.getUint32(), rnd.getUint32()), 1556 Ivec4(rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31), rnd.getInt(1, 32))); 1557 } 1558 for (int i = 0; i < ITERATIONS; ++i) 1559 { 1560 std::stringstream ss; 1561 ss << "ivec3_" << i; 1562 bitfieldInsertGroup->addChild(new ShaderBitfieldOperationCaseBitfieldInsertInt3( 1563 m_context, ss.str().c_str(), m_glslVersion, Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), 1564 Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31), rnd.getInt(1, 32))); 1565 } 1566 for (int i = 0; i < ITERATIONS; ++i) 1567 { 1568 std::stringstream ss; 1569 ss << "ivec4_" << i; 1570 bitfieldInsertGroup->addChild(new ShaderBitfieldOperationCaseBitfieldInsertInt4( 1571 m_context, ss.str().c_str(), m_glslVersion, 1572 Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), 1573 Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31), 1574 rnd.getInt(1, 32))); 1575 } 1576 1577 struct UnaryTest 1578 { 1579 char const* funcName; 1580 UnaryUFunc funcU; 1581 UnaryIFunc funcI; 1582 } commonTests[] = { 1583 { "bitfieldReverse", bitfieldReverse, 1584 reinterpret_cast<UnaryIFunc>(bitfieldReverse) }, // shader_bitfield_operation.bitfieldReverse 1585 { "bitCount", bitCount, reinterpret_cast<UnaryIFunc>(bitCount) }, // shader_bitfield_operation.bitCount 1586 { "findLSB", findLSB, reinterpret_cast<UnaryIFunc>(findLSB) }, // shader_bitfield_operation.findLSB 1587 { "findMSB", findMSBU, findMSBI }, // shader_bitfield_operation.findMSB 1588 }; 1589 for (int test = 0; test < DE_LENGTH_OF_ARRAY(commonTests); ++test) 1590 { 1591 tcu::TestCaseGroup* commonGroup = new tcu::TestCaseGroup(m_testCtx, commonTests[test].funcName, ""); 1592 addChild(commonGroup); 1593 commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryUint1( 1594 m_context, "uint_zero", m_glslVersion, commonTests[test].funcName, commonTests[test].funcU, Uvec4(0))); 1595 for (int i = 0; i < ITERATIONS; ++i) 1596 { 1597 std::stringstream ss; 1598 ss << "uint_" << i; 1599 commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryUint1( 1600 m_context, ss.str().c_str(), m_glslVersion, commonTests[test].funcName, commonTests[test].funcU, 1601 Uvec4(rnd.getUint32()))); 1602 } 1603 for (int i = 0; i < ITERATIONS; ++i) 1604 { 1605 std::stringstream ss; 1606 ss << "uvec2_" << i; 1607 commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryUint2( 1608 m_context, ss.str().c_str(), m_glslVersion, commonTests[test].funcName, commonTests[test].funcU, 1609 Uvec4(rnd.getUint32(), rnd.getUint32()))); 1610 } 1611 for (int i = 0; i < ITERATIONS; ++i) 1612 { 1613 std::stringstream ss; 1614 ss << "uvec3_" << i; 1615 commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryUint3( 1616 m_context, ss.str().c_str(), m_glslVersion, commonTests[test].funcName, commonTests[test].funcU, 1617 Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()))); 1618 } 1619 for (int i = 0; i < ITERATIONS; ++i) 1620 { 1621 std::stringstream ss; 1622 ss << "uvec4_" << i; 1623 commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryUint4( 1624 m_context, ss.str().c_str(), m_glslVersion, commonTests[test].funcName, commonTests[test].funcU, 1625 Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()))); 1626 } 1627 1628 commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryInt1( 1629 m_context, "int_zero", m_glslVersion, commonTests[test].funcName, commonTests[test].funcI, Ivec4(0))); 1630 commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryInt1( 1631 m_context, "int_minus_one", m_glslVersion, commonTests[test].funcName, commonTests[test].funcI, Ivec4(-1))); 1632 for (int i = 0; i < ITERATIONS; ++i) 1633 { 1634 std::stringstream ss; 1635 ss << "int_" << i; 1636 commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryInt1( 1637 m_context, ss.str().c_str(), m_glslVersion, commonTests[test].funcName, commonTests[test].funcI, 1638 Ivec4(rnd.getUint32()))); 1639 } 1640 for (int i = 0; i < ITERATIONS; ++i) 1641 { 1642 std::stringstream ss; 1643 ss << "ivec2_" << i; 1644 commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryInt2( 1645 m_context, ss.str().c_str(), m_glslVersion, commonTests[test].funcName, commonTests[test].funcI, 1646 Ivec4(rnd.getUint32(), rnd.getUint32()))); 1647 } 1648 for (int i = 0; i < ITERATIONS; ++i) 1649 { 1650 std::stringstream ss; 1651 ss << "ivec3_" << i; 1652 commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryInt3( 1653 m_context, ss.str().c_str(), m_glslVersion, commonTests[test].funcName, commonTests[test].funcI, 1654 Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()))); 1655 } 1656 for (int i = 0; i < ITERATIONS; ++i) 1657 { 1658 std::stringstream ss; 1659 ss << "ivec4_" << i; 1660 commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryInt4( 1661 m_context, ss.str().c_str(), m_glslVersion, commonTests[test].funcName, commonTests[test].funcI, 1662 Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()))); 1663 } 1664 } 1665 1666 // shader_bitfield_operation.uaddCarry 1667 tcu::TestCaseGroup* uaddCarryGroup = new tcu::TestCaseGroup(m_testCtx, "uaddCarry", ""); 1668 addChild(uaddCarryGroup); 1669 for (int i = 0; i < ITERATIONS; ++i) 1670 { 1671 std::stringstream ss; 1672 ss << "uint_" << i; 1673 uaddCarryGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint1( 1674 m_context, ss.str().c_str(), m_glslVersion, "outUvec4.x = uaddCarry(inUvec4.x, in2Uvec4.x, out2Uvec4.x);", 1675 uaddCarry, Uvec4(rnd.getUint32()), Uvec4(rnd.getUint32()))); 1676 } 1677 for (int i = 0; i < ITERATIONS; ++i) 1678 { 1679 std::stringstream ss; 1680 ss << "uvec2_" << i; 1681 uaddCarryGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint2( 1682 m_context, ss.str().c_str(), m_glslVersion, 1683 "outUvec4.xy = uaddCarry(inUvec4.xy, in2Uvec4.xy, out2Uvec4.xy);", uaddCarry, 1684 Uvec4(rnd.getUint32(), rnd.getUint32()), Uvec4(rnd.getUint32(), rnd.getUint32()))); 1685 } 1686 for (int i = 0; i < ITERATIONS; ++i) 1687 { 1688 std::stringstream ss; 1689 ss << "uvec3_" << i; 1690 uaddCarryGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint3( 1691 m_context, ss.str().c_str(), m_glslVersion, 1692 "outUvec4.xyz = uaddCarry(inUvec4.xyz, in2Uvec4.xyz, out2Uvec4.xyz);", uaddCarry, 1693 Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), 1694 Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()))); 1695 } 1696 for (int i = 0; i < ITERATIONS; ++i) 1697 { 1698 std::stringstream ss; 1699 ss << "uvec4_" << i; 1700 uaddCarryGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint4( 1701 m_context, ss.str().c_str(), m_glslVersion, "outUvec4 = uaddCarry(inUvec4, in2Uvec4, out2Uvec4);", 1702 uaddCarry, Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), 1703 Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()))); 1704 } 1705 1706 // shader_bitfield_operation.usubBorrow 1707 tcu::TestCaseGroup* usubBorrowGroup = new tcu::TestCaseGroup(m_testCtx, "usubBorrow", ""); 1708 addChild(usubBorrowGroup); 1709 for (int i = 0; i < ITERATIONS; ++i) 1710 { 1711 std::stringstream ss; 1712 ss << "uint_" << i; 1713 usubBorrowGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint1( 1714 m_context, ss.str().c_str(), m_glslVersion, "outUvec4.x = usubBorrow(inUvec4.x, in2Uvec4.x, out2Uvec4.x);", 1715 usubBorrow, Uvec4(rnd.getUint32()), Uvec4(rnd.getUint32()))); 1716 } 1717 for (int i = 0; i < ITERATIONS; ++i) 1718 { 1719 std::stringstream ss; 1720 ss << "uvec2_" << i; 1721 usubBorrowGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint2( 1722 m_context, ss.str().c_str(), m_glslVersion, 1723 "outUvec4.xy = usubBorrow(inUvec4.xy, in2Uvec4.xy, out2Uvec4.xy);", usubBorrow, 1724 Uvec4(rnd.getUint32(), rnd.getUint32()), Uvec4(rnd.getUint32(), rnd.getUint32()))); 1725 } 1726 for (int i = 0; i < ITERATIONS; ++i) 1727 { 1728 std::stringstream ss; 1729 ss << "uvec3_" << i; 1730 usubBorrowGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint3( 1731 m_context, ss.str().c_str(), m_glslVersion, 1732 "outUvec4.xyz = usubBorrow(inUvec4.xyz, in2Uvec4.xyz, out2Uvec4.xyz);", usubBorrow, 1733 Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), 1734 Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()))); 1735 } 1736 for (int i = 0; i < ITERATIONS; ++i) 1737 { 1738 std::stringstream ss; 1739 ss << "uvec4_" << i; 1740 usubBorrowGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint4( 1741 m_context, ss.str().c_str(), m_glslVersion, "outUvec4 = usubBorrow(inUvec4, in2Uvec4, out2Uvec4);", 1742 usubBorrow, Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), 1743 Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()))); 1744 } 1745 1746 // shader_bitfield_operation.umulExtended 1747 tcu::TestCaseGroup* umulExtendedGroup = new tcu::TestCaseGroup(m_testCtx, "umulExtended", ""); 1748 addChild(umulExtendedGroup); 1749 for (int i = 0; i < ITERATIONS; ++i) 1750 { 1751 std::stringstream ss; 1752 ss << "uint_" << i; 1753 umulExtendedGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint1( 1754 m_context, ss.str().c_str(), m_glslVersion, "umulExtended(inUvec4.x, in2Uvec4.x, outUvec4.x, out2Uvec4.x);", 1755 umulExtended, Uvec4(rnd.getUint32()), Uvec4(rnd.getUint32()))); 1756 } 1757 for (int i = 0; i < ITERATIONS; ++i) 1758 { 1759 std::stringstream ss; 1760 ss << "uvec2_" << i; 1761 umulExtendedGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint2( 1762 m_context, ss.str().c_str(), m_glslVersion, 1763 "umulExtended(inUvec4.xy, in2Uvec4.xy, outUvec4.xy, out2Uvec4.xy);", umulExtended, 1764 Uvec4(rnd.getUint32(), rnd.getUint32()), Uvec4(rnd.getUint32(), rnd.getUint32()))); 1765 } 1766 for (int i = 0; i < ITERATIONS; ++i) 1767 { 1768 std::stringstream ss; 1769 ss << "uvec3_" << i; 1770 umulExtendedGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint3( 1771 m_context, ss.str().c_str(), m_glslVersion, 1772 "umulExtended(inUvec4.xyz, in2Uvec4.xyz, outUvec4.xyz, out2Uvec4.xyz);", umulExtended, 1773 Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), 1774 Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()))); 1775 } 1776 for (int i = 0; i < ITERATIONS; ++i) 1777 { 1778 std::stringstream ss; 1779 ss << "uvec4_" << i; 1780 umulExtendedGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint4( 1781 m_context, ss.str().c_str(), m_glslVersion, "umulExtended(inUvec4, in2Uvec4, outUvec4, out2Uvec4);", 1782 umulExtended, Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), 1783 Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()))); 1784 } 1785 1786 // shader_bitfield_operation.imulExtended 1787 tcu::TestCaseGroup* imulExtendedGroup = new tcu::TestCaseGroup(m_testCtx, "imulExtended", ""); 1788 addChild(imulExtendedGroup); 1789 for (int i = 0; i < ITERATIONS; ++i) 1790 { 1791 std::stringstream ss; 1792 ss << "int_" << i; 1793 imulExtendedGroup->addChild(new ShaderBitfieldOperationCaseBinaryInt1( 1794 m_context, ss.str().c_str(), m_glslVersion, "imulExtended(inIvec4.x, in2Ivec4.x, outIvec4.x, out2Ivec4.x);", 1795 imulExtended, Ivec4(rnd.getUint32()), Ivec4(rnd.getUint32()))); 1796 } 1797 for (int i = 0; i < ITERATIONS; ++i) 1798 { 1799 std::stringstream ss; 1800 ss << "ivec2_" << i; 1801 imulExtendedGroup->addChild(new ShaderBitfieldOperationCaseBinaryInt2( 1802 m_context, ss.str().c_str(), m_glslVersion, 1803 "imulExtended(inIvec4.xy, in2Ivec4.xy, outIvec4.xy, out2Ivec4.xy);", imulExtended, 1804 Ivec4(rnd.getUint32(), rnd.getUint32()), Ivec4(rnd.getUint32(), rnd.getUint32()))); 1805 } 1806 for (int i = 0; i < ITERATIONS; ++i) 1807 { 1808 std::stringstream ss; 1809 ss << "ivec3_" << i; 1810 imulExtendedGroup->addChild(new ShaderBitfieldOperationCaseBinaryInt3( 1811 m_context, ss.str().c_str(), m_glslVersion, 1812 "imulExtended(inIvec4.xyz, in2Ivec4.xyz, outIvec4.xyz, out2Ivec4.xyz);", imulExtended, 1813 Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), 1814 Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()))); 1815 } 1816 for (int i = 0; i < ITERATIONS; ++i) 1817 { 1818 std::stringstream ss; 1819 ss << "ivec4_" << i; 1820 imulExtendedGroup->addChild(new ShaderBitfieldOperationCaseBinaryInt4( 1821 m_context, ss.str().c_str(), m_glslVersion, "imulExtended(inIvec4, in2Ivec4, outIvec4, out2Ivec4);", 1822 imulExtended, Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), 1823 Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()))); 1824 } 1825 } 1826 1827 } // glcts 1828
