/*-------------------------------------------------------------------------
|
* drawElements Quality Program OpenGL (ES) 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 Buffer test utilities.
|
*//*--------------------------------------------------------------------*/
|
|
#include "glsBufferTestUtil.hpp"
|
#include "tcuRandomValueIterator.hpp"
|
#include "tcuSurface.hpp"
|
#include "tcuImageCompare.hpp"
|
#include "tcuVector.hpp"
|
#include "tcuFormatUtil.hpp"
|
#include "tcuTextureUtil.hpp"
|
#include "tcuRenderTarget.hpp"
|
#include "tcuTestLog.hpp"
|
#include "gluPixelTransfer.hpp"
|
#include "gluRenderContext.hpp"
|
#include "gluStrUtil.hpp"
|
#include "gluShaderProgram.hpp"
|
#include "deMemory.h"
|
#include "deStringUtil.hpp"
|
#include "deArrayUtil.hpp"
|
|
#include <algorithm>
|
|
#include "glwEnums.hpp"
|
#include "glwFunctions.hpp"
|
|
namespace deqp
|
{
|
namespace gls
|
{
|
namespace BufferTestUtil
|
{
|
|
enum
|
{
|
VERIFY_QUAD_SIZE = 8, //!< Quad size in VertexArrayVerifier
|
MAX_LINES_PER_INDEX_ARRAY_DRAW = 128, //!< Maximum number of lines per one draw in IndexArrayVerifier
|
INDEX_ARRAY_DRAW_VIEWPORT_WIDTH = 128,
|
INDEX_ARRAY_DRAW_VIEWPORT_HEIGHT = 128
|
};
|
|
using tcu::TestLog;
|
using std::vector;
|
using std::string;
|
using std::set;
|
|
// Helper functions.
|
|
void fillWithRandomBytes (deUint8* ptr, int numBytes, deUint32 seed)
|
{
|
std::copy(tcu::RandomValueIterator<deUint8>::begin(seed, numBytes), tcu::RandomValueIterator<deUint8>::end(), ptr);
|
}
|
|
bool compareByteArrays (tcu::TestLog& log, const deUint8* resPtr, const deUint8* refPtr, int numBytes)
|
{
|
bool isOk = true;
|
const int maxSpanLen = 8;
|
const int maxDiffSpans = 4;
|
int numDiffSpans = 0;
|
int diffSpanStart = -1;
|
int ndx = 0;
|
|
log << TestLog::Section("Verify", "Verification result");
|
|
for (;ndx < numBytes; ndx++)
|
{
|
if (resPtr[ndx] != refPtr[ndx])
|
{
|
if (diffSpanStart < 0)
|
diffSpanStart = ndx;
|
|
isOk = false;
|
}
|
else if (diffSpanStart >= 0)
|
{
|
if (numDiffSpans < maxDiffSpans)
|
{
|
int len = ndx-diffSpanStart;
|
int printLen = de::min(len, maxSpanLen);
|
|
log << TestLog::Message << len << " byte difference at offset " << diffSpanStart << "\n"
|
<< " expected " << tcu::formatArray(tcu::Format::HexIterator<deUint8>(refPtr+diffSpanStart), tcu::Format::HexIterator<deUint8>(refPtr+diffSpanStart+printLen)) << "\n"
|
<< " got " << tcu::formatArray(tcu::Format::HexIterator<deUint8>(resPtr+diffSpanStart), tcu::Format::HexIterator<deUint8>(resPtr+diffSpanStart+printLen))
|
<< TestLog::EndMessage;
|
}
|
else
|
log << TestLog::Message << "(output too long, truncated)" << TestLog::EndMessage;
|
|
numDiffSpans += 1;
|
diffSpanStart = -1;
|
}
|
}
|
|
if (diffSpanStart >= 0)
|
{
|
if (numDiffSpans < maxDiffSpans)
|
{
|
int len = ndx-diffSpanStart;
|
int printLen = de::min(len, maxSpanLen);
|
|
log << TestLog::Message << len << " byte difference at offset " << diffSpanStart << "\n"
|
<< " expected " << tcu::formatArray(tcu::Format::HexIterator<deUint8>(refPtr+diffSpanStart), tcu::Format::HexIterator<deUint8>(refPtr+diffSpanStart+printLen)) << "\n"
|
<< " got " << tcu::formatArray(tcu::Format::HexIterator<deUint8>(resPtr+diffSpanStart), tcu::Format::HexIterator<deUint8>(resPtr+diffSpanStart+printLen))
|
<< TestLog::EndMessage;
|
}
|
else
|
log << TestLog::Message << "(output too long, truncated)" << TestLog::EndMessage;
|
}
|
|
log << TestLog::Message << (isOk ? "Verification passed." : "Verification FAILED!") << TestLog::EndMessage;
|
log << TestLog::EndSection;
|
|
return isOk;
|
}
|
|
const char* getBufferTargetName (deUint32 target)
|
{
|
switch (target)
|
{
|
case GL_ARRAY_BUFFER: return "array";
|
case GL_COPY_READ_BUFFER: return "copy_read";
|
case GL_COPY_WRITE_BUFFER: return "copy_write";
|
case GL_ELEMENT_ARRAY_BUFFER: return "element_array";
|
case GL_PIXEL_PACK_BUFFER: return "pixel_pack";
|
case GL_PIXEL_UNPACK_BUFFER: return "pixel_unpack";
|
case GL_TEXTURE_BUFFER: return "texture";
|
case GL_TRANSFORM_FEEDBACK_BUFFER: return "transform_feedback";
|
case GL_UNIFORM_BUFFER: return "uniform";
|
default:
|
DE_ASSERT(false);
|
return DE_NULL;
|
}
|
}
|
|
const char* getUsageHintName (deUint32 hint)
|
{
|
switch (hint)
|
{
|
case GL_STREAM_DRAW: return "stream_draw";
|
case GL_STREAM_READ: return "stream_read";
|
case GL_STREAM_COPY: return "stream_copy";
|
case GL_STATIC_DRAW: return "static_draw";
|
case GL_STATIC_READ: return "static_read";
|
case GL_STATIC_COPY: return "static_copy";
|
case GL_DYNAMIC_DRAW: return "dynamic_draw";
|
case GL_DYNAMIC_READ: return "dynamic_read";
|
case GL_DYNAMIC_COPY: return "dynamic_copy";
|
default:
|
DE_ASSERT(false);
|
return DE_NULL;
|
}
|
}
|
|
// BufferCase
|
|
BufferCase::BufferCase (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* description)
|
: TestCase (testCtx, name, description)
|
, CallLogWrapper (renderCtx.getFunctions(), testCtx.getLog())
|
, m_renderCtx (renderCtx)
|
{
|
}
|
|
BufferCase::~BufferCase (void)
|
{
|
enableLogging(false);
|
BufferCase::deinit();
|
}
|
|
void BufferCase::init (void)
|
{
|
enableLogging(true);
|
}
|
|
void BufferCase::deinit (void)
|
{
|
for (set<deUint32>::const_iterator bufIter = m_allocatedBuffers.begin(); bufIter != m_allocatedBuffers.end(); bufIter++)
|
glDeleteBuffers(1, &(*bufIter));
|
}
|
|
deUint32 BufferCase::genBuffer (void)
|
{
|
deUint32 buf = 0;
|
glGenBuffers(1, &buf);
|
if (buf != 0)
|
{
|
try
|
{
|
m_allocatedBuffers.insert(buf);
|
}
|
catch (const std::exception&)
|
{
|
glDeleteBuffers(1, &buf);
|
throw;
|
}
|
}
|
return buf;
|
}
|
|
void BufferCase::deleteBuffer (deUint32 buffer)
|
{
|
glDeleteBuffers(1, &buffer);
|
m_allocatedBuffers.erase(buffer);
|
}
|
|
void BufferCase::checkError (void)
|
{
|
glw::GLenum err = glGetError();
|
if (err != GL_NO_ERROR)
|
throw tcu::TestError(string("Got ") + glu::getErrorStr(err).toString());
|
}
|
|
// ReferenceBuffer
|
|
void ReferenceBuffer::setSize (int numBytes)
|
{
|
m_data.resize(numBytes);
|
}
|
|
void ReferenceBuffer::setData (int numBytes, const deUint8* bytes)
|
{
|
m_data.resize(numBytes);
|
std::copy(bytes, bytes+numBytes, m_data.begin());
|
}
|
|
void ReferenceBuffer::setSubData (int offset, int numBytes, const deUint8* bytes)
|
{
|
DE_ASSERT(de::inBounds(offset, 0, (int)m_data.size()) && de::inRange(offset+numBytes, offset, (int)m_data.size()));
|
std::copy(bytes, bytes+numBytes, m_data.begin()+offset);
|
}
|
|
// BufferWriterBase
|
|
BufferWriterBase::BufferWriterBase (glu::RenderContext& renderCtx, tcu::TestLog& log)
|
: CallLogWrapper (renderCtx.getFunctions(), log)
|
, m_renderCtx (renderCtx)
|
{
|
enableLogging(true);
|
}
|
|
void BufferWriterBase::write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes, deUint32 targetHint)
|
{
|
DE_UNREF(targetHint);
|
write(buffer, offset, numBytes, bytes);
|
}
|
|
// BufferWriter
|
|
BufferWriter::BufferWriter (glu::RenderContext& renderCtx, tcu::TestLog& log, WriteType writeType)
|
: m_writer(DE_NULL)
|
{
|
switch (writeType)
|
{
|
case WRITE_BUFFER_SUB_DATA: m_writer = new BufferSubDataWriter (renderCtx, log); break;
|
case WRITE_BUFFER_WRITE_MAP: m_writer = new BufferWriteMapWriter (renderCtx, log); break;
|
default:
|
TCU_FAIL("Unsupported writer");
|
}
|
}
|
|
BufferWriter::~BufferWriter (void)
|
{
|
delete m_writer;
|
}
|
|
void BufferWriter::write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes)
|
{
|
DE_ASSERT(numBytes >= getMinSize());
|
DE_ASSERT(offset%getAlignment() == 0);
|
DE_ASSERT((offset+numBytes)%getAlignment() == 0);
|
return m_writer->write(buffer, offset, numBytes, bytes);
|
}
|
|
void BufferWriter::write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes, deUint32 targetHint)
|
{
|
DE_ASSERT(numBytes >= getMinSize());
|
DE_ASSERT(offset%getAlignment() == 0);
|
DE_ASSERT((offset+numBytes)%getAlignment() == 0);
|
return m_writer->write(buffer, offset, numBytes, bytes, targetHint);
|
}
|
|
// BufferSubDataWriter
|
|
void BufferSubDataWriter::write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes)
|
{
|
write(buffer, offset, numBytes, bytes, GL_ARRAY_BUFFER);
|
}
|
|
void BufferSubDataWriter::write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes, deUint32 target)
|
{
|
glBindBuffer(target, buffer);
|
glBufferSubData(target, offset, numBytes, bytes);
|
glBindBuffer(target, 0);
|
GLU_CHECK();
|
}
|
|
// BufferWriteMapWriter
|
|
void BufferWriteMapWriter::write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes)
|
{
|
write(buffer, offset, numBytes, bytes, GL_ARRAY_BUFFER);
|
}
|
|
void BufferWriteMapWriter::write (deUint32 buffer, int offset, int numBytes, const deUint8* bytes, deUint32 target)
|
{
|
glBindBuffer(target, buffer);
|
|
void* ptr = glMapBufferRange(target, offset, numBytes, GL_MAP_WRITE_BIT);
|
GLU_CHECK_MSG("glMapBufferRange");
|
|
deMemcpy(ptr, bytes, numBytes);
|
|
glUnmapBuffer(target);
|
glBindBuffer(target, 0);
|
GLU_CHECK();
|
}
|
|
// BufferVerifierBase
|
|
BufferVerifierBase::BufferVerifierBase (glu::RenderContext& renderCtx, tcu::TestLog& log)
|
: CallLogWrapper (renderCtx.getFunctions(), log)
|
, m_renderCtx (renderCtx)
|
, m_log (log)
|
{
|
enableLogging(true);
|
}
|
|
bool BufferVerifierBase::verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes, deUint32 targetHint)
|
{
|
DE_UNREF(targetHint);
|
return verify(buffer, reference, offset, numBytes);
|
}
|
|
// BufferVerifier
|
|
BufferVerifier::BufferVerifier (glu::RenderContext& renderCtx, tcu::TestLog& log, VerifyType verifyType)
|
: m_verifier(DE_NULL)
|
{
|
switch (verifyType)
|
{
|
case VERIFY_AS_VERTEX_ARRAY: m_verifier = new VertexArrayVerifier(renderCtx, log); break;
|
case VERIFY_AS_INDEX_ARRAY: m_verifier = new IndexArrayVerifier (renderCtx, log); break;
|
case VERIFY_BUFFER_READ_MAP: m_verifier = new BufferMapVerifier (renderCtx, log); break;
|
default:
|
TCU_FAIL("Unsupported verifier");
|
}
|
}
|
|
BufferVerifier::~BufferVerifier (void)
|
{
|
delete m_verifier;
|
}
|
|
bool BufferVerifier::verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes)
|
{
|
DE_ASSERT(numBytes >= getMinSize());
|
DE_ASSERT(offset%getAlignment() == 0);
|
DE_ASSERT((offset+numBytes)%getAlignment() == 0);
|
return m_verifier->verify(buffer, reference, offset, numBytes);
|
}
|
|
bool BufferVerifier::verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes, deUint32 targetHint)
|
{
|
DE_ASSERT(numBytes >= getMinSize());
|
DE_ASSERT(offset%getAlignment() == 0);
|
DE_ASSERT((offset+numBytes)%getAlignment() == 0);
|
return m_verifier->verify(buffer, reference, offset, numBytes, targetHint);
|
}
|
|
// BufferMapVerifier
|
|
bool BufferMapVerifier::verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes)
|
{
|
return verify(buffer, reference, offset, numBytes, GL_ARRAY_BUFFER);
|
}
|
|
bool BufferMapVerifier::verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes, deUint32 target)
|
{
|
const deUint8* mapPtr = DE_NULL;
|
bool isOk = false;
|
|
glBindBuffer(target, buffer);
|
mapPtr = (const deUint8*)glMapBufferRange(target, offset, numBytes, GL_MAP_READ_BIT);
|
GLU_CHECK_MSG("glMapBufferRange");
|
TCU_CHECK(mapPtr);
|
|
isOk = compareByteArrays(m_log, mapPtr, reference+offset, numBytes);
|
|
glUnmapBuffer(target);
|
GLU_CHECK_MSG("glUnmapBuffer");
|
|
glBindBuffer(target, 0);
|
|
return isOk;
|
}
|
|
// VertexArrayVerifier
|
|
VertexArrayVerifier::VertexArrayVerifier (glu::RenderContext& renderCtx, tcu::TestLog& log)
|
: BufferVerifierBase (renderCtx, log)
|
, m_program (DE_NULL)
|
, m_posLoc (0)
|
, m_byteVecLoc (0)
|
, m_vao (0)
|
{
|
const glu::ContextType ctxType = renderCtx.getType();
|
const glu::GLSLVersion glslVersion = glu::isContextTypeES(ctxType) ? glu::GLSL_VERSION_300_ES : glu::GLSL_VERSION_330;
|
|
DE_ASSERT(glu::isGLSLVersionSupported(ctxType, glslVersion));
|
|
m_program = new glu::ShaderProgram(m_renderCtx, glu::makeVtxFragSources(
|
string(glu::getGLSLVersionDeclaration(glslVersion)) + "\n"
|
"in highp vec2 a_position;\n"
|
"in mediump vec3 a_byteVec;\n"
|
"out mediump vec3 v_byteVec;\n"
|
"void main (void)\n"
|
"{\n"
|
" gl_Position = vec4(a_position, 0.0, 1.0);\n"
|
" v_byteVec = a_byteVec;\n"
|
"}\n",
|
|
string(glu::getGLSLVersionDeclaration(glslVersion)) + "\n"
|
"in mediump vec3 v_byteVec;\n"
|
"layout(location = 0) out mediump vec4 o_color;\n"
|
"void main (void)\n"
|
"{\n"
|
" o_color = vec4(v_byteVec, 1.0);\n"
|
"}\n"));
|
|
if (!m_program->isOk())
|
{
|
m_log << *m_program;
|
delete m_program;
|
TCU_FAIL("Compile failed");
|
}
|
|
const glw::Functions& gl = m_renderCtx.getFunctions();
|
m_posLoc = gl.getAttribLocation(m_program->getProgram(), "a_position");
|
m_byteVecLoc = gl.getAttribLocation(m_program->getProgram(), "a_byteVec");
|
|
gl.genVertexArrays(1, &m_vao);
|
gl.genBuffers(1, &m_positionBuf);
|
gl.genBuffers(1, &m_indexBuf);
|
GLU_EXPECT_NO_ERROR(gl.getError(), "Initialization failed");
|
}
|
|
VertexArrayVerifier::~VertexArrayVerifier (void)
|
{
|
const glw::Functions& gl = m_renderCtx.getFunctions();
|
|
if (m_vao) gl.deleteVertexArrays(1, &m_vao);
|
if (m_positionBuf) gl.deleteBuffers(1, &m_positionBuf);
|
if (m_indexBuf) gl.deleteBuffers(1, &m_indexBuf);
|
|
delete m_program;
|
}
|
|
static void computePositions (vector<tcu::Vec2>& positions, int gridSizeX, int gridSizeY)
|
{
|
positions.resize(gridSizeX*gridSizeY*4);
|
|
for (int y = 0; y < gridSizeY; y++)
|
for (int x = 0; x < gridSizeX; x++)
|
{
|
float sx0 = (float)(x+0) / (float)gridSizeX;
|
float sy0 = (float)(y+0) / (float)gridSizeY;
|
float sx1 = (float)(x+1) / (float)gridSizeX;
|
float sy1 = (float)(y+1) / (float)gridSizeY;
|
float fx0 = 2.0f * sx0 - 1.0f;
|
float fy0 = 2.0f * sy0 - 1.0f;
|
float fx1 = 2.0f * sx1 - 1.0f;
|
float fy1 = 2.0f * sy1 - 1.0f;
|
int baseNdx = (y * gridSizeX + x)*4;
|
|
positions[baseNdx+0] = tcu::Vec2(fx0, fy0);
|
positions[baseNdx+1] = tcu::Vec2(fx0, fy1);
|
positions[baseNdx+2] = tcu::Vec2(fx1, fy0);
|
positions[baseNdx+3] = tcu::Vec2(fx1, fy1);
|
}
|
}
|
|
static void computeIndices (vector<deUint16>& indices, int gridSizeX, int gridSizeY)
|
{
|
indices.resize(3 * 2 * gridSizeX * gridSizeY);
|
|
for (int quadNdx = 0; quadNdx < gridSizeX*gridSizeY; quadNdx++)
|
{
|
int v00 = quadNdx*4 + 0;
|
int v01 = quadNdx*4 + 1;
|
int v10 = quadNdx*4 + 2;
|
int v11 = quadNdx*4 + 3;
|
|
DE_ASSERT(v11 < (1<<16));
|
|
indices[quadNdx*6 + 0] = (deUint16)v10;
|
indices[quadNdx*6 + 1] = (deUint16)v00;
|
indices[quadNdx*6 + 2] = (deUint16)v01;
|
|
indices[quadNdx*6 + 3] = (deUint16)v10;
|
indices[quadNdx*6 + 4] = (deUint16)v01;
|
indices[quadNdx*6 + 5] = (deUint16)v11;
|
}
|
}
|
|
static inline tcu::Vec4 fetchVtxColor (const deUint8* ptr, int vtxNdx)
|
{
|
return tcu::RGBA(*(ptr + vtxNdx*3 + 0),
|
*(ptr + vtxNdx*3 + 1),
|
*(ptr + vtxNdx*3 + 2),
|
255).toVec();
|
}
|
|
static void renderQuadGridReference (tcu::Surface& dst, int numQuads, int rowLength, const deUint8* inPtr)
|
{
|
using tcu::Vec4;
|
|
dst.setSize(rowLength*VERIFY_QUAD_SIZE, (numQuads/rowLength + (numQuads%rowLength != 0 ? 1 : 0))*VERIFY_QUAD_SIZE);
|
|
tcu::PixelBufferAccess dstAccess = dst.getAccess();
|
tcu::clear(dstAccess, tcu::IVec4(0, 0, 0, 0xff));
|
|
for (int quadNdx = 0; quadNdx < numQuads; quadNdx++)
|
{
|
int x0 = (quadNdx%rowLength)*VERIFY_QUAD_SIZE;
|
int y0 = (quadNdx/rowLength)*VERIFY_QUAD_SIZE;
|
Vec4 v00 = fetchVtxColor(inPtr, quadNdx*4 + 0);
|
Vec4 v10 = fetchVtxColor(inPtr, quadNdx*4 + 1);
|
Vec4 v01 = fetchVtxColor(inPtr, quadNdx*4 + 2);
|
Vec4 v11 = fetchVtxColor(inPtr, quadNdx*4 + 3);
|
|
for (int y = 0; y < VERIFY_QUAD_SIZE; y++)
|
for (int x = 0; x < VERIFY_QUAD_SIZE; x++)
|
{
|
float fx = ((float)x+0.5f) / (float)VERIFY_QUAD_SIZE;
|
float fy = ((float)y+0.5f) / (float)VERIFY_QUAD_SIZE;
|
|
bool tri = fx + fy <= 1.0f;
|
float tx = tri ? fx : (1.0f-fx);
|
float ty = tri ? fy : (1.0f-fy);
|
const Vec4& t0 = tri ? v00 : v11;
|
const Vec4& t1 = tri ? v01 : v10;
|
const Vec4& t2 = tri ? v10 : v01;
|
Vec4 color = t0 + (t1-t0)*tx + (t2-t0)*ty;
|
|
dstAccess.setPixel(color, x0+x, y0+y);
|
}
|
}
|
}
|
|
bool VertexArrayVerifier::verify (deUint32 buffer, const deUint8* refPtr, int offset, int numBytes)
|
{
|
const tcu::RenderTarget& renderTarget = m_renderCtx.getRenderTarget();
|
const int numBytesInVtx = 3;
|
const int numBytesInQuad = numBytesInVtx*4;
|
int maxQuadsX = de::min(128, renderTarget.getWidth() / VERIFY_QUAD_SIZE);
|
int maxQuadsY = de::min(128, renderTarget.getHeight() / VERIFY_QUAD_SIZE);
|
int maxQuadsPerBatch = maxQuadsX*maxQuadsY;
|
int numVerified = 0;
|
deUint32 program = m_program->getProgram();
|
tcu::RGBA threshold = renderTarget.getPixelFormat().getColorThreshold() + tcu::RGBA(3,3,3,3);
|
bool isOk = true;
|
|
vector<tcu::Vec2> positions;
|
vector<deUint16> indices;
|
|
tcu::Surface rendered;
|
tcu::Surface reference;
|
|
DE_ASSERT(numBytes >= numBytesInQuad); // Can't render full quad with smaller buffers.
|
|
computePositions(positions, maxQuadsX, maxQuadsY);
|
computeIndices(indices, maxQuadsX, maxQuadsY);
|
|
// Reset buffer bindings.
|
glBindBuffer (GL_PIXEL_PACK_BUFFER, 0);
|
|
// Setup rendering state.
|
glViewport (0, 0, maxQuadsX*VERIFY_QUAD_SIZE, maxQuadsY*VERIFY_QUAD_SIZE);
|
glClearColor (0.0f, 0.0f, 0.0f, 1.0f);
|
glUseProgram (program);
|
glBindVertexArray (m_vao);
|
|
// Upload positions
|
glBindBuffer (GL_ARRAY_BUFFER, m_positionBuf);
|
glBufferData (GL_ARRAY_BUFFER, (glw::GLsizeiptr)(positions.size()*sizeof(positions[0])), &positions[0], GL_STATIC_DRAW);
|
glEnableVertexAttribArray (m_posLoc);
|
glVertexAttribPointer (m_posLoc, 2, GL_FLOAT, GL_FALSE, 0, DE_NULL);
|
|
// Upload indices
|
glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, m_indexBuf);
|
glBufferData (GL_ELEMENT_ARRAY_BUFFER, (glw::GLsizeiptr)(indices.size()*sizeof(indices[0])), &indices[0], GL_STATIC_DRAW);
|
|
glEnableVertexAttribArray (m_byteVecLoc);
|
glBindBuffer (GL_ARRAY_BUFFER, buffer);
|
|
while (numVerified < numBytes)
|
{
|
int numRemaining = numBytes-numVerified;
|
bool isLeftoverBatch = numRemaining < numBytesInQuad;
|
int numBytesToVerify = isLeftoverBatch ? numBytesInQuad : de::min(maxQuadsPerBatch*numBytesInQuad, numRemaining - numRemaining%numBytesInQuad);
|
int curOffset = isLeftoverBatch ? (numBytes-numBytesInQuad) : numVerified;
|
int numQuads = numBytesToVerify/numBytesInQuad;
|
int numCols = de::min(maxQuadsX, numQuads);
|
int numRows = numQuads/maxQuadsX + (numQuads%maxQuadsX != 0 ? 1 : 0);
|
string imageSetDesc = string("Bytes ") + de::toString(offset+curOffset) + " to " + de::toString(offset+curOffset+numBytesToVerify-1);
|
|
DE_ASSERT(numBytesToVerify > 0 && numBytesToVerify%numBytesInQuad == 0);
|
DE_ASSERT(de::inBounds(curOffset, 0, numBytes));
|
DE_ASSERT(de::inRange(curOffset+numBytesToVerify, curOffset, numBytes));
|
|
// Render batch.
|
glClear (GL_COLOR_BUFFER_BIT);
|
glVertexAttribPointer (m_byteVecLoc, 3, GL_UNSIGNED_BYTE, GL_TRUE, 0, (const glw::GLvoid*)(deUintptr)(offset + curOffset));
|
glDrawElements (GL_TRIANGLES, numQuads*6, GL_UNSIGNED_SHORT, DE_NULL);
|
|
renderQuadGridReference(reference, numQuads, numCols, refPtr + offset + curOffset);
|
|
rendered.setSize(numCols*VERIFY_QUAD_SIZE, numRows*VERIFY_QUAD_SIZE);
|
glu::readPixels(m_renderCtx, 0, 0, rendered.getAccess());
|
|
if (!tcu::pixelThresholdCompare(m_log, "RenderResult", imageSetDesc.c_str(), reference, rendered, threshold, tcu::COMPARE_LOG_RESULT))
|
{
|
isOk = false;
|
break;
|
}
|
|
numVerified += isLeftoverBatch ? numRemaining : numBytesToVerify;
|
}
|
|
glBindVertexArray(0);
|
|
return isOk;
|
}
|
|
// IndexArrayVerifier
|
|
IndexArrayVerifier::IndexArrayVerifier (glu::RenderContext& renderCtx, tcu::TestLog& log)
|
: BufferVerifierBase (renderCtx, log)
|
, m_program (DE_NULL)
|
, m_posLoc (0)
|
, m_colorLoc (0)
|
{
|
|
const glu::ContextType ctxType = renderCtx.getType();
|
const glu::GLSLVersion glslVersion = glu::isContextTypeES(ctxType) ? glu::GLSL_VERSION_300_ES : glu::GLSL_VERSION_330;
|
|
DE_ASSERT(glu::isGLSLVersionSupported(ctxType, glslVersion));
|
|
m_program = new glu::ShaderProgram(m_renderCtx, glu::makeVtxFragSources(
|
string(glu::getGLSLVersionDeclaration(glslVersion)) + "\n"
|
"in highp vec2 a_position;\n"
|
"in mediump vec3 a_color;\n"
|
"out mediump vec3 v_color;\n"
|
"void main (void)\n"
|
"{\n"
|
" gl_Position = vec4(a_position, 0.0, 1.0);\n"
|
" v_color = a_color;\n"
|
"}\n",
|
|
string(glu::getGLSLVersionDeclaration(glslVersion)) + "\n"
|
"in mediump vec3 v_color;\n"
|
"layout(location = 0) out mediump vec4 o_color;\n"
|
"void main (void)\n"
|
"{\n"
|
" o_color = vec4(v_color, 1.0);\n"
|
"}\n"));
|
|
if (!m_program->isOk())
|
{
|
m_log << *m_program;
|
delete m_program;
|
TCU_FAIL("Compile failed");
|
}
|
|
const glw::Functions& gl = m_renderCtx.getFunctions();
|
m_posLoc = gl.getAttribLocation(m_program->getProgram(), "a_position");
|
m_colorLoc = gl.getAttribLocation(m_program->getProgram(), "a_color");
|
|
gl.genVertexArrays(1, &m_vao);
|
gl.genBuffers(1, &m_positionBuf);
|
gl.genBuffers(1, &m_colorBuf);
|
GLU_EXPECT_NO_ERROR(gl.getError(), "Initialization failed");
|
}
|
|
IndexArrayVerifier::~IndexArrayVerifier (void)
|
{
|
const glw::Functions& gl = m_renderCtx.getFunctions();
|
|
if (m_vao) gl.deleteVertexArrays(1, &m_vao);
|
if (m_positionBuf) gl.deleteBuffers(1, &m_positionBuf);
|
if (m_colorBuf) gl.deleteBuffers(1, &m_colorBuf);
|
|
delete m_program;
|
}
|
|
static void computeIndexVerifierPositions (std::vector<tcu::Vec2>& dst)
|
{
|
const int numPosX = 16;
|
const int numPosY = 16;
|
|
dst.resize(numPosX*numPosY);
|
|
for (int y = 0; y < numPosY; y++)
|
{
|
for (int x = 0; x < numPosX; x++)
|
{
|
float xf = float(x) / float(numPosX-1);
|
float yf = float(y) / float(numPosY-1);
|
|
dst[y*numPosX + x] = tcu::Vec2(2.0f*xf - 1.0f, 2.0f*yf - 1.0f);
|
}
|
}
|
}
|
|
static void computeIndexVerifierColors (std::vector<tcu::Vec3>& dst)
|
{
|
const int numColors = 256;
|
const float minVal = 0.1f;
|
const float maxVal = 0.5f;
|
de::Random rnd (0xabc231);
|
|
dst.resize(numColors);
|
|
for (std::vector<tcu::Vec3>::iterator i = dst.begin(); i != dst.end(); ++i)
|
{
|
i->x() = rnd.getFloat(minVal, maxVal);
|
i->y() = rnd.getFloat(minVal, maxVal);
|
i->z() = rnd.getFloat(minVal, maxVal);
|
}
|
}
|
|
template<typename T>
|
static void execVertexFetch (T* dst, const T* src, const deUint8* indices, int numIndices)
|
{
|
for (int i = 0; i < numIndices; ++i)
|
dst[i] = src[indices[i]];
|
}
|
|
bool IndexArrayVerifier::verify (deUint32 buffer, const deUint8* refPtr, int offset, int numBytes)
|
{
|
const tcu::RenderTarget& renderTarget = m_renderCtx.getRenderTarget();
|
const int viewportW = de::min<int>(INDEX_ARRAY_DRAW_VIEWPORT_WIDTH, renderTarget.getWidth());
|
const int viewportH = de::min<int>(INDEX_ARRAY_DRAW_VIEWPORT_HEIGHT, renderTarget.getHeight());
|
const int minBytesPerBatch = 2;
|
const tcu::RGBA threshold (0,0,0,0);
|
|
std::vector<tcu::Vec2> positions;
|
std::vector<tcu::Vec3> colors;
|
|
std::vector<tcu::Vec2> fetchedPos (MAX_LINES_PER_INDEX_ARRAY_DRAW+1);
|
std::vector<tcu::Vec3> fetchedColor (MAX_LINES_PER_INDEX_ARRAY_DRAW+1);
|
|
tcu::Surface indexBufferImg (viewportW, viewportH);
|
tcu::Surface referenceImg (viewportW, viewportH);
|
|
int numVerified = 0;
|
bool isOk = true;
|
|
DE_STATIC_ASSERT(sizeof(tcu::Vec2) == sizeof(float)*2);
|
DE_STATIC_ASSERT(sizeof(tcu::Vec3) == sizeof(float)*3);
|
|
computeIndexVerifierPositions(positions);
|
computeIndexVerifierColors(colors);
|
|
// Reset buffer bindings.
|
glBindVertexArray (m_vao);
|
glBindBuffer (GL_PIXEL_PACK_BUFFER, 0);
|
glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, buffer);
|
|
// Setup rendering state.
|
glViewport (0, 0, viewportW, viewportH);
|
glClearColor (0.0f, 0.0f, 0.0f, 1.0f);
|
glUseProgram (m_program->getProgram());
|
glEnableVertexAttribArray (m_posLoc);
|
glEnableVertexAttribArray (m_colorLoc);
|
glEnable (GL_BLEND);
|
glBlendFunc (GL_ONE, GL_ONE);
|
glBlendEquation (GL_FUNC_ADD);
|
|
while (numVerified < numBytes)
|
{
|
int numRemaining = numBytes-numVerified;
|
bool isLeftoverBatch = numRemaining < minBytesPerBatch;
|
int numBytesToVerify = isLeftoverBatch ? minBytesPerBatch : de::min(MAX_LINES_PER_INDEX_ARRAY_DRAW+1, numRemaining);
|
int curOffset = isLeftoverBatch ? (numBytes-minBytesPerBatch) : numVerified;
|
string imageSetDesc = string("Bytes ") + de::toString(offset+curOffset) + " to " + de::toString(offset+curOffset+numBytesToVerify-1);
|
|
// Step 1: Render using index buffer.
|
glClear (GL_COLOR_BUFFER_BIT);
|
|
glBindBuffer (GL_ARRAY_BUFFER, m_positionBuf);
|
glBufferData (GL_ARRAY_BUFFER, (glw::GLsizeiptr)(positions.size()*sizeof(positions[0])), &positions[0], GL_STREAM_DRAW);
|
glVertexAttribPointer (m_posLoc, 2, GL_FLOAT, GL_FALSE, 0, DE_NULL);
|
|
glBindBuffer (GL_ARRAY_BUFFER, m_colorBuf);
|
glBufferData (GL_ARRAY_BUFFER, (glw::GLsizeiptr)(colors.size()*sizeof(colors[0])), &colors[0], GL_STREAM_DRAW);
|
glVertexAttribPointer (m_colorLoc, 3, GL_FLOAT, GL_FALSE, 0, DE_NULL);
|
|
glDrawElements (GL_LINE_STRIP, numBytesToVerify, GL_UNSIGNED_BYTE, (void*)(deUintptr)(offset+curOffset));
|
glu::readPixels (m_renderCtx, 0, 0, indexBufferImg.getAccess());
|
|
// Step 2: Do manual fetch and render without index buffer.
|
execVertexFetch(&fetchedPos[0], &positions[0], refPtr+offset+curOffset, numBytesToVerify);
|
execVertexFetch(&fetchedColor[0], &colors[0], refPtr+offset+curOffset, numBytesToVerify);
|
|
glClear (GL_COLOR_BUFFER_BIT);
|
|
glBindBuffer (GL_ARRAY_BUFFER, m_positionBuf);
|
glBufferData (GL_ARRAY_BUFFER, (glw::GLsizeiptr)(fetchedPos.size()*sizeof(fetchedPos[0])), &fetchedPos[0], GL_STREAM_DRAW);
|
glVertexAttribPointer (m_posLoc, 2, GL_FLOAT, GL_FALSE, 0, DE_NULL);
|
|
glBindBuffer (GL_ARRAY_BUFFER, m_colorBuf);
|
glBufferData (GL_ARRAY_BUFFER, (glw::GLsizeiptr)(fetchedColor.size()*sizeof(fetchedColor[0])), &fetchedColor[0], GL_STREAM_DRAW);
|
glVertexAttribPointer (m_colorLoc, 3, GL_FLOAT, GL_FALSE, 0, DE_NULL);
|
|
glDrawArrays (GL_LINE_STRIP, 0, numBytesToVerify);
|
glu::readPixels (m_renderCtx, 0, 0, referenceImg.getAccess());
|
|
if (!tcu::pixelThresholdCompare(m_log, "RenderResult", imageSetDesc.c_str(), referenceImg, indexBufferImg, threshold, tcu::COMPARE_LOG_RESULT))
|
{
|
isOk = false;
|
break;
|
}
|
|
numVerified += isLeftoverBatch ? numRemaining : numBytesToVerify;
|
}
|
|
glBindVertexArray(0);
|
|
return isOk;
|
}
|
|
const char* getWriteTypeDescription (WriteType write)
|
{
|
static const char* s_desc[] =
|
{
|
"glBufferSubData()",
|
"glMapBufferRange()",
|
"transform feedback",
|
"glReadPixels() into PBO binding"
|
};
|
return de::getSizedArrayElement<WRITE_LAST>(s_desc, write);
|
}
|
|
const char* getVerifyTypeDescription (VerifyType verify)
|
{
|
static const char* s_desc[] =
|
{
|
"rendering as vertex data",
|
"rendering as index data",
|
"reading in shader as uniform buffer data",
|
"using as PBO and uploading to texture",
|
"reading back using glMapBufferRange()"
|
};
|
return de::getSizedArrayElement<VERIFY_LAST>(s_desc, verify);
|
}
|
|
} // BufferTestUtil
|
} // gls
|
} // deqp
|
