1/*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL (ES) 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 block case. 22 *//*--------------------------------------------------------------------*/ 23 24#include "glsUniformBlockCase.hpp" 25#include "gluRenderContext.hpp" 26#include "gluShaderProgram.hpp" 27#include "gluPixelTransfer.hpp" 28#include "gluContextInfo.hpp" 29#include "gluRenderContext.hpp" 30#include "gluDrawUtil.hpp" 31#include "glwFunctions.hpp" 32#include "glwEnums.hpp" 33#include "tcuTestLog.hpp" 34#include "tcuSurface.hpp" 35#include "tcuRenderTarget.hpp" 36#include "deRandom.hpp" 37#include "deStringUtil.hpp" 38#include "deMemory.h" 39#include "deString.h" 40 41#include <algorithm> 42#include <map> 43 44using tcu::TestLog; 45using std::string; 46using std::vector; 47using std::map; 48 49namespace deqp 50{ 51namespace gls 52{ 53namespace ub 54{ 55 56static bool isSupportedGLSLVersion (glu::GLSLVersion version) 57{ 58 return version >= (glslVersionIsES(version) ? glu::GLSL_VERSION_300_ES : glu::GLSL_VERSION_330); 59} 60 61struct PrecisionFlagsFmt 62{ 63 deUint32 flags; 64 PrecisionFlagsFmt (deUint32 flags_) : flags(flags_) {} 65}; 66 67std::ostream& operator<< (std::ostream& str, const PrecisionFlagsFmt& fmt) 68{ 69 // Precision. 70 DE_ASSERT(dePop32(fmt.flags & (PRECISION_LOW|PRECISION_MEDIUM|PRECISION_HIGH)) <= 1); 71 str << (fmt.flags & PRECISION_LOW ? "lowp" : 72 fmt.flags & PRECISION_MEDIUM ? "mediump" : 73 fmt.flags & PRECISION_HIGH ? "highp" : ""); 74 return str; 75} 76 77struct LayoutFlagsFmt 78{ 79 deUint32 flags; 80 LayoutFlagsFmt (deUint32 flags_) : flags(flags_) {} 81}; 82 83std::ostream& operator<< (std::ostream& str, const LayoutFlagsFmt& fmt) 84{ 85 static const struct 86 { 87 deUint32 bit; 88 const char* token; 89 } bitDesc[] = 90 { 91 { LAYOUT_SHARED, "shared" }, 92 { LAYOUT_PACKED, "packed" }, 93 { LAYOUT_STD140, "std140" }, 94 { LAYOUT_ROW_MAJOR, "row_major" }, 95 { LAYOUT_COLUMN_MAJOR, "column_major" } 96 }; 97 98 deUint32 remBits = fmt.flags; 99 for (int descNdx = 0; descNdx < DE_LENGTH_OF_ARRAY(bitDesc); descNdx++) 100 { 101 if (remBits & bitDesc[descNdx].bit) 102 { 103 if (remBits != fmt.flags) 104 str << ", "; 105 str << bitDesc[descNdx].token; 106 remBits &= ~bitDesc[descNdx].bit; 107 } 108 } 109 DE_ASSERT(remBits == 0); 110 return str; 111} 112 113// VarType implementation. 114 115VarType::VarType (void) 116 : m_type (TYPE_LAST) 117 , m_flags (0) 118{ 119} 120 121VarType::VarType (const VarType& other) 122 : m_type (TYPE_LAST) 123 , m_flags (0) 124{ 125 *this = other; 126} 127 128VarType::VarType (glu::DataType basicType, deUint32 flags) 129 : m_type (TYPE_BASIC) 130 , m_flags (flags) 131{ 132 m_data.basicType = basicType; 133} 134 135VarType::VarType (const VarType& elementType, int arraySize) 136 : m_type (TYPE_ARRAY) 137 , m_flags (0) 138{ 139 m_data.array.size = arraySize; 140 m_data.array.elementType = new VarType(elementType); 141} 142 143VarType::VarType (const StructType* structPtr) 144 : m_type (TYPE_STRUCT) 145 , m_flags (0) 146{ 147 m_data.structPtr = structPtr; 148} 149 150VarType::~VarType (void) 151{ 152 if (m_type == TYPE_ARRAY) 153 delete m_data.array.elementType; 154} 155 156VarType& VarType::operator= (const VarType& other) 157{ 158 if (this == &other) 159 return *this; // Self-assignment. 160 161 if (m_type == TYPE_ARRAY) 162 delete m_data.array.elementType; 163 164 m_type = other.m_type; 165 m_flags = other.m_flags; 166 m_data = Data(); 167 168 if (m_type == TYPE_ARRAY) 169 { 170 m_data.array.elementType = new VarType(*other.m_data.array.elementType); 171 m_data.array.size = other.m_data.array.size; 172 } 173 else 174 m_data = other.m_data; 175 176 return *this; 177} 178 179// StructType implementation. 180 181void StructType::addMember (const char* name, const VarType& type, deUint32 flags) 182{ 183 m_members.push_back(StructMember(name, type, flags)); 184} 185 186// Uniform implementation. 187 188Uniform::Uniform (const char* name, const VarType& type, deUint32 flags) 189 : m_name (name) 190 , m_type (type) 191 , m_flags (flags) 192{ 193} 194 195// UniformBlock implementation. 196 197UniformBlock::UniformBlock (const char* blockName) 198 : m_blockName (blockName) 199 , m_arraySize (0) 200 , m_flags (0) 201{ 202} 203 204struct BlockLayoutEntry 205{ 206 BlockLayoutEntry (void) 207 : size(0) 208 { 209 } 210 211 std::string name; 212 int size; 213 std::vector<int> activeUniformIndices; 214}; 215 216std::ostream& operator<< (std::ostream& stream, const BlockLayoutEntry& entry) 217{ 218 stream << entry.name << " { name = " << entry.name 219 << ", size = " << entry.size 220 << ", activeUniformIndices = ["; 221 222 for (vector<int>::const_iterator i = entry.activeUniformIndices.begin(); i != entry.activeUniformIndices.end(); i++) 223 { 224 if (i != entry.activeUniformIndices.begin()) 225 stream << ", "; 226 stream << *i; 227 } 228 229 stream << "] }"; 230 return stream; 231} 232 233struct UniformLayoutEntry 234{ 235 UniformLayoutEntry (void) 236 : type (glu::TYPE_LAST) 237 , size (0) 238 , blockNdx (-1) 239 , offset (-1) 240 , arrayStride (-1) 241 , matrixStride (-1) 242 , isRowMajor (false) 243 { 244 } 245 246 std::string name; 247 glu::DataType type; 248 int size; 249 int blockNdx; 250 int offset; 251 int arrayStride; 252 int matrixStride; 253 bool isRowMajor; 254}; 255 256std::ostream& operator<< (std::ostream& stream, const UniformLayoutEntry& entry) 257{ 258 stream << entry.name << " { type = " << glu::getDataTypeName(entry.type) 259 << ", size = " << entry.size 260 << ", blockNdx = " << entry.blockNdx 261 << ", offset = " << entry.offset 262 << ", arrayStride = " << entry.arrayStride 263 << ", matrixStride = " << entry.matrixStride 264 << ", isRowMajor = " << (entry.isRowMajor ? "true" : "false") 265 << " }"; 266 return stream; 267} 268 269class UniformLayout 270{ 271public: 272 std::vector<BlockLayoutEntry> blocks; 273 std::vector<UniformLayoutEntry> uniforms; 274 275 int getUniformIndex (const char* name) const; 276 int getBlockIndex (const char* name) const; 277}; 278 279// \todo [2012-01-24 pyry] Speed up lookups using hash. 280 281int UniformLayout::getUniformIndex (const char* name) const 282{ 283 for (int ndx = 0; ndx < (int)uniforms.size(); ndx++) 284 { 285 if (uniforms[ndx].name == name) 286 return ndx; 287 } 288 return -1; 289} 290 291int UniformLayout::getBlockIndex (const char* name) const 292{ 293 for (int ndx = 0; ndx < (int)blocks.size(); ndx++) 294 { 295 if (blocks[ndx].name == name) 296 return ndx; 297 } 298 return -1; 299} 300 301// ShaderInterface implementation. 302 303ShaderInterface::ShaderInterface (void) 304{ 305} 306 307ShaderInterface::~ShaderInterface (void) 308{ 309 for (std::vector<StructType*>::iterator i = m_structs.begin(); i != m_structs.end(); i++) 310 delete *i; 311 312 for (std::vector<UniformBlock*>::iterator i = m_uniformBlocks.begin(); i != m_uniformBlocks.end(); i++) 313 delete *i; 314} 315 316StructType& ShaderInterface::allocStruct (const char* name) 317{ 318 m_structs.reserve(m_structs.size()+1); 319 m_structs.push_back(new StructType(name)); 320 return *m_structs.back(); 321} 322 323struct StructNameEquals 324{ 325 std::string name; 326 327 StructNameEquals (const char* name_) : name(name_) {} 328 329 bool operator() (const StructType* type) const 330 { 331 return type->getTypeName() && name == type->getTypeName(); 332 } 333}; 334 335const StructType* ShaderInterface::findStruct (const char* name) const 336{ 337 std::vector<StructType*>::const_iterator pos = std::find_if(m_structs.begin(), m_structs.end(), StructNameEquals(name)); 338 return pos != m_structs.end() ? *pos : DE_NULL; 339} 340 341void ShaderInterface::getNamedStructs (std::vector<const StructType*>& structs) const 342{ 343 for (std::vector<StructType*>::const_iterator i = m_structs.begin(); i != m_structs.end(); i++) 344 { 345 if ((*i)->getTypeName() != DE_NULL) 346 structs.push_back(*i); 347 } 348} 349 350UniformBlock& ShaderInterface::allocBlock (const char* name) 351{ 352 m_uniformBlocks.reserve(m_uniformBlocks.size()+1); 353 m_uniformBlocks.push_back(new UniformBlock(name)); 354 return *m_uniformBlocks.back(); 355} 356 357namespace // Utilities 358{ 359 360// Layout computation. 361 362int getDataTypeByteSize (glu::DataType type) 363{ 364 return glu::getDataTypeScalarSize(type)*sizeof(deUint32); 365} 366 367int getDataTypeByteAlignment (glu::DataType type) 368{ 369 switch (type) 370 { 371 case glu::TYPE_FLOAT: 372 case glu::TYPE_INT: 373 case glu::TYPE_UINT: 374 case glu::TYPE_BOOL: return 1*sizeof(deUint32); 375 376 case glu::TYPE_FLOAT_VEC2: 377 case glu::TYPE_INT_VEC2: 378 case glu::TYPE_UINT_VEC2: 379 case glu::TYPE_BOOL_VEC2: return 2*sizeof(deUint32); 380 381 case glu::TYPE_FLOAT_VEC3: 382 case glu::TYPE_INT_VEC3: 383 case glu::TYPE_UINT_VEC3: 384 case glu::TYPE_BOOL_VEC3: // Fall-through to vec4 385 386 case glu::TYPE_FLOAT_VEC4: 387 case glu::TYPE_INT_VEC4: 388 case glu::TYPE_UINT_VEC4: 389 case glu::TYPE_BOOL_VEC4: return 4*sizeof(deUint32); 390 391 default: 392 DE_ASSERT(false); 393 return 0; 394 } 395} 396 397int getDataTypeArrayStride (glu::DataType type) 398{ 399 DE_ASSERT(!glu::isDataTypeMatrix(type)); 400 401 int baseStride = getDataTypeByteSize(type); 402 int vec4Alignment = sizeof(deUint32)*4; 403 404 DE_ASSERT(baseStride <= vec4Alignment); 405 return de::max(baseStride, vec4Alignment); // Really? See rule 4. 406} 407 408static inline int deRoundUp32 (int a, int b) 409{ 410 int d = a/b; 411 return d*b == a ? a : (d+1)*b; 412} 413 414int computeStd140BaseAlignment (const VarType& type) 415{ 416 const int vec4Alignment = sizeof(deUint32)*4; 417 418 if (type.isBasicType()) 419 { 420 glu::DataType basicType = type.getBasicType(); 421 422 if (glu::isDataTypeMatrix(basicType)) 423 { 424 bool isRowMajor = !!(type.getFlags() & LAYOUT_ROW_MAJOR); 425 int vecSize = isRowMajor ? glu::getDataTypeMatrixNumColumns(basicType) 426 : glu::getDataTypeMatrixNumRows(basicType); 427 428 return getDataTypeArrayStride(glu::getDataTypeFloatVec(vecSize)); 429 } 430 else 431 return getDataTypeByteAlignment(basicType); 432 } 433 else if (type.isArrayType()) 434 { 435 int elemAlignment = computeStd140BaseAlignment(type.getElementType()); 436 437 // Round up to alignment of vec4 438 return deRoundUp32(elemAlignment, vec4Alignment); 439 } 440 else 441 { 442 DE_ASSERT(type.isStructType()); 443 444 int maxBaseAlignment = 0; 445 446 for (StructType::ConstIterator memberIter = type.getStruct().begin(); memberIter != type.getStruct().end(); memberIter++) 447 maxBaseAlignment = de::max(maxBaseAlignment, computeStd140BaseAlignment(memberIter->getType())); 448 449 return deRoundUp32(maxBaseAlignment, vec4Alignment); 450 } 451} 452 453inline deUint32 mergeLayoutFlags (deUint32 prevFlags, deUint32 newFlags) 454{ 455 const deUint32 packingMask = LAYOUT_PACKED|LAYOUT_SHARED|LAYOUT_STD140; 456 const deUint32 matrixMask = LAYOUT_ROW_MAJOR|LAYOUT_COLUMN_MAJOR; 457 458 deUint32 mergedFlags = 0; 459 460 mergedFlags |= ((newFlags & packingMask) ? newFlags : prevFlags) & packingMask; 461 mergedFlags |= ((newFlags & matrixMask) ? newFlags : prevFlags) & matrixMask; 462 463 return mergedFlags; 464} 465 466void computeStd140Layout (UniformLayout& layout, int& curOffset, int curBlockNdx, const std::string& curPrefix, const VarType& type, deUint32 layoutFlags) 467{ 468 int baseAlignment = computeStd140BaseAlignment(type); 469 470 curOffset = deAlign32(curOffset, baseAlignment); 471 472 if (type.isBasicType()) 473 { 474 glu::DataType basicType = type.getBasicType(); 475 UniformLayoutEntry entry; 476 477 entry.name = curPrefix; 478 entry.type = basicType; 479 entry.size = 1; 480 entry.arrayStride = 0; 481 entry.matrixStride = 0; 482 entry.blockNdx = curBlockNdx; 483 484 if (glu::isDataTypeMatrix(basicType)) 485 { 486 // Array of vectors as specified in rules 5 & 7. 487 bool isRowMajor = !!(layoutFlags & LAYOUT_ROW_MAJOR); 488 int vecSize = isRowMajor ? glu::getDataTypeMatrixNumColumns(basicType) 489 : glu::getDataTypeMatrixNumRows(basicType); 490 int numVecs = isRowMajor ? glu::getDataTypeMatrixNumRows(basicType) 491 : glu::getDataTypeMatrixNumColumns(basicType); 492 int stride = getDataTypeArrayStride(glu::getDataTypeFloatVec(vecSize)); 493 494 entry.offset = curOffset; 495 entry.matrixStride = stride; 496 entry.isRowMajor = isRowMajor; 497 498 curOffset += numVecs*stride; 499 } 500 else 501 { 502 // Scalar or vector. 503 entry.offset = curOffset; 504 505 curOffset += getDataTypeByteSize(basicType); 506 } 507 508 layout.uniforms.push_back(entry); 509 } 510 else if (type.isArrayType()) 511 { 512 const VarType& elemType = type.getElementType(); 513 514 if (elemType.isBasicType() && !glu::isDataTypeMatrix(elemType.getBasicType())) 515 { 516 // Array of scalars or vectors. 517 glu::DataType elemBasicType = elemType.getBasicType(); 518 UniformLayoutEntry entry; 519 int stride = getDataTypeArrayStride(elemBasicType); 520 521 entry.name = curPrefix + "[0]"; // Array uniforms are always postfixed with [0] 522 entry.type = elemBasicType; 523 entry.blockNdx = curBlockNdx; 524 entry.offset = curOffset; 525 entry.size = type.getArraySize(); 526 entry.arrayStride = stride; 527 entry.matrixStride = 0; 528 529 curOffset += stride*type.getArraySize(); 530 531 layout.uniforms.push_back(entry); 532 } 533 else if (elemType.isBasicType() && glu::isDataTypeMatrix(elemType.getBasicType())) 534 { 535 // Array of matrices. 536 glu::DataType elemBasicType = elemType.getBasicType(); 537 bool isRowMajor = !!(layoutFlags & LAYOUT_ROW_MAJOR); 538 int vecSize = isRowMajor ? glu::getDataTypeMatrixNumColumns(elemBasicType) 539 : glu::getDataTypeMatrixNumRows(elemBasicType); 540 int numVecs = isRowMajor ? glu::getDataTypeMatrixNumRows(elemBasicType) 541 : glu::getDataTypeMatrixNumColumns(elemBasicType); 542 int stride = getDataTypeArrayStride(glu::getDataTypeFloatVec(vecSize)); 543 UniformLayoutEntry entry; 544 545 entry.name = curPrefix + "[0]"; // Array uniforms are always postfixed with [0] 546 entry.type = elemBasicType; 547 entry.blockNdx = curBlockNdx; 548 entry.offset = curOffset; 549 entry.size = type.getArraySize(); 550 entry.arrayStride = stride*numVecs; 551 entry.matrixStride = stride; 552 entry.isRowMajor = isRowMajor; 553 554 curOffset += numVecs*type.getArraySize()*stride; 555 556 layout.uniforms.push_back(entry); 557 } 558 else 559 { 560 DE_ASSERT(elemType.isStructType() || elemType.isArrayType()); 561 562 for (int elemNdx = 0; elemNdx < type.getArraySize(); elemNdx++) 563 computeStd140Layout(layout, curOffset, curBlockNdx, curPrefix + "[" + de::toString(elemNdx) + "]", type.getElementType(), layoutFlags); 564 } 565 } 566 else 567 { 568 DE_ASSERT(type.isStructType()); 569 570 for (StructType::ConstIterator memberIter = type.getStruct().begin(); memberIter != type.getStruct().end(); memberIter++) 571 computeStd140Layout(layout, curOffset, curBlockNdx, curPrefix + "." + memberIter->getName(), memberIter->getType(), layoutFlags); 572 573 curOffset = deAlign32(curOffset, baseAlignment); 574 } 575} 576 577void computeStd140Layout (UniformLayout& layout, const ShaderInterface& interface) 578{ 579 // \todo [2012-01-23 pyry] Uniforms in default block. 580 581 int numUniformBlocks = interface.getNumUniformBlocks(); 582 583 for (int blockNdx = 0; blockNdx < numUniformBlocks; blockNdx++) 584 { 585 const UniformBlock& block = interface.getUniformBlock(blockNdx); 586 bool hasInstanceName = block.getInstanceName() != DE_NULL; 587 std::string blockPrefix = hasInstanceName ? (std::string(block.getBlockName()) + ".") : std::string(""); 588 int curOffset = 0; 589 int activeBlockNdx = (int)layout.blocks.size(); 590 int firstUniformNdx = (int)layout.uniforms.size(); 591 592 for (UniformBlock::ConstIterator uniformIter = block.begin(); uniformIter != block.end(); uniformIter++) 593 { 594 const Uniform& uniform = *uniformIter; 595 computeStd140Layout(layout, curOffset, activeBlockNdx, blockPrefix + uniform.getName(), uniform.getType(), mergeLayoutFlags(block.getFlags(), uniform.getFlags())); 596 } 597 598 int uniformIndicesEnd = (int)layout.uniforms.size(); 599 int blockSize = curOffset; 600 int numInstances = block.isArray() ? block.getArraySize() : 1; 601 602 // Create block layout entries for each instance. 603 for (int instanceNdx = 0; instanceNdx < numInstances; instanceNdx++) 604 { 605 // Allocate entry for instance. 606 layout.blocks.push_back(BlockLayoutEntry()); 607 BlockLayoutEntry& blockEntry = layout.blocks.back(); 608 609 blockEntry.name = block.getBlockName(); 610 blockEntry.size = blockSize; 611 612 // Compute active uniform set for block. 613 for (int uniformNdx = firstUniformNdx; uniformNdx < uniformIndicesEnd; uniformNdx++) 614 blockEntry.activeUniformIndices.push_back(uniformNdx); 615 616 if (block.isArray()) 617 blockEntry.name += "[" + de::toString(instanceNdx) + "]"; 618 } 619 } 620} 621 622// Value generator. 623 624void generateValue (const UniformLayoutEntry& entry, void* basePtr, de::Random& rnd) 625{ 626 glu::DataType scalarType = glu::getDataTypeScalarType(entry.type); 627 int scalarSize = glu::getDataTypeScalarSize(entry.type); 628 bool isMatrix = glu::isDataTypeMatrix(entry.type); 629 int numVecs = isMatrix ? (entry.isRowMajor ? glu::getDataTypeMatrixNumRows(entry.type) : glu::getDataTypeMatrixNumColumns(entry.type)) : 1; 630 int vecSize = scalarSize / numVecs; 631 bool isArray = entry.size > 1; 632 const int compSize = sizeof(deUint32); 633 634 DE_ASSERT(scalarSize%numVecs == 0); 635 636 for (int elemNdx = 0; elemNdx < entry.size; elemNdx++) 637 { 638 deUint8* elemPtr = (deUint8*)basePtr + entry.offset + (isArray ? elemNdx*entry.arrayStride : 0); 639 640 for (int vecNdx = 0; vecNdx < numVecs; vecNdx++) 641 { 642 deUint8* vecPtr = elemPtr + (isMatrix ? vecNdx*entry.matrixStride : 0); 643 644 for (int compNdx = 0; compNdx < vecSize; compNdx++) 645 { 646 deUint8* compPtr = vecPtr + compSize*compNdx; 647 648 switch (scalarType) 649 { 650 case glu::TYPE_FLOAT: *((float*)compPtr) = (float)rnd.getInt(-9, 9); break; 651 case glu::TYPE_INT: *((int*)compPtr) = rnd.getInt(-9, 9); break; 652 case glu::TYPE_UINT: *((deUint32*)compPtr) = (deUint32)rnd.getInt(0, 9); break; 653 // \note Random bit pattern is used for true values. Spec states that all non-zero values are 654 // interpreted as true but some implementations fail this. 655 case glu::TYPE_BOOL: *((deUint32*)compPtr) = rnd.getBool() ? rnd.getUint32()|1u : 0u; break; 656 default: 657 DE_ASSERT(false); 658 } 659 } 660 } 661 } 662} 663 664void generateValues (const UniformLayout& layout, const std::map<int, void*>& blockPointers, deUint32 seed) 665{ 666 de::Random rnd (seed); 667 int numBlocks = (int)layout.blocks.size(); 668 669 for (int blockNdx = 0; blockNdx < numBlocks; blockNdx++) 670 { 671 void* basePtr = blockPointers.find(blockNdx)->second; 672 int numEntries = (int)layout.blocks[blockNdx].activeUniformIndices.size(); 673 674 for (int entryNdx = 0; entryNdx < numEntries; entryNdx++) 675 { 676 const UniformLayoutEntry& entry = layout.uniforms[layout.blocks[blockNdx].activeUniformIndices[entryNdx]]; 677 generateValue(entry, basePtr, rnd); 678 } 679 } 680} 681 682// Shader generator. 683 684const char* getCompareFuncForType (glu::DataType type) 685{ 686 switch (type) 687 { 688 case glu::TYPE_FLOAT: return "mediump float compare_float (highp float a, highp float b) { return abs(a - b) < 0.05 ? 1.0 : 0.0; }\n"; 689 case glu::TYPE_FLOAT_VEC2: return "mediump float compare_vec2 (highp vec2 a, highp vec2 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y); }\n"; 690 case glu::TYPE_FLOAT_VEC3: return "mediump float compare_vec3 (highp vec3 a, highp vec3 b) { return compare_float(a.x, b.x)*compare_float(a.y, b.y)*compare_float(a.z, b.z); }\n"; 691 case glu::TYPE_FLOAT_VEC4: return "mediump float compare_vec4 (highp vec4 a, highp 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); }\n"; 692 case glu::TYPE_FLOAT_MAT2: return "mediump float compare_mat2 (highp mat2 a, highp mat2 b) { return compare_vec2(a[0], b[0])*compare_vec2(a[1], b[1]); }\n"; 693 case glu::TYPE_FLOAT_MAT2X3: return "mediump float compare_mat2x3 (highp mat2x3 a, highp mat2x3 b){ return compare_vec3(a[0], b[0])*compare_vec3(a[1], b[1]); }\n"; 694 case glu::TYPE_FLOAT_MAT2X4: return "mediump float compare_mat2x4 (highp mat2x4 a, highp mat2x4 b){ return compare_vec4(a[0], b[0])*compare_vec4(a[1], b[1]); }\n"; 695 case glu::TYPE_FLOAT_MAT3X2: return "mediump float compare_mat3x2 (highp mat3x2 a, highp mat3x2 b){ return compare_vec2(a[0], b[0])*compare_vec2(a[1], b[1])*compare_vec2(a[2], b[2]); }\n"; 696 case glu::TYPE_FLOAT_MAT3: return "mediump float compare_mat3 (highp mat3 a, highp mat3 b) { return compare_vec3(a[0], b[0])*compare_vec3(a[1], b[1])*compare_vec3(a[2], b[2]); }\n"; 697 case glu::TYPE_FLOAT_MAT3X4: return "mediump float compare_mat3x4 (highp mat3x4 a, highp mat3x4 b){ return compare_vec4(a[0], b[0])*compare_vec4(a[1], b[1])*compare_vec4(a[2], b[2]); }\n"; 698 case glu::TYPE_FLOAT_MAT4X2: return "mediump float compare_mat4x2 (highp mat4x2 a, highp mat4x2 b){ return compare_vec2(a[0], b[0])*compare_vec2(a[1], b[1])*compare_vec2(a[2], b[2])*compare_vec2(a[3], b[3]); }\n"; 699 case glu::TYPE_FLOAT_MAT4X3: return "mediump float compare_mat4x3 (highp mat4x3 a, highp mat4x3 b){ return compare_vec3(a[0], b[0])*compare_vec3(a[1], b[1])*compare_vec3(a[2], b[2])*compare_vec3(a[3], b[3]); }\n"; 700 case glu::TYPE_FLOAT_MAT4: return "mediump float compare_mat4 (highp mat4 a, highp 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]); }\n"; 701 case glu::TYPE_INT: return "mediump float compare_int (highp int a, highp int b) { return a == b ? 1.0 : 0.0; }\n"; 702 case glu::TYPE_INT_VEC2: return "mediump float compare_ivec2 (highp ivec2 a, highp ivec2 b) { return a == b ? 1.0 : 0.0; }\n"; 703 case glu::TYPE_INT_VEC3: return "mediump float compare_ivec3 (highp ivec3 a, highp ivec3 b) { return a == b ? 1.0 : 0.0; }\n"; 704 case glu::TYPE_INT_VEC4: return "mediump float compare_ivec4 (highp ivec4 a, highp ivec4 b) { return a == b ? 1.0 : 0.0; }\n"; 705 case glu::TYPE_UINT: return "mediump float compare_uint (highp uint a, highp uint b) { return a == b ? 1.0 : 0.0; }\n"; 706 case glu::TYPE_UINT_VEC2: return "mediump float compare_uvec2 (highp uvec2 a, highp uvec2 b) { return a == b ? 1.0 : 0.0; }\n"; 707 case glu::TYPE_UINT_VEC3: return "mediump float compare_uvec3 (highp uvec3 a, highp uvec3 b) { return a == b ? 1.0 : 0.0; }\n"; 708 case glu::TYPE_UINT_VEC4: return "mediump float compare_uvec4 (highp uvec4 a, highp uvec4 b) { return a == b ? 1.0 : 0.0; }\n"; 709 case glu::TYPE_BOOL: return "mediump float compare_bool (bool a, bool b) { return a == b ? 1.0 : 0.0; }\n"; 710 case glu::TYPE_BOOL_VEC2: return "mediump float compare_bvec2 (bvec2 a, bvec2 b) { return a == b ? 1.0 : 0.0; }\n"; 711 case glu::TYPE_BOOL_VEC3: return "mediump float compare_bvec3 (bvec3 a, bvec3 b) { return a == b ? 1.0 : 0.0; }\n"; 712 case glu::TYPE_BOOL_VEC4: return "mediump float compare_bvec4 (bvec4 a, bvec4 b) { return a == b ? 1.0 : 0.0; }\n"; 713 default: 714 DE_ASSERT(false); 715 return DE_NULL; 716 } 717} 718 719void getCompareDependencies (std::set<glu::DataType>& compareFuncs, glu::DataType basicType) 720{ 721 switch (basicType) 722 { 723 case glu::TYPE_FLOAT_VEC2: 724 case glu::TYPE_FLOAT_VEC3: 725 case glu::TYPE_FLOAT_VEC4: 726 compareFuncs.insert(glu::TYPE_FLOAT); 727 compareFuncs.insert(basicType); 728 break; 729 730 case glu::TYPE_FLOAT_MAT2: 731 case glu::TYPE_FLOAT_MAT2X3: 732 case glu::TYPE_FLOAT_MAT2X4: 733 case glu::TYPE_FLOAT_MAT3X2: 734 case glu::TYPE_FLOAT_MAT3: 735 case glu::TYPE_FLOAT_MAT3X4: 736 case glu::TYPE_FLOAT_MAT4X2: 737 case glu::TYPE_FLOAT_MAT4X3: 738 case glu::TYPE_FLOAT_MAT4: 739 compareFuncs.insert(glu::TYPE_FLOAT); 740 compareFuncs.insert(glu::getDataTypeFloatVec(glu::getDataTypeMatrixNumRows(basicType))); 741 compareFuncs.insert(basicType); 742 break; 743 744 default: 745 compareFuncs.insert(basicType); 746 break; 747 } 748} 749 750void collectUniqueBasicTypes (std::set<glu::DataType>& basicTypes, const VarType& type) 751{ 752 if (type.isStructType()) 753 { 754 for (StructType::ConstIterator iter = type.getStruct().begin(); iter != type.getStruct().end(); ++iter) 755 collectUniqueBasicTypes(basicTypes, iter->getType()); 756 } 757 else if (type.isArrayType()) 758 collectUniqueBasicTypes(basicTypes, type.getElementType()); 759 else 760 { 761 DE_ASSERT(type.isBasicType()); 762 basicTypes.insert(type.getBasicType()); 763 } 764} 765 766void collectUniqueBasicTypes (std::set<glu::DataType>& basicTypes, const UniformBlock& uniformBlock) 767{ 768 for (UniformBlock::ConstIterator iter = uniformBlock.begin(); iter != uniformBlock.end(); ++iter) 769 collectUniqueBasicTypes(basicTypes, iter->getType()); 770} 771 772void collectUniqueBasicTypes (std::set<glu::DataType>& basicTypes, const ShaderInterface& interface) 773{ 774 for (int ndx = 0; ndx < interface.getNumUniformBlocks(); ++ndx) 775 collectUniqueBasicTypes(basicTypes, interface.getUniformBlock(ndx)); 776} 777 778void generateCompareFuncs (std::ostream& str, const ShaderInterface& interface) 779{ 780 std::set<glu::DataType> types; 781 std::set<glu::DataType> compareFuncs; 782 783 // Collect unique basic types 784 collectUniqueBasicTypes(types, interface); 785 786 // Set of compare functions required 787 for (std::set<glu::DataType>::const_iterator iter = types.begin(); iter != types.end(); ++iter) 788 { 789 getCompareDependencies(compareFuncs, *iter); 790 } 791 792 for (int type = 0; type < glu::TYPE_LAST; ++type) 793 { 794 if (compareFuncs.find(glu::DataType(type)) != compareFuncs.end()) 795 str << getCompareFuncForType(glu::DataType(type)); 796 } 797} 798 799struct Indent 800{ 801 int level; 802 Indent (int level_) : level(level_) {} 803}; 804 805std::ostream& operator<< (std::ostream& str, const Indent& indent) 806{ 807 for (int i = 0; i < indent.level; i++) 808 str << "\t"; 809 return str; 810} 811 812void generateDeclaration (std::ostringstream& src, const VarType& type, const char* name, int indentLevel, deUint32 unusedHints); 813void generateDeclaration (std::ostringstream& src, const Uniform& uniform, int indentLevel); 814void generateDeclaration (std::ostringstream& src, const StructType& structType, int indentLevel); 815 816void generateLocalDeclaration (std::ostringstream& src, const StructType& structType, int indentLevel); 817void generateFullDeclaration (std::ostringstream& src, const StructType& structType, int indentLevel); 818 819void generateDeclaration (std::ostringstream& src, const StructType& structType, int indentLevel) 820{ 821 DE_ASSERT(structType.getTypeName() != DE_NULL); 822 generateFullDeclaration(src, structType, indentLevel); 823 src << ";\n"; 824} 825 826void generateFullDeclaration (std::ostringstream& src, const StructType& structType, int indentLevel) 827{ 828 src << "struct"; 829 if (structType.getTypeName()) 830 src << " " << structType.getTypeName(); 831 src << "\n" << Indent(indentLevel) << "{\n"; 832 833 for (StructType::ConstIterator memberIter = structType.begin(); memberIter != structType.end(); memberIter++) 834 { 835 src << Indent(indentLevel+1); 836 generateDeclaration(src, memberIter->getType(), memberIter->getName(), indentLevel+1, memberIter->getFlags() & UNUSED_BOTH); 837 } 838 839 src << Indent(indentLevel) << "}"; 840} 841 842void generateLocalDeclaration (std::ostringstream& src, const StructType& structType, int indentLevel) 843{ 844 if (structType.getTypeName() == DE_NULL) 845 generateFullDeclaration(src, structType, indentLevel); 846 else 847 src << structType.getTypeName(); 848} 849 850void generateDeclaration (std::ostringstream& src, const VarType& type, const char* name, int indentLevel, deUint32 unusedHints) 851{ 852 deUint32 flags = type.getFlags(); 853 854 if ((flags & LAYOUT_MASK) != 0) 855 src << "layout(" << LayoutFlagsFmt(flags & LAYOUT_MASK) << ") "; 856 857 if ((flags & PRECISION_MASK) != 0) 858 src << PrecisionFlagsFmt(flags & PRECISION_MASK) << " "; 859 860 if (type.isBasicType()) 861 src << glu::getDataTypeName(type.getBasicType()) << " " << name; 862 else if (type.isArrayType()) 863 { 864 std::vector<int> arraySizes; 865 const VarType* curType = &type; 866 while (curType->isArrayType()) 867 { 868 arraySizes.push_back(curType->getArraySize()); 869 curType = &curType->getElementType(); 870 } 871 872 if (curType->isBasicType()) 873 { 874 if ((curType->getFlags() & PRECISION_MASK) != 0) 875 src << PrecisionFlagsFmt(curType->getFlags() & PRECISION_MASK) << " "; 876 src << glu::getDataTypeName(curType->getBasicType()); 877 } 878 else 879 { 880 DE_ASSERT(curType->isStructType()); 881 generateLocalDeclaration(src, curType->getStruct(), indentLevel+1); 882 } 883 884 src << " " << name; 885 886 for (std::vector<int>::const_iterator sizeIter = arraySizes.begin(); sizeIter != arraySizes.end(); sizeIter++) 887 src << "[" << *sizeIter << "]"; 888 } 889 else 890 { 891 generateLocalDeclaration(src, type.getStruct(), indentLevel+1); 892 src << " " << name; 893 } 894 895 src << ";"; 896 897 // Print out unused hints. 898 if (unusedHints != 0) 899 src << " // unused in " << (unusedHints == UNUSED_BOTH ? "both shaders" : 900 unusedHints == UNUSED_VERTEX ? "vertex shader" : 901 unusedHints == UNUSED_FRAGMENT ? "fragment shader" : "???"); 902 903 src << "\n"; 904} 905 906void generateDeclaration (std::ostringstream& src, const Uniform& uniform, int indentLevel) 907{ 908 if ((uniform.getFlags() & LAYOUT_MASK) != 0) 909 src << "layout(" << LayoutFlagsFmt(uniform.getFlags() & LAYOUT_MASK) << ") "; 910 911 generateDeclaration(src, uniform.getType(), uniform.getName(), indentLevel, uniform.getFlags() & UNUSED_BOTH); 912} 913 914void generateDeclaration (std::ostringstream& src, const UniformBlock& block) 915{ 916 if ((block.getFlags() & LAYOUT_MASK) != 0) 917 src << "layout(" << LayoutFlagsFmt(block.getFlags() & LAYOUT_MASK) << ") "; 918 919 src << "uniform " << block.getBlockName(); 920 src << "\n{\n"; 921 922 for (UniformBlock::ConstIterator uniformIter = block.begin(); uniformIter != block.end(); uniformIter++) 923 { 924 src << Indent(1); 925 generateDeclaration(src, *uniformIter, 1 /* indent level */); 926 } 927 928 src << "}"; 929 930 if (block.getInstanceName() != DE_NULL) 931 { 932 src << " " << block.getInstanceName(); 933 if (block.isArray()) 934 src << "[" << block.getArraySize() << "]"; 935 } 936 else 937 DE_ASSERT(!block.isArray()); 938 939 src << ";\n"; 940} 941 942void generateValueSrc (std::ostringstream& src, const UniformLayoutEntry& entry, const void* basePtr, int elementNdx) 943{ 944 glu::DataType scalarType = glu::getDataTypeScalarType(entry.type); 945 int scalarSize = glu::getDataTypeScalarSize(entry.type); 946 bool isArray = entry.size > 1; 947 const deUint8* elemPtr = (const deUint8*)basePtr + entry.offset + (isArray ? elementNdx*entry.arrayStride : 0); 948 const int compSize = sizeof(deUint32); 949 950 if (scalarSize > 1) 951 src << glu::getDataTypeName(entry.type) << "("; 952 953 if (glu::isDataTypeMatrix(entry.type)) 954 { 955 int numRows = glu::getDataTypeMatrixNumRows(entry.type); 956 int numCols = glu::getDataTypeMatrixNumColumns(entry.type); 957 958 DE_ASSERT(scalarType == glu::TYPE_FLOAT); 959 960 // Constructed in column-wise order. 961 for (int colNdx = 0; colNdx < numCols; colNdx++) 962 { 963 for (int rowNdx = 0; rowNdx < numRows; rowNdx++) 964 { 965 const deUint8* compPtr = elemPtr + (entry.isRowMajor ? rowNdx*entry.matrixStride + colNdx*compSize 966 : colNdx*entry.matrixStride + rowNdx*compSize); 967 968 if (colNdx > 0 || rowNdx > 0) 969 src << ", "; 970 971 src << de::floatToString(*((const float*)compPtr), 1); 972 } 973 } 974 } 975 else 976 { 977 for (int scalarNdx = 0; scalarNdx < scalarSize; scalarNdx++) 978 { 979 const deUint8* compPtr = elemPtr + scalarNdx*compSize; 980 981 if (scalarNdx > 0) 982 src << ", "; 983 984 switch (scalarType) 985 { 986 case glu::TYPE_FLOAT: src << de::floatToString(*((const float*)compPtr), 1); break; 987 case glu::TYPE_INT: src << *((const int*)compPtr); break; 988 case glu::TYPE_UINT: src << *((const deUint32*)compPtr) << "u"; break; 989 case glu::TYPE_BOOL: src << (*((const deUint32*)compPtr) != 0u ? "true" : "false"); break; 990 default: 991 DE_ASSERT(false); 992 } 993 } 994 } 995 996 if (scalarSize > 1) 997 src << ")"; 998} 999 1000void generateCompareSrc (std::ostringstream& src, const char* resultVar, const VarType& type, const char* srcName, const char* apiName, const UniformLayout& layout, const void* basePtr, deUint32 unusedMask) 1001{ 1002 if (type.isBasicType() || (type.isArrayType() && type.getElementType().isBasicType())) 1003 { 1004 // Basic type or array of basic types. 1005 bool isArray = type.isArrayType(); 1006 glu::DataType elementType = isArray ? type.getElementType().getBasicType() : type.getBasicType(); 1007 const char* typeName = glu::getDataTypeName(elementType); 1008 std::string fullApiName = string(apiName) + (isArray ? "[0]" : ""); // Arrays are always postfixed with [0] 1009 int uniformNdx = layout.getUniformIndex(fullApiName.c_str()); 1010 const UniformLayoutEntry& entry = layout.uniforms[uniformNdx]; 1011 1012 if (isArray) 1013 { 1014 for (int elemNdx = 0; elemNdx < type.getArraySize(); elemNdx++) 1015 { 1016 src << "\tresult *= compare_" << typeName << "(" << srcName << "[" << elemNdx << "], "; 1017 generateValueSrc(src, entry, basePtr, elemNdx); 1018 src << ");\n"; 1019 } 1020 } 1021 else 1022 { 1023 src << "\tresult *= compare_" << typeName << "(" << srcName << ", "; 1024 generateValueSrc(src, entry, basePtr, 0); 1025 src << ");\n"; 1026 } 1027 } 1028 else if (type.isArrayType()) 1029 { 1030 const VarType& elementType = type.getElementType(); 1031 1032 for (int elementNdx = 0; elementNdx < type.getArraySize(); elementNdx++) 1033 { 1034 std::string op = string("[") + de::toString(elementNdx) + "]"; 1035 generateCompareSrc(src, resultVar, elementType, (string(srcName) + op).c_str(), (string(apiName) + op).c_str(), layout, basePtr, unusedMask); 1036 } 1037 } 1038 else 1039 { 1040 DE_ASSERT(type.isStructType()); 1041 1042 for (StructType::ConstIterator memberIter = type.getStruct().begin(); memberIter != type.getStruct().end(); memberIter++) 1043 { 1044 if (memberIter->getFlags() & unusedMask) 1045 continue; // Skip member. 1046 1047 string op = string(".") + memberIter->getName(); 1048 generateCompareSrc(src, resultVar, memberIter->getType(), (string(srcName) + op).c_str(), (string(apiName) + op).c_str(), layout, basePtr, unusedMask); 1049 } 1050 } 1051} 1052 1053void generateCompareSrc (std::ostringstream& src, const char* resultVar, const ShaderInterface& interface, const UniformLayout& layout, const std::map<int, void*>& blockPointers, bool isVertex) 1054{ 1055 deUint32 unusedMask = isVertex ? UNUSED_VERTEX : UNUSED_FRAGMENT; 1056 1057 for (int blockNdx = 0; blockNdx < interface.getNumUniformBlocks(); blockNdx++) 1058 { 1059 const UniformBlock& block = interface.getUniformBlock(blockNdx); 1060 1061 if ((block.getFlags() & (isVertex ? DECLARE_VERTEX : DECLARE_FRAGMENT)) == 0) 1062 continue; // Skip. 1063 1064 bool hasInstanceName = block.getInstanceName() != DE_NULL; 1065 bool isArray = block.isArray(); 1066 int numInstances = isArray ? block.getArraySize() : 1; 1067 std::string apiPrefix = hasInstanceName ? string(block.getBlockName()) + "." : string(""); 1068 1069 DE_ASSERT(!isArray || hasInstanceName); 1070 1071 for (int instanceNdx = 0; instanceNdx < numInstances; instanceNdx++) 1072 { 1073 std::string instancePostfix = isArray ? string("[") + de::toString(instanceNdx) + "]" : string(""); 1074 std::string blockInstanceName = block.getBlockName() + instancePostfix; 1075 std::string srcPrefix = hasInstanceName ? string(block.getInstanceName()) + instancePostfix + "." : string(""); 1076 int activeBlockNdx = layout.getBlockIndex(blockInstanceName.c_str()); 1077 void* basePtr = blockPointers.find(activeBlockNdx)->second; 1078 1079 for (UniformBlock::ConstIterator uniformIter = block.begin(); uniformIter != block.end(); uniformIter++) 1080 { 1081 const Uniform& uniform = *uniformIter; 1082 1083 if (uniform.getFlags() & unusedMask) 1084 continue; // Don't read from that uniform. 1085 1086 generateCompareSrc(src, resultVar, uniform.getType(), (srcPrefix + uniform.getName()).c_str(), (apiPrefix + uniform.getName()).c_str(), layout, basePtr, unusedMask); 1087 } 1088 } 1089 } 1090} 1091 1092void generateVertexShader (std::ostringstream& src, glu::GLSLVersion glslVersion, const ShaderInterface& interface, const UniformLayout& layout, const std::map<int, void*>& blockPointers) 1093{ 1094 DE_ASSERT(isSupportedGLSLVersion(glslVersion)); 1095 1096 src << glu::getGLSLVersionDeclaration(glslVersion) << "\n"; 1097 src << "in highp vec4 a_position;\n"; 1098 src << "out mediump float v_vtxResult;\n"; 1099 src << "\n"; 1100 1101 std::vector<const StructType*> namedStructs; 1102 interface.getNamedStructs(namedStructs); 1103 for (std::vector<const StructType*>::const_iterator structIter = namedStructs.begin(); structIter != namedStructs.end(); structIter++) 1104 generateDeclaration(src, **structIter, 0); 1105 1106 for (int blockNdx = 0; blockNdx < interface.getNumUniformBlocks(); blockNdx++) 1107 { 1108 const UniformBlock& block = interface.getUniformBlock(blockNdx); 1109 if (block.getFlags() & DECLARE_VERTEX) 1110 generateDeclaration(src, block); 1111 } 1112 1113 // Comparison utilities. 1114 src << "\n"; 1115 generateCompareFuncs(src, interface); 1116 1117 src << "\n" 1118 "void main (void)\n" 1119 "{\n" 1120 " gl_Position = a_position;\n" 1121 " mediump float result = 1.0;\n"; 1122 1123 // Value compare. 1124 generateCompareSrc(src, "result", interface, layout, blockPointers, true); 1125 1126 src << " v_vtxResult = result;\n" 1127 "}\n"; 1128} 1129 1130void generateFragmentShader (std::ostringstream& src, glu::GLSLVersion glslVersion, const ShaderInterface& interface, const UniformLayout& layout, const std::map<int, void*>& blockPointers) 1131{ 1132 DE_ASSERT(isSupportedGLSLVersion(glslVersion)); 1133 1134 src << glu::getGLSLVersionDeclaration(glslVersion) << "\n"; 1135 src << "in mediump float v_vtxResult;\n"; 1136 src << "layout(location = 0) out mediump vec4 dEQP_FragColor;\n"; 1137 src << "\n"; 1138 1139 std::vector<const StructType*> namedStructs; 1140 interface.getNamedStructs(namedStructs); 1141 for (std::vector<const StructType*>::const_iterator structIter = namedStructs.begin(); structIter != namedStructs.end(); structIter++) 1142 generateDeclaration(src, **structIter, 0); 1143 1144 for (int blockNdx = 0; blockNdx < interface.getNumUniformBlocks(); blockNdx++) 1145 { 1146 const UniformBlock& block = interface.getUniformBlock(blockNdx); 1147 if (block.getFlags() & DECLARE_FRAGMENT) 1148 generateDeclaration(src, block); 1149 } 1150 1151 // Comparison utilities. 1152 src << "\n"; 1153 generateCompareFuncs(src, interface); 1154 1155 src << "\n" 1156 "void main (void)\n" 1157 "{\n" 1158 " mediump float result = 1.0;\n"; 1159 1160 // Value compare. 1161 generateCompareSrc(src, "result", interface, layout, blockPointers, false); 1162 1163 src << " dEQP_FragColor = vec4(1.0, v_vtxResult, result, 1.0);\n" 1164 "}\n"; 1165} 1166 1167void getGLUniformLayout (const glw::Functions& gl, UniformLayout& layout, deUint32 program) 1168{ 1169 int numActiveUniforms = 0; 1170 int numActiveBlocks = 0; 1171 1172 gl.getProgramiv(program, GL_ACTIVE_UNIFORMS, &numActiveUniforms); 1173 gl.getProgramiv(program, GL_ACTIVE_UNIFORM_BLOCKS, &numActiveBlocks); 1174 1175 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to get number of uniforms and uniform blocks"); 1176 1177 // Block entries. 1178 layout.blocks.resize(numActiveBlocks); 1179 for (int blockNdx = 0; blockNdx < numActiveBlocks; blockNdx++) 1180 { 1181 BlockLayoutEntry& entry = layout.blocks[blockNdx]; 1182 int size; 1183 int nameLen; 1184 int numBlockUniforms; 1185 1186 gl.getActiveUniformBlockiv(program, (deUint32)blockNdx, GL_UNIFORM_BLOCK_DATA_SIZE, &size); 1187 gl.getActiveUniformBlockiv(program, (deUint32)blockNdx, GL_UNIFORM_BLOCK_NAME_LENGTH, &nameLen); 1188 gl.getActiveUniformBlockiv(program, (deUint32)blockNdx, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, &numBlockUniforms); 1189 1190 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform block query failed"); 1191 1192 // \note Some implementations incorrectly return 0 as name length even though the length should include null terminator. 1193 std::vector<char> nameBuf(nameLen > 0 ? nameLen : 1); 1194 gl.getActiveUniformBlockName(program, (deUint32)blockNdx, (glw::GLsizei)nameBuf.size(), DE_NULL, &nameBuf[0]); 1195 1196 entry.name = std::string(&nameBuf[0]); 1197 entry.size = size; 1198 entry.activeUniformIndices.resize(numBlockUniforms); 1199 1200 if (numBlockUniforms > 0) 1201 gl.getActiveUniformBlockiv(program, (deUint32)blockNdx, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, &entry.activeUniformIndices[0]); 1202 1203 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform block query failed"); 1204 } 1205 1206 if (numActiveUniforms > 0) 1207 { 1208 // Uniform entries. 1209 std::vector<deUint32> uniformIndices(numActiveUniforms); 1210 for (int i = 0; i < numActiveUniforms; i++) 1211 uniformIndices[i] = (deUint32)i; 1212 1213 std::vector<int> types (numActiveUniforms); 1214 std::vector<int> sizes (numActiveUniforms); 1215 std::vector<int> nameLengths (numActiveUniforms); 1216 std::vector<int> blockIndices (numActiveUniforms); 1217 std::vector<int> offsets (numActiveUniforms); 1218 std::vector<int> arrayStrides (numActiveUniforms); 1219 std::vector<int> matrixStrides (numActiveUniforms); 1220 std::vector<int> rowMajorFlags (numActiveUniforms); 1221 1222 // Execute queries. 1223 gl.getActiveUniformsiv(program, (glw::GLsizei)uniformIndices.size(), &uniformIndices[0], GL_UNIFORM_TYPE, &types[0]); 1224 gl.getActiveUniformsiv(program, (glw::GLsizei)uniformIndices.size(), &uniformIndices[0], GL_UNIFORM_SIZE, &sizes[0]); 1225 gl.getActiveUniformsiv(program, (glw::GLsizei)uniformIndices.size(), &uniformIndices[0], GL_UNIFORM_NAME_LENGTH, &nameLengths[0]); 1226 gl.getActiveUniformsiv(program, (glw::GLsizei)uniformIndices.size(), &uniformIndices[0], GL_UNIFORM_BLOCK_INDEX, &blockIndices[0]); 1227 gl.getActiveUniformsiv(program, (glw::GLsizei)uniformIndices.size(), &uniformIndices[0], GL_UNIFORM_OFFSET, &offsets[0]); 1228 gl.getActiveUniformsiv(program, (glw::GLsizei)uniformIndices.size(), &uniformIndices[0], GL_UNIFORM_ARRAY_STRIDE, &arrayStrides[0]); 1229 gl.getActiveUniformsiv(program, (glw::GLsizei)uniformIndices.size(), &uniformIndices[0], GL_UNIFORM_MATRIX_STRIDE, &matrixStrides[0]); 1230 gl.getActiveUniformsiv(program, (glw::GLsizei)uniformIndices.size(), &uniformIndices[0], GL_UNIFORM_IS_ROW_MAJOR, &rowMajorFlags[0]); 1231 1232 GLU_EXPECT_NO_ERROR(gl.getError(), "Active uniform query failed"); 1233 1234 // Translate to LayoutEntries 1235 layout.uniforms.resize(numActiveUniforms); 1236 for (int uniformNdx = 0; uniformNdx < numActiveUniforms; uniformNdx++) 1237 { 1238 UniformLayoutEntry& entry = layout.uniforms[uniformNdx]; 1239 std::vector<char> nameBuf (nameLengths[uniformNdx]); 1240 glw::GLsizei nameLen = 0; 1241 int size = 0; 1242 deUint32 type = GL_NONE; 1243 1244 gl.getActiveUniform(program, (deUint32)uniformNdx, (glw::GLsizei)nameBuf.size(), &nameLen, &size, &type, &nameBuf[0]); 1245 1246 GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform name query failed"); 1247 1248 // \note glGetActiveUniform() returns length without \0 and glGetActiveUniformsiv() with \0 1249 if (nameLen+1 != nameLengths[uniformNdx] || 1250 size != sizes[uniformNdx] || 1251 type != (deUint32)types[uniformNdx]) 1252 TCU_FAIL("Values returned by glGetActiveUniform() don't match with values queried with glGetActiveUniformsiv()."); 1253 1254 entry.name = std::string(&nameBuf[0]); 1255 entry.type = glu::getDataTypeFromGLType(types[uniformNdx]); 1256 entry.size = sizes[uniformNdx]; 1257 entry.blockNdx = blockIndices[uniformNdx]; 1258 entry.offset = offsets[uniformNdx]; 1259 entry.arrayStride = arrayStrides[uniformNdx]; 1260 entry.matrixStride = matrixStrides[uniformNdx]; 1261 entry.isRowMajor = rowMajorFlags[uniformNdx] != GL_FALSE; 1262 } 1263 } 1264} 1265 1266void copyUniformData (const UniformLayoutEntry& dstEntry, void* dstBlockPtr, const UniformLayoutEntry& srcEntry, const void* srcBlockPtr) 1267{ 1268 deUint8* dstBasePtr = (deUint8*)dstBlockPtr + dstEntry.offset; 1269 const deUint8* srcBasePtr = (const deUint8*)srcBlockPtr + srcEntry.offset; 1270 1271 DE_ASSERT(dstEntry.size <= srcEntry.size); 1272 DE_ASSERT(dstEntry.type == srcEntry.type); 1273 1274 int scalarSize = glu::getDataTypeScalarSize(dstEntry.type); 1275 bool isMatrix = glu::isDataTypeMatrix(dstEntry.type); 1276 const int compSize = sizeof(deUint32); 1277 1278 for (int elementNdx = 0; elementNdx < dstEntry.size; elementNdx++) 1279 { 1280 deUint8* dstElemPtr = dstBasePtr + elementNdx*dstEntry.arrayStride; 1281 const deUint8* srcElemPtr = srcBasePtr + elementNdx*srcEntry.arrayStride; 1282 1283 if (isMatrix) 1284 { 1285 int numRows = glu::getDataTypeMatrixNumRows(dstEntry.type); 1286 int numCols = glu::getDataTypeMatrixNumColumns(dstEntry.type); 1287 1288 for (int colNdx = 0; colNdx < numCols; colNdx++) 1289 { 1290 for (int rowNdx = 0; rowNdx < numRows; rowNdx++) 1291 { 1292 deUint8* dstCompPtr = dstElemPtr + (dstEntry.isRowMajor ? rowNdx*dstEntry.matrixStride + colNdx*compSize 1293 : colNdx*dstEntry.matrixStride + rowNdx*compSize); 1294 const deUint8* srcCompPtr = srcElemPtr + (srcEntry.isRowMajor ? rowNdx*srcEntry.matrixStride + colNdx*compSize 1295 : colNdx*srcEntry.matrixStride + rowNdx*compSize); 1296 deMemcpy(dstCompPtr, srcCompPtr, compSize); 1297 } 1298 } 1299 } 1300 else 1301 deMemcpy(dstElemPtr, srcElemPtr, scalarSize*compSize); 1302 } 1303} 1304 1305void copyUniformData (const UniformLayout& dstLayout, const std::map<int, void*>& dstBlockPointers, const UniformLayout& srcLayout, const std::map<int, void*>& srcBlockPointers) 1306{ 1307 // \note Src layout is used as reference in case of activeUniforms happens to be incorrect in dstLayout blocks. 1308 int numBlocks = (int)srcLayout.blocks.size(); 1309 1310 for (int srcBlockNdx = 0; srcBlockNdx < numBlocks; srcBlockNdx++) 1311 { 1312 const BlockLayoutEntry& srcBlock = srcLayout.blocks[srcBlockNdx]; 1313 const void* srcBlockPtr = srcBlockPointers.find(srcBlockNdx)->second; 1314 int dstBlockNdx = dstLayout.getBlockIndex(srcBlock.name.c_str()); 1315 void* dstBlockPtr = dstBlockNdx >= 0 ? dstBlockPointers.find(dstBlockNdx)->second : DE_NULL; 1316 1317 if (dstBlockNdx < 0) 1318 continue; 1319 1320 for (vector<int>::const_iterator srcUniformNdxIter = srcBlock.activeUniformIndices.begin(); srcUniformNdxIter != srcBlock.activeUniformIndices.end(); srcUniformNdxIter++) 1321 { 1322 const UniformLayoutEntry& srcEntry = srcLayout.uniforms[*srcUniformNdxIter]; 1323 int dstUniformNdx = dstLayout.getUniformIndex(srcEntry.name.c_str()); 1324 1325 if (dstUniformNdx < 0) 1326 continue; 1327 1328 copyUniformData(dstLayout.uniforms[dstUniformNdx], dstBlockPtr, srcEntry, srcBlockPtr); 1329 } 1330 } 1331} 1332 1333} // anonymous (utilities) 1334 1335class UniformBufferManager 1336{ 1337public: 1338 UniformBufferManager (const glu::RenderContext& renderCtx); 1339 ~UniformBufferManager (void); 1340 1341 deUint32 allocBuffer (void); 1342 1343private: 1344 UniformBufferManager (const UniformBufferManager& other); 1345 UniformBufferManager& operator= (const UniformBufferManager& other); 1346 1347 const glu::RenderContext& m_renderCtx; 1348 std::vector<deUint32> m_buffers; 1349}; 1350 1351UniformBufferManager::UniformBufferManager (const glu::RenderContext& renderCtx) 1352 : m_renderCtx(renderCtx) 1353{ 1354} 1355 1356UniformBufferManager::~UniformBufferManager (void) 1357{ 1358 if (!m_buffers.empty()) 1359 m_renderCtx.getFunctions().deleteBuffers((glw::GLsizei)m_buffers.size(), &m_buffers[0]); 1360} 1361 1362deUint32 UniformBufferManager::allocBuffer (void) 1363{ 1364 deUint32 buf = 0; 1365 1366 m_buffers.reserve(m_buffers.size()+1); 1367 m_renderCtx.getFunctions().genBuffers(1, &buf); 1368 GLU_EXPECT_NO_ERROR(m_renderCtx.getFunctions().getError(), "Failed to allocate uniform buffer"); 1369 m_buffers.push_back(buf); 1370 1371 return buf; 1372} 1373 1374} // ub 1375 1376using namespace ub; 1377 1378// UniformBlockCase. 1379 1380UniformBlockCase::UniformBlockCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description, glu::GLSLVersion glslVersion, BufferMode bufferMode) 1381 : TestCase (testCtx, name, description) 1382 , m_renderCtx (renderCtx) 1383 , m_glslVersion (glslVersion) 1384 , m_bufferMode (bufferMode) 1385{ 1386 TCU_CHECK_INTERNAL(isSupportedGLSLVersion(glslVersion)); 1387} 1388 1389UniformBlockCase::~UniformBlockCase (void) 1390{ 1391} 1392 1393UniformBlockCase::IterateResult UniformBlockCase::iterate (void) 1394{ 1395 TestLog& log = m_testCtx.getLog(); 1396 const glw::Functions& gl = m_renderCtx.getFunctions(); 1397 UniformLayout refLayout; //!< std140 layout. 1398 vector<deUint8> data; //!< Data. 1399 map<int, void*> blockPointers; //!< Reference block pointers. 1400 1401 // Initialize result to pass. 1402 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1403 1404 // Compute reference layout. 1405 computeStd140Layout(refLayout, m_interface); 1406 1407 // Assign storage for reference values. 1408 { 1409 int totalSize = 0; 1410 for (vector<BlockLayoutEntry>::const_iterator blockIter = refLayout.blocks.begin(); blockIter != refLayout.blocks.end(); blockIter++) 1411 totalSize += blockIter->size; 1412 data.resize(totalSize); 1413 1414 // Pointers for each block. 1415 int curOffset = 0; 1416 for (int blockNdx = 0; blockNdx < (int)refLayout.blocks.size(); blockNdx++) 1417 { 1418 blockPointers[blockNdx] = &data[0] + curOffset; 1419 curOffset += refLayout.blocks[blockNdx].size; 1420 } 1421 } 1422 1423 // Generate values. 1424 generateValues(refLayout, blockPointers, 1 /* seed */); 1425 1426 // Generate shaders and build program. 1427 std::ostringstream vtxSrc; 1428 std::ostringstream fragSrc; 1429 1430 generateVertexShader(vtxSrc, m_glslVersion, m_interface, refLayout, blockPointers); 1431 generateFragmentShader(fragSrc, m_glslVersion, m_interface, refLayout, blockPointers); 1432 1433 glu::ShaderProgram program(m_renderCtx, glu::makeVtxFragSources(vtxSrc.str(), fragSrc.str())); 1434 log << program; 1435 1436 if (!program.isOk()) 1437 { 1438 // Compile failed. 1439 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Compile failed"); 1440 return STOP; 1441 } 1442 1443 // Query layout from GL. 1444 UniformLayout glLayout; 1445 getGLUniformLayout(gl, glLayout, program.getProgram()); 1446 1447 // Print layout to log. 1448 log << TestLog::Section("ActiveUniformBlocks", "Active Uniform Blocks"); 1449 for (int blockNdx = 0; blockNdx < (int)glLayout.blocks.size(); blockNdx++) 1450 log << TestLog::Message << blockNdx << ": " << glLayout.blocks[blockNdx] << TestLog::EndMessage; 1451 log << TestLog::EndSection; 1452 1453 log << TestLog::Section("ActiveUniforms", "Active Uniforms"); 1454 for (int uniformNdx = 0; uniformNdx < (int)glLayout.uniforms.size(); uniformNdx++) 1455 log << TestLog::Message << uniformNdx << ": " << glLayout.uniforms[uniformNdx] << TestLog::EndMessage; 1456 log << TestLog::EndSection; 1457 1458 // Check that we can even try rendering with given layout. 1459 if (!checkLayoutIndices(glLayout) || !checkLayoutBounds(glLayout) || !compareTypes(refLayout, glLayout)) 1460 { 1461 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid layout"); 1462 return STOP; // It is not safe to use the given layout. 1463 } 1464 1465 // Verify all std140 blocks. 1466 if (!compareStd140Blocks(refLayout, glLayout)) 1467 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid std140 layout"); 1468 1469 // Verify all shared blocks - all uniforms should be active, and certain properties match. 1470 if (!compareSharedBlocks(refLayout, glLayout)) 1471 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid shared layout"); 1472 1473 // Check consistency with index queries 1474 if (!checkIndexQueries(program.getProgram(), glLayout)) 1475 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Inconsintent block index query results"); 1476 1477 // Use program. 1478 gl.useProgram(program.getProgram()); 1479 1480 // Assign binding points to all active uniform blocks. 1481 for (int blockNdx = 0; blockNdx < (int)glLayout.blocks.size(); blockNdx++) 1482 { 1483 deUint32 binding = (deUint32)blockNdx; // \todo [2012-01-25 pyry] Randomize order? 1484 gl.uniformBlockBinding(program.getProgram(), (deUint32)blockNdx, binding); 1485 } 1486 1487 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set uniform block bindings"); 1488 1489 // Allocate buffers, write data and bind to targets. 1490 UniformBufferManager bufferManager(m_renderCtx); 1491 if (m_bufferMode == BUFFERMODE_PER_BLOCK) 1492 { 1493 int numBlocks = (int)glLayout.blocks.size(); 1494 vector<vector<deUint8> > glData (numBlocks); 1495 map<int, void*> glBlockPointers; 1496 1497 for (int blockNdx = 0; blockNdx < numBlocks; blockNdx++) 1498 { 1499 glData[blockNdx].resize(glLayout.blocks[blockNdx].size); 1500 glBlockPointers[blockNdx] = &glData[blockNdx][0]; 1501 } 1502 1503 copyUniformData(glLayout, glBlockPointers, refLayout, blockPointers); 1504 1505 for (int blockNdx = 0; blockNdx < numBlocks; blockNdx++) 1506 { 1507 deUint32 buffer = bufferManager.allocBuffer(); 1508 deUint32 binding = (deUint32)blockNdx; 1509 1510 gl.bindBuffer(GL_UNIFORM_BUFFER, buffer); 1511 gl.bufferData(GL_UNIFORM_BUFFER, (glw::GLsizeiptr)glData[blockNdx].size(), &glData[blockNdx][0], GL_STATIC_DRAW); 1512 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to upload uniform buffer data"); 1513 1514 gl.bindBufferBase(GL_UNIFORM_BUFFER, binding, buffer); 1515 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase(GL_UNIFORM_BUFFER) failed"); 1516 } 1517 } 1518 else 1519 { 1520 DE_ASSERT(m_bufferMode == BUFFERMODE_SINGLE); 1521 1522 int totalSize = 0; 1523 int curOffset = 0; 1524 int numBlocks = (int)glLayout.blocks.size(); 1525 int bindingAlignment = 0; 1526 map<int, int> glBlockOffsets; 1527 1528 gl.getIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &bindingAlignment); 1529 1530 // Compute total size and offsets. 1531 curOffset = 0; 1532 for (int blockNdx = 0; blockNdx < numBlocks; blockNdx++) 1533 { 1534 if (bindingAlignment > 0) 1535 curOffset = deRoundUp32(curOffset, bindingAlignment); 1536 glBlockOffsets[blockNdx] = curOffset; 1537 curOffset += glLayout.blocks[blockNdx].size; 1538 } 1539 totalSize = curOffset; 1540 1541 // Assign block pointers. 1542 vector<deUint8> glData(totalSize); 1543 map<int, void*> glBlockPointers; 1544 1545 for (int blockNdx = 0; blockNdx < numBlocks; blockNdx++) 1546 glBlockPointers[blockNdx] = &glData[glBlockOffsets[blockNdx]]; 1547 1548 // Copy to gl format. 1549 copyUniformData(glLayout, glBlockPointers, refLayout, blockPointers); 1550 1551 // Allocate buffer and upload data. 1552 deUint32 buffer = bufferManager.allocBuffer(); 1553 gl.bindBuffer(GL_UNIFORM_BUFFER, buffer); 1554 if (!glData.empty()) 1555 gl.bufferData(GL_UNIFORM_BUFFER, (glw::GLsizeiptr)glData.size(), &glData[0], GL_STATIC_DRAW); 1556 1557 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to upload uniform buffer data"); 1558 1559 // Bind ranges to binding points. 1560 for (int blockNdx = 0; blockNdx < numBlocks; blockNdx++) 1561 { 1562 deUint32 binding = (deUint32)blockNdx; 1563 gl.bindBufferRange(GL_UNIFORM_BUFFER, binding, buffer, (glw::GLintptr)glBlockOffsets[blockNdx], (glw::GLsizeiptr)glLayout.blocks[blockNdx].size); 1564 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferRange(GL_UNIFORM_BUFFER) failed"); 1565 } 1566 } 1567 1568 bool renderOk = render(program.getProgram()); 1569 if (!renderOk) 1570 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image compare failed"); 1571 1572 return STOP; 1573} 1574 1575bool UniformBlockCase::compareStd140Blocks (const UniformLayout& refLayout, const UniformLayout& cmpLayout) const 1576{ 1577 TestLog& log = m_testCtx.getLog(); 1578 bool isOk = true; 1579 int numBlocks = m_interface.getNumUniformBlocks(); 1580 1581 for (int blockNdx = 0; blockNdx < numBlocks; blockNdx++) 1582 { 1583 const UniformBlock& block = m_interface.getUniformBlock(blockNdx); 1584 bool isArray = block.isArray(); 1585 std::string instanceName = string(block.getBlockName()) + (isArray ? "[0]" : ""); 1586 int refBlockNdx = refLayout.getBlockIndex(instanceName.c_str()); 1587 int cmpBlockNdx = cmpLayout.getBlockIndex(instanceName.c_str()); 1588 bool isUsed = (block.getFlags() & (DECLARE_VERTEX|DECLARE_FRAGMENT)) != 0; 1589 1590 if ((block.getFlags() & LAYOUT_STD140) == 0) 1591 continue; // Not std140 layout. 1592 1593 DE_ASSERT(refBlockNdx >= 0); 1594 1595 if (cmpBlockNdx < 0) 1596 { 1597 // Not found, should it? 1598 if (isUsed) 1599 { 1600 log << TestLog::Message << "Error: Uniform block '" << instanceName << "' not found" << TestLog::EndMessage; 1601 isOk = false; 1602 } 1603 1604 continue; // Skip block. 1605 } 1606 1607 const BlockLayoutEntry& refBlockLayout = refLayout.blocks[refBlockNdx]; 1608 const BlockLayoutEntry& cmpBlockLayout = cmpLayout.blocks[cmpBlockNdx]; 1609 1610 // \todo [2012-01-24 pyry] Verify that activeUniformIndices is correct. 1611 // \todo [2012-01-24 pyry] Verify all instances. 1612 if (refBlockLayout.activeUniformIndices.size() != cmpBlockLayout.activeUniformIndices.size()) 1613 { 1614 log << TestLog::Message << "Error: Number of active uniforms differ in block '" << instanceName 1615 << "' (expected " << refBlockLayout.activeUniformIndices.size() 1616 << ", got " << cmpBlockLayout.activeUniformIndices.size() 1617 << ")" << TestLog::EndMessage; 1618 isOk = false; 1619 } 1620 1621 for (vector<int>::const_iterator ndxIter = refBlockLayout.activeUniformIndices.begin(); ndxIter != refBlockLayout.activeUniformIndices.end(); ndxIter++) 1622 { 1623 const UniformLayoutEntry& refEntry = refLayout.uniforms[*ndxIter]; 1624 int cmpEntryNdx = cmpLayout.getUniformIndex(refEntry.name.c_str()); 1625 1626 if (cmpEntryNdx < 0) 1627 { 1628 log << TestLog::Message << "Error: Uniform '" << refEntry.name << "' not found" << TestLog::EndMessage; 1629 isOk = false; 1630 continue; 1631 } 1632 1633 const UniformLayoutEntry& cmpEntry = cmpLayout.uniforms[cmpEntryNdx]; 1634 1635 if (refEntry.type != cmpEntry.type || 1636 refEntry.size != cmpEntry.size || 1637 refEntry.offset != cmpEntry.offset || 1638 refEntry.arrayStride != cmpEntry.arrayStride || 1639 refEntry.matrixStride != cmpEntry.matrixStride || 1640 refEntry.isRowMajor != cmpEntry.isRowMajor) 1641 { 1642 log << TestLog::Message << "Error: Layout mismatch in '" << refEntry.name << "':\n" 1643 << " expected: type = " << glu::getDataTypeName(refEntry.type) << ", size = " << refEntry.size << ", offset = " << refEntry.offset << ", array stride = "<< refEntry.arrayStride << ", matrix stride = " << refEntry.matrixStride << ", row major = " << (refEntry.isRowMajor ? "true" : "false") << "\n" 1644 << " got: type = " << glu::getDataTypeName(cmpEntry.type) << ", size = " << cmpEntry.size << ", offset = " << cmpEntry.offset << ", array stride = "<< cmpEntry.arrayStride << ", matrix stride = " << cmpEntry.matrixStride << ", row major = " << (cmpEntry.isRowMajor ? "true" : "false") 1645 << TestLog::EndMessage; 1646 isOk = false; 1647 } 1648 } 1649 } 1650 1651 return isOk; 1652} 1653 1654bool UniformBlockCase::compareSharedBlocks (const UniformLayout& refLayout, const UniformLayout& cmpLayout) const 1655{ 1656 TestLog& log = m_testCtx.getLog(); 1657 bool isOk = true; 1658 int numBlocks = m_interface.getNumUniformBlocks(); 1659 1660 for (int blockNdx = 0; blockNdx < numBlocks; blockNdx++) 1661 { 1662 const UniformBlock& block = m_interface.getUniformBlock(blockNdx); 1663 bool isArray = block.isArray(); 1664 std::string instanceName = string(block.getBlockName()) + (isArray ? "[0]" : ""); 1665 int refBlockNdx = refLayout.getBlockIndex(instanceName.c_str()); 1666 int cmpBlockNdx = cmpLayout.getBlockIndex(instanceName.c_str()); 1667 bool isUsed = (block.getFlags() & (DECLARE_VERTEX|DECLARE_FRAGMENT)) != 0; 1668 1669 if ((block.getFlags() & LAYOUT_SHARED) == 0) 1670 continue; // Not shared layout. 1671 1672 DE_ASSERT(refBlockNdx >= 0); 1673 1674 if (cmpBlockNdx < 0) 1675 { 1676 // Not found, should it? 1677 if (isUsed) 1678 { 1679 log << TestLog::Message << "Error: Uniform block '" << instanceName << "' not found" << TestLog::EndMessage; 1680 isOk = false; 1681 } 1682 1683 continue; // Skip block. 1684 } 1685 1686 const BlockLayoutEntry& refBlockLayout = refLayout.blocks[refBlockNdx]; 1687 const BlockLayoutEntry& cmpBlockLayout = cmpLayout.blocks[cmpBlockNdx]; 1688 1689 if (refBlockLayout.activeUniformIndices.size() != cmpBlockLayout.activeUniformIndices.size()) 1690 { 1691 log << TestLog::Message << "Error: Number of active uniforms differ in block '" << instanceName 1692 << "' (expected " << refBlockLayout.activeUniformIndices.size() 1693 << ", got " << cmpBlockLayout.activeUniformIndices.size() 1694 << ")" << TestLog::EndMessage; 1695 isOk = false; 1696 } 1697 1698 for (vector<int>::const_iterator ndxIter = refBlockLayout.activeUniformIndices.begin(); ndxIter != refBlockLayout.activeUniformIndices.end(); ndxIter++) 1699 { 1700 const UniformLayoutEntry& refEntry = refLayout.uniforms[*ndxIter]; 1701 int cmpEntryNdx = cmpLayout.getUniformIndex(refEntry.name.c_str()); 1702 1703 if (cmpEntryNdx < 0) 1704 { 1705 log << TestLog::Message << "Error: Uniform '" << refEntry.name << "' not found" << TestLog::EndMessage; 1706 isOk = false; 1707 continue; 1708 } 1709 1710 const UniformLayoutEntry& cmpEntry = cmpLayout.uniforms[cmpEntryNdx]; 1711 1712 if (refEntry.type != cmpEntry.type || 1713 refEntry.size != cmpEntry.size || 1714 refEntry.isRowMajor != cmpEntry.isRowMajor) 1715 { 1716 log << TestLog::Message << "Error: Layout mismatch in '" << refEntry.name << "':\n" 1717 << " expected: type = " << glu::getDataTypeName(refEntry.type) << ", size = " << refEntry.size << ", row major = " << (refEntry.isRowMajor ? "true" : "false") << "\n" 1718 << " got: type = " << glu::getDataTypeName(cmpEntry.type) << ", size = " << cmpEntry.size << ", row major = " << (cmpEntry.isRowMajor ? "true" : "false") 1719 << TestLog::EndMessage; 1720 isOk = false; 1721 } 1722 } 1723 } 1724 1725 return isOk; 1726} 1727 1728bool UniformBlockCase::compareTypes (const UniformLayout& refLayout, const UniformLayout& cmpLayout) const 1729{ 1730 TestLog& log = m_testCtx.getLog(); 1731 bool isOk = true; 1732 int numBlocks = m_interface.getNumUniformBlocks(); 1733 1734 for (int blockNdx = 0; blockNdx < numBlocks; blockNdx++) 1735 { 1736 const UniformBlock& block = m_interface.getUniformBlock(blockNdx); 1737 bool isArray = block.isArray(); 1738 int numInstances = isArray ? block.getArraySize() : 1; 1739 1740 for (int instanceNdx = 0; instanceNdx < numInstances; instanceNdx++) 1741 { 1742 std::ostringstream instanceName; 1743 1744 instanceName << block.getBlockName(); 1745 if (isArray) 1746 instanceName << "[" << instanceNdx << "]"; 1747 1748 int cmpBlockNdx = cmpLayout.getBlockIndex(instanceName.str().c_str()); 1749 1750 if (cmpBlockNdx < 0) 1751 continue; 1752 1753 const BlockLayoutEntry& cmpBlockLayout = cmpLayout.blocks[cmpBlockNdx]; 1754 1755 for (vector<int>::const_iterator ndxIter = cmpBlockLayout.activeUniformIndices.begin(); ndxIter != cmpBlockLayout.activeUniformIndices.end(); ndxIter++) 1756 { 1757 const UniformLayoutEntry& cmpEntry = cmpLayout.uniforms[*ndxIter]; 1758 int refEntryNdx = refLayout.getUniformIndex(cmpEntry.name.c_str()); 1759 1760 if (refEntryNdx < 0) 1761 { 1762 log << TestLog::Message << "Error: Uniform '" << cmpEntry.name << "' not found in reference layout" << TestLog::EndMessage; 1763 isOk = false; 1764 continue; 1765 } 1766 1767 const UniformLayoutEntry& refEntry = refLayout.uniforms[refEntryNdx]; 1768 1769 // \todo [2012-11-26 pyry] Should we check other properties as well? 1770 if (refEntry.type != cmpEntry.type) 1771 { 1772 log << TestLog::Message << "Error: Uniform type mismatch in '" << refEntry.name << "':\n" 1773 << " expected: " << glu::getDataTypeName(refEntry.type) << "\n" 1774 << " got: " << glu::getDataTypeName(cmpEntry.type) 1775 << TestLog::EndMessage; 1776 isOk = false; 1777 } 1778 } 1779 } 1780 } 1781 1782 return isOk; 1783} 1784 1785bool UniformBlockCase::checkLayoutIndices (const UniformLayout& layout) const 1786{ 1787 TestLog& log = m_testCtx.getLog(); 1788 int numUniforms = (int)layout.uniforms.size(); 1789 int numBlocks = (int)layout.blocks.size(); 1790 bool isOk = true; 1791 1792 // Check uniform block indices. 1793 for (int uniformNdx = 0; uniformNdx < numUniforms; uniformNdx++) 1794 { 1795 const UniformLayoutEntry& uniform = layout.uniforms[uniformNdx]; 1796 1797 if (uniform.blockNdx < 0 || !deInBounds32(uniform.blockNdx, 0, numBlocks)) 1798 { 1799 log << TestLog::Message << "Error: Invalid block index in uniform '" << uniform.name << "'" << TestLog::EndMessage; 1800 isOk = false; 1801 } 1802 } 1803 1804 // Check active uniforms. 1805 for (int blockNdx = 0; blockNdx < numBlocks; blockNdx++) 1806 { 1807 const BlockLayoutEntry& block = layout.blocks[blockNdx]; 1808 1809 for (vector<int>::const_iterator uniformIter = block.activeUniformIndices.begin(); uniformIter != block.activeUniformIndices.end(); uniformIter++) 1810 { 1811 if (!deInBounds32(*uniformIter, 0, numUniforms)) 1812 { 1813 log << TestLog::Message << "Error: Invalid active uniform index " << *uniformIter << " in block '" << block.name << "'" << TestLog::EndMessage; 1814 isOk = false; 1815 } 1816 } 1817 } 1818 1819 return isOk; 1820} 1821 1822bool UniformBlockCase::checkLayoutBounds (const UniformLayout& layout) const 1823{ 1824 TestLog& log = m_testCtx.getLog(); 1825 int numUniforms = (int)layout.uniforms.size(); 1826 bool isOk = true; 1827 1828 for (int uniformNdx = 0; uniformNdx < numUniforms; uniformNdx++) 1829 { 1830 const UniformLayoutEntry& uniform = layout.uniforms[uniformNdx]; 1831 1832 if (uniform.blockNdx < 0) 1833 continue; 1834 1835 const BlockLayoutEntry& block = layout.blocks[uniform.blockNdx]; 1836 bool isMatrix = glu::isDataTypeMatrix(uniform.type); 1837 int numVecs = isMatrix ? (uniform.isRowMajor ? glu::getDataTypeMatrixNumRows(uniform.type) : glu::getDataTypeMatrixNumColumns(uniform.type)) : 1; 1838 int numComps = isMatrix ? (uniform.isRowMajor ? glu::getDataTypeMatrixNumColumns(uniform.type) : glu::getDataTypeMatrixNumRows(uniform.type)) : glu::getDataTypeScalarSize(uniform.type); 1839 int numElements = uniform.size; 1840 const int compSize = sizeof(deUint32); 1841 int vecSize = numComps*compSize; 1842 1843 int minOffset = 0; 1844 int maxOffset = 0; 1845 1846 // For negative strides. 1847 minOffset = de::min(minOffset, (numVecs-1)*uniform.matrixStride); 1848 minOffset = de::min(minOffset, (numElements-1)*uniform.arrayStride); 1849 minOffset = de::min(minOffset, (numElements-1)*uniform.arrayStride + (numVecs-1)*uniform.matrixStride); 1850 1851 maxOffset = de::max(maxOffset, vecSize); 1852 maxOffset = de::max(maxOffset, (numVecs-1)*uniform.matrixStride + vecSize); 1853 maxOffset = de::max(maxOffset, (numElements-1)*uniform.arrayStride + vecSize); 1854 maxOffset = de::max(maxOffset, (numElements-1)*uniform.arrayStride + (numVecs-1)*uniform.matrixStride + vecSize); 1855 1856 if (uniform.offset+minOffset < 0 || uniform.offset+maxOffset > block.size) 1857 { 1858 log << TestLog::Message << "Error: Uniform '" << uniform.name << "' out of block bounds" << TestLog::EndMessage; 1859 isOk = false; 1860 } 1861 } 1862 1863 return isOk; 1864} 1865 1866bool UniformBlockCase::checkIndexQueries (deUint32 program, const UniformLayout& layout) const 1867{ 1868 tcu::TestLog& log = m_testCtx.getLog(); 1869 const glw::Functions& gl = m_renderCtx.getFunctions(); 1870 bool allOk = true; 1871 1872 // \note Spec mandates that uniform blocks are assigned consecutive locations from 0 1873 // to ACTIVE_UNIFORM_BLOCKS. BlockLayoutEntries are stored in that order in UniformLayout. 1874 for (int blockNdx = 0; blockNdx < (int)layout.blocks.size(); blockNdx++) 1875 { 1876 const BlockLayoutEntry& block = layout.blocks[blockNdx]; 1877 const int queriedNdx = gl.getUniformBlockIndex(program, block.name.c_str()); 1878 1879 if (queriedNdx != blockNdx) 1880 { 1881 log << TestLog::Message << "ERROR: glGetUniformBlockIndex(" << block.name << ") returned " << queriedNdx << ", expected " << blockNdx << "!" << TestLog::EndMessage; 1882 allOk = false; 1883 } 1884 1885 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformBlockIndex()"); 1886 } 1887 1888 return allOk; 1889} 1890 1891bool UniformBlockCase::render (deUint32 program) const 1892{ 1893 tcu::TestLog& log = m_testCtx.getLog(); 1894 const glw::Functions& gl = m_renderCtx.getFunctions(); 1895 de::Random rnd (deStringHash(getName())); 1896 const tcu::RenderTarget& renderTarget = m_renderCtx.getRenderTarget(); 1897 const int viewportW = de::min(renderTarget.getWidth(), 128); 1898 const int viewportH = de::min(renderTarget.getHeight(), 128); 1899 const int viewportX = rnd.getInt(0, renderTarget.getWidth() - viewportW); 1900 const int viewportY = rnd.getInt(0, renderTarget.getHeight() - viewportH); 1901 1902 gl.clearColor(0.125f, 0.25f, 0.5f, 1.0f); 1903 gl.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT); 1904 1905 // Draw 1906 { 1907 const float position[] = 1908 { 1909 -1.0f, -1.0f, 0.0f, 1.0f, 1910 -1.0f, +1.0f, 0.0f, 1.0f, 1911 +1.0f, -1.0f, 0.0f, 1.0f, 1912 +1.0f, +1.0f, 0.0f, 1.0f 1913 }; 1914 const deUint16 indices[] = { 0, 1, 2, 2, 1, 3 }; 1915 1916 gl.viewport(viewportX, viewportY, viewportW, viewportH); 1917 1918 glu::VertexArrayBinding posArray = glu::va::Float("a_position", 4, 4, 0, &position[0]); 1919 glu::draw(m_renderCtx, program, 1, &posArray, 1920 glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0])); 1921 GLU_EXPECT_NO_ERROR(gl.getError(), "Draw failed"); 1922 } 1923 1924 // Verify that all pixels are white. 1925 { 1926 tcu::Surface pixels (viewportW, viewportH); 1927 int numFailedPixels = 0; 1928 1929 glu::readPixels(m_renderCtx, viewportX, viewportY, pixels.getAccess()); 1930 GLU_EXPECT_NO_ERROR(gl.getError(), "Reading pixels failed"); 1931 1932 for (int y = 0; y < pixels.getHeight(); y++) 1933 { 1934 for (int x = 0; x < pixels.getWidth(); x++) 1935 { 1936 if (pixels.getPixel(x, y) != tcu::RGBA::white) 1937 numFailedPixels += 1; 1938 } 1939 } 1940 1941 if (numFailedPixels > 0) 1942 { 1943 log << TestLog::Image("Image", "Rendered image", pixels); 1944 log << TestLog::Message << "Image comparison failed, got " << numFailedPixels << " non-white pixels" << TestLog::EndMessage; 1945 } 1946 1947 return numFailedPixels == 0; 1948 } 1949} 1950 1951} // gls 1952} // deqp 1953