1 #ifndef _GLSTEXTURETESTUTIL_HPP 2 #define _GLSTEXTURETESTUTIL_HPP 3 /*------------------------------------------------------------------------- 4 * drawElements Quality Program OpenGL (ES) Module 5 * ----------------------------------------------- 6 * 7 * Copyright 2014 The Android Open Source Project 8 * 9 * Licensed under the Apache License, Version 2.0 (the "License"); 10 * you may not use this file except in compliance with the License. 11 * You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 * 21 *//*! 22 * \file 23 * \brief Texture test utilities. 24 * 25 * About coordinates: 26 * + Quads consist of 2 triangles, rendered using explicit indices. 27 * + All TextureTestUtil functions and classes expect texture coordinates 28 * for quads to be specified in order (-1, -1), (-1, 1), (1, -1), (1, 1). 29 *//*--------------------------------------------------------------------*/ 30 31 #include "tcuDefs.hpp" 32 #include "tcuTexture.hpp" 33 #include "tcuSurface.hpp" 34 #include "tcuPixelFormat.hpp" 35 #include "tcuRenderTarget.hpp" 36 #include "tcuTestContext.hpp" 37 #include "deMath.h" 38 #include "deInt32.h" 39 #include "gluShaderProgram.hpp" 40 #include "tcuTestLog.hpp" 41 #include "tcuCompressedTexture.hpp" 42 #include "gluShaderUtil.hpp" 43 44 #include <map> 45 46 namespace tcu 47 { 48 struct LookupPrecision; 49 struct LodPrecision; 50 struct TexComparePrecision; 51 } 52 53 namespace deqp 54 { 55 namespace gls 56 { 57 namespace TextureTestUtil 58 { 59 60 enum TextureType 61 { 62 TEXTURETYPE_2D = 0, 63 TEXTURETYPE_CUBE, 64 TEXTURETYPE_2D_ARRAY, 65 TEXTURETYPE_3D, 66 TEXTURETYPE_CUBE_ARRAY, 67 TEXTURETYPE_1D, 68 TEXTURETYPE_1D_ARRAY, 69 TEXTURETYPE_BUFFER, 70 71 TEXTURETYPE_LAST 72 }; 73 74 enum SamplerType 75 { 76 SAMPLERTYPE_FLOAT, 77 SAMPLERTYPE_INT, 78 SAMPLERTYPE_UINT, 79 SAMPLERTYPE_SHADOW, 80 81 SAMPLERTYPE_FETCH_FLOAT, 82 SAMPLERTYPE_FETCH_INT, 83 SAMPLERTYPE_FETCH_UINT, 84 85 SAMPLERTYPE_LAST 86 }; 87 88 SamplerType getSamplerType (tcu::TextureFormat format); 89 SamplerType getFetchSamplerType (tcu::TextureFormat format); 90 91 struct RenderParams 92 { 93 enum Flags 94 { 95 PROJECTED = (1<<0), 96 USE_BIAS = (1<<1), 97 LOG_PROGRAMS = (1<<2), 98 LOG_UNIFORMS = (1<<3), 99 100 LOG_ALL = LOG_PROGRAMS|LOG_UNIFORMS 101 }; 102 103 RenderParams (TextureType texType_) 104 : texType (texType_) 105 , samplerType (SAMPLERTYPE_FLOAT) 106 , flags (0) 107 , w (1.0f) 108 , bias (0.0f) 109 , ref (0.0f) 110 , colorScale (1.0f) 111 , colorBias (0.0f) 112 { 113 } 114 115 TextureType texType; //!< Texture type. 116 SamplerType samplerType; //!< Sampler type. 117 deUint32 flags; //!< Feature flags. 118 tcu::Vec4 w; //!< w coordinates for quad vertices. 119 float bias; //!< User-supplied bias. 120 float ref; //!< Reference value for shadow lookups. 121 122 // color = lookup() * scale + bias 123 tcu::Vec4 colorScale; //!< Scale for texture color values. 124 tcu::Vec4 colorBias; //!< Bias for texture color values. 125 }; 126 127 enum Program 128 { 129 PROGRAM_2D_FLOAT = 0, 130 PROGRAM_2D_INT, 131 PROGRAM_2D_UINT, 132 PROGRAM_2D_SHADOW, 133 134 PROGRAM_2D_FLOAT_BIAS, 135 PROGRAM_2D_INT_BIAS, 136 PROGRAM_2D_UINT_BIAS, 137 PROGRAM_2D_SHADOW_BIAS, 138 139 PROGRAM_1D_FLOAT, 140 PROGRAM_1D_INT, 141 PROGRAM_1D_UINT, 142 PROGRAM_1D_SHADOW, 143 144 PROGRAM_1D_FLOAT_BIAS, 145 PROGRAM_1D_INT_BIAS, 146 PROGRAM_1D_UINT_BIAS, 147 PROGRAM_1D_SHADOW_BIAS, 148 149 PROGRAM_CUBE_FLOAT, 150 PROGRAM_CUBE_INT, 151 PROGRAM_CUBE_UINT, 152 PROGRAM_CUBE_SHADOW, 153 154 PROGRAM_CUBE_FLOAT_BIAS, 155 PROGRAM_CUBE_INT_BIAS, 156 PROGRAM_CUBE_UINT_BIAS, 157 PROGRAM_CUBE_SHADOW_BIAS, 158 159 PROGRAM_1D_ARRAY_FLOAT, 160 PROGRAM_1D_ARRAY_INT, 161 PROGRAM_1D_ARRAY_UINT, 162 PROGRAM_1D_ARRAY_SHADOW, 163 164 PROGRAM_2D_ARRAY_FLOAT, 165 PROGRAM_2D_ARRAY_INT, 166 PROGRAM_2D_ARRAY_UINT, 167 PROGRAM_2D_ARRAY_SHADOW, 168 169 PROGRAM_3D_FLOAT, 170 PROGRAM_3D_INT, 171 PROGRAM_3D_UINT, 172 173 PROGRAM_3D_FLOAT_BIAS, 174 PROGRAM_3D_INT_BIAS, 175 PROGRAM_3D_UINT_BIAS, 176 177 PROGRAM_CUBE_ARRAY_FLOAT, 178 PROGRAM_CUBE_ARRAY_INT, 179 PROGRAM_CUBE_ARRAY_UINT, 180 PROGRAM_CUBE_ARRAY_SHADOW, 181 182 PROGRAM_BUFFER_FLOAT, 183 PROGRAM_BUFFER_INT, 184 PROGRAM_BUFFER_UINT, 185 186 PROGRAM_LAST 187 }; 188 189 class ProgramLibrary 190 { 191 public: 192 ProgramLibrary (const glu::RenderContext& context, tcu::TestContext& testCtx, glu::GLSLVersion glslVersion, glu::Precision texCoordPrecision); 193 ~ProgramLibrary (void); 194 195 glu::ShaderProgram* getProgram (Program program); 196 void clear (void); 197 198 private: 199 ProgramLibrary (const ProgramLibrary& other); 200 ProgramLibrary& operator= (const ProgramLibrary& other); 201 202 const glu::RenderContext& m_context; 203 tcu::TestContext& m_testCtx; 204 glu::GLSLVersion m_glslVersion; 205 glu::Precision m_texCoordPrecision; 206 std::map<Program, glu::ShaderProgram*> m_programs; 207 }; 208 209 class TextureRenderer 210 { 211 public: 212 TextureRenderer (const glu::RenderContext& context, tcu::TestContext& testCtx, glu::GLSLVersion glslVersion, glu::Precision texCoordPrecision); 213 ~TextureRenderer (void); 214 215 void clear (void); //!< Frees allocated resources. Destructor will call clear() as well. 216 217 void renderQuad (int texUnit, const float* texCoord, TextureType texType); 218 void renderQuad (int texUnit, const float* texCoord, const RenderParams& params); 219 220 private: 221 TextureRenderer (const TextureRenderer& other); 222 TextureRenderer& operator= (const TextureRenderer& other); 223 224 const glu::RenderContext& m_renderCtx; 225 tcu::TestContext& m_testCtx; 226 ProgramLibrary m_programLibrary; 227 }; 228 229 class RandomViewport 230 { 231 public: 232 int x; 233 int y; 234 int width; 235 int height; 236 237 RandomViewport (const tcu::RenderTarget& renderTarget, int preferredWidth, int preferredHeight, deUint32 seed); 238 }; 239 240 inline tcu::RGBA toRGBA (const tcu::Vec4& v) 241 { 242 // \todo [2011-10-24 pyry] Rounding mode? 243 return tcu::RGBA(deClamp32(deRoundFloatToInt32(v.x()*255.0f), 0, 255), 244 deClamp32(deRoundFloatToInt32(v.y()*255.0f), 0, 255), 245 deClamp32(deRoundFloatToInt32(v.z()*255.0f), 0, 255), 246 deClamp32(deRoundFloatToInt32(v.w()*255.0f), 0, 255)); 247 } 248 249 inline tcu::RGBA toRGBAMasked (const tcu::Vec4& v, deUint8 mask) 250 { 251 // \todo [2011-10-24 pyry] Rounding mode? 252 return tcu::RGBA((mask&tcu::RGBA::RED_MASK) ? deClamp32(deRoundFloatToInt32(v.x()*255.0f), 0, 255) : 0, 253 (mask&tcu::RGBA::GREEN_MASK) ? deClamp32(deRoundFloatToInt32(v.y()*255.0f), 0, 255) : 0, 254 (mask&tcu::RGBA::BLUE_MASK) ? deClamp32(deRoundFloatToInt32(v.z()*255.0f), 0, 255) : 0, 255 (mask&tcu::RGBA::ALPHA_MASK) ? deClamp32(deRoundFloatToInt32(v.w()*255.0f), 0, 255) : 0xff); 256 } 257 258 inline tcu::Vec4 toVec4 (const tcu::RGBA& c) 259 { 260 return tcu::Vec4(c.getRed() / 255.0f, 261 c.getGreen() / 255.0f, 262 c.getBlue() / 255.0f, 263 c.getAlpha() / 255.0f); 264 } 265 266 inline deUint8 getColorMask (const tcu::PixelFormat& format) 267 { 268 return (format.redBits ? tcu::RGBA::RED_MASK : 0) | 269 (format.greenBits ? tcu::RGBA::GREEN_MASK : 0) | 270 (format.blueBits ? tcu::RGBA::BLUE_MASK : 0) | 271 (format.alphaBits ? tcu::RGBA::ALPHA_MASK : 0); 272 } 273 274 inline tcu::IVec4 getBitsVec (const tcu::PixelFormat& format) 275 { 276 return tcu::IVec4(format.redBits, format.greenBits, format.blueBits, format.alphaBits); 277 } 278 279 inline tcu::BVec4 getCompareMask (const tcu::PixelFormat& format) 280 { 281 return tcu::BVec4(format.redBits > 0, 282 format.greenBits > 0, 283 format.blueBits > 0, 284 format.alphaBits > 0); 285 } 286 287 // \todo [2012-02-09 pyry] Move to tcuSurfaceAccess? 288 class SurfaceAccess 289 { 290 public: 291 SurfaceAccess (tcu::Surface& surface, const tcu::PixelFormat& colorFmt); 292 SurfaceAccess (tcu::Surface& surface, const tcu::PixelFormat& colorFmt, int x, int y, int width, int height); 293 SurfaceAccess (const SurfaceAccess& parent, int x, int y, int width, int height); 294 295 int getWidth (void) const { return m_width; } 296 int getHeight (void) const { return m_height; } 297 298 void setPixel (const tcu::Vec4& color, int x, int y) const; 299 300 private: 301 mutable tcu::Surface* m_surface; 302 deUint8 m_colorMask; 303 int m_x; 304 int m_y; 305 int m_width; 306 int m_height; 307 }; 308 309 inline void SurfaceAccess::setPixel (const tcu::Vec4& color, int x, int y) const 310 { 311 DE_ASSERT(de::inBounds(x, 0, m_width) && de::inBounds(y, 0, m_height)); 312 m_surface->setPixel(m_x+x, m_y+y, toRGBAMasked(color, m_colorMask)); 313 } 314 315 enum LodMode 316 { 317 LODMODE_EXACT = 0, //!< Ideal lod computation. 318 LODMODE_MIN_BOUND, //!< Use estimation range minimum bound. 319 LODMODE_MAX_BOUND, //!< Use estimation range maximum bound. 320 321 LODMODE_LAST 322 }; 323 324 struct ReferenceParams : public RenderParams 325 { 326 ReferenceParams (TextureType texType_) 327 : RenderParams (texType_) 328 , sampler () 329 , lodMode (LODMODE_EXACT) 330 , minLod (-1000.0f) 331 , maxLod (1000.0f) 332 , baseLevel (0) 333 , maxLevel (1000) 334 { 335 } 336 337 ReferenceParams (TextureType texType_, const tcu::Sampler& sampler_, LodMode lodMode_ = LODMODE_EXACT) 338 : RenderParams (texType_) 339 , sampler (sampler_) 340 , lodMode (lodMode_) 341 , minLod (-1000.0f) 342 , maxLod (1000.0f) 343 , baseLevel (0) 344 , maxLevel (1000) 345 { 346 } 347 348 tcu::Sampler sampler; 349 LodMode lodMode; 350 float minLod; 351 float maxLod; 352 int baseLevel; 353 int maxLevel; 354 }; 355 356 void clear (const SurfaceAccess& dst, const tcu::Vec4& color); 357 358 // Similar to sampleTexture() except uses texelFetch. 359 void fetchTexture (const SurfaceAccess& dst, const tcu::ConstPixelBufferAccess& src, const float* texCoord, const tcu::Vec4& colorScale, const tcu::Vec4& colorBias); 360 361 void sampleTexture (const SurfaceAccess& dst, const tcu::Texture2DView& src, const float* texCoord, const ReferenceParams& params); 362 void sampleTexture (const SurfaceAccess& dst, const tcu::TextureCubeView& src, const float* texCoord, const ReferenceParams& params); 363 void sampleTextureMultiFace (const SurfaceAccess& dst, const tcu::TextureCubeView& src, const float* texCoord, const ReferenceParams& params); 364 void sampleTexture (const SurfaceAccess& dst, const tcu::Texture2DArrayView& src, const float* texCoord, const ReferenceParams& params); 365 void sampleTexture (const SurfaceAccess& dst, const tcu::Texture3DView& src, const float* texCoord, const ReferenceParams& params); 366 void sampleTexture (const SurfaceAccess& dst, const tcu::TextureCubeArrayView& src, const float* texCoord, const ReferenceParams& params); 367 void sampleTexture (const SurfaceAccess& dst, const tcu::Texture1DView& src, const float* texCoord, const ReferenceParams& params); 368 void sampleTexture (const SurfaceAccess& dst, const tcu::Texture1DArrayView& src, const float* texCoord, const ReferenceParams& params); 369 370 void computeQuadTexCoord1D (std::vector<float>& dst, float left, float right); 371 void computeQuadTexCoord1DArray (std::vector<float>& dst, int layerNdx, float left, float right); 372 void computeQuadTexCoord2D (std::vector<float>& dst, const tcu::Vec2& bottomLeft, const tcu::Vec2& topRight); 373 void computeQuadTexCoord2DArray (std::vector<float>& dst, int layerNdx, const tcu::Vec2& bottomLeft, const tcu::Vec2& topRight); 374 void computeQuadTexCoord3D (std::vector<float>& dst, const tcu::Vec3& p0, const tcu::Vec3& p1, const tcu::IVec3& dirSwz); 375 void computeQuadTexCoordCube (std::vector<float>& dst, tcu::CubeFace face); 376 void computeQuadTexCoordCube (std::vector<float>& dst, tcu::CubeFace face, const tcu::Vec2& bottomLeft, const tcu::Vec2& topRight); 377 void computeQuadTexCoordCubeArray (std::vector<float>& dst, tcu::CubeFace face, const tcu::Vec2& bottomLeft, const tcu::Vec2& topRight, const tcu::Vec2& layerRange); 378 379 bool compareImages (tcu::TestLog& log, const char* name, const char* desc, const tcu::Surface& reference, const tcu::Surface& rendered, tcu::RGBA threshold); 380 bool compareImages (tcu::TestLog& log, const tcu::Surface& reference, const tcu::Surface& rendered, tcu::RGBA threshold); 381 int measureAccuracy (tcu::TestLog& log, const tcu::Surface& reference, const tcu::Surface& rendered, int bestScoreDiff, int worstScoreDiff); 382 383 int computeTextureLookupDiff (const tcu::ConstPixelBufferAccess& result, 384 const tcu::ConstPixelBufferAccess& reference, 385 const tcu::PixelBufferAccess& errorMask, 386 const tcu::Texture1DView& src, 387 const float* texCoord, 388 const ReferenceParams& sampleParams, 389 const tcu::LookupPrecision& lookupPrec, 390 const tcu::LodPrecision& lodPrec, 391 qpWatchDog* watchDog); 392 393 int computeTextureLookupDiff (const tcu::ConstPixelBufferAccess& result, 394 const tcu::ConstPixelBufferAccess& reference, 395 const tcu::PixelBufferAccess& errorMask, 396 const tcu::Texture2DView& src, 397 const float* texCoord, 398 const ReferenceParams& sampleParams, 399 const tcu::LookupPrecision& lookupPrec, 400 const tcu::LodPrecision& lodPrec, 401 qpWatchDog* watchDog); 402 403 int computeTextureLookupDiff (const tcu::ConstPixelBufferAccess& result, 404 const tcu::ConstPixelBufferAccess& reference, 405 const tcu::PixelBufferAccess& errorMask, 406 const tcu::TextureCubeView& src, 407 const float* texCoord, 408 const ReferenceParams& sampleParams, 409 const tcu::LookupPrecision& lookupPrec, 410 const tcu::LodPrecision& lodPrec, 411 qpWatchDog* watchDog); 412 413 int computeTextureLookupDiff (const tcu::ConstPixelBufferAccess& result, 414 const tcu::ConstPixelBufferAccess& reference, 415 const tcu::PixelBufferAccess& errorMask, 416 const tcu::Texture1DArrayView& src, 417 const float* texCoord, 418 const ReferenceParams& sampleParams, 419 const tcu::LookupPrecision& lookupPrec, 420 const tcu::LodPrecision& lodPrec, 421 qpWatchDog* watchDog); 422 423 int computeTextureLookupDiff (const tcu::ConstPixelBufferAccess& result, 424 const tcu::ConstPixelBufferAccess& reference, 425 const tcu::PixelBufferAccess& errorMask, 426 const tcu::Texture2DArrayView& src, 427 const float* texCoord, 428 const ReferenceParams& sampleParams, 429 const tcu::LookupPrecision& lookupPrec, 430 const tcu::LodPrecision& lodPrec, 431 qpWatchDog* watchDog); 432 433 int computeTextureLookupDiff (const tcu::ConstPixelBufferAccess& result, 434 const tcu::ConstPixelBufferAccess& reference, 435 const tcu::PixelBufferAccess& errorMask, 436 const tcu::Texture3DView& src, 437 const float* texCoord, 438 const ReferenceParams& sampleParams, 439 const tcu::LookupPrecision& lookupPrec, 440 const tcu::LodPrecision& lodPrec, 441 qpWatchDog* watchDog); 442 443 int computeTextureLookupDiff (const tcu::ConstPixelBufferAccess& result, 444 const tcu::ConstPixelBufferAccess& reference, 445 const tcu::PixelBufferAccess& errorMask, 446 const tcu::TextureCubeArrayView& src, 447 const float* texCoord, 448 const ReferenceParams& sampleParams, 449 const tcu::LookupPrecision& lookupPrec, 450 const tcu::IVec4& coordBits, 451 const tcu::LodPrecision& lodPrec, 452 qpWatchDog* watchDog); 453 454 bool verifyTextureResult (tcu::TestContext& testCtx, 455 const tcu::ConstPixelBufferAccess& result, 456 const tcu::Texture1DView& src, 457 const float* texCoord, 458 const ReferenceParams& sampleParams, 459 const tcu::LookupPrecision& lookupPrec, 460 const tcu::LodPrecision& lodPrec, 461 const tcu::PixelFormat& pixelFormat); 462 463 bool verifyTextureResult (tcu::TestContext& testCtx, 464 const tcu::ConstPixelBufferAccess& result, 465 const tcu::Texture2DView& src, 466 const float* texCoord, 467 const ReferenceParams& sampleParams, 468 const tcu::LookupPrecision& lookupPrec, 469 const tcu::LodPrecision& lodPrec, 470 const tcu::PixelFormat& pixelFormat); 471 472 bool verifyTextureResult (tcu::TestContext& testCtx, 473 const tcu::ConstPixelBufferAccess& result, 474 const tcu::TextureCubeView& src, 475 const float* texCoord, 476 const ReferenceParams& sampleParams, 477 const tcu::LookupPrecision& lookupPrec, 478 const tcu::LodPrecision& lodPrec, 479 const tcu::PixelFormat& pixelFormat); 480 481 bool verifyTextureResult (tcu::TestContext& testCtx, 482 const tcu::ConstPixelBufferAccess& result, 483 const tcu::Texture1DArrayView& src, 484 const float* texCoord, 485 const ReferenceParams& sampleParams, 486 const tcu::LookupPrecision& lookupPrec, 487 const tcu::LodPrecision& lodPrec, 488 const tcu::PixelFormat& pixelFormat); 489 490 bool verifyTextureResult (tcu::TestContext& testCtx, 491 const tcu::ConstPixelBufferAccess& result, 492 const tcu::Texture2DArrayView& src, 493 const float* texCoord, 494 const ReferenceParams& sampleParams, 495 const tcu::LookupPrecision& lookupPrec, 496 const tcu::LodPrecision& lodPrec, 497 const tcu::PixelFormat& pixelFormat); 498 499 bool verifyTextureResult (tcu::TestContext& testCtx, 500 const tcu::ConstPixelBufferAccess& result, 501 const tcu::Texture3DView& src, 502 const float* texCoord, 503 const ReferenceParams& sampleParams, 504 const tcu::LookupPrecision& lookupPrec, 505 const tcu::LodPrecision& lodPrec, 506 const tcu::PixelFormat& pixelFormat); 507 508 bool verifyTextureResult (tcu::TestContext& testCtx, 509 const tcu::ConstPixelBufferAccess& result, 510 const tcu::TextureCubeArrayView& src, 511 const float* texCoord, 512 const ReferenceParams& sampleParams, 513 const tcu::LookupPrecision& lookupPrec, 514 const tcu::IVec4& coordBits, 515 const tcu::LodPrecision& lodPrec, 516 const tcu::PixelFormat& pixelFormat); 517 518 int computeTextureCompareDiff (const tcu::ConstPixelBufferAccess& result, 519 const tcu::ConstPixelBufferAccess& reference, 520 const tcu::PixelBufferAccess& errorMask, 521 const tcu::Texture2DView& src, 522 const float* texCoord, 523 const ReferenceParams& sampleParams, 524 const tcu::TexComparePrecision& comparePrec, 525 const tcu::LodPrecision& lodPrec, 526 const tcu::Vec3& nonShadowThreshold); 527 528 int computeTextureCompareDiff (const tcu::ConstPixelBufferAccess& result, 529 const tcu::ConstPixelBufferAccess& reference, 530 const tcu::PixelBufferAccess& errorMask, 531 const tcu::TextureCubeView& src, 532 const float* texCoord, 533 const ReferenceParams& sampleParams, 534 const tcu::TexComparePrecision& comparePrec, 535 const tcu::LodPrecision& lodPrec, 536 const tcu::Vec3& nonShadowThreshold); 537 538 int computeTextureCompareDiff (const tcu::ConstPixelBufferAccess& result, 539 const tcu::ConstPixelBufferAccess& reference, 540 const tcu::PixelBufferAccess& errorMask, 541 const tcu::Texture2DArrayView& src, 542 const float* texCoord, 543 const ReferenceParams& sampleParams, 544 const tcu::TexComparePrecision& comparePrec, 545 const tcu::LodPrecision& lodPrec, 546 const tcu::Vec3& nonShadowThreshold); 547 548 // Mipmap generation comparison. 549 550 struct GenMipmapPrecision 551 { 552 tcu::IVec3 filterBits; //!< Bits in filtering parameters (fixed-point). 553 tcu::Vec4 colorThreshold; //!< Threshold for color value comparison. 554 tcu::BVec4 colorMask; //!< Color channel comparison mask. 555 }; 556 557 qpTestResult compareGenMipmapResult (tcu::TestLog& log, const tcu::Texture2D& resultTexture, const tcu::Texture2D& level0Reference, const GenMipmapPrecision& precision); 558 qpTestResult compareGenMipmapResult (tcu::TestLog& log, const tcu::TextureCube& resultTexture, const tcu::TextureCube& level0Reference, const GenMipmapPrecision& precision); 559 560 // Utility for logging texture gradient ranges. 561 struct LogGradientFmt 562 { 563 LogGradientFmt (const tcu::Vec4* min_, const tcu::Vec4* max_) : valueMin(min_), valueMax(max_) {} 564 const tcu::Vec4* valueMin; 565 const tcu::Vec4* valueMax; 566 }; 567 568 std::ostream& operator<< (std::ostream& str, const LogGradientFmt& fmt); 569 inline LogGradientFmt formatGradient (const tcu::Vec4* minVal, const tcu::Vec4* maxVal) { return LogGradientFmt(minVal, maxVal); } 570 571 } // TextureTestUtil 572 } // gls 573 } // deqp 574 575 #endif // _GLSTEXTURETESTUTIL_HPP 576
