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