/*-------------------------------------------------------------------------
* drawElements Quality Program OpenGL ES 3.1 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 Stencil texturing tests.
*//*--------------------------------------------------------------------*/
#include "es31fStencilTexturingTests.hpp"
#include "gluStrUtil.hpp"
#include "gluObjectWrapper.hpp"
#include "gluRenderContext.hpp"
#include "gluShaderProgram.hpp"
#include "gluDrawUtil.hpp"
#include "gluPixelTransfer.hpp"
#include "gluTextureUtil.hpp"
#include "gluContextInfo.hpp"
#include "glsTextureTestUtil.hpp"
#include "tcuVector.hpp"
#include "tcuTexture.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuTexLookupVerifier.hpp"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"
#include "deStringUtil.hpp"
namespace deqp
{
namespace gles31
{
namespace Functional
{
using std::vector;
using std::string;
using tcu::IVec4;
using tcu::Vec2;
using tcu::Vec4;
using tcu::TestLog;
using tcu::TextureLevel;
using tcu::TextureFormat;
namespace
{
static void genTestRects (vector<IVec4>& rects, int width, int height)
{
int curWidth = width;
int curHeight = height;
int ndx = 0;
for (;;)
{
rects.push_back(IVec4(width-curWidth, height-curHeight, curWidth, curHeight));
DE_ASSERT(curWidth >= 1 && curHeight >= 1);
if (curWidth == 1 && curHeight == 1)
break;
else if (curHeight > 1 && ((ndx%2) == 0 || curWidth == 1))
curHeight -= 1;
else
curWidth -= 1;
ndx += 1;
}
}
static void rectsToTriangles (const vector<IVec4>& rects, int width, int height, vector<Vec2>& positions, vector<deUint16>& indices)
{
const float w = float(width);
const float h = float(height);
positions.resize(rects.size()*4);
indices.resize(rects.size()*6);
for (int rectNdx = 0; rectNdx < (int)rects.size(); rectNdx++)
{
const int rx = rects[rectNdx].x();
const int ry = rects[rectNdx].y();
const int rw = rects[rectNdx].z();
const int rh = rects[rectNdx].w();
const float x0 = float(rx*2)/w - 1.0f;
const float x1 = float((rx+rw)*2)/w - 1.0f;
const float y0 = float(ry*2)/h - 1.0f;
const float y1 = float((ry+rh)*2)/h - 1.0f;
positions[rectNdx*4 + 0] = Vec2(x0, y0);
positions[rectNdx*4 + 1] = Vec2(x1, y0);
positions[rectNdx*4 + 2] = Vec2(x0, y1);
positions[rectNdx*4 + 3] = Vec2(x1, y1);
indices[rectNdx*6 + 0] = (deUint16)(rectNdx*4 + 0);
indices[rectNdx*6 + 1] = (deUint16)(rectNdx*4 + 1);
indices[rectNdx*6 + 2] = (deUint16)(rectNdx*4 + 2);
indices[rectNdx*6 + 3] = (deUint16)(rectNdx*4 + 2);
indices[rectNdx*6 + 4] = (deUint16)(rectNdx*4 + 1);
indices[rectNdx*6 + 5] = (deUint16)(rectNdx*4 + 3);
}
}
static void drawTestPattern (const glu::RenderContext& renderCtx, int width, int height)
{
const glu::ShaderProgram program(renderCtx, glu::ProgramSources()
<< glu::VertexSource(
"#version 300 es\n"
"in highp vec4 a_position;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
"}\n")
<< glu::FragmentSource(
"#version 300 es\n"
"void main (void) {}\n"));
const glw::Functions& gl = renderCtx.getFunctions();
vector<IVec4> rects;
vector<Vec2> positions;
vector<deUint16> indices;
if (!program.isOk())
throw tcu::TestError("Compile failed");
gl.useProgram (program.getProgram());
gl.viewport (0, 0, width, height);
gl.clear (GL_STENCIL_BUFFER_BIT);
gl.enable (GL_STENCIL_TEST);
gl.stencilOp (GL_KEEP, GL_KEEP, GL_INCR_WRAP);
gl.stencilFunc (GL_ALWAYS, 0, ~0u);
GLU_EXPECT_NO_ERROR(gl.getError(), "State setup failed");
genTestRects (rects, width, height);
rectsToTriangles(rects, width, height, positions, indices);
{
const glu::VertexArrayBinding posBinding = glu::va::Float("a_position", 2, (int)positions.size(), 0, positions[0].getPtr());
glu::draw(renderCtx, program.getProgram(), 1, &posBinding, glu::pr::Triangles((int)indices.size(), &indices[0]));
}
gl.disable(GL_STENCIL_TEST);
}
static void renderTestPatternReference (const tcu::PixelBufferAccess& dst)
{
const int stencilBits = tcu::getTextureFormatBitDepth(tcu::getEffectiveDepthStencilAccess(dst, tcu::Sampler::MODE_STENCIL).getFormat()).x();
const deUint32 stencilMask = (1u<<stencilBits)-1u;
vector<IVec4> rects;
DE_ASSERT(dst.getFormat().order == TextureFormat::S || dst.getFormat().order == TextureFormat::DS);
// clear depth and stencil
if (dst.getFormat().order == TextureFormat::DS)
tcu::clearDepth(dst, 0.0f);
tcu::clearStencil(dst, 0u);
genTestRects(rects, dst.getWidth(), dst.getHeight());
for (vector<IVec4>::const_iterator rectIter = rects.begin(); rectIter != rects.end(); ++rectIter)
{
const int x0 = rectIter->x();
const int y0 = rectIter->y();
const int x1 = x0+rectIter->z();
const int y1 = y0+rectIter->w();
for (int y = y0; y < y1; y++)
{
for (int x = x0; x < x1; x++)
{
const int oldVal = dst.getPixStencil(x, y);
const int newVal = (oldVal+1)&stencilMask;
dst.setPixStencil(newVal, x, y);
}
}
}
}
static void blitStencilToColor2D (const glu::RenderContext& renderCtx, deUint32 srcTex, int width, int height)
{
const glu::ShaderProgram program(renderCtx, glu::ProgramSources()
<< glu::VertexSource(
"#version 300 es\n"
"in highp vec4 a_position;\n"
"in highp vec2 a_texCoord;\n"
"out highp vec2 v_texCoord;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
" v_texCoord = a_texCoord;\n"
"}\n")
<< glu::FragmentSource(
"#version 300 es\n"
"uniform highp usampler2D u_sampler;\n"
"in highp vec2 v_texCoord;\n"
"layout(location = 0) out highp uint o_stencil;\n"
"void main (void)\n"
"{\n"
" o_stencil = texture(u_sampler, v_texCoord).x;\n"
"}\n"));
const float positions[] =
{
-1.0f, -1.0f,
+1.0f, -1.0f,
-1.0f, +1.0f,
+1.0f, +1.0f
};
const float texCoord[] =
{
0.0f, 0.0f,
1.0f, 0.0f,
0.0f, 1.0f,
1.0f, 1.0f
};
const glu::VertexArrayBinding vertexArrays[] =
{
glu::va::Float("a_position", 2, 4, 0, &positions[0]),
glu::va::Float("a_texCoord", 2, 4, 0, &texCoord[0])
};
const deUint8 indices[] = { 0, 1, 2, 2, 1, 3 };
const glw::Functions& gl = renderCtx.getFunctions();
if (!program.isOk())
throw tcu::TestError("Compile failed");
gl.activeTexture(GL_TEXTURE0);
gl.bindTexture(GL_TEXTURE_2D, srcTex);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl.texParameteri(GL_TEXTURE_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, GL_STENCIL_INDEX);
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture state setup failed");
gl.useProgram(program.getProgram());
gl.uniform1i(gl.getUniformLocation(program.getProgram(), "u_sampler"), 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "Program setup failed");
gl.viewport(0, 0, width, height);
glu::draw(renderCtx, program.getProgram(), DE_LENGTH_OF_ARRAY(vertexArrays), &vertexArrays[0],
glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0]));
}
static void blitStencilToColor2DArray (const glu::RenderContext& renderCtx, deUint32 srcTex, int width, int height, int level)
{
const glu::ShaderProgram program(renderCtx, glu::ProgramSources()
<< glu::VertexSource(
"#version 300 es\n"
"in highp vec4 a_position;\n"
"in highp vec3 a_texCoord;\n"
"out highp vec3 v_texCoord;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
" v_texCoord = a_texCoord;\n"
"}\n")
<< glu::FragmentSource(
"#version 300 es\n"
"uniform highp usampler2DArray u_sampler;\n"
"in highp vec3 v_texCoord;\n"
"layout(location = 0) out highp uint o_stencil;\n"
"void main (void)\n"
"{\n"
" o_stencil = texture(u_sampler, v_texCoord).x;\n"
"}\n"));
const float positions[] =
{
-1.0f, -1.0f,
+1.0f, -1.0f,
-1.0f, +1.0f,
+1.0f, +1.0f
};
const float texCoord[] =
{
0.0f, 0.0f, float(level),
1.0f, 0.0f, float(level),
0.0f, 1.0f, float(level),
1.0f, 1.0f, float(level)
};
const glu::VertexArrayBinding vertexArrays[] =
{
glu::va::Float("a_position", 2, 4, 0, &positions[0]),
glu::va::Float("a_texCoord", 3, 4, 0, &texCoord[0])
};
const deUint8 indices[] = { 0, 1, 2, 2, 1, 3 };
const glw::Functions& gl = renderCtx.getFunctions();
if (!program.isOk())
throw tcu::TestError("Compile failed");
gl.activeTexture(GL_TEXTURE0);
gl.bindTexture(GL_TEXTURE_2D_ARRAY, srcTex);
gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_DEPTH_STENCIL_TEXTURE_MODE, GL_STENCIL_INDEX);
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture state setup failed");
gl.useProgram(program.getProgram());
gl.uniform1i(gl.getUniformLocation(program.getProgram(), "u_sampler"), 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "Program setup failed");
gl.viewport(0, 0, width, height);
glu::draw(renderCtx, program.getProgram(), DE_LENGTH_OF_ARRAY(vertexArrays), &vertexArrays[0],
glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0]));
}
static void blitStencilToColorCube (const glu::RenderContext& renderCtx, deUint32 srcTex, const float* texCoord, int width, int height)
{
const glu::ShaderProgram program(renderCtx, glu::ProgramSources()
<< glu::VertexSource(
"#version 300 es\n"
"in highp vec4 a_position;\n"
"in highp vec3 a_texCoord;\n"
"out highp vec3 v_texCoord;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
" v_texCoord = a_texCoord;\n"
"}\n")
<< glu::FragmentSource(
"#version 300 es\n"
"uniform highp usamplerCube u_sampler;\n"
"in highp vec3 v_texCoord;\n"
"layout(location = 0) out highp vec4 o_color;\n"
"void main (void)\n"
"{\n"
" o_color.x = float(texture(u_sampler, v_texCoord).x) / 255.0;\n"
" o_color.yzw = vec3(0.0, 0.0, 1.0);\n"
"}\n"));
const float positions[] =
{
-1.0f, -1.0f,
-1.0f, +1.0f,
+1.0f, -1.0f,
+1.0f, +1.0f
};
const glu::VertexArrayBinding vertexArrays[] =
{
glu::va::Float("a_position", 2, 4, 0, &positions[0]),
glu::va::Float("a_texCoord", 3, 4, 0, texCoord)
};
const deUint8 indices[] = { 0, 1, 2, 2, 1, 3 };
const glw::Functions& gl = renderCtx.getFunctions();
if (!program.isOk())
throw tcu::TestError("Compile failed");
gl.activeTexture(GL_TEXTURE0);
gl.bindTexture(GL_TEXTURE_CUBE_MAP, srcTex);
gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_DEPTH_STENCIL_TEXTURE_MODE, GL_STENCIL_INDEX);
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture state setup failed");
gl.useProgram(program.getProgram());
gl.uniform1i(gl.getUniformLocation(program.getProgram(), "u_sampler"), 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "Program setup failed");
gl.viewport(0, 0, width, height);
glu::draw(renderCtx, program.getProgram(), DE_LENGTH_OF_ARRAY(vertexArrays), &vertexArrays[0],
glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0]));
}
static inline tcu::ConstPixelBufferAccess stencilToRedAccess (const tcu::ConstPixelBufferAccess& access)
{
DE_ASSERT(access.getFormat() == TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8));
return tcu::ConstPixelBufferAccess(TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT8), access.getSize(), access.getPitch(), access.getDataPtr());
}
static bool compareStencilToRed (tcu::TestLog& log, const tcu::ConstPixelBufferAccess& stencilRef, const tcu::ConstPixelBufferAccess& result)
{
const int maxPrints = 10;
int numFailed = 0;
DE_ASSERT(stencilRef.getFormat().order == TextureFormat::S);
DE_ASSERT(stencilRef.getWidth() == result.getWidth() && stencilRef.getHeight() == result.getHeight());
for (int y = 0; y < stencilRef.getHeight(); y++)
{
for (int x = 0; x < stencilRef.getWidth(); x++)
{
const int ref = stencilRef.getPixStencil(x, y);
const int res = result.getPixelInt(x, y).x();
if (ref != res)
{
if (numFailed < maxPrints)
log << TestLog::Message << "ERROR: Expected " << ref << ", got " << res << " at (" << x << ", " << y << ")" << TestLog::EndMessage;
else if (numFailed == maxPrints)
log << TestLog::Message << "..." << TestLog::EndMessage;
numFailed += 1;
}
}
}
log << TestLog::Message << "Found " << numFailed << " faulty pixels, comparison " << (numFailed == 0 ? "passed." : "FAILED!") << TestLog::EndMessage;
log << TestLog::ImageSet("ComparisonResult", "Image comparison result")
<< TestLog::Image("Result", "Result stencil buffer", result);
if (numFailed > 0)
log << TestLog::Image("Reference", "Reference stencil buffer", stencilToRedAccess(stencilRef));
log << TestLog::EndImageSet;
return numFailed == 0;
}
static bool compareRedChannel (tcu::TestLog& log, const tcu::ConstPixelBufferAccess& result, int reference)
{
const int maxPrints = 10;
int numFailed = 0;
for (int y = 0; y < result.getHeight(); y++)
{
for (int x = 0; x < result.getWidth(); x++)
{
const int res = result.getPixelInt(x, y).x();
if (reference != res)
{
if (numFailed < maxPrints)
log << TestLog::Message << "ERROR: Expected " << reference << ", got " << res << " at (" << x << ", " << y << ")" << TestLog::EndMessage;
else if (numFailed == maxPrints)
log << TestLog::Message << "..." << TestLog::EndMessage;
numFailed += 1;
}
}
}
log << TestLog::Message << "Found " << numFailed << " faulty pixels, comparison " << (numFailed == 0 ? "passed." : "FAILED!") << TestLog::EndMessage;
log << TestLog::ImageSet("ComparisonResult", "Image comparison result")
<< TestLog::Image("Result", "Result stencil buffer", result);
log << TestLog::EndImageSet;
return numFailed == 0;
}
static void stencilToUnorm8 (const tcu::TextureCube& src, tcu::TextureCube& dst)
{
for (int levelNdx = 0; levelNdx < src.getNumLevels(); levelNdx++)
{
for (int faceNdx = 0; faceNdx < tcu::CUBEFACE_LAST; faceNdx++)
{
const tcu::CubeFace face = tcu::CubeFace(faceNdx);
if (!src.isLevelEmpty(face, levelNdx))
{
dst.allocLevel(face, levelNdx);
const tcu::ConstPixelBufferAccess srcLevel = src.getLevelFace(levelNdx, face);
const tcu::PixelBufferAccess dstLevel = dst.getLevelFace(levelNdx, face);
for (int y = 0; y < src.getSize(); y++)
for (int x = 0; x < src.getSize(); x++)
dstLevel.setPixel(Vec4(float(srcLevel.getPixStencil(x, y)) / 255.f, 0.f, 0.f, 1.f), x, y);
}
}
}
}
static void checkDepthStencilFormatSupport (const glu::ContextInfo& ctxInfo, deUint32 format)
{
if (format == GL_STENCIL_INDEX8)
{
const char* reqExt = "GL_OES_texture_stencil8";
if (!ctxInfo.isExtensionSupported(reqExt))
throw tcu::NotSupportedError(glu::getTextureFormatStr(format).toString() + " requires " + reqExt);
}
else
{
DE_ASSERT(format == GL_DEPTH32F_STENCIL8 || format == GL_DEPTH24_STENCIL8);
}
}
static void checkFramebufferStatus (const glw::Functions& gl)
{
const deUint32 status = gl.checkFramebufferStatus(GL_FRAMEBUFFER);
if (status == GL_FRAMEBUFFER_UNSUPPORTED)
throw tcu::NotSupportedError("Unsupported framebuffer configuration");
else if (status != GL_FRAMEBUFFER_COMPLETE)
throw tcu::TestError("Incomplete framebuffer: " + glu::getFramebufferStatusStr(status).toString());
}
class UploadTex2DCase : public TestCase
{
public:
UploadTex2DCase (Context& context, const char* name, deUint32 format)
: TestCase (context, name, glu::getTextureFormatName(format))
, m_format (format)
{
}
IterateResult iterate (void)
{
const glu::RenderContext& renderCtx = m_context.getRenderContext();
const glw::Functions& gl = renderCtx.getFunctions();
const int width = 129;
const int height = 113;
glu::Framebuffer fbo (renderCtx);
glu::Renderbuffer colorBuf (renderCtx);
glu::Texture depthStencilTex (renderCtx);
TextureLevel uploadLevel (glu::mapGLInternalFormat(m_format), width, height);
TextureLevel readLevel (TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT32), width, height);
TextureLevel stencilOnlyLevel (TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8), width, height);
checkDepthStencilFormatSupport(m_context.getContextInfo(), m_format);
renderTestPatternReference(uploadLevel);
renderTestPatternReference(stencilOnlyLevel);
gl.bindTexture(GL_TEXTURE_2D, *depthStencilTex);
gl.texStorage2D(GL_TEXTURE_2D, 1, m_format, width, height);
glu::texSubImage2D(renderCtx, GL_TEXTURE_2D, 0, 0, 0, uploadLevel);
GLU_EXPECT_NO_ERROR(gl.getError(), "Uploading texture data failed");
gl.bindRenderbuffer(GL_RENDERBUFFER, *colorBuf);
gl.renderbufferStorage(GL_RENDERBUFFER, GL_R32UI, width, height);
gl.bindFramebuffer(GL_FRAMEBUFFER, *fbo);
gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, *colorBuf);
checkFramebufferStatus(gl);
blitStencilToColor2D(renderCtx, *depthStencilTex, width, height);
glu::readPixels(renderCtx, 0, 0, readLevel);
{
const bool compareOk = compareStencilToRed(m_testCtx.getLog(), stencilOnlyLevel, readLevel);
m_testCtx.setTestResult(compareOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
compareOk ? "Pass" : "Image comparison failed");
}
return STOP;
}
private:
const deUint32 m_format;
};
class UploadTex2DArrayCase : public TestCase
{
public:
UploadTex2DArrayCase (Context& context, const char* name, deUint32 format)
: TestCase (context, name, glu::getTextureFormatName(format))
, m_format (format)
{
}
IterateResult iterate (void)
{
const glu::RenderContext& renderCtx = m_context.getRenderContext();
const glw::Functions& gl = renderCtx.getFunctions();
const int width = 41;
const int height = 13;
const int levels = 7;
const int ptrnLevel = 3;
glu::Framebuffer fbo (renderCtx);
glu::Renderbuffer colorBuf (renderCtx);
glu::Texture depthStencilTex (renderCtx);
TextureLevel uploadLevel (glu::mapGLInternalFormat(m_format), width, height, levels);
checkDepthStencilFormatSupport(m_context.getContextInfo(), m_format);
for (int levelNdx = 0; levelNdx < levels; levelNdx++)
{
const tcu::PixelBufferAccess levelAccess = tcu::getSubregion(uploadLevel.getAccess(), 0, 0, levelNdx, width, height, 1);
if (levelNdx == ptrnLevel)
renderTestPatternReference(levelAccess);
else
tcu::clearStencil(levelAccess, levelNdx);
}
gl.bindTexture(GL_TEXTURE_2D_ARRAY, *depthStencilTex);
gl.texStorage3D(GL_TEXTURE_2D_ARRAY, 1, m_format, width, height, levels);
glu::texSubImage3D(renderCtx, GL_TEXTURE_2D_ARRAY, 0, 0, 0, 0, uploadLevel);
GLU_EXPECT_NO_ERROR(gl.getError(), "Uploading texture data failed");
gl.bindRenderbuffer(GL_RENDERBUFFER, *colorBuf);
gl.renderbufferStorage(GL_RENDERBUFFER, GL_R32UI, width, height);
gl.bindFramebuffer(GL_FRAMEBUFFER, *fbo);
gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, *colorBuf);
checkFramebufferStatus(gl);
{
TextureLevel readLevel (TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT32), width, height);
bool allLevelsOk = true;
for (int levelNdx = 0; levelNdx < levels; levelNdx++)
{
tcu::ScopedLogSection section(m_testCtx.getLog(), "Level" + de::toString(levelNdx), "Level " + de::toString(levelNdx));
bool levelOk;
blitStencilToColor2DArray(renderCtx, *depthStencilTex, width, height, levelNdx);
glu::readPixels(renderCtx, 0, 0, readLevel);
if (levelNdx == ptrnLevel)
{
TextureLevel reference(TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8), width, height);
renderTestPatternReference(reference);
levelOk = compareStencilToRed(m_testCtx.getLog(), reference, readLevel);
}
else
levelOk = compareRedChannel(m_testCtx.getLog(), readLevel, levelNdx);
if (!levelOk)
{
allLevelsOk = false;
break;
}
}
m_testCtx.setTestResult(allLevelsOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
allLevelsOk ? "Pass" : "Image comparison failed");
}
return STOP;
}
private:
const deUint32 m_format;
};
class UploadTexCubeCase : public TestCase
{
public:
UploadTexCubeCase (Context& context, const char* name, deUint32 format)
: TestCase (context, name, glu::getTextureFormatName(format))
, m_format (format)
{
}
IterateResult iterate (void)
{
const glu::RenderContext& renderCtx = m_context.getRenderContext();
const glw::Functions& gl = renderCtx.getFunctions();
const int size = 64;
const int renderWidth = 128;
const int renderHeight = 128;
vector<float> texCoord;
glu::Framebuffer fbo (renderCtx);
glu::Renderbuffer colorBuf (renderCtx);
glu::Texture depthStencilTex (renderCtx);
tcu::TextureCube texData (glu::mapGLInternalFormat(m_format), size);
tcu::TextureLevel result (TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), renderWidth, renderHeight);
checkDepthStencilFormatSupport(m_context.getContextInfo(), m_format);
for (int faceNdx = 0; faceNdx < tcu::CUBEFACE_LAST; faceNdx++)
{
const tcu::CubeFace face = tcu::CubeFace(faceNdx);
const int stencilVal = 42*faceNdx;
texData.allocLevel(face, 0);
tcu::clearStencil(texData.getLevelFace(0, face), stencilVal);
}
glu::TextureTestUtil::computeQuadTexCoordCube(texCoord, tcu::CUBEFACE_NEGATIVE_X, Vec2(-1.5f, -1.3f), Vec2(1.3f, 1.4f));
gl.bindTexture(GL_TEXTURE_CUBE_MAP, *depthStencilTex);
gl.texStorage2D(GL_TEXTURE_CUBE_MAP, 1, m_format, size, size);
for (int faceNdx = 0; faceNdx < tcu::CUBEFACE_LAST; faceNdx++)
glu::texSubImage2D(renderCtx, glu::getGLCubeFace(tcu::CubeFace(faceNdx)), 0, 0, 0, texData.getLevelFace(0, tcu::CubeFace(faceNdx)));
GLU_EXPECT_NO_ERROR(gl.getError(), "Uploading texture data failed");
gl.bindRenderbuffer(GL_RENDERBUFFER, *colorBuf);
gl.renderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, renderWidth, renderHeight);
gl.bindFramebuffer(GL_FRAMEBUFFER, *fbo);
gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, *colorBuf);
checkFramebufferStatus(gl);
blitStencilToColorCube(renderCtx, *depthStencilTex, &texCoord[0], renderWidth, renderHeight);
glu::readPixels(renderCtx, 0, 0, result);
{
using namespace glu::TextureTestUtil;
tcu::TextureCube redTex (TextureFormat(TextureFormat::R, TextureFormat::UNORM_INT8), size);
const ReferenceParams sampleParams (TEXTURETYPE_CUBE, tcu::Sampler(tcu::Sampler::CLAMP_TO_EDGE,
tcu::Sampler::CLAMP_TO_EDGE,
tcu::Sampler::CLAMP_TO_EDGE,
tcu::Sampler::NEAREST,
tcu::Sampler::NEAREST));
tcu::LookupPrecision lookupPrec;
tcu::LodPrecision lodPrec;
bool compareOk;
lookupPrec.colorMask = tcu::BVec4(true, true, true, true);
lookupPrec.colorThreshold = tcu::computeFixedPointThreshold(IVec4(8, 8, 8, 8));
lookupPrec.coordBits = tcu::IVec3(22, 22, 22);
lookupPrec.uvwBits = tcu::IVec3(5, 5, 0);
lodPrec.lodBits = 7;
lodPrec.derivateBits = 16;
stencilToUnorm8(texData, redTex);
compareOk = verifyTextureResult(m_testCtx, result, redTex, &texCoord[0], sampleParams, lookupPrec, lodPrec, tcu::PixelFormat(8, 8, 8, 8));
m_testCtx.setTestResult(compareOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
compareOk ? "Pass" : "Image comparison failed");
}
return STOP;
}
private:
const deUint32 m_format;
};
class RenderTex2DCase : public TestCase
{
public:
RenderTex2DCase (Context& context, const char* name, deUint32 format)
: TestCase (context, name, glu::getTextureFormatName(format))
, m_format (format)
{
}
IterateResult iterate (void)
{
const glu::RenderContext& renderCtx = m_context.getRenderContext();
const glw::Functions& gl = renderCtx.getFunctions();
const int width = 117;
const int height = 193;
glu::Framebuffer fbo (renderCtx);
glu::Renderbuffer colorBuf (renderCtx);
glu::Texture depthStencilTex (renderCtx);
TextureLevel result (TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT32), width, height);
TextureLevel reference (TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8), width, height);
checkDepthStencilFormatSupport(m_context.getContextInfo(), m_format);
gl.bindRenderbuffer(GL_RENDERBUFFER, *colorBuf);
gl.renderbufferStorage(GL_RENDERBUFFER, GL_R32UI, width, height);
gl.bindTexture(GL_TEXTURE_2D, *depthStencilTex);
gl.texStorage2D(GL_TEXTURE_2D, 1, m_format, width, height);
gl.bindFramebuffer(GL_FRAMEBUFFER, *fbo);
gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, *colorBuf);
gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, *depthStencilTex, 0);
checkFramebufferStatus(gl);
drawTestPattern(renderCtx, width, height);
gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, 0);
checkFramebufferStatus(gl);
blitStencilToColor2D(renderCtx, *depthStencilTex, width, height);
glu::readPixels(renderCtx, 0, 0, result.getAccess());
renderTestPatternReference(reference);
{
const bool compareOk = compareStencilToRed(m_testCtx.getLog(), reference, result);
m_testCtx.setTestResult(compareOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
compareOk ? "Pass" : "Image comparison failed");
}
return STOP;
}
private:
const deUint32 m_format;
};
class ClearTex2DCase : public TestCase
{
public:
ClearTex2DCase (Context& context, const char* name, deUint32 format)
: TestCase (context, name, glu::getTextureFormatName(format))
, m_format (format)
{
}
IterateResult iterate (void)
{
const glu::RenderContext& renderCtx = m_context.getRenderContext();
const glw::Functions& gl = renderCtx.getFunctions();
const int width = 125;
const int height = 117;
const int cellSize = 8;
glu::Framebuffer fbo (renderCtx);
glu::Renderbuffer colorBuf (renderCtx);
glu::Texture depthStencilTex (renderCtx);
TextureLevel result (TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT32), width, height);
TextureLevel reference (TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8), width, height);
checkDepthStencilFormatSupport(m_context.getContextInfo(), m_format);
gl.bindRenderbuffer(GL_RENDERBUFFER, *colorBuf);
gl.renderbufferStorage(GL_RENDERBUFFER, GL_R32UI, width, height);
gl.bindTexture(GL_TEXTURE_2D, *depthStencilTex);
gl.texStorage2D(GL_TEXTURE_2D, 1, m_format, width, height);
gl.bindFramebuffer(GL_FRAMEBUFFER, *fbo);
gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, *colorBuf);
gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, *depthStencilTex, 0);
checkFramebufferStatus(gl);
gl.enable(GL_SCISSOR_TEST);
for (int y = 0; y < height; y += cellSize)
{
for (int x = 0; x < width; x += cellSize)
{
const int clearW = de::min(cellSize, width-x);
const int clearH = de::min(cellSize, height-y);
const int stencil = int((deInt32Hash(x) ^ deInt32Hash(y)) & 0xff);
gl.clearStencil(stencil);
gl.scissor(x, y, clearW, clearH);
gl.clear(GL_STENCIL_BUFFER_BIT);
tcu::clearStencil(tcu::getSubregion(reference.getAccess(), x, y, clearW, clearH), stencil);
}
}
gl.disable(GL_SCISSOR_TEST);
gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, 0);
checkFramebufferStatus(gl);
blitStencilToColor2D(renderCtx, *depthStencilTex, width, height);
glu::readPixels(renderCtx, 0, 0, result.getAccess());
{
const bool compareOk = compareStencilToRed(m_testCtx.getLog(), reference, result);
m_testCtx.setTestResult(compareOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
compareOk ? "Pass" : "Image comparison failed");
}
return STOP;
}
private:
const deUint32 m_format;
};
class CompareModeCase : public TestCase
{
public:
CompareModeCase (Context& context, const char* name, deUint32 format)
: TestCase (context, name, glu::getTextureFormatName(format))
, m_format (format)
{
}
IterateResult iterate (void)
{
const glu::RenderContext& renderCtx = m_context.getRenderContext();
const glw::Functions& gl = renderCtx.getFunctions();
const int width = 64;
const int height = 64;
glu::Framebuffer fbo (renderCtx);
glu::Renderbuffer colorBuf (renderCtx);
glu::Texture depthStencilTex (renderCtx);
TextureLevel uploadLevel (glu::mapGLInternalFormat(m_format), width, height);
TextureLevel readLevel (TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT32), width, height);
TextureLevel stencilOnlyLevel (TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8), width, height);
checkDepthStencilFormatSupport(m_context.getContextInfo(), m_format);
m_testCtx.getLog() << TestLog::Message << "NOTE: Texture compare mode has no effect when reading stencil values." << TestLog::EndMessage;
renderTestPatternReference(uploadLevel);
renderTestPatternReference(stencilOnlyLevel);
gl.bindTexture(GL_TEXTURE_2D, *depthStencilTex);
gl.texStorage2D(GL_TEXTURE_2D, 1, m_format, width, height);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LESS);
glu::texSubImage2D(renderCtx, GL_TEXTURE_2D, 0, 0, 0, uploadLevel);
GLU_EXPECT_NO_ERROR(gl.getError(), "Uploading texture data failed");
gl.bindRenderbuffer(GL_RENDERBUFFER, *colorBuf);
gl.renderbufferStorage(GL_RENDERBUFFER, GL_R32UI, width, height);
gl.bindFramebuffer(GL_FRAMEBUFFER, *fbo);
gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, *colorBuf);
checkFramebufferStatus(gl);
blitStencilToColor2D(renderCtx, *depthStencilTex, width, height);
glu::readPixels(renderCtx, 0, 0, readLevel);
{
const bool compareOk = compareStencilToRed(m_testCtx.getLog(), stencilOnlyLevel, readLevel);
m_testCtx.setTestResult(compareOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
compareOk ? "Pass" : "Image comparison failed");
}
return STOP;
}
private:
const deUint32 m_format;
};
class BaseLevelCase : public TestCase
{
public:
BaseLevelCase (Context& context, const char* name, deUint32 format)
: TestCase (context, name, glu::getTextureFormatName(format))
, m_format (format)
{
}
IterateResult iterate (void)
{
const glu::RenderContext& renderCtx = m_context.getRenderContext();
const glw::Functions& gl = renderCtx.getFunctions();
const int width = 128;
const int height = 128;
const int levelNdx = 2;
const int levelWidth = width>>levelNdx;
const int levelHeight = height>>levelNdx;
glu::Framebuffer fbo (renderCtx);
glu::Renderbuffer colorBuf (renderCtx);
glu::Texture depthStencilTex (renderCtx);
TextureLevel uploadLevel (glu::mapGLInternalFormat(m_format), levelWidth, levelHeight);
TextureLevel readLevel (TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT32), levelWidth, levelHeight);
TextureLevel stencilOnlyLevel (TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8), levelWidth, levelHeight);
checkDepthStencilFormatSupport(m_context.getContextInfo(), m_format);
m_testCtx.getLog() << TestLog::Message << "GL_TEXTURE_BASE_LEVEL = " << levelNdx << TestLog::EndMessage;
renderTestPatternReference(uploadLevel);
renderTestPatternReference(stencilOnlyLevel);
gl.bindTexture(GL_TEXTURE_2D, *depthStencilTex);
gl.texStorage2D(GL_TEXTURE_2D, deLog2Floor32(de::max(width, height))+1, m_format, width, height);
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, levelNdx);
glu::texSubImage2D(renderCtx, GL_TEXTURE_2D, levelNdx, 0, 0, uploadLevel);
GLU_EXPECT_NO_ERROR(gl.getError(), "Uploading texture data failed");
gl.bindRenderbuffer(GL_RENDERBUFFER, *colorBuf);
gl.renderbufferStorage(GL_RENDERBUFFER, GL_R32UI, levelWidth, levelHeight);
gl.bindFramebuffer(GL_FRAMEBUFFER, *fbo);
gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, *colorBuf);
checkFramebufferStatus(gl);
blitStencilToColor2D(renderCtx, *depthStencilTex, levelWidth, levelHeight);
glu::readPixels(renderCtx, 0, 0, readLevel);
{
const bool compareOk = compareStencilToRed(m_testCtx.getLog(), stencilOnlyLevel, readLevel);
m_testCtx.setTestResult(compareOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
compareOk ? "Pass" : "Image comparison failed");
}
return STOP;
}
private:
const deUint32 m_format;
};
} // anonymous
StencilTexturingTests::StencilTexturingTests (Context& context)
: TestCaseGroup(context, "stencil_texturing", "Stencil texturing tests")
{
}
StencilTexturingTests::~StencilTexturingTests (void)
{
}
void StencilTexturingTests::init (void)
{
// .format
{
tcu::TestCaseGroup* const formatGroup = new tcu::TestCaseGroup(m_testCtx, "format", "Formats");
addChild(formatGroup);
formatGroup->addChild(new UploadTex2DCase (m_context, "depth32f_stencil8_2d", GL_DEPTH32F_STENCIL8));
formatGroup->addChild(new UploadTex2DArrayCase (m_context, "depth32f_stencil8_2d_array", GL_DEPTH32F_STENCIL8));
formatGroup->addChild(new UploadTexCubeCase (m_context, "depth32f_stencil8_cube", GL_DEPTH32F_STENCIL8));
formatGroup->addChild(new UploadTex2DCase (m_context, "depth24_stencil8_2d", GL_DEPTH24_STENCIL8));
formatGroup->addChild(new UploadTex2DArrayCase (m_context, "depth24_stencil8_2d_array", GL_DEPTH24_STENCIL8));
formatGroup->addChild(new UploadTexCubeCase (m_context, "depth24_stencil8_cube", GL_DEPTH24_STENCIL8));
// OES_texture_stencil8
formatGroup->addChild(new UploadTex2DCase (m_context, "stencil_index8_2d", GL_STENCIL_INDEX8));
formatGroup->addChild(new UploadTex2DArrayCase (m_context, "stencil_index8_2d_array", GL_STENCIL_INDEX8));
formatGroup->addChild(new UploadTexCubeCase (m_context, "stencil_index8_cube", GL_STENCIL_INDEX8));
}
// .render
{
tcu::TestCaseGroup* const readRenderGroup = new tcu::TestCaseGroup(m_testCtx, "render", "Read rendered stencil values");
addChild(readRenderGroup);
readRenderGroup->addChild(new ClearTex2DCase (m_context, "depth32f_stencil8_clear", GL_DEPTH32F_STENCIL8));
readRenderGroup->addChild(new RenderTex2DCase (m_context, "depth32f_stencil8_draw", GL_DEPTH32F_STENCIL8));
readRenderGroup->addChild(new ClearTex2DCase (m_context, "depth24_stencil8_clear", GL_DEPTH24_STENCIL8));
readRenderGroup->addChild(new RenderTex2DCase (m_context, "depth24_stencil8_draw", GL_DEPTH24_STENCIL8));
}
// .misc
{
tcu::TestCaseGroup* const miscGroup = new tcu::TestCaseGroup(m_testCtx, "misc", "Misc cases");
addChild(miscGroup);
miscGroup->addChild(new CompareModeCase (m_context, "compare_mode_effect", GL_DEPTH24_STENCIL8));
miscGroup->addChild(new BaseLevelCase (m_context, "base_level", GL_DEPTH24_STENCIL8));
}
}
} // Functional
} // gles31
} // deqp