You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
522 lines
16 KiB
522 lines
16 KiB
/*-------------------------------------------------------------------------
|
|
* 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
|