Home | History | Annotate | Download | only in accuracy 
      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 
     41 namespace deqp
     42 {
     43 namespace gles2
     44 {
     45 namespace Accuracy
     46 {
     47 
     48 using tcu::TestLog;
     49 using std::vector;
     50 using std::string;
     51 using tcu::Sampler;
     52 using tcu::Vec2;
     53 using tcu::Mat2;
     54 using tcu::Vec4;
     55 using tcu::IVec2;
     56 using tcu::IVec4;
     57 using namespace glu;
     58 using namespace gls::TextureTestUtil;
     59 
     60 enum 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 
     72 class Texture2DMipmapCase : public tcu::TestCase
     73 {
     74 public:
     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 
     95 private:
     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 
    115 Texture2DMipmapCase::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 
    146 Texture2DMipmapCase::~Texture2DMipmapCase (void)
    147 {
    148 	deinit();
    149 }
    150 
    151 void 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 
    174 void Texture2DMipmapCase::deinit (void)
    175 {
    176 	delete m_texture;
    177 	m_texture = DE_NULL;
    178 
    179 	m_renderer.clear();
    180 }
    181 
    182 static 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 
    219 static 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 
    244 Texture2DMipmapCase::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 
    373 class TextureCubeMipmapCase : public tcu::TestCase
    374 {
    375 public:
    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 
    395 private:
    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 
    414 TextureCubeMipmapCase::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 
    443 TextureCubeMipmapCase::~TextureCubeMipmapCase (void)
    444 {
    445 	deinit();
    446 }
    447 
    448 void 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 
    485 void TextureCubeMipmapCase::deinit (void)
    486 {
    487 	delete m_texture;
    488 	m_texture = DE_NULL;
    489 
    490 	m_renderer.clear();
    491 }
    492 
    493 static 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 
    518 static 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 
    524 TextureCubeMipmapCase::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 
    638 TextureMipmapTests::TextureMipmapTests (Context& context)
    639 	: TestCaseGroup(context, "mipmap", "Mipmapping accuracy tests")
    640 {
    641 }
    642 
    643 TextureMipmapTests::~TextureMipmapTests (void)
    644 {
    645 }
    646 
    647 void 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