| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES 3.0 Module |
| * ------------------------------------------------- |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Vertex array object tests |
| *//*--------------------------------------------------------------------*/ |
| #include "es3fVertexArrayObjectTests.hpp" |
| |
| #include "gluShaderProgram.hpp" |
| #include "gluPixelTransfer.hpp" |
| #include "gluRenderContext.hpp" |
| |
| #include "tcuTestLog.hpp" |
| #include "tcuImageCompare.hpp" |
| #include "tcuSurface.hpp" |
| #include "tcuRenderTarget.hpp" |
| |
| #include "deRandom.hpp" |
| #include "deString.h" |
| #include "deMemory.h" |
| |
| #include <vector> |
| #include <string> |
| #include <memory> |
| |
| #include "glw.h" |
| |
| using std::string; |
| using std::vector; |
| |
| namespace deqp |
| { |
| namespace gles3 |
| { |
| namespace Functional |
| { |
| |
| namespace |
| { |
| struct Attribute |
| { |
| Attribute(void); |
| GLboolean enabled; |
| GLint size; |
| GLint stride; |
| GLenum type; |
| GLboolean integer; |
| GLint divisor; |
| GLint offset; |
| GLboolean normalized; |
| |
| int bufferNdx; |
| }; |
| |
| struct VertexArrayState |
| { |
| VertexArrayState(void); |
| |
| vector<Attribute> attributes; |
| int elementArrayBuffer; |
| }; |
| |
| VertexArrayState::VertexArrayState(void) : elementArrayBuffer(-1) |
| { |
| } |
| |
| Attribute::Attribute(void) |
| : enabled(GL_FALSE) |
| , size(1) |
| , stride(0) |
| , type(GL_FLOAT) |
| , integer(GL_FALSE) |
| , divisor(0) |
| , offset(0) |
| , normalized(GL_FALSE) |
| , bufferNdx(0) |
| { |
| } |
| |
| struct BufferSpec |
| { |
| int count; |
| int size; |
| int componentCount; |
| int stride; |
| int offset; |
| |
| GLenum type; |
| |
| int intRangeMin; |
| int intRangeMax; |
| |
| float floatRangeMin; |
| float floatRangeMax; |
| }; |
| |
| struct Spec |
| { |
| Spec(void); |
| |
| int count; |
| int instances; |
| bool useDrawElements; |
| GLenum indexType; |
| int indexOffset; |
| int indexRangeMin; |
| int indexRangeMax; |
| int indexCount; |
| VertexArrayState state; |
| VertexArrayState vao; |
| vector<BufferSpec> buffers; |
| }; |
| |
| Spec::Spec(void) |
| : count(-1) |
| , instances(-1) |
| , useDrawElements(false) |
| , indexType(GL_NONE) |
| , indexOffset(-1) |
| , indexRangeMin(-1) |
| , indexRangeMax(-1) |
| , indexCount(-1) |
| { |
| } |
| |
| } // namespace |
| |
| class VertexArrayObjectTest : public TestCase |
| { |
| public: |
| VertexArrayObjectTest(Context &context, const Spec &spec, const char *name, const char *description); |
| ~VertexArrayObjectTest(void); |
| virtual void init(void); |
| virtual void deinit(void); |
| virtual IterateResult iterate(void); |
| |
| private: |
| Spec m_spec; |
| tcu::TestLog &m_log; |
| vector<GLuint> m_buffers; |
| glu::ShaderProgram *m_vaoProgram; |
| glu::ShaderProgram *m_stateProgram; |
| de::Random m_random; |
| uint8_t *m_indices; |
| |
| void logVertexArrayState(tcu::TestLog &log, const VertexArrayState &state, const std::string &msg); |
| uint8_t *createRandomBufferData(const BufferSpec &buffer); |
| uint8_t *generateIndices(void); |
| glu::ShaderProgram *createProgram(const VertexArrayState &state); |
| void setState(const VertexArrayState &state); |
| void render(tcu::Surface &vaoResult, tcu::Surface &defaultResult); |
| void makeDrawCall(const VertexArrayState &state); |
| void genReferences(tcu::Surface &vaoRef, tcu::Surface &defaultRef); |
| |
| VertexArrayObjectTest(const VertexArrayObjectTest &); |
| VertexArrayObjectTest &operator=(const VertexArrayObjectTest &); |
| }; |
| |
| VertexArrayObjectTest::VertexArrayObjectTest(Context &context, const Spec &spec, const char *name, |
| const char *description) |
| : TestCase(context, name, description) |
| , m_spec(spec) |
| , m_log(context.getTestContext().getLog()) |
| , m_vaoProgram(NULL) |
| , m_stateProgram(NULL) |
| , m_random(deStringHash(name)) |
| , m_indices(NULL) |
| { |
| // Makes zero to zero mapping for buffers |
| m_buffers.push_back(0); |
| } |
| |
| VertexArrayObjectTest::~VertexArrayObjectTest(void) |
| { |
| } |
| |
| void VertexArrayObjectTest::logVertexArrayState(tcu::TestLog &log, const VertexArrayState &state, |
| const std::string &msg) |
| { |
| std::stringstream message; |
| |
| message << msg << "\n"; |
| message << "GL_ELEMENT_ARRAY_BUFFER : " << state.elementArrayBuffer << "\n"; |
| |
| for (int attribNdx = 0; attribNdx < (int)state.attributes.size(); attribNdx++) |
| { |
| message << "attribute : " << attribNdx << "\n" |
| << "\tGL_VERTEX_ATTRIB_ARRAY_ENABLED : " |
| << (state.attributes[attribNdx].enabled ? "GL_TRUE" : "GL_FALSE") << "\n" |
| << "\tGL_VERTEX_ATTRIB_ARRAY_SIZE : " << state.attributes[attribNdx].size << "\n" |
| << "\tGL_VERTEX_ATTRIB_ARRAY_STRIDE : " << state.attributes[attribNdx].stride << "\n" |
| << "\tGL_VERTEX_ATTRIB_ARRAY_TYPE : " << state.attributes[attribNdx].type << "\n" |
| << "\tGL_VERTEX_ATTRIB_ARRAY_NORMALIZED : " |
| << (state.attributes[attribNdx].normalized ? "GL_TRUE" : "GL_FALSE") << "\n" |
| << "\tGL_VERTEX_ATTRIB_ARRAY_INTEGER : " |
| << (state.attributes[attribNdx].integer ? "GL_TRUE" : "GL_FALSE") << "\n" |
| << "\tGL_VERTEX_ATTRIB_ARRAY_DIVISOR : " << state.attributes[attribNdx].divisor << "\n" |
| << "\tGL_VERTEX_ATTRIB_ARRAY_POINTER : " << state.attributes[attribNdx].offset << "\n" |
| << "\tGL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING : " << m_buffers[state.attributes[attribNdx].bufferNdx] |
| << "\n"; |
| } |
| log << tcu::TestLog::Message << message.str() << tcu::TestLog::EndMessage; |
| } |
| |
| void VertexArrayObjectTest::init(void) |
| { |
| // \note [mika] Index 0 is reserved for 0 buffer |
| for (int bufferNdx = 0; bufferNdx < (int)m_spec.buffers.size(); bufferNdx++) |
| { |
| uint8_t *data = createRandomBufferData(m_spec.buffers[bufferNdx]); |
| |
| try |
| { |
| GLuint buffer; |
| GLU_CHECK_CALL(glGenBuffers(1, &buffer)); |
| m_buffers.push_back(buffer); |
| |
| GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, buffer)); |
| GLU_CHECK_CALL(glBufferData(GL_ARRAY_BUFFER, m_spec.buffers[bufferNdx].size, data, GL_DYNAMIC_DRAW)); |
| GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, 0)); |
| } |
| catch (...) |
| { |
| delete[] data; |
| throw; |
| } |
| |
| delete[] data; |
| } |
| |
| m_vaoProgram = createProgram(m_spec.vao); |
| m_log << tcu::TestLog::Message << "Program used with Vertex Array Object" << tcu::TestLog::EndMessage; |
| m_log << *m_vaoProgram; |
| m_stateProgram = createProgram(m_spec.state); |
| m_log << tcu::TestLog::Message << "Program used with Vertex Array State" << tcu::TestLog::EndMessage; |
| m_log << *m_stateProgram; |
| |
| if (!m_vaoProgram->isOk() || !m_stateProgram->isOk()) |
| TCU_FAIL("Failed to compile shaders"); |
| |
| if (m_spec.useDrawElements && (m_spec.vao.elementArrayBuffer == 0 || m_spec.state.elementArrayBuffer == 0)) |
| m_indices = generateIndices(); |
| } |
| |
| void VertexArrayObjectTest::deinit(void) |
| { |
| GLU_CHECK_CALL(glDeleteBuffers((GLsizei)m_buffers.size(), &(m_buffers[0]))); |
| m_buffers.clear(); |
| delete m_vaoProgram; |
| delete m_stateProgram; |
| delete[] m_indices; |
| } |
| |
| uint8_t *VertexArrayObjectTest::generateIndices(void) |
| { |
| int typeSize = 0; |
| switch (m_spec.indexType) |
| { |
| case GL_UNSIGNED_INT: |
| typeSize = sizeof(GLuint); |
| break; |
| case GL_UNSIGNED_SHORT: |
| typeSize = sizeof(GLushort); |
| break; |
| case GL_UNSIGNED_BYTE: |
| typeSize = sizeof(GLubyte); |
| break; |
| default: |
| DE_ASSERT(false); |
| } |
| |
| uint8_t *indices = new uint8_t[m_spec.indexCount * typeSize]; |
| |
| for (int i = 0; i < m_spec.indexCount; i++) |
| { |
| uint8_t *pos = indices + typeSize * i; |
| |
| switch (m_spec.indexType) |
| { |
| case GL_UNSIGNED_INT: |
| { |
| GLuint v = (GLuint)m_random.getInt(m_spec.indexRangeMin, m_spec.indexRangeMax); |
| deMemcpy(pos, &v, sizeof(v)); |
| break; |
| } |
| |
| case GL_UNSIGNED_SHORT: |
| { |
| GLushort v = (GLushort)m_random.getInt(m_spec.indexRangeMin, m_spec.indexRangeMax); |
| deMemcpy(pos, &v, sizeof(v)); |
| break; |
| } |
| |
| case GL_UNSIGNED_BYTE: |
| { |
| GLubyte v = (GLubyte)m_random.getInt(m_spec.indexRangeMin, m_spec.indexRangeMax); |
| deMemcpy(pos, &v, sizeof(v)); |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| return indices; |
| } |
| |
| uint8_t *VertexArrayObjectTest::createRandomBufferData(const BufferSpec &buffer) |
| { |
| uint8_t *data = new uint8_t[buffer.size]; |
| |
| int stride; |
| |
| if (buffer.stride != 0) |
| { |
| stride = buffer.stride; |
| } |
| else |
| { |
| switch (buffer.type) |
| { |
| case GL_FLOAT: |
| stride = buffer.componentCount * (int)sizeof(GLfloat); |
| break; |
| case GL_INT: |
| stride = buffer.componentCount * (int)sizeof(GLint); |
| break; |
| case GL_UNSIGNED_INT: |
| stride = buffer.componentCount * (int)sizeof(GLuint); |
| break; |
| case GL_SHORT: |
| stride = buffer.componentCount * (int)sizeof(GLshort); |
| break; |
| case GL_UNSIGNED_SHORT: |
| stride = buffer.componentCount * (int)sizeof(GLushort); |
| break; |
| case GL_BYTE: |
| stride = buffer.componentCount * (int)sizeof(GLbyte); |
| break; |
| case GL_UNSIGNED_BYTE: |
| stride = buffer.componentCount * (int)sizeof(GLubyte); |
| break; |
| |
| default: |
| stride = 0; |
| DE_ASSERT(false); |
| } |
| } |
| |
| uint8_t *itr = data; |
| |
| for (int pos = 0; pos < buffer.count; pos++) |
| { |
| uint8_t *componentItr = itr; |
| for (int componentNdx = 0; componentNdx < buffer.componentCount; componentNdx++) |
| { |
| switch (buffer.type) |
| { |
| case GL_FLOAT: |
| { |
| float v = buffer.floatRangeMin + (buffer.floatRangeMax - buffer.floatRangeMin) * m_random.getFloat(); |
| deMemcpy(componentItr, &v, sizeof(v)); |
| componentItr += sizeof(v); |
| break; |
| } |
| |
| case GL_INT: |
| { |
| GLint v = m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); |
| deMemcpy(componentItr, &v, sizeof(v)); |
| componentItr += sizeof(v); |
| break; |
| } |
| |
| case GL_UNSIGNED_INT: |
| { |
| GLuint v = m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); |
| deMemcpy(componentItr, &v, sizeof(v)); |
| componentItr += sizeof(v); |
| break; |
| } |
| |
| case GL_SHORT: |
| { |
| GLshort v = (GLshort)m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); |
| deMemcpy(componentItr, &v, sizeof(v)); |
| componentItr += sizeof(v); |
| break; |
| } |
| |
| case GL_UNSIGNED_SHORT: |
| { |
| GLushort v = (GLushort)m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); |
| deMemcpy(componentItr, &v, sizeof(v)); |
| componentItr += sizeof(v); |
| break; |
| } |
| |
| case GL_BYTE: |
| { |
| GLbyte v = (GLbyte)m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); |
| deMemcpy(componentItr, &v, sizeof(v)); |
| componentItr += sizeof(v); |
| break; |
| } |
| |
| case GL_UNSIGNED_BYTE: |
| { |
| GLubyte v = (GLubyte)m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); |
| deMemcpy(componentItr, &v, sizeof(v)); |
| componentItr += sizeof(v); |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| itr += stride; |
| } |
| |
| return data; |
| } |
| |
| glu::ShaderProgram *VertexArrayObjectTest::createProgram(const VertexArrayState &state) |
| { |
| std::stringstream vertexShaderStream; |
| std::stringstream value; |
| |
| vertexShaderStream << "#version 300 es\n"; |
| |
| for (int attribNdx = 0; attribNdx < (int)state.attributes.size(); attribNdx++) |
| { |
| if (state.attributes[attribNdx].integer) |
| vertexShaderStream << "layout(location = " << attribNdx << ") in mediump ivec4 a_attrib" << attribNdx |
| << ";\n"; |
| else |
| vertexShaderStream << "layout(location = " << attribNdx << ") in mediump vec4 a_attrib" << attribNdx |
| << ";\n"; |
| |
| if (state.attributes[attribNdx].integer) |
| { |
| float scale = 0.0f; |
| |
| switch (state.attributes[0].type) |
| { |
| case GL_SHORT: |
| scale = (1.0f / float((1u << 14) - 1u)); |
| break; |
| case GL_UNSIGNED_SHORT: |
| scale = (1.0f / float((1u << 15) - 1u)); |
| break; |
| case GL_INT: |
| scale = (1.0f / float((1u << 30) - 1u)); |
| break; |
| case GL_UNSIGNED_INT: |
| scale = (1.0f / float((1u << 31) - 1u)); |
| break; |
| case GL_BYTE: |
| scale = (1.0f / float((1u << 6) - 1u)); |
| break; |
| case GL_UNSIGNED_BYTE: |
| scale = (1.0f / float((1u << 7) - 1u)); |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| } |
| value << (attribNdx != 0 ? " + " : "") << scale << " * vec4(a_attrib" << attribNdx << ")"; |
| } |
| else if (state.attributes[attribNdx].type != GL_FLOAT && !state.attributes[attribNdx].normalized) |
| { |
| float scale = 0.0f; |
| |
| switch (state.attributes[0].type) |
| { |
| case GL_SHORT: |
| scale = (0.5f / float((1u << 14) - 1u)); |
| break; |
| case GL_UNSIGNED_SHORT: |
| scale = (0.5f / float((1u << 15) - 1u)); |
| break; |
| case GL_INT: |
| scale = (0.5f / float((1u << 30) - 1u)); |
| break; |
| case GL_UNSIGNED_INT: |
| scale = (0.5f / float((1u << 31) - 1u)); |
| break; |
| case GL_BYTE: |
| scale = (0.5f / float((1u << 6) - 1u)); |
| break; |
| case GL_UNSIGNED_BYTE: |
| scale = (0.5f / float((1u << 7) - 1u)); |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| } |
| value << (attribNdx != 0 ? " + " : "") << scale << " * a_attrib" << attribNdx; |
| } |
| else |
| value << (attribNdx != 0 ? " + " : "") << "a_attrib" << attribNdx; |
| } |
| |
| vertexShaderStream << "out mediump vec4 v_value;\n" |
| << "void main (void)\n" |
| << "{\n" |
| << "\tv_value = " << value.str() << ";\n"; |
| |
| if (state.attributes[0].integer) |
| { |
| float scale = 0.0f; |
| |
| switch (state.attributes[0].type) |
| { |
| case GL_SHORT: |
| scale = (1.0f / float((1u << 14) - 1u)); |
| break; |
| case GL_UNSIGNED_SHORT: |
| scale = (1.0f / float((1u << 15) - 1u)); |
| break; |
| case GL_INT: |
| scale = (1.0f / float((1u << 30) - 1u)); |
| break; |
| case GL_UNSIGNED_INT: |
| scale = (1.0f / float((1u << 31) - 1u)); |
| break; |
| case GL_BYTE: |
| scale = (1.0f / float((1u << 6) - 1u)); |
| break; |
| case GL_UNSIGNED_BYTE: |
| scale = (1.0f / float((1u << 7) - 1u)); |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| } |
| |
| vertexShaderStream << "\tgl_Position = vec4(" << scale << " * " |
| << "vec3(a_attrib0.xyz), 1.0);\n" |
| << "}"; |
| } |
| else |
| { |
| if (state.attributes[0].normalized || state.attributes[0].type == GL_FLOAT) |
| { |
| vertexShaderStream << "\tgl_Position = vec4(a_attrib0.xyz, 1.0);\n" |
| << "}"; |
| } |
| else |
| { |
| float scale = 0.0f; |
| |
| switch (state.attributes[0].type) |
| { |
| case GL_SHORT: |
| scale = (1.0f / float((1u << 14) - 1u)); |
| break; |
| case GL_UNSIGNED_SHORT: |
| scale = (1.0f / float((1u << 15) - 1u)); |
| break; |
| case GL_INT: |
| scale = (1.0f / float((1u << 30) - 1u)); |
| break; |
| case GL_UNSIGNED_INT: |
| scale = (1.0f / float((1u << 31) - 1u)); |
| break; |
| case GL_BYTE: |
| scale = (1.0f / float((1u << 6) - 1u)); |
| break; |
| case GL_UNSIGNED_BYTE: |
| scale = (1.0f / float((1u << 7) - 1u)); |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| } |
| |
| scale *= 0.5f; |
| |
| vertexShaderStream << "\tgl_Position = vec4(" << scale << " * " |
| << "a_attrib0.xyz, 1.0);\n" |
| << "}"; |
| } |
| } |
| |
| const char *fragmentShader = "#version 300 es\n" |
| "in mediump vec4 v_value;\n" |
| "layout(location = 0) out mediump vec4 fragColor;\n" |
| "void main (void)\n" |
| "{\n" |
| "\tfragColor = vec4(v_value.xyz, 1.0);\n" |
| "}"; |
| |
| return new glu::ShaderProgram(m_context.getRenderContext(), |
| glu::makeVtxFragSources(vertexShaderStream.str(), fragmentShader)); |
| } |
| |
| void VertexArrayObjectTest::setState(const VertexArrayState &state) |
| { |
| GLU_CHECK_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_buffers[state.elementArrayBuffer])); |
| |
| for (int attribNdx = 0; attribNdx < (int)state.attributes.size(); attribNdx++) |
| { |
| GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, m_buffers[state.attributes[attribNdx].bufferNdx])); |
| if (state.attributes[attribNdx].enabled) |
| GLU_CHECK_CALL(glEnableVertexAttribArray(attribNdx)); |
| else |
| GLU_CHECK_CALL(glDisableVertexAttribArray(attribNdx)); |
| |
| if (state.attributes[attribNdx].integer) |
| GLU_CHECK_CALL(glVertexAttribIPointer(attribNdx, state.attributes[attribNdx].size, |
| state.attributes[attribNdx].type, state.attributes[attribNdx].stride, |
| (const GLvoid *)((GLintptr)state.attributes[attribNdx].offset))); |
| else |
| GLU_CHECK_CALL( |
| glVertexAttribPointer(attribNdx, state.attributes[attribNdx].size, state.attributes[attribNdx].type, |
| state.attributes[attribNdx].normalized, state.attributes[attribNdx].stride, |
| (const GLvoid *)((GLintptr)state.attributes[attribNdx].offset))); |
| |
| GLU_CHECK_CALL(glVertexAttribDivisor(attribNdx, state.attributes[attribNdx].divisor)); |
| } |
| } |
| |
| void VertexArrayObjectTest::makeDrawCall(const VertexArrayState &state) |
| { |
| GLU_CHECK_CALL(glClearColor(0.7f, 0.7f, 0.7f, 1.0f)); |
| GLU_CHECK_CALL(glClear(GL_COLOR_BUFFER_BIT)); |
| |
| for (int attribNdx = 0; attribNdx < (int)state.attributes.size(); attribNdx++) |
| { |
| if (state.attributes[attribNdx].integer) |
| glVertexAttribI4i(attribNdx, 0, 0, 0, 1); |
| else |
| glVertexAttrib4f(attribNdx, 0.0f, 0.0f, 0.0f, 1.0f); |
| } |
| |
| if (m_spec.useDrawElements) |
| { |
| if (state.elementArrayBuffer == 0) |
| { |
| if (m_spec.instances == 0) |
| GLU_CHECK_CALL(glDrawElements(GL_TRIANGLES, m_spec.count, m_spec.indexType, m_indices)); |
| else |
| GLU_CHECK_CALL( |
| glDrawElementsInstanced(GL_TRIANGLES, m_spec.count, m_spec.indexType, m_indices, m_spec.instances)); |
| } |
| else |
| { |
| if (m_spec.instances == 0) |
| GLU_CHECK_CALL(glDrawElements(GL_TRIANGLES, m_spec.count, m_spec.indexType, |
| (GLvoid *)((GLintptr)m_spec.indexOffset))); |
| else |
| GLU_CHECK_CALL(glDrawElementsInstanced(GL_TRIANGLES, m_spec.count, m_spec.indexType, |
| (GLvoid *)((GLintptr)m_spec.indexOffset), m_spec.instances)); |
| } |
| } |
| else |
| { |
| if (m_spec.instances == 0) |
| GLU_CHECK_CALL(glDrawArrays(GL_TRIANGLES, 0, m_spec.count)); |
| else |
| GLU_CHECK_CALL(glDrawArraysInstanced(GL_TRIANGLES, 0, m_spec.count, m_spec.instances)); |
| } |
| } |
| |
| void VertexArrayObjectTest::render(tcu::Surface &vaoResult, tcu::Surface &defaultResult) |
| { |
| GLuint vao = 0; |
| |
| GLU_CHECK_CALL(glGenVertexArrays(1, &vao)); |
| GLU_CHECK_CALL(glBindVertexArray(vao)); |
| setState(m_spec.vao); |
| GLU_CHECK_CALL(glBindVertexArray(0)); |
| |
| setState(m_spec.state); |
| |
| GLU_CHECK_CALL(glBindVertexArray(vao)); |
| GLU_CHECK_CALL(glUseProgram(m_vaoProgram->getProgram())); |
| makeDrawCall(m_spec.vao); |
| glu::readPixels(m_context.getRenderContext(), 0, 0, vaoResult.getAccess()); |
| setState(m_spec.vao); |
| GLU_CHECK_CALL(glBindVertexArray(0)); |
| |
| GLU_CHECK_CALL(glUseProgram(m_stateProgram->getProgram())); |
| makeDrawCall(m_spec.state); |
| glu::readPixels(m_context.getRenderContext(), 0, 0, defaultResult.getAccess()); |
| } |
| |
| void VertexArrayObjectTest::genReferences(tcu::Surface &vaoRef, tcu::Surface &defaultRef) |
| { |
| setState(m_spec.vao); |
| GLU_CHECK_CALL(glUseProgram(m_vaoProgram->getProgram())); |
| makeDrawCall(m_spec.vao); |
| glu::readPixels(m_context.getRenderContext(), 0, 0, vaoRef.getAccess()); |
| |
| setState(m_spec.state); |
| GLU_CHECK_CALL(glUseProgram(m_stateProgram->getProgram())); |
| makeDrawCall(m_spec.state); |
| glu::readPixels(m_context.getRenderContext(), 0, 0, defaultRef.getAccess()); |
| } |
| |
| TestCase::IterateResult VertexArrayObjectTest::iterate(void) |
| { |
| tcu::Surface vaoReference(m_context.getRenderContext().getRenderTarget().getWidth(), |
| m_context.getRenderContext().getRenderTarget().getHeight()); |
| tcu::Surface stateReference(m_context.getRenderContext().getRenderTarget().getWidth(), |
| m_context.getRenderContext().getRenderTarget().getHeight()); |
| |
| tcu::Surface vaoResult(m_context.getRenderContext().getRenderTarget().getWidth(), |
| m_context.getRenderContext().getRenderTarget().getHeight()); |
| tcu::Surface stateResult(m_context.getRenderContext().getRenderTarget().getWidth(), |
| m_context.getRenderContext().getRenderTarget().getHeight()); |
| |
| bool isOk; |
| |
| logVertexArrayState(m_log, m_spec.vao, "Vertex Array Object State"); |
| logVertexArrayState(m_log, m_spec.state, "OpenGL Vertex Array State"); |
| genReferences(stateReference, vaoReference); |
| render(stateResult, vaoResult); |
| |
| isOk = tcu::pixelThresholdCompare(m_log, "Results", "Comparison result from rendering with Vertex Array State", |
| stateReference, stateResult, tcu::RGBA(0, 0, 0, 0), tcu::COMPARE_LOG_RESULT); |
| isOk = isOk && |
| tcu::pixelThresholdCompare(m_log, "Results", "Comparison result from rendering with Vertex Array Object", |
| vaoReference, vaoResult, tcu::RGBA(0, 0, 0, 0), tcu::COMPARE_LOG_RESULT); |
| |
| if (isOk) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| return STOP; |
| } |
| } |
| |
| class MultiVertexArrayObjectTest : public TestCase |
| { |
| public: |
| MultiVertexArrayObjectTest(Context &context, const char *name, const char *description); |
| ~MultiVertexArrayObjectTest(void); |
| virtual void init(void); |
| virtual void deinit(void); |
| virtual IterateResult iterate(void); |
| |
| private: |
| Spec m_spec; |
| tcu::TestLog &m_log; |
| vector<GLuint> m_buffers; |
| glu::ShaderProgram *m_vaoProgram; |
| glu::ShaderProgram *m_stateProgram; |
| de::Random m_random; |
| uint8_t *m_indices; |
| |
| void logVertexArrayState(tcu::TestLog &log, const VertexArrayState &state, const std::string &msg); |
| uint8_t *createRandomBufferData(const BufferSpec &buffer); |
| uint8_t *generateIndices(void); |
| glu::ShaderProgram *createProgram(const VertexArrayState &state); |
| void setState(const VertexArrayState &state); |
| void render(tcu::Surface &vaoResult, tcu::Surface &defaultResult); |
| void makeDrawCall(const VertexArrayState &state); |
| void genReferences(tcu::Surface &vaoRef, tcu::Surface &defaultRef); |
| |
| MultiVertexArrayObjectTest(const MultiVertexArrayObjectTest &); |
| MultiVertexArrayObjectTest &operator=(const MultiVertexArrayObjectTest &); |
| }; |
| |
| MultiVertexArrayObjectTest::MultiVertexArrayObjectTest(Context &context, const char *name, const char *description) |
| : TestCase(context, name, description) |
| , m_log(context.getTestContext().getLog()) |
| , m_vaoProgram(NULL) |
| , m_stateProgram(NULL) |
| , m_random(deStringHash(name)) |
| , m_indices(NULL) |
| { |
| // Makes zero to zero mapping for buffers |
| m_buffers.push_back(0); |
| } |
| |
| MultiVertexArrayObjectTest::~MultiVertexArrayObjectTest(void) |
| { |
| } |
| |
| void MultiVertexArrayObjectTest::logVertexArrayState(tcu::TestLog &log, const VertexArrayState &state, |
| const std::string &msg) |
| { |
| std::stringstream message; |
| |
| message << msg << "\n"; |
| message << "GL_ELEMENT_ARRAY_BUFFER : " << state.elementArrayBuffer << "\n"; |
| |
| for (int attribNdx = 0; attribNdx < (int)state.attributes.size(); attribNdx++) |
| { |
| message << "attribute : " << attribNdx << "\n" |
| << "\tGL_VERTEX_ATTRIB_ARRAY_ENABLED : " |
| << (state.attributes[attribNdx].enabled ? "GL_TRUE" : "GL_FALSE") << "\n" |
| << "\tGL_VERTEX_ATTRIB_ARRAY_SIZE : " << state.attributes[attribNdx].size << "\n" |
| << "\tGL_VERTEX_ATTRIB_ARRAY_STRIDE : " << state.attributes[attribNdx].stride << "\n" |
| << "\tGL_VERTEX_ATTRIB_ARRAY_TYPE : " << state.attributes[attribNdx].type << "\n" |
| << "\tGL_VERTEX_ATTRIB_ARRAY_NORMALIZED : " |
| << (state.attributes[attribNdx].normalized ? "GL_TRUE" : "GL_FALSE") << "\n" |
| << "\tGL_VERTEX_ATTRIB_ARRAY_INTEGER : " |
| << (state.attributes[attribNdx].integer ? "GL_TRUE" : "GL_FALSE") << "\n" |
| << "\tGL_VERTEX_ATTRIB_ARRAY_DIVISOR : " << state.attributes[attribNdx].divisor << "\n" |
| << "\tGL_VERTEX_ATTRIB_ARRAY_POINTER : " << state.attributes[attribNdx].offset << "\n" |
| << "\t GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING : " << m_buffers[state.attributes[attribNdx].bufferNdx] |
| << "\n"; |
| } |
| log << tcu::TestLog::Message << message.str() << tcu::TestLog::EndMessage; |
| } |
| |
| void MultiVertexArrayObjectTest::init(void) |
| { |
| GLint attribCount; |
| |
| GLU_CHECK_CALL(glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &attribCount)); |
| |
| m_spec.useDrawElements = false; |
| m_spec.instances = 0; |
| m_spec.count = 24; |
| m_spec.indexOffset = 0; |
| m_spec.indexRangeMin = 0; |
| m_spec.indexRangeMax = 0; |
| m_spec.indexType = GL_NONE; |
| m_spec.indexCount = 0; |
| m_spec.vao.elementArrayBuffer = 0; |
| m_spec.state.elementArrayBuffer = 0; |
| |
| for (int attribNdx = 0; attribNdx < attribCount; attribNdx++) |
| { |
| BufferSpec shortCoordBuffer48 = {48, 2 * 384, 4, 0, 0, GL_SHORT, -32768, 32768, 0.0f, 0.0f}; |
| m_spec.buffers.push_back(shortCoordBuffer48); |
| |
| m_spec.state.attributes.push_back(Attribute()); |
| m_spec.state.attributes[attribNdx].enabled = (m_random.getInt(0, 4) == 0) ? GL_FALSE : GL_TRUE; |
| m_spec.state.attributes[attribNdx].size = m_random.getInt(2, 4); |
| m_spec.state.attributes[attribNdx].stride = 2 * m_random.getInt(1, 3); |
| m_spec.state.attributes[attribNdx].type = GL_SHORT; |
| m_spec.state.attributes[attribNdx].integer = m_random.getBool(); |
| m_spec.state.attributes[attribNdx].divisor = m_random.getInt(0, 1); |
| m_spec.state.attributes[attribNdx].offset = 2 * m_random.getInt(0, 2); |
| m_spec.state.attributes[attribNdx].normalized = m_random.getBool(); |
| m_spec.state.attributes[attribNdx].bufferNdx = attribNdx + 1; |
| |
| if (attribNdx == 0) |
| { |
| m_spec.state.attributes[attribNdx].divisor = 0; |
| m_spec.state.attributes[attribNdx].enabled = GL_TRUE; |
| m_spec.state.attributes[attribNdx].size = 2; |
| } |
| |
| m_spec.vao.attributes.push_back(Attribute()); |
| m_spec.vao.attributes[attribNdx].enabled = (m_random.getInt(0, 4) == 0) ? GL_FALSE : GL_TRUE; |
| m_spec.vao.attributes[attribNdx].size = m_random.getInt(2, 4); |
| m_spec.vao.attributes[attribNdx].stride = 2 * m_random.getInt(1, 3); |
| m_spec.vao.attributes[attribNdx].type = GL_SHORT; |
| m_spec.vao.attributes[attribNdx].integer = m_random.getBool(); |
| m_spec.vao.attributes[attribNdx].divisor = m_random.getInt(0, 1); |
| m_spec.vao.attributes[attribNdx].offset = 2 * m_random.getInt(0, 2); |
| m_spec.vao.attributes[attribNdx].normalized = m_random.getBool(); |
| m_spec.vao.attributes[attribNdx].bufferNdx = attribCount - attribNdx; |
| |
| if (attribNdx == 0) |
| { |
| m_spec.vao.attributes[attribNdx].divisor = 0; |
| m_spec.vao.attributes[attribNdx].enabled = GL_TRUE; |
| m_spec.vao.attributes[attribNdx].size = 2; |
| } |
| } |
| |
| // \note [mika] Index 0 is reserved for 0 buffer |
| for (int bufferNdx = 0; bufferNdx < (int)m_spec.buffers.size(); bufferNdx++) |
| { |
| uint8_t *data = createRandomBufferData(m_spec.buffers[bufferNdx]); |
| |
| try |
| { |
| GLuint buffer; |
| GLU_CHECK_CALL(glGenBuffers(1, &buffer)); |
| m_buffers.push_back(buffer); |
| |
| GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, buffer)); |
| GLU_CHECK_CALL(glBufferData(GL_ARRAY_BUFFER, m_spec.buffers[bufferNdx].size, data, GL_DYNAMIC_DRAW)); |
| GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, 0)); |
| } |
| catch (...) |
| { |
| delete[] data; |
| throw; |
| } |
| |
| delete[] data; |
| } |
| |
| m_vaoProgram = createProgram(m_spec.vao); |
| m_log << tcu::TestLog::Message << "Program used with Vertex Array Object" << tcu::TestLog::EndMessage; |
| m_log << *m_vaoProgram; |
| m_stateProgram = createProgram(m_spec.state); |
| m_log << tcu::TestLog::Message << "Program used with Vertex Array State" << tcu::TestLog::EndMessage; |
| m_log << *m_stateProgram; |
| |
| if (!m_vaoProgram->isOk() || !m_stateProgram->isOk()) |
| TCU_FAIL("Failed to compile shaders"); |
| |
| if (m_spec.useDrawElements && (m_spec.vao.elementArrayBuffer == 0 || m_spec.state.elementArrayBuffer == 0)) |
| m_indices = generateIndices(); |
| } |
| |
| void MultiVertexArrayObjectTest::deinit(void) |
| { |
| GLU_CHECK_CALL(glDeleteBuffers((GLsizei)m_buffers.size(), &(m_buffers[0]))); |
| m_buffers.clear(); |
| delete m_vaoProgram; |
| delete m_stateProgram; |
| delete[] m_indices; |
| } |
| |
| uint8_t *MultiVertexArrayObjectTest::generateIndices(void) |
| { |
| int typeSize = 0; |
| switch (m_spec.indexType) |
| { |
| case GL_UNSIGNED_INT: |
| typeSize = sizeof(GLuint); |
| break; |
| case GL_UNSIGNED_SHORT: |
| typeSize = sizeof(GLushort); |
| break; |
| case GL_UNSIGNED_BYTE: |
| typeSize = sizeof(GLubyte); |
| break; |
| default: |
| DE_ASSERT(false); |
| } |
| |
| uint8_t *indices = new uint8_t[m_spec.indexCount * typeSize]; |
| |
| for (int i = 0; i < m_spec.indexCount; i++) |
| { |
| uint8_t *pos = indices + typeSize * i; |
| |
| switch (m_spec.indexType) |
| { |
| case GL_UNSIGNED_INT: |
| { |
| GLuint v = (GLuint)m_random.getInt(m_spec.indexRangeMin, m_spec.indexRangeMax); |
| deMemcpy(pos, &v, sizeof(v)); |
| break; |
| } |
| |
| case GL_UNSIGNED_SHORT: |
| { |
| GLushort v = (GLushort)m_random.getInt(m_spec.indexRangeMin, m_spec.indexRangeMax); |
| deMemcpy(pos, &v, sizeof(v)); |
| break; |
| } |
| |
| case GL_UNSIGNED_BYTE: |
| { |
| GLubyte v = (GLubyte)m_random.getInt(m_spec.indexRangeMin, m_spec.indexRangeMax); |
| deMemcpy(pos, &v, sizeof(v)); |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| return indices; |
| } |
| |
| uint8_t *MultiVertexArrayObjectTest::createRandomBufferData(const BufferSpec &buffer) |
| { |
| uint8_t *data = new uint8_t[buffer.size]; |
| |
| int stride; |
| |
| if (buffer.stride != 0) |
| { |
| stride = buffer.stride; |
| } |
| else |
| { |
| switch (buffer.type) |
| { |
| case GL_FLOAT: |
| stride = buffer.componentCount * (int)sizeof(GLfloat); |
| break; |
| case GL_INT: |
| stride = buffer.componentCount * (int)sizeof(GLint); |
| break; |
| case GL_UNSIGNED_INT: |
| stride = buffer.componentCount * (int)sizeof(GLuint); |
| break; |
| case GL_SHORT: |
| stride = buffer.componentCount * (int)sizeof(GLshort); |
| break; |
| case GL_UNSIGNED_SHORT: |
| stride = buffer.componentCount * (int)sizeof(GLushort); |
| break; |
| case GL_BYTE: |
| stride = buffer.componentCount * (int)sizeof(GLbyte); |
| break; |
| case GL_UNSIGNED_BYTE: |
| stride = buffer.componentCount * (int)sizeof(GLubyte); |
| break; |
| |
| default: |
| stride = 0; |
| DE_ASSERT(false); |
| } |
| } |
| |
| uint8_t *itr = data; |
| |
| for (int pos = 0; pos < buffer.count; pos++) |
| { |
| uint8_t *componentItr = itr; |
| for (int componentNdx = 0; componentNdx < buffer.componentCount; componentNdx++) |
| { |
| switch (buffer.type) |
| { |
| case GL_FLOAT: |
| { |
| float v = buffer.floatRangeMin + (buffer.floatRangeMax - buffer.floatRangeMin) * m_random.getFloat(); |
| deMemcpy(componentItr, &v, sizeof(v)); |
| componentItr += sizeof(v); |
| break; |
| } |
| |
| case GL_INT: |
| { |
| GLint v = m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); |
| deMemcpy(componentItr, &v, sizeof(v)); |
| componentItr += sizeof(v); |
| break; |
| } |
| |
| case GL_UNSIGNED_INT: |
| { |
| GLuint v = (GLuint)m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); |
| deMemcpy(componentItr, &v, sizeof(v)); |
| componentItr += sizeof(v); |
| break; |
| } |
| |
| case GL_SHORT: |
| { |
| GLshort v = (GLshort)m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); |
| deMemcpy(componentItr, &v, sizeof(v)); |
| componentItr += sizeof(v); |
| break; |
| } |
| |
| case GL_UNSIGNED_SHORT: |
| { |
| GLushort v = (GLushort)m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); |
| deMemcpy(componentItr, &v, sizeof(v)); |
| componentItr += sizeof(v); |
| break; |
| } |
| |
| case GL_BYTE: |
| { |
| GLbyte v = (GLbyte)m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); |
| deMemcpy(componentItr, &v, sizeof(v)); |
| componentItr += sizeof(v); |
| break; |
| } |
| |
| case GL_UNSIGNED_BYTE: |
| { |
| GLubyte v = (GLubyte)m_random.getInt(buffer.intRangeMin, buffer.intRangeMax); |
| deMemcpy(componentItr, &v, sizeof(v)); |
| componentItr += sizeof(v); |
| break; |
| } |
| |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| itr += stride; |
| } |
| |
| return data; |
| } |
| |
| glu::ShaderProgram *MultiVertexArrayObjectTest::createProgram(const VertexArrayState &state) |
| { |
| std::stringstream vertexShaderStream; |
| std::stringstream value; |
| |
| vertexShaderStream << "#version 300 es\n"; |
| |
| for (int attribNdx = 0; attribNdx < (int)state.attributes.size(); attribNdx++) |
| { |
| if (state.attributes[attribNdx].integer) |
| vertexShaderStream << "layout(location = " << attribNdx << ") in mediump ivec4 a_attrib" << attribNdx |
| << ";\n"; |
| else |
| vertexShaderStream << "layout(location = " << attribNdx << ") in mediump vec4 a_attrib" << attribNdx |
| << ";\n"; |
| |
| if (state.attributes[attribNdx].integer) |
| { |
| float scale = 0.0f; |
| |
| switch (state.attributes[0].type) |
| { |
| case GL_SHORT: |
| scale = (1.0f / float((1u << 14) - 1u)); |
| break; |
| case GL_UNSIGNED_SHORT: |
| scale = (1.0f / float((1u << 15) - 1u)); |
| break; |
| case GL_INT: |
| scale = (1.0f / float((1u << 30) - 1u)); |
| break; |
| case GL_UNSIGNED_INT: |
| scale = (1.0f / float((1u << 31) - 1u)); |
| break; |
| case GL_BYTE: |
| scale = (1.0f / float((1u << 6) - 1u)); |
| break; |
| case GL_UNSIGNED_BYTE: |
| scale = (1.0f / float((1u << 7) - 1u)); |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| } |
| value << (attribNdx != 0 ? " + " : "") << scale << " * vec4(a_attrib" << attribNdx << ")"; |
| } |
| else if (state.attributes[attribNdx].type != GL_FLOAT && !state.attributes[attribNdx].normalized) |
| { |
| float scale = 0.0f; |
| |
| switch (state.attributes[0].type) |
| { |
| case GL_SHORT: |
| scale = (0.5f / float((1u << 14) - 1u)); |
| break; |
| case GL_UNSIGNED_SHORT: |
| scale = (0.5f / float((1u << 15) - 1u)); |
| break; |
| case GL_INT: |
| scale = (0.5f / float((1u << 30) - 1u)); |
| break; |
| case GL_UNSIGNED_INT: |
| scale = (0.5f / float((1u << 31) - 1u)); |
| break; |
| case GL_BYTE: |
| scale = (0.5f / float((1u << 6) - 1u)); |
| break; |
| case GL_UNSIGNED_BYTE: |
| scale = (0.5f / float((1u << 7) - 1u)); |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| } |
| value << (attribNdx != 0 ? " + " : "") << scale << " * a_attrib" << attribNdx; |
| } |
| else |
| value << (attribNdx != 0 ? " + " : "") << "a_attrib" << attribNdx; |
| } |
| |
| vertexShaderStream << "out mediump vec4 v_value;\n" |
| << "void main (void)\n" |
| << "{\n" |
| << "\tv_value = " << value.str() << ";\n"; |
| |
| if (state.attributes[0].integer) |
| { |
| float scale = 0.0f; |
| |
| switch (state.attributes[0].type) |
| { |
| case GL_SHORT: |
| scale = (1.0f / float((1u << 14) - 1u)); |
| break; |
| case GL_UNSIGNED_SHORT: |
| scale = (1.0f / float((1u << 15) - 1u)); |
| break; |
| case GL_INT: |
| scale = (1.0f / float((1u << 30) - 1u)); |
| break; |
| case GL_UNSIGNED_INT: |
| scale = (1.0f / float((1u << 31) - 1u)); |
| break; |
| case GL_BYTE: |
| scale = (1.0f / float((1u << 6) - 1u)); |
| break; |
| case GL_UNSIGNED_BYTE: |
| scale = (1.0f / float((1u << 7) - 1u)); |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| } |
| |
| vertexShaderStream << "\tgl_Position = vec4(" << scale << " * " |
| << "a_attrib0.xyz, 1.0);\n" |
| << "}"; |
| } |
| else |
| { |
| if (state.attributes[0].normalized || state.attributes[0].type == GL_FLOAT) |
| { |
| vertexShaderStream << "\tgl_Position = vec4(a_attrib0.xyz, 1.0);\n" |
| << "}"; |
| } |
| else |
| { |
| float scale = 0.0f; |
| |
| switch (state.attributes[0].type) |
| { |
| case GL_SHORT: |
| scale = (1.0f / float((1u << 14) - 1u)); |
| break; |
| case GL_UNSIGNED_SHORT: |
| scale = (1.0f / float((1u << 15) - 1u)); |
| break; |
| case GL_INT: |
| scale = (1.0f / float((1u << 30) - 1u)); |
| break; |
| case GL_UNSIGNED_INT: |
| scale = (1.0f / float((1u << 31) - 1u)); |
| break; |
| case GL_BYTE: |
| scale = (1.0f / float((1u << 6) - 1u)); |
| break; |
| case GL_UNSIGNED_BYTE: |
| scale = (1.0f / float((1u << 7) - 1u)); |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| } |
| |
| scale *= 0.5f; |
| |
| vertexShaderStream << "\tgl_Position = vec4(" << scale << " * " |
| << "vec3(a_attrib0.xyz), 1.0);\n" |
| << "}"; |
| } |
| } |
| |
| const char *fragmentShader = "#version 300 es\n" |
| "in mediump vec4 v_value;\n" |
| "layout(location = 0) out mediump vec4 fragColor;\n" |
| "void main (void)\n" |
| "{\n" |
| "\tfragColor = vec4(v_value.xyz, 1.0);\n" |
| "}"; |
| |
| return new glu::ShaderProgram(m_context.getRenderContext(), |
| glu::makeVtxFragSources(vertexShaderStream.str(), fragmentShader)); |
| } |
| |
| void MultiVertexArrayObjectTest::setState(const VertexArrayState &state) |
| { |
| GLU_CHECK_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_buffers[state.elementArrayBuffer])); |
| |
| for (int attribNdx = 0; attribNdx < (int)state.attributes.size(); attribNdx++) |
| { |
| GLU_CHECK_CALL(glBindBuffer(GL_ARRAY_BUFFER, m_buffers[state.attributes[attribNdx].bufferNdx])); |
| if (state.attributes[attribNdx].enabled) |
| GLU_CHECK_CALL(glEnableVertexAttribArray(attribNdx)); |
| else |
| GLU_CHECK_CALL(glDisableVertexAttribArray(attribNdx)); |
| |
| if (state.attributes[attribNdx].integer) |
| GLU_CHECK_CALL(glVertexAttribIPointer(attribNdx, state.attributes[attribNdx].size, |
| state.attributes[attribNdx].type, state.attributes[attribNdx].stride, |
| (const GLvoid *)((GLintptr)state.attributes[attribNdx].offset))); |
| else |
| GLU_CHECK_CALL( |
| glVertexAttribPointer(attribNdx, state.attributes[attribNdx].size, state.attributes[attribNdx].type, |
| state.attributes[attribNdx].normalized, state.attributes[attribNdx].stride, |
| (const GLvoid *)((GLintptr)state.attributes[attribNdx].offset))); |
| |
| GLU_CHECK_CALL(glVertexAttribDivisor(attribNdx, state.attributes[attribNdx].divisor)); |
| } |
| } |
| |
| void MultiVertexArrayObjectTest::makeDrawCall(const VertexArrayState &state) |
| { |
| GLU_CHECK_CALL(glClearColor(0.7f, 0.7f, 0.7f, 1.0f)); |
| GLU_CHECK_CALL(glClear(GL_COLOR_BUFFER_BIT)); |
| |
| if (m_spec.useDrawElements) |
| { |
| if (state.elementArrayBuffer == 0) |
| { |
| if (m_spec.instances == 0) |
| GLU_CHECK_CALL(glDrawElements(GL_TRIANGLES, m_spec.count, m_spec.indexType, m_indices)); |
| else |
| GLU_CHECK_CALL( |
| glDrawElementsInstanced(GL_TRIANGLES, m_spec.count, m_spec.indexType, m_indices, m_spec.instances)); |
| } |
| else |
| { |
| if (m_spec.instances == 0) |
| GLU_CHECK_CALL(glDrawElements(GL_TRIANGLES, m_spec.count, m_spec.indexType, |
| (GLvoid *)((GLintptr)m_spec.indexOffset))); |
| else |
| GLU_CHECK_CALL(glDrawElementsInstanced(GL_TRIANGLES, m_spec.count, m_spec.indexType, |
| (GLvoid *)((GLintptr)m_spec.indexOffset), m_spec.instances)); |
| } |
| } |
| else |
| { |
| if (m_spec.instances == 0) |
| GLU_CHECK_CALL(glDrawArrays(GL_TRIANGLES, 0, m_spec.count)); |
| else |
| GLU_CHECK_CALL(glDrawArraysInstanced(GL_TRIANGLES, 0, m_spec.count, m_spec.instances)); |
| } |
| } |
| |
| void MultiVertexArrayObjectTest::render(tcu::Surface &vaoResult, tcu::Surface &defaultResult) |
| { |
| GLuint vao = 0; |
| |
| GLU_CHECK_CALL(glGenVertexArrays(1, &vao)); |
| GLU_CHECK_CALL(glBindVertexArray(vao)); |
| setState(m_spec.vao); |
| GLU_CHECK_CALL(glBindVertexArray(0)); |
| |
| setState(m_spec.state); |
| |
| GLU_CHECK_CALL(glBindVertexArray(vao)); |
| GLU_CHECK_CALL(glUseProgram(m_vaoProgram->getProgram())); |
| makeDrawCall(m_spec.vao); |
| glu::readPixels(m_context.getRenderContext(), 0, 0, vaoResult.getAccess()); |
| setState(m_spec.vao); |
| GLU_CHECK_CALL(glBindVertexArray(0)); |
| |
| GLU_CHECK_CALL(glUseProgram(m_stateProgram->getProgram())); |
| makeDrawCall(m_spec.state); |
| glu::readPixels(m_context.getRenderContext(), 0, 0, defaultResult.getAccess()); |
| } |
| |
| void MultiVertexArrayObjectTest::genReferences(tcu::Surface &vaoRef, tcu::Surface &defaultRef) |
| { |
| setState(m_spec.vao); |
| GLU_CHECK_CALL(glUseProgram(m_vaoProgram->getProgram())); |
| makeDrawCall(m_spec.vao); |
| glu::readPixels(m_context.getRenderContext(), 0, 0, vaoRef.getAccess()); |
| |
| setState(m_spec.state); |
| GLU_CHECK_CALL(glUseProgram(m_stateProgram->getProgram())); |
| makeDrawCall(m_spec.state); |
| glu::readPixels(m_context.getRenderContext(), 0, 0, defaultRef.getAccess()); |
| } |
| |
| TestCase::IterateResult MultiVertexArrayObjectTest::iterate(void) |
| { |
| tcu::Surface vaoReference(m_context.getRenderContext().getRenderTarget().getWidth(), |
| m_context.getRenderContext().getRenderTarget().getHeight()); |
| tcu::Surface stateReference(m_context.getRenderContext().getRenderTarget().getWidth(), |
| m_context.getRenderContext().getRenderTarget().getHeight()); |
| |
| tcu::Surface vaoResult(m_context.getRenderContext().getRenderTarget().getWidth(), |
| m_context.getRenderContext().getRenderTarget().getHeight()); |
| tcu::Surface stateResult(m_context.getRenderContext().getRenderTarget().getWidth(), |
| m_context.getRenderContext().getRenderTarget().getHeight()); |
| |
| bool isOk; |
| |
| logVertexArrayState(m_log, m_spec.vao, "Vertex Array Object State"); |
| logVertexArrayState(m_log, m_spec.state, "OpenGL Vertex Array State"); |
| genReferences(stateReference, vaoReference); |
| render(stateResult, vaoResult); |
| |
| isOk = tcu::pixelThresholdCompare(m_log, "Results", "Comparison result from rendering with Vertex Array State", |
| stateReference, stateResult, tcu::RGBA(0, 0, 0, 0), tcu::COMPARE_LOG_RESULT); |
| isOk = isOk && |
| tcu::pixelThresholdCompare(m_log, "Results", "Comparison result from rendering with Vertex Array Object", |
| vaoReference, vaoResult, tcu::RGBA(0, 0, 0, 0), tcu::COMPARE_LOG_RESULT); |
| |
| if (isOk) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| return STOP; |
| } |
| } |
| |
| VertexArrayObjectTestGroup::VertexArrayObjectTestGroup(Context &context) |
| : TestCaseGroup(context, "vertex_array_objects", "Vertex array object test cases") |
| { |
| } |
| |
| VertexArrayObjectTestGroup::~VertexArrayObjectTestGroup(void) |
| { |
| } |
| |
| void VertexArrayObjectTestGroup::init(void) |
| { |
| BufferSpec floatCoordBuffer48_1 = {48, 384, 2, 0, 0, GL_FLOAT, 0, 0, -1.0f, 1.0f}; |
| BufferSpec floatCoordBuffer48_2 = {48, 384, 2, 0, 0, GL_FLOAT, 0, 0, -1.0f, 1.0f}; |
| |
| BufferSpec shortCoordBuffer48 = {48, 192, 2, 0, 0, GL_SHORT, -32768, 32768, 0.0f, 0.0f}; |
| |
| // Different buffer |
| { |
| Spec spec; |
| |
| VertexArrayState state; |
| |
| state.attributes.push_back(Attribute()); |
| |
| state.attributes[0].enabled = true; |
| state.attributes[0].size = 2; |
| state.attributes[0].stride = 0; |
| state.attributes[0].type = GL_FLOAT; |
| state.attributes[0].integer = GL_FALSE; |
| state.attributes[0].divisor = 0; |
| state.attributes[0].offset = 0; |
| state.attributes[0].normalized = GL_FALSE; |
| |
| state.elementArrayBuffer = 0; |
| |
| spec.buffers.push_back(floatCoordBuffer48_1); |
| spec.buffers.push_back(floatCoordBuffer48_2); |
| |
| spec.useDrawElements = false; |
| spec.instances = 0; |
| spec.count = 48; |
| spec.vao = state; |
| spec.state = state; |
| spec.indexOffset = 0; |
| spec.indexRangeMin = 0; |
| spec.indexRangeMax = 0; |
| spec.indexType = GL_NONE; |
| spec.indexCount = 0; |
| |
| spec.state.attributes[0].bufferNdx = 1; |
| spec.vao.attributes[0].bufferNdx = 2; |
| addChild(new VertexArrayObjectTest(m_context, spec, "diff_buffer", "diff_buffer")); |
| } |
| // Different size |
| { |
| Spec spec; |
| |
| VertexArrayState state; |
| |
| state.attributes.push_back(Attribute()); |
| |
| state.attributes[0].enabled = true; |
| state.attributes[0].size = 2; |
| state.attributes[0].stride = 0; |
| state.attributes[0].type = GL_FLOAT; |
| state.attributes[0].integer = GL_FALSE; |
| state.attributes[0].divisor = 0; |
| state.attributes[0].offset = 0; |
| state.attributes[0].normalized = GL_FALSE; |
| state.attributes[0].bufferNdx = 1; |
| |
| state.elementArrayBuffer = 0; |
| |
| spec.buffers.push_back(floatCoordBuffer48_1); |
| |
| spec.useDrawElements = false; |
| spec.instances = 0; |
| spec.count = 24; |
| spec.vao = state; |
| spec.state = state; |
| spec.indexOffset = 0; |
| spec.indexRangeMin = 0; |
| spec.indexRangeMax = 0; |
| spec.indexType = GL_NONE; |
| spec.indexCount = 0; |
| |
| spec.state.attributes[0].size = 2; |
| spec.vao.attributes[0].size = 3; |
| addChild(new VertexArrayObjectTest(m_context, spec, "diff_size", "diff_size")); |
| } |
| |
| // Different stride |
| { |
| Spec spec; |
| |
| VertexArrayState state; |
| |
| state.attributes.push_back(Attribute()); |
| |
| state.attributes[0].enabled = true; |
| state.attributes[0].size = 2; |
| state.attributes[0].stride = 0; |
| state.attributes[0].type = GL_SHORT; |
| state.attributes[0].integer = GL_FALSE; |
| state.attributes[0].divisor = 0; |
| state.attributes[0].offset = 0; |
| state.attributes[0].normalized = GL_TRUE; |
| state.attributes[0].bufferNdx = 1; |
| |
| state.elementArrayBuffer = 0; |
| |
| spec.buffers.push_back(shortCoordBuffer48); |
| |
| spec.useDrawElements = false; |
| spec.instances = 0; |
| spec.count = 24; |
| spec.vao = state; |
| spec.state = state; |
| spec.indexOffset = 0; |
| spec.indexRangeMin = 0; |
| spec.indexRangeMax = 0; |
| spec.indexType = GL_NONE; |
| spec.indexCount = 0; |
| |
| spec.vao.attributes[0].stride = 2; |
| spec.state.attributes[0].stride = 4; |
| addChild(new VertexArrayObjectTest(m_context, spec, "diff_stride", "diff_stride")); |
| } |
| |
| // Different types |
| { |
| Spec spec; |
| |
| VertexArrayState state; |
| |
| state.attributes.push_back(Attribute()); |
| |
| state.attributes[0].enabled = true; |
| state.attributes[0].size = 2; |
| state.attributes[0].stride = 0; |
| state.attributes[0].type = GL_SHORT; |
| state.attributes[0].integer = GL_FALSE; |
| state.attributes[0].divisor = 0; |
| state.attributes[0].offset = 0; |
| state.attributes[0].normalized = GL_TRUE; |
| state.attributes[0].bufferNdx = 1; |
| |
| state.elementArrayBuffer = 0; |
| |
| spec.buffers.push_back(shortCoordBuffer48); |
| |
| spec.useDrawElements = false; |
| spec.instances = 0; |
| spec.count = 24; |
| spec.vao = state; |
| spec.state = state; |
| spec.indexOffset = 0; |
| spec.indexRangeMin = 0; |
| spec.indexRangeMax = 0; |
| spec.indexType = GL_NONE; |
| spec.indexCount = 0; |
| |
| spec.vao.attributes[0].type = GL_SHORT; |
| spec.state.attributes[0].type = GL_BYTE; |
| addChild(new VertexArrayObjectTest(m_context, spec, "diff_type", "diff_type")); |
| } |
| // Different "integer" |
| { |
| Spec spec; |
| |
| VertexArrayState state; |
| |
| state.attributes.push_back(Attribute()); |
| |
| state.attributes[0].enabled = true; |
| state.attributes[0].size = 2; |
| state.attributes[0].stride = 0; |
| state.attributes[0].type = GL_BYTE; |
| state.attributes[0].integer = GL_TRUE; |
| state.attributes[0].divisor = 0; |
| state.attributes[0].offset = 0; |
| state.attributes[0].normalized = GL_FALSE; |
| state.attributes[0].bufferNdx = 1; |
| |
| state.elementArrayBuffer = 0; |
| |
| spec.buffers.push_back(shortCoordBuffer48); |
| |
| spec.useDrawElements = false; |
| spec.count = 24; |
| spec.vao = state; |
| spec.state = state; |
| spec.instances = 0; |
| spec.indexOffset = 0; |
| spec.indexRangeMin = 0; |
| spec.indexRangeMax = 0; |
| spec.indexType = GL_NONE; |
| spec.indexCount = 0; |
| |
| spec.state.attributes[0].integer = GL_FALSE; |
| spec.vao.attributes[0].integer = GL_TRUE; |
| addChild(new VertexArrayObjectTest(m_context, spec, "diff_integer", "diff_integer")); |
| } |
| // Different divisor |
| { |
| Spec spec; |
| |
| VertexArrayState state; |
| |
| state.attributes.push_back(Attribute()); |
| state.attributes.push_back(Attribute()); |
| |
| state.attributes[0].enabled = true; |
| state.attributes[0].size = 2; |
| state.attributes[0].stride = 0; |
| state.attributes[0].type = GL_SHORT; |
| state.attributes[0].integer = GL_FALSE; |
| state.attributes[0].divisor = 0; |
| state.attributes[0].offset = 0; |
| state.attributes[0].normalized = GL_TRUE; |
| state.attributes[0].bufferNdx = 1; |
| |
| state.attributes[1].enabled = true; |
| state.attributes[1].size = 4; |
| state.attributes[1].stride = 0; |
| state.attributes[1].type = GL_FLOAT; |
| state.attributes[1].integer = GL_FALSE; |
| state.attributes[1].divisor = 0; |
| state.attributes[1].offset = 0; |
| state.attributes[1].normalized = GL_FALSE; |
| state.attributes[1].bufferNdx = 2; |
| |
| state.elementArrayBuffer = 0; |
| |
| spec.buffers.push_back(shortCoordBuffer48); |
| spec.buffers.push_back(floatCoordBuffer48_1); |
| |
| spec.useDrawElements = false; |
| spec.instances = 10; |
| spec.count = 12; |
| spec.vao = state; |
| spec.state = state; |
| spec.indexOffset = 0; |
| spec.indexRangeMin = 0; |
| spec.indexRangeMax = 0; |
| spec.indexType = GL_NONE; |
| spec.indexCount = 0; |
| |
| spec.vao.attributes[1].divisor = 3; |
| spec.state.attributes[1].divisor = 2; |
| |
| addChild(new VertexArrayObjectTest(m_context, spec, "diff_divisor", "diff_divisor")); |
| } |
| // Different offset |
| { |
| Spec spec; |
| |
| VertexArrayState state; |
| |
| state.attributes.push_back(Attribute()); |
| |
| state.attributes[0].enabled = true; |
| state.attributes[0].size = 2; |
| state.attributes[0].stride = 0; |
| state.attributes[0].type = GL_SHORT; |
| state.attributes[0].integer = GL_FALSE; |
| state.attributes[0].divisor = 0; |
| state.attributes[0].offset = 0; |
| state.attributes[0].normalized = GL_TRUE; |
| state.attributes[0].bufferNdx = 1; |
| |
| state.elementArrayBuffer = 0; |
| |
| spec.buffers.push_back(shortCoordBuffer48); |
| |
| spec.useDrawElements = false; |
| spec.instances = 0; |
| spec.count = 24; |
| spec.vao = state; |
| spec.state = state; |
| spec.indexOffset = 0; |
| spec.indexRangeMin = 0; |
| spec.indexRangeMax = 0; |
| spec.indexType = GL_NONE; |
| spec.indexCount = 0; |
| |
| spec.vao.attributes[0].offset = 2; |
| spec.state.attributes[0].offset = 4; |
| addChild(new VertexArrayObjectTest(m_context, spec, "diff_offset", "diff_offset")); |
| } |
| // Different normalize |
| { |
| Spec spec; |
| |
| VertexArrayState state; |
| |
| state.attributes.push_back(Attribute()); |
| |
| state.attributes[0].enabled = true; |
| state.attributes[0].size = 2; |
| state.attributes[0].stride = 0; |
| state.attributes[0].type = GL_SHORT; |
| state.attributes[0].integer = GL_FALSE; |
| state.attributes[0].divisor = 0; |
| state.attributes[0].offset = 0; |
| state.attributes[0].normalized = GL_TRUE; |
| state.attributes[0].bufferNdx = 1; |
| |
| state.elementArrayBuffer = 0; |
| |
| spec.buffers.push_back(shortCoordBuffer48); |
| |
| spec.useDrawElements = false; |
| spec.instances = 0; |
| spec.count = 48; |
| spec.vao = state; |
| spec.state = state; |
| spec.indexOffset = 0; |
| spec.indexRangeMin = 0; |
| spec.indexRangeMax = 0; |
| spec.indexType = GL_NONE; |
| spec.indexCount = 0; |
| |
| spec.vao.attributes[0].normalized = GL_TRUE; |
| spec.state.attributes[0].normalized = GL_FALSE; |
| addChild(new VertexArrayObjectTest(m_context, spec, "diff_normalize", "diff_normalize")); |
| } |
| // DrawElements with buffer / Pointer |
| { |
| Spec spec; |
| |
| VertexArrayState state; |
| |
| state.attributes.push_back(Attribute()); |
| |
| state.attributes[0].enabled = true; |
| state.attributes[0].size = 2; |
| state.attributes[0].stride = 0; |
| state.attributes[0].type = GL_FLOAT; |
| state.attributes[0].integer = GL_FALSE; |
| state.attributes[0].divisor = 0; |
| state.attributes[0].offset = 0; |
| state.attributes[0].normalized = GL_TRUE; |
| state.attributes[0].bufferNdx = 1; |
| |
| state.elementArrayBuffer = 0; |
| |
| spec.buffers.push_back(floatCoordBuffer48_1); |
| |
| BufferSpec indexBuffer = {24, 192, 1, 0, 0, GL_UNSIGNED_SHORT, 0, 48, 0.0f, 0.0f}; |
| spec.buffers.push_back(indexBuffer); |
| |
| spec.useDrawElements = true; |
| spec.count = 24; |
| spec.vao = state; |
| spec.state = state; |
| spec.instances = 0; |
| spec.indexOffset = 0; |
| spec.indexRangeMin = 0; |
| spec.indexRangeMax = 48; |
| spec.indexType = GL_UNSIGNED_SHORT; |
| spec.indexCount = 24; |
| |
| spec.state.elementArrayBuffer = 0; |
| spec.vao.elementArrayBuffer = 2; |
| addChild(new VertexArrayObjectTest(m_context, spec, "diff_indices", "diff_indices")); |
| } |
| // Use all attributes |
| |
| addChild(new MultiVertexArrayObjectTest(m_context, "all_attributes", "all_attributes")); |
| } |
| |
| } // namespace Functional |
| } // namespace gles3 |
| } // namespace deqp |
