glsTextureTestUtil.hpp revision c8e526bfc2141e1cb7a269483fb55dc2a8e77c11 
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
49namespace tcu
50{
51struct LookupPrecision;
52struct LodPrecision;
53struct TexComparePrecision;
54}
55
56namespace deqp
57{
58namespace gls
59{
60namespace TextureTestUtil
61{
62
63enum 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
77enum 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
91SamplerType		getSamplerType		(tcu::TextureFormat format);
92SamplerType		getFetchSamplerType	(tcu::TextureFormat format);
93
94struct 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
130enum 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
192class ProgramLibrary
193{
194public:
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
201private:
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
212class TextureRenderer
213{
214public:
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
223private:
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
232class RandomViewport
233{
234public:
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
243inline 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
251inline 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
259inline 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
267inline deUint8 getColorMask (const tcu::PixelFormat& format)
268{
269	return (deUint8)((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
275inline tcu::IVec4 getBitsVec (const tcu::PixelFormat& format)
276{
277	return tcu::IVec4(format.redBits, format.greenBits, format.blueBits, format.alphaBits);
278}
279
280inline 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?
289class SurfaceAccess
290{
291public:
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
301private:
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
310inline 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
316enum 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
325struct 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
357void			clear						(const SurfaceAccess& dst, const tcu::Vec4& color);
358
359// Similar to sampleTexture() except uses texelFetch.
360void			fetchTexture				(const SurfaceAccess& dst, const tcu::ConstPixelBufferAccess& src, const float* texCoord, const tcu::Vec4& colorScale, const tcu::Vec4& colorBias);
361
362void			sampleTexture				(const SurfaceAccess& dst, const tcu::Texture2DView&		src, const float* texCoord, const ReferenceParams& params);
363void			sampleTexture				(const SurfaceAccess& dst, const tcu::TextureCubeView&		src, const float* texCoord, const ReferenceParams& params);
364void			sampleTexture				(const SurfaceAccess& dst, const tcu::Texture2DArrayView&	src, const float* texCoord, const ReferenceParams& params);
365void			sampleTexture				(const SurfaceAccess& dst, const tcu::Texture3DView&		src, const float* texCoord, const ReferenceParams& params);
366void			sampleTexture				(const SurfaceAccess& dst, const tcu::TextureCubeArrayView&	src, const float* texCoord, const ReferenceParams& params);
367void			sampleTexture				(const SurfaceAccess& dst, const tcu::Texture1DView&		src, const float* texCoord, const ReferenceParams& params);
368void			sampleTexture				(const SurfaceAccess& dst, const tcu::Texture1DArrayView&	src, const float* texCoord, const ReferenceParams& params);
369
370void			computeQuadTexCoord1D			(std::vector<float>& dst, float left, float right);
371void			computeQuadTexCoord1DArray		(std::vector<float>& dst, int layerNdx, float left, float right);
372void			computeQuadTexCoord2D			(std::vector<float>& dst, const tcu::Vec2& bottomLeft, const tcu::Vec2& topRight);
373void			computeQuadTexCoord2DArray		(std::vector<float>& dst, int layerNdx, const tcu::Vec2& bottomLeft, const tcu::Vec2& topRight);
374void			computeQuadTexCoord3D			(std::vector<float>& dst, const tcu::Vec3& p0, const tcu::Vec3& p1, const tcu::IVec3& dirSwz);
375void			computeQuadTexCoordCube			(std::vector<float>& dst, tcu::CubeFace face);
376void			computeQuadTexCoordCube			(std::vector<float>& dst, tcu::CubeFace face, const tcu::Vec2& bottomLeft, const tcu::Vec2& topRight);
377void			computeQuadTexCoordCubeArray	(std::vector<float>& dst, tcu::CubeFace face, const tcu::Vec2& bottomLeft, const tcu::Vec2& topRight, const tcu::Vec2& layerRange);
378
379bool			compareImages				(tcu::TestLog& log, const char* name, const char* desc, const tcu::Surface& reference, const tcu::Surface& rendered, tcu::RGBA threshold);
380bool			compareImages				(tcu::TestLog& log, const tcu::Surface& reference, const tcu::Surface& rendered, tcu::RGBA threshold);
381int				measureAccuracy				(tcu::TestLog& log, const tcu::Surface& reference, const tcu::Surface& rendered, int bestScoreDiff, int worstScoreDiff);
382
383int				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
393int				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
403int				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
413int				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
423int				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
433int				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
443int				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
454bool			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
463bool			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
472bool			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
481bool			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
490bool			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
499bool			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
508bool			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
518int				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
528int				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
538int				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
550struct 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
557qpTestResult	compareGenMipmapResult		(tcu::TestLog& log, const tcu::Texture2D& resultTexture, const tcu::Texture2D& level0Reference, const GenMipmapPrecision& precision);
558qpTestResult	compareGenMipmapResult		(tcu::TestLog& log, const tcu::TextureCube& resultTexture, const tcu::TextureCube& level0Reference, const GenMipmapPrecision& precision);
559
560// Utility for logging texture gradient ranges.
561struct 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
568std::ostream&			operator<<		(std::ostream& str, const LogGradientFmt& fmt);
569inline 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