Google Git
Sign in
fuchsia / third_party / vulkan-cts / refs/heads/upstream/opengl-cts-4.6.4 / . / modules / gles3 / functional / es3fTextureMipmapTests.cpp
blob: 2e23778ded72e3f4c9d0514d39c377f34ec1e4cd [file] [log] [blame] [edit]
/*-------------------------------------------------------------------------
* 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 Mipmapping tests.
*//*--------------------------------------------------------------------*/
#include "es3fTextureMipmapTests.hpp"
#include "glsTextureTestUtil.hpp"
#include "gluTexture.hpp"
#include "gluTextureUtil.hpp"
#include "gluPixelTransfer.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuMatrix.hpp"
#include "tcuMatrixUtil.hpp"
#include "tcuTexLookupVerifier.hpp"
#include "tcuVectorUtil.hpp"
#include "deStringUtil.hpp"
#include "deRandom.hpp"
#include "deString.h"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"
using std::string;
using std::vector;
using namespace deqp::gls;
namespace deqp
{
namespace gles3
{
namespace Functional
{
using std::string;
using std::vector;
using tcu::IVec4;
using tcu::TestLog;
using tcu::Vec2;
using tcu::Vec3;
using tcu::Vec4;
using namespace gls::TextureTestUtil;
using namespace glu::TextureTestUtil;
static float getMinLodForCell(int cellNdx)
{
static const float s_values[] = {1.0f, 3.5f, 2.0f, -2.0f, 0.0f, 3.0f, 10.0f, 4.8f,
5.8f, 5.7f, -1.9f, 4.0f, 6.5f, 7.1f, -1e10, 1000.f};
return s_values[cellNdx % DE_LENGTH_OF_ARRAY(s_values)];
}
static float getMaxLodForCell(int cellNdx)
{
static const float s_values[] = {0.0f, 0.2f, 0.7f, 0.4f, 1.3f, 0.0f, 0.5f, 1.2f, -2.0f,
1.0f, 0.1f, 0.3f, 2.7f, 1.2f, 10.0f, -1000.f, 1e10f};
return s_values[cellNdx % DE_LENGTH_OF_ARRAY(s_values)];
}
enum CoordType
{
COORDTYPE_BASIC, //!< texCoord = translateScale(position).
COORDTYPE_BASIC_BIAS, //!< Like basic, but with bias values.
COORDTYPE_AFFINE, //!< texCoord = translateScaleRotateShear(position).
COORDTYPE_PROJECTED, //!< Projected coordinates, w != 1
COORDTYPE_LAST
};
// Texture2DMipmapCase
class Texture2DMipmapCase : public tcu::TestCase
{
public:
Texture2DMipmapCase(tcu::TestContext &testCtx, glu::RenderContext &renderCtx, const glu::ContextInfo &renderCtxInfo,
const char *name, const char *desc, CoordType coordType, uint32_t minFilter, uint32_t wrapS,
uint32_t wrapT, uint32_t format, uint32_t dataType, int width, int height);
~Texture2DMipmapCase(void);
void init(void);
void deinit(void);
IterateResult iterate(void);
private:
Texture2DMipmapCase(const Texture2DMipmapCase &other);
Texture2DMipmapCase &operator=(const Texture2DMipmapCase &other);
glu::RenderContext &m_renderCtx;
const glu::ContextInfo &m_renderCtxInfo;
CoordType m_coordType;
uint32_t m_minFilter;
uint32_t m_wrapS;
uint32_t m_wrapT;
uint32_t m_format;
uint32_t m_dataType;
int m_width;
int m_height;
glu::Texture2D *m_texture;
TextureRenderer m_renderer;
};
Texture2DMipmapCase::Texture2DMipmapCase(tcu::TestContext &testCtx, glu::RenderContext &renderCtx,
const glu::ContextInfo &renderCtxInfo, const char *name, const char *desc,
CoordType coordType, uint32_t minFilter, uint32_t wrapS, uint32_t wrapT,
uint32_t format, uint32_t dataType, int width, int height)
: TestCase(testCtx, name, desc)
, m_renderCtx(renderCtx)
, m_renderCtxInfo(renderCtxInfo)
, m_coordType(coordType)
, m_minFilter(minFilter)
, m_wrapS(wrapS)
, m_wrapT(wrapT)
, m_format(format)
, m_dataType(dataType)
, m_width(width)
, m_height(height)
, m_texture(DE_NULL)
, m_renderer(renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
{
}
Texture2DMipmapCase::~Texture2DMipmapCase(void)
{
deinit();
}
void Texture2DMipmapCase::init(void)
{
if (m_coordType == COORDTYPE_PROJECTED && m_renderCtx.getRenderTarget().getNumSamples() > 0)
throw tcu::NotSupportedError("Projected lookup validation not supported in multisample config");
m_texture = new glu::Texture2D(m_renderCtx, m_format, m_dataType, m_width, m_height);
int numLevels = deLog2Floor32(de::max(m_width, m_height)) + 1;
// Fill texture with colored grid.
for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
{
uint32_t step = 0xff / (numLevels - 1);
uint32_t inc = deClamp32(step * levelNdx, 0x00, 0xff);
uint32_t dec = 0xff - inc;
uint32_t rgb = (inc << 16) | (dec << 8) | 0xff;
uint32_t color = 0xff000000 | rgb;
m_texture->getRefTexture().allocLevel(levelNdx);
tcu::clear(m_texture->getRefTexture().getLevel(levelNdx), tcu::RGBA(color).toVec());
}
}
void Texture2DMipmapCase::deinit(void)
{
delete m_texture;
m_texture = DE_NULL;
m_renderer.clear();
}
static void getBasicTexCoord2D(std::vector<float> &dst, int cellNdx)
{
static const struct
{
Vec2 bottomLeft;
Vec2 topRight;
} s_basicCoords[] = {
{Vec2(-0.1f, 0.1f), Vec2(0.8f, 1.0f)}, {Vec2(-0.3f, -0.6f), Vec2(0.7f, 0.4f)},
{Vec2(-0.3f, 0.6f), Vec2(0.7f, -0.9f)}, {Vec2(-0.8f, 0.6f), Vec2(0.7f, -0.9f)},
{Vec2(-0.5f, -0.5f), Vec2(1.5f, 1.5f)}, {Vec2(1.0f, -1.0f), Vec2(-1.3f, 1.0f)},
{Vec2(1.2f, -1.0f), Vec2(-1.3f, 1.6f)}, {Vec2(2.2f, -1.1f), Vec2(-1.3f, 0.8f)},
{Vec2(-1.5f, 1.6f), Vec2(1.7f, -1.4f)}, {Vec2(2.0f, 1.6f), Vec2(2.3f, -1.4f)},
{Vec2(1.3f, -2.6f), Vec2(-2.7f, 2.9f)}, {Vec2(-0.8f, -6.6f), Vec2(6.0f, -0.9f)},
{Vec2(-8.0f, 9.0f), Vec2(8.3f, -7.0f)}, {Vec2(-16.0f, 10.0f), Vec2(18.3f, 24.0f)},
{Vec2(30.2f, 55.0f), Vec2(-24.3f, -1.6f)}, {Vec2(-33.2f, 64.1f), Vec2(32.1f, -64.1f)},
};
DE_ASSERT(de::inBounds(cellNdx, 0, DE_LENGTH_OF_ARRAY(s_basicCoords)));
const Vec2 &bottomLeft = s_basicCoords[cellNdx].bottomLeft;
const Vec2 &topRight = s_basicCoords[cellNdx].topRight;
computeQuadTexCoord2D(dst, bottomLeft, topRight);
}
static void getAffineTexCoord2D(std::vector<float> &dst, int cellNdx)
{
// Use basic coords as base.
getBasicTexCoord2D(dst, cellNdx);
// Rotate based on cell index.
float angle = 2.0f * DE_PI * ((float)cellNdx / 16.0f);
tcu::Mat2 rotMatrix = tcu::rotationMatrix(angle);
// Second and third row are sheared.
float shearX = de::inRange(cellNdx, 4, 11) ? (float)(15 - cellNdx) / 16.0f : 0.0f;
tcu::Mat2 shearMatrix = tcu::shearMatrix(tcu::Vec2(shearX, 0.0f));
tcu::Mat2 transform = rotMatrix * shearMatrix;
Vec2 p0 = transform * Vec2(dst[0], dst[1]);
Vec2 p1 = transform * Vec2(dst[2], dst[3]);
Vec2 p2 = transform * Vec2(dst[4], dst[5]);
Vec2 p3 = transform * Vec2(dst[6], dst[7]);
dst[0] = p0.x();
dst[1] = p0.y();
dst[2] = p1.x();
dst[3] = p1.y();
dst[4] = p2.x();
dst[5] = p2.y();
dst[6] = p3.x();
dst[7] = p3.y();
}
Texture2DMipmapCase::IterateResult Texture2DMipmapCase::iterate(void)
{
const glw::Functions &gl = m_renderCtx.getFunctions();
const tcu::Texture2D &refTexture = m_texture->getRefTexture();
const uint32_t magFilter = GL_NEAREST;
const int texWidth = refTexture.getWidth();
const int texHeight = refTexture.getHeight();
const int defViewportWidth = texWidth * 4;
const int defViewportHeight = texHeight * 4;
const RandomViewport viewport(m_renderCtx.getRenderTarget(), defViewportWidth, defViewportHeight,
deStringHash(getName()));
ReferenceParams sampleParams(TEXTURETYPE_2D);
vector<float> texCoord;
const bool isProjected = m_coordType == COORDTYPE_PROJECTED;
const bool useLodBias = m_coordType == COORDTYPE_BASIC_BIAS;
tcu::Surface renderedFrame(viewport.width, viewport.height);
// Viewport is divided into 4x4 grid.
int gridWidth = 4;
int gridHeight = 4;
int cellWidth = viewport.width / gridWidth;
int cellHeight = viewport.height / gridHeight;
// Bail out if rendertarget is too small.
if (viewport.width < defViewportWidth / 2 || viewport.height < defViewportHeight / 2)
throw tcu::NotSupportedError("Too small viewport", "", __FILE__, __LINE__);
// Sampling parameters.
sampleParams.sampler = glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, magFilter);
sampleParams.samplerType = glu::TextureTestUtil::getSamplerType(m_texture->getRefTexture().getFormat());
sampleParams.flags = (isProjected ? ReferenceParams::PROJECTED : 0) | (useLodBias ? ReferenceParams::USE_BIAS : 0);
sampleParams.lodMode = LODMODE_EXACT; // Use ideal lod.
// Upload texture data.
m_texture->upload();
// Bind gradient texture and setup sampler parameters.
gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture());
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, magFilter);
GLU_EXPECT_NO_ERROR(gl.getError(), "After texture setup");
// Bias values.
static const float s_bias[] = {1.0f, -2.0f, 0.8f, -0.5f, 1.5f, 0.9f, 2.0f, 4.0f};
// Projection values.
static const Vec4 s_projections[] = {Vec4(1.2f, 1.0f, 0.7f, 1.0f), Vec4(1.3f, 0.8f, 0.6f, 2.0f),
Vec4(0.8f, 1.0f, 1.7f, 0.6f), Vec4(1.2f, 1.0f, 1.7f, 1.5f)};
// Render cells.
for (int gridY = 0; gridY < gridHeight; gridY++)
{
for (int gridX = 0; gridX < gridWidth; gridX++)
{
const int curX = cellWidth * gridX;
const int curY = cellHeight * gridY;
const int curW = gridX + 1 == gridWidth ? (viewport.width - curX) : cellWidth;
const int curH = gridY + 1 == gridHeight ? (viewport.height - curY) : cellHeight;
const int cellNdx = gridY * gridWidth + gridX;
// Compute texcoord.
switch (m_coordType)
{
case COORDTYPE_BASIC_BIAS: // Fall-through.
case COORDTYPE_PROJECTED:
case COORDTYPE_BASIC:
getBasicTexCoord2D(texCoord, cellNdx);
break;
case COORDTYPE_AFFINE:
getAffineTexCoord2D(texCoord, cellNdx);
break;
default:
DE_ASSERT(false);
}
if (isProjected)
sampleParams.w = s_projections[cellNdx % DE_LENGTH_OF_ARRAY(s_projections)];
if (useLodBias)
sampleParams.bias = s_bias[cellNdx % DE_LENGTH_OF_ARRAY(s_bias)];
// Render with GL.
gl.viewport(viewport.x + curX, viewport.y + curY, curW, curH);
m_renderer.renderQuad(0, &texCoord[0], sampleParams);
}
}
// Read result.
glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
// Compare and log.
{
const tcu::PixelFormat &pixelFormat = m_renderCtx.getRenderTarget().getPixelFormat();
const bool isTrilinear = m_minFilter == GL_NEAREST_MIPMAP_LINEAR || m_minFilter == GL_LINEAR_MIPMAP_LINEAR;
tcu::Surface referenceFrame(viewport.width, viewport.height);
tcu::Surface errorMask(viewport.width, viewport.height);
tcu::LookupPrecision lookupPrec;
tcu::LodPrecision lodPrec;
int numFailedPixels = 0;
lookupPrec.coordBits = tcu::IVec3(20, 20, 0);
lookupPrec.uvwBits = tcu::IVec3(16, 16, 0); // Doesn't really matter since pixels are unicolored.
lookupPrec.colorThreshold =
tcu::computeFixedPointThreshold(max(getBitsVec(pixelFormat) - (isTrilinear ? 2 : 1), tcu::IVec4(0)));
lookupPrec.colorMask = getCompareMask(pixelFormat);
lodPrec.derivateBits = 10;
lodPrec.lodBits = isProjected ? 6 : 8;
for (int gridY = 0; gridY < gridHeight; gridY++)
{
for (int gridX = 0; gridX < gridWidth; gridX++)
{
const int curX = cellWidth * gridX;
const int curY = cellHeight * gridY;
const int curW = gridX + 1 == gridWidth ? (viewport.width - curX) : cellWidth;
const int curH = gridY + 1 == gridHeight ? (viewport.height - curY) : cellHeight;
const int cellNdx = gridY * gridWidth + gridX;
// Compute texcoord.
switch (m_coordType)
{
case COORDTYPE_BASIC_BIAS: // Fall-through.
case COORDTYPE_PROJECTED:
case COORDTYPE_BASIC:
getBasicTexCoord2D(texCoord, cellNdx);
break;
case COORDTYPE_AFFINE:
getAffineTexCoord2D(texCoord, cellNdx);
break;
default:
DE_ASSERT(false);
}
if (isProjected)
sampleParams.w = s_projections[cellNdx % DE_LENGTH_OF_ARRAY(s_projections)];
if (useLodBias)
sampleParams.bias = s_bias[cellNdx % DE_LENGTH_OF_ARRAY(s_bias)];
// Render ideal result
sampleTexture(tcu::SurfaceAccess(referenceFrame, pixelFormat, curX, curY, curW, curH), refTexture,
&texCoord[0], sampleParams);
// Compare this cell
numFailedPixels += computeTextureLookupDiff(
tcu::getSubregion(renderedFrame.getAccess(), curX, curY, curW, curH),
tcu::getSubregion(referenceFrame.getAccess(), curX, curY, curW, curH),
tcu::getSubregion(errorMask.getAccess(), curX, curY, curW, curH), m_texture->getRefTexture(),
&texCoord[0], sampleParams, lookupPrec, lodPrec, m_testCtx.getWatchDog());
}
}
if (numFailedPixels > 0)
m_testCtx.getLog() << TestLog::Message << "ERROR: Image verification failed, found " << numFailedPixels
<< " invalid pixels!" << TestLog::EndMessage;
m_testCtx.getLog() << TestLog::ImageSet("Result", "Verification result")
<< TestLog::Image("Rendered", "Rendered image", renderedFrame);
if (numFailedPixels > 0)
{
m_testCtx.getLog() << TestLog::Image("Reference", "Ideal reference", referenceFrame)
<< TestLog::Image("ErrorMask", "Error mask", errorMask);
}
m_testCtx.getLog() << TestLog::EndImageSet;
{
const bool isOk = numFailedPixels == 0;
m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
isOk ? "Pass" : "Image verification failed");
}
}
return STOP;
}
// TextureCubeMipmapCase
class TextureCubeMipmapCase : public tcu::TestCase
{
public:
TextureCubeMipmapCase(tcu::TestContext &testCtx, glu::RenderContext &renderCtx,
const glu::ContextInfo &renderCtxInfo, const char *name, const char *desc,
CoordType coordType, uint32_t minFilter, uint32_t wrapS, uint32_t wrapT, uint32_t format,
uint32_t dataType, int size);
~TextureCubeMipmapCase(void);
void init(void);
void deinit(void);
IterateResult iterate(void);
private:
TextureCubeMipmapCase(const TextureCubeMipmapCase &other);
TextureCubeMipmapCase &operator=(const TextureCubeMipmapCase &other);
glu::RenderContext &m_renderCtx;
const glu::ContextInfo &m_renderCtxInfo;
CoordType m_coordType;
uint32_t m_minFilter;
uint32_t m_wrapS;
uint32_t m_wrapT;
uint32_t m_format;
uint32_t m_dataType;
int m_size;
glu::TextureCube *m_texture;
TextureRenderer m_renderer;
};
TextureCubeMipmapCase::TextureCubeMipmapCase(tcu::TestContext &testCtx, glu::RenderContext &renderCtx,
const glu::ContextInfo &renderCtxInfo, const char *name, const char *desc,
CoordType coordType, uint32_t minFilter, uint32_t wrapS, uint32_t wrapT,
uint32_t format, uint32_t dataType, int size)
: TestCase(testCtx, name, desc)
, m_renderCtx(renderCtx)
, m_renderCtxInfo(renderCtxInfo)
, m_coordType(coordType)
, m_minFilter(minFilter)
, m_wrapS(wrapS)
, m_wrapT(wrapT)
, m_format(format)
, m_dataType(dataType)
, m_size(size)
, m_texture(DE_NULL)
, m_renderer(renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
{
}
TextureCubeMipmapCase::~TextureCubeMipmapCase(void)
{
deinit();
}
void TextureCubeMipmapCase::init(void)
{
if (m_coordType == COORDTYPE_PROJECTED && m_renderCtx.getRenderTarget().getNumSamples() > 0)
throw tcu::NotSupportedError("Projected lookup validation not supported in multisample config");
m_texture = new glu::TextureCube(m_renderCtx, m_format, m_dataType, m_size);
int numLevels = deLog2Floor32(m_size) + 1;
// Fill texture with colored grid.
for (int faceNdx = 0; faceNdx < tcu::CUBEFACE_LAST; faceNdx++)
{
for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
{
uint32_t step = 0xff / (numLevels - 1);
uint32_t inc = deClamp32(step * levelNdx, 0x00, 0xff);
uint32_t dec = 0xff - inc;
uint32_t rgb = 0;
switch (faceNdx)
{
case 0:
rgb = (inc << 16) | (dec << 8) | 255;
break;
case 1:
rgb = (255 << 16) | (inc << 8) | dec;
break;
case 2:
rgb = (dec << 16) | (255 << 8) | inc;
break;
case 3:
rgb = (dec << 16) | (inc << 8) | 255;
break;
case 4:
rgb = (255 << 16) | (dec << 8) | inc;
break;
case 5:
rgb = (inc << 16) | (255 << 8) | dec;
break;
}
uint32_t color = 0xff000000 | rgb;
m_texture->getRefTexture().allocLevel((tcu::CubeFace)faceNdx, levelNdx);
tcu::clear(m_texture->getRefTexture().getLevelFace(levelNdx, (tcu::CubeFace)faceNdx),
tcu::RGBA(color).toVec());
}
}
}
void TextureCubeMipmapCase::deinit(void)
{
delete m_texture;
m_texture = DE_NULL;
m_renderer.clear();
}
static void randomPartition(vector<IVec4> &dst, de::Random &rnd, int x, int y, int width, int height)
{
const int minWidth = 8;
const int minHeight = 8;
bool partition = rnd.getFloat() > 0.4f;
bool partitionX = partition && width > minWidth && rnd.getBool();
bool partitionY = partition && height > minHeight && !partitionX;
if (partitionX)
{
int split = width / 2 + rnd.getInt(-width / 4, +width / 4);
randomPartition(dst, rnd, x, y, split, height);
randomPartition(dst, rnd, x + split, y, width - split, height);
}
else if (partitionY)
{
int split = height / 2 + rnd.getInt(-height / 4, +height / 4);
randomPartition(dst, rnd, x, y, width, split);
randomPartition(dst, rnd, x, y + split, width, height - split);
}
else
dst.push_back(IVec4(x, y, width, height));
}
static void computeGridLayout(vector<IVec4> &dst, int width, int height)
{
de::Random rnd(7);
randomPartition(dst, rnd, 0, 0, width, height);
}
TextureCubeMipmapCase::IterateResult TextureCubeMipmapCase::iterate(void)
{
const uint32_t magFilter = GL_NEAREST;
const int texWidth = m_texture->getRefTexture().getSize();
const int texHeight = m_texture->getRefTexture().getSize();
const int defViewportWidth = texWidth * 2;
const int defViewportHeight = texHeight * 2;
const glw::Functions &gl = m_renderCtx.getFunctions();
const RandomViewport viewport(m_renderCtx.getRenderTarget(), defViewportWidth, defViewportHeight,
deStringHash(getName()));
const bool isProjected = m_coordType == COORDTYPE_PROJECTED;
const bool useLodBias = m_coordType == COORDTYPE_BASIC_BIAS;
vector<float> texCoord;
tcu::Surface renderedFrame(viewport.width, viewport.height);
// Bail out if rendertarget is too small.
if (viewport.width < defViewportWidth / 2 || viewport.height < defViewportHeight / 2)
throw tcu::NotSupportedError("Too small viewport", "", __FILE__, __LINE__);
// Upload texture data.
m_texture->upload();
// Bind gradient texture and setup sampler parameters.
gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_texture->getGLTexture());
gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, m_wrapS);
gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, m_wrapT);
gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, m_minFilter);
gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, magFilter);
GLU_EXPECT_NO_ERROR(gl.getError(), "After texture setup");
// Compute grid.
vector<IVec4> gridLayout;
computeGridLayout(gridLayout, viewport.width, viewport.height);
// Bias values.
static const float s_bias[] = {1.0f, -2.0f, 0.8f, -0.5f, 1.5f, 0.9f, 2.0f, 4.0f};
// Projection values \note Less agressive than in 2D case due to smaller quads.
static const Vec4 s_projections[] = {Vec4(1.2f, 1.0f, 0.7f, 1.0f), Vec4(1.3f, 0.8f, 0.6f, 1.1f),
Vec4(0.8f, 1.0f, 1.2f, 0.8f), Vec4(1.2f, 1.0f, 1.3f, 0.9f)};
// Render with GL
for (int cellNdx = 0; cellNdx < (int)gridLayout.size(); cellNdx++)
{
const int curX = gridLayout[cellNdx].x();
const int curY = gridLayout[cellNdx].y();
const int curW = gridLayout[cellNdx].z();
const int curH = gridLayout[cellNdx].w();
const tcu::CubeFace cubeFace = (tcu::CubeFace)(cellNdx % tcu::CUBEFACE_LAST);
RenderParams params(TEXTURETYPE_CUBE);
DE_ASSERT(m_coordType != COORDTYPE_AFFINE); // Not supported.
computeQuadTexCoordCube(texCoord, cubeFace);
if (isProjected)
{
params.flags |= ReferenceParams::PROJECTED;
params.w = s_projections[cellNdx % DE_LENGTH_OF_ARRAY(s_projections)];
}
if (useLodBias)
{
params.flags |= ReferenceParams::USE_BIAS;
params.bias = s_bias[cellNdx % DE_LENGTH_OF_ARRAY(s_bias)];
}
// Render with GL.
gl.viewport(viewport.x + curX, viewport.y + curY, curW, curH);
m_renderer.renderQuad(0, &texCoord[0], params);
}
GLU_EXPECT_NO_ERROR(gl.getError(), "Draw");
// Read result.
glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess());
GLU_EXPECT_NO_ERROR(gl.getError(), "Read pixels");
// Render reference and compare
{
tcu::Surface referenceFrame(viewport.width, viewport.height);
tcu::Surface errorMask(viewport.width, viewport.height);
int numFailedPixels = 0;
ReferenceParams params(TEXTURETYPE_CUBE);
tcu::LookupPrecision lookupPrec;
tcu::LodPrecision lodPrec;
// Params for rendering reference
params.sampler = glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, magFilter);
params.sampler.seamlessCubeMap = true;
params.lodMode = LODMODE_EXACT;
// Comparison parameters
lookupPrec.colorMask = getCompareMask(m_renderCtx.getRenderTarget().getPixelFormat());
lookupPrec.colorThreshold = tcu::computeFixedPointThreshold(
max(getBitsVec(m_renderCtx.getRenderTarget().getPixelFormat()) - 2, IVec4(0)));
lookupPrec.coordBits = isProjected ? tcu::IVec3(8) : tcu::IVec3(10);
lookupPrec.uvwBits = tcu::IVec3(5, 5, 0);
lodPrec.derivateBits = 10;
lodPrec.lodBits = isProjected ? 3 : 6;
for (int cellNdx = 0; cellNdx < (int)gridLayout.size(); cellNdx++)
{
const int curX = gridLayout[cellNdx].x();
const int curY = gridLayout[cellNdx].y();
const int curW = gridLayout[cellNdx].z();
const int curH = gridLayout[cellNdx].w();
const tcu::CubeFace cubeFace = (tcu::CubeFace)(cellNdx % tcu::CUBEFACE_LAST);
DE_ASSERT(m_coordType != COORDTYPE_AFFINE); // Not supported.
computeQuadTexCoordCube(texCoord, cubeFace);
if (isProjected)
{
params.flags |= ReferenceParams::PROJECTED;
params.w = s_projections[cellNdx % DE_LENGTH_OF_ARRAY(s_projections)];
}
if (useLodBias)
{
params.flags |= ReferenceParams::USE_BIAS;
params.bias = s_bias[cellNdx % DE_LENGTH_OF_ARRAY(s_bias)];
}
// Render ideal reference.
{
tcu::SurfaceAccess idealDst(referenceFrame, m_renderCtx.getRenderTarget().getPixelFormat(), curX, curY,
curW, curH);
sampleTexture(idealDst, m_texture->getRefTexture(), &texCoord[0], params);
}
// Compare this cell
numFailedPixels += computeTextureLookupDiff(
tcu::getSubregion(renderedFrame.getAccess(), curX, curY, curW, curH),
tcu::getSubregion(referenceFrame.getAccess(), curX, curY, curW, curH),
tcu::getSubregion(errorMask.getAccess(), curX, curY, curW, curH), m_texture->getRefTexture(),
&texCoord[0], params, lookupPrec, lodPrec, m_testCtx.getWatchDog());
}
if (numFailedPixels > 0)
m_testCtx.getLog() << TestLog::Message << "ERROR: Image verification failed, found " << numFailedPixels
<< " invalid pixels!" << TestLog::EndMessage;
m_testCtx.getLog() << TestLog::ImageSet("Result", "Verification result")
<< TestLog::Image("Rendered", "Rendered image", renderedFrame);
if (numFailedPixels > 0)
{
m_testCtx.getLog() << TestLog::Image("Reference", "Ideal reference", referenceFrame)
<< TestLog::Image("ErrorMask", "Error mask", errorMask);
}
m_testCtx.getLog() << TestLog::EndImageSet;
{
const bool isOk = numFailedPixels == 0;
m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
isOk ? "Pass" : "Image verification failed");
}
}
return STOP;
}
// Texture2DGenMipmapCase
class Texture2DGenMipmapCase : public tcu::TestCase
{
public:
Texture2DGenMipmapCase(tcu::TestContext &testCtx, glu::RenderContext &renderCtx, const char *name, const char *desc,
uint32_t format, uint32_t dataType, uint32_t hint, int width, int height);
~Texture2DGenMipmapCase(void);
void init(void);
void deinit(void);
IterateResult iterate(void);
private:
Texture2DGenMipmapCase(const Texture2DGenMipmapCase &other);
Texture2DGenMipmapCase &operator=(const Texture2DGenMipmapCase &other);
glu::RenderContext &m_renderCtx;
uint32_t m_format;
uint32_t m_dataType;
uint32_t m_hint;
int m_width;
int m_height;
glu::Texture2D *m_texture;
TextureRenderer m_renderer;
};
Texture2DGenMipmapCase::Texture2DGenMipmapCase(tcu::TestContext &testCtx, glu::RenderContext &renderCtx,
const char *name, const char *desc, uint32_t format, uint32_t dataType,
uint32_t hint, int width, int height)
: TestCase(testCtx, name, desc)
, m_renderCtx(renderCtx)
, m_format(format)
, m_dataType(dataType)
, m_hint(hint)
, m_width(width)
, m_height(height)
, m_texture(DE_NULL)
, m_renderer(renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
{
}
Texture2DGenMipmapCase::~Texture2DGenMipmapCase(void)
{
deinit();
}
void Texture2DGenMipmapCase::init(void)
{
DE_ASSERT(!m_texture);
m_texture = new glu::Texture2D(m_renderCtx, m_format, m_dataType, m_width, m_height);
}
void Texture2DGenMipmapCase::deinit(void)
{
delete m_texture;
m_texture = DE_NULL;
m_renderer.clear();
}
Texture2DGenMipmapCase::IterateResult Texture2DGenMipmapCase::iterate(void)
{
const glw::Functions &gl = m_renderCtx.getFunctions();
const uint32_t minFilter = GL_NEAREST_MIPMAP_NEAREST;
const uint32_t magFilter = GL_NEAREST;
const uint32_t wrapS = GL_CLAMP_TO_EDGE;
const uint32_t wrapT = GL_CLAMP_TO_EDGE;
const int numLevels = deLog2Floor32(de::max(m_width, m_height)) + 1;
tcu::Texture2D resultTexture(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8),
m_texture->getRefTexture().getWidth(), m_texture->getRefTexture().getHeight());
vector<float> texCoord;
// Initialize texture level 0 with colored grid.
m_texture->getRefTexture().allocLevel(0);
tcu::fillWithGrid(m_texture->getRefTexture().getLevel(0), 8, tcu::Vec4(1.0f, 0.5f, 0.0f, 0.5f),
tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f));
// Upload data and setup params.
m_texture->upload();
gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture());
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapS);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapT);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);
GLU_EXPECT_NO_ERROR(gl.getError(), "After texture setup");
// Generate mipmap.
gl.hint(GL_GENERATE_MIPMAP_HINT, m_hint);
gl.generateMipmap(GL_TEXTURE_2D);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenerateMipmap()");
// Use (0, 0) -> (1, 1) texture coordinates.
computeQuadTexCoord2D(texCoord, Vec2(0.0f, 0.0f), Vec2(1.0f, 1.0f));
// Fetch resulting texture by rendering.
for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
{
const int levelWidth = de::max(1, m_width >> levelNdx);
const int levelHeight = de::max(1, m_height >> levelNdx);
const RandomViewport viewport(m_renderCtx.getRenderTarget(), levelWidth, levelHeight,
deStringHash(getName()) + levelNdx);
gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
m_renderer.renderQuad(0, &texCoord[0], TEXTURETYPE_2D);
resultTexture.allocLevel(levelNdx);
glu::readPixels(m_renderCtx, viewport.x, viewport.y, resultTexture.getLevel(levelNdx));
}
// Compare results
{
const IVec4 framebufferBits = max(getBitsVec(m_renderCtx.getRenderTarget().getPixelFormat()) - 2, IVec4(0));
const IVec4 formatBits = tcu::getTextureFormatBitDepth(glu::mapGLTransferFormat(m_format, m_dataType));
const tcu::BVec4 formatMask = greaterThan(formatBits, IVec4(0));
const IVec4 cmpBits = select(min(framebufferBits, formatBits), framebufferBits, formatMask);
GenMipmapPrecision comparePrec;
comparePrec.colorMask = getCompareMask(m_renderCtx.getRenderTarget().getPixelFormat());
comparePrec.colorThreshold = tcu::computeFixedPointThreshold(cmpBits);
comparePrec.filterBits = tcu::IVec3(4, 4, 0);
const qpTestResult compareResult =
compareGenMipmapResult(m_testCtx.getLog(), resultTexture, m_texture->getRefTexture(), comparePrec);
m_testCtx.setTestResult(compareResult, compareResult == QP_TEST_RESULT_PASS ? "Pass" :
compareResult == QP_TEST_RESULT_QUALITY_WARNING ?
"Low-quality method used" :
compareResult == QP_TEST_RESULT_FAIL ? "Image comparison failed" :
"");
}
return STOP;
}
// TextureCubeGenMipmapCase
class TextureCubeGenMipmapCase : public tcu::TestCase
{
public:
TextureCubeGenMipmapCase(tcu::TestContext &testCtx, glu::RenderContext &renderCtx, const char *name,
const char *desc, uint32_t format, uint32_t dataType, uint32_t hint, int size);
~TextureCubeGenMipmapCase(void);
void init(void);
void deinit(void);
IterateResult iterate(void);
private:
TextureCubeGenMipmapCase(const TextureCubeGenMipmapCase &other);
TextureCubeGenMipmapCase &operator=(const TextureCubeGenMipmapCase &other);
glu::RenderContext &m_renderCtx;
uint32_t m_format;
uint32_t m_dataType;
uint32_t m_hint;
int m_size;
glu::TextureCube *m_texture;
TextureRenderer m_renderer;
};
TextureCubeGenMipmapCase::TextureCubeGenMipmapCase(tcu::TestContext &testCtx, glu::RenderContext &renderCtx,
const char *name, const char *desc, uint32_t format,
uint32_t dataType, uint32_t hint, int size)
: TestCase(testCtx, name, desc)
, m_renderCtx(renderCtx)
, m_format(format)
, m_dataType(dataType)
, m_hint(hint)
, m_size(size)
, m_texture(DE_NULL)
, m_renderer(renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_HIGHP)
{
}
TextureCubeGenMipmapCase::~TextureCubeGenMipmapCase(void)
{
deinit();
}
void TextureCubeGenMipmapCase::init(void)
{
if (m_renderCtx.getRenderTarget().getWidth() < 3 * m_size || m_renderCtx.getRenderTarget().getHeight() < 2 * m_size)
throw tcu::NotSupportedError("Render target size must be at least (" + de::toString(3 * m_size) + ", " +
de::toString(2 * m_size) + ")");
DE_ASSERT(!m_texture);
m_texture = new glu::TextureCube(m_renderCtx, m_format, m_dataType, m_size);
}
void TextureCubeGenMipmapCase::deinit(void)
{
delete m_texture;
m_texture = DE_NULL;
m_renderer.clear();
}
TextureCubeGenMipmapCase::IterateResult TextureCubeGenMipmapCase::iterate(void)
{
const glw::Functions &gl = m_renderCtx.getFunctions();
const uint32_t minFilter = GL_NEAREST_MIPMAP_NEAREST;
const uint32_t magFilter = GL_NEAREST;
const uint32_t wrapS = GL_CLAMP_TO_EDGE;
const uint32_t wrapT = GL_CLAMP_TO_EDGE;
tcu::TextureCube resultTexture(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8),
m_size);
const int numLevels = deLog2Floor32(m_size) + 1;
vector<float> texCoord;
// Initialize texture level 0 with colored grid.
for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
{
Vec4 ca, cb; // Grid colors.
switch (face)
{
case 0:
ca = Vec4(1.0f, 0.3f, 0.0f, 0.7f);
cb = Vec4(0.0f, 0.0f, 1.0f, 1.0f);
break;
case 1:
ca = Vec4(0.0f, 1.0f, 0.5f, 0.5f);
cb = Vec4(1.0f, 0.0f, 0.0f, 1.0f);
break;
case 2:
ca = Vec4(0.7f, 0.0f, 1.0f, 0.3f);
cb = Vec4(0.0f, 1.0f, 0.0f, 1.0f);
break;
case 3:
ca = Vec4(0.0f, 0.3f, 1.0f, 1.0f);
cb = Vec4(1.0f, 0.0f, 0.0f, 0.7f);
break;
case 4:
ca = Vec4(1.0f, 0.0f, 0.5f, 1.0f);
cb = Vec4(0.0f, 1.0f, 0.0f, 0.5f);
break;
case 5:
ca = Vec4(0.7f, 1.0f, 0.0f, 1.0f);
cb = Vec4(0.0f, 0.0f, 1.0f, 0.3f);
break;
}
m_texture->getRefTexture().allocLevel((tcu::CubeFace)face, 0);
fillWithGrid(m_texture->getRefTexture().getLevelFace(0, (tcu::CubeFace)face), 8, ca, cb);
}
// Upload data and setup params.
m_texture->upload();
gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_texture->getGLTexture());
gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, wrapS);
gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, wrapT);
gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, minFilter);
gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, magFilter);
GLU_EXPECT_NO_ERROR(gl.getError(), "After texture setup");
// Generate mipmap.
gl.hint(GL_GENERATE_MIPMAP_HINT, m_hint);
gl.generateMipmap(GL_TEXTURE_CUBE_MAP);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenerateMipmap()");
// Render all levels.
for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
{
const int levelWidth = de::max(1, m_size >> levelNdx);
const int levelHeight = de::max(1, m_size >> levelNdx);
for (int faceNdx = 0; faceNdx < tcu::CUBEFACE_LAST; faceNdx++)
{
const RandomViewport viewport(m_renderCtx.getRenderTarget(), levelWidth * 3, levelHeight * 2,
deStringHash(getName()) ^ deInt32Hash(levelNdx + faceNdx));
const tcu::CubeFace face = tcu::CubeFace(faceNdx);
computeQuadTexCoordCube(texCoord, face);
gl.viewport(viewport.x, viewport.y, levelWidth, levelHeight);
m_renderer.renderQuad(0, &texCoord[0], TEXTURETYPE_CUBE);
resultTexture.allocLevel(face, levelNdx);
glu::readPixels(m_renderCtx, viewport.x, viewport.y, resultTexture.getLevelFace(levelNdx, face));
}
}
// Compare results
{
const IVec4 framebufferBits = max(getBitsVec(m_renderCtx.getRenderTarget().getPixelFormat()) - 2, IVec4(0));
const IVec4 formatBits = tcu::getTextureFormatBitDepth(glu::mapGLTransferFormat(m_format, m_dataType));
const tcu::BVec4 formatMask = greaterThan(formatBits, IVec4(0));
const IVec4 cmpBits = select(min(framebufferBits, formatBits), framebufferBits, formatMask);
GenMipmapPrecision comparePrec;
comparePrec.colorMask = getCompareMask(m_renderCtx.getRenderTarget().getPixelFormat());
comparePrec.colorThreshold = tcu::computeFixedPointThreshold(cmpBits);
comparePrec.filterBits = tcu::IVec3(4, 4, 0);
const qpTestResult compareResult =
compareGenMipmapResult(m_testCtx.getLog(), resultTexture, m_texture->getRefTexture(), comparePrec);
m_testCtx.setTestResult(compareResult, compareResult == QP_TEST_RESULT_PASS ? "Pass" :
compareResult == QP_TEST_RESULT_QUALITY_WARNING ?
"Low-quality method used" :
compareResult == QP_TEST_RESULT_FAIL ? "Image comparison failed" :
"");
}
return STOP;
}
// Texture3DMipmapCase
class Texture3DMipmapCase : public TestCase
{
public:
Texture3DMipmapCase(Context &context, const char *name, const char *desc, CoordType coordType, uint32_t minFilter,
uint32_t wrapS, uint32_t wrapT, uint32_t wrapR, uint32_t format, int width, int height,
int depth);
~Texture3DMipmapCase(void);
void init(void);
void deinit(void);
IterateResult iterate(void);
private:
Texture3DMipmapCase(const Texture3DMipmapCase &other);
Texture3DMipmapCase &operator=(const Texture3DMipmapCase &other);
CoordType m_coordType;
uint32_t m_minFilter;
uint32_t m_wrapS;
uint32_t m_wrapT;
uint32_t m_wrapR;
uint32_t m_internalFormat;
int m_width;
int m_height;
int m_depth;
glu::Texture3D *m_texture;
TextureTestUtil::TextureRenderer m_renderer;
};
Texture3DMipmapCase::Texture3DMipmapCase(Context &context, const char *name, const char *desc, CoordType coordType,
uint32_t minFilter, uint32_t wrapS, uint32_t wrapT, uint32_t wrapR,
uint32_t format, int width, int height, int depth)
: TestCase(context, name, desc)
, m_coordType(coordType)
, m_minFilter(minFilter)
, m_wrapS(wrapS)
, m_wrapT(wrapT)
, m_wrapR(wrapR)
, m_internalFormat(format)
, m_width(width)
, m_height(height)
, m_depth(depth)
, m_texture(DE_NULL)
, m_renderer(context.getRenderContext(), context.getTestContext().getLog(), glu::GLSL_VERSION_300_ES,
glu::PRECISION_HIGHP)
{
}
Texture3DMipmapCase::~Texture3DMipmapCase(void)
{
Texture3DMipmapCase::deinit();
}
void Texture3DMipmapCase::init(void)
{
const tcu::TextureFormat &texFmt = glu::mapGLInternalFormat(m_internalFormat);
tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(texFmt);
const tcu::Vec4 &cScale = fmtInfo.lookupScale;
const tcu::Vec4 &cBias = fmtInfo.lookupBias;
int numLevels = deLog2Floor32(de::max(de::max(m_width, m_height), m_depth)) + 1;
if (m_coordType == COORDTYPE_PROJECTED && m_context.getRenderTarget().getNumSamples() > 0)
throw tcu::NotSupportedError("Projected lookup validation not supported in multisample config");
m_texture = new glu::Texture3D(m_context.getRenderContext(), m_internalFormat, m_width, m_height, m_depth);
// Fill texture with colored grid.
for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
{
uint32_t step = 0xff / (numLevels - 1);
uint32_t inc = deClamp32(step * levelNdx, 0x00, 0xff);
uint32_t dec = 0xff - inc;
uint32_t rgb = (0xff << 16) | (dec << 8) | inc;
uint32_t color = 0xff000000 | rgb;
m_texture->getRefTexture().allocLevel(levelNdx);
tcu::clear(m_texture->getRefTexture().getLevel(levelNdx), tcu::RGBA(color).toVec() * cScale + cBias);
}
m_texture->upload();
}
void Texture3DMipmapCase::deinit(void)
{
delete m_texture;
m_texture = DE_NULL;
m_renderer.clear();
}
static void getBasicTexCoord3D(std::vector<float> &dst, int cellNdx)
{
static const struct
{
float sScale;
float sBias;
float tScale;
float tBias;
float rScale;
float rBias;
} s_params[] = {// sScale sBias tScale tBias rScale rBias
{0.9f, -0.1f, 0.7f, 0.3f, 0.8f, 0.9f}, {1.2f, -0.1f, 1.1f, 0.3f, 1.0f, 0.9f},
{1.5f, 0.7f, 0.9f, -0.3f, 1.1f, 0.1f}, {1.2f, 0.7f, -2.3f, -0.3f, 1.1f, 0.2f},
{1.1f, 0.8f, -1.3f, -0.3f, 2.9f, 0.9f}, {3.4f, 0.8f, 4.0f, 0.0f, -3.3f, -1.0f},
{-3.4f, -0.1f, -4.0f, 0.0f, -5.1f, 1.0f}, {-4.0f, -0.1f, 3.4f, 0.1f, 5.7f, 0.0f},
{-5.6f, 0.0f, 0.5f, 1.2f, 3.9f, 4.0f}, {5.0f, -2.0f, 3.1f, 1.2f, 5.1f, 0.2f},
{2.5f, -2.0f, 6.3f, 3.0f, 5.1f, 0.2f}, {-8.3f, 0.0f, 7.1f, 3.0f, 2.0f, 0.2f},
{3.8f, 0.0f, 9.7f, 1.0f, 7.0f, 0.7f}, {13.3f, 0.0f, 7.1f, 3.0f, 2.0f, 0.2f},
{16.0f, 8.0f, 12.7f, 1.0f, 17.1f, 0.7f}, {15.3f, 0.0f, 20.1f, 3.0f, 33.0f, 3.2f}};
float sScale = s_params[cellNdx % DE_LENGTH_OF_ARRAY(s_params)].sScale;
float sBias = s_params[cellNdx % DE_LENGTH_OF_ARRAY(s_params)].sBias;
float tScale = s_params[cellNdx % DE_LENGTH_OF_ARRAY(s_params)].tScale;
float tBias = s_params[cellNdx % DE_LENGTH_OF_ARRAY(s_params)].tBias;
float rScale = s_params[cellNdx % DE_LENGTH_OF_ARRAY(s_params)].rScale;
float rBias = s_params[cellNdx % DE_LENGTH_OF_ARRAY(s_params)].rBias;
dst.resize(3 * 4);
dst[0] = sBias;
dst[1] = tBias;
dst[2] = rBias;
dst[3] = sBias;
dst[4] = tBias + tScale;
dst[5] = rBias + rScale * 0.5f;
dst[6] = sBias + sScale;
dst[7] = tBias;
dst[8] = rBias + rScale * 0.5f;
dst[9] = sBias + sScale;
dst[10] = tBias + tScale;
dst[11] = rBias + rScale;
}
static void getAffineTexCoord3D(std::vector<float> &dst, int cellNdx)
{
// Use basic coords as base.
getBasicTexCoord3D(dst, cellNdx);
// Rotate based on cell index.
float angleX = 0.0f + 2.0f * DE_PI * ((float)cellNdx / 16.0f);
float angleY = 1.0f + 2.0f * DE_PI * ((float)cellNdx / 32.0f);
tcu::Mat3 rotMatrix = tcu::rotationMatrixX(angleX) * tcu::rotationMatrixY(angleY);
Vec3 p0 = rotMatrix * Vec3(dst[0], dst[1], dst[2]);
Vec3 p1 = rotMatrix * Vec3(dst[3], dst[4], dst[5]);
Vec3 p2 = rotMatrix * Vec3(dst[6], dst[7], dst[8]);
Vec3 p3 = rotMatrix * Vec3(dst[9], dst[10], dst[11]);
dst[0] = p0.x();
dst[1] = p0.y();
dst[2] = p0.z();
dst[3] = p1.x();
dst[4] = p1.y();
dst[5] = p1.z();
dst[6] = p2.x();
dst[7] = p2.y();
dst[8] = p2.z();
dst[9] = p3.x();
dst[10] = p3.y();
dst[11] = p3.z();
}
Texture3DMipmapCase::IterateResult Texture3DMipmapCase::iterate(void)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
const tcu::Texture3D &refTexture = m_texture->getRefTexture();
const tcu::TextureFormat &texFmt = refTexture.getFormat();
const tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(texFmt);
const int texWidth = refTexture.getWidth();
const int texHeight = refTexture.getHeight();
const uint32_t magFilter = GL_NEAREST;
const tcu::RenderTarget &renderTarget = m_context.getRenderContext().getRenderTarget();
const RandomViewport viewport(renderTarget, texWidth * 4, texHeight * 4, deStringHash(getName()));
const bool isProjected = m_coordType == COORDTYPE_PROJECTED;
const bool useLodBias = m_coordType == COORDTYPE_BASIC_BIAS;
// Viewport is divided into 4x4 grid.
const int gridWidth = 4;
const int gridHeight = 4;
const int cellWidth = viewport.width / gridWidth;
const int cellHeight = viewport.height / gridHeight;
ReferenceParams sampleParams(TEXTURETYPE_3D);
tcu::Surface renderedFrame(viewport.width, viewport.height);
vector<float> texCoord;
// Sampling parameters.
sampleParams.sampler = glu::mapGLSampler(m_wrapS, m_wrapT, m_wrapR, m_minFilter, magFilter);
sampleParams.samplerType = getSamplerType(texFmt);
sampleParams.colorBias = fmtInfo.lookupBias;
sampleParams.colorScale = fmtInfo.lookupScale;
sampleParams.flags = (isProjected ? ReferenceParams::PROJECTED : 0) | (useLodBias ? ReferenceParams::USE_BIAS : 0);
// Bind texture and setup sampler parameters.
gl.bindTexture(GL_TEXTURE_3D, m_texture->getGLTexture());
gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, m_wrapS);
gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, m_wrapT);
gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, m_wrapR);
gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, m_minFilter);
gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, magFilter);
GLU_EXPECT_NO_ERROR(gl.getError(), "After texture setup");
// Bias values.
static const float s_bias[] = {1.0f, -2.0f, 0.8f, -0.5f, 1.5f, 0.9f, 2.0f, 4.0f};
// Projection values.
static const Vec4 s_projections[] = {Vec4(1.2f, 1.0f, 0.7f, 1.0f), Vec4(1.3f, 0.8f, 0.6f, 2.0f),
Vec4(0.8f, 1.0f, 1.7f, 0.6f), Vec4(1.2f, 1.0f, 1.7f, 1.5f)};
// Render cells.
for (int gridY = 0; gridY < gridHeight; gridY++)
{
for (int gridX = 0; gridX < gridWidth; gridX++)
{
const int curX = cellWidth * gridX;
const int curY = cellHeight * gridY;
const int curW = gridX + 1 == gridWidth ? (viewport.width - curX) : cellWidth;
const int curH = gridY + 1 == gridHeight ? (viewport.height - curY) : cellHeight;
const int cellNdx = gridY * gridWidth + gridX;
// Compute texcoord.
switch (m_coordType)
{
case COORDTYPE_BASIC_BIAS: // Fall-through.
case COORDTYPE_PROJECTED:
case COORDTYPE_BASIC:
getBasicTexCoord3D(texCoord, cellNdx);
break;
case COORDTYPE_AFFINE:
getAffineTexCoord3D(texCoord, cellNdx);
break;
default:
DE_ASSERT(false);
}
// Set projection.
if (isProjected)
sampleParams.w = s_projections[cellNdx % DE_LENGTH_OF_ARRAY(s_projections)];
// Set LOD bias.
if (useLodBias)
sampleParams.bias = s_bias[cellNdx % DE_LENGTH_OF_ARRAY(s_bias)];
// Render with GL.
gl.viewport(viewport.x + curX, viewport.y + curY, curW, curH);
m_renderer.renderQuad(0, &texCoord[0], sampleParams);
}
}
// Read result.
glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, renderedFrame.getAccess());
// Compare and log
{
const tcu::PixelFormat &pixelFormat = m_context.getRenderTarget().getPixelFormat();
const bool isTrilinear = m_minFilter == GL_NEAREST_MIPMAP_LINEAR || m_minFilter == GL_LINEAR_MIPMAP_LINEAR;
tcu::Surface referenceFrame(viewport.width, viewport.height);
tcu::Surface errorMask(viewport.width, viewport.height);
tcu::LookupPrecision lookupPrec;
tcu::LodPrecision lodPrec;
int numFailedPixels = 0;
lookupPrec.coordBits = tcu::IVec3(20, 20, 20);
lookupPrec.uvwBits = tcu::IVec3(16, 16, 16); // Doesn't really matter since pixels are unicolored.
lookupPrec.colorThreshold =
tcu::computeFixedPointThreshold(max(getBitsVec(pixelFormat) - (isTrilinear ? 2 : 1), tcu::IVec4(0)));
lookupPrec.colorMask = getCompareMask(pixelFormat);
lodPrec.derivateBits = 10;
lodPrec.lodBits = isProjected ? 6 : 8;
for (int gridY = 0; gridY < gridHeight; gridY++)
{
for (int gridX = 0; gridX < gridWidth; gridX++)
{
const int curX = cellWidth * gridX;
const int curY = cellHeight * gridY;
const int curW = gridX + 1 == gridWidth ? (viewport.width - curX) : cellWidth;
const int curH = gridY + 1 == gridHeight ? (viewport.height - curY) : cellHeight;
const int cellNdx = gridY * gridWidth + gridX;
switch (m_coordType)
{
case COORDTYPE_BASIC_BIAS: // Fall-through.
case COORDTYPE_PROJECTED:
case COORDTYPE_BASIC:
getBasicTexCoord3D(texCoord, cellNdx);
break;
case COORDTYPE_AFFINE:
getAffineTexCoord3D(texCoord, cellNdx);
break;
default:
DE_ASSERT(false);
}
if (isProjected)
sampleParams.w = s_projections[cellNdx % DE_LENGTH_OF_ARRAY(s_projections)];
if (useLodBias)
sampleParams.bias = s_bias[cellNdx % DE_LENGTH_OF_ARRAY(s_bias)];
// Render ideal result
sampleTexture(tcu::SurfaceAccess(referenceFrame, pixelFormat, curX, curY, curW, curH), refTexture,
&texCoord[0], sampleParams);
// Compare this cell
numFailedPixels += computeTextureLookupDiff(
tcu::getSubregion(renderedFrame.getAccess(), curX, curY, curW, curH),
tcu::getSubregion(referenceFrame.getAccess(), curX, curY, curW, curH),
tcu::getSubregion(errorMask.getAccess(), curX, curY, curW, curH), m_texture->getRefTexture(),
&texCoord[0], sampleParams, lookupPrec, lodPrec, m_testCtx.getWatchDog());
}
}
if (numFailedPixels > 0)
m_testCtx.getLog() << TestLog::Message << "ERROR: Image verification failed, found " << numFailedPixels
<< " invalid pixels!" << TestLog::EndMessage;
m_testCtx.getLog() << TestLog::ImageSet("Result", "Verification result")
<< TestLog::Image("Rendered", "Rendered image", renderedFrame);
if (numFailedPixels > 0)
{
m_testCtx.getLog() << TestLog::Image("Reference", "Ideal reference", referenceFrame)
<< TestLog::Image("ErrorMask", "Error mask", errorMask);
}
m_testCtx.getLog() << TestLog::EndImageSet;
{
const bool isOk = numFailedPixels == 0;
m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
isOk ? "Pass" : "Image verification failed");
}
}
return STOP;
}
// Texture2DLodControlCase + test cases
class Texture2DLodControlCase : public TestCase
{
public:
Texture2DLodControlCase(Context &context, const char *name, const char *desc, uint32_t minFilter);
~Texture2DLodControlCase(void);
void init(void);
void deinit(void);
IterateResult iterate(void);
protected:
virtual void setTextureParams(int cellNdx) = DE_NULL;
virtual void getReferenceParams(ReferenceParams &params, int cellNdx) = DE_NULL;
const int m_texWidth;
const int m_texHeight;
private:
Texture2DLodControlCase(const Texture2DLodControlCase &other);
Texture2DLodControlCase &operator=(const Texture2DLodControlCase &other);
uint32_t m_minFilter;
glu::Texture2D *m_texture;
TextureTestUtil::TextureRenderer m_renderer;
};
Texture2DLodControlCase::Texture2DLodControlCase(Context &context, const char *name, const char *desc,
uint32_t minFilter)
: TestCase(context, name, desc)
, m_texWidth(64)
, m_texHeight(64)
, m_minFilter(minFilter)
, m_texture(DE_NULL)
, m_renderer(context.getRenderContext(), context.getTestContext().getLog(), glu::GLSL_VERSION_300_ES,
glu::PRECISION_HIGHP)
{
}
Texture2DLodControlCase::~Texture2DLodControlCase(void)
{
Texture2DLodControlCase::deinit();
}
void Texture2DLodControlCase::init(void)
{
const uint32_t format = GL_RGBA8;
int numLevels = deLog2Floor32(de::max(m_texWidth, m_texHeight)) + 1;
m_texture = new glu::Texture2D(m_context.getRenderContext(), format, m_texWidth, m_texHeight);
// Fill texture with colored grid.
for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
{
uint32_t step = 0xff / (numLevels - 1);
uint32_t inc = deClamp32(step * levelNdx, 0x00, 0xff);
uint32_t dec = 0xff - inc;
uint32_t rgb = (inc << 16) | (dec << 8) | 0xff;
uint32_t color = 0xff000000 | rgb;
m_texture->getRefTexture().allocLevel(levelNdx);
tcu::clear(m_texture->getRefTexture().getLevel(levelNdx), tcu::RGBA(color).toVec());
}
}
void Texture2DLodControlCase::deinit(void)
{
delete m_texture;
m_texture = DE_NULL;
m_renderer.clear();
}
Texture2DLodControlCase::IterateResult Texture2DLodControlCase::iterate(void)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
const uint32_t wrapS = GL_REPEAT;
const uint32_t wrapT = GL_REPEAT;
const uint32_t magFilter = GL_NEAREST;
const tcu::Texture2D &refTexture = m_texture->getRefTexture();
const int texWidth = refTexture.getWidth();
const int texHeight = refTexture.getHeight();
const tcu::RenderTarget &renderTarget = m_context.getRenderContext().getRenderTarget();
const RandomViewport viewport(renderTarget, texWidth * 4, texHeight * 4, deStringHash(getName()));
ReferenceParams sampleParams(TEXTURETYPE_2D, glu::mapGLSampler(wrapS, wrapT, m_minFilter, magFilter));
vector<float> texCoord;
tcu::Surface renderedFrame(viewport.width, viewport.height);
// Viewport is divided into 4x4 grid.
const int gridWidth = 4;
const int gridHeight = 4;
const int cellWidth = viewport.width / gridWidth;
const int cellHeight = viewport.height / gridHeight;
// Upload texture data.
m_texture->upload();
// Bind gradient texture and setup sampler parameters.
gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture());
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapS);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapT);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_minFilter);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);
GLU_EXPECT_NO_ERROR(gl.getError(), "After texture setup");
// Render cells.
for (int gridY = 0; gridY < gridHeight; gridY++)
{
for (int gridX = 0; gridX < gridWidth; gridX++)
{
int curX = cellWidth * gridX;
int curY = cellHeight * gridY;
int curW = gridX + 1 == gridWidth ? (viewport.width - curX) : cellWidth;
int curH = gridY + 1 == gridHeight ? (viewport.height - curY) : cellHeight;
int cellNdx = gridY * gridWidth + gridX;
// Compute texcoord.
getBasicTexCoord2D(texCoord, cellNdx);
// Render with GL.
setTextureParams(cellNdx);
gl.viewport(viewport.x + curX, viewport.y + curY, curW, curH);
m_renderer.renderQuad(0, &texCoord[0], sampleParams);
}
}
glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, renderedFrame.getAccess());
GLU_EXPECT_NO_ERROR(gl.getError(), "Read pixels");
// Compare and log.
{
const tcu::PixelFormat &pixelFormat = m_context.getRenderTarget().getPixelFormat();
const bool isTrilinear = m_minFilter == GL_NEAREST_MIPMAP_LINEAR || m_minFilter == GL_LINEAR_MIPMAP_LINEAR;
tcu::Surface referenceFrame(viewport.width, viewport.height);
tcu::Surface errorMask(viewport.width, viewport.height);
tcu::LookupPrecision lookupPrec;
tcu::LodPrecision lodPrec;
int numFailedPixels = 0;
lookupPrec.coordBits = tcu::IVec3(20, 20, 0);
lookupPrec.uvwBits = tcu::IVec3(16, 16, 0); // Doesn't really matter since pixels are unicolored.
lookupPrec.colorThreshold =
tcu::computeFixedPointThreshold(max(getBitsVec(pixelFormat) - (isTrilinear ? 2 : 1), tcu::IVec4(0)));
lookupPrec.colorMask = getCompareMask(pixelFormat);
lodPrec.derivateBits = 10;
lodPrec.lodBits = 8;
for (int gridY = 0; gridY < gridHeight; gridY++)
{
for (int gridX = 0; gridX < gridWidth; gridX++)
{
const int curX = cellWidth * gridX;
const int curY = cellHeight * gridY;
const int curW = gridX + 1 == gridWidth ? (viewport.width - curX) : cellWidth;
const int curH = gridY + 1 == gridHeight ? (viewport.height - curY) : cellHeight;
const int cellNdx = gridY * gridWidth + gridX;
getBasicTexCoord2D(texCoord, cellNdx);
getReferenceParams(sampleParams, cellNdx);
// Render ideal result
sampleTexture(tcu::SurfaceAccess(referenceFrame, pixelFormat, curX, curY, curW, curH), refTexture,
&texCoord[0], sampleParams);
// Compare this cell
numFailedPixels += computeTextureLookupDiff(
tcu::getSubregion(renderedFrame.getAccess(), curX, curY, curW, curH),
tcu::getSubregion(referenceFrame.getAccess(), curX, curY, curW, curH),
tcu::getSubregion(errorMask.getAccess(), curX, curY, curW, curH), m_texture->getRefTexture(),
&texCoord[0], sampleParams, lookupPrec, lodPrec, m_testCtx.getWatchDog());
}
}
if (numFailedPixels > 0)
m_testCtx.getLog() << TestLog::Message << "ERROR: Image verification failed, found " << numFailedPixels
<< " invalid pixels!" << TestLog::EndMessage;
m_testCtx.getLog() << TestLog::ImageSet("Result", "Verification result")
<< TestLog::Image("Rendered", "Rendered image", renderedFrame);
if (numFailedPixels > 0)
{
m_testCtx.getLog() << TestLog::Image("Reference", "Ideal reference", referenceFrame)
<< TestLog::Image("ErrorMask", "Error mask", errorMask);
}
m_testCtx.getLog() << TestLog::EndImageSet;
{
const bool isOk = numFailedPixels == 0;
m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
isOk ? "Pass" : "Image verification failed");
}
}
return STOP;
}
class Texture2DMinLodCase : public Texture2DLodControlCase
{
public:
Texture2DMinLodCase(Context &context, const char *name, const char *desc, uint32_t minFilter)
: Texture2DLodControlCase(context, name, desc, minFilter)
{
}
protected:
void setTextureParams(int cellNdx)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.texParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, getMinLodForCell(cellNdx));
}
void getReferenceParams(ReferenceParams &params, int cellNdx)
{
params.minLod = getMinLodForCell(cellNdx);
}
};
class Texture2DMaxLodCase : public Texture2DLodControlCase
{
public:
Texture2DMaxLodCase(Context &context, const char *name, const char *desc, uint32_t minFilter)
: Texture2DLodControlCase(context, name, desc, minFilter)
{
}
protected:
void setTextureParams(int cellNdx)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.texParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, getMaxLodForCell(cellNdx));
}
void getReferenceParams(ReferenceParams &params, int cellNdx)
{
params.maxLod = getMaxLodForCell(cellNdx);
}
};
class Texture2DBaseLevelCase : public Texture2DLodControlCase
{
public:
Texture2DBaseLevelCase(Context &context, const char *name, const char *desc, uint32_t minFilter)
: Texture2DLodControlCase(context, name, desc, minFilter)
{
}
protected:
int getBaseLevel(int cellNdx) const
{
const int numLevels = deLog2Floor32(de::max(m_texWidth, m_texHeight)) + 1;
const int baseLevel = (deInt32Hash(cellNdx) ^ deStringHash(getName()) ^ 0xac2f274a) % numLevels;
return baseLevel;
}
void setTextureParams(int cellNdx)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, getBaseLevel(cellNdx));
}
void getReferenceParams(ReferenceParams &params, int cellNdx)
{
params.baseLevel = getBaseLevel(cellNdx);
}
};
class Texture2DMaxLevelCase : public Texture2DLodControlCase
{
public:
Texture2DMaxLevelCase(Context &context, const char *name, const char *desc, uint32_t minFilter)
: Texture2DLodControlCase(context, name, desc, minFilter)
{
}
protected:
int getMaxLevel(int cellNdx) const
{
const int numLevels = deLog2Floor32(de::max(m_texWidth, m_texHeight)) + 1;
const int maxLevel = (deInt32Hash(cellNdx) ^ deStringHash(getName()) ^ 0x82cfa4e) % numLevels;
return maxLevel;
}
void setTextureParams(int cellNdx)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, getMaxLevel(cellNdx));
}
void getReferenceParams(ReferenceParams &params, int cellNdx)
{
params.maxLevel = getMaxLevel(cellNdx);
}
};
// TextureCubeLodControlCase + test cases
class TextureCubeLodControlCase : public TestCase
{
public:
TextureCubeLodControlCase(Context &context, const char *name, const char *desc, uint32_t minFilter);
~TextureCubeLodControlCase(void);
void init(void);
void deinit(void);
IterateResult iterate(void);
protected:
virtual void setTextureParams(int cellNdx) = DE_NULL;
virtual void getReferenceParams(ReferenceParams &params, int cellNdx) = DE_NULL;
const int m_texSize;
private:
TextureCubeLodControlCase(const TextureCubeLodControlCase &other);
TextureCubeLodControlCase &operator=(const TextureCubeLodControlCase &other);
uint32_t m_minFilter;
glu::TextureCube *m_texture;
TextureTestUtil::TextureRenderer m_renderer;
};
TextureCubeLodControlCase::TextureCubeLodControlCase(Context &context, const char *name, const char *desc,
uint32_t minFilter)
: TestCase(context, name, desc)
, m_texSize(64)
, m_minFilter(minFilter)
, m_texture(DE_NULL)
, m_renderer(context.getRenderContext(), context.getTestContext().getLog(), glu::GLSL_VERSION_300_ES,
glu::PRECISION_HIGHP)
{
}
TextureCubeLodControlCase::~TextureCubeLodControlCase(void)
{
deinit();
}
void TextureCubeLodControlCase::init(void)
{
const uint32_t format = GL_RGBA8;
const int numLevels = deLog2Floor32(m_texSize) + 1;
m_texture = new glu::TextureCube(m_context.getRenderContext(), format, m_texSize);
// Fill texture with colored grid.
for (int faceNdx = 0; faceNdx < tcu::CUBEFACE_LAST; faceNdx++)
{
for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
{
uint32_t step = 0xff / (numLevels - 1);
uint32_t inc = deClamp32(step * levelNdx, 0x00, 0xff);
uint32_t dec = 0xff - inc;
uint32_t rgb = 0;
switch (faceNdx)
{
case 0:
rgb = (inc << 16) | (dec << 8) | 255;
break;
case 1:
rgb = (255 << 16) | (inc << 8) | dec;
break;
case 2:
rgb = (dec << 16) | (255 << 8) | inc;
break;
case 3:
rgb = (dec << 16) | (inc << 8) | 255;
break;
case 4:
rgb = (255 << 16) | (dec << 8) | inc;
break;
case 5:
rgb = (inc << 16) | (255 << 8) | dec;
break;
}
uint32_t color = 0xff000000 | rgb;
m_texture->getRefTexture().allocLevel((tcu::CubeFace)faceNdx, levelNdx);
tcu::clear(m_texture->getRefTexture().getLevelFace(levelNdx, (tcu::CubeFace)faceNdx),
tcu::RGBA(color).toVec());
}
}
}
void TextureCubeLodControlCase::deinit(void)
{
delete m_texture;
m_texture = DE_NULL;
m_renderer.clear();
}
TextureCubeLodControlCase::IterateResult TextureCubeLodControlCase::iterate(void)
{
const uint32_t wrapS = GL_CLAMP_TO_EDGE;
const uint32_t wrapT = GL_CLAMP_TO_EDGE;
const uint32_t magFilter = GL_NEAREST;
const int texWidth = m_texture->getRefTexture().getSize();
const int texHeight = m_texture->getRefTexture().getSize();
const int defViewportWidth = texWidth * 2;
const int defViewportHeight = texHeight * 2;
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
const RandomViewport viewport(m_context.getRenderTarget(), defViewportWidth, defViewportHeight,
deStringHash(getName()));
vector<float> texCoord;
tcu::Surface renderedFrame(viewport.width, viewport.height);
// Upload texture data.
m_texture->upload();
// Bind gradient texture and setup sampler parameters.
gl.bindTexture(GL_TEXTURE_CUBE_MAP, m_texture->getGLTexture());
gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, wrapS);
gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, wrapT);
gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, m_minFilter);
gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, magFilter);
GLU_EXPECT_NO_ERROR(gl.getError(), "After texture setup");
// Compute grid.
vector<tcu::IVec4> gridLayout;
computeGridLayout(gridLayout, viewport.width, viewport.height);
for (int cellNdx = 0; cellNdx < (int)gridLayout.size(); cellNdx++)
{
const int curX = gridLayout[cellNdx].x();
const int curY = gridLayout[cellNdx].y();
const int curW = gridLayout[cellNdx].z();
const int curH = gridLayout[cellNdx].w();
const tcu::CubeFace cubeFace = (tcu::CubeFace)(cellNdx % tcu::CUBEFACE_LAST);
RenderParams params(TEXTURETYPE_CUBE);
computeQuadTexCoordCube(texCoord, cubeFace);
setTextureParams(cellNdx);
// Render with GL.
gl.viewport(viewport.x + curX, viewport.y + curY, curW, curH);
m_renderer.renderQuad(0, &texCoord[0], params);
GLU_EXPECT_NO_ERROR(gl.getError(), "Draw");
}
// Read result.
glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, renderedFrame.getAccess());
GLU_EXPECT_NO_ERROR(gl.getError(), "Read pixels");
// Render reference and compare
{
tcu::Surface referenceFrame(viewport.width, viewport.height);
tcu::Surface errorMask(viewport.width, viewport.height);
int numFailedPixels = 0;
ReferenceParams params(TEXTURETYPE_CUBE);
tcu::LookupPrecision lookupPrec;
tcu::LodPrecision lodPrec;
// Params for rendering reference
params.sampler = glu::mapGLSampler(wrapS, wrapT, m_minFilter, magFilter);
params.sampler.seamlessCubeMap = true;
params.lodMode = LODMODE_EXACT;
// Comparison parameters
lookupPrec.colorMask = getCompareMask(m_context.getRenderTarget().getPixelFormat());
lookupPrec.colorThreshold = tcu::computeFixedPointThreshold(
max(getBitsVec(m_context.getRenderTarget().getPixelFormat()) - 2, IVec4(0)));
lookupPrec.coordBits = tcu::IVec3(10);
lookupPrec.uvwBits = tcu::IVec3(5, 5, 0);
lodPrec.derivateBits = 10;
lodPrec.lodBits = 6;
for (int cellNdx = 0; cellNdx < (int)gridLayout.size(); cellNdx++)
{
const int curX = gridLayout[cellNdx].x();
const int curY = gridLayout[cellNdx].y();
const int curW = gridLayout[cellNdx].z();
const int curH = gridLayout[cellNdx].w();
const tcu::CubeFace cubeFace = (tcu::CubeFace)(cellNdx % tcu::CUBEFACE_LAST);
computeQuadTexCoordCube(texCoord, cubeFace);
getReferenceParams(params, cellNdx);
// Render ideal reference.
{
tcu::SurfaceAccess idealDst(referenceFrame, m_context.getRenderTarget().getPixelFormat(), curX, curY,
curW, curH);
sampleTexture(idealDst, m_texture->getRefTexture(), &texCoord[0], params);
}
// Compare this cell
numFailedPixels += computeTextureLookupDiff(
tcu::getSubregion(renderedFrame.getAccess(), curX, curY, curW, curH),
tcu::getSubregion(referenceFrame.getAccess(), curX, curY, curW, curH),
tcu::getSubregion(errorMask.getAccess(), curX, curY, curW, curH), m_texture->getRefTexture(),
&texCoord[0], params, lookupPrec, lodPrec, m_testCtx.getWatchDog());
}
if (numFailedPixels > 0)
m_testCtx.getLog() << TestLog::Message << "ERROR: Image verification failed, found " << numFailedPixels
<< " invalid pixels!" << TestLog::EndMessage;
m_testCtx.getLog() << TestLog::ImageSet("Result", "Verification result")
<< TestLog::Image("Rendered", "Rendered image", renderedFrame);
if (numFailedPixels > 0)
{
m_testCtx.getLog() << TestLog::Image("Reference", "Ideal reference", referenceFrame)
<< TestLog::Image("ErrorMask", "Error mask", errorMask);
}
m_testCtx.getLog() << TestLog::EndImageSet;
{
const bool isOk = numFailedPixels == 0;
m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
isOk ? "Pass" : "Image verification failed");
}
}
return STOP;
}
class TextureCubeMinLodCase : public TextureCubeLodControlCase
{
public:
TextureCubeMinLodCase(Context &context, const char *name, const char *desc, uint32_t minFilter)
: TextureCubeLodControlCase(context, name, desc, minFilter)
{
}
protected:
void setTextureParams(int cellNdx)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.texParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_LOD, getMinLodForCell(cellNdx));
}
void getReferenceParams(ReferenceParams &params, int cellNdx)
{
params.minLod = getMinLodForCell(cellNdx);
}
};
class TextureCubeMaxLodCase : public TextureCubeLodControlCase
{
public:
TextureCubeMaxLodCase(Context &context, const char *name, const char *desc, uint32_t minFilter)
: TextureCubeLodControlCase(context, name, desc, minFilter)
{
}
protected:
void setTextureParams(int cellNdx)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.texParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LOD, getMaxLodForCell(cellNdx));
}
void getReferenceParams(ReferenceParams &params, int cellNdx)
{
params.maxLod = getMaxLodForCell(cellNdx);
}
};
class TextureCubeBaseLevelCase : public TextureCubeLodControlCase
{
public:
TextureCubeBaseLevelCase(Context &context, const char *name, const char *desc, uint32_t minFilter)
: TextureCubeLodControlCase(context, name, desc, minFilter)
{
}
protected:
int getBaseLevel(int cellNdx) const
{
const int numLevels = deLog2Floor32(m_texSize) + 1;
const int baseLevel = (deInt32Hash(cellNdx) ^ deStringHash(getName()) ^ 0x23fae13) % numLevels;
return baseLevel;
}
void setTextureParams(int cellNdx)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_BASE_LEVEL, getBaseLevel(cellNdx));
}
void getReferenceParams(ReferenceParams &params, int cellNdx)
{
params.baseLevel = getBaseLevel(cellNdx);
}
};
class TextureCubeMaxLevelCase : public TextureCubeLodControlCase
{
public:
TextureCubeMaxLevelCase(Context &context, const char *name, const char *desc, uint32_t minFilter)
: TextureCubeLodControlCase(context, name, desc, minFilter)
{
}
protected:
int getMaxLevel(int cellNdx) const
{
const int numLevels = deLog2Floor32(m_texSize) + 1;
const int maxLevel = (deInt32Hash(cellNdx) ^ deStringHash(getName()) ^ 0x974e21) % numLevels;
return maxLevel;
}
void setTextureParams(int cellNdx)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_LEVEL, getMaxLevel(cellNdx));
}
void getReferenceParams(ReferenceParams &params, int cellNdx)
{
params.maxLevel = getMaxLevel(cellNdx);
}
};
// Texture3DLodControlCase + test cases
class Texture3DLodControlCase : public TestCase
{
public:
Texture3DLodControlCase(Context &context, const char *name, const char *desc, uint32_t minFilter);
~Texture3DLodControlCase(void);
void init(void);
void deinit(void);
IterateResult iterate(void);
protected:
virtual void setTextureParams(int cellNdx) = DE_NULL;
virtual void getReferenceParams(ReferenceParams &params, int cellNdx) = DE_NULL;
const int m_texWidth;
const int m_texHeight;
const int m_texDepth;
private:
Texture3DLodControlCase(const Texture3DLodControlCase &other);
Texture3DLodControlCase &operator=(const Texture3DLodControlCase &other);
uint32_t m_minFilter;
glu::Texture3D *m_texture;
TextureTestUtil::TextureRenderer m_renderer;
};
Texture3DLodControlCase::Texture3DLodControlCase(Context &context, const char *name, const char *desc,
uint32_t minFilter)
: TestCase(context, name, desc)
, m_texWidth(32)
, m_texHeight(32)
, m_texDepth(32)
, m_minFilter(minFilter)
, m_texture(DE_NULL)
, m_renderer(context.getRenderContext(), context.getTestContext().getLog(), glu::GLSL_VERSION_300_ES,
glu::PRECISION_HIGHP)
{
}
Texture3DLodControlCase::~Texture3DLodControlCase(void)
{
Texture3DLodControlCase::deinit();
}
void Texture3DLodControlCase::init(void)
{
const uint32_t format = GL_RGBA8;
const tcu::TextureFormat &texFmt = glu::mapGLInternalFormat(format);
tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(texFmt);
const tcu::Vec4 &cScale = fmtInfo.lookupScale;
const tcu::Vec4 &cBias = fmtInfo.lookupBias;
int numLevels = deLog2Floor32(de::max(de::max(m_texWidth, m_texHeight), m_texDepth)) + 1;
m_texture = new glu::Texture3D(m_context.getRenderContext(), format, m_texWidth, m_texHeight, m_texDepth);
// Fill texture with colored grid.
for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
{
uint32_t step = 0xff / (numLevels - 1);
uint32_t inc = deClamp32(step * levelNdx, 0x00, 0xff);
uint32_t dec = 0xff - inc;
uint32_t rgb = (inc << 16) | (dec << 8) | 0xff;
uint32_t color = 0xff000000 | rgb;
m_texture->getRefTexture().allocLevel(levelNdx);
tcu::clear(m_texture->getRefTexture().getLevel(levelNdx), tcu::RGBA(color).toVec() * cScale + cBias);
}
m_texture->upload();
}
void Texture3DLodControlCase::deinit(void)
{
delete m_texture;
m_texture = DE_NULL;
m_renderer.clear();
}
Texture3DLodControlCase::IterateResult Texture3DLodControlCase::iterate(void)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
const uint32_t wrapS = GL_CLAMP_TO_EDGE;
const uint32_t wrapT = GL_CLAMP_TO_EDGE;
const uint32_t wrapR = GL_CLAMP_TO_EDGE;
const uint32_t magFilter = GL_NEAREST;
const tcu::Texture3D &refTexture = m_texture->getRefTexture();
const tcu::TextureFormat &texFmt = refTexture.getFormat();
const tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(texFmt);
const int texWidth = refTexture.getWidth();
const int texHeight = refTexture.getHeight();
const tcu::RenderTarget &renderTarget = m_context.getRenderContext().getRenderTarget();
const RandomViewport viewport(renderTarget, texWidth * 4, texHeight * 4, deStringHash(getName()));
// Viewport is divided into 4x4 grid.
const int gridWidth = 4;
const int gridHeight = 4;
const int cellWidth = viewport.width / gridWidth;
const int cellHeight = viewport.height / gridHeight;
tcu::Surface renderedFrame(viewport.width, viewport.height);
vector<float> texCoord;
ReferenceParams sampleParams(TEXTURETYPE_3D);
// Sampling parameters.
sampleParams.sampler = glu::mapGLSampler(wrapS, wrapT, wrapR, m_minFilter, magFilter);
sampleParams.samplerType = getSamplerType(texFmt);
sampleParams.colorBias = fmtInfo.lookupBias;
sampleParams.colorScale = fmtInfo.lookupScale;
// Bind texture and setup sampler parameters.
gl.bindTexture(GL_TEXTURE_3D, m_texture->getGLTexture());
gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, wrapS);
gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, wrapT);
gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, wrapR);
gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, m_minFilter);
gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, magFilter);
GLU_EXPECT_NO_ERROR(gl.getError(), "After texture setup");
// Render cells.
for (int gridY = 0; gridY < gridHeight; gridY++)
{
for (int gridX = 0; gridX < gridWidth; gridX++)
{
int curX = cellWidth * gridX;
int curY = cellHeight * gridY;
int curW = gridX + 1 == gridWidth ? (viewport.width - curX) : cellWidth;
int curH = gridY + 1 == gridHeight ? (viewport.height - curY) : cellHeight;
int cellNdx = gridY * gridWidth + gridX;
// Compute texcoord.
getBasicTexCoord3D(texCoord, cellNdx);
setTextureParams(cellNdx);
// Render with GL.
gl.viewport(viewport.x + curX, viewport.y + curY, curW, curH);
m_renderer.renderQuad(0, &texCoord[0], sampleParams);
}
}
// Read result.
glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, renderedFrame.getAccess());
// Compare and log
{
const tcu::PixelFormat &pixelFormat = m_context.getRenderTarget().getPixelFormat();
const bool isTrilinear = m_minFilter == GL_NEAREST_MIPMAP_LINEAR || m_minFilter == GL_LINEAR_MIPMAP_LINEAR;
tcu::Surface referenceFrame(viewport.width, viewport.height);
tcu::Surface errorMask(viewport.width, viewport.height);
tcu::LookupPrecision lookupPrec;
tcu::LodPrecision lodPrec;
int numFailedPixels = 0;
lookupPrec.coordBits = tcu::IVec3(20, 20, 20);
lookupPrec.uvwBits = tcu::IVec3(16, 16, 16); // Doesn't really matter since pixels are unicolored.
lookupPrec.colorThreshold =
tcu::computeFixedPointThreshold(max(getBitsVec(pixelFormat) - (isTrilinear ? 2 : 1), tcu::IVec4(0)));
lookupPrec.colorMask = getCompareMask(pixelFormat);
lodPrec.derivateBits = 10;
lodPrec.lodBits = 8;
for (int gridY = 0; gridY < gridHeight; gridY++)
{
for (int gridX = 0; gridX < gridWidth; gridX++)
{
const int curX = cellWidth * gridX;
const int curY = cellHeight * gridY;
const int curW = gridX + 1 == gridWidth ? (viewport.width - curX) : cellWidth;
const int curH = gridY + 1 == gridHeight ? (viewport.height - curY) : cellHeight;
const int cellNdx = gridY * gridWidth + gridX;
getBasicTexCoord3D(texCoord, cellNdx);
getReferenceParams(sampleParams, cellNdx);
// Render ideal result
sampleTexture(tcu::SurfaceAccess(referenceFrame, pixelFormat, curX, curY, curW, curH), refTexture,
&texCoord[0], sampleParams);
// Compare this cell
numFailedPixels += computeTextureLookupDiff(
tcu::getSubregion(renderedFrame.getAccess(), curX, curY, curW, curH),
tcu::getSubregion(referenceFrame.getAccess(), curX, curY, curW, curH),
tcu::getSubregion(errorMask.getAccess(), curX, curY, curW, curH), m_texture->getRefTexture(),
&texCoord[0], sampleParams, lookupPrec, lodPrec, m_testCtx.getWatchDog());
}
}
if (numFailedPixels > 0)
m_testCtx.getLog() << TestLog::Message << "ERROR: Image verification failed, found " << numFailedPixels
<< " invalid pixels!" << TestLog::EndMessage;
m_testCtx.getLog() << TestLog::ImageSet("Result", "Verification result")
<< TestLog::Image("Rendered", "Rendered image", renderedFrame);
if (numFailedPixels > 0)
{
m_testCtx.getLog() << TestLog::Image("Reference", "Ideal reference", referenceFrame)
<< TestLog::Image("ErrorMask", "Error mask", errorMask);
}
m_testCtx.getLog() << TestLog::EndImageSet;
{
const bool isOk = numFailedPixels == 0;
m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
isOk ? "Pass" : "Image verification failed");
}
}
return STOP;
}
class Texture3DMinLodCase : public Texture3DLodControlCase
{
public:
Texture3DMinLodCase(Context &context, const char *name, const char *desc, uint32_t minFilter)
: Texture3DLodControlCase(context, name, desc, minFilter)
{
}
protected:
void setTextureParams(int cellNdx)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.texParameterf(GL_TEXTURE_3D, GL_TEXTURE_MIN_LOD, getMinLodForCell(cellNdx));
}
void getReferenceParams(ReferenceParams &params, int cellNdx)
{
params.minLod = getMinLodForCell(cellNdx);
}
};
class Texture3DMaxLodCase : public Texture3DLodControlCase
{
public:
Texture3DMaxLodCase(Context &context, const char *name, const char *desc, uint32_t minFilter)
: Texture3DLodControlCase(context, name, desc, minFilter)
{
}
protected:
void setTextureParams(int cellNdx)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.texParameterf(GL_TEXTURE_3D, GL_TEXTURE_MAX_LOD, getMaxLodForCell(cellNdx));
}
void getReferenceParams(ReferenceParams &params, int cellNdx)
{
params.maxLod = getMaxLodForCell(cellNdx);
}
};
class Texture3DBaseLevelCase : public Texture3DLodControlCase
{
public:
Texture3DBaseLevelCase(Context &context, const char *name, const char *desc, uint32_t minFilter)
: Texture3DLodControlCase(context, name, desc, minFilter)
{
}
protected:
int getBaseLevel(int cellNdx) const
{
const int numLevels = deLog2Floor32(de::max(m_texWidth, de::max(m_texHeight, m_texDepth))) + 1;
const int baseLevel = (deInt32Hash(cellNdx) ^ deStringHash(getName()) ^ 0x7347e9) % numLevels;
return baseLevel;
}
void setTextureParams(int cellNdx)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_BASE_LEVEL, getBaseLevel(cellNdx));
}
void getReferenceParams(ReferenceParams &params, int cellNdx)
{
params.baseLevel = getBaseLevel(cellNdx);
}
};
class Texture3DMaxLevelCase : public Texture3DLodControlCase
{
public:
Texture3DMaxLevelCase(Context &context, const char *name, const char *desc, uint32_t minFilter)
: Texture3DLodControlCase(context, name, desc, minFilter)
{
}
protected:
int getMaxLevel(int cellNdx) const
{
const int numLevels = deLog2Floor32(de::max(m_texWidth, de::max(m_texHeight, m_texDepth))) + 1;
const int maxLevel = (deInt32Hash(cellNdx) ^ deStringHash(getName()) ^ 0x9111e7) % numLevels;
return maxLevel;
}
void setTextureParams(int cellNdx)
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.texParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, getMaxLevel(cellNdx));
}
void getReferenceParams(ReferenceParams &params, int cellNdx)
{
params.maxLevel = getMaxLevel(cellNdx);
}
};
TextureMipmapTests::TextureMipmapTests(Context &context) : TestCaseGroup(context, "mipmap", "Mipmapping tests")
{
}
TextureMipmapTests::~TextureMipmapTests(void)
{
}
void TextureMipmapTests::init(void)
{
tcu::TestCaseGroup *group2D = new tcu::TestCaseGroup(m_testCtx, "2d", "2D Texture Mipmapping");
tcu::TestCaseGroup *groupCube = new tcu::TestCaseGroup(m_testCtx, "cube", "Cube Map Mipmapping");
tcu::TestCaseGroup *group3D = new tcu::TestCaseGroup(m_testCtx, "3d", "3D Texture Mipmapping");
addChild(group2D);
addChild(groupCube);
addChild(group3D);
static const struct
{
const char *name;
uint32_t mode;
} wrapModes[] = {{"clamp", GL_CLAMP_TO_EDGE}, {"repeat", GL_REPEAT}, {"mirror", GL_MIRRORED_REPEAT}};
static const struct
{
const char *name;
uint32_t mode;
} minFilterModes[] = {{"nearest_nearest", GL_NEAREST_MIPMAP_NEAREST},
{"linear_nearest", GL_LINEAR_MIPMAP_NEAREST},
{"nearest_linear", GL_NEAREST_MIPMAP_LINEAR},
{"linear_linear", GL_LINEAR_MIPMAP_LINEAR}};
static const struct
{
CoordType type;
const char *name;
const char *desc;
} coordTypes[] = {{COORDTYPE_BASIC, "basic", "Mipmapping with translated and scaled coordinates"},
{COORDTYPE_AFFINE, "affine", "Mipmapping with affine coordinate transform"},
{COORDTYPE_PROJECTED, "projected", "Mipmapping with perspective projection"}};
static const struct
{
const char *name;
uint32_t format;
uint32_t dataType;
} formats[] = {{"a8", GL_ALPHA, GL_UNSIGNED_BYTE},
{"l8", GL_LUMINANCE, GL_UNSIGNED_BYTE},
{"la88", GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE},
{"rgb565", GL_RGB, GL_UNSIGNED_SHORT_5_6_5},
{"rgb888", GL_RGB, GL_UNSIGNED_BYTE},
{"rgba4444", GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4},
{"rgba5551", GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1},
{"rgba8888", GL_RGBA, GL_UNSIGNED_BYTE}};
static const struct
{
const char *name;
uint32_t hint;
} genHints[] = {{"fastest", GL_FASTEST}, {"nicest", GL_NICEST}};
static const struct
{
const char *name;
int width;
int height;
} tex2DSizes[] = {{DE_NULL, 64, 64}, // Default.
{"npot", 63, 57},
{"non_square", 32, 64}};
static const struct
{
const char *name;
int width;
int height;
int depth;
} tex3DSizes[] = {{DE_NULL, 32, 32, 32}, // Default.
{"npot", 33, 29, 27}};
const int cubeMapSize = 64;
static const struct
{
CoordType type;
const char *name;
const char *desc;
} cubeCoordTypes[] = {{COORDTYPE_BASIC, "basic", "Mipmapping with translated and scaled coordinates"},
{COORDTYPE_PROJECTED, "projected", "Mipmapping with perspective projection"},
{COORDTYPE_BASIC_BIAS, "bias", "User-supplied bias value"}};
// 2D cases.
for (int coordType = 0; coordType < DE_LENGTH_OF_ARRAY(coordTypes); coordType++)
{
tcu::TestCaseGroup *coordTypeGroup =
new tcu::TestCaseGroup(m_testCtx, coordTypes[coordType].name, coordTypes[coordType].desc);
group2D->addChild(coordTypeGroup);
for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
{
for (int wrapMode = 0; wrapMode < DE_LENGTH_OF_ARRAY(wrapModes); wrapMode++)
{
// Add non_square variants to basic cases only.
int sizeEnd = coordTypes[coordType].type == COORDTYPE_BASIC ? DE_LENGTH_OF_ARRAY(tex2DSizes) : 1;
for (int size = 0; size < sizeEnd; size++)
{
std::ostringstream name;
name << minFilterModes[minFilter].name << "_" << wrapModes[wrapMode].name;
if (tex2DSizes[size].name)
name << "_" << tex2DSizes[size].name;
coordTypeGroup->addChild(new Texture2DMipmapCase(
m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), name.str().c_str(), "",
coordTypes[coordType].type, minFilterModes[minFilter].mode, wrapModes[wrapMode].mode,
wrapModes[wrapMode].mode, GL_RGBA, GL_UNSIGNED_BYTE, tex2DSizes[size].width,
tex2DSizes[size].height));
}
}
}
}
// 2D bias variants.
{
tcu::TestCaseGroup *biasGroup = new tcu::TestCaseGroup(m_testCtx, "bias", "User-supplied bias value");
group2D->addChild(biasGroup);
for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
biasGroup->addChild(new Texture2DMipmapCase(
m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), minFilterModes[minFilter].name, "",
COORDTYPE_BASIC_BIAS, minFilterModes[minFilter].mode, GL_REPEAT, GL_REPEAT, GL_RGBA, GL_UNSIGNED_BYTE,
tex2DSizes[0].width, tex2DSizes[0].height));
}
// 2D mipmap generation variants.
{
tcu::TestCaseGroup *genMipmapGroup = new tcu::TestCaseGroup(m_testCtx, "generate", "Mipmap generation tests");
group2D->addChild(genMipmapGroup);
for (int format = 0; format < DE_LENGTH_OF_ARRAY(formats); format++)
{
for (int size = 0; size < DE_LENGTH_OF_ARRAY(tex2DSizes); size++)
{
for (int hint = 0; hint < DE_LENGTH_OF_ARRAY(genHints); hint++)
{
std::ostringstream name;
name << formats[format].name;
if (tex2DSizes[size].name)
name << "_" << tex2DSizes[size].name;
name << "_" << genHints[hint].name;
genMipmapGroup->addChild(new Texture2DGenMipmapCase(
m_testCtx, m_context.getRenderContext(), name.str().c_str(), "", formats[format].format,
formats[format].dataType, genHints[hint].hint, tex2DSizes[size].width,
tex2DSizes[size].height));
}
}
}
}
// 2D LOD controls.
{
// MIN_LOD
tcu::TestCaseGroup *minLodGroup = new tcu::TestCaseGroup(m_testCtx, "min_lod", "Lod control: min lod");
group2D->addChild(minLodGroup);
for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
minLodGroup->addChild(
new Texture2DMinLodCase(m_context, minFilterModes[minFilter].name, "", minFilterModes[minFilter].mode));
// MAX_LOD
tcu::TestCaseGroup *maxLodGroup = new tcu::TestCaseGroup(m_testCtx, "max_lod", "Lod control: max lod");
group2D->addChild(maxLodGroup);
for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
maxLodGroup->addChild(
new Texture2DMaxLodCase(m_context, minFilterModes[minFilter].name, "", minFilterModes[minFilter].mode));
// BASE_LEVEL
tcu::TestCaseGroup *baseLevelGroup = new tcu::TestCaseGroup(m_testCtx, "base_level", "Base level");
group2D->addChild(baseLevelGroup);
for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
baseLevelGroup->addChild(new Texture2DBaseLevelCase(m_context, minFilterModes[minFilter].name, "",
minFilterModes[minFilter].mode));
// MAX_LEVEL
tcu::TestCaseGroup *maxLevelGroup = new tcu::TestCaseGroup(m_testCtx, "max_level", "Max level");
group2D->addChild(maxLevelGroup);
for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
maxLevelGroup->addChild(new Texture2DMaxLevelCase(m_context, minFilterModes[minFilter].name, "",
minFilterModes[minFilter].mode));
}
// Cubemap cases.
for (int coordType = 0; coordType < DE_LENGTH_OF_ARRAY(cubeCoordTypes); coordType++)
{
tcu::TestCaseGroup *coordTypeGroup =
new tcu::TestCaseGroup(m_testCtx, cubeCoordTypes[coordType].name, cubeCoordTypes[coordType].desc);
groupCube->addChild(coordTypeGroup);
for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
{
coordTypeGroup->addChild(new TextureCubeMipmapCase(
m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), minFilterModes[minFilter].name, "",
cubeCoordTypes[coordType].type, minFilterModes[minFilter].mode, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE,
GL_RGBA, GL_UNSIGNED_BYTE, cubeMapSize));
}
}
// Cubemap mipmap generation variants.
{
tcu::TestCaseGroup *genMipmapGroup = new tcu::TestCaseGroup(m_testCtx, "generate", "Mipmap generation tests");
groupCube->addChild(genMipmapGroup);
for (int format = 0; format < DE_LENGTH_OF_ARRAY(formats); format++)
{
for (int hint = 0; hint < DE_LENGTH_OF_ARRAY(genHints); hint++)
{
std::ostringstream name;
name << formats[format].name << "_" << genHints[hint].name;
genMipmapGroup->addChild(new TextureCubeGenMipmapCase(
m_testCtx, m_context.getRenderContext(), name.str().c_str(), "", formats[format].format,
formats[format].dataType, genHints[hint].hint, cubeMapSize));
}
}
}
// Cubemap LOD controls.
{
// MIN_LOD
tcu::TestCaseGroup *minLodGroup = new tcu::TestCaseGroup(m_testCtx, "min_lod", "Lod control: min lod");
groupCube->addChild(minLodGroup);
for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
minLodGroup->addChild(new TextureCubeMinLodCase(m_context, minFilterModes[minFilter].name, "",
minFilterModes[minFilter].mode));
// MAX_LOD
tcu::TestCaseGroup *maxLodGroup = new tcu::TestCaseGroup(m_testCtx, "max_lod", "Lod control: max lod");
groupCube->addChild(maxLodGroup);
for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
maxLodGroup->addChild(new TextureCubeMaxLodCase(m_context, minFilterModes[minFilter].name, "",
minFilterModes[minFilter].mode));
// BASE_LEVEL
tcu::TestCaseGroup *baseLevelGroup = new tcu::TestCaseGroup(m_testCtx, "base_level", "Base level");
groupCube->addChild(baseLevelGroup);
for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
baseLevelGroup->addChild(new TextureCubeBaseLevelCase(m_context, minFilterModes[minFilter].name, "",
minFilterModes[minFilter].mode));
// MAX_LEVEL
tcu::TestCaseGroup *maxLevelGroup = new tcu::TestCaseGroup(m_testCtx, "max_level", "Max level");
groupCube->addChild(maxLevelGroup);
for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
maxLevelGroup->addChild(new TextureCubeMaxLevelCase(m_context, minFilterModes[minFilter].name, "",
minFilterModes[minFilter].mode));
}
// 3D cases.
for (int coordType = 0; coordType < DE_LENGTH_OF_ARRAY(coordTypes); coordType++)
{
tcu::TestCaseGroup *coordTypeGroup =
new tcu::TestCaseGroup(m_testCtx, coordTypes[coordType].name, coordTypes[coordType].desc);
group3D->addChild(coordTypeGroup);
for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
{
for (int wrapMode = 0; wrapMode < DE_LENGTH_OF_ARRAY(wrapModes); wrapMode++)
{
// Add other size variants to basic cases only.
int sizeEnd = coordTypes[coordType].type == COORDTYPE_BASIC ? DE_LENGTH_OF_ARRAY(tex3DSizes) : 1;
for (int size = 0; size < sizeEnd; size++)
{
std::ostringstream name;
name << minFilterModes[minFilter].name << "_" << wrapModes[wrapMode].name;
if (tex3DSizes[size].name)
name << "_" << tex3DSizes[size].name;
coordTypeGroup->addChild(new Texture3DMipmapCase(
m_context, name.str().c_str(), "", coordTypes[coordType].type, minFilterModes[minFilter].mode,
wrapModes[wrapMode].mode, wrapModes[wrapMode].mode, wrapModes[wrapMode].mode, GL_RGBA8,
tex3DSizes[size].width, tex3DSizes[size].height, tex3DSizes[size].depth));
}
}
}
}
// 3D bias variants.
{
tcu::TestCaseGroup *biasGroup = new tcu::TestCaseGroup(m_testCtx, "bias", "User-supplied bias value");
group3D->addChild(biasGroup);
for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
biasGroup->addChild(new Texture3DMipmapCase(m_context, minFilterModes[minFilter].name, "",
COORDTYPE_BASIC_BIAS, minFilterModes[minFilter].mode, GL_REPEAT,
GL_REPEAT, GL_REPEAT, GL_RGBA8, tex3DSizes[0].width,
tex3DSizes[0].height, tex3DSizes[0].depth));
}
// 3D LOD controls.
{
// MIN_LOD
tcu::TestCaseGroup *minLodGroup = new tcu::TestCaseGroup(m_testCtx, "min_lod", "Lod control: min lod");
group3D->addChild(minLodGroup);
for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
minLodGroup->addChild(
new Texture3DMinLodCase(m_context, minFilterModes[minFilter].name, "", minFilterModes[minFilter].mode));
// MAX_LOD
tcu::TestCaseGroup *maxLodGroup = new tcu::TestCaseGroup(m_testCtx, "max_lod", "Lod control: max lod");
group3D->addChild(maxLodGroup);
for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
maxLodGroup->addChild(
new Texture3DMaxLodCase(m_context, minFilterModes[minFilter].name, "", minFilterModes[minFilter].mode));
// BASE_LEVEL
tcu::TestCaseGroup *baseLevelGroup = new tcu::TestCaseGroup(m_testCtx, "base_level", "Base level");
group3D->addChild(baseLevelGroup);
for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
baseLevelGroup->addChild(new Texture3DBaseLevelCase(m_context, minFilterModes[minFilter].name, "",
minFilterModes[minFilter].mode));
// MAX_LEVEL
tcu::TestCaseGroup *maxLevelGroup = new tcu::TestCaseGroup(m_testCtx, "max_level", "Max level");
group3D->addChild(maxLevelGroup);
for (int minFilter = 0; minFilter < DE_LENGTH_OF_ARRAY(minFilterModes); minFilter++)
maxLevelGroup->addChild(new Texture3DMaxLevelCase(m_context, minFilterModes[minFilter].name, "",
minFilterModes[minFilter].mode));
}
}
} // namespace Functional
} // namespace gles3
} // namespace deqp