1/*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 2.0 Module
3 * -------------------------------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 *      http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Mipmapping accuracy tests.
22 *//*--------------------------------------------------------------------*/
23
24#include "es2aTextureMipmapTests.hpp"
25#include "glsTextureTestUtil.hpp"
26#include "gluTexture.hpp"
27#include "gluStrUtil.hpp"
28#include "gluTextureUtil.hpp"
29#include "gluPixelTransfer.hpp"
30#include "tcuTestLog.hpp"
31#include "tcuTextureUtil.hpp"
32#include "tcuVector.hpp"
33#include "tcuMatrix.hpp"
34#include "tcuMatrixUtil.hpp"
35#include "deStringUtil.hpp"
36#include "deRandom.hpp"
37
38#include "glwEnums.hpp"
39#include "glwFunctions.hpp"
40
41namespace deqp
42{
43namespace gles2
44{
45namespace Accuracy
46{
47
48using tcu::TestLog;
49using std::vector;
50using std::string;
51using tcu::Sampler;
52using tcu::Vec2;
53using tcu::Mat2;
54using tcu::Vec4;
55using tcu::IVec2;
56using tcu::IVec4;
57using namespace glu;
58using namespace gls::TextureTestUtil;
59
60enum CoordType
61{
62	COORDTYPE_BASIC,		//!< texCoord = translateScale(position).
63	COORDTYPE_BASIC_BIAS,	//!< Like basic, but with bias values.
64	COORDTYPE_AFFINE,		//!< texCoord = translateScaleRotateShear(position).
65	COORDTYPE_PROJECTED,	//!< Projected coordinates, w != 1
66
67	COORDTYPE_LAST
68};
69
70// Texture2DMipmapCase
71
72class Texture2DMipmapCase : public tcu::TestCase
73{
74public:
75
76								Texture2DMipmapCase			(tcu::TestContext&			testCtx,
77															 glu::RenderContext&		renderCtx,
78															 const glu::ContextInfo&	renderCtxInfo,
79															 const char*				name,
80															 const char*				desc,
81															 CoordType					coordType,
82															 deUint32					minFilter,
83															 deUint32					wrapS,
84															 deUint32					wrapT,
85															 deUint32					format,
86															 deUint32					dataType,
87															 int						width,
88															 int						height);
89								~Texture2DMipmapCase		(void);
90
91	void						init						(void);
92	void						deinit						(void);
93	IterateResult				iterate						(void);
94
95private:
96								Texture2DMipmapCase			(const Texture2DMipmapCase& other);
97	Texture2DMipmapCase&		operator=					(const Texture2DMipmapCase& other);
98
99	glu::RenderContext&			m_renderCtx;
100	const glu::ContextInfo&		m_renderCtxInfo;
101
102	CoordType					m_coordType;
103	deUint32					m_minFilter;
104	deUint32					m_wrapS;
105	deUint32					m_wrapT;
106	deUint32					m_format;
107	deUint32					m_dataType;
108	int							m_width;
109	int							m_height;
110
111	glu::Texture2D*				m_texture;
112	TextureRenderer				m_renderer;
113};
114
115Texture2DMipmapCase::Texture2DMipmapCase (tcu::TestContext&			testCtx,
116										  glu::RenderContext&		renderCtx,
117										  const glu::ContextInfo&	renderCtxInfo,
118										  const char*				name,
119										  const char*				desc,
120										  CoordType					coordType,
121										  deUint32					minFilter,
122										  deUint32					wrapS,
123										  deUint32					wrapT,
124										  deUint32					format,
125										  deUint32					dataType,
126										  int						width,
127										  int						height)
128	: TestCase			(testCtx, tcu::NODETYPE_ACCURACY, name, desc)
129	, m_renderCtx		(renderCtx)
130	, m_renderCtxInfo	(renderCtxInfo)
131	, m_coordType		(coordType)
132	, m_minFilter		(minFilter)
133	, m_wrapS			(wrapS)
134	, m_wrapT			(wrapT)
135	, m_format			(format)
136	, m_dataType		(dataType)
137	, m_width			(width)
138	, m_height			(height)
139	, m_texture			(DE_NULL)
140	, m_renderer		(renderCtx, testCtx, glu::GLSL_VERSION_100_ES,
141						 renderCtxInfo.isFragmentHighPrecisionSupported() ? glu::PRECISION_HIGHP // Use highp if available.
142																		  : glu::PRECISION_MEDIUMP)
143{
144}
145
146Texture2DMipmapCase::~Texture2DMipmapCase (void)
147{
148	deinit();
149}
150
151void Texture2DMipmapCase::init (void)
152{
153	if (!m_renderCtxInfo.isFragmentHighPrecisionSupported())
154		m_testCtx.getLog() << TestLog::Message << "Warning: High precision not supported in fragment shaders." << TestLog::EndMessage;
155
156	m_texture = new Texture2D(m_renderCtx, m_format, m_dataType, m_width, m_height);
157
158	int numLevels = deLog2Floor32(de::max(m_width, m_height))+1;
159
160	// Fill texture with colored grid.
161	for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
162	{
163		deUint32	step		= 0xff / (numLevels-1);
164		deUint32	inc			= deClamp32(step*levelNdx, 0x00, 0xff);
165		deUint32	dec			= 0xff - inc;
166		deUint32	rgb			= (inc << 16) | (dec << 8) | 0xff;
167		deUint32	color		= 0xff000000 | rgb;
168
169		m_texture->getRefTexture().allocLevel(levelNdx);
170		tcu::clear(m_texture->getRefTexture().getLevel(levelNdx), toVec4(tcu::RGBA(color)));
171	}
172}
173
174void Texture2DMipmapCase::deinit (void)
175{
176	delete m_texture;
177	m_texture = DE_NULL;
178
179	m_renderer.clear();
180}
181
182static void getBasicTexCoord2D (std::vector<float>& dst, int cellNdx)
183{
184	static const struct
185	{
186		Vec2 bottomLeft;
187		Vec2 topRight;
188	} s_basicCoords[] =
189	{
190		{ Vec2(-0.1f,  0.1f), Vec2( 0.8f,  1.0f) },
191		{ Vec2(-0.3f, -0.6f), Vec2( 0.7f,  0.4f) },
192		{ Vec2(-0.3f,  0.6f), Vec2( 0.7f, -0.9f) },
193		{ Vec2(-0.8f,  0.6f), Vec2( 0.7f, -0.9f) },
194
195		{ Vec2(-0.5f, -0.5f), Vec2( 1.5f,  1.5f) },
196		{ Vec2( 1.0f, -1.0f), Vec2(-1.3f,  1.0f) },
197		{ Vec2( 1.2f, -1.0f), Vec2(-1.3f,  1.6f) },
198		{ Vec2( 2.2f, -1.1f), Vec2(-1.3f,  0.8f) },
199
200		{ Vec2(-1.5f,  1.6f), Vec2( 1.7f, -1.4f) },
201		{ Vec2( 2.0f,  1.6f), Vec2( 2.3f, -1.4f) },
202		{ Vec2( 1.3f, -2.6f), Vec2(-2.7f,  2.9f) },
203		{ Vec2(-0.8f, -6.6f), Vec2( 6.0f, -0.9f) },
204
205		{ Vec2( -8.0f,   9.0f), Vec2(  8.3f,  -7.0f) },
206		{ Vec2(-16.0f,  10.0f), Vec2( 18.3f,  24.0f) },
207		{ Vec2( 30.2f,  55.0f), Vec2(-24.3f,  -1.6f) },
208		{ Vec2(-33.2f,  64.1f), Vec2( 32.1f, -64.1f) },
209	};
210
211	DE_ASSERT(de::inBounds(cellNdx, 0, DE_LENGTH_OF_ARRAY(s_basicCoords)));
212
213	const Vec2& bottomLeft	= s_basicCoords[cellNdx].bottomLeft;
214	const Vec2& topRight	= s_basicCoords[cellNdx].topRight;
215
216	computeQuadTexCoord2D(dst, bottomLeft, topRight);
217}
218
219static void getAffineTexCoord2D (std::vector<float>& dst, int cellNdx)
220{
221	// Use basic coords as base.
222	getBasicTexCoord2D(dst, cellNdx);
223
224	// Rotate based on cell index.
225	float		angle		= 2.0f*DE_PI * ((float)cellNdx / 16.0f);
226	tcu::Mat2	rotMatrix	= tcu::rotationMatrix(angle);
227
228	// Second and third row are sheared.
229	float		shearX		= de::inRange(cellNdx, 4, 11) ? (float)(15-cellNdx) / 16.0f : 0.0f;
230	tcu::Mat2	shearMatrix	= tcu::shearMatrix(tcu::Vec2(shearX, 0.0f));
231
232	tcu::Mat2	transform	= rotMatrix * shearMatrix;
233	Vec2		p0			= transform * Vec2(dst[0], dst[1]);
234	Vec2		p1			= transform * Vec2(dst[2], dst[3]);
235	Vec2		p2			= transform * Vec2(dst[4], dst[5]);
236	Vec2		p3			= transform * Vec2(dst[6], dst[7]);
237
238	dst[0] = p0.x();	dst[1] = p0.y();
239	dst[2] = p1.x();	dst[3] = p1.y();
240	dst[4] = p2.x();	dst[5] = p2.y();
241	dst[6] = p3.x();	dst[7] = p3.y();
242}
243
244Texture2DMipmapCase::IterateResult Texture2DMipmapCase::iterate (void)
245{
246	// Constants.
247	const deUint32				magFilter			= GL_NEAREST;
248
249	const glw::Functions&		gl					= m_renderCtx.getFunctions();
250	TestLog&					log					= m_testCtx.getLog();
251
252	const tcu::Texture2D&		refTexture			= m_texture->getRefTexture();
253	const tcu::TextureFormat&	texFmt				= refTexture.getFormat();
254	tcu::TextureFormatInfo		fmtInfo				= tcu::getTextureFormatInfo(texFmt);
255
256	int							texWidth			= refTexture.getWidth();
257	int							texHeight			= refTexture.getHeight();
258	int							defViewportWidth	= texWidth*4;
259	int							defViewportHeight	= texHeight*4;
260
261	RandomViewport				viewport			(m_renderCtx.getRenderTarget(), defViewportWidth, defViewportHeight, deStringHash(getName()));
262	ReferenceParams				sampleParams		(TEXTURETYPE_2D);
263	vector<float>				texCoord;
264	bool						isProjected			= m_coordType == COORDTYPE_PROJECTED;
265	bool						useLodBias			= m_coordType == COORDTYPE_BASIC_BIAS;
266
267	tcu::Surface				renderedFrame		(viewport.width, viewport.height);
268
269	// Accuracy cases test against ideal lod computation.
270	tcu::Surface				idealFrame			(viewport.width, viewport.height);
271
272	// Viewport is divided into 4x4 grid.
273	int							gridWidth			= 4;
274	int							gridHeight			= 4;
275	int							cellWidth			= viewport.width / gridWidth;
276	int							cellHeight			= viewport.height / gridHeight;
277
278	// Accuracy measurements are off unless we get the expected viewport size.
279	if (viewport.width < defViewportWidth || viewport.height < defViewportHeight)
280		throw tcu::NotSupportedError("Too small viewport", "", __FILE__, __LINE__);
281
282	// Sampling parameters.
283	sampleParams.sampler		= glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, magFilter);
284	sampleParams.samplerType	= gls::TextureTestUtil::getSamplerType(m_texture->getRefTexture().getFormat());
285	sampleParams.colorBias		= fmtInfo.lookupBias;
286	sampleParams.colorScale		= fmtInfo.lookupScale;
287	sampleParams.flags			= (isProjected ? ReferenceParams::PROJECTED : 0) | (useLodBias ? ReferenceParams::USE_BIAS : 0);
288
289	// Upload texture data.
290	m_texture->upload();
291
292	// Use unit 0.
293	gl.activeTexture(GL_TEXTURE0);
294
295	// Bind gradient texture and setup sampler parameters.
296	gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture());
297	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,		m_wrapS);
298	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,		m_wrapT);
299	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,	m_minFilter);
300	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,	magFilter);
301
302	GLU_EXPECT_NO_ERROR(gl.getError(), "After texture setup");
303
304	// Bias values.
305	static const float s_bias[] = { 1.0f, -2.0f, 0.8f, -0.5f, 1.5f, 0.9f, 2.0f, 4.0f };
306
307	// Projection values.
308	static const Vec4 s_projections[] =
309	{
310		Vec4(1.2f, 1.0f, 0.7f, 1.0f),
311		Vec4(1.3f, 0.8f, 0.6f, 2.0f),
312		Vec4(0.8f, 1.0f, 1.7f, 0.6f),
313		Vec4(1.2f, 1.0f, 1.7f, 1.5f)
314	};
315
316	// Render cells.
317	for (int gridY = 0; gridY < gridHeight; gridY++)
318	{
319		for (int gridX = 0; gridX < gridWidth; gridX++)
320		{
321			int				curX		= cellWidth*gridX;
322			int				curY		= cellHeight*gridY;
323			int				curW		= gridX+1 == gridWidth ? (viewport.width-curX) : cellWidth;
324			int				curH		= gridY+1 == gridHeight ? (viewport.height-curY) : cellHeight;
325			int				cellNdx		= gridY*gridWidth + gridX;
326
327			// Compute texcoord.
328			switch (m_coordType)
329			{
330				case COORDTYPE_BASIC_BIAS:	// Fall-through.
331				case COORDTYPE_PROJECTED:
332				case COORDTYPE_BASIC:		getBasicTexCoord2D	(texCoord, cellNdx);	break;
333				case COORDTYPE_AFFINE:		getAffineTexCoord2D	(texCoord, cellNdx);	break;
334				default:					DE_ASSERT(DE_FALSE);
335			}
336
337			if (isProjected)
338				sampleParams.w = s_projections[cellNdx % DE_LENGTH_OF_ARRAY(s_projections)];
339
340			if (useLodBias)
341				sampleParams.bias = s_bias[cellNdx % DE_LENGTH_OF_ARRAY(s_bias)];
342
343			// Render with GL.
344			gl.viewport(viewport.x+curX, viewport.y+curY, curW, curH);
345			m_renderer.renderQuad(0, &texCoord[0], sampleParams);
346
347			// Render reference(s).
348			{
349				SurfaceAccess idealDst(idealFrame, m_renderCtx.getRenderTarget().getPixelFormat(), curX, curY, curW, curH);
350				sampleParams.lodMode = LODMODE_EXACT;
351				sampleTexture(idealDst, m_texture->getRefTexture(), &texCoord[0], sampleParams);
352			}
353		}
354	}
355
356	// Read result.
357	glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
358
359	// Compare and log.
360	{
361		const int	bestScoreDiff	= (texWidth/16)*(texHeight/16);
362		const int	worstScoreDiff	= texWidth*texHeight;
363
364		int score = measureAccuracy(log, idealFrame, renderedFrame, bestScoreDiff, worstScoreDiff);
365		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, de::toString(score).c_str());
366	}
367
368	return STOP;
369}
370
371// TextureCubeMipmapCase
372
373class TextureCubeMipmapCase : public tcu::TestCase
374{
375public:
376
377								TextureCubeMipmapCase		(tcu::TestContext&			testCtx,
378															 glu::RenderContext&		renderCtx,
379															 const glu::ContextInfo&	renderCtxInfo,
380															 const char*				name,
381															 const char*				desc,
382															 CoordType					coordType,
383															 deUint32					minFilter,
384															 deUint32					wrapS,
385															 deUint32					wrapT,
386															 deUint32					format,
387															 deUint32					dataType,
388															 int						size);
389								~TextureCubeMipmapCase		(void);
390
391	void						init						(void);
392	void						deinit						(void);
393	IterateResult				iterate						(void);
394
395private:
396								TextureCubeMipmapCase		(const TextureCubeMipmapCase& other);
397	TextureCubeMipmapCase&		operator=					(const TextureCubeMipmapCase& other);
398
399	glu::RenderContext&			m_renderCtx;
400	const glu::ContextInfo&		m_renderCtxInfo;
401
402	CoordType					m_coordType;
403	deUint32					m_minFilter;
404	deUint32					m_wrapS;
405	deUint32					m_wrapT;
406	deUint32					m_format;
407	deUint32					m_dataType;
408	int							m_size;
409
410	glu::TextureCube*			m_texture;
411	TextureRenderer				m_renderer;
412};
413
414TextureCubeMipmapCase::TextureCubeMipmapCase (tcu::TestContext&			testCtx,
415											  glu::RenderContext&		renderCtx,
416											  const glu::ContextInfo&	renderCtxInfo,
417											  const char*				name,
418											  const char*				desc,
419											  CoordType					coordType,
420											  deUint32					minFilter,
421											  deUint32					wrapS,
422											  deUint32					wrapT,
423											  deUint32					format,
424											  deUint32					dataType,
425											  int						size)
426	: TestCase			(testCtx, tcu::NODETYPE_ACCURACY, name, desc)
427	, m_renderCtx		(renderCtx)
428	, m_renderCtxInfo	(renderCtxInfo)
429	, m_coordType		(coordType)
430	, m_minFilter		(minFilter)
431	, m_wrapS			(wrapS)
432	, m_wrapT			(wrapT)
433	, m_format			(format)
434	, m_dataType		(dataType)
435	, m_size			(size)
436	, m_texture			(DE_NULL)
437	, m_renderer		(renderCtx, testCtx, glu::GLSL_VERSION_100_ES,
438						 renderCtxInfo.isFragmentHighPrecisionSupported() ? glu::PRECISION_HIGHP // Use highp if available.
439																		  : glu::PRECISION_MEDIUMP)
440{
441}
442
443TextureCubeMipmapCase::~TextureCubeMipmapCase (void)
444{
445	deinit();
446}
447
448void TextureCubeMipmapCase::init (void)
449{
450	if (!m_renderCtxInfo.isFragmentHighPrecisionSupported())
451		m_testCtx.getLog() << TestLog::Message << "Warning: High precision not supported in fragment shaders." << TestLog::EndMessage;
452
453	m_texture = new TextureCube(m_renderCtx, m_format, m_dataType, m_size);
454
455	int numLevels = deLog2Floor32(m_size)+1;
456
457	// Fill texture with colored grid.
458	for (int faceNdx = 0; faceNdx < tcu::CUBEFACE_LAST; faceNdx++)
459	{
460		for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
461		{
462			deUint32	step		= 0xff / (numLevels-1);
463			deUint32	inc			= deClamp32(step*levelNdx, 0x00, 0xff);
464			deUint32	dec			= 0xff - inc;
465			deUint32	rgb			= 0;
466
467			switch (faceNdx)
468			{
469				case 0: rgb = (inc << 16) | (dec << 8) | 255; break;
470				case 1: rgb = (255 << 16) | (inc << 8) | dec; break;
471				case 2: rgb = (dec << 16) | (255 << 8) | inc; break;
472				case 3: rgb = (dec << 16) | (inc << 8) | 255; break;
473				case 4: rgb = (255 << 16) | (dec << 8) | inc; break;
474				case 5: rgb = (inc << 16) | (255 << 8) | dec; break;
475			}
476
477			deUint32	color		= 0xff000000 | rgb;
478
479			m_texture->getRefTexture().allocLevel((tcu::CubeFace)faceNdx, levelNdx);
480			tcu::clear(m_texture->getRefTexture().getLevelFace(levelNdx, (tcu::CubeFace)faceNdx), toVec4(tcu::RGBA(color)));
481		}
482	}
483}
484
485void TextureCubeMipmapCase::deinit (void)
486{
487	delete m_texture;
488	m_texture = DE_NULL;
489
490	m_renderer.clear();
491}
492
493static void randomPartition (vector<IVec4>& dst, de::Random& rnd, int x, int y, int width, int height)
494{
495	const int minWidth	= 8;
496	const int minHeight	= 8;
497
498	bool	partition		= rnd.getFloat() > 0.4f;
499	bool	partitionX		= partition && width > minWidth && rnd.getBool();
500	bool	partitionY		= partition && height > minHeight && !partitionX;
501
502	if (partitionX)
503	{
504		int split = width/2 + rnd.getInt(-width/4, +width/4);
505		randomPartition(dst, rnd, x, y, split, height);
506		randomPartition(dst, rnd, x+split, y, width-split, height);
507	}
508	else if (partitionY)
509	{
510		int split = height/2 + rnd.getInt(-height/4, +height/4);
511		randomPartition(dst, rnd, x, y, width, split);
512		randomPartition(dst, rnd, x, y+split, width, height-split);
513	}
514	else
515		dst.push_back(IVec4(x, y, width, height));
516}
517
518static void computeGridLayout (vector<IVec4>& dst, int width, int height)
519{
520	de::Random rnd(7);
521	randomPartition(dst, rnd, 0, 0, width, height);
522}
523
524TextureCubeMipmapCase::IterateResult TextureCubeMipmapCase::iterate (void)
525{
526	// Constants.
527	const deUint32			magFilter			= GL_NEAREST;
528
529	int						texWidth			= m_texture->getRefTexture().getSize();
530	int						texHeight			= m_texture->getRefTexture().getSize();
531
532	int						defViewportWidth	= texWidth*2;
533	int						defViewportHeight	= texHeight*2;
534
535	const glw::Functions&	gl					= m_renderCtx.getFunctions();
536	TestLog&				log					= m_testCtx.getLog();
537	RandomViewport			viewport			(m_renderCtx.getRenderTarget(), defViewportWidth, defViewportHeight, deStringHash(getName()));
538	tcu::Sampler			sampler				= mapGLSampler(m_wrapS, m_wrapT, m_minFilter, magFilter);
539
540	vector<float>			texCoord;
541
542	bool					isProjected			= m_coordType == COORDTYPE_PROJECTED;
543	bool					useLodBias			= m_coordType == COORDTYPE_BASIC_BIAS;
544
545	tcu::Surface			renderedFrame		(viewport.width, viewport.height);
546
547	// Accuracy cases test against ideal lod computation.
548	tcu::Surface			idealFrame			(viewport.width, viewport.height);
549
550	// Accuracy measurements are off unless we get the expected viewport size.
551	if (viewport.width < defViewportWidth || viewport.height < defViewportHeight)
552		throw tcu::NotSupportedError("Too small viewport", "", __FILE__, __LINE__);
553
554	// Upload texture data.
555	m_texture->upload();
556
557	// Use unit 0.
558	gl.activeTexture(GL_TEXTURE0);
559
560	// Bind gradient texture and setup sampler parameters.
561	gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_texture->getGLTexture());
562	gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S,		m_wrapS);
563	gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T,		m_wrapT);
564	gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER,	m_minFilter);
565	gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER,	magFilter);
566
567	GLU_EXPECT_NO_ERROR(gl.getError(), "After texture setup");
568
569	// Compute grid.
570	vector<IVec4> gridLayout;
571	computeGridLayout(gridLayout, viewport.width, viewport.height);
572
573	// Bias values.
574	static const float s_bias[] = { 1.0f, -2.0f, 0.8f, -0.5f, 1.5f, 0.9f, 2.0f, 4.0f };
575
576	// Projection values \note Less agressive than in 2D case due to smaller quads.
577	static const Vec4 s_projections[] =
578	{
579		Vec4(1.2f, 1.0f, 0.7f, 1.0f),
580		Vec4(1.3f, 0.8f, 0.6f, 1.1f),
581		Vec4(0.8f, 1.0f, 1.2f, 0.8f),
582		Vec4(1.2f, 1.0f, 1.3f, 0.9f)
583	};
584
585	for (int cellNdx = 0; cellNdx < (int)gridLayout.size(); cellNdx++)
586	{
587		int				curX		= gridLayout[cellNdx].x();
588		int				curY		= gridLayout[cellNdx].y();
589		int				curW		= gridLayout[cellNdx].z();
590		int				curH		= gridLayout[cellNdx].w();
591		tcu::CubeFace	cubeFace	= (tcu::CubeFace)(cellNdx % tcu::CUBEFACE_LAST);
592		ReferenceParams	params		(TEXTURETYPE_CUBE);
593
594		params.sampler = sampler;
595
596		DE_ASSERT(m_coordType != COORDTYPE_AFFINE); // Not supported.
597		computeQuadTexCoordCube(texCoord, cubeFace);
598
599		if (isProjected)
600		{
601			params.flags	|= ReferenceParams::PROJECTED;
602			params.w		 = s_projections[cellNdx % DE_LENGTH_OF_ARRAY(s_projections)];
603		}
604
605		if (useLodBias)
606		{
607			params.flags	|= ReferenceParams::USE_BIAS;
608			params.bias		 = s_bias[cellNdx % DE_LENGTH_OF_ARRAY(s_bias)];
609		}
610
611		// Render with GL.
612		gl.viewport(viewport.x+curX, viewport.y+curY, curW, curH);
613		m_renderer.renderQuad(0, &texCoord[0], params);
614
615		// Render reference(s).
616		{
617			SurfaceAccess idealDst(idealFrame, m_renderCtx.getRenderTarget().getPixelFormat(), curX, curY, curW, curH);
618			params.lodMode = LODMODE_EXACT;
619			sampleTexture(idealDst, m_texture->getRefTexture(), &texCoord[0], params);
620		}
621	}
622
623	// Read result.
624	glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
625
626	// Compare and log.
627	{
628		const int	bestScoreDiff	= (texWidth/16)*(texHeight/16);
629		const int	worstScoreDiff	= texWidth*texHeight;
630
631		int score = measureAccuracy(log, idealFrame, renderedFrame, bestScoreDiff, worstScoreDiff);
632		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, de::toString(score).c_str());
633	}
634
635	return STOP;
636}
637
638TextureMipmapTests::TextureMipmapTests (Context& context)
639	: TestCaseGroup(context, "mipmap", "Mipmapping accuracy tests")
640{
641}
642
643TextureMipmapTests::~TextureMipmapTests (void)
644{
645}
646
647void TextureMipmapTests::init (void)
648{
649	tcu::TestCaseGroup* group2D		= new tcu::TestCaseGroup(m_testCtx, "2d",	"2D Texture Mipmapping");
650	tcu::TestCaseGroup*	groupCube	= new tcu::TestCaseGroup(m_testCtx, "cube",	"Cube Map Filtering");
651	addChild(group2D);
652	addChild(groupCube);
653
654	static const struct
655	{
656		const char*		name;
657		deUint32		mode;
658	} wrapModes[] =
659	{
660		{ "clamp",		GL_CLAMP_TO_EDGE },
661		{ "repeat",		GL_REPEAT },
662		{ "mirror",		GL_MIRRORED_REPEAT }
663	};
664
665	static const struct
666	{
667		const char*		name;
668		deUint32		mode;
669	} minFilterModes[] =
670	{
671		{ "nearest_nearest",	GL_NEAREST_MIPMAP_NEAREST	},
672		{ "linear_nearest",		GL_LINEAR_MIPMAP_NEAREST	},
673		{ "nearest_linear",		GL_NEAREST_MIPMAP_LINEAR	},
674		{ "linear_linear",		GL_LINEAR_MIPMAP_LINEAR		}
675	};
676
677	static const struct
678	{
679		CoordType		type;
680		const char*		name;
681		const char*		desc;
682	} coordTypes[] =
683	{
684		{ COORDTYPE_BASIC,		"basic",		"Mipmapping with translated and scaled coordinates" },
685		{ COORDTYPE_AFFINE,		"affine",		"Mipmapping with affine coordinate transform"		},
686		{ COORDTYPE_PROJECTED,	"projected",	"Mipmapping with perspective projection"			}
687	};
688
689	const int tex2DWidth	= 64;
690	const int tex2DHeight	= 64;
691
692	// 2D cases.
693	for (int coordType = 0; coordType < DE_LENGTH_OF_ARRAY(coordTypes); coordType++)
694	{
695		tcu::TestCaseGroup* coordTypeGroup = new tcu::TestCaseGroup(m_testCtx, coordTypes[coordType].name, coordTypes[coordType].desc);
696		group2D->addChild(coordTypeGroup);
697
698		for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
699		{
700			for (int wrapMode = 0; wrapMode < DE_LENGTH_OF_ARRAY(wrapModes); wrapMode++)
701			{
702				std::ostringstream name;
703				name << minFilterModes[minFilter].name
704						<< "_" << wrapModes[wrapMode].name;
705
706				coordTypeGroup->addChild(new Texture2DMipmapCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(),
707																	name.str().c_str(), "",
708																	coordTypes[coordType].type,
709																	minFilterModes[minFilter].mode,
710																	wrapModes[wrapMode].mode,
711																	wrapModes[wrapMode].mode,
712																	GL_RGBA, GL_UNSIGNED_BYTE,
713																	tex2DWidth, tex2DHeight));
714			}
715		}
716	}
717
718	const int cubeMapSize = 64;
719
720	static const struct
721	{
722		CoordType		type;
723		const char*		name;
724		const char*		desc;
725	} cubeCoordTypes[] =
726	{
727		{ COORDTYPE_BASIC,		"basic",		"Mipmapping with translated and scaled coordinates" },
728		{ COORDTYPE_PROJECTED,	"projected",	"Mipmapping with perspective projection"			}
729	};
730
731	// Cubemap cases.
732	for (int coordType = 0; coordType < DE_LENGTH_OF_ARRAY(cubeCoordTypes); coordType++)
733	{
734		tcu::TestCaseGroup* coordTypeGroup = new tcu::TestCaseGroup(m_testCtx, cubeCoordTypes[coordType].name, cubeCoordTypes[coordType].desc);
735		groupCube->addChild(coordTypeGroup);
736
737		for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
738		{
739			coordTypeGroup->addChild(new TextureCubeMipmapCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(),
740															   minFilterModes[minFilter].name, "",
741															   cubeCoordTypes[coordType].type,
742															   minFilterModes[minFilter].mode,
743															   GL_CLAMP_TO_EDGE,
744															   GL_CLAMP_TO_EDGE,
745															   GL_RGBA, GL_UNSIGNED_BYTE, cubeMapSize));
746		}
747	}
748}
749
750} // Accuracy
751} // gles2
752} // deqp
753