| /*------------------------------------------------------------------------- |
| * 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 std::set; |
| using std::string; |
| using std::vector; |
| using tcu::TestLog; |
| |
| // Helper functions. |
| |
| void fillWithRandomBytes(uint8_t *ptr, int numBytes, uint32_t seed) |
| { |
| std::copy(tcu::RandomValueIterator<uint8_t>::begin(seed, numBytes), tcu::RandomValueIterator<uint8_t>::end(), ptr); |
| } |
| |
| bool compareByteArrays(tcu::TestLog &log, const uint8_t *resPtr, const uint8_t *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<uint8_t>(refPtr + diffSpanStart), |
| tcu::Format::HexIterator<uint8_t>(refPtr + diffSpanStart + printLen)) |
| << "\n" |
| << " got " |
| << tcu::formatArray(tcu::Format::HexIterator<uint8_t>(resPtr + diffSpanStart), |
| tcu::Format::HexIterator<uint8_t>(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<uint8_t>(refPtr + diffSpanStart), |
| tcu::Format::HexIterator<uint8_t>(refPtr + diffSpanStart + printLen)) |
| << "\n" |
| << " got " |
| << tcu::formatArray(tcu::Format::HexIterator<uint8_t>(resPtr + diffSpanStart), |
| tcu::Format::HexIterator<uint8_t>(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(uint32_t 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(uint32_t 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<uint32_t>::const_iterator bufIter = m_allocatedBuffers.begin(); bufIter != m_allocatedBuffers.end(); |
| bufIter++) |
| glDeleteBuffers(1, &(*bufIter)); |
| } |
| |
| uint32_t BufferCase::genBuffer(void) |
| { |
| uint32_t 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(uint32_t 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 uint8_t *bytes) |
| { |
| m_data.resize(numBytes); |
| std::copy(bytes, bytes + numBytes, m_data.begin()); |
| } |
| |
| void ReferenceBuffer::setSubData(int offset, int numBytes, const uint8_t *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(uint32_t buffer, int offset, int numBytes, const uint8_t *bytes, uint32_t 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(uint32_t buffer, int offset, int numBytes, const uint8_t *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(uint32_t buffer, int offset, int numBytes, const uint8_t *bytes, uint32_t 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(uint32_t buffer, int offset, int numBytes, const uint8_t *bytes) |
| { |
| write(buffer, offset, numBytes, bytes, GL_ARRAY_BUFFER); |
| } |
| |
| void BufferSubDataWriter::write(uint32_t buffer, int offset, int numBytes, const uint8_t *bytes, uint32_t target) |
| { |
| glBindBuffer(target, buffer); |
| glBufferSubData(target, offset, numBytes, bytes); |
| glBindBuffer(target, 0); |
| GLU_CHECK(); |
| } |
| |
| // BufferWriteMapWriter |
| |
| void BufferWriteMapWriter::write(uint32_t buffer, int offset, int numBytes, const uint8_t *bytes) |
| { |
| write(buffer, offset, numBytes, bytes, GL_ARRAY_BUFFER); |
| } |
| |
| void BufferWriteMapWriter::write(uint32_t buffer, int offset, int numBytes, const uint8_t *bytes, uint32_t 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(uint32_t buffer, const uint8_t *reference, int offset, int numBytes, |
| uint32_t 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(uint32_t buffer, const uint8_t *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(uint32_t buffer, const uint8_t *reference, int offset, int numBytes, uint32_t 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(uint32_t buffer, const uint8_t *reference, int offset, int numBytes) |
| { |
| return verify(buffer, reference, offset, numBytes, GL_ARRAY_BUFFER); |
| } |
| |
| bool BufferMapVerifier::verify(uint32_t buffer, const uint8_t *reference, int offset, int numBytes, uint32_t target) |
| { |
| const uint8_t *mapPtr = DE_NULL; |
| bool isOk = false; |
| |
| glBindBuffer(target, buffer); |
| mapPtr = (const uint8_t *)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<uint16_t> &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] = (uint16_t)v10; |
| indices[quadNdx * 6 + 1] = (uint16_t)v00; |
| indices[quadNdx * 6 + 2] = (uint16_t)v01; |
| |
| indices[quadNdx * 6 + 3] = (uint16_t)v10; |
| indices[quadNdx * 6 + 4] = (uint16_t)v01; |
| indices[quadNdx * 6 + 5] = (uint16_t)v11; |
| } |
| } |
| |
| static inline tcu::Vec4 fetchVtxColor(const uint8_t *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 uint8_t *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(uint32_t buffer, const uint8_t *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; |
| uint32_t program = m_program->getProgram(); |
| tcu::RGBA threshold = renderTarget.getPixelFormat().getColorThreshold() + tcu::RGBA(3, 3, 3, 3); |
| bool isOk = true; |
| |
| vector<tcu::Vec2> positions; |
| vector<uint16_t> 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 *)(uintptr_t)(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 uint8_t *indices, int numIndices) |
| { |
| for (int i = 0; i < numIndices; ++i) |
| dst[i] = src[indices[i]]; |
| } |
| |
| bool IndexArrayVerifier::verify(uint32_t buffer, const uint8_t *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 *)(uintptr_t)(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); |
| } |
| |
| } // namespace BufferTestUtil |
| } // namespace gls |
| } // namespace deqp |
