modules/glshared/glsTextureTestUtil.hpp

   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 toRGBA (const tcu::Vec4& v)
 244 {
 245         return tcu::RGBA(tcu::floatToU8(v.x()),
 246                                          tcu::floatToU8(v.y()),
 247                                          tcu::floatToU8(v.z()),
 248                                          tcu::floatToU8(v.w()));
 249 }
 250
 251 inline tcu::RGBA toRGBAMasked (const tcu::Vec4& v, deUint8 mask)
 252 {
 253         return tcu::RGBA((mask&tcu::RGBA::RED_MASK)             ? tcu::floatToU8(v.x()) : 0,
 254                                          (mask&tcu::RGBA::GREEN_MASK)   ? tcu::floatToU8(v.y()) : 0,
 255                                          (mask&tcu::RGBA::BLUE_MASK)    ? tcu::floatToU8(v.z()) : 0,
 256                                          (mask&tcu::RGBA::ALPHA_MASK)   ? tcu::floatToU8(v.w()) : 0xFF); //!< \note Alpha defaults to full saturation when reading masked format
 257 }
 258
 259 inline tcu::Vec4 toVec4 (const tcu::RGBA& c)
 260 {
 261         return tcu::Vec4(c.getRed()             / 255.0f,
 262                                          c.getGreen()   / 255.0f,
 263                                          c.getBlue()    / 255.0f,
 264                                          c.getAlpha()   / 255.0f);
 265 }
 266
 267 inline deUint8 getColorMask (const tcu::PixelFormat& format)
 268 {
 269         return (format.redBits          ? tcu::RGBA::RED_MASK   : 0) |
 270                    (format.greenBits    ? tcu::RGBA::GREEN_MASK : 0) |
 271                    (format.blueBits             ? tcu::RGBA::BLUE_MASK  : 0) |
 272                    (format.alphaBits    ? tcu::RGBA::ALPHA_MASK : 0);
 273 }
 274
 275 inline tcu::IVec4 getBitsVec (const tcu::PixelFormat& format)
 276 {
 277         return tcu::IVec4(format.redBits, format.greenBits, format.blueBits, format.alphaBits);
 278 }
 279
 280 inline tcu::BVec4 getCompareMask (const tcu::PixelFormat& format)
 281 {
 282         return tcu::BVec4(format.redBits        > 0,
 283                                           format.greenBits      > 0,
 284                                           format.blueBits       > 0,
 285                                           format.alphaBits      > 0);
 286 }
 287
 288 // \todo [2012-02-09 pyry] Move to tcuSurfaceAccess?
 289 class SurfaceAccess
 290 {
 291 public:
 292                                                         SurfaceAccess           (tcu::Surface& surface, const tcu::PixelFormat& colorFmt);
 293                                                         SurfaceAccess           (tcu::Surface& surface, const tcu::PixelFormat& colorFmt, int x, int y, int width, int height);
 294                                                         SurfaceAccess           (const SurfaceAccess& parent, int x, int y, int width, int height);
 295
 296         int                                             getWidth                        (void) const    { return m_width;       }
 297         int                                             getHeight                       (void) const    { return m_height;      }
 298
 299         void                                    setPixel                        (const tcu::Vec4& color, int x, int y) const;
 300
 301 private:
 302         mutable tcu::Surface*   m_surface;
 303         deUint8                                 m_colorMask;
 304         int                                             m_x;
 305         int                                             m_y;
 306         int                                             m_width;
 307         int                                             m_height;
 308 };
 309
 310 inline void SurfaceAccess::setPixel (const tcu::Vec4& color, int x, int y) const
 311 {
 312         DE_ASSERT(de::inBounds(x, 0, m_width) && de::inBounds(y, 0, m_height));
 313         m_surface->setPixel(m_x+x, m_y+y, toRGBAMasked(color, m_colorMask));
 314 }
 315
 316 enum LodMode
 317 {
 318         LODMODE_EXACT = 0,              //!< Ideal lod computation.
 319         LODMODE_MIN_BOUND,              //!< Use estimation range minimum bound.
 320         LODMODE_MAX_BOUND,              //!< Use estimation range maximum bound.
 321
 322         LODMODE_LAST
 323 };
 324
 325 struct ReferenceParams : public RenderParams
 326 {
 327         ReferenceParams (TextureType texType_)
 328                 : RenderParams  (texType_)
 329                 , sampler               ()
 330                 , lodMode               (LODMODE_EXACT)
 331                 , minLod                (-1000.0f)
 332                 , maxLod                (1000.0f)
 333                 , baseLevel             (0)
 334                 , maxLevel              (1000)
 335         {
 336         }
 337
 338         ReferenceParams (TextureType texType_, const tcu::Sampler& sampler_, LodMode lodMode_ = LODMODE_EXACT)
 339                 : RenderParams  (texType_)
 340                 , sampler               (sampler_)
 341                 , lodMode               (lodMode_)
 342                 , minLod                (-1000.0f)
 343                 , maxLod                (1000.0f)
 344                 , baseLevel             (0)
 345                 , maxLevel              (1000)
 346         {
 347         }
 348
 349         tcu::Sampler            sampler;
 350         LodMode                         lodMode;
 351         float                           minLod;
 352         float                           maxLod;
 353         int                                     baseLevel;
 354         int                                     maxLevel;
 355 };
 356
 357 void                    clear                                           (const SurfaceAccess& dst, const tcu::Vec4& color);
 358
 359 // Similar to sampleTexture() except uses texelFetch.
 360 void                    fetchTexture                            (const SurfaceAccess& dst, const tcu::ConstPixelBufferAccess& src, const float* texCoord, const tcu::Vec4& colorScale, const tcu::Vec4& colorBias);
 361
 362 void                    sampleTexture                           (const SurfaceAccess& dst, const tcu::Texture2DView&            src, const float* texCoord, const ReferenceParams& params);
 363 void                    sampleTexture                           (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