| /*------------------------------------------------------------------------- |
| * OpenGL Conformance Test Suite |
| * ----------------------------- |
| * |
| * Copyright (c) 2014-2016 The Khronos Group Inc. |
| * |
| * 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 |
| */ /*-------------------------------------------------------------------*/ |
| |
| /** |
| * @file gl4cVertexAttrib64BitTests.hpp |
| * @brief Implement conformance tests for GL_ARB_vertex_attrib_64bit functionality |
| **/ |
| |
| #include "gl4cVertexAttrib64BitTest.hpp" |
| |
| #include "gluContextInfo.hpp" |
| #include "gluStrUtil.hpp" |
| #include "glwDefs.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| #include "tcuTestLog.hpp" |
| |
| #include <algorithm> |
| #include <iomanip> |
| #include <string> |
| #include <vector> |
| |
| using namespace glw; |
| |
| namespace VertexAttrib64Bit |
| { |
| |
| class Base : public deqp::TestCase |
| { |
| public: |
| /* Public constructor and destructor */ |
| Base(deqp::Context& context, const char* name, const char* description); |
| |
| virtual ~Base() |
| { |
| } |
| |
| /* Public methods */ |
| void BuildProgram(const GLchar* fragment_shader_code, GLuint& program_id, const GLchar* vertex_shader_code, |
| GLuint& out_fragment_shader_id, GLuint& out_vertex_shader_id) const; |
| |
| void BuildProgramVSOnly(GLuint out_program_id, const GLchar* vertex_shader_code, |
| GLuint& out_vertex_shader_id) const; |
| |
| void CompileShader(GLuint id, const GLchar* source_code) const; |
| |
| GLint GetMaxVertexAttribs() const; |
| |
| void IterateStart(); |
| |
| tcu::TestNode::IterateResult IterateStop(bool result) const; |
| |
| void LinkProgram(GLuint id) const; |
| |
| static GLdouble RandomDouble(GLdouble min, GLdouble max); |
| |
| void RequireExtension(const GLchar* extension_name) const; |
| |
| /* Public fields */ |
| /* Test framework objects */ |
| glw::Functions gl; /* prefix "m_" ommitted for readability */ |
| tcu::TestLog& m_log; |
| }; |
| |
| /** Constructor |
| * |
| **/ |
| Base::Base(deqp::Context& context, const char* name, const char* description) |
| : TestCase(context, name, description), m_log(m_context.getTestContext().getLog()) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| void Base::BuildProgram(const GLchar* fragment_shader_code, GLuint& program_id, const GLchar* vertex_shader_code, |
| GLuint& out_fragment_shader_id, GLuint& out_vertex_shader_id) const |
| { |
| out_fragment_shader_id = gl.createShader(GL_FRAGMENT_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); |
| |
| out_vertex_shader_id = gl.createShader(GL_VERTEX_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); |
| |
| CompileShader(out_fragment_shader_id, fragment_shader_code); |
| CompileShader(out_vertex_shader_id, vertex_shader_code); |
| |
| gl.attachShader(program_id, out_fragment_shader_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); |
| |
| gl.attachShader(program_id, out_vertex_shader_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); |
| |
| LinkProgram(program_id); |
| } |
| |
| /** Builds and links a program object consisting only of vertex shader stage. |
| * The function also creates a vertex shader, assigns it user-provided body |
| * and compiles it. |
| * |
| * @param program_id ID of a created program object to configure. |
| * @param vertex_shader_code Source code to use for the vertex shader. |
| * @param out_vertex_shader_id Will hold |
| **/ |
| void Base::BuildProgramVSOnly(GLuint program_id, const GLchar* vertex_shader_code, GLuint& out_vertex_shader_id) const |
| { |
| out_vertex_shader_id = gl.createShader(GL_VERTEX_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); |
| |
| CompileShader(out_vertex_shader_id, vertex_shader_code); |
| |
| gl.attachShader(program_id, out_vertex_shader_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); |
| |
| LinkProgram(program_id); |
| } |
| |
| void Base::CompileShader(GLuint id, const GLchar* source_code) const |
| { |
| GLint status = 0; |
| |
| gl.shaderSource(id, 1, &source_code, 0 /* length */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderSource"); |
| |
| gl.compileShader(id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "CompileShader"); |
| |
| gl.getShaderiv(id, GL_COMPILE_STATUS, &status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv"); |
| |
| if (GL_FALSE == status) |
| { |
| GLint message_length = 0; |
| std::vector<GLchar> message; |
| |
| gl.getShaderiv(id, GL_INFO_LOG_LENGTH, &message_length); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv"); |
| |
| message.resize(message_length + 1); |
| |
| gl.getShaderInfoLog(id, message_length, &message_length, &message[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderInfoLog"); |
| |
| m_log << tcu::TestLog::Section("Shader compilation error", ""); |
| |
| m_log << tcu::TestLog::Message << "Compilation log:\n" << &message[0] << tcu::TestLog::EndMessage; |
| |
| m_log << tcu::TestLog::Message << "Shader source:\n" << source_code << tcu::TestLog::EndMessage; |
| |
| m_log << tcu::TestLog::EndSection; |
| |
| TCU_FAIL("Shader compilation failed"); |
| } |
| } |
| |
| /** Get value of GL_MAX_VERTEX_ATTRIBS |
| * |
| * Throws exception in case of failure |
| * |
| * @return Value |
| **/ |
| GLint Base::GetMaxVertexAttribs() const |
| { |
| GLint max_vertex_attribs; |
| |
| gl.getIntegerv(GL_MAX_VERTEX_ATTRIBS, &max_vertex_attribs); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv"); |
| |
| return max_vertex_attribs; |
| } |
| |
| void Base::IterateStart() |
| { |
| gl = m_context.getRenderContext().getFunctions(); |
| } |
| |
| tcu::TestNode::IterateResult Base::IterateStop(bool result) const |
| { |
| /* Set test result */ |
| if (false == result) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| |
| /* Done */ |
| return tcu::TestNode::STOP; |
| } |
| |
| void Base::LinkProgram(GLuint id) const |
| { |
| GLint status = 0; |
| gl.linkProgram(id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "LinkProgram"); |
| |
| gl.getProgramiv(id, GL_LINK_STATUS, &status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv"); |
| |
| if (GL_FALSE == status) |
| { |
| GLint message_length = 0; |
| std::vector<GLchar> message; |
| |
| gl.getProgramiv(id, GL_INFO_LOG_LENGTH, &message_length); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv"); |
| |
| message.resize(message_length + 1); |
| |
| gl.getProgramInfoLog(id, message_length, &message_length, &message[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramInfoLog"); |
| |
| m_log << tcu::TestLog::Section("Program link error", ""); |
| |
| m_log << tcu::TestLog::Message << "Link log:\n" << &message[0] << tcu::TestLog::EndMessage; |
| |
| m_log << tcu::TestLog::EndSection; |
| |
| TCU_FAIL("Program linking failed"); |
| } |
| } |
| |
| /** Return "random" double value from range <min:max> |
| * |
| * @return Value |
| **/ |
| GLdouble Base::RandomDouble(GLdouble min, GLdouble max) |
| { |
| static const glw::GLushort max_value = 0x2000; |
| static glw::GLushort value = 0x1234; |
| |
| GLdouble fraction = ((GLdouble)value) / ((GLdouble)max_value); |
| const GLdouble range = max - min; |
| |
| value = static_cast<glw::GLushort>((max_value <= value) ? 0 : value + 1); |
| |
| return min + fraction * range; |
| } |
| |
| /** Throws tcu::NotSupportedError if requested extensions is not available. |
| * |
| **/ |
| void Base::RequireExtension(const GLchar* extension_name) const |
| { |
| const std::vector<std::string>& extensions = m_context.getContextInfo().getExtensions(); |
| |
| if (std::find(extensions.begin(), extensions.end(), extension_name) == extensions.end()) |
| { |
| std::string message = "Required extension is not supported: "; |
| message.append(extension_name); |
| |
| throw tcu::NotSupportedError(message); |
| } |
| } |
| |
| /** Implementation of conformance test "1", description follows. |
| * |
| * Make sure the following errors are generated as specified: |
| * |
| * a) GL_INVALID_VALUE should be generated by: |
| * I. glVertexAttribL1d () |
| * II. glVertexAttribL2d () |
| * III. glVertexAttribL3d () |
| * IV. glVertexAttribL4d () |
| * V. glVertexAttribL1dv () |
| * VI. glVertexAttribL2dv () |
| * VII. glVertexAttribL3dv () |
| * VIII. glVertexAttribL4dv () |
| * IX. glVertexAttribLPointer() |
| * |
| * if <index> is greater than or equal to GL_MAX_VERTEX_ATTRIBS; |
| * |
| * b) GL_INVALID_ENUM should be generated by glVertexAttribLPointer() |
| * if <type> is not GL_DOUBLE; |
| * |
| * c) GL_INVALID_VALUE should be generated by glVertexAttribLPointer() |
| * if <size> is not 1, 2, 3 or 4. |
| * |
| * d) GL_INVALID_VALUE should be generated by glVertexAttribLPointer() |
| * if <stride> is negative. |
| * |
| * e) GL_INVALID_OPERATION should be generated by glVertexAttribLPointer() |
| * if zero is bound to the GL_ARRAY_BUFFER buffer object binding |
| * point and the <pointer> argument is not NULL. |
| * |
| * f) GL_INVALID_OPERATION should be generated by glGetVertexAttribLdv() |
| * if <index> is zero. |
| **/ |
| class ApiErrorsTest : public Base |
| { |
| public: |
| /* Public methods */ |
| ApiErrorsTest(deqp::Context& context); |
| |
| virtual ~ApiErrorsTest() |
| { |
| } |
| |
| /* Public methods inheritated from TestCase */ |
| virtual void deinit(); |
| virtual tcu::TestNode::IterateResult iterate(); |
| |
| private: |
| /* Private methods */ |
| void invalidEnum(bool& result); |
| void invalidOperation(bool& result); |
| void invalidValue(bool& result); |
| void verifyError(GLenum expected_error, const char* function_name, int line_number, bool& result); |
| |
| /* Private fields */ |
| GLuint m_vertex_array_object_id; |
| }; |
| |
| /** Constructor |
| * |
| * @param context CTS context instance |
| **/ |
| ApiErrorsTest::ApiErrorsTest(deqp::Context& context) |
| : Base(context, "api_errors", "Verify that API routines provoke errors as specified"), m_vertex_array_object_id(0) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| void ApiErrorsTest::deinit() |
| { |
| /* Delete VAO */ |
| if (0 != m_vertex_array_object_id) |
| { |
| gl.bindVertexArray(0); |
| gl.deleteVertexArrays(1, &m_vertex_array_object_id); |
| m_vertex_array_object_id = 0; |
| } |
| } |
| |
| /** Execute test |
| * |
| * @return tcu::TestNode::STOP |
| **/ |
| tcu::TestNode::IterateResult ApiErrorsTest::iterate() |
| { |
| IterateStart(); |
| |
| bool result = true; |
| |
| RequireExtension("GL_ARB_vertex_attrib_64bit"); |
| |
| gl.genVertexArrays(1, &m_vertex_array_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GenVertexArrays"); |
| |
| gl.bindVertexArray(m_vertex_array_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindVertexArray"); |
| |
| invalidEnum(result); |
| invalidOperation(result); |
| invalidValue(result); |
| |
| /* Done */ |
| return IterateStop(result); |
| } |
| |
| /** Test if GL_INVALID_ENUM error is provoked as expected |
| * |
| * @param result If test fails result is set to false, not modified otherwise. |
| **/ |
| void ApiErrorsTest::invalidEnum(bool& result) |
| { |
| /* |
| *b) GL_INVALID_ENUM should be generated by glVertexAttribLPointer() |
| * if <type> is not GL_DOUBLE; |
| */ |
| |
| static const GLenum type_array[] = { GL_BYTE, |
| GL_UNSIGNED_BYTE, |
| GL_SHORT, |
| GL_UNSIGNED_SHORT, |
| GL_INT, |
| GL_UNSIGNED_INT, |
| GL_HALF_FLOAT, |
| GL_FLOAT, |
| GL_FIXED, |
| GL_INT_2_10_10_10_REV, |
| GL_UNSIGNED_INT_2_10_10_10_REV, |
| GL_UNSIGNED_INT_10F_11F_11F_REV }; |
| static const GLuint type_array_length = sizeof(type_array) / sizeof(type_array[0]); |
| |
| for (GLuint i = 0; i < type_array_length; ++i) |
| { |
| const GLenum type = type_array[i]; |
| |
| std::stringstream message; |
| message << "VertexAttribLPointer(..., " << glu::getTypeName(type) << " /* type */, ...)"; |
| |
| gl.vertexAttribLPointer(1 /*index */, 4 /*size */, type, 0 /* stride */, 0 /* pointer */); |
| verifyError(GL_INVALID_ENUM, message.str().c_str(), __LINE__, result); |
| } |
| |
| gl.vertexAttribLPointer(1 /* index */, 4 /*size */, GL_DOUBLE, 0 /* stride */, 0 /* pointer */); |
| verifyError(GL_NO_ERROR, "VertexAttribLPointer(..., GL_DOUBLE /* type */, ...)", __LINE__, result); |
| } |
| |
| /** Test if GL_INVALID_OPERATON error is provoked as expected |
| * |
| * @param result If test fails result is set to false, not modified otherwise. |
| **/ |
| void ApiErrorsTest::invalidOperation(bool& result) |
| { |
| |
| /* |
| *e) GL_INVALID_OPERATION should be generated by glVertexAttribLPointer() |
| * if zero is bound to the GL_ARRAY_BUFFER buffer object binding |
| * point and the <pointer> argument is not NULL. |
| */ |
| static const GLvoid* pointer_array[] = { (GLvoid*)1, (GLvoid*)4, (GLvoid*)-16 }; |
| static const GLuint pointer_array_length = sizeof(pointer_array) / sizeof(pointer_array[0]); |
| |
| gl.bindBuffer(GL_ARRAY_BUFFER, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer"); |
| |
| for (GLuint i = 0; i < pointer_array_length; ++i) |
| { |
| const GLvoid* pointer = pointer_array[i]; |
| |
| std::stringstream message; |
| message << "VertexAttribLPointer(..., " << pointer << " /* pointer */)"; |
| |
| gl.vertexAttribLPointer(1 /* index */, 4 /*size */, GL_DOUBLE, 0 /* stride */, pointer); |
| verifyError(GL_INVALID_OPERATION, message.str().c_str(), __LINE__, result); |
| } |
| } |
| |
| /** Test if GL_INVALID_VALUE error is provoked as expected |
| * |
| * @param result If test fails result is set to false, not modified otherwise. |
| **/ |
| void ApiErrorsTest::invalidValue(bool& result) |
| { |
| GLint max_vertex_attribs = GetMaxVertexAttribs(); |
| const GLdouble vector[4] = { 0.0, 0.0, 0.0, 0.0 }; |
| |
| /* |
| * a) GL_INVALID_VALUE should be generated by: |
| * I. glVertexAttribL1d () |
| * II. glVertexAttribL2d () |
| * III. glVertexAttribL3d () |
| * IV. glVertexAttribL4d () |
| * V. glVertexAttribL1dv () |
| * VI. glVertexAttribL2dv () |
| * VII. glVertexAttribL3dv () |
| * VIII. glVertexAttribL4dv () |
| * IX. glVertexAttribLPointer() |
| * |
| * if <index> is greater than or equal to GL_MAX_VERTEX_ATTRIBS; |
| */ |
| gl.vertexAttribL1d(max_vertex_attribs, 0.0); |
| verifyError(GL_INVALID_VALUE, "VertexAttribL1d(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result); |
| |
| gl.vertexAttribL1d(max_vertex_attribs + 1, 0.0); |
| verifyError(GL_INVALID_VALUE, "VertexAttribL1d(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result); |
| |
| gl.vertexAttribL2d(max_vertex_attribs, 0.0, 0.0); |
| verifyError(GL_INVALID_VALUE, "VertexAttribL2d(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result); |
| |
| gl.vertexAttribL2d(max_vertex_attribs + 1, 0.0, 0.0); |
| verifyError(GL_INVALID_VALUE, "VertexAttribL2d(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result); |
| |
| gl.vertexAttribL3d(max_vertex_attribs, 0.0, 0.0, 0.0); |
| verifyError(GL_INVALID_VALUE, "VertexAttribL3d(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result); |
| |
| gl.vertexAttribL3d(max_vertex_attribs + 1, 0.0, 0.0, 0.0); |
| verifyError(GL_INVALID_VALUE, "VertexAttribL3d(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result); |
| |
| gl.vertexAttribL4d(max_vertex_attribs, 0.0, 0.0, 0.0, 0.0); |
| verifyError(GL_INVALID_VALUE, "VertexAttribL4d(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result); |
| |
| gl.vertexAttribL4d(max_vertex_attribs + 1, 0.0, 0.0, 0.0, 0.0); |
| verifyError(GL_INVALID_VALUE, "VertexAttribL4d(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result); |
| |
| gl.vertexAttribL1dv(max_vertex_attribs, vector); |
| verifyError(GL_INVALID_VALUE, "VertexAttribL1dv(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result); |
| |
| gl.vertexAttribL1dv(max_vertex_attribs + 1, vector); |
| verifyError(GL_INVALID_VALUE, "VertexAttribL1dv(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result); |
| |
| gl.vertexAttribL2dv(max_vertex_attribs, vector); |
| verifyError(GL_INVALID_VALUE, "VertexAttribL2dv(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result); |
| |
| gl.vertexAttribL2dv(max_vertex_attribs + 1, vector); |
| verifyError(GL_INVALID_VALUE, "VertexAttribL2dv(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result); |
| |
| gl.vertexAttribL3dv(max_vertex_attribs, vector); |
| verifyError(GL_INVALID_VALUE, "VertexAttribL3dv(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result); |
| |
| gl.vertexAttribL3dv(max_vertex_attribs + 1, vector); |
| verifyError(GL_INVALID_VALUE, "VertexAttribL3dv(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result); |
| |
| gl.vertexAttribL4dv(max_vertex_attribs, vector); |
| verifyError(GL_INVALID_VALUE, "VertexAttribL4dv(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result); |
| |
| gl.vertexAttribL4dv(max_vertex_attribs + 1, vector); |
| verifyError(GL_INVALID_VALUE, "VertexAttribL4dv(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result); |
| |
| gl.vertexAttribLPointer(max_vertex_attribs, 4 /*size */, GL_DOUBLE, 0 /* stride */, 0 /* pointer */); |
| verifyError(GL_INVALID_VALUE, "VertexAttribLPointer(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result); |
| |
| gl.vertexAttribLPointer(max_vertex_attribs + 1, 4 /*size */, GL_DOUBLE, 0 /* stride */, 0 /* pointer */); |
| verifyError(GL_INVALID_VALUE, "VertexAttribLPointer(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result); |
| |
| /* |
| *c) GL_INVALID_VALUE should be generated by glVertexAttribLPointer() |
| *if <size> is not 1, 2, 3 or 4. |
| */ |
| gl.vertexAttribLPointer(1, 0 /*size */, GL_DOUBLE, 0 /* stride */, 0 /* pointer */); |
| verifyError(GL_INVALID_VALUE, "VertexAttribLPointer(..., 0 /* size */, ...)", __LINE__, result); |
| |
| gl.vertexAttribLPointer(1, 5 /*size */, GL_DOUBLE, 0 /* stride */, 0 /* pointer */); |
| verifyError(GL_INVALID_VALUE, "VertexAttribLPointer(..., 5 /* size */, ...)", __LINE__, result); |
| |
| /* |
| *d) GL_INVALID_VALUE should be generated by glVertexAttribLPointer() |
| * if <stride> is negative. |
| */ |
| gl.vertexAttribLPointer(1, 4 /*size */, GL_DOUBLE, -1 /* stride */, 0 /* pointer */); |
| verifyError(GL_INVALID_VALUE, "VertexAttribLPointer(..., -1 /* stride */, ...)", __LINE__, result); |
| |
| gl.vertexAttribLPointer(1, 4 /*size */, GL_DOUBLE, -4 /* stride */, 0 /* pointer */); |
| verifyError(GL_INVALID_VALUE, "VertexAttribLPointer(..., -4 /* stride */, ...)", __LINE__, result); |
| } |
| |
| /** Verify that GetError returns expected error code. In case of failure logs error message. |
| * |
| * @param expected_error Expected error code |
| * @param function_name Name of function to log in case of error |
| * @param line_number Line number, for reference |
| * @param result Result of verification, set to false in case of failure, not modified otherwise |
| **/ |
| void ApiErrorsTest::verifyError(GLenum expected_error, const char* function_name, int line_number, bool& result) |
| { |
| GLenum error = gl.getError(); |
| |
| if (expected_error != error) |
| { |
| m_log << tcu::TestLog::Section("Error", ""); |
| |
| m_log << tcu::TestLog::Message << "GetError returned: " << glu::getErrorStr(error) << tcu::TestLog::EndMessage; |
| |
| m_log << tcu::TestLog::Message << "Expected: " << glu::getErrorStr(expected_error) << tcu::TestLog::EndMessage; |
| |
| m_log << tcu::TestLog::Message << "Operation: " << function_name << tcu::TestLog::EndMessage; |
| |
| m_log << tcu::TestLog::Message << "File: " << __FILE__ << "@" << line_number << tcu::TestLog::EndMessage; |
| |
| m_log << tcu::TestLog::EndSection; |
| |
| result = false; |
| } |
| } |
| |
| /** Implementation of conformance test "2", description follows. |
| * |
| * Make sure that all available generic vertex attributes report |
| * correct values when queried with corresponding glGetVertexAttribL*() |
| * function, after they had been set with a glVertexAttribL*() call. |
| * All double-precision floating-point setters and getters should |
| * be checked, as enlisted below: |
| * |
| * * glVertexAttribL1d () |
| * * glVertexAttribL2d () |
| * * glVertexAttribL3d () |
| * * glVertexAttribL4d () |
| * * glVertexAttribL1dv() |
| * * glVertexAttribL2dv() |
| * * glVertexAttribL3dv() |
| * * glVertexAttribL4dv() |
| * |
| * The test should also verify glGetVertexAttribiv() and |
| * glGetVertexAttribLdv() report correct property values for all |
| * vertex attribute arrays configured with glVertexAttribLPointer() |
| * call. Two different configurations should be checked for each |
| * VAA index. |
| **/ |
| class GetVertexAttribTest : public Base |
| { |
| public: |
| /* Public constructor and destructor */ |
| GetVertexAttribTest(deqp::Context& context); |
| |
| virtual ~GetVertexAttribTest() |
| { |
| } |
| |
| /* Public methods inheritated from TestCase */ |
| virtual void deinit(); |
| virtual tcu::TestNode::IterateResult iterate(); |
| |
| private: |
| /* Private types */ |
| /** Template class to store vertex attribute data |
| * |
| * @tparam SIZE Number of elements |
| **/ |
| template <GLuint SIZE> |
| class vertexAttribute |
| { |
| public: |
| vertexAttribute(GLdouble min, GLdouble max) |
| { |
| for (GLuint i = 0; i < SIZE; ++i) |
| { |
| m_array[i] = RandomDouble(min, max); |
| } |
| } |
| |
| GLdouble m_array[SIZE]; |
| }; |
| |
| /* Private methods */ |
| /* checkVertexAttrib methods */ |
| template <GLuint SIZE> |
| void checkVertexAttribLd(GLuint index, bool& result) const; |
| |
| template <GLuint SIZE> |
| void checkVertexAttribLdv(GLuint index, bool& result) const; |
| |
| void checkVertexAttribLPointer(GLuint index, bool& result) const; |
| |
| /* Wrappers for vertexAttribLd routines */ |
| template <GLuint SIZE> |
| void vertexAttribLd(GLuint index, const vertexAttribute<SIZE>& attribute) const; |
| |
| template <GLuint SIZE> |
| void vertexAttribLdv(GLuint index, const vertexAttribute<SIZE>& attribute) const; |
| |
| /* Utilities */ |
| bool compareDoubles(const GLdouble* a, const GLdouble* b, GLuint length) const; |
| |
| void initTest(); |
| |
| bool verifyResults(GLuint index, GLenum pname, GLint expected_value) const; |
| |
| bool verifyResults(const GLdouble* set_values, GLuint length, GLuint index, const char* function_name, |
| int line_number) const; |
| |
| bool verifyPointerResults(const GLdouble* set_values, GLuint length, GLuint index, int line_number) const; |
| |
| void logError(const GLdouble* set_values, const GLdouble* get_values, GLuint length, const char* function_name, |
| GLuint index, int line_number) const; |
| |
| /* Private fields */ |
| const GLdouble m_epsilon; |
| static const GLuint m_n_iterations = 128; |
| GLint m_max_vertex_attribs; |
| const GLdouble m_min; |
| const GLdouble m_max; |
| |
| /* GL objects */ |
| GLuint m_buffer_object_id; |
| GLuint m_vertex_array_object_id; |
| }; |
| |
| /** Constructor |
| * |
| * @param context CTS context |
| **/ |
| GetVertexAttribTest::GetVertexAttribTest(deqp::Context& context) |
| : Base(context, "get_vertex_attrib", "Verify that GetVertexAttribL* routines") |
| , m_epsilon(0.0) |
| , m_max_vertex_attribs(0) |
| , m_min(-16.384) |
| , m_max(16.384) |
| , m_buffer_object_id(0) |
| , m_vertex_array_object_id(0) |
| { |
| /* Nothing to be done */ |
| } |
| |
| /** Clean up after test |
| * |
| **/ |
| void GetVertexAttribTest::deinit() |
| { |
| if (0 != m_buffer_object_id) |
| { |
| gl.bindBuffer(GL_ARRAY_BUFFER, 0); |
| gl.deleteBuffers(1, &m_buffer_object_id); |
| m_buffer_object_id = 0; |
| } |
| |
| if (0 != m_vertex_array_object_id) |
| { |
| gl.bindVertexArray(0); |
| gl.deleteVertexArrays(1, &m_vertex_array_object_id); |
| m_vertex_array_object_id = 0; |
| } |
| } |
| |
| /** Execute test |
| * |
| * @return tcu::TestNode::STOP |
| **/ |
| tcu::TestNode::IterateResult GetVertexAttribTest::iterate() |
| { |
| IterateStart(); |
| |
| bool result = true; |
| |
| RequireExtension("GL_ARB_vertex_attrib_64bit"); |
| |
| initTest(); |
| |
| for (GLint i = 1; i < m_max_vertex_attribs; ++i) |
| { |
| checkVertexAttribLd<1>(i, result); |
| checkVertexAttribLd<2>(i, result); |
| checkVertexAttribLd<3>(i, result); |
| checkVertexAttribLd<4>(i, result); |
| checkVertexAttribLdv<1>(i, result); |
| checkVertexAttribLdv<2>(i, result); |
| checkVertexAttribLdv<3>(i, result); |
| checkVertexAttribLdv<4>(i, result); |
| checkVertexAttribLPointer(i, result); |
| } |
| |
| /* Done */ |
| return IterateStop(result); |
| } |
| |
| /** Verifies glVertexAttribLd routines |
| * |
| * @tparam SIZE Size of vertex attribute |
| * |
| * @param index Index of vertex attribute, starts from 1. |
| * @param result Result of verification, set to false in case of failure, not modified otherwise. |
| **/ |
| template <GLuint SIZE> |
| void GetVertexAttribTest::checkVertexAttribLd(GLuint index, bool& result) const |
| { |
| std::stringstream function_name; |
| |
| function_name << "VertexAttribL" << SIZE << "d"; |
| |
| for (GLuint i = 0; i < m_n_iterations; ++i) |
| { |
| vertexAttribute<SIZE> vertex_attribute(m_min, m_max); |
| |
| vertexAttribLd<SIZE>(index, vertex_attribute); |
| GLU_EXPECT_NO_ERROR(gl.getError(), function_name.str().c_str()); |
| |
| if (false == verifyResults(vertex_attribute.m_array, SIZE, index, function_name.str().c_str(), __LINE__)) |
| { |
| result = false; |
| return; |
| } |
| } |
| } |
| |
| /** Verifies glVertexAttribLdv routines |
| * |
| * @tparam SIZE Size of vertex attribute |
| * |
| * @param index Index of vertex attribute, starts from 1. |
| * @param result Result of verification, set to false in case of failure, not modified otherwise. |
| **/ |
| template <GLuint SIZE> |
| void GetVertexAttribTest::checkVertexAttribLdv(GLuint index, bool& result) const |
| { |
| std::stringstream function_name; |
| |
| function_name << "VertexAttribL" << SIZE << "dv"; |
| |
| for (GLuint i = 0; i < m_n_iterations; ++i) |
| { |
| vertexAttribute<SIZE> vertex_attribute(m_min, m_max); |
| |
| vertexAttribLdv<SIZE>(index, vertex_attribute); |
| GLU_EXPECT_NO_ERROR(gl.getError(), function_name.str().c_str()); |
| |
| if (false == verifyResults(vertex_attribute.m_array, SIZE, index, function_name.str().c_str(), __LINE__)) |
| { |
| result = false; |
| return; |
| } |
| } |
| } |
| |
| /** Verifies glVertexAttribLPointer |
| * |
| * @param index Index of vertex attribute, starts from 1. |
| * @param result Result of verification, set to false in case of failure, not modified otherwise. |
| **/ |
| void GetVertexAttribTest::checkVertexAttribLPointer(GLuint index, bool& result) const |
| { |
| static const GLuint max_size = 4; |
| static const GLuint max_stride = 16; |
| |
| gl.bindVertexArray(m_vertex_array_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindVertexArray"); |
| |
| gl.bindBuffer(GL_ARRAY_BUFFER, m_buffer_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer"); |
| |
| for (GLuint size = 1; size <= max_size; ++size) |
| { |
| for (GLuint stride = 0; stride < max_stride; ++stride) |
| { |
| gl.bindBuffer(GL_ARRAY_BUFFER, m_buffer_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer"); |
| |
| gl.vertexAttribLPointer(index, size, GL_DOUBLE, stride, (GLvoid*)0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "VertexAttribLPointer"); |
| |
| gl.bindBuffer(GL_ARRAY_BUFFER, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer"); |
| |
| if (false == verifyResults(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, m_buffer_object_id)) |
| { |
| result = false; |
| } |
| |
| if (false == verifyResults(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_FALSE)) |
| { |
| result = false; |
| } |
| |
| if (false == verifyResults(index, GL_VERTEX_ATTRIB_ARRAY_SIZE, size)) |
| { |
| result = false; |
| } |
| |
| if (false == verifyResults(index, GL_VERTEX_ATTRIB_ARRAY_STRIDE, stride)) |
| { |
| result = false; |
| } |
| |
| if (false == verifyResults(index, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_DOUBLE)) |
| { |
| result = false; |
| } |
| |
| if (false == verifyResults(index, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, GL_FALSE)) |
| { |
| result = false; |
| } |
| |
| if (false == verifyResults(index, GL_VERTEX_ATTRIB_ARRAY_INTEGER, GL_FALSE)) |
| { |
| result = false; |
| } |
| |
| if (false == verifyResults(index, GL_VERTEX_ATTRIB_ARRAY_DIVISOR, 0)) |
| { |
| result = false; |
| } |
| } |
| } |
| } |
| |
| /** Wrapper of vertexAttribLd routines. |
| * |
| * @tparam SIZE Size of vertex attribute. Specialisation for 1. |
| * |
| * @param index Index parameter |
| * @param attribute Vertex attribute data are taken from provided instance of vertexAttribute |
| **/ |
| template <> |
| void GetVertexAttribTest::vertexAttribLd<1>(GLuint index, |
| const GetVertexAttribTest::vertexAttribute<1>& attribute) const |
| { |
| gl.vertexAttribL1d(index, attribute.m_array[0]); |
| } |
| |
| /** Wrapper of vertexAttribLd routines. |
| * |
| * @tparam SIZE Size of vertex attribute. Specialisation for 2. |
| * |
| * @param index Index parameter |
| * @param attribute Vertex attribute data are taken from provided instance of vertexAttribute |
| **/ |
| template <> |
| void GetVertexAttribTest::vertexAttribLd<2>(GLuint index, |
| const GetVertexAttribTest::vertexAttribute<2>& attribute) const |
| { |
| gl.vertexAttribL2d(index, attribute.m_array[0], attribute.m_array[1]); |
| } |
| |
| /** Wrapper of vertexAttribLd routines. |
| * |
| * @tparam SIZE Size of vertex attribute. Specialisation for 3. |
| * |
| * @param index Index parameter |
| * @param attribute Vertex attribute data are taken from provided instance of vertexAttribute |
| **/ |
| template <> |
| void GetVertexAttribTest::vertexAttribLd<3>(GLuint index, |
| const GetVertexAttribTest::vertexAttribute<3>& attribute) const |
| { |
| gl.vertexAttribL3d(index, attribute.m_array[0], attribute.m_array[1], attribute.m_array[2]); |
| } |
| |
| /** Wrapper of vertexAttribLd routines. |
| * |
| * @tparam SIZE Size of vertex attribute. Specialisation for 4. |
| * |
| * @param index Index parameter |
| * @param attribute Vertex attribute data are taken from provided instance of vertexAttribute |
| **/ |
| template <> |
| void GetVertexAttribTest::vertexAttribLd<4>(GLuint index, |
| const GetVertexAttribTest::vertexAttribute<4>& attribute) const |
| { |
| gl.vertexAttribL4d(index, attribute.m_array[0], attribute.m_array[1], attribute.m_array[2], attribute.m_array[3]); |
| } |
| |
| /** Wrapper of vertexAttribLdv routines. |
| * |
| * @tparam SIZE Size of vertex attribute. Specialisation for 1. |
| * |
| * @param index Index parameter |
| * @param attribute Vertex attribute data are taken from provided instance of vertexAttribute |
| **/ |
| template <> |
| void GetVertexAttribTest::vertexAttribLdv<1>(GLuint index, |
| const GetVertexAttribTest::vertexAttribute<1>& attribute) const |
| { |
| gl.vertexAttribL1dv(index, attribute.m_array); |
| } |
| |
| /** Wrapper of vertexAttribLdv routines. |
| * |
| * @tparam SIZE Size of vertex attribute. Specialisation for 2. |
| * |
| * @param index Index parameter |
| * @param attribute Vertex attribute data are taken from provided instance of vertexAttribute |
| **/ |
| template <> |
| void GetVertexAttribTest::vertexAttribLdv<2>(GLuint index, |
| const GetVertexAttribTest::vertexAttribute<2>& attribute) const |
| { |
| gl.vertexAttribL2dv(index, attribute.m_array); |
| } |
| |
| /** Wrapper of vertexAttribLdv routines. |
| * |
| * @tparam SIZE Size of vertex attribute. Specialisation for 3. |
| * |
| * @param index Index parameter |
| * @param attribute Vertex attribute data are taken from provided instance of vertexAttribute |
| **/ |
| template <> |
| void GetVertexAttribTest::vertexAttribLdv<3>(GLuint index, |
| const GetVertexAttribTest::vertexAttribute<3>& attribute) const |
| { |
| gl.vertexAttribL3dv(index, attribute.m_array); |
| } |
| |
| /** Wrapper of vertexAttribLdv routines. |
| * |
| * @tparam SIZE Size of vertex attribute. Specialisation for 4. |
| * |
| * @param index Index parameter |
| * @param attribute Vertex attribute data are taken from provided instance of vertexAttribute |
| **/ |
| template <> |
| void GetVertexAttribTest::vertexAttribLdv<4>(GLuint index, |
| const GetVertexAttribTest::vertexAttribute<4>& attribute) const |
| { |
| gl.vertexAttribL4dv(index, attribute.m_array); |
| } |
| |
| /** Compare two arrays of doubles |
| * |
| * @param a First array of doubles |
| * @param b Second array of doubles |
| * @param length Length of arrays |
| * |
| * @return true if arrays are considered equal, false otherwise |
| **/ |
| bool GetVertexAttribTest::compareDoubles(const GLdouble* a, const GLdouble* b, GLuint length) const |
| { |
| for (GLuint i = 0; i < length; ++i) |
| { |
| if ((b[i] > a[i] + m_epsilon) || (b[i] < a[i] - m_epsilon)) |
| { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| /** Prepare buffer and vertex array object, get max vertex attributes |
| * |
| **/ |
| void GetVertexAttribTest::initTest() |
| { |
| gl.genBuffers(1, &m_buffer_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GenBuffers"); |
| |
| gl.bindBuffer(GL_ARRAY_BUFFER, m_buffer_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer"); |
| |
| gl.bufferData(GL_ARRAY_BUFFER, 16 * sizeof(GLdouble), 0, GL_DYNAMIC_DRAW); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BufferStorage"); |
| |
| gl.genVertexArrays(1, &m_vertex_array_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GenVertexArrays"); |
| |
| m_max_vertex_attribs = GetMaxVertexAttribs(); |
| } |
| |
| /** Logs message informing that values got with GetVertexAttribLdv do not match set with "function_name" |
| * |
| * @param set_values Values set with "function_name" |
| * @param get_values Values extracted with GetVertexAttribLdv |
| * @param length Length of "get/set_values" arrays |
| * @param function_name Name of function used to set vertex attributes |
| * @param index Index of vertex attribute |
| * @param line_number Line number refereing to location of "function_name" |
| **/ |
| void GetVertexAttribTest::logError(const GLdouble* set_values, const GLdouble* get_values, GLuint length, |
| const char* function_name, GLuint index, int line_number) const |
| { |
| m_log << tcu::TestLog::Section("Error", ""); |
| |
| tcu::MessageBuilder message = m_log << tcu::TestLog::Message; |
| message << "Values set with " << function_name << " ["; |
| |
| for (GLuint i = 0; i < length; ++i) |
| { |
| message << std::setprecision(24) << set_values[i]; |
| |
| if (length != i + 1) |
| { |
| message << ", "; |
| } |
| } |
| |
| message << "]" << tcu::TestLog::EndMessage; |
| |
| message = m_log << tcu::TestLog::Message; |
| message << "Values got with GetVertexAttribLdv" |
| << " ["; |
| |
| for (GLuint i = 0; i < length; ++i) |
| { |
| message << std::setprecision(24) << get_values[i]; |
| |
| if (length != i + 1) |
| { |
| message << ", "; |
| } |
| } |
| |
| message << "]" << tcu::TestLog::EndMessage; |
| |
| m_log << tcu::TestLog::Message << "Index: " << index << tcu::TestLog::EndMessage; |
| |
| m_log << tcu::TestLog::Message << "File: " << __FILE__ << "@" << line_number << tcu::TestLog::EndMessage; |
| |
| m_log << tcu::TestLog::EndSection; |
| } |
| |
| /** Verify results of vertexAttribLPointer |
| * |
| * @param index Index of vertex attribute |
| * @param pname Parameter name to be querried with getVertexAttribiv and getVertexAttribLdv |
| * @param expected_value Expected valued |
| * |
| * @return true if Results match expected_value, false otherwise |
| **/ |
| bool GetVertexAttribTest::verifyResults(GLuint index, GLenum pname, GLint expected_value) const |
| { |
| GLint params_getVertexAttribiv = 0; |
| GLdouble params_getVertexAttribLdv = 0.0; |
| |
| gl.getVertexAttribiv(index, pname, ¶ms_getVertexAttribiv); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetVertexAttribiv"); |
| |
| gl.getVertexAttribLdv(index, pname, ¶ms_getVertexAttribLdv); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetVertexAttribLdv"); |
| |
| if ((expected_value != params_getVertexAttribiv) || (expected_value != params_getVertexAttribLdv)) |
| { |
| m_log << tcu::TestLog::Section("Error", ""); |
| |
| m_log << tcu::TestLog::Message << "GetVertexAttribiv(" << index << "/* index */, " |
| << glu::getVertexAttribParameterNameName(pname) << "/* pname */)" << tcu::TestLog::EndMessage; |
| |
| m_log << tcu::TestLog::Message << "Result: " << params_getVertexAttribiv << tcu::TestLog::EndMessage; |
| |
| m_log << tcu::TestLog::Message << "GetVertexAttribLdv(" << index << "/* index */, " |
| << glu::getVertexAttribParameterNameName(pname) << "/* pname */)" << tcu::TestLog::EndMessage; |
| |
| m_log << tcu::TestLog::Message << "Result: " << params_getVertexAttribLdv << tcu::TestLog::EndMessage; |
| |
| m_log << tcu::TestLog::Message << "Expected: " << expected_value << tcu::TestLog::EndMessage; |
| |
| m_log << tcu::TestLog::Message << "File: " << __FILE__ << "@" << __LINE__ << tcu::TestLog::EndMessage; |
| |
| m_log << tcu::TestLog::EndSection; |
| |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** Verify results of vertexAttribLdv routines |
| * |
| * @param set_values Values set with vertexAttribLdv |
| * @param length Length of "set_values" array |
| * @param index Index of vertex attribute |
| * @param function_name Name of function used to set, it will be used for error logging |
| * @param line_number Line number refering to location of "function_name", used to log errors |
| * |
| * @return true if results match set values, false otherwise |
| **/ |
| bool GetVertexAttribTest::verifyResults(const GLdouble* set_values, GLuint length, GLuint index, |
| const char* function_name, int line_number) const |
| { |
| GLdouble results[4] = { 0.0, 0.0, 0.0, 0.0 }; |
| |
| gl.getVertexAttribLdv(index, GL_CURRENT_VERTEX_ATTRIB, results); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetVertexAttribLdv"); |
| |
| if (false == compareDoubles(set_values, results, length)) |
| { |
| logError(set_values, results, length, function_name, index, line_number); |
| |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** Implementation of conformance test "3", description follows. |
| * |
| * Verify that a total of GL_MAX_VERTEX_ATTRIBS double and dvec2, |
| * (GL_MAX_VERTEX_ATTRIBS / 2) dvec3, dvec4 and dmat2, |
| * (GL_MAX_VERTEX_ATTRIBS / 3) dmat3x2, |
| * (GL_MAX_VERTEX_ATTRIBS / 4) dmat4x2, dmat2x3 and dmat2x4, |
| * (GL_MAX_VERTEX_ATTRIBS / 6) dmat3 and dmat3x4, |
| * (GL_MAX_VERTEX_ATTRIBS / 8) dmat4x3 and dmat4, |
| * attributes can be used in each shader stage at the same time. |
| * |
| * The test should run in 7 iterations: |
| * |
| * a) In the first iteration, (GL_MAX_VERTEX_ATTRIBS / 2) double |
| * attributes and (GL_MAX_VERTEX_ATTRIBS / 2) dvec2 attributes |
| * should be defined in a vertex shader. The test should verify |
| * the values exposed by these attributes and write 1 to an |
| * output variable if all attribute values are found to be |
| * correct, or set it to 0 if at least one of the retrieved |
| * values is found invalid. |
| * |
| * Double attributes should be assigned the value: |
| * (n_attribute + gl_VertexID * 2) |
| * |
| * Dvec2 attribute components should be assigned the following |
| * vector values: |
| * (n_attribute + gl_VertexID * 3 + 1, |
| * n_attribute + gl_VertexID * 3 + 2) |
| * |
| * b) In the second iteration, (GL_MAX_VERTEX_ATTRIBS / 4) dvec3 |
| * and (GL_MAX_VERTEX_ATTRIBS / 4) dvec4 attributes should be |
| * defined in a vertex shader. Verification of the data exposed |
| * by these input variables should be performed as in step a), |
| * with an exception of the values passed through the attributes. |
| * |
| * Dvec3 attribute components should be assigned the following |
| * vector values: |
| * (n_attribute + gl_VertexID * 3 + 0, |
| * n_attribute + gl_VertexID * 3 + 1, |
| * n_attribute + gl_VertexID * 3 + 2). |
| * |
| * Dvec4 attribute components should be assigned the following |
| * vector values: |
| * (n_attribute + gl_VertexID * 4 + 0, |
| * n_attribute + gl_VertexID * 4 + 1, |
| * n_attribute + gl_VertexID * 4 + 2, |
| * n_attribute + gl_VertexID * 4 + 3). |
| * |
| * n_attribute corresponds to the ordinal number of each attribute, |
| * as defined in the shader. |
| * |
| * c) In the third iteration, (GL_MAX_VERTEX_ATTRIBS / 2) dmat2 attributes |
| * should be defined in a vertex shader. Verification of the data exposed |
| * by these input variables should be performed as in step a), with an |
| * exception of the values passed through the attributes. |
| * |
| * Subsequent matrix elements should be assigned the following value: |
| * (n_type + n_attribute + gl_VertexID * 16 + n_value) |
| * |
| * n_type corresponds to the ordinal number of type as per the |
| * order at the beginning of the paragraph. |
| * n_value corresponds to the ordinal number of the element. |
| * |
| * d) In the fourth iteration, (GL_MAX_VERTEX_ATTRIBS / 8) dmat3x2 and |
| * (GL_MAX_VERTEX_ATTRIBS / 8) dmat4x2 attributes should be defined in a |
| * vertex shader. Verification of the data exposed by these input |
| * variables should be performed as in step a), with an exception of the |
| * values passed through the attributes. |
| * |
| * Use the same element values as in step c) |
| * |
| * e) In the fifth iteration, (GL_MAX_VERTEX_ATTRIBS / 8) dmat2x3 and |
| * (GL_MAX_VERTEX_ATTRIBS / 8) dmat2x4 attributes should be defined in a |
| * vertex shader. Verification of the data exposed by these input |
| * variables should be performed as in step a), with an exception of the |
| * values passed through the attributes. |
| * |
| * Use the same element values as in step c) |
| * |
| * f) In the sixth iteration, (GL_MAX_VERTEX_ATTRIBS / 12) dmat3 and |
| * (GL_MAX_VERTEX_ATTRIBS / 12) dmat3x4 attributes should be defined in a |
| * vertex shader. Verification of the data exposed by these input |
| * variables should be performed as in step a), with an exception of the |
| * values passed through the attributes. |
| * |
| * Use the same element values as in step c) |
| * |
| * g) In the seventh iteration, (GL_MAX_VERTEX_ATTRIBS / 16) dmat4x3 and |
| * (GL_MAX_VERTEX_ATTRIBS / 16) dmat4 attributes should be defined in a |
| * vertex shader. Verification of the data exposed by these input |
| * variables should be performed as in step a), with an exception of the |
| * values passed through the attributes. |
| * |
| * Use the same element values as in step c) |
| * |
| * h) Modify the language of cases a) - g), so that instead of separate |
| * attributes, all attributes of the same type are now a single arrayed |
| * attribute. |
| * |
| * Vertex shaders from both iterations should be used to form two program |
| * objects. 1024 vertices should be used for a non-indiced GL_POINTS |
| * draw call, made using those two programs. |
| * |
| * All glVertexAttribL*() and glVertexAttribLPointer() should be used for |
| * the purpose of the test. The following draw call API functions should be |
| * tested: |
| * |
| * a) glDrawArrays() |
| * b) glDrawArraysInstanced(), primcount > 1, zero vertex attrib divisor |
| * c) glDrawArraysInstanced(), primcount > 1, non-zero vertex attrib divisor |
| * d) glDrawElements() |
| * e) glDrawElementsInstanced(), properties as in b) |
| * f) glDrawElementsInstanced(), properties as in c) |
| * |
| * All shaders used by the test should come in two flavors: |
| * |
| * - one where attribute locations are explicitly defined in the body; |
| * - the other one where attribute locations are to be assigned by |
| * the compiler. |
| * |
| * For each shader, the test should make sure that all attributes have |
| * been assigned correct amount of locations. (eg: dvec4 attribute |
| * should be granted exactly one location). |
| * |
| * Data stored in output variables should be XFBed to the test. |
| * The test passes if the retrieved values are found to be valid |
| * for all vertex shader invocations. |
| **/ |
| |
| class LimitTest : public Base |
| { |
| public: |
| /* Public constructor and destructor */ |
| LimitTest(deqp::Context& context); |
| |
| virtual ~LimitTest() |
| { |
| } |
| |
| /* Public methods inheritated from TestCase */ |
| virtual void deinit(); |
| virtual tcu::TestNode::IterateResult iterate(); |
| |
| private: |
| /* Private types */ |
| class programInfo |
| { |
| public: |
| programInfo(const glw::Functions& gl); |
| ~programInfo(); |
| |
| GLuint m_fragment_shader_id; |
| GLuint m_program_id; |
| GLuint m_vertex_shader_id; |
| |
| private: |
| const glw::Functions& gl; |
| }; |
| |
| struct attributeConfiguration |
| { |
| attributeConfiguration() |
| : m_n_attributes_per_group(0) |
| , m_n_elements(0) |
| , m_n_rows(0) |
| , m_n_types(0) |
| , m_type_names(0) |
| , m_vertex_length(0) |
| { |
| /* nothing to be done */ |
| } |
| |
| GLint m_n_attributes_per_group; |
| const GLint* m_n_elements; |
| const GLint* m_n_rows; |
| GLint m_n_types; |
| const GLchar* const* m_type_names; |
| GLint m_vertex_length; |
| }; |
| |
| typedef GLint _varyingType; |
| |
| /* Private enums */ |
| enum _iteration |
| { |
| DOUBLE_DVEC2, // 1 + 1 = 2 |
| DVEC3_DVEC4, // 2 + 2 = 4 |
| DMAT2, // 2 * 1 = 2 |
| DMAT3X2_DMAT4X2, // 3 * 1 + 4 * 1 = 8 |
| DMAT2X3_DMAT2X4, // 2 * 2 + 2 * 2 = 8 |
| DMAT3_DMAT3X4, // 3 * 2 + 3 * 2 = 12 |
| DMAT4X3_DMAT4 // 4 * 2 + 4 * 2 = 16 |
| }; |
| |
| enum _attributeType |
| { |
| REGULAR, |
| PER_INSTANCE, |
| CONSTANT, |
| }; |
| |
| /*Private methods */ |
| GLint calculateAttributeGroupOffset(const attributeConfiguration& configuration, GLint index) const; |
| |
| GLint calculateAttributeLocation(const attributeConfiguration& configuration, GLint attribute, GLint n_type) const; |
| |
| void calculateVertexLength(attributeConfiguration& configuration) const; |
| |
| void configureAttribute(_iteration iteration, const attributeConfiguration& configuration, GLint n_type, |
| GLuint program_id, bool use_arrays, bool use_vertex_array) const; |
| |
| void getProgramDetails(_iteration iteration, bool use_arrays, bool use_locations, bool use_vertex_attrib_divisor, |
| std::string& out_varying_name, std::string& out_vertex_shader_code) const; |
| |
| void getVertexArrayConfiguration(_iteration iteration, attributeConfiguration& out_configuration) const; |
| |
| void logTestIterationAndConfig(_iteration iteration, _attributeType attribute_type, bool use_arrays, |
| bool use_locations) const; |
| |
| void prepareProgram(_iteration iteration, bool use_arrays, bool use_locations, bool use_vertex_attrib_divisor, |
| programInfo& programInfo); |
| |
| void prepareVertexArray(_iteration iteration, _attributeType attribute_type, GLuint program_id, |
| bool use_arrays) const; |
| |
| void prepareVertexArrayBuffer(_iteration iteration); |
| |
| void setAttributes(_iteration iteration, const attributeConfiguration& configuration, GLuint vertex, |
| std::vector<GLdouble>& out_buffer_data) const; |
| |
| void setAttributes_a(const attributeConfiguration& configuration, GLint n_type, GLuint vertex, |
| std::vector<GLdouble>& out_buffer_data) const; |
| |
| void setAttributes_a_scalar(const attributeConfiguration& configuration, GLint n_type, GLuint vertex, |
| std::vector<GLdouble>& out_buffer_data) const; |
| |
| void setAttributes_a_vec(const attributeConfiguration& configuration, GLint n_type, GLuint vertex, |
| std::vector<GLdouble>& out_buffer_data) const; |
| |
| void setAttributes_b(const attributeConfiguration& configuration, GLint n_type, GLuint vertex, |
| std::vector<GLdouble>& out_buffer_dataa) const; |
| |
| void setAttributes_c(const attributeConfiguration& configuration, GLint n_type, GLuint vertex, |
| std::vector<GLdouble>& out_buffer_data) const; |
| |
| bool testDrawArrays() const; |
| bool testDrawArraysInstanced() const; |
| bool testDrawElements() const; |
| bool testDrawElementsInstanced() const; |
| void testInit(); |
| bool testIteration(_iteration iteration); |
| |
| bool testProgram(_iteration iteration, GLuint program_id, bool use_arrays) const; |
| |
| bool testProgramWithConstant(_iteration iteration, GLuint program_id, bool use_arrays) const; |
| |
| bool testProgramWithDivisor(_iteration iteration, GLuint program_id, bool use_arrays) const; |
| |
| bool verifyResult(bool use_instancing) const; |
| |
| /* Private fields */ |
| /* Constants */ |
| static const GLint m_array_attribute = -1; |
| static const GLuint m_n_instances = 16; |
| static const GLuint m_n_varyings = 1; |
| static const GLuint m_n_vertices = 1024; |
| static const GLuint m_transform_feedback_buffer_size = |
| sizeof(_varyingType) * m_n_instances * m_n_vertices * m_n_varyings; |
| |
| /* GL objects */ |
| GLuint m_element_array_buffer_id; |
| GLuint m_transoform_feedback_buffer_id; |
| GLuint m_vertex_array_buffer_id; |
| GLuint m_vertex_array_object_id; |
| }; |
| |
| /** Constructor |
| * |
| **/ |
| LimitTest::programInfo::programInfo(const glw::Functions& gl_functions) |
| : m_fragment_shader_id(0), m_program_id(0), m_vertex_shader_id(0), gl(gl_functions) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Destructor |
| * |
| **/ |
| LimitTest::programInfo::~programInfo() |
| { |
| if (0 != m_program_id) |
| { |
| gl.deleteProgram(m_program_id); |
| m_program_id = 0; |
| } |
| |
| if (0 != m_fragment_shader_id) |
| { |
| gl.deleteShader(m_fragment_shader_id); |
| m_fragment_shader_id = 0; |
| } |
| |
| if (0 != m_vertex_shader_id) |
| { |
| gl.deleteShader(m_vertex_shader_id); |
| m_vertex_shader_id = 0; |
| } |
| } |
| |
| /** Constructor |
| * |
| * @param context CTS context |
| **/ |
| LimitTest::LimitTest(deqp::Context& context) |
| : Base(context, "limits_test", "Verify that maximum allowed number of attribiutes can be used") |
| , m_element_array_buffer_id(0) |
| , m_transoform_feedback_buffer_id(0) |
| , m_vertex_array_buffer_id(0) |
| , m_vertex_array_object_id(0) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Clean up after test |
| * |
| **/ |
| void LimitTest::deinit() |
| { |
| /* Restore default settings */ |
| if (0 != gl.disable) |
| { |
| gl.disable(GL_RASTERIZER_DISCARD); |
| } |
| |
| /* Delete GL objects */ |
| if (0 != m_element_array_buffer_id) |
| { |
| gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); |
| gl.deleteBuffers(1, &m_element_array_buffer_id); |
| m_element_array_buffer_id = 0; |
| } |
| |
| if (0 != m_transoform_feedback_buffer_id) |
| { |
| gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, 0); |
| gl.deleteBuffers(1, &m_transoform_feedback_buffer_id); |
| m_transoform_feedback_buffer_id = 0; |
| } |
| |
| if (0 != m_vertex_array_buffer_id) |
| { |
| gl.bindBuffer(GL_ARRAY_BUFFER, 0); |
| gl.deleteBuffers(1, &m_vertex_array_buffer_id); |
| m_vertex_array_buffer_id = 0; |
| } |
| |
| if (0 != m_vertex_array_object_id) |
| { |
| gl.bindVertexArray(0); |
| gl.deleteVertexArrays(1, &m_vertex_array_object_id); |
| m_vertex_array_object_id = 0; |
| } |
| } |
| |
| /** Execute test |
| * |
| * @return tcu::TestNode::STOP |
| **/ |
| tcu::TestNode::IterateResult LimitTest::iterate() |
| { |
| IterateStart(); |
| |
| bool result = true; |
| |
| RequireExtension("GL_ARB_vertex_attrib_64bit"); |
| |
| testInit(); |
| |
| if (false == testIteration(DOUBLE_DVEC2)) |
| { |
| result = false; |
| } |
| |
| if (false == testIteration(DVEC3_DVEC4)) |
| { |
| result = false; |
| } |
| |
| if (false == testIteration(DMAT2)) |
| { |
| result = false; |
| } |
| |
| if (false == testIteration(DMAT3X2_DMAT4X2)) |
| { |
| result = false; |
| } |
| |
| if (false == testIteration(DMAT2X3_DMAT2X4)) |
| { |
| result = false; |
| } |
| |
| if (false == testIteration(DMAT3_DMAT3X4)) |
| { |
| result = false; |
| } |
| |
| if (false == testIteration(DMAT4X3_DMAT4)) |
| { |
| result = false; |
| } |
| |
| /* Done */ |
| return IterateStop(result); |
| } |
| |
| /** Calculate offset of "n_type" attributes group in doubles, tightly packed, for vertex buffer offsets |
| * |
| * @param configuration Attribute configuration |
| * @param n_type Attribute type ordinal number |
| * |
| * @return Calculated offset |
| **/ |
| GLint LimitTest::calculateAttributeGroupOffset(const attributeConfiguration& configuration, GLint n_type) const |
| { |
| GLint result = 0; |
| |
| for (GLint i = 0; i < n_type; ++i) |
| { |
| result += configuration.m_n_attributes_per_group * configuration.m_n_elements[i]; |
| } |
| |
| return result; |
| } |
| |
| /** Calculates attribute location for manually setting "layout(location =)". |
| * Results are in reveresed order of vertex buffer |
| * |
| * @param configuration Attribute configuration |
| * @param attribute Intex of attribute in "n_type" group |
| * @param n_type Ordinal number of type |
| * |
| * @return Calculated location |
| **/ |
| GLint LimitTest::calculateAttributeLocation(const attributeConfiguration& configuration, GLint attribute, |
| GLint n_type) const |
| { |
| const GLint n_types = configuration.m_n_types; |
| GLint result = 0; |
| |
| /* Amount of location required for types after given "n_type" */ |
| for (GLint i = n_types - 1; i > n_type; --i) |
| { |
| const GLint n_elements = configuration.m_n_elements[i]; |
| const GLint n_rows = configuration.m_n_rows[i]; |
| const GLint n_columns = n_elements / n_rows; |
| |
| result += n_columns * configuration.m_n_attributes_per_group; |
| } |
| |
| /* Amount of locations required for attributes after given attribute in given "n_type" */ |
| /* Arrayed attributes does not have any attributes after */ |
| if (m_array_attribute != attribute) |
| { |
| const GLint n_elements = configuration.m_n_elements[n_type]; |
| const GLint n_rows = configuration.m_n_rows[n_type]; |
| const GLint n_columns = n_elements / n_rows; |
| |
| result += n_columns * (configuration.m_n_attributes_per_group - 1 - attribute); |
| } |
| |
| /* Done */ |
| return result; |
| } |
| |
| /** Calculate vertex length in "doubles", tightly packed, for offset in vertex buffer |
| * |
| * @param configuration Attribute configuration, result is store as field ::m_vertex_length |
| **/ |
| void LimitTest::calculateVertexLength(attributeConfiguration& configuration) const |
| { |
| GLint result = 0; |
| |
| for (GLint i = 0; i < configuration.m_n_types; ++i) |
| { |
| result += configuration.m_n_elements[i] * configuration.m_n_attributes_per_group; |
| } |
| |
| configuration.m_vertex_length = result; |
| } |
| |
| /** Configure attributes in given "n_type" group |
| * |
| * @param iteration Iteration id |
| * @param configuration Configuration of attributes |
| * @param n_type "n_type" of attibutes |
| * @param program_id Program object id |
| * @param use_arrays If attributes are groupd in arrays |
| * @param use_vertex_array If attributes are configured with vertex array or as constants |
| **/ |
| void LimitTest::configureAttribute(_iteration iteration, const attributeConfiguration& configuration, GLint n_type, |
| GLuint program_id, bool use_arrays, bool use_vertex_array) const |
| { |
| static const GLint invalid_attrib_location = -1; |
| |
| const GLint attributes_index = n_type * configuration.m_n_attributes_per_group; |
| const GLint group_offset = calculateAttributeGroupOffset(configuration, n_type); |
| const GLint n_elements = configuration.m_n_elements[n_type]; |
| const GLint n_rows = configuration.m_n_rows[n_type]; |
| const GLint n_columns = n_elements / n_rows; |
| const GLint vertex_length = configuration.m_vertex_length; |
| |
| /* For each attribute in "n_type" group */ |
| for (GLint i = 0; i < configuration.m_n_attributes_per_group; ++i) |
| { |
| const GLint attribute_ordinal = i + attributes_index; |
| std::stringstream attribute_name; |
| |
| /* Separate attributes are called: attribute_ORDINAL, arrayed: attribute_N_TYPE[INDEX] */ |
| if (false == use_arrays) |
| { |
| attribute_name << "attribute_" << attribute_ordinal; |
| } |
| else |
| { |
| attribute_name << "attribute_" << n_type << "[" << i << "]"; |
| } |
| |
| /* get location */ |
| GLint attribute_location = gl.getAttribLocation(program_id, attribute_name.str().c_str()); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetAttribLocation"); |
| |
| if (invalid_attrib_location == attribute_location) |
| { |
| m_log << tcu::TestLog::Message << "GetAttribLocation(" << program_id << ", " << attribute_name.str() |
| << ") returned: " << attribute_location << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Inactive attribute"); |
| } |
| |
| /* Configure */ |
| if (true == use_vertex_array) |
| { |
| /* With vertex array */ |
| for (GLint column = 0; column < n_columns; ++column) |
| { |
| const GLint attribute_offset = group_offset + i * n_elements; |
| const GLint column_offset = column * n_rows; |
| |
| gl.enableVertexAttribArray(attribute_location + column); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "EnableVertexAttribArray"); |
| |
| gl.vertexAttribLPointer(attribute_location + column, n_rows /* size */, GL_DOUBLE, |
| static_cast<glw::GLsizei>(vertex_length * sizeof(GLdouble)), |
| (GLvoid*)((attribute_offset + column_offset) * sizeof(GLdouble))); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "VertexAttribLPointer"); |
| } |
| } |
| else |
| { |
| /* As constant */ |
| for (GLint column = 0; column < n_columns; ++column) |
| { |
| switch (iteration) |
| { |
| case DOUBLE_DVEC2: |
| |
| /* Double attributes should be assigned the value: |
| (n_attribute + gl_VertexID * 2) */ |
| /* Dvec2 attribute components should be assigned the following |
| vector values: |
| (n_attribute + gl_VertexID * 3 + 1, |
| n_attribute + gl_VertexID * 3 + 2)*/ |
| |
| if (1 == n_rows) |
| { |
| gl.vertexAttribL1d(attribute_location, attribute_ordinal); |
| } |
| else |
| { |
| gl.vertexAttribL2d(attribute_location, attribute_ordinal + 1, attribute_ordinal + 2); |
| } |
| |
| break; |
| |
| case DVEC3_DVEC4: |
| |
| /* Dvec3 attribute components should be assigned the following |
| vector values: |
| (n_attribute + gl_VertexID * 3 + 0, |
| n_attribute + gl_VertexID * 3 + 1, |
| n_attribute + gl_VertexID * 3 + 2). |
| |
| Dvec4 attribute components should be assigned the following |
| vector values: |
| (n_attribute + gl_VertexID * 4 + 0, |
| n_attribute + gl_VertexID * 4 + 1, |
| n_attribute + gl_VertexID * 4 + 2, |
| n_attribute + gl_VertexID * 4 + 3).*/ |
| |
| if (3 == n_rows) |
| { |
| gl.vertexAttribL3d(attribute_location, attribute_ordinal + 0, attribute_ordinal + 1, |
| attribute_ordinal + 2); |
| } |
| else |
| { |
| gl.vertexAttribL4d(attribute_location, attribute_ordinal + 0, attribute_ordinal + 1, |
| attribute_ordinal + 2, attribute_ordinal + 3); |
| } |
| |
| break; |
| |
| case DMAT2: |
| case DMAT3X2_DMAT4X2: |
| case DMAT2X3_DMAT2X4: |
| case DMAT3_DMAT3X4: |
| case DMAT4X3_DMAT4: |
| |
| /* Subsequent matrix elements should be assigned the following value: |
| (n_type + n_attribute + gl_VertexID * 16 + n_value)*/ |
| |
| if (2 == n_rows) |
| { |
| gl.vertexAttribL2d(attribute_location + column, |
| n_type + attribute_ordinal + 0 + column * n_rows, |
| n_type + attribute_ordinal + 1 + column * n_rows); |
| } |
| else if (3 == n_rows) |
| { |
| gl.vertexAttribL3d(attribute_location + column, |
| n_type + attribute_ordinal + 0 + column * n_rows, |
| n_type + attribute_ordinal + 1 + column * n_rows, |
| n_type + attribute_ordinal + 2 + column * n_rows); |
| } |
| else |
| { |
| gl.vertexAttribL4d(attribute_location + column, |
| n_type + attribute_ordinal + 0 + column * n_rows, |
| n_type + attribute_ordinal + 1 + column * n_rows, |
| n_type + attribute_ordinal + 2 + column * n_rows, |
| n_type + attribute_ordinal + 3 + column * n_rows); |
| } |
| |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| /** Get varying name and vertex shader code for given configuration |
| * |
| * @param iteration Iteration id |
| * @param use_arrays If attributes should be grouped in arrays |
| * @param use_locations If attributes locations should be set manualy |
| * @param use_vertex_attrib_divisor If vertex attribute divisor should be used |
| * @param out_varying_name Name of varying to be captured with transform feedback |
| * @param out_vertex_shader_code Source code of vertex shader |
| **/ |
| void LimitTest::getProgramDetails(_iteration iteration, bool use_arrays, bool use_locations, |
| bool use_vertex_attrib_divisor, std::string& out_varying_name, |
| std::string& out_vertex_shader_code) const |
| { |
| static const GLchar* varying_name = "vs_output_value"; |
| |
| attributeConfiguration configuration; |
| GLint n_attributes = 0; |
| GLint n_types = 0; |
| std::stringstream stream; |
| |
| const GLchar* advancement_str = (true == use_vertex_attrib_divisor) ? "gl_InstanceID" : "gl_VertexID"; |
| |
| getVertexArrayConfiguration(iteration, configuration); |
| |
| n_attributes = configuration.m_n_attributes_per_group; |
| n_types = configuration.m_n_types; |
| |
| /* Preamble */ |
| stream << "#version 400\n" |
| "#extension GL_ARB_vertex_attrib_64bit : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n"; |
| |
| /* Attribute declarations */ |
| /* Spearated attributes are called: attribute_ORDINAL, arrayed: attribute_N_TYPE */ |
| for (GLint n_type = 0; n_type < n_types; ++n_type) |
| { |
| const GLint attribute_offset = n_type * n_attributes; |
| const GLchar* type_name = configuration.m_type_names[n_type]; |
| |
| stream << "// " << type_name << "\n"; |
| |
| if (false == use_arrays) |
| { |
| for (GLint attribute = 0; attribute < n_attributes; ++attribute) |
| { |
| if (true == use_locations) |
| { |
| const GLint location = calculateAttributeLocation(configuration, attribute, n_type); |
| |
| stream << "layout(location = " << location << ") "; |
| } |
| |
| stream << "in " << type_name << " attribute_" << attribute + attribute_offset << ";\n"; |
| } |
| } |
| else |
| { |
| if (true == use_locations) |
| { |
| const GLint location = calculateAttributeLocation(configuration, m_array_attribute, n_type); |
| |
| stream << "layout(location = " << location << ") "; |
| } |
| |
| stream << "in " << type_name << " attribute_" << n_type << "[" << n_attributes << "];\n"; |
| } |
| |
| stream << "\n"; |
| } |
| |
| /* Varying declaration */ |
| stream << "out int " << varying_name << ";\n\n"; |
| |
| /* Main */ |
| stream << "void main()\n" |
| "{\n"; |
| |
| for (GLint n_type = 0; n_type < n_types; ++n_type) |
| { |
| const GLint n_elements = configuration.m_n_elements[n_type]; |
| const GLchar* type_name = configuration.m_type_names[n_type]; |
| |
| stream << "// " << type_name << "\n"; |
| |
| /* if (attribute_name != type(values)) |
| * { |
| * varying = 0; |
| * } |
| */ |
| for (GLint attribute = 0; attribute < n_attributes; ++attribute) |
| { |
| const GLint attribute_ordinal = attribute + n_type * n_attributes; |
| |
| /* First attribute is verified with "if", rest with "else if" */ |
| if (0 == attribute_ordinal) |
| { |
| stream << " if (attribute_"; |
| } |
| else |
| { |
| stream << " else if (attribute_"; |
| } |
| |
| /* Spearated attributes are called: attribute_ORDINAL, arrayed: attribute_N_TYPE[INDEX] */ |
| if (false == use_arrays) |
| { |
| stream << attribute_ordinal; |
| } |
| else |
| { |
| stream << n_type << "[" << attribute << "]"; |
| } |
| |
| /* != type() */ |
| stream << " != " << type_name << "("; |
| |
| /* Values for type constructor, depend on iteration */ |
| switch (iteration) |
| { |
| case DOUBLE_DVEC2: |
| |
| /* Double attributes should be assigned the value: |
| (n_attribute + gl_VertexID * 2) */ |
| /* Dvec2 attribute components should be assigned the following |
| vector values: |
| (n_attribute + gl_VertexID * 3 + 1, |
| n_attribute + gl_VertexID * 3 + 2)*/ |
| |
| if (1 == n_elements) |
| { |
| stream << attribute_ordinal << " + " << advancement_str << " * 2"; |
| } |
| else |
| { |
| stream << attribute_ordinal << " + " << advancement_str << " * 3 + 1" |
| << ", " << attribute_ordinal << " + " << advancement_str << " * 3 + 2"; |
| } |
| |
| break; |
| |
| case DVEC3_DVEC4: |
| |
| /* Dvec3 attribute components should be assigned the following |
| vector values: |
| (n_attribute + gl_VertexID * 3 + 0, |
| n_attribute + gl_VertexID * 3 + 1, |
| n_attribute + gl_VertexID * 3 + 2). |
| |
| Dvec4 attribute components should be assigned the following |
| vector values: |
| (n_attribute + gl_VertexID * 4 + 0, |
| n_attribute + gl_VertexID * 4 + 1, |
| n_attribute + gl_VertexID * 4 + 2, |
| n_attribute + gl_VertexID * 4 + 3).*/ |
| |
| for (GLint element = 0; element < n_elements; ++element) |
| { |
| stream << attribute_ordinal << " + " << advancement_str << " * " << n_elements << " + " << element; |
| |
| if (n_elements != element + 1) |
| { |
| stream << ", "; |
| } |
| } |
| |
| break; |
| |
| case DMAT2: |
| case DMAT3X2_DMAT4X2: |
| case DMAT2X3_DMAT2X4: |
| case DMAT3_DMAT3X4: |
| case DMAT4X3_DMAT4: |
| |
| /* Subsequent matrix elements should be assigned the following value: |
| (n_type + n_attribute + gl_VertexID * 16 + n_value)*/ |
| |
| for (GLint element = 0; element < n_elements; ++element) |
| { |
| stream << n_type << " + " << attribute_ordinal << " + " << advancement_str << " * 16 + " << element; |
| |
| if (n_elements != element + 1) |
| { |
| stream << ", "; |
| } |
| } |
| |
| break; |
| } |
| |
| /* type() { varying = 0 } */ |
| stream << "))\n" |
| << " {\n" |
| << " " << varying_name << " = 0;\n" |
| << " }\n"; |
| } |
| } |
| |
| /* All attributes verified: else { varyin = 1 } |
| Close main body */ |
| stream << " else\n" |
| << " {\n" |
| << " " << varying_name << " = 1;\n" |
| << " }\n" |
| << "}\n\n"; |
| |
| /* Store results */ |
| out_varying_name = varying_name; |
| out_vertex_shader_code = stream.str(); |
| } |
| |
| /** Get configuration of vertex array object |
| * |
| * @param iteration Iteration id |
| * @param out_configuration Configuration |
| **/ |
| void LimitTest::getVertexArrayConfiguration(_iteration iteration, attributeConfiguration& out_configuration) const |
| { |
| static const GLuint n_elements_per_scalar = 1; |
| static const GLuint n_elements_per_vec2 = 2; |
| static const GLuint n_elements_per_vec3 = 3; |
| static const GLuint n_elements_per_vec4 = 4; |
| static const GLuint n_elements_per_mat2 = 4; |
| static const GLuint n_elements_per_mat2x3 = 6; |
| static const GLuint n_elements_per_mat2x4 = 8; |
| static const GLuint n_elements_per_mat3 = 9; |
| static const GLuint n_elements_per_mat3x2 = 6; |
| static const GLuint n_elements_per_mat3x4 = 12; |
| static const GLuint n_elements_per_mat4 = 16; |
| static const GLuint n_elements_per_mat4x2 = 8; |
| static const GLuint n_elements_per_mat4x3 = 12; |
| |
| const GLint max_vertex_attribs = GetMaxVertexAttribs(); |
| |
| switch (iteration) |
| { |
| case DOUBLE_DVEC2: |
| { |
| static const GLint n_elements[] = { n_elements_per_scalar, n_elements_per_vec2 }; |
| static const GLint n_types = sizeof(n_elements) / sizeof(n_elements[0]); |
| |
| static const GLint divisor = 2; |
| |
| static const GLchar* type_names[] = { "double", "dvec2" }; |
| |
| static const GLint n_rows[] = { |
| 1, 2, |
| }; |
| |
| out_configuration.m_n_attributes_per_group = max_vertex_attribs / divisor; |
| out_configuration.m_n_elements = n_elements; |
| out_configuration.m_n_rows = n_rows; |
| out_configuration.m_n_types = n_types; |
| out_configuration.m_type_names = type_names; |
| } |
| break; |
| case DVEC3_DVEC4: |
| { |
| static const GLint n_elements[] = { n_elements_per_vec3, n_elements_per_vec4 }; |
| static const GLint n_types = sizeof(n_elements) / sizeof(n_elements[0]); |
| |
| static const GLint divisor = 4; |
| |
| static const GLchar* type_names[] = { "dvec3", "dvec4" }; |
| |
| static const GLint n_rows[] = { |
| 3, 4, |
| }; |
| |
| out_configuration.m_n_attributes_per_group = max_vertex_attribs / divisor; |
| out_configuration.m_n_elements = n_elements; |
| out_configuration.m_n_rows = n_rows; |
| out_configuration.m_n_types = n_types; |
| out_configuration.m_type_names = type_names; |
| } |
| break; |
| case DMAT2: |
| { |
| static const GLint n_elements[] = { n_elements_per_mat2 }; |
| static const GLint n_types = sizeof(n_elements) / sizeof(n_elements[0]); |
| |
| static const GLint divisor = 2; |
| |
| static const GLchar* type_names[] = { "dmat2" }; |
| |
| static const GLint n_rows[] = { 2 }; |
| |
| out_configuration.m_n_attributes_per_group = max_vertex_attribs / divisor; |
| out_configuration.m_n_elements = n_elements; |
| out_configuration.m_n_rows = n_rows; |
| out_configuration.m_n_types = n_types; |
| out_configuration.m_type_names = type_names; |
| } |
| break; |
| case DMAT3X2_DMAT4X2: |
| { |
| static const GLint n_elements[] = { n_elements_per_mat3x2, n_elements_per_mat4x2 }; |
| static const GLint n_types = sizeof(n_elements) / sizeof(n_elements[0]); |
| |
| static const GLint divisor = 8; |
| |
| static const GLchar* type_names[] = { "dmat3x2", "dmat4x2" }; |
| |
| static const GLint n_rows[] = { 2, 2 }; |
| |
| out_configuration.m_n_attributes_per_group = max_vertex_attribs / divisor; |
| out_configuration.m_n_elements = n_elements; |
| out_configuration.m_n_rows = n_rows; |
| out_configuration.m_n_types = n_types; |
| out_configuration.m_type_names = type_names; |
| } |
| break; |
| case DMAT2X3_DMAT2X4: |
| { |
| static const GLint n_elements[] = { n_elements_per_mat2x3, n_elements_per_mat2x4 }; |
| static const GLint n_types = sizeof(n_elements) / sizeof(n_elements[0]); |
| |
| static const GLint divisor = 8; |
| |
| static const GLchar* type_names[] = { "dmat2x3", "dmat2x4" }; |
| |
| static const GLint n_rows[] = { 3, 4 }; |
| |
| out_configuration.m_n_attributes_per_group = max_vertex_attribs / divisor; |
| out_configuration.m_n_elements = n_elements; |
| out_configuration.m_n_rows = n_rows; |
| out_configuration.m_n_types = n_types; |
| out_configuration.m_type_names = type_names; |
| } |
| break; |
| case DMAT3_DMAT3X4: |
| { |
| static const GLint n_elements[] = { n_elements_per_mat3, n_elements_per_mat3x4 }; |
| static const GLint n_types = sizeof(n_elements) / sizeof(n_elements[0]); |
| |
| static const GLint divisor = 12; |
| |
| static const GLchar* type_names[] = { "dmat3", "dmat3x4" }; |
| |
| static const GLint n_rows[] = { 3, 4 }; |
| |
| out_configuration.m_n_attributes_per_group = max_vertex_attribs / divisor; |
| out_configuration.m_n_elements = n_elements; |
| out_configuration.m_n_rows = n_rows; |
| out_configuration.m_n_types = n_types; |
| out_configuration.m_type_names = type_names; |
| } |
| break; |
| case DMAT4X3_DMAT4: |
| { |
| static const GLint n_elements[] = { n_elements_per_mat4x3, n_elements_per_mat4 }; |
| static const GLint n_types = sizeof(n_elements) / sizeof(n_elements[0]); |
| |
| static const GLint divisor = 16; |
| |
| static const GLchar* type_names[] = { "dmat4x3", "dmat4" }; |
| |
| static const GLint n_rows[] = { 3, 4 }; |
| |
| out_configuration.m_n_attributes_per_group = max_vertex_attribs / divisor; |
| out_configuration.m_n_elements = n_elements; |
| out_configuration.m_n_rows = n_rows; |
| out_configuration.m_n_types = n_types; |
| out_configuration.m_type_names = type_names; |
| } |
| break; |
| } |
| |
| calculateVertexLength(out_configuration); |
| } |
| |
| /** Logs iteration and configuration of test |
| * |
| * @param iteration Iteration id |
| * @param use_arrays If attributes are grouped in arrays |
| * @param use_locations If manual attribute locations are used |
| * @param attribute_type Regular, constant or per instance |
| **/ |
| void LimitTest::logTestIterationAndConfig(_iteration iteration, _attributeType attribute_type, bool use_arrays, |
| bool use_locations) const |
| { |
| tcu::MessageBuilder message = m_log << tcu::TestLog::Message; |
| |
| switch (iteration) |
| { |
| case DOUBLE_DVEC2: |
| message << "Iteration: double + dvec2"; |
| |
| break; |
| case DVEC3_DVEC4: |
| message << "Iteration: devc3 + dvec4"; |
| |
| break; |
| case DMAT2: |
| message << "Iteration: dmat2"; |
| |
| break; |
| case DMAT3X2_DMAT4X2: |
| message << "Iteration: dmat3x2 + dmat4x2"; |
| |
| break; |
| case DMAT2X3_DMAT2X4: |
| message << "Iteration: dmat2x3 + dmat2x4"; |
| |
| break; |
| case DMAT3_DMAT3X4: |
| message << "Iteration: dmat3 + dmat3x4"; |
| |
| break; |
| case DMAT4X3_DMAT4: |
| message << "Iteration: dmat4x3 + dmat4"; |
| |
| break; |
| } |
| |
| message << "Configuration: "; |
| |
| if (true == use_arrays) |
| { |
| message << "arrayed attributes"; |
| } |
| else |
| { |
| message << "separate attributes"; |
| } |
| |
| message << ", "; |
| |
| if (true == use_locations) |
| { |
| message << "reversed locations"; |
| } |
| else |
| { |
| message << "default locations"; |
| } |
| |
| message << ", "; |
| |
| switch (attribute_type) |
| { |
| case REGULAR: |
| message << "vertex attribute divisor: 0"; |
| |
| break; |
| case CONSTANT: |
| message << "constant vertex attribute"; |
| |
| break; |
| case PER_INSTANCE: |
| message << "vertex attribute divisor: 1"; |
| |
| break; |
| } |
| |
| message << tcu::TestLog::EndMessage; |
| } |
| |
| /** Prepare program info for given configuration |
| * |
| * @param iteration Iteration id |
| * @param use_arrays If attributes should be grouped in arrays |
| * @param use_locations If manual attribute locations should be used |
| * @param use_vertex_attrib_divisor If vertex attribute divisor should be used |
| * @param program_info Program info |
| **/ |
| void LimitTest::prepareProgram(_iteration iteration, bool use_arrays, bool use_locations, |
| bool use_vertex_attrib_divisor, programInfo& program_info) |
| { |
| static const GLchar* fragment_shader_code = "#version 400\n" |
| "#extension GL_ARB_vertex_attrib_64bit : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " discard;\n" |
| "}\n\n"; |
| std::string varying_name; |
| std::string vertex_shader_code; |
| |
| program_info.m_program_id = gl.createProgram(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "CreateProgram"); |
| |
| getProgramDetails(iteration, use_arrays, use_locations, use_vertex_attrib_divisor, varying_name, |
| vertex_shader_code); |
| |
| { |
| const GLchar* temp_varying_name = varying_name.c_str(); |
| |
| gl.transformFeedbackVaryings(program_info.m_program_id, m_n_varyings, &temp_varying_name, |
| GL_INTERLEAVED_ATTRIBS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "TransformFeedbackVaryings"); |
| } |
| |
| BuildProgram(fragment_shader_code, program_info.m_program_id, vertex_shader_code.c_str(), |
| program_info.m_fragment_shader_id, program_info.m_vertex_shader_id); |
| } |
| |
| /** Configure vertex array object for all attributes |
| * |
| * @param iteration Iteration id |
| * @param attribute_type Regular, constant or per instance |
| * @param program_id Program object id |
| * @param use_arrays If attributes are grouped with arrays |
| **/ |
| void LimitTest::prepareVertexArray(_iteration iteration, _attributeType attribute_type, GLuint program_id, |
| bool use_arrays) const |
| { |
| const GLint max_vertex_attribs = GetMaxVertexAttribs(); |
| const GLuint vertex_attrib_divisor = (PER_INSTANCE == attribute_type) ? 1 : 0; |
| |
| attributeConfiguration configuration; |
| |
| getVertexArrayConfiguration(iteration, configuration); |
| |
| /* Set vertex attributes divisor and disable */ |
| for (GLint i = 0; i < max_vertex_attribs; ++i) |
| { |
| gl.vertexAttribDivisor(i, vertex_attrib_divisor); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "VertexAttribDivisor"); |
| |
| gl.disableVertexAttribArray(i); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DisableVertexAttribArray"); |
| } |
| |
| for (GLint n_type = 0; n_type < configuration.m_n_types; ++n_type) |
| { |
| configureAttribute(iteration, configuration, n_type, program_id, use_arrays, (CONSTANT != attribute_type)); |
| } |
| } |
| |
| /** Prepare vertex buffer data for given iteration |
| * |
| * @param iteration Iteration id |
| **/ |
| void LimitTest::prepareVertexArrayBuffer(_iteration iteration) |
| { |
| GLuint buffer_length = 0; |
| attributeConfiguration configuration; |
| |
| getVertexArrayConfiguration(iteration, configuration); |
| |
| buffer_length = m_n_vertices * configuration.m_vertex_length; |
| |
| std::vector<GLdouble> buffer_data; |
| buffer_data.resize(buffer_length); |
| |
| for (GLuint vertex = 0; vertex < m_n_vertices; ++vertex) |
| { |
| setAttributes(iteration, configuration, vertex, buffer_data); |
| } |
| |
| gl.bufferData(GL_ARRAY_BUFFER, buffer_length * sizeof(GLdouble), &buffer_data[0], GL_STATIC_DRAW); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BufferData"); |
| } |
| |
| /** Set all attributes for <vertex> |
| * |
| * @param iteration Iteration id |
| * @param configuration Attribute configuration |
| * @param vertex Vertex orinal number |
| * @param out_buffer_data Buffer data |
| **/ |
| void LimitTest::setAttributes(_iteration iteration, const attributeConfiguration& configuration, GLuint vertex, |
| std::vector<GLdouble>& out_buffer_data) const |
| { |
| const GLint n_types = configuration.m_n_types; |
| |
| for (GLint n_type = 0; n_type < n_types; ++n_type) |
| { |
| switch (iteration) |
| { |
| case DOUBLE_DVEC2: |
| |
| setAttributes_a(configuration, n_type, vertex, out_buffer_data); |
| |
| break; |
| |
| case DVEC3_DVEC4: |
| |
| setAttributes_b(configuration, n_type, vertex, out_buffer_data); |
| |
| break; |
| |
| case DMAT2: |
| case DMAT3X2_DMAT4X2: |
| case DMAT2X3_DMAT2X4: |
| case DMAT3_DMAT3X4: |
| case DMAT4X3_DMAT4: |
| |
| setAttributes_c(configuration, n_type, vertex, out_buffer_data); |
| |
| break; |
| } |
| } |
| } |
| |
| /** Set attributes of given <n_type> for <vertex>, as described in "iteration a". |
| * |
| * @param configuration Attribute configuration |
| * @param n_type "n_type" ordinal number |
| * @param vertex Vertex orinal number |
| * @param out_buffer_data Buffer data |
| **/ |
| void LimitTest::setAttributes_a(const attributeConfiguration& configuration, GLint n_type, GLuint vertex, |
| std::vector<GLdouble>& out_buffer_data) const |
| { |
| const GLint n_elements = configuration.m_n_elements[n_type]; |
| |
| if (1 == n_elements) |
| { |
| setAttributes_a_scalar(configuration, n_type, vertex, out_buffer_data); |
| } |
| else |
| { |
| setAttributes_a_vec(configuration, n_type, vertex, out_buffer_data); |
| } |
| } |
| |
| /** Set scalar double attributes of given <n_type> for <vertex>, as described in "iteration a". |
| * |
| * @param configuration Attribute configuration |
| * @param n_type "n_type" ordinal number |
| * @param vertex Vertex orinal number |
| * @param out_buffer_data Buffer data |
| **/ |
| void LimitTest::setAttributes_a_scalar(const attributeConfiguration& configuration, GLint n_type, GLuint vertex, |
| std::vector<GLdouble>& out_buffer_data) const |
| { |
| const GLint n_attributes = configuration.m_n_attributes_per_group; |
| const GLint attribute_index = n_attributes * n_type; |
| GLuint vertex_offset = vertex * configuration.m_vertex_length; |
| |
| const GLint group_offset = calculateAttributeGroupOffset(configuration, n_type) + vertex_offset; |
| |
| /* Double attributes should be assigned the value: |
| (n_attribute + gl_VertexID * 2) */ |
| |
| for (GLint attribute = 0; attribute < n_attributes; ++attribute) |
| { |
| const GLuint attribute_offset = attribute + group_offset; |
| |
| out_buffer_data[attribute_offset] = attribute + attribute_index + vertex * 2; |
| } |
| } |
| |
| /** Set dvec2 attributes of given <n_type> for <vertex>, as described in "iteration a". |
| * |
| * @param configuration Attribute configuration |
| * @param n_type "n_type" ordinal number |
| * @param vertex Vertex orinal number |
| * @param out_buffer_data Buffer data |
| **/ |
| void LimitTest::setAttributes_a_vec(const attributeConfiguration& configuration, GLint n_type, GLuint vertex, |
| std::vector<GLdouble>& out_buffer_data) const |
| { |
| const GLint n_attributes = configuration.m_n_attributes_per_group; |
| const GLint attribute_index = n_attributes * n_type; |
| const GLint n_elements = configuration.m_n_elements[n_type]; |
| GLuint vertex_offset = vertex * configuration.m_vertex_length; |
| |
| const GLint group_offset = calculateAttributeGroupOffset(configuration, n_type) + vertex_offset; |
| |
| /* Dvec2 attribute components should be assigned the following |
| vector values: |
| (n_attribute + gl_VertexID * 3 + 1, |
| n_attribute + gl_VertexID * 3 + 2)*/ |
| |
| for (GLint attribute = 0; attribute < n_attributes; ++attribute) |
| { |
| const GLuint attribute_offset = n_elements * attribute + group_offset; |
| |
| for (GLint i = 0; i < n_elements; ++i) |
| { |
| out_buffer_data[attribute_offset + i] = attribute + attribute_index + vertex * 3 + i + 1; |
| } |
| } |
| } |
| |
| /** Set attributes of given <n_type> for <vertex>, as described in "iteration b". |
| * |
| * @param configuration Attribute configuration |
| * @param n_type "n_type" ordinal number |
| * @param vertex Vertex orinal number |
| * @param out_buffer_data Buffer data |
| **/ |
| void LimitTest::setAttributes_b(const attributeConfiguration& configuration, GLint n_type, GLuint vertex, |
| std::vector<GLdouble>& out_buffer_data) const |
| { |
| const GLint n_attributes = configuration.m_n_attributes_per_group; |
| const GLint attribute_index = n_attributes * n_type; |
| const GLint n_elements = configuration.m_n_elements[n_type]; |
| GLuint vertex_offset = vertex * configuration.m_vertex_length; |
| |
| const GLint group_offset = calculateAttributeGroupOffset(configuration, n_type) + vertex_offset; |
| |
| /* Dvec3 attribute components should be assigned the following |
| vector values: |
| (n_attribute + gl_VertexID * 3 + 0, |
| n_attribute + gl_VertexID * 3 + 1, |
| n_attribute + gl_VertexID * 3 + 2). |
| |
| Dvec4 attribute components should be assigned the following |
| vector values: |
| (n_attribute + gl_VertexID * 4 + 0, |
| n_attribute + gl_VertexID * 4 + 1, |
| n_attribute + gl_VertexID * 4 + 2, |
| n_attribute + gl_VertexID * 4 + 3).*/ |
| |
| for (GLint attribute = 0; attribute < n_attributes; ++attribute) |
| { |
| const GLuint attribute_offset = n_elements * attribute + group_offset; |
| |
| for (GLint i = 0; i < n_elements; ++i) |
| { |
| out_buffer_data[attribute_offset + i] = attribute + attribute_index + vertex * n_elements + i; |
| } |
| } |
| } |
| |
| /** Set attributes of given <n_type> for <vertex>, as described in "iteration c". |
| * |
| * @param configuration Attribute configuration |
| * @param n_type "n_type" ordinal number |
| * @param vertex Vertex orinal number |
| * @param out_buffer_data Buffer data |
| **/ |
| void LimitTest::setAttributes_c(const attributeConfiguration& configuration, GLint n_type, GLuint vertex, |
| std::vector<GLdouble>& out_buffer_data) const |
| { |
| const GLint n_attributes = configuration.m_n_attributes_per_group; |
| const GLint attribute_index = n_attributes * n_type; |
| const GLint n_elements = configuration.m_n_elements[n_type]; |
| GLuint vertex_offset = vertex * configuration.m_vertex_length; |
| |
| const GLint group_offset = calculateAttributeGroupOffset(configuration, n_type) + vertex_offset; |
| |
| /* Subsequent matrix elements should be assigned the following value: |
| (n_type + n_attribute + gl_VertexID * 16 + n_value)*/ |
| |
| for (GLint attribute = 0; attribute < n_attributes; ++attribute) |
| { |
| const GLuint attribute_offset = n_elements * attribute + group_offset; |
| |
| for (GLint i = 0; i < n_elements; ++i) |
| { |
| out_buffer_data[attribute_offset + i] = n_type + attribute + attribute_index + vertex * 16 + i; |
| } |
| } |
| } |
| |
| /** Run test with DrawArrays routine |
| * |
| * @return true if test pass, false otherwise |
| **/ |
| bool LimitTest::testDrawArrays() const |
| { |
| gl.beginTransformFeedback(GL_POINTS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); |
| |
| gl.drawArrays(GL_POINTS, 0 /* first */, m_n_vertices); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); |
| |
| gl.endTransformFeedback(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); |
| |
| if (true == verifyResult(false)) |
| { |
| return true; |
| } |
| else |
| { |
| m_log << tcu::TestLog::Message << "Draw function: DrawArrays" << tcu::TestLog::EndMessage; |
| |
| return false; |
| } |
| } |
| |
| /** Run test with DrawArraysInstanced routine |
| * |
| * @return true if test pass, false otherwise |
| **/ |
| bool LimitTest::testDrawArraysInstanced() const |
| { |
| gl.beginTransformFeedback(GL_POINTS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); |
| |
| gl.drawArraysInstanced(GL_POINTS, 0 /* first */, m_n_vertices, m_n_instances); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArraysInstanced"); |
| |
| gl.endTransformFeedback(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); |
| |
| if (true == verifyResult(true)) |
| { |
| return true; |
| } |
| else |
| { |
| m_log << tcu::TestLog::Message << "Draw function: DrawArraysInstanced" << tcu::TestLog::EndMessage; |
| |
| return false; |
| } |
| } |
| |
| /** Run test with DrawElements routine |
| * |
| * @return true if test pass, false otherwise |
| **/ |
| bool LimitTest::testDrawElements() const |
| { |
| gl.beginTransformFeedback(GL_POINTS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); |
| |
| gl.drawElements(GL_POINTS, m_n_vertices, GL_UNSIGNED_INT, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DrawElements"); |
| |
| gl.endTransformFeedback(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); |
| |
| if (true == verifyResult(false)) |
| { |
| return true; |
| } |
| else |
| { |
| m_log << tcu::TestLog::Message << "Draw function: DrawElements" << tcu::TestLog::EndMessage; |
| |
| return false; |
| } |
| } |
| |
| /** Run test with DrawElementsInstanced routine |
| * |
| * @return true if test pass, false otherwise |
| **/ |
| bool LimitTest::testDrawElementsInstanced() const |
| { |
| gl.beginTransformFeedback(GL_POINTS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); |
| |
| gl.drawElementsInstanced(GL_POINTS, m_n_vertices, GL_UNSIGNED_INT, 0, m_n_instances); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DrawElementsInstanced"); |
| |
| gl.endTransformFeedback(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); |
| |
| if (true == verifyResult(true)) |
| { |
| return true; |
| } |
| else |
| { |
| m_log << tcu::TestLog::Message << "Draw function: DrawElementsInstanced" << tcu::TestLog::EndMessage; |
| |
| return false; |
| } |
| } |
| |
| /** Test initialisation |
| * |
| **/ |
| void LimitTest::testInit() |
| { |
| /* Prepare data for element array buffer */ |
| std::vector<GLuint> indices_data; |
| indices_data.resize(m_n_vertices); |
| for (GLuint i = 0; i < m_n_vertices; ++i) |
| { |
| indices_data[i] = i; |
| } |
| |
| /* Prepare vertex array object */ |
| gl.genVertexArrays(1, &m_vertex_array_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GenVertexArrays"); |
| |
| gl.bindVertexArray(m_vertex_array_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindVertexArray"); |
| |
| /* Generate buffers */ |
| gl.genBuffers(1, &m_element_array_buffer_id); |
| gl.genBuffers(1, &m_transoform_feedback_buffer_id); |
| gl.genBuffers(1, &m_vertex_array_buffer_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GenBuffers"); |
| |
| /* Prepare element array buffer */ |
| gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_element_array_buffer_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer"); |
| |
| gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, m_n_vertices * sizeof(GLuint), &indices_data[0], GL_STATIC_DRAW); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BufferData"); |
| |
| /* Prepare transform feedback buffer */ |
| gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_transoform_feedback_buffer_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer"); |
| |
| gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, m_transform_feedback_buffer_size, 0 /* data */, GL_DYNAMIC_COPY); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BufferData"); |
| |
| /* Bind array buffer for future use */ |
| gl.bindBuffer(GL_ARRAY_BUFFER, m_vertex_array_buffer_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer"); |
| |
| /* Disabe rasterization */ |
| gl.enable(GL_RASTERIZER_DISCARD); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Enable"); |
| } |
| |
| /** Tests specified "iteration" |
| * |
| * @param iteration Iteration id |
| * |
| * @return true if tests pass, false otherwise |
| **/ |
| bool LimitTest::testIteration(_iteration iteration) |
| { |
| bool result = true; |
| |
| /* Program infos */ |
| programInfo _no_array__no_location______regular(gl); |
| programInfo use_array__no_location______regular(gl); |
| programInfo _no_array_use_location______regular(gl); |
| programInfo use_array_use_location______regular(gl); |
| programInfo _no_array__no_location_per_instance(gl); |
| programInfo use_array__no_location_per_instance(gl); |
| programInfo _no_array_use_location_per_instance(gl); |
| programInfo use_array_use_location_per_instance(gl); |
| |
| /* Prepare programs for all configuration */ |
| prepareProgram(iteration, false, false, false, _no_array__no_location______regular); |
| prepareProgram(iteration, true, false, false, use_array__no_location______regular); |
| prepareProgram(iteration, false, true, false, _no_array_use_location______regular); |
| prepareProgram(iteration, true, true, false, use_array_use_location______regular); |
| prepareProgram(iteration, false, false, true, _no_array__no_location_per_instance); |
| prepareProgram(iteration, true, false, true, use_array__no_location_per_instance); |
| prepareProgram(iteration, false, true, true, _no_array_use_location_per_instance); |
| prepareProgram(iteration, true, true, true, use_array_use_location_per_instance); |
| |
| /* Bind buffers */ |
| gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_element_array_buffer_id); |
| gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_transoform_feedback_buffer_id, 0, |
| m_transform_feedback_buffer_size); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindBufferRange"); |
| |
| /* Prepare vertex array buffer for iteration */ |
| prepareVertexArrayBuffer(iteration); |
| |
| /* Regular and instanced draw calls, vertex attribute divisor: 0 */ |
| if (false == testProgram(iteration, _no_array__no_location______regular.m_program_id, false)) |
| { |
| logTestIterationAndConfig(iteration, REGULAR, false /* use_arrays */, false /* use_locations */); |
| |
| result = false; |
| } |
| |
| if (false == testProgram(iteration, use_array__no_location______regular.m_program_id, true)) |
| { |
| logTestIterationAndConfig(iteration, REGULAR, true /* use_arrays */, false /* use_locations */); |
| |
| result = false; |
| } |
| |
| if (false == testProgram(iteration, _no_array_use_location______regular.m_program_id, false)) |
| { |
| logTestIterationAndConfig(iteration, REGULAR, false /* use_arrays */, true /* use_locations */); |
| |
| result = false; |
| } |
| |
| if (false == testProgram(iteration, use_array_use_location______regular.m_program_id, true)) |
| { |
| logTestIterationAndConfig(iteration, REGULAR, true /* use_arrays */, true /* use_locations */); |
| |
| result = false; |
| } |
| |
| /* Regular draw calls, constant vertex attribute */ |
| if (false == testProgramWithConstant(iteration, _no_array__no_location_per_instance.m_program_id, false)) |
| { |
| logTestIterationAndConfig(iteration, CONSTANT, false /* use_arrays */, false /* use_locations */); |
| |
| result = false; |
| } |
| |
| if (false == testProgramWithConstant(iteration, use_array__no_location_per_instance.m_program_id, true)) |
| { |
| logTestIterationAndConfig(iteration, CONSTANT, true /* use_arrays */, false /* use_locations */); |
| |
| result = false; |
| } |
| |
| if (false == testProgramWithConstant(iteration, _no_array_use_location_per_instance.m_program_id, false)) |
| { |
| logTestIterationAndConfig(iteration, CONSTANT, false /* use_arrays */, true /* use_locations */); |
| |
| result = false; |
| } |
| |
| if (false == testProgramWithConstant(iteration, use_array_use_location_per_instance.m_program_id, true)) |
| { |
| logTestIterationAndConfig(iteration, CONSTANT, true /* use_arrays */, true /* use_locations */); |
| |
| result = false; |
| } |
| |
| /* Instanced draw calls, vertex attribute divisor: 1 */ |
| if (false == testProgramWithDivisor(iteration, _no_array__no_location_per_instance.m_program_id, false)) |
| { |
| logTestIterationAndConfig(iteration, PER_INSTANCE, false /* use_arrays */, false /* use_locations */); |
| |
| result = false; |
| } |
| |
| if (false == testProgramWithDivisor(iteration, use_array__no_location_per_instance.m_program_id, true)) |
| { |
| logTestIterationAndConfig(iteration, PER_INSTANCE, true /* use_arrays */, false /* use_locations */); |
| |
| result = false; |
| } |
| |
| if (false == testProgramWithDivisor(iteration, _no_array_use_location_per_instance.m_program_id, false)) |
| { |
| logTestIterationAndConfig(iteration, PER_INSTANCE, false /* use_arrays */, true /* use_locations */); |
| |
| result = false; |
| } |
| |
| if (false == testProgramWithDivisor(iteration, use_array_use_location_per_instance.m_program_id, true)) |
| { |
| logTestIterationAndConfig(iteration, PER_INSTANCE, true /* use_arrays */, true /* use_locations */); |
| |
| result = false; |
| } |
| |
| /* Done */ |
| return result; |
| } |
| |
| /** Tests regular and instanced draw calls with vertex attribute divisor set to 0 |
| * |
| * @param iteration Iteration id |
| * @param program_id Program object id |
| * @param use_arrays true if arrays of attributes are used |
| * |
| * @return true if tests pass, false otherwise |
| **/ |
| bool LimitTest::testProgram(_iteration iteration, GLuint program_id, bool use_arrays) const |
| { |
| bool result = true; |
| |
| gl.useProgram(program_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgram"); |
| |
| prepareVertexArray(iteration, REGULAR, program_id, use_arrays); |
| |
| if (false == testDrawArrays()) |
| { |
| result = false; |
| } |
| |
| if (false == testDrawElements()) |
| { |
| result = false; |
| } |
| |
| if (false == testDrawArraysInstanced()) |
| { |
| result = false; |
| } |
| |
| if (false == testDrawElementsInstanced()) |
| { |
| result = false; |
| } |
| |
| return result; |
| } |
| |
| /** Tests constant attributes value, set with VertexAttribLd* routines |
| * |
| * @param iteration Iteration id |
| * @param program_id Program object id |
| * @param use_arrays true if arrays of attributes are used |
| * |
| * @return true if tests pass, false otherwise |
| **/ |
| bool LimitTest::testProgramWithConstant(_iteration iteration, GLuint program_id, bool use_arrays) const |
| { |
| bool result = true; |
| |
| gl.useProgram(program_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgram"); |
| |
| prepareVertexArray(iteration, CONSTANT, program_id, use_arrays); |
| |
| if (false == testDrawArrays()) |
| { |
| result = false; |
| } |
| |
| if (false == testDrawElements()) |
| { |
| result = false; |
| } |
| |
| return result; |
| } |
| |
| /** Tests instanced draw calls with vertex attribute divisor set to 1 |
| * |
| * @param iteration Iteration id |
| * @param program_id Program object id |
| * @param use_arrays true if arrays of attributes are used |
| * |
| * @return true if tests pass, false otherwise |
| **/ |
| bool LimitTest::testProgramWithDivisor(_iteration iteration, GLuint program_id, bool use_arrays) const |
| { |
| bool result = true; |
| |
| gl.useProgram(program_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgram"); |
| |
| prepareVertexArray(iteration, PER_INSTANCE, program_id, use_arrays); |
| |
| if (false == testDrawArraysInstanced()) |
| { |
| result = false; |
| } |
| |
| if (false == testDrawElementsInstanced()) |
| { |
| result = false; |
| } |
| |
| return result; |
| } |
| |
| /** Verifies results |
| * |
| * @param use_instancing true if instanced draw call was made, otherwise false |
| * |
| * @result true if all vertices outputed 1, false otherwise |
| **/ |
| bool LimitTest::verifyResult(bool use_instancing) const |
| { |
| _varyingType* buffer_data = (_varyingType*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); |
| const GLuint n_instances = (true == use_instancing) ? m_n_instances : 1; |
| bool result = true; |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); |
| |
| if (0 == buffer_data) |
| { |
| TCU_FAIL("Failed to map GL_TRANSFORM_FEEDBACK_BUFFER buffer"); |
| } |
| |
| /* For each instance */ |
| for (GLuint instance = 0; instance < n_instances; ++instance) |
| { |
| const GLuint instance_offset = instance * m_n_vertices * m_n_varyings; |
| |
| /* For each vertex */ |
| for (GLuint vertex = 0; vertex < m_n_vertices; ++vertex) |
| { |
| const GLuint vertex_offset = vertex * m_n_varyings; |
| |
| if (1 != buffer_data[vertex_offset + instance_offset]) |
| { |
| if (true == use_instancing) |
| { |
| m_log << tcu::TestLog::Message << "Failure. Instance: " << instance << " Vertex: " << vertex |
| << tcu::TestLog::EndMessage; |
| } |
| else |
| { |
| m_log << tcu::TestLog::Message << "Failure. Vertex: " << vertex << tcu::TestLog::EndMessage; |
| } |
| |
| /* Save failure and break loop */ |
| result = false; |
| |
| /* Sorry about that, but this is nested loop */ |
| goto end; |
| } |
| } |
| } |
| |
| end: |
| gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); |
| |
| return result; |
| } |
| |
| /** Implementation of conformance test "4", description follows. |
| * |
| * Make sure non-trivial VAO configurations are correctly supported |
| * for double-precision floating-point types. |
| * |
| * Consider the following Vertex Buffer Object configurations: |
| * |
| * BO1: |
| * 0 72 73 75 91 96 |
| * --------------+-+--+-------+--- |
| * | A |B| C| D | E| (times 1024) |
| * ------------------------------- |
| * |
| * where: |
| * |
| * A: 3x3 double matrix (72 bytes) |
| * B: 1 unsigned byte (1 byte) |
| * C: 1 short (2 bytes) |
| * D: 2 doubles (16 bytes) |
| * E: padding (5 bytes) |
| * (+) -------- |
| * 96 bytes |
| * |
| * BO2: |
| * --+------------------ |
| * |A| B | (times 1024) |
| * --+------------------ |
| * |
| * where: |
| * |
| * A: 1 signed byte (1 byte) |
| * B: 4x2 double matrix (64 bytes) |
| * (+) -------- |
| * 65 bytes |
| * |
| * A VAO used for the test should be configured as described |
| * below: |
| * |
| * Att 0 (L): VAP-type:GL_DOUBLE, GLSL-type: dmat3, stride:96, |
| * offset: 0, normalized:0, source:BO1; |
| * Att 1 (F): VAP-type:GL_UNSIGNED_BYTE, GLSL-type: float, stride:5, |
| * offset: 0, normalized:1, source:BO2; |
| * Att 2 (L): VAP-type:GL_DOUBLE, GLSL-type: dvec2, stride:96, |
| * offset: 75, normalized:0, source:BO1; |
| * Att 3 (L): VAP-type:GL_DOUBLE, GLSL-type: double, stride:48, |
| * offset: 0, normalized:0, source:BO1; |
| * Att 4 (L): VAP-type:GL_DOUBLE, GLSL-type: dmat4x2, stride:65, |
| * offset: 1, normalized:0, source:BO2; |
| * Att 5 (F): VAP-type:GL_SHORT, GLSL-type: float, stride:96, |
| * offset: 73, normalized:0, source:BO1; |
| * Att 6 (I): VAP-type:GL_BYTE, GLSL-type: int, stride:96, |
| * offset: 72, normalized:1, source:BO1; |
| * |
| * where: |
| * |
| * GLSL-type: Input variable type, as to be used in corresponding |
| * vertex shader. |
| * (F): glVertexAttribPointer() call should be used to configure |
| * given vertex attribute array; |
| * (I): glVertexAttribIPointer() call should be used to configure |
| * given vertex attribute array; |
| * (L): glVertexAttribLPointer() call should be used to configure |
| * given vertex attribute array; |
| * VAP-type: <type> argument as passed to corresponding |
| * glVertexAttrib*Pointer() call. |
| * |
| * The test should use a program object consisting only of VS. |
| * The shader should read all the attributes and store the |
| * values in corresponding output variables. These should then be |
| * XFBed out to the test implementation, which should then verify |
| * the values read in the shader are valid in light of the specification. |
| * |
| * All the draw call types described in test 3) should be tested. |
| * A single draw call for each of the types, rendering a total of |
| * 1024 points should be used for the purpose of the test |
| * |
| **/ |
| class VAOTest : public Base |
| { |
| public: |
| /* Public methods */ |
| VAOTest(deqp::Context& context); |
| |
| virtual ~VAOTest() |
| { |
| } |
| |
| /* Public methods inheritated from TestCase */ |
| virtual void deinit(); |
| virtual tcu::TestNode::IterateResult iterate(); |
| |
| private: |
| /* Private type declarations */ |
| enum _draw_call_type |
| { |
| DRAW_CALL_TYPE_ARRAYS, |
| DRAW_CALL_TYPE_ELEMENTS, |
| |
| /* Always last */ |
| DRAW_CALL_TYPE_COUNT |
| }; |
| |
| /* Private methods */ |
| bool executeTest(_draw_call_type draw_call, bool instanced, bool zero_vertex_attrib_divisor); |
| |
| void initBufferObjects(); |
| void initBuffers(); |
| void initProgramObject(); |
| void initVAO(); |
| |
| bool verifyXFBData(const void* data, _draw_call_type draw_call, bool instanced, bool zero_vertex_attrib_divisor); |
| |
| /* Private fields */ |
| unsigned char* m_bo_1_data; |
| unsigned int m_bo_1_data_size; |
| unsigned int m_bo_1_offset_matrix; |
| unsigned int m_bo_1_offset_ubyte; |
| unsigned int m_bo_1_offset_short; |
| unsigned int m_bo_1_offset_double; |
| unsigned char* m_bo_2_data; |
| unsigned int m_bo_2_data_size; |
| unsigned int m_bo_2_offset_sbyte; |
| unsigned int m_bo_2_offset_matrix; |
| unsigned short* m_bo_index_data; |
| unsigned int m_bo_index_data_size; |
| glw::GLuint m_bo_id_1; |
| glw::GLuint m_bo_id_2; |
| glw::GLuint m_bo_id_indices; |
| glw::GLuint m_bo_id_result; |
| glw::GLint m_po_bo1_dmat3_attr_location; |
| glw::GLint m_po_bo2_dmat4x2_attr_location; |
| glw::GLint m_po_bo1_double_attr_location; |
| glw::GLint m_po_bo1_dvec2_attr_location; |
| glw::GLint m_po_bo1_float2_attr_location; |
| glw::GLint m_po_bo1_int_attr_location; |
| glw::GLint m_po_bo2_float_attr_location; |
| glw::GLuint m_po_id; |
| glw::GLuint m_vao_id; |
| glw::GLuint m_vs_id; |
| unsigned int m_xfb_bo1_dmat3_offset; |
| unsigned int m_xfb_bo1_dmat3_size; |
| unsigned int m_xfb_bo1_double_offset; |
| unsigned int m_xfb_bo1_double_size; |
| unsigned int m_xfb_bo1_dvec2_offset; |
| unsigned int m_xfb_bo1_dvec2_size; |
| unsigned int m_xfb_bo1_float2_offset; |
| unsigned int m_xfb_bo1_float2_size; |
| unsigned int m_xfb_bo1_int_offset; |
| unsigned int m_xfb_bo1_int_size; |
| unsigned int m_xfb_bo2_dmat4x2_offset; |
| unsigned int m_xfb_bo2_dmat4x2_size; |
| unsigned int m_xfb_bo2_float_offset; |
| unsigned int m_xfb_bo2_float_size; |
| unsigned int m_xfb_total_size; |
| |
| const unsigned int m_bo_1_batch_size; |
| const unsigned int m_bo_2_batch_size; |
| const unsigned int m_n_batches; |
| const unsigned int m_n_draw_call_instances; |
| const unsigned int m_nonzero_vertex_attrib_divisor; |
| const unsigned int m_po_bo1_dmat3_attr_offset; |
| const unsigned int m_po_bo1_dmat3_attr_stride; |
| const unsigned int m_po_bo1_double_attr_offset; |
| const unsigned int m_po_bo1_double_attr_stride; |
| const unsigned int m_po_bo1_dvec2_attr_offset; |
| const unsigned int m_po_bo1_dvec2_attr_stride; |
| const unsigned int m_po_bo1_float2_attr_offset; |
| const unsigned int m_po_bo1_float2_attr_stride; |
| const unsigned int m_po_bo1_int_attr_offset; |
| const unsigned int m_po_bo1_int_attr_stride; |
| const unsigned int m_po_bo2_dmat4x2_attr_offset; |
| const unsigned int m_po_bo2_dmat4x2_attr_stride; |
| const unsigned int m_po_bo2_float_attr_offset; |
| const unsigned int m_po_bo2_float_attr_stride; |
| }; |
| |
| /** Constructor |
| * |
| * @param context CTS context instance |
| **/ |
| VAOTest::VAOTest(deqp::Context& context) |
| : Base(context, "vao", "Verify that non-trivial VAO configurations are correctly supported " |
| "for double-precision floating-point types.") |
| , m_bo_1_data(DE_NULL) |
| , m_bo_1_data_size(0) |
| , m_bo_1_offset_matrix(0) |
| , m_bo_1_offset_ubyte(72) |
| , m_bo_1_offset_short(73) |
| , m_bo_1_offset_double(75) |
| , m_bo_2_data(DE_NULL) |
| , m_bo_2_data_size(0) |
| , m_bo_2_offset_sbyte(0) |
| , m_bo_2_offset_matrix(1) |
| , m_bo_index_data(DE_NULL) |
| , m_bo_index_data_size(0) |
| , m_bo_id_1(0) |
| , m_bo_id_2(0) |
| , m_bo_id_indices(0) |
| , m_bo_id_result(0) |
| , m_po_bo1_dmat3_attr_location(-1) |
| , m_po_bo2_dmat4x2_attr_location(-1) |
| , m_po_bo1_double_attr_location(-1) |
| , m_po_bo1_dvec2_attr_location(-1) |
| , m_po_bo1_float2_attr_location(-1) |
| , m_po_bo1_int_attr_location(-1) |
| , m_po_bo2_float_attr_location(-1) |
| , m_po_id(0) |
| , m_vao_id(0) |
| , m_vs_id(0) |
| , m_xfb_bo1_dmat3_offset(0) |
| , m_xfb_bo1_dmat3_size(0) |
| , m_xfb_bo1_double_offset(0) |
| , m_xfb_bo1_double_size(0) |
| , m_xfb_bo1_dvec2_offset(0) |
| , m_xfb_bo1_dvec2_size(0) |
| , m_xfb_bo1_float2_offset(0) |
| , m_xfb_bo1_float2_size(0) |
| , m_xfb_bo1_int_offset(0) |
| , m_xfb_bo1_int_size(0) |
| , m_xfb_bo2_dmat4x2_offset(0) |
| , m_xfb_bo2_dmat4x2_size(0) |
| , m_xfb_bo2_float_offset(0) |
| , m_xfb_bo2_float_size(0) |
| , m_xfb_total_size(0) |
| , m_bo_1_batch_size(96) |
| , m_bo_2_batch_size(65) |
| , m_n_batches(1024) |
| , m_n_draw_call_instances(4) |
| , m_nonzero_vertex_attrib_divisor(2) |
| , m_po_bo1_dmat3_attr_offset(0) |
| , m_po_bo1_dmat3_attr_stride(96) |
| , m_po_bo1_double_attr_offset(0) |
| , m_po_bo1_double_attr_stride(48) |
| , m_po_bo1_dvec2_attr_offset(75) |
| , m_po_bo1_dvec2_attr_stride(96) |
| , m_po_bo1_float2_attr_offset(73) |
| , m_po_bo1_float2_attr_stride(96) |
| , m_po_bo1_int_attr_offset(72) |
| , m_po_bo1_int_attr_stride(96) |
| , m_po_bo2_dmat4x2_attr_offset(1) |
| , m_po_bo2_dmat4x2_attr_stride(65) |
| , m_po_bo2_float_attr_offset(0) |
| , m_po_bo2_float_attr_stride(5) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Deinitializes GL objects and deallocates buffers that may have |
| * been created during test execution */ |
| void VAOTest::deinit() |
| { |
| if (m_bo_1_data != DE_NULL) |
| { |
| delete[] m_bo_1_data; |
| |
| m_bo_1_data = DE_NULL; |
| } |
| |
| if (m_bo_2_data != DE_NULL) |
| { |
| delete[] m_bo_2_data; |
| |
| m_bo_2_data = DE_NULL; |
| } |
| |
| if (m_bo_index_data != DE_NULL) |
| { |
| delete[] m_bo_index_data; |
| |
| m_bo_index_data = DE_NULL; |
| } |
| |
| if (m_bo_id_1 != 0) |
| { |
| gl.deleteBuffers(1, &m_bo_id_1); |
| |
| m_bo_id_1 = 0; |
| } |
| |
| if (m_bo_id_2 != 0) |
| { |
| gl.deleteBuffers(1, &m_bo_id_2); |
| |
| m_bo_id_2 = 0; |
| } |
| |
| if (m_bo_id_indices != 0) |
| { |
| gl.deleteBuffers(1, &m_bo_id_indices); |
| |
| m_bo_id_indices = 0; |
| } |
| |
| if (m_bo_id_result != 0) |
| { |
| gl.deleteBuffers(1, &m_bo_id_result); |
| |
| m_bo_id_result = 0; |
| } |
| |
| if (m_po_id != 0) |
| { |
| gl.deleteProgram(m_po_id); |
| |
| m_po_id = 0; |
| } |
| |
| if (m_vao_id != 0) |
| { |
| gl.deleteVertexArrays(1, &m_vao_id); |
| |
| m_vao_id = 0; |
| } |
| |
| if (m_vs_id != 0) |
| { |
| gl.deleteShader(m_vs_id); |
| |
| m_vs_id = 0; |
| } |
| } |
| |
| /** Executes a single test iteration. |
| * |
| * This function may throw error exceptions if GL implementation misbehaves. |
| * |
| * @param draw_call Type of the draw call that should be issued. |
| * @param instanced True if the draw call should be instanced, false otherwise. |
| * @param zero_vertex_attrib_divisor True if a zero divisor should be used for all checked attributes, |
| * false to use a value of m_nonzero_vertex_attrib_divisor as the divisor. |
| * |
| * @return true if the test iteration passed, false otherwise. |
| **/ |
| bool VAOTest::executeTest(_draw_call_type draw_call, bool instanced, bool zero_vertex_attrib_divisor) |
| { |
| bool result = true; |
| |
| gl.beginTransformFeedback(GL_POINTS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed."); |
| { |
| const glw::GLint divisor = (zero_vertex_attrib_divisor) ? 0 : m_nonzero_vertex_attrib_divisor; |
| const glw::GLint attributes[] = { m_po_bo1_dmat3_attr_location, m_po_bo1_dmat3_attr_location + 1, |
| m_po_bo1_dmat3_attr_location + 2, |
| |
| m_po_bo2_dmat4x2_attr_location, m_po_bo2_dmat4x2_attr_location + 1, |
| m_po_bo2_dmat4x2_attr_location + 2, m_po_bo2_dmat4x2_attr_location + 3, |
| |
| m_po_bo1_double_attr_location, m_po_bo1_dvec2_attr_location, |
| m_po_bo1_float2_attr_location, m_po_bo1_int_attr_location, |
| m_po_bo2_float_attr_location }; |
| const unsigned int n_attributes = sizeof(attributes) / sizeof(attributes[0]); |
| |
| for (unsigned int n_attribute = 0; n_attribute < n_attributes; ++n_attribute) |
| { |
| glw::GLint attribute = attributes[n_attribute]; |
| |
| /* Configure vertex attribute divisor */ |
| gl.vertexAttribDivisor(attribute, divisor); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribDivisor() call failed."); |
| } /* for (all attribute locations) */ |
| |
| /* Issue the draw call */ |
| switch (draw_call) |
| { |
| case DRAW_CALL_TYPE_ARRAYS: |
| { |
| if (instanced) |
| { |
| gl.drawArraysInstanced(GL_POINTS, 0 /* first */, m_n_batches, m_n_draw_call_instances); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArraysInstanced() call failed"); |
| } |
| else |
| { |
| gl.drawArrays(GL_POINTS, 0 /* first */, m_n_batches); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed."); |
| } |
| |
| break; |
| } /* case DRAW_CALL_TYPE_ARRAYS: */ |
| |
| case DRAW_CALL_TYPE_ELEMENTS: |
| { |
| if (instanced) |
| { |
| gl.drawElementsInstanced(GL_POINTS, m_n_batches, GL_UNSIGNED_SHORT, DE_NULL /* indices */, |
| m_n_draw_call_instances); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawElementsInstanced() call failed."); |
| } |
| else |
| { |
| gl.drawElements(GL_POINTS, m_n_batches, GL_UNSIGNED_SHORT, DE_NULL); /* indices */ |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawElements() call failed."); |
| } |
| |
| break; |
| } /* case DRAW_CALL_TYPE_ELEMENTS: */ |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized draw call type"); |
| } |
| } /* switch (draw_call) */ |
| } |
| gl.endTransformFeedback(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed."); |
| |
| /* Retrieve the results */ |
| const void* pXFBData = gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer() call failed."); |
| |
| /* Verify the data */ |
| result = verifyXFBData(pXFBData, draw_call, instanced, zero_vertex_attrib_divisor); |
| |
| /* Unmap the buffer */ |
| gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed."); |
| |
| return result; |
| } |
| |
| /** Initializes buffer objects that will be used by the test. |
| * |
| * This function may throw error exceptions if GL implementation misbehaves. |
| **/ |
| void VAOTest::initBufferObjects() |
| { |
| DE_ASSERT(m_bo_1_data != DE_NULL); |
| DE_ASSERT(m_bo_2_data != DE_NULL); |
| |
| /* Generate BOs */ |
| gl.genBuffers(1, &m_bo_id_1); |
| gl.genBuffers(1, &m_bo_id_2); |
| gl.genBuffers(1, &m_bo_id_indices); |
| gl.genBuffers(1, &m_bo_id_result); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call(s) failed."); |
| |
| /* Initiailize BO storage */ |
| gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id_1); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed."); |
| |
| gl.bufferData(GL_ARRAY_BUFFER, m_bo_1_data_size, m_bo_1_data, GL_STATIC_DRAW); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed."); |
| |
| gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id_2); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed."); |
| |
| gl.bufferData(GL_ARRAY_BUFFER, m_bo_2_data_size, m_bo_2_data, GL_STATIC_DRAW); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed."); |
| |
| gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_bo_id_indices); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed."); |
| |
| gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, m_bo_index_data_size, m_bo_index_data, GL_STATIC_DRAW); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed."); |
| |
| /* Finally, reserve sufficient amount of space for the data to be XFBed out from |
| * the test program. We need: |
| * |
| * a) dmat3: (3 * 3 * 2) components: 18 float components |
| * b) float: (1) component : 1 float component |
| * c) dvec2: (2 * 2) components: 4 float components |
| * d) double: (1 * 2) components: 2 float components |
| * e) dmat4x2: (4 * 2 * 2) components: 16 float components |
| * f) int: (1) components: 1 int component |
| * g) float: (1) component: 1 float components |
| * h) padding: 4 bytes because fp64 buffer needs 8 bytes alignment |
| * (+)------ |
| * (42 float + 1 int + 4 bytes padding) components times 1024 batches: 43008 floats, 1024 ints |
| * |
| * Don't forget about instanced draw calls. We'll be XFBing data for either 1 or m_n_draw_call_instances |
| * instances. |
| */ |
| const unsigned int xfb_dat_pad = sizeof(int); |
| const unsigned int xfb_data_size = |
| static_cast<unsigned int>((42 * sizeof(float) + sizeof(int) + xfb_dat_pad) * 1024 * m_n_draw_call_instances); |
| |
| gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id_result); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed."); |
| |
| gl.bufferData(GL_ARRAY_BUFFER, xfb_data_size, DE_NULL /* data */, GL_STATIC_DRAW); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed."); |
| |
| /* Set up XFB bindings */ |
| gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_bo_id_result); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed."); |
| |
| gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* index */, m_bo_id_result); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed."); |
| } |
| |
| /** Initializes buffers that will later be used to fill storage of buffer objects used by the test. */ |
| void VAOTest::initBuffers() |
| { |
| DE_ASSERT(m_bo_1_data == DE_NULL); |
| DE_ASSERT(m_bo_2_data == DE_NULL); |
| DE_ASSERT(m_bo_index_data == DE_NULL); |
| |
| /* Prepare buffers storing underlying data. The buffers will be used for: |
| * |
| * - storage purposes; |
| * - verification of the data XFBed from the vertex shader. |
| */ |
| m_bo_1_data_size = m_bo_1_batch_size * m_n_batches; |
| m_bo_2_data_size = m_bo_2_batch_size * m_n_batches; |
| m_bo_index_data_size = static_cast<unsigned int>(sizeof(unsigned short) * m_n_batches); |
| |
| m_bo_1_data = new unsigned char[m_bo_1_data_size]; |
| m_bo_2_data = new unsigned char[m_bo_2_data_size]; |
| m_bo_index_data = new unsigned short[m_bo_index_data_size / sizeof(unsigned short)]; |
| |
| /* Workaround for alignment issue that may result in bus error on some platforms */ |
| union { |
| double d; |
| unsigned char c[sizeof(double)]; |
| } u; |
| |
| /* Fill index data */ |
| for (unsigned short n_index = 0; n_index < (unsigned short)m_n_batches; ++n_index) |
| { |
| m_bo_index_data[n_index] = (unsigned short)((unsigned short)(m_n_batches - 1) - n_index); |
| } |
| |
| /* Fill 3x3 matrix data in BO1 */ |
| for (unsigned int n_matrix = 0; n_matrix < m_n_batches; ++n_matrix) |
| { |
| double* matrix_ptr = (double*)(m_bo_1_data + n_matrix * m_bo_1_batch_size + m_bo_1_offset_matrix); |
| |
| for (unsigned int n_element = 0; n_element < 9 /* 3x3 matrix */; ++n_element) |
| { |
| matrix_ptr[n_element] = (double)(n_matrix * 3 * 3 + n_element + 1); |
| } |
| } /* for (all matrices) */ |
| |
| /* Fill unsigned byte data in BO1 */ |
| for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element) |
| { |
| unsigned char* data_ptr = m_bo_1_data + n_element * m_bo_1_batch_size + m_bo_1_offset_ubyte; |
| |
| *data_ptr = (unsigned char)n_element; |
| } |
| |
| /* Fill short data in BO1 */ |
| for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element) |
| { |
| unsigned short* data_ptr = (unsigned short*)(m_bo_1_data + n_element * m_bo_1_batch_size + m_bo_1_offset_short); |
| |
| *data_ptr = (unsigned short)n_element; |
| } |
| |
| /* Fill 2 doubles data in BO1 */ |
| for (unsigned int n_batch = 0; n_batch < m_n_batches; ++n_batch) |
| { |
| unsigned char* data1_ptr = m_bo_1_data + n_batch * m_bo_1_batch_size + m_bo_1_offset_double; |
| unsigned char* data2_ptr = data1_ptr + sizeof(double); |
| |
| u.d = (double)(2 * n_batch); |
| memcpy(data1_ptr, u.c, sizeof(double)); |
| u.d = (double)(2 * n_batch + 1); |
| memcpy(data2_ptr, u.c, sizeof(double)); |
| } |
| |
| /* Fill signed byte data in BO2 */ |
| for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element) |
| { |
| signed char* data_ptr = (signed char*)(m_bo_2_data + n_element * m_bo_2_batch_size + m_bo_2_offset_sbyte); |
| |
| *data_ptr = (signed char)n_element; |
| } |
| |
| /* Fill 4x2 matrix data in BO2 */ |
| for (unsigned int n_matrix = 0; n_matrix < m_n_batches; ++n_matrix) |
| { |
| unsigned char* matrix_ptr = m_bo_2_data + n_matrix * m_bo_2_batch_size + m_bo_2_offset_matrix; |
| |
| for (unsigned int n_element = 0; n_element < 8 /* 4x2 matrix */; ++n_element) |
| { |
| u.d = (double)(n_matrix * 4 * 2 + n_element); |
| memcpy(matrix_ptr + (sizeof(double) * n_element), u.c, sizeof(double)); |
| } |
| } /* for (all matrices) */ |
| } |
| |
| /** Initializes a program object used by the test. |
| * |
| * This function may throw error exceptions if GL implementation misbehaves. |
| * |
| **/ |
| void VAOTest::initProgramObject() |
| { |
| DE_ASSERT(m_po_id == 0); |
| DE_ASSERT(m_vs_id == 0); |
| |
| /* Generate a program object */ |
| m_po_id = gl.createProgram(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed."); |
| |
| /* Configure XFB */ |
| const char* xfb_varyings[] = { "out_bo1_dmat3", "out_bo1_double", "out_bo1_int", "out_bo1_dvec2", |
| "out_bo1_float2", "out_bo2_dmat4x2", "out_bo2_float", "gl_SkipComponents1" }; |
| const unsigned int n_xfb_varyings = sizeof(xfb_varyings) / sizeof(xfb_varyings[0]); |
| |
| gl.transformFeedbackVaryings(m_po_id, n_xfb_varyings, xfb_varyings, GL_INTERLEAVED_ATTRIBS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() call failed."); |
| |
| /* Initialize XFB-specific offset information for the verification routine */ |
| m_xfb_bo1_dmat3_offset = 0; |
| m_xfb_bo1_dmat3_size = sizeof(double) * 3 * 3; |
| m_xfb_bo1_double_offset = m_xfb_bo1_dmat3_offset + m_xfb_bo1_dmat3_size; |
| m_xfb_bo1_double_size = sizeof(double); |
| m_xfb_bo1_int_offset = m_xfb_bo1_double_offset + m_xfb_bo1_double_size; |
| m_xfb_bo1_int_size = sizeof(int); |
| m_xfb_bo1_dvec2_offset = m_xfb_bo1_int_offset + m_xfb_bo1_int_size; |
| m_xfb_bo1_dvec2_size = sizeof(double) * 2; |
| m_xfb_bo1_float2_offset = m_xfb_bo1_dvec2_offset + m_xfb_bo1_dvec2_size; |
| m_xfb_bo1_float2_size = sizeof(float); |
| m_xfb_bo2_dmat4x2_offset = m_xfb_bo1_float2_offset + m_xfb_bo1_float2_size; |
| m_xfb_bo2_dmat4x2_size = sizeof(double) * 4 * 2; |
| m_xfb_bo2_float_offset = m_xfb_bo2_dmat4x2_offset + m_xfb_bo2_dmat4x2_size; |
| m_xfb_bo2_float_size = sizeof(float); |
| m_xfb_total_size = m_xfb_bo1_dmat3_size + m_xfb_bo1_double_size + m_xfb_bo1_int_size + m_xfb_bo1_dvec2_size + |
| m_xfb_bo1_float2_size + m_xfb_bo2_dmat4x2_size + m_xfb_bo2_float_size + sizeof(int); |
| |
| /* Build the test program object */ |
| const char* vs_code = "#version 400\n" |
| "\n" |
| "#extension GL_ARB_vertex_attrib_64bit : require\n" |
| "\n" |
| "in dmat3 in_bo1_dmat3;\n" |
| "in double in_bo1_double;\n" |
| "in dvec2 in_bo1_dvec2;\n" |
| "in float in_bo1_float2;\n" |
| "in int in_bo1_int;\n" |
| "in dmat4x2 in_bo2_dmat4x2;\n" |
| "in float in_bo2_float;\n" |
| "\n" |
| "out dmat3 out_bo1_dmat3;\n" |
| "out double out_bo1_double;\n" |
| "out dvec2 out_bo1_dvec2;\n" |
| "out float out_bo1_float2;\n" |
| "out int out_bo1_int;\n" |
| "out dmat4x2 out_bo2_dmat4x2;\n" |
| "out float out_bo2_float;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " out_bo1_dmat3 = in_bo1_dmat3;\n" |
| " out_bo1_double = in_bo1_double;\n" |
| " out_bo1_dvec2 = in_bo1_dvec2;\n" |
| " out_bo1_int = in_bo1_int;\n" |
| " out_bo1_float2 = in_bo1_float2;\n" |
| " out_bo2_dmat4x2 = in_bo2_dmat4x2;\n" |
| " out_bo2_float = in_bo2_float;\n" |
| "}\n"; |
| |
| BuildProgramVSOnly(m_po_id, vs_code, m_vs_id); |
| |
| m_po_bo1_dmat3_attr_location = gl.getAttribLocation(m_po_id, "in_bo1_dmat3"); |
| m_po_bo1_double_attr_location = gl.getAttribLocation(m_po_id, "in_bo1_double"); |
| m_po_bo1_dvec2_attr_location = gl.getAttribLocation(m_po_id, "in_bo1_dvec2"); |
| m_po_bo1_float2_attr_location = gl.getAttribLocation(m_po_id, "in_bo1_float2"); |
| m_po_bo1_int_attr_location = gl.getAttribLocation(m_po_id, "in_bo1_int"); |
| m_po_bo2_dmat4x2_attr_location = gl.getAttribLocation(m_po_id, "in_bo2_dmat4x2"); |
| m_po_bo2_float_attr_location = gl.getAttribLocation(m_po_id, "in_bo2_float"); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation() call(s) failed."); |
| |
| if (m_po_bo1_dmat3_attr_location == -1 || m_po_bo1_double_attr_location == -1 || |
| m_po_bo1_dvec2_attr_location == -1 || m_po_bo1_int_attr_location == -1 || m_po_bo1_float2_attr_location == -1 || |
| m_po_bo2_dmat4x2_attr_location == -1 || m_po_bo2_float_attr_location == -1) |
| { |
| TCU_FAIL("At least one attribute is considered inactive which is invalid."); |
| } |
| } |
| |
| /** Initializes a vertex array object used by the test. |
| * |
| * This function may throw error exceptions if GL implementation misbehaves. |
| **/ |
| void VAOTest::initVAO() |
| { |
| gl.genVertexArrays(1, &m_vao_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed."); |
| |
| gl.bindVertexArray(m_vao_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed."); |
| |
| /* Set up BO1-sourced attributes */ |
| gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id_1); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed."); |
| |
| gl.vertexAttribLPointer(m_po_bo1_dmat3_attr_location + 0, 3, /* size */ |
| GL_DOUBLE, m_po_bo1_dmat3_attr_stride, |
| (const glw::GLvoid*)(deUintptr)m_po_bo1_dmat3_attr_offset); |
| gl.vertexAttribLPointer(m_po_bo1_dmat3_attr_location + 1, 3, /* size */ |
| GL_DOUBLE, m_po_bo1_dmat3_attr_stride, |
| (const glw::GLvoid*)(m_po_bo1_dmat3_attr_offset + 1 * sizeof(double) * 3)); |
| gl.vertexAttribLPointer(m_po_bo1_dmat3_attr_location + 2, 3, /* size */ |
| GL_DOUBLE, m_po_bo1_dmat3_attr_stride, |
| (const glw::GLvoid*)(m_po_bo1_dmat3_attr_offset + 2 * sizeof(double) * 3)); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribLPointer() call(s) failed."); |
| |
| gl.enableVertexAttribArray(m_po_bo1_dmat3_attr_location + 0); |
| gl.enableVertexAttribArray(m_po_bo1_dmat3_attr_location + 1); |
| gl.enableVertexAttribArray(m_po_bo1_dmat3_attr_location + 2); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() call(s) failed."); |
| |
| gl.vertexAttribLPointer(m_po_bo1_dvec2_attr_location, 2, /* size */ |
| GL_DOUBLE, m_po_bo1_dvec2_attr_stride, |
| (const glw::GLvoid*)(deUintptr)m_po_bo1_dvec2_attr_offset); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribLPointer() call failed."); |
| |
| gl.enableVertexAttribArray(m_po_bo1_dvec2_attr_location); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() call failed."); |
| |
| gl.vertexAttribLPointer(m_po_bo1_double_attr_location, 1, /* size */ |
| GL_DOUBLE, m_po_bo1_double_attr_stride, |
| (const glw::GLvoid*)(deUintptr)m_po_bo1_double_attr_offset); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribLPointer() call failed."); |
| |
| gl.enableVertexAttribArray(m_po_bo1_double_attr_location); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() call failed."); |
| |
| gl.vertexAttribPointer(m_po_bo1_float2_attr_location, 1, /* size */ |
| GL_SHORT, GL_FALSE, /* normalized */ |
| m_po_bo1_float2_attr_stride, (const glw::GLvoid*)(deUintptr)m_po_bo1_float2_attr_offset); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer() call failed."); |
| |
| gl.enableVertexAttribArray(m_po_bo1_float2_attr_location); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() call failed."); |
| |
| gl.vertexAttribIPointer(m_po_bo1_int_attr_location, 1, /* size */ |
| GL_BYTE, m_po_bo1_int_attr_stride, (const glw::GLvoid*)(deUintptr)m_po_bo1_int_attr_offset); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribIPointer() call failed."); |
| |
| gl.enableVertexAttribArray(m_po_bo1_int_attr_location); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() call failed."); |
| |
| /* Set up BO2-sourced attributes */ |
| gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id_2); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed."); |
| |
| gl.vertexAttribPointer(m_po_bo2_float_attr_location, 1, /* size */ |
| GL_UNSIGNED_BYTE, GL_TRUE, m_po_bo2_float_attr_stride, |
| (const glw::GLvoid*)(deUintptr)m_po_bo2_float_attr_offset); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer() call failed."); |
| |
| gl.enableVertexAttribArray(m_po_bo2_float_attr_location); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() call failed."); |
| |
| gl.vertexAttribLPointer(m_po_bo2_dmat4x2_attr_location + 0, 2, /* size */ |
| GL_DOUBLE, m_po_bo2_dmat4x2_attr_stride, |
| (const glw::GLvoid*)(deUintptr)m_po_bo2_dmat4x2_attr_offset); |
| gl.vertexAttribLPointer(m_po_bo2_dmat4x2_attr_location + 1, 2, /* size */ |
| GL_DOUBLE, m_po_bo2_dmat4x2_attr_stride, |
| (const glw::GLvoid*)(m_po_bo2_dmat4x2_attr_offset + 2 * sizeof(double))); |
| gl.vertexAttribLPointer(m_po_bo2_dmat4x2_attr_location + 2, 2, /* size */ |
| GL_DOUBLE, m_po_bo2_dmat4x2_attr_stride, |
| (const glw::GLvoid*)(m_po_bo2_dmat4x2_attr_offset + 4 * sizeof(double))); |
| gl.vertexAttribLPointer(m_po_bo2_dmat4x2_attr_location + 3, 2, /* size */ |
| GL_DOUBLE, m_po_bo2_dmat4x2_attr_stride, |
| (const glw::GLvoid*)(m_po_bo2_dmat4x2_attr_offset + 6 * sizeof(double))); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribLPointer() call failed."); |
| |
| gl.enableVertexAttribArray(m_po_bo2_dmat4x2_attr_location + 0); |
| gl.enableVertexAttribArray(m_po_bo2_dmat4x2_attr_location + 1); |
| gl.enableVertexAttribArray(m_po_bo2_dmat4x2_attr_location + 2); |
| gl.enableVertexAttribArray(m_po_bo2_dmat4x2_attr_location + 3); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() call(s) failed."); |
| |
| /* Set up element binding */ |
| gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_bo_id_indices); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed."); |
| } |
| |
| /** Executes the test |
| * |
| * @return tcu::TestNode::STOP |
| **/ |
| tcu::TestNode::IterateResult VAOTest::iterate() |
| { |
| IterateStart(); |
| |
| bool result = true; |
| |
| RequireExtension("GL_ARB_vertex_attrib_64bit"); |
| |
| /* Initialize GL objects required to run the test */ |
| initBuffers(); |
| initBufferObjects(); |
| initProgramObject(); |
| initVAO(); |
| |
| /* Activate the program object before we continue */ |
| gl.useProgram(m_po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); |
| |
| /* Iterate through all draw call combinations */ |
| for (int n_draw_call_type = 0; n_draw_call_type < DRAW_CALL_TYPE_COUNT; ++n_draw_call_type) |
| { |
| _draw_call_type draw_call = (_draw_call_type)n_draw_call_type; |
| |
| for (int n_instanced_draw_call = 0; n_instanced_draw_call <= 1; /* false & true */ |
| ++n_instanced_draw_call) |
| { |
| bool instanced_draw_call = (n_instanced_draw_call == 1); |
| |
| for (int n_vertex_attrib_divisor = 0; n_vertex_attrib_divisor <= 1; /* 0 & non-zero divisor */ |
| ++n_vertex_attrib_divisor) |
| { |
| bool zero_vertex_attrib_divisor = (n_vertex_attrib_divisor == 0); |
| |
| /* Execute the test */ |
| result &= executeTest(draw_call, instanced_draw_call, zero_vertex_attrib_divisor); |
| } /* for (two vertex attrib divisor configurations) */ |
| } /* for (non-instanced & instanced draw calls) */ |
| } /* for (array-based & indiced draw calls) */ |
| |
| /* Done */ |
| return IterateStop(result); |
| } |
| |
| /** Verifies data that has been XFBed out by the draw call. |
| * |
| * @param data XFBed data. Must not be NULL. |
| * @param draw_call Type of the draw call that was issued. |
| * @param instanced True if the draw call was instanced, false otherwise. |
| * @param zero_vertex_attrib_divisor True if a zero divisor was used for all checked attributes, |
| * false if the divisors were set to a value of m_nonzero_vertex_attrib_divisor. |
| */ |
| bool VAOTest::verifyXFBData(const void* data, _draw_call_type draw_call, bool instanced, |
| bool zero_vertex_attrib_divisor) |
| { |
| const float epsilon = 1e-5f; |
| bool is_indiced = (draw_call == DRAW_CALL_TYPE_ELEMENTS); |
| const unsigned int n_instances = (instanced) ? m_n_draw_call_instances : 1; |
| bool result = true; |
| const unsigned char* xfb_data_ptr = (const unsigned char*)data; |
| |
| for (unsigned int n_instance = 0; n_instance < n_instances; ++n_instance) |
| { |
| /* Verify dmat3 data from BO1 has been exposed correctly */ |
| for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element) |
| { |
| unsigned int in_index = n_element; |
| unsigned int xfb_index = is_indiced ? m_bo_index_data[n_element] : n_element; |
| |
| if (!zero_vertex_attrib_divisor) |
| { |
| in_index = n_instance / m_nonzero_vertex_attrib_divisor; |
| } |
| |
| const double* in_matrix_data_ptr = |
| (const double*)(m_bo_1_data + (in_index)*m_po_bo1_dmat3_attr_stride + m_po_bo1_dmat3_attr_offset); |
| const double* xfb_matrix_data_ptr = |
| (const double*)(xfb_data_ptr + (m_n_batches * n_instance + xfb_index) * m_xfb_total_size + |
| m_xfb_bo1_dmat3_offset); |
| |
| if (memcmp(in_matrix_data_ptr, xfb_matrix_data_ptr, m_xfb_bo1_dmat3_size) != 0) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "BO1 dmat3 attribute values mismatch for batch [" |
| << n_element << "]" |
| ", expected:[" |
| << in_matrix_data_ptr[0] << ", " << in_matrix_data_ptr[1] << ", " |
| << in_matrix_data_ptr[2] << ", " << in_matrix_data_ptr[3] << ", " |
| << in_matrix_data_ptr[4] << ", " << in_matrix_data_ptr[5] << ", " |
| << in_matrix_data_ptr[6] << ", " << in_matrix_data_ptr[7] << ", " |
| << in_matrix_data_ptr[8] << ", " |
| << "], XFBed out:[" << xfb_matrix_data_ptr[0] << ", " << xfb_matrix_data_ptr[1] |
| << ", " << xfb_matrix_data_ptr[2] << ", " << xfb_matrix_data_ptr[3] << ", " |
| << xfb_matrix_data_ptr[4] << ", " << xfb_matrix_data_ptr[5] << ", " |
| << xfb_matrix_data_ptr[6] << ", " << xfb_matrix_data_ptr[7] << ", " |
| << xfb_matrix_data_ptr[8] << ", " |
| << "]" << tcu::TestLog::EndMessage; |
| |
| result = false; |
| break; |
| } |
| } |
| |
| /* Verify float data from BO2 has been exposed correctly */ |
| for (unsigned int n_batch = 0; n_batch < m_n_batches; ++n_batch) |
| { |
| unsigned int in_index = n_batch; |
| const unsigned int xfb_index = is_indiced ? m_bo_index_data[n_batch] : n_batch; |
| |
| if (!zero_vertex_attrib_divisor) |
| { |
| in_index = n_instance / m_nonzero_vertex_attrib_divisor; |
| } |
| |
| const unsigned char* in_ubyte_data_ptr = |
| (const unsigned char*)(m_bo_2_data + (in_index)*m_po_bo2_float_attr_stride + |
| m_po_bo2_float_attr_offset); |
| const float* xfb_float_data_ptr = |
| (const float*)(xfb_data_ptr + (m_n_batches * n_instance + xfb_index) * m_xfb_total_size + |
| m_xfb_bo2_float_offset); |
| float expected_value = ((float)*in_ubyte_data_ptr / 255.0f); |
| |
| if (de::abs(expected_value - *xfb_float_data_ptr) > epsilon) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "BO2 float attribute value mismatch for batch [" |
| << n_batch << "]" |
| ", expected: [" |
| << expected_value << "]" |
| ", XFBed out:[" |
| << *xfb_float_data_ptr << "]" << tcu::TestLog::EndMessage; |
| |
| result = false; |
| break; |
| } |
| } |
| |
| /* Verify dvec2 data from BO1 has been exposed correctly */ |
| for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element) |
| { |
| unsigned int in_index = n_element; |
| const unsigned int xfb_index = is_indiced ? m_bo_index_data[n_element] : n_element; |
| |
| if (!zero_vertex_attrib_divisor) |
| { |
| in_index = n_instance / m_nonzero_vertex_attrib_divisor; |
| } |
| |
| const double* in_dvec2_data_ptr = |
| (const double*)(m_bo_1_data + (in_index)*m_po_bo1_dvec2_attr_stride + m_po_bo1_dvec2_attr_offset); |
| const double* xfb_dvec2_data_ptr = |
| (const double*)(xfb_data_ptr + (m_n_batches * n_instance + xfb_index) * m_xfb_total_size + |
| m_xfb_bo1_dvec2_offset); |
| |
| if (memcmp(in_dvec2_data_ptr, in_dvec2_data_ptr, m_xfb_bo1_dvec2_size) != 0) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "BO1 dvec2 attribute values mismatch for batch [" |
| << n_element << "]" |
| ", expected:[" |
| << in_dvec2_data_ptr[0] << ", " << in_dvec2_data_ptr[1] << ", " |
| << "], XFBed out:[" << xfb_dvec2_data_ptr[0] << ", " << xfb_dvec2_data_ptr[1] << ", " |
| << "]" << tcu::TestLog::EndMessage; |
| |
| result = false; |
| break; |
| } |
| } |
| |
| /* Verify double data from BO1 has been exposed correctly */ |
| for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element) |
| { |
| unsigned int in_index = n_element; |
| const unsigned int xfb_index = is_indiced ? m_bo_index_data[n_element] : n_element; |
| |
| if (!zero_vertex_attrib_divisor) |
| { |
| in_index = n_instance / m_nonzero_vertex_attrib_divisor; |
| } |
| |
| const double* in_double_data_ptr = |
| (const double*)(m_bo_1_data + (in_index)*m_po_bo1_double_attr_stride + m_po_bo1_double_attr_offset); |
| const double* xfb_double_data_ptr = |
| (const double*)(xfb_data_ptr + (m_n_batches * n_instance + xfb_index) * m_xfb_total_size + |
| m_xfb_bo1_double_offset); |
| |
| if (memcmp(in_double_data_ptr, xfb_double_data_ptr, m_xfb_bo1_double_size) != 0) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "BO1 double attribute value mismatch for batch [" |
| << n_element << "]" |
| ", expected: [" |
| << *in_double_data_ptr << "]" |
| ", XFBed out:[" |
| << *xfb_double_data_ptr << "]" << tcu::TestLog::EndMessage; |
| |
| result = false; |
| break; |
| } |
| } |
| |
| /* Verify dmat4x2 data from BO2 has been exposed correctly */ |
| for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element) |
| { |
| unsigned int in_index = n_element; |
| const unsigned int xfb_index = is_indiced ? m_bo_index_data[n_element] : n_element; |
| |
| if (!zero_vertex_attrib_divisor) |
| { |
| in_index = n_instance / m_nonzero_vertex_attrib_divisor; |
| } |
| |
| const unsigned char* in_matrix_data_ptr = |
| m_bo_2_data + (in_index)*m_po_bo2_dmat4x2_attr_stride + m_po_bo2_dmat4x2_attr_offset; |
| const unsigned char* xfb_matrix_data_ptr = |
| xfb_data_ptr + (m_n_batches * n_instance + xfb_index) * m_xfb_total_size + m_xfb_bo2_dmat4x2_offset; |
| |
| if (memcmp(in_matrix_data_ptr, xfb_matrix_data_ptr, m_xfb_bo2_dmat4x2_size) != 0) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "BO2 dmat4x2 attribute values mismatch for batch [" |
| << n_element << "]" |
| ", expected:[" |
| << in_matrix_data_ptr[0] << ", " << in_matrix_data_ptr[1] << ", " |
| << in_matrix_data_ptr[2] << ", " << in_matrix_data_ptr[3] << ", " |
| << in_matrix_data_ptr[4] << ", " << in_matrix_data_ptr[5] << ", " |
| << in_matrix_data_ptr[6] << ", " << in_matrix_data_ptr[7] << ", " |
| << "], XFBed out:[" << xfb_matrix_data_ptr[0] << ", " << xfb_matrix_data_ptr[1] |
| << ", " << xfb_matrix_data_ptr[2] << ", " << xfb_matrix_data_ptr[3] << ", " |
| << xfb_matrix_data_ptr[4] << ", " << xfb_matrix_data_ptr[5] << ", " |
| << xfb_matrix_data_ptr[6] << ", " << xfb_matrix_data_ptr[7] << ", " |
| << "]" << tcu::TestLog::EndMessage; |
| |
| result = false; |
| break; |
| } |
| } |
| |
| /* Verify int data from BO1 has been exposed correctly */ |
| for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element) |
| { |
| unsigned int in_index = n_element; |
| const unsigned int xfb_index = is_indiced ? m_bo_index_data[n_element] : n_element; |
| |
| if (!zero_vertex_attrib_divisor) |
| { |
| in_index = n_instance / m_nonzero_vertex_attrib_divisor; |
| } |
| |
| const signed char* in_char_data_ptr = |
| (const signed char*)(m_bo_1_data + (in_index)*m_po_bo1_int_attr_stride + m_po_bo1_int_attr_offset); |
| const signed int* xfb_int_data_ptr = |
| (const signed int*)(xfb_data_ptr + (m_n_batches * n_instance + xfb_index) * m_xfb_total_size + |
| m_xfb_bo1_int_offset); |
| |
| if (de::abs((signed int)*in_char_data_ptr - *xfb_int_data_ptr) > epsilon) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "BO1 int attribute value mismatch for batch [" |
| << n_element << "]" |
| ", expected: [" |
| << (signed int)*in_char_data_ptr << "]" |
| ", XFBed out:[" |
| << *xfb_int_data_ptr << "]" << tcu::TestLog::EndMessage; |
| |
| result = false; |
| break; |
| } |
| } |
| |
| /* Verify float data from BO1 has been exposed correctly */ |
| for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element) |
| { |
| unsigned int in_index = n_element; |
| const unsigned int xfb_index = is_indiced ? m_bo_index_data[n_element] : n_element; |
| |
| if (!zero_vertex_attrib_divisor) |
| { |
| in_index = n_instance / m_nonzero_vertex_attrib_divisor; |
| } |
| |
| const unsigned short* in_short_data_ptr = |
| (const unsigned short*)(m_bo_1_data + (in_index)*m_po_bo1_float2_attr_stride + |
| m_po_bo1_float2_attr_offset); |
| const float* xfb_float_data_ptr = |
| (const float*)(xfb_data_ptr + (m_n_batches * n_instance + xfb_index) * m_xfb_total_size + |
| m_xfb_bo1_float2_offset); |
| |
| if (de::abs(*in_short_data_ptr - *xfb_float_data_ptr) > epsilon) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "BO1 float attribute value mismatch for batch [" |
| << n_element << "]" |
| ", expected: [" |
| << (signed int)*in_short_data_ptr << "]" |
| ", XFBed out:[" |
| << *xfb_float_data_ptr << "]" << tcu::TestLog::EndMessage; |
| |
| result = false; |
| break; |
| } |
| } |
| } /* for (all instances) */ |
| |
| return result; |
| } |
| |
| } /* namespace VertexAttrib64Bit */ |
| |
| namespace gl4cts |
| { |
| |
| VertexAttrib64BitTests::VertexAttrib64BitTests(deqp::Context& context) |
| : TestCaseGroup(context, "vertex_attrib_64bit", "Verifes GL_ARB_vertex_attrib_64bit functionality") |
| { |
| /* Nothing to be done here */ |
| } |
| |
| void VertexAttrib64BitTests::init(void) |
| { |
| addChild(new VertexAttrib64Bit::ApiErrorsTest(m_context)); |
| addChild(new VertexAttrib64Bit::GetVertexAttribTest(m_context)); |
| addChild(new VertexAttrib64Bit::LimitTest(m_context)); |
| addChild(new VertexAttrib64Bit::VAOTest(m_context)); |
| } |
| |
| } /* namespace gl4cts */ |
