/*-------------------------------------------------------------------------
* drawElements Quality Program OpenGL ES 2.0 Module
* -------------------------------------------------
*
* Copyright 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*//*!
* \file
* \brief Depth and stencil clear tests.
*//*--------------------------------------------------------------------*/
#include "es2fDepthStencilClearTests.hpp"
#include "gluShaderProgram.hpp"
#include "gluPixelTransfer.hpp"
#include "gluRenderContext.hpp"
#include "tcuTestLog.hpp"
#include "tcuTexture.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuImageCompare.hpp"
#include "tcuSurface.hpp"
#include "tcuRenderTarget.hpp"
#include "deRandom.hpp"
#include "deMath.h"
#include "deString.h"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"
namespace deqp
{
namespace gles2
{
namespace Functional
{
using tcu::Vec3;
using tcu::Vec4;
using tcu::TestLog;
using std::string;
using std::vector;
namespace
{
enum
{
STENCIL_STEPS = 32,
DEPTH_STEPS = 32
};
struct Clear
{
Clear (void)
: clearMask (0)
, clearDepth (0.0f)
, clearStencil (0)
, useScissor (false)
, scissor (0, 0, 0, 0)
, depthMask (false)
, stencilMask (0)
{
}
deUint32 clearMask;
float clearDepth;
int clearStencil;
bool useScissor;
tcu::IVec4 scissor;
bool depthMask;
deUint32 stencilMask;
};
tcu::TextureFormat getDepthFormat (int depthBits)
{
switch (depthBits)
{
case 8: return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNORM_INT8);
case 16: return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNORM_INT16);
case 24: return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::UNORM_INT24);
case 32: return tcu::TextureFormat(tcu::TextureFormat::D, tcu::TextureFormat::FLOAT);
default:
TCU_FAIL("Can't map depth buffer format");
}
}
tcu::TextureFormat getStencilFormat (int stencilBits)
{
switch (stencilBits)
{
case 8: return tcu::TextureFormat(tcu::TextureFormat::S, tcu::TextureFormat::UNSIGNED_INT8);
case 16: return tcu::TextureFormat(tcu::TextureFormat::S, tcu::TextureFormat::UNSIGNED_INT16);
case 24: return tcu::TextureFormat(tcu::TextureFormat::S, tcu::TextureFormat::UNSIGNED_INT24);
case 32: return tcu::TextureFormat(tcu::TextureFormat::S, tcu::TextureFormat::UNSIGNED_INT32);
default:
TCU_FAIL("Can't map depth buffer format");
}
}
} // anonymous.
class DepthStencilClearCase : public TestCase
{
public:
DepthStencilClearCase (Context& context, const char* name, const char* description, int numIters, int numClears, bool depth, bool stencil, bool scissor, bool masked);
~DepthStencilClearCase (void);
void init (void);
void deinit (void);
IterateResult iterate (void);
private:
void generateClears (vector<Clear>& dst, deUint32 seed);
void renderGL (tcu::Surface& dst, const vector<Clear>& clears);
void renderReference (tcu::Surface& dst, const vector<Clear>& clears);
bool m_testDepth;
bool m_testStencil;
bool m_testScissor;
bool m_masked;
int m_numIters;
int m_numClears;
int m_curIter;
glu::ShaderProgram* m_visProgram;
};
DepthStencilClearCase::DepthStencilClearCase (Context& context, const char* name, const char* description, int numIters, int numClears, bool depth, bool stencil, bool scissor, bool masked)
: TestCase (context, name, description)
, m_testDepth (depth)
, m_testStencil (stencil)
, m_testScissor (scissor)
, m_masked (masked)
, m_numIters (numIters)
, m_numClears (numClears)
, m_curIter (0)
, m_visProgram (DE_NULL)
{
}
DepthStencilClearCase::~DepthStencilClearCase (void)
{
DepthStencilClearCase::deinit();
}
void DepthStencilClearCase::init (void)
{
TestLog& log = m_testCtx.getLog();
m_visProgram = new glu::ShaderProgram(m_context.getRenderContext(), glu::makeVtxFragSources(
// Vertex shader.
"attribute highp vec4 a_position;\n"
"void main (void)\n"
"{\n"
" gl_Position = a_position;\n"
"}\n",
// Fragment shader.
"uniform mediump vec4 u_color;\n"
"void main (void)\n"
"{\n"
" gl_FragColor = u_color;\n"
"}\n"));
if (!m_visProgram->isOk())
{
log << *m_visProgram;
delete m_visProgram;
m_visProgram = DE_NULL;
TCU_FAIL("Compile failed");
}
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
void DepthStencilClearCase::deinit (void)
{
delete m_visProgram;
m_visProgram = DE_NULL;
}
DepthStencilClearCase::IterateResult DepthStencilClearCase::iterate (void)
{
const tcu::RenderTarget& renderTarget = m_context.getRenderTarget();
int width = renderTarget.getWidth();
int height = renderTarget.getHeight();
tcu::Surface result (width, height);
tcu::Surface reference (width, height);
tcu::RGBA threshold = renderTarget.getPixelFormat().getColorThreshold() + tcu::RGBA(1,1,1,1);
vector<Clear> clears;
if ((m_testDepth && renderTarget.getDepthBits() == 0) ||
(m_testStencil && renderTarget.getStencilBits() == 0))
throw tcu::NotSupportedError("No depth/stencil buffers", "", __FILE__, __LINE__);
generateClears(clears, deStringHash(getName())^deInt32Hash(m_curIter));
renderGL(result, clears);
renderReference(reference, clears);
bool isLastIter = m_curIter+1 == m_numIters;
bool isOk = tcu::pixelThresholdCompare(m_testCtx.getLog(), "Result", "Image comparison result", reference, result, threshold, isLastIter ? tcu::COMPARE_LOG_RESULT : tcu::COMPARE_LOG_ON_ERROR);
if (!isOk)
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
m_curIter += 1;
return isLastIter || !isOk ? STOP : CONTINUE;
}
void DepthStencilClearCase::generateClears (vector<Clear>& clears, deUint32 seed)
{
const tcu::RenderTarget& renderTarget = m_context.getRenderContext().getRenderTarget();
int width = renderTarget.getWidth();
int height = renderTarget.getHeight();
de::Random rnd (seed);
clears.resize(m_numClears);
for (vector<Clear>::iterator clear = clears.begin(); clear != clears.end(); clear++)
{
if (m_testScissor)
{
int w = rnd.getInt(1, width);
int h = rnd.getInt(1, height);
int x = rnd.getInt(0, width-w);
int y = rnd.getInt(0, height-h);
clear->useScissor = true; // \todo [pyry] Should we randomize?
clear->scissor = tcu::IVec4(x, y, w, h);
}
else
clear->useScissor = false;
clear->clearDepth = rnd.getFloat(-0.2f, 1.2f);
clear->clearStencil = rnd.getUint32();
clear->depthMask = m_masked ? rnd.getBool() : true;
clear->stencilMask = m_masked ? rnd.getUint32() : 0xffffffffu;
if (m_testDepth && m_testStencil)
{
switch (rnd.getInt(0, 2))
{
case 0: clear->clearMask = GL_DEPTH_BUFFER_BIT; break;
case 1: clear->clearMask = GL_STENCIL_BUFFER_BIT; break;
case 2: clear->clearMask = GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT; break;
}
}
else if (m_testDepth)
clear->clearMask = GL_DEPTH_BUFFER_BIT;
else
{
DE_ASSERT(m_testStencil);
clear->clearMask = GL_STENCIL_BUFFER_BIT;
}
}
}
void DepthStencilClearCase::renderGL (tcu::Surface& dst, const vector<Clear>& clears)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
int colorLoc = gl.getUniformLocation(m_visProgram->getProgram(), "u_color");
int positionLoc = gl.getAttribLocation(m_visProgram->getProgram(), "a_position");
static const deUint8 indices[] = { 0, 1, 2, 2, 1, 3 };
// Clear with default values.
gl.clearDepthf (1.0f);
gl.clearStencil (0);
gl.clearColor (1.0f, 0.0f, 0.0f, 1.0f);
gl.clear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "Before clears");
for (vector<Clear>::const_iterator clear = clears.begin(); clear != clears.end(); clear++)
{
if (clear->useScissor)
{
gl.enable(GL_SCISSOR_TEST);
gl.scissor(clear->scissor.x(), clear->scissor.y(), clear->scissor.z(), clear->scissor.w());
}
// Clear values.
gl.clearDepthf (clear->clearDepth);
gl.clearStencil (clear->clearStencil);
// Masks.
gl.depthMask (clear->depthMask ? GL_TRUE : GL_FALSE);
gl.stencilMask (clear->stencilMask);
// Execute clear.
gl.clear (clear->clearMask);
if (clear->useScissor)
gl.disable(GL_SCISSOR_TEST);
}
// Restore default masks.
gl.depthMask (GL_TRUE);
gl.stencilMask (0xffffffffu);
GLU_EXPECT_NO_ERROR(gl.getError(), "After clears");
gl.useProgram (m_visProgram->getProgram());
gl.enableVertexAttribArray (positionLoc);
// Visualize depth / stencil buffers.
if (m_testDepth)
{
int numSteps = DEPTH_STEPS;
float step = 2.0f / (float)numSteps;
gl.enable (GL_DEPTH_TEST);
gl.depthFunc(GL_LESS);
gl.depthMask(GL_FALSE);
gl.colorMask(GL_FALSE, GL_FALSE, GL_TRUE, GL_FALSE);
for (int ndx = 0; ndx < numSteps; ndx++)
{
float d = -1.0f + step*(float)ndx;
float c = (float)ndx / (float)(numSteps-1);
float pos[] =
{
-1.0f, -1.0f, d,
-1.0f, 1.0f, d,
1.0f, -1.0f, d,
1.0f, 1.0f, d
};
gl.uniform4f (colorLoc, 0.0f, 0.0f, c, 1.0f);
gl.vertexAttribPointer (positionLoc, 3, GL_FLOAT, GL_FALSE, 0, &pos[0]);
gl.drawElements (GL_TRIANGLES, DE_LENGTH_OF_ARRAY(indices), GL_UNSIGNED_BYTE, &indices[0]);
}
gl.disable (GL_DEPTH_TEST);
gl.depthMask(GL_TRUE);
GLU_EXPECT_NO_ERROR(gl.getError(), "After depth visualization");
}
if (m_testStencil)
{
int numSteps = STENCIL_STEPS;
int numValues = (1 << TestCase::m_context.getRenderContext().getRenderTarget().getStencilBits()); // 2^bits
int step = numValues / numSteps;
gl.enable (GL_STENCIL_TEST);
gl.stencilOp (GL_KEEP, GL_KEEP, GL_KEEP);
gl.colorMask (GL_FALSE, GL_TRUE, GL_FALSE, GL_FALSE);
static const float pos[] =
{
-1.0f, -1.0f,
-1.0f, 1.0f,
1.0f, -1.0f,
1.0f, 1.0f
};
gl.vertexAttribPointer(positionLoc, 2, GL_FLOAT, GL_FALSE, 0, &pos[0]);
for (int ndx = 0; ndx < numSteps; ndx++)
{
int s = step*ndx;
float c = (float)ndx / (float)(numSteps-1);
gl.stencilFunc (GL_LEQUAL, s, 0xffu);
gl.uniform4f (colorLoc, 0.0f, c, 0.0f, 1.0f);
gl.drawElements (GL_TRIANGLES, DE_LENGTH_OF_ARRAY(indices), GL_UNSIGNED_BYTE, &indices[0]);
}
gl.disable(GL_STENCIL_TEST);
GLU_EXPECT_NO_ERROR(gl.getError(), "After stencil visualization");
}
// Restore color mask (changed by visualization).
gl.colorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glu::readPixels(m_context.getRenderContext(), 0, 0, dst.getAccess());
}
void DepthStencilClearCase::renderReference (tcu::Surface& dst, const vector<Clear>& clears)
{
glu::RenderContext& renderCtx = TestCase::m_context.getRenderContext();
const tcu::RenderTarget& renderTarget = renderCtx.getRenderTarget();
// Clear surface to red.
tcu::clear(dst.getAccess(), tcu::RGBA::red().toVec());
if (m_testDepth)
{
// Simulated depth buffer span.
tcu::TextureLevel depthBufRow (getDepthFormat(renderTarget.getDepthBits()), dst.getWidth(), 1, 1);
tcu::PixelBufferAccess rowAccess = depthBufRow.getAccess();
for (int y = 0; y < dst.getHeight(); y++)
{
// Clear to default value.
for (int x = 0; x < rowAccess.getWidth(); x++)
rowAccess.setPixel(Vec4(1.0f), x, 0);
// Execute clears.
for (vector<Clear>::const_iterator clear = clears.begin(); clear != clears.end(); clear++)
{
// Clear / mask test.
if ((clear->clearMask & GL_DEPTH_BUFFER_BIT) == 0 || !clear->depthMask)
continue;
tcu::IVec4 clearRect = clear->useScissor ? clear->scissor : tcu::IVec4(0, 0, dst.getWidth(), dst.getHeight());
// Intersection test.
if (!de::inBounds(y, clearRect.y(), clearRect.y()+clearRect.w()))
continue;
for (int x = clearRect.x(); x < clearRect.x()+clearRect.z(); x++)
rowAccess.setPixDepth(de::clamp(clear->clearDepth, 0.0f, 1.0f), x, 0);
}
// Map to colors.
for (int x = 0; x < dst.getWidth(); x++)
{
float depth = rowAccess.getPixDepth(x, 0);
float step = deFloatFloor(depth * (float)DEPTH_STEPS) / (float)(DEPTH_STEPS-1);
tcu::RGBA oldColor = dst.getPixel(x, y);
tcu::RGBA newColor = tcu::RGBA(oldColor.getRed(), oldColor.getGreen(), deClamp32(deRoundFloatToInt32(step * 255.0f), 0, 255), oldColor.getAlpha());
dst.setPixel(x, y, newColor);
}
}
}
if (m_testStencil)
{
// Simulated stencil buffer span.
int stencilBits = renderTarget.getStencilBits();
tcu::TextureLevel depthBufRow (getStencilFormat(stencilBits), dst.getWidth(), 1, 1);
tcu::PixelBufferAccess rowAccess = depthBufRow.getAccess();
deUint32 bufMask = (1u<<stencilBits)-1;
for (int y = 0; y < dst.getHeight(); y++)
{
// Clear to default value.
for (int x = 0; x < rowAccess.getWidth(); x++)
rowAccess.setPixel(tcu::UVec4(0), x, 0);
// Execute clears.
for (vector<Clear>::const_iterator clear = clears.begin(); clear != clears.end(); clear++)
{
// Clear / mask test.
if ((clear->clearMask & GL_STENCIL_BUFFER_BIT) == 0 || clear->stencilMask == 0)
continue;
tcu::IVec4 clearRect = clear->useScissor ? clear->scissor : tcu::IVec4(0, 0, dst.getWidth(), dst.getHeight());
// Intersection test.
if (!de::inBounds(y, clearRect.y(), clearRect.y()+clearRect.w()))
continue;
for (int x = clearRect.x(); x < clearRect.x()+clearRect.z(); x++)
{
deUint32 oldVal = rowAccess.getPixStencil(x, 0);
deUint32 newVal = ((oldVal & ~clear->stencilMask) | (clear->clearStencil & clear->stencilMask)) & bufMask;
rowAccess.setPixStencil(newVal, x, 0);
}
}
// Map to colors.
for (int x = 0; x < dst.getWidth(); x++)
{
deUint32 stencil = rowAccess.getPixStencil(x, 0);
float step = (float)(stencil / ((1u<<stencilBits) / (deUint32)STENCIL_STEPS)) / (float)(STENCIL_STEPS-1);
tcu::RGBA oldColor = dst.getPixel(x, y);
tcu::RGBA newColor = tcu::RGBA(oldColor.getRed(), deClamp32(deRoundFloatToInt32(step * 255.0f), 0, 255), oldColor.getBlue(), oldColor.getAlpha());
dst.setPixel(x, y, newColor);
}
}
}
}
DepthStencilClearTests::DepthStencilClearTests (Context& context)
: TestCaseGroup(context, "depth_stencil_clear", "Depth and stencil clear tests")
{
}
void DepthStencilClearTests::init (void)
{
// iters clears depth stencil scissor masked
addChild(new DepthStencilClearCase(m_context, "depth", "", 4, 2, true, false, false, false));
addChild(new DepthStencilClearCase(m_context, "depth_scissored", "", 4, 16, true, false, true, false));
addChild(new DepthStencilClearCase(m_context, "depth_scissored_masked", "", 4, 16, true, false, true, true));
addChild(new DepthStencilClearCase(m_context, "stencil", "", 4, 2, false, true, false, false));
addChild(new DepthStencilClearCase(m_context, "stencil_masked", "", 4, 8, false, true, false, true));
addChild(new DepthStencilClearCase(m_context, "stencil_scissored", "", 4, 16, false, true, true, false));
addChild(new DepthStencilClearCase(m_context, "stencil_scissored_masked", "", 4, 16, false, true, true, true));
addChild(new DepthStencilClearCase(m_context, "depth_stencil", "", 4, 2, true, true, false, false));
addChild(new DepthStencilClearCase(m_context, "depth_stencil_masked", "", 4, 8, true, true, false, true));
addChild(new DepthStencilClearCase(m_context, "depth_stencil_scissored", "", 4, 16, true, true, true, false));
addChild(new DepthStencilClearCase(m_context, "depth_stencil_scissored_masked", "", 4, 16, true, true, true, true));
}
} // Functional
} // gles2
} // deqp