1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 2.0 Module 3 * ------------------------------------------------- 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Uniform API tests. 22 * 23 * \todo [2013-02-26 nuutti] Much duplication between this and ES3. 24 * Utilities to glshared? 25 *//*--------------------------------------------------------------------*/ 26 27 #include "es2fUniformApiTests.hpp" 28 #include "gluCallLogWrapper.hpp" 29 #include "gluShaderProgram.hpp" 30 #include "gluVarType.hpp" 31 #include "gluPixelTransfer.hpp" 32 #include "gluTextureUtil.hpp" 33 #include "gluTexture.hpp" 34 #include "tcuRenderTarget.hpp" 35 #include "tcuTestLog.hpp" 36 #include "tcuSurface.hpp" 37 #include "tcuCommandLine.hpp" 38 #include "deRandom.hpp" 39 #include "deStringUtil.hpp" 40 #include "deSharedPtr.hpp" 41 #include "deString.h" 42 #include "deMemory.h" 43 44 #include "glwEnums.hpp" 45 #include "glwFunctions.hpp" 46 47 #include <set> 48 #include <cstring> 49 50 using namespace glw; 51 52 namespace deqp 53 { 54 namespace gles2 55 { 56 namespace Functional 57 { 58 59 using std::vector; 60 using std::string; 61 using tcu::TestLog; 62 using tcu::ScopedLogSection; 63 using glu::ShaderProgram; 64 using glu::StructType; 65 using de::Random; 66 using de::SharedPtr; 67 68 typedef bool (* dataTypePredicate)(glu::DataType); 69 70 static const int MAX_RENDER_WIDTH = 32; 71 static const int MAX_RENDER_HEIGHT = 32; 72 static const int MAX_NUM_SAMPLER_UNIFORMS = 16; 73 74 static const glu::DataType s_testDataTypes[] = 75 { 76 glu::TYPE_FLOAT, 77 glu::TYPE_FLOAT_VEC2, 78 glu::TYPE_FLOAT_VEC3, 79 glu::TYPE_FLOAT_VEC4, 80 glu::TYPE_FLOAT_MAT2, 81 glu::TYPE_FLOAT_MAT3, 82 glu::TYPE_FLOAT_MAT4, 83 84 glu::TYPE_INT, 85 glu::TYPE_INT_VEC2, 86 glu::TYPE_INT_VEC3, 87 glu::TYPE_INT_VEC4, 88 89 glu::TYPE_BOOL, 90 glu::TYPE_BOOL_VEC2, 91 glu::TYPE_BOOL_VEC3, 92 glu::TYPE_BOOL_VEC4, 93 94 glu::TYPE_SAMPLER_2D, 95 glu::TYPE_SAMPLER_CUBE 96 }; 97 98 static inline int getGLInt (const glw::Functions& funcs, const deUint32 name) 99 { 100 int val = -1; 101 funcs.getIntegerv(name, &val); 102 return val; 103 } 104 105 static inline tcu::Vec4 vec4FromPtr (const float* const ptr) 106 { 107 tcu::Vec4 result; 108 for (int i = 0; i < 4; i++) 109 result[i] = ptr[i]; 110 return result; 111 } 112 113 static inline string beforeLast (const string& str, const char c) 114 { 115 return str.substr(0, str.find_last_of(c)); 116 } 117 118 static inline void fillWithColor (const tcu::PixelBufferAccess& access, const tcu::Vec4& color) 119 { 120 for (int z = 0; z < access.getDepth(); z++) 121 for (int y = 0; y < access.getHeight(); y++) 122 for (int x = 0; x < access.getWidth(); x++) 123 access.setPixel(color, x, y, z); 124 } 125 126 static inline int getSamplerNumLookupDimensions (const glu::DataType type) 127 { 128 switch (type) 129 { 130 case glu::TYPE_SAMPLER_2D: 131 return 2; 132 133 case glu::TYPE_SAMPLER_CUBE: 134 return 3; 135 136 default: // \note All others than 2d and cube are gles3-only types. 137 DE_ASSERT(false); 138 return 0; 139 } 140 } 141 142 template<glu::DataType T> 143 static bool dataTypeEquals (const glu::DataType t) 144 { 145 return t == T; 146 } 147 148 template<int N> 149 static bool dataTypeIsMatrixWithNRows (const glu::DataType t) 150 { 151 return glu::isDataTypeMatrix(t) && glu::getDataTypeMatrixNumRows(t) == N; 152 } 153 154 static bool typeContainsMatchingBasicType (const glu::VarType& type, const dataTypePredicate predicate) 155 { 156 if (type.isBasicType()) 157 return predicate(type.getBasicType()); 158 else if (type.isArrayType()) 159 return typeContainsMatchingBasicType(type.getElementType(), predicate); 160 else 161 { 162 DE_ASSERT(type.isStructType()); 163 const StructType& structType = *type.getStructPtr(); 164 for (int i = 0; i < structType.getNumMembers(); i++) 165 if (typeContainsMatchingBasicType(structType.getMember(i).getType(), predicate)) 166 return true; 167 return false; 168 } 169 } 170 171 static void getDistinctSamplerTypes (vector<glu::DataType>& dst, const glu::VarType& type) 172 { 173 if (type.isBasicType()) 174 { 175 const glu::DataType basicType = type.getBasicType(); 176 if (glu::isDataTypeSampler(basicType) && std::find(dst.begin(), dst.end(), basicType) == dst.end()) 177 dst.push_back(basicType); 178 } 179 else if (type.isArrayType()) 180 getDistinctSamplerTypes(dst, type.getElementType()); 181 else 182 { 183 DE_ASSERT(type.isStructType()); 184 const StructType& structType = *type.getStructPtr(); 185 for (int i = 0; i < structType.getNumMembers(); i++) 186 getDistinctSamplerTypes(dst, structType.getMember(i).getType()); 187 } 188 } 189 190 static int getNumSamplersInType (const glu::VarType& type) 191 { 192 if (type.isBasicType()) 193 return glu::isDataTypeSampler(type.getBasicType()) ? 1 : 0; 194 else if (type.isArrayType()) 195 return getNumSamplersInType(type.getElementType()) * type.getArraySize(); 196 else 197 { 198 DE_ASSERT(type.isStructType()); 199 const StructType& structType = *type.getStructPtr(); 200 int sum = 0; 201 for (int i = 0; i < structType.getNumMembers(); i++) 202 sum += getNumSamplersInType(structType.getMember(i).getType()); 203 return sum; 204 } 205 } 206 207 static glu::VarType generateRandomType (const int maxDepth, int& curStructIdx, vector<const StructType*>& structTypesDst, Random& rnd) 208 { 209 const bool isStruct = maxDepth > 0 && rnd.getFloat() < 0.2f; 210 const bool isArray = rnd.getFloat() < 0.3f; 211 212 if (isStruct) 213 { 214 const int numMembers = rnd.getInt(1, 5); 215 StructType* const structType = new StructType(("structType" + de::toString(curStructIdx++)).c_str()); 216 217 for (int i = 0; i < numMembers; i++) 218 structType->addMember(("m" + de::toString(i)).c_str(), generateRandomType(maxDepth-1, curStructIdx, structTypesDst, rnd)); 219 220 structTypesDst.push_back(structType); 221 return isArray ? glu::VarType(glu::VarType(structType), rnd.getInt(1, 5)) : glu::VarType(structType); 222 } 223 else 224 { 225 const glu::DataType basicType = (glu::DataType)s_testDataTypes[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_testDataTypes)-1)]; 226 const glu::Precision precision = glu::isDataTypeBoolOrBVec(basicType) ? glu::PRECISION_LAST : glu::PRECISION_MEDIUMP; 227 return isArray ? glu::VarType(glu::VarType(basicType, precision), rnd.getInt(1, 5)) : glu::VarType(basicType, precision); 228 } 229 } 230 231 namespace 232 { 233 234 struct VarValue 235 { 236 glu::DataType type; 237 238 union 239 { 240 float floatV[4*4]; // At most mat4. \note Matrices here are column-major. 241 deInt32 intV[4]; 242 bool boolV[4]; 243 struct 244 { 245 int unit; 246 float fillColor[4]; 247 } samplerV; 248 } val; 249 }; 250 251 enum CaseShaderType 252 { 253 CASESHADERTYPE_VERTEX = 0, 254 CASESHADERTYPE_FRAGMENT, 255 CASESHADERTYPE_BOTH, 256 257 CASESHADERTYPE_LAST 258 }; 259 260 struct Uniform 261 { 262 string name; 263 glu::VarType type; 264 265 Uniform (const char* const name_, const glu::VarType& type_) : name(name_), type(type_) {} 266 }; 267 268 // A set of uniforms, along with related struct types. 269 class UniformCollection 270 { 271 public: 272 int getNumUniforms (void) const { return (int)m_uniforms.size(); } 273 int getNumStructTypes (void) const { return (int)m_structTypes.size(); } 274 Uniform& getUniform (const int ndx) { return m_uniforms[ndx]; } 275 const Uniform& getUniform (const int ndx) const { return m_uniforms[ndx]; } 276 const StructType* getStructType (const int ndx) const { return m_structTypes[ndx]; } 277 void addUniform (const Uniform& uniform) { m_uniforms.push_back(uniform); } 278 void addStructType (const StructType* const type) { m_structTypes.push_back(type); } 279 280 UniformCollection (void) {} 281 ~UniformCollection (void) 282 { 283 for (int i = 0; i < (int)m_structTypes.size(); i++) 284 delete m_structTypes[i]; 285 } 286 287 // Add the contents of m_uniforms and m_structTypes to receiver, and remove them from this one. 288 // \note receiver takes ownership of the struct types. 289 void moveContents (UniformCollection& receiver) 290 { 291 for (int i = 0; i < (int)m_uniforms.size(); i++) 292 receiver.addUniform(m_uniforms[i]); 293 m_uniforms.clear(); 294 295 for (int i = 0; i < (int)m_structTypes.size(); i++) 296 receiver.addStructType(m_structTypes[i]); 297 m_structTypes.clear(); 298 } 299 300 bool containsMatchingBasicType (const dataTypePredicate predicate) const 301 { 302 for (int i = 0; i < (int)m_uniforms.size(); i++) 303 if (typeContainsMatchingBasicType(m_uniforms[i].type, predicate)) 304 return true; 305 return false; 306 } 307 308 vector<glu::DataType> getSamplerTypes (void) const 309 { 310 vector<glu::DataType> samplerTypes; 311 for (int i = 0; i < (int)m_uniforms.size(); i++) 312 getDistinctSamplerTypes(samplerTypes, m_uniforms[i].type); 313 return samplerTypes; 314 } 315 316 bool containsSeveralSamplerTypes (void) const 317 { 318 return getSamplerTypes().size() > 1; 319 } 320 321 int getNumSamplers (void) const 322 { 323 int sum = 0; 324 for (int i = 0; i < (int)m_uniforms.size(); i++) 325 sum += getNumSamplersInType(m_uniforms[i].type); 326 return sum; 327 } 328 329 static UniformCollection* basic (const glu::DataType type, const char* const nameSuffix = "") 330 { 331 UniformCollection* const res = new UniformCollection; 332 const glu::Precision prec = glu::isDataTypeBoolOrBVec(type) ? glu::PRECISION_LAST : glu::PRECISION_MEDIUMP; 333 res->m_uniforms.push_back(Uniform((string("u_var") + nameSuffix).c_str(), glu::VarType(type, prec))); 334 return res; 335 } 336 337 static UniformCollection* basicArray (const glu::DataType type, const char* const nameSuffix = "") 338 { 339 UniformCollection* const res = new UniformCollection; 340 const glu::Precision prec = glu::isDataTypeBoolOrBVec(type) ? glu::PRECISION_LAST : glu::PRECISION_MEDIUMP; 341 res->m_uniforms.push_back(Uniform((string("u_var") + nameSuffix).c_str(), glu::VarType(glu::VarType(type, prec), 3))); 342 return res; 343 } 344 345 static UniformCollection* basicStruct (const glu::DataType type0, const glu::DataType type1, const bool containsArrays, const char* const nameSuffix = "") 346 { 347 UniformCollection* const res = new UniformCollection; 348 const glu::Precision prec0 = glu::isDataTypeBoolOrBVec(type0) ? glu::PRECISION_LAST : glu::PRECISION_MEDIUMP; 349 const glu::Precision prec1 = glu::isDataTypeBoolOrBVec(type1) ? glu::PRECISION_LAST : glu::PRECISION_MEDIUMP; 350 351 StructType* const structType = new StructType((string("structType") + nameSuffix).c_str()); 352 structType->addMember("m0", glu::VarType(type0, prec0)); 353 structType->addMember("m1", glu::VarType(type1, prec1)); 354 if (containsArrays) 355 { 356 structType->addMember("m2", glu::VarType(glu::VarType(type0, prec0), 3)); 357 structType->addMember("m3", glu::VarType(glu::VarType(type1, prec1), 3)); 358 } 359 360 res->addStructType(structType); 361 res->addUniform(Uniform((string("u_var") + nameSuffix).c_str(), glu::VarType(structType))); 362 363 return res; 364 } 365 366 static UniformCollection* structInArray (const glu::DataType type0, const glu::DataType type1, const bool containsArrays, const char* const nameSuffix = "") 367 { 368 UniformCollection* const res = basicStruct(type0, type1, containsArrays, nameSuffix); 369 res->getUniform(0).type = glu::VarType(res->getUniform(0).type, 3); 370 return res; 371 } 372 373 static UniformCollection* nestedArraysStructs (const glu::DataType type0, const glu::DataType type1, const char* const nameSuffix = "") 374 { 375 UniformCollection* const res = new UniformCollection; 376 const glu::Precision prec0 = glu::isDataTypeBoolOrBVec(type0) ? glu::PRECISION_LAST : glu::PRECISION_MEDIUMP; 377 const glu::Precision prec1 = glu::isDataTypeBoolOrBVec(type1) ? glu::PRECISION_LAST : glu::PRECISION_MEDIUMP; 378 StructType* const structType = new StructType((string("structType") + nameSuffix).c_str()); 379 StructType* const subStructType = new StructType((string("subStructType") + nameSuffix).c_str()); 380 StructType* const subSubStructType = new StructType((string("subSubStructType") + nameSuffix).c_str()); 381 382 subSubStructType->addMember("mss0", glu::VarType(type0, prec0)); 383 subSubStructType->addMember("mss1", glu::VarType(type1, prec1)); 384 385 subStructType->addMember("ms0", glu::VarType(type1, prec1)); 386 subStructType->addMember("ms1", glu::VarType(glu::VarType(type0, prec0), 2)); 387 subStructType->addMember("ms2", glu::VarType(glu::VarType(subSubStructType), 2)); 388 389 structType->addMember("m0", glu::VarType(type0, prec0)); 390 structType->addMember("m1", glu::VarType(subStructType)); 391 structType->addMember("m2", glu::VarType(type1, prec1)); 392 393 res->addStructType(subSubStructType); 394 res->addStructType(subStructType); 395 res->addStructType(structType); 396 397 res->addUniform(Uniform((string("u_var") + nameSuffix).c_str(), glu::VarType(structType))); 398 399 return res; 400 } 401 402 static UniformCollection* multipleBasic (const char* const nameSuffix = "") 403 { 404 static const glu::DataType types[] = { glu::TYPE_FLOAT, glu::TYPE_INT_VEC3, glu::TYPE_FLOAT_MAT3, glu::TYPE_BOOL_VEC2 }; 405 UniformCollection* const res = new UniformCollection; 406 407 for (int i = 0; i < DE_LENGTH_OF_ARRAY(types); i++) 408 { 409 UniformCollection* const sub = basic(types[i], ("_" + de::toString(i) + nameSuffix).c_str()); 410 sub->moveContents(*res); 411 delete sub; 412 } 413 414 return res; 415 } 416 417 static UniformCollection* multipleBasicArray (const char* const nameSuffix = "") 418 { 419 static const glu::DataType types[] = { glu::TYPE_FLOAT, glu::TYPE_INT_VEC3, glu::TYPE_BOOL_VEC2 }; 420 UniformCollection* const res = new UniformCollection; 421 422 for (int i = 0; i < DE_LENGTH_OF_ARRAY(types); i++) 423 { 424 UniformCollection* const sub = basicArray(types[i], ("_" + de::toString(i) + nameSuffix).c_str()); 425 sub->moveContents(*res); 426 delete sub; 427 } 428 429 return res; 430 } 431 432 static UniformCollection* multipleNestedArraysStructs (const char* const nameSuffix = "") 433 { 434 static const glu::DataType types0[] = { glu::TYPE_FLOAT, glu::TYPE_INT, glu::TYPE_BOOL_VEC4 }; 435 static const glu::DataType types1[] = { glu::TYPE_FLOAT_VEC4, glu::TYPE_INT_VEC4, glu::TYPE_BOOL }; 436 UniformCollection* const res = new UniformCollection; 437 438 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(types0) == DE_LENGTH_OF_ARRAY(types1)); 439 440 for (int i = 0; i < DE_LENGTH_OF_ARRAY(types0); i++) 441 { 442 UniformCollection* const sub = nestedArraysStructs(types0[i], types1[i], ("_" + de::toString(i) + nameSuffix).c_str()); 443 sub->moveContents(*res); 444 delete sub; 445 } 446 447 return res; 448 } 449 450 static UniformCollection* random (const deUint32 seed) 451 { 452 Random rnd (seed); 453 const int numUniforms = rnd.getInt(1, 5); 454 int structIdx = 0; 455 UniformCollection* const res = new UniformCollection; 456 457 for (int i = 0; i < numUniforms; i++) 458 { 459 vector<const StructType*> structTypes; 460 Uniform uniform(("u_var" + de::toString(i)).c_str(), glu::VarType()); 461 462 // \note Discard uniforms that would cause number of samplers to exceed MAX_NUM_SAMPLER_UNIFORMS. 463 do 464 { 465 for (int j = 0; j < (int)structTypes.size(); j++) 466 delete structTypes[j]; 467 structTypes.clear(); 468 uniform.type = (("u_var" + de::toString(i)).c_str(), generateRandomType(3, structIdx, structTypes, rnd)); 469 } while (res->getNumSamplers() + getNumSamplersInType(uniform.type) > MAX_NUM_SAMPLER_UNIFORMS); 470 471 res->addUniform(uniform); 472 for (int j = 0; j < (int)structTypes.size(); j++) 473 res->addStructType(structTypes[j]); 474 } 475 476 return res; 477 } 478 479 private: 480 // \note Copying these would be cumbersome, since deep-copying both m_uniforms and m_structTypes 481 // would mean that we'd need to update pointers from uniforms to point to the new structTypes. 482 // When the same UniformCollection is needed in several places, a SharedPtr is used instead. 483 UniformCollection (const UniformCollection&); // Not allowed. 484 UniformCollection& operator= (const UniformCollection&); // Not allowed. 485 486 vector<Uniform> m_uniforms; 487 vector<const StructType*> m_structTypes; 488 }; 489 490 }; // anonymous 491 492 static VarValue getSamplerFillValue (const VarValue& sampler) 493 { 494 DE_ASSERT(glu::isDataTypeSampler(sampler.type)); 495 496 VarValue result; 497 result.type = glu::TYPE_FLOAT_VEC4; 498 499 for (int i = 0; i < 4; i++) 500 result.val.floatV[i] = sampler.val.samplerV.fillColor[i]; 501 502 return result; 503 } 504 505 static VarValue getSamplerUnitValue (const VarValue& sampler) 506 { 507 DE_ASSERT(glu::isDataTypeSampler(sampler.type)); 508 509 VarValue result; 510 result.type = glu::TYPE_INT; 511 result.val.intV[0] = sampler.val.samplerV.unit; 512 513 return result; 514 } 515 516 static string shaderVarValueStr (const VarValue& value) 517 { 518 const int numElems = glu::getDataTypeScalarSize(value.type); 519 std::ostringstream result; 520 521 if (numElems > 1) 522 result << glu::getDataTypeName(value.type) << "("; 523 524 for (int i = 0; i < numElems; i++) 525 { 526 if (i > 0) 527 result << ", "; 528 529 if (glu::isDataTypeFloatOrVec(value.type) || glu::isDataTypeMatrix(value.type)) 530 result << de::floatToString(value.val.floatV[i], 2); 531 else if (glu::isDataTypeIntOrIVec((value.type))) 532 result << de::toString(value.val.intV[i]); 533 else if (glu::isDataTypeBoolOrBVec((value.type))) 534 result << (value.val.boolV[i] ? "true" : "false"); 535 else if (glu::isDataTypeSampler((value.type))) 536 result << shaderVarValueStr(getSamplerFillValue(value)); 537 else 538 DE_ASSERT(false); 539 } 540 541 if (numElems > 1) 542 result << ")"; 543 544 return result.str(); 545 } 546 547 static string apiVarValueStr (const VarValue& value) 548 { 549 const int numElems = glu::getDataTypeScalarSize(value.type); 550 std::ostringstream result; 551 552 if (numElems > 1) 553 result << "("; 554 555 for (int i = 0; i < numElems; i++) 556 { 557 if (i > 0) 558 result << ", "; 559 560 if (glu::isDataTypeFloatOrVec(value.type) || glu::isDataTypeMatrix(value.type)) 561 result << de::floatToString(value.val.floatV[i], 2); 562 else if (glu::isDataTypeIntOrIVec((value.type))) 563 result << de::toString(value.val.intV[i]); 564 else if (glu::isDataTypeBoolOrBVec((value.type))) 565 result << (value.val.boolV[i] ? "true" : "false"); 566 else if (glu::isDataTypeSampler((value.type))) 567 result << value.val.samplerV.unit; 568 else 569 DE_ASSERT(false); 570 } 571 572 if (numElems > 1) 573 result << ")"; 574 575 return result.str(); 576 } 577 578 static VarValue generateRandomVarValue (const glu::DataType type, Random& rnd, int samplerUnit = -1 /* Used if type is a sampler type. \note Samplers' unit numbers are not randomized. */) 579 { 580 const int numElems = glu::getDataTypeScalarSize(type); 581 VarValue result; 582 result.type = type; 583 584 DE_ASSERT((samplerUnit >= 0) == (glu::isDataTypeSampler(type))); 585 586 if (glu::isDataTypeFloatOrVec(type) || glu::isDataTypeMatrix(type)) 587 { 588 for (int i = 0; i < numElems; i++) 589 result.val.floatV[i] = rnd.getFloat(-10.0f, 10.0f); 590 } 591 else if (glu::isDataTypeIntOrIVec(type)) 592 { 593 for (int i = 0; i < numElems; i++) 594 result.val.intV[i] = rnd.getInt(-10, 10); 595 } 596 else if (glu::isDataTypeBoolOrBVec(type)) 597 { 598 for (int i = 0; i < numElems; i++) 599 result.val.boolV[i] = rnd.getBool(); 600 } 601 else if (glu::isDataTypeSampler(type)) 602 { 603 result.val.samplerV.unit = samplerUnit; 604 605 for (int i = 0; i < 4; i++) 606 result.val.samplerV.fillColor[i] = rnd.getFloat(0.0f, 1.0f); 607 } 608 else 609 DE_ASSERT(false); 610 611 return result; 612 } 613 614 static VarValue generateZeroVarValue (const glu::DataType type) 615 { 616 const int numElems = glu::getDataTypeScalarSize(type); 617 VarValue result; 618 result.type = type; 619 620 if (glu::isDataTypeFloatOrVec(type) || glu::isDataTypeMatrix(type)) 621 { 622 for (int i = 0; i < numElems; i++) 623 result.val.floatV[i] = 0.0f; 624 } 625 else if (glu::isDataTypeIntOrIVec(type)) 626 { 627 for (int i = 0; i < numElems; i++) 628 result.val.intV[i] = 0; 629 } 630 else if (glu::isDataTypeBoolOrBVec(type)) 631 { 632 for (int i = 0; i < numElems; i++) 633 result.val.boolV[i] = false; 634 } 635 else if (glu::isDataTypeSampler(type)) 636 { 637 result.val.samplerV.unit = 0; 638 639 for (int i = 0; i < 4; i++) 640 result.val.samplerV.fillColor[i] = 0.12f * (float)i; 641 } 642 else 643 DE_ASSERT(false); 644 645 return result; 646 } 647 648 static bool apiVarValueEquals (const VarValue& a, const VarValue& b) 649 { 650 const int size = glu::getDataTypeScalarSize(a.type); 651 const float floatThreshold = 0.05f; 652 653 DE_ASSERT(a.type == b.type); 654 655 if (glu::isDataTypeFloatOrVec(a.type) || glu::isDataTypeMatrix(a.type)) 656 { 657 for (int i = 0; i < size; i++) 658 if (de::abs(a.val.floatV[i] - b.val.floatV[i]) >= floatThreshold) 659 return false; 660 } 661 else if (glu::isDataTypeIntOrIVec(a.type)) 662 { 663 for (int i = 0; i < size; i++) 664 if (a.val.intV[i] != b.val.intV[i]) 665 return false; 666 } 667 else if (glu::isDataTypeBoolOrBVec(a.type)) 668 { 669 for (int i = 0; i < size; i++) 670 if (a.val.boolV[i] != b.val.boolV[i]) 671 return false; 672 } 673 else if (glu::isDataTypeSampler(a.type)) 674 { 675 if (a.val.samplerV.unit != b.val.samplerV.unit) 676 return false; 677 } 678 else 679 DE_ASSERT(false); 680 681 return true; 682 } 683 684 static VarValue getRandomBoolRepresentation (const VarValue& boolValue, const glu::DataType targetScalarType, Random& rnd) 685 { 686 DE_ASSERT(glu::isDataTypeBoolOrBVec(boolValue.type)); 687 688 const int size = glu::getDataTypeScalarSize(boolValue.type); 689 const glu::DataType targetType = size == 1 ? targetScalarType : glu::getDataTypeVector(targetScalarType, size); 690 VarValue result; 691 result.type = targetType; 692 693 switch (targetScalarType) 694 { 695 case glu::TYPE_INT: 696 for (int i = 0; i < size; i++) 697 { 698 if (boolValue.val.boolV[i]) 699 { 700 result.val.intV[i] = rnd.getInt(-10, 10); 701 if (result.val.intV[i] == 0) 702 result.val.intV[i] = 1; 703 } 704 else 705 result.val.intV[i] = 0; 706 } 707 break; 708 709 case glu::TYPE_FLOAT: 710 for (int i = 0; i < size; i++) 711 { 712 if (boolValue.val.boolV[i]) 713 { 714 result.val.floatV[i] = rnd.getFloat(-10.0f, 10.0f); 715 if (result.val.floatV[i] == 0.0f) 716 result.val.floatV[i] = 1.0f; 717 } 718 else 719 result.val.floatV[i] = 0; 720 } 721 break; 722 723 default: 724 DE_ASSERT(false); 725 } 726 727 return result; 728 } 729 730 static const char* getCaseShaderTypeName (const CaseShaderType type) 731 { 732 switch (type) 733 { 734 case CASESHADERTYPE_VERTEX: return "vertex"; 735 case CASESHADERTYPE_FRAGMENT: return "fragment"; 736 case CASESHADERTYPE_BOTH: return "both"; 737 default: 738 DE_ASSERT(false); 739 return DE_NULL; 740 } 741 } 742 743 static CaseShaderType randomCaseShaderType (const deUint32 seed) 744 { 745 return (CaseShaderType)Random(seed).getInt(0, CASESHADERTYPE_LAST-1); 746 } 747 748 class UniformCase : public TestCase, protected glu::CallLogWrapper 749 { 750 public: 751 enum Feature 752 { 753 // ARRAYUSAGE_ONLY_MIDDLE_INDEX: only middle index of each array is used in shader. If not given, use all indices. 754 FEATURE_ARRAYUSAGE_ONLY_MIDDLE_INDEX = 1<<0, 755 756 // UNIFORMFUNC_VALUE: use pass-by-value versions of uniform assignment funcs, e.g. glUniform1f(), where possible. If not given, use pass-by-pointer versions. 757 FEATURE_UNIFORMFUNC_VALUE = 1<<1, 758 759 // ARRAYASSIGN: how basic-type arrays are assigned with glUniform*(). If none given, assign each element of an array separately. 760 FEATURE_ARRAYASSIGN_FULL = 1<<2, //!< Assign all elements of an array with one glUniform*(). 761 FEATURE_ARRAYASSIGN_BLOCKS_OF_TWO = 1<<3, //!< Assign two elements per one glUniform*(). 762 763 // UNIFORMUSAGE_EVERY_OTHER: use about half of the uniforms. If not given, use all uniforms (except that some array indices may be omitted according to ARRAYUSAGE). 764 FEATURE_UNIFORMUSAGE_EVERY_OTHER = 1<<4, 765 766 // BOOLEANAPITYPE: type used to pass booleans to and from GL api. If none given, use float. 767 FEATURE_BOOLEANAPITYPE_INT = 1<<5, 768 769 // UNIFORMVALUE_ZERO: use zero-valued uniforms. If not given, use random uniform values. 770 FEATURE_UNIFORMVALUE_ZERO = 1<<6, 771 772 // ARRAY_FIRST_ELEM_NAME_NO_INDEX: in certain API functions, when referring to the first element of an array, use just the array name without [0] at the end. 773 FEATURE_ARRAY_FIRST_ELEM_NAME_NO_INDEX = 1<<7 774 }; 775 776 UniformCase (Context& context, const char* name, const char* description, CaseShaderType caseType, const SharedPtr<const UniformCollection>& uniformCollection); 777 UniformCase (Context& context, const char* name, const char* description, CaseShaderType caseType, const SharedPtr<const UniformCollection>& uniformCollection, deUint32 features); 778 UniformCase (Context& context, const char* name, const char* description, deUint32 seed); // \note Randomizes caseType, uniformCollection and features. 779 virtual ~UniformCase (void); 780 781 virtual void init (void); 782 virtual void deinit (void); 783 784 IterateResult iterate (void); 785 786 protected: 787 // A basic uniform is a uniform (possibly struct or array member) whose type is a basic type (e.g. float, ivec4, sampler2d). 788 struct BasicUniform 789 { 790 string name; 791 glu::DataType type; 792 bool isUsedInShader; 793 VarValue finalValue; //!< The value we ultimately want to set for this uniform. 794 795 string rootName; //!< If this is a member of a basic-typed array, rootName is the name of that array with "[0]" appended. Otherwise it equals name. 796 int elemNdx; //!< If this is a member of a basic-typed array, elemNdx is the index in that array. Otherwise -1. 797 int rootSize; //!< If this is a member of a basic-typed array, rootSize is the size of that array. Otherwise 1. 798 799 BasicUniform (const char* const name_, 800 const glu::DataType type_, 801 const bool isUsedInShader_, 802 const VarValue& finalValue_, 803 const char* const rootName_ = DE_NULL, 804 const int elemNdx_ = -1, 805 const int rootSize_ = 1) 806 : name (name_) 807 , type (type_) 808 , isUsedInShader (isUsedInShader_) 809 , finalValue (finalValue_) 810 , rootName (rootName_ == DE_NULL ? name_ : rootName_) 811 , elemNdx (elemNdx_) 812 , rootSize (rootSize_) 813 { 814 } 815 816 static vector<BasicUniform>::const_iterator findWithName (const vector<BasicUniform>& vec, const char* const name) 817 { 818 for (vector<BasicUniform>::const_iterator it = vec.begin(); it != vec.end(); it++) 819 { 820 if (it->name == name) 821 return it; 822 } 823 return vec.end(); 824 } 825 }; 826 827 // Reference values for info that is expected to be reported by glGetActiveUniform(). 828 struct BasicUniformReportRef 829 { 830 string name; 831 // \note minSize and maxSize are for arrays and can be distinct since implementations are allowed, but not required, to trim the inactive end indices of arrays. 832 int minSize; 833 int maxSize; 834 glu::DataType type; 835 bool isUsedInShader; 836 837 BasicUniformReportRef (const char* const name_, const int minS, const int maxS, const glu::DataType type_, const bool used) 838 : name(name_), minSize(minS), maxSize(maxS), type(type_), isUsedInShader(used) { DE_ASSERT(minSize <= maxSize); } 839 BasicUniformReportRef (const char* const name_, const glu::DataType type_, const bool used) 840 : name(name_), minSize(1), maxSize(1), type(type_), isUsedInShader(used) {} 841 }; 842 843 // Info that is actually reported by glGetActiveUniform(). 844 struct BasicUniformReportGL 845 { 846 string name; 847 int nameLength; 848 int size; 849 glu::DataType type; 850 851 int index; 852 853 BasicUniformReportGL (const char* const name_, const int nameLength_, const int size_, const glu::DataType type_, const int index_) 854 : name(name_), nameLength(nameLength_), size(size_), type(type_), index(index_) {} 855 856 static vector<BasicUniformReportGL>::const_iterator findWithName (const vector<BasicUniformReportGL>& vec, const char* const name) 857 { 858 for (vector<BasicUniformReportGL>::const_iterator it = vec.begin(); it != vec.end(); it++) 859 { 860 if (it->name == name) 861 return it; 862 } 863 return vec.end(); 864 } 865 }; 866 867 // Query info with glGetActiveUniform() and check validity. 868 bool getActiveUniforms (vector<BasicUniformReportGL>& dst, const vector<BasicUniformReportRef>& ref, deUint32 programGL); 869 // Get uniform values with glGetUniform*() and put to valuesDst. Uniforms that get -1 from glGetUniformLocation() get glu::TYPE_INVALID. 870 bool getUniforms (vector<VarValue>& valuesDst, const vector<BasicUniform>& basicUniforms, deUint32 programGL); 871 // Check that every uniform has the default (zero) value. 872 bool checkUniformDefaultValues (const vector<VarValue>& values, const vector<BasicUniform>& basicUniforms); 873 // Assign the basicUniforms[].finalValue values for uniforms. \note rnd parameter is for booleans (true can be any nonzero value). 874 void assignUniforms (const vector<BasicUniform>& basicUniforms, deUint32 programGL, Random& rnd); 875 // Compare the uniform values given in values (obtained with glGetUniform*()) with the basicUniform.finalValue values. 876 bool compareUniformValues (const vector<VarValue>& values, const vector<BasicUniform>& basicUniforms); 877 // Render and check that all pixels are white (i.e. all uniform comparisons passed). 878 bool renderTest (const vector<BasicUniform>& basicUniforms, const ShaderProgram& program, Random& rnd); 879 880 virtual bool test (const vector<BasicUniform>& basicUniforms, const vector<BasicUniformReportRef>& basicUniformReportsRef, const ShaderProgram& program, Random& rnd) = 0; 881 882 const deUint32 m_features; 883 const SharedPtr<const UniformCollection> m_uniformCollection; 884 885 private: 886 static deUint32 randomFeatures (deUint32 seed); 887 888 // Generates the basic uniforms, based on the uniform with name varName and type varType, in the same manner as are expected 889 // to be returned by glGetActiveUniform(), e.g. generates a name like var[0] for arrays, and recursively generates struct member names. 890 void generateBasicUniforms (vector<BasicUniform>& basicUniformsDst, 891 vector<BasicUniformReportRef>& basicUniformReportsDst, 892 const glu::VarType& varType, 893 const char* varName, 894 bool isParentActive, 895 int& samplerUnitCounter, 896 Random& rnd) const; 897 898 void writeUniformDefinitions (std::ostringstream& dst) const; 899 void writeUniformCompareExpr (std::ostringstream& dst, const BasicUniform& uniform) const; 900 void writeUniformComparisons (std::ostringstream& dst, const vector<BasicUniform>& basicUniforms, const char* variableName) const; 901 902 string generateVertexSource (const vector<BasicUniform>& basicUniforms) const; 903 string generateFragmentSource (const vector<BasicUniform>& basicUniforms) const; 904 905 void setupTexture (const VarValue& value); 906 907 const CaseShaderType m_caseShaderType; 908 909 vector<glu::Texture2D*> m_textures2d; 910 vector<glu::TextureCube*> m_texturesCube; 911 vector<deUint32> m_filledTextureUnits; 912 }; 913 914 deUint32 UniformCase::randomFeatures (const deUint32 seed) 915 { 916 static const deUint32 arrayUsageChoices[] = { 0, FEATURE_ARRAYUSAGE_ONLY_MIDDLE_INDEX }; 917 static const deUint32 uniformFuncChoices[] = { 0, FEATURE_UNIFORMFUNC_VALUE }; 918 static const deUint32 arrayAssignChoices[] = { 0, FEATURE_ARRAYASSIGN_FULL, FEATURE_ARRAYASSIGN_BLOCKS_OF_TWO }; 919 static const deUint32 uniformUsageChoices[] = { 0, FEATURE_UNIFORMUSAGE_EVERY_OTHER }; 920 static const deUint32 booleanApiTypeChoices[] = { 0, FEATURE_BOOLEANAPITYPE_INT }; 921 static const deUint32 uniformValueChoices[] = { 0, FEATURE_UNIFORMVALUE_ZERO }; 922 923 Random rnd(seed); 924 925 deUint32 result = 0; 926 927 #define ARRAY_CHOICE(ARR) (ARR[rnd.getInt(0, DE_LENGTH_OF_ARRAY(ARR)-1)]) 928 929 result |= ARRAY_CHOICE(arrayUsageChoices); 930 result |= ARRAY_CHOICE(uniformFuncChoices); 931 result |= ARRAY_CHOICE(arrayAssignChoices); 932 result |= ARRAY_CHOICE(uniformUsageChoices); 933 result |= ARRAY_CHOICE(booleanApiTypeChoices); 934 result |= ARRAY_CHOICE(uniformValueChoices); 935 936 #undef ARRAY_CHOICE 937 938 return result; 939 } 940 941 UniformCase::UniformCase (Context& context, const char* const name, const char* const description, const CaseShaderType caseShaderType, const SharedPtr<const UniformCollection>& uniformCollection, const deUint32 features) 942 : TestCase (context, name, description) 943 , CallLogWrapper (context.getRenderContext().getFunctions(), m_testCtx.getLog()) 944 , m_features (features) 945 , m_uniformCollection (uniformCollection) 946 , m_caseShaderType (caseShaderType) 947 { 948 } 949 950 UniformCase::UniformCase (Context& context, const char* const name, const char* const description, const CaseShaderType caseShaderType, const SharedPtr<const UniformCollection>& uniformCollection) 951 : TestCase (context, name, description) 952 , CallLogWrapper (context.getRenderContext().getFunctions(), m_testCtx.getLog()) 953 , m_features (0) 954 , m_uniformCollection (uniformCollection) 955 , m_caseShaderType (caseShaderType) 956 { 957 } 958 959 UniformCase::UniformCase (Context& context, const char* name, const char* description, const deUint32 seed) 960 : TestCase (context, name, description) 961 , CallLogWrapper (context.getRenderContext().getFunctions(), m_testCtx.getLog()) 962 , m_features (randomFeatures(seed)) 963 , m_uniformCollection (UniformCollection::random(seed)) 964 , m_caseShaderType (randomCaseShaderType(seed)) 965 { 966 } 967 968 void UniformCase::init (void) 969 { 970 { 971 const glw::Functions& funcs = m_context.getRenderContext().getFunctions(); 972 const int numSamplerUniforms = m_uniformCollection->getNumSamplers(); 973 const int vertexTexUnitsRequired = m_caseShaderType != CASESHADERTYPE_FRAGMENT ? numSamplerUniforms : 0; 974 const int fragmentTexUnitsRequired = m_caseShaderType != CASESHADERTYPE_VERTEX ? numSamplerUniforms : 0; 975 const int combinedTexUnitsRequired = vertexTexUnitsRequired + fragmentTexUnitsRequired; 976 const int vertexTexUnitsSupported = getGLInt(funcs, GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS); 977 const int fragmentTexUnitsSupported = getGLInt(funcs, GL_MAX_TEXTURE_IMAGE_UNITS); 978 const int combinedTexUnitsSupported = getGLInt(funcs, GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS); 979 980 DE_ASSERT(numSamplerUniforms <= MAX_NUM_SAMPLER_UNIFORMS); 981 982 if (vertexTexUnitsRequired > vertexTexUnitsSupported) 983 throw tcu::NotSupportedError(de::toString(vertexTexUnitsRequired) + " vertex texture units required, " + de::toString(vertexTexUnitsSupported) + " supported"); 984 if (fragmentTexUnitsRequired > fragmentTexUnitsSupported) 985 throw tcu::NotSupportedError(de::toString(fragmentTexUnitsRequired) + " fragment texture units required, " + de::toString(fragmentTexUnitsSupported) + " supported"); 986 if (combinedTexUnitsRequired > combinedTexUnitsSupported) 987 throw tcu::NotSupportedError(de::toString(combinedTexUnitsRequired) + " combined texture units required, " + de::toString(combinedTexUnitsSupported) + " supported"); 988 } 989 990 enableLogging(true); 991 } 992 993 void UniformCase::deinit (void) 994 { 995 for (int i = 0; i < (int)m_textures2d.size(); i++) 996 delete m_textures2d[i]; 997 m_textures2d.clear(); 998 999 for (int i = 0; i < (int)m_texturesCube.size(); i++) 1000 delete m_texturesCube[i]; 1001 m_texturesCube.clear(); 1002 1003 m_filledTextureUnits.clear(); 1004 } 1005 1006 UniformCase::~UniformCase (void) 1007 { 1008 UniformCase::deinit(); 1009 } 1010 1011 void UniformCase::generateBasicUniforms (vector<BasicUniform>& basicUniformsDst, vector<BasicUniformReportRef>& basicUniformReportsDst, const glu::VarType& varType, const char* const varName, const bool isParentActive, int& samplerUnitCounter, Random& rnd) const 1012 { 1013 if (varType.isBasicType()) 1014 { 1015 const bool isActive = isParentActive && (m_features & FEATURE_UNIFORMUSAGE_EVERY_OTHER ? basicUniformsDst.size() % 2 == 0 : true); 1016 const glu::DataType type = varType.getBasicType(); 1017 const VarValue value = m_features & FEATURE_UNIFORMVALUE_ZERO ? generateZeroVarValue(type) 1018 : glu::isDataTypeSampler(type) ? generateRandomVarValue(type, rnd, samplerUnitCounter++) 1019 : generateRandomVarValue(varType.getBasicType(), rnd); 1020 1021 basicUniformsDst.push_back(BasicUniform(varName, varType.getBasicType(), isActive, value)); 1022 basicUniformReportsDst.push_back(BasicUniformReportRef(varName, varType.getBasicType(), isActive)); 1023 } 1024 else if (varType.isArrayType()) 1025 { 1026 const int size = varType.getArraySize(); 1027 const string arrayRootName = string("") + varName + "[0]"; 1028 vector<bool> isElemActive; 1029 1030 for (int elemNdx = 0; elemNdx < varType.getArraySize(); elemNdx++) 1031 { 1032 const string indexedName = string("") + varName + "[" + de::toString(elemNdx) + "]"; 1033 const bool isCurElemActive = isParentActive && 1034 (m_features & FEATURE_UNIFORMUSAGE_EVERY_OTHER ? basicUniformsDst.size() % 2 == 0 : true) && 1035 (m_features & FEATURE_ARRAYUSAGE_ONLY_MIDDLE_INDEX ? elemNdx == size/2 : true); 1036 1037 isElemActive.push_back(isCurElemActive); 1038 1039 if (varType.getElementType().isBasicType()) 1040 { 1041 // \note We don't want separate entries in basicUniformReportsDst for elements of basic-type arrays. 1042 const glu::DataType elemBasicType = varType.getElementType().getBasicType(); 1043 const VarValue value = m_features & FEATURE_UNIFORMVALUE_ZERO ? generateZeroVarValue(elemBasicType) 1044 : glu::isDataTypeSampler(elemBasicType) ? generateRandomVarValue(elemBasicType, rnd, samplerUnitCounter++) 1045 : generateRandomVarValue(elemBasicType, rnd); 1046 1047 basicUniformsDst.push_back(BasicUniform(indexedName.c_str(), elemBasicType, isCurElemActive, value, arrayRootName.c_str(), elemNdx, size)); 1048 } 1049 else 1050 generateBasicUniforms(basicUniformsDst, basicUniformReportsDst, varType.getElementType(), indexedName.c_str(), isCurElemActive, samplerUnitCounter, rnd); 1051 } 1052 1053 if (varType.getElementType().isBasicType()) 1054 { 1055 int minSize; 1056 for (minSize = varType.getArraySize(); minSize > 0 && !isElemActive[minSize-1]; minSize--); 1057 1058 basicUniformReportsDst.push_back(BasicUniformReportRef(arrayRootName.c_str(), minSize, size, varType.getElementType().getBasicType(), isParentActive && minSize > 0)); 1059 } 1060 } 1061 else 1062 { 1063 DE_ASSERT(varType.isStructType()); 1064 1065 const StructType& structType = *varType.getStructPtr(); 1066 1067 for (int i = 0; i < structType.getNumMembers(); i++) 1068 { 1069 const glu::StructMember& member = structType.getMember(i); 1070 const string memberFullName = string("") + varName + "." + member.getName(); 1071 1072 generateBasicUniforms(basicUniformsDst, basicUniformReportsDst, member.getType(), memberFullName.c_str(), isParentActive, samplerUnitCounter, rnd); 1073 } 1074 } 1075 } 1076 1077 void UniformCase::writeUniformDefinitions (std::ostringstream& dst) const 1078 { 1079 for (int i = 0; i < (int)m_uniformCollection->getNumStructTypes(); i++) 1080 dst << glu::declare(m_uniformCollection->getStructType(i)) << ";\n"; 1081 1082 for (int i = 0; i < (int)m_uniformCollection->getNumUniforms(); i++) 1083 dst << "uniform " << glu::declare(m_uniformCollection->getUniform(i).type, m_uniformCollection->getUniform(i).name.c_str()) << ";\n"; 1084 1085 dst << "\n"; 1086 1087 { 1088 static const struct 1089 { 1090 dataTypePredicate requiringTypes[2]; 1091 const char* definition; 1092 } compareFuncs[] = 1093 { 1094 { { glu::isDataTypeFloatOrVec, glu::isDataTypeMatrix }, "mediump float compare_float (mediump float a, mediump float b) { return abs(a - b) < 0.05 ? 1.0 : 0.0; }" }, 1095 { { dataTypeEquals<glu::TYPE_FLOAT_VEC2>, dataTypeIsMatrixWithNRows<2> }, "mediump float compare_vec2 (mediump vec2 a, mediump vec2 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y); }" }, 1096 { { dataTypeEquals<glu::TYPE_FLOAT_VEC3>, dataTypeIsMatrixWithNRows<3> }, "mediump float compare_vec3 (mediump vec3 a, mediump vec3 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y)*compare_float(a.z, b.z); }" }, 1097 { { dataTypeEquals<glu::TYPE_FLOAT_VEC4>, dataTypeIsMatrixWithNRows<4> }, "mediump float compare_vec4 (mediump vec4 a, mediump vec4 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y)*compare_float(a.z, b.z)*compare_float(a.w, b.w); }" }, 1098 { { dataTypeEquals<glu::TYPE_FLOAT_MAT2>, dataTypeEquals<glu::TYPE_INVALID> }, "mediump float compare_mat2 (mediump mat2 a, mediump mat2 b) { return compare_vec2(a[0], b[0])*compare_vec2(a[1], b[1]); }" }, 1099 { { dataTypeEquals<glu::TYPE_FLOAT_MAT3>, dataTypeEquals<glu::TYPE_INVALID> }, "mediump float compare_mat3 (mediump mat3 a, mediump mat3 b) { return compare_vec3(a[0], b[0])*compare_vec3(a[1], b[1])*compare_vec3(a[2], b[2]); }" }, 1100 { { dataTypeEquals<glu::TYPE_FLOAT_MAT4>, dataTypeEquals<glu::TYPE_INVALID> }, "mediump float compare_mat4 (mediump mat4 a, mediump mat4 b) { return compare_vec4(a[0], b[0])*compare_vec4(a[1], b[1])*compare_vec4(a[2], b[2])*compare_vec4(a[3], b[3]); }" }, 1101 { { dataTypeEquals<glu::TYPE_INT>, dataTypeEquals<glu::TYPE_INVALID> }, "mediump float compare_int (mediump int a, mediump int b) { return a == b ? 1.0 : 0.0; }" }, 1102 { { dataTypeEquals<glu::TYPE_INT_VEC2>, dataTypeEquals<glu::TYPE_INVALID> }, "mediump float compare_ivec2 (mediump ivec2 a, mediump ivec2 b) { return a == b ? 1.0 : 0.0; }" }, 1103 { { dataTypeEquals<glu::TYPE_INT_VEC3>, dataTypeEquals<glu::TYPE_INVALID> }, "mediump float compare_ivec3 (mediump ivec3 a, mediump ivec3 b) { return a == b ? 1.0 : 0.0; }" }, 1104 { { dataTypeEquals<glu::TYPE_INT_VEC4>, dataTypeEquals<glu::TYPE_INVALID> }, "mediump float compare_ivec4 (mediump ivec4 a, mediump ivec4 b) { return a == b ? 1.0 : 0.0; }" }, 1105 { { dataTypeEquals<glu::TYPE_BOOL>, dataTypeEquals<glu::TYPE_INVALID> }, "mediump float compare_bool (bool a, bool b) { return a == b ? 1.0 : 0.0; }" }, 1106 { { dataTypeEquals<glu::TYPE_BOOL_VEC2>, dataTypeEquals<glu::TYPE_INVALID> }, "mediump float compare_bvec2 (bvec2 a, bvec2 b) { return a == b ? 1.0 : 0.0; }" }, 1107 { { dataTypeEquals<glu::TYPE_BOOL_VEC3>, dataTypeEquals<glu::TYPE_INVALID> }, "mediump float compare_bvec3 (bvec3 a, bvec3 b) { return a == b ? 1.0 : 0.0; }" }, 1108 { { dataTypeEquals<glu::TYPE_BOOL_VEC4>, dataTypeEquals<glu::TYPE_INVALID> }, "mediump float compare_bvec4 (bvec4 a, bvec4 b) { return a == b ? 1.0 : 0.0; }" } 1109 }; 1110 1111 const bool containsSamplers = !m_uniformCollection->getSamplerTypes().empty(); 1112 1113 for (int compFuncNdx = 0; compFuncNdx < DE_LENGTH_OF_ARRAY(compareFuncs); compFuncNdx++) 1114 { 1115 const dataTypePredicate (&typeReq)[2] = compareFuncs[compFuncNdx].requiringTypes; 1116 const bool containsTypeSampler = containsSamplers && (typeReq[0](glu::TYPE_FLOAT_VEC4) || typeReq[1](glu::TYPE_FLOAT_VEC4)); 1117 1118 if (containsTypeSampler || m_uniformCollection->containsMatchingBasicType(typeReq[0]) || m_uniformCollection->containsMatchingBasicType(typeReq[1])) 1119 dst << compareFuncs[compFuncNdx].definition << "\n"; 1120 } 1121 } 1122 } 1123 1124 void UniformCase::writeUniformCompareExpr (std::ostringstream& dst, const BasicUniform& uniform) const 1125 { 1126 if (glu::isDataTypeSampler(uniform.type)) 1127 { 1128 dst << "compare_vec4(" 1129 << (uniform.type == glu::TYPE_SAMPLER_2D ? "texture2D" : "textureCube") 1130 << "(" << uniform.name << ", vec" << getSamplerNumLookupDimensions(uniform.type) << "(0.0))"; 1131 } 1132 else 1133 dst << "compare_" << glu::getDataTypeName(uniform.type) << "(" << uniform.name; 1134 1135 dst << ", " << shaderVarValueStr(uniform.finalValue) << ")"; 1136 } 1137 1138 void UniformCase::writeUniformComparisons (std::ostringstream& dst, const vector<BasicUniform>& basicUniforms, const char* const variableName) const 1139 { 1140 for (int i = 0; i < (int)basicUniforms.size(); i++) 1141 { 1142 const BasicUniform& unif = basicUniforms[i]; 1143 1144 if (unif.isUsedInShader) 1145 { 1146 dst << "\t" << variableName << " *= "; 1147 writeUniformCompareExpr(dst, basicUniforms[i]); 1148 dst << ";\n"; 1149 } 1150 else 1151 dst << "\t// UNUSED: " << basicUniforms[i].name << "\n"; 1152 } 1153 } 1154 1155 string UniformCase::generateVertexSource (const vector<BasicUniform>& basicUniforms) const 1156 { 1157 const bool isVertexCase = m_caseShaderType == CASESHADERTYPE_VERTEX || m_caseShaderType == CASESHADERTYPE_BOTH; 1158 std::ostringstream result; 1159 1160 result << "attribute highp vec4 a_position;\n" 1161 "varying mediump float v_vtxOut;\n" 1162 "\n"; 1163 1164 if (isVertexCase) 1165 writeUniformDefinitions(result); 1166 1167 result << "\n" 1168 "void main (void)\n" 1169 "{\n" 1170 " gl_Position = a_position;\n" 1171 " v_vtxOut = 1.0;\n"; 1172 1173 if (isVertexCase) 1174 writeUniformComparisons(result, basicUniforms, "v_vtxOut"); 1175 1176 result << "}\n"; 1177 1178 return result.str(); 1179 } 1180 1181 string UniformCase::generateFragmentSource (const vector<BasicUniform>& basicUniforms) const 1182 { 1183 const bool isFragmentCase = m_caseShaderType == CASESHADERTYPE_FRAGMENT || m_caseShaderType == CASESHADERTYPE_BOTH; 1184 std::ostringstream result; 1185 1186 result << "varying mediump float v_vtxOut;\n" 1187 "\n"; 1188 1189 if (isFragmentCase) 1190 writeUniformDefinitions(result); 1191 1192 result << "\n" 1193 "void main (void)\n" 1194 "{\n" 1195 " mediump float result = v_vtxOut;\n"; 1196 1197 if (isFragmentCase) 1198 writeUniformComparisons(result, basicUniforms, "result"); 1199 1200 result << " gl_FragColor = vec4(result, result, result, 1.0);\n" 1201 "}\n"; 1202 1203 return result.str(); 1204 } 1205 1206 void UniformCase::setupTexture (const VarValue& value) 1207 { 1208 enableLogging(false); 1209 1210 const int width = 32; 1211 const int height = 32; 1212 const tcu::Vec4 color = vec4FromPtr(&value.val.samplerV.fillColor[0]); 1213 1214 if (value.type == glu::TYPE_SAMPLER_2D) 1215 { 1216 glu::Texture2D* texture = new glu::Texture2D(m_context.getRenderContext(), GL_RGBA, GL_UNSIGNED_BYTE, width, height); 1217 tcu::Texture2D& refTexture = texture->getRefTexture(); 1218 m_textures2d.push_back(texture); 1219 1220 refTexture.allocLevel(0); 1221 fillWithColor(refTexture.getLevel(0), color); 1222 1223 GLU_CHECK_CALL(glActiveTexture(GL_TEXTURE0 + value.val.samplerV.unit)); 1224 m_filledTextureUnits.push_back(value.val.samplerV.unit); 1225 texture->upload(); 1226 GLU_CHECK_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); 1227 GLU_CHECK_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); 1228 GLU_CHECK_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)); 1229 GLU_CHECK_CALL(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)); 1230 } 1231 else if (value.type == glu::TYPE_SAMPLER_CUBE) 1232 { 1233 DE_ASSERT(width == height); 1234 1235 glu::TextureCube* texture = new glu::TextureCube(m_context.getRenderContext(), GL_RGBA, GL_UNSIGNED_BYTE, width); 1236 tcu::TextureCube& refTexture = texture->getRefTexture(); 1237 m_texturesCube.push_back(texture); 1238 1239 for (int face = 0; face < (int)tcu::CUBEFACE_LAST; face++) 1240 { 1241 refTexture.allocLevel((tcu::CubeFace)face, 0); 1242 fillWithColor(refTexture.getLevelFace(0, (tcu::CubeFace)face), color); 1243 } 1244 1245 GLU_CHECK_CALL(glActiveTexture(GL_TEXTURE0 + value.val.samplerV.unit)); 1246 m_filledTextureUnits.push_back(value.val.samplerV.unit); 1247 texture->upload(); 1248 1249 GLU_CHECK_CALL(glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)); 1250 GLU_CHECK_CALL(glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)); 1251 GLU_CHECK_CALL(glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST)); 1252 GLU_CHECK_CALL(glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST)); 1253 1254 } 1255 else 1256 DE_ASSERT(false); 1257 1258 enableLogging(true); 1259 } 1260 1261 bool UniformCase::getActiveUniforms (vector<BasicUniformReportGL>& basicUniformReportsDst, const vector<BasicUniformReportRef>& basicUniformReportsRef, const deUint32 programGL) 1262 { 1263 TestLog& log = m_testCtx.getLog(); 1264 GLint numActiveUniforms = 0; 1265 GLint uniformMaxNameLength = 0; 1266 vector<char> nameBuffer; 1267 bool success = true; 1268 1269 GLU_CHECK_CALL(glGetProgramiv(programGL, GL_ACTIVE_UNIFORMS, &numActiveUniforms)); 1270 log << TestLog::Message << "// Number of active uniforms reported: " << numActiveUniforms << TestLog::EndMessage; 1271 GLU_CHECK_CALL(glGetProgramiv(programGL, GL_ACTIVE_UNIFORM_MAX_LENGTH, &uniformMaxNameLength)); 1272 log << TestLog::Message << "// Maximum uniform name length reported: " << uniformMaxNameLength << TestLog::EndMessage; 1273 nameBuffer.resize(uniformMaxNameLength); 1274 1275 for (int unifNdx = 0; unifNdx < numActiveUniforms; unifNdx++) 1276 { 1277 GLsizei reportedNameLength = 0; 1278 GLint reportedSize = -1; 1279 GLenum reportedTypeGL = GL_NONE; 1280 1281 GLU_CHECK_CALL(glGetActiveUniform(programGL, (GLuint)unifNdx, (GLsizei)uniformMaxNameLength, &reportedNameLength, &reportedSize, &reportedTypeGL, &nameBuffer[0])); 1282 1283 const glu::DataType reportedType = glu::getDataTypeFromGLType(reportedTypeGL); 1284 const string reportedNameStr (&nameBuffer[0]); 1285 1286 TCU_CHECK_MSG(reportedType != glu::TYPE_LAST, "Invalid uniform type"); 1287 1288 log << TestLog::Message << "// Got name = " << reportedNameStr << ", name length = " << reportedNameLength << ", size = " << reportedSize << ", type = " << glu::getDataTypeName(reportedType) << TestLog::EndMessage; 1289 1290 if ((GLsizei)reportedNameStr.length() != reportedNameLength) 1291 { 1292 log << TestLog::Message << "// FAILURE: wrong name length reported, should be " << reportedNameStr.length() << TestLog::EndMessage; 1293 success = false; 1294 } 1295 1296 if (!deStringBeginsWith(reportedNameStr.c_str(), "gl_")) // Ignore built-in uniforms. 1297 { 1298 int referenceNdx; 1299 for (referenceNdx = 0; referenceNdx < (int)basicUniformReportsRef.size(); referenceNdx++) 1300 { 1301 if (basicUniformReportsRef[referenceNdx].name == reportedNameStr) 1302 break; 1303 } 1304 1305 if (referenceNdx >= (int)basicUniformReportsRef.size()) 1306 { 1307 log << TestLog::Message << "// FAILURE: invalid non-built-in uniform name reported" << TestLog::EndMessage; 1308 success = false; 1309 } 1310 else 1311 { 1312 const BasicUniformReportRef& reference = basicUniformReportsRef[referenceNdx]; 1313 1314 DE_ASSERT(reference.type != glu::TYPE_LAST); 1315 DE_ASSERT(reference.minSize >= 1 || (reference.minSize == 0 && !reference.isUsedInShader)); 1316 DE_ASSERT(reference.minSize <= reference.maxSize); 1317 1318 if (BasicUniformReportGL::findWithName(basicUniformReportsDst, reportedNameStr.c_str()) != basicUniformReportsDst.end()) 1319 { 1320 log << TestLog::Message << "// FAILURE: same uniform name reported twice" << TestLog::EndMessage; 1321 success = false; 1322 } 1323 1324 basicUniformReportsDst.push_back(BasicUniformReportGL(reportedNameStr.c_str(), reportedNameLength, reportedSize, reportedType, unifNdx)); 1325 1326 if (reportedType != reference.type) 1327 { 1328 log << TestLog::Message << "// FAILURE: wrong type reported, should be " << glu::getDataTypeName(reference.type) << TestLog::EndMessage; 1329 success = false; 1330 } 1331 if (reportedSize < reference.minSize || reportedSize > reference.maxSize) 1332 { 1333 log << TestLog::Message 1334 << "// FAILURE: wrong size reported, should be " 1335 << (reference.minSize == reference.maxSize ? de::toString(reference.minSize) : "in the range [" + de::toString(reference.minSize) + ", " + de::toString(reference.maxSize) + "]") 1336 << TestLog::EndMessage; 1337 1338 success = false; 1339 } 1340 } 1341 } 1342 } 1343 1344 for (int i = 0; i < (int)basicUniformReportsRef.size(); i++) 1345 { 1346 const BasicUniformReportRef& expected = basicUniformReportsRef[i]; 1347 if (expected.isUsedInShader && BasicUniformReportGL::findWithName(basicUniformReportsDst, expected.name.c_str()) == basicUniformReportsDst.end()) 1348 { 1349 log << TestLog::Message << "// FAILURE: uniform with name " << expected.name << " was not reported by GL" << TestLog::EndMessage; 1350 success = false; 1351 } 1352 } 1353 1354 return success; 1355 } 1356 1357 bool UniformCase::getUniforms (vector<VarValue>& valuesDst, const vector<BasicUniform>& basicUniforms, const deUint32 programGL) 1358 { 1359 TestLog& log = m_testCtx.getLog(); 1360 bool success = true; 1361 1362 for (int unifNdx = 0; unifNdx < (int)basicUniforms.size(); unifNdx++) 1363 { 1364 const BasicUniform& uniform = basicUniforms[unifNdx]; 1365 const string queryName = m_features & FEATURE_ARRAY_FIRST_ELEM_NAME_NO_INDEX && uniform.elemNdx == 0 ? beforeLast(uniform.name, '[') : uniform.name; 1366 const int location = glGetUniformLocation(programGL, queryName.c_str()); 1367 const int size = glu::getDataTypeScalarSize(uniform.type); 1368 VarValue value; 1369 1370 deMemset(&value, 0xcd, sizeof(value)); // Initialize to known garbage. 1371 1372 if (location == -1) 1373 { 1374 value.type = glu::TYPE_INVALID; 1375 valuesDst.push_back(value); 1376 if (uniform.isUsedInShader) 1377 { 1378 log << TestLog::Message << "// FAILURE: " << uniform.name << " was used in shader, but has location -1" << TestLog::EndMessage; 1379 success = false; 1380 } 1381 continue; 1382 } 1383 1384 value.type = uniform.type; 1385 1386 DE_STATIC_ASSERT(sizeof(GLint) == sizeof(value.val.intV[0])); 1387 DE_STATIC_ASSERT(sizeof(GLfloat) == sizeof(value.val.floatV[0])); 1388 1389 if (glu::isDataTypeFloatOrVec(uniform.type) || glu::isDataTypeMatrix(uniform.type)) 1390 GLU_CHECK_CALL(glGetUniformfv(programGL, location, &value.val.floatV[0])); 1391 else if (glu::isDataTypeIntOrIVec(uniform.type)) 1392 GLU_CHECK_CALL(glGetUniformiv(programGL, location, &value.val.intV[0])); 1393 else if (glu::isDataTypeBoolOrBVec(uniform.type)) 1394 { 1395 if (m_features & FEATURE_BOOLEANAPITYPE_INT) 1396 { 1397 GLU_CHECK_CALL(glGetUniformiv(programGL, location, &value.val.intV[0])); 1398 for (int i = 0; i < size; i++) 1399 value.val.boolV[i] = value.val.intV[i] != 0; 1400 } 1401 else // Default: use float. 1402 { 1403 GLU_CHECK_CALL(glGetUniformfv(programGL, location, &value.val.floatV[0])); 1404 for (int i = 0; i < size; i++) 1405 value.val.boolV[i] = value.val.floatV[i] != 0.0f; 1406 } 1407 } 1408 else if (glu::isDataTypeSampler(uniform.type)) 1409 { 1410 GLint unit = -1; 1411 GLU_CHECK_CALL(glGetUniformiv(programGL, location, &unit)); 1412 value.val.samplerV.unit = unit; 1413 } 1414 else 1415 DE_ASSERT(false); 1416 1417 valuesDst.push_back(value); 1418 1419 log << TestLog::Message << "// Got " << uniform.name << " value " << apiVarValueStr(value) << TestLog::EndMessage; 1420 } 1421 1422 return success; 1423 } 1424 1425 bool UniformCase::checkUniformDefaultValues (const vector<VarValue>& values, const vector<BasicUniform>& basicUniforms) 1426 { 1427 TestLog& log = m_testCtx.getLog(); 1428 bool success = true; 1429 1430 DE_ASSERT(values.size() == basicUniforms.size()); 1431 1432 for (int unifNdx = 0; unifNdx < (int)basicUniforms.size(); unifNdx++) 1433 { 1434 const BasicUniform& uniform = basicUniforms[unifNdx]; 1435 const VarValue& unifValue = values[unifNdx]; 1436 const int valSize = glu::getDataTypeScalarSize(uniform.type); 1437 1438 log << TestLog::Message << "// Checking uniform " << uniform.name << TestLog::EndMessage; 1439 1440 if (unifValue.type == glu::TYPE_INVALID) // This happens when glGetUniformLocation() returned -1. 1441 continue; 1442 1443 #define CHECK_UNIFORM(VAR_VALUE_MEMBER, ZERO) \ 1444 do \ 1445 { \ 1446 for (int i = 0; i < valSize; i++) \ 1447 { \ 1448 if (unifValue.val.VAR_VALUE_MEMBER[i] != ZERO) \ 1449 { \ 1450 log << TestLog::Message << "// FAILURE: uniform " << uniform.name << " has non-zero initial value" << TestLog::EndMessage; \ 1451 success = false; \ 1452 } \ 1453 } \ 1454 } while (false) 1455 1456 if (glu::isDataTypeFloatOrVec(uniform.type) || glu::isDataTypeMatrix(uniform.type)) 1457 CHECK_UNIFORM(floatV, 0.0f); 1458 else if (glu::isDataTypeIntOrIVec(uniform.type)) 1459 CHECK_UNIFORM(intV, 0); 1460 else if (glu::isDataTypeBoolOrBVec(uniform.type)) 1461 CHECK_UNIFORM(boolV, false); 1462 else if (glu::isDataTypeSampler(uniform.type)) 1463 { 1464 if (unifValue.val.samplerV.unit != 0) 1465 { 1466 log << TestLog::Message << "// FAILURE: uniform " << uniform.name << " has non-zero initial value" << TestLog::EndMessage; 1467 success = false; 1468 } 1469 } 1470 else 1471 DE_ASSERT(false); 1472 1473 #undef CHECK_UNIFORM 1474 } 1475 1476 return success; 1477 } 1478 1479 void UniformCase::assignUniforms (const vector<BasicUniform>& basicUniforms, deUint32 programGL, Random& rnd) 1480 { 1481 TestLog& log = m_testCtx.getLog(); 1482 const glu::DataType boolApiType = m_features & FEATURE_BOOLEANAPITYPE_INT ? glu::TYPE_INT 1483 : glu::TYPE_FLOAT; 1484 1485 for (int unifNdx = 0; unifNdx < (int)basicUniforms.size(); unifNdx++) 1486 { 1487 const BasicUniform& uniform = basicUniforms[unifNdx]; 1488 const bool isArrayMember = uniform.elemNdx >= 0; 1489 const string queryName = m_features & FEATURE_ARRAY_FIRST_ELEM_NAME_NO_INDEX && uniform.elemNdx == 0 ? beforeLast(uniform.name, '[') : uniform.name; 1490 const int numValuesToAssign = !isArrayMember ? 1 1491 : m_features & FEATURE_ARRAYASSIGN_FULL ? (uniform.elemNdx == 0 ? uniform.rootSize : 0) 1492 : m_features & FEATURE_ARRAYASSIGN_BLOCKS_OF_TWO ? (uniform.elemNdx % 2 == 0 ? 2 : 0) 1493 : /* Default: assign array elements separately */ 1; 1494 1495 DE_ASSERT(numValuesToAssign >= 0); 1496 DE_ASSERT(numValuesToAssign == 1 || isArrayMember); 1497 1498 if (numValuesToAssign == 0) 1499 { 1500 log << TestLog::Message << "// Uniform " << uniform.name << " is covered by another glUniform*v() call to the same array" << TestLog::EndMessage; 1501 continue; 1502 } 1503 1504 const int location = glGetUniformLocation(programGL, queryName.c_str()); 1505 const int typeSize = glu::getDataTypeScalarSize(uniform.type); 1506 const bool assignByValue = m_features & FEATURE_UNIFORMFUNC_VALUE && !glu::isDataTypeMatrix(uniform.type) && numValuesToAssign == 1; 1507 vector<VarValue> valuesToAssign; 1508 1509 for (int i = 0; i < numValuesToAssign; i++) 1510 { 1511 const string curName = isArrayMember ? beforeLast(uniform.rootName, '[') + "[" + de::toString(uniform.elemNdx+i) + "]" : uniform.name; 1512 VarValue unifValue; 1513 1514 if (isArrayMember) 1515 { 1516 const vector<BasicUniform>::const_iterator elemUnif = BasicUniform::findWithName(basicUniforms, curName.c_str()); 1517 if (elemUnif == basicUniforms.end()) 1518 continue; 1519 unifValue = elemUnif->finalValue; 1520 } 1521 else 1522 unifValue = uniform.finalValue; 1523 1524 const VarValue apiValue = glu::isDataTypeBoolOrBVec(unifValue.type) ? getRandomBoolRepresentation(unifValue, boolApiType, rnd) 1525 : glu::isDataTypeSampler(unifValue.type) ? getSamplerUnitValue(unifValue) 1526 : unifValue; 1527 1528 valuesToAssign.push_back(apiValue); 1529 1530 if (glu::isDataTypeBoolOrBVec(uniform.type)) 1531 log << TestLog::Message << "// Using type " << glu::getDataTypeName(boolApiType) << " to set boolean value " << apiVarValueStr(unifValue) << " for " << curName << TestLog::EndMessage; 1532 else if (glu::isDataTypeSampler(uniform.type)) 1533 log << TestLog::Message << "// Texture for the sampler uniform " << curName << " will be filled with color " << apiVarValueStr(getSamplerFillValue(uniform.finalValue)) << TestLog::EndMessage; 1534 } 1535 1536 DE_ASSERT(!valuesToAssign.empty()); 1537 1538 if (glu::isDataTypeFloatOrVec(valuesToAssign[0].type)) 1539 { 1540 if (assignByValue) 1541 { 1542 const float* const ptr = &valuesToAssign[0].val.floatV[0]; 1543 1544 switch (typeSize) 1545 { 1546 case 1: GLU_CHECK_CALL(glUniform1f(location, ptr[0])); break; 1547 case 2: GLU_CHECK_CALL(glUniform2f(location, ptr[0], ptr[1])); break; 1548 case 3: GLU_CHECK_CALL(glUniform3f(location, ptr[0], ptr[1], ptr[2])); break; 1549 case 4: GLU_CHECK_CALL(glUniform4f(location, ptr[0], ptr[1], ptr[2], ptr[3])); break; 1550 default: 1551 DE_ASSERT(false); 1552 } 1553 } 1554 else 1555 { 1556 vector<float> buffer(valuesToAssign.size() * typeSize); 1557 for (int i = 0; i < (int)buffer.size(); i++) 1558 buffer[i] = valuesToAssign[i / typeSize].val.floatV[i % typeSize]; 1559 1560 DE_STATIC_ASSERT(sizeof(GLfloat) == sizeof(buffer[0])); 1561 switch (typeSize) 1562 { 1563 case 1: GLU_CHECK_CALL(glUniform1fv(location, (GLsizei)valuesToAssign.size(), &buffer[0])); break; 1564 case 2: GLU_CHECK_CALL(glUniform2fv(location, (GLsizei)valuesToAssign.size(), &buffer[0])); break; 1565 case 3: GLU_CHECK_CALL(glUniform3fv(location, (GLsizei)valuesToAssign.size(), &buffer[0])); break; 1566 case 4: GLU_CHECK_CALL(glUniform4fv(location, (GLsizei)valuesToAssign.size(), &buffer[0])); break; 1567 default: 1568 DE_ASSERT(false); 1569 } 1570 } 1571 } 1572 else if (glu::isDataTypeMatrix(valuesToAssign[0].type)) 1573 { 1574 DE_ASSERT(!assignByValue); 1575 1576 vector<float> buffer(valuesToAssign.size() * typeSize); 1577 for (int i = 0; i < (int)buffer.size(); i++) 1578 buffer[i] = valuesToAssign[i / typeSize].val.floatV[i % typeSize]; 1579 1580 switch (uniform.type) 1581 { 1582 case glu::TYPE_FLOAT_MAT2: GLU_CHECK_CALL(glUniformMatrix2fv(location, (GLsizei)valuesToAssign.size(), GL_FALSE, &buffer[0])); break; 1583 case glu::TYPE_FLOAT_MAT3: GLU_CHECK_CALL(glUniformMatrix3fv(location, (GLsizei)valuesToAssign.size(), GL_FALSE, &buffer[0])); break; 1584 case glu::TYPE_FLOAT_MAT4: GLU_CHECK_CALL(glUniformMatrix4fv(location, (GLsizei)valuesToAssign.size(), GL_FALSE, &buffer[0])); break; 1585 default: 1586 DE_ASSERT(false); 1587 } 1588 } 1589 else if (glu::isDataTypeIntOrIVec(valuesToAssign[0].type)) 1590 { 1591 if (assignByValue) 1592 { 1593 const deInt32* const ptr = &valuesToAssign[0].val.intV[0]; 1594 1595 switch (typeSize) 1596 { 1597 case 1: GLU_CHECK_CALL(glUniform1i(location, ptr[0])); break; 1598 case 2: GLU_CHECK_CALL(glUniform2i(location, ptr[0], ptr[1])); break; 1599 case 3: GLU_CHECK_CALL(glUniform3i(location, ptr[0], ptr[1], ptr[2])); break; 1600 case 4: GLU_CHECK_CALL(glUniform4i(location, ptr[0], ptr[1], ptr[2], ptr[3])); break; 1601 default: 1602 DE_ASSERT(false); 1603 } 1604 } 1605 else 1606 { 1607 vector<deInt32> buffer(valuesToAssign.size() * typeSize); 1608 for (int i = 0; i < (int)buffer.size(); i++) 1609 buffer[i] = valuesToAssign[i / typeSize].val.intV[i % typeSize]; 1610 1611 DE_STATIC_ASSERT(sizeof(GLint) == sizeof(buffer[0])); 1612 switch (typeSize) 1613 { 1614 case 1: GLU_CHECK_CALL(glUniform1iv(location, (GLsizei)valuesToAssign.size(), &buffer[0])); break; 1615 case 2: GLU_CHECK_CALL(glUniform2iv(location, (GLsizei)valuesToAssign.size(), &buffer[0])); break; 1616 case 3: GLU_CHECK_CALL(glUniform3iv(location, (GLsizei)valuesToAssign.size(), &buffer[0])); break; 1617 case 4: GLU_CHECK_CALL(glUniform4iv(location, (GLsizei)valuesToAssign.size(), &buffer[0])); break; 1618 default: 1619 DE_ASSERT(false); 1620 } 1621 } 1622 } 1623 else if (glu::isDataTypeSampler(valuesToAssign[0].type)) 1624 { 1625 if (assignByValue) 1626 GLU_CHECK_CALL(glUniform1i(location, uniform.finalValue.val.samplerV.unit)); 1627 else 1628 { 1629 const GLint unit = uniform.finalValue.val.samplerV.unit; 1630 GLU_CHECK_CALL(glUniform1iv(location, (GLsizei)valuesToAssign.size(), &unit)); 1631 } 1632 } 1633 else 1634 DE_ASSERT(false); 1635 } 1636 } 1637 1638 bool UniformCase::compareUniformValues (const vector<VarValue>& values, const vector<BasicUniform>& basicUniforms) 1639 { 1640 TestLog& log = m_testCtx.getLog(); 1641 bool success = true; 1642 1643 for (int unifNdx = 0; unifNdx < (int)basicUniforms.size(); unifNdx++) 1644 { 1645 const BasicUniform& uniform = basicUniforms[unifNdx]; 1646 const VarValue& unifValue = values[unifNdx]; 1647 1648 log << TestLog::Message << "// Checking uniform " << uniform.name << TestLog::EndMessage; 1649 1650 if (unifValue.type == glu::TYPE_INVALID) // This happens when glGetUniformLocation() returned -1. 1651 continue; 1652 1653 if (!apiVarValueEquals(unifValue, uniform.finalValue)) 1654 { 1655 log << TestLog::Message << "// FAILURE: value obtained with glGetUniform*() for uniform " << uniform.name << " differs from value set with glUniform*()" << TestLog::EndMessage; 1656 success = false; 1657 } 1658 } 1659 1660 return success; 1661 } 1662 1663 bool UniformCase::renderTest (const vector<BasicUniform>& basicUniforms, const ShaderProgram& program, Random& rnd) 1664 { 1665 TestLog& log = m_testCtx.getLog(); 1666 const tcu::RenderTarget& renderTarget = m_context.getRenderTarget(); 1667 const int viewportW = de::min(renderTarget.getWidth(), MAX_RENDER_WIDTH); 1668 const int viewportH = de::min(renderTarget.getHeight(), MAX_RENDER_HEIGHT); 1669 const int viewportX = rnd.getInt(0, renderTarget.getWidth() - viewportW); 1670 const int viewportY = rnd.getInt(0, renderTarget.getHeight() - viewportH); 1671 tcu::Surface renderedImg (viewportW, viewportH); 1672 1673 // Assert that no two samplers of different types have the same texture unit - this is an error in GL. 1674 for (int i = 0; i < (int)basicUniforms.size(); i++) 1675 { 1676 if (glu::isDataTypeSampler(basicUniforms[i].type)) 1677 { 1678 for (int j = 0; j < i; j++) 1679 { 1680 if (glu::isDataTypeSampler(basicUniforms[j].type) && basicUniforms[i].type != basicUniforms[j].type) 1681 DE_ASSERT(basicUniforms[i].finalValue.val.samplerV.unit != basicUniforms[j].finalValue.val.samplerV.unit); 1682 } 1683 } 1684 } 1685 1686 for (int i = 0; i < (int)basicUniforms.size(); i++) 1687 { 1688 if (glu::isDataTypeSampler(basicUniforms[i].type) && std::find(m_filledTextureUnits.begin(), m_filledTextureUnits.end(), basicUniforms[i].finalValue.val.samplerV.unit) == m_filledTextureUnits.end()) 1689 { 1690 log << TestLog::Message << "// Filling texture at unit " << apiVarValueStr(basicUniforms[i].finalValue) << " with color " << shaderVarValueStr(basicUniforms[i].finalValue) << TestLog::EndMessage; 1691 setupTexture(basicUniforms[i].finalValue); 1692 } 1693 } 1694 1695 GLU_CHECK_CALL(glViewport(viewportX, viewportY, viewportW, viewportH)); 1696 1697 { 1698 static const float position[] = 1699 { 1700 -1.0f, -1.0f, 0.0f, 1.0f, 1701 -1.0f, +1.0f, 0.0f, 1.0f, 1702 +1.0f, -1.0f, 0.0f, 1.0f, 1703 +1.0f, +1.0f, 0.0f, 1.0f 1704 }; 1705 static const deUint16 indices[] = { 0, 1, 2, 2, 1, 3 }; 1706 1707 const int posLoc = glGetAttribLocation(program.getProgram(), "a_position"); 1708 1709 glEnableVertexAttribArray(posLoc); 1710 glVertexAttribPointer(posLoc, 4, GL_FLOAT, GL_FALSE, 0, &position[0]); 1711 1712 GLU_CHECK_CALL(glDrawElements(GL_TRIANGLES, DE_LENGTH_OF_ARRAY(indices), GL_UNSIGNED_SHORT, &indices[0])); 1713 } 1714 1715 glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, renderedImg.getAccess()); 1716 1717 int numFailedPixels = 0; 1718 for (int y = 0; y < renderedImg.getHeight(); y++) 1719 { 1720 for (int x = 0; x < renderedImg.getWidth(); x++) 1721 { 1722 if (renderedImg.getPixel(x, y) != tcu::RGBA::white()) 1723 numFailedPixels += 1; 1724 } 1725 } 1726 1727 if (numFailedPixels > 0) 1728 { 1729 log << TestLog::Image("RenderedImage", "Rendered image", renderedImg); 1730 log << TestLog::Message << "FAILURE: image comparison failed, got " << numFailedPixels << " non-white pixels" << TestLog::EndMessage; 1731 return false; 1732 } 1733 else 1734 { 1735 log << TestLog::Message << "Success: got all-white pixels (all uniforms have correct values)" << TestLog::EndMessage; 1736 return true; 1737 } 1738 } 1739 1740 UniformCase::IterateResult UniformCase::iterate (void) 1741 { 1742 Random rnd (deStringHash(getName()) ^ (deUint32)m_context.getTestContext().getCommandLine().getBaseSeed()); 1743 TestLog& log = m_testCtx.getLog(); 1744 vector<BasicUniform> basicUniforms; 1745 vector<BasicUniformReportRef> basicUniformReportsRef; 1746 1747 { 1748 int samplerUnitCounter = 0; 1749 for (int i = 0; i < (int)m_uniformCollection->getNumUniforms(); i++) 1750 generateBasicUniforms(basicUniforms, basicUniformReportsRef, m_uniformCollection->getUniform(i).type, m_uniformCollection->getUniform(i).name.c_str(), true, samplerUnitCounter, rnd); 1751 } 1752 1753 const string vertexSource = generateVertexSource(basicUniforms); 1754 const string fragmentSource = generateFragmentSource(basicUniforms); 1755 const ShaderProgram program (m_context.getRenderContext(), glu::makeVtxFragSources(vertexSource, fragmentSource)); 1756 1757 log << program; 1758 1759 if (!program.isOk()) 1760 { 1761 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Compile failed"); 1762 return STOP; 1763 } 1764 1765 GLU_CHECK_CALL(glUseProgram(program.getProgram())); 1766 1767 const bool success = test(basicUniforms, basicUniformReportsRef, program, rnd); 1768 m_testCtx.setTestResult(success ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 1769 success ? "Passed" : "Failed"); 1770 1771 return STOP; 1772 } 1773 1774 class UniformInfoQueryCase : public UniformCase 1775 { 1776 public: 1777 UniformInfoQueryCase (Context& context, const char* name, const char* description, CaseShaderType shaderType, const SharedPtr<const UniformCollection>& uniformCollection, deUint32 additionalFeatures = 0); 1778 bool test (const vector<BasicUniform>& basicUniforms, const vector<BasicUniformReportRef>& basicUniformReportsRef, const ShaderProgram& program, Random& rnd); 1779 }; 1780 1781 UniformInfoQueryCase::UniformInfoQueryCase (Context& context, const char* const name, const char* const description, const CaseShaderType shaderType, const SharedPtr<const UniformCollection>& uniformCollection, const deUint32 additionalFeatures) 1782 : UniformCase (context, name, description, shaderType, uniformCollection, additionalFeatures) 1783 { 1784 } 1785 1786 bool UniformInfoQueryCase::test (const vector<BasicUniform>& basicUniforms, const vector<BasicUniformReportRef>& basicUniformReportsRef, const ShaderProgram& program, Random& rnd) 1787 { 1788 DE_UNREF(basicUniforms); 1789 DE_UNREF(rnd); 1790 1791 const deUint32 programGL = program.getProgram(); 1792 TestLog& log = m_testCtx.getLog(); 1793 vector<BasicUniformReportGL> basicUniformReportsUniform; 1794 1795 const ScopedLogSection section(log, "InfoGetActiveUniform", "Uniform information queries with glGetActiveUniform()"); 1796 const bool success = getActiveUniforms(basicUniformReportsUniform, basicUniformReportsRef, programGL); 1797 1798 if (!success) 1799 return false; 1800 1801 return true; 1802 } 1803 1804 class UniformValueCase : public UniformCase 1805 { 1806 public: 1807 enum ValueToCheck 1808 { 1809 VALUETOCHECK_INITIAL = 0, //!< Verify the initial values of the uniforms (i.e. check that they're zero). 1810 VALUETOCHECK_ASSIGNED, //!< Assign values to uniforms with glUniform*(), and check those. 1811 1812 VALUETOCHECK_LAST 1813 }; 1814 enum CheckMethod 1815 { 1816 CHECKMETHOD_GET_UNIFORM = 0, //!< Check values with glGetUniform*(). 1817 CHECKMETHOD_RENDER, //!< Check values by rendering with the value-checking shader. 1818 1819 CHECKMETHOD_LAST 1820 }; 1821 enum AssignMethod 1822 { 1823 ASSIGNMETHOD_POINTER = 0, 1824 ASSIGNMETHOD_VALUE, 1825 1826 ASSIGNMETHOD_LAST 1827 }; 1828 1829 UniformValueCase (Context& context, 1830 const char* name, 1831 const char* description, 1832 CaseShaderType shaderType, 1833 const SharedPtr<const UniformCollection>& uniformCollection, 1834 ValueToCheck valueToCheck, 1835 CheckMethod checkMethod, 1836 AssignMethod assignMethod, 1837 deUint32 additionalFeatures = 0); 1838 1839 bool test (const vector<BasicUniform>& basicUniforms, const vector<BasicUniformReportRef>& basicUniformReportsRef, const ShaderProgram& program, Random& rnd); 1840 1841 static const char* getValueToCheckName (ValueToCheck valueToCheck); 1842 static const char* getValueToCheckDescription (ValueToCheck valueToCheck); 1843 static const char* getCheckMethodName (CheckMethod checkMethod); 1844 static const char* getCheckMethodDescription (CheckMethod checkMethod); 1845 static const char* getAssignMethodName (AssignMethod checkMethod); 1846 static const char* getAssignMethodDescription (AssignMethod checkMethod); 1847 1848 private: 1849 const ValueToCheck m_valueToCheck; 1850 const CheckMethod m_checkMethod; 1851 }; 1852 1853 const char* UniformValueCase::getValueToCheckName (const ValueToCheck valueToCheck) 1854 { 1855 switch (valueToCheck) 1856 { 1857 case VALUETOCHECK_INITIAL: return "initial"; 1858 case VALUETOCHECK_ASSIGNED: return "assigned"; 1859 default: DE_ASSERT(false); return DE_NULL; 1860 } 1861 } 1862 1863 const char* UniformValueCase::getValueToCheckDescription (const ValueToCheck valueToCheck) 1864 { 1865 switch (valueToCheck) 1866 { 1867 case VALUETOCHECK_INITIAL: return "Check initial uniform values (zeros)"; 1868 case VALUETOCHECK_ASSIGNED: return "Check assigned uniform values"; 1869 default: DE_ASSERT(false); return DE_NULL; 1870 } 1871 } 1872 1873 const char* UniformValueCase::getCheckMethodName (const CheckMethod checkMethod) 1874 { 1875 switch (checkMethod) 1876 { 1877 case CHECKMETHOD_GET_UNIFORM: return "get_uniform"; 1878 case CHECKMETHOD_RENDER: return "render"; 1879 default: DE_ASSERT(false); return DE_NULL; 1880 } 1881 } 1882 1883 const char* UniformValueCase::getCheckMethodDescription (const CheckMethod checkMethod) 1884 { 1885 switch (checkMethod) 1886 { 1887 case CHECKMETHOD_GET_UNIFORM: return "Verify values with glGetUniform*()"; 1888 case CHECKMETHOD_RENDER: return "Verify values by rendering"; 1889 default: DE_ASSERT(false); return DE_NULL; 1890 } 1891 } 1892 1893 const char* UniformValueCase::getAssignMethodName (const AssignMethod assignMethod) 1894 { 1895 switch (assignMethod) 1896 { 1897 case ASSIGNMETHOD_POINTER: return "by_pointer"; 1898 case ASSIGNMETHOD_VALUE: return "by_value"; 1899 default: DE_ASSERT(false); return DE_NULL; 1900 } 1901 } 1902 1903 const char* UniformValueCase::getAssignMethodDescription (const AssignMethod assignMethod) 1904 { 1905 switch (assignMethod) 1906 { 1907 case ASSIGNMETHOD_POINTER: return "Assign values by-pointer"; 1908 case ASSIGNMETHOD_VALUE: return "Assign values by-value"; 1909 default: DE_ASSERT(false); return DE_NULL; 1910 } 1911 } 1912 1913 UniformValueCase::UniformValueCase (Context& context, 1914 const char* const name, 1915 const char* const description, 1916 const CaseShaderType shaderType, 1917 const SharedPtr<const UniformCollection>& uniformCollection, 1918 const ValueToCheck valueToCheck, 1919 const CheckMethod checkMethod, 1920 const AssignMethod assignMethod, 1921 const deUint32 additionalFeatures) 1922 : UniformCase (context, name, description, shaderType, uniformCollection, 1923 (valueToCheck == VALUETOCHECK_INITIAL ? FEATURE_UNIFORMVALUE_ZERO : 0) | (assignMethod == ASSIGNMETHOD_VALUE ? FEATURE_UNIFORMFUNC_VALUE : 0) | additionalFeatures) 1924 , m_valueToCheck (valueToCheck) 1925 , m_checkMethod (checkMethod) 1926 { 1927 DE_ASSERT(!(assignMethod == ASSIGNMETHOD_LAST && valueToCheck == VALUETOCHECK_ASSIGNED)); 1928 } 1929 1930 bool UniformValueCase::test (const vector<BasicUniform>& basicUniforms, const vector<BasicUniformReportRef>& basicUniformReportsRef, const ShaderProgram& program, Random& rnd) 1931 { 1932 DE_UNREF(basicUniformReportsRef); 1933 1934 const deUint32 programGL = program.getProgram(); 1935 TestLog& log = m_testCtx.getLog(); 1936 1937 if (m_valueToCheck == VALUETOCHECK_ASSIGNED) 1938 { 1939 const ScopedLogSection section(log, "UniformAssign", "Uniform value assignments"); 1940 assignUniforms(basicUniforms, programGL, rnd); 1941 } 1942 else 1943 DE_ASSERT(m_valueToCheck == VALUETOCHECK_INITIAL); 1944 1945 if (m_checkMethod == CHECKMETHOD_GET_UNIFORM) 1946 { 1947 vector<VarValue> values; 1948 1949 { 1950 const ScopedLogSection section(log, "GetUniforms", "Uniform value query"); 1951 const bool success = getUniforms(values, basicUniforms, program.getProgram()); 1952 1953 if (!success) 1954 return false; 1955 } 1956 1957 if (m_valueToCheck == VALUETOCHECK_ASSIGNED) 1958 { 1959 const ScopedLogSection section(log, "ValueCheck", "Verify that the reported values match the assigned values"); 1960 const bool success = compareUniformValues(values, basicUniforms); 1961 1962 if (!success) 1963 return false; 1964 } 1965 else 1966 { 1967 DE_ASSERT(m_valueToCheck == VALUETOCHECK_INITIAL); 1968 const ScopedLogSection section(log, "ValueCheck", "Verify that the uniforms have correct initial values (zeros)"); 1969 const bool success = checkUniformDefaultValues(values, basicUniforms); 1970 1971 if (!success) 1972 return false; 1973 } 1974 } 1975 else 1976 { 1977 DE_ASSERT(m_checkMethod == CHECKMETHOD_RENDER); 1978 1979 const ScopedLogSection section(log, "RenderTest", "Render test"); 1980 const bool success = renderTest(basicUniforms, program, rnd); 1981 1982 if (!success) 1983 return false; 1984 } 1985 1986 return true; 1987 } 1988 1989 class RandomUniformCase : public UniformCase 1990 { 1991 public: 1992 RandomUniformCase (Context& m_context, const char* name, const char* description, deUint32 seed); 1993 1994 bool test (const vector<BasicUniform>& basicUniforms, const vector<BasicUniformReportRef>& basicUniformReportsRef, const ShaderProgram& program, Random& rnd); 1995 }; 1996 1997 RandomUniformCase::RandomUniformCase (Context& context, const char* const name, const char* const description, const deUint32 seed) 1998 : UniformCase (context, name, description, seed ^ (deUint32)context.getTestContext().getCommandLine().getBaseSeed()) 1999 { 2000 } 2001 2002 bool RandomUniformCase::test (const vector<BasicUniform>& basicUniforms, const vector<BasicUniformReportRef>& basicUniformReportsRef, const ShaderProgram& program, Random& rnd) 2003 { 2004 // \note Different sampler types may not be bound to same unit when rendering. 2005 const bool renderingPossible = (m_features & FEATURE_UNIFORMVALUE_ZERO) == 0 || !m_uniformCollection->containsSeveralSamplerTypes(); 2006 2007 bool performGetActiveUniforms = rnd.getBool(); 2008 const bool performGetUniforms = rnd.getBool(); 2009 const bool performCheckUniformDefaultValues = performGetUniforms && rnd.getBool(); 2010 const bool performAssignUniforms = rnd.getBool(); 2011 const bool performCompareUniformValues = performGetUniforms && performAssignUniforms && rnd.getBool(); 2012 const bool performRenderTest = renderingPossible && performAssignUniforms && rnd.getBool(); 2013 const deUint32 programGL = program.getProgram(); 2014 TestLog& log = m_testCtx.getLog(); 2015 2016 if (!(performGetActiveUniforms || performGetUniforms || performCheckUniformDefaultValues || performAssignUniforms || performCompareUniformValues || performRenderTest)) 2017 performGetActiveUniforms = true; // Do something at least. 2018 2019 #define PERFORM_AND_CHECK(CALL, SECTION_NAME, SECTION_DESCRIPTION) \ 2020 do \ 2021 { \ 2022 const ScopedLogSection section(log, (SECTION_NAME), (SECTION_DESCRIPTION)); \ 2023 const bool success = (CALL); \ 2024 if (!success) \ 2025 return false; \ 2026 } while (false) 2027 2028 if (performGetActiveUniforms) 2029 { 2030 vector<BasicUniformReportGL> reportsUniform; 2031 PERFORM_AND_CHECK(getActiveUniforms(reportsUniform, basicUniformReportsRef, programGL), "InfoGetActiveUniform", "Uniform information queries with glGetActiveUniform()"); 2032 } 2033 2034 { 2035 vector<VarValue> uniformDefaultValues; 2036 2037 if (performGetUniforms) 2038 PERFORM_AND_CHECK(getUniforms(uniformDefaultValues, basicUniforms, programGL), "GetUniformDefaults", "Uniform default value query"); 2039 if (performCheckUniformDefaultValues) 2040 PERFORM_AND_CHECK(checkUniformDefaultValues(uniformDefaultValues, basicUniforms), "DefaultValueCheck", "Verify that the uniforms have correct initial values (zeros)"); 2041 } 2042 2043 { 2044 vector<VarValue> uniformValues; 2045 2046 if (performAssignUniforms) 2047 { 2048 const ScopedLogSection section(log, "UniformAssign", "Uniform value assignments"); 2049 assignUniforms(basicUniforms, programGL, rnd); 2050 } 2051 if (performCompareUniformValues) 2052 { 2053 PERFORM_AND_CHECK(getUniforms(uniformValues, basicUniforms, programGL), "GetUniforms", "Uniform value query"); 2054 PERFORM_AND_CHECK(compareUniformValues(uniformValues, basicUniforms), "ValueCheck", "Verify that the reported values match the assigned values"); 2055 } 2056 } 2057 2058 if (performRenderTest) 2059 PERFORM_AND_CHECK(renderTest(basicUniforms, program, rnd), "RenderTest", "Render test"); 2060 2061 #undef PERFORM_AND_CHECK 2062 2063 return true; 2064 } 2065 2066 UniformApiTests::UniformApiTests (Context& context) 2067 : TestCaseGroup(context, "uniform_api", "Uniform API Tests") 2068 { 2069 } 2070 2071 UniformApiTests::~UniformApiTests (void) 2072 { 2073 } 2074 2075 namespace 2076 { 2077 2078 // \note Although this is only used in UniformApiTest::init, it needs to be defined here as it's used as a template argument. 2079 struct UniformCollectionCase 2080 { 2081 string namePrefix; 2082 SharedPtr<const UniformCollection> uniformCollection; 2083 2084 UniformCollectionCase (const char* const name, const UniformCollection* uniformCollection_) 2085 : namePrefix (name ? name + string("_") : "") 2086 , uniformCollection (uniformCollection_) 2087 { 2088 } 2089 }; 2090 2091 } // anonymous 2092 2093 void UniformApiTests::init (void) 2094 { 2095 // Generate sets of UniformCollections that are used by several cases. 2096 2097 enum 2098 { 2099 UNIFORMCOLLECTIONS_BASIC = 0, 2100 UNIFORMCOLLECTIONS_BASIC_ARRAY, 2101 UNIFORMCOLLECTIONS_BASIC_STRUCT, 2102 UNIFORMCOLLECTIONS_STRUCT_IN_ARRAY, 2103 UNIFORMCOLLECTIONS_ARRAY_IN_STRUCT, 2104 UNIFORMCOLLECTIONS_NESTED_STRUCTS_ARRAYS, 2105 UNIFORMCOLLECTIONS_MULTIPLE_BASIC, 2106 UNIFORMCOLLECTIONS_MULTIPLE_BASIC_ARRAY, 2107 UNIFORMCOLLECTIONS_MULTIPLE_NESTED_STRUCTS_ARRAYS, 2108 2109 UNIFORMCOLLECTIONS_LAST 2110 }; 2111 2112 struct UniformCollectionGroup 2113 { 2114 string name; 2115 vector<UniformCollectionCase> cases; 2116 } defaultUniformCollections[UNIFORMCOLLECTIONS_LAST]; 2117 2118 defaultUniformCollections[UNIFORMCOLLECTIONS_BASIC].name = "basic"; 2119 defaultUniformCollections[UNIFORMCOLLECTIONS_BASIC_ARRAY].name = "basic_array"; 2120 defaultUniformCollections[UNIFORMCOLLECTIONS_BASIC_STRUCT].name = "basic_struct"; 2121 defaultUniformCollections[UNIFORMCOLLECTIONS_STRUCT_IN_ARRAY].name = "struct_in_array"; 2122 defaultUniformCollections[UNIFORMCOLLECTIONS_ARRAY_IN_STRUCT].name = "array_in_struct"; 2123 defaultUniformCollections[UNIFORMCOLLECTIONS_NESTED_STRUCTS_ARRAYS].name = "nested_structs_arrays"; 2124 defaultUniformCollections[UNIFORMCOLLECTIONS_MULTIPLE_BASIC].name = "multiple_basic"; 2125 defaultUniformCollections[UNIFORMCOLLECTIONS_MULTIPLE_BASIC_ARRAY].name = "multiple_basic_array"; 2126 defaultUniformCollections[UNIFORMCOLLECTIONS_MULTIPLE_NESTED_STRUCTS_ARRAYS].name = "multiple_nested_structs_arrays"; 2127 2128 for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_testDataTypes); dataTypeNdx++) 2129 { 2130 const glu::DataType dataType = s_testDataTypes[dataTypeNdx]; 2131 const char* const typeName = glu::getDataTypeName(dataType); 2132 2133 defaultUniformCollections[UNIFORMCOLLECTIONS_BASIC].cases.push_back(UniformCollectionCase(typeName, UniformCollection::basic(dataType))); 2134 2135 if (glu::isDataTypeScalar(dataType) || 2136 (glu::isDataTypeVector(dataType) && glu::getDataTypeScalarSize(dataType) == 4) || 2137 dataType == glu::TYPE_FLOAT_MAT4 || 2138 dataType == glu::TYPE_SAMPLER_2D) 2139 defaultUniformCollections[UNIFORMCOLLECTIONS_BASIC_ARRAY].cases.push_back(UniformCollectionCase(typeName, UniformCollection::basicArray(dataType))); 2140 2141 if (glu::isDataTypeScalar(dataType) || 2142 dataType == glu::TYPE_FLOAT_MAT4 || 2143 dataType == glu::TYPE_SAMPLER_2D) 2144 { 2145 const glu::DataType secondDataType = glu::isDataTypeScalar(dataType) ? glu::getDataTypeVector(dataType, 4) 2146 : dataType == glu::TYPE_FLOAT_MAT4 ? glu::TYPE_FLOAT_MAT2 2147 : dataType == glu::TYPE_SAMPLER_2D ? glu::TYPE_SAMPLER_CUBE 2148 : glu::TYPE_LAST; 2149 DE_ASSERT(secondDataType != glu::TYPE_LAST); 2150 const char* const secondTypeName = glu::getDataTypeName(secondDataType); 2151 const string name = string("") + typeName + "_" + secondTypeName; 2152 2153 defaultUniformCollections[UNIFORMCOLLECTIONS_BASIC_STRUCT].cases.push_back (UniformCollectionCase(name.c_str(), UniformCollection::basicStruct(dataType, secondDataType, false))); 2154 defaultUniformCollections[UNIFORMCOLLECTIONS_ARRAY_IN_STRUCT].cases.push_back (UniformCollectionCase(name.c_str(), UniformCollection::basicStruct(dataType, secondDataType, true))); 2155 defaultUniformCollections[UNIFORMCOLLECTIONS_STRUCT_IN_ARRAY].cases.push_back (UniformCollectionCase(name.c_str(), UniformCollection::structInArray(dataType, secondDataType, false))); 2156 defaultUniformCollections[UNIFORMCOLLECTIONS_NESTED_STRUCTS_ARRAYS].cases.push_back (UniformCollectionCase(name.c_str(), UniformCollection::nestedArraysStructs(dataType, secondDataType))); 2157 } 2158 } 2159 defaultUniformCollections[UNIFORMCOLLECTIONS_MULTIPLE_BASIC].cases.push_back (UniformCollectionCase(DE_NULL, UniformCollection::multipleBasic())); 2160 defaultUniformCollections[UNIFORMCOLLECTIONS_MULTIPLE_BASIC_ARRAY].cases.push_back (UniformCollectionCase(DE_NULL, UniformCollection::multipleBasicArray())); 2161 defaultUniformCollections[UNIFORMCOLLECTIONS_MULTIPLE_NESTED_STRUCTS_ARRAYS].cases.push_back (UniformCollectionCase(DE_NULL, UniformCollection::multipleNestedArraysStructs())); 2162 2163 // Info-query cases (check info returned by e.g. glGetActiveUniforms()). 2164 2165 { 2166 TestCaseGroup* const infoQueryGroup = new TestCaseGroup(m_context, "info_query", "Test glGetActiveUniform()"); 2167 addChild(infoQueryGroup); 2168 2169 for (int collectionGroupNdx = 0; collectionGroupNdx < (int)UNIFORMCOLLECTIONS_LAST; collectionGroupNdx++) 2170 { 2171 const UniformCollectionGroup& collectionGroup = defaultUniformCollections[collectionGroupNdx]; 2172 TestCaseGroup* const collectionTestGroup = new TestCaseGroup(m_context, collectionGroup.name.c_str(), ""); 2173 infoQueryGroup->addChild(collectionTestGroup); 2174 2175 for (int collectionNdx = 0; collectionNdx < (int)collectionGroup.cases.size(); collectionNdx++) 2176 { 2177 const UniformCollectionCase& collectionCase = collectionGroup.cases[collectionNdx]; 2178 2179 for (int shaderType = 0; shaderType < (int)CASESHADERTYPE_LAST; shaderType++) 2180 { 2181 const string name = collectionCase.namePrefix + getCaseShaderTypeName((CaseShaderType)shaderType); 2182 const SharedPtr<const UniformCollection>& uniformCollection = collectionCase.uniformCollection; 2183 2184 collectionTestGroup->addChild(new UniformInfoQueryCase(m_context, name.c_str(), "", (CaseShaderType)shaderType, uniformCollection)); 2185 } 2186 } 2187 } 2188 2189 // Info-querying cases when unused uniforms are present. 2190 2191 { 2192 TestCaseGroup* const unusedUniformsGroup = new TestCaseGroup(m_context, "unused_uniforms", "Test with unused uniforms"); 2193 infoQueryGroup->addChild(unusedUniformsGroup); 2194 2195 const UniformCollectionGroup& collectionGroup = defaultUniformCollections[UNIFORMCOLLECTIONS_ARRAY_IN_STRUCT]; 2196 2197 for (int collectionNdx = 0; collectionNdx < (int)collectionGroup.cases.size(); collectionNdx++) 2198 { 2199 const UniformCollectionCase& collectionCase = collectionGroup.cases[collectionNdx]; 2200 const string collName = collectionCase.namePrefix; 2201 const SharedPtr<const UniformCollection>& uniformCollection = collectionCase.uniformCollection; 2202 2203 for (int shaderType = 0; shaderType < (int)CASESHADERTYPE_LAST; shaderType++) 2204 { 2205 const string name = collName + getCaseShaderTypeName((CaseShaderType)shaderType); 2206 unusedUniformsGroup->addChild(new UniformInfoQueryCase(m_context, name.c_str(), "", (CaseShaderType)shaderType, uniformCollection, 2207 UniformCase::FEATURE_UNIFORMUSAGE_EVERY_OTHER | UniformCase::FEATURE_ARRAYUSAGE_ONLY_MIDDLE_INDEX)); 2208 } 2209 } 2210 } 2211 } 2212 2213 // Cases testing uniform values. 2214 2215 { 2216 TestCaseGroup* const valueGroup = new TestCaseGroup(m_context, "value", "Uniform value tests"); 2217 addChild(valueGroup); 2218 2219 // Cases checking uniforms' initial values (all must be zeros), with glGetUniform*() or by rendering. 2220 2221 { 2222 TestCaseGroup* const initialValuesGroup = new TestCaseGroup(m_context, 2223 UniformValueCase::getValueToCheckName(UniformValueCase::VALUETOCHECK_INITIAL), 2224 UniformValueCase::getValueToCheckDescription(UniformValueCase::VALUETOCHECK_INITIAL)); 2225 valueGroup->addChild(initialValuesGroup); 2226 2227 for (int checkMethodI = 0; checkMethodI < (int)UniformValueCase::CHECKMETHOD_LAST; checkMethodI++) 2228 { 2229 const UniformValueCase::CheckMethod checkMethod = (UniformValueCase::CheckMethod)checkMethodI; 2230 TestCaseGroup* const checkMethodGroup = new TestCaseGroup(m_context, UniformValueCase::getCheckMethodName(checkMethod), UniformValueCase::getCheckMethodDescription(checkMethod)); 2231 initialValuesGroup->addChild(checkMethodGroup); 2232 2233 for (int collectionGroupNdx = 0; collectionGroupNdx < (int)UNIFORMCOLLECTIONS_LAST; collectionGroupNdx++) 2234 { 2235 const UniformCollectionGroup& collectionGroup = defaultUniformCollections[collectionGroupNdx]; 2236 TestCaseGroup* const collectionTestGroup = new TestCaseGroup(m_context, collectionGroup.name.c_str(), ""); 2237 checkMethodGroup->addChild(collectionTestGroup); 2238 2239 for (int collectionNdx = 0; collectionNdx < (int)collectionGroup.cases.size(); collectionNdx++) 2240 { 2241 const UniformCollectionCase& collectionCase = collectionGroup.cases[collectionNdx]; 2242 const string collName = collectionCase.namePrefix; 2243 const SharedPtr<const UniformCollection>& uniformCollection = collectionCase.uniformCollection; 2244 const bool containsBooleans = uniformCollection->containsMatchingBasicType(glu::isDataTypeBoolOrBVec); 2245 const bool varyBoolApiType = checkMethod == UniformValueCase::CHECKMETHOD_GET_UNIFORM && containsBooleans && 2246 (collectionGroupNdx == UNIFORMCOLLECTIONS_BASIC || collectionGroupNdx == UNIFORMCOLLECTIONS_BASIC_ARRAY); 2247 const int numBoolVariations = varyBoolApiType ? 2 : 1; 2248 2249 if (checkMethod == UniformValueCase::CHECKMETHOD_RENDER && uniformCollection->containsSeveralSamplerTypes()) 2250 continue; // \note Samplers' initial API values (i.e. their texture units) are 0, and no two samplers of different types shall have same unit when rendering. 2251 2252 for (int booleanTypeI = 0; booleanTypeI < numBoolVariations; booleanTypeI++) 2253 { 2254 const deUint32 booleanTypeFeat = booleanTypeI == 1 ? UniformCase::FEATURE_BOOLEANAPITYPE_INT 2255 : 0; 2256 const char* const booleanTypeName = booleanTypeI == 1 ? "int" 2257 : "float"; 2258 const string nameWithApiType = varyBoolApiType ? collName + "api_" + booleanTypeName + "_" : collName; 2259 2260 for (int shaderType = 0; shaderType < (int)CASESHADERTYPE_LAST; shaderType++) 2261 { 2262 const string name = nameWithApiType + getCaseShaderTypeName((CaseShaderType)shaderType); 2263 collectionTestGroup->addChild(new UniformValueCase(m_context, name.c_str(), "", (CaseShaderType)shaderType, uniformCollection, 2264 UniformValueCase::VALUETOCHECK_INITIAL, checkMethod, UniformValueCase::ASSIGNMETHOD_LAST, booleanTypeFeat)); 2265 } 2266 } 2267 } 2268 } 2269 } 2270 } 2271 2272 // Cases that first assign values to each uniform, then check the values with glGetUniform*() or by rendering. 2273 2274 { 2275 TestCaseGroup* const assignedValuesGroup = new TestCaseGroup(m_context, 2276 UniformValueCase::getValueToCheckName(UniformValueCase::VALUETOCHECK_ASSIGNED), 2277 UniformValueCase::getValueToCheckDescription(UniformValueCase::VALUETOCHECK_ASSIGNED)); 2278 valueGroup->addChild(assignedValuesGroup); 2279 2280 for (int assignMethodI = 0; assignMethodI < (int)UniformValueCase::ASSIGNMETHOD_LAST; assignMethodI++) 2281 { 2282 const UniformValueCase::AssignMethod assignMethod = (UniformValueCase::AssignMethod)assignMethodI; 2283 TestCaseGroup* const assignMethodGroup = new TestCaseGroup(m_context, UniformValueCase::getAssignMethodName(assignMethod), UniformValueCase::getAssignMethodDescription(assignMethod)); 2284 assignedValuesGroup->addChild(assignMethodGroup); 2285 2286 for (int checkMethodI = 0; checkMethodI < (int)UniformValueCase::CHECKMETHOD_LAST; checkMethodI++) 2287 { 2288 const UniformValueCase::CheckMethod checkMethod = (UniformValueCase::CheckMethod)checkMethodI; 2289 TestCaseGroup* const checkMethodGroup = new TestCaseGroup(m_context, UniformValueCase::getCheckMethodName(checkMethod), UniformValueCase::getCheckMethodDescription(checkMethod)); 2290 assignMethodGroup->addChild(checkMethodGroup); 2291 2292 for (int collectionGroupNdx = 0; collectionGroupNdx < (int)UNIFORMCOLLECTIONS_LAST; collectionGroupNdx++) 2293 { 2294 const int numArrayFirstElemNameCases = checkMethod == UniformValueCase::CHECKMETHOD_GET_UNIFORM && collectionGroupNdx == UNIFORMCOLLECTIONS_BASIC_ARRAY ? 2 : 1; 2295 2296 for (int referToFirstArrayElemWithoutIndexI = 0; referToFirstArrayElemWithoutIndexI < numArrayFirstElemNameCases; referToFirstArrayElemWithoutIndexI++) 2297 { 2298 const UniformCollectionGroup& collectionGroup = defaultUniformCollections[collectionGroupNdx]; 2299 const string collectionGroupName = collectionGroup.name + (referToFirstArrayElemWithoutIndexI == 0 ? "" : "_first_elem_without_brackets"); 2300 TestCaseGroup* collectionTestGroup = DE_NULL; 2301 2302 for (int collectionNdx = 0; collectionNdx < (int)collectionGroup.cases.size(); collectionNdx++) 2303 { 2304 const UniformCollectionCase& collectionCase = collectionGroup.cases[collectionNdx]; 2305 const string collName = collectionCase.namePrefix; 2306 const SharedPtr<const UniformCollection>& uniformCollection = collectionCase.uniformCollection; 2307 const bool containsBooleans = uniformCollection->containsMatchingBasicType(glu::isDataTypeBoolOrBVec); 2308 const bool varyBoolApiType = checkMethod == UniformValueCase::CHECKMETHOD_GET_UNIFORM && containsBooleans && 2309 (collectionGroupNdx == UNIFORMCOLLECTIONS_BASIC || collectionGroupNdx == UNIFORMCOLLECTIONS_BASIC_ARRAY); 2310 const int numBoolVariations = varyBoolApiType ? 2 : 1; 2311 const bool containsMatrices = uniformCollection->containsMatchingBasicType(glu::isDataTypeMatrix); 2312 2313 if (containsMatrices && assignMethod != UniformValueCase::ASSIGNMETHOD_POINTER) 2314 continue; 2315 2316 for (int booleanTypeI = 0; booleanTypeI < numBoolVariations; booleanTypeI++) 2317 { 2318 const deUint32 booleanTypeFeat = booleanTypeI == 1 ? UniformCase::FEATURE_BOOLEANAPITYPE_INT 2319 : 0; 2320 const char* const booleanTypeName = booleanTypeI == 1 ? "int" 2321 : "float"; 2322 const string nameWithBoolType = varyBoolApiType ? collName + "api_" + booleanTypeName + "_" : collName; 2323 const string nameWithMatrixType = nameWithBoolType; 2324 2325 for (int shaderType = 0; shaderType < (int)CASESHADERTYPE_LAST; shaderType++) 2326 { 2327 const string name = nameWithMatrixType + getCaseShaderTypeName((CaseShaderType)shaderType); 2328 const deUint32 arrayFirstElemNameNoIndexFeat = referToFirstArrayElemWithoutIndexI == 0 ? 0 : UniformCase::FEATURE_ARRAY_FIRST_ELEM_NAME_NO_INDEX; 2329 2330 // skip empty groups by creating groups on demand 2331 if (!collectionTestGroup) 2332 { 2333 collectionTestGroup = new TestCaseGroup(m_context, collectionGroupName.c_str(), ""); 2334 checkMethodGroup->addChild(collectionTestGroup); 2335 } 2336 2337 collectionTestGroup->addChild(new UniformValueCase(m_context, name.c_str(), "", (CaseShaderType)shaderType, uniformCollection, 2338 UniformValueCase::VALUETOCHECK_ASSIGNED, checkMethod, assignMethod, 2339 booleanTypeFeat | arrayFirstElemNameNoIndexFeat)); 2340 } 2341 } 2342 } 2343 } 2344 } 2345 } 2346 } 2347 2348 // Cases assign multiple basic-array elements with one glUniform*v() (i.e. the count parameter is bigger than 1). 2349 2350 { 2351 static const struct 2352 { 2353 UniformCase::Feature arrayAssignMode; 2354 const char* name; 2355 const char* description; 2356 } arrayAssignGroups[] = 2357 { 2358 { UniformCase::FEATURE_ARRAYASSIGN_FULL, "basic_array_assign_full", "Assign entire basic-type arrays per glUniform*v() call" }, 2359 { UniformCase::FEATURE_ARRAYASSIGN_BLOCKS_OF_TWO, "basic_array_assign_partial", "Assign two elements of a basic-type array per glUniform*v() call" } 2360 }; 2361 2362 for (int arrayAssignGroupNdx = 0; arrayAssignGroupNdx < DE_LENGTH_OF_ARRAY(arrayAssignGroups); arrayAssignGroupNdx++) 2363 { 2364 UniformCase::Feature arrayAssignMode = arrayAssignGroups[arrayAssignGroupNdx].arrayAssignMode; 2365 const char* const groupName = arrayAssignGroups[arrayAssignGroupNdx].name; 2366 const char* const groupDesc = arrayAssignGroups[arrayAssignGroupNdx].description; 2367 2368 TestCaseGroup* const curArrayAssignGroup = new TestCaseGroup(m_context, groupName, groupDesc); 2369 assignedValuesGroup->addChild(curArrayAssignGroup); 2370 2371 static const int basicArrayCollectionGroups[] = { UNIFORMCOLLECTIONS_BASIC_ARRAY, UNIFORMCOLLECTIONS_ARRAY_IN_STRUCT, UNIFORMCOLLECTIONS_MULTIPLE_BASIC_ARRAY }; 2372 2373 for (int collectionGroupNdx = 0; collectionGroupNdx < DE_LENGTH_OF_ARRAY(basicArrayCollectionGroups); collectionGroupNdx++) 2374 { 2375 const UniformCollectionGroup& collectionGroup = defaultUniformCollections[basicArrayCollectionGroups[collectionGroupNdx]]; 2376 TestCaseGroup* const collectionTestGroup = new TestCaseGroup(m_context, collectionGroup.name.c_str(), ""); 2377 curArrayAssignGroup->addChild(collectionTestGroup); 2378 2379 for (int collectionNdx = 0; collectionNdx < (int)collectionGroup.cases.size(); collectionNdx++) 2380 { 2381 const UniformCollectionCase& collectionCase = collectionGroup.cases[collectionNdx]; 2382 const string collName = collectionCase.namePrefix; 2383 const SharedPtr<const UniformCollection>& uniformCollection = collectionCase.uniformCollection; 2384 2385 for (int shaderType = 0; shaderType < (int)CASESHADERTYPE_LAST; shaderType++) 2386 { 2387 const string name = collName + getCaseShaderTypeName((CaseShaderType)shaderType); 2388 collectionTestGroup->addChild(new UniformValueCase(m_context, name.c_str(), "", (CaseShaderType)shaderType, uniformCollection, 2389 UniformValueCase::VALUETOCHECK_ASSIGNED, UniformValueCase::CHECKMETHOD_GET_UNIFORM, UniformValueCase::ASSIGNMETHOD_POINTER, 2390 arrayAssignMode)); 2391 } 2392 } 2393 } 2394 } 2395 } 2396 2397 // Value checking cases when unused uniforms are present. 2398 2399 { 2400 TestCaseGroup* const unusedUniformsGroup = new TestCaseGroup(m_context, "unused_uniforms", "Test with unused uniforms"); 2401 assignedValuesGroup->addChild(unusedUniformsGroup); 2402 2403 const UniformCollectionGroup& collectionGroup = defaultUniformCollections[UNIFORMCOLLECTIONS_ARRAY_IN_STRUCT]; 2404 2405 for (int collectionNdx = 0; collectionNdx < (int)collectionGroup.cases.size(); collectionNdx++) 2406 { 2407 const UniformCollectionCase& collectionCase = collectionGroup.cases[collectionNdx]; 2408 const string collName = collectionCase.namePrefix; 2409 const SharedPtr<const UniformCollection>& uniformCollection = collectionCase.uniformCollection; 2410 2411 for (int shaderType = 0; shaderType < (int)CASESHADERTYPE_LAST; shaderType++) 2412 { 2413 const string name = collName + getCaseShaderTypeName((CaseShaderType)shaderType); 2414 unusedUniformsGroup->addChild(new UniformValueCase(m_context, name.c_str(), "", (CaseShaderType)shaderType, uniformCollection, 2415 UniformValueCase::VALUETOCHECK_ASSIGNED, UniformValueCase::CHECKMETHOD_GET_UNIFORM, UniformValueCase::ASSIGNMETHOD_POINTER, 2416 UniformCase::FEATURE_ARRAYUSAGE_ONLY_MIDDLE_INDEX | UniformCase::FEATURE_UNIFORMUSAGE_EVERY_OTHER)); 2417 } 2418 } 2419 } 2420 } 2421 } 2422 2423 // Random cases. 2424 2425 { 2426 const int numRandomCases = 100; 2427 TestCaseGroup* const randomGroup = new TestCaseGroup(m_context, "random", "Random cases"); 2428 addChild(randomGroup); 2429 2430 for (int ndx = 0; ndx < numRandomCases; ndx++) 2431 randomGroup->addChild(new RandomUniformCase(m_context, de::toString(ndx).c_str(), "", (deUint32)ndx)); 2432 } 2433 } 2434 2435 } // Functional 2436 } // gles2 2437 } // deqp 2438
