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