xref: /external/deqp/modules/gles3/functional/es3fTextureSwizzleTests.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES 3.0 Module
 * -------------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Texture swizzle tests.
 *//*--------------------------------------------------------------------*/

#include "es3fTextureSwizzleTests.hpp"
#include "glsTextureTestUtil.hpp"
#include "gluPixelTransfer.hpp"
#include "gluTexture.hpp"
#include "gluRenderContext.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuRenderTarget.hpp"
#include "deString.h"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"

namespace deqp
{
namespace gles3
{
namespace Functional
{

using std::string;
using std::vector;
using tcu::TestLog;
using namespace deqp::gls;
using namespace deqp::gls::TextureTestUtil;
using namespace glu::TextureTestUtil;

static int swizzle (const tcu::RGBA& c, deUint32 swz)
{
	switch (swz)
	{
		case GL_RED:	return c.getRed();
		case GL_GREEN:	return c.getGreen();
		case GL_BLUE:	return c.getBlue();
		case GL_ALPHA:	return c.getAlpha();
		case GL_ZERO:	return 0;
		case GL_ONE:	return (1<<8)-1;
		default:
			DE_ASSERT(false);
			return 0;
	}
}

static void swizzle (tcu::Surface& surface, deUint32 swzR, deUint32 swzG, deUint32 swzB, deUint32 swzA)
{
	for (int y = 0; y < surface.getHeight(); y++)
	{
		for (int x = 0; x < surface.getWidth(); x++)
		{
			tcu::RGBA p = surface.getPixel(x, y);
			surface.setPixel(x, y, tcu::RGBA(swizzle(p, swzR), swizzle(p, swzG), swizzle(p, swzB), swizzle(p, swzA)));
		}
	}
}

class Texture2DSwizzleCase : public TestCase
{
public:
							Texture2DSwizzleCase	(Context& context, const char* name, const char* description, deUint32 internalFormat, deUint32 format, deUint32 dataType, deUint32 swizzleR, deUint32 swizzleG, deUint32 swizzleB, deUint32 swizzleA);
							~Texture2DSwizzleCase	(void);

	void					init					(void);
	void					deinit					(void);
	IterateResult			iterate					(void);

private:
							Texture2DSwizzleCase	(const Texture2DSwizzleCase& other);
	Texture2DSwizzleCase&	operator=				(const Texture2DSwizzleCase& other);

	deUint32				m_internalFormat;
	deUint32				m_format;
	deUint32				m_dataType;
	deUint32				m_swizzleR;
	deUint32				m_swizzleG;
	deUint32				m_swizzleB;
	deUint32				m_swizzleA;

	glu::Texture2D*			m_texture;
	TextureRenderer			m_renderer;
};

Texture2DSwizzleCase::Texture2DSwizzleCase (Context& context, const char* name, const char* description, deUint32 internalFormat, deUint32 format, deUint32 dataType, deUint32 swizzleR, deUint32 swizzleG, deUint32 swizzleB, deUint32 swizzleA)
	: TestCase			(context, name, description)
	, m_internalFormat	(internalFormat)
	, m_format			(format)
	, m_dataType		(dataType)
	, m_swizzleR		(swizzleR)
	, m_swizzleG		(swizzleG)
	, m_swizzleB		(swizzleB)
	, m_swizzleA		(swizzleA)
	, m_texture			(DE_NULL)
	, m_renderer		(context.getRenderContext(), context.getTestContext().getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
{
}

Texture2DSwizzleCase::~Texture2DSwizzleCase (void)
{
	deinit();
}

void Texture2DSwizzleCase::init (void)
{
	int	width	= de::min(128, m_context.getRenderContext().getRenderTarget().getWidth());
	int	height	= de::min(128, m_context.getRenderContext().getRenderTarget().getHeight());

	m_texture = (m_internalFormat == m_format) ? new glu::Texture2D(m_context.getRenderContext(), m_format, m_dataType, width, height)
											   : new glu::Texture2D(m_context.getRenderContext(), m_internalFormat, width, height);

	tcu::TextureFormatInfo spec = tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat());

	// Fill level 0.
	m_texture->getRefTexture().allocLevel(0);
	tcu::fillWithComponentGradients(m_texture->getRefTexture().getLevel(0), spec.valueMin, spec.valueMax);
}

void Texture2DSwizzleCase::deinit (void)
{
	delete m_texture;
	m_texture = DE_NULL;

	m_renderer.clear();
}

Texture2DSwizzleCase::IterateResult Texture2DSwizzleCase::iterate (void)
{
	const glw::Functions&	gl					= m_context.getRenderContext().getFunctions();
	TestLog&				log					= m_testCtx.getLog();
	RandomViewport			viewport			(m_context.getRenderContext().getRenderTarget(), m_texture->getRefTexture().getWidth(), m_texture->getRefTexture().getHeight(), deStringHash(getName()));
	tcu::Surface			renderedFrame		(viewport.width, viewport.height);
	tcu::Surface			referenceFrame		(viewport.width, viewport.height);
	tcu::RGBA				threshold			= m_context.getRenderTarget().getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1);
	vector<float>			texCoord;
	ReferenceParams			renderParams		(TEXTURETYPE_2D);
	tcu::TextureFormatInfo	spec				= tcu::getTextureFormatInfo(m_texture->getRefTexture().getFormat());

	renderParams.samplerType	= getSamplerType(m_texture->getRefTexture().getFormat());
	renderParams.sampler		= tcu::Sampler(tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::CLAMP_TO_EDGE, tcu::Sampler::NEAREST, tcu::Sampler::NEAREST);
	renderParams.colorScale		= spec.lookupScale;
	renderParams.colorBias		= spec.lookupBias;

	computeQuadTexCoord2D(texCoord, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f));

	// Setup base viewport.
	gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);

	// Upload texture data to GL.
	m_texture->upload();

	// Bind to unit 0.
	gl.activeTexture(GL_TEXTURE0);
	gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture());

	// Setup nearest neighbor filtering and clamp-to-edge.
	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,		GL_CLAMP_TO_EDGE);
	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,		GL_CLAMP_TO_EDGE);
	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,	GL_NEAREST);
	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,	GL_NEAREST);

	// Setup texture swizzle.
	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R,	m_swizzleR);
	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G,	m_swizzleG);
	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B,	m_swizzleB);
	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A,	m_swizzleA);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state");

	// Draw.
	m_renderer.renderQuad(0, &texCoord[0], renderParams);
	glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, renderedFrame.getAccess());

	// Compute reference
	{
		const tcu::PixelFormat pixelFormat = m_context.getRenderTarget().getPixelFormat();

		// Do initial rendering to RGBA8 in order to keep alpha
		sampleTexture(tcu::SurfaceAccess(referenceFrame, tcu::PixelFormat(8,8,8,8)), m_texture->getRefTexture(), &texCoord[0], renderParams);

		// Swizzle channels
		swizzle(referenceFrame, m_swizzleR, m_swizzleG, m_swizzleB, m_swizzleA);

		// Convert to destination format
		if (pixelFormat != tcu::PixelFormat(8,8,8,8))
		{
			for (int y = 0; y < referenceFrame.getHeight(); y++)
			{
				for (int x = 0; x < referenceFrame.getWidth(); x++)
				{
					tcu::RGBA p = referenceFrame.getPixel(x, y);
					referenceFrame.setPixel(x, y, pixelFormat.convertColor(p));
				}
			}
		}
	}

	// Compare and log.
	bool isOk = compareImages(log, referenceFrame, renderedFrame, threshold);

	m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS	: QP_TEST_RESULT_FAIL,
							isOk ? "Pass"				: "Image comparison failed");

	return STOP;
}

TextureSwizzleTests::TextureSwizzleTests (Context& context)
	: TestCaseGroup(context, "swizzle", "Texture Swizzle Tests")
{
}

TextureSwizzleTests::~TextureSwizzleTests (void)
{
}

void TextureSwizzleTests::init (void)
{
	static const struct
	{
		const char*		name;
		deUint32		internalFormat;
		deUint32		format;
		deUint32		dataType;
	} formats[] =
	{
		{ "alpha",				GL_ALPHA,				GL_ALPHA,			GL_UNSIGNED_BYTE },
		{ "luminance",			GL_LUMINANCE,			GL_LUMINANCE,		GL_UNSIGNED_BYTE },
		{ "luminance_alpha",	GL_LUMINANCE_ALPHA,		GL_LUMINANCE_ALPHA,	GL_UNSIGNED_BYTE },
		{ "red",				GL_R8,					GL_RED,				GL_UNSIGNED_BYTE },
		{ "rg",					GL_RG8,					GL_RG,				GL_UNSIGNED_BYTE },
		{ "rgb",				GL_RGB8,				GL_RGB,				GL_UNSIGNED_BYTE },
		{ "rgba",				GL_RGBA8,				GL_RGBA,			GL_UNSIGNED_BYTE }
	};

	static const struct
	{
		const char*		name;
		deUint32		channel;
	} channels[] =
	{
		{ "r",	GL_TEXTURE_SWIZZLE_R },
		{ "g",	GL_TEXTURE_SWIZZLE_G },
		{ "b",	GL_TEXTURE_SWIZZLE_B },
		{ "a",	GL_TEXTURE_SWIZZLE_A }
	};

	static const struct
	{
		const char*		name;
		deUint32		swizzle;
	} swizzles[] =
	{
		{ "red",		GL_RED		},
		{ "green",		GL_GREEN	},
		{ "blue",		GL_BLUE		},
		{ "alpha",		GL_ALPHA	},
		{ "zero",		GL_ZERO		},
		{ "one",		GL_ONE		}
	};

	static const struct
	{
		const char*		name;
		deUint32		swzR;
		deUint32		swzG;
		deUint32		swzB;
		deUint32		swzA;
	} swizzleCases[] =
	{
		{ "all_red",			GL_RED,		GL_RED,		GL_RED,		GL_RED		},
		{ "all_green",			GL_GREEN,	GL_GREEN,	GL_GREEN,	GL_GREEN	},
		{ "all_blue",			GL_BLUE,	GL_BLUE,	GL_BLUE,	GL_BLUE		},
		{ "all_alpha",			GL_ALPHA,	GL_ALPHA,	GL_ALPHA,	GL_ALPHA	},
		{ "all_zero",			GL_ZERO,	GL_ZERO,	GL_ZERO,	GL_ZERO		},
		{ "all_one",			GL_ONE,		GL_ONE,		GL_ONE,		GL_ONE		},
		{ "bgra",				GL_BLUE,	GL_GREEN,	GL_RED,		GL_ALPHA	},
		{ "abgr",				GL_ALPHA,	GL_BLUE,	GL_GREEN,	GL_RED		},
		{ "one_one_red_green",	GL_ONE,		GL_ONE,		GL_RED,		GL_GREEN	}
	};

	static const deUint32 defaultSwizzles[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA };

	// All swizzles applied to each channel.
	tcu::TestCaseGroup* singleChannelGroup = new tcu::TestCaseGroup(m_testCtx, "single_channel", "Single-channel swizzle");
	addChild(singleChannelGroup);
	for (int chanNdx = 0; chanNdx < DE_LENGTH_OF_ARRAY(channels); chanNdx++)
	{
		for (int swzNdx = 0; swzNdx < DE_LENGTH_OF_ARRAY(swizzles); swzNdx++)
		{
			if (swizzles[swzNdx].swizzle == defaultSwizzles[chanNdx])
				continue; // No need to test default case.

			string		name	= string(channels[chanNdx].name) + "_" + swizzles[swzNdx].name;
			deUint32	swz		= swizzles[swzNdx].swizzle;
			deUint32	swzR	= (chanNdx == 0) ? swz : defaultSwizzles[0];
			deUint32	swzG	= (chanNdx == 1) ? swz : defaultSwizzles[1];
			deUint32	swzB	= (chanNdx == 2) ? swz : defaultSwizzles[2];
			deUint32	swzA	= (chanNdx == 3) ? swz : defaultSwizzles[3];

			singleChannelGroup->addChild(new Texture2DSwizzleCase(m_context, name.c_str(), "Single-channel swizzle", GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, swzR, swzG, swzB, swzA));
		}
	}

	// Swizzles for all formats.
	tcu::TestCaseGroup* multiChannelGroup = new tcu::TestCaseGroup(m_testCtx, "multi_channel", "Multi-channel swizzle");
	addChild(multiChannelGroup);
	for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(formats); fmtNdx++)
	{
		for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(swizzleCases); caseNdx++)
		{
			string		name		= string(formats[fmtNdx].name) + "_" + swizzleCases[caseNdx].name;
			deUint32	swzR		= swizzleCases[caseNdx].swzR;
			deUint32	swzG		= swizzleCases[caseNdx].swzG;
			deUint32	swzB		= swizzleCases[caseNdx].swzB;
			deUint32	swzA		= swizzleCases[caseNdx].swzA;
			deUint32	intFormat	= formats[fmtNdx].internalFormat;
			deUint32	format		= formats[fmtNdx].format;
			deUint32	dataType	= formats[fmtNdx].dataType;

			multiChannelGroup->addChild(new Texture2DSwizzleCase(m_context, name.c_str(), "Multi-channel swizzle", intFormat, format, dataType, swzR, swzG, swzB, swzA));
		}
	}
}

} // Functional
} // gles3
} // deqp