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