/*------------------------------------------------------------------------- * drawElements Quality Program OpenGL ES 3.1 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 Vertex attribute binding tests. *//*--------------------------------------------------------------------*/ #include "es31fVertexAttributeBindingTests.hpp" #include "tcuRenderTarget.hpp" #include "tcuSurface.hpp" #include "gluCallLogWrapper.hpp" #include "gluRenderContext.hpp" #include "gluPixelTransfer.hpp" #include "gluShaderProgram.hpp" #include "gluObjectWrapper.hpp" #include "gluStrUtil.hpp" #include "glwFunctions.hpp" #include "glwEnums.hpp" #include "deStringUtil.hpp" #include "deInt32.h" namespace deqp { namespace gles31 { namespace Functional { namespace { static const char* const s_colorFragmentShader = "#version 310 es\n" "in mediump vec4 v_color;\n" "layout(location = 0) out mediump vec4 fragColor;\n" "void main (void)\n" "{\n" " fragColor = v_color;\n" "}\n"; static const char* const s_positionColorShader = "#version 310 es\n" "in highp vec4 a_position;\n" "in highp vec4 a_color;\n" "out highp vec4 v_color;\n" "void main (void)\n" "{\n" " gl_Position = a_position;\n" " v_color = a_color;\n" "}\n"; static const char* const s_positionColorOffsetShader = "#version 310 es\n" "in highp vec4 a_position;\n" "in highp vec4 a_offset;\n" "in highp vec4 a_color;\n" "out highp vec4 v_color;\n" "void main (void)\n" "{\n" " gl_Position = a_position + a_offset;\n" " v_color = a_color;\n" "}\n"; // Verifies image contains only yellow or greeen, or a linear combination // of these colors. static bool verifyImageYellowGreen (const tcu::Surface& image, tcu::TestLog& log, bool logImageOnSuccess) { using tcu::TestLog; const int colorThreshold = 20; tcu::Surface error (image.getWidth(), image.getHeight()); bool isOk = true; log << TestLog::Message << "Verifying image contents." << TestLog::EndMessage; for (int y = 0; y < image.getHeight(); y++) for (int x = 0; x < image.getWidth(); x++) { const tcu::RGBA pixel = image.getPixel(x, y); bool pixelOk = true; // Any pixel with !(G ~= 255) is faulty (not a linear combinations of green and yellow) if (de::abs(pixel.getGreen() - 255) > colorThreshold) pixelOk = false; // Any pixel with !(B ~= 0) is faulty (not a linear combinations of green and yellow) if (de::abs(pixel.getBlue() - 0) > colorThreshold) pixelOk = false; error.setPixel(x, y, (pixelOk) ? (tcu::RGBA(0, 255, 0, 255)) : (tcu::RGBA(255, 0, 0, 255))); isOk = isOk && pixelOk; } if (!isOk) { log << TestLog::Message << "Image verification failed." << TestLog::EndMessage; log << TestLog::ImageSet("Verfication result", "Result of rendering") << TestLog::Image("Result", "Result", image) << TestLog::Image("ErrorMask", "Error mask", error) << TestLog::EndImageSet; } else { log << TestLog::Message << "Image verification passed." << TestLog::EndMessage; if (logImageOnSuccess) log << TestLog::ImageSet("Verfication result", "Result of rendering") << TestLog::Image("Result", "Result", image) << TestLog::EndImageSet; } return isOk; } class BindingRenderCase : public TestCase { public: enum { TEST_RENDER_SIZE = 64 }; BindingRenderCase (Context& ctx, const char* name, const char* desc, bool unalignedData); virtual ~BindingRenderCase (void); virtual void init (void); virtual void deinit (void); IterateResult iterate (void); private: virtual void renderTo (tcu::Surface& dst) = 0; virtual void createBuffers (void) = 0; virtual void createShader (void) = 0; protected: const bool m_unalignedData; glw::GLuint m_vao; glu::ShaderProgram* m_program; }; BindingRenderCase::BindingRenderCase (Context& ctx, const char* name, const char* desc, bool unalignedData) : TestCase (ctx, name, desc) , m_unalignedData (unalignedData) , m_vao (0) , m_program (DE_NULL) { } BindingRenderCase::~BindingRenderCase (void) { deinit(); } void BindingRenderCase::init (void) { // check requirements if (m_context.getRenderTarget().getWidth() < TEST_RENDER_SIZE || m_context.getRenderTarget().getHeight() < TEST_RENDER_SIZE) throw tcu::NotSupportedError("Test requires at least " + de::toString<int>(TEST_RENDER_SIZE) + "x" + de::toString<int>(TEST_RENDER_SIZE) + " render target"); // resources m_context.getRenderContext().getFunctions().genVertexArrays(1, &m_vao); if (m_context.getRenderContext().getFunctions().getError() != GL_NO_ERROR) throw tcu::TestError("could not gen vao"); createBuffers(); createShader(); } void BindingRenderCase::deinit (void) { if (m_vao) { m_context.getRenderContext().getFunctions().deleteVertexArrays(1, &m_vao); m_vao = 0; } delete m_program; m_program = DE_NULL; } BindingRenderCase::IterateResult BindingRenderCase::iterate (void) { tcu::Surface surface(TEST_RENDER_SIZE, TEST_RENDER_SIZE); // draw pattern renderTo(surface); // verify results if (verifyImageYellowGreen(surface, m_testCtx.getLog(), false)) m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); else if (m_unalignedData) m_testCtx.setTestResult(QP_TEST_RESULT_COMPATIBILITY_WARNING, "Failed to draw with unaligned data"); else m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed"); return STOP; } class SingleBindingCase : public BindingRenderCase { public: enum CaseFlag { FLAG_ATTRIB_UNALIGNED = (1<<0), // !< unalign attributes with relativeOffset FLAG_ATTRIB_ALIGNED = (1<<1), // !< align attributes with relativeOffset to the buffer begin (and not buffer offset) FLAG_ATTRIBS_MULTIPLE_ELEMS = (1<<2), // !< use multiple attribute elements FLAG_ATTRIBS_SHARED_ELEMS = (1<<3), // !< use multiple shared attribute elements. xyzw & rgba stored as (x, y, zr, wg, b, a) FLAG_BUF_ALIGNED_OFFSET = (1<<4), // !< use aligned offset to the buffer object FLAG_BUF_UNALIGNED_OFFSET = (1<<5), // !< use unaligned offset to the buffer object FLAG_BUF_UNALIGNED_STRIDE = (1<<6), // !< unalign buffer elements }; SingleBindingCase (Context& ctx, const char* name, int flags); ~SingleBindingCase (void); void init (void); void deinit (void); private: struct TestSpec { int bufferOffset; int bufferStride; int positionAttrOffset; int colorAttrOffset; bool hasColorAttr; }; enum { GRID_SIZE = 20 }; void renderTo (tcu::Surface& dst); static TestSpec genTestSpec (int flags); static std::string genTestDescription (int flags); static bool isDataUnaligned (int flags); void createBuffers (void); void createShader (void); std::string genVertexSource (void); const TestSpec m_spec; glw::GLuint m_buf; }; SingleBindingCase::SingleBindingCase (Context& ctx, const char* name, int flags) : BindingRenderCase (ctx, name, genTestDescription(flags).c_str(), isDataUnaligned(flags)) , m_spec (genTestSpec(flags)) , m_buf (0) { DE_ASSERT(!((flags & FLAG_ATTRIB_UNALIGNED) && (flags & FLAG_ATTRIB_ALIGNED))); DE_ASSERT(!((flags & FLAG_ATTRIB_ALIGNED) && (flags & FLAG_BUF_UNALIGNED_STRIDE))); DE_ASSERT(!isDataUnaligned(flags)); } SingleBindingCase::~SingleBindingCase (void) { deinit(); } void SingleBindingCase::init (void) { // log what we are trying to do m_testCtx.getLog() << tcu::TestLog::Message << "Rendering " << (int)GRID_SIZE << "x" << (int)GRID_SIZE << " grid.\n" << "Buffer format:\n" << " bufferOffset: " << m_spec.bufferOffset << "\n" << " bufferStride: " << m_spec.bufferStride << "\n" << "Vertex position format:\n" << " type: float4\n" << " offset: " << m_spec.positionAttrOffset << "\n" << " total offset: " << m_spec.bufferOffset + m_spec.positionAttrOffset << "\n" << tcu::TestLog::EndMessage; if (m_spec.hasColorAttr) m_testCtx.getLog() << tcu::TestLog::Message << "Color:\n" << " type: float4\n" << " offset: " << m_spec.colorAttrOffset << "\n" << " total offset: " << m_spec.bufferOffset + m_spec.colorAttrOffset << "\n" << tcu::TestLog::EndMessage; // init BindingRenderCase::init(); } void SingleBindingCase::deinit (void) { if (m_buf) { m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_buf); m_buf = 0; } BindingRenderCase::deinit(); } void SingleBindingCase::renderTo (tcu::Surface& dst) { glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); const int positionLoc = gl.glGetAttribLocation(m_program->getProgram(), "a_position"); const int colorLoc = gl.glGetAttribLocation(m_program->getProgram(), "a_color"); const int colorUniformLoc = gl.glGetUniformLocation(m_program->getProgram(), "u_color"); gl.enableLogging(true); gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); gl.glClear(GL_COLOR_BUFFER_BIT); gl.glViewport(0, 0, dst.getWidth(), dst.getHeight()); gl.glBindVertexArray(m_vao); GLU_EXPECT_NO_ERROR(gl.glGetError(), "set vao"); gl.glUseProgram(m_program->getProgram()); GLU_EXPECT_NO_ERROR(gl.glGetError(), "use program"); if (m_spec.hasColorAttr) { gl.glBindVertexBuffer(3, m_buf, m_spec.bufferOffset, m_spec.bufferStride); gl.glVertexAttribBinding(positionLoc, 3); gl.glVertexAttribFormat(positionLoc, 4, GL_FLOAT, GL_FALSE, m_spec.positionAttrOffset); gl.glEnableVertexAttribArray(positionLoc); gl.glVertexAttribBinding(colorLoc, 3); gl.glVertexAttribFormat(colorLoc, 4, GL_FLOAT, GL_FALSE, m_spec.colorAttrOffset); gl.glEnableVertexAttribArray(colorLoc); GLU_EXPECT_NO_ERROR(gl.glGetError(), "set va"); gl.glDrawArrays(GL_TRIANGLES, 0, GRID_SIZE*GRID_SIZE*6); GLU_EXPECT_NO_ERROR(gl.glGetError(), "draw"); } else { gl.glBindVertexBuffer(3, m_buf, m_spec.bufferOffset, m_spec.bufferStride); gl.glVertexAttribBinding(positionLoc, 3); gl.glVertexAttribFormat(positionLoc, 4, GL_FLOAT, GL_FALSE, m_spec.positionAttrOffset); gl.glEnableVertexAttribArray(positionLoc); GLU_EXPECT_NO_ERROR(gl.glGetError(), "set va"); gl.glUniform4f(colorUniformLoc, 0.0f, 1.0f, 0.0f, 1.0f); gl.glDrawArrays(GL_TRIANGLES, 0, GRID_SIZE*GRID_SIZE*6); GLU_EXPECT_NO_ERROR(gl.glGetError(), "draw"); } gl.glFinish(); gl.glBindVertexArray(0); gl.glUseProgram(0); GLU_EXPECT_NO_ERROR(gl.glGetError(), "clean"); glu::readPixels(m_context.getRenderContext(), 0, 0, dst.getAccess()); } SingleBindingCase::TestSpec SingleBindingCase::genTestSpec (int flags) { const int datumSize = 4; const int bufferOffset = (flags & FLAG_BUF_ALIGNED_OFFSET) ? (32) : (flags & FLAG_BUF_UNALIGNED_OFFSET) ? (19) : (0); const int attrBufAlignment = ((bufferOffset % datumSize) == 0) ? (0) : (datumSize - (bufferOffset % datumSize)); const int positionAttrOffset = (flags & FLAG_ATTRIB_UNALIGNED) ? (3) : (flags & FLAG_ATTRIB_ALIGNED) ? (attrBufAlignment) : (0); const bool hasColorAttr = (flags & FLAG_ATTRIBS_SHARED_ELEMS) || (flags & FLAG_ATTRIBS_MULTIPLE_ELEMS); const int colorAttrOffset = (flags & FLAG_ATTRIBS_SHARED_ELEMS) ? (2 * datumSize) : (flags & FLAG_ATTRIBS_MULTIPLE_ELEMS) ? (4 * datumSize) : (-1); const int bufferStrideBase = de::max(positionAttrOffset + 4 * datumSize, colorAttrOffset + 4 * datumSize); const int bufferStrideAlignment = ((bufferStrideBase % datumSize) == 0) ? (0) : (datumSize - (bufferStrideBase % datumSize)); const int bufferStridePadding = ((flags & FLAG_BUF_UNALIGNED_STRIDE) && deIsAligned32(bufferStrideBase, datumSize)) ? (13) : (!(flags & FLAG_BUF_UNALIGNED_STRIDE) && !deIsAligned32(bufferStrideBase, datumSize)) ? (bufferStrideAlignment) : (0); TestSpec spec; spec.bufferOffset = bufferOffset; spec.bufferStride = bufferStrideBase + bufferStridePadding; spec.positionAttrOffset = positionAttrOffset; spec.colorAttrOffset = colorAttrOffset; spec.hasColorAttr = hasColorAttr; if (flags & FLAG_ATTRIB_UNALIGNED) DE_ASSERT(!deIsAligned32(spec.bufferOffset + spec.positionAttrOffset, datumSize)); else if (flags & FLAG_ATTRIB_ALIGNED) DE_ASSERT(deIsAligned32(spec.bufferOffset + spec.positionAttrOffset, datumSize)); if (flags & FLAG_BUF_UNALIGNED_STRIDE) DE_ASSERT(!deIsAligned32(spec.bufferStride, datumSize)); else DE_ASSERT(deIsAligned32(spec.bufferStride, datumSize)); return spec; } std::string SingleBindingCase::genTestDescription (int flags) { std::ostringstream buf; buf << "draw test pattern"; if (flags & FLAG_ATTRIB_UNALIGNED) buf << ", attribute offset (unaligned)"; if (flags & FLAG_ATTRIB_ALIGNED) buf << ", attribute offset (aligned)"; if (flags & FLAG_ATTRIBS_MULTIPLE_ELEMS) buf << ", 2 attributes"; if (flags & FLAG_ATTRIBS_SHARED_ELEMS) buf << ", 2 attributes (some components shared)"; if (flags & FLAG_BUF_ALIGNED_OFFSET) buf << ", buffer offset aligned"; if (flags & FLAG_BUF_UNALIGNED_OFFSET) buf << ", buffer offset unaligned"; if (flags & FLAG_BUF_UNALIGNED_STRIDE) buf << ", buffer stride unaligned"; return buf.str(); } bool SingleBindingCase::isDataUnaligned (int flags) { if (flags & FLAG_ATTRIB_UNALIGNED) return true; if (flags & FLAG_ATTRIB_ALIGNED) return false; return (flags & FLAG_BUF_UNALIGNED_OFFSET) || (flags & FLAG_BUF_UNALIGNED_STRIDE); } void SingleBindingCase::createBuffers (void) { const glw::Functions& gl = m_context.getRenderContext().getFunctions(); std::vector<deUint8> dataBuf (m_spec.bufferOffset + m_spec.bufferStride * GRID_SIZE * GRID_SIZE * 6); // In interleaved mode color rg and position zw are the same. Select "good" values for r and g const tcu::Vec4 colorA (0.0f, 1.0f, 0.0f, 1.0f); const tcu::Vec4 colorB (0.5f, 1.0f, 0.0f, 1.0f); for (int y = 0; y < GRID_SIZE; ++y) for (int x = 0; x < GRID_SIZE; ++x) { const tcu::Vec4& color = ((x + y) % 2 == 0) ? (colorA) : (colorB); const tcu::Vec4 positions[6] = { tcu::Vec4(float(x+0) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+0) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f), tcu::Vec4(float(x+0) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+1) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f), tcu::Vec4(float(x+1) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+1) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f), tcu::Vec4(float(x+0) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+0) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f), tcu::Vec4(float(x+1) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+1) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f), tcu::Vec4(float(x+1) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+0) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f), }; // copy cell vertices to the buffer. for (int v = 0; v < 6; ++v) memcpy(&dataBuf[m_spec.bufferOffset + m_spec.positionAttrOffset + m_spec.bufferStride * ((y * GRID_SIZE + x) * 6 + v)], positions[v].getPtr(), sizeof(positions[v])); // copy color to buffer if (m_spec.hasColorAttr) for (int v = 0; v < 6; ++v) memcpy(&dataBuf[m_spec.bufferOffset + m_spec.colorAttrOffset + m_spec.bufferStride * ((y * GRID_SIZE + x) * 6 + v)], color.getPtr(), sizeof(color)); } gl.genBuffers(1, &m_buf); gl.bindBuffer(GL_ARRAY_BUFFER, m_buf); gl.bufferData(GL_ARRAY_BUFFER, (glw::GLsizeiptr)dataBuf.size(), &dataBuf[0], GL_STATIC_DRAW); gl.bindBuffer(GL_ARRAY_BUFFER, 0); if (gl.getError() != GL_NO_ERROR) throw tcu::TestError("could not init buffer"); } void SingleBindingCase::createShader (void) { m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::VertexSource(genVertexSource()) << glu::FragmentSource(s_colorFragmentShader)); m_testCtx.getLog() << *m_program; if (!m_program->isOk()) throw tcu::TestError("could not build shader"); } std::string SingleBindingCase::genVertexSource (void) { const bool useUniformColor = !m_spec.hasColorAttr; std::ostringstream buf; buf << "#version 310 es\n" "in highp vec4 a_position;\n"; if (!useUniformColor) buf << "in highp vec4 a_color;\n"; else buf << "uniform highp vec4 u_color;\n"; buf << "out highp vec4 v_color;\n" "void main (void)\n" "{\n" " gl_Position = a_position;\n" " v_color = " << ((useUniformColor) ? ("u_color") : ("a_color")) << ";\n" "}\n"; return buf.str(); } class MultipleBindingCase : public BindingRenderCase { public: enum CaseFlag { FLAG_ZERO_STRIDE = (1<<0), // !< set a buffer stride to zero FLAG_INSTANCED = (1<<1), // !< set a buffer instance divisor to non-zero FLAG_ALIASING_BUFFERS = (1<<2), // !< bind buffer to multiple binding points }; MultipleBindingCase (Context& ctx, const char* name, int flags); ~MultipleBindingCase (void); void init (void); void deinit (void); private: struct TestSpec { bool zeroStride; bool instanced; bool aliasingBuffers; }; enum { GRID_SIZE = 20 }; void renderTo (tcu::Surface& dst); TestSpec genTestSpec (int flags) const; std::string genTestDescription (int flags) const; void createBuffers (void); void createShader (void); const TestSpec m_spec; glw::GLuint m_primitiveBuf; glw::GLuint m_colorOffsetBuf; }; MultipleBindingCase::MultipleBindingCase (Context& ctx, const char* name, int flags) : BindingRenderCase (ctx, name, genTestDescription(flags).c_str(), false) , m_spec (genTestSpec(flags)) , m_primitiveBuf (0) , m_colorOffsetBuf (0) { DE_ASSERT(!(m_spec.instanced && m_spec.zeroStride)); } MultipleBindingCase::~MultipleBindingCase (void) { deinit(); } void MultipleBindingCase::init (void) { BindingRenderCase::init(); // log what we are trying to do m_testCtx.getLog() << tcu::TestLog::Message << "Rendering " << (int)GRID_SIZE << "x" << (int)GRID_SIZE << " grid.\n" << "Vertex positions:\n" << " binding point: 1\n" << "Vertex offsets:\n" << " binding point: 2\n" << "Vertex colors:\n" << " binding point: 2\n" << "Binding point 1:\n" << " buffer object: " << m_primitiveBuf << "\n" << "Binding point 2:\n" << " buffer object: " << ((m_spec.aliasingBuffers) ? (m_primitiveBuf) : (m_colorOffsetBuf)) << "\n" << " instance divisor: " << ((m_spec.instanced) ? (1) : (0)) << "\n" << " stride: " << ((m_spec.zeroStride) ? (0) : (4*4*2)) << "\n" << tcu::TestLog::EndMessage; } void MultipleBindingCase::deinit (void) { if (m_primitiveBuf) { m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_primitiveBuf); m_primitiveBuf = DE_NULL; } if (m_colorOffsetBuf) { m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_colorOffsetBuf); m_colorOffsetBuf = DE_NULL; } BindingRenderCase::deinit(); } void MultipleBindingCase::renderTo (tcu::Surface& dst) { glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); const int positionLoc = gl.glGetAttribLocation(m_program->getProgram(), "a_position"); const int colorLoc = gl.glGetAttribLocation(m_program->getProgram(), "a_color"); const int offsetLoc = gl.glGetAttribLocation(m_program->getProgram(), "a_offset"); const int positionBinding = 1; const int colorOffsetBinding = 2; gl.enableLogging(true); gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); gl.glClear(GL_COLOR_BUFFER_BIT); gl.glViewport(0, 0, dst.getWidth(), dst.getHeight()); gl.glBindVertexArray(m_vao); GLU_EXPECT_NO_ERROR(gl.glGetError(), "set vao"); gl.glUseProgram(m_program->getProgram()); GLU_EXPECT_NO_ERROR(gl.glGetError(), "use program"); // Setup format & binding gl.glEnableVertexAttribArray(positionLoc); gl.glEnableVertexAttribArray(colorLoc); gl.glEnableVertexAttribArray(offsetLoc); gl.glVertexAttribFormat(positionLoc, 4, GL_FLOAT, GL_FALSE, 0); gl.glVertexAttribFormat(colorLoc, 4, GL_FLOAT, GL_FALSE, 0); gl.glVertexAttribFormat(offsetLoc, 4, GL_FLOAT, GL_FALSE, sizeof(tcu::Vec4)); gl.glVertexAttribBinding(positionLoc, positionBinding); gl.glVertexAttribBinding(colorLoc, colorOffsetBinding); gl.glVertexAttribBinding(offsetLoc, colorOffsetBinding); GLU_EXPECT_NO_ERROR(gl.glGetError(), "setup attribs"); // setup binding points gl.glVertexBindingDivisor(positionBinding, 0); gl.glBindVertexBuffer(positionBinding, m_primitiveBuf, 0, sizeof(tcu::Vec4)); { const int stride = (m_spec.zeroStride) ? (0) : (2 * (int)sizeof(tcu::Vec4)); const int offset = (!m_spec.aliasingBuffers) ? (0) : (m_spec.instanced) ? (6 * (int)sizeof(tcu::Vec4)) : (6 * GRID_SIZE * GRID_SIZE * (int)sizeof(tcu::Vec4)); const glw::GLuint buffer = (m_spec.aliasingBuffers) ? (m_primitiveBuf) : (m_colorOffsetBuf); const int divisor = (m_spec.instanced) ? (1) : (0); gl.glVertexBindingDivisor(colorOffsetBinding, divisor); gl.glBindVertexBuffer(colorOffsetBinding, buffer, offset, (glw::GLsizei)stride); } GLU_EXPECT_NO_ERROR(gl.glGetError(), "set binding points"); if (m_spec.instanced) gl.glDrawArraysInstanced(GL_TRIANGLES, 0, 6, GRID_SIZE*GRID_SIZE); else gl.glDrawArrays(GL_TRIANGLES, 0, GRID_SIZE*GRID_SIZE*6); GLU_EXPECT_NO_ERROR(gl.glGetError(), "draw"); gl.glFinish(); gl.glBindVertexArray(0); gl.glUseProgram(0); GLU_EXPECT_NO_ERROR(gl.glGetError(), "clean"); glu::readPixels(m_context.getRenderContext(), 0, 0, dst.getAccess()); } MultipleBindingCase::TestSpec MultipleBindingCase::genTestSpec (int flags) const { MultipleBindingCase::TestSpec spec; spec.zeroStride = !!(flags & FLAG_ZERO_STRIDE); spec.instanced = !!(flags & FLAG_INSTANCED); spec.aliasingBuffers = !!(flags & FLAG_ALIASING_BUFFERS); return spec; } std::string MultipleBindingCase::genTestDescription (int flags) const { std::ostringstream buf; buf << "draw test pattern"; if (flags & FLAG_ZERO_STRIDE) buf << ", zero stride"; if (flags & FLAG_INSTANCED) buf << ", instanced binding point"; if (flags & FLAG_ALIASING_BUFFERS) buf << ", binding points share buffer object"; return buf.str(); } void MultipleBindingCase::createBuffers (void) { const glw::Functions& gl = m_context.getRenderContext().getFunctions(); const tcu::Vec4 green = tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f); const tcu::Vec4 yellow = tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f); const int vertexDataSize = (m_spec.instanced) ? (6) : (6 * GRID_SIZE * GRID_SIZE); const int offsetColorSize = (m_spec.zeroStride) ? (2) : (m_spec.instanced) ? (2 * GRID_SIZE * GRID_SIZE) : (2 * 6 * GRID_SIZE * GRID_SIZE); const int primitiveBufSize = (m_spec.aliasingBuffers) ? (vertexDataSize + offsetColorSize) : (vertexDataSize); const int colorOffsetBufSize = (m_spec.aliasingBuffers) ? (0) : (offsetColorSize); std::vector<tcu::Vec4> primitiveData (primitiveBufSize); std::vector<tcu::Vec4> colorOffsetData (colorOffsetBufSize); tcu::Vec4* colorOffsetWritePtr = DE_NULL; if (m_spec.aliasingBuffers) { if (m_spec.instanced) colorOffsetWritePtr = &primitiveData[6]; else colorOffsetWritePtr = &primitiveData[GRID_SIZE*GRID_SIZE*6]; } else colorOffsetWritePtr = &colorOffsetData[0]; // write vertex position if (m_spec.instanced) { // store single basic primitive primitiveData[0] = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f); primitiveData[1] = tcu::Vec4(0.0f, 2.0f / GRID_SIZE, 0.0f, 1.0f); primitiveData[2] = tcu::Vec4(2.0f / GRID_SIZE, 2.0f / GRID_SIZE, 0.0f, 1.0f); primitiveData[3] = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f); primitiveData[4] = tcu::Vec4(2.0f / GRID_SIZE, 2.0f / GRID_SIZE, 0.0f, 1.0f); primitiveData[5] = tcu::Vec4(2.0f / GRID_SIZE, 0.0f, 0.0f, 1.0f); } else { // store whole grid for (int y = 0; y < GRID_SIZE; ++y) for (int x = 0; x < GRID_SIZE; ++x) { primitiveData[(y * GRID_SIZE + x) * 6 + 0] = tcu::Vec4(float(x+0) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+0) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f); primitiveData[(y * GRID_SIZE + x) * 6 + 1] = tcu::Vec4(float(x+0) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+1) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f); primitiveData[(y * GRID_SIZE + x) * 6 + 2] = tcu::Vec4(float(x+1) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+1) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f); primitiveData[(y * GRID_SIZE + x) * 6 + 3] = tcu::Vec4(float(x+0) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+0) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f); primitiveData[(y * GRID_SIZE + x) * 6 + 4] = tcu::Vec4(float(x+1) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+1) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f); primitiveData[(y * GRID_SIZE + x) * 6 + 5] = tcu::Vec4(float(x+1) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+0) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f); } } // store color&offset if (m_spec.zeroStride) { colorOffsetWritePtr[0] = green; colorOffsetWritePtr[1] = tcu::Vec4(0.0f); } else if (m_spec.instanced) { for (int y = 0; y < GRID_SIZE; ++y) for (int x = 0; x < GRID_SIZE; ++x) { const tcu::Vec4& color = ((x + y) % 2 == 0) ? (green) : (yellow); colorOffsetWritePtr[(y * GRID_SIZE + x) * 2 + 0] = color; colorOffsetWritePtr[(y * GRID_SIZE + x) * 2 + 1] = tcu::Vec4(float(x) / float(GRID_SIZE) * 2.0f - 1.0f, float(y) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 0.0f); } } else { for (int y = 0; y < GRID_SIZE; ++y) for (int x = 0; x < GRID_SIZE; ++x) for (int v = 0; v < 6; ++v) { const tcu::Vec4& color = ((x + y) % 2 == 0) ? (green) : (yellow); colorOffsetWritePtr[((y * GRID_SIZE + x) * 6 + v) * 2 + 0] = color; colorOffsetWritePtr[((y * GRID_SIZE + x) * 6 + v) * 2 + 1] = tcu::Vec4(0.0f); } } // upload vertex data gl.genBuffers(1, &m_primitiveBuf); gl.bindBuffer(GL_ARRAY_BUFFER, m_primitiveBuf); gl.bufferData(GL_ARRAY_BUFFER, (int)(primitiveData.size() * sizeof(tcu::Vec4)), primitiveData[0].getPtr(), GL_STATIC_DRAW); GLU_EXPECT_NO_ERROR(gl.getError(), "upload data"); if (!m_spec.aliasingBuffers) { // upload color & offset data gl.genBuffers(1, &m_colorOffsetBuf); gl.bindBuffer(GL_ARRAY_BUFFER, m_colorOffsetBuf); gl.bufferData(GL_ARRAY_BUFFER, (int)(colorOffsetData.size() * sizeof(tcu::Vec4)), colorOffsetData[0].getPtr(), GL_STATIC_DRAW); GLU_EXPECT_NO_ERROR(gl.getError(), "upload colordata"); } } void MultipleBindingCase::createShader (void) { m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::VertexSource(s_positionColorOffsetShader) << glu::FragmentSource(s_colorFragmentShader)); m_testCtx.getLog() << *m_program; if (!m_program->isOk()) throw tcu::TestError("could not build shader"); } class MixedBindingCase : public BindingRenderCase { public: enum CaseType { CASE_BASIC = 0, CASE_INSTANCED_BINDING, CASE_INSTANCED_ATTRIB, CASE_LAST }; MixedBindingCase (Context& ctx, const char* name, const char* desc, CaseType caseType); ~MixedBindingCase (void); void init (void); void deinit (void); private: enum { GRID_SIZE = 20 }; void renderTo (tcu::Surface& dst); void createBuffers (void); void createShader (void); const CaseType m_case; glw::GLuint m_posBuffer; glw::GLuint m_colorOffsetBuffer; }; MixedBindingCase::MixedBindingCase (Context& ctx, const char* name, const char* desc, CaseType caseType) : BindingRenderCase (ctx, name, desc, false) , m_case (caseType) , m_posBuffer (0) , m_colorOffsetBuffer (0) { DE_ASSERT(caseType < CASE_LAST); } MixedBindingCase::~MixedBindingCase (void) { deinit(); } void MixedBindingCase::init (void) { BindingRenderCase::init(); } void MixedBindingCase::deinit (void) { if (m_posBuffer) { m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_posBuffer); m_posBuffer = DE_NULL; } if (m_colorOffsetBuffer) { m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_colorOffsetBuffer); m_colorOffsetBuffer = DE_NULL; } BindingRenderCase::deinit(); } void MixedBindingCase::renderTo (tcu::Surface& dst) { glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); const int positionLoc = gl.glGetAttribLocation(m_program->getProgram(), "a_position"); const int colorLoc = gl.glGetAttribLocation(m_program->getProgram(), "a_color"); const int offsetLoc = gl.glGetAttribLocation(m_program->getProgram(), "a_offset"); gl.enableLogging(true); gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); gl.glClear(GL_COLOR_BUFFER_BIT); gl.glViewport(0, 0, dst.getWidth(), dst.getHeight()); gl.glBindVertexArray(m_vao); GLU_EXPECT_NO_ERROR(gl.glGetError(), "set vao"); gl.glUseProgram(m_program->getProgram()); GLU_EXPECT_NO_ERROR(gl.glGetError(), "use program"); switch (m_case) { case CASE_BASIC: { // bind position using vertex_attrib_binding api gl.glBindVertexBuffer(positionLoc, m_posBuffer, 0, (glw::GLsizei)sizeof(tcu::Vec4)); gl.glVertexAttribBinding(positionLoc, positionLoc); gl.glVertexAttribFormat(positionLoc, 4, GL_FLOAT, GL_FALSE, 0); GLU_EXPECT_NO_ERROR(gl.glGetError(), "set binding"); // bind color using old api gl.glBindBuffer(GL_ARRAY_BUFFER, m_colorOffsetBuffer); gl.glVertexAttribPointer(colorLoc, 4, GL_FLOAT, GL_FALSE, glw::GLsizei(2 * sizeof(tcu::Vec4)), DE_NULL); gl.glVertexAttribPointer(offsetLoc, 4, GL_FLOAT, GL_FALSE, glw::GLsizei(2 * sizeof(tcu::Vec4)), (deUint8*)DE_NULL + sizeof(tcu::Vec4)); GLU_EXPECT_NO_ERROR(gl.glGetError(), "set va"); // draw gl.glEnableVertexAttribArray(positionLoc); gl.glEnableVertexAttribArray(colorLoc); gl.glEnableVertexAttribArray(offsetLoc); gl.glDrawArrays(GL_TRIANGLES, 0, 6*GRID_SIZE*GRID_SIZE); break; } case CASE_INSTANCED_BINDING: { // bind position using old api gl.glBindBuffer(GL_ARRAY_BUFFER, m_posBuffer); gl.glVertexAttribPointer(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL); GLU_EXPECT_NO_ERROR(gl.glGetError(), "set va"); // bind color using vertex_attrib_binding api gl.glBindVertexBuffer(colorLoc, m_colorOffsetBuffer, 0, (glw::GLsizei)(2 * sizeof(tcu::Vec4))); gl.glVertexBindingDivisor(colorLoc, 1); gl.glVertexAttribBinding(colorLoc, colorLoc); gl.glVertexAttribBinding(offsetLoc, colorLoc); gl.glVertexAttribFormat(colorLoc, 4, GL_FLOAT, GL_FALSE, 0); gl.glVertexAttribFormat(offsetLoc, 4, GL_FLOAT, GL_FALSE, sizeof(tcu::Vec4)); GLU_EXPECT_NO_ERROR(gl.glGetError(), "set binding"); // draw gl.glEnableVertexAttribArray(positionLoc); gl.glEnableVertexAttribArray(colorLoc); gl.glEnableVertexAttribArray(offsetLoc); gl.glDrawArraysInstanced(GL_TRIANGLES, 0, 6, GRID_SIZE*GRID_SIZE); break; } case CASE_INSTANCED_ATTRIB: { // bind position using vertex_attrib_binding api gl.glBindVertexBuffer(positionLoc, m_posBuffer, 0, (glw::GLsizei)sizeof(tcu::Vec4)); gl.glVertexAttribBinding(positionLoc, positionLoc); gl.glVertexAttribFormat(positionLoc, 4, GL_FLOAT, GL_FALSE, 0); GLU_EXPECT_NO_ERROR(gl.glGetError(), "set binding"); // bind color using old api gl.glBindBuffer(GL_ARRAY_BUFFER, m_colorOffsetBuffer); gl.glVertexAttribPointer(colorLoc, 4, GL_FLOAT, GL_FALSE, glw::GLsizei(2 * sizeof(tcu::Vec4)), DE_NULL); gl.glVertexAttribPointer(offsetLoc, 4, GL_FLOAT, GL_FALSE, glw::GLsizei(2 * sizeof(tcu::Vec4)), (deUint8*)DE_NULL + sizeof(tcu::Vec4)); gl.glVertexAttribDivisor(colorLoc, 1); gl.glVertexAttribDivisor(offsetLoc, 1); GLU_EXPECT_NO_ERROR(gl.glGetError(), "set va"); // draw gl.glEnableVertexAttribArray(positionLoc); gl.glEnableVertexAttribArray(colorLoc); gl.glEnableVertexAttribArray(offsetLoc); gl.glDrawArraysInstanced(GL_TRIANGLES, 0, 6, GRID_SIZE*GRID_SIZE); break; } default: DE_ASSERT(DE_FALSE); } gl.glFinish(); gl.glBindVertexArray(0); gl.glUseProgram(0); GLU_EXPECT_NO_ERROR(gl.glGetError(), "clean"); glu::readPixels(m_context.getRenderContext(), 0, 0, dst.getAccess()); } void MixedBindingCase::createBuffers (void) { const glw::Functions& gl = m_context.getRenderContext().getFunctions(); const tcu::Vec4 green = tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f); const tcu::Vec4 yellow = tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f); // draw grid. In instanced mode, each cell is an instance const bool instanced = (m_case == CASE_INSTANCED_BINDING) || (m_case == CASE_INSTANCED_ATTRIB); const int numCells = GRID_SIZE*GRID_SIZE; const int numPositionCells = (instanced) ? (1) : (numCells); const int numPositionElements = 6 * numPositionCells; const int numInstanceElementsPerCell = (instanced) ? (1) : (6); const int numColorOffsetElements = numInstanceElementsPerCell * numCells; std::vector<tcu::Vec4> positionData (numPositionElements); std::vector<tcu::Vec4> colorOffsetData (2 * numColorOffsetElements); // positions for (int primNdx = 0; primNdx < numPositionCells; ++primNdx) { positionData[primNdx*6 + 0] = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f); positionData[primNdx*6 + 1] = tcu::Vec4(0.0f, 2.0f / GRID_SIZE, 0.0f, 1.0f); positionData[primNdx*6 + 2] = tcu::Vec4(2.0f / GRID_SIZE, 2.0f / GRID_SIZE, 0.0f, 1.0f); positionData[primNdx*6 + 3] = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f); positionData[primNdx*6 + 4] = tcu::Vec4(2.0f / GRID_SIZE, 2.0f / GRID_SIZE, 0.0f, 1.0f); positionData[primNdx*6 + 5] = tcu::Vec4(2.0f / GRID_SIZE, 0.0f, 0.0f, 1.0f); } // color & offset for (int y = 0; y < GRID_SIZE; ++y) for (int x = 0; x < GRID_SIZE; ++x) { for (int v = 0; v < numInstanceElementsPerCell; ++v) { const tcu::Vec4& color = ((x + y) % 2 == 0) ? (green) : (yellow); colorOffsetData[((y * GRID_SIZE + x) * numInstanceElementsPerCell + v) * 2 + 0] = color; colorOffsetData[((y * GRID_SIZE + x) * numInstanceElementsPerCell + v) * 2 + 1] = tcu::Vec4(float(x) / float(GRID_SIZE) * 2.0f - 1.0f, float(y) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 0.0f); } } // upload vertex data gl.genBuffers(1, &m_posBuffer); gl.bindBuffer(GL_ARRAY_BUFFER, m_posBuffer); gl.bufferData(GL_ARRAY_BUFFER, (int)(positionData.size() * sizeof(tcu::Vec4)), positionData[0].getPtr(), GL_STATIC_DRAW); GLU_EXPECT_NO_ERROR(gl.getError(), "upload position data"); gl.genBuffers(1, &m_colorOffsetBuffer); gl.bindBuffer(GL_ARRAY_BUFFER, m_colorOffsetBuffer); gl.bufferData(GL_ARRAY_BUFFER, (int)(colorOffsetData.size() * sizeof(tcu::Vec4)), colorOffsetData[0].getPtr(), GL_STATIC_DRAW); GLU_EXPECT_NO_ERROR(gl.getError(), "upload position data"); } void MixedBindingCase::createShader (void) { m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::VertexSource(s_positionColorOffsetShader) << glu::FragmentSource(s_colorFragmentShader)); m_testCtx.getLog() << *m_program; if (!m_program->isOk()) throw tcu::TestError("could not build shader"); } class MixedApiCase : public BindingRenderCase { public: enum CaseType { CASE_CHANGE_BUFFER = 0, CASE_CHANGE_BUFFER_OFFSET, CASE_CHANGE_BUFFER_STRIDE, CASE_CHANGE_BINDING_POINT, CASE_LAST }; MixedApiCase (Context& ctx, const char* name, const char* desc, CaseType caseType); ~MixedApiCase (void); void init (void); void deinit (void); private: enum { GRID_SIZE = 20 }; void renderTo (tcu::Surface& dst); void createBuffers (void); void createShader (void); const CaseType m_case; glw::GLuint m_buffer; }; MixedApiCase::MixedApiCase (Context& ctx, const char* name, const char* desc, CaseType caseType) : BindingRenderCase (ctx, name, desc, false) , m_case (caseType) , m_buffer (0) { DE_ASSERT(caseType < CASE_LAST); } MixedApiCase::~MixedApiCase (void) { deinit(); } void MixedApiCase::init (void) { BindingRenderCase::init(); } void MixedApiCase::deinit (void) { if (m_buffer) { m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_buffer); m_buffer = DE_NULL; } BindingRenderCase::deinit(); } void MixedApiCase::renderTo (tcu::Surface& dst) { glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); const int positionLoc = gl.glGetAttribLocation(m_program->getProgram(), "a_position"); const int colorLoc = gl.glGetAttribLocation(m_program->getProgram(), "a_color"); glu::Buffer dummyBuffer (m_context.getRenderContext()); gl.enableLogging(true); gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); gl.glClear(GL_COLOR_BUFFER_BIT); gl.glViewport(0, 0, dst.getWidth(), dst.getHeight()); gl.glBindVertexArray(m_vao); GLU_EXPECT_NO_ERROR(gl.glGetError(), "set vao"); gl.glUseProgram(m_program->getProgram()); GLU_EXPECT_NO_ERROR(gl.glGetError(), "use program"); switch (m_case) { case CASE_CHANGE_BUFFER: { // bind data using old api gl.glBindBuffer(GL_ARRAY_BUFFER, *dummyBuffer); gl.glVertexAttribPointer(positionLoc, 4, GL_FLOAT, GL_FALSE, (glw::GLsizei)(2 * sizeof(tcu::Vec4)), (const deUint8*)DE_NULL); gl.glVertexAttribPointer(colorLoc, 4, GL_FLOAT, GL_FALSE, (glw::GLsizei)(2 * sizeof(tcu::Vec4)), (const deUint8*)DE_NULL + sizeof(tcu::Vec4)); // change buffer with vertex_attrib_binding gl.glBindVertexBuffer(positionLoc, m_buffer, 0, (glw::GLsizei)(2 * sizeof(tcu::Vec4))); gl.glBindVertexBuffer(colorLoc, m_buffer, sizeof(tcu::Vec4), (glw::GLsizei)(2 * sizeof(tcu::Vec4))); GLU_EXPECT_NO_ERROR(gl.glGetError(), ""); break; } case CASE_CHANGE_BUFFER_OFFSET: { // bind data using old api gl.glBindBuffer(GL_ARRAY_BUFFER, m_buffer); gl.glVertexAttribPointer(positionLoc, 4, GL_FLOAT, GL_FALSE, (glw::GLsizei)(2 * sizeof(tcu::Vec4)), (const deUint8*)DE_NULL); gl.glVertexAttribPointer(colorLoc, 4, GL_FLOAT, GL_FALSE, (glw::GLsizei)(2 * sizeof(tcu::Vec4)), (const deUint8*)DE_NULL); // change buffer offset with vertex_attrib_binding gl.glBindVertexBuffer(positionLoc, m_buffer, 0, (glw::GLsizei)(2 * sizeof(tcu::Vec4))); gl.glBindVertexBuffer(colorLoc, m_buffer, sizeof(tcu::Vec4), (glw::GLsizei)(2 * sizeof(tcu::Vec4))); GLU_EXPECT_NO_ERROR(gl.glGetError(), ""); break; } case CASE_CHANGE_BUFFER_STRIDE: { // bind data using old api gl.glBindBuffer(GL_ARRAY_BUFFER, m_buffer); gl.glVertexAttribPointer(positionLoc, 4, GL_FLOAT, GL_FALSE, 8, (const deUint8*)DE_NULL); gl.glVertexAttribPointer(colorLoc, 4, GL_FLOAT, GL_FALSE, 4, (const deUint8*)DE_NULL); // change buffer stride with vertex_attrib_binding gl.glBindVertexBuffer(positionLoc, m_buffer, 0, (glw::GLsizei)(2 * sizeof(tcu::Vec4))); gl.glBindVertexBuffer(colorLoc, m_buffer, sizeof(tcu::Vec4), (glw::GLsizei)(2 * sizeof(tcu::Vec4))); GLU_EXPECT_NO_ERROR(gl.glGetError(), ""); break; } case CASE_CHANGE_BINDING_POINT: { const int maxUsedLocation = de::max(positionLoc, colorLoc); const int bindingPoint1 = maxUsedLocation + 1; const int bindingPoint2 = maxUsedLocation + 2; // bind data using old api gl.glBindBuffer(GL_ARRAY_BUFFER, m_buffer); gl.glVertexAttribPointer(bindingPoint1, 4, GL_FLOAT, GL_FALSE, (glw::GLsizei)(2 * sizeof(tcu::Vec4)), (const deUint8*)DE_NULL); gl.glVertexAttribPointer(bindingPoint2, 4, GL_FLOAT, GL_FALSE, (glw::GLsizei)(2 * sizeof(tcu::Vec4)), (const deUint8*)DE_NULL + sizeof(tcu::Vec4)); // change buffer binding point with vertex_attrib_binding gl.glVertexAttribFormat(positionLoc, 4, GL_FLOAT, GL_FALSE, 0); gl.glVertexAttribFormat(colorLoc, 4, GL_FLOAT, GL_FALSE, 0); gl.glVertexAttribBinding(positionLoc, bindingPoint1); gl.glVertexAttribBinding(colorLoc, bindingPoint2); GLU_EXPECT_NO_ERROR(gl.glGetError(), ""); break; } default: DE_ASSERT(DE_FALSE); } // draw gl.glEnableVertexAttribArray(positionLoc); gl.glEnableVertexAttribArray(colorLoc); gl.glDrawArrays(GL_TRIANGLES, 0, 6*GRID_SIZE*GRID_SIZE); gl.glFinish(); gl.glBindVertexArray(0); gl.glUseProgram(0); GLU_EXPECT_NO_ERROR(gl.glGetError(), "clean"); glu::readPixels(m_context.getRenderContext(), 0, 0, dst.getAccess()); } void MixedApiCase::createBuffers (void) { const tcu::Vec4 green = tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f); const tcu::Vec4 yellow = tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f); const glw::Functions& gl = m_context.getRenderContext().getFunctions(); std::vector<tcu::Vec4> vertexData (12 * GRID_SIZE * GRID_SIZE); for (int y = 0; y < GRID_SIZE; ++y) for (int x = 0; x < GRID_SIZE; ++x) { const tcu::Vec4& color = ((x + y) % 2 == 0) ? (green) : (yellow); vertexData[(y * GRID_SIZE + x) * 12 + 0] = tcu::Vec4(float(x+0) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+0) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f); vertexData[(y * GRID_SIZE + x) * 12 + 1] = color; vertexData[(y * GRID_SIZE + x) * 12 + 2] = tcu::Vec4(float(x+0) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+1) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f); vertexData[(y * GRID_SIZE + x) * 12 + 3] = color; vertexData[(y * GRID_SIZE + x) * 12 + 4] = tcu::Vec4(float(x+1) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+1) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f); vertexData[(y * GRID_SIZE + x) * 12 + 5] = color; vertexData[(y * GRID_SIZE + x) * 12 + 6] = tcu::Vec4(float(x+0) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+0) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f); vertexData[(y * GRID_SIZE + x) * 12 + 7] = color; vertexData[(y * GRID_SIZE + x) * 12 + 8] = tcu::Vec4(float(x+1) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+1) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f); vertexData[(y * GRID_SIZE + x) * 12 + 9] = color; vertexData[(y * GRID_SIZE + x) * 12 + 10] = tcu::Vec4(float(x+1) / float(GRID_SIZE) * 2.0f - 1.0f, float(y+0) / float(GRID_SIZE) * 2.0f - 1.0f, 0.0f, 1.0f); vertexData[(y * GRID_SIZE + x) * 12 + 11] = color; } // upload vertex data gl.genBuffers(1, &m_buffer); gl.bindBuffer(GL_ARRAY_BUFFER, m_buffer); gl.bufferData(GL_ARRAY_BUFFER, (int)(vertexData.size() * sizeof(tcu::Vec4)), vertexData[0].getPtr(), GL_STATIC_DRAW); GLU_EXPECT_NO_ERROR(gl.getError(), "upload data"); } void MixedApiCase::createShader (void) { m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources() << glu::VertexSource(s_positionColorShader) << glu::FragmentSource(s_colorFragmentShader)); m_testCtx.getLog() << *m_program; if (!m_program->isOk()) throw tcu::TestError("could not build shader"); } class DefaultVAOCase : public TestCase { public: enum CaseType { CASE_BIND_VERTEX_BUFFER, CASE_VERTEX_ATTRIB_FORMAT, CASE_VERTEX_ATTRIB_I_FORMAT, CASE_VERTEX_ATTRIB_BINDING, CASE_VERTEX_BINDING_DIVISOR, CASE_LAST }; DefaultVAOCase (Context& ctx, const char* name, const char* desc, CaseType caseType); ~DefaultVAOCase (void); IterateResult iterate (void); private: const CaseType m_caseType; }; DefaultVAOCase::DefaultVAOCase (Context& ctx, const char* name, const char* desc, CaseType caseType) : TestCase (ctx, name, desc) , m_caseType (caseType) { DE_ASSERT(caseType < CASE_LAST); } DefaultVAOCase::~DefaultVAOCase (void) { } DefaultVAOCase::IterateResult DefaultVAOCase::iterate (void) { glw::GLenum error = 0; glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog()); gl.enableLogging(true); switch (m_caseType) { case CASE_BIND_VERTEX_BUFFER: { glu::Buffer buffer(m_context.getRenderContext()); gl.glBindVertexBuffer(0, *buffer, 0, 0); break; } case CASE_VERTEX_ATTRIB_FORMAT: gl.glVertexAttribFormat(0, 4, GL_FLOAT, GL_FALSE, 0); break; case CASE_VERTEX_ATTRIB_I_FORMAT: gl.glVertexAttribIFormat(0, 4, GL_INT, 0); break; case CASE_VERTEX_ATTRIB_BINDING: gl.glVertexAttribBinding(0, 0); break; case CASE_VERTEX_BINDING_DIVISOR: gl.glVertexBindingDivisor(0, 1); break; default: DE_ASSERT(false); } error = gl.glGetError(); if (error != GL_INVALID_OPERATION) { m_testCtx.getLog() << tcu::TestLog::Message << "ERROR! Expected GL_INVALID_OPERATION, got " << glu::getErrorStr(error) << tcu::TestLog::EndMessage; m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid error"); } else m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); return STOP; } class BindToCreateCase : public TestCase { public: BindToCreateCase (Context& ctx, const char* name, const char* desc); ~BindToCreateCase (void); IterateResult iterate (void); }; BindToCreateCase::BindToCreateCase (Context& ctx, const char* name, const char* desc) : TestCase(ctx, name, desc) { } BindToCreateCase::~BindToCreateCase (void) { } BindToCreateCase::IterateResult BindToCreateCase::iterate (void) { glw::GLuint buffer = 0; glw::GLenum error; glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog()); glu::VertexArray vao (m_context.getRenderContext()); gl.enableLogging(true); gl.glGenBuffers(1, &buffer); gl.glDeleteBuffers(1, &buffer); GLU_EXPECT_NO_ERROR(gl.glGetError(), ""); gl.glBindVertexArray(*vao); gl.glBindVertexBuffer(0, buffer, 0, 0); error = gl.glGetError(); if (error != GL_INVALID_OPERATION) { m_testCtx.getLog() << tcu::TestLog::Message << "ERROR! Expected GL_INVALID_OPERATION, got " << glu::getErrorStr(error) << tcu::TestLog::EndMessage; m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid error"); } else m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); return STOP; } class NegativeApiCase : public TestCase { public: enum CaseType { CASE_LARGE_OFFSET, CASE_LARGE_STRIDE, CASE_NEGATIVE_STRIDE, CASE_NEGATIVE_OFFSET, CASE_INVALID_ATTR, CASE_INVALID_BINDING, CASE_LAST }; NegativeApiCase (Context& ctx, const char* name, const char* desc, CaseType caseType); ~NegativeApiCase (void); IterateResult iterate (void); private: const CaseType m_caseType; }; NegativeApiCase::NegativeApiCase (Context& ctx, const char* name, const char* desc, CaseType caseType) : TestCase (ctx, name, desc) , m_caseType (caseType) { } NegativeApiCase::~NegativeApiCase (void) { } NegativeApiCase::IterateResult NegativeApiCase::iterate (void) { glw::GLenum error; glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog()); glu::VertexArray vao (m_context.getRenderContext()); gl.enableLogging(true); gl.glBindVertexArray(*vao); switch (m_caseType) { case CASE_LARGE_OFFSET: { glw::GLint maxOffset = -1; glw::GLint largeOffset; gl.glGetIntegerv(GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET, &maxOffset); GLU_EXPECT_NO_ERROR(gl.glGetError(), ""); largeOffset = maxOffset + 1; // skip if maximum unsigned or signed values if (maxOffset == -1 || maxOffset == 0x7FFFFFFF) throw tcu::NotSupportedError("Implementation supports all offsets"); gl.glVertexAttribFormat(0, 4, GL_FLOAT, GL_FALSE, largeOffset); break; } case CASE_LARGE_STRIDE: { glu::Buffer buffer (m_context.getRenderContext()); glw::GLint maxStride = -1; glw::GLint largeStride; gl.glGetIntegerv(GL_MAX_VERTEX_ATTRIB_STRIDE, &maxStride); GLU_EXPECT_NO_ERROR(gl.glGetError(), ""); largeStride = maxStride + 1; // skip if maximum unsigned or signed values if (maxStride == -1 || maxStride == 0x7FFFFFFF) throw tcu::NotSupportedError("Implementation supports all strides"); gl.glBindVertexBuffer(0, *buffer, 0, largeStride); break; } case CASE_NEGATIVE_STRIDE: { glu::Buffer buffer(m_context.getRenderContext()); gl.glBindVertexBuffer(0, *buffer, 0, -20); break; } case CASE_NEGATIVE_OFFSET: { glu::Buffer buffer(m_context.getRenderContext()); gl.glBindVertexBuffer(0, *buffer, -20, 0); break; } case CASE_INVALID_ATTR: { glw::GLint maxIndex = -1; glw::GLint largeIndex; gl.glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxIndex); GLU_EXPECT_NO_ERROR(gl.glGetError(), ""); largeIndex = maxIndex + 1; // skip if maximum unsigned or signed values if (maxIndex == -1 || maxIndex == 0x7FFFFFFF) throw tcu::NotSupportedError("Implementation supports any attribute index"); gl.glVertexAttribBinding(largeIndex, 0); break; } case CASE_INVALID_BINDING: { glw::GLint maxBindings = -1; glw::GLint largeBinding; gl.glGetIntegerv(GL_MAX_VERTEX_ATTRIB_BINDINGS, &maxBindings); GLU_EXPECT_NO_ERROR(gl.glGetError(), ""); largeBinding = maxBindings + 1; // skip if maximum unsigned or signed values if (maxBindings == -1 || maxBindings == 0x7FFFFFFF) throw tcu::NotSupportedError("Implementation supports any binding"); gl.glVertexAttribBinding(0, largeBinding); break; } default: DE_ASSERT(false); } error = gl.glGetError(); if (error != GL_INVALID_VALUE) { m_testCtx.getLog() << tcu::TestLog::Message << "ERROR! Expected GL_INVALID_VALUE, got " << glu::getErrorStr(error) << tcu::TestLog::EndMessage; m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid error"); } else m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); return STOP; } } // anonymous VertexAttributeBindingTests::VertexAttributeBindingTests (Context& context) : TestCaseGroup(context, "vertex_attribute_binding", "Test vertex attribute binding") { } VertexAttributeBindingTests::~VertexAttributeBindingTests (void) { } void VertexAttributeBindingTests::init (void) { tcu::TestCaseGroup* const usageGroup = new tcu::TestCaseGroup(m_testCtx, "usage", "Test using binding points"); tcu::TestCaseGroup* const negativeGroup = new tcu::TestCaseGroup(m_testCtx, "negative", "Negative test"); addChild(usageGroup); addChild(negativeGroup); // .usage { tcu::TestCaseGroup* const singleGroup = new tcu::TestCaseGroup(m_testCtx, "single_binding", "Test using single binding point"); tcu::TestCaseGroup* const multipleGroup = new tcu::TestCaseGroup(m_testCtx, "multiple_bindings", "Test using multiple binding points"); tcu::TestCaseGroup* const mixedGroup = new tcu::TestCaseGroup(m_testCtx, "mixed_usage", "Test using binding point and non binding point api variants"); usageGroup->addChild(singleGroup); usageGroup->addChild(multipleGroup); usageGroup->addChild(mixedGroup); // single binding singleGroup->addChild(new SingleBindingCase(m_context, "elements_1", 0)); singleGroup->addChild(new SingleBindingCase(m_context, "elements_2", SingleBindingCase::FLAG_ATTRIBS_MULTIPLE_ELEMS)); singleGroup->addChild(new SingleBindingCase(m_context, "elements_2_share_elements", SingleBindingCase::FLAG_ATTRIBS_SHARED_ELEMS)); singleGroup->addChild(new SingleBindingCase(m_context, "offset_elements_1", SingleBindingCase::FLAG_BUF_ALIGNED_OFFSET | 0)); singleGroup->addChild(new SingleBindingCase(m_context, "offset_elements_2", SingleBindingCase::FLAG_BUF_ALIGNED_OFFSET | SingleBindingCase::FLAG_ATTRIBS_MULTIPLE_ELEMS)); singleGroup->addChild(new SingleBindingCase(m_context, "offset_elements_2_share_elements", SingleBindingCase::FLAG_BUF_ALIGNED_OFFSET | SingleBindingCase::FLAG_ATTRIBS_SHARED_ELEMS)); singleGroup->addChild(new SingleBindingCase(m_context, "unaligned_offset_elements_1_aligned_elements", SingleBindingCase::FLAG_BUF_UNALIGNED_OFFSET | SingleBindingCase::FLAG_ATTRIB_ALIGNED)); // !< total offset is aligned // multiple bindings multipleGroup->addChild(new MultipleBindingCase(m_context, "basic", 0)); multipleGroup->addChild(new MultipleBindingCase(m_context, "zero_stride", MultipleBindingCase::FLAG_ZERO_STRIDE)); multipleGroup->addChild(new MultipleBindingCase(m_context, "instanced", MultipleBindingCase::FLAG_INSTANCED)); multipleGroup->addChild(new MultipleBindingCase(m_context, "aliasing_buffer_zero_stride", MultipleBindingCase::FLAG_ALIASING_BUFFERS | MultipleBindingCase::FLAG_ZERO_STRIDE)); multipleGroup->addChild(new MultipleBindingCase(m_context, "aliasing_buffer_instanced", MultipleBindingCase::FLAG_ALIASING_BUFFERS | MultipleBindingCase::FLAG_INSTANCED)); // mixed cases mixedGroup->addChild(new MixedBindingCase(m_context, "mixed_attribs_basic", "Use different api for different attributes", MixedBindingCase::CASE_BASIC)); mixedGroup->addChild(new MixedBindingCase(m_context, "mixed_attribs_instanced_binding", "Use different api for different attributes", MixedBindingCase::CASE_INSTANCED_BINDING)); mixedGroup->addChild(new MixedBindingCase(m_context, "mixed_attribs_instanced_attrib", "Use different api for different attributes", MixedBindingCase::CASE_INSTANCED_ATTRIB)); mixedGroup->addChild(new MixedApiCase(m_context, "mixed_api_change_buffer", "change buffer with vertex_attrib_binding api", MixedApiCase::CASE_CHANGE_BUFFER)); mixedGroup->addChild(new MixedApiCase(m_context, "mixed_api_change_buffer_offset", "change buffer offset with vertex_attrib_binding api", MixedApiCase::CASE_CHANGE_BUFFER_OFFSET)); mixedGroup->addChild(new MixedApiCase(m_context, "mixed_api_change_buffer_stride", "change buffer stride with vertex_attrib_binding api", MixedApiCase::CASE_CHANGE_BUFFER_STRIDE)); mixedGroup->addChild(new MixedApiCase(m_context, "mixed_api_change_binding_point", "change binding point with vertex_attrib_binding api", MixedApiCase::CASE_CHANGE_BINDING_POINT)); } // negative { negativeGroup->addChild(new DefaultVAOCase(m_context, "default_vao_bind_vertex_buffer", "use with default vao", DefaultVAOCase::CASE_BIND_VERTEX_BUFFER)); negativeGroup->addChild(new DefaultVAOCase(m_context, "default_vao_vertex_attrib_format", "use with default vao", DefaultVAOCase::CASE_VERTEX_ATTRIB_FORMAT)); negativeGroup->addChild(new DefaultVAOCase(m_context, "default_vao_vertex_attrib_i_format", "use with default vao", DefaultVAOCase::CASE_VERTEX_ATTRIB_I_FORMAT)); negativeGroup->addChild(new DefaultVAOCase(m_context, "default_vao_vertex_attrib_binding", "use with default vao", DefaultVAOCase::CASE_VERTEX_ATTRIB_BINDING)); negativeGroup->addChild(new DefaultVAOCase(m_context, "default_vao_vertex_binding_divisor", "use with default vao", DefaultVAOCase::CASE_VERTEX_BINDING_DIVISOR)); negativeGroup->addChild(new BindToCreateCase(m_context, "bind_create_new_buffer", "bind not existing buffer")); negativeGroup->addChild(new NegativeApiCase(m_context, "vertex_attrib_format_large_offset", "large relative offset", NegativeApiCase::CASE_LARGE_OFFSET)); negativeGroup->addChild(new NegativeApiCase(m_context, "bind_vertex_buffer_large_stride", "large stride", NegativeApiCase::CASE_LARGE_STRIDE)); negativeGroup->addChild(new NegativeApiCase(m_context, "bind_vertex_buffer_negative_stride", "negative stride", NegativeApiCase::CASE_NEGATIVE_STRIDE)); negativeGroup->addChild(new NegativeApiCase(m_context, "bind_vertex_buffer_negative_offset", "negative offset", NegativeApiCase::CASE_NEGATIVE_OFFSET)); negativeGroup->addChild(new NegativeApiCase(m_context, "vertex_attrib_binding_invalid_attr", "bind invalid attr", NegativeApiCase::CASE_INVALID_ATTR)); negativeGroup->addChild(new NegativeApiCase(m_context, "vertex_attrib_binding_invalid_binding", "bind invalid binding", NegativeApiCase::CASE_INVALID_BINDING)); } } } // Functional } // gles31 } // deqp