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 Texture filtering accuracy tests. 22 *//*--------------------------------------------------------------------*/ 23 24#include "es3aTextureFilteringTests.hpp" 25#include "glsTextureTestUtil.hpp" 26#include "gluPixelTransfer.hpp" 27#include "gluTexture.hpp" 28#include "gluTextureUtil.hpp" 29#include "tcuTextureUtil.hpp" 30#include "tcuImageCompare.hpp" 31#include "deStringUtil.hpp" 32#include "deString.h" 33 34#include "glwFunctions.hpp" 35#include "glwEnums.hpp" 36 37namespace deqp 38{ 39namespace gles3 40{ 41namespace Accuracy 42{ 43 44using std::vector; 45using std::string; 46using tcu::TestLog; 47using namespace gls::TextureTestUtil; 48using namespace glu::TextureTestUtil; 49 50class Texture2DFilteringCase : public tcu::TestCase 51{ 52public: 53 Texture2DFilteringCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 internalFormat, int width, int height); 54 Texture2DFilteringCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, const std::vector<std::string>& filenames); 55 ~Texture2DFilteringCase (void); 56 57 void init (void); 58 void deinit (void); 59 IterateResult iterate (void); 60 61private: 62 Texture2DFilteringCase (const Texture2DFilteringCase& other); 63 Texture2DFilteringCase& operator= (const Texture2DFilteringCase& other); 64 65 glu::RenderContext& m_renderCtx; 66 const glu::ContextInfo& m_renderCtxInfo; 67 68 deUint32 m_minFilter; 69 deUint32 m_magFilter; 70 deUint32 m_wrapS; 71 deUint32 m_wrapT; 72 73 deUint32 m_internalFormat; 74 int m_width; 75 int m_height; 76 77 std::vector<std::string> m_filenames; 78 79 std::vector<glu::Texture2D*> m_textures; 80 TextureRenderer m_renderer; 81}; 82 83Texture2DFilteringCase::Texture2DFilteringCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, deUint32 internalFormat, int width, int height) 84 : TestCase (testCtx, tcu::NODETYPE_ACCURACY, name, desc) 85 , m_renderCtx (renderCtx) 86 , m_renderCtxInfo (ctxInfo) 87 , m_minFilter (minFilter) 88 , m_magFilter (magFilter) 89 , m_wrapS (wrapS) 90 , m_wrapT (wrapT) 91 , m_internalFormat (internalFormat) 92 , m_width (width) 93 , m_height (height) 94 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 95{ 96} 97 98Texture2DFilteringCase::Texture2DFilteringCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, const std::vector<std::string>& filenames) 99 : TestCase (testCtx, tcu::NODETYPE_ACCURACY, name, desc) 100 , m_renderCtx (renderCtx) 101 , m_renderCtxInfo (ctxInfo) 102 , m_minFilter (minFilter) 103 , m_magFilter (magFilter) 104 , m_wrapS (wrapS) 105 , m_wrapT (wrapT) 106 , m_internalFormat (GL_NONE) 107 , m_width (0) 108 , m_height (0) 109 , m_filenames (filenames) 110 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_100_ES, glu::PRECISION_HIGHP) 111{ 112} 113 114Texture2DFilteringCase::~Texture2DFilteringCase (void) 115{ 116 deinit(); 117} 118 119void Texture2DFilteringCase::init (void) 120{ 121 try 122 { 123 if (!m_filenames.empty()) 124 { 125 m_textures.reserve(1); 126 m_textures.push_back(glu::Texture2D::create(m_renderCtx, m_renderCtxInfo, m_testCtx.getArchive(), (int)m_filenames.size(), m_filenames)); 127 } 128 else 129 { 130 // Create 2 textures. 131 m_textures.reserve(2); 132 for (int ndx = 0; ndx < 2; ndx++) 133 m_textures.push_back(new glu::Texture2D(m_renderCtx, m_internalFormat, m_width, m_height)); 134 135 const int numLevels = deLog2Floor32(de::max(m_width, m_height))+1; 136 tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(m_textures[0]->getRefTexture().getFormat()); 137 tcu::Vec4 cBias = fmtInfo.valueMin; 138 tcu::Vec4 cScale = fmtInfo.valueMax-fmtInfo.valueMin; 139 140 // Fill first gradient texture. 141 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 142 { 143 tcu::Vec4 gMin = tcu::Vec4(-0.5f, -0.5f, -0.5f, 2.0f)*cScale + cBias; 144 tcu::Vec4 gMax = tcu::Vec4( 1.0f, 1.0f, 1.0f, 0.0f)*cScale + cBias; 145 146 m_textures[0]->getRefTexture().allocLevel(levelNdx); 147 tcu::fillWithComponentGradients(m_textures[0]->getRefTexture().getLevel(levelNdx), gMin, gMax); 148 } 149 150 // Fill second with grid texture. 151 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 152 { 153 deUint32 step = 0x00ffffff / numLevels; 154 deUint32 rgb = step*levelNdx; 155 deUint32 colorA = 0xff000000 | rgb; 156 deUint32 colorB = 0xff000000 | ~rgb; 157 158 m_textures[1]->getRefTexture().allocLevel(levelNdx); 159 tcu::fillWithGrid(m_textures[1]->getRefTexture().getLevel(levelNdx), 4, tcu::RGBA(colorA).toVec()*cScale + cBias, tcu::RGBA(colorB).toVec()*cScale + cBias); 160 } 161 162 // Upload. 163 for (std::vector<glu::Texture2D*>::iterator i = m_textures.begin(); i != m_textures.end(); i++) 164 (*i)->upload(); 165 } 166 } 167 catch (...) 168 { 169 // Clean up to save memory. 170 Texture2DFilteringCase::deinit(); 171 throw; 172 } 173} 174 175void Texture2DFilteringCase::deinit (void) 176{ 177 for (std::vector<glu::Texture2D*>::iterator i = m_textures.begin(); i != m_textures.end(); i++) 178 delete *i; 179 m_textures.clear(); 180 181 m_renderer.clear(); 182} 183 184Texture2DFilteringCase::IterateResult Texture2DFilteringCase::iterate (void) 185{ 186 const glw::Functions& gl = m_renderCtx.getFunctions(); 187 TestLog& log = m_testCtx.getLog(); 188 const int defViewportWidth = 256; 189 const int defViewportHeight = 256; 190 RandomViewport viewport (m_renderCtx.getRenderTarget(), defViewportWidth, defViewportHeight, deStringHash(getName())); 191 tcu::Surface renderedFrame (viewport.width, viewport.height); 192 tcu::Surface referenceFrame (viewport.width, viewport.height); 193 const tcu::TextureFormat& texFmt = m_textures[0]->getRefTexture().getFormat(); 194 tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(texFmt); 195 ReferenceParams refParams (TEXTURETYPE_2D); 196 vector<float> texCoord; 197 198 // Accuracy measurements are off unless viewport size is 256x256 199 if (viewport.width < defViewportWidth || viewport.height < defViewportHeight) 200 throw tcu::NotSupportedError("Too small viewport", "", __FILE__, __LINE__); 201 202 // Viewport is divided into 4 sections. 203 int leftWidth = viewport.width / 2; 204 int rightWidth = viewport.width - leftWidth; 205 int bottomHeight = viewport.height / 2; 206 int topHeight = viewport.height - bottomHeight; 207 208 int curTexNdx = 0; 209 210 // Use unit 0. 211 gl.activeTexture(GL_TEXTURE0); 212 213 // Bind gradient texture and setup sampler parameters. 214 gl.bindTexture(GL_TEXTURE_2D, m_textures[curTexNdx]->getGLTexture()); 215 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, m_wrapS); 216 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, m_wrapT); 217 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_minFilter); 218 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, m_magFilter); 219 220 // Setup params for reference. 221 refParams.sampler = glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, m_magFilter); 222 refParams.samplerType = getSamplerType(texFmt); 223 refParams.lodMode = LODMODE_EXACT; 224 refParams.colorBias = fmtInfo.lookupBias; 225 refParams.colorScale = fmtInfo.lookupScale; 226 227 // Bottom left: Minification 228 { 229 gl.viewport(viewport.x, viewport.y, leftWidth, bottomHeight); 230 231 computeQuadTexCoord2D(texCoord, tcu::Vec2(-4.0f, -4.5f), tcu::Vec2(4.0f, 2.5f)); 232 233 m_renderer.renderQuad(0, &texCoord[0], refParams); 234 sampleTexture(tcu::SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat(), 0, 0, leftWidth, bottomHeight), 235 m_textures[curTexNdx]->getRefTexture(), &texCoord[0], refParams); 236 } 237 238 // Bottom right: Magnification 239 { 240 gl.viewport(viewport.x+leftWidth, viewport.y, rightWidth, bottomHeight); 241 242 computeQuadTexCoord2D(texCoord, tcu::Vec2(-0.5f, 0.75f), tcu::Vec2(0.25f, 1.25f)); 243 244 m_renderer.renderQuad(0, &texCoord[0], refParams); 245 sampleTexture(tcu::SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat(), leftWidth, 0, rightWidth, bottomHeight), 246 m_textures[curTexNdx]->getRefTexture(), &texCoord[0], refParams); 247 } 248 249 if (m_textures.size() >= 2) 250 { 251 curTexNdx += 1; 252 253 // Setup second texture. 254 gl.bindTexture(GL_TEXTURE_2D, m_textures[curTexNdx]->getGLTexture()); 255 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, m_wrapS); 256 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, m_wrapT); 257 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_minFilter); 258 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, m_magFilter); 259 } 260 261 // Top left: Minification 262 // \note Minification is chosen so that 0.0 < lod <= 0.5. This way special minification threshold rule will be triggered. 263 { 264 gl.viewport(viewport.x, viewport.y+bottomHeight, leftWidth, topHeight); 265 266 float sMin = -0.5f; 267 float tMin = -0.2f; 268 float sRange = ((float)leftWidth * 1.2f) / (float)m_textures[curTexNdx]->getRefTexture().getWidth(); 269 float tRange = ((float)topHeight * 1.1f) / (float)m_textures[curTexNdx]->getRefTexture().getHeight(); 270 271 computeQuadTexCoord2D(texCoord, tcu::Vec2(sMin, tMin), tcu::Vec2(sMin+sRange, tMin+tRange)); 272 273 m_renderer.renderQuad(0, &texCoord[0], refParams); 274 sampleTexture(tcu::SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat(), 0, bottomHeight, leftWidth, topHeight), 275 m_textures[curTexNdx]->getRefTexture(), &texCoord[0], refParams); 276 } 277 278 // Top right: Magnification 279 { 280 gl.viewport(viewport.x+leftWidth, viewport.y+bottomHeight, rightWidth, topHeight); 281 282 computeQuadTexCoord2D(texCoord, tcu::Vec2(-0.5f, 0.75f), tcu::Vec2(0.25f, 1.25f)); 283 284 m_renderer.renderQuad(0, &texCoord[0], refParams); 285 sampleTexture(tcu::SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat(), leftWidth, bottomHeight, rightWidth, topHeight), 286 m_textures[curTexNdx]->getRefTexture(), &texCoord[0], refParams); 287 } 288 289 // Read result. 290 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess()); 291 292 // Compare and log. 293 { 294 const int bestScoreDiff = 16; 295 const int worstScoreDiff = 3200; 296 297 int score = measureAccuracy(log, referenceFrame, renderedFrame, bestScoreDiff, worstScoreDiff); 298 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, de::toString(score).c_str()); 299 } 300 301 return STOP; 302} 303 304class TextureCubeFilteringCase : public tcu::TestCase 305{ 306public: 307 TextureCubeFilteringCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, bool onlySampleFaceInterior, deUint32 internalFormat, int width, int height); 308 TextureCubeFilteringCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, bool onlySampleFaceInterior, const std::vector<std::string>& filenames); 309 ~TextureCubeFilteringCase (void); 310 311 void init (void); 312 void deinit (void); 313 IterateResult iterate (void); 314 315private: 316 TextureCubeFilteringCase (const TextureCubeFilteringCase& other); 317 TextureCubeFilteringCase& operator= (const TextureCubeFilteringCase& other); 318 319 glu::RenderContext& m_renderCtx; 320 const glu::ContextInfo& m_renderCtxInfo; 321 322 deUint32 m_minFilter; 323 deUint32 m_magFilter; 324 deUint32 m_wrapS; 325 deUint32 m_wrapT; 326 bool m_onlySampleFaceInterior; //!< If true, we avoid sampling anywhere near a face's edges. 327 328 deUint32 m_internalFormat; 329 int m_width; 330 int m_height; 331 332 std::vector<std::string> m_filenames; 333 334 std::vector<glu::TextureCube*> m_textures; 335 TextureRenderer m_renderer; 336}; 337 338TextureCubeFilteringCase::TextureCubeFilteringCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, bool onlySampleFaceInterior, deUint32 internalFormat, int width, int height) 339 : TestCase (testCtx, tcu::NODETYPE_ACCURACY, name, desc) 340 , m_renderCtx (renderCtx) 341 , m_renderCtxInfo (ctxInfo) 342 , m_minFilter (minFilter) 343 , m_magFilter (magFilter) 344 , m_wrapS (wrapS) 345 , m_wrapT (wrapT) 346 , m_onlySampleFaceInterior (onlySampleFaceInterior) 347 , m_internalFormat (internalFormat) 348 , m_width (width) 349 , m_height (height) 350 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 351{ 352} 353 354TextureCubeFilteringCase::TextureCubeFilteringCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const char* desc, deUint32 minFilter, deUint32 magFilter, deUint32 wrapS, deUint32 wrapT, bool onlySampleFaceInterior, const std::vector<std::string>& filenames) 355 : TestCase (testCtx, tcu::NODETYPE_ACCURACY, name, desc) 356 , m_renderCtx (renderCtx) 357 , m_renderCtxInfo (ctxInfo) 358 , m_minFilter (minFilter) 359 , m_magFilter (magFilter) 360 , m_wrapS (wrapS) 361 , m_wrapT (wrapT) 362 , m_onlySampleFaceInterior (onlySampleFaceInterior) 363 , m_internalFormat (GL_NONE) 364 , m_width (0) 365 , m_height (0) 366 , m_filenames (filenames) 367 , m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP) 368{ 369} 370 371TextureCubeFilteringCase::~TextureCubeFilteringCase (void) 372{ 373 deinit(); 374} 375 376void TextureCubeFilteringCase::init (void) 377{ 378 try 379 { 380 if (!m_filenames.empty()) 381 { 382 m_textures.reserve(1); 383 m_textures.push_back(glu::TextureCube::create(m_renderCtx, m_renderCtxInfo, m_testCtx.getArchive(), (int)m_filenames.size() / 6, m_filenames)); 384 } 385 else 386 { 387 m_textures.reserve(2); 388 DE_ASSERT(m_width == m_height); 389 for (int ndx = 0; ndx < 2; ndx++) 390 m_textures.push_back(new glu::TextureCube(m_renderCtx, m_internalFormat, m_width)); 391 392 const int numLevels = deLog2Floor32(de::max(m_width, m_height))+1; 393 tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(m_textures[0]->getRefTexture().getFormat()); 394 tcu::Vec4 cBias = fmtInfo.valueMin; 395 tcu::Vec4 cScale = fmtInfo.valueMax-fmtInfo.valueMin; 396 397 // Fill first with gradient texture. 398 static const tcu::Vec4 gradients[tcu::CUBEFACE_LAST][2] = 399 { 400 { tcu::Vec4(-1.0f, -1.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // negative x 401 { tcu::Vec4( 0.0f, -1.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // positive x 402 { tcu::Vec4(-1.0f, 0.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // negative y 403 { tcu::Vec4(-1.0f, -1.0f, 0.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) }, // positive y 404 { tcu::Vec4(-1.0f, -1.0f, -1.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f) }, // negative z 405 { tcu::Vec4( 0.0f, 0.0f, 0.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) } // positive z 406 }; 407 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 408 { 409 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 410 { 411 m_textures[0]->getRefTexture().allocLevel((tcu::CubeFace)face, levelNdx); 412 tcu::fillWithComponentGradients(m_textures[0]->getRefTexture().getLevelFace(levelNdx, (tcu::CubeFace)face), gradients[face][0]*cScale + cBias, gradients[face][1]*cScale + cBias); 413 } 414 } 415 416 // Fill second with grid texture. 417 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 418 { 419 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 420 { 421 deUint32 step = 0x00ffffff / (numLevels*tcu::CUBEFACE_LAST); 422 deUint32 rgb = step*levelNdx*face; 423 deUint32 colorA = 0xff000000 | rgb; 424 deUint32 colorB = 0xff000000 | ~rgb; 425 426 m_textures[1]->getRefTexture().allocLevel((tcu::CubeFace)face, levelNdx); 427 tcu::fillWithGrid(m_textures[1]->getRefTexture().getLevelFace(levelNdx, (tcu::CubeFace)face), 4, tcu::RGBA(colorA).toVec()*cScale + cBias, tcu::RGBA(colorB).toVec()*cScale + cBias); 428 } 429 } 430 431 if (m_magFilter == GL_LINEAR || m_minFilter == GL_LINEAR || m_minFilter == GL_LINEAR_MIPMAP_NEAREST || m_minFilter == GL_LINEAR_MIPMAP_LINEAR) 432 { 433 // Using seamless linear cube map filtering - set all corner texels to the same color, because cube corner sampling in this case is not very well defined by the spec. 434 // \todo Probably should also do this for cases where textures are loaded from files. 435 436 for (int texNdx = 0; texNdx < (int)m_textures.size(); texNdx++) 437 { 438 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 439 { 440 for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) 441 { 442 static const tcu::Vec4 color(0.0f, 0.0f, 0.0f, 1.0f); 443 tcu::PixelBufferAccess access = m_textures[texNdx]->getRefTexture().getLevelFace(levelNdx, (tcu::CubeFace)face); 444 445 access.setPixel(color, 0, 0); 446 access.setPixel(color, access.getWidth()-1, 0); 447 access.setPixel(color, 0, access.getHeight()-1); 448 access.setPixel(color, access.getWidth()-1, access.getHeight()-1); 449 } 450 } 451 } 452 } 453 454 // Upload. 455 for (std::vector<glu::TextureCube*>::iterator i = m_textures.begin(); i != m_textures.end(); i++) 456 (*i)->upload(); 457 } 458 } 459 catch (const std::exception&) 460 { 461 // Clean up to save memory. 462 TextureCubeFilteringCase::deinit(); 463 throw; 464 } 465} 466 467void TextureCubeFilteringCase::deinit (void) 468{ 469 for (std::vector<glu::TextureCube*>::iterator i = m_textures.begin(); i != m_textures.end(); i++) 470 delete *i; 471 m_textures.clear(); 472 473 m_renderer.clear(); 474} 475 476static void renderFaces ( 477 const glw::Functions& gl, 478 const tcu::SurfaceAccess& dstRef, 479 const tcu::TextureCube& refTexture, 480 const ReferenceParams& params, 481 TextureRenderer& renderer, 482 int x, 483 int y, 484 int width, 485 int height, 486 const tcu::Vec2& bottomLeft, 487 const tcu::Vec2& topRight, 488 const tcu::Vec2& texCoordTopRightFactor) 489{ 490 DE_ASSERT(width == dstRef.getWidth() && height == dstRef.getHeight()); 491 492 vector<float> texCoord; 493 494 DE_STATIC_ASSERT(tcu::CUBEFACE_LAST == 6); 495 for (int face = 0; face < tcu::CUBEFACE_LAST; face++) 496 { 497 bool isRightmost = (face == 2) || (face == 5); 498 bool isTop = face >= 3; 499 int curX = (face % 3) * (width / 3); 500 int curY = (face / 3) * (height / 2); 501 int curW = isRightmost ? (width-curX) : (width / 3); 502 int curH = isTop ? (height-curY) : (height / 2); 503 504 computeQuadTexCoordCube(texCoord, (tcu::CubeFace)face, bottomLeft, topRight); 505 506 { 507 // Move the top and right edges of the texture coord quad. This is useful when we want a cube edge visible. 508 int texCoordSRow = face == tcu::CUBEFACE_NEGATIVE_X || face == tcu::CUBEFACE_POSITIVE_X ? 2 : 0; 509 int texCoordTRow = face == tcu::CUBEFACE_NEGATIVE_Y || face == tcu::CUBEFACE_POSITIVE_Y ? 2 : 1; 510 texCoord[6 + texCoordSRow] *= texCoordTopRightFactor.x(); 511 texCoord[9 + texCoordSRow] *= texCoordTopRightFactor.x(); 512 texCoord[3 + texCoordTRow] *= texCoordTopRightFactor.y(); 513 texCoord[9 + texCoordTRow] *= texCoordTopRightFactor.y(); 514 } 515 516 gl.viewport(x+curX, y+curY, curW, curH); 517 518 renderer.renderQuad(0, &texCoord[0], params); 519 520 sampleTexture(tcu::SurfaceAccess(dstRef, curX, curY, curW, curH), refTexture, &texCoord[0], params); 521 } 522 523 GLU_EXPECT_NO_ERROR(gl.getError(), "Post render"); 524} 525 526TextureCubeFilteringCase::IterateResult TextureCubeFilteringCase::iterate (void) 527{ 528 const glw::Functions& gl = m_renderCtx.getFunctions(); 529 TestLog& log = m_testCtx.getLog(); 530 const int cellSize = 28; 531 const int defViewportWidth = cellSize*6; 532 const int defViewportHeight = cellSize*4; 533 RandomViewport viewport (m_renderCtx.getRenderTarget(), cellSize*6, cellSize*4, deStringHash(getName())); 534 tcu::Surface renderedFrame (viewport.width, viewport.height); 535 tcu::Surface referenceFrame (viewport.width, viewport.height); 536 ReferenceParams sampleParams (TEXTURETYPE_CUBE); 537 const tcu::TextureFormat& texFmt = m_textures[0]->getRefTexture().getFormat(); 538 tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(texFmt); 539 540 // Accuracy measurements are off unless viewport size is exactly as expected. 541 if (getNodeType() == tcu::NODETYPE_ACCURACY && (viewport.width < defViewportWidth || viewport.height < defViewportHeight)) 542 throw tcu::NotSupportedError("Too small viewport", "", __FILE__, __LINE__); 543 544 // Viewport is divided into 4 sections. 545 int leftWidth = viewport.width / 2; 546 int rightWidth = viewport.width - leftWidth; 547 int bottomHeight = viewport.height / 2; 548 int topHeight = viewport.height - bottomHeight; 549 550 int curTexNdx = 0; 551 552 // Sampling parameters. 553 sampleParams.sampler = glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, m_magFilter); 554 sampleParams.sampler.seamlessCubeMap = true; 555 sampleParams.samplerType = getSamplerType(texFmt); 556 sampleParams.colorBias = fmtInfo.lookupBias; 557 sampleParams.colorScale = fmtInfo.lookupScale; 558 sampleParams.lodMode = LODMODE_EXACT; 559 560 // Use unit 0. 561 gl.activeTexture(GL_TEXTURE0); 562 563 // Setup gradient texture. 564 gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_textures[curTexNdx]->getGLTexture()); 565 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, m_wrapS); 566 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, m_wrapT); 567 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, m_minFilter); 568 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, m_magFilter); 569 570 // Bottom left: Minification 571 renderFaces(gl, 572 tcu::SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat(), 0, 0, leftWidth, bottomHeight), 573 m_textures[curTexNdx]->getRefTexture(), sampleParams, 574 m_renderer, 575 viewport.x, viewport.y, leftWidth, bottomHeight, 576 m_onlySampleFaceInterior ? tcu::Vec2(-0.81f, -0.81f) : tcu::Vec2(-0.975f, -0.975f), 577 m_onlySampleFaceInterior ? tcu::Vec2( 0.8f, 0.8f) : tcu::Vec2( 0.975f, 0.975f), 578 !m_onlySampleFaceInterior ? tcu::Vec2(1.3f, 1.25f) : tcu::Vec2(1.0f, 1.0f)); 579 580 // Bottom right: Magnification 581 renderFaces(gl, 582 tcu::SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat(), leftWidth, 0, rightWidth, bottomHeight), 583 m_textures[curTexNdx]->getRefTexture(), sampleParams, 584 m_renderer, 585 viewport.x+leftWidth, viewport.y, rightWidth, bottomHeight, 586 tcu::Vec2(0.5f, 0.65f), m_onlySampleFaceInterior ? tcu::Vec2(0.8f, 0.8f) : tcu::Vec2(0.975f, 0.975f), 587 !m_onlySampleFaceInterior ? tcu::Vec2(1.1f, 1.06f) : tcu::Vec2(1.0f, 1.0f)); 588 589 if (m_textures.size() >= 2) 590 { 591 curTexNdx += 1; 592 593 // Setup second texture. 594 gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_textures[curTexNdx]->getGLTexture()); 595 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, m_wrapS); 596 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, m_wrapT); 597 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, m_minFilter); 598 gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, m_magFilter); 599 } 600 601 // Top left: Minification 602 renderFaces(gl, 603 tcu::SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat(), 0, bottomHeight, leftWidth, topHeight), 604 m_textures[curTexNdx]->getRefTexture(), sampleParams, 605 m_renderer, 606 viewport.x, viewport.y+bottomHeight, leftWidth, topHeight, 607 m_onlySampleFaceInterior ? tcu::Vec2(-0.81f, -0.81f) : tcu::Vec2(-0.975f, -0.975f), 608 m_onlySampleFaceInterior ? tcu::Vec2( 0.8f, 0.8f) : tcu::Vec2( 0.975f, 0.975f), 609 !m_onlySampleFaceInterior ? tcu::Vec2(1.3f, 1.25f) : tcu::Vec2(1.0f, 1.0f)); 610 611 // Top right: Magnification 612 renderFaces(gl, 613 tcu::SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat(), leftWidth, bottomHeight, rightWidth, topHeight), 614 m_textures[curTexNdx]->getRefTexture(), sampleParams, 615 m_renderer, 616 viewport.x+leftWidth, viewport.y+bottomHeight, rightWidth, topHeight, 617 tcu::Vec2(0.5f, -0.65f), m_onlySampleFaceInterior ? tcu::Vec2(0.8f, -0.8f) : tcu::Vec2(0.975f, -0.975f), 618 !m_onlySampleFaceInterior ? tcu::Vec2(1.1f, 1.06f) : tcu::Vec2(1.0f, 1.0f)); 619 620 // Read result. 621 glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess()); 622 623 // Compare and log. 624 { 625 const int bestScoreDiff = 16; 626 const int worstScoreDiff = 10000; 627 628 int score = measureAccuracy(log, referenceFrame, renderedFrame, bestScoreDiff, worstScoreDiff); 629 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, de::toString(score).c_str()); 630 } 631 632 return STOP; 633} 634 635TextureFilteringTests::TextureFilteringTests (Context& context) 636 : TestCaseGroup(context, "filter", "Texture Filtering Accuracy Tests") 637{ 638} 639 640TextureFilteringTests::~TextureFilteringTests (void) 641{ 642} 643 644void TextureFilteringTests::init (void) 645{ 646 tcu::TestCaseGroup* group2D = new tcu::TestCaseGroup(m_testCtx, "2d", "2D Texture Filtering"); 647 tcu::TestCaseGroup* groupCube = new tcu::TestCaseGroup(m_testCtx, "cube", "Cube Map Filtering"); 648 addChild(group2D); 649 addChild(groupCube); 650 651 static const struct 652 { 653 const char* name; 654 deUint32 mode; 655 } wrapModes[] = 656 { 657 { "clamp", GL_CLAMP_TO_EDGE }, 658 { "repeat", GL_REPEAT }, 659 { "mirror", GL_MIRRORED_REPEAT } 660 }; 661 662 static const struct 663 { 664 const char* name; 665 deUint32 mode; 666 } minFilterModes[] = 667 { 668 { "nearest", GL_NEAREST }, 669 { "linear", GL_LINEAR }, 670 { "nearest_mipmap_nearest", GL_NEAREST_MIPMAP_NEAREST }, 671 { "linear_mipmap_nearest", GL_LINEAR_MIPMAP_NEAREST }, 672 { "nearest_mipmap_linear", GL_NEAREST_MIPMAP_LINEAR }, 673 { "linear_mipmap_linear", GL_LINEAR_MIPMAP_LINEAR } 674 }; 675 676 static const struct 677 { 678 const char* name; 679 deUint32 mode; 680 } magFilterModes[] = 681 { 682 { "nearest", GL_NEAREST }, 683 { "linear", GL_LINEAR } 684 }; 685 686 static const struct 687 { 688 const char* name; 689 int width; 690 int height; 691 } sizes2D[] = 692 { 693 { "pot", 32, 64 }, 694 { "npot", 31, 55 } 695 }; 696 697 static const struct 698 { 699 const char* name; 700 int width; 701 int height; 702 } sizesCube[] = 703 { 704 { "pot", 64, 64 }, 705 { "npot", 63, 63 } 706 }; 707 708 static const struct 709 { 710 const char* name; 711 deUint32 format; 712 } formats[] = 713 { 714 { "rgba8", GL_RGBA8 } 715 }; 716 717#define FOR_EACH(ITERATOR, ARRAY, BODY) \ 718 for (int (ITERATOR) = 0; (ITERATOR) < DE_LENGTH_OF_ARRAY(ARRAY); (ITERATOR)++) \ 719 BODY 720 721 // 2D cases. 722 FOR_EACH(minFilter, minFilterModes, 723 FOR_EACH(magFilter, magFilterModes, 724 FOR_EACH(wrapMode, wrapModes, 725 FOR_EACH(format, formats, 726 FOR_EACH(size, sizes2D, 727 { 728 string name = string("") + minFilterModes[minFilter].name + "_" + magFilterModes[magFilter].name + "_" + wrapModes[wrapMode].name + "_" + formats[format].name + string("_") + sizes2D[size].name; 729 730 group2D->addChild(new Texture2DFilteringCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), 731 name.c_str(), "", 732 minFilterModes[minFilter].mode, 733 magFilterModes[magFilter].mode, 734 wrapModes[wrapMode].mode, 735 wrapModes[wrapMode].mode, 736 formats[format].format, 737 sizes2D[size].width, sizes2D[size].height)); 738 }))))); 739 740 // Cubemap cases. 741 FOR_EACH(minFilter, minFilterModes, 742 FOR_EACH(magFilter, magFilterModes, 743 FOR_EACH(wrapMode, wrapModes, 744 FOR_EACH(format, formats, 745 FOR_EACH(size, sizesCube, 746 { 747 string name = string("") + minFilterModes[minFilter].name + "_" + magFilterModes[magFilter].name + "_" + wrapModes[wrapMode].name + "_" + formats[format].name + string("_") + sizesCube[size].name; 748 749 groupCube->addChild(new TextureCubeFilteringCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), 750 name.c_str(), "", 751 minFilterModes[minFilter].mode, 752 magFilterModes[magFilter].mode, 753 wrapModes[wrapMode].mode, 754 wrapModes[wrapMode].mode, 755 false, 756 formats[format].format, 757 sizesCube[size].width, sizesCube[size].height)); 758 }))))); 759} 760 761} // Accuracy 762} // gles3 763} // deqp 764