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