1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.1 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 GLSL textureGather[Offset[s]] tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es31fTextureGatherTests.hpp" 25 #include "glsTextureTestUtil.hpp" 26 #include "gluShaderProgram.hpp" 27 #include "gluTexture.hpp" 28 #include "gluDrawUtil.hpp" 29 #include "gluPixelTransfer.hpp" 30 #include "gluTextureUtil.hpp" 31 #include "gluStrUtil.hpp" 32 #include "gluObjectWrapper.hpp" 33 #include "tcuTextureUtil.hpp" 34 #include "tcuSurface.hpp" 35 #include "tcuTestLog.hpp" 36 #include "tcuVectorUtil.hpp" 37 #include "tcuTexLookupVerifier.hpp" 38 #include "tcuTexCompareVerifier.hpp" 39 #include "tcuCommandLine.hpp" 40 #include "deUniquePtr.hpp" 41 #include "deStringUtil.hpp" 42 #include "deRandom.hpp" 43 #include "deString.h" 44 45 #include "glwEnums.hpp" 46 #include "glwFunctions.hpp" 47 48 using glu::ShaderProgram; 49 using tcu::ConstPixelBufferAccess; 50 using tcu::PixelBufferAccess; 51 using tcu::TestLog; 52 using tcu::IVec2; 53 using tcu::IVec3; 54 using tcu::IVec4; 55 using tcu::UVec4; 56 using tcu::Vec2; 57 using tcu::Vec3; 58 using tcu::Vec4; 59 using de::MovePtr; 60 61 using std::string; 62 using std::vector; 63 64 namespace deqp 65 { 66 67 using glu::TextureTestUtil::TextureType; 68 using glu::TextureTestUtil::TEXTURETYPE_2D; 69 using glu::TextureTestUtil::TEXTURETYPE_2D_ARRAY; 70 using glu::TextureTestUtil::TEXTURETYPE_CUBE; 71 72 namespace gles31 73 { 74 namespace Functional 75 { 76 77 namespace 78 { 79 80 // Round-to-zero int division, because pre-c++11 it's somewhat implementation-defined for negative values. 81 static inline int divRoundToZero (int a, int b) 82 { 83 return de::abs(a) / de::abs(b) * deSign32(a) * deSign32(b); 84 } 85 86 static void fillWithRandomColorTiles (const PixelBufferAccess& dst, const Vec4& minVal, const Vec4& maxVal, deUint32 seed) 87 { 88 const int numCols = dst.getWidth() >= 7 ? 7 : dst.getWidth(); 89 const int numRows = dst.getHeight() >= 5 ? 5 : dst.getHeight(); 90 de::Random rnd (seed); 91 92 for (int slice = 0; slice < dst.getDepth(); slice++) 93 for (int row = 0; row < numRows; row++) 94 for (int col = 0; col < numCols; col++) 95 { 96 const int yBegin = (row+0)*dst.getHeight()/numRows; 97 const int yEnd = (row+1)*dst.getHeight()/numRows; 98 const int xBegin = (col+0)*dst.getWidth()/numCols; 99 const int xEnd = (col+1)*dst.getWidth()/numCols; 100 Vec4 color; 101 for (int i = 0; i < 4; i++) 102 color[i] = rnd.getFloat(minVal[i], maxVal[i]); 103 tcu::clear(tcu::getSubregion(dst, xBegin, yBegin, slice, xEnd-xBegin, yEnd-yBegin, 1), color); 104 } 105 } 106 107 static inline bool isDepthFormat (const tcu::TextureFormat& fmt) 108 { 109 return fmt.order == tcu::TextureFormat::D || fmt.order == tcu::TextureFormat::DS; 110 } 111 112 static inline bool isUnormFormatType (tcu::TextureFormat::ChannelType type) 113 { 114 return type == tcu::TextureFormat::UNORM_INT8 || 115 type == tcu::TextureFormat::UNORM_INT16 || 116 type == tcu::TextureFormat::UNORM_INT32; 117 } 118 119 static inline bool isSIntFormatType (tcu::TextureFormat::ChannelType type) 120 { 121 return type == tcu::TextureFormat::SIGNED_INT8 || 122 type == tcu::TextureFormat::SIGNED_INT16 || 123 type == tcu::TextureFormat::SIGNED_INT32; 124 } 125 126 static inline bool isUIntFormatType (tcu::TextureFormat::ChannelType type) 127 { 128 return type == tcu::TextureFormat::UNSIGNED_INT8 || 129 type == tcu::TextureFormat::UNSIGNED_INT16 || 130 type == tcu::TextureFormat::UNSIGNED_INT32; 131 } 132 133 static tcu::TextureLevel getPixels (const glu::RenderContext& renderCtx, const IVec2& size, const tcu::TextureFormat& colorBufferFormat) 134 { 135 tcu::TextureLevel result(colorBufferFormat, size.x(), size.y()); 136 137 // only a few pixel formats are guaranteed to be valid targets for readPixels, convert the rest 138 if (colorBufferFormat.order == tcu::TextureFormat::RGBA && 139 (colorBufferFormat.type == tcu::TextureFormat::UNORM_INT8 || 140 colorBufferFormat.type == tcu::TextureFormat::SIGNED_INT32 || 141 colorBufferFormat.type == tcu::TextureFormat::UNSIGNED_INT32)) 142 { 143 // valid as is 144 glu::readPixels(renderCtx, 0, 0, result.getAccess()); 145 } 146 else if (colorBufferFormat.order == tcu::TextureFormat::RGBA && 147 (isSIntFormatType(colorBufferFormat.type) || 148 isUIntFormatType(colorBufferFormat.type))) 149 { 150 // signed and unsigned integers must be read using 32-bit values 151 const bool isSigned = isSIntFormatType(colorBufferFormat.type); 152 tcu::TextureLevel readResult (tcu::TextureFormat(tcu::TextureFormat::RGBA, 153 (isSigned) ? (tcu::TextureFormat::SIGNED_INT32) : (tcu::TextureFormat::UNSIGNED_INT32)), 154 size.x(), 155 size.y()); 156 157 glu::readPixels(renderCtx, 0, 0, readResult.getAccess()); 158 tcu::copy(result.getAccess(), readResult.getAccess()); 159 } 160 else 161 { 162 // unreadable format 163 DE_ASSERT(false); 164 } 165 166 return result; 167 } 168 169 enum TextureSwizzleComponent 170 { 171 TEXTURESWIZZLECOMPONENT_R = 0, 172 TEXTURESWIZZLECOMPONENT_G, 173 TEXTURESWIZZLECOMPONENT_B, 174 TEXTURESWIZZLECOMPONENT_A, 175 TEXTURESWIZZLECOMPONENT_ZERO, 176 TEXTURESWIZZLECOMPONENT_ONE, 177 178 TEXTURESWIZZLECOMPONENT_LAST 179 }; 180 181 static std::ostream& operator<< (std::ostream& stream, TextureSwizzleComponent comp) 182 { 183 switch (comp) 184 { 185 case TEXTURESWIZZLECOMPONENT_R: return stream << "RED"; 186 case TEXTURESWIZZLECOMPONENT_G: return stream << "GREEN"; 187 case TEXTURESWIZZLECOMPONENT_B: return stream << "BLUE"; 188 case TEXTURESWIZZLECOMPONENT_A: return stream << "ALPHA"; 189 case TEXTURESWIZZLECOMPONENT_ZERO: return stream << "ZERO"; 190 case TEXTURESWIZZLECOMPONENT_ONE: return stream << "ONE"; 191 default: DE_ASSERT(false); return stream; 192 } 193 } 194 195 struct MaybeTextureSwizzle 196 { 197 public: 198 static MaybeTextureSwizzle createNoneTextureSwizzle (void); 199 static MaybeTextureSwizzle createSomeTextureSwizzle (void); 200 201 bool isSome (void) const; 202 bool isNone (void) const; 203 bool isIdentitySwizzle (void) const; 204 205 tcu::Vector<TextureSwizzleComponent, 4>& getSwizzle (void); 206 const tcu::Vector<TextureSwizzleComponent, 4>& getSwizzle (void) const; 207 208 private: 209 MaybeTextureSwizzle (void); 210 211 tcu::Vector<TextureSwizzleComponent, 4> m_swizzle; 212 bool m_isSome; 213 }; 214 215 static std::ostream& operator<< (std::ostream& stream, const MaybeTextureSwizzle& comp) 216 { 217 if (comp.isNone()) 218 stream << "[default swizzle state]"; 219 else 220 stream << "(" << comp.getSwizzle()[0] 221 << ", " << comp.getSwizzle()[1] 222 << ", " << comp.getSwizzle()[2] 223 << ", " << comp.getSwizzle()[3] 224 << ")"; 225 226 return stream; 227 } 228 229 MaybeTextureSwizzle MaybeTextureSwizzle::createNoneTextureSwizzle (void) 230 { 231 MaybeTextureSwizzle swizzle; 232 233 swizzle.m_swizzle[0] = TEXTURESWIZZLECOMPONENT_LAST; 234 swizzle.m_swizzle[1] = TEXTURESWIZZLECOMPONENT_LAST; 235 swizzle.m_swizzle[2] = TEXTURESWIZZLECOMPONENT_LAST; 236 swizzle.m_swizzle[3] = TEXTURESWIZZLECOMPONENT_LAST; 237 swizzle.m_isSome = false; 238 239 return swizzle; 240 } 241 242 MaybeTextureSwizzle MaybeTextureSwizzle::createSomeTextureSwizzle (void) 243 { 244 MaybeTextureSwizzle swizzle; 245 246 swizzle.m_swizzle[0] = TEXTURESWIZZLECOMPONENT_R; 247 swizzle.m_swizzle[1] = TEXTURESWIZZLECOMPONENT_G; 248 swizzle.m_swizzle[2] = TEXTURESWIZZLECOMPONENT_B; 249 swizzle.m_swizzle[3] = TEXTURESWIZZLECOMPONENT_A; 250 swizzle.m_isSome = true; 251 252 return swizzle; 253 } 254 255 bool MaybeTextureSwizzle::isSome (void) const 256 { 257 return m_isSome; 258 } 259 260 bool MaybeTextureSwizzle::isNone (void) const 261 { 262 return !m_isSome; 263 } 264 265 bool MaybeTextureSwizzle::isIdentitySwizzle (void) const 266 { 267 return m_isSome && 268 m_swizzle[0] == TEXTURESWIZZLECOMPONENT_R && 269 m_swizzle[1] == TEXTURESWIZZLECOMPONENT_G && 270 m_swizzle[2] == TEXTURESWIZZLECOMPONENT_B && 271 m_swizzle[3] == TEXTURESWIZZLECOMPONENT_A; 272 } 273 274 tcu::Vector<TextureSwizzleComponent, 4>& MaybeTextureSwizzle::getSwizzle (void) 275 { 276 return m_swizzle; 277 } 278 279 const tcu::Vector<TextureSwizzleComponent, 4>& MaybeTextureSwizzle::getSwizzle (void) const 280 { 281 return m_swizzle; 282 } 283 284 MaybeTextureSwizzle::MaybeTextureSwizzle (void) 285 : m_swizzle (TEXTURESWIZZLECOMPONENT_LAST, TEXTURESWIZZLECOMPONENT_LAST, TEXTURESWIZZLECOMPONENT_LAST, TEXTURESWIZZLECOMPONENT_LAST) 286 , m_isSome (false) 287 { 288 } 289 290 static deUint32 getGLTextureSwizzleComponent (TextureSwizzleComponent c) 291 { 292 switch (c) 293 { 294 case TEXTURESWIZZLECOMPONENT_R: return GL_RED; 295 case TEXTURESWIZZLECOMPONENT_G: return GL_GREEN; 296 case TEXTURESWIZZLECOMPONENT_B: return GL_BLUE; 297 case TEXTURESWIZZLECOMPONENT_A: return GL_ALPHA; 298 case TEXTURESWIZZLECOMPONENT_ZERO: return GL_ZERO; 299 case TEXTURESWIZZLECOMPONENT_ONE: return GL_ONE; 300 default: DE_ASSERT(false); return (deUint32)-1; 301 } 302 } 303 304 template <typename T> 305 static inline T swizzleColorChannel (const tcu::Vector<T, 4>& src, TextureSwizzleComponent swizzle) 306 { 307 switch (swizzle) 308 { 309 case TEXTURESWIZZLECOMPONENT_R: return src[0]; 310 case TEXTURESWIZZLECOMPONENT_G: return src[1]; 311 case TEXTURESWIZZLECOMPONENT_B: return src[2]; 312 case TEXTURESWIZZLECOMPONENT_A: return src[3]; 313 case TEXTURESWIZZLECOMPONENT_ZERO: return (T)0; 314 case TEXTURESWIZZLECOMPONENT_ONE: return (T)1; 315 default: DE_ASSERT(false); return (T)-1; 316 } 317 } 318 319 template <typename T> 320 static inline tcu::Vector<T, 4> swizzleColor (const tcu::Vector<T, 4>& src, const MaybeTextureSwizzle& swizzle) 321 { 322 DE_ASSERT(swizzle.isSome()); 323 324 tcu::Vector<T, 4> result; 325 for (int i = 0; i < 4; i++) 326 result[i] = swizzleColorChannel(src, swizzle.getSwizzle()[i]); 327 return result; 328 } 329 330 template <typename T> 331 static void swizzlePixels (const PixelBufferAccess& dst, const ConstPixelBufferAccess& src, const MaybeTextureSwizzle& swizzle) 332 { 333 DE_ASSERT(dst.getWidth() == src.getWidth() && 334 dst.getHeight() == src.getHeight() && 335 dst.getDepth() == src.getDepth()); 336 for (int z = 0; z < src.getDepth(); z++) 337 for (int y = 0; y < src.getHeight(); y++) 338 for (int x = 0; x < src.getWidth(); x++) 339 dst.setPixel(swizzleColor(src.getPixelT<T>(x, y, z), swizzle), x, y, z); 340 } 341 342 static void swizzlePixels (const PixelBufferAccess& dst, const ConstPixelBufferAccess& src, const MaybeTextureSwizzle& swizzle) 343 { 344 if (isDepthFormat(dst.getFormat())) 345 DE_ASSERT(swizzle.isNone() || swizzle.isIdentitySwizzle()); 346 347 if (swizzle.isNone() || swizzle.isIdentitySwizzle()) 348 tcu::copy(dst, src); 349 else if (isUnormFormatType(dst.getFormat().type)) 350 swizzlePixels<float>(dst, src, swizzle); 351 else if (isUIntFormatType(dst.getFormat().type)) 352 swizzlePixels<deUint32>(dst, src, swizzle); 353 else if (isSIntFormatType(dst.getFormat().type)) 354 swizzlePixels<deInt32>(dst, src, swizzle); 355 else 356 DE_ASSERT(false); 357 } 358 359 static void swizzleTexture (tcu::Texture2D& dst, const tcu::Texture2D& src, const MaybeTextureSwizzle& swizzle) 360 { 361 dst = tcu::Texture2D(src.getFormat(), src.getWidth(), src.getHeight()); 362 for (int levelNdx = 0; levelNdx < src.getNumLevels(); levelNdx++) 363 { 364 if (src.isLevelEmpty(levelNdx)) 365 continue; 366 dst.allocLevel(levelNdx); 367 swizzlePixels(dst.getLevel(levelNdx), src.getLevel(levelNdx), swizzle); 368 } 369 } 370 371 static void swizzleTexture (tcu::Texture2DArray& dst, const tcu::Texture2DArray& src, const MaybeTextureSwizzle& swizzle) 372 { 373 dst = tcu::Texture2DArray(src.getFormat(), src.getWidth(), src.getHeight(), src.getNumLayers()); 374 for (int levelNdx = 0; levelNdx < src.getNumLevels(); levelNdx++) 375 { 376 if (src.isLevelEmpty(levelNdx)) 377 continue; 378 dst.allocLevel(levelNdx); 379 swizzlePixels(dst.getLevel(levelNdx), src.getLevel(levelNdx), swizzle); 380 } 381 } 382 383 static void swizzleTexture (tcu::TextureCube& dst, const tcu::TextureCube& src, const MaybeTextureSwizzle& swizzle) 384 { 385 dst = tcu::TextureCube(src.getFormat(), src.getSize()); 386 for (int faceI = 0; faceI < tcu::CUBEFACE_LAST; faceI++) 387 { 388 const tcu::CubeFace face = (tcu::CubeFace)faceI; 389 for (int levelNdx = 0; levelNdx < src.getNumLevels(); levelNdx++) 390 { 391 if (src.isLevelEmpty(face, levelNdx)) 392 continue; 393 dst.allocLevel(face, levelNdx); 394 swizzlePixels(dst.getLevelFace(levelNdx, face), src.getLevelFace(levelNdx, face), swizzle); 395 } 396 } 397 } 398 399 static tcu::Texture2DView getOneLevelSubView (const tcu::Texture2DView& view, int level) 400 { 401 return tcu::Texture2DView(1, view.getLevels() + level); 402 } 403 404 static tcu::Texture2DArrayView getOneLevelSubView (const tcu::Texture2DArrayView& view, int level) 405 { 406 return tcu::Texture2DArrayView(1, view.getLevels() + level); 407 } 408 409 static tcu::TextureCubeView getOneLevelSubView (const tcu::TextureCubeView& view, int level) 410 { 411 const tcu::ConstPixelBufferAccess* levels[tcu::CUBEFACE_LAST]; 412 413 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 414 levels[face] = view.getFaceLevels((tcu::CubeFace)face) + level; 415 416 return tcu::TextureCubeView(1, levels); 417 } 418 419 class PixelOffsets 420 { 421 public: 422 virtual void operator() (const IVec2& pixCoord, IVec2 (&dst)[4]) const = 0; 423 virtual ~PixelOffsets (void) {} 424 }; 425 426 class MultiplePixelOffsets : public PixelOffsets 427 { 428 public: 429 MultiplePixelOffsets (const IVec2& a, 430 const IVec2& b, 431 const IVec2& c, 432 const IVec2& d) 433 { 434 m_offsets[0] = a; 435 m_offsets[1] = b; 436 m_offsets[2] = c; 437 m_offsets[3] = d; 438 } 439 440 void operator() (const IVec2& /* pixCoord */, IVec2 (&dst)[4]) const 441 { 442 for (int i = 0; i < DE_LENGTH_OF_ARRAY(dst); i++) 443 dst[i] = m_offsets[i]; 444 } 445 446 private: 447 IVec2 m_offsets[4]; 448 }; 449 450 class SinglePixelOffsets : public MultiplePixelOffsets 451 { 452 public: 453 SinglePixelOffsets (const IVec2& offset) 454 : MultiplePixelOffsets(offset + IVec2(0, 1), 455 offset + IVec2(1, 1), 456 offset + IVec2(1, 0), 457 offset + IVec2(0, 0)) 458 { 459 } 460 }; 461 462 class DynamicSinglePixelOffsets : public PixelOffsets 463 { 464 public: 465 DynamicSinglePixelOffsets (const IVec2& offsetRange) : m_offsetRange(offsetRange) {} 466 467 void operator() (const IVec2& pixCoord, IVec2 (&dst)[4]) const 468 { 469 const int offsetRangeSize = m_offsetRange.y() - m_offsetRange.x() + 1; 470 SinglePixelOffsets(tcu::mod(pixCoord.swizzle(1,0), IVec2(offsetRangeSize)) + m_offsetRange.x())(IVec2(), dst); 471 } 472 473 private: 474 IVec2 m_offsetRange; 475 }; 476 477 template <typename T> 478 static inline T triQuadInterpolate (const T (&values)[4], float xFactor, float yFactor) 479 { 480 if (xFactor + yFactor < 1.0f) 481 return values[0] + (values[2]-values[0])*xFactor + (values[1]-values[0])*yFactor; 482 else 483 return values[3] + (values[1]-values[3])*(1.0f-xFactor) + (values[2]-values[3])*(1.0f-yFactor); 484 } 485 486 template <int N> 487 static inline void computeTexCoordVecs (const vector<float>& texCoords, tcu::Vector<float, N> (&dst)[4]) 488 { 489 DE_ASSERT((int)texCoords.size() == 4*N); 490 for (int i = 0; i < 4; i++) 491 for (int j = 0; j < N; j++) 492 dst[i][j] = texCoords[i*N + j]; 493 } 494 495 #if defined(DE_DEBUG) 496 // Whether offsets correspond to the sample offsets used with plain textureGather(). 497 static inline bool isZeroOffsetOffsets (const IVec2 (&offsets)[4]) 498 { 499 IVec2 ref[4]; 500 SinglePixelOffsets(IVec2(0))(IVec2(), ref); 501 return std::equal(DE_ARRAY_BEGIN(offsets), 502 DE_ARRAY_END(offsets), 503 DE_ARRAY_BEGIN(ref)); 504 } 505 #endif 506 507 template <typename ColorScalarType> 508 static tcu::Vector<ColorScalarType, 4> gatherOffsets (const tcu::Texture2DView& texture, const tcu::Sampler& sampler, const Vec2& coord, int componentNdx, const IVec2 (&offsets)[4]) 509 { 510 return texture.gatherOffsets(sampler, coord.x(), coord.y(), componentNdx, offsets).cast<ColorScalarType>(); 511 } 512 513 template <typename ColorScalarType> 514 static tcu::Vector<ColorScalarType, 4> gatherOffsets (const tcu::Texture2DArrayView& texture, const tcu::Sampler& sampler, const Vec3& coord, int componentNdx, const IVec2 (&offsets)[4]) 515 { 516 return texture.gatherOffsets(sampler, coord.x(), coord.y(), coord.z(), componentNdx, offsets).cast<ColorScalarType>(); 517 } 518 519 template <typename ColorScalarType> 520 static tcu::Vector<ColorScalarType, 4> gatherOffsets (const tcu::TextureCubeView& texture, const tcu::Sampler& sampler, const Vec3& coord, int componentNdx, const IVec2 (&offsets)[4]) 521 { 522 DE_ASSERT(isZeroOffsetOffsets(offsets)); 523 DE_UNREF(offsets); 524 return texture.gather(sampler, coord.x(), coord.y(), coord.z(), componentNdx).cast<ColorScalarType>(); 525 } 526 527 static Vec4 gatherOffsetsCompare (const tcu::Texture2DView& texture, const tcu::Sampler& sampler, float refZ, const Vec2& coord, const IVec2 (&offsets)[4]) 528 { 529 return texture.gatherOffsetsCompare(sampler, refZ, coord.x(), coord.y(), offsets); 530 } 531 532 static Vec4 gatherOffsetsCompare (const tcu::Texture2DArrayView& texture, const tcu::Sampler& sampler, float refZ, const Vec3& coord, const IVec2 (&offsets)[4]) 533 { 534 return texture.gatherOffsetsCompare(sampler, refZ, coord.x(), coord.y(), coord.z(), offsets); 535 } 536 537 static Vec4 gatherOffsetsCompare (const tcu::TextureCubeView& texture, const tcu::Sampler& sampler, float refZ, const Vec3& coord, const IVec2 (&offsets)[4]) 538 { 539 DE_ASSERT(isZeroOffsetOffsets(offsets)); 540 DE_UNREF(offsets); 541 return texture.gatherCompare(sampler, refZ, coord.x(), coord.y(), coord.z()); 542 } 543 544 template <typename PrecType, typename ColorScalarT> 545 static bool isGatherOffsetsResultValid (const tcu::TextureCubeView& texture, 546 const tcu::Sampler& sampler, 547 const PrecType& prec, 548 const Vec3& coord, 549 int componentNdx, 550 const IVec2 (&offsets)[4], 551 const tcu::Vector<ColorScalarT, 4>& result) 552 { 553 DE_ASSERT(isZeroOffsetOffsets(offsets)); 554 DE_UNREF(offsets); 555 return tcu::isGatherResultValid(texture, sampler, prec, coord, componentNdx, result); 556 } 557 558 static bool isGatherOffsetsCompareResultValid (const tcu::TextureCubeView& texture, 559 const tcu::Sampler& sampler, 560 const tcu::TexComparePrecision& prec, 561 const Vec3& coord, 562 const IVec2 (&offsets)[4], 563 float cmpReference, 564 const Vec4& result) 565 { 566 DE_ASSERT(isZeroOffsetOffsets(offsets)); 567 DE_UNREF(offsets); 568 return tcu::isGatherCompareResultValid(texture, sampler, prec, coord, cmpReference, result); 569 } 570 571 template <typename ColorScalarType, typename PrecType, typename TexViewT, typename TexCoordT> 572 static bool verifyGatherOffsets (TestLog& log, 573 const ConstPixelBufferAccess& result, 574 const TexViewT& texture, 575 const TexCoordT (&texCoords)[4], 576 const tcu::Sampler& sampler, 577 const PrecType& lookupPrec, 578 int componentNdx, 579 const PixelOffsets& getPixelOffsets) 580 { 581 typedef tcu::Vector<ColorScalarType, 4> ColorVec; 582 583 const int width = result.getWidth(); 584 const int height = result.getWidth(); 585 tcu::TextureLevel ideal (result.getFormat(), width, height); 586 const PixelBufferAccess idealAccess = ideal.getAccess(); 587 tcu::Surface errorMask (width, height); 588 bool success = true; 589 590 tcu::clear(errorMask.getAccess(), tcu::RGBA::green().toVec()); 591 592 for (int py = 0; py < height; py++) 593 for (int px = 0; px < width; px++) 594 { 595 IVec2 offsets[4]; 596 getPixelOffsets(IVec2(px, py), offsets); 597 598 const Vec2 viewportCoord = (Vec2((float)px, (float)py) + 0.5f) / Vec2((float)width, (float)height); 599 const TexCoordT texCoord = triQuadInterpolate(texCoords, viewportCoord.x(), viewportCoord.y()); 600 const ColorVec resultPix = result.getPixelT<ColorScalarType>(px, py); 601 const ColorVec idealPix = gatherOffsets<ColorScalarType>(texture, sampler, texCoord, componentNdx, offsets); 602 603 idealAccess.setPixel(idealPix, px, py); 604 605 if (tcu::boolAny(tcu::logicalAnd(lookupPrec.colorMask, 606 tcu::greaterThan(tcu::absDiff(resultPix, idealPix), 607 lookupPrec.colorThreshold.template cast<ColorScalarType>())))) 608 { 609 if (!isGatherOffsetsResultValid(texture, sampler, lookupPrec, texCoord, componentNdx, offsets, resultPix)) 610 { 611 errorMask.setPixel(px, py, tcu::RGBA::red()); 612 success = false; 613 } 614 } 615 } 616 617 log << TestLog::ImageSet("VerifyResult", "Verification result") 618 << TestLog::Image("Rendered", "Rendered image", result); 619 620 if (!success) 621 { 622 log << TestLog::Image("Reference", "Ideal reference image", ideal) 623 << TestLog::Image("ErrorMask", "Error mask", errorMask); 624 } 625 626 log << TestLog::EndImageSet; 627 628 return success; 629 } 630 631 class PixelCompareRefZ 632 { 633 public: 634 virtual float operator() (const IVec2& pixCoord) const = 0; 635 }; 636 637 class PixelCompareRefZDefault : public PixelCompareRefZ 638 { 639 public: 640 PixelCompareRefZDefault (const IVec2& renderSize) : m_renderSize(renderSize) {} 641 642 float operator() (const IVec2& pixCoord) const 643 { 644 return ((float)pixCoord.x() + 0.5f) / (float)m_renderSize.x(); 645 } 646 647 private: 648 IVec2 m_renderSize; 649 }; 650 651 template <typename TexViewT, typename TexCoordT> 652 static bool verifyGatherOffsetsCompare (TestLog& log, 653 const ConstPixelBufferAccess& result, 654 const TexViewT& texture, 655 const TexCoordT (&texCoords)[4], 656 const tcu::Sampler& sampler, 657 const tcu::TexComparePrecision& compPrec, 658 const PixelCompareRefZ& getPixelRefZ, 659 const PixelOffsets& getPixelOffsets) 660 { 661 const int width = result.getWidth(); 662 const int height = result.getWidth(); 663 tcu::Surface ideal (width, height); 664 const PixelBufferAccess idealAccess = ideal.getAccess(); 665 tcu::Surface errorMask (width, height); 666 bool success = true; 667 668 tcu::clear(errorMask.getAccess(), tcu::RGBA::green().toVec()); 669 670 for (int py = 0; py < height; py++) 671 for (int px = 0; px < width; px++) 672 { 673 IVec2 offsets[4]; 674 getPixelOffsets(IVec2(px, py), offsets); 675 676 const Vec2 viewportCoord = (Vec2((float)px, (float)py) + 0.5f) / Vec2((float)width, (float)height); 677 const TexCoordT texCoord = triQuadInterpolate(texCoords, viewportCoord.x(), viewportCoord.y()); 678 const float refZ = getPixelRefZ(IVec2(px, py)); 679 const Vec4 resultPix = result.getPixel(px, py); 680 const Vec4 idealPix = gatherOffsetsCompare(texture, sampler, refZ, texCoord, offsets); 681 682 idealAccess.setPixel(idealPix, px, py); 683 684 if (!tcu::boolAll(tcu::equal(resultPix, idealPix))) 685 { 686 if (!isGatherOffsetsCompareResultValid(texture, sampler, compPrec, texCoord, offsets, refZ, resultPix)) 687 { 688 errorMask.setPixel(px, py, tcu::RGBA::red()); 689 success = false; 690 } 691 } 692 } 693 694 log << TestLog::ImageSet("VerifyResult", "Verification result") 695 << TestLog::Image("Rendered", "Rendered image", result); 696 697 if (!success) 698 { 699 log << TestLog::Image("Reference", "Ideal reference image", ideal) 700 << TestLog::Image("ErrorMask", "Error mask", errorMask); 701 } 702 703 log << TestLog::EndImageSet; 704 705 return success; 706 } 707 708 static bool verifySingleColored (TestLog& log, const ConstPixelBufferAccess& result, const Vec4& refColor) 709 { 710 const int width = result.getWidth(); 711 const int height = result.getWidth(); 712 tcu::Surface ideal (width, height); 713 const PixelBufferAccess idealAccess = ideal.getAccess(); 714 tcu::Surface errorMask (width, height); 715 bool success = true; 716 717 tcu::clear(errorMask.getAccess(), tcu::RGBA::green().toVec()); 718 tcu::clear(idealAccess, refColor); 719 720 for (int py = 0; py < height; py++) 721 for (int px = 0; px < width; px++) 722 { 723 if (result.getPixel(px, py) != refColor) 724 { 725 errorMask.setPixel(px, py, tcu::RGBA::red()); 726 success = false; 727 } 728 } 729 730 log << TestLog::ImageSet("VerifyResult", "Verification result") 731 << TestLog::Image("Rendered", "Rendered image", result); 732 733 if (!success) 734 { 735 log << TestLog::Image("Reference", "Ideal reference image", ideal) 736 << TestLog::Image("ErrorMask", "Error mask", errorMask); 737 } 738 739 log << TestLog::EndImageSet; 740 741 return success; 742 } 743 744 enum GatherType 745 { 746 GATHERTYPE_BASIC = 0, 747 GATHERTYPE_OFFSET, 748 GATHERTYPE_OFFSET_DYNAMIC, 749 GATHERTYPE_OFFSETS, 750 751 GATHERTYPE_LAST 752 }; 753 754 enum GatherCaseFlags 755 { 756 GATHERCASE_MIPMAP_INCOMPLETE = (1<<0), //!< Excercise special case of sampling mipmap-incomplete texture 757 GATHERCASE_DONT_SAMPLE_CUBE_CORNERS = (1<<1) //!< For cube map cases: do not sample cube corners 758 }; 759 760 static inline const char* gatherTypeName (GatherType type) 761 { 762 switch (type) 763 { 764 case GATHERTYPE_BASIC: return "basic"; 765 case GATHERTYPE_OFFSET: return "offset"; 766 case GATHERTYPE_OFFSET_DYNAMIC: return "offset_dynamic"; 767 case GATHERTYPE_OFFSETS: return "offsets"; 768 default: DE_ASSERT(false); return DE_NULL; 769 } 770 } 771 772 static inline const char* gatherTypeDescription (GatherType type) 773 { 774 switch (type) 775 { 776 case GATHERTYPE_BASIC: return "textureGather"; 777 case GATHERTYPE_OFFSET: return "textureGatherOffset"; 778 case GATHERTYPE_OFFSET_DYNAMIC: return "textureGatherOffset with dynamic offsets"; 779 case GATHERTYPE_OFFSETS: return "textureGatherOffsets"; 780 default: DE_ASSERT(false); return DE_NULL; 781 } 782 } 783 784 static inline bool requireGpuShader5 (GatherType gatherType) 785 { 786 return gatherType == GATHERTYPE_OFFSET_DYNAMIC || gatherType == GATHERTYPE_OFFSETS; 787 } 788 789 struct GatherArgs 790 { 791 int componentNdx; // If negative, implicit component index 0 is used (i.e. the parameter is not given). 792 IVec2 offsets[4]; // \note Unless GATHERTYPE_OFFSETS is used, only offsets[0] is relevant; also, for GATHERTYPE_OFFSET_DYNAMIC, none are relevant. 793 794 GatherArgs (void) 795 : componentNdx(-1) 796 { 797 std::fill(DE_ARRAY_BEGIN(offsets), DE_ARRAY_END(offsets), IVec2()); 798 } 799 800 GatherArgs (int comp, 801 const IVec2& off0 = IVec2(), 802 const IVec2& off1 = IVec2(), 803 const IVec2& off2 = IVec2(), 804 const IVec2& off3 = IVec2()) 805 : componentNdx(comp) 806 { 807 offsets[0] = off0; 808 offsets[1] = off1; 809 offsets[2] = off2; 810 offsets[3] = off3; 811 } 812 }; 813 814 static MovePtr<PixelOffsets> makePixelOffsetsFunctor (GatherType gatherType, const GatherArgs& gatherArgs, const IVec2& offsetRange) 815 { 816 if (gatherType == GATHERTYPE_BASIC || gatherType == GATHERTYPE_OFFSET) 817 { 818 const IVec2 offset = gatherType == GATHERTYPE_BASIC ? IVec2(0) : gatherArgs.offsets[0]; 819 return MovePtr<PixelOffsets>(new SinglePixelOffsets(offset)); 820 } 821 else if (gatherType == GATHERTYPE_OFFSET_DYNAMIC) 822 { 823 return MovePtr<PixelOffsets>(new DynamicSinglePixelOffsets(offsetRange)); 824 } 825 else if (gatherType == GATHERTYPE_OFFSETS) 826 return MovePtr<PixelOffsets>(new MultiplePixelOffsets(gatherArgs.offsets[0], 827 gatherArgs.offsets[1], 828 gatherArgs.offsets[2], 829 gatherArgs.offsets[3])); 830 else 831 { 832 DE_ASSERT(false); 833 return MovePtr<PixelOffsets>(DE_NULL); 834 } 835 } 836 837 static inline glu::DataType getSamplerType (TextureType textureType, const tcu::TextureFormat& format) 838 { 839 if (isDepthFormat(format)) 840 { 841 switch (textureType) 842 { 843 case TEXTURETYPE_2D: return glu::TYPE_SAMPLER_2D_SHADOW; 844 case TEXTURETYPE_2D_ARRAY: return glu::TYPE_SAMPLER_2D_ARRAY_SHADOW; 845 case TEXTURETYPE_CUBE: return glu::TYPE_SAMPLER_CUBE_SHADOW; 846 default: DE_ASSERT(false); return glu::TYPE_LAST; 847 } 848 } 849 else 850 { 851 switch (textureType) 852 { 853 case TEXTURETYPE_2D: return glu::getSampler2DType(format); 854 case TEXTURETYPE_2D_ARRAY: return glu::getSampler2DArrayType(format); 855 case TEXTURETYPE_CUBE: return glu::getSamplerCubeType(format); 856 default: DE_ASSERT(false); return glu::TYPE_LAST; 857 } 858 } 859 } 860 861 static inline glu::DataType getSamplerGatherResultType (glu::DataType samplerType) 862 { 863 switch (samplerType) 864 { 865 case glu::TYPE_SAMPLER_2D_SHADOW: 866 case glu::TYPE_SAMPLER_2D_ARRAY_SHADOW: 867 case glu::TYPE_SAMPLER_CUBE_SHADOW: 868 case glu::TYPE_SAMPLER_2D: 869 case glu::TYPE_SAMPLER_2D_ARRAY: 870 case glu::TYPE_SAMPLER_CUBE: 871 return glu::TYPE_FLOAT_VEC4; 872 873 case glu::TYPE_INT_SAMPLER_2D: 874 case glu::TYPE_INT_SAMPLER_2D_ARRAY: 875 case glu::TYPE_INT_SAMPLER_CUBE: 876 return glu::TYPE_INT_VEC4; 877 878 case glu::TYPE_UINT_SAMPLER_2D: 879 case glu::TYPE_UINT_SAMPLER_2D_ARRAY: 880 case glu::TYPE_UINT_SAMPLER_CUBE: 881 return glu::TYPE_UINT_VEC4; 882 883 default: 884 DE_ASSERT(false); 885 return glu::TYPE_LAST; 886 } 887 } 888 889 static inline int getNumTextureSamplingDimensions (TextureType type) 890 { 891 switch (type) 892 { 893 case TEXTURETYPE_2D: return 2; 894 case TEXTURETYPE_2D_ARRAY: return 3; 895 case TEXTURETYPE_CUBE: return 3; 896 default: DE_ASSERT(false); return -1; 897 } 898 } 899 900 static deUint32 getGLTextureType (TextureType type) 901 { 902 switch (type) 903 { 904 case TEXTURETYPE_2D: return GL_TEXTURE_2D; 905 case TEXTURETYPE_2D_ARRAY: return GL_TEXTURE_2D_ARRAY; 906 case TEXTURETYPE_CUBE: return GL_TEXTURE_CUBE_MAP; 907 default: DE_ASSERT(false); return (deUint32)-1; 908 } 909 } 910 911 enum OffsetSize 912 { 913 OFFSETSIZE_NONE = 0, 914 OFFSETSIZE_MINIMUM_REQUIRED, 915 OFFSETSIZE_IMPLEMENTATION_MAXIMUM, 916 917 OFFSETSIZE_LAST 918 }; 919 920 static inline bool isMipmapFilter (tcu::Sampler::FilterMode filter) 921 { 922 switch (filter) 923 { 924 case tcu::Sampler::NEAREST: 925 case tcu::Sampler::LINEAR: 926 return false; 927 928 case tcu::Sampler::NEAREST_MIPMAP_NEAREST: 929 case tcu::Sampler::NEAREST_MIPMAP_LINEAR: 930 case tcu::Sampler::LINEAR_MIPMAP_NEAREST: 931 case tcu::Sampler::LINEAR_MIPMAP_LINEAR: 932 return true; 933 934 default: 935 DE_ASSERT(false); 936 return false; 937 } 938 } 939 940 class TextureGatherCase : public TestCase 941 { 942 public: 943 TextureGatherCase (Context& context, 944 const char* name, 945 const char* description, 946 TextureType textureType, 947 GatherType gatherType, 948 OffsetSize offsetSize, 949 tcu::TextureFormat textureFormat, 950 tcu::Sampler::CompareMode shadowCompareMode, //!< Should be COMPAREMODE_NONE iff textureFormat is a depth format. 951 tcu::Sampler::WrapMode wrapS, 952 tcu::Sampler::WrapMode wrapT, 953 const MaybeTextureSwizzle& texSwizzle, 954 // \note Filter modes have no effect on gather (except when it comes to 955 // texture completeness); these are supposed to test just that. 956 tcu::Sampler::FilterMode minFilter, 957 tcu::Sampler::FilterMode magFilter, 958 int baseLevel, 959 deUint32 flags); 960 961 void init (void); 962 void deinit (void); 963 IterateResult iterate (void); 964 965 protected: 966 IVec2 getOffsetRange (void) const; 967 968 template <typename TexViewT, typename TexCoordT> 969 bool verify (const ConstPixelBufferAccess& rendered, 970 const TexViewT& texture, 971 const TexCoordT (&bottomLeft)[4], 972 const GatherArgs& gatherArgs) const; 973 974 virtual void generateIterations (void) = 0; 975 virtual void createAndUploadTexture (void) = 0; 976 virtual int getNumIterations (void) const = 0; 977 virtual GatherArgs getGatherArgs (int iterationNdx) const = 0; 978 virtual vector<float> computeQuadTexCoord (int iterationNdx) const = 0; 979 virtual bool verify (int iterationNdx, const ConstPixelBufferAccess& rendered) const = 0; 980 981 const GatherType m_gatherType; 982 const OffsetSize m_offsetSize; 983 const tcu::TextureFormat m_textureFormat; 984 const tcu::Sampler::CompareMode m_shadowCompareMode; 985 const tcu::Sampler::WrapMode m_wrapS; 986 const tcu::Sampler::WrapMode m_wrapT; 987 const MaybeTextureSwizzle m_textureSwizzle; 988 const tcu::Sampler::FilterMode m_minFilter; 989 const tcu::Sampler::FilterMode m_magFilter; 990 const int m_baseLevel; 991 const deUint32 m_flags; 992 993 private: 994 enum 995 { 996 SPEC_MAX_MIN_OFFSET = -8, 997 SPEC_MIN_MAX_OFFSET = 7 998 }; 999 1000 static const IVec2 RENDER_SIZE; 1001 1002 static glu::VertexSource genVertexShaderSource (bool requireGpuShader5, int numTexCoordComponents, bool useNormalizedCoordInput); 1003 static glu::FragmentSource genFragmentShaderSource (bool requireGpuShader5, int numTexCoordComponents, glu::DataType samplerType, const string& funcCall, bool useNormalizedCoordInput, bool usePixCoord); 1004 static string genGatherFuncCall (GatherType, const tcu::TextureFormat&, const GatherArgs&, const string& refZExpr, const IVec2& offsetRange, int indentationDepth); 1005 static glu::ProgramSources genProgramSources (GatherType, TextureType, const tcu::TextureFormat&, const GatherArgs&, const string& refZExpr, const IVec2& offsetRange); 1006 1007 const TextureType m_textureType; 1008 1009 const tcu::TextureFormat m_colorBufferFormat; 1010 MovePtr<glu::Renderbuffer> m_colorBuffer; 1011 MovePtr<glu::Framebuffer> m_fbo; 1012 1013 int m_currentIteration; 1014 MovePtr<ShaderProgram> m_program; 1015 }; 1016 1017 const IVec2 TextureGatherCase::RENDER_SIZE = IVec2(64, 64); 1018 1019 TextureGatherCase::TextureGatherCase (Context& context, 1020 const char* name, 1021 const char* description, 1022 TextureType textureType, 1023 GatherType gatherType, 1024 OffsetSize offsetSize, 1025 tcu::TextureFormat textureFormat, 1026 tcu::Sampler::CompareMode shadowCompareMode, //!< Should be COMPAREMODE_NONE iff textureType == TEXTURETYPE_NORMAL. 1027 tcu::Sampler::WrapMode wrapS, 1028 tcu::Sampler::WrapMode wrapT, 1029 const MaybeTextureSwizzle& textureSwizzle, 1030 tcu::Sampler::FilterMode minFilter, 1031 tcu::Sampler::FilterMode magFilter, 1032 int baseLevel, 1033 deUint32 flags) 1034 : TestCase (context, name, description) 1035 , m_gatherType (gatherType) 1036 , m_offsetSize (offsetSize) 1037 , m_textureFormat (textureFormat) 1038 , m_shadowCompareMode (shadowCompareMode) 1039 , m_wrapS (wrapS) 1040 , m_wrapT (wrapT) 1041 , m_textureSwizzle (textureSwizzle) 1042 , m_minFilter (minFilter) 1043 , m_magFilter (magFilter) 1044 , m_baseLevel (baseLevel) 1045 , m_flags (flags) 1046 , m_textureType (textureType) 1047 , m_colorBufferFormat (tcu::TextureFormat(tcu::TextureFormat::RGBA, 1048 isDepthFormat(textureFormat) ? tcu::TextureFormat::UNORM_INT8 : textureFormat.type)) 1049 , m_currentIteration (0) 1050 { 1051 DE_ASSERT((m_gatherType == GATHERTYPE_BASIC) == (m_offsetSize == OFFSETSIZE_NONE)); 1052 DE_ASSERT((m_shadowCompareMode != tcu::Sampler::COMPAREMODE_NONE) == isDepthFormat(m_textureFormat)); 1053 DE_ASSERT(isUnormFormatType(m_colorBufferFormat.type) || 1054 m_colorBufferFormat.type == tcu::TextureFormat::UNSIGNED_INT8 || 1055 m_colorBufferFormat.type == tcu::TextureFormat::UNSIGNED_INT16 || 1056 m_colorBufferFormat.type == tcu::TextureFormat::SIGNED_INT8 || 1057 m_colorBufferFormat.type == tcu::TextureFormat::SIGNED_INT16); 1058 DE_ASSERT(glu::isGLInternalColorFormatFilterable(glu::getInternalFormat(m_colorBufferFormat)) || 1059 (m_magFilter == tcu::Sampler::NEAREST && (m_minFilter == tcu::Sampler::NEAREST || m_minFilter == tcu::Sampler::NEAREST_MIPMAP_NEAREST))); 1060 DE_ASSERT(isMipmapFilter(m_minFilter) || !(m_flags & GATHERCASE_MIPMAP_INCOMPLETE)); 1061 DE_ASSERT(m_textureType == TEXTURETYPE_CUBE || !(m_flags & GATHERCASE_DONT_SAMPLE_CUBE_CORNERS)); 1062 DE_ASSERT(!((m_flags & GATHERCASE_MIPMAP_INCOMPLETE) && isDepthFormat(m_textureFormat))); // It's not clear what shadow textures should return when incomplete. 1063 } 1064 1065 IVec2 TextureGatherCase::getOffsetRange (void) const 1066 { 1067 switch (m_offsetSize) 1068 { 1069 case OFFSETSIZE_NONE: 1070 return IVec2(0); 1071 break; 1072 1073 case OFFSETSIZE_MINIMUM_REQUIRED: 1074 // \note Defined by spec. 1075 return IVec2(SPEC_MAX_MIN_OFFSET, 1076 SPEC_MIN_MAX_OFFSET); 1077 break; 1078 1079 case OFFSETSIZE_IMPLEMENTATION_MAXIMUM: 1080 return IVec2(m_context.getContextInfo().getInt(GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET), 1081 m_context.getContextInfo().getInt(GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET)); 1082 break; 1083 1084 default: 1085 DE_ASSERT(false); 1086 return IVec2(-1); 1087 } 1088 } 1089 1090 glu::VertexSource TextureGatherCase::genVertexShaderSource (bool requireGpuShader5, int numTexCoordComponents, bool useNormalizedCoordInput) 1091 { 1092 DE_ASSERT(numTexCoordComponents == 2 || numTexCoordComponents == 3); 1093 const string texCoordType = "vec" + de::toString(numTexCoordComponents); 1094 return glu::VertexSource("#version 310 es\n" 1095 + string(requireGpuShader5 ? "#extension GL_EXT_gpu_shader5 : require\n" : "") + 1096 "\n" 1097 "in highp vec2 a_position;\n" 1098 "in highp " + texCoordType + " a_texCoord;\n" 1099 + (useNormalizedCoordInput ? "in highp vec2 a_normalizedCoord; // (0,0) to (1,1)\n" : "") + 1100 "\n" 1101 "out highp " + texCoordType + " v_texCoord;\n" 1102 + (useNormalizedCoordInput ? "out highp vec2 v_normalizedCoord;\n" : "") + 1103 "\n" 1104 "void main (void)\n" 1105 "{\n" 1106 " gl_Position = vec4(a_position.x, a_position.y, 0.0, 1.0);\n" 1107 " v_texCoord = a_texCoord;\n" 1108 + (useNormalizedCoordInput ? "\tv_normalizedCoord = a_normalizedCoord;\n" : "") + 1109 "}\n"); 1110 } 1111 1112 glu::FragmentSource TextureGatherCase::genFragmentShaderSource (bool requireGpuShader5, 1113 int numTexCoordComponents, 1114 glu::DataType samplerType, 1115 const string& funcCall, 1116 bool useNormalizedCoordInput, 1117 bool usePixCoord) 1118 { 1119 DE_ASSERT(glu::isDataTypeSampler(samplerType)); 1120 DE_ASSERT(de::inRange(numTexCoordComponents, 2, 3)); 1121 DE_ASSERT(!usePixCoord || useNormalizedCoordInput); 1122 1123 const string texCoordType = "vec" + de::toString(numTexCoordComponents); 1124 1125 return glu::FragmentSource("#version 310 es\n" 1126 + string(requireGpuShader5 ? "#extension GL_EXT_gpu_shader5 : require\n" : "") + 1127 "\n" 1128 "layout (location = 0) out mediump " + glu::getDataTypeName(getSamplerGatherResultType(samplerType)) + " o_color;\n" 1129 "\n" 1130 "in highp " + texCoordType + " v_texCoord;\n" 1131 + (useNormalizedCoordInput ? "in highp vec2 v_normalizedCoord;\n" : "") + 1132 "\n" 1133 "uniform highp " + string(glu::getDataTypeName(samplerType)) + " u_sampler;\n" 1134 + (useNormalizedCoordInput ? "uniform highp vec2 u_viewportSize;\n" : "") + 1135 "\n" 1136 "void main(void)\n" 1137 "{\n" 1138 + (usePixCoord ? "\tivec2 pixCoord = ivec2(v_normalizedCoord*u_viewportSize);\n" : "") + 1139 " o_color = " + funcCall + ";\n" 1140 "}\n"); 1141 } 1142 1143 string TextureGatherCase::genGatherFuncCall (GatherType gatherType, const tcu::TextureFormat& textureFormat, const GatherArgs& gatherArgs, const string& refZExpr, const IVec2& offsetRange, int indentationDepth) 1144 { 1145 string result; 1146 1147 switch (gatherType) 1148 { 1149 case GATHERTYPE_BASIC: 1150 result += "textureGather"; 1151 break; 1152 case GATHERTYPE_OFFSET: // \note Fallthrough. 1153 case GATHERTYPE_OFFSET_DYNAMIC: 1154 result += "textureGatherOffset"; 1155 break; 1156 case GATHERTYPE_OFFSETS: 1157 result += "textureGatherOffsets"; 1158 break; 1159 default: 1160 DE_ASSERT(false); 1161 } 1162 1163 result += "(u_sampler, v_texCoord"; 1164 1165 if (isDepthFormat(textureFormat)) 1166 { 1167 DE_ASSERT(gatherArgs.componentNdx < 0); 1168 result += ", " + refZExpr; 1169 } 1170 1171 if (gatherType == GATHERTYPE_OFFSET || 1172 gatherType == GATHERTYPE_OFFSET_DYNAMIC || 1173 gatherType == GATHERTYPE_OFFSETS) 1174 { 1175 result += ", "; 1176 switch (gatherType) 1177 { 1178 case GATHERTYPE_OFFSET: 1179 result += "ivec2" + de::toString(gatherArgs.offsets[0]); 1180 break; 1181 1182 case GATHERTYPE_OFFSET_DYNAMIC: 1183 result += "pixCoord.yx % ivec2(" + de::toString(offsetRange.y() - offsetRange.x() + 1) + ") + " + de::toString(offsetRange.x()); 1184 break; 1185 1186 case GATHERTYPE_OFFSETS: 1187 result += "ivec2[4](\n" 1188 + string(indentationDepth, '\t') + "\tivec2" + de::toString(gatherArgs.offsets[0]) + ",\n" 1189 + string(indentationDepth, '\t') + "\tivec2" + de::toString(gatherArgs.offsets[1]) + ",\n" 1190 + string(indentationDepth, '\t') + "\tivec2" + de::toString(gatherArgs.offsets[2]) + ",\n" 1191 + string(indentationDepth, '\t') + "\tivec2" + de::toString(gatherArgs.offsets[3]) + ")\n" 1192 + string(indentationDepth, '\t') + "\t"; 1193 break; 1194 1195 default: 1196 DE_ASSERT(false); 1197 } 1198 } 1199 1200 if (gatherArgs.componentNdx >= 0) 1201 { 1202 DE_ASSERT(gatherArgs.componentNdx < 4); 1203 result += ", " + de::toString(gatherArgs.componentNdx); 1204 } 1205 1206 result += ")"; 1207 1208 return result; 1209 } 1210 1211 // \note If componentNdx for genProgramSources() is -1, component index is not specified. 1212 glu::ProgramSources TextureGatherCase::genProgramSources (GatherType gatherType, 1213 TextureType textureType, 1214 const tcu::TextureFormat& textureFormat, 1215 const GatherArgs& gatherArgs, 1216 const string& refZExpr, 1217 const IVec2& offsetRange) 1218 { 1219 const bool usePixCoord = gatherType == GATHERTYPE_OFFSET_DYNAMIC; 1220 const bool useNormalizedCoord = usePixCoord || isDepthFormat(textureFormat); 1221 const bool isDynamicOffset = gatherType == GATHERTYPE_OFFSET_DYNAMIC; 1222 const bool isShadow = isDepthFormat(textureFormat); 1223 const glu::DataType samplerType = getSamplerType(textureType, textureFormat); 1224 const int numDims = getNumTextureSamplingDimensions(textureType); 1225 const string funcCall = genGatherFuncCall(gatherType, textureFormat, gatherArgs, refZExpr, offsetRange, 1); 1226 1227 return glu::ProgramSources() << genVertexShaderSource(requireGpuShader5(gatherType), numDims, isDynamicOffset || isShadow) 1228 << genFragmentShaderSource(requireGpuShader5(gatherType), numDims, samplerType, funcCall, useNormalizedCoord, usePixCoord); 1229 } 1230 1231 void TextureGatherCase::init (void) 1232 { 1233 TestLog& log = m_testCtx.getLog(); 1234 const glu::RenderContext& renderCtx = m_context.getRenderContext(); 1235 const glw::Functions& gl = renderCtx.getFunctions(); 1236 const deUint32 texTypeGL = getGLTextureType(m_textureType); 1237 1238 // Check prerequisites. 1239 if (requireGpuShader5(m_gatherType) && !m_context.getContextInfo().isExtensionSupported("GL_EXT_gpu_shader5")) 1240 throw tcu::NotSupportedError("GL_EXT_gpu_shader5 required"); 1241 1242 // Log and check implementation offset limits, if appropriate. 1243 if (m_offsetSize == OFFSETSIZE_IMPLEMENTATION_MAXIMUM) 1244 { 1245 const IVec2 offsetRange = getOffsetRange(); 1246 log << TestLog::Integer("ImplementationMinTextureGatherOffset", "Implementation's value for GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET", "", QP_KEY_TAG_NONE, offsetRange[0]) 1247 << TestLog::Integer("ImplementationMaxTextureGatherOffset", "Implementation's value for GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET", "", QP_KEY_TAG_NONE, offsetRange[1]); 1248 TCU_CHECK_MSG(offsetRange[0] <= SPEC_MAX_MIN_OFFSET, ("GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET must be at most " + de::toString((int)SPEC_MAX_MIN_OFFSET)).c_str()); 1249 TCU_CHECK_MSG(offsetRange[1] >= SPEC_MIN_MAX_OFFSET, ("GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET must be at least " + de::toString((int)SPEC_MIN_MAX_OFFSET)).c_str()); 1250 } 1251 1252 // Create rbo and fbo. 1253 1254 m_colorBuffer = MovePtr<glu::Renderbuffer>(new glu::Renderbuffer(renderCtx)); 1255 gl.bindRenderbuffer(GL_RENDERBUFFER, **m_colorBuffer); 1256 gl.renderbufferStorage(GL_RENDERBUFFER, glu::getInternalFormat(m_colorBufferFormat), RENDER_SIZE.x(), RENDER_SIZE.y()); 1257 GLU_EXPECT_NO_ERROR(gl.getError(), "Create and setup renderbuffer object"); 1258 1259 m_fbo = MovePtr<glu::Framebuffer>(new glu::Framebuffer(renderCtx)); 1260 gl.bindFramebuffer(GL_FRAMEBUFFER, **m_fbo); 1261 gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, **m_colorBuffer); 1262 GLU_EXPECT_NO_ERROR(gl.getError(), "Create and setup framebuffer object"); 1263 1264 log << TestLog::Message << "Using a framebuffer object with renderbuffer with format " 1265 << glu::getTextureFormatName(glu::getInternalFormat(m_colorBufferFormat)) 1266 << " and size " << RENDER_SIZE << TestLog::EndMessage; 1267 1268 // Generate subclass-specific iterations. 1269 1270 generateIterations(); 1271 m_currentIteration = 0; 1272 1273 // Initialize texture. 1274 1275 createAndUploadTexture(); 1276 gl.texParameteri(texTypeGL, GL_TEXTURE_WRAP_S, glu::getGLWrapMode(m_wrapS)); 1277 gl.texParameteri(texTypeGL, GL_TEXTURE_WRAP_T, glu::getGLWrapMode(m_wrapT)); 1278 gl.texParameteri(texTypeGL, GL_TEXTURE_MIN_FILTER, glu::getGLFilterMode(m_minFilter)); 1279 gl.texParameteri(texTypeGL, GL_TEXTURE_MAG_FILTER, glu::getGLFilterMode(m_magFilter)); 1280 1281 if (m_baseLevel != 0) 1282 gl.texParameteri(texTypeGL, GL_TEXTURE_BASE_LEVEL, m_baseLevel); 1283 1284 if (isDepthFormat(m_textureFormat)) 1285 { 1286 gl.texParameteri(texTypeGL, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); 1287 gl.texParameteri(texTypeGL, GL_TEXTURE_COMPARE_FUNC, glu::getGLCompareFunc(m_shadowCompareMode)); 1288 } 1289 1290 if (m_textureSwizzle.isSome()) 1291 { 1292 const deUint32 swizzleNamesGL[4] = 1293 { 1294 GL_TEXTURE_SWIZZLE_R, 1295 GL_TEXTURE_SWIZZLE_G, 1296 GL_TEXTURE_SWIZZLE_B, 1297 GL_TEXTURE_SWIZZLE_A 1298 }; 1299 1300 for (int i = 0; i < 4; i++) 1301 { 1302 const deUint32 curGLSwizzle = getGLTextureSwizzleComponent(m_textureSwizzle.getSwizzle()[i]); 1303 gl.texParameteri(texTypeGL, swizzleNamesGL[i], curGLSwizzle); 1304 } 1305 } 1306 1307 GLU_EXPECT_NO_ERROR(gl.getError(), "Set texture parameters"); 1308 1309 log << TestLog::Message << "Texture base level is " << m_baseLevel << TestLog::EndMessage 1310 << TestLog::Message << "s and t wrap modes are " 1311 << glu::getTextureWrapModeName(glu::getGLWrapMode(m_wrapS)) << " and " 1312 << glu::getTextureWrapModeName(glu::getGLWrapMode(m_wrapT)) << ", respectively" << TestLog::EndMessage 1313 << TestLog::Message << "Minification and magnification filter modes are " 1314 << glu::getTextureFilterName(glu::getGLFilterMode(m_minFilter)) << " and " 1315 << glu::getTextureFilterName(glu::getGLFilterMode(m_magFilter)) << ", respectively " 1316 << ((m_flags & GATHERCASE_MIPMAP_INCOMPLETE) ? 1317 "(note that they cause the texture to be incomplete)" : 1318 "(note that they should have no effect on gather result)") 1319 << TestLog::EndMessage 1320 << TestLog::Message << "Using texture swizzle " << m_textureSwizzle << TestLog::EndMessage; 1321 1322 if (m_shadowCompareMode != tcu::Sampler::COMPAREMODE_NONE) 1323 log << TestLog::Message << "Using texture compare func " << glu::getCompareFuncName(glu::getGLCompareFunc(m_shadowCompareMode)) << TestLog::EndMessage; 1324 } 1325 1326 void TextureGatherCase::deinit (void) 1327 { 1328 m_program = MovePtr<ShaderProgram>(DE_NULL); 1329 m_fbo = MovePtr<glu::Framebuffer>(DE_NULL); 1330 m_colorBuffer = MovePtr<glu::Renderbuffer>(DE_NULL); 1331 } 1332 1333 TextureGatherCase::IterateResult TextureGatherCase::iterate (void) 1334 { 1335 TestLog& log = m_testCtx.getLog(); 1336 const tcu::ScopedLogSection iterationSection (log, "Iteration" + de::toString(m_currentIteration), "Iteration " + de::toString(m_currentIteration)); 1337 const glu::RenderContext& renderCtx = m_context.getRenderContext(); 1338 const glw::Functions& gl = renderCtx.getFunctions(); 1339 const GatherArgs& gatherArgs = getGatherArgs(m_currentIteration); 1340 const string refZExpr = "v_normalizedCoord.x"; 1341 const bool needPixelCoordInShader = m_gatherType == GATHERTYPE_OFFSET_DYNAMIC; 1342 const bool needNormalizedCoordInShader = needPixelCoordInShader || isDepthFormat(m_textureFormat); 1343 1344 // Generate a program appropriate for this iteration. 1345 1346 m_program = MovePtr<ShaderProgram>(new ShaderProgram(renderCtx, genProgramSources(m_gatherType, m_textureType, m_textureFormat, gatherArgs, refZExpr, getOffsetRange()))); 1347 if (m_currentIteration == 0) 1348 m_testCtx.getLog() << *m_program; 1349 else 1350 m_testCtx.getLog() << TestLog::Message << "Using a program similar to the previous one, except with a gather function call as follows:\n" 1351 << genGatherFuncCall(m_gatherType, m_textureFormat, gatherArgs, refZExpr, getOffsetRange(), 0) 1352 << TestLog::EndMessage; 1353 if (!m_program->isOk()) 1354 { 1355 if (m_currentIteration != 0) 1356 m_testCtx.getLog() << *m_program; 1357 TCU_FAIL("Failed to build program"); 1358 } 1359 1360 // Render. 1361 1362 gl.viewport(0, 0, RENDER_SIZE.x(), RENDER_SIZE.y()); 1363 gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f); 1364 gl.clear(GL_COLOR_BUFFER_BIT); 1365 1366 { 1367 const float position[4*2] = 1368 { 1369 -1.0f, -1.0f, 1370 -1.0f, +1.0f, 1371 +1.0f, -1.0f, 1372 +1.0f, +1.0f, 1373 }; 1374 1375 const float normalizedCoord[4*2] = 1376 { 1377 0.0f, 0.0f, 1378 0.0f, 1.0f, 1379 1.0f, 0.0f, 1380 1.0f, 1.0f, 1381 }; 1382 1383 const vector<float> texCoord = computeQuadTexCoord(m_currentIteration); 1384 1385 vector<glu::VertexArrayBinding> attrBindings; 1386 attrBindings.push_back(glu::va::Float("a_position", 2, 4, 0, &position[0])); 1387 attrBindings.push_back(glu::va::Float("a_texCoord", (int)texCoord.size()/4, 4, 0, &texCoord[0])); 1388 if (needNormalizedCoordInShader) 1389 attrBindings.push_back(glu::va::Float("a_normalizedCoord", 2, 4, 0, &normalizedCoord[0])); 1390 1391 const deUint16 indices[6] = { 0, 1, 2, 2, 1, 3 }; 1392 1393 gl.useProgram(m_program->getProgram()); 1394 1395 { 1396 const int samplerUniformLocation = gl.getUniformLocation(m_program->getProgram(), "u_sampler"); 1397 TCU_CHECK(samplerUniformLocation >= 0); 1398 gl.uniform1i(samplerUniformLocation, 0); 1399 } 1400 1401 if (needPixelCoordInShader) 1402 { 1403 const int viewportSizeUniformLocation = gl.getUniformLocation(m_program->getProgram(), "u_viewportSize"); 1404 TCU_CHECK(viewportSizeUniformLocation >= 0); 1405 gl.uniform2f(viewportSizeUniformLocation, (float)RENDER_SIZE.x(), (float)RENDER_SIZE.y()); 1406 } 1407 1408 if (texCoord.size() == 2*4) 1409 { 1410 Vec2 texCoordVec[4]; 1411 computeTexCoordVecs(texCoord, texCoordVec); 1412 log << TestLog::Message << "Texture coordinates run from " << texCoordVec[0] << " to " << texCoordVec[3] << TestLog::EndMessage; 1413 } 1414 else if (texCoord.size() == 3*4) 1415 { 1416 Vec3 texCoordVec[4]; 1417 computeTexCoordVecs(texCoord, texCoordVec); 1418 log << TestLog::Message << "Texture coordinates run from " << texCoordVec[0] << " to " << texCoordVec[3] << TestLog::EndMessage; 1419 } 1420 else 1421 DE_ASSERT(false); 1422 1423 glu::draw(renderCtx, m_program->getProgram(), (int)attrBindings.size(), &attrBindings[0], 1424 glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0])); 1425 } 1426 1427 // Verify result. 1428 1429 { 1430 const tcu::TextureLevel rendered = getPixels(renderCtx, RENDER_SIZE, m_colorBufferFormat); 1431 1432 if (!verify(m_currentIteration, rendered.getAccess())) 1433 { 1434 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Result verification failed"); 1435 return STOP; 1436 } 1437 } 1438 1439 m_currentIteration++; 1440 if (m_currentIteration == (int)getNumIterations()) 1441 { 1442 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1443 return STOP; 1444 } 1445 else 1446 return CONTINUE; 1447 } 1448 1449 template <typename TexViewT, typename TexCoordT> 1450 bool TextureGatherCase::verify (const ConstPixelBufferAccess& rendered, 1451 const TexViewT& texture, 1452 const TexCoordT (&texCoords)[4], 1453 const GatherArgs& gatherArgs) const 1454 { 1455 TestLog& log = m_testCtx.getLog(); 1456 1457 if (m_flags & GATHERCASE_MIPMAP_INCOMPLETE) 1458 { 1459 const int componentNdx = de::max(0, gatherArgs.componentNdx); 1460 const Vec4 incompleteColor (0.0f, 0.0f, 0.0f, 1.0f); 1461 const Vec4 refColor (incompleteColor[componentNdx]); 1462 const bool isOk = verifySingleColored(log, rendered, refColor); 1463 1464 if (!isOk) 1465 log << TestLog::Message << "Note: expected color " << refColor << " for all pixels; " 1466 << incompleteColor[componentNdx] << " is component at index " << componentNdx 1467 << " in the color " << incompleteColor << ", which is used for incomplete textures" << TestLog::EndMessage; 1468 1469 return isOk; 1470 } 1471 else 1472 { 1473 DE_ASSERT(m_colorBufferFormat.order == tcu::TextureFormat::RGBA); 1474 DE_ASSERT(m_colorBufferFormat.type == tcu::TextureFormat::UNORM_INT8 || 1475 m_colorBufferFormat.type == tcu::TextureFormat::UNSIGNED_INT8 || 1476 m_colorBufferFormat.type == tcu::TextureFormat::SIGNED_INT8); 1477 1478 const MovePtr<PixelOffsets> pixelOffsets = makePixelOffsetsFunctor(m_gatherType, gatherArgs, getOffsetRange()); 1479 const tcu::PixelFormat pixelFormat = tcu::PixelFormat(8,8,8,8); 1480 const IVec4 colorBits = tcu::max(glu::TextureTestUtil::getBitsVec(pixelFormat) - 1, tcu::IVec4(0)); 1481 const IVec3 coordBits = m_textureType == TEXTURETYPE_2D ? IVec3(20,20,0) 1482 : m_textureType == TEXTURETYPE_CUBE ? IVec3(10,10,10) 1483 : m_textureType == TEXTURETYPE_2D_ARRAY ? IVec3(20,20,20) 1484 : IVec3(-1); 1485 const IVec3 uvwBits = m_textureType == TEXTURETYPE_2D ? IVec3(7,7,0) 1486 : m_textureType == TEXTURETYPE_CUBE ? IVec3(6,6,0) 1487 : m_textureType == TEXTURETYPE_2D_ARRAY ? IVec3(7,7,7) 1488 : IVec3(-1); 1489 tcu::Sampler sampler; 1490 sampler.wrapS = m_wrapS; 1491 sampler.wrapT = m_wrapT; 1492 sampler.compare = m_shadowCompareMode; 1493 1494 if (isDepthFormat(m_textureFormat)) 1495 { 1496 tcu::TexComparePrecision comparePrec; 1497 comparePrec.coordBits = coordBits; 1498 comparePrec.uvwBits = uvwBits; 1499 comparePrec.referenceBits = 16; 1500 comparePrec.resultBits = pixelFormat.redBits-1; 1501 1502 return verifyGatherOffsetsCompare(log, rendered, texture, texCoords, sampler, comparePrec, PixelCompareRefZDefault(RENDER_SIZE), *pixelOffsets); 1503 } 1504 else 1505 { 1506 const int componentNdx = de::max(0, gatherArgs.componentNdx); 1507 1508 if (isUnormFormatType(m_textureFormat.type)) 1509 { 1510 tcu::LookupPrecision lookupPrec; 1511 lookupPrec.colorThreshold = tcu::computeFixedPointThreshold(colorBits); 1512 lookupPrec.coordBits = coordBits; 1513 lookupPrec.uvwBits = uvwBits; 1514 lookupPrec.colorMask = glu::TextureTestUtil::getCompareMask(pixelFormat); 1515 return verifyGatherOffsets<float>(log, rendered, texture, texCoords, sampler, lookupPrec, componentNdx, *pixelOffsets); 1516 } 1517 else if (isUIntFormatType(m_textureFormat.type) || isSIntFormatType(m_textureFormat.type)) 1518 { 1519 tcu::IntLookupPrecision lookupPrec; 1520 lookupPrec.colorThreshold = UVec4(0); 1521 lookupPrec.coordBits = coordBits; 1522 lookupPrec.uvwBits = uvwBits; 1523 lookupPrec.colorMask = glu::TextureTestUtil::getCompareMask(pixelFormat); 1524 1525 if (isUIntFormatType(m_textureFormat.type)) 1526 return verifyGatherOffsets<deUint32>(log, rendered, texture, texCoords, sampler, lookupPrec, componentNdx, *pixelOffsets); 1527 else if (isSIntFormatType(m_textureFormat.type)) 1528 return verifyGatherOffsets<deInt32>(log, rendered, texture, texCoords, sampler, lookupPrec, componentNdx, *pixelOffsets); 1529 else 1530 { 1531 DE_ASSERT(false); 1532 return false; 1533 } 1534 } 1535 else 1536 { 1537 DE_ASSERT(false); 1538 return false; 1539 } 1540 } 1541 } 1542 } 1543 1544 vector<GatherArgs> generateBasic2DCaseIterations (GatherType gatherType, const tcu::TextureFormat& textureFormat, const IVec2& offsetRange) 1545 { 1546 const int numComponentCases = isDepthFormat(textureFormat) ? 1 : 4+1; // \note For non-depth textures, test explicit components 0 to 3 and implicit component 0. 1547 vector<GatherArgs> result; 1548 1549 for (int componentCaseNdx = 0; componentCaseNdx < numComponentCases; componentCaseNdx++) 1550 { 1551 const int componentNdx = componentCaseNdx - 1; 1552 1553 switch (gatherType) 1554 { 1555 case GATHERTYPE_BASIC: 1556 result.push_back(GatherArgs(componentNdx)); 1557 break; 1558 1559 case GATHERTYPE_OFFSET: 1560 { 1561 const int min = offsetRange.x(); 1562 const int max = offsetRange.y(); 1563 const int hmin = divRoundToZero(min, 2); 1564 const int hmax = divRoundToZero(max, 2); 1565 1566 result.push_back(GatherArgs(componentNdx, IVec2(min, max))); 1567 1568 if (componentCaseNdx == 0) // Don't test all offsets variants for all color components (they should be pretty orthogonal). 1569 { 1570 result.push_back(GatherArgs(componentNdx, IVec2(min, min))); 1571 result.push_back(GatherArgs(componentNdx, IVec2(max, min))); 1572 result.push_back(GatherArgs(componentNdx, IVec2(max, max))); 1573 1574 result.push_back(GatherArgs(componentNdx, IVec2(0, hmax))); 1575 result.push_back(GatherArgs(componentNdx, IVec2(hmin, 0))); 1576 result.push_back(GatherArgs(componentNdx, IVec2(0, 0))); 1577 } 1578 1579 break; 1580 } 1581 1582 case GATHERTYPE_OFFSET_DYNAMIC: 1583 result.push_back(GatherArgs(componentNdx)); 1584 break; 1585 1586 case GATHERTYPE_OFFSETS: 1587 { 1588 const int min = offsetRange.x(); 1589 const int max = offsetRange.y(); 1590 const int hmin = divRoundToZero(min, 2); 1591 const int hmax = divRoundToZero(max, 2); 1592 1593 result.push_back(GatherArgs(componentNdx, 1594 IVec2(min, min), 1595 IVec2(min, max), 1596 IVec2(max, min), 1597 IVec2(max, max))); 1598 1599 if (componentCaseNdx == 0) // Don't test all offsets variants for all color components (they should be pretty orthogonal). 1600 result.push_back(GatherArgs(componentNdx, 1601 IVec2(min, hmax), 1602 IVec2(hmin, max), 1603 IVec2(0, hmax), 1604 IVec2(hmax, 0))); 1605 break; 1606 } 1607 1608 default: 1609 DE_ASSERT(false); 1610 } 1611 } 1612 1613 return result; 1614 } 1615 1616 class TextureGather2DCase : public TextureGatherCase 1617 { 1618 public: 1619 TextureGather2DCase (Context& context, 1620 const char* name, 1621 const char* description, 1622 GatherType gatherType, 1623 OffsetSize offsetSize, 1624 tcu::TextureFormat textureFormat, 1625 tcu::Sampler::CompareMode shadowCompareMode, 1626 tcu::Sampler::WrapMode wrapS, 1627 tcu::Sampler::WrapMode wrapT, 1628 const MaybeTextureSwizzle& texSwizzle, 1629 tcu::Sampler::FilterMode minFilter, 1630 tcu::Sampler::FilterMode magFilter, 1631 int baseLevel, 1632 deUint32 flags, 1633 const IVec2& textureSize) 1634 : TextureGatherCase (context, name, description, TEXTURETYPE_2D, gatherType, offsetSize, textureFormat, shadowCompareMode, wrapS, wrapT, texSwizzle, minFilter, magFilter, baseLevel, flags) 1635 , m_textureSize (textureSize) 1636 , m_swizzledTexture (tcu::TextureFormat(), 1, 1) 1637 { 1638 } 1639 1640 protected: 1641 void generateIterations (void); 1642 void createAndUploadTexture (void); 1643 int getNumIterations (void) const { DE_ASSERT(!m_iterations.empty()); return (int)m_iterations.size(); } 1644 GatherArgs getGatherArgs (int iterationNdx) const { return m_iterations[iterationNdx]; } 1645 vector<float> computeQuadTexCoord (int iterationNdx) const; 1646 bool verify (int iterationNdx, const ConstPixelBufferAccess& rendered) const; 1647 1648 private: 1649 const IVec2 m_textureSize; 1650 1651 MovePtr<glu::Texture2D> m_texture; 1652 tcu::Texture2D m_swizzledTexture; 1653 vector<GatherArgs> m_iterations; 1654 }; 1655 1656 vector<float> TextureGather2DCase::computeQuadTexCoord (int /* iterationNdx */) const 1657 { 1658 vector<float> res; 1659 glu::TextureTestUtil::computeQuadTexCoord2D(res, Vec2(-0.3f, -0.4f), Vec2(1.5f, 1.6f)); 1660 return res; 1661 } 1662 1663 void TextureGather2DCase::generateIterations (void) 1664 { 1665 DE_ASSERT(m_iterations.empty()); 1666 m_iterations = generateBasic2DCaseIterations(m_gatherType, m_textureFormat, getOffsetRange()); 1667 } 1668 1669 void TextureGather2DCase::createAndUploadTexture (void) 1670 { 1671 const glu::RenderContext& renderCtx = m_context.getRenderContext(); 1672 const glw::Functions& gl = renderCtx.getFunctions(); 1673 const tcu::TextureFormatInfo texFmtInfo = tcu::getTextureFormatInfo(m_textureFormat); 1674 1675 m_texture = MovePtr<glu::Texture2D>(new glu::Texture2D(renderCtx, glu::getInternalFormat(m_textureFormat), m_textureSize.x(), m_textureSize.y())); 1676 1677 { 1678 tcu::Texture2D& refTexture = m_texture->getRefTexture(); 1679 const int levelBegin = m_baseLevel; 1680 const int levelEnd = isMipmapFilter(m_minFilter) && !(m_flags & GATHERCASE_MIPMAP_INCOMPLETE) ? refTexture.getNumLevels() : m_baseLevel+1; 1681 DE_ASSERT(m_baseLevel < refTexture.getNumLevels()); 1682 1683 for (int levelNdx = levelBegin; levelNdx < levelEnd; levelNdx++) 1684 { 1685 refTexture.allocLevel(levelNdx); 1686 const PixelBufferAccess& level = refTexture.getLevel(levelNdx); 1687 fillWithRandomColorTiles(level, texFmtInfo.valueMin, texFmtInfo.valueMax, (deUint32)m_testCtx.getCommandLine().getBaseSeed()); 1688 m_testCtx.getLog() << TestLog::Image("InputTextureLevel" + de::toString(levelNdx), "Input texture, level " + de::toString(levelNdx), level) 1689 << TestLog::Message << "Note: texture level's size is " << IVec2(level.getWidth(), level.getHeight()) << TestLog::EndMessage; 1690 } 1691 1692 swizzleTexture(m_swizzledTexture, refTexture, m_textureSwizzle); 1693 } 1694 1695 gl.activeTexture(GL_TEXTURE0); 1696 m_texture->upload(); 1697 } 1698 1699 bool TextureGather2DCase::verify (int iterationNdx, const ConstPixelBufferAccess& rendered) const 1700 { 1701 Vec2 texCoords[4]; 1702 computeTexCoordVecs(computeQuadTexCoord(iterationNdx), texCoords); 1703 return TextureGatherCase::verify(rendered, getOneLevelSubView(tcu::Texture2DView(m_swizzledTexture), m_baseLevel), texCoords, m_iterations[iterationNdx]); 1704 } 1705 1706 class TextureGather2DArrayCase : public TextureGatherCase 1707 { 1708 public: 1709 TextureGather2DArrayCase (Context& context, 1710 const char* name, 1711 const char* description, 1712 GatherType gatherType, 1713 OffsetSize offsetSize, 1714 tcu::TextureFormat textureFormat, 1715 tcu::Sampler::CompareMode shadowCompareMode, 1716 tcu::Sampler::WrapMode wrapS, 1717 tcu::Sampler::WrapMode wrapT, 1718 const MaybeTextureSwizzle& texSwizzle, 1719 tcu::Sampler::FilterMode minFilter, 1720 tcu::Sampler::FilterMode magFilter, 1721 int baseLevel, 1722 deUint32 flags, 1723 const IVec3& textureSize) 1724 : TextureGatherCase (context, name, description, TEXTURETYPE_2D_ARRAY, gatherType, offsetSize, textureFormat, shadowCompareMode, wrapS, wrapT, texSwizzle, minFilter, magFilter, baseLevel, flags) 1725 , m_textureSize (textureSize) 1726 , m_swizzledTexture (tcu::TextureFormat(), 1, 1, 1) 1727 { 1728 } 1729 1730 protected: 1731 void generateIterations (void); 1732 void createAndUploadTexture (void); 1733 int getNumIterations (void) const { DE_ASSERT(!m_iterations.empty()); return (int)m_iterations.size(); } 1734 GatherArgs getGatherArgs (int iterationNdx) const { return m_iterations[iterationNdx].gatherArgs; } 1735 vector<float> computeQuadTexCoord (int iterationNdx) const; 1736 bool verify (int iterationNdx, const ConstPixelBufferAccess& rendered) const; 1737 1738 private: 1739 struct Iteration 1740 { 1741 GatherArgs gatherArgs; 1742 int layerNdx; 1743 }; 1744 1745 const IVec3 m_textureSize; 1746 1747 MovePtr<glu::Texture2DArray> m_texture; 1748 tcu::Texture2DArray m_swizzledTexture; 1749 vector<Iteration> m_iterations; 1750 }; 1751 1752 vector<float> TextureGather2DArrayCase::computeQuadTexCoord (int iterationNdx) const 1753 { 1754 vector<float> res; 1755 glu::TextureTestUtil::computeQuadTexCoord2DArray(res, m_iterations[iterationNdx].layerNdx, Vec2(-0.3f, -0.4f), Vec2(1.5f, 1.6f)); 1756 return res; 1757 } 1758 1759 void TextureGather2DArrayCase::generateIterations (void) 1760 { 1761 DE_ASSERT(m_iterations.empty()); 1762 1763 const vector<GatherArgs> basicIterations = generateBasic2DCaseIterations(m_gatherType, m_textureFormat, getOffsetRange()); 1764 1765 // \note Out-of-bounds layer indices are tested too. 1766 for (int layerNdx = -1; layerNdx < m_textureSize.z()+1; layerNdx++) 1767 { 1768 // Don't duplicate all cases for all layers. 1769 if (layerNdx == 0) 1770 { 1771 for (int basicNdx = 0; basicNdx < (int)basicIterations.size(); basicNdx++) 1772 { 1773 m_iterations.push_back(Iteration()); 1774 m_iterations.back().gatherArgs = basicIterations[basicNdx]; 1775 m_iterations.back().layerNdx = layerNdx; 1776 } 1777 } 1778 else 1779 { 1780 // For other layers than 0, only test one component and one set of offsets per layer. 1781 for (int basicNdx = 0; basicNdx < (int)basicIterations.size(); basicNdx++) 1782 { 1783 if (isDepthFormat(m_textureFormat) || basicIterations[basicNdx].componentNdx == (layerNdx + 2) % 4) 1784 { 1785 m_iterations.push_back(Iteration()); 1786 m_iterations.back().gatherArgs = basicIterations[basicNdx]; 1787 m_iterations.back().layerNdx = layerNdx; 1788 break; 1789 } 1790 } 1791 } 1792 } 1793 } 1794 1795 void TextureGather2DArrayCase::createAndUploadTexture (void) 1796 { 1797 TestLog& log = m_testCtx.getLog(); 1798 const glu::RenderContext& renderCtx = m_context.getRenderContext(); 1799 const glw::Functions& gl = renderCtx.getFunctions(); 1800 const tcu::TextureFormatInfo texFmtInfo = tcu::getTextureFormatInfo(m_textureFormat); 1801 1802 m_texture = MovePtr<glu::Texture2DArray>(new glu::Texture2DArray(renderCtx, glu::getInternalFormat(m_textureFormat), m_textureSize.x(), m_textureSize.y(), m_textureSize.z())); 1803 1804 { 1805 tcu::Texture2DArray& refTexture = m_texture->getRefTexture(); 1806 const int levelBegin = m_baseLevel; 1807 const int levelEnd = isMipmapFilter(m_minFilter) && !(m_flags & GATHERCASE_MIPMAP_INCOMPLETE) ? refTexture.getNumLevels() : m_baseLevel+1; 1808 DE_ASSERT(m_baseLevel < refTexture.getNumLevels()); 1809 1810 for (int levelNdx = levelBegin; levelNdx < levelEnd; levelNdx++) 1811 { 1812 refTexture.allocLevel(levelNdx); 1813 const PixelBufferAccess& level = refTexture.getLevel(levelNdx); 1814 fillWithRandomColorTiles(level, texFmtInfo.valueMin, texFmtInfo.valueMax, (deUint32)m_testCtx.getCommandLine().getBaseSeed()); 1815 1816 log << TestLog::ImageSet("InputTextureLevel", "Input texture, level " + de::toString(levelNdx)); 1817 for (int layerNdx = 0; layerNdx < m_textureSize.z(); layerNdx++) 1818 log << TestLog::Image("InputTextureLevel" + de::toString(layerNdx) + "Layer" + de::toString(layerNdx), 1819 "Layer " + de::toString(layerNdx), 1820 tcu::getSubregion(level, 0, 0, layerNdx, level.getWidth(), level.getHeight(), 1)); 1821 log << TestLog::EndImageSet 1822 << TestLog::Message << "Note: texture level's size is " << IVec3(level.getWidth(), level.getHeight(), level.getDepth()) << TestLog::EndMessage; 1823 } 1824 1825 swizzleTexture(m_swizzledTexture, refTexture, m_textureSwizzle); 1826 } 1827 1828 gl.activeTexture(GL_TEXTURE0); 1829 m_texture->upload(); 1830 } 1831 1832 bool TextureGather2DArrayCase::verify (int iterationNdx, const ConstPixelBufferAccess& rendered) const 1833 { 1834 Vec3 texCoords[4]; 1835 computeTexCoordVecs(computeQuadTexCoord(iterationNdx), texCoords); 1836 return TextureGatherCase::verify(rendered, getOneLevelSubView(tcu::Texture2DArrayView(m_swizzledTexture), m_baseLevel), texCoords, m_iterations[iterationNdx].gatherArgs); 1837 } 1838 1839 // \note Cube case always uses just basic textureGather(); offset versions are not defined for cube maps. 1840 class TextureGatherCubeCase : public TextureGatherCase 1841 { 1842 public: 1843 TextureGatherCubeCase (Context& context, 1844 const char* name, 1845 const char* description, 1846 tcu::TextureFormat textureFormat, 1847 tcu::Sampler::CompareMode shadowCompareMode, 1848 tcu::Sampler::WrapMode wrapS, 1849 tcu::Sampler::WrapMode wrapT, 1850 const MaybeTextureSwizzle& texSwizzle, 1851 tcu::Sampler::FilterMode minFilter, 1852 tcu::Sampler::FilterMode magFilter, 1853 int baseLevel, 1854 deUint32 flags, 1855 int textureSize) 1856 : TextureGatherCase (context, name, description, TEXTURETYPE_CUBE, GATHERTYPE_BASIC, OFFSETSIZE_NONE, textureFormat, shadowCompareMode, wrapS, wrapT, texSwizzle, minFilter, magFilter, baseLevel, flags) 1857 , m_textureSize (textureSize) 1858 , m_swizzledTexture (tcu::TextureFormat(), 1) 1859 { 1860 } 1861 1862 protected: 1863 void generateIterations (void); 1864 void createAndUploadTexture (void); 1865 int getNumIterations (void) const { DE_ASSERT(!m_iterations.empty()); return (int)m_iterations.size(); } 1866 GatherArgs getGatherArgs (int iterationNdx) const { return m_iterations[iterationNdx].gatherArgs; } 1867 vector<float> computeQuadTexCoord (int iterationNdx) const; 1868 bool verify (int iterationNdx, const ConstPixelBufferAccess& rendered) const; 1869 1870 private: 1871 struct Iteration 1872 { 1873 GatherArgs gatherArgs; 1874 tcu::CubeFace face; 1875 }; 1876 1877 const int m_textureSize; 1878 1879 MovePtr<glu::TextureCube> m_texture; 1880 tcu::TextureCube m_swizzledTexture; 1881 vector<Iteration> m_iterations; 1882 }; 1883 1884 vector<float> TextureGatherCubeCase::computeQuadTexCoord (int iterationNdx) const 1885 { 1886 const bool corners = (m_flags & GATHERCASE_DONT_SAMPLE_CUBE_CORNERS) == 0; 1887 const Vec2 minC = corners ? Vec2(-1.2f) : Vec2(-0.6f, -1.2f); 1888 const Vec2 maxC = corners ? Vec2( 1.2f) : Vec2( 0.6f, 1.2f); 1889 vector<float> res; 1890 glu::TextureTestUtil::computeQuadTexCoordCube(res, m_iterations[iterationNdx].face, minC, maxC); 1891 return res; 1892 } 1893 1894 void TextureGatherCubeCase::generateIterations (void) 1895 { 1896 DE_ASSERT(m_iterations.empty()); 1897 1898 const vector<GatherArgs> basicIterations = generateBasic2DCaseIterations(m_gatherType, m_textureFormat, getOffsetRange()); 1899 1900 for (int cubeFaceI = 0; cubeFaceI < tcu::CUBEFACE_LAST; cubeFaceI++) 1901 { 1902 const tcu::CubeFace cubeFace = (tcu::CubeFace)cubeFaceI; 1903 1904 // Don't duplicate all cases for all faces. 1905 if (cubeFaceI == 0) 1906 { 1907 for (int basicNdx = 0; basicNdx < (int)basicIterations.size(); basicNdx++) 1908 { 1909 m_iterations.push_back(Iteration()); 1910 m_iterations.back().gatherArgs = basicIterations[basicNdx]; 1911 m_iterations.back().face = cubeFace; 1912 } 1913 } 1914 else 1915 { 1916 // For other faces than first, only test one component per face. 1917 for (int basicNdx = 0; basicNdx < (int)basicIterations.size(); basicNdx++) 1918 { 1919 if (isDepthFormat(m_textureFormat) || basicIterations[basicNdx].componentNdx == cubeFaceI % 4) 1920 { 1921 m_iterations.push_back(Iteration()); 1922 m_iterations.back().gatherArgs = basicIterations[basicNdx]; 1923 m_iterations.back().face = cubeFace; 1924 break; 1925 } 1926 } 1927 } 1928 } 1929 } 1930 1931 void TextureGatherCubeCase::createAndUploadTexture (void) 1932 { 1933 TestLog& log = m_testCtx.getLog(); 1934 const glu::RenderContext& renderCtx = m_context.getRenderContext(); 1935 const glw::Functions& gl = renderCtx.getFunctions(); 1936 const tcu::TextureFormatInfo texFmtInfo = tcu::getTextureFormatInfo(m_textureFormat); 1937 1938 m_texture = MovePtr<glu::TextureCube>(new glu::TextureCube(renderCtx, glu::getInternalFormat(m_textureFormat), m_textureSize)); 1939 1940 { 1941 tcu::TextureCube& refTexture = m_texture->getRefTexture(); 1942 const int levelBegin = m_baseLevel; 1943 const int levelEnd = isMipmapFilter(m_minFilter) && !(m_flags & GATHERCASE_MIPMAP_INCOMPLETE) ? refTexture.getNumLevels() : m_baseLevel+1; 1944 DE_ASSERT(m_baseLevel < refTexture.getNumLevels()); 1945 1946 for (int levelNdx = levelBegin; levelNdx < levelEnd; levelNdx++) 1947 { 1948 log << TestLog::ImageSet("InputTextureLevel" + de::toString(levelNdx), "Input texture, level " + de::toString(levelNdx)); 1949 1950 for (int cubeFaceI = 0; cubeFaceI < tcu::CUBEFACE_LAST; cubeFaceI++) 1951 { 1952 const tcu::CubeFace cubeFace = (tcu::CubeFace)cubeFaceI; 1953 refTexture.allocLevel(cubeFace, levelNdx); 1954 const PixelBufferAccess& levelFace = refTexture.getLevelFace(levelNdx, cubeFace); 1955 fillWithRandomColorTiles(levelFace, texFmtInfo.valueMin, texFmtInfo.valueMax, (deUint32)m_testCtx.getCommandLine().getBaseSeed() ^ (deUint32)cubeFaceI); 1956 1957 m_testCtx.getLog() << TestLog::Image("InputTextureLevel" + de::toString(levelNdx) + "Face" + de::toString((int)cubeFace), 1958 de::toString(cubeFace), 1959 levelFace); 1960 } 1961 1962 log << TestLog::EndImageSet 1963 << TestLog::Message << "Note: texture level's size is " << refTexture.getLevelFace(levelNdx, tcu::CUBEFACE_NEGATIVE_X).getWidth() << TestLog::EndMessage; 1964 } 1965 1966 swizzleTexture(m_swizzledTexture, refTexture, m_textureSwizzle); 1967 } 1968 1969 gl.activeTexture(GL_TEXTURE0); 1970 m_texture->upload(); 1971 } 1972 1973 bool TextureGatherCubeCase::verify (int iterationNdx, const ConstPixelBufferAccess& rendered) const 1974 { 1975 Vec3 texCoords[4]; 1976 computeTexCoordVecs(computeQuadTexCoord(iterationNdx), texCoords); 1977 return TextureGatherCase::verify(rendered, getOneLevelSubView(tcu::TextureCubeView(m_swizzledTexture), m_baseLevel), texCoords, m_iterations[iterationNdx].gatherArgs); 1978 } 1979 1980 static inline TextureGatherCase* makeTextureGatherCase (TextureType textureType, 1981 Context& context, 1982 const char* name, 1983 const char* description, 1984 GatherType gatherType, 1985 OffsetSize offsetSize, 1986 tcu::TextureFormat textureFormat, 1987 tcu::Sampler::CompareMode shadowCompareMode, 1988 tcu::Sampler::WrapMode wrapS, 1989 tcu::Sampler::WrapMode wrapT, 1990 const MaybeTextureSwizzle& texSwizzle, 1991 tcu::Sampler::FilterMode minFilter, 1992 tcu::Sampler::FilterMode magFilter, 1993 int baseLevel, 1994 const IVec3& textureSize, 1995 deUint32 flags = 0) 1996 { 1997 switch (textureType) 1998 { 1999 case TEXTURETYPE_2D: 2000 return new TextureGather2DCase(context, name, description, gatherType, offsetSize, textureFormat, shadowCompareMode, 2001 wrapS, wrapT, texSwizzle, minFilter, magFilter, baseLevel, flags, textureSize.swizzle(0, 1)); 2002 2003 case TEXTURETYPE_2D_ARRAY: 2004 return new TextureGather2DArrayCase(context, name, description, gatherType, offsetSize, textureFormat, shadowCompareMode, 2005 wrapS, wrapT, texSwizzle, minFilter, magFilter, baseLevel, flags, textureSize); 2006 2007 case TEXTURETYPE_CUBE: 2008 DE_ASSERT(gatherType == GATHERTYPE_BASIC); 2009 DE_ASSERT(offsetSize == OFFSETSIZE_NONE); 2010 return new TextureGatherCubeCase(context, name, description, textureFormat, shadowCompareMode, 2011 wrapS, wrapT, texSwizzle, minFilter, magFilter, baseLevel, flags, textureSize.x()); 2012 2013 default: 2014 DE_ASSERT(false); 2015 return DE_NULL; 2016 } 2017 } 2018 2019 } // anonymous 2020 2021 TextureGatherTests::TextureGatherTests (Context& context) 2022 : TestCaseGroup(context, "gather", "textureGather* tests") 2023 { 2024 } 2025 2026 static inline const char* compareModeName (tcu::Sampler::CompareMode mode) 2027 { 2028 switch (mode) 2029 { 2030 case tcu::Sampler::COMPAREMODE_LESS: return "less"; 2031 case tcu::Sampler::COMPAREMODE_LESS_OR_EQUAL: return "less_or_equal"; 2032 case tcu::Sampler::COMPAREMODE_GREATER: return "greater"; 2033 case tcu::Sampler::COMPAREMODE_GREATER_OR_EQUAL: return "greater_or_equal"; 2034 case tcu::Sampler::COMPAREMODE_EQUAL: return "equal"; 2035 case tcu::Sampler::COMPAREMODE_NOT_EQUAL: return "not_equal"; 2036 case tcu::Sampler::COMPAREMODE_ALWAYS: return "always"; 2037 case tcu::Sampler::COMPAREMODE_NEVER: return "never"; 2038 default: DE_ASSERT(false); return DE_NULL; 2039 } 2040 } 2041 2042 void TextureGatherTests::init (void) 2043 { 2044 const struct 2045 { 2046 const char* name; 2047 TextureType type; 2048 } textureTypes[] = 2049 { 2050 { "2d", TEXTURETYPE_2D }, 2051 { "2d_array", TEXTURETYPE_2D_ARRAY }, 2052 { "cube", TEXTURETYPE_CUBE } 2053 }; 2054 2055 const struct 2056 { 2057 const char* name; 2058 tcu::TextureFormat format; 2059 } formats[] = 2060 { 2061 { "rgba8", tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8) }, 2062 { "rgba8ui", tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT8) }, 2063 { "rgba8i", tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT8) }, 2064 { "depth32f", tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::FLOAT) } 2065 }; 2066 2067 const struct 2068 { 2069 const char* name; 2070 IVec3 size; 2071 } textureSizes[] = 2072 { 2073 { "size_pot", IVec3(64, 64, 3) }, 2074 { "size_npot", IVec3(17, 23, 3) } 2075 }; 2076 2077 const struct 2078 { 2079 const char* name; 2080 tcu::Sampler::WrapMode mode; 2081 } wrapModes[] = 2082 { 2083 { "clamp_to_edge", tcu::Sampler::CLAMP_TO_EDGE }, 2084 { "repeat", tcu::Sampler::REPEAT_GL }, 2085 { "mirrored_repeat", tcu::Sampler::MIRRORED_REPEAT_GL } 2086 }; 2087 2088 for (int gatherTypeI = 0; gatherTypeI < GATHERTYPE_LAST; gatherTypeI++) 2089 { 2090 const GatherType gatherType = (GatherType)gatherTypeI; 2091 TestCaseGroup* const gatherTypeGroup = new TestCaseGroup(m_context, gatherTypeName(gatherType), gatherTypeDescription(gatherType)); 2092 addChild(gatherTypeGroup); 2093 2094 for (int offsetSizeI = 0; offsetSizeI < OFFSETSIZE_LAST; offsetSizeI++) 2095 { 2096 const OffsetSize offsetSize = (OffsetSize)offsetSizeI; 2097 if ((gatherType == GATHERTYPE_BASIC) != (offsetSize == OFFSETSIZE_NONE)) 2098 continue; 2099 2100 TestCaseGroup* const offsetSizeGroup = offsetSize == OFFSETSIZE_NONE ? 2101 gatherTypeGroup : 2102 new TestCaseGroup(m_context, 2103 offsetSize == OFFSETSIZE_MINIMUM_REQUIRED ? "min_required_offset" 2104 : offsetSize == OFFSETSIZE_IMPLEMENTATION_MAXIMUM ? "implementation_offset" 2105 : DE_NULL, 2106 offsetSize == OFFSETSIZE_MINIMUM_REQUIRED ? "Use offsets within GL minimum required range" 2107 : offsetSize == OFFSETSIZE_IMPLEMENTATION_MAXIMUM ? "Use offsets within the implementation range" 2108 : DE_NULL); 2109 if (offsetSizeGroup != gatherTypeGroup) 2110 gatherTypeGroup->addChild(offsetSizeGroup); 2111 2112 for (int textureTypeNdx = 0; textureTypeNdx < DE_LENGTH_OF_ARRAY(textureTypes); textureTypeNdx++) 2113 { 2114 const TextureType textureType = textureTypes[textureTypeNdx].type; 2115 2116 if (textureType == TEXTURETYPE_CUBE && gatherType != GATHERTYPE_BASIC) 2117 continue; 2118 2119 TestCaseGroup* const textureTypeGroup = new TestCaseGroup(m_context, textureTypes[textureTypeNdx].name, ""); 2120 offsetSizeGroup->addChild(textureTypeGroup); 2121 2122 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++) 2123 { 2124 const tcu::TextureFormat& format = formats[formatNdx].format; 2125 TestCaseGroup* const formatGroup = new TestCaseGroup(m_context, formats[formatNdx].name, ""); 2126 textureTypeGroup->addChild(formatGroup); 2127 2128 for (int noCornersI = 0; noCornersI <= ((textureType == TEXTURETYPE_CUBE)?1:0); noCornersI++) 2129 { 2130 const bool noCorners = noCornersI!= 0; 2131 TestCaseGroup* const cornersGroup = noCorners 2132 ? new TestCaseGroup(m_context, "no_corners", "Test case variants that don't sample around cube map corners") 2133 : formatGroup; 2134 2135 if (formatGroup != cornersGroup) 2136 formatGroup->addChild(cornersGroup); 2137 2138 for (int textureSizeNdx = 0; textureSizeNdx < DE_LENGTH_OF_ARRAY(textureSizes); textureSizeNdx++) 2139 { 2140 const IVec3& textureSize = textureSizes[textureSizeNdx].size; 2141 TestCaseGroup* const textureSizeGroup = new TestCaseGroup(m_context, textureSizes[textureSizeNdx].name, ""); 2142 cornersGroup->addChild(textureSizeGroup); 2143 2144 for (int compareModeI = 0; compareModeI < tcu::Sampler::COMPAREMODE_LAST; compareModeI++) 2145 { 2146 const tcu::Sampler::CompareMode compareMode = (tcu::Sampler::CompareMode)compareModeI; 2147 2148 if ((compareMode != tcu::Sampler::COMPAREMODE_NONE) != isDepthFormat(format)) 2149 continue; 2150 2151 if (compareMode != tcu::Sampler::COMPAREMODE_NONE && 2152 compareMode != tcu::Sampler::COMPAREMODE_LESS && 2153 compareMode != tcu::Sampler::COMPAREMODE_GREATER) 2154 continue; 2155 2156 TestCaseGroup* const compareModeGroup = compareMode == tcu::Sampler::COMPAREMODE_NONE ? 2157 textureSizeGroup : 2158 new TestCaseGroup(m_context, 2159 (string() + "compare_" + compareModeName(compareMode)).c_str(), 2160 ""); 2161 if (compareModeGroup != textureSizeGroup) 2162 textureSizeGroup->addChild(compareModeGroup); 2163 2164 for (int wrapCaseNdx = 0; wrapCaseNdx < DE_LENGTH_OF_ARRAY(wrapModes); wrapCaseNdx++) 2165 { 2166 const int wrapSNdx = wrapCaseNdx; 2167 const int wrapTNdx = (wrapCaseNdx + 1) % DE_LENGTH_OF_ARRAY(wrapModes); 2168 const tcu::Sampler::WrapMode wrapS = wrapModes[wrapSNdx].mode; 2169 const tcu::Sampler::WrapMode wrapT = wrapModes[wrapTNdx].mode; 2170 2171 const string caseName = string() + wrapModes[wrapSNdx].name + "_" + wrapModes[wrapTNdx].name; 2172 2173 compareModeGroup->addChild(makeTextureGatherCase(textureType, m_context, caseName.c_str(), "", gatherType, offsetSize, format, compareMode, wrapS, wrapT, 2174 MaybeTextureSwizzle::createNoneTextureSwizzle(), tcu::Sampler::NEAREST, tcu::Sampler::NEAREST, 0, textureSize, 2175 noCorners ? GATHERCASE_DONT_SAMPLE_CUBE_CORNERS : 0)); 2176 } 2177 } 2178 } 2179 } 2180 2181 if (offsetSize != OFFSETSIZE_MINIMUM_REQUIRED) // Don't test all features for both offset size types, as they should be rather orthogonal. 2182 { 2183 if (!isDepthFormat(format)) 2184 { 2185 TestCaseGroup* const swizzleGroup = new TestCaseGroup(m_context, "texture_swizzle", ""); 2186 formatGroup->addChild(swizzleGroup); 2187 2188 DE_STATIC_ASSERT(TEXTURESWIZZLECOMPONENT_R == 0); 2189 for (int swizzleCaseNdx = 0; swizzleCaseNdx < TEXTURESWIZZLECOMPONENT_LAST; swizzleCaseNdx++) 2190 { 2191 MaybeTextureSwizzle swizzle = MaybeTextureSwizzle::createSomeTextureSwizzle(); 2192 string caseName; 2193 2194 for (int i = 0; i < 4; i++) 2195 { 2196 swizzle.getSwizzle()[i] = (TextureSwizzleComponent)((swizzleCaseNdx + i) % (int)TEXTURESWIZZLECOMPONENT_LAST); 2197 caseName += (i > 0 ? "_" : "") + de::toLower(de::toString(swizzle.getSwizzle()[i])); 2198 } 2199 2200 swizzleGroup->addChild(makeTextureGatherCase(textureType, m_context, caseName.c_str(), "", gatherType, offsetSize, format, 2201 tcu::Sampler::COMPAREMODE_NONE, tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, 2202 swizzle, tcu::Sampler::NEAREST, tcu::Sampler::NEAREST, 0, IVec3(64, 64, 3))); 2203 } 2204 } 2205 2206 { 2207 TestCaseGroup* const filterModeGroup = new TestCaseGroup(m_context, "filter_mode", "Test that filter modes have no effect"); 2208 formatGroup->addChild(filterModeGroup); 2209 2210 const struct 2211 { 2212 const char* name; 2213 tcu::Sampler::FilterMode filter; 2214 } magFilters[] = 2215 { 2216 { "linear", tcu::Sampler::LINEAR }, 2217 { "nearest", tcu::Sampler::NEAREST } 2218 }; 2219 2220 const struct 2221 { 2222 const char* name; 2223 tcu::Sampler::FilterMode filter; 2224 } minFilters[] = 2225 { 2226 // \note Don't test NEAREST here, as it's covered by other cases. 2227 { "linear", tcu::Sampler::LINEAR }, 2228 { "nearest_mipmap_nearest", tcu::Sampler::NEAREST_MIPMAP_NEAREST }, 2229 { "nearest_mipmap_linear", tcu::Sampler::NEAREST_MIPMAP_LINEAR }, 2230 { "linear_mipmap_nearest", tcu::Sampler::LINEAR_MIPMAP_NEAREST }, 2231 { "linear_mipmap_linear", tcu::Sampler::LINEAR_MIPMAP_LINEAR }, 2232 }; 2233 2234 for (int minFilterNdx = 0; minFilterNdx < DE_LENGTH_OF_ARRAY(minFilters); minFilterNdx++) 2235 for (int magFilterNdx = 0; magFilterNdx < DE_LENGTH_OF_ARRAY(magFilters); magFilterNdx++) 2236 { 2237 const tcu::Sampler::FilterMode minFilter = minFilters[minFilterNdx].filter; 2238 const tcu::Sampler::FilterMode magFilter = magFilters[magFilterNdx].filter; 2239 const tcu::Sampler::CompareMode compareMode = isDepthFormat(format) ? tcu::Sampler::COMPAREMODE_LESS : tcu::Sampler::COMPAREMODE_NONE; 2240 2241 if ((isUnormFormatType(format.type) || isDepthFormat(format)) && magFilter == tcu::Sampler::NEAREST) 2242 continue; // Covered by other cases. 2243 if ((isUIntFormatType(format.type) || isSIntFormatType(format.type)) && 2244 (magFilter != tcu::Sampler::NEAREST || minFilter != tcu::Sampler::NEAREST_MIPMAP_NEAREST)) 2245 continue; 2246 2247 const string caseName = string() + "min_" + minFilters[minFilterNdx].name + "_mag_" + magFilters[magFilterNdx].name; 2248 2249 filterModeGroup->addChild(makeTextureGatherCase(textureType, m_context, caseName.c_str(), "", gatherType, offsetSize, format, compareMode, 2250 tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, MaybeTextureSwizzle::createNoneTextureSwizzle(), 2251 minFilter, magFilter, 0, IVec3(64, 64, 3))); 2252 } 2253 } 2254 2255 { 2256 TestCaseGroup* const baseLevelGroup = new TestCaseGroup(m_context, "base_level", ""); 2257 formatGroup->addChild(baseLevelGroup); 2258 2259 for (int baseLevel = 1; baseLevel <= 2; baseLevel++) 2260 { 2261 const string caseName = "level_" + de::toString(baseLevel); 2262 const tcu::Sampler::CompareMode compareMode = isDepthFormat(format) ? tcu::Sampler::COMPAREMODE_LESS : tcu::Sampler::COMPAREMODE_NONE; 2263 baseLevelGroup->addChild(makeTextureGatherCase(textureType, m_context, caseName.c_str(), "", gatherType, offsetSize, format, 2264 compareMode, tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, 2265 MaybeTextureSwizzle::createNoneTextureSwizzle(), tcu::Sampler::NEAREST, tcu::Sampler::NEAREST, 2266 baseLevel, IVec3(64, 64, 3))); 2267 } 2268 } 2269 2270 // What shadow textures should return for incomplete textures is unclear. 2271 // Integer and unsigned integer lookups from incomplete textures return undefined values. 2272 if (!isDepthFormat(format) && !isSIntFormatType(format.type) && !isUIntFormatType(format.type)) 2273 { 2274 TestCaseGroup* const incompleteGroup = new TestCaseGroup(m_context, "incomplete", "Test that textureGather* takes components from (0,0,0,1) for incomplete textures"); 2275 formatGroup->addChild(incompleteGroup); 2276 2277 const tcu::Sampler::CompareMode compareMode = isDepthFormat(format) ? tcu::Sampler::COMPAREMODE_LESS : tcu::Sampler::COMPAREMODE_NONE; 2278 incompleteGroup->addChild(makeTextureGatherCase(textureType, m_context, "mipmap_incomplete", "", gatherType, offsetSize, format, 2279 compareMode, tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, 2280 MaybeTextureSwizzle::createNoneTextureSwizzle(), tcu::Sampler::NEAREST_MIPMAP_NEAREST, tcu::Sampler::NEAREST, 2281 0, IVec3(64, 64, 3), GATHERCASE_MIPMAP_INCOMPLETE)); 2282 } 2283 } 2284 } 2285 } 2286 } 2287 } 2288 } 2289 2290 } // Functional 2291 } // gles31 2292 } // deqp 2293
