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
RenderParamsdeqp::gls::TextureTestUtil::RenderParams106 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
toRGBAMasked(const tcu::Vec4 & v,deUint8 mask)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
toVec4(const tcu::RGBA & c)252 inline tcu::Vec4 toVec4 (const tcu::RGBA& c)
253 {
254 return c.toVec();
255 }
256
getColorMask(const tcu::PixelFormat & format)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
getBitsVec(const tcu::PixelFormat & format)265 inline tcu::IVec4 getBitsVec (const tcu::PixelFormat& format)
266 {
267 return tcu::IVec4(format.redBits, format.greenBits, format.blueBits, format.alphaBits);
268 }
269
getCompareMask(const tcu::PixelFormat & format)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
getWidth(void) const286 int getWidth (void) const { return m_width; }
getHeight(void) const287 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
setPixel(const tcu::Vec4 & color,int x,int y) const300 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 {
ReferenceParamsdeqp::gls::TextureTestUtil::ReferenceParams317 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
ReferenceParamsdeqp::gls::TextureTestUtil::ReferenceParams328 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 {
LogGradientFmtdeqp::gls::TextureTestUtil::LogGradientFmt555 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);
formatGradient(const tcu::Vec4 * minVal,const tcu::Vec4 * maxVal)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