1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 2.0 Module 3 * ------------------------------------------------- 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Mipmapping accuracy tests. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es2aTextureMipmapTests.hpp" 25 #include "glsTextureTestUtil.hpp" 26 #include "gluTexture.hpp" 27 #include "gluStrUtil.hpp" 28 #include "gluTextureUtil.hpp" 29 #include "gluPixelTransfer.hpp" 30 #include "tcuTestLog.hpp" 31 #include "tcuTextureUtil.hpp" 32 #include "tcuTexVerifierUtil.hpp" 33 #include "tcuVector.hpp" 34 #include "tcuMatrix.hpp" 35 #include "tcuMatrixUtil.hpp" 36 #include "deStringUtil.hpp" 37 #include "deRandom.hpp" 38 39 #include "glwEnums.hpp" 40 #include "glwFunctions.hpp" 41 42 namespace deqp 43 { 44 namespace gles2 45 { 46 namespace Accuracy 47 { 48 49 using tcu::TestLog; 50 using std::vector; 51 using std::string; 52 using tcu::Sampler; 53 using tcu::Vec2; 54 using tcu::Mat2; 55 using tcu::Vec4; 56 using tcu::IVec2; 57 using tcu::IVec4; 58 using namespace glu; 59 using namespace gls::TextureTestUtil; 60 using namespace glu::TextureTestUtil; 61 62 enum CoordType 63 { 64 COORDTYPE_BASIC, //!< texCoord = translateScale(position). 65 COORDTYPE_BASIC_BIAS, //!< Like basic, but with bias values. 66 COORDTYPE_AFFINE, //!< texCoord = translateScaleRotateShear(position). 67 COORDTYPE_PROJECTED, //!< Projected coordinates, w != 1 68 69 COORDTYPE_LAST 70 }; 71 72 // Texture2DMipmapCase 73 74 class Texture2DMipmapCase : public tcu::TestCase 75 { 76 public: 77 78 Texture2DMipmapCase (tcu::TestContext& testCtx, 79 glu::RenderContext& renderCtx, 80 const glu::ContextInfo& renderCtxInfo, 81 const char* name, 82 const char* desc, 83 CoordType coordType, 84 deUint32 minFilter, 85 deUint32 wrapS, 86 deUint32 wrapT, 87 deUint32 format, 88 deUint32 dataType, 89 int width, 90 int height); 91 ~Texture2DMipmapCase (void); 92 93 void init (void); 94 void deinit (void); 95 IterateResult iterate (void); 96 97 private: 98 Texture2DMipmapCase (const Texture2DMipmapCase& other); 99 Texture2DMipmapCase& operator= (const Texture2DMipmapCase& other); 100 101 glu::RenderContext& m_renderCtx; 102 const glu::ContextInfo& m_renderCtxInfo; 103 104 CoordType m_coordType; 105 deUint32 m_minFilter; 106 deUint32 m_wrapS; 107 deUint32 m_wrapT; 108 deUint32 m_format; 109 deUint32 m_dataType; 110 int m_width; 111 int m_height; 112 113 glu::Texture2D* m_texture; 114 TextureRenderer m_renderer; 115 }; 116 117 Texture2DMipmapCase::Texture2DMipmapCase (tcu::TestContext& testCtx, 118 glu::RenderContext& renderCtx, 119 const glu::ContextInfo& renderCtxInfo, 120 const char* name, 121 const char* desc, 122 CoordType coordType, 123 deUint32 minFilter, 124 deUint32 wrapS, 125 deUint32 wrapT, 126 deUint32 format, 127 deUint32 dataType, 128 int width, 129 int height) 130 : TestCase (testCtx, tcu::NODETYPE_ACCURACY, name, desc) 131 , m_renderCtx (renderCtx) 132 , m_renderCtxInfo (renderCtxInfo) 133 , m_coordType (coordType) 134 , m_minFilter (minFilter) 135 , m_wrapS (wrapS) 136 , m_wrapT (wrapT) 137 , m_format (format) 138 , m_dataType (dataType) 139 , m_width (width) 140 , m_height (height) 141 , m_texture (DE_NULL) 142 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_100_ES, 143 renderCtxInfo.isFragmentHighPrecisionSupported() ? glu::PRECISION_HIGHP // Use highp if available. 144 : glu::PRECISION_MEDIUMP) 145 { 146 } 147 148 Texture2DMipmapCase::~Texture2DMipmapCase (void) 149 { 150 deinit(); 151 } 152 153 void Texture2DMipmapCase::init (void) 154 { 155 if (!m_renderCtxInfo.isFragmentHighPrecisionSupported()) 156 m_testCtx.getLog() << TestLog::Message << "Warning: High precision not supported in fragment shaders." << TestLog::EndMessage; 157 158 m_texture = new Texture2D(m_renderCtx, m_format, m_dataType, m_width, m_height); 159 160 int numLevels = deLog2Floor32(de::max(m_width, m_height))+1; 161 162 // Fill texture with colored grid. 163 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 164 { 165 deUint32 step = 0xff / (numLevels-1); 166 deUint32 inc = deClamp32(step*levelNdx, 0x00, 0xff); 167 deUint32 dec = 0xff - inc; 168 deUint32 rgb = (inc << 16) | (dec << 8) | 0xff; 169 deUint32 color = 0xff000000 | rgb; 170 171 m_texture->getRefTexture().allocLevel(levelNdx); 172 tcu::clear(m_texture->getRefTexture().getLevel(levelNdx), tcu::RGBA(color).toVec()); 173 } 174 } 175 176 void Texture2DMipmapCase::deinit (void) 177 { 178 delete m_texture; 179 m_texture = DE_NULL; 180 181 m_renderer.clear(); 182 } 183 184 static void getBasicTexCoord2D (std::vector<float>& dst, int cellNdx) 185 { 186 static const struct 187 { 188 Vec2 bottomLeft; 189 Vec2 topRight; 190 } s_basicCoords[] = 191 { 192 { Vec2(-0.1f, 0.1f), Vec2( 0.8f, 1.0f) }, 193 { Vec2(-0.3f, -0.6f), Vec2( 0.7f, 0.4f) }, 194 { Vec2(-0.3f, 0.6f), Vec2( 0.7f, -0.9f) }, 195 { Vec2(-0.8f, 0.6f), Vec2( 0.7f, -0.9f) }, 196 197 { Vec2(-0.5f, -0.5f), Vec2( 1.5f, 1.5f) }, 198 { Vec2( 1.0f, -1.0f), Vec2(-1.3f, 1.0f) }, 199 { Vec2( 1.2f, -1.0f), Vec2(-1.3f, 1.6f) }, 200 { Vec2( 2.2f, -1.1f), Vec2(-1.3f, 0.8f) }, 201 202 { Vec2(-1.5f, 1.6f), Vec2( 1.7f, -1.4f) }, 203 { Vec2( 2.0f, 1.6f), Vec2( 2.3f, -1.4f) }, 204 { Vec2( 1.3f, -2.6f), Vec2(-2.7f, 2.9f) }, 205 { Vec2(-0.8f, -6.6f), Vec2( 6.0f, -0.9f) }, 206 207 { Vec2( -8.0f, 9.0f), Vec2( 8.3f, -7.0f) }, 208 { Vec2(-16.0f, 10.0f), Vec2( 18.3f, 24.0f) }, 209 { Vec2( 30.2f, 55.0f), Vec2(-24.3f, -1.6f) }, 210 { Vec2(-33.2f, 64.1f), Vec2( 32.1f, -64.1f) }, 211 }; 212 213 DE_ASSERT(de::inBounds(cellNdx, 0, DE_LENGTH_OF_ARRAY(s_basicCoords))); 214 215 const Vec2& bottomLeft = s_basicCoords[cellNdx].bottomLeft; 216 const Vec2& topRight = s_basicCoords[cellNdx].topRight; 217 218 computeQuadTexCoord2D(dst, bottomLeft, topRight); 219 } 220 221 static void getAffineTexCoord2D (std::vector<float>& dst, int cellNdx) 222 { 223 // Use basic coords as base. 224 getBasicTexCoord2D(dst, cellNdx); 225 226 // Rotate based on cell index. 227 float angle = 2.0f*DE_PI * ((float)cellNdx / 16.0f); 228 tcu::Mat2 rotMatrix = tcu::rotationMatrix(angle); 229 230 // Second and third row are sheared. 231 float shearX = de::inRange(cellNdx, 4, 11) ? (float)(15-cellNdx) / 16.0f : 0.0f; 232 tcu::Mat2 shearMatrix = tcu::shearMatrix(tcu::Vec2(shearX, 0.0f)); 233 234 tcu::Mat2 transform = rotMatrix * shearMatrix; 235 Vec2 p0 = transform * Vec2(dst[0], dst[1]); 236 Vec2 p1 = transform * Vec2(dst[2], dst[3]); 237 Vec2 p2 = transform * Vec2(dst[4], dst[5]); 238 Vec2 p3 = transform * Vec2(dst[6], dst[7]); 239 240 dst[0] = p0.x(); dst[1] = p0.y(); 241 dst[2] = p1.x(); dst[3] = p1.y(); 242 dst[4] = p2.x(); dst[5] = p2.y(); 243 dst[6] = p3.x(); dst[7] = p3.y(); 244 } 245 246 Texture2DMipmapCase::IterateResult Texture2DMipmapCase::iterate (void) 247 { 248 // Constants. 249 const deUint32 magFilter = GL_NEAREST; 250 251 const glw::Functions& gl = m_renderCtx.getFunctions(); 252 TestLog& log = m_testCtx.getLog(); 253 254 const tcu::Texture2D& refTexture = m_texture->getRefTexture(); 255 const tcu::TextureFormat& texFmt = refTexture.getFormat(); 256 tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(texFmt); 257 258 int texWidth = refTexture.getWidth(); 259 int texHeight = refTexture.getHeight(); 260 int defViewportWidth = texWidth*4; 261 int defViewportHeight = texHeight*4; 262 263 RandomViewport viewport (m_renderCtx.getRenderTarget(), defViewportWidth, defViewportHeight, deStringHash(getName())); 264 ReferenceParams sampleParams (TEXTURETYPE_2D); 265 vector<float> texCoord; 266 bool isProjected = m_coordType == COORDTYPE_PROJECTED; 267 bool useLodBias = m_coordType == COORDTYPE_BASIC_BIAS; 268 269 tcu::Surface renderedFrame (viewport.width, viewport.height); 270 271 // Accuracy cases test against ideal lod computation. 272 tcu::Surface idealFrame (viewport.width, viewport.height); 273 274 // Viewport is divided into 4x4 grid. 275 int gridWidth = 4; 276 int gridHeight = 4; 277 int cellWidth = viewport.width / gridWidth; 278 int cellHeight = viewport.height / gridHeight; 279 280 // Accuracy measurements are off unless we get the expected viewport size. 281 if (viewport.width < defViewportWidth || viewport.height < defViewportHeight) 282 throw tcu::NotSupportedError("Too small viewport", "", __FILE__, __LINE__); 283 284 // Sampling parameters. 285 sampleParams.sampler = glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, magFilter); 286 sampleParams.samplerType = glu::TextureTestUtil::getSamplerType(m_texture->getRefTexture().getFormat()); 287 sampleParams.colorBias = fmtInfo.lookupBias; 288 sampleParams.colorScale = fmtInfo.lookupScale; 289 sampleParams.flags = (isProjected ? ReferenceParams::PROJECTED : 0) | (useLodBias ? ReferenceParams::USE_BIAS : 0); 290 291 // Upload texture data. 292 m_texture->upload(); 293 294 // Use unit 0. 295 gl.activeTexture(GL_TEXTURE0); 296 297 // Bind gradient texture and setup sampler parameters. 298 gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture()); 299 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, m_wrapS); 300 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, m_wrapT); 301 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_minFilter); 302 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter); 303 304 GLU_EXPECT_NO_ERROR(gl.getError(), "After texture setup"); 305 306 // Bias values. 307 static const float s_bias[] = { 1.0f, -2.0f, 0.8f, -0.5f, 1.5f, 0.9f, 2.0f, 4.0f }; 308 309 // Projection values. 310 static const Vec4 s_projections[] = 311 { 312 Vec4(1.2f, 1.0f, 0.7f, 1.0f), 313 Vec4(1.3f, 0.8f, 0.6f, 2.0f), 314 Vec4(0.8f, 1.0f, 1.7f, 0.6f), 315 Vec4(1.2f, 1.0f, 1.7f, 1.5f) 316 }; 317 318 // Render cells. 319 for (int gridY = 0; gridY < gridHeight; gridY++) 320 { 321 for (int gridX = 0; gridX < gridWidth; gridX++) 322 { 323 int curX = cellWidth*gridX; 324 int curY = cellHeight*gridY; 325 int curW = gridX+1 == gridWidth ? (viewport.width-curX) : cellWidth; 326 int curH = gridY+1 == gridHeight ? (viewport.height-curY) : cellHeight; 327 int cellNdx = gridY*gridWidth + gridX; 328 329 // Compute texcoord. 330 switch (m_coordType) 331 { 332 case COORDTYPE_BASIC_BIAS: // Fall-through. 333 case COORDTYPE_PROJECTED: 334 case COORDTYPE_BASIC: getBasicTexCoord2D (texCoord, cellNdx); break; 335 case COORDTYPE_AFFINE: getAffineTexCoord2D (texCoord, cellNdx); break; 336 default: DE_ASSERT(DE_FALSE); 337 } 338 339 if (isProjected) 340 sampleParams.w = s_projections[cellNdx % DE_LENGTH_OF_ARRAY(s_projections)]; 341 342 if (useLodBias) 343 sampleParams.bias = s_bias[cellNdx % DE_LENGTH_OF_ARRAY(s_bias)]; 344 345 // Render with GL. 346 gl.viewport(viewport.x+curX, viewport.y+curY, curW, curH); 347 m_renderer.renderQuad(0, &texCoord[0], sampleParams); 348 349 // Render reference(s). 350 { 351 tcu::SurfaceAccess idealDst(idealFrame, m_renderCtx.getRenderTarget().getPixelFormat(), curX, curY, curW, curH); 352 sampleParams.lodMode = LODMODE_EXACT; 353 sampleTexture(idealDst, m_texture->getRefTexture(), &texCoord[0], sampleParams); 354 } 355 } 356 } 357 358 // Read result. 359 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess()); 360 361 // Compare and log. 362 { 363 const int bestScoreDiff = (texWidth/16)*(texHeight/16); 364 const int worstScoreDiff = texWidth*texHeight; 365 366 int score = measureAccuracy(log, idealFrame, renderedFrame, bestScoreDiff, worstScoreDiff); 367 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, de::toString(score).c_str()); 368 } 369 370 return STOP; 371 } 372 373 // TextureCubeMipmapCase 374 375 class TextureCubeMipmapCase : public tcu::TestCase 376 { 377 public: 378 379 TextureCubeMipmapCase (tcu::TestContext& testCtx, 380 glu::RenderContext& renderCtx, 381 const glu::ContextInfo& renderCtxInfo, 382 const char* name, 383 const char* desc, 384 CoordType coordType, 385 deUint32 minFilter, 386 deUint32 wrapS, 387 deUint32 wrapT, 388 deUint32 format, 389 deUint32 dataType, 390 int size); 391 ~TextureCubeMipmapCase (void); 392 393 void init (void); 394 void deinit (void); 395 IterateResult iterate (void); 396 397 private: 398 TextureCubeMipmapCase (const TextureCubeMipmapCase& other); 399 TextureCubeMipmapCase& operator= (const TextureCubeMipmapCase& other); 400 401 glu::RenderContext& m_renderCtx; 402 const glu::ContextInfo& m_renderCtxInfo; 403 404 CoordType m_coordType; 405 deUint32 m_minFilter; 406 deUint32 m_wrapS; 407 deUint32 m_wrapT; 408 deUint32 m_format; 409 deUint32 m_dataType; 410 int m_size; 411 412 glu::TextureCube* m_texture; 413 TextureRenderer m_renderer; 414 }; 415 416 TextureCubeMipmapCase::TextureCubeMipmapCase (tcu::TestContext& testCtx, 417 glu::RenderContext& renderCtx, 418 const glu::ContextInfo& renderCtxInfo, 419 const char* name, 420 const char* desc, 421 CoordType coordType, 422 deUint32 minFilter, 423 deUint32 wrapS, 424 deUint32 wrapT, 425 deUint32 format, 426 deUint32 dataType, 427 int size) 428 : TestCase (testCtx, tcu::NODETYPE_ACCURACY, name, desc) 429 , m_renderCtx (renderCtx) 430 , m_renderCtxInfo (renderCtxInfo) 431 , m_coordType (coordType) 432 , m_minFilter (minFilter) 433 , m_wrapS (wrapS) 434 , m_wrapT (wrapT) 435 , m_format (format) 436 , m_dataType (dataType) 437 , m_size (size) 438 , m_texture (DE_NULL) 439 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_100_ES, 440 renderCtxInfo.isFragmentHighPrecisionSupported() ? glu::PRECISION_HIGHP // Use highp if available. 441 : glu::PRECISION_MEDIUMP) 442 { 443 } 444 445 TextureCubeMipmapCase::~TextureCubeMipmapCase (void) 446 { 447 deinit(); 448 } 449 450 void TextureCubeMipmapCase::init (void) 451 { 452 if (!m_renderCtxInfo.isFragmentHighPrecisionSupported()) 453 m_testCtx.getLog() << TestLog::Message << "Warning: High precision not supported in fragment shaders." << TestLog::EndMessage; 454 455 m_texture = new TextureCube(m_renderCtx, m_format, m_dataType, m_size); 456 457 int numLevels = deLog2Floor32(m_size)+1; 458 459 // Fill texture with colored grid. 460 for (int faceNdx = 0; faceNdx < tcu::CUBEFACE_LAST; faceNdx++) 461 { 462 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 463 { 464 deUint32 step = 0xff / (numLevels-1); 465 deUint32 inc = deClamp32(step*levelNdx, 0x00, 0xff); 466 deUint32 dec = 0xff - inc; 467 deUint32 rgb = 0; 468 469 switch (faceNdx) 470 { 471 case 0: rgb = (inc << 16) | (dec << 8) | 255; break; 472 case 1: rgb = (255 << 16) | (inc << 8) | dec; break; 473 case 2: rgb = (dec << 16) | (255 << 8) | inc; break; 474 case 3: rgb = (dec << 16) | (inc << 8) | 255; break; 475 case 4: rgb = (255 << 16) | (dec << 8) | inc; break; 476 case 5: rgb = (inc << 16) | (255 << 8) | dec; break; 477 } 478 479 deUint32 color = 0xff000000 | rgb; 480 481 m_texture->getRefTexture().allocLevel((tcu::CubeFace)faceNdx, levelNdx); 482 tcu::clear(m_texture->getRefTexture().getLevelFace(levelNdx, (tcu::CubeFace)faceNdx), tcu::RGBA(color).toVec()); 483 } 484 } 485 } 486 487 void TextureCubeMipmapCase::deinit (void) 488 { 489 delete m_texture; 490 m_texture = DE_NULL; 491 492 m_renderer.clear(); 493 } 494 495 static void randomPartition (vector<IVec4>& dst, de::Random& rnd, int x, int y, int width, int height) 496 { 497 const int minWidth = 8; 498 const int minHeight = 8; 499 500 bool partition = rnd.getFloat() > 0.4f; 501 bool partitionX = partition && width > minWidth && rnd.getBool(); 502 bool partitionY = partition && height > minHeight && !partitionX; 503 504 if (partitionX) 505 { 506 int split = width/2 + rnd.getInt(-width/4, +width/4); 507 randomPartition(dst, rnd, x, y, split, height); 508 randomPartition(dst, rnd, x+split, y, width-split, height); 509 } 510 else if (partitionY) 511 { 512 int split = height/2 + rnd.getInt(-height/4, +height/4); 513 randomPartition(dst, rnd, x, y, width, split); 514 randomPartition(dst, rnd, x, y+split, width, height-split); 515 } 516 else 517 dst.push_back(IVec4(x, y, width, height)); 518 } 519 520 static void computeGridLayout (vector<IVec4>& dst, int width, int height) 521 { 522 de::Random rnd(7); 523 randomPartition(dst, rnd, 0, 0, width, height); 524 } 525 526 TextureCubeMipmapCase::IterateResult TextureCubeMipmapCase::iterate (void) 527 { 528 // Constants. 529 const deUint32 magFilter = GL_NEAREST; 530 531 int texWidth = m_texture->getRefTexture().getSize(); 532 int texHeight = m_texture->getRefTexture().getSize(); 533 534 int defViewportWidth = texWidth*2; 535 int defViewportHeight = texHeight*2; 536 537 const glw::Functions& gl = m_renderCtx.getFunctions(); 538 TestLog& log = m_testCtx.getLog(); 539 RandomViewport viewport (m_renderCtx.getRenderTarget(), defViewportWidth, defViewportHeight, deStringHash(getName())); 540 tcu::Sampler sampler = mapGLSampler(m_wrapS, m_wrapT, m_minFilter, magFilter); 541 542 vector<float> texCoord; 543 544 bool isProjected = m_coordType == COORDTYPE_PROJECTED; 545 bool useLodBias = m_coordType == COORDTYPE_BASIC_BIAS; 546 547 tcu::Surface renderedFrame (viewport.width, viewport.height); 548 549 // Accuracy cases test against ideal lod computation. 550 tcu::Surface idealFrame (viewport.width, viewport.height); 551 552 // Accuracy measurements are off unless we get the expected viewport size. 553 if (viewport.width < defViewportWidth || viewport.height < defViewportHeight) 554 throw tcu::NotSupportedError("Too small viewport", "", __FILE__, __LINE__); 555 556 // Upload texture data. 557 m_texture->upload(); 558 559 // Use unit 0. 560 gl.activeTexture(GL_TEXTURE0); 561 562 // Bind gradient texture and setup sampler parameters. 563 gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_texture->getGLTexture()); 564 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, m_wrapS); 565 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, m_wrapT); 566 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, m_minFilter); 567 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, magFilter); 568 569 GLU_EXPECT_NO_ERROR(gl.getError(), "After texture setup"); 570 571 // Compute grid. 572 vector<IVec4> gridLayout; 573 computeGridLayout(gridLayout, viewport.width, viewport.height); 574 575 // Bias values. 576 static const float s_bias[] = { 1.0f, -2.0f, 0.8f, -0.5f, 1.5f, 0.9f, 2.0f, 4.0f }; 577 578 // Projection values \note Less agressive than in 2D case due to smaller quads. 579 static const Vec4 s_projections[] = 580 { 581 Vec4(1.2f, 1.0f, 0.7f, 1.0f), 582 Vec4(1.3f, 0.8f, 0.6f, 1.1f), 583 Vec4(0.8f, 1.0f, 1.2f, 0.8f), 584 Vec4(1.2f, 1.0f, 1.3f, 0.9f) 585 }; 586 587 for (int cellNdx = 0; cellNdx < (int)gridLayout.size(); cellNdx++) 588 { 589 int curX = gridLayout[cellNdx].x(); 590 int curY = gridLayout[cellNdx].y(); 591 int curW = gridLayout[cellNdx].z(); 592 int curH = gridLayout[cellNdx].w(); 593 tcu::CubeFace cubeFace = (tcu::CubeFace)(cellNdx % tcu::CUBEFACE_LAST); 594 ReferenceParams params (TEXTURETYPE_CUBE); 595 596 params.sampler = sampler; 597 598 DE_ASSERT(m_coordType != COORDTYPE_AFFINE); // Not supported. 599 computeQuadTexCoordCube(texCoord, cubeFace); 600 601 if (isProjected) 602 { 603 params.flags |= ReferenceParams::PROJECTED; 604 params.w = s_projections[cellNdx % DE_LENGTH_OF_ARRAY(s_projections)]; 605 } 606 607 if (useLodBias) 608 { 609 params.flags |= ReferenceParams::USE_BIAS; 610 params.bias = s_bias[cellNdx % DE_LENGTH_OF_ARRAY(s_bias)]; 611 } 612 613 // Render with GL. 614 gl.viewport(viewport.x+curX, viewport.y+curY, curW, curH); 615 m_renderer.renderQuad(0, &texCoord[0], params); 616 617 // Render reference(s). 618 { 619 tcu::SurfaceAccess idealDst(idealFrame, m_renderCtx.getRenderTarget().getPixelFormat(), curX, curY, curW, curH); 620 params.lodMode = LODMODE_EXACT; 621 sampleTexture(idealDst, m_texture->getRefTexture(), &texCoord[0], params); 622 } 623 } 624 625 // Read result. 626 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess()); 627 628 // Compare and log. 629 { 630 const int bestScoreDiff = (texWidth/16)*(texHeight/16); 631 const int worstScoreDiff = texWidth*texHeight; 632 633 int score = measureAccuracy(log, idealFrame, renderedFrame, bestScoreDiff, worstScoreDiff); 634 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, de::toString(score).c_str()); 635 } 636 637 return STOP; 638 } 639 640 TextureMipmapTests::TextureMipmapTests (Context& context) 641 : TestCaseGroup(context, "mipmap", "Mipmapping accuracy tests") 642 { 643 } 644 645 TextureMipmapTests::~TextureMipmapTests (void) 646 { 647 } 648 649 void TextureMipmapTests::init (void) 650 { 651 tcu::TestCaseGroup* group2D = new tcu::TestCaseGroup(m_testCtx, "2d", "2D Texture Mipmapping"); 652 tcu::TestCaseGroup* groupCube = new tcu::TestCaseGroup(m_testCtx, "cube", "Cube Map Filtering"); 653 addChild(group2D); 654 addChild(groupCube); 655 656 static const struct 657 { 658 const char* name; 659 deUint32 mode; 660 } wrapModes[] = 661 { 662 { "clamp", GL_CLAMP_TO_EDGE }, 663 { "repeat", GL_REPEAT }, 664 { "mirror", GL_MIRRORED_REPEAT } 665 }; 666 667 static const struct 668 { 669 const char* name; 670 deUint32 mode; 671 } minFilterModes[] = 672 { 673 { "nearest_nearest", GL_NEAREST_MIPMAP_NEAREST }, 674 { "linear_nearest", GL_LINEAR_MIPMAP_NEAREST }, 675 { "nearest_linear", GL_NEAREST_MIPMAP_LINEAR }, 676 { "linear_linear", GL_LINEAR_MIPMAP_LINEAR } 677 }; 678 679 static const struct 680 { 681 CoordType type; 682 const char* name; 683 const char* desc; 684 } coordTypes[] = 685 { 686 { COORDTYPE_BASIC, "basic", "Mipmapping with translated and scaled coordinates" }, 687 { COORDTYPE_AFFINE, "affine", "Mipmapping with affine coordinate transform" }, 688 { COORDTYPE_PROJECTED, "projected", "Mipmapping with perspective projection" } 689 }; 690 691 const int tex2DWidth = 64; 692 const int tex2DHeight = 64; 693 694 // 2D cases. 695 for (int coordType = 0; coordType < DE_LENGTH_OF_ARRAY(coordTypes); coordType++) 696 { 697 tcu::TestCaseGroup* coordTypeGroup = new tcu::TestCaseGroup(m_testCtx, coordTypes[coordType].name, coordTypes[coordType].desc); 698 group2D->addChild(coordTypeGroup); 699 700 for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++) 701 { 702 for (int wrapMode = 0; wrapMode < DE_LENGTH_OF_ARRAY(wrapModes); wrapMode++) 703 { 704 std::ostringstream name; 705 name << minFilterModes[minFilter].name 706 << "_" << wrapModes[wrapMode].name; 707 708 coordTypeGroup->addChild(new Texture2DMipmapCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), 709 name.str().c_str(), "", 710 coordTypes[coordType].type, 711 minFilterModes[minFilter].mode, 712 wrapModes[wrapMode].mode, 713 wrapModes[wrapMode].mode, 714 GL_RGBA, GL_UNSIGNED_BYTE, 715 tex2DWidth, tex2DHeight)); 716 } 717 } 718 } 719 720 const int cubeMapSize = 64; 721 722 static const struct 723 { 724 CoordType type; 725 const char* name; 726 const char* desc; 727 } cubeCoordTypes[] = 728 { 729 { COORDTYPE_BASIC, "basic", "Mipmapping with translated and scaled coordinates" }, 730 { COORDTYPE_PROJECTED, "projected", "Mipmapping with perspective projection" } 731 }; 732 733 // Cubemap cases. 734 for (int coordType = 0; coordType < DE_LENGTH_OF_ARRAY(cubeCoordTypes); coordType++) 735 { 736 tcu::TestCaseGroup* coordTypeGroup = new tcu::TestCaseGroup(m_testCtx, cubeCoordTypes[coordType].name, cubeCoordTypes[coordType].desc); 737 groupCube->addChild(coordTypeGroup); 738 739 for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++) 740 { 741 coordTypeGroup->addChild(new TextureCubeMipmapCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), 742 minFilterModes[minFilter].name, "", 743 cubeCoordTypes[coordType].type, 744 minFilterModes[minFilter].mode, 745 GL_CLAMP_TO_EDGE, 746 GL_CLAMP_TO_EDGE, 747 GL_RGBA, GL_UNSIGNED_BYTE, cubeMapSize)); 748 } 749 } 750 } 751 752 } // Accuracy 753 } // gles2 754 } // deqp 755
