/*-------------------------------------------------------------------------
* 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 Stencil tests.
*//*--------------------------------------------------------------------*/
#include "es3fStencilTests.hpp"
#include "tcuSurface.hpp"
#include "tcuVector.hpp"
#include "tcuTestLog.hpp"
#include "tcuImageCompare.hpp"
#include "tcuRenderTarget.hpp"
#include "sglrContextUtil.hpp"
#include "sglrGLContext.hpp"
#include "sglrReferenceContext.hpp"
#include "deRandom.hpp"
#include "deMath.h"
#include "deString.h"
#include <vector>
#include "glwEnums.hpp"
#include "glwDefs.hpp"
using tcu::Vec3;
using tcu::IVec2;
using tcu::IVec4;
using std::vector;
using namespace glw;
namespace deqp
{
namespace gles3
{
namespace Functional
{
class StencilShader : public sglr::ShaderProgram
{
public:
StencilShader (void)
: sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration()
<< sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT)
<< sglr::pdec::Uniform("u_color", glu::TYPE_FLOAT_VEC4)
<< sglr::pdec::VertexSource("#version 300 es\n"
"in highp vec4 a_position;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
"}\n")
<< sglr::pdec::FragmentSource("#version 300 es\n"
"uniform highp vec4 u_color;\n"
"layout(location = 0) out mediump vec4 o_color;\n"
"void main (void)\n"
"{\n"
" o_color = u_color;\n"
"}\n"))
, u_color (getUniformByName("u_color"))
{
}
void setColor (sglr::Context& ctx, deUint32 program, const tcu::Vec4& color)
{
ctx.useProgram(program);
ctx.uniform4fv(ctx.getUniformLocation(program, "u_color"), 1, color.getPtr());
}
private:
void shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
{
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
rr::VertexPacket& packet = *packets[packetNdx];
packet.position = rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx);
}
}
void shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
{
const tcu::Vec4 color(u_color.value.f4);
DE_UNREF(packets);
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
}
const sglr::UniformSlot& u_color;
};
class StencilOp
{
public:
enum Type
{
TYPE_CLEAR_STENCIL = 0,
TYPE_CLEAR_DEPTH,
TYPE_QUAD,
TYPE_LAST
};
Type type;
GLenum stencilTest;
int stencil; //!< Ref for quad op, clear value for clears
deUint32 stencilMask;
GLenum depthTest;
float depth; //!< Quad depth or clear value
GLenum sFail;
GLenum dFail;
GLenum dPass;
StencilOp (Type type_, GLenum stencilTest_ = GL_ALWAYS, int stencil_ = 0, GLenum depthTest_ = GL_ALWAYS, float depth_ = 1.0f, GLenum sFail_ = GL_KEEP, GLenum dFail_ = GL_KEEP, GLenum dPass_ = GL_KEEP)
: type (type_)
, stencilTest (stencilTest_)
, stencil (stencil_)
, stencilMask (0xffffffffu)
, depthTest (depthTest_)
, depth (depth_)
, sFail (sFail_)
, dFail (dFail_)
, dPass (dPass_)
{
}
static StencilOp clearStencil (int stencil)
{
StencilOp op(TYPE_CLEAR_STENCIL);
op.stencil = stencil;
return op;
}
static StencilOp clearDepth (float depth)
{
StencilOp op(TYPE_CLEAR_DEPTH);
op.depth = depth;
return op;
}
static StencilOp quad (GLenum stencilTest, int stencil, GLenum depthTest, float depth, GLenum sFail, GLenum dFail, GLenum dPass)
{
return StencilOp(TYPE_QUAD, stencilTest, stencil, depthTest, depth, sFail, dFail, dPass);
}
};
class StencilCase : public TestCase
{
public:
StencilCase (Context& context, const char* name, const char* description);
virtual ~StencilCase (void);
void init (void);
void deinit (void);
IterateResult iterate (void);
virtual void genOps (vector<StencilOp>& dst, int stencilBits, int depthBits, int targetStencil) = DE_NULL;
private:
void executeOps (sglr::Context& context, const IVec4& cell, const vector<StencilOp>& ops);
void visualizeStencil (sglr::Context& context, int stencilBits, int stencilStep);
StencilShader m_shader;
deUint32 m_shaderID;
};
StencilCase::StencilCase (Context& context, const char* name, const char* description)
: TestCase (context, name, description)
, m_shaderID (0)
{
}
StencilCase::~StencilCase (void)
{
}
void StencilCase::init (void)
{
}
void StencilCase::deinit (void)
{
}
void StencilCase::executeOps (sglr::Context& context, const IVec4& cell, const vector<StencilOp>& ops)
{
// For quadOps
float x0 = 2.0f*((float)cell.x() / (float)context.getWidth())-1.0f;
float y0 = 2.0f*((float)cell.y() / (float)context.getHeight())-1.0f;
float x1 = x0 + 2.0f*((float)cell.z() / (float)context.getWidth());
float y1 = y0 + 2.0f*((float)cell.w() / (float)context.getHeight());
m_shader.setColor(context, m_shaderID, tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
for (vector<StencilOp>::const_iterator i = ops.begin(); i != ops.end(); i++)
{
const StencilOp& op = *i;
switch (op.type)
{
case StencilOp::TYPE_CLEAR_DEPTH:
context.enable(GL_SCISSOR_TEST);
context.scissor(cell.x(), cell.y(), cell.z(), cell.w());
context.clearDepthf(op.depth);
context.clear(GL_DEPTH_BUFFER_BIT);
context.disable(GL_SCISSOR_TEST);
break;
case StencilOp::TYPE_CLEAR_STENCIL:
context.enable(GL_SCISSOR_TEST);
context.scissor(cell.x(), cell.y(), cell.z(), cell.w());
context.clearStencil(op.stencil);
context.clear(GL_STENCIL_BUFFER_BIT);
context.disable(GL_SCISSOR_TEST);
break;
case StencilOp::TYPE_QUAD:
context.enable(GL_DEPTH_TEST);
context.enable(GL_STENCIL_TEST);
context.depthFunc(op.depthTest);
context.stencilFunc(op.stencilTest, op.stencil, op.stencilMask);
context.stencilOp(op.sFail, op.dFail, op.dPass);
sglr::drawQuad(context, m_shaderID, Vec3(x0, y0, op.depth), Vec3(x1, y1, op.depth));
context.disable(GL_STENCIL_TEST);
context.disable(GL_DEPTH_TEST);
break;
default:
DE_ASSERT(DE_FALSE);
}
}
}
void StencilCase::visualizeStencil (sglr::Context& context, int stencilBits, int stencilStep)
{
int endVal = 1<<stencilBits;
int numStencilValues = endVal/stencilStep + 1;
context.enable(GL_STENCIL_TEST);
context.stencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
for (int ndx = 0; ndx < numStencilValues; ndx++)
{
int value = deMin32(ndx*stencilStep, endVal-1);
float colorMix = (float)value/(float)de::max(1, endVal-1);
tcu::Vec4 color (0.0f, 1.0f-colorMix, colorMix, 1.0f);
m_shader.setColor(context, m_shaderID, color);
context.stencilFunc(GL_EQUAL, value, 0xffffffffu);
sglr::drawQuad(context, m_shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(+1.0f, +1.0f, 0.0f));
}
}
TestCase::IterateResult StencilCase::iterate (void)
{
const tcu::RenderTarget& renderTarget = m_context.getRenderContext().getRenderTarget();
int depthBits = renderTarget.getDepthBits();
int stencilBits = renderTarget.getStencilBits();
int stencilStep = stencilBits == 8 ? 8 : 1;
int numStencilValues = (1<<stencilBits)/stencilStep + 1;
int gridSize = (int)deFloatCeil(deFloatSqrt((float)(numStencilValues+2)));
int width = deMin32(128, renderTarget.getWidth());
int height = deMin32(128, renderTarget.getHeight());
tcu::TestLog& log = m_testCtx.getLog();
de::Random rnd (deStringHash(m_name.c_str()));
int viewportX = rnd.getInt(0, renderTarget.getWidth()-width);
int viewportY = rnd.getInt(0, renderTarget.getHeight()-height);
IVec4 viewport = IVec4(viewportX, viewportY, width, height);
tcu::Surface gles2Frame (width, height);
tcu::Surface refFrame (width, height);
GLenum gles2Error;
const char* failReason = DE_NULL;
// Get ops for stencil values
vector<vector<StencilOp> > ops(numStencilValues+2);
{
// Values from 0 to max
for (int ndx = 0; ndx < numStencilValues; ndx++)
genOps(ops[ndx], stencilBits, depthBits, deMin32(ndx*stencilStep, (1<<stencilBits)-1));
// -1 and max+1
genOps(ops[numStencilValues+0], stencilBits, depthBits, 1<<stencilBits);
genOps(ops[numStencilValues+1], stencilBits, depthBits, -1);
}
// Compute cells: (x, y, w, h)
vector<IVec4> cells;
int cellWidth = width/gridSize;
int cellHeight = height/gridSize;
for (int y = 0; y < gridSize; y++)
for (int x = 0; x < gridSize; x++)
cells.push_back(IVec4(x*cellWidth, y*cellHeight, cellWidth, cellHeight));
DE_ASSERT(ops.size() <= cells.size());
// Execute for gles3 context
{
sglr::GLContext context(m_context.getRenderContext(), log, 0 /* don't log calls or program */, viewport);
m_shaderID = context.createProgram(&m_shader);
context.clearColor(1.0f, 0.0f, 0.0f, 1.0f);
context.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
for (int ndx = 0; ndx < (int)ops.size(); ndx++)
executeOps(context, cells[ndx], ops[ndx]);
visualizeStencil(context, stencilBits, stencilStep);
gles2Error = context.getError();
context.readPixels(gles2Frame, 0, 0, width, height);
}
// Execute for reference context
{
sglr::ReferenceContextBuffers buffers (tcu::PixelFormat(8,8,8,renderTarget.getPixelFormat().alphaBits?8:0), renderTarget.getDepthBits(), renderTarget.getStencilBits(), width, height);
sglr::ReferenceContext context (sglr::ReferenceContextLimits(m_context.getRenderContext()), buffers.getColorbuffer(), buffers.getDepthbuffer(), buffers.getStencilbuffer());
m_shaderID = context.createProgram(&m_shader);
context.clearColor(1.0f, 0.0f, 0.0f, 1.0f);
context.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
for (int ndx = 0; ndx < (int)ops.size(); ndx++)
executeOps(context, cells[ndx], ops[ndx]);
visualizeStencil(context, stencilBits, stencilStep);
context.readPixels(refFrame, 0, 0, width, height);
}
// Check error
bool errorCodeOk = (gles2Error == GL_NO_ERROR);
if (!errorCodeOk && !failReason)
failReason = "Got unexpected error";
// Compare images
const float threshold = 0.02f;
bool imagesOk = tcu::fuzzyCompare(log, "ComparisonResult", "Image comparison result", refFrame, gles2Frame, threshold, tcu::COMPARE_LOG_RESULT);
if (!imagesOk && !failReason)
failReason = "Image comparison failed";
// Store test result
bool isOk = errorCodeOk && imagesOk;
m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
isOk ? "Pass" : failReason);
return STOP;
}
StencilTests::StencilTests (Context& context)
: TestCaseGroup(context, "stencil", "Stencil Tests")
{
}
StencilTests::~StencilTests (void)
{
}
typedef void (*GenStencilOpsFunc) (vector<StencilOp>& dst, int stencilBits, int depthBits, int targetStencil);
class SimpleStencilCase : public StencilCase
{
public:
SimpleStencilCase (Context& context, const char* name, const char* description, GenStencilOpsFunc genOpsFunc)
: StencilCase (context, name, description)
, m_genOps (genOpsFunc)
{
}
void genOps (vector<StencilOp>& dst, int stencilBits, int depthBits, int targetStencil)
{
m_genOps(dst, stencilBits, depthBits, targetStencil);
}
private:
GenStencilOpsFunc m_genOps;
};
void StencilTests::init (void)
{
#define STENCIL_CASE(NAME, DESCRIPTION, GEN_OPS_BODY) \
do { \
struct Gen_##NAME { \
static void genOps (vector<StencilOp>& dst, int stencilBits, int depthBits, int targetStencil) \
{ \
DE_UNREF(stencilBits && depthBits); \
GEN_OPS_BODY \
} \
}; \
addChild(new SimpleStencilCase(m_context, #NAME, DESCRIPTION, Gen_##NAME::genOps)); \
} while (deGetFalse());
STENCIL_CASE(clear, "Stencil clear",
{
// \note Unused bits are set to 1, clear should mask them out
int mask = (1<<stencilBits)-1;
dst.push_back(StencilOp::clearStencil(targetStencil | ~mask));
});
// Replace in different points
STENCIL_CASE(stencil_fail_replace, "Set stencil on stencil fail",
{
dst.push_back(StencilOp::quad(GL_NEVER, targetStencil, GL_ALWAYS, 0.0f, GL_REPLACE, GL_KEEP, GL_KEEP));
});
STENCIL_CASE(depth_fail_replace, "Set stencil on depth fail",
{
dst.push_back(StencilOp::clearDepth(0.0f));
dst.push_back(StencilOp::quad(GL_ALWAYS, targetStencil, GL_LESS, 0.5f, GL_KEEP, GL_REPLACE, GL_KEEP));
});
STENCIL_CASE(depth_pass_replace, "Set stencil on depth pass",
{
dst.push_back(StencilOp::quad(GL_ALWAYS, targetStencil, GL_LESS, 0.0f, GL_KEEP, GL_KEEP, GL_REPLACE));
});
// Increment, decrement
STENCIL_CASE(incr_stencil_fail, "Increment on stencil fail",
{
if (targetStencil > 0)
{
dst.push_back(StencilOp::clearStencil(targetStencil-1));
dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_INCR, GL_KEEP, GL_KEEP));
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
});
STENCIL_CASE(decr_stencil_fail, "Decrement on stencil fail",
{
int maxStencil = (1<<stencilBits)-1;
if (targetStencil < maxStencil)
{
dst.push_back(StencilOp::clearStencil(targetStencil+1));
dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_DECR, GL_KEEP, GL_KEEP));
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
});
STENCIL_CASE(incr_wrap_stencil_fail, "Increment (wrap) on stencil fail",
{
int maxStencil = (1<<stencilBits)-1;
dst.push_back(StencilOp::clearStencil((targetStencil-1)&maxStencil));
dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_INCR_WRAP, GL_KEEP, GL_KEEP));
});
STENCIL_CASE(decr_wrap_stencil_fail, "Decrement (wrap) on stencil fail",
{
int maxStencil = (1<<stencilBits)-1;
dst.push_back(StencilOp::clearStencil((targetStencil+1)&maxStencil));
dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_DECR_WRAP, GL_KEEP, GL_KEEP));
});
// Zero, Invert
STENCIL_CASE(zero_stencil_fail, "Zero on stencil fail",
{
dst.push_back(StencilOp::clearStencil(targetStencil));
dst.push_back(StencilOp::quad(GL_NOTEQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_ZERO, GL_KEEP, GL_KEEP));
dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_REPLACE, GL_KEEP, GL_KEEP));
});
STENCIL_CASE(invert_stencil_fail, "Invert on stencil fail",
{
int mask = (1<<stencilBits)-1;
dst.push_back(StencilOp::clearStencil((~targetStencil)&mask));
dst.push_back(StencilOp::quad(GL_EQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_INVERT, GL_KEEP, GL_KEEP));
});
// Comparison modes
STENCIL_CASE(cmp_equal, "Equality comparison",
{
int mask = (1<<stencilBits)-1;
int inv = (~targetStencil)&mask;
dst.push_back(StencilOp::clearStencil(inv));
dst.push_back(StencilOp::quad(GL_EQUAL, inv, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT));
dst.push_back(StencilOp::quad(GL_EQUAL, inv, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT));
});
STENCIL_CASE(cmp_not_equal, "Equality comparison",
{
int mask = (1<<stencilBits)-1;
int inv = (~targetStencil)&mask;
dst.push_back(StencilOp::clearStencil(inv));
dst.push_back(StencilOp::quad(GL_NOTEQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT));
dst.push_back(StencilOp::quad(GL_NOTEQUAL, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT));
});
STENCIL_CASE(cmp_less_than, "Less than comparison",
{
int maxStencil = (1<<stencilBits)-1;
if (targetStencil < maxStencil)
{
dst.push_back(StencilOp::clearStencil(targetStencil+1));
dst.push_back(StencilOp::quad(GL_LESS, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_DECR));
dst.push_back(StencilOp::quad(GL_LESS, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_DECR));
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
});
STENCIL_CASE(cmp_less_or_equal, "Less or equal comparison",
{
int maxStencil = (1<<stencilBits)-1;
if (targetStencil < maxStencil)
{
dst.push_back(StencilOp::clearStencil(targetStencil+1));
dst.push_back(StencilOp::quad(GL_LEQUAL, targetStencil+1, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_DECR));
dst.push_back(StencilOp::quad(GL_LEQUAL, targetStencil+1, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_DECR));
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
});
STENCIL_CASE(cmp_greater_than, "Greater than comparison",
{
if (targetStencil > 0)
{
dst.push_back(StencilOp::clearStencil(targetStencil-1));
dst.push_back(StencilOp::quad(GL_GREATER, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INCR));
dst.push_back(StencilOp::quad(GL_GREATER, targetStencil, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INCR));
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
});
STENCIL_CASE(cmp_greater_or_equal, "Greater or equal comparison",
{
if (targetStencil > 0)
{
dst.push_back(StencilOp::clearStencil(targetStencil-1));
dst.push_back(StencilOp::quad(GL_GEQUAL, targetStencil-1, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INCR));
dst.push_back(StencilOp::quad(GL_GEQUAL, targetStencil-1, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INCR));
}
else
dst.push_back(StencilOp::clearStencil(targetStencil));
});
STENCIL_CASE(cmp_mask_equal, "Equality comparison with mask",
{
int valMask = (1<<stencilBits)-1;
int mask = (1<<7)|(1<<5)|(1<<3)|(1<<1);
dst.push_back(StencilOp::clearStencil(~targetStencil));
StencilOp op = StencilOp::quad(GL_EQUAL, (~targetStencil | ~mask) & valMask, GL_ALWAYS, 0.0f, GL_KEEP, GL_KEEP, GL_INVERT);
op.stencilMask = mask;
dst.push_back(op);
});
}
} // Functional
} // gles3
} // deqp