/*-------------------------------------------------------------------------
* drawElements Quality Program OpenGL ES 2.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 wrap mode tests.
*//*--------------------------------------------------------------------*/
#include "es2fTextureWrapTests.hpp"
#include "glsTextureTestUtil.hpp"
#include "gluTexture.hpp"
#include "gluStrUtil.hpp"
#include "gluTextureUtil.hpp"
#include "gluPixelTransfer.hpp"
#include "tcuTestLog.hpp"
#include "tcuTextureUtil.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
namespace deqp
{
namespace gles2
{
namespace Functional
{
using tcu::TestLog;
using std::vector;
using std::string;
using tcu::Sampler;
using namespace glu;
using namespace gls::TextureTestUtil;
using namespace glu::TextureTestUtil;
enum
{
VIEWPORT_WIDTH = 256,
VIEWPORT_HEIGHT = 256
};
class TextureWrapCase : public tcu::TestCase
{
public:
TextureWrapCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const char* description, deUint32 format, deUint32 dataType, deUint32 wrapS, deUint32 wrapT, deUint32 minFilter, deUint32 magFilter, int width, int height);
TextureWrapCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const char* description, deUint32 wrapS, deUint32 wrapT, deUint32 minFilter, deUint32 magFilter, const std::vector<std::string>& filenames);
~TextureWrapCase (void);
void init (void);
void deinit (void);
IterateResult iterate (void);
private:
TextureWrapCase (const TextureWrapCase& other);
TextureWrapCase& operator= (const TextureWrapCase& other);
glu::RenderContext& m_renderCtx;
const glu::ContextInfo& m_renderCtxInfo;
deUint32 m_format;
deUint32 m_dataType;
deUint32 m_wrapS;
deUint32 m_wrapT;
deUint32 m_minFilter;
deUint32 m_magFilter;
int m_width;
int m_height;
std::vector<std::string> m_filenames;
glu::Texture2D* m_texture;
TextureRenderer m_renderer;
};
TextureWrapCase::TextureWrapCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const char* description, deUint32 format, deUint32 dataType, deUint32 wrapS, deUint32 wrapT, deUint32 minFilter, deUint32 magFilter, int width, int height)
: TestCase (testCtx, name, description)
, m_renderCtx (renderCtx)
, m_renderCtxInfo (ctxInfo)
, m_format (format)
, m_dataType (dataType)
, m_wrapS (wrapS)
, m_wrapT (wrapT)
, m_minFilter (minFilter)
, m_magFilter (magFilter)
, m_width (width)
, m_height (height)
, m_texture (DE_NULL)
, m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_100_ES, glu::PRECISION_MEDIUMP)
{
}
TextureWrapCase::TextureWrapCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const char* description, deUint32 wrapS, deUint32 wrapT, deUint32 minFilter, deUint32 magFilter, const std::vector<std::string>& filenames)
: TestCase (testCtx, name, description)
, m_renderCtx (renderCtx)
, m_renderCtxInfo (ctxInfo)
, m_format (GL_NONE)
, m_dataType (GL_NONE)
, m_wrapS (wrapS)
, m_wrapT (wrapT)
, m_minFilter (minFilter)
, m_magFilter (magFilter)
, m_width (0)
, m_height (0)
, m_filenames (filenames)
, m_texture (DE_NULL)
, m_renderer (renderCtx, testCtx.getLog(), glu::GLSL_VERSION_100_ES, glu::PRECISION_MEDIUMP)
{
}
TextureWrapCase::~TextureWrapCase (void)
{
deinit();
}
void TextureWrapCase::init (void)
{
if (!m_filenames.empty())
{
DE_ASSERT(m_width == 0 && m_height == 0 && m_format == GL_NONE && m_dataType == GL_NONE);
m_texture = glu::Texture2D::create(m_renderCtx, m_renderCtxInfo, m_testCtx.getArchive(), (int)m_filenames.size(), m_filenames);
m_width = m_texture->getRefTexture().getWidth();
m_height = m_texture->getRefTexture().getHeight();
}
else
{
m_texture = new Texture2D(m_renderCtx, m_format, m_dataType, m_width, m_height);
// Fill level 0.
m_texture->getRefTexture().allocLevel(0);
tcu::fillWithComponentGradients(m_texture->getRefTexture().getLevel(0), tcu::Vec4(-0.5f, -0.5f, -0.5f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f));
m_texture->upload();
}
}
void TextureWrapCase::deinit (void)
{
delete m_texture;
m_texture = DE_NULL;
m_renderer.clear();
}
TextureWrapCase::IterateResult TextureWrapCase::iterate (void)
{
const glw::Functions& gl = m_renderCtx.getFunctions();
TestLog& log = m_testCtx.getLog();
RandomViewport viewport (m_renderCtx.getRenderTarget(), VIEWPORT_WIDTH, VIEWPORT_HEIGHT, deStringHash(getName()));
tcu::Surface renderedFrame (viewport.width, viewport.height);
tcu::Surface referenceFrame (viewport.width, viewport.height);
bool isCompressedTex = !m_filenames.empty();
ReferenceParams refParams (TEXTURETYPE_2D);
int leftWidth = viewport.width / 2;
int rightWidth = viewport.width - leftWidth;
vector<float> texCoord;
tcu::RGBA threshold = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold()
+ (isCompressedTex ? tcu::RGBA(7,7,7,7) : tcu::RGBA(3,3,3,3));
// Bind to unit 0.
gl.activeTexture(GL_TEXTURE0);
gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture());
// Setup filtering and wrap modes.
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, m_wrapS);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, m_wrapT);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_minFilter);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, m_magFilter);
GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state");
// Parameters for reference images.
refParams.sampler = mapGLSampler(m_wrapS, m_wrapT, m_minFilter, m_magFilter);
refParams.lodMode = LODMODE_EXACT;
// Left: minification
{
gl.viewport(viewport.x, viewport.y, leftWidth, viewport.height);
computeQuadTexCoord2D(texCoord, tcu::Vec2(-1.5f, -3.0f), tcu::Vec2(1.5f, 2.5f));
m_renderer.renderQuad(0, &texCoord[0], refParams);
glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
sampleTexture(tcu::SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat(), 0, 0, leftWidth, viewport.height),
m_texture->getRefTexture(), &texCoord[0], refParams);
}
// Right: magnification
{
gl.viewport(viewport.x+leftWidth, viewport.y, rightWidth, viewport.height);
computeQuadTexCoord2D(texCoord, tcu::Vec2(-0.5f, 0.75f), tcu::Vec2(0.25f, 1.25f));
m_renderer.renderQuad(0, &texCoord[0], refParams);
glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
sampleTexture(tcu::SurfaceAccess(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat(), leftWidth, 0, rightWidth, viewport.height),
m_texture->getRefTexture(), &texCoord[0], refParams);
}
// 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;
}
TextureWrapTests::TextureWrapTests (Context& context)
: TestCaseGroup(context, "wrap", "Wrap Mode Tests")
{
}
TextureWrapTests::~TextureWrapTests (void)
{
}
void TextureWrapTests::init (void)
{
static const struct
{
const char* name;
deUint32 mode;
} wrapModes[] =
{
{ "clamp", GL_CLAMP_TO_EDGE },
{ "repeat", GL_REPEAT },
{ "mirror", GL_MIRRORED_REPEAT }
};
static const struct
{
const char* name;
deUint32 mode;
} filteringModes[] =
{
{ "nearest", GL_NEAREST },
{ "linear", GL_LINEAR }
};
static const struct
{
const char* name;
int width;
int height;
} sizes[] =
{
{ "pot", 64, 128 },
{ "npot", 63, 112 }
};
static const struct
{
const char* name;
deUint32 format;
deUint32 dataType;
} formats[] =
{
{ "rgba8888", GL_RGBA, GL_UNSIGNED_BYTE },
{ "rgb888", GL_RGB, GL_UNSIGNED_BYTE },
{ "rgba4444", GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4 },
{ "l8", GL_LUMINANCE, GL_UNSIGNED_BYTE },
};
#define FOR_EACH(ITERATOR, ARRAY, BODY) \
for (int ITERATOR = 0; ITERATOR < DE_LENGTH_OF_ARRAY(ARRAY); ITERATOR++) \
BODY
FOR_EACH(wrapS, wrapModes,
FOR_EACH(wrapT, wrapModes,
FOR_EACH(filter, filteringModes,
FOR_EACH(size, sizes,
FOR_EACH(format, formats,
{
bool is_clamp_clamp = (wrapModes[wrapS].mode == GL_CLAMP_TO_EDGE && wrapModes[wrapT].mode == GL_CLAMP_TO_EDGE);
bool is_repeat_mirror = (wrapModes[wrapS].mode == GL_REPEAT && wrapModes[wrapT].mode == GL_MIRRORED_REPEAT);
if (!is_clamp_clamp && !is_repeat_mirror && format != 0)
continue; // Use other format varants with clamp_clamp & repeat_mirror pair only.
if (!is_clamp_clamp && (!deIsPowerOfTwo32(sizes[size].width) || !deIsPowerOfTwo32(sizes[size].height)))
continue; // Not supported as described in Spec section 3.8.2.
string name = string("") + wrapModes[wrapS].name + "_" + wrapModes[wrapT].name + "_" + filteringModes[filter].name + "_" + sizes[size].name + "_" + formats[format].name;
addChild(new TextureWrapCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), name.c_str(), "",
formats[format].format, formats[format].dataType,
wrapModes[wrapS].mode,
wrapModes[wrapT].mode,
filteringModes[filter].mode, filteringModes[filter].mode,
sizes[size].width, sizes[size].height));
})))));
// Power-of-two ETC1 texture
std::vector<std::string> potFilenames;
potFilenames.push_back("data/etc1/photo_helsinki_mip_0.pkm");
FOR_EACH(wrapS, wrapModes,
FOR_EACH(wrapT, wrapModes,
FOR_EACH(filter, filteringModes,
{
string name = string("") + wrapModes[wrapS].name + "_" + wrapModes[wrapT].name + "_" + filteringModes[filter].name + "_pot_etc1";
addChild(new TextureWrapCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), name.c_str(), "",
wrapModes[wrapS].mode,
wrapModes[wrapT].mode,
filteringModes[filter].mode, filteringModes[filter].mode,
potFilenames));
})));
std::vector<std::string> npotFilenames;
npotFilenames.push_back("data/etc1/photo_helsinki_113x89.pkm");
// NPOT ETC1 texture
for (int filter = 0; filter < DE_LENGTH_OF_ARRAY(filteringModes); filter++)
{
string name = string("clamp_clamp_") + filteringModes[filter].name + "_npot_etc1";
addChild(new TextureWrapCase(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), name.c_str(), "",
GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE,
filteringModes[filter].mode, filteringModes[filter].mode,
npotFilenames));
}
}
} // Functional
} // gles2
} // deqp