1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.0 Module 3 * ------------------------------------------------- 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Shadow texture lookup tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es3fTextureShadowTests.hpp" 25 #include "gluTexture.hpp" 26 #include "gluPixelTransfer.hpp" 27 #include "gluTextureUtil.hpp" 28 #include "glsTextureTestUtil.hpp" 29 #include "tcuTextureUtil.hpp" 30 #include "tcuRenderTarget.hpp" 31 #include "tcuTexCompareVerifier.hpp" 32 #include "deString.h" 33 #include "deStringUtil.hpp" 34 #include "glwFunctions.hpp" 35 #include "glwEnums.hpp" 36 37 namespace deqp 38 { 39 namespace gles3 40 { 41 namespace Functional 42 { 43 44 using std::vector; 45 using std::string; 46 using tcu::TestLog; 47 using namespace deqp::gls::TextureTestUtil; 48 49 enum 50 { 51 TEX2D_VIEWPORT_WIDTH = 64, 52 TEX2D_VIEWPORT_HEIGHT = 64, 53 TEX2D_MIN_VIEWPORT_WIDTH = 64, 54 TEX2D_MIN_VIEWPORT_HEIGHT = 64 55 }; 56 57 static bool isFloatingPointDepthFormat (const tcu::TextureFormat& format) 58 { 59 // Only two depth and depth-stencil formats are floating point 60 return (format.order == tcu::TextureFormat::D && format.type == tcu::TextureFormat::FLOAT) || 61 (format.order == tcu::TextureFormat::DS && format.type == tcu::TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV); 62 } 63 64 static void clampFloatingPointTexture (const tcu::PixelBufferAccess& access) 65 { 66 DE_ASSERT(isFloatingPointDepthFormat(access.getFormat())); 67 68 for (int z = 0; z < access.getDepth(); ++z) 69 for (int y = 0; y < access.getHeight(); ++y) 70 for (int x = 0; x < access.getWidth(); ++x) 71 access.setPixDepth( de::clamp(access.getPixDepth(x, y, z), 0.0f, 1.0f), x, y, z); 72 } 73 74 static void clampFloatingPointTexture (tcu::Texture2D& target) 75 { 76 for (int level = 0; level < target.getNumLevels(); ++level) 77 if (!target.isLevelEmpty(level)) 78 clampFloatingPointTexture(target.getLevel(level)); 79 } 80 81 static void clampFloatingPointTexture (tcu::Texture2DArray& target) 82 { 83 for (int level = 0; level < target.getNumLevels(); ++level) 84 if (!target.isLevelEmpty(level)) 85 clampFloatingPointTexture(target.getLevel(level)); 86 } 87 88 static void clampFloatingPointTexture (tcu::TextureCube& target) 89 { 90 for (int level = 0; level < target.getNumLevels(); ++level) 91 for (int face = tcu::CUBEFACE_NEGATIVE_X; face < tcu::CUBEFACE_LAST; ++face) 92 clampFloatingPointTexture(target.getLevelFace(level, (tcu::CubeFace)face)); 93 } 94 95 template<typename TextureType> 96 bool verifyTexCompareResult (tcu::TestContext& testCtx, 97 const tcu::ConstPixelBufferAccess& result, 98 const TextureType& src, 99 const float* texCoord, 100 const ReferenceParams& sampleParams, 101 const tcu::TexComparePrecision& comparePrec, 102 const tcu::LodPrecision& lodPrec, 103 const tcu::PixelFormat& pixelFormat) 104 { 105 tcu::TestLog& log = testCtx.getLog(); 106 tcu::Surface reference (result.getWidth(), result.getHeight()); 107 tcu::Surface errorMask (result.getWidth(), result.getHeight()); 108 const tcu::Vec3 nonShadowThreshold = tcu::computeFixedPointThreshold(getBitsVec(pixelFormat)-1).swizzle(1,2,3); 109 int numFailedPixels; 110 111 // sampleTexture() expects source image to be the same state as it would be in a GL implementation, that is 112 // the floating point depth values should be in [0, 1] range as data is clamped during texture upload. Since 113 // we don't have a separate "uploading" phase and just reuse the buffer we used for GL-upload, do the clamping 114 // here if necessary. 115 116 if (isFloatingPointDepthFormat(src.getFormat())) 117 { 118 TextureType clampedSource(src); 119 120 clampFloatingPointTexture(clampedSource); 121 122 // sample clamped values 123 124 sampleTexture(SurfaceAccess(reference, pixelFormat), clampedSource, texCoord, sampleParams); 125 numFailedPixels = computeTextureCompareDiff(result, reference.getAccess(), errorMask.getAccess(), clampedSource, texCoord, sampleParams, comparePrec, lodPrec, nonShadowThreshold); 126 } 127 else 128 { 129 // sample raw values (they are guaranteed to be in [0, 1] range as the format cannot represent any other values) 130 131 sampleTexture(SurfaceAccess(reference, pixelFormat), src, texCoord, sampleParams); 132 numFailedPixels = computeTextureCompareDiff(result, reference.getAccess(), errorMask.getAccess(), src, texCoord, sampleParams, comparePrec, lodPrec, nonShadowThreshold); 133 } 134 135 if (numFailedPixels > 0) 136 log << TestLog::Message << "ERROR: Result verification failed, got " << numFailedPixels << " invalid pixels!" << TestLog::EndMessage; 137 138 log << TestLog::ImageSet("VerifyResult", "Verification result") 139 << TestLog::Image("Rendered", "Rendered image", result); 140 141 if (numFailedPixels > 0) 142 { 143 log << TestLog::Image("Reference", "Ideal reference image", reference) 144 << TestLog::Image("ErrorMask", "Error mask", errorMask); 145 } 146 147 log << TestLog::EndImageSet; 148 149 return numFailedPixels == 0; 150 } 151 152 class Texture2DShadowCase : public TestCase 153 { 154 public: 155 Texture2DShadowCase (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int width, int height, deUint32 compareFunc); 156 ~Texture2DShadowCase (void); 157 158 void init (void); 159 void deinit (void); 160 IterateResult iterate (void); 161 162 private: 163 Texture2DShadowCase (const Texture2DShadowCase& other); 164 Texture2DShadowCase& operator= (const Texture2DShadowCase& other); 165 166 const deUint32 m_minFilter; 167 const deUint32 m_magFilter; 168 const deUint32 m_wrapS; 169 const deUint32 m_wrapT; 170 const deUint32 m_format; 171 const int m_width; 172 const int m_height; 173 const deUint32 m_compareFunc; 174 175 struct FilterCase 176 { 177 const glu::Texture2D* texture; 178 tcu::Vec2 minCoord; 179 tcu::Vec2 maxCoord; 180 float ref; 181 182 FilterCase (void) 183 : texture (DE_NULL) 184 , ref (0.0f) 185 { 186 } 187 188 FilterCase (const glu::Texture2D* tex_, const float ref_, const tcu::Vec2& minCoord_, const tcu::Vec2& maxCoord_) 189 : texture (tex_) 190 , minCoord (minCoord_) 191 , maxCoord (maxCoord_) 192 , ref (ref_) 193 { 194 } 195 }; 196 197 std::vector<glu::Texture2D*> m_textures; 198 std::vector<FilterCase> m_cases; 199 200 TextureRenderer m_renderer; 201 202 int m_caseNdx; 203 }; 204 205 Texture2DShadowCase::Texture2DShadowCase (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int width, int height, deUint32 compareFunc) 206 : TestCase (context, name, desc) 207 , m_minFilter (minFilter) 208 , m_magFilter (magFilter) 209 , m_wrapS (wrapS) 210 , m_wrapT (wrapT) 211 , m_format (format) 212 , m_width (width) 213 , m_height (height) 214 , m_compareFunc (compareFunc) 215 , m_renderer (context.getRenderContext(), context.getTestContext().getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 216 , m_caseNdx (0) 217 { 218 } 219 220 Texture2DShadowCase::~Texture2DShadowCase (void) 221 { 222 deinit(); 223 } 224 225 void Texture2DShadowCase::init (void) 226 { 227 try 228 { 229 // Create 2 textures. 230 m_textures.reserve(2); 231 m_textures.push_back(new glu::Texture2D(m_context.getRenderContext(), m_format, m_width, m_height)); 232 m_textures.push_back(new glu::Texture2D(m_context.getRenderContext(), m_format, m_width, m_height)); 233 234 int numLevels = m_textures[0]->getRefTexture().getNumLevels(); 235 236 // Fill first gradient texture. 237 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 238 { 239 m_textures[0]->getRefTexture().allocLevel(levelNdx); 240 tcu::fillWithComponentGradients(m_textures[0]->getRefTexture().getLevel(levelNdx), tcu::Vec4(-0.5f, -0.5f, -0.5f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f)); 241 } 242 243 // Fill second with grid texture. 244 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 245 { 246 deUint32 step = 0x00ffffff / numLevels; 247 deUint32 rgb = step*levelNdx; 248 deUint32 colorA = 0xff000000 | rgb; 249 deUint32 colorB = 0xff000000 | ~rgb; 250 251 m_textures[1]->getRefTexture().allocLevel(levelNdx); 252 tcu::fillWithGrid(m_textures[1]->getRefTexture().getLevel(levelNdx), 4, toVec4(tcu::RGBA(colorA)), toVec4(tcu::RGBA(colorB))); 253 } 254 255 // Upload. 256 for (std::vector<glu::Texture2D*>::iterator i = m_textures.begin(); i != m_textures.end(); i++) 257 (*i)->upload(); 258 } 259 catch (const std::exception&) 260 { 261 // Clean up to save memory. 262 Texture2DShadowCase::deinit(); 263 throw; 264 } 265 266 // Compute cases. 267 { 268 const float refInRangeUpper = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 1.0f : 0.5f; 269 const float refInRangeLower = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 0.0f : 0.5f; 270 const float refOutOfBoundsUpper = 1.1f; // !< lookup function should clamp values to [0, 1] range 271 const float refOutOfBoundsLower = -0.1f; 272 273 const struct 274 { 275 int texNdx; 276 float ref; 277 float lodX; 278 float lodY; 279 float oX; 280 float oY; 281 } cases[] = 282 { 283 { 0, refInRangeUpper, 1.6f, 2.9f, -1.0f, -2.7f }, 284 { 0, refInRangeLower, -2.0f, -1.35f, -0.2f, 0.7f }, 285 { 1, refInRangeUpper, 0.14f, 0.275f, -1.5f, -1.1f }, 286 { 1, refInRangeLower, -0.92f, -2.64f, 0.4f, -0.1f }, 287 { 1, refOutOfBoundsUpper, -0.39f, -0.52f, 0.65f, 0.87f }, 288 { 1, refOutOfBoundsLower, -1.55f, 0.65f, 0.35f, 0.91f }, 289 }; 290 291 const float viewportW = (float)de::min<int>(TEX2D_VIEWPORT_WIDTH, m_context.getRenderTarget().getWidth()); 292 const float viewportH = (float)de::min<int>(TEX2D_VIEWPORT_HEIGHT, m_context.getRenderTarget().getHeight()); 293 294 for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(cases); caseNdx++) 295 { 296 const int texNdx = de::clamp(cases[caseNdx].texNdx, 0, (int)m_textures.size()-1); 297 const float ref = cases[caseNdx].ref; 298 const float lodX = cases[caseNdx].lodX; 299 const float lodY = cases[caseNdx].lodY; 300 const float oX = cases[caseNdx].oX; 301 const float oY = cases[caseNdx].oY; 302 const float sX = deFloatExp2(lodX)*viewportW / float(m_textures[texNdx]->getRefTexture().getWidth()); 303 const float sY = deFloatExp2(lodY)*viewportH / float(m_textures[texNdx]->getRefTexture().getHeight()); 304 305 m_cases.push_back(FilterCase(m_textures[texNdx], ref, tcu::Vec2(oX, oY), tcu::Vec2(oX+sX, oY+sY))); 306 } 307 } 308 309 m_caseNdx = 0; 310 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 311 } 312 313 void Texture2DShadowCase::deinit (void) 314 { 315 for (std::vector<glu::Texture2D*>::iterator i = m_textures.begin(); i != m_textures.end(); i++) 316 delete *i; 317 m_textures.clear(); 318 319 m_renderer.clear(); 320 m_cases.clear(); 321 } 322 323 Texture2DShadowCase::IterateResult Texture2DShadowCase::iterate (void) 324 { 325 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 326 const RandomViewport viewport (m_context.getRenderTarget(), TEX2D_VIEWPORT_WIDTH, TEX2D_VIEWPORT_HEIGHT, deStringHash(getName()) ^ deInt32Hash(m_caseNdx)); 327 const FilterCase& curCase = m_cases[m_caseNdx]; 328 const tcu::ScopedLogSection section (m_testCtx.getLog(), string("Test") + de::toString(m_caseNdx), string("Test ") + de::toString(m_caseNdx)); 329 ReferenceParams sampleParams (TEXTURETYPE_2D); 330 tcu::Surface rendered (viewport.width, viewport.height); 331 vector<float> texCoord; 332 333 if (viewport.width < TEX2D_MIN_VIEWPORT_WIDTH || viewport.height < TEX2D_MIN_VIEWPORT_HEIGHT) 334 throw tcu::NotSupportedError("Too small render target", "", __FILE__, __LINE__); 335 336 // Setup params for reference. 337 sampleParams.sampler = glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, m_magFilter); 338 sampleParams.sampler.compare = glu::mapGLCompareFunc(m_compareFunc); 339 sampleParams.samplerType = SAMPLERTYPE_SHADOW; 340 sampleParams.lodMode = LODMODE_EXACT; 341 sampleParams.ref = curCase.ref; 342 343 m_testCtx.getLog() << TestLog::Message << "Compare reference value = " << sampleParams.ref << TestLog::EndMessage; 344 345 // Compute texture coordinates. 346 m_testCtx.getLog() << TestLog::Message << "Texture coordinates: " << curCase.minCoord << " -> " << curCase.maxCoord << TestLog::EndMessage; 347 computeQuadTexCoord2D(texCoord, curCase.minCoord, curCase.maxCoord); 348 349 gl.bindTexture (GL_TEXTURE_2D, curCase.texture->getGLTexture()); 350 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_minFilter); 351 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, m_magFilter); 352 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, m_wrapS); 353 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, m_wrapT); 354 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); 355 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, m_compareFunc); 356 357 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 358 m_renderer.renderQuad(0, &texCoord[0], sampleParams); 359 glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, rendered.getAccess()); 360 361 { 362 const tcu::PixelFormat pixelFormat = m_context.getRenderTarget().getPixelFormat(); 363 tcu::LodPrecision lodPrecision; 364 tcu::TexComparePrecision texComparePrecision; 365 366 lodPrecision.derivateBits = 18; 367 lodPrecision.lodBits = 6; 368 texComparePrecision.coordBits = tcu::IVec3(20,20,0); 369 texComparePrecision.uvwBits = tcu::IVec3(7,7,0); 370 texComparePrecision.pcfBits = 5; 371 texComparePrecision.referenceBits = 16; 372 texComparePrecision.resultBits = pixelFormat.redBits-1; 373 374 const bool isHighQuality = verifyTexCompareResult(m_testCtx, rendered.getAccess(), curCase.texture->getRefTexture(), 375 &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat); 376 377 if (!isHighQuality) 378 { 379 m_testCtx.getLog() << TestLog::Message << "Warning: Verification assuming high-quality PCF filtering failed." << TestLog::EndMessage; 380 381 lodPrecision.lodBits = 4; 382 texComparePrecision.uvwBits = tcu::IVec3(4,4,0); 383 texComparePrecision.pcfBits = 0; 384 385 const bool isOk = verifyTexCompareResult(m_testCtx, rendered.getAccess(), curCase.texture->getRefTexture(), 386 &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat); 387 388 if (!isOk) 389 { 390 m_testCtx.getLog() << TestLog::Message << "ERROR: Verification against low precision requirements failed, failing test case." << TestLog::EndMessage; 391 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed"); 392 } 393 else if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) 394 m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Low-quality result"); 395 } 396 } 397 398 m_caseNdx += 1; 399 return m_caseNdx < (int)m_cases.size() ? CONTINUE : STOP; 400 } 401 402 class TextureCubeShadowCase : public TestCase 403 { 404 public: 405 TextureCubeShadowCase (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int size, deUint32 compareFunc); 406 ~TextureCubeShadowCase (void); 407 408 void init (void); 409 void deinit (void); 410 IterateResult iterate (void); 411 412 private: 413 TextureCubeShadowCase (const TextureCubeShadowCase& other); 414 TextureCubeShadowCase& operator= (const TextureCubeShadowCase& other); 415 416 const deUint32 m_minFilter; 417 const deUint32 m_magFilter; 418 const deUint32 m_wrapS; 419 const deUint32 m_wrapT; 420 421 const deUint32 m_format; 422 const int m_size; 423 424 const deUint32 m_compareFunc; 425 426 struct FilterCase 427 { 428 const glu::TextureCube* texture; 429 tcu::Vec2 bottomLeft; 430 tcu::Vec2 topRight; 431 float ref; 432 433 FilterCase (void) 434 : texture (DE_NULL) 435 , ref (0.0f) 436 { 437 } 438 439 FilterCase (const glu::TextureCube* tex_, const float ref_, const tcu::Vec2& bottomLeft_, const tcu::Vec2& topRight_) 440 : texture (tex_) 441 , bottomLeft(bottomLeft_) 442 , topRight (topRight_) 443 , ref (ref_) 444 { 445 } 446 }; 447 448 glu::TextureCube* m_gradientTex; 449 glu::TextureCube* m_gridTex; 450 std::vector<FilterCase> m_cases; 451 452 TextureRenderer m_renderer; 453 454 int m_caseNdx; 455 }; 456 457 TextureCubeShadowCase::TextureCubeShadowCase (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int size, deUint32 compareFunc) 458 : TestCase (context, name, desc) 459 , m_minFilter (minFilter) 460 , m_magFilter (magFilter) 461 , m_wrapS (wrapS) 462 , m_wrapT (wrapT) 463 , m_format (format) 464 , m_size (size) 465 , m_compareFunc (compareFunc) 466 , m_gradientTex (DE_NULL) 467 , m_gridTex (DE_NULL) 468 , m_renderer (context.getRenderContext(), context.getTestContext().getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 469 , m_caseNdx (0) 470 { 471 } 472 473 TextureCubeShadowCase::~TextureCubeShadowCase (void) 474 { 475 TextureCubeShadowCase::deinit(); 476 } 477 478 void TextureCubeShadowCase::init (void) 479 { 480 try 481 { 482 DE_ASSERT(!m_gradientTex && !m_gridTex); 483 484 int numLevels = deLog2Floor32(m_size)+1; 485 tcu::TextureFormat texFmt = glu::mapGLInternalFormat(m_format); 486 tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(texFmt); 487 tcu::Vec4 cBias = fmtInfo.valueMin; 488 tcu::Vec4 cScale = fmtInfo.valueMax-fmtInfo.valueMin; 489 490 // Create textures. 491 m_gradientTex = new glu::TextureCube(m_context.getRenderContext(), m_format, m_size); 492 m_gridTex = new glu::TextureCube(m_context.getRenderContext(), m_format, m_size); 493 494 // Fill first with gradient texture. 495 static const tcu::Vec4 gradients[tcu::CUBEFACE_LAST][2] = 496 { 497 { tcu::Vec4(-1.0f, -1.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // negative x 498 { tcu::Vec4( 0.0f, -1.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // positive x 499 { tcu::Vec4(-1.0f, 0.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // negative y 500 { tcu::Vec4(-1.0f, -1.0f, 0.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // positive y 501 { tcu::Vec4(-1.0f, -1.0f, -1.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f) }, // negative z 502 { tcu::Vec4( 0.0f, 0.0f, 0.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) } // positive z 503 }; 504 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 505 { 506 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 507 { 508 m_gradientTex->getRefTexture().allocLevel((tcu::CubeFace)face, levelNdx); 509 tcu::fillWithComponentGradients(m_gradientTex->getRefTexture().getLevelFace(levelNdx, (tcu::CubeFace)face), gradients[face][0]*cScale + cBias, gradients[face][1]*cScale + cBias); 510 } 511 } 512 513 // Fill second with grid texture. 514 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 515 { 516 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 517 { 518 deUint32 step = 0x00ffffff / (numLevels*tcu::CUBEFACE_LAST); 519 deUint32 rgb = step*levelNdx*face; 520 deUint32 colorA = 0xff000000 | rgb; 521 deUint32 colorB = 0xff000000 | ~rgb; 522 523 m_gridTex->getRefTexture().allocLevel((tcu::CubeFace)face, levelNdx); 524 tcu::fillWithGrid(m_gridTex->getRefTexture().getLevelFace(levelNdx, (tcu::CubeFace)face), 4, toVec4(tcu::RGBA(colorA))*cScale + cBias, toVec4(tcu::RGBA(colorB))*cScale + cBias); 525 } 526 } 527 528 // Upload. 529 m_gradientTex->upload(); 530 m_gridTex->upload(); 531 } 532 catch (const std::exception&) 533 { 534 // Clean up to save memory. 535 TextureCubeShadowCase::deinit(); 536 throw; 537 } 538 539 // Compute cases 540 { 541 const float refInRangeUpper = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 1.0f : 0.5f; 542 const float refInRangeLower = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 0.0f : 0.5f; 543 const float refOutOfBoundsUpper = 1.1f; 544 const float refOutOfBoundsLower = -0.1f; 545 const bool singleSample = m_context.getRenderTarget().getNumSamples() == 0; 546 547 if (singleSample) 548 m_cases.push_back(FilterCase(m_gradientTex, refInRangeUpper, tcu::Vec2(-1.25f, -1.2f), tcu::Vec2(1.2f, 1.25f))); // minification 549 else 550 m_cases.push_back(FilterCase(m_gradientTex, refInRangeUpper, tcu::Vec2(-1.19f, -1.3f), tcu::Vec2(1.1f, 1.35f))); // minification - w/ tuned coordinates to avoid hitting triangle edges 551 552 m_cases.push_back(FilterCase(m_gradientTex, refInRangeLower, tcu::Vec2(0.8f, 0.8f), tcu::Vec2(1.25f, 1.20f))); // magnification 553 m_cases.push_back(FilterCase(m_gridTex, refInRangeUpper, tcu::Vec2(-1.19f, -1.3f), tcu::Vec2(1.1f, 1.35f))); // minification 554 m_cases.push_back(FilterCase(m_gridTex, refInRangeLower, tcu::Vec2(-1.2f, -1.1f), tcu::Vec2(-0.8f, -0.8f))); // magnification 555 m_cases.push_back(FilterCase(m_gridTex, refOutOfBoundsUpper, tcu::Vec2(-0.61f, -0.1f), tcu::Vec2(0.9f, 1.18f))); // reference value clamp, upper 556 557 if (singleSample) 558 m_cases.push_back(FilterCase(m_gridTex, refOutOfBoundsLower, tcu::Vec2(-0.75f, 1.0f), tcu::Vec2(0.05f, 0.75f))); // reference value clamp, lower 559 else 560 m_cases.push_back(FilterCase(m_gridTex, refOutOfBoundsLower, tcu::Vec2(-0.75f, 1.0f), tcu::Vec2(0.25f, 0.75f))); // reference value clamp, lower 561 } 562 563 m_caseNdx = 0; 564 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 565 } 566 567 void TextureCubeShadowCase::deinit (void) 568 { 569 delete m_gradientTex; 570 delete m_gridTex; 571 572 m_gradientTex = DE_NULL; 573 m_gridTex = DE_NULL; 574 575 m_renderer.clear(); 576 m_cases.clear(); 577 } 578 579 static const char* getFaceDesc (const tcu::CubeFace face) 580 { 581 switch (face) 582 { 583 case tcu::CUBEFACE_NEGATIVE_X: return "-X"; 584 case tcu::CUBEFACE_POSITIVE_X: return "+X"; 585 case tcu::CUBEFACE_NEGATIVE_Y: return "-Y"; 586 case tcu::CUBEFACE_POSITIVE_Y: return "+Y"; 587 case tcu::CUBEFACE_NEGATIVE_Z: return "-Z"; 588 case tcu::CUBEFACE_POSITIVE_Z: return "+Z"; 589 default: 590 DE_ASSERT(false); 591 return DE_NULL; 592 } 593 } 594 595 TextureCubeShadowCase::IterateResult TextureCubeShadowCase::iterate (void) 596 { 597 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 598 const int viewportSize = 28; 599 const RandomViewport viewport (m_context.getRenderTarget(), viewportSize, viewportSize, deStringHash(getName()) ^ deInt32Hash(m_caseNdx)); 600 const tcu::ScopedLogSection iterSection (m_testCtx.getLog(), string("Test") + de::toString(m_caseNdx), string("Test ") + de::toString(m_caseNdx)); 601 const FilterCase& curCase = m_cases[m_caseNdx]; 602 ReferenceParams sampleParams (TEXTURETYPE_CUBE); 603 604 if (viewport.width < viewportSize || viewport.height < viewportSize) 605 throw tcu::NotSupportedError("Too small render target", DE_NULL, __FILE__, __LINE__); 606 607 // Setup texture 608 gl.bindTexture (GL_TEXTURE_CUBE_MAP, curCase.texture->getGLTexture()); 609 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, m_minFilter); 610 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, m_magFilter); 611 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, m_wrapS); 612 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, m_wrapT); 613 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); 614 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_COMPARE_FUNC, m_compareFunc); 615 616 // Other state 617 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 618 619 // Params for reference computation. 620 sampleParams.sampler = glu::mapGLSampler(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, m_minFilter, m_magFilter); 621 sampleParams.sampler.seamlessCubeMap = true; 622 sampleParams.sampler.compare = glu::mapGLCompareFunc(m_compareFunc); 623 sampleParams.samplerType = SAMPLERTYPE_SHADOW; 624 sampleParams.lodMode = LODMODE_EXACT; 625 sampleParams.ref = curCase.ref; 626 627 m_testCtx.getLog() 628 << TestLog::Message 629 << "Compare reference value = " << sampleParams.ref << "\n" 630 << "Coordinates: " << curCase.bottomLeft << " -> " << curCase.topRight 631 << TestLog::EndMessage; 632 633 for (int faceNdx = 0; faceNdx < tcu::CUBEFACE_LAST; faceNdx++) 634 { 635 const tcu::CubeFace face = tcu::CubeFace(faceNdx); 636 tcu::Surface result (viewport.width, viewport.height); 637 vector<float> texCoord; 638 639 computeQuadTexCoordCube(texCoord, face, curCase.bottomLeft, curCase.topRight); 640 641 m_testCtx.getLog() << TestLog::Message << "Face " << getFaceDesc(face) << TestLog::EndMessage; 642 643 // \todo Log texture coordinates. 644 645 m_renderer.renderQuad(0, &texCoord[0], sampleParams); 646 GLU_EXPECT_NO_ERROR(gl.getError(), "Draw"); 647 648 glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, result.getAccess()); 649 GLU_EXPECT_NO_ERROR(gl.getError(), "Read pixels"); 650 651 { 652 const tcu::PixelFormat pixelFormat = m_context.getRenderTarget().getPixelFormat(); 653 tcu::LodPrecision lodPrecision; 654 tcu::TexComparePrecision texComparePrecision; 655 656 lodPrecision.derivateBits = 10; 657 lodPrecision.lodBits = 5; 658 texComparePrecision.coordBits = tcu::IVec3(10,10,10); 659 texComparePrecision.uvwBits = tcu::IVec3(6,6,0); 660 texComparePrecision.pcfBits = 5; 661 texComparePrecision.referenceBits = 16; 662 texComparePrecision.resultBits = pixelFormat.redBits-1; 663 664 const bool isHighQuality = verifyTexCompareResult(m_testCtx, result.getAccess(), curCase.texture->getRefTexture(), 665 &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat); 666 667 if (!isHighQuality) 668 { 669 m_testCtx.getLog() << TestLog::Message << "Warning: Verification assuming high-quality PCF filtering failed." << TestLog::EndMessage; 670 671 lodPrecision.lodBits = 4; 672 texComparePrecision.uvwBits = tcu::IVec3(4,4,0); 673 texComparePrecision.pcfBits = 0; 674 675 const bool isOk = verifyTexCompareResult(m_testCtx, result.getAccess(), curCase.texture->getRefTexture(), 676 &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat); 677 678 if (!isOk) 679 { 680 m_testCtx.getLog() << TestLog::Message << "ERROR: Verification against low precision requirements failed, failing test case." << TestLog::EndMessage; 681 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed"); 682 } 683 else if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) 684 m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Low-quality result"); 685 } 686 } 687 } 688 689 m_caseNdx += 1; 690 return m_caseNdx < (int)m_cases.size() ? CONTINUE : STOP; 691 } 692 693 class Texture2DArrayShadowCase : public TestCase 694 { 695 public: 696 Texture2DArrayShadowCase (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int width, int height, int numLayers, deUint32 compareFunc); 697 ~Texture2DArrayShadowCase (void); 698 699 void init (void); 700 void deinit (void); 701 IterateResult iterate (void); 702 703 private: 704 Texture2DArrayShadowCase (const Texture2DArrayShadowCase& other); 705 Texture2DArrayShadowCase& operator= (const Texture2DArrayShadowCase& other); 706 707 const deUint32 m_minFilter; 708 const deUint32 m_magFilter; 709 const deUint32 m_wrapS; 710 const deUint32 m_wrapT; 711 712 const deUint32 m_format; 713 const int m_width; 714 const int m_height; 715 const int m_numLayers; 716 717 const deUint32 m_compareFunc; 718 719 struct FilterCase 720 { 721 const glu::Texture2DArray* texture; 722 tcu::Vec3 minCoord; 723 tcu::Vec3 maxCoord; 724 float ref; 725 726 FilterCase (void) 727 : texture (DE_NULL) 728 , ref (0.0f) 729 { 730 } 731 732 FilterCase (const glu::Texture2DArray* tex_, float ref_, const tcu::Vec3& minCoord_, const tcu::Vec3& maxCoord_) 733 : texture (tex_) 734 , minCoord (minCoord_) 735 , maxCoord (maxCoord_) 736 , ref (ref_) 737 { 738 } 739 }; 740 741 glu::Texture2DArray* m_gradientTex; 742 glu::Texture2DArray* m_gridTex; 743 std::vector<FilterCase> m_cases; 744 745 TextureRenderer m_renderer; 746 747 int m_caseNdx; 748 }; 749 750 Texture2DArrayShadowCase::Texture2DArrayShadowCase (Context& context, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 format, int width, int height, int numLayers, deUint32 compareFunc) 751 : TestCase (context, name, desc) 752 , m_minFilter (minFilter) 753 , m_magFilter (magFilter) 754 , m_wrapS (wrapS) 755 , m_wrapT (wrapT) 756 , m_format (format) 757 , m_width (width) 758 , m_height (height) 759 , m_numLayers (numLayers) 760 , m_compareFunc (compareFunc) 761 , m_gradientTex (DE_NULL) 762 , m_gridTex (DE_NULL) 763 , m_renderer (context.getRenderContext(), context.getTestContext().getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 764 , m_caseNdx (0) 765 { 766 } 767 768 Texture2DArrayShadowCase::~Texture2DArrayShadowCase (void) 769 { 770 Texture2DArrayShadowCase::deinit(); 771 } 772 773 void Texture2DArrayShadowCase::init (void) 774 { 775 try 776 { 777 tcu::TextureFormat texFmt = glu::mapGLInternalFormat(m_format); 778 tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(texFmt); 779 tcu::Vec4 cScale = fmtInfo.valueMax-fmtInfo.valueMin; 780 tcu::Vec4 cBias = fmtInfo.valueMin; 781 int numLevels = deLog2Floor32(de::max(m_width, m_height)) + 1; 782 783 // Create textures. 784 m_gradientTex = new glu::Texture2DArray(m_context.getRenderContext(), m_format, m_width, m_height, m_numLayers); 785 m_gridTex = new glu::Texture2DArray(m_context.getRenderContext(), m_format, m_width, m_height, m_numLayers); 786 787 // Fill first gradient texture. 788 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 789 { 790 tcu::Vec4 gMin = tcu::Vec4(-0.5f, -0.5f, -0.5f, 2.0f)*cScale + cBias; 791 tcu::Vec4 gMax = tcu::Vec4( 1.0f, 1.0f, 1.0f, 0.0f)*cScale + cBias; 792 793 m_gradientTex->getRefTexture().allocLevel(levelNdx); 794 tcu::fillWithComponentGradients(m_gradientTex->getRefTexture().getLevel(levelNdx), gMin, gMax); 795 } 796 797 // Fill second with grid texture. 798 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 799 { 800 deUint32 step = 0x00ffffff / numLevels; 801 deUint32 rgb = step*levelNdx; 802 deUint32 colorA = 0xff000000 | rgb; 803 deUint32 colorB = 0xff000000 | ~rgb; 804 805 m_gridTex->getRefTexture().allocLevel(levelNdx); 806 tcu::fillWithGrid(m_gridTex->getRefTexture().getLevel(levelNdx), 4, tcu::RGBA(colorA).toVec()*cScale + cBias, tcu::RGBA(colorB).toVec()*cScale + cBias); 807 } 808 809 // Upload. 810 m_gradientTex->upload(); 811 m_gridTex->upload(); 812 } 813 catch (...) 814 { 815 // Clean up to save memory. 816 Texture2DArrayShadowCase::deinit(); 817 throw; 818 } 819 820 // Compute cases. 821 { 822 const float refInRangeUpper = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 1.0f : 0.5f; 823 const float refInRangeLower = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 0.0f : 0.5f; 824 const float refOutOfBoundsUpper = 1.1f; // !< lookup function should clamp values to [0, 1] range 825 const float refOutOfBoundsLower = -0.1f; 826 827 const struct 828 { 829 int texNdx; 830 float ref; 831 float lodX; 832 float lodY; 833 float oX; 834 float oY; 835 } cases[] = 836 { 837 { 0, refInRangeUpper, 1.6f, 2.9f, -1.0f, -2.7f }, 838 { 0, refInRangeLower, -2.0f, -1.35f, -0.2f, 0.7f }, 839 { 1, refInRangeUpper, 0.14f, 0.275f, -1.5f, -1.1f }, 840 { 1, refInRangeLower, -0.92f, -2.64f, 0.4f, -0.1f }, 841 { 1, refOutOfBoundsUpper, -0.49f, -0.22f, 0.45f, 0.97f }, 842 { 1, refOutOfBoundsLower, -0.85f, 0.75f, 0.25f, 0.61f }, 843 }; 844 845 const float viewportW = (float)de::min<int>(TEX2D_VIEWPORT_WIDTH, m_context.getRenderTarget().getWidth()); 846 const float viewportH = (float)de::min<int>(TEX2D_VIEWPORT_HEIGHT, m_context.getRenderTarget().getHeight()); 847 848 const float minLayer = -0.5f; 849 const float maxLayer = (float)m_numLayers; 850 851 for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(cases); caseNdx++) 852 { 853 const glu::Texture2DArray* tex = cases[caseNdx].texNdx > 0 ? m_gridTex : m_gradientTex; 854 const float ref = cases[caseNdx].ref; 855 const float lodX = cases[caseNdx].lodX; 856 const float lodY = cases[caseNdx].lodY; 857 const float oX = cases[caseNdx].oX; 858 const float oY = cases[caseNdx].oY; 859 const float sX = deFloatExp2(lodX)*viewportW / float(tex->getRefTexture().getWidth()); 860 const float sY = deFloatExp2(lodY)*viewportH / float(tex->getRefTexture().getHeight()); 861 862 m_cases.push_back(FilterCase(tex, ref, tcu::Vec3(oX, oY, minLayer), tcu::Vec3(oX+sX, oY+sY, maxLayer))); 863 } 864 } 865 866 m_caseNdx = 0; 867 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 868 } 869 870 void Texture2DArrayShadowCase::deinit (void) 871 { 872 delete m_gradientTex; 873 delete m_gridTex; 874 875 m_gradientTex = DE_NULL; 876 m_gridTex = DE_NULL; 877 878 m_renderer.clear(); 879 m_cases.clear(); 880 } 881 882 Texture2DArrayShadowCase::IterateResult Texture2DArrayShadowCase::iterate (void) 883 { 884 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 885 const RandomViewport viewport (m_context.getRenderTarget(), TEX2D_VIEWPORT_WIDTH, TEX2D_VIEWPORT_HEIGHT, deStringHash(getName()) ^ deInt32Hash(m_caseNdx)); 886 const FilterCase& curCase = m_cases[m_caseNdx]; 887 const tcu::ScopedLogSection section (m_testCtx.getLog(), string("Test") + de::toString(m_caseNdx), string("Test ") + de::toString(m_caseNdx)); 888 ReferenceParams sampleParams (TEXTURETYPE_2D_ARRAY); 889 tcu::Surface rendered (viewport.width, viewport.height); 890 891 const float texCoord[] = 892 { 893 curCase.minCoord.x(), curCase.minCoord.y(), curCase.minCoord.z(), 894 curCase.minCoord.x(), curCase.maxCoord.y(), (curCase.minCoord.z() + curCase.maxCoord.z()) / 2.0f, 895 curCase.maxCoord.x(), curCase.minCoord.y(), (curCase.minCoord.z() + curCase.maxCoord.z()) / 2.0f, 896 curCase.maxCoord.x(), curCase.maxCoord.y(), curCase.maxCoord.z() 897 }; 898 899 if (viewport.width < TEX2D_MIN_VIEWPORT_WIDTH || viewport.height < TEX2D_MIN_VIEWPORT_HEIGHT) 900 throw tcu::NotSupportedError("Too small render target", "", __FILE__, __LINE__); 901 902 // Setup params for reference. 903 sampleParams.sampler = glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, m_magFilter); 904 sampleParams.sampler.compare = glu::mapGLCompareFunc(m_compareFunc); 905 sampleParams.samplerType = SAMPLERTYPE_SHADOW; 906 sampleParams.lodMode = LODMODE_EXACT; 907 sampleParams.ref = curCase.ref; 908 909 m_testCtx.getLog() 910 << TestLog::Message 911 << "Compare reference value = " << sampleParams.ref << "\n" 912 << "Texture coordinates: " << curCase.minCoord << " -> " << curCase.maxCoord 913 << TestLog::EndMessage; 914 915 gl.bindTexture (GL_TEXTURE_2D_ARRAY, curCase.texture->getGLTexture()); 916 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, m_minFilter); 917 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, m_magFilter); 918 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, m_wrapS); 919 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, m_wrapT); 920 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); 921 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_FUNC, m_compareFunc); 922 923 gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); 924 m_renderer.renderQuad(0, &texCoord[0], sampleParams); 925 glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, rendered.getAccess()); 926 927 { 928 const tcu::PixelFormat pixelFormat = m_context.getRenderTarget().getPixelFormat(); 929 tcu::LodPrecision lodPrecision; 930 tcu::TexComparePrecision texComparePrecision; 931 932 lodPrecision.derivateBits = 18; 933 lodPrecision.lodBits = 6; 934 texComparePrecision.coordBits = tcu::IVec3(20,20,20); 935 texComparePrecision.uvwBits = tcu::IVec3(7,7,7); 936 texComparePrecision.pcfBits = 5; 937 texComparePrecision.referenceBits = 16; 938 texComparePrecision.resultBits = pixelFormat.redBits-1; 939 940 const bool isHighQuality = verifyTexCompareResult(m_testCtx, rendered.getAccess(), curCase.texture->getRefTexture(), 941 &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat); 942 943 if (!isHighQuality) 944 { 945 m_testCtx.getLog() << TestLog::Message << "Warning: Verification assuming high-quality PCF filtering failed." << TestLog::EndMessage; 946 947 lodPrecision.lodBits = 4; 948 texComparePrecision.uvwBits = tcu::IVec3(4,4,4); 949 texComparePrecision.pcfBits = 0; 950 951 const bool isOk = verifyTexCompareResult(m_testCtx, rendered.getAccess(), curCase.texture->getRefTexture(), 952 &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat); 953 954 if (!isOk) 955 { 956 m_testCtx.getLog() << TestLog::Message << "ERROR: Verification against low precision requirements failed, failing test case." << TestLog::EndMessage; 957 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed"); 958 } 959 else if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) 960 m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Low-quality result"); 961 } 962 } 963 964 m_caseNdx += 1; 965 return m_caseNdx < (int)m_cases.size() ? CONTINUE : STOP; 966 } 967 968 TextureShadowTests::TextureShadowTests (Context& context) 969 : TestCaseGroup(context, "shadow", "Shadow texture lookup tests") 970 { 971 } 972 973 TextureShadowTests::~TextureShadowTests (void) 974 { 975 } 976 977 void TextureShadowTests::init (void) 978 { 979 static const struct 980 { 981 const char* name; 982 deUint32 format; 983 } formats[] = 984 { 985 { "depth_component16", GL_DEPTH_COMPONENT16 }, 986 { "depth_component32f", GL_DEPTH_COMPONENT32F }, 987 { "depth24_stencil8", GL_DEPTH24_STENCIL8 } 988 }; 989 990 static const struct 991 { 992 const char* name; 993 deUint32 minFilter; 994 deUint32 magFilter; 995 } filters[] = 996 { 997 { "nearest", GL_NEAREST, GL_NEAREST }, 998 { "linear", GL_LINEAR, GL_LINEAR }, 999 { "nearest_mipmap_nearest", GL_NEAREST_MIPMAP_NEAREST, GL_LINEAR }, 1000 { "linear_mipmap_nearest", GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR }, 1001 { "nearest_mipmap_linear", GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR }, 1002 { "linear_mipmap_linear", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR } 1003 }; 1004 1005 static const struct 1006 { 1007 const char* name; 1008 deUint32 func; 1009 } compareFuncs[] = 1010 { 1011 { "less_or_equal", GL_LEQUAL }, 1012 { "greater_or_equal", GL_GEQUAL }, 1013 { "less", GL_LESS }, 1014 { "greater", GL_GREATER }, 1015 { "equal", GL_EQUAL }, 1016 { "not_equal", GL_NOTEQUAL }, 1017 { "always", GL_ALWAYS }, 1018 { "never", GL_NEVER } 1019 }; 1020 1021 // 2D cases. 1022 { 1023 tcu::TestCaseGroup* group2D = new tcu::TestCaseGroup(m_testCtx, "2d", "2D texture shadow lookup tests"); 1024 addChild(group2D); 1025 1026 for (int filterNdx = 0; filterNdx < DE_LENGTH_OF_ARRAY(filters); filterNdx++) 1027 { 1028 tcu::TestCaseGroup* filterGroup = new tcu::TestCaseGroup(m_testCtx, filters[filterNdx].name, ""); 1029 group2D->addChild(filterGroup); 1030 1031 for (int compareNdx = 0; compareNdx < DE_LENGTH_OF_ARRAY(compareFuncs); compareNdx++) 1032 { 1033 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++) 1034 { 1035 deUint32 minFilter = filters[filterNdx].minFilter; 1036 deUint32 magFilter = filters[filterNdx].magFilter; 1037 deUint32 format = formats[formatNdx].format; 1038 deUint32 compareFunc = compareFuncs[compareNdx].func; 1039 const deUint32 wrapS = GL_REPEAT; 1040 const deUint32 wrapT = GL_REPEAT; 1041 const int width = 32; 1042 const int height = 64; 1043 string name = string(compareFuncs[compareNdx].name) + "_" + formats[formatNdx].name; 1044 1045 filterGroup->addChild(new Texture2DShadowCase(m_context, name.c_str(), "", minFilter, magFilter, wrapS, wrapT, format, width, height, compareFunc)); 1046 } 1047 } 1048 } 1049 } 1050 1051 // Cubemap cases. 1052 { 1053 tcu::TestCaseGroup* groupCube = new tcu::TestCaseGroup(m_testCtx, "cube", "Cube map texture shadow lookup tests"); 1054 addChild(groupCube); 1055 1056 for (int filterNdx = 0; filterNdx < DE_LENGTH_OF_ARRAY(filters); filterNdx++) 1057 { 1058 tcu::TestCaseGroup* filterGroup = new tcu::TestCaseGroup(m_testCtx, filters[filterNdx].name, ""); 1059 groupCube->addChild(filterGroup); 1060 1061 for (int compareNdx = 0; compareNdx < DE_LENGTH_OF_ARRAY(compareFuncs); compareNdx++) 1062 { 1063 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++) 1064 { 1065 deUint32 minFilter = filters[filterNdx].minFilter; 1066 deUint32 magFilter = filters[filterNdx].magFilter; 1067 deUint32 format = formats[formatNdx].format; 1068 deUint32 compareFunc = compareFuncs[compareNdx].func; 1069 const deUint32 wrapS = GL_REPEAT; 1070 const deUint32 wrapT = GL_REPEAT; 1071 const int size = 32; 1072 string name = string(compareFuncs[compareNdx].name) + "_" + formats[formatNdx].name; 1073 1074 filterGroup->addChild(new TextureCubeShadowCase(m_context, name.c_str(), "", minFilter, magFilter, wrapS, wrapT, format, size, compareFunc)); 1075 } 1076 } 1077 } 1078 } 1079 1080 // 2D array cases. 1081 { 1082 tcu::TestCaseGroup* group2DArray = new tcu::TestCaseGroup(m_testCtx, "2d_array", "2D texture array shadow lookup tests"); 1083 addChild(group2DArray); 1084 1085 for (int filterNdx = 0; filterNdx < DE_LENGTH_OF_ARRAY(filters); filterNdx++) 1086 { 1087 tcu::TestCaseGroup* filterGroup = new tcu::TestCaseGroup(m_testCtx, filters[filterNdx].name, ""); 1088 group2DArray->addChild(filterGroup); 1089 1090 for (int compareNdx = 0; compareNdx < DE_LENGTH_OF_ARRAY(compareFuncs); compareNdx++) 1091 { 1092 for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++) 1093 { 1094 deUint32 minFilter = filters[filterNdx].minFilter; 1095 deUint32 magFilter = filters[filterNdx].magFilter; 1096 deUint32 format = formats[formatNdx].format; 1097 deUint32 compareFunc = compareFuncs[compareNdx].func; 1098 const deUint32 wrapS = GL_REPEAT; 1099 const deUint32 wrapT = GL_REPEAT; 1100 const int width = 32; 1101 const int height = 64; 1102 const int numLayers = 8; 1103 string name = string(compareFuncs[compareNdx].name) + "_" + formats[formatNdx].name; 1104 1105 filterGroup->addChild(new Texture2DArrayShadowCase(m_context, name.c_str(), "", minFilter, magFilter, wrapS, wrapT, format, width, height, numLayers, compareFunc)); 1106 } 1107 } 1108 } 1109 } 1110 } 1111 1112 } // Functional 1113 } // gles3 1114 } // deqp 1115
