| /*------------------------------------------------------------------------- |
| * 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 gl4cShaderSubroutineTests.cpp |
| * \brief Implements conformance tests for "Shader Subroutine" functionality. |
| */ /*-------------------------------------------------------------------*/ |
| |
| #include "gl4cShaderSubroutineTests.hpp" |
| #include "gluContextInfo.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| #include "tcuMatrix.hpp" |
| #include <cmath> |
| #include <cstring> |
| #include <deMath.h> |
| |
| using namespace glw; |
| |
| namespace gl4cts |
| { |
| namespace ShaderSubroutine |
| { |
| /** Constructor. |
| * |
| * @param context CTS context. |
| **/ |
| Utils::buffer::buffer(deqp::Context& context) : m_id(0), m_context(context) |
| { |
| } |
| |
| /** Destructor |
| * |
| **/ |
| Utils::buffer::~buffer() |
| { |
| if (0 != m_id) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.deleteBuffers(1, &m_id); |
| m_id = 0; |
| } |
| } |
| |
| /** Execute BindBufferRange |
| * |
| * @param target <target> parameter |
| * @param index <index> parameter |
| * @param offset <offset> parameter |
| * @param size <size> parameter |
| **/ |
| void Utils::buffer::bindRange(glw::GLenum target, glw::GLuint index, glw::GLintptr offset, glw::GLsizeiptr size) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.bindBufferRange(target, index, m_id, offset, size); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindBufferRange"); |
| } |
| |
| /** Execute GenBuffer |
| * |
| **/ |
| void Utils::buffer::generate() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.genBuffers(1, &m_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GenBuffers"); |
| } |
| |
| /** Execute BufferData |
| * |
| * @param target <target> parameter |
| * @param size <size> parameter |
| * @param data <data> parameter |
| * @param usage <usage> parameter |
| **/ |
| void Utils::buffer::update(glw::GLenum target, glw::GLsizeiptr size, glw::GLvoid* data, glw::GLenum usage) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.bindBuffer(target, m_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "bindBuffer"); |
| |
| gl.bufferData(target, size, data, usage); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "bufferData"); |
| } |
| |
| /** Constructor |
| * |
| * @param context CTS context |
| **/ |
| Utils::framebuffer::framebuffer(deqp::Context& context) : m_id(0), m_context(context) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Destructor |
| * |
| **/ |
| Utils::framebuffer::~framebuffer() |
| { |
| if (0 != m_id) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.deleteFramebuffers(1, &m_id); |
| m_id = 0; |
| } |
| } |
| |
| /** Attach texture to specified attachment |
| * |
| * @param attachment Attachment |
| * @param texture_id Texture id |
| * @param width Texture width |
| * @param height Texture height |
| **/ |
| void Utils::framebuffer::attachTexture(glw::GLenum attachment, glw::GLuint texture_id, glw::GLuint width, |
| glw::GLuint height) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| bind(); |
| |
| gl.bindTexture(GL_TEXTURE_2D, texture_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture"); |
| |
| gl.framebufferTexture2D(GL_DRAW_FRAMEBUFFER, attachment, GL_TEXTURE_2D, texture_id, 0 /* level */); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "FramebufferTexture2D"); |
| |
| gl.viewport(0 /* x */, 0 /* y */, width, height); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Viewport"); |
| } |
| |
| /** Binds framebuffer to DRAW_FRAMEBUFFER |
| * |
| **/ |
| void Utils::framebuffer::bind() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, m_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindFramebuffer"); |
| } |
| |
| /** Clear framebuffer |
| * |
| * @param mask <mask> parameter of glClear. Decides which shall be cleared |
| **/ |
| void Utils::framebuffer::clear(glw::GLenum mask) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.clear(mask); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Clear"); |
| } |
| |
| /** Specifie clear color |
| * |
| * @param red Red channel |
| * @param green Green channel |
| * @param blue Blue channel |
| * @param alpha Alpha channel |
| **/ |
| void Utils::framebuffer::clearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.clearColor(red, green, blue, alpha); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "ClearColor"); |
| } |
| |
| /** Generate framebuffer |
| * |
| **/ |
| void Utils::framebuffer::generate() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.genFramebuffers(1, &m_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GenFramebuffers"); |
| } |
| |
| const glw::GLenum Utils::program::ARB_COMPUTE_SHADER = 0x91B9; |
| |
| /** Constructor. |
| * |
| * @param context CTS context. |
| **/ |
| Utils::program::program(deqp::Context& context) |
| : m_compute_shader_id(0) |
| , m_fragment_shader_id(0) |
| , m_geometry_shader_id(0) |
| , m_program_object_id(0) |
| , m_tesselation_control_shader_id(0) |
| , m_tesselation_evaluation_shader_id(0) |
| , m_vertex_shader_id(0) |
| , m_context(context) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Destructor |
| * |
| **/ |
| Utils::program::~program() |
| { |
| remove(); |
| } |
| |
| /** Build program |
| * |
| * @param compute_shader_code Compute shader source code |
| * @param fragment_shader_code Fragment shader source code |
| * @param geometry_shader_code Geometry shader source code |
| * @param tesselation_control_shader_code Tesselation control shader source code |
| * @param tesselation_evaluation_shader_code Tesselation evaluation shader source code |
| * @param vertex_shader_code Vertex shader source code |
| * @param varying_names Array of strings containing names of varyings to be captured with transfrom feedback |
| * @param n_varying_names Number of varyings to be captured with transfrom feedback |
| * @param is_separable Selects if monolithis or separable program should be built. Defaults to false |
| **/ |
| void Utils::program::build(const glw::GLchar* compute_shader_code, const glw::GLchar* fragment_shader_code, |
| const glw::GLchar* geometry_shader_code, const glw::GLchar* tesselation_control_shader_code, |
| const glw::GLchar* tesselation_evaluation_shader_code, const glw::GLchar* vertex_shader_code, |
| const glw::GLchar* const* varying_names, glw::GLuint n_varying_names, bool is_separable) |
| { |
| /* GL entry points */ |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Create shader objects and compile */ |
| if (0 != compute_shader_code) |
| { |
| m_compute_shader_id = gl.createShader(ARB_COMPUTE_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); |
| |
| compile(m_compute_shader_id, compute_shader_code); |
| } |
| |
| if (0 != fragment_shader_code) |
| { |
| m_fragment_shader_id = gl.createShader(GL_FRAGMENT_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); |
| |
| compile(m_fragment_shader_id, fragment_shader_code); |
| } |
| |
| if (0 != geometry_shader_code) |
| { |
| m_geometry_shader_id = gl.createShader(GL_GEOMETRY_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); |
| |
| compile(m_geometry_shader_id, geometry_shader_code); |
| } |
| |
| if (0 != tesselation_control_shader_code) |
| { |
| m_tesselation_control_shader_id = gl.createShader(GL_TESS_CONTROL_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); |
| |
| compile(m_tesselation_control_shader_id, tesselation_control_shader_code); |
| } |
| |
| if (0 != tesselation_evaluation_shader_code) |
| { |
| m_tesselation_evaluation_shader_id = gl.createShader(GL_TESS_EVALUATION_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); |
| |
| compile(m_tesselation_evaluation_shader_id, tesselation_evaluation_shader_code); |
| } |
| |
| if (0 != vertex_shader_code) |
| { |
| m_vertex_shader_id = gl.createShader(GL_VERTEX_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader"); |
| |
| compile(m_vertex_shader_id, vertex_shader_code); |
| } |
| |
| /* Create program object */ |
| m_program_object_id = gl.createProgram(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "CreateProgram"); |
| |
| /* Set up captyured varyings' names */ |
| if (0 != n_varying_names) |
| { |
| gl.transformFeedbackVaryings(m_program_object_id, n_varying_names, varying_names, GL_INTERLEAVED_ATTRIBS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "TransformFeedbackVaryings"); |
| } |
| |
| /* Set separable parameter */ |
| if (true == is_separable) |
| { |
| gl.programParameteri(m_program_object_id, GL_PROGRAM_SEPARABLE, GL_TRUE); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "ProgramParameteri"); |
| } |
| |
| /* Link program */ |
| link(); |
| } |
| |
| /** Compile shader |
| * |
| * @param shader_id Shader object id |
| * @param shader_code Shader source code |
| **/ |
| void Utils::program::compile(glw::GLuint shader_id, const glw::GLchar* shader_code) const |
| { |
| /* GL entry points */ |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Compilation status */ |
| glw::GLint status = GL_FALSE; |
| |
| /* Set source code */ |
| gl.shaderSource(shader_id, 1 /* count */, &shader_code, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderSource"); |
| |
| /* Compile */ |
| gl.compileShader(shader_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "CompileShader"); |
| |
| /* Get compilation status */ |
| gl.getShaderiv(shader_id, GL_COMPILE_STATUS, &status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv"); |
| |
| /* Log compilation error */ |
| if (GL_TRUE != status) |
| { |
| glw::GLint length = 0; |
| std::vector<glw::GLchar> message; |
| |
| /* Error log length */ |
| gl.getShaderiv(shader_id, GL_INFO_LOG_LENGTH, &length); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv"); |
| |
| /* Prepare storage */ |
| message.resize(length); |
| |
| /* Get error log */ |
| gl.getShaderInfoLog(shader_id, length, 0, &message[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderInfoLog"); |
| |
| /* Log */ |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Failed to compile shader:\n" |
| << &message[0] << "\nShader source\n" |
| << shader_code << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Failed to compile shader"); |
| } |
| } |
| |
| /** Checks whether the tested driver supports GL_ARB_get_program_binary |
| * |
| * @return true if the extension is supported and, also, at least one binary format. |
| **/ |
| bool Utils::program::isProgramBinarySupported() const |
| { |
| glw::GLint n_program_binary_formats = 0; |
| |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_context.getContextInfo().isExtensionSupported("GL_ARB_get_program_binary")) |
| { |
| gl.getIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &n_program_binary_formats); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() call failed."); |
| } |
| |
| return n_program_binary_formats > 0; |
| } |
| |
| /** Create program from provided binary |
| * |
| * @param binary Buffer with binary form of program |
| * @param binary_format Format of <binary> data |
| **/ |
| void Utils::program::createFromBinary(const std::vector<GLubyte>& binary, GLenum binary_format) |
| { |
| /* GL entry points */ |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Create program object */ |
| m_program_object_id = gl.createProgram(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "CreateProgram"); |
| |
| gl.programBinary(m_program_object_id, binary_format, &binary[0], (GLsizei)binary.size()); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "ProgramBinary"); |
| } |
| |
| /** Get binary form of program |
| * |
| * @param binary Buffer for binary data |
| * @param binary_format Format of binary data |
| **/ |
| void Utils::program::getBinary(std::vector<GLubyte>& binary, GLenum& binary_format) const |
| { |
| /* GL entry points */ |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Get binary size */ |
| GLint length = 0; |
| gl.getProgramiv(m_program_object_id, GL_PROGRAM_BINARY_LENGTH, &length); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv"); |
| |
| /* Allocate storage */ |
| binary.resize(length); |
| |
| /* Get binary */ |
| gl.getProgramBinary(m_program_object_id, (GLsizei)binary.size(), &length, &binary_format, &binary[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramBinary"); |
| } |
| |
| /** Get subroutine index |
| * |
| * @param subroutine_name Subroutine name |
| * |
| * @return Index of subroutine |
| **/ |
| GLuint Utils::program::getSubroutineIndex(const glw::GLchar* subroutine_name, glw::GLenum shader_stage) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLuint index = -1; |
| |
| index = gl.getSubroutineIndex(m_program_object_id, shader_stage, subroutine_name); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetSubroutineIndex"); |
| |
| if (GL_INVALID_INDEX == index) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Subroutine: " << subroutine_name |
| << " is not available" << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Subroutine is not available"); |
| } |
| |
| return index; |
| } |
| |
| /** Get subroutine uniform location |
| * |
| * @param uniform_name Subroutine uniform name |
| * |
| * @return Location of subroutine uniform |
| **/ |
| GLint Utils::program::getSubroutineUniformLocation(const glw::GLchar* uniform_name, glw::GLenum shader_stage) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLint location = -1; |
| |
| location = gl.getSubroutineUniformLocation(m_program_object_id, shader_stage, uniform_name); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetSubroutineUniformLocation"); |
| |
| if (-1 == location) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Subroutine uniform: " << uniform_name |
| << " is not available" << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Subroutine uniform is not available"); |
| } |
| |
| return location; |
| } |
| |
| /** Get uniform location |
| * |
| * @param uniform_name Subroutine uniform name |
| * |
| * @return Location of uniform |
| **/ |
| GLint Utils::program::getUniformLocation(const glw::GLchar* uniform_name) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLint location = -1; |
| |
| location = gl.getUniformLocation(m_program_object_id, uniform_name); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformLocation"); |
| |
| if (-1 == location) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Uniform: " << uniform_name |
| << " is not available" << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Uniform is not available"); |
| } |
| |
| return location; |
| } |
| |
| /** Attach shaders and link program |
| * |
| **/ |
| void Utils::program::link() const |
| { |
| /* GL entry points */ |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Link status */ |
| glw::GLint status = GL_FALSE; |
| |
| /* Attach shaders */ |
| if (0 != m_compute_shader_id) |
| { |
| gl.attachShader(m_program_object_id, m_compute_shader_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); |
| } |
| |
| if (0 != m_fragment_shader_id) |
| { |
| gl.attachShader(m_program_object_id, m_fragment_shader_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); |
| } |
| |
| if (0 != m_geometry_shader_id) |
| { |
| gl.attachShader(m_program_object_id, m_geometry_shader_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); |
| } |
| |
| if (0 != m_tesselation_control_shader_id) |
| { |
| gl.attachShader(m_program_object_id, m_tesselation_control_shader_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); |
| } |
| |
| if (0 != m_tesselation_evaluation_shader_id) |
| { |
| gl.attachShader(m_program_object_id, m_tesselation_evaluation_shader_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); |
| } |
| |
| if (0 != m_vertex_shader_id) |
| { |
| gl.attachShader(m_program_object_id, m_vertex_shader_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader"); |
| } |
| |
| /* Link */ |
| gl.linkProgram(m_program_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "LinkProgram"); |
| |
| /* Get link status */ |
| gl.getProgramiv(m_program_object_id, GL_LINK_STATUS, &status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv"); |
| |
| /* Log link error */ |
| if (GL_TRUE != status) |
| { |
| glw::GLint length = 0; |
| std::vector<glw::GLchar> message; |
| |
| /* Get error log length */ |
| gl.getProgramiv(m_program_object_id, GL_INFO_LOG_LENGTH, &length); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv"); |
| |
| message.resize(length); |
| |
| /* Get error log */ |
| gl.getProgramInfoLog(m_program_object_id, length, 0, &message[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramInfoLog"); |
| |
| /* Log */ |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Failed to link program:\n" |
| << &message[0] << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Failed to link program"); |
| } |
| } |
| |
| /** Delete program object and all attached shaders |
| * |
| **/ |
| void Utils::program::remove() |
| { |
| /* GL entry points */ |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Make sure program object is no longer used by GL */ |
| gl.useProgram(0); |
| |
| /* Clean program object */ |
| if (0 != m_program_object_id) |
| { |
| gl.deleteProgram(m_program_object_id); |
| m_program_object_id = 0; |
| } |
| |
| /* Clean shaders */ |
| if (0 != m_compute_shader_id) |
| { |
| gl.deleteShader(m_compute_shader_id); |
| m_compute_shader_id = 0; |
| } |
| |
| if (0 != m_fragment_shader_id) |
| { |
| gl.deleteShader(m_fragment_shader_id); |
| m_fragment_shader_id = 0; |
| } |
| |
| if (0 != m_geometry_shader_id) |
| { |
| gl.deleteShader(m_geometry_shader_id); |
| m_geometry_shader_id = 0; |
| } |
| |
| if (0 != m_tesselation_control_shader_id) |
| { |
| gl.deleteShader(m_tesselation_control_shader_id); |
| m_tesselation_control_shader_id = 0; |
| } |
| |
| if (0 != m_tesselation_evaluation_shader_id) |
| { |
| gl.deleteShader(m_tesselation_evaluation_shader_id); |
| m_tesselation_evaluation_shader_id = 0; |
| } |
| |
| if (0 != m_vertex_shader_id) |
| { |
| gl.deleteShader(m_vertex_shader_id); |
| m_vertex_shader_id = 0; |
| } |
| } |
| |
| /** Execute UseProgram |
| * |
| **/ |
| void Utils::program::use() const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.useProgram(m_program_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgram"); |
| } |
| |
| /** Constructor. |
| * |
| * @param context CTS context. |
| **/ |
| Utils::texture::texture(deqp::Context& context) : m_id(0), m_context(context) |
| { |
| /* Nothing to done here */ |
| } |
| |
| /** Destructor |
| * |
| **/ |
| Utils::texture::~texture() |
| { |
| if (0 != m_id) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.deleteTextures(1, &m_id); |
| m_id = 0; |
| } |
| } |
| |
| /** Bind texture to GL_TEXTURE_2D |
| * |
| **/ |
| void Utils::texture::bind() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.bindTexture(GL_TEXTURE_2D, m_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture"); |
| } |
| |
| /** Create 2d texture |
| * |
| * @param width Width of texture |
| * @param height Height of texture |
| * @param internal_format Internal format of texture |
| **/ |
| void Utils::texture::create(glw::GLuint width, glw::GLuint height, glw::GLenum internal_format) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.genTextures(1, &m_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GenTextures"); |
| |
| bind(); |
| |
| gl.texStorage2D(GL_TEXTURE_2D, 1 /* levels */, internal_format, width, height); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "TexStorage2D"); |
| } |
| |
| /** Get contents of texture |
| * |
| * @param format Format of image |
| * @param type Type of image |
| * @param out_data Buffer for image |
| **/ |
| void Utils::texture::get(glw::GLenum format, glw::GLenum type, glw::GLvoid* out_data) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| bind(); |
| |
| gl.getTexImage(GL_TEXTURE_2D, 0, format, type, out_data); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetTexImage"); |
| } |
| |
| /** Update contents of texture |
| * |
| * @param width Width of texture |
| * @param height Height of texture |
| * @param format Format of data |
| * @param type Type of data |
| * @param data Buffer with image |
| **/ |
| void Utils::texture::update(glw::GLuint width, glw::GLuint height, glw::GLenum format, glw::GLenum type, |
| glw::GLvoid* data) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| bind(); |
| |
| gl.texSubImage2D(GL_TEXTURE_2D, 0 /* level */, 0 /* x */, 0 /* y */, width, height, format, type, data); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "TexSubImage2D"); |
| } |
| |
| /** Constructor. |
| * |
| * @param context CTS context. |
| **/ |
| Utils::vertexArray::vertexArray(deqp::Context& context) : m_id(0), m_context(context) |
| { |
| } |
| |
| /** Destructor |
| * |
| **/ |
| Utils::vertexArray::~vertexArray() |
| { |
| if (0 != m_id) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.deleteVertexArrays(1, &m_id); |
| |
| m_id = 0; |
| } |
| } |
| |
| /** Execute BindVertexArray |
| * |
| **/ |
| void Utils::vertexArray::bind() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.bindVertexArray(m_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindVertexArray"); |
| } |
| |
| /** Execute GenVertexArrays |
| * |
| **/ |
| void Utils::vertexArray::generate() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.genVertexArrays(1, &m_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GenVertexArrays"); |
| } |
| |
| /** Builds a program object consisting of up to 5 shader stages |
| * (vertex/tessellation control/tessellation evaluation/geometry/fragment). |
| * The shaders are attached to the program object, then compiled. Finally, |
| * the program object is linked. |
| * |
| * XFB can be optionally configured for the program object. |
| * |
| * Should an error be reported by GL implementation, a TestError |
| * exception will be thrown. |
| * |
| * @param gl OpenGL functions from the active rendering context. |
| * @param vs_body Body to use for the vertex shader. Can be an empty string. |
| * @param tc_body Body to use for the tessellation control shader. Can be |
| * an empty string. |
| * @param te_body Body to use for the tessellation evaluation shader. Can be |
| * an empty string. |
| * @param gs_body Body to use for the geometry shader. Can be an empty string. |
| * @param fs_body Body to use for the fragment shader. Can be an empty string. |
| * @param xfb_varyings An array of names of varyings to use for XFB. Can be NULL. |
| * @param n_xfb_varyings Amount of XFB varyings defined in @param xfb_varyings.Can be 0. |
| * @param out_vs_id Deref will be used to store GL id of a generated vertex shader. |
| * Can be NULL in which case no vertex shader will be used for the |
| * program object. |
| * @param out_tc_id Deref will be used to store GL id of a generated tess control shader. |
| * Can be NULL in which case no tess control shader will be used for the |
| * program object. |
| * @param out_te_id Deref will be used to store GL id of a generated tess evaluation shader. |
| * Can be NULL in which case no tess evaluation shader will be used for the |
| * program object. |
| * @param out_gs_id Deref will be used to store GL id of a generated geometry shader. |
| * Can be NULL in which case no geometry shader will be used for the |
| * program object. |
| * @param out_fs_id Deref will be used to store GL id of a generated fragment shader. |
| * Can be NULL in which case no fragment shader will be used for the |
| * program object. |
| * @param out_po_id Deref will be used to store GL id of a generated program object. |
| * Must not be NULL. |
| * |
| * @return true if the program was built successfully, false otherwise. |
| * */ |
| bool Utils::buildProgram(const glw::Functions& gl, const std::string& vs_body, const std::string& tc_body, |
| const std::string& te_body, const std::string& gs_body, const std::string& fs_body, |
| const glw::GLchar** xfb_varyings, const unsigned int& n_xfb_varyings, glw::GLuint* out_vs_id, |
| glw::GLuint* out_tc_id, glw::GLuint* out_te_id, glw::GLuint* out_gs_id, glw::GLuint* out_fs_id, |
| glw::GLuint* out_po_id) |
| { |
| bool result = false; |
| |
| /* Link the program object */ |
| glw::GLint link_status = GL_FALSE; |
| |
| /* Create objects, set up shader bodies and attach all requested shaders to the program object */ |
| *out_po_id = gl.createProgram(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed."); |
| |
| if (out_vs_id != DE_NULL) |
| { |
| const char* vs_body_raw_ptr = vs_body.c_str(); |
| |
| *out_vs_id = gl.createShader(GL_VERTEX_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed."); |
| |
| gl.attachShader(*out_po_id, *out_vs_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed."); |
| |
| gl.shaderSource(*out_vs_id, 1 /* count */, &vs_body_raw_ptr, DE_NULL /* length */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed."); |
| } |
| |
| if (out_tc_id != DE_NULL) |
| { |
| const char* tc_body_raw_ptr = tc_body.c_str(); |
| |
| *out_tc_id = gl.createShader(GL_TESS_CONTROL_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed."); |
| |
| gl.attachShader(*out_po_id, *out_tc_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed."); |
| |
| gl.shaderSource(*out_tc_id, 1 /* count */, &tc_body_raw_ptr, DE_NULL /* length */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed."); |
| } |
| |
| if (out_te_id != DE_NULL) |
| { |
| const char* te_body_raw_ptr = te_body.c_str(); |
| |
| *out_te_id = gl.createShader(GL_TESS_EVALUATION_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed."); |
| |
| gl.attachShader(*out_po_id, *out_te_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed."); |
| |
| gl.shaderSource(*out_te_id, 1 /* count */, &te_body_raw_ptr, DE_NULL /* length */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed."); |
| } |
| |
| if (out_gs_id != DE_NULL) |
| { |
| const char* gs_body_raw_ptr = gs_body.c_str(); |
| |
| *out_gs_id = gl.createShader(GL_GEOMETRY_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed."); |
| |
| gl.attachShader(*out_po_id, *out_gs_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed."); |
| |
| gl.shaderSource(*out_gs_id, 1 /* count */, &gs_body_raw_ptr, DE_NULL /* length */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed."); |
| } |
| |
| if (out_fs_id != DE_NULL) |
| { |
| const char* fs_body_raw_ptr = fs_body.c_str(); |
| |
| *out_fs_id = gl.createShader(GL_FRAGMENT_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed."); |
| |
| gl.attachShader(*out_po_id, *out_fs_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed."); |
| |
| gl.shaderSource(*out_fs_id, 1 /* count */, &fs_body_raw_ptr, DE_NULL /* length */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed."); |
| } |
| |
| /* Compile all shaders */ |
| const glw::GLuint so_ids[] = { (out_vs_id != DE_NULL) ? *out_vs_id : 0, (out_tc_id != DE_NULL) ? *out_tc_id : 0, |
| (out_te_id != DE_NULL) ? *out_te_id : 0, (out_gs_id != DE_NULL) ? *out_gs_id : 0, |
| (out_fs_id != DE_NULL) ? *out_fs_id : 0 }; |
| const unsigned int n_so_ids = sizeof(so_ids) / sizeof(so_ids[0]); |
| |
| for (unsigned int n_so_id = 0; n_so_id < n_so_ids; ++n_so_id) |
| { |
| glw::GLuint so_id = so_ids[n_so_id]; |
| |
| if (so_id != 0) |
| { |
| glw::GLint compile_status = GL_FALSE; |
| |
| gl.compileShader(so_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed."); |
| |
| gl.getShaderiv(so_id, GL_COMPILE_STATUS, &compile_status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed."); |
| |
| if (compile_status != GL_TRUE) |
| { |
| goto end; |
| } |
| } /* if (so_id != 0) */ |
| } /* for (all shader objects) */ |
| |
| /* Set up XFB */ |
| if (xfb_varyings != NULL) |
| { |
| gl.transformFeedbackVaryings(*out_po_id, n_xfb_varyings, xfb_varyings, GL_INTERLEAVED_ATTRIBS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() call failed."); |
| } |
| |
| gl.linkProgram(*out_po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() call failed."); |
| |
| gl.getProgramiv(*out_po_id, GL_LINK_STATUS, &link_status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed."); |
| |
| if (link_status != GL_TRUE) |
| { |
| goto end; |
| } |
| |
| /* All done */ |
| result = true; |
| |
| end: |
| return result; |
| } |
| |
| /** Retrieves base variable type for user-specified variable type |
| * (eg. float for vec4) |
| * |
| * @param variable_type Variable type to use for the query. |
| * |
| * @return As per description. |
| **/ |
| Utils::_variable_type Utils::getBaseVariableType(const _variable_type& variable_type) |
| { |
| _variable_type result = VARIABLE_TYPE_UNKNOWN; |
| |
| switch (variable_type) |
| { |
| case VARIABLE_TYPE_BOOL: |
| case VARIABLE_TYPE_BVEC2: |
| case VARIABLE_TYPE_BVEC3: |
| case VARIABLE_TYPE_BVEC4: |
| { |
| result = VARIABLE_TYPE_BOOL; |
| |
| break; |
| } |
| |
| case VARIABLE_TYPE_DOUBLE: |
| case VARIABLE_TYPE_DVEC2: |
| case VARIABLE_TYPE_DVEC3: |
| case VARIABLE_TYPE_DVEC4: |
| { |
| result = VARIABLE_TYPE_DOUBLE; |
| |
| break; |
| } |
| |
| case VARIABLE_TYPE_FLOAT: |
| case VARIABLE_TYPE_MAT2: |
| case VARIABLE_TYPE_MAT2X3: |
| case VARIABLE_TYPE_MAT2X4: |
| case VARIABLE_TYPE_MAT3: |
| case VARIABLE_TYPE_MAT3X2: |
| case VARIABLE_TYPE_MAT3X4: |
| case VARIABLE_TYPE_MAT4: |
| case VARIABLE_TYPE_MAT4X2: |
| case VARIABLE_TYPE_MAT4X3: |
| case VARIABLE_TYPE_VEC2: |
| case VARIABLE_TYPE_VEC3: |
| case VARIABLE_TYPE_VEC4: |
| { |
| result = VARIABLE_TYPE_FLOAT; |
| |
| break; |
| } |
| |
| case VARIABLE_TYPE_INT: |
| case VARIABLE_TYPE_IVEC2: |
| case VARIABLE_TYPE_IVEC3: |
| case VARIABLE_TYPE_IVEC4: |
| { |
| result = VARIABLE_TYPE_INT; |
| |
| break; |
| } |
| |
| case VARIABLE_TYPE_UINT: |
| case VARIABLE_TYPE_UVEC2: |
| case VARIABLE_TYPE_UVEC3: |
| case VARIABLE_TYPE_UVEC4: |
| { |
| result = VARIABLE_TYPE_UINT; |
| |
| break; |
| } |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized variable type"); |
| } |
| } /* switch (variable_type) */ |
| |
| return result; |
| } |
| |
| /** Retrieves size of a single component (in bytes) for user-specified |
| * variable type. |
| * |
| * @param variable_type Variable type to use for the query. |
| * |
| * @return As per description. |
| **/ |
| unsigned int Utils::getComponentSizeForVariableType(const _variable_type& variable_type) |
| { |
| _variable_type base_variable_type = getBaseVariableType(variable_type); |
| unsigned int result = 0; |
| |
| switch (base_variable_type) |
| { |
| case VARIABLE_TYPE_BOOL: |
| result = sizeof(bool); |
| break; |
| case VARIABLE_TYPE_DOUBLE: |
| result = sizeof(double); |
| break; |
| case VARIABLE_TYPE_FLOAT: |
| result = sizeof(float); |
| break; |
| case VARIABLE_TYPE_INT: |
| result = sizeof(int); |
| break; |
| case VARIABLE_TYPE_UINT: |
| result = sizeof(unsigned int); |
| break; |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized base variable type"); |
| } |
| } /* switch (variable_type) */ |
| |
| return result; |
| } |
| |
| /** Retrieves a GLenum value corresponding to internal shader stage |
| * representation. |
| * |
| * @param shader_stage Shader stage to user for the query. |
| * |
| * @return Requested value or GL_NONE if the stage was not recognized. |
| **/ |
| glw::GLenum Utils::getGLenumForShaderStage(const _shader_stage& shader_stage) |
| { |
| glw::GLenum result = GL_NONE; |
| |
| switch (shader_stage) |
| { |
| case SHADER_STAGE_VERTEX: |
| result = GL_VERTEX_SHADER; |
| break; |
| case SHADER_STAGE_TESSELLATION_CONTROL: |
| result = GL_TESS_CONTROL_SHADER; |
| break; |
| case SHADER_STAGE_TESSELLATION_EVALUATION: |
| result = GL_TESS_EVALUATION_SHADER; |
| break; |
| case SHADER_STAGE_GEOMETRY: |
| result = GL_GEOMETRY_SHADER; |
| break; |
| case SHADER_STAGE_FRAGMENT: |
| result = GL_FRAGMENT_SHADER; |
| break; |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized shader stage requested"); |
| } |
| } /* switch (shader_stage) */ |
| |
| return result; |
| } |
| |
| /** Retrieves number of components that user-specified variable type supports. |
| * |
| * @param variable_type GLSL variable type to use for the query. |
| * |
| * @return As per description. |
| **/ |
| unsigned int Utils::getNumberOfComponentsForVariableType(const _variable_type& variable_type) |
| { |
| unsigned int result = 0; |
| |
| switch (variable_type) |
| { |
| case VARIABLE_TYPE_BOOL: |
| case VARIABLE_TYPE_DOUBLE: |
| case VARIABLE_TYPE_FLOAT: |
| case VARIABLE_TYPE_INT: |
| case VARIABLE_TYPE_UINT: |
| { |
| result = 1; |
| |
| break; |
| } |
| |
| case VARIABLE_TYPE_BVEC2: |
| case VARIABLE_TYPE_DVEC2: |
| case VARIABLE_TYPE_IVEC2: |
| case VARIABLE_TYPE_UVEC2: |
| case VARIABLE_TYPE_VEC2: |
| { |
| result = 2; |
| |
| break; |
| } |
| |
| case VARIABLE_TYPE_BVEC3: |
| case VARIABLE_TYPE_DVEC3: |
| case VARIABLE_TYPE_IVEC3: |
| case VARIABLE_TYPE_UVEC3: |
| case VARIABLE_TYPE_VEC3: |
| { |
| result = 3; |
| |
| break; |
| } |
| |
| case VARIABLE_TYPE_BVEC4: |
| case VARIABLE_TYPE_DVEC4: |
| case VARIABLE_TYPE_IVEC4: |
| case VARIABLE_TYPE_MAT2: |
| case VARIABLE_TYPE_UVEC4: |
| case VARIABLE_TYPE_VEC4: |
| { |
| result = 4; |
| |
| break; |
| } |
| |
| case VARIABLE_TYPE_MAT2X3: |
| case VARIABLE_TYPE_MAT3X2: |
| { |
| result = 6; |
| |
| break; |
| } |
| |
| case VARIABLE_TYPE_MAT2X4: |
| case VARIABLE_TYPE_MAT4X2: |
| { |
| result = 8; |
| |
| break; |
| } |
| |
| case VARIABLE_TYPE_MAT3: |
| { |
| result = 9; |
| |
| break; |
| } |
| |
| case VARIABLE_TYPE_MAT3X4: |
| case VARIABLE_TYPE_MAT4X3: |
| { |
| result = 12; |
| |
| break; |
| } |
| |
| case VARIABLE_TYPE_MAT4: |
| { |
| result = 16; |
| |
| break; |
| } |
| |
| default: |
| break; |
| } /* switch (variable_type) */ |
| |
| return result; |
| } |
| |
| /** Retrieves a literal defining user-specified shader stage enum. |
| * |
| * @param shader_stage Shader stage to use for the query. |
| * |
| * @return Requested string or "?" if the stage was not recognized. |
| **/ |
| std::string Utils::getShaderStageString(const _shader_stage& shader_stage) |
| { |
| std::string result = "?"; |
| |
| switch (shader_stage) |
| { |
| case SHADER_STAGE_FRAGMENT: |
| result = "Fragment Shader"; |
| break; |
| case SHADER_STAGE_GEOMETRY: |
| result = "Geometry Shader"; |
| break; |
| case SHADER_STAGE_TESSELLATION_CONTROL: |
| result = "Tessellation Control Shader"; |
| break; |
| case SHADER_STAGE_TESSELLATION_EVALUATION: |
| result = "Tessellation Evaluation Shader"; |
| break; |
| case SHADER_STAGE_VERTEX: |
| result = "Vertex Shader"; |
| break; |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized shader stage"); |
| } |
| } /* switch (shader_stage) */ |
| |
| return result; |
| } |
| |
| /** Retrieves a literal defining user-specified shader stage enum. |
| * |
| * @param shader_stage_glenum Shader stage to use for the query. |
| * |
| * @return Requested string or "?" if the stage was not recognized. |
| **/ |
| std::string Utils::getShaderStageStringFromGLEnum(const glw::GLenum shader_stage_glenum) |
| { |
| std::string result = "?"; |
| |
| switch (shader_stage_glenum) |
| { |
| case GL_FRAGMENT_SHADER: |
| result = "Fragment Shader"; |
| break; |
| case GL_GEOMETRY_SHADER: |
| result = "Geometry Shader"; |
| break; |
| case GL_TESS_CONTROL_SHADER: |
| result = "Tessellation Control Shader"; |
| break; |
| case GL_TESS_EVALUATION_SHADER: |
| result = "Tessellation Evaluation Shader"; |
| break; |
| case GL_VERTEX_SHADER: |
| result = "Vertex Shader"; |
| break; |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized shader string"); |
| } |
| } /* switch (shader_stage_glenum) */ |
| |
| return result; |
| } |
| |
| /** Returns string that represents program interface name |
| * |
| * @param program_interface Program interface |
| * |
| * @return String representation of known program interface |
| **/ |
| const GLchar* Utils::programInterfaceToStr(glw::GLenum program_interface) |
| { |
| const GLchar* string = "Unknown program interface"; |
| |
| switch (program_interface) |
| { |
| case GL_VERTEX_SUBROUTINE: |
| string = "GL_VERTEX_SUBROUTINE"; |
| break; |
| case GL_VERTEX_SUBROUTINE_UNIFORM: |
| string = "GL_VERTEX_SUBROUTINE_UNIFORM"; |
| break; |
| default: |
| TCU_FAIL("Not implemented"); |
| break; |
| }; |
| |
| return string; |
| } |
| |
| /** Returns string that represents pname's name |
| * |
| * @param pname pname |
| * |
| * @return String representation of known pnames |
| **/ |
| const GLchar* Utils::pnameToStr(glw::GLenum pname) |
| { |
| const GLchar* string = "Unknown pname"; |
| |
| switch (pname) |
| { |
| case GL_ACTIVE_SUBROUTINE_UNIFORMS: |
| string = "GL_ACTIVE_SUBROUTINE_UNIFORMS"; |
| break; |
| case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS: |
| string = "GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS"; |
| break; |
| case GL_ACTIVE_SUBROUTINES: |
| string = "GL_ACTIVE_SUBROUTINES"; |
| break; |
| case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH: |
| string = "GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH"; |
| break; |
| case GL_ACTIVE_SUBROUTINE_MAX_LENGTH: |
| string = "GL_ACTIVE_SUBROUTINE_MAX_LENGTH"; |
| break; |
| case GL_NUM_COMPATIBLE_SUBROUTINES: |
| string = "GL_NUM_COMPATIBLE_SUBROUTINES"; |
| break; |
| case GL_UNIFORM_SIZE: |
| string = "GL_UNIFORM_SIZE"; |
| break; |
| case GL_COMPATIBLE_SUBROUTINES: |
| string = "GL_COMPATIBLE_SUBROUTINES"; |
| break; |
| case GL_UNIFORM_NAME_LENGTH: |
| string = "GL_UNIFORM_NAME_LENGTH"; |
| break; |
| case GL_ACTIVE_RESOURCES: |
| string = "GL_ACTIVE_RESOURCES"; |
| break; |
| case GL_MAX_NAME_LENGTH: |
| string = "GL_MAX_NAME_LENGTH"; |
| break; |
| case GL_MAX_NUM_COMPATIBLE_SUBROUTINES: |
| string = "GL_MAX_NUM_COMPATIBLE_SUBROUTINES"; |
| break; |
| case GL_NAME_LENGTH: |
| string = "GL_NAME_LENGTH"; |
| break; |
| case GL_ARRAY_SIZE: |
| string = "GL_ARRAY_SIZE"; |
| break; |
| case GL_LOCATION: |
| string = "GL_LOCATION"; |
| break; |
| default: |
| TCU_FAIL("Not implemented"); |
| break; |
| }; |
| |
| return string; |
| } |
| |
| bool Utils::compare(const glw::GLfloat& left, const glw::GLfloat& right) |
| { |
| static const glw::GLfloat m_epsilon = 0.00001f; |
| |
| if (m_epsilon < std::abs(right - left)) |
| { |
| return false; |
| } |
| else |
| { |
| return true; |
| } |
| } |
| |
| /** Returns a variable type enum corresponding to user-specified base variable type |
| * and the number of components it should support. |
| * |
| * @param base_variable_type Base variable type to use for the query. |
| * @param n_components Number of components to consider for the query. |
| * |
| * @return As per description. |
| **/ |
| Utils::_variable_type Utils::getVariableTypeFromProperties(const _variable_type& base_variable_type, |
| const unsigned int& n_components) |
| { |
| _variable_type result = VARIABLE_TYPE_UNKNOWN; |
| |
| switch (base_variable_type) |
| { |
| case VARIABLE_TYPE_BOOL: |
| { |
| switch (n_components) |
| { |
| case 1: |
| result = VARIABLE_TYPE_BOOL; |
| break; |
| case 2: |
| result = VARIABLE_TYPE_BVEC2; |
| break; |
| case 3: |
| result = VARIABLE_TYPE_BVEC3; |
| break; |
| case 4: |
| result = VARIABLE_TYPE_BVEC4; |
| break; |
| |
| default: |
| { |
| TCU_FAIL("Unsupported number of components requested"); |
| } |
| } /* switch (n_components) */ |
| |
| break; |
| } |
| |
| case VARIABLE_TYPE_DOUBLE: |
| { |
| switch (n_components) |
| { |
| case 1: |
| result = VARIABLE_TYPE_DOUBLE; |
| break; |
| case 2: |
| result = VARIABLE_TYPE_DVEC2; |
| break; |
| case 3: |
| result = VARIABLE_TYPE_DVEC3; |
| break; |
| case 4: |
| result = VARIABLE_TYPE_DVEC4; |
| break; |
| |
| default: |
| { |
| TCU_FAIL("Unsupported number of components requested"); |
| } |
| } /* switch (n_components) */ |
| |
| break; |
| } |
| |
| case VARIABLE_TYPE_FLOAT: |
| { |
| switch (n_components) |
| { |
| case 1: |
| result = VARIABLE_TYPE_FLOAT; |
| break; |
| case 2: |
| result = VARIABLE_TYPE_VEC2; |
| break; |
| case 3: |
| result = VARIABLE_TYPE_VEC3; |
| break; |
| case 4: |
| result = VARIABLE_TYPE_VEC4; |
| break; |
| |
| default: |
| { |
| TCU_FAIL("Unsupported number of components requested"); |
| } |
| } /* switch (n_components) */ |
| |
| break; |
| } |
| |
| case VARIABLE_TYPE_INT: |
| { |
| switch (n_components) |
| { |
| case 1: |
| result = VARIABLE_TYPE_INT; |
| break; |
| case 2: |
| result = VARIABLE_TYPE_IVEC2; |
| break; |
| case 3: |
| result = VARIABLE_TYPE_IVEC3; |
| break; |
| case 4: |
| result = VARIABLE_TYPE_IVEC4; |
| break; |
| |
| default: |
| { |
| TCU_FAIL("Unsupported number of components requested"); |
| } |
| } /* switch (n_components) */ |
| |
| break; |
| } |
| |
| case VARIABLE_TYPE_UINT: |
| { |
| switch (n_components) |
| { |
| case 1: |
| result = VARIABLE_TYPE_UINT; |
| break; |
| case 2: |
| result = VARIABLE_TYPE_UVEC2; |
| break; |
| case 3: |
| result = VARIABLE_TYPE_UVEC3; |
| break; |
| case 4: |
| result = VARIABLE_TYPE_UVEC4; |
| break; |
| |
| default: |
| { |
| TCU_FAIL("Unsupported number of components requested"); |
| } |
| } /* switch (n_components) */ |
| |
| break; |
| } |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized base variable type"); |
| } |
| } /* switch (base_variable_type) */ |
| |
| return result; |
| } |
| |
| /** Returns a GLSL literal corresponding to user-specified variable type. |
| * |
| * @param variable_type Variable type to use for the query. |
| * |
| * @return As per description or [?] if @param variable_type was not |
| * recognized. |
| **/ |
| std::string Utils::getVariableTypeGLSLString(const _variable_type& variable_type) |
| { |
| std::string result = "[?]"; |
| |
| switch (variable_type) |
| { |
| case VARIABLE_TYPE_BOOL: |
| result = "bool"; |
| break; |
| case VARIABLE_TYPE_BVEC2: |
| result = "bvec2"; |
| break; |
| case VARIABLE_TYPE_BVEC3: |
| result = "bvec3"; |
| break; |
| case VARIABLE_TYPE_BVEC4: |
| result = "bvec4"; |
| break; |
| case VARIABLE_TYPE_DOUBLE: |
| result = "double"; |
| break; |
| case VARIABLE_TYPE_DVEC2: |
| result = "dvec2"; |
| break; |
| case VARIABLE_TYPE_DVEC3: |
| result = "dvec3"; |
| break; |
| case VARIABLE_TYPE_DVEC4: |
| result = "dvec4"; |
| break; |
| case VARIABLE_TYPE_FLOAT: |
| result = "float"; |
| break; |
| case VARIABLE_TYPE_INT: |
| result = "int"; |
| break; |
| case VARIABLE_TYPE_IVEC2: |
| result = "ivec2"; |
| break; |
| case VARIABLE_TYPE_IVEC3: |
| result = "ivec3"; |
| break; |
| case VARIABLE_TYPE_IVEC4: |
| result = "ivec4"; |
| break; |
| case VARIABLE_TYPE_MAT2: |
| result = "mat2"; |
| break; |
| case VARIABLE_TYPE_MAT2X3: |
| result = "mat2x3"; |
| break; |
| case VARIABLE_TYPE_MAT2X4: |
| result = "mat2x4"; |
| break; |
| case VARIABLE_TYPE_MAT3: |
| result = "mat3"; |
| break; |
| case VARIABLE_TYPE_MAT3X2: |
| result = "mat3x2"; |
| break; |
| case VARIABLE_TYPE_MAT3X4: |
| result = "mat3x4"; |
| break; |
| case VARIABLE_TYPE_MAT4: |
| result = "mat4"; |
| break; |
| case VARIABLE_TYPE_MAT4X2: |
| result = "mat4x2"; |
| break; |
| case VARIABLE_TYPE_MAT4X3: |
| result = "mat4x3"; |
| break; |
| case VARIABLE_TYPE_UINT: |
| result = "uint"; |
| break; |
| case VARIABLE_TYPE_UVEC2: |
| result = "uvec2"; |
| break; |
| case VARIABLE_TYPE_UVEC3: |
| result = "uvec3"; |
| break; |
| case VARIABLE_TYPE_UVEC4: |
| result = "uvec4"; |
| break; |
| case VARIABLE_TYPE_VEC2: |
| result = "vec2"; |
| break; |
| case VARIABLE_TYPE_VEC3: |
| result = "vec3"; |
| break; |
| case VARIABLE_TYPE_VEC4: |
| result = "vec4"; |
| break; |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized variable type"); |
| } |
| } /* switch (variable_type) */ |
| |
| return result; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| * |
| **/ |
| APITest1::APITest1(deqp::Context& context) |
| : TestCase(context, "min_maxes", "Verifies the implementation returns valid GL_MAX_SUBROUTINE* pnames " |
| "which meet the minimum maximum requirements enforced by the spec.") |
| , m_has_test_passed(true) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult APITest1::iterate() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* Iterate over all pnames */ |
| const struct |
| { |
| glw::GLenum pname; |
| const char* pname_string; |
| glw::GLint min_value; |
| } pnames[] = { { GL_MAX_SUBROUTINES, "GL_MAX_SUBROUTINES", 256 }, |
| { GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS, "GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS", 1024 } }; |
| const unsigned int n_pnames = sizeof(pnames) / sizeof(pnames[0]); |
| |
| for (unsigned int n_pname = 0; n_pname < n_pnames; ++n_pname) |
| { |
| glw::GLboolean bool_value = GL_FALSE; |
| glw::GLdouble double_value = 0.0; |
| glw::GLfloat float_value = 0.0f; |
| glw::GLint int_value = 0; |
| glw::GLint64 int64_value = 0; |
| const glw::GLint min_value = pnames[n_pname].min_value; |
| const glw::GLenum& pname = pnames[n_pname].pname; |
| const char* pname_string = pnames[n_pname].pname_string; |
| |
| /* Retrieve the pname values */ |
| gl.getBooleanv(pname, &bool_value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv() call failed."); |
| |
| gl.getDoublev(pname, &double_value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetDoublev() call failed."); |
| |
| gl.getFloatv(pname, &float_value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetFloatv() call failed."); |
| |
| gl.getIntegerv(pname, &int_value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() call failed."); |
| |
| gl.getInteger64v(pname, &int64_value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetInteger64v() call failed."); |
| |
| /* Make sure the value reported meets the min max requirement */ |
| if (int_value < min_value) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "GL implementation reports a value of [" << int_value |
| << "]" |
| " for property [" |
| << pname_string << "]" |
| ", whereas the min max for the property is [" |
| << min_value << "]." << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| /* Verify the other getters reported valid values */ |
| const float epsilon = 1e-5f; |
| |
| if (((int_value == 0) && (bool_value == GL_TRUE)) || ((int_value != 0) && (bool_value != GL_TRUE))) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Invalid boolean value [" << bool_value |
| << "]" |
| " reported for property [" |
| << pname_string << "]" |
| " (int value:[" |
| << int_value << "])" << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| if (de::abs(double_value - (double)int_value) > epsilon) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Invalid double value [" << double_value |
| << "]" |
| " reported for property [" |
| << pname_string << "]" |
| " (int value:[" |
| << int_value << "])" << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| if (de::abs(float_value - (float)int_value) > epsilon) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Invalid float value [" << float_value |
| << "]" |
| " reported for property [" |
| << pname_string << "]" |
| " (int value:[" |
| << int_value << "])" << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| if (int64_value != int_value) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Invalid 64-bit integer value [" << float_value |
| << "]" |
| " reported for property [" |
| << pname_string << "]" |
| " (int value:[" |
| << int_value << "])" << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| } /* for (all pnames) */ |
| |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| * |
| **/ |
| APITest2::APITest2(deqp::Context& context) |
| : TestCase(context, "name_getters", "Verifies glGetActiveSubroutineName() and glGetActiveSubroutineUniformName() " |
| "functions work correctly.") |
| , m_buffer(DE_NULL) |
| , m_has_test_passed(true) |
| , m_po_id(0) |
| , m_subroutine_name1("subroutine1") |
| , m_subroutine_name2("subroutine2") |
| , m_subroutine_uniform_name("data_provider") |
| , m_vs_id(0) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Destroys all ES objects that may have been created during test initialization, |
| * as well as releases any buffers that may have been allocated during the process. |
| */ |
| void APITest2::deinit() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_buffer != DE_NULL) |
| { |
| delete[] m_buffer; |
| |
| m_buffer = DE_NULL; |
| } |
| |
| if (m_po_id != 0) |
| { |
| gl.deleteProgram(m_po_id); |
| |
| m_po_id = 0; |
| } |
| |
| if (m_vs_id != 0) |
| { |
| gl.deleteShader(m_vs_id); |
| |
| m_vs_id = 0; |
| } |
| } |
| |
| /** Returns body of a vertex shader that should be used for the test. |
| * |
| * @return As per description. |
| **/ |
| std::string APITest2::getVertexShaderBody() |
| { |
| return "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "subroutine int ExampleSubroutineType(int example_argument);\n" |
| "\n" |
| "subroutine(ExampleSubroutineType) int subroutine1(int example_argument)\n" |
| "{\n" |
| " return 1;\n" |
| "}\n" |
| "\n" |
| "subroutine(ExampleSubroutineType) int subroutine2(int example_argument)\n" |
| "{\n" |
| " return 2;\n" |
| "}\n" |
| "\n" |
| "subroutine uniform ExampleSubroutineType data_provider;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = vec4(float(data_provider(0)), vec3(1) );\n" |
| "}\n"; |
| } |
| |
| /** Initializes all ES objects required to run the test. */ |
| void APITest2::initTest() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Generate program & shader objects */ |
| m_po_id = gl.createProgram(); |
| m_vs_id = gl.createShader(GL_VERTEX_SHADER); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() or glCreateShader() call(s) failed."); |
| |
| /* Attach the shader to the program object */ |
| gl.attachShader(m_po_id, m_vs_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed."); |
| |
| /* Compile the shader */ |
| glw::GLint compile_status = GL_FALSE; |
| std::string vs_body = getVertexShaderBody(); |
| const char* vs_body_raw_ptr = vs_body.c_str(); |
| |
| gl.shaderSource(m_vs_id, 1 /* count */, &vs_body_raw_ptr, DE_NULL /* length */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed."); |
| |
| gl.compileShader(m_vs_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed."); |
| |
| gl.getShaderiv(m_vs_id, GL_COMPILE_STATUS, &compile_status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed."); |
| |
| if (compile_status != GL_TRUE) |
| { |
| TCU_FAIL("Shader compilation failed."); |
| } |
| |
| /* Try to link the program object */ |
| glw::GLint link_status = GL_FALSE; |
| |
| gl.linkProgram(m_po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() call failed."); |
| |
| gl.getProgramiv(m_po_id, GL_LINK_STATUS, &link_status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed."); |
| |
| if (link_status != GL_TRUE) |
| { |
| TCU_FAIL("Program linking failed."); |
| } |
| |
| /* Perform a few sanity checks */ |
| glw::GLint n_active_subroutines = 0; |
| glw::GLint n_active_subroutine_uniforms = 0; |
| |
| gl.getProgramStageiv(m_po_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINES, &n_active_subroutines); |
| gl.getProgramStageiv(m_po_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &n_active_subroutine_uniforms); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramStageiv() call failed."); |
| |
| if (n_active_subroutines != 2 /* subroutines declared in vertex shader */) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Invalid amount of active subroutines reported; expected: 2," |
| " reported:" |
| << n_active_subroutines << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid GL_ACTIVE_SUBROUTINES property value."); |
| } |
| |
| if (n_active_subroutine_uniforms != 1) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Invalid amount of active subroutine uniforms reported: expected: 1," |
| " reported: " |
| << n_active_subroutine_uniforms << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid GL_ACTIVE_SUBROUTINE_UNIFORMS property value."); |
| } |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult APITest2::iterate() |
| { |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* Initialize a test program object */ |
| initTest(); |
| |
| /* Verify glGetActiveSubroutineName() works correctly */ |
| verifyGLGetActiveSubroutineNameFunctionality(); |
| |
| /* Verify glGetActiveSubroutineUniformName() works correctly */ |
| verifyGLGetActiveSubroutineUniformNameFunctionality(); |
| |
| /* Done */ |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Verifies glGetActiveSubroutineName() behaves as per GL_ARB_shader_subroutine |
| * specification. |
| **/ |
| void APITest2::verifyGLGetActiveSubroutineNameFunctionality() |
| { |
| GLsizei expected_length1 = (GLsizei)strlen(m_subroutine_name1) + 1; |
| GLsizei expected_length2 = (GLsizei)strlen(m_subroutine_name1) + 1; |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLsizei reported_length = 0; |
| |
| gl.getActiveSubroutineName(m_po_id, GL_VERTEX_SHADER, 0, /* index */ |
| 0, /* bufsize */ |
| DE_NULL, /* length */ |
| DE_NULL); /* name */ |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveSubroutineName() call failed."); |
| |
| gl.getProgramInterfaceiv(m_po_id, GL_VERTEX_SUBROUTINE, GL_MAX_NAME_LENGTH, &reported_length); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveSubroutineName() call failed."); |
| |
| if ((reported_length != expected_length1) && (reported_length != expected_length2)) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Invalid active subroutine name length reported:" << reported_length |
| << ", instead of: " << expected_length1 << " or " << expected_length2 |
| << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Incorrect length of active subroutine name"); |
| } |
| |
| m_buffer = new glw::GLchar[reported_length]; |
| |
| memset(m_buffer, 0, reported_length); |
| |
| gl.getActiveSubroutineName(m_po_id, GL_VERTEX_SHADER, 0, reported_length, DE_NULL, /* length */ |
| m_buffer); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveSubroutineName() call failed."); |
| |
| if (strcmp(m_buffer, m_subroutine_name1) != 0 && strcmp(m_buffer, m_subroutine_name2) != 0) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Invalid active subroutine name reported:[" << m_buffer |
| << "]" |
| " instead of:[" |
| << m_subroutine_name1 << "]" |
| " or:[" |
| << m_subroutine_name2 << "]." << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid active subroutine name reported."); |
| } |
| |
| delete[] m_buffer; |
| m_buffer = DE_NULL; |
| } |
| |
| /** Verifies glGetActiveSubroutineUniformName() behaves as per GL_ARB_shader_subroutine |
| * specification. |
| **/ |
| void APITest2::verifyGLGetActiveSubroutineUniformNameFunctionality() |
| { |
| GLsizei expected_length = (GLsizei)strlen(m_subroutine_uniform_name); |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLsizei reported_length = 0; |
| |
| gl.getActiveSubroutineUniformName(m_po_id, GL_VERTEX_SHADER, 0, /* index */ |
| 0, /* bufsize */ |
| DE_NULL, /* length */ |
| DE_NULL); /* name */ |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveSubroutineUniformName() call failed."); |
| |
| gl.getActiveSubroutineUniformName(m_po_id, GL_VERTEX_SHADER, 0, /* index */ |
| 0, /* bufsize */ |
| &reported_length, DE_NULL); /* name */ |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveSubroutineUniformName() call failed."); |
| |
| // reported_length is the actual number of characters written into <name> |
| // If <bufSize> is 0, reported_length should be 0 |
| if (reported_length != 0) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Invalid active subroutine uniform name length reported:" << reported_length |
| << ", instead of: " << 0 << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Incorrect length of active subroutine uniform name"); |
| } |
| |
| m_buffer = new glw::GLchar[expected_length + 1]; |
| |
| memset(m_buffer, 0, expected_length + 1); |
| |
| gl.getActiveSubroutineUniformName(m_po_id, GL_VERTEX_SHADER, 0, expected_length + 1, &reported_length, m_buffer); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "getActiveSubroutineUniformName() call failed."); |
| |
| if (reported_length != expected_length) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Invalid active subroutine uniform name length reported:" << reported_length |
| << ", instead of: " << expected_length << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Incorrect length of active subroutine uniform name"); |
| } |
| |
| if (strcmp(m_buffer, m_subroutine_uniform_name) != 0) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Invalid active subroutine uniform name reported:[" << m_buffer |
| << "]" |
| " instead of:[" |
| << m_subroutine_uniform_name << "]" << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Invalid active subroutine uniform name reported."); |
| } |
| |
| delete[] m_buffer; |
| m_buffer = DE_NULL; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| * |
| **/ |
| FunctionalTest1_2::FunctionalTest1_2(deqp::Context& context) |
| : TestCase(context, "two_subroutines_single_subroutine_uniform", |
| "Verifies the subroutines work correctly in a vertex shader for" |
| " bool/float/int/uint/double/*vec*/*mat* argument and return types") |
| , m_has_test_passed(true) |
| , m_po_id(0) |
| , m_po_getter0_subroutine_index(GL_INVALID_INDEX) |
| , m_po_getter1_subroutine_index(GL_INVALID_INDEX) |
| , m_po_subroutine_uniform_index(-1) |
| , m_xfb_bo_id(0) |
| , m_vao_id(0) |
| , m_vs_id(0) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Destroys all ES objects that may have been created during test initialization, |
| * as well as releases any buffers that may have been allocated during the process. |
| */ |
| void FunctionalTest1_2::deinit() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| deinitTestIteration(); |
| |
| if (m_xfb_bo_id != 0) |
| { |
| gl.deleteBuffers(1, &m_xfb_bo_id); |
| |
| m_xfb_bo_id = 0; |
| } |
| |
| if (m_vao_id != 0) |
| { |
| gl.deleteVertexArrays(1, &m_vao_id); |
| |
| m_vao_id = 0; |
| } |
| } |
| |
| /** Deinitializes GL objects that are iteration-specific */ |
| void FunctionalTest1_2::deinitTestIteration() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_po_id != 0) |
| { |
| gl.deleteProgram(m_po_id); |
| |
| m_po_id = 0; |
| } |
| |
| if (m_vs_id != 0) |
| { |
| gl.deleteShader(m_vs_id); |
| |
| m_vs_id = 0; |
| } |
| } |
| |
| /** Executes a single test iteration using user-specified test case propertiesz. |
| * |
| * @param test-case Test case descriptor. |
| * |
| * @return true if the test iteration passed, false otherwise. |
| **/ |
| bool FunctionalTest1_2::executeTestIteration(const _test_case& test_case) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| bool result = true; |
| |
| /* Build the test program */ |
| std::string empty_body; |
| std::string vs_body = getVertexShaderBody(test_case.variable_type, test_case.array_size); |
| const glw::GLchar* xfb_varyings[] = { "result" }; |
| const unsigned int n_xfb_varyings = sizeof(xfb_varyings) / sizeof(xfb_varyings[0]); |
| |
| if (!Utils::buildProgram(gl, vs_body, empty_body, empty_body, empty_body, empty_body, xfb_varyings, n_xfb_varyings, |
| &m_vs_id, NULL, /* out_tc_id */ |
| NULL, /* out_te_id */ |
| NULL, /* out_gs_id */ |
| NULL, &m_po_id)) |
| { |
| TCU_FAIL("Test program failed to build."); |
| } |
| |
| /* Retrieve subroutine locations */ |
| m_po_getter0_subroutine_index = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "getter0"); |
| m_po_getter1_subroutine_index = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "getter1"); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() call(s) failed."); |
| |
| if (m_po_getter0_subroutine_index == GL_INVALID_INDEX || m_po_getter1_subroutine_index == GL_INVALID_INDEX) |
| { |
| TCU_FAIL("At least one subroutine is considered inactive which is invalid."); |
| } |
| |
| /* Retrieve subroutine uniform location */ |
| m_po_subroutine_uniform_index = gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "colorGetterUniform"); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineUniformLocation() call failed."); |
| |
| if (m_po_subroutine_uniform_index == -1) |
| { |
| TCU_FAIL("Subroutine uniform is considered inactive which is invalid."); |
| } |
| |
| /* Set up XFB BO storage */ |
| const Utils::_variable_type base_variable_type = Utils::getBaseVariableType(test_case.variable_type); |
| unsigned int iteration_xfb_bo_size = Utils::getComponentSizeForVariableType(base_variable_type) * |
| Utils::getNumberOfComponentsForVariableType(test_case.variable_type); |
| unsigned int total_xfb_bo_size = 0; |
| |
| if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) |
| { |
| /* Boolean varyings are not supported by OpenGL. Instead, we use ints to output |
| * boolean values. */ |
| iteration_xfb_bo_size = static_cast<unsigned int>(iteration_xfb_bo_size * sizeof(int)); |
| } |
| |
| total_xfb_bo_size = iteration_xfb_bo_size * 2 /* subroutines we will be testing */; |
| |
| gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, total_xfb_bo_size, DE_NULL /* data */, GL_STATIC_DRAW); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed."); |
| |
| /* Activate test program object */ |
| gl.useProgram(m_po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); |
| |
| /* Run two iterations. Each iteration should invoke different subroutine. */ |
| const glw::GLuint subroutine_indices[] = { m_po_getter0_subroutine_index, m_po_getter1_subroutine_index }; |
| const unsigned int n_subroutine_indices = sizeof(subroutine_indices) / sizeof(subroutine_indices[0]); |
| |
| for (unsigned int n_subroutine_index = 0; n_subroutine_index < n_subroutine_indices; ++n_subroutine_index) |
| { |
| /* Configure which subroutine should be used for the draw call */ |
| glw::GLuint current_subroutine_index = subroutine_indices[n_subroutine_index]; |
| |
| gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, 1 /* count */, ¤t_subroutine_index); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformSubroutinesuiv() call failed."); |
| |
| /* Update XFB binding so that we do not overwrite data XFBed in previous iterations */ |
| gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, /* index */ |
| m_xfb_bo_id, iteration_xfb_bo_size * n_subroutine_index, iteration_xfb_bo_size); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferRange() call failed."); |
| |
| /* Draw a single point */ |
| gl.beginTransformFeedback(GL_POINTS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed."); |
| { |
| gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed."); |
| } |
| gl.endTransformFeedback(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed."); |
| } /* for (all subroutine indices) */ |
| |
| /* Map the BO storage into process space */ |
| const void* xfb_data_ptr = gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer() call failed."); |
| |
| result &= verifyXFBData(xfb_data_ptr, test_case.variable_type); |
| |
| gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffeR() call failed."); |
| |
| return result; |
| } |
| |
| /** Retrieves body of a vertex shader that should be used to verify |
| * subroutine support, given user-specified test iteration properties. |
| * |
| * @param variable_type GLSL type that should be used for argument and |
| * return type definition in a subroutine. This setting |
| * also affects type of the only output variable in the shader. |
| * @param array_size 1 if non-arrayed arguments/return types should be tested; |
| * 2 if arrayed arguments/return types should be tested. |
| * |
| * @return Requested string. |
| **/ |
| std::string FunctionalTest1_2::getVertexShaderBody(const Utils::_variable_type& variable_type, unsigned int array_size) |
| { |
| Utils::_variable_type base_variable_type = Utils::getBaseVariableType(variable_type); |
| unsigned int n_variable_type_components = Utils::getNumberOfComponentsForVariableType(variable_type); |
| std::stringstream result_sstream; |
| std::string variable_type_glsl = Utils::getVariableTypeGLSLString(variable_type); |
| std::stringstream variable_type_glsl_array_sstream; |
| std::stringstream variable_type_glsl_arrayed_sstream; |
| |
| variable_type_glsl_arrayed_sstream << variable_type_glsl; |
| |
| if (array_size > 1) |
| { |
| variable_type_glsl_array_sstream << "[" << array_size << "]"; |
| variable_type_glsl_arrayed_sstream << variable_type_glsl_array_sstream.str(); |
| } |
| |
| /* Form pre-amble */ |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n"; |
| |
| if (variable_type == Utils::VARIABLE_TYPE_DOUBLE) |
| { |
| result_sstream << "#extension GL_ARB_gpu_shader_fp64 : require\n"; |
| } |
| |
| /* Form subroutine type declaration */ |
| result_sstream << "\n" |
| "subroutine " |
| << variable_type_glsl_arrayed_sstream.str() << " colorGetter(in " << variable_type_glsl |
| << " in_value" << variable_type_glsl_array_sstream.str() << ");\n" |
| "\n"; |
| |
| /* Declare getter functions */ |
| for (int n_getter = 0; n_getter < 2; ++n_getter) |
| { |
| result_sstream << "subroutine(colorGetter) " << variable_type_glsl_arrayed_sstream.str() << " getter" |
| << n_getter << "(in " << variable_type_glsl << " in_value" |
| << variable_type_glsl_array_sstream.str() << ")\n" |
| "{\n"; |
| |
| if (array_size > 1) |
| { |
| result_sstream << variable_type_glsl << " temp" << variable_type_glsl_array_sstream.str() << ";\n"; |
| } |
| |
| if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) |
| { |
| if (array_size > 1) |
| { |
| for (unsigned int array_index = 0; array_index < array_size; ++array_index) |
| { |
| result_sstream << " temp[" << array_index << "]" |
| " = " |
| << ((n_getter == 0) ? ((variable_type_glsl == "bool") ? "!" : "not") : "") |
| << "(in_value[" << array_index << "]);\n"; |
| } |
| |
| result_sstream << " return temp;\n"; |
| } |
| else |
| { |
| result_sstream << " return " |
| << ((n_getter == 0) ? ((variable_type_glsl == "bool") ? "!" : "not") : "") |
| << "(in_value);\n"; |
| } |
| } /* if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) */ |
| else |
| { |
| if (array_size > 1) |
| { |
| for (unsigned int array_index = 0; array_index < array_size; ++array_index) |
| { |
| result_sstream << " temp[" << array_index << "]" |
| " = in_value[" |
| << array_index << "] + " << (n_getter + 1) << ";\n"; |
| } |
| |
| result_sstream << " return temp;\n"; |
| } |
| else |
| { |
| result_sstream << " return (in_value + " << (n_getter + 1) << ");\n"; |
| } |
| } |
| |
| result_sstream << "}\n"; |
| } /* for (both getter functions) */ |
| |
| /* Declare subroutine uniform */ |
| result_sstream << "subroutine uniform colorGetter colorGetterUniform;\n" |
| "\n"; |
| |
| /* Declare output variable */ |
| result_sstream << "out "; |
| |
| if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) |
| { |
| Utils::_variable_type result_as_int_variable_type = |
| Utils::getVariableTypeFromProperties(Utils::VARIABLE_TYPE_INT, n_variable_type_components); |
| std::string variable_type_glsl_as_int = Utils::getVariableTypeGLSLString(result_as_int_variable_type); |
| |
| result_sstream << variable_type_glsl_as_int; |
| } |
| else |
| { |
| result_sstream << variable_type_glsl; |
| } |
| |
| result_sstream << " result;\n" |
| "\n"; |
| |
| /* Declare main(): prepare input argument for the subroutine function */ |
| result_sstream << "void main()\n" |
| "{\n" |
| " " |
| << variable_type_glsl << " temp"; |
| |
| if (array_size > 1) |
| { |
| result_sstream << "[" << array_size << "]"; |
| }; |
| |
| result_sstream << ";\n"; |
| |
| for (unsigned int array_index = 0; array_index < array_size; ++array_index) |
| { |
| result_sstream << " temp"; |
| |
| if (array_size > 1) |
| { |
| result_sstream << "[" << array_index << "]"; |
| } |
| |
| result_sstream << " = " << variable_type_glsl << "("; |
| |
| if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) |
| { |
| result_sstream << "true"; |
| } |
| else |
| { |
| for (unsigned int n_component = 0; n_component < n_variable_type_components; ++n_component) |
| { |
| result_sstream << "3"; |
| |
| if (n_component != (n_variable_type_components - 1)) |
| { |
| result_sstream << ", "; |
| } |
| } /* for (all components) */ |
| } |
| |
| result_sstream << ");\n"; |
| } /* for (all array indices) */ |
| |
| /* Declare main(): call the subroutine. Verify the input and write the result |
| * to the output variable. |
| **/ |
| if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) |
| { |
| Utils::_variable_type result_as_int_variable_type = |
| Utils::getVariableTypeFromProperties(Utils::VARIABLE_TYPE_INT, n_variable_type_components); |
| std::string variable_type_glsl_as_int = Utils::getVariableTypeGLSLString(result_as_int_variable_type); |
| |
| result_sstream << variable_type_glsl_arrayed_sstream.str() << " subroutine_result = colorGetterUniform(temp);\n" |
| "result = "; |
| |
| for (unsigned int array_index = 0; array_index < array_size; ++array_index) |
| { |
| if (variable_type_glsl == "bool") |
| result_sstream << "bool(subroutine_result"; |
| else |
| result_sstream << "all(subroutine_result"; |
| |
| if (array_size > 1) |
| { |
| result_sstream << "[" << array_index << "]"; |
| } |
| |
| result_sstream << ")"; |
| |
| if (array_index != (array_size - 1)) |
| { |
| result_sstream << "&& "; |
| } |
| } |
| |
| result_sstream << " == true ? " << variable_type_glsl_as_int << "(1) : " << variable_type_glsl_as_int << "(0);"; |
| } |
| else |
| { |
| if (array_size > 1) |
| { |
| DE_ASSERT(array_size == 2); |
| |
| result_sstream << variable_type_glsl << " subroutine_result" << variable_type_glsl_array_sstream.str() |
| << " = colorGetterUniform(temp);\n" |
| "\n" |
| "if (subroutine_result[0] == subroutine_result[1]) result = subroutine_result[0];\n" |
| "else\n" |
| "result = " |
| << variable_type_glsl << "(-1);\n"; |
| } |
| else |
| { |
| result_sstream << "result = colorGetterUniform(temp);\n"; |
| } |
| } |
| |
| /* All done */ |
| result_sstream << "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Initializes all GL objects required to run the test. */ |
| void FunctionalTest1_2::initTest() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Generate buffer object to hold result XFB data */ |
| gl.genBuffers(1, &m_xfb_bo_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed."); |
| |
| /* Set up XFB BO bindings */ |
| gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_xfb_bo_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed."); |
| |
| gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* index */, m_xfb_bo_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed."); |
| |
| /* Generate VAO to use for the draw calls */ |
| 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."); |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult FunctionalTest1_2::iterate() |
| { |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* Initialize a test program object */ |
| initTest(); |
| |
| /* Construct test case descriptors: first, iIerate over all |
| * variable types we want to cover */ |
| const Utils::_variable_type variable_types[] = { |
| Utils::VARIABLE_TYPE_BOOL, Utils::VARIABLE_TYPE_BVEC2, Utils::VARIABLE_TYPE_BVEC3, |
| Utils::VARIABLE_TYPE_BVEC4, Utils::VARIABLE_TYPE_DOUBLE, Utils::VARIABLE_TYPE_FLOAT, |
| Utils::VARIABLE_TYPE_INT, Utils::VARIABLE_TYPE_IVEC2, Utils::VARIABLE_TYPE_IVEC3, |
| Utils::VARIABLE_TYPE_IVEC4, Utils::VARIABLE_TYPE_MAT2, Utils::VARIABLE_TYPE_MAT2X3, |
| Utils::VARIABLE_TYPE_MAT2X4, Utils::VARIABLE_TYPE_MAT3, Utils::VARIABLE_TYPE_MAT3X2, |
| Utils::VARIABLE_TYPE_MAT3X4, Utils::VARIABLE_TYPE_MAT4, Utils::VARIABLE_TYPE_MAT4X2, |
| Utils::VARIABLE_TYPE_MAT4X3, Utils::VARIABLE_TYPE_UINT, Utils::VARIABLE_TYPE_UVEC2, |
| Utils::VARIABLE_TYPE_UVEC3, Utils::VARIABLE_TYPE_UVEC4, Utils::VARIABLE_TYPE_VEC2, |
| Utils::VARIABLE_TYPE_VEC3, Utils::VARIABLE_TYPE_VEC4 |
| }; |
| const unsigned int n_variable_types = sizeof(variable_types) / sizeof(variable_types[0]); |
| |
| for (unsigned int n_variable_type = 0; n_variable_type < n_variable_types; ++n_variable_type) |
| { |
| Utils::_variable_type current_variable_type = variable_types[n_variable_type]; |
| |
| /* We need to test both arrayed and non-arrayed arguments */ |
| for (unsigned int array_size = 1; array_size < 3; ++array_size) |
| { |
| /* Exclude double variables if the relevant extension is unavailable */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_gpu_shader_fp64") && |
| current_variable_type == Utils::VARIABLE_TYPE_DOUBLE) |
| { |
| continue; |
| } |
| |
| /* Form the descriptor */ |
| _test_case test_case; |
| |
| test_case.array_size = array_size; |
| test_case.variable_type = current_variable_type; |
| |
| /* Store the test case descriptor */ |
| m_test_cases.push_back(test_case); |
| } /* for (both arrayed and non-arrayed arguments) */ |
| } /* for (all variable types) */ |
| |
| /* Iterate over all test cases and execute the test */ |
| for (_test_cases_const_iterator test_case_iterator = m_test_cases.begin(); test_case_iterator != m_test_cases.end(); |
| ++test_case_iterator) |
| { |
| const _test_case& test_case = *test_case_iterator; |
| |
| m_has_test_passed &= executeTestIteration(test_case); |
| |
| /* Release GL objects that were created during the execution */ |
| deinitTestIteration(); |
| } /* for (all test cases) */ |
| |
| /* Done */ |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Verifies data that has been XFBed out by the vertex shader. |
| * |
| * @param xfb_data Buffer holding the data. |
| * @param variable_type GLSL type used for the test iteration |
| * that generated the data at @param xfb_data. |
| * |
| * @return true if the data was found to be valid, false if it |
| * was detected to be incorrect. |
| **/ |
| bool FunctionalTest1_2::verifyXFBData(const void* xfb_data, const Utils::_variable_type& variable_type) |
| { |
| const Utils::_variable_type base_variable_type = Utils::getBaseVariableType(variable_type); |
| const float epsilon = 1e-5f; |
| const unsigned int n_variable_type_components = Utils::getNumberOfComponentsForVariableType(variable_type); |
| bool result = true; |
| const unsigned char* traveller_ptr = (const unsigned char*)xfb_data; |
| |
| /* Boolean arguments/return types are tested with a slightly different shader so we |
| * need to test them in a separate code-path. |
| */ |
| if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) |
| { |
| /* 0 should be returned when getter0 is used, 1 otherwise */ |
| const unsigned int ref_values[] = { 0, 1 }; |
| const unsigned int n_ref_values = sizeof(ref_values) / sizeof(ref_values[0]); |
| |
| for (unsigned int n_ref_value = 0; n_ref_value < n_ref_values; ++n_ref_value) |
| { |
| const unsigned int ref_value = ref_values[n_ref_value]; |
| |
| for (unsigned int n_component = 0; n_component < n_variable_type_components; ++n_component) |
| { |
| int* result_value_ptr = (int*)(traveller_ptr); |
| |
| if (*result_value_ptr != (int)ref_value) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported by subroutine using " |
| "[" |
| << Utils::getVariableTypeGLSLString(variable_type) << "]" |
| << " argument/return types (" |
| "expected:[" |
| << ref_value << "], found:[" << *result_value_ptr << "])" |
| << tcu::TestLog::EndMessage; |
| |
| result = false; |
| break; |
| } |
| |
| traveller_ptr += sizeof(int); |
| } /* for (all components) */ |
| } /* for (all reference values) */ |
| } /* if (base_variable_type == Utils::VARIABLE_TYPE_BOOL) */ |
| else |
| { |
| /* 4 should be returned when getter0 is used, 5 otherwise */ |
| const unsigned int ref_values[] = { 4, 5 }; |
| const unsigned int n_ref_values = sizeof(ref_values) / sizeof(ref_values[0]); |
| |
| for (unsigned int n_ref_value = 0; n_ref_value < n_ref_values; ++n_ref_value) |
| { |
| const unsigned int ref_value = ref_values[n_ref_value]; |
| |
| DE_ASSERT( |
| base_variable_type == Utils::VARIABLE_TYPE_DOUBLE || base_variable_type == Utils::VARIABLE_TYPE_FLOAT || |
| base_variable_type == Utils::VARIABLE_TYPE_INT || base_variable_type == Utils::VARIABLE_TYPE_UINT); |
| |
| for (unsigned int n_component = 0; n_component < n_variable_type_components; ++n_component) |
| { |
| const double* double_value_ptr = (double*)traveller_ptr; |
| const float* float_value_ptr = (float*)traveller_ptr; |
| const int* int_value_ptr = (int*)traveller_ptr; |
| |
| switch (base_variable_type) |
| { |
| case Utils::VARIABLE_TYPE_DOUBLE: |
| { |
| if (de::abs(*double_value_ptr - (double)ref_value) > epsilon) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported by subroutine using " |
| "[" |
| << Utils::getVariableTypeGLSLString(variable_type) << "]" |
| << " argument/return types (" |
| "expected:[" |
| << ref_value << "], found:[" << *double_value_ptr << "])" |
| << tcu::TestLog::EndMessage; |
| |
| result = false; |
| } |
| |
| traveller_ptr += sizeof(double); |
| break; |
| } |
| |
| case Utils::VARIABLE_TYPE_FLOAT: |
| { |
| if (de::abs(*float_value_ptr - (float)ref_value) > epsilon) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported by subroutine using " |
| "[" |
| << Utils::getVariableTypeGLSLString(variable_type) << "]" |
| << " argument/return types (" |
| "expected:[" |
| << ref_value << "], found:[" << *float_value_ptr << "])" |
| << tcu::TestLog::EndMessage; |
| |
| result = false; |
| } |
| |
| traveller_ptr += sizeof(float); |
| break; |
| } |
| |
| case Utils::VARIABLE_TYPE_INT: |
| case Utils::VARIABLE_TYPE_UINT: |
| { |
| if (*int_value_ptr != (int)ref_value) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported by subroutine using " |
| "[" |
| << Utils::getVariableTypeGLSLString(variable_type) << "]" |
| << " argument/return types (" |
| "expected:[" |
| << ref_value << "], found:[" << *int_value_ptr << "])" |
| << tcu::TestLog::EndMessage; |
| |
| result = false; |
| } |
| |
| traveller_ptr += sizeof(int); |
| break; |
| } |
| |
| default: |
| break; |
| } /* switch (base_variable_type) */ |
| } /* for (all components) */ |
| } /* for (all reference values) */ |
| } |
| |
| return result; |
| } |
| |
| /** Constructor |
| * |
| * @param context CTS context |
| **/ |
| FunctionalTest3_4::FunctionalTest3_4(deqp::Context& context) |
| : TestCase(context, "four_subroutines_with_two_uniforms", "Verify Get* API and draw calls") |
| , m_n_active_subroutine_uniforms(0) |
| , m_n_active_subroutine_uniform_locations(0) |
| , m_n_active_subroutines(0) |
| , m_n_active_subroutine_uniform_name_length(0) |
| , m_n_active_subroutine_name_length(0) |
| , m_n_active_subroutine_uniform_size(0) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Execute test |
| * |
| * @return tcu::TestNode::STOP |
| **/ |
| tcu::TestNode::IterateResult FunctionalTest3_4::iterate() |
| { |
| static const glw::GLchar* vertex_shader_code = |
| "#version 400 core\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "// Sub routine type declaration\n" |
| "subroutine vec4 routine_type(in vec4 iparam);\n" |
| "\n" |
| "// Sub routine definitions\n" |
| "subroutine(routine_type) vec4 inverse_order(in vec4 iparam)\n" |
| "{\n" |
| " return iparam.wzyx;\n" |
| "}\n" |
| "\n" |
| "subroutine(routine_type) vec4 negate(in vec4 iparam)\n" |
| "{\n" |
| " return -iparam;\n" |
| "}\n" |
| "\n" |
| "subroutine(routine_type) vec4 inverse(in vec4 iparam)\n" |
| "{\n" |
| " return 1 / iparam;\n" |
| "}\n" |
| "\n" |
| "subroutine(routine_type) vec4 square(in vec4 iparam)\n" |
| "{\n" |
| " return iparam * iparam;\n" |
| "}\n" |
| "\n" |
| "// Sub routine uniforms\n" |
| "subroutine uniform routine_type first_routine;\n" |
| "subroutine uniform routine_type second_routine;\n" |
| "\n" |
| "// Input data\n" |
| "uniform vec4 input_data;\n" |
| "\n" |
| "// Output\n" |
| "out vec4 out_input_data;\n" |
| "out vec4 out_result_from_first_routine;\n" |
| "out vec4 out_result_from_second_routine;\n" |
| "out vec4 out_result_from_combined_routines;\n" |
| "out vec4 out_result_from_routines_combined_in_reveresed_order;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " out_input_data = input_data;\n" |
| " out_result_from_first_routine = first_routine(input_data);\n" |
| " out_result_from_second_routine = second_routine(input_data);\n" |
| " out_result_from_combined_routines = second_routine(first_routine(input_data));\n" |
| " out_result_from_routines_combined_in_reveresed_order = first_routine(second_routine(input_data));\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* varying_names[] = { |
| "out_input_data", |
| "out_result_from_first_routine", |
| "out_result_from_second_routine", |
| "out_result_from_combined_routines", |
| "out_result_from_routines_combined_in_reveresed_order", |
| }; |
| |
| static const GLchar* subroutine_uniform_names[] = { "first_routine", "second_routine" }; |
| |
| static const GLchar* subroutine_names[] = { "inverse_order", "negate", "inverse", "square" }; |
| |
| static const GLuint n_varyings = sizeof(varying_names) / sizeof(varying_names[0]); |
| static const GLuint transform_feedback_buffer_size = n_varyings * sizeof(GLfloat) * 4 /* vec4 */; |
| |
| static const GLuint inverse_order_routine_index = 0; |
| static const GLuint negate_routine_index = 1; |
| static const GLuint inverse_routine_index = 2; |
| static const GLuint square_routine_index = 3; |
| |
| /* Test data */ |
| static const Utils::vec4<GLfloat> inverse_order_negate_data[5] = { |
| Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f), |
| Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f), Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), |
| Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), |
| }; |
| |
| static const Utils::vec4<GLfloat> inverse_order_inverse_data[5] = { |
| Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f), |
| Utils::vec4<GLfloat>(-0.5f, -1.0f, 1.0f, 0.5f), Utils::vec4<GLfloat>(0.5f, 1.0f, -1.0f, -0.5f), |
| Utils::vec4<GLfloat>(0.5f, 1.0f, -1.0f, -0.5f), |
| }; |
| |
| static const Utils::vec4<GLfloat> inverse_order_square_data[5] = { |
| Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f), |
| Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f), Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f), |
| Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f), |
| }; |
| |
| static const Utils::vec4<GLfloat> negate_inverse_data[5] = { |
| Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f), |
| Utils::vec4<GLfloat>(-0.5f, -1.0f, 1.0f, 0.5f), Utils::vec4<GLfloat>(0.5f, 1.0f, -1.0f, -0.5f), |
| Utils::vec4<GLfloat>(0.5f, 1.0f, -1.0f, -0.5f), |
| }; |
| |
| static const Utils::vec4<GLfloat> negate_square_data[5] = { |
| Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), Utils::vec4<GLfloat>(2.0f, 1.0f, -1.0f, -2.0f), |
| Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f), Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f), |
| Utils::vec4<GLfloat>(-4.0f, -1.0f, -1.0f, -4.0f), |
| }; |
| |
| static const Utils::vec4<GLfloat> inverse_square_data[5] = { |
| Utils::vec4<GLfloat>(-2.0f, -1.0f, 1.0f, 2.0f), Utils::vec4<GLfloat>(-0.5f, -1.0f, 1.0f, 0.5f), |
| Utils::vec4<GLfloat>(4.0f, 1.0f, 1.0f, 4.0f), Utils::vec4<GLfloat>(0.25f, 1.0f, 1.0f, 0.25f), |
| Utils::vec4<GLfloat>(0.25f, 1.0f, 1.0f, 0.25f), |
| }; |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| m_n_active_subroutine_uniforms = 2; |
| m_n_active_subroutine_uniform_locations = 2; |
| m_n_active_subroutines = 4; |
| m_n_active_subroutine_uniform_name_length = 0; |
| m_n_active_subroutine_name_length = 0; |
| m_n_active_subroutine_uniform_size = 1; |
| |
| /* GL objects */ |
| Utils::program program(m_context); |
| Utils::buffer transform_feedback_buffer(m_context); |
| Utils::vertexArray vao(m_context); |
| |
| bool result = true; |
| |
| /* Calculate max name lengths for subroutines and subroutine uniforms */ |
| for (GLint i = 0; i < m_n_active_subroutine_uniforms; ++i) |
| { |
| const GLsizei length = (GLsizei)strlen(subroutine_uniform_names[i]); |
| |
| if (length > m_n_active_subroutine_uniform_name_length) |
| { |
| m_n_active_subroutine_uniform_name_length = length; |
| } |
| } |
| |
| for (GLint i = 0; i < m_n_active_subroutines; ++i) |
| { |
| const GLsizei length = (GLsizei)strlen(subroutine_names[i]); |
| |
| if (length > m_n_active_subroutine_name_length) |
| { |
| m_n_active_subroutine_name_length = length; |
| } |
| } |
| |
| /* Init */ |
| program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code, varying_names, |
| n_varyings); |
| |
| vao.generate(); |
| vao.bind(); |
| |
| transform_feedback_buffer.generate(); |
| transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */, |
| GL_DYNAMIC_COPY); |
| transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size); |
| |
| program.use(); |
| |
| /* Inspect Get* API */ |
| if ((false == inspectProgramStageiv(program.m_program_object_id)) || |
| (false == inspectActiveSubroutineUniformiv(program.m_program_object_id, subroutine_uniform_names)) || |
| (false == inspectActiveSubroutineUniformName(program.m_program_object_id, subroutine_uniform_names)) || |
| (false == inspectActiveSubroutineName(program.m_program_object_id, subroutine_names)) || |
| (false == |
| inspectSubroutineBinding(program.m_program_object_id, subroutine_names, subroutine_uniform_names, false))) |
| { |
| result = false; |
| } |
| |
| /* Inspect GetProgram* API */ |
| if (true == m_context.getContextInfo().isExtensionSupported("GL_ARB_program_interface_query")) |
| { |
| if ((false == inspectProgramInterfaceiv(program.m_program_object_id)) || |
| (false == |
| inspectProgramResourceiv(program.m_program_object_id, subroutine_names, subroutine_uniform_names)) || |
| (false == |
| inspectSubroutineBinding(program.m_program_object_id, subroutine_names, subroutine_uniform_names, true))) |
| { |
| result = false; |
| } |
| } |
| |
| /* Test shader execution */ |
| if ((false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index], |
| subroutine_names[negate_routine_index], subroutine_uniform_names, inverse_order_negate_data, |
| false)) || |
| (false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index], |
| subroutine_names[inverse_routine_index], subroutine_uniform_names, |
| inverse_order_inverse_data, false)) || |
| (false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index], |
| subroutine_names[square_routine_index], subroutine_uniform_names, inverse_order_square_data, |
| false)) || |
| (false == testDraw(program.m_program_object_id, subroutine_names[negate_routine_index], |
| subroutine_names[inverse_routine_index], subroutine_uniform_names, negate_inverse_data, |
| false)) || |
| (false == testDraw(program.m_program_object_id, subroutine_names[negate_routine_index], |
| subroutine_names[square_routine_index], subroutine_uniform_names, negate_square_data, |
| false)) || |
| (false == testDraw(program.m_program_object_id, subroutine_names[inverse_routine_index], |
| subroutine_names[square_routine_index], subroutine_uniform_names, inverse_square_data, |
| false))) |
| { |
| result = false; |
| } |
| |
| if (true == m_context.getContextInfo().isExtensionSupported("GL_ARB_program_interface_query")) |
| { |
| if ((false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index], |
| subroutine_names[negate_routine_index], subroutine_uniform_names, |
| inverse_order_negate_data, true)) || |
| (false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index], |
| subroutine_names[inverse_routine_index], subroutine_uniform_names, |
| inverse_order_inverse_data, true)) || |
| (false == testDraw(program.m_program_object_id, subroutine_names[inverse_order_routine_index], |
| subroutine_names[square_routine_index], subroutine_uniform_names, |
| inverse_order_square_data, true)) || |
| (false == testDraw(program.m_program_object_id, subroutine_names[negate_routine_index], |
| subroutine_names[inverse_routine_index], subroutine_uniform_names, negate_inverse_data, |
| true)) || |
| (false == testDraw(program.m_program_object_id, subroutine_names[negate_routine_index], |
| subroutine_names[square_routine_index], subroutine_uniform_names, negate_square_data, |
| true)) || |
| (false == testDraw(program.m_program_object_id, subroutine_names[inverse_routine_index], |
| subroutine_names[square_routine_index], subroutine_uniform_names, inverse_square_data, |
| true))) |
| { |
| result = false; |
| } |
| } |
| |
| /* Done */ |
| if (true == result) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return tcu::TestNode::STOP; |
| } |
| |
| /** Verify result of getProgramStageiv |
| * |
| * @param program_id Program object id |
| * @param pname <pname> parameter for getProgramStageiv |
| * @param expected Expected value |
| * |
| * @return true if result is equal to expected value, flase otherwise |
| **/ |
| bool FunctionalTest3_4::checkProgramStageiv(glw::GLuint program_id, glw::GLenum pname, glw::GLint expected) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLint value = 0; |
| |
| gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, pname, &value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv"); |
| |
| if (expected != value) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message |
| << "Error. Invalid result. Function: getProgramStageiv. " |
| << "pname: " << Utils::pnameToStr(pname) << ". " |
| << "Result: " << value << ". " |
| << "Expected: " << expected << "." << tcu::TestLog::EndMessage; |
| |
| return false; |
| } |
| else |
| { |
| return true; |
| } |
| } |
| |
| /** Verify result of getProgramResourceiv |
| * |
| * @param program_id Program object id |
| * @param program_interface Program interface |
| * @param pname <pname> parameter for getProgramStageiv |
| * @param resource_name Resource name |
| * @param expected Expected value |
| * |
| * @return true if result is equal to expected value, false otherwise |
| **/ |
| bool FunctionalTest3_4::checkProgramResourceiv(GLuint program_id, GLenum program_interface, GLenum pname, |
| const glw::GLchar* resource_name, GLint expected) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLuint index = gl.getProgramResourceIndex(program_id, program_interface, resource_name); |
| GLint value = 0; |
| |
| if (GL_INVALID_INDEX == index) |
| { |
| return false; |
| } |
| |
| gl.getProgramResourceiv(program_id, program_interface, index, 1, &pname, 1, 0, &value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "getProgramResourceiv"); |
| |
| if (expected != value) |
| { |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "Error. Invalid result. Function: getProgramResourceiv. " |
| << "Program interface: " << Utils::programInterfaceToStr(program_interface) << ". " |
| << "Resource name: " << resource_name << ". " |
| << "Property: " << Utils::pnameToStr(pname) << ". " |
| << "Result: " << value << ". " |
| << "Expected: " << expected << "." << tcu::TestLog::EndMessage; |
| |
| return false; |
| } |
| else |
| { |
| return true; |
| } |
| } |
| |
| /** Verify result of getProgramInterfaceiv |
| * |
| * @param program_id Program object id |
| * @param program_interface Program interface |
| * @param pname <pname> parameter for getProgramStageiv |
| * @param expected Expected value |
| * |
| * @return true if result is equal to expected value, flase otherwise |
| **/ |
| bool FunctionalTest3_4::checkProgramInterfaceiv(GLuint program_id, GLenum program_interface, GLenum pname, |
| GLint expected) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLint value = 0; |
| |
| gl.getProgramInterfaceiv(program_id, program_interface, pname, &value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramInterfaceiv"); |
| |
| if (expected != value) |
| { |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "Error. Invalid result. Function: getProgramInterfaceiv. " |
| << "Program interface: " << Utils::programInterfaceToStr(program_interface) << ". " |
| << "pname: " << Utils::pnameToStr(pname) << ". " |
| << "Result: " << value << ". " |
| << "Expected: " << expected << "." << tcu::TestLog::EndMessage; |
| |
| return false; |
| } |
| else |
| { |
| return true; |
| } |
| } |
| |
| /** Verify result of getActiveSubroutineUniformiv |
| * |
| * @param program_id Program object id |
| * @param index <index> parameter for getActiveSubroutineUniformiv |
| * @param pname <pname> parameter for getActiveSubroutineUniformiv |
| * @param expected Expected value |
| * |
| * @return true if result is equal to expected value, flase otherwise |
| **/ |
| bool FunctionalTest3_4::checkActiveSubroutineUniformiv(GLuint program_id, GLuint index, GLenum pname, |
| GLint expected) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLint value = 0; |
| |
| gl.getActiveSubroutineUniformiv(program_id, GL_VERTEX_SHADER, index, pname, &value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "getActiveSubroutineUniformiv"); |
| |
| if (expected != value) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message |
| << "Error. Invalid result. Function: getActiveSubroutineUniformiv. " |
| << "idnex: " << index << ". " |
| << "pname: " << Utils::pnameToStr(pname) << ". " |
| << "Result: " << value << ". " |
| << "Expected: " << expected << "." << tcu::TestLog::EndMessage; |
| |
| return false; |
| } |
| else |
| { |
| return true; |
| } |
| } |
| |
| /** Returns index of program resource |
| * |
| * @param program_id Program object id |
| * @param program_interface Program interface |
| * @param resource_name Name of resource |
| * |
| * @return Index of specified resource |
| **/ |
| GLuint FunctionalTest3_4::getProgramResourceIndex(GLuint program_id, GLenum program_interface, |
| const glw::GLchar* resource_name) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLuint index = gl.getProgramResourceIndex(program_id, program_interface, resource_name); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "getProgramResourceIndex"); |
| |
| if (GL_INVALID_INDEX == index) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Program resource is not available. " |
| << "Program interface: " << Utils::programInterfaceToStr(program_interface) |
| << ". " |
| << "Resource name: " << resource_name << "." << tcu::TestLog::EndMessage; |
| } |
| |
| return index; |
| } |
| |
| /** Get subroutine index |
| * |
| * @param program_id Program object id |
| * @param subroutine_name Subroutine name |
| * @param use_program_query If true getProgramResourceIndex is used, otherwise getSubroutineIndex |
| * |
| * @return Index of subroutine |
| **/ |
| GLuint FunctionalTest3_4::getSubroutineIndex(GLuint program_id, const glw::GLchar* subroutine_name, |
| bool use_program_query) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLuint index = -1; |
| |
| if (false == use_program_query) |
| { |
| index = gl.getSubroutineIndex(program_id, GL_VERTEX_SHADER, subroutine_name); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetSubroutineIndex"); |
| } |
| else |
| { |
| index = gl.getProgramResourceIndex(program_id, GL_VERTEX_SUBROUTINE, subroutine_name); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramResourceIndex"); |
| } |
| |
| if (GL_INVALID_INDEX == index) |
| { |
| TCU_FAIL("Subroutine is not available"); |
| } |
| |
| return index; |
| } |
| |
| /** Get subroutine uniform location |
| * |
| * @param program_id Program object id |
| * @param uniform_name Subroutine uniform name |
| * @param use_program_query If true getProgramResourceLocation is used, otherwise getSubroutineUniformLocation |
| * |
| * @return Location of subroutine uniform |
| **/ |
| GLint FunctionalTest3_4::getSubroutineUniformLocation(GLuint program_id, const glw::GLchar* uniform_name, |
| bool use_program_query) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLint location = -1; |
| |
| if (false == use_program_query) |
| { |
| location = gl.getSubroutineUniformLocation(program_id, GL_VERTEX_SHADER, uniform_name); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetSubroutineUniformLocation"); |
| } |
| else |
| { |
| location = gl.getProgramResourceLocation(program_id, GL_VERTEX_SUBROUTINE_UNIFORM, uniform_name); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramResourceLocation"); |
| } |
| |
| if (-1 == location) |
| { |
| TCU_FAIL("Subroutine uniform is not available"); |
| } |
| |
| return location; |
| } |
| |
| /** Test if getProgramStageiv results are as expected |
| * |
| * @param program_id Program object id |
| * |
| * @result false in case of invalid result for any pname, true otherwise |
| **/ |
| bool FunctionalTest3_4::inspectProgramStageiv(glw::GLuint program_id) const |
| { |
| bool result = true; |
| |
| const inspectionDetails details[] = { |
| { GL_ACTIVE_SUBROUTINE_UNIFORMS, m_n_active_subroutine_uniforms }, |
| { GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS, m_n_active_subroutine_uniform_locations }, |
| { GL_ACTIVE_SUBROUTINES, m_n_active_subroutines }, |
| { GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH, m_n_active_subroutine_uniform_name_length + 1 }, |
| { GL_ACTIVE_SUBROUTINE_MAX_LENGTH, m_n_active_subroutine_name_length + 1 } |
| }; |
| const GLuint n_details = sizeof(details) / sizeof(details[0]); |
| |
| for (GLuint i = 0; i < n_details; ++i) |
| { |
| if (false == checkProgramStageiv(program_id, details[i].pname, details[i].expected_value)) |
| { |
| result = false; |
| } |
| } |
| |
| return result; |
| } |
| |
| /** Test if checkProgramInterfaceiv results are as expected |
| * |
| * @param program_id Program object id |
| * |
| * @result false in case of invalid result for any pname, true otherwise |
| **/ |
| bool FunctionalTest3_4::inspectProgramInterfaceiv(glw::GLuint program_id) const |
| { |
| bool result = true; |
| |
| const inspectionDetailsForProgramInterface details[] = { |
| { GL_VERTEX_SUBROUTINE_UNIFORM, GL_ACTIVE_RESOURCES, m_n_active_subroutine_uniforms }, |
| { GL_VERTEX_SUBROUTINE_UNIFORM, GL_MAX_NAME_LENGTH, m_n_active_subroutine_uniform_name_length + 1 }, |
| { GL_VERTEX_SUBROUTINE_UNIFORM, GL_MAX_NUM_COMPATIBLE_SUBROUTINES, m_n_active_subroutines }, |
| { GL_VERTEX_SUBROUTINE, GL_ACTIVE_RESOURCES, m_n_active_subroutines }, |
| { GL_VERTEX_SUBROUTINE, GL_MAX_NAME_LENGTH, m_n_active_subroutine_name_length + 1 } |
| }; |
| const GLuint n_details = sizeof(details) / sizeof(details[0]); |
| |
| for (GLuint i = 0; i < n_details; ++i) |
| { |
| if (false == checkProgramInterfaceiv(program_id, details[i].program_interface, details[i].pname, |
| details[i].expected_value)) |
| { |
| result = false; |
| } |
| } |
| |
| return result; |
| } |
| |
| /** Test if checkProgramResourceiv results are as expected |
| * |
| * @param program_id Program object id |
| * @param subroutine_names Array of subroutine names |
| * @param uniform_names Array of uniform names |
| * |
| * @result false in case of invalid result for any pname, true otherwise |
| **/ |
| bool FunctionalTest3_4::inspectProgramResourceiv(GLuint program_id, const GLchar** subroutine_names, |
| const GLchar** uniform_names) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| bool result = true; |
| |
| for (GLint subroutine = 0; subroutine < m_n_active_subroutines; ++subroutine) |
| { |
| const GLchar* subroutine_name = subroutine_names[subroutine]; |
| const GLint length = (GLint)strlen(subroutine_name) + 1; |
| |
| if (false == checkProgramResourceiv(program_id, GL_VERTEX_SUBROUTINE, GL_NAME_LENGTH, subroutine_name, length)) |
| { |
| result = false; |
| } |
| } |
| |
| inspectionDetails details[] = { |
| { GL_NAME_LENGTH, 0 }, |
| { GL_ARRAY_SIZE, 1 }, |
| { GL_NUM_COMPATIBLE_SUBROUTINES, m_n_active_subroutines }, |
| { GL_LOCATION, 0 }, |
| }; |
| const GLuint n_details = sizeof(details) / sizeof(details[0]); |
| |
| for (GLint uniform = 0; uniform < m_n_active_subroutine_uniforms; ++uniform) |
| { |
| const GLchar* uniform_name = uniform_names[uniform]; |
| const GLint length = (GLint)strlen(uniform_name) + 1; |
| const GLint location = getSubroutineUniformLocation(program_id, uniform_name, true); |
| |
| details[0].expected_value = length; |
| details[3].expected_value = location; |
| |
| for (GLuint i = 0; i < n_details; ++i) |
| { |
| if (false == checkProgramResourceiv(program_id, GL_VERTEX_SUBROUTINE_UNIFORM, details[i].pname, |
| uniform_name, details[i].expected_value)) |
| { |
| result = false; |
| } |
| } |
| |
| /* Check compatible subroutines */ |
| GLuint index = getProgramResourceIndex(program_id, GL_VERTEX_SUBROUTINE_UNIFORM, uniform_name); |
| |
| if (GL_INVALID_INDEX != index) |
| { |
| std::vector<GLint> compatible_subroutines; |
| GLint index_sum = 0; |
| GLenum prop = GL_COMPATIBLE_SUBROUTINES; |
| |
| compatible_subroutines.resize(m_n_active_subroutines); |
| |
| gl.getProgramResourceiv(program_id, GL_VERTEX_SUBROUTINE_UNIFORM, index, 1, &prop, m_n_active_subroutines, |
| 0, &compatible_subroutines[0]); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramResourceiv"); |
| |
| /* Expected indices are 0, 1, 2, ... N */ |
| for (GLint i = 0; i < m_n_active_subroutines; ++i) |
| { |
| index_sum += compatible_subroutines[i]; |
| } |
| |
| /* Sum of E1, ..., EN = (E1 + EN) * N / 2 */ |
| if (((m_n_active_subroutines - 1) * m_n_active_subroutines) / 2 != index_sum) |
| { |
| tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; |
| |
| message << "Error. Invalid result. Function: getProgramResourceiv. " |
| << "Program interface: GL_VERTEX_SUBROUTINE_UNIFORM. " |
| << "Resource name: " << uniform_name << ". " |
| << "Property: GL_COMPATIBLE_SUBROUTINES. " |
| << "Results: "; |
| |
| for (GLint i = 1; i < m_n_active_subroutines; ++i) |
| { |
| message << compatible_subroutines[i]; |
| } |
| |
| message << tcu::TestLog::EndMessage; |
| |
| result = false; |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| /** Test if getActiveSubroutineUniformiv results are as expected |
| * |
| * @param program_id Program object id |
| * @param uniform_names Array of subroutine uniform names available in program |
| * |
| * @result false in case of invalid result for any pname, true otherwise |
| **/ |
| bool FunctionalTest3_4::inspectActiveSubroutineUniformiv(GLuint program_id, const GLchar** uniform_names) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| bool result = true; |
| GLint n_active_subroutine_uniforms = 0; |
| |
| inspectionDetails details[] = { |
| { GL_NUM_COMPATIBLE_SUBROUTINES, m_n_active_subroutines }, |
| { GL_UNIFORM_SIZE, m_n_active_subroutine_uniform_size }, |
| { GL_UNIFORM_NAME_LENGTH, 0 }, |
| }; |
| const GLuint n_details = sizeof(details) / sizeof(details[0]); |
| |
| /* Get amount of active subroutine uniforms */ |
| gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &n_active_subroutine_uniforms); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv"); |
| |
| for (GLint uniform = 0; uniform < n_active_subroutine_uniforms; ++uniform) |
| { |
| GLint name_length = (GLint)strlen(uniform_names[uniform]); |
| |
| details[2].expected_value = name_length + 1; |
| |
| /* Checks from "details" */ |
| for (GLuint i = 0; i < n_details; ++i) |
| { |
| if (false == |
| checkActiveSubroutineUniformiv(program_id, uniform, details[i].pname, details[i].expected_value)) |
| { |
| result = false; |
| } |
| } |
| |
| /* Check compatible subroutines */ |
| std::vector<GLint> compatible_subroutines; |
| compatible_subroutines.resize(m_n_active_subroutines); |
| GLint index_sum = 0; |
| |
| gl.getActiveSubroutineUniformiv(program_id, GL_VERTEX_SHADER, uniform, GL_COMPATIBLE_SUBROUTINES, |
| &compatible_subroutines[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "getActiveSubroutineUniformiv"); |
| |
| /* Expected indices are 0, 1, 2, ... N */ |
| for (GLint i = 0; i < m_n_active_subroutines; ++i) |
| { |
| index_sum += compatible_subroutines[i]; |
| } |
| |
| /* Sum of E1, ..., EN = (E1 + EN) * N / 2 */ |
| if (((m_n_active_subroutines - 1) * m_n_active_subroutines) / 2 != index_sum) |
| { |
| tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; |
| |
| message << "Error. Invalid result. Function: getActiveSubroutineUniformiv. idnex: " << uniform |
| << ". pname: " << Utils::pnameToStr(GL_COMPATIBLE_SUBROUTINES) << ". Results: "; |
| |
| for (GLint i = 1; i < m_n_active_subroutines; ++i) |
| { |
| message << compatible_subroutines[i]; |
| } |
| |
| message << tcu::TestLog::EndMessage; |
| |
| result = false; |
| } |
| } |
| |
| return result; |
| } |
| |
| /** Test if getActiveSubroutineUniformName results are as expected |
| * |
| * @param program_id Program object id |
| * @param uniform_names Array of subroutine uniform names available in program |
| * |
| * @result false in case of invalid result, true otherwise |
| **/ |
| bool FunctionalTest3_4::inspectActiveSubroutineUniformName(GLuint program_id, const GLchar** uniform_names) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| bool result = true; |
| GLint n_active_subroutine_uniforms = 0; |
| std::vector<GLchar> active_uniform_name; |
| |
| gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &n_active_subroutine_uniforms); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv"); |
| |
| active_uniform_name.resize(m_n_active_subroutine_uniform_name_length + 1); |
| |
| for (GLint uniform = 0; uniform < n_active_subroutine_uniforms; ++uniform) |
| { |
| bool is_name_ok = false; |
| |
| gl.getActiveSubroutineUniformName(program_id, GL_VERTEX_SHADER, uniform, (GLsizei)active_uniform_name.size(), |
| 0 /* length */, &active_uniform_name[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetActiveSubroutineUniformName"); |
| |
| for (GLint name = 0; name < n_active_subroutine_uniforms; ++name) |
| { |
| if (0 == strcmp(uniform_names[name], &active_uniform_name[0])) |
| { |
| is_name_ok = true; |
| break; |
| } |
| } |
| |
| if (false == is_name_ok) |
| { |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message |
| << "Error. Invalid result. Function: getActiveSubroutineUniformName. idnex: " << uniform |
| << ". Result: " << &active_uniform_name[0] << tcu::TestLog::EndMessage; |
| |
| result = false; |
| break; |
| } |
| } |
| |
| return result; |
| } |
| |
| /** Test if getActiveSubroutineUniformName results are as expected |
| * |
| * @param program_id Program object id |
| * @param subroutine_names Array of subroutine names available in program |
| * |
| * @result false in case of invalid result, true otherwise |
| **/ |
| bool FunctionalTest3_4::inspectActiveSubroutineName(GLuint program_id, const GLchar** subroutine_names) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| bool result = true; |
| GLint n_active_subroutines = 0; |
| std::vector<GLchar> active_subroutine_name; |
| |
| gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINES, &n_active_subroutines); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv"); |
| |
| active_subroutine_name.resize(m_n_active_subroutine_name_length + 1); |
| |
| for (GLint uniform = 0; uniform < n_active_subroutines; ++uniform) |
| { |
| bool is_name_ok = false; |
| |
| gl.getActiveSubroutineName(program_id, GL_VERTEX_SHADER, uniform, (GLsizei)active_subroutine_name.size(), |
| 0 /* length */, &active_subroutine_name[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "getActiveSubroutineName"); |
| |
| for (GLint name = 0; name < n_active_subroutines; ++name) |
| { |
| if (0 == strcmp(subroutine_names[name], &active_subroutine_name[0])) |
| { |
| is_name_ok = true; |
| break; |
| } |
| } |
| |
| if (false == is_name_ok) |
| { |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message |
| << "Error. Invalid result. Function: getActiveSubroutineName. idnex: " << uniform |
| << ". Result: " << &active_subroutine_name[0] << tcu::TestLog::EndMessage; |
| |
| result = false; |
| break; |
| } |
| } |
| |
| return result; |
| } |
| |
| /** Test if it is possible to "bind" all subroutines uniforms with all subroutines |
| * |
| * @param program_id Program object id |
| * @param subroutine_names Array of subroutine names available in program |
| * @param uniform_names Array of subroutine uniform names available in program |
| * |
| * @result false in case of invalid result, true otherwise |
| **/ |
| bool FunctionalTest3_4::inspectSubroutineBinding(GLuint program_id, const GLchar** subroutine_names, |
| const GLchar** uniform_names, bool use_program_query) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| bool result = true; |
| GLint n_active_subroutines = 0; |
| GLint n_active_subroutine_uniforms = 0; |
| std::vector<GLuint> subroutine_uniforms; |
| GLuint queried_subroutine_index = 0; |
| |
| gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINES, &n_active_subroutines); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv"); |
| |
| gl.getProgramStageiv(program_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &n_active_subroutine_uniforms); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramStageiv"); |
| |
| subroutine_uniforms.resize(n_active_subroutine_uniforms); |
| |
| for (GLint uniform = 0; uniform < n_active_subroutine_uniforms; ++uniform) |
| { |
| GLuint uniform_location = getSubroutineUniformLocation(program_id, uniform_names[uniform], use_program_query); |
| |
| for (GLint routine = 0; routine < n_active_subroutines; ++routine) |
| { |
| GLuint routine_index = getSubroutineIndex(program_id, subroutine_names[routine], use_program_query); |
| |
| subroutine_uniforms[uniform] = routine_index; |
| |
| gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, n_active_subroutine_uniforms, &subroutine_uniforms[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); |
| |
| gl.getUniformSubroutineuiv(GL_VERTEX_SHADER, uniform_location, &queried_subroutine_index); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformSubroutineuiv"); |
| |
| if (queried_subroutine_index != routine_index) |
| { |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "Error. Invalid result. Function: gl.getUniformSubroutineuiv." |
| << " Subroutine uniform: " << uniform << ", name: " << uniform_names[uniform] |
| << ", location: " << uniform_location << ". Subroutine: " << routine |
| << ", name: " << subroutine_names[routine] << ", index: " << routine_index |
| << ". Result: " << queried_subroutine_index << tcu::TestLog::EndMessage; |
| |
| result = false; |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| /** Execute draw call and verify results |
| * |
| * @param program_id Program object id |
| * @param first_routine_name Name of subroutine that shall be used aas first_routine |
| * @param second_routine_name Name of subroutine that shall be used aas second_routine |
| * @param uniform_names Name of uniforms |
| * @param expected_results Test data. [0] is used as input data. All are used as expected_results |
| * @param use_program_query If true GetProgram* API will be used |
| * |
| * @return false in case of invalid result, true otherwise |
| **/ |
| bool FunctionalTest3_4::testDraw(GLuint program_id, const GLchar* first_routine_name, const GLchar* second_routine_name, |
| const GLchar** uniform_names, const Utils::vec4<GLfloat> expected_results[5], |
| bool use_program_query) const |
| { |
| static const GLuint n_varyings = 5; |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| bool result = true; |
| GLuint subroutine_uniforms[2] = { 0 }; |
| |
| /* Get subroutine uniform locations */ |
| GLint first_routine_location = getSubroutineUniformLocation(program_id, uniform_names[0], use_program_query); |
| |
| GLint second_routine_location = getSubroutineUniformLocation(program_id, uniform_names[1], use_program_query); |
| |
| /* Get subroutine indices */ |
| GLuint first_routine_index = getSubroutineIndex(program_id, first_routine_name, use_program_query); |
| |
| GLuint second_routine_index = getSubroutineIndex(program_id, second_routine_name, use_program_query); |
| |
| /* Map uniforms with subroutines */ |
| subroutine_uniforms[first_routine_location] = first_routine_index; |
| subroutine_uniforms[second_routine_location] = second_routine_index; |
| |
| gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, 2 /* number of uniforms */, &subroutine_uniforms[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); |
| |
| /* Get location of input_data */ |
| GLint input_data_location = gl.getUniformLocation(program_id, "input_data"); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformLocation"); |
| |
| if (-1 == input_data_location) |
| { |
| TCU_FAIL("Uniform is not available"); |
| } |
| |
| /* Set up input_data */ |
| gl.uniform4f(input_data_location, expected_results[0].m_x, expected_results[0].m_y, expected_results[0].m_z, |
| expected_results[0].m_w); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f"); |
| |
| /* Execute draw call with transform feedback */ |
| gl.beginTransformFeedback(GL_POINTS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); |
| |
| gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); |
| |
| gl.endTransformFeedback(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); |
| |
| /* Verify results */ |
| GLfloat* feedback_data = (GLfloat*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); |
| |
| Utils::vec4<GLfloat> results[5]; |
| |
| results[0].m_x = feedback_data[0]; |
| results[0].m_y = feedback_data[1]; |
| results[0].m_z = feedback_data[2]; |
| results[0].m_w = feedback_data[3]; |
| |
| results[1].m_x = feedback_data[4]; |
| results[1].m_y = feedback_data[5]; |
| results[1].m_z = feedback_data[6]; |
| results[1].m_w = feedback_data[7]; |
| |
| results[2].m_x = feedback_data[8]; |
| results[2].m_y = feedback_data[9]; |
| results[2].m_z = feedback_data[10]; |
| results[2].m_w = feedback_data[11]; |
| |
| results[3].m_x = feedback_data[12]; |
| results[3].m_y = feedback_data[13]; |
| results[3].m_z = feedback_data[14]; |
| results[3].m_w = feedback_data[15]; |
| |
| results[4].m_x = feedback_data[16]; |
| results[4].m_y = feedback_data[17]; |
| results[4].m_z = feedback_data[18]; |
| results[4].m_w = feedback_data[19]; |
| |
| gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); |
| |
| for (GLuint i = 0; i < n_varyings; ++i) |
| { |
| result = result && (results[i] == expected_results[i]); |
| } |
| |
| if (false == result) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message |
| << "Error. Invalid result. First routine: " << first_routine_name |
| << ". Second routine: " << second_routine_name << tcu::TestLog::EndMessage; |
| |
| tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; |
| |
| message << "Results:"; |
| |
| for (GLuint i = 0; i < n_varyings; ++i) |
| { |
| results[i].log(message); |
| } |
| |
| message << tcu::TestLog::EndMessage; |
| |
| message = m_context.getTestContext().getLog() << tcu::TestLog::Message; |
| |
| message << "Expected:"; |
| |
| for (GLuint i = 0; i < n_varyings; ++i) |
| { |
| expected_results[i].log(message); |
| } |
| |
| message << tcu::TestLog::EndMessage; |
| } |
| |
| return result; |
| } |
| |
| /** Constructor |
| * |
| * @param context CTS context |
| **/ |
| FunctionalTest5::FunctionalTest5(deqp::Context& context) |
| : TestCase(context, "eight_subroutines_four_uniforms", "Verify multiple subroutine sets") |
| { |
| } |
| |
| /** Execute test |
| * |
| * @return tcu::TestNode::STOP |
| **/ |
| tcu::TestNode::IterateResult FunctionalTest5::iterate() |
| { |
| static const GLchar* vertex_shader_code = |
| "#version 400 core\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "// Subroutine types\n" |
| "subroutine vec4 routine_type_1(in vec4 left, in vec4 right);\n" |
| "subroutine vec4 routine_type_2(in vec4 iparam);\n" |
| "subroutine vec4 routine_type_3(in vec4 a, in vec4 b, in vec4 c);\n" |
| "subroutine bvec4 routine_type_4(in vec4 left, in vec4 right);\n" |
| "\n" |
| "// Subroutine definitions\n" |
| "// 1st type\n" |
| "subroutine(routine_type_1) vec4 add(in vec4 left, in vec4 right)\n" |
| "{\n" |
| " return left + right;\n" |
| "}\n" |
| "\n" |
| "subroutine(routine_type_1) vec4 subtract(in vec4 left, in vec4 right)\n" |
| "{\n" |
| " return left - right;\n" |
| "}\n" |
| "\n" |
| "// 2nd type\n" |
| "subroutine(routine_type_2) vec4 square(in vec4 iparam)\n" |
| "{\n" |
| " return iparam * iparam;\n" |
| "}\n" |
| "\n" |
| "subroutine(routine_type_2) vec4 square_root(in vec4 iparam)\n" |
| "{\n" |
| " return sqrt(iparam);\n" |
| "}\n" |
| "\n" |
| "// 3rd type\n" |
| "subroutine(routine_type_3) vec4 do_fma(in vec4 a, in vec4 b, in vec4 c)\n" |
| "{\n" |
| " return fma(a, b, c);\n" |
| "}\n" |
| "\n" |
| "subroutine(routine_type_3) vec4 blend(in vec4 a, in vec4 b, in vec4 c)\n" |
| "{\n" |
| " return c * a + (vec4(1) - c) * b;\n" |
| "}\n" |
| "\n" |
| "// 4th type\n" |
| "subroutine(routine_type_4) bvec4 are_equal(in vec4 left, in vec4 right)\n" |
| "{\n" |
| " return equal(left, right);\n" |
| "}\n" |
| "\n" |
| "subroutine(routine_type_4) bvec4 are_greater(in vec4 left, in vec4 right)\n" |
| "{\n" |
| " return greaterThan(left, right);\n" |
| "}\n" |
| "\n" |
| "// Sub routine uniforms\n" |
| "subroutine uniform routine_type_1 first_routine;\n" |
| "subroutine uniform routine_type_2 second_routine;\n" |
| "subroutine uniform routine_type_3 third_routine;\n" |
| "subroutine uniform routine_type_4 fourth_routine;\n" |
| "\n" |
| "// Input data\n" |
| "uniform vec4 first_input;\n" |
| "uniform vec4 second_input;\n" |
| "uniform vec4 third_input;\n" |
| "\n" |
| "// Output\n" |
| "out vec4 out_result_from_first_routine;\n" |
| "out vec4 out_result_from_second_routine;\n" |
| "out vec4 out_result_from_third_routine;\n" |
| "out uvec4 out_result_from_fourth_routine;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " out_result_from_first_routine = first_routine (first_input, second_input);\n" |
| " out_result_from_second_routine = second_routine(first_input);\n" |
| " out_result_from_third_routine = third_routine (first_input, second_input, third_input);\n" |
| " out_result_from_fourth_routine = uvec4(fourth_routine(first_input, second_input));\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* subroutine_names[4][2] = { |
| { "add", "subtract" }, { "square", "square_root" }, { "do_fma", "blend" }, { "are_equal", "are_greater" } |
| }; |
| |
| static const GLchar* subroutine_uniform_names[4][1] = { |
| { "first_routine" }, { "second_routine" }, { "third_routine" }, { "fourth_routine" } |
| }; |
| |
| static const GLuint n_subroutine_types = sizeof(subroutine_names) / sizeof(subroutine_names[0]); |
| static const GLuint n_subroutines_per_type = sizeof(subroutine_names[0]) / sizeof(subroutine_names[0][0]); |
| static const GLuint n_subroutine_uniforms_per_type = |
| sizeof(subroutine_uniform_names[0]) / sizeof(subroutine_uniform_names[0][0]); |
| |
| static const GLchar* uniform_names[] = { "first_input", "second_input", "third_input" }; |
| static const GLuint n_uniform_names = sizeof(uniform_names) / sizeof(uniform_names[0]); |
| |
| static const GLchar* varying_names[] = { "out_result_from_first_routine", "out_result_from_second_routine", |
| "out_result_from_third_routine", "out_result_from_fourth_routine" }; |
| static const GLuint n_varyings = sizeof(varying_names) / sizeof(varying_names[0]); |
| static const GLuint transform_feedback_buffer_size = n_varyings * sizeof(GLfloat) * 4 /* vec4 */; |
| |
| /* Test data */ |
| static const Utils::vec4<GLfloat> input_data[3] = { Utils::vec4<GLfloat>(1.0f, 4.0f, 9.0f, 16.0f), |
| Utils::vec4<GLfloat>(16.0f, 9.0f, 4.0f, 1.0f), |
| Utils::vec4<GLfloat>(0.25f, 0.5f, 0.75f, 1.0f) }; |
| |
| static const Utils::vec4<GLfloat> expected_result_from_first_routine[2] = { |
| Utils::vec4<GLfloat>(17.0f, 13.0f, 13.0f, 17.0f), Utils::vec4<GLfloat>(-15.0f, -5.0f, 5.0f, 15.0f) |
| }; |
| |
| static const Utils::vec4<GLfloat> expected_result_from_second_routine[2] = { |
| Utils::vec4<GLfloat>(1.0f, 16.0f, 81.0f, 256.0f), Utils::vec4<GLfloat>(1.0f, 2.0f, 3.0f, 4.0f) |
| }; |
| |
| static const Utils::vec4<GLfloat> expected_result_from_third_routine[2] = { |
| Utils::vec4<GLfloat>(16.25f, 36.5f, 36.75f, 17.0f), Utils::vec4<GLfloat>(12.25f, 6.5f, 7.75f, 16.0f) |
| }; |
| |
| static const Utils::vec4<GLuint> expected_result_from_fourth_routine[2] = { Utils::vec4<GLuint>(0, 0, 0, 0), |
| Utils::vec4<GLuint>(0, 0, 1, 1) }; |
| |
| /* All combinations of subroutines */ |
| static const GLuint subroutine_combinations[][4] = { |
| { 0, 0, 0, 0 }, { 0, 0, 0, 1 }, { 0, 0, 1, 0 }, { 0, 0, 1, 1 }, { 0, 1, 0, 0 }, { 0, 1, 0, 1 }, |
| { 0, 1, 1, 0 }, { 0, 1, 1, 1 }, { 1, 0, 0, 0 }, { 1, 0, 0, 1 }, { 1, 0, 1, 0 }, { 1, 0, 1, 1 }, |
| { 1, 1, 0, 0 }, { 1, 1, 0, 1 }, { 1, 1, 1, 0 }, { 1, 1, 1, 1 } |
| }; |
| static const GLuint n_subroutine_combinations = |
| sizeof(subroutine_combinations) / sizeof(subroutine_combinations[0]); |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* Result */ |
| bool result = true; |
| |
| /* GL objects */ |
| Utils::program program(m_context); |
| Utils::buffer transform_feedback_buffer(m_context); |
| Utils::vertexArray vao(m_context); |
| |
| /* Init GL objects */ |
| program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code, varying_names, |
| n_varyings); |
| |
| program.use(); |
| |
| vao.generate(); |
| vao.bind(); |
| |
| transform_feedback_buffer.generate(); |
| transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */, |
| GL_DYNAMIC_COPY); |
| transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size); |
| |
| /* Get subroutine uniform locations and subroutine indices */ |
| for (GLuint type = 0; type < n_subroutine_types; ++type) |
| { |
| for (GLuint uniform = 0; uniform < n_subroutine_uniforms_per_type; ++uniform) |
| { |
| m_subroutine_uniform_locations[type][uniform] = |
| program.getSubroutineUniformLocation(subroutine_uniform_names[type][uniform], GL_VERTEX_SHADER); |
| } |
| |
| for (GLuint routine = 0; routine < n_subroutines_per_type; ++routine) |
| { |
| m_subroutine_indices[type][routine] = |
| program.getSubroutineIndex(subroutine_names[type][routine], GL_VERTEX_SHADER); |
| } |
| } |
| |
| /* Get uniform locations */ |
| for (GLuint i = 0; i < n_uniform_names; ++i) |
| { |
| m_uniform_locations[i] = program.getUniformLocation(uniform_names[i]); |
| } |
| |
| /* Draw with each routine combination */ |
| for (GLuint i = 0; i < n_subroutine_combinations; ++i) |
| { |
| Utils::vec4<GLfloat> first_routine_result; |
| Utils::vec4<GLfloat> second_routine_result; |
| Utils::vec4<GLfloat> third_routine_result; |
| Utils::vec4<GLuint> fourth_routine_result; |
| |
| testDraw(subroutine_combinations[i], input_data, first_routine_result, second_routine_result, |
| third_routine_result, fourth_routine_result); |
| |
| if (false == verify(first_routine_result, second_routine_result, third_routine_result, fourth_routine_result, |
| expected_result_from_first_routine[subroutine_combinations[i][0]], |
| expected_result_from_second_routine[subroutine_combinations[i][1]], |
| expected_result_from_third_routine[subroutine_combinations[i][2]], |
| expected_result_from_fourth_routine[subroutine_combinations[i][3]])) |
| { |
| logError(subroutine_names, subroutine_combinations[i], input_data, first_routine_result, |
| second_routine_result, third_routine_result, fourth_routine_result, |
| expected_result_from_first_routine[subroutine_combinations[i][0]], |
| expected_result_from_second_routine[subroutine_combinations[i][1]], |
| expected_result_from_third_routine[subroutine_combinations[i][2]], |
| expected_result_from_fourth_routine[subroutine_combinations[i][3]]); |
| |
| result = false; |
| } |
| } |
| |
| /* Done */ |
| if (true == result) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return tcu::TestNode::STOP; |
| } |
| |
| /** Log error message |
| * |
| * @param subroutine_names Array of subroutine names |
| * @param subroutine_combination Combination of subroutines |
| * @param input_data Input data |
| * @param first_routine_result Result of first routine |
| * @param second_routine_result Result of second routine |
| * @param third_routine_result Result of third routine |
| * @param fourth_routine_result Result of fourth routine |
| * @param first_routine_expected_result Expected result of first routine |
| * @param second_routine_expected_result Expected result of second routine |
| * @param third_routine_expected_result Expected result of third routine |
| * @param fourth_routine_expected_result Expected result of fourth routine |
| **/ |
| void FunctionalTest5::logError(const glw::GLchar* subroutine_names[4][2], const glw::GLuint subroutine_combination[4], |
| const Utils::vec4<glw::GLfloat> input_data[3], |
| const Utils::vec4<glw::GLfloat>& first_routine_result, |
| const Utils::vec4<glw::GLfloat>& second_routine_result, |
| const Utils::vec4<glw::GLfloat>& third_routine_result, |
| const Utils::vec4<glw::GLuint>& fourth_routine_result, |
| const Utils::vec4<glw::GLfloat>& first_routine_expected_result, |
| const Utils::vec4<glw::GLfloat>& second_routine_expected_result, |
| const Utils::vec4<glw::GLfloat>& third_routine_expected_result, |
| const Utils::vec4<glw::GLuint>& fourth_routine_expected_result) const |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result." |
| << tcu::TestLog::EndMessage; |
| |
| tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; |
| |
| message << "Function: " << subroutine_names[0][subroutine_combination[0]] << "( "; |
| input_data[0].log(message); |
| message << ", "; |
| input_data[1].log(message); |
| message << " ). Result: "; |
| first_routine_result.log(message); |
| message << ". Expected: "; |
| first_routine_expected_result.log(message); |
| |
| message << tcu::TestLog::EndMessage; |
| |
| message = m_context.getTestContext().getLog() << tcu::TestLog::Message; |
| |
| message << "Function: " << subroutine_names[1][subroutine_combination[1]] << "( "; |
| input_data[0].log(message); |
| message << " ). Result: "; |
| second_routine_result.log(message); |
| message << ". Expected: "; |
| second_routine_expected_result.log(message); |
| |
| message << tcu::TestLog::EndMessage; |
| |
| message = m_context.getTestContext().getLog() << tcu::TestLog::Message; |
| |
| message << "Function: " << subroutine_names[2][subroutine_combination[2]] << "( "; |
| input_data[0].log(message); |
| message << ", "; |
| input_data[1].log(message); |
| message << ", "; |
| input_data[2].log(message); |
| message << "). Result: "; |
| third_routine_result.log(message); |
| message << ". Expected: "; |
| third_routine_expected_result.log(message); |
| |
| message << tcu::TestLog::EndMessage; |
| |
| message = m_context.getTestContext().getLog() << tcu::TestLog::Message; |
| |
| message << "Function: " << subroutine_names[3][subroutine_combination[3]] << "( "; |
| input_data[0].log(message); |
| message << ", "; |
| input_data[1].log(message); |
| message << ", "; |
| message << " ). Result: "; |
| fourth_routine_result.log(message); |
| message << ". Expected: "; |
| fourth_routine_expected_result.log(message); |
| |
| message << tcu::TestLog::EndMessage; |
| } |
| |
| /** Execute draw call and capture results |
| * |
| * @param subroutine_combination Combination of subroutines |
| * @param input_data Input data |
| * @param out_first_routine_result Result of first routine |
| * @param out_second_routine_result Result of second routine |
| * @param out_third_routine_result Result of third routine |
| * @param out_fourth_routine_result Result of fourth routine |
| **/ |
| void FunctionalTest5::testDraw(const glw::GLuint subroutine_combination[4], |
| const Utils::vec4<glw::GLfloat> input_data[3], |
| Utils::vec4<glw::GLfloat>& out_first_routine_result, |
| Utils::vec4<glw::GLfloat>& out_second_routine_result, |
| Utils::vec4<glw::GLfloat>& out_third_routine_result, |
| Utils::vec4<glw::GLuint>& out_fourth_routine_result) const |
| { |
| static const GLuint n_uniforms = sizeof(m_uniform_locations) / sizeof(m_uniform_locations[0]); |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLuint subroutine_indices[4]; |
| static const GLuint n_subroutine_uniforms = sizeof(subroutine_indices) / sizeof(subroutine_indices[0]); |
| |
| /* Prepare subroutine uniform data */ |
| for (GLuint i = 0; i < n_subroutine_uniforms; ++i) |
| { |
| const GLuint location = m_subroutine_uniform_locations[i][0]; |
| |
| subroutine_indices[location] = m_subroutine_indices[i][subroutine_combination[i]]; |
| } |
| |
| /* Set up subroutine uniforms */ |
| gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, n_subroutine_uniforms, &subroutine_indices[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); |
| |
| /* Set up input data uniforms */ |
| for (GLuint i = 0; i < n_uniforms; ++i) |
| { |
| gl.uniform4f(m_uniform_locations[i], input_data[i].m_x, input_data[i].m_y, input_data[i].m_z, |
| input_data[i].m_w); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f"); |
| } |
| |
| /* Execute draw call with transform feedback */ |
| gl.beginTransformFeedback(GL_POINTS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); |
| |
| gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); |
| |
| gl.endTransformFeedback(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); |
| |
| /* Capture results */ |
| GLvoid* feedback_data = gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); |
| |
| GLfloat* float_ptr = (GLfloat*)feedback_data; |
| |
| /* First result */ |
| out_first_routine_result.m_x = float_ptr[0]; |
| out_first_routine_result.m_y = float_ptr[1]; |
| out_first_routine_result.m_z = float_ptr[2]; |
| out_first_routine_result.m_w = float_ptr[3]; |
| |
| /* Second result */ |
| out_second_routine_result.m_x = float_ptr[4]; |
| out_second_routine_result.m_y = float_ptr[5]; |
| out_second_routine_result.m_z = float_ptr[6]; |
| out_second_routine_result.m_w = float_ptr[7]; |
| |
| /* Third result */ |
| out_third_routine_result.m_x = float_ptr[8]; |
| out_third_routine_result.m_y = float_ptr[9]; |
| out_third_routine_result.m_z = float_ptr[10]; |
| out_third_routine_result.m_w = float_ptr[11]; |
| |
| /* Fourth result */ |
| GLuint* uint_ptr = (GLuint*)(float_ptr + 12); |
| out_fourth_routine_result.m_x = uint_ptr[0]; |
| out_fourth_routine_result.m_y = uint_ptr[1]; |
| out_fourth_routine_result.m_z = uint_ptr[2]; |
| out_fourth_routine_result.m_w = uint_ptr[3]; |
| |
| gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); |
| } |
| |
| /** Verify if results match expected results |
| * |
| * @param first_routine_result Result of first routine |
| * @param second_routine_result Result of second routine |
| * @param third_routine_result Result of third routine |
| * @param fourth_routine_result Result of fourth routine |
| * @param first_routine_expected_result Expected result of first routine |
| * @param second_routine_expected_result Expected result of second routine |
| * @param third_routine_expected_result Expected result of third routine |
| * @param fourth_routine_expected_result Expected result of fourth routine |
| **/ |
| bool FunctionalTest5::verify(const Utils::vec4<glw::GLfloat>& first_routine_result, |
| const Utils::vec4<glw::GLfloat>& second_routine_result, |
| const Utils::vec4<glw::GLfloat>& third_routine_result, |
| const Utils::vec4<glw::GLuint>& fourth_routine_result, |
| const Utils::vec4<glw::GLfloat>& first_routine_expected_result, |
| const Utils::vec4<glw::GLfloat>& second_routine_expected_result, |
| const Utils::vec4<glw::GLfloat>& third_routine_expected_result, |
| const Utils::vec4<glw::GLuint>& fourth_routine_expected_result) const |
| { |
| bool result = true; |
| |
| result = result && (first_routine_result == first_routine_expected_result); |
| result = result && (second_routine_result == second_routine_expected_result); |
| result = result && (third_routine_result == third_routine_expected_result); |
| result = result && (fourth_routine_result == fourth_routine_expected_result); |
| |
| return result; |
| } |
| |
| /** Constructor |
| * |
| * @param context CTS context |
| **/ |
| FunctionalTest6::FunctionalTest6(deqp::Context& context) |
| : TestCase(context, "static_subroutine_call", "Verify that subroutine can be called in a static manner") |
| { |
| } |
| |
| /** Execute test |
| * |
| * @return tcu::TestNode::STOP |
| **/ |
| tcu::TestNode::IterateResult FunctionalTest6::iterate() |
| { |
| static const GLchar* vertex_shader_code = "#version 400 core\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "// Subroutine type\n" |
| "subroutine vec4 routine_type(in vec4 iparam);\n" |
| "\n" |
| "// Subroutine definition\n" |
| "subroutine(routine_type) vec4 square(in vec4 iparam)\n" |
| "{\n" |
| " return iparam * iparam;\n" |
| "}\n" |
| "\n" |
| "// Sub routine uniform\n" |
| "subroutine uniform routine_type routine;\n" |
| "\n" |
| "// Input data\n" |
| "uniform vec4 input_data;\n" |
| "\n" |
| "// Output\n" |
| "out vec4 out_result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " out_result = square(input_data);\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* varying_name = "out_result"; |
| |
| /* Test data */ |
| static const Utils::vec4<GLfloat> input_data(1.0f, 4.0f, 9.0f, 16.0f); |
| |
| static const Utils::vec4<GLfloat> expected_result(1.0f, 16.0f, 81.0f, 256.0f); |
| |
| static const GLuint transform_feedback_buffer_size = 4 * sizeof(GLfloat); |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* GL objects */ |
| Utils::program program(m_context); |
| Utils::buffer transform_feedback_buffer(m_context); |
| Utils::vertexArray vao(m_context); |
| |
| /* Init GL objects */ |
| program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code, &varying_name, |
| 1 /* n_varyings */); |
| |
| program.use(); |
| |
| vao.generate(); |
| vao.bind(); |
| |
| transform_feedback_buffer.generate(); |
| transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */, |
| GL_DYNAMIC_COPY); |
| transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size); |
| |
| /* Test */ |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| const GLint uniform_location = gl.getUniformLocation(program.m_program_object_id, "input_data"); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "GetUniformLocation"); |
| |
| if (-1 == uniform_location) |
| { |
| TCU_FAIL("Uniform is not available"); |
| } |
| |
| /* Set up input data uniforms */ |
| gl.uniform4f(uniform_location, input_data.m_x, input_data.m_y, input_data.m_z, input_data.m_w); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f"); |
| |
| /* Execute draw call with transform feedback */ |
| gl.beginTransformFeedback(GL_POINTS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); |
| |
| gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); |
| |
| gl.endTransformFeedback(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); |
| |
| /* Capture results */ |
| GLfloat* feedback_data = (GLfloat*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); |
| |
| Utils::vec4<GLfloat> result(feedback_data[0], feedback_data[1], feedback_data[2], feedback_data[3]); |
| |
| gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); |
| |
| /* Verify */ |
| if (expected_result == result) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result." |
| << tcu::TestLog::EndMessage; |
| |
| tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; |
| |
| message << "Function: square( "; |
| input_data.log(message); |
| message << " ). Result: "; |
| result.log(message); |
| message << ". Expected: "; |
| expected_result.log(message); |
| |
| message << tcu::TestLog::EndMessage; |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| } |
| |
| /* Done */ |
| return tcu::TestNode::STOP; |
| } |
| |
| /** Constructor |
| * |
| * @param context CTS context |
| **/ |
| FunctionalTest7_8::FunctionalTest7_8(deqp::Context& context) |
| : TestCase(context, "arrayed_subroutine_uniforms", "Verify that subroutine can be called in a static manner") |
| { |
| } |
| |
| /** Execute test |
| * |
| * @return tcu::TestNode::STOP |
| **/ |
| tcu::TestNode::IterateResult FunctionalTest7_8::iterate() |
| { |
| static const GLchar* vertex_shader_code = |
| "#version 400 core\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "// Subroutine type\n" |
| "subroutine vec4 routine_type(in vec4 left, in vec4 right);\n" |
| "\n" |
| "// Subroutine definitions\n" |
| "subroutine(routine_type) vec4 add(in vec4 left, in vec4 right)\n" |
| "{\n" |
| " return left + right;\n" |
| "}\n" |
| "\n" |
| "subroutine(routine_type) vec4 multiply(in vec4 left, in vec4 right)\n" |
| "{\n" |
| " return left * right;\n" |
| "}\n" |
| "\n" |
| "// Sub routine uniform\n" |
| "subroutine uniform routine_type routine[4];\n" |
| "\n" |
| "// Input data\n" |
| "uniform vec4 uni_left;\n" |
| "uniform vec4 uni_right;\n" |
| "uniform uvec4 uni_indices;\n" |
| "\n" |
| "// Output\n" |
| "out vec4 out_combined;\n" |
| "out vec4 out_combined_inverted;\n" |
| "out vec4 out_constant;\n" |
| "out vec4 out_constant_inverted;\n" |
| "out vec4 out_dynamic;\n" |
| "out vec4 out_dynamic_inverted;\n" |
| "out vec4 out_loop;\n" |
| "out uint out_array_length;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " out_combined = routine[3](routine[2](routine[1](routine[0](uni_left, uni_right), uni_right), " |
| "uni_right), uni_right);\n" |
| " out_combined_inverted = routine[0](routine[1](routine[2](routine[3](uni_left, uni_right), uni_right), " |
| "uni_right), uni_right);\n" |
| " \n" |
| " out_constant = routine[3](routine[2](routine[1](routine[0](vec4(1, 2, 3, 4), vec4(-5, -6, -7, " |
| "-8)), vec4(-1, -2, -3, -4)), vec4(5, 6, 7, 8)), vec4(1, 2, 3, 4));\n" |
| " out_constant_inverted = routine[0](routine[1](routine[2](routine[3](vec4(1, 2, 3, 4), vec4(-5, -6, -7, " |
| "-8)), vec4(-1, -2, -3, -4)), vec4(5, 6, 7, 8)), vec4(1, 2, 3, 4));\n" |
| " \n" |
| " out_dynamic = " |
| "routine[uni_indices.w](routine[uni_indices.z](routine[uni_indices.y](routine[uni_indices.x](uni_left, " |
| "uni_right), uni_right), uni_right), uni_right);\n" |
| " out_dynamic_inverted = " |
| "routine[uni_indices.x](routine[uni_indices.y](routine[uni_indices.z](routine[uni_indices.w](uni_left, " |
| "uni_right), uni_right), uni_right), uni_right);\n" |
| " \n" |
| " out_loop = uni_left;\n" |
| " for (uint i = 0u; i < routine.length(); ++i)\n" |
| " {\n" |
| " out_loop = routine[i](out_loop, uni_right);\n" |
| " }\n" |
| " \n" |
| " out_array_length = routine.length() + 6 - (uni_indices.x + uni_indices.y + uni_indices.z + " |
| "uni_indices.w);\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* subroutine_names[] = { |
| "add", "multiply", |
| }; |
| static const GLuint n_subroutine_names = sizeof(subroutine_names) / sizeof(subroutine_names[0]); |
| |
| static const GLchar* subroutine_uniform_names[] = { "routine[0]", "routine[1]", "routine[2]", "routine[3]" }; |
| static const GLuint n_subroutine_uniform_names = |
| sizeof(subroutine_uniform_names) / sizeof(subroutine_uniform_names[0]); |
| |
| static const GLchar* uniform_names[] = { |
| "uni_left", "uni_right", "uni_indices", |
| }; |
| static const GLuint n_uniform_names = sizeof(uniform_names) / sizeof(uniform_names[0]); |
| |
| static const GLchar* varying_names[] = { "out_combined", "out_combined_inverted", |
| "out_constant", "out_constant_inverted", |
| "out_dynamic", "out_dynamic_inverted", |
| "out_loop", "out_array_length" }; |
| |
| static const GLuint n_varyings = sizeof(varying_names) / sizeof(varying_names[0]); |
| static const GLuint transform_feedback_buffer_size = n_varyings * 4 * sizeof(GLfloat); |
| |
| /* Test data */ |
| static const Utils::vec4<GLfloat> uni_left(-1.0f, 0.75f, -0.5f, 0.25f); |
| static const Utils::vec4<GLfloat> uni_right(1.0f, -0.75f, 0.5f, -0.25f); |
| static const Utils::vec4<GLuint> uni_indices(1, 2, 0, 3); |
| |
| static const GLuint subroutine_combinations[][4] = { |
| { 0, 0, 0, 0 }, /* + + + + */ |
| { 0, 0, 0, 1 }, /* + + + * */ |
| { 0, 0, 1, 0 }, /* + + * + */ |
| { 0, 0, 1, 1 }, /* + + * * */ |
| { 0, 1, 0, 0 }, /* + * + + */ |
| { 0, 1, 0, 1 }, /* + * + * */ |
| { 0, 1, 1, 0 }, /* + * * + */ |
| { 0, 1, 1, 1 }, /* + * * * */ |
| { 1, 0, 0, 0 }, /* * + + + */ |
| { 1, 0, 0, 1 }, /* * + + * */ |
| { 1, 0, 1, 0 }, /* * + * + */ |
| { 1, 0, 1, 1 }, /* * + * * */ |
| { 1, 1, 0, 0 }, /* * * + + */ |
| { 1, 1, 0, 1 }, /* * * + * */ |
| { 1, 1, 1, 0 }, /* * * * + */ |
| { 1, 1, 1, 1 } /* * * * * */ |
| }; |
| static const GLuint n_subroutine_combinations = |
| sizeof(subroutine_combinations) / sizeof(subroutine_combinations[0]); |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* GL objects */ |
| Utils::program program(m_context); |
| Utils::buffer transform_feedback_buffer(m_context); |
| Utils::vertexArray vao(m_context); |
| |
| bool result = true; |
| |
| /* Init GL objects */ |
| program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code, varying_names, |
| n_varyings); |
| |
| program.use(); |
| |
| vao.generate(); |
| vao.bind(); |
| |
| transform_feedback_buffer.generate(); |
| |
| /* Get subroutine indices */ |
| for (GLuint routine = 0; routine < n_subroutine_names; ++routine) |
| { |
| m_subroutine_indices[routine] = program.getSubroutineIndex(subroutine_names[routine], GL_VERTEX_SHADER); |
| } |
| |
| /* Get subroutine uniform locations */ |
| for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform) |
| { |
| m_subroutine_uniform_locations[uniform] = |
| program.getSubroutineUniformLocation(subroutine_uniform_names[uniform], GL_VERTEX_SHADER); |
| } |
| |
| /* Get uniform locations */ |
| for (GLuint i = 0; i < n_uniform_names; ++i) |
| { |
| m_uniform_locations[i] = program.getUniformLocation(uniform_names[i]); |
| } |
| |
| /* Test */ |
| for (GLuint i = 0; i < n_subroutine_combinations; ++i) |
| { |
| /* Clean */ |
| transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */, |
| GL_DYNAMIC_COPY); |
| transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size); |
| |
| /* Verify */ |
| if (false == testDraw(subroutine_combinations[i], uni_left, uni_right, uni_indices)) |
| { |
| result = false; |
| } |
| } |
| |
| if (true == result) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| /* Done */ |
| return tcu::TestNode::STOP; |
| } |
| |
| /* Calculate result of function applied to operands |
| * |
| * @param function Function id, 0 is sum, 1 is multiplication |
| * @param left Left operand |
| * @param right Right operand |
| * @param out Function result |
| **/ |
| void FunctionalTest7_8::calculate(glw::GLuint function, const Utils::vec4<glw::GLfloat>& left, |
| const Utils::vec4<glw::GLfloat>& right, Utils::vec4<glw::GLfloat>& out) const |
| { |
| if (0 == function) |
| { |
| out.m_x = left.m_x + right.m_x; |
| out.m_y = left.m_y + right.m_y; |
| out.m_z = left.m_z + right.m_z; |
| out.m_w = left.m_w + right.m_w; |
| } |
| else |
| { |
| out.m_x = left.m_x * right.m_x; |
| out.m_y = left.m_y * right.m_y; |
| out.m_z = left.m_z * right.m_z; |
| out.m_w = left.m_w * right.m_w; |
| } |
| } |
| |
| /** Calculate expected values for all operations |
| * |
| * @param combination Function combination, first applied function is at index [0] |
| * @param left Left operand |
| * @param right Right operand |
| * @param indices Indices used by dynamic calls |
| * @param out_combined Expected result of "combined" operation |
| * @param out_combined_inverted Expected result of "combined_inverted" operation |
| * @param out_constant Expected result of "constant" operation |
| * @param out_constant_inverted Expected result of "constant_inverted" operation |
| * @param out_dynamic Expected result of "dynamic" operation |
| * @param out_dynamic_inverted Expected result of "out_dynamic_inverted" operation |
| * @param out_loop Expected result of "loop" operation |
| **/ |
| void FunctionalTest7_8::calculate( |
| const glw::GLuint combination[4], const Utils::vec4<glw::GLfloat>& left, const Utils::vec4<glw::GLfloat>& right, |
| const Utils::vec4<glw::GLuint>& indices, Utils::vec4<glw::GLfloat>& out_combined, |
| Utils::vec4<glw::GLfloat>& out_combined_inverted, Utils::vec4<glw::GLfloat>& out_constant, |
| Utils::vec4<glw::GLfloat>& out_constant_inverted, Utils::vec4<glw::GLfloat>& out_dynamic, |
| Utils::vec4<glw::GLfloat>& out_dynamic_inverted, Utils::vec4<glw::GLfloat>& out_loop) const |
| { |
| /* Indices used by "dynamic" operations, range <0..4> */ |
| const GLuint dynamic_combination[4] = { combination[indices.m_x], combination[indices.m_y], |
| combination[indices.m_z], combination[indices.m_w] }; |
| |
| /* Values used by "constant" operations, come from shader code */ |
| const Utils::vec4<glw::GLfloat> constant_values[] = { Utils::vec4<glw::GLfloat>(1, 2, 3, 4), |
| Utils::vec4<glw::GLfloat>(-5, -6, -7, -8), |
| Utils::vec4<glw::GLfloat>(-1, -2, -3, -4), |
| Utils::vec4<glw::GLfloat>(5, 6, 7, 8), |
| Utils::vec4<glw::GLfloat>(1, 2, 3, 4) }; |
| |
| /* Start values */ |
| Utils::vec4<glw::GLfloat> combined = left; |
| Utils::vec4<glw::GLfloat> combined_inverted = left; |
| Utils::vec4<glw::GLfloat> constant = constant_values[0]; |
| Utils::vec4<glw::GLfloat> constant_inverted = constant_values[0]; |
| Utils::vec4<glw::GLfloat> dynamic = left; |
| Utils::vec4<glw::GLfloat> dynamic_inverted = left; |
| |
| /* Calculate expected results */ |
| for (GLuint i = 0; i < 4; ++i) |
| { |
| GLuint function = combination[i]; |
| GLuint function_inverted = combination[3 - i]; |
| GLuint dynamic_function = dynamic_combination[i]; |
| GLuint dynamic_function_inverted = dynamic_combination[3 - i]; |
| |
| calculate(function, combined, right, combined); |
| calculate(function_inverted, combined_inverted, right, combined_inverted); |
| calculate(function, constant, constant_values[i + 1], constant); |
| calculate(function_inverted, constant_inverted, constant_values[i + 1], constant_inverted); |
| calculate(dynamic_function, dynamic, right, dynamic); |
| calculate(dynamic_function_inverted, dynamic_inverted, right, dynamic_inverted); |
| } |
| |
| /* Store results */ |
| out_combined = combined; |
| out_combined_inverted = combined_inverted; |
| out_constant = constant; |
| out_constant_inverted = constant_inverted; |
| out_dynamic = dynamic; |
| out_dynamic_inverted = dynamic_inverted; |
| out_loop = combined; |
| } |
| |
| /** Log error |
| * |
| * @param combination Operations combination |
| * @param left Left operand |
| * @param right Right operand |
| * @param indices Inidices used by "dynamic" calls |
| * @param vec4_expected Expected results |
| * @param vec4_result Results |
| * @param array_length Length of array |
| * @param result Comparison results |
| **/ |
| void FunctionalTest7_8::logError(const glw::GLuint combination[4], const Utils::vec4<glw::GLfloat>& left, |
| const Utils::vec4<glw::GLfloat>& right, const Utils::vec4<glw::GLuint>& indices, |
| const Utils::vec4<glw::GLfloat> vec4_expected[7], |
| const Utils::vec4<glw::GLfloat> vec4_result[7], glw::GLuint array_length, |
| bool result[7]) const |
| { |
| static const GLuint n_functions = 4; |
| static const GLuint n_operations = 7; |
| |
| /* Indices used by "dynamic" operations, range <0..4> */ |
| const GLuint dynamic_combination[4] = { combination[indices.m_x], combination[indices.m_y], |
| combination[indices.m_z], combination[indices.m_w] }; |
| |
| /* Function symbols */ |
| GLchar functions[4]; |
| GLchar functions_inverted[4]; |
| GLchar functions_dynamic[4]; |
| GLchar functions_dynamic_inverted[4]; |
| |
| for (GLuint i = 0; i < n_functions; ++i) |
| { |
| GLchar function = (0 == combination[i]) ? '+' : '*'; |
| GLchar dynamic_function = (0 == dynamic_combination[i]) ? '+' : '*'; |
| |
| functions[i] = function; |
| functions_inverted[n_functions - i - 1] = function; |
| functions_dynamic[i] = dynamic_function; |
| functions_dynamic_inverted[n_functions - i - 1] = dynamic_function; |
| } |
| |
| /* Values used by "constant" operations, come from shader code */ |
| const Utils::vec4<glw::GLfloat> constant_values[] = { Utils::vec4<glw::GLfloat>(1, 2, 3, 4), |
| Utils::vec4<glw::GLfloat>(-5, -6, -7, -8), |
| Utils::vec4<glw::GLfloat>(-1, -2, -3, -4), |
| Utils::vec4<glw::GLfloat>(5, 6, 7, 8), |
| Utils::vec4<glw::GLfloat>(1, 2, 3, 4) }; |
| |
| /* Values used by non-"constant" operations */ |
| Utils::vec4<glw::GLfloat> dynamic_values[5]; |
| dynamic_values[0] = left; |
| dynamic_values[1] = right; |
| dynamic_values[2] = right; |
| dynamic_values[3] = right; |
| dynamic_values[4] = right; |
| |
| /* For each operation */ |
| for (GLuint i = 0; i < n_operations; ++i) |
| { |
| /* If result is failure */ |
| if (false == result[i]) |
| { |
| const GLchar* description = 0; |
| const Utils::vec4<glw::GLfloat>* input = 0; |
| const GLchar* operation = 0; |
| |
| switch (i) |
| { |
| case 0: |
| description = "Call made with predefined array indices"; |
| input = dynamic_values; |
| operation = functions; |
| break; |
| case 1: |
| description = "Call made with predefined array indices in inverted order"; |
| input = dynamic_values; |
| operation = functions_inverted; |
| break; |
| case 2: |
| description = "Call made with predefined array indices, for constant values"; |
| input = constant_values; |
| operation = functions; |
| break; |
| case 3: |
| description = "Call made with predefined array indices in inverted order, for constant values"; |
| input = constant_values; |
| operation = functions_inverted; |
| break; |
| case 4: |
| description = "Call made with dynamic array indices"; |
| input = dynamic_values; |
| operation = functions_dynamic; |
| break; |
| case 5: |
| description = "Call made with dynamic array indices in inverted order"; |
| input = dynamic_values; |
| operation = functions_dynamic_inverted; |
| break; |
| case 6: |
| description = "Call made with loop"; |
| input = dynamic_values; |
| operation = functions; |
| break; |
| } |
| |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result." |
| << tcu::TestLog::EndMessage; |
| |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << description << tcu::TestLog::EndMessage; |
| |
| tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; |
| |
| message << "Operation: (((("; |
| input[0].log(message); |
| for (GLuint function = 0; function < n_functions; ++function) |
| { |
| message << " " << operation[function] << " "; |
| |
| input[function + 1].log(message); |
| |
| message << ")"; |
| } |
| |
| message << tcu::TestLog::EndMessage; |
| |
| message = m_context.getTestContext().getLog() << tcu::TestLog::Message; |
| |
| message << "Result: "; |
| vec4_result[i].log(message); |
| |
| message << tcu::TestLog::EndMessage; |
| |
| message = m_context.getTestContext().getLog() << tcu::TestLog::Message; |
| |
| message << "Expected: "; |
| vec4_expected[i].log(message); |
| |
| message << tcu::TestLog::EndMessage; |
| } |
| |
| /* Check array length, it should be 4 */ |
| if (4 != array_length) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message |
| << "Error. Invalid array length: " << array_length << ". Expected 4." |
| << tcu::TestLog::EndMessage; |
| } |
| } |
| } |
| |
| /** Execute draw call and verifies captrued varyings |
| * |
| * @param combination Function combination, first applied function is at index [0] |
| * @param left Left operand |
| * @param right Right operand |
| * @param indices Indices used by dynamic calls |
| * |
| * @return true if all results match expected values, false otherwise |
| **/ |
| bool FunctionalTest7_8::testDraw(const glw::GLuint combination[4], const Utils::vec4<glw::GLfloat>& left, |
| const Utils::vec4<glw::GLfloat>& right, const Utils::vec4<glw::GLuint>& indices) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| static const GLuint n_vec4_varyings = 7; |
| bool result = true; |
| GLuint subroutine_indices[4]; |
| static const GLuint n_subroutine_uniforms = sizeof(subroutine_indices) / sizeof(subroutine_indices[0]); |
| |
| /* Prepare expected results */ |
| Utils::vec4<glw::GLfloat> expected_results[7]; |
| calculate(combination, left, right, indices, expected_results[0], expected_results[1], expected_results[2], |
| expected_results[3], expected_results[4], expected_results[5], expected_results[6]); |
| |
| /* Set up input data uniforms */ |
| gl.uniform4f(m_uniform_locations[0], left.m_x, left.m_y, left.m_z, left.m_w); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f"); |
| |
| gl.uniform4f(m_uniform_locations[1], right.m_x, right.m_y, right.m_z, right.m_w); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f"); |
| |
| gl.uniform4ui(m_uniform_locations[2], indices.m_x, indices.m_y, indices.m_z, indices.m_w); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4ui"); |
| |
| /* Prepare subroutine uniform data */ |
| for (GLuint i = 0; i < n_subroutine_uniforms; ++i) |
| { |
| const GLuint location = m_subroutine_uniform_locations[i]; |
| |
| subroutine_indices[location] = m_subroutine_indices[combination[i]]; |
| } |
| |
| /* Set up subroutine uniforms */ |
| gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, n_subroutine_uniforms, &subroutine_indices[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); |
| |
| /* Execute draw call with transform feedback */ |
| gl.beginTransformFeedback(GL_POINTS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); |
| |
| gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); |
| |
| gl.endTransformFeedback(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); |
| |
| /* Capture results */ |
| GLvoid* feedback_data = (GLvoid*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); |
| |
| Utils::vec4<GLfloat> vec4_results[7]; |
| bool results[7]; |
| GLfloat* float_data = (GLfloat*)feedback_data; |
| for (GLuint i = 0; i < n_vec4_varyings; ++i) |
| { |
| vec4_results[i].m_x = float_data[i * 4 + 0]; |
| vec4_results[i].m_y = float_data[i * 4 + 1]; |
| vec4_results[i].m_z = float_data[i * 4 + 2]; |
| vec4_results[i].m_w = float_data[i * 4 + 3]; |
| } |
| |
| GLuint* uint_data = (GLuint*)(float_data + (n_vec4_varyings)*4); |
| GLuint array_length = uint_data[0]; |
| |
| /* Unmap buffer */ |
| gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); |
| |
| /* Verification */ |
| for (GLuint i = 0; i < n_vec4_varyings; ++i) |
| { |
| results[i] = (vec4_results[i] == expected_results[i]); |
| result = result && results[i]; |
| } |
| |
| result = result && (4 == array_length); |
| |
| /* Log error if any */ |
| if (false == result) |
| { |
| logError(combination, left, right, indices, expected_results, vec4_results, array_length, results); |
| } |
| |
| /* Done */ |
| return result; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| * |
| **/ |
| FunctionalTest9::FunctionalTest9(deqp::Context& context) |
| : TestCase(context, "subroutines_3_subroutine_types_and_subroutine_uniforms_one_function", |
| "Makes sure that program with one function associated with 3 different " |
| "subroutine types and 3 subroutine uniforms using that function compiles " |
| "and works as expected") |
| , m_has_test_passed(true) |
| , m_n_points_to_draw(16) /* arbitrary value */ |
| , m_po_id(0) |
| , m_vao_id(0) |
| , m_vs_id(0) |
| , m_xfb_bo_id(0) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** De-initializes GL objects that may have been created during test execution. */ |
| void FunctionalTest9::deinit() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| 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; |
| } |
| |
| if (m_xfb_bo_id != 0) |
| { |
| gl.deleteBuffers(1, &m_xfb_bo_id); |
| |
| m_xfb_bo_id = 0; |
| } |
| } |
| |
| /** Retrieves body of a vertex shader that should be used |
| * for the testing purposes. |
| **/ |
| std::string FunctionalTest9::getVertexShaderBody() const |
| { |
| return "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "subroutine void subroutineType1(inout float);\n" |
| "subroutine void subroutineType2(inout float);\n" |
| "subroutine void subroutineType3(inout float);\n" |
| "\n" |
| "subroutine(subroutineType1, subroutineType2, subroutineType3) void function(inout float result)\n" |
| "{\n" |
| " result += float(0.123) + float(gl_VertexID);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineType1 subroutine_uniform1;\n" |
| "subroutine uniform subroutineType2 subroutine_uniform2;\n" |
| "subroutine uniform subroutineType3 subroutine_uniform3;\n" |
| "\n" |
| "out vec4 result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " result = vec4(0, 1, 2, 3);\n" |
| "\n" |
| " subroutine_uniform1(result.x);\n" |
| " subroutine_uniform2(result.y);\n" |
| " subroutine_uniform3(result.z);\n" |
| "\n" |
| " result.w += result.x + result.y + result.z;\n" |
| "}\n"; |
| } |
| |
| /** Initializes all GL objects required to run the test. */ |
| void FunctionalTest9::initTest() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Set up program object */ |
| const char* xfb_varyings[] = { "result" }; |
| |
| const unsigned int n_xfb_varyings = sizeof(xfb_varyings) / sizeof(xfb_varyings[0]); |
| if (!Utils::buildProgram(gl, getVertexShaderBody(), "", /* tc_body */ |
| "", /* te_body */ |
| "", /* gs_body */ |
| "", /* fs_body */ |
| xfb_varyings, n_xfb_varyings, &m_vs_id, DE_NULL, /* out_tc_id */ |
| DE_NULL, /* out_te_id */ |
| DE_NULL, /* out_gs_id */ |
| DE_NULL, /* out_fs_id */ |
| &m_po_id)) |
| { |
| TCU_FAIL("Program failed to link successfully"); |
| } |
| |
| /* Set up a buffer object we will use to hold XFB data */ |
| const unsigned int xfb_bo_size = static_cast<unsigned int>(sizeof(float) * 4 /* components */ * m_n_points_to_draw); |
| |
| gl.genBuffers(1, &m_xfb_bo_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed."); |
| |
| gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_xfb_bo_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed."); |
| |
| gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* index */, m_xfb_bo_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed."); |
| |
| gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, xfb_bo_size, DE_NULL, /* data */ |
| GL_STATIC_COPY); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed."); |
| |
| /* Generate & bind a VAO */ |
| 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."); |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult FunctionalTest9::iterate() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| initTest(); |
| |
| /* Issue a draw call to make use of the three subroutine uniforms that we've defined */ |
| gl.useProgram(m_po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); |
| |
| gl.beginTransformFeedback(GL_POINTS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed."); |
| { |
| gl.drawArrays(GL_POINTS, 0 /* first */, m_n_points_to_draw); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed."); |
| } |
| gl.endTransformFeedback(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed."); |
| |
| /* Map the XFB BO storage into process space */ |
| const glw::GLvoid* xfb_data_ptr = gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer() call failed."); |
| |
| verifyXFBData(xfb_data_ptr); |
| |
| gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed."); |
| |
| /* All done */ |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Verifies the data XFBed out by the vertex shader. Should the data |
| * be found invalid, m_has_test_passed will be set to false. |
| * |
| * @param data_ptr XFB data. |
| **/ |
| void FunctionalTest9::verifyXFBData(const glw::GLvoid* data_ptr) |
| { |
| const float epsilon = 1e-5f; |
| bool should_continue = true; |
| const glw::GLfloat* traveller_ptr = (const glw::GLfloat*)data_ptr; |
| |
| for (unsigned int n_point = 0; n_point < m_n_points_to_draw && should_continue; ++n_point) |
| { |
| tcu::Vec4 expected_result(0, 1, 2, 3); |
| |
| for (unsigned int n_component = 0; n_component < 3 /* xyz */; ++n_component) |
| { |
| expected_result[n_component] += 0.123f + float(n_point); |
| } |
| |
| expected_result[3 /* w */] += expected_result[0] + expected_result[1] + expected_result[2]; |
| |
| if (de::abs(expected_result[0] - traveller_ptr[0]) > epsilon || |
| de::abs(expected_result[1] - traveller_ptr[1]) > epsilon || |
| de::abs(expected_result[2] - traveller_ptr[2]) > epsilon || |
| de::abs(expected_result[3] - traveller_ptr[3]) > epsilon) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "XFBed data is invalid. Expected:" |
| "(" |
| << expected_result[0] << ", " << expected_result[1] << ", " << expected_result[2] << ", " |
| << expected_result[3] << "), found:(" << traveller_ptr[0] << ", " << traveller_ptr[1] |
| << ", " << traveller_ptr[2] << ", " << traveller_ptr[3] << ")." |
| << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| should_continue = false; |
| } |
| |
| traveller_ptr += 4; /* xyzw */ |
| } /* for (all rendered points) */ |
| } |
| |
| /** Constructor |
| * |
| * @param context CTS context |
| **/ |
| FunctionalTest10::FunctionalTest10(deqp::Context& context) |
| : TestCase(context, "arrays_of_arrays_of_uniforms", "Verify that arrays of arrays of uniforms works as expected") |
| { |
| } |
| |
| /** Execute test |
| * |
| * @return tcu::TestNode::STOP |
| **/ |
| tcu::TestNode::IterateResult FunctionalTest10::iterate() |
| { |
| static const GLchar* vertex_shader_code = "#version 400 core\n" |
| "#extension GL_ARB_arrays_of_arrays : require\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "// Subroutine type\n" |
| "subroutine int routine_type(in int iparam);\n" |
| "\n" |
| "// Subroutine definitions\n" |
| "subroutine(routine_type) int increment(in int iparam)\n" |
| "{\n" |
| " return iparam + 1;\n" |
| "}\n" |
| "\n" |
| "subroutine(routine_type) int decrement(in int iparam)\n" |
| "{\n" |
| " return iparam - 1;\n" |
| "}\n" |
| "\n" |
| "// Sub routine uniform\n" |
| "subroutine uniform routine_type routine[4][4];\n" |
| "\n" |
| "// Output\n" |
| "out int out_result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " int result = 0;\n" |
| " \n" |
| " for (uint j = 0; j < routine.length(); ++j)\n" |
| " {\n" |
| " for (uint i = 0; i < routine[j].length(); ++i)\n" |
| " {\n" |
| " result = routine[j][i](result);\n" |
| " }\n" |
| " }\n" |
| " \n" |
| " out_result = result;\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* subroutine_names[] = { |
| "increment", "decrement", |
| }; |
| static const GLuint n_subroutine_names = sizeof(subroutine_names) / sizeof(subroutine_names[0]); |
| |
| static const GLchar* subroutine_uniform_names[] = { |
| "routine[0][0]", "routine[1][0]", "routine[2][0]", "routine[3][0]", "routine[0][1]", "routine[1][1]", |
| "routine[2][1]", "routine[3][1]", "routine[0][2]", "routine[1][2]", "routine[2][2]", "routine[3][2]", |
| "routine[0][3]", "routine[1][3]", "routine[2][3]", "routine[3][3]" |
| }; |
| static const GLuint n_subroutine_uniform_names = |
| sizeof(subroutine_uniform_names) / sizeof(subroutine_uniform_names[0]); |
| |
| static const GLchar* varying_name = "out_result"; |
| static const GLuint transform_feedback_buffer_size = sizeof(GLint); |
| |
| static const GLuint configuration_increment[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; |
| |
| static const GLuint configuration_decrement[16] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; |
| |
| static const GLuint configuration_mix[16] = { 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1 }; |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* Do not execute the test if GL_ARB_arrays_of_arrays is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_arrays_of_arrays")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_arrays_of_arrays is not supported."); |
| } |
| |
| bool result = true; |
| |
| /* GL objects */ |
| Utils::program program(m_context); |
| Utils::buffer transform_feedback_buffer(m_context); |
| Utils::vertexArray vao(m_context); |
| |
| /* Init GL objects */ |
| program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code, &varying_name, |
| 1 /* n_varyings */); |
| |
| program.use(); |
| |
| vao.generate(); |
| vao.bind(); |
| |
| transform_feedback_buffer.generate(); |
| transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */, |
| GL_DYNAMIC_COPY); |
| transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size); |
| |
| /* Get subroutine indices */ |
| for (GLuint routine = 0; routine < n_subroutine_names; ++routine) |
| { |
| m_subroutine_indices[routine] = program.getSubroutineIndex(subroutine_names[routine], GL_VERTEX_SHADER); |
| } |
| |
| /* Get subroutine uniform locations */ |
| for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform) |
| { |
| m_subroutine_uniform_locations[uniform] = |
| program.getSubroutineUniformLocation(subroutine_uniform_names[uniform], GL_VERTEX_SHADER); |
| } |
| |
| /* Test */ |
| GLint increment_result = testDraw(configuration_increment); |
| GLint decrement_result = testDraw(configuration_decrement); |
| GLint mix_result = testDraw(configuration_mix); |
| |
| /* Verify */ |
| if (16 != increment_result) |
| { |
| result = false; |
| } |
| |
| if (-16 != decrement_result) |
| { |
| result = false; |
| } |
| if (0 != mix_result) |
| { |
| result = false; |
| } |
| |
| /* Set test result */ |
| if (true == result) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result." |
| << " Incrementation applied 16 times: " << increment_result |
| << ". Decrementation applied 16 times: " << decrement_result |
| << ". Incrementation and decrementation applied 8 times: " << mix_result |
| << tcu::TestLog::EndMessage; |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| /* Done */ |
| return tcu::TestNode::STOP; |
| } |
| |
| /** Execute draw call and return captured varying |
| * |
| * @param routine_indices Configuration of subroutine uniforms |
| * |
| * @return Value of varying captured with transform feedback |
| **/ |
| GLint FunctionalTest10::testDraw(const GLuint routine_indices[16]) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLuint subroutine_indices[16]; |
| static const GLuint n_subroutine_uniforms = sizeof(subroutine_indices) / sizeof(subroutine_indices[0]); |
| |
| /* Prepare subroutine uniform data */ |
| for (GLuint i = 0; i < n_subroutine_uniforms; ++i) |
| { |
| const GLuint location = m_subroutine_uniform_locations[i]; |
| |
| subroutine_indices[location] = m_subroutine_indices[routine_indices[i]]; |
| } |
| |
| /* Set up subroutine uniforms */ |
| gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, n_subroutine_uniforms, &subroutine_indices[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); |
| |
| /* Execute draw call with transform feedback */ |
| gl.beginTransformFeedback(GL_POINTS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); |
| |
| gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); |
| |
| gl.endTransformFeedback(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); |
| |
| /* Capture results */ |
| GLint* feedback_data = (GLint*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); |
| |
| GLint result = feedback_data[0]; |
| |
| /* Unmap buffer */ |
| gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); |
| |
| return result; |
| } |
| |
| /* Definitions of constants used by FunctionalTest11 */ |
| const GLuint FunctionalTest11::m_texture_height = 32; |
| const GLuint FunctionalTest11::m_texture_width = 32; |
| |
| /** Constructor |
| * |
| * @param context CTS context |
| **/ |
| FunctionalTest11::FunctionalTest11(deqp::Context& context) |
| : TestCase(context, "globals_sampling_output_discard_function_calls", "Verify that global variables, texture " |
| "sampling, fragment output, fragment discard " |
| "and function calls work as expected") |
| { |
| } |
| |
| /** Execute test |
| * |
| * @return tcu::TestNode::STOP |
| **/ |
| tcu::TestNode::IterateResult FunctionalTest11::iterate() |
| { |
| static const GLchar* fragment_shader_code = |
| "#version 400 core\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "// Output\n" |
| "layout(location = 0) out vec4 out_color;\n" |
| "\n" |
| "// Global variables\n" |
| "vec4 success_color;\n" |
| "vec4 failure_color;\n" |
| "\n" |
| "// Samplers\n" |
| "uniform sampler2D sampler_1;\n" |
| "uniform sampler2D sampler_2;\n" |
| "\n" |
| "// Functions\n" |
| "bool are_same(in vec4 left, in vec4 right)\n" |
| "{\n" |
| " bvec4 result;\n" |
| "\n" |
| " result.x = (left.x == right.x);\n" |
| " result.y = (left.y == right.y);\n" |
| " result.z = (left.z == right.z);\n" |
| " result.w = (left.w == right.w);\n" |
| "\n" |
| " return all(result);\n" |
| "}\n" |
| "\n" |
| "bool are_different(in vec4 left, in vec4 right)\n" |
| "{\n" |
| " bvec4 result;\n" |
| "\n" |
| " result.x = (left.x != right.x);\n" |
| " result.y = (left.y != right.y);\n" |
| " result.z = (left.z != right.z);\n" |
| " result.w = (left.w != right.w);\n" |
| "\n" |
| " return any(result);\n" |
| "}\n" |
| "\n" |
| "// Subroutine types\n" |
| "subroutine void discard_fragment_type(void);\n" |
| "subroutine void set_global_colors_type(void);\n" |
| "subroutine vec4 sample_texture_type(in vec2);\n" |
| "subroutine bool comparison_type(in vec4 left, in vec4 right);\n" |
| "subroutine void test_type(void);\n" |
| "\n" |
| "// Subroutine definitions\n" |
| "// discard_fragment_type\n" |
| "subroutine(discard_fragment_type) void discard_yes(void)\n" |
| "{\n" |
| " discard;\n" |
| "}\n" |
| "\n" |
| "subroutine(discard_fragment_type) void discard_no(void)\n" |
| "{\n" |
| "}\n" |
| "\n" |
| "// set_global_colors_type\n" |
| "subroutine(set_global_colors_type) void red_pass_blue_fail(void)\n" |
| "{\n" |
| " success_color = vec4(1, 0, 0, 1);\n" |
| " failure_color = vec4(0, 0, 1, 1);\n" |
| "}\n" |
| "\n" |
| "subroutine(set_global_colors_type) void blue_pass_red_fail(void)\n" |
| "{\n" |
| " success_color = vec4(0, 0, 1, 1);\n" |
| " failure_color = vec4(1, 0, 0, 1);\n" |
| "}\n" |
| "\n" |
| "// sample_texture_type\n" |
| "subroutine(sample_texture_type) vec4 first_sampler(in vec2 coord)\n" |
| "{\n" |
| " return texture(sampler_1, coord);\n" |
| "}\n" |
| "\n" |
| "subroutine(sample_texture_type) vec4 second_sampler(in vec2 coord)\n" |
| "{\n" |
| " return texture(sampler_2, coord);\n" |
| "}\n" |
| "\n" |
| "// comparison_type\n" |
| "subroutine(comparison_type) bool check_equal(in vec4 left, in vec4 right)\n" |
| "{\n" |
| " return are_same(left, right);\n" |
| "}\n" |
| "\n" |
| "subroutine(comparison_type) bool check_not_equal(in vec4 left, in vec4 right)\n" |
| "{\n" |
| " return are_different(left, right);\n" |
| "}\n" |
| "\n" |
| "// Subroutine uniforms\n" |
| "subroutine uniform discard_fragment_type discard_fragment;\n" |
| "subroutine uniform set_global_colors_type set_global_colors;\n" |
| "subroutine uniform sample_texture_type sample_texture;\n" |
| "subroutine uniform comparison_type compare;\n" |
| "\n" |
| "// Subroutine definitions\n" |
| "// test_type\n" |
| "subroutine(test_type) void test_with_discard(void)\n" |
| "{\n" |
| " discard_fragment();" |
| "\n" |
| " out_color = failure_color;\n" |
| "\n" |
| " set_global_colors();\n" |
| "\n" |
| " vec4 sampled_color = sample_texture(gl_PointCoord);\n" |
| "\n" |
| " bool comparison_result = compare(success_color, sampled_color);\n" |
| "\n" |
| " if (true == comparison_result)\n" |
| " {\n" |
| " out_color = success_color;\n" |
| " }\n" |
| " else\n" |
| " {\n" |
| " out_color = failure_color;\n" |
| " }\n" |
| "}\n" |
| "\n" |
| "subroutine(test_type) void test_without_discard(void)\n" |
| "{\n" |
| " set_global_colors();\n" |
| "\n" |
| " vec4 sampled_color = sample_texture(gl_PointCoord);\n" |
| "\n" |
| " bool comparison_result = compare(success_color, sampled_color);\n" |
| "\n" |
| " if (true == comparison_result)\n" |
| " {\n" |
| " out_color = success_color;\n" |
| " }\n" |
| " else\n" |
| " {\n" |
| " out_color = failure_color;\n" |
| " }\n" |
| "}\n" |
| "\n" |
| "// Subroutine uniforms\n" |
| "subroutine uniform test_type test;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " // Set colors\n" |
| " success_color = vec4(0.5, 0.5, 0.5, 0.5);\n" |
| " failure_color = vec4(0.5, 0.5, 0.5, 0.5);\n" |
| "\n" |
| " test();\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* geometry_shader_code = "#version 400 core\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "layout(points) in;\n" |
| "layout(triangle_strip, max_vertices = 4) out;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = vec4(-1, -1, 0, 1);\n" |
| " EmitVertex();\n" |
| " \n" |
| " gl_Position = vec4(-1, 1, 0, 1);\n" |
| " EmitVertex();\n" |
| " \n" |
| " gl_Position = vec4( 1, -1, 0, 1);\n" |
| " EmitVertex();\n" |
| " \n" |
| " gl_Position = vec4( 1, 1, 0, 1);\n" |
| " EmitVertex();\n" |
| " \n" |
| " EndPrimitive();\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* vertex_shader_code = "#version 400 core\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* subroutine_names[][2] = { { "discard_yes", "discard_no" }, |
| { "red_pass_blue_fail", "blue_pass_red_fail" }, |
| { "first_sampler", "second_sampler" }, |
| { "check_equal", "check_not_equal" }, |
| { "test_with_discard", "test_without_discard" } }; |
| static const GLuint n_subroutine_types = sizeof(subroutine_names) / sizeof(subroutine_names[0]); |
| |
| static const GLchar* subroutine_uniform_names[] = { "discard_fragment", "set_global_colors", "sample_texture", |
| "compare", "test" }; |
| static const GLuint n_subroutine_uniform_names = |
| sizeof(subroutine_uniform_names) / sizeof(subroutine_uniform_names[0]); |
| |
| static const GLchar* uniform_names[] = { |
| "sampler_1", "sampler_2", |
| }; |
| static const GLuint n_uniform_names = sizeof(uniform_names) / sizeof(uniform_names[0]); |
| |
| /* Colors */ |
| static const GLubyte blue_color[4] = { 0, 0, 255, 255 }; |
| static const GLubyte clean_color[4] = { 0, 0, 0, 0 }; |
| static const GLubyte red_color[4] = { 255, 0, 0, 255 }; |
| |
| /* Configurations */ |
| static const testConfiguration test_configurations[] = { |
| testConfiguration( |
| "Expect red color from 1st sampler", red_color, 1 /* discard_fragment : discard_no */, |
| 0 /* set_global_colors : red_pass_blue_fail */, 0 /* sample_texture : first_sampler */, |
| 0 /* compare : check_equal */, 0 /* test : test_with_discard */, 1 /* red */, |
| 0 /* blue */), |
| |
| testConfiguration( |
| "Test \"without discard\" option, expect no blue color from 2nd sampler", blue_color, |
| 0 /* discard_fragment : discard_yes */, 1 /* set_global_colors : blue_pass_red_fail */, |
| 1 /* sample_texture : second_sampler */, 1 /* compare : check_not_equal */, |
| 1 /* test : test_without_discard */, 0 /* blue */, 1 /* red */), |
| |
| testConfiguration("Fragment shoud be discarded", clean_color, 0 /* discard_fragment : discard_yes */, |
| 0 /* set_global_colors : red_pass_blue_fail */, |
| 0 /* sample_texture : first_sampler */, |
| 0 /* compare : check_equal */, |
| 0 /* test : test_with_discard */, 1 /* red */, 0 /* blue */), |
| |
| testConfiguration( |
| "Expect blue color from 1st sampler", blue_color, 1 /* discard_fragment : discard_no */, |
| 1 /* set_global_colors : blue_pass_red_fail */, 0 /* sample_texture : first_sampler */, |
| 0 /* compare : check_equal */, 0 /* test : test_with_discard */, |
| 0 /* blue */, 1 /* red */), |
| |
| testConfiguration( |
| "Expect red color from 2nd sampler", red_color, 1 /* discard_fragment : discard_no */, |
| 0 /* set_global_colors : red_pass_blue_fail */, 1 /* sample_texture : second_sampler */, |
| 0 /* compare : check_equal */, 0 /* test : test_with_discard */, |
| 0 /* blue */, 1 /* red */), |
| |
| testConfiguration( |
| "Expect no blue color from 2nd sampler", blue_color, 1 /* discard_fragment : discard_no */, |
| 1 /* set_global_colors : blue_pass_red_fail */, 1 /* sample_texture : second_sampler */, |
| 1 /* compare : check_not_equal */, 0 /* test : test_with_discard */, |
| 0 /* blue */, 1 /* red */), |
| }; |
| static const GLuint n_test_cases = sizeof(test_configurations) / sizeof(test_configurations[0]); |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* GL objects */ |
| Utils::texture blue_texture(m_context); |
| Utils::texture color_texture(m_context); |
| Utils::framebuffer framebuffer(m_context); |
| Utils::program program(m_context); |
| Utils::texture red_texture(m_context); |
| Utils::vertexArray vao(m_context); |
| |
| /* Init GL objects */ |
| program.build(0 /* cs */, fragment_shader_code /* fs */, geometry_shader_code /* gs */, 0 /* tcs */, 0 /* test */, |
| vertex_shader_code, 0 /* varying_names */, 0 /* n_varyings */); |
| |
| program.use(); |
| |
| vao.generate(); |
| vao.bind(); |
| |
| blue_texture.create(m_texture_width, m_texture_height, GL_RGBA8); |
| color_texture.create(m_texture_width, m_texture_height, GL_RGBA8); |
| red_texture.create(m_texture_width, m_texture_height, GL_RGBA8); |
| |
| framebuffer.generate(); |
| framebuffer.bind(); |
| framebuffer.attachTexture(GL_COLOR_ATTACHMENT0, color_texture.m_id, m_texture_width, m_texture_height); |
| |
| /* Get subroutine indices */ |
| for (GLuint type = 0; type < n_subroutine_types; ++type) |
| { |
| m_subroutine_indices[type][0] = program.getSubroutineIndex(subroutine_names[type][0], GL_FRAGMENT_SHADER); |
| m_subroutine_indices[type][1] = program.getSubroutineIndex(subroutine_names[type][1], GL_FRAGMENT_SHADER); |
| } |
| |
| /* Get subroutine uniform locations */ |
| for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform) |
| { |
| m_subroutine_uniform_locations[uniform] = |
| program.getSubroutineUniformLocation(subroutine_uniform_names[uniform], GL_FRAGMENT_SHADER); |
| } |
| |
| /* Get uniform locations */ |
| for (GLuint i = 0; i < n_uniform_names; ++i) |
| { |
| m_uniform_locations[i] = program.getUniformLocation(uniform_names[i]); |
| } |
| |
| /* Prepare textures */ |
| fillTexture(blue_texture, blue_color); |
| fillTexture(color_texture, clean_color); |
| fillTexture(red_texture, red_color); |
| |
| m_source_textures[0] = blue_texture.m_id; |
| m_source_textures[1] = red_texture.m_id; |
| |
| framebuffer.clearColor(0.0f, 0.0f, 0.0f, 0.0f); |
| |
| /* Test */ |
| bool result = true; |
| for (GLuint i = 0; i < n_test_cases; ++i) |
| { |
| /* Clean output texture */ |
| framebuffer.clear(GL_COLOR_BUFFER_BIT); |
| |
| /* Execute test */ |
| if (false == testDraw(test_configurations[i].m_routines, test_configurations[i].m_samplers, |
| test_configurations[i].m_expected_color, color_texture)) |
| { |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "Error. Failure for configuration: " << test_configurations[i].m_description |
| << tcu::TestLog::EndMessage; |
| |
| result = false; |
| } |
| } |
| |
| /* Set result */ |
| if (true == result) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| /* Done */ |
| return tcu::TestNode::STOP; |
| } |
| |
| /** Fill texture with specified color |
| * |
| * @param texture Texture instance |
| * @param color Color |
| **/ |
| void FunctionalTest11::fillTexture(Utils::texture& texture, const glw::GLubyte color[4]) const |
| { |
| std::vector<GLubyte> texture_data; |
| |
| /* Prepare texture data */ |
| texture_data.resize(m_texture_width * m_texture_height * 4); |
| |
| for (GLuint y = 0; y < m_texture_height; ++y) |
| { |
| const GLuint line_offset = y * m_texture_width * 4; |
| |
| for (GLuint x = 0; x < m_texture_width; ++x) |
| { |
| const GLuint point_offset = x * 4 + line_offset; |
| |
| texture_data[point_offset + 0] = color[0]; /* red */ |
| texture_data[point_offset + 1] = color[1]; /* green */ |
| texture_data[point_offset + 2] = color[2]; /* blue */ |
| texture_data[point_offset + 3] = color[3]; /* alpha */ |
| } |
| } |
| |
| texture.update(m_texture_width, m_texture_height, GL_RGBA, GL_UNSIGNED_BYTE, &texture_data[0]); |
| } |
| |
| /** Execute draw call and verify results |
| * |
| * @param routine_configuration Configurations of routines to be used |
| * @param sampler_configuration Configuration of textures to be bound to samplers |
| * @param expected_color Expected color of result image |
| * |
| * @return true if result image is filled with expected color, false otherwise |
| **/ |
| bool FunctionalTest11::testDraw(const glw::GLuint routine_configuration[5], const glw::GLuint sampler_configuration[2], |
| const glw::GLubyte expected_color[4], Utils::texture& color_texture) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| static const GLint n_samplers = 2; |
| static const GLint n_subroutine_uniforms = 5; |
| GLuint subroutine_indices[5]; |
| |
| /* Set samplers */ |
| for (GLuint i = 0; i < n_samplers; ++i) |
| { |
| const GLuint location = m_uniform_locations[i]; |
| const GLuint texture = m_source_textures[sampler_configuration[i]]; |
| |
| gl.activeTexture(GL_TEXTURE0 + i); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "ActiveTexture"); |
| |
| gl.bindTexture(GL_TEXTURE_2D, texture); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture"); |
| |
| gl.uniform1i(location, i); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform1i"); |
| } |
| |
| gl.activeTexture(GL_TEXTURE0 + 0); |
| |
| /* Set subroutine uniforms */ |
| for (GLuint i = 0; i < n_subroutine_uniforms; ++i) |
| { |
| const GLuint location = m_subroutine_uniform_locations[i]; |
| const GLuint routine = routine_configuration[i]; |
| |
| subroutine_indices[location] = m_subroutine_indices[i][routine]; |
| } |
| |
| gl.uniformSubroutinesuiv(GL_FRAGMENT_SHADER, 5, subroutine_indices); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); |
| |
| /* Draw */ |
| gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); |
| |
| /* Capture result */ |
| std::vector<GLubyte> captured_data; |
| captured_data.resize(m_texture_width * m_texture_height * 4); |
| |
| color_texture.get(GL_RGBA, GL_UNSIGNED_BYTE, &captured_data[0]); |
| |
| /* Verify result */ |
| for (GLuint y = 0; y < m_texture_height; ++y) |
| { |
| const GLuint line_offset = y * m_texture_width * 4; |
| |
| for (GLuint x = 0; x < m_texture_width; ++x) |
| { |
| const GLuint point_offset = x * 4 + line_offset; |
| bool is_as_expected = true; |
| |
| is_as_expected = is_as_expected && (expected_color[0] == captured_data[point_offset + 0]); /* red */ |
| is_as_expected = is_as_expected && (expected_color[1] == captured_data[point_offset + 1]); /* green */ |
| is_as_expected = is_as_expected && (expected_color[2] == captured_data[point_offset + 2]); /* blue */ |
| is_as_expected = is_as_expected && (expected_color[3] == captured_data[point_offset + 3]); /* alpha */ |
| |
| if (false == is_as_expected) |
| { |
| return false; |
| } |
| } |
| } |
| |
| /* Done */ |
| return true; |
| } |
| |
| /* Constatns used by FunctionalTest12 */ |
| const glw::GLuint FunctionalTest12::m_texture_height = 16; |
| const glw::GLuint FunctionalTest12::m_texture_width = 16; |
| |
| /** Constructor |
| * |
| * @param context CTS context |
| **/ |
| FunctionalTest12::FunctionalTest12(deqp::Context& context) |
| : TestCase(context, "ssbo_atomic_image_load_store", |
| "Verify that SSBO, atomic counters and image load store work as expected") |
| , m_left_image(0) |
| , m_right_image(0) |
| { |
| } |
| |
| /** Execute test |
| * |
| * @return tcu::TestNode::STOP |
| **/ |
| tcu::TestNode::IterateResult FunctionalTest12::iterate() |
| { |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| bool result = true; |
| |
| /* Test atomic counters */ |
| if (true == m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_atomic_counters")) |
| { |
| if (false == testAtomic()) |
| { |
| result = false; |
| } |
| } |
| |
| /* Test shader storage buffer */ |
| if (true == m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_storage_buffer_object")) |
| { |
| if (false == testSSBO()) |
| { |
| result = false; |
| } |
| } |
| |
| /* Test image load store */ |
| if (true == m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_image_load_store")) |
| { |
| if (false == testImage()) |
| { |
| result = false; |
| } |
| } |
| |
| /* Set result */ |
| if (true == result) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| /* Done */ |
| return tcu::TestNode::STOP; |
| } |
| |
| /** Fill texture with specified color |
| * |
| * @param texture Texture instance |
| * @param color Color |
| **/ |
| void FunctionalTest12::fillTexture(Utils::texture& texture, const glw::GLuint color[4]) const |
| { |
| std::vector<GLuint> texture_data; |
| |
| /* Prepare texture data */ |
| texture_data.resize(m_texture_width * m_texture_height * 4); |
| |
| for (GLuint y = 0; y < m_texture_height; ++y) |
| { |
| const GLuint line_offset = y * m_texture_width * 4; |
| |
| for (GLuint x = 0; x < m_texture_width; ++x) |
| { |
| const GLuint point_offset = x * 4 + line_offset; |
| |
| texture_data[point_offset + 0] = color[0]; /* red */ |
| texture_data[point_offset + 1] = color[1]; /* green */ |
| texture_data[point_offset + 2] = color[2]; /* blue */ |
| texture_data[point_offset + 3] = color[3]; /* alpha */ |
| } |
| } |
| |
| texture.update(m_texture_width, m_texture_height, GL_RGBA_INTEGER, GL_UNSIGNED_INT, &texture_data[0]); |
| } |
| |
| /** Test atomic counters |
| * |
| * @return true if test pass, false otherwise |
| **/ |
| bool FunctionalTest12::testAtomic() |
| { |
| static const GLchar* fragment_shader_code = "#version 400 core\n" |
| "#extension GL_ARB_shader_atomic_counters : require\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "layout(location = 0) out uint out_color;\n" |
| "\n" |
| "layout(binding = 0, offset = 8) uniform atomic_uint one;\n" |
| "layout(binding = 0, offset = 4) uniform atomic_uint two;\n" |
| "layout(binding = 0, offset = 0) uniform atomic_uint three;\n" |
| "\n" |
| "subroutine void atomic_routine(void)\n;" |
| "\n" |
| "subroutine(atomic_routine) void increment_two(void)\n" |
| "{\n" |
| " out_color = atomicCounterIncrement(two);\n" |
| "}\n" |
| "\n" |
| "subroutine(atomic_routine) void decrement_three(void)\n" |
| "{\n" |
| " out_color = atomicCounterDecrement(three);\n" |
| "}\n" |
| "\n" |
| "subroutine(atomic_routine) void read_one(void)\n" |
| "{\n" |
| " out_color = atomicCounter(one);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform atomic_routine routine;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " routine();\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* geometry_shader_code = "#version 400 core\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "layout(points) in;\n" |
| "layout(triangle_strip, max_vertices = 4) out;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = vec4(-1, -1, 0, 1);\n" |
| " EmitVertex();\n" |
| " \n" |
| " gl_Position = vec4(-1, 1, 0, 1);\n" |
| " EmitVertex();\n" |
| " \n" |
| " gl_Position = vec4( 1, -1, 0, 1);\n" |
| " EmitVertex();\n" |
| " \n" |
| " gl_Position = vec4( 1, 1, 0, 1);\n" |
| " EmitVertex();\n" |
| " \n" |
| " EndPrimitive();\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* vertex_shader_code = "#version 400 core\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* subroutine_names[] = { "increment_two", "decrement_three", "read_one" }; |
| |
| /* Test data */ |
| static const glw::GLuint atomic_buffer_data[] = { m_texture_width * m_texture_height, |
| m_texture_width * m_texture_height, |
| m_texture_width * m_texture_height }; |
| |
| static const glw::GLuint expected_incremented_two[] = { atomic_buffer_data[0], 2 * atomic_buffer_data[1], |
| atomic_buffer_data[2] }; |
| |
| static const glw::GLuint expected_decremented_three[] = { 0, expected_incremented_two[1], |
| expected_incremented_two[2] }; |
| |
| static const glw::GLuint expected_read_one[] = { expected_decremented_three[0], expected_decremented_three[1], |
| expected_decremented_three[2] }; |
| |
| /* GL objects */ |
| Utils::buffer atomic_buffer(m_context); |
| Utils::texture color_texture(m_context); |
| Utils::framebuffer framebuffer(m_context); |
| Utils::program program(m_context); |
| Utils::vertexArray vao(m_context); |
| |
| /* Init GL objects */ |
| program.build(0 /* cs */, fragment_shader_code /* fs */, geometry_shader_code /* gs */, 0 /* tcs */, 0 /* test */, |
| vertex_shader_code, 0 /* varying_names */, 0 /* n_varyings */); |
| |
| program.use(); |
| |
| vao.generate(); |
| vao.bind(); |
| |
| color_texture.create(m_texture_width, m_texture_height, GL_R32UI); |
| |
| atomic_buffer.generate(); |
| atomic_buffer.update(GL_ATOMIC_COUNTER_BUFFER, sizeof(atomic_buffer_data), (GLvoid*)atomic_buffer_data, |
| GL_STATIC_DRAW); |
| atomic_buffer.bindRange(GL_ATOMIC_COUNTER_BUFFER, 0 /* index */, 0 /* offset */, sizeof(atomic_buffer_data)); |
| |
| framebuffer.generate(); |
| framebuffer.bind(); |
| framebuffer.attachTexture(GL_COLOR_ATTACHMENT0, color_texture.m_id, m_texture_width, m_texture_height); |
| framebuffer.clearColor(0.0f, 0.0f, 0.0f, 0.0f); |
| framebuffer.clear(GL_COLOR_BUFFER_BIT); |
| |
| /* Subroutine indices */ |
| GLuint increment_two = program.getSubroutineIndex(subroutine_names[0], GL_FRAGMENT_SHADER); |
| GLuint decrement_three = program.getSubroutineIndex(subroutine_names[1], GL_FRAGMENT_SHADER); |
| GLuint read_one = program.getSubroutineIndex(subroutine_names[2], GL_FRAGMENT_SHADER); |
| |
| /* Test */ |
| bool result = true; |
| |
| if (false == testAtomicDraw(increment_two, expected_incremented_two)) |
| { |
| result = false; |
| } |
| |
| if (false == testAtomicDraw(decrement_three, expected_decremented_three)) |
| { |
| result = false; |
| } |
| |
| if (false == testAtomicDraw(read_one, expected_read_one)) |
| { |
| result = false; |
| } |
| |
| /* Done */ |
| return result; |
| } |
| |
| /** Execture draw call and verify results |
| * |
| * @param subroutine_index Index of subroutine that shall be used during draw call |
| * @param expected_results Expected results |
| * |
| * @return true if results are as expected, false otherwise |
| **/ |
| bool FunctionalTest12::testAtomicDraw(GLuint subroutine_index, const GLuint expected_results[3]) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Set subroutine uniforms */ |
| gl.uniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &subroutine_index); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); |
| |
| /* Draw */ |
| gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); |
| |
| /* Capture results */ |
| GLuint* atomic_results = (GLuint*)gl.mapBuffer(GL_ATOMIC_COUNTER_BUFFER, GL_READ_ONLY); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); |
| |
| /* Verify */ |
| bool result = (0 == memcmp(expected_results, atomic_results, 3 * sizeof(GLuint))); |
| |
| if (false == result) |
| { |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "Error. Invalid result. " |
| << "Result: [ " << atomic_results[0] << ", " << atomic_results[1] << ", " << atomic_results[2] << " ] " |
| << "Expected: [ " << expected_results[0] << ", " << expected_results[1] << ", " << expected_results[2] |
| << " ]" << tcu::TestLog::EndMessage; |
| } |
| |
| /* Unmap buffer */ |
| gl.unmapBuffer(GL_ATOMIC_COUNTER_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); |
| |
| /* Done */ |
| return result; |
| } |
| |
| /** Test image load store |
| * |
| * @return true if test pass, false otherwise |
| **/ |
| bool FunctionalTest12::testImage() |
| { |
| static const GLchar* fragment_shader_code = |
| "#version 400 core\n" |
| "#extension GL_ARB_shader_image_load_store : require\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "layout(location = 0) out uvec4 out_color;\n" |
| "\n" |
| "layout(rgba32ui) uniform uimage2D left_image;\n" |
| "layout(rgba32ui) uniform uimage2D right_image;\n" |
| "\n" |
| "subroutine void image_routine(void);\n" |
| "\n" |
| "subroutine(image_routine) void left_to_right(void)\n" |
| "{\n" |
| " out_color = imageLoad (left_image, ivec2(gl_FragCoord.xy));\n" |
| " imageStore(right_image, ivec2(gl_FragCoord.xy), out_color);\n" |
| "}\n" |
| "\n" |
| "subroutine(image_routine) void right_to_left(void)\n" |
| "{\n" |
| " out_color = imageLoad (right_image, ivec2(gl_FragCoord.xy));\n" |
| " imageStore(left_image, ivec2(gl_FragCoord.xy), out_color);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform image_routine routine;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " routine();\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* geometry_shader_code = "#version 400 core\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "layout(points) in;\n" |
| "layout(triangle_strip, max_vertices = 4) out;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = vec4(-1, -1, 0, 1);\n" |
| " EmitVertex();\n" |
| " \n" |
| " gl_Position = vec4(-1, 1, 0, 1);\n" |
| " EmitVertex();\n" |
| " \n" |
| " gl_Position = vec4( 1, -1, 0, 1);\n" |
| " EmitVertex();\n" |
| " \n" |
| " gl_Position = vec4( 1, 1, 0, 1);\n" |
| " EmitVertex();\n" |
| " \n" |
| " EndPrimitive();\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* vertex_shader_code = "#version 400 core\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* subroutine_names[] = { "left_to_right", "right_to_left" }; |
| |
| static const GLchar* uniform_names[] = { "left_image", "right_image" }; |
| |
| /* Test data */ |
| static const GLuint blue_color[4] = { 0, 0, 255, 255 }; |
| static const GLuint clean_color[4] = { 16, 32, 64, 128 }; |
| static const GLuint red_color[4] = { 255, 0, 0, 255 }; |
| |
| /* GL objects */ |
| Utils::texture blue_texture(m_context); |
| Utils::texture destination_texture(m_context); |
| Utils::texture color_texture(m_context); |
| Utils::framebuffer framebuffer(m_context); |
| Utils::program program(m_context); |
| Utils::texture red_texture(m_context); |
| Utils::vertexArray vao(m_context); |
| |
| /* Init GL objects */ |
| program.build(0 /* cs */, fragment_shader_code /* fs */, geometry_shader_code /* gs */, 0 /* tcs */, 0 /* test */, |
| vertex_shader_code, 0 /* varying_names */, 0 /* n_varyings */); |
| |
| program.use(); |
| |
| vao.generate(); |
| vao.bind(); |
| |
| blue_texture.create(m_texture_width, m_texture_height, GL_RGBA32UI); |
| destination_texture.create(m_texture_width, m_texture_height, GL_RGBA32UI); |
| color_texture.create(m_texture_width, m_texture_height, GL_RGBA32UI); |
| red_texture.create(m_texture_width, m_texture_height, GL_RGBA32UI); |
| |
| fillTexture(blue_texture, blue_color); |
| fillTexture(destination_texture, clean_color); |
| fillTexture(red_texture, red_color); |
| |
| framebuffer.generate(); |
| framebuffer.bind(); |
| framebuffer.attachTexture(GL_COLOR_ATTACHMENT0, color_texture.m_id, m_texture_width, m_texture_height); |
| framebuffer.clearColor(0.0f, 0.0f, 0.0f, 0.0f); |
| framebuffer.clear(GL_COLOR_BUFFER_BIT); |
| |
| /* Subroutine indices */ |
| GLuint left_to_right = program.getSubroutineIndex(subroutine_names[0], GL_FRAGMENT_SHADER); |
| GLuint right_to_left = program.getSubroutineIndex(subroutine_names[1], GL_FRAGMENT_SHADER); |
| |
| /* Uniform locations */ |
| m_left_image = program.getUniformLocation(uniform_names[0]); |
| m_right_image = program.getUniformLocation(uniform_names[1]); |
| |
| /* Test */ |
| bool result = true; |
| |
| if (false == testImageDraw(left_to_right, blue_texture, destination_texture, blue_color, blue_color)) |
| { |
| result = false; |
| } |
| |
| if (false == testImageDraw(left_to_right, red_texture, destination_texture, red_color, red_color)) |
| { |
| result = false; |
| } |
| |
| if (false == testImageDraw(right_to_left, destination_texture, blue_texture, blue_color, blue_color)) |
| { |
| result = false; |
| } |
| |
| if (false == testImageDraw(right_to_left, destination_texture, red_texture, red_color, red_color)) |
| { |
| result = false; |
| } |
| |
| if (false == testImageDraw(left_to_right, blue_texture, red_texture, blue_color, blue_color)) |
| { |
| result = false; |
| } |
| |
| /* Done */ |
| return result; |
| } |
| |
| /** Execute draw call and verifies results |
| * |
| * @param subroutine_index Index of subroutine that shall be used during draw call |
| * @param left "Left" texture |
| * @param right "Right" texture |
| * @param expected_left_color Expected color of "left" texture |
| * @param expected_right_color Expected color of "right" texture |
| * |
| * @return true if verification result is positive, false otherwise |
| **/ |
| bool FunctionalTest12::testImageDraw(GLuint subroutine_index, Utils::texture& left, Utils::texture& right, |
| const GLuint expected_left_color[4], const GLuint expected_right_color[4]) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Set subroutine uniforms */ |
| gl.uniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &subroutine_index); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); |
| |
| /* Set up image units */ |
| gl.uniform1i(m_left_image, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform1i"); |
| |
| gl.uniform1i(m_right_image, 1); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform1i"); |
| |
| gl.bindImageTexture(0, left.m_id, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32UI); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindImageTexture"); |
| |
| gl.bindImageTexture(1, right.m_id, 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32UI); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BindImageTexture"); |
| |
| /* Draw */ |
| gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); |
| |
| /* Verify results */ |
| bool result = true; |
| |
| if (false == verifyTexture(left, expected_left_color)) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message |
| << "Error. Invalid result. Left texture is filled with wrong color." |
| << tcu::TestLog::EndMessage; |
| result = false; |
| } |
| |
| if (false == verifyTexture(right, expected_right_color)) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message |
| << "Error. Invalid result. Right texture is filled with wrong color." |
| << tcu::TestLog::EndMessage; |
| result = false; |
| } |
| |
| /* Done */ |
| return result; |
| } |
| |
| /** Test shader storage buffer |
| * |
| * @return true if test pass, false otherwise |
| **/ |
| bool FunctionalTest12::testSSBO() |
| { |
| static const GLchar* fragment_shader_code = "#version 400 core\n" |
| "#extension GL_ARB_shader_storage_buffer_object : require\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "layout(location = 0) out uvec4 out_color;\n" |
| "\n" |
| "layout(std140, binding = 0) buffer Buffer\n" |
| "{\n" |
| " uvec4 entry;\n" |
| "};\n" |
| "\n" |
| "subroutine void ssbo_routine(void)\n;" |
| "\n" |
| "subroutine(ssbo_routine) void increment(void)\n" |
| "{\n" |
| " out_color.x = atomicAdd(entry.x, 1);\n" |
| " out_color.y = atomicAdd(entry.y, 1);\n" |
| " out_color.z = atomicAdd(entry.z, 1);\n" |
| " out_color.w = atomicAdd(entry.w, 1);\n" |
| "}\n" |
| "\n" |
| "subroutine(ssbo_routine) void decrement(void)\n" |
| "{\n" |
| " out_color.x = atomicAdd(entry.x, -1);\n" |
| " out_color.y = atomicAdd(entry.y, -1);\n" |
| " out_color.z = atomicAdd(entry.z, -1);\n" |
| " out_color.w = atomicAdd(entry.w, -1);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform ssbo_routine routine;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " routine();\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* geometry_shader_code = "#version 400 core\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "layout(points) in;\n" |
| "layout(triangle_strip, max_vertices = 4) out;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_Position = vec4(-1, -1, 0, 1);\n" |
| " EmitVertex();\n" |
| " \n" |
| " gl_Position = vec4(-1, 1, 0, 1);\n" |
| " EmitVertex();\n" |
| " \n" |
| " gl_Position = vec4( 1, -1, 0, 1);\n" |
| " EmitVertex();\n" |
| " \n" |
| " gl_Position = vec4( 1, 1, 0, 1);\n" |
| " EmitVertex();\n" |
| " \n" |
| " EndPrimitive();\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* vertex_shader_code = "#version 400 core\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* subroutine_names[] = { "increment", "decrement" }; |
| |
| /* Test data */ |
| static const glw::GLuint buffer_data[] = { m_texture_width * m_texture_height + 1, |
| m_texture_width * m_texture_height + 2, |
| m_texture_width * m_texture_height + 3, |
| m_texture_width * m_texture_height + 4 }; |
| |
| static const glw::GLuint expected_incremented[] = { m_texture_width * m_texture_height + buffer_data[0], |
| m_texture_width * m_texture_height + buffer_data[1], |
| m_texture_width * m_texture_height + buffer_data[2], |
| m_texture_width * m_texture_height + buffer_data[3] }; |
| |
| static const glw::GLuint expected_decremented[] = { buffer_data[0], buffer_data[1], buffer_data[2], |
| buffer_data[3] }; |
| |
| /* GL objects */ |
| Utils::buffer buffer(m_context); |
| Utils::texture color_texture(m_context); |
| Utils::framebuffer framebuffer(m_context); |
| Utils::program program(m_context); |
| Utils::vertexArray vao(m_context); |
| |
| /* Init GL objects */ |
| program.build(0 /* cs */, fragment_shader_code /* fs */, geometry_shader_code /* gs */, 0 /* tcs */, 0 /* test */, |
| vertex_shader_code, 0 /* varying_names */, 0 /* n_varyings */); |
| |
| program.use(); |
| |
| vao.generate(); |
| vao.bind(); |
| |
| color_texture.create(m_texture_width, m_texture_height, GL_RGBA32UI); |
| |
| buffer.generate(); |
| buffer.update(GL_SHADER_STORAGE_BUFFER, sizeof(buffer_data), (GLvoid*)buffer_data, GL_STATIC_DRAW); |
| buffer.bindRange(GL_SHADER_STORAGE_BUFFER, 0 /* index */, 0 /* offset */, sizeof(buffer_data)); |
| |
| framebuffer.generate(); |
| framebuffer.bind(); |
| framebuffer.attachTexture(GL_COLOR_ATTACHMENT0, color_texture.m_id, m_texture_width, m_texture_height); |
| framebuffer.clearColor(0.0f, 0.0f, 0.0f, 0.0f); |
| framebuffer.clear(GL_COLOR_BUFFER_BIT); |
| |
| /* Subroutine indices */ |
| GLuint increment = program.getSubroutineIndex(subroutine_names[0], GL_FRAGMENT_SHADER); |
| GLuint decrement = program.getSubroutineIndex(subroutine_names[1], GL_FRAGMENT_SHADER); |
| |
| /* Test */ |
| bool result = true; |
| |
| if (false == testSSBODraw(increment, expected_incremented)) |
| { |
| result = false; |
| } |
| |
| if (false == testSSBODraw(decrement, expected_decremented)) |
| { |
| result = false; |
| } |
| |
| /* Done */ |
| return result; |
| } |
| |
| /** Execute draw call and verify results |
| * |
| * @param subroutine_index Index of subroutine that shall be used by draw call |
| * @param expected_results Expected results |
| * |
| * |
| **/ |
| bool FunctionalTest12::testSSBODraw(GLuint subroutine_index, const GLuint expected_results[4]) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Set subroutine uniforms */ |
| gl.uniformSubroutinesuiv(GL_FRAGMENT_SHADER, 1, &subroutine_index); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); |
| |
| /* Draw */ |
| gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); |
| |
| /* Capture results */ |
| GLuint* ssbo_results = (GLuint*)gl.mapBuffer(GL_SHADER_STORAGE_BUFFER, GL_READ_ONLY); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); |
| |
| /* Verify */ |
| bool result = (0 == memcmp(expected_results, ssbo_results, 4 * sizeof(GLuint))); |
| |
| if (false == result) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result. " |
| << "Result: [ " << ssbo_results[0] << ", " << ssbo_results[1] << ", " |
| << ssbo_results[2] << ", " << ssbo_results[3] << " ] " |
| << "Expected: [ " << expected_results[0] << ", " << expected_results[1] |
| << ", " << expected_results[2] << ", " << expected_results[3] << " ]" |
| << tcu::TestLog::EndMessage; |
| } |
| |
| /* Unmap buffer */ |
| gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); |
| |
| /* Done */ |
| return result; |
| } |
| |
| /** Check if texture is filled with expected color |
| * |
| * @param texture Texture instance |
| * @param expected_color Expected color |
| * |
| * @return true if texture is filled with specified color, false otherwise |
| **/ |
| bool FunctionalTest12::verifyTexture(Utils::texture& texture, const GLuint expected_color[4]) const |
| { |
| std::vector<GLuint> results; |
| results.resize(m_texture_width * m_texture_height * 4); |
| |
| texture.get(GL_RGBA_INTEGER, GL_UNSIGNED_INT, &results[0]); |
| |
| for (GLuint y = 0; y < m_texture_height; ++y) |
| { |
| const GLuint line_offset = y * m_texture_width * 4; |
| |
| for (GLuint x = 0; x < m_texture_width; ++x) |
| { |
| const GLuint point_offset = line_offset + x * 4; |
| bool result = true; |
| |
| result = result && (results[point_offset + 0] == expected_color[0]); |
| result = result && (results[point_offset + 1] == expected_color[1]); |
| result = result && (results[point_offset + 2] == expected_color[2]); |
| result = result && (results[point_offset + 3] == expected_color[3]); |
| |
| if (false == result) |
| { |
| return false; |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| * |
| **/ |
| FunctionalTest13::FunctionalTest13(deqp::Context& context) |
| : TestCase(context, "subroutines_with_separate_shader_objects", |
| "Verifies that subroutines work correctly when used in separate " |
| "shader objects") |
| , m_fbo_id(0) |
| , m_pipeline_id(0) |
| , m_read_buffer(DE_NULL) |
| , m_to_height(4) |
| , m_to_id(0) |
| , m_to_width(4) |
| , m_vao_id(0) |
| , m_has_test_passed(true) |
| { |
| memset(m_fs_po_ids, 0, sizeof(m_fs_po_ids)); |
| memset(m_gs_po_ids, 0, sizeof(m_gs_po_ids)); |
| memset(m_tc_po_ids, 0, sizeof(m_tc_po_ids)); |
| memset(m_te_po_ids, 0, sizeof(m_te_po_ids)); |
| memset(m_vs_po_ids, 0, sizeof(m_vs_po_ids)); |
| } |
| |
| /** Deinitializes all GL objects that may have been created during test |
| * execution, as well as releases all process-side buffers that may have |
| * been allocated during the process. |
| * The function also restores default GL state configuration. |
| **/ |
| void FunctionalTest13::deinit() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_fbo_id != 0) |
| { |
| gl.deleteFramebuffers(1, &m_fbo_id); |
| |
| m_fbo_id = 0; |
| } |
| |
| if (m_pipeline_id != 0) |
| { |
| gl.deleteProgramPipelines(1, &m_pipeline_id); |
| |
| m_pipeline_id = 0; |
| } |
| |
| if (m_read_buffer != DE_NULL) |
| { |
| delete[] m_read_buffer; |
| |
| m_read_buffer = DE_NULL; |
| } |
| |
| for (unsigned int n_id = 0; n_id < 2 /* po id variants */; ++n_id) |
| { |
| if (m_fs_po_ids[n_id] != 0) |
| { |
| gl.deleteProgram(m_fs_po_ids[n_id]); |
| |
| m_fs_po_ids[n_id] = 0; |
| } |
| |
| if (m_gs_po_ids[n_id] != 0) |
| { |
| gl.deleteProgram(m_gs_po_ids[n_id]); |
| |
| m_gs_po_ids[n_id] = 0; |
| } |
| |
| if (m_tc_po_ids[n_id] != 0) |
| { |
| gl.deleteProgram(m_tc_po_ids[n_id]); |
| |
| m_tc_po_ids[n_id] = 0; |
| } |
| |
| if (m_te_po_ids[n_id] != 0) |
| { |
| gl.deleteProgram(m_te_po_ids[n_id]); |
| |
| m_te_po_ids[n_id] = 0; |
| } |
| |
| if (m_vs_po_ids[n_id] != 0) |
| { |
| gl.deleteProgram(m_vs_po_ids[n_id]); |
| |
| m_vs_po_ids[n_id] = 0; |
| } |
| } /* for (both shader program object variants) */ |
| |
| if (m_to_id != 0) |
| { |
| gl.deleteTextures(1, &m_to_id); |
| |
| m_to_id = 0; |
| } |
| |
| if (m_vao_id != 0) |
| { |
| gl.deleteVertexArrays(1, &m_vao_id); |
| |
| m_vao_id = 0; |
| } |
| |
| /* Restore default GL_PATCH_VERTICES setting value */ |
| gl.patchParameteri(GL_PATCH_VERTICES, 3); |
| |
| /* Restore default GL_PACK_ALIGNMENT setting value */ |
| gl.pixelStorei(GL_PACK_ALIGNMENT, 4); |
| } |
| |
| /** Retrieves body of a fragment shader that should be used for the test. |
| * The subroutine implementations are slightly changed, depending on the |
| * index of the shader, as specified by the caller. |
| * |
| * @param n_id Index of the shader. |
| * |
| * @return Requested string. |
| **/ |
| std::string FunctionalTest13::getFragmentShaderBody(unsigned int n_id) |
| { |
| std::stringstream result_sstream; |
| |
| /* Pre-amble */ |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| /* Sub-routine */ |
| "subroutine void SubroutineFSType(inout vec4 result);\n" |
| "\n" |
| "subroutine(SubroutineFSType) void SubroutineFS1(inout vec4 result)\n" |
| "{\n" |
| " result += vec4(" |
| << float(n_id + 1) / 10.0f << ", " << float(n_id + 2) / 10.0f << ", " << float(n_id + 3) / 10.0f |
| << ", " << float(n_id + 4) / 10.0f |
| << ");\n" |
| "}\n" |
| "subroutine(SubroutineFSType) void SubroutineFS2(inout vec4 result)\n" |
| "{\n" |
| " result += vec4(" |
| << float(n_id + 1) / 20.0f << ", " << float(n_id + 2) / 20.0f << ", " << float(n_id + 3) / 20.0f |
| << ", " << float(n_id + 4) / 20.0f << ");\n" |
| "}\n" |
| "\n" |
| "subroutine uniform SubroutineFSType function;\n" |
| "\n" |
| /* Input block */ |
| "in GS_DATA\n" |
| "{\n" |
| " vec4 data;\n" |
| "} in_gs;\n" |
| "\n" |
| "out vec4 result;\n" |
| /* main() declaration */ |
| "void main()\n" |
| "{\n" |
| " vec4 data = in_gs.data;\n" |
| " function(data);\n" |
| "\n" |
| " result = data;\n" |
| "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves body of a geometry shader that should be used for the test. |
| * The subroutine implementations are slightly changed, depending on the |
| * index of the shader, as specified by the caller. |
| * |
| * @param n_id Index of the shader. |
| * |
| * @return Requested string. |
| **/ |
| std::string FunctionalTest13::getGeometryShaderBody(unsigned int n_id) |
| { |
| std::stringstream result_sstream; |
| |
| /* Pre-amble */ |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout(points) in;\n" |
| "layout(triangle_strip, max_vertices = 4) out;\n" |
| /* Sub-routine */ |
| "subroutine void SubroutineGSType(inout vec4 result);\n" |
| "\n" |
| "subroutine(SubroutineGSType) void SubroutineGS1(inout vec4 result)\n" |
| "{\n" |
| " result += vec4(0, 0, 0, " |
| << float(n_id + 1) * 0.425f << ");\n" |
| "}\n" |
| "subroutine(SubroutineGSType) void SubroutineGS2(inout vec4 result)\n" |
| "{\n" |
| " result += vec4(0, 0, 0, " |
| << float(n_id + 1) * 0.0425f << ");\n" |
| "}\n" |
| "\n" |
| "subroutine uniform SubroutineGSType function;\n" |
| "\n" |
| /* Input block */ |
| "in TE_DATA\n" |
| "{\n" |
| " vec4 data;\n" |
| "} in_te[];\n" |
| "\n" |
| /* Output block */ |
| "out GS_DATA\n" |
| "{\n" |
| " vec4 data;\n" |
| "} out_gs;\n" |
| "\n" |
| "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n" |
| "out gl_PerVertex { vec4 gl_Position; };\n" |
| /* main() declaration */ |
| "void main()\n" |
| "{\n" |
| " vec4 data = in_te[0].data;\n" |
| "\n" |
| " function(data);\n" |
| "\n" |
| " gl_Position = vec4(1, -1, 0, 1);\n" |
| " out_gs.data = data;\n" |
| " EmitVertex();\n" |
| "\n" |
| " gl_Position = vec4(-1, -1, 0, 1);\n" |
| " out_gs.data = data;\n" |
| " EmitVertex();\n" |
| "\n" |
| " gl_Position = vec4(1, 1, 0, 1);\n" |
| " out_gs.data = data;\n" |
| " EmitVertex();\n" |
| "\n" |
| " gl_Position = vec4(-1, 1, 0, 1);\n" |
| " out_gs.data = data;\n" |
| " EmitVertex();\n" |
| " EndPrimitive();\n" |
| "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves body of a tessellation control shader that should be used for the test. |
| * The subroutine implementations are slightly changed, depending on the |
| * index of the shader, as specified by the caller. |
| * |
| * @param n_id Index of the shader. |
| * |
| * @return Requested string. |
| **/ |
| std::string FunctionalTest13::getTessellationControlShaderBody(unsigned int n_id) |
| { |
| std::stringstream result_sstream; |
| |
| /* Pre-amble */ |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout(vertices = 4) out;\n" |
| /* Sub-routine */ |
| "subroutine void SubroutineTCType(inout vec4 result);\n" |
| "\n" |
| "subroutine(SubroutineTCType) void SubroutineTC1(inout vec4 result)\n" |
| "{\n" |
| " result += vec4(0, " |
| << float(n_id + 1) * 0.25f << ", 0, 0);\n" |
| "}\n" |
| "subroutine(SubroutineTCType) void SubroutineTC2(inout vec4 result)\n" |
| "{\n" |
| " result += vec4(0, " |
| << float(n_id + 1) * 0.025f |
| << ", 0, 0);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform SubroutineTCType function;\n" |
| "\n" |
| /* Input block */ |
| "in VS_DATA\n" |
| "{\n" |
| " vec4 data;\n" |
| "} in_vs[];\n" |
| "\n" |
| /* Output block */ |
| "out TC_DATA\n" |
| "{\n" |
| " vec4 data;\n" |
| "} out_tc[];\n" |
| "\n" |
| "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n" |
| "out gl_PerVertex { vec4 gl_Position; } gl_out[];\n" |
| /* main() declaration */ |
| "void main()\n" |
| "{\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| " gl_TessLevelOuter[2] = 1.0;\n" |
| " gl_TessLevelOuter[3] = 1.0;\n" |
| " gl_TessLevelInner[0] = 1.0;\n" |
| " gl_TessLevelInner[1] = 1.0;\n" |
| " gl_out[gl_InvocationID].gl_Position = gl_in[0].gl_Position;\n" |
| " out_tc[gl_InvocationID].data = in_vs[0].data;\n" |
| "\n" |
| " function(out_tc[gl_InvocationID].data);\n" |
| "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves body of a tessellation evaluation shader that should be used for the test. |
| * The subroutine implementations are slightly changed, depending on the |
| * index of the shader, as specified by the caller. |
| * |
| * @param n_id Index of the shader. |
| * |
| * @return Requested string. |
| **/ |
| std::string FunctionalTest13::getTessellationEvaluationShaderBody(unsigned int n_id) |
| { |
| std::stringstream result_sstream; |
| |
| /* Pre-amble */ |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout(quads, point_mode) in;\n" |
| /* Sub-routine */ |
| "subroutine void SubroutineTEType(inout vec4 result);\n" |
| "\n" |
| "subroutine(SubroutineTEType) void SubroutineTE1(inout vec4 result)\n" |
| "{\n" |
| " result += vec4(0, 0, " |
| << float(n_id + 1) * 0.325f << ", 0);\n" |
| "}\n" |
| "subroutine(SubroutineTEType) void SubroutineTE2(inout vec4 result)\n" |
| "{\n" |
| " result += vec4(0, 0, " |
| << float(n_id + 1) * 0.0325f << ", 0);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform SubroutineTEType function;\n" |
| "\n" |
| /* Input block */ |
| "in TC_DATA\n" |
| "{\n" |
| " vec4 data;\n" |
| "} in_tc[];\n" |
| "\n" |
| /* Output block */ |
| "out TE_DATA\n" |
| "{\n" |
| " vec4 data;\n" |
| "} out_te;\n" |
| "\n" |
| "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n" |
| "out gl_PerVertex { vec4 gl_Position; };\n" |
| /* main() declaration */ |
| "void main()\n" |
| "{\n" |
| " gl_Position = gl_in[0].gl_Position;\n" |
| " out_te.data = in_tc[0].data;\n" |
| "\n" |
| " function(out_te.data);\n" |
| "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves body of a vertex shader that should be used for the test. |
| * The subroutine implementations are slightly changed, depending on the |
| * index of the shader, as specified by the caller. |
| * |
| * @param n_id Index of the shader. |
| * |
| * @return Requested string. |
| **/ |
| std::string FunctionalTest13::getVertexShaderBody(unsigned int n_id) |
| { |
| std::stringstream result_sstream; |
| |
| /* Pre-amble */ |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| /* Sub-routine */ |
| "subroutine void SubroutineVSType(inout vec4 result);\n" |
| "\n" |
| "subroutine(SubroutineVSType) void SubroutineVS1(inout vec4 result)\n" |
| "{\n" |
| " result += vec4(" |
| << float(n_id + 1) * 0.125f << ", 0, 0, 0);\n" |
| "}\n" |
| "subroutine(SubroutineVSType) void SubroutineVS2(inout vec4 result)\n" |
| "{\n" |
| " result += vec4(" |
| << float(n_id + 1) * 0.0125f << ", 0, 0, 0);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform SubroutineVSType function;\n" |
| "\n" |
| /* Output block */ |
| "out VS_DATA\n" |
| "{\n" |
| " vec4 data;\n" |
| "} out_vs;\n" |
| "\n" |
| "out gl_PerVertex { vec4 gl_Position; };\n" |
| /* main() declaration */ |
| "void main()\n" |
| "{\n" |
| " gl_Position = vec4(0, 0, 0, 1);\n" |
| " out_vs.data = vec4(0);\n" |
| "\n" |
| " function(out_vs.data);\n" |
| "\n" |
| "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Initializes all GL objects required to run the test. Also modifies a few |
| * GL states in order for the test to run correctly. |
| **/ |
| void FunctionalTest13::initTest() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Set up viewport */ |
| gl.viewport(0 /* x */, 0 /* y */, m_to_width, m_to_height); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() call failed."); |
| |
| /* Make sure no program is used */ |
| gl.useProgram(0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); |
| |
| /* Generate a pipeline object */ |
| gl.genProgramPipelines(1, &m_pipeline_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGenProgramPipelines() call failed."); |
| |
| gl.bindProgramPipeline(m_pipeline_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed."); |
| |
| /* Initialize all shader programs */ |
| for (unsigned int n_id = 0; n_id < 2 /* variants for each shader type */; ++n_id) |
| { |
| std::string fs_body = getFragmentShaderBody(n_id); |
| const char* fs_body_raw_ptr = fs_body.c_str(); |
| std::string gs_body = getGeometryShaderBody(n_id); |
| const char* gs_body_raw_ptr = gs_body.c_str(); |
| std::string tc_body = getTessellationControlShaderBody(n_id); |
| const char* tc_body_raw_ptr = tc_body.c_str(); |
| std::string te_body = getTessellationEvaluationShaderBody(n_id); |
| const char* te_body_raw_ptr = te_body.c_str(); |
| std::string vs_body = getVertexShaderBody(n_id); |
| const char* vs_body_raw_ptr = vs_body.c_str(); |
| |
| m_fs_po_ids[n_id] = gl.createShaderProgramv(GL_FRAGMENT_SHADER, 1 /* count */, &fs_body_raw_ptr); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed."); |
| |
| m_gs_po_ids[n_id] = gl.createShaderProgramv(GL_GEOMETRY_SHADER, 1 /* count */, &gs_body_raw_ptr); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed."); |
| |
| m_tc_po_ids[n_id] = gl.createShaderProgramv(GL_TESS_CONTROL_SHADER, 1 /* count */, &tc_body_raw_ptr); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed."); |
| |
| m_te_po_ids[n_id] = gl.createShaderProgramv(GL_TESS_EVALUATION_SHADER, 1 /* count */, &te_body_raw_ptr); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed."); |
| |
| m_vs_po_ids[n_id] = gl.createShaderProgramv(GL_VERTEX_SHADER, 1 /* count */, &vs_body_raw_ptr); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed."); |
| |
| /* Verify that all shader program objects have been linked successfully */ |
| const glw::GLuint po_ids[] = { |
| m_fs_po_ids[n_id], m_gs_po_ids[n_id], m_tc_po_ids[n_id], m_te_po_ids[n_id], m_vs_po_ids[n_id], |
| }; |
| const unsigned int n_po_ids = sizeof(po_ids) / sizeof(po_ids[0]); |
| |
| for (unsigned int n_po_id = 0; n_po_id < n_po_ids; ++n_po_id) |
| { |
| glw::GLint link_status = GL_FALSE; |
| glw::GLuint po_id = po_ids[n_po_id]; |
| |
| gl.getProgramiv(po_id, GL_LINK_STATUS, &link_status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed."); |
| |
| if (link_status != GL_TRUE) |
| { |
| TCU_FAIL("Shader program object linking failed."); |
| } |
| } /* for (all shader program objects) */ |
| } /* for (both shader program object variants) */ |
| |
| /* Generate a texture object. We will use the base mip-map as a render-target */ |
| gl.genTextures(1, &m_to_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() call failed."); |
| |
| gl.bindTexture(GL_TEXTURE_2D, m_to_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() call failed."); |
| |
| gl.texStorage2D(GL_TEXTURE_2D, 1 /* levels */, GL_RGBA32F, m_to_width, m_to_height); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() call failed"); |
| |
| /* Generate and configure a FBO we will use for the draw call */ |
| gl.genFramebuffers(1, &m_fbo_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() call failed."); |
| |
| gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() call failed."); |
| |
| gl.framebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_to_id, 0 /* level */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() call failed."); |
| |
| /* Generate & bind a VAO */ |
| 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 tessellation */ |
| gl.patchParameteri(GL_PATCH_VERTICES, 1); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glPatchParameteri() call failed."); |
| |
| /* Set up pixel storage alignment */ |
| gl.pixelStorei(GL_PACK_ALIGNMENT, 1); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei() call failed."); |
| |
| /* Allocate enough space to hold color attachment data */ |
| m_read_buffer = (unsigned char*)new float[m_to_width * m_to_height * 4 /* rgba */]; |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult FunctionalTest13::iterate() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine and GL_ARB_separate_shader_objects |
| * are not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_separate_shader_objects")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_separate_shader_objects is not supported"); |
| } |
| |
| /* Initialize all GL objects before we continue */ |
| initTest(); |
| |
| /* Iterate over all possible FS/GS/TC/TE/VS permutations */ |
| for (int n_shader_permutation = 0; n_shader_permutation < 32 /* 2^5 */; ++n_shader_permutation) |
| { |
| const unsigned int n_fs_idx = ((n_shader_permutation & (1 << 0)) != 0) ? 1 : 0; |
| const unsigned int n_gs_idx = ((n_shader_permutation & (1 << 1)) != 0) ? 1 : 0; |
| const unsigned int n_tc_idx = ((n_shader_permutation & (1 << 2)) != 0) ? 1 : 0; |
| const unsigned int n_te_idx = ((n_shader_permutation & (1 << 3)) != 0) ? 1 : 0; |
| const unsigned int n_vs_idx = ((n_shader_permutation & (1 << 4)) != 0) ? 1 : 0; |
| const unsigned int fs_po_id = m_fs_po_ids[n_fs_idx]; |
| const unsigned int gs_po_id = m_gs_po_ids[n_gs_idx]; |
| const unsigned int tc_po_id = m_tc_po_ids[n_tc_idx]; |
| const unsigned int te_po_id = m_te_po_ids[n_te_idx]; |
| const unsigned int vs_po_id = m_vs_po_ids[n_vs_idx]; |
| |
| /* Configure fragment shader stage */ |
| gl.useProgramStages(m_pipeline_id, GL_FRAGMENT_SHADER_BIT, fs_po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed for GL_FRAGMENT_SHADER_BIT bit"); |
| |
| /* Configure geometry shader stage */ |
| gl.useProgramStages(m_pipeline_id, GL_GEOMETRY_SHADER_BIT, gs_po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed for GL_GEOMETRY_SHADER_BIT bit"); |
| |
| /* Configure tessellation control shader stage */ |
| gl.useProgramStages(m_pipeline_id, GL_TESS_CONTROL_SHADER_BIT, tc_po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed for GL_TESS_CONTROL_SHADER_BIT bit"); |
| |
| /* Configure tessellation evaluation shader stage */ |
| gl.useProgramStages(m_pipeline_id, GL_TESS_EVALUATION_SHADER_BIT, te_po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed for GL_TESS_EVALUATION_SHADER_BIT bit"); |
| |
| /* Configure vertex shader stage */ |
| gl.useProgramStages(m_pipeline_id, GL_VERTEX_SHADER_BIT, vs_po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed for GL_VERTEX_SHADER_BIT bit"); |
| |
| /* Validate the pipeline */ |
| glw::GLint validate_status = GL_FALSE; |
| |
| gl.validateProgramPipeline(m_pipeline_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glValidateProgramPipeline() call failed."); |
| |
| gl.getProgramPipelineiv(m_pipeline_id, GL_VALIDATE_STATUS, &validate_status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramPipelineiv() call failed."); |
| |
| if (validate_status != GL_TRUE) |
| { |
| TCU_FAIL("Program pipeline has not been validated successfully."); |
| } |
| |
| /* Retrieve subroutine indices */ |
| GLuint fs_subroutine_indices[2] = { (GLuint)-1 }; |
| GLint fs_subroutine_uniform_index = 0; |
| GLuint gs_subroutine_indices[2] = { (GLuint)-1 }; |
| GLint gs_subroutine_uniform_index = 0; |
| GLuint tc_subroutine_indices[2] = { (GLuint)-1 }; |
| GLint tc_subroutine_uniform_index = 0; |
| GLuint te_subroutine_indices[2] = { (GLuint)-1 }; |
| GLint te_subroutine_uniform_index = 0; |
| GLuint vs_subroutine_indices[2] = { (GLuint)-1 }; |
| GLint vs_subroutine_uniform_index = 0; |
| |
| for (unsigned int n_subroutine = 0; n_subroutine < 2; ++n_subroutine) |
| { |
| std::stringstream fs_subroutine_name_sstream; |
| std::stringstream gs_subroutine_name_sstream; |
| std::stringstream tc_subroutine_name_sstream; |
| std::stringstream te_subroutine_name_sstream; |
| std::stringstream vs_subroutine_name_sstream; |
| |
| fs_subroutine_name_sstream << "SubroutineFS" << (n_subroutine + 1); |
| gs_subroutine_name_sstream << "SubroutineGS" << (n_subroutine + 1); |
| tc_subroutine_name_sstream << "SubroutineTC" << (n_subroutine + 1); |
| te_subroutine_name_sstream << "SubroutineTE" << (n_subroutine + 1); |
| vs_subroutine_name_sstream << "SubroutineVS" << (n_subroutine + 1); |
| |
| fs_subroutine_indices[n_subroutine] = |
| gl.getSubroutineIndex(fs_po_id, GL_FRAGMENT_SHADER, fs_subroutine_name_sstream.str().c_str()); |
| gs_subroutine_indices[n_subroutine] = |
| gl.getSubroutineIndex(gs_po_id, GL_GEOMETRY_SHADER, gs_subroutine_name_sstream.str().c_str()); |
| tc_subroutine_indices[n_subroutine] = |
| gl.getSubroutineIndex(tc_po_id, GL_TESS_CONTROL_SHADER, tc_subroutine_name_sstream.str().c_str()); |
| te_subroutine_indices[n_subroutine] = |
| gl.getSubroutineIndex(te_po_id, GL_TESS_EVALUATION_SHADER, te_subroutine_name_sstream.str().c_str()); |
| vs_subroutine_indices[n_subroutine] = |
| gl.getSubroutineIndex(vs_po_id, GL_VERTEX_SHADER, vs_subroutine_name_sstream.str().c_str()); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() call(s) failed."); |
| |
| if (fs_subroutine_indices[n_subroutine] == (GLuint)-1 || |
| gs_subroutine_indices[n_subroutine] == (GLuint)-1 || |
| tc_subroutine_indices[n_subroutine] == (GLuint)-1 || |
| te_subroutine_indices[n_subroutine] == (GLuint)-1 || vs_subroutine_indices[n_subroutine] == (GLuint)-1) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "At least one subroutine was not recognized by glGetSubroutineIndex() call. " |
| "(fs:" |
| << fs_subroutine_indices[n_subroutine] |
| << ", gs:" << gs_subroutine_indices[n_subroutine] |
| << ", tc:" << tc_subroutine_indices[n_subroutine] |
| << ", te:" << te_subroutine_indices[n_subroutine] |
| << ", vs:" << vs_subroutine_indices[n_subroutine] << ")." |
| << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("At least one subroutine was not recognized"); |
| } |
| } /* for (both subroutines) */ |
| |
| /* Retrieve subroutine uniform indices */ |
| fs_subroutine_uniform_index = gl.getSubroutineUniformLocation(fs_po_id, GL_FRAGMENT_SHADER, "function"); |
| gs_subroutine_uniform_index = gl.getSubroutineUniformLocation(gs_po_id, GL_GEOMETRY_SHADER, "function"); |
| tc_subroutine_uniform_index = gl.getSubroutineUniformLocation(tc_po_id, GL_TESS_CONTROL_SHADER, "function"); |
| te_subroutine_uniform_index = gl.getSubroutineUniformLocation(te_po_id, GL_TESS_EVALUATION_SHADER, "function"); |
| vs_subroutine_uniform_index = gl.getSubroutineUniformLocation(vs_po_id, GL_VERTEX_SHADER, "function"); |
| |
| if (fs_subroutine_uniform_index == -1 || gs_subroutine_uniform_index == -1 || |
| tc_subroutine_uniform_index == -1 || te_subroutine_uniform_index == -1 || vs_subroutine_uniform_index == -1) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "At least one subroutine uniform is considered inactive by " |
| "glGetSubroutineUniformLocation (" |
| "fs:" |
| << fs_subroutine_uniform_index << ", gs:" << gs_subroutine_uniform_index |
| << ", tc:" << tc_subroutine_uniform_index << ", te:" << te_subroutine_uniform_index |
| << ", vs:" << vs_subroutine_uniform_index << ")." << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("At least one subroutine uniform is considered inactive"); |
| } |
| |
| /* Check if both subroutines work correctly in each stage */ |
| for (int n_subroutine_permutation = 0; n_subroutine_permutation < 32; /* 2^5 */ |
| ++n_subroutine_permutation) |
| { |
| unsigned int n_fs_subroutine = ((n_subroutine_permutation & (1 << 0)) != 0) ? 1 : 0; |
| unsigned int n_gs_subroutine = ((n_subroutine_permutation & (1 << 1)) != 0) ? 1 : 0; |
| unsigned int n_tc_subroutine = ((n_subroutine_permutation & (1 << 2)) != 0) ? 1 : 0; |
| unsigned int n_te_subroutine = ((n_subroutine_permutation & (1 << 3)) != 0) ? 1 : 0; |
| unsigned int n_vs_subroutine = ((n_subroutine_permutation & (1 << 4)) != 0) ? 1 : 0; |
| |
| /* Configure subroutine uniforms */ |
| struct |
| { |
| glw::GLenum stage; |
| glw::GLuint po_id; |
| glw::GLuint* indices; |
| } configurations[] = { |
| { GL_FRAGMENT_SHADER, fs_po_id, fs_subroutine_indices + n_fs_subroutine }, |
| { GL_GEOMETRY_SHADER, gs_po_id, gs_subroutine_indices + n_gs_subroutine }, |
| { GL_TESS_CONTROL_SHADER, tc_po_id, tc_subroutine_indices + n_tc_subroutine }, |
| { GL_TESS_EVALUATION_SHADER, te_po_id, te_subroutine_indices + n_te_subroutine }, |
| { GL_VERTEX_SHADER, vs_po_id, vs_subroutine_indices + n_vs_subroutine }, |
| }; |
| |
| for (int i = 0; i < 5; ++i) |
| { |
| gl.activeShaderProgram(m_pipeline_id, configurations[i].po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveShaderProgram() call failed."); |
| |
| gl.uniformSubroutinesuiv(configurations[i].stage, 1 /* count */, configurations[i].indices); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformSubroutinesuiv() call failed."); |
| } |
| |
| /* Render a full-screen quad with the pipeline */ |
| gl.clear(GL_COLOR_BUFFER_BIT); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glClear() call failed."); |
| |
| gl.drawArrays(GL_PATCHES, 0 /* first */, 1 /* count */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed."); |
| |
| /* Read color attachment's contents */ |
| gl.readPixels(0, /* x */ |
| 0, /* y */ |
| m_to_width, m_to_height, GL_RGBA, GL_FLOAT, m_read_buffer); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() call failed."); |
| |
| /* Verify the contents */ |
| verifyReadBuffer(n_fs_idx, n_fs_subroutine, n_gs_idx, n_gs_subroutine, n_tc_idx, n_tc_subroutine, n_te_idx, |
| n_te_subroutine, n_vs_idx, n_vs_subroutine); |
| } /* for (all subroutine permutations) */ |
| } /* for (all program shader object permutations) */ |
| |
| /** All done */ |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Verifies the data that have been rendered using a pipeline object. |
| * Contents of the data depends on indices of the shaders, as well as |
| * on the subroutines that have been activated for particular iteration. |
| * |
| * @param n_fs_id Index of the fragment shader used for the iteration; |
| * @param n_fs_subroutine Index of the subroutine used in the fragment shader |
| * for the iteration; |
| * @param n_gs_id Index of the geometry shader used for the iteration; |
| * @param n_gs_subroutine Index of the subroutine used in the geometry shader |
| * for the iteration; |
| * @param n_tc_id Index of the tessellation control shader used for the iteration; |
| * @param n_tc_subroutine Index of the subroutine used in the tessellation control |
| * shader for the iteration; |
| * @param n_te_id Index of the tessellation evaluation shader used for the iteration; |
| * @param n_te_subroutine Index of the subroutine used in the tessellation evaluation |
| * shader for the iteration; |
| * @param n_vs_id Index of the vertex shader used for the iteration; |
| * @param n_vs_subroutine Index of the subroutine used in the vertex shader for |
| * the iteration. |
| */ |
| void FunctionalTest13::verifyReadBuffer(unsigned int n_fs_id, unsigned int n_fs_subroutine, unsigned int n_gs_id, |
| unsigned int n_gs_subroutine, unsigned int n_tc_id, |
| unsigned int n_tc_subroutine, unsigned int n_te_id, |
| unsigned int n_te_subroutine, unsigned int n_vs_id, |
| unsigned int n_vs_subroutine) |
| { |
| float expected_color[4] = { 0 }; |
| float fs_modifier[4] = { 0 }; |
| float gs_modifier[4] = { 0 }; |
| float tc_modifier[4] = { 0 }; |
| float te_modifier[4] = { 0 }; |
| float vs_modifier[4] = { 0 }; |
| |
| if (n_fs_subroutine == 0) |
| { |
| for (unsigned int n_component = 0; n_component < 4; ++n_component) |
| { |
| fs_modifier[n_component] = float(n_fs_id + n_component + 1) / 10.0f; |
| } |
| } |
| else |
| { |
| for (unsigned int n_component = 0; n_component < 4; ++n_component) |
| { |
| fs_modifier[n_component] = float(n_fs_id + n_component + 1) / 20.0f; |
| } |
| } |
| |
| if (n_gs_subroutine == 0) |
| { |
| gs_modifier[3] = float(n_gs_id + 1) * 0.425f; |
| } |
| else |
| { |
| gs_modifier[3] = float(n_gs_id + 1) * 0.0425f; |
| } |
| |
| if (n_tc_subroutine == 0) |
| { |
| tc_modifier[1] = float(n_tc_id + 1) * 0.25f; |
| } |
| else |
| { |
| tc_modifier[1] = float(n_tc_id + 1) * 0.025f; |
| } |
| |
| if (n_te_subroutine == 0) |
| { |
| te_modifier[2] = float(n_te_id + 1) * 0.325f; |
| } |
| else |
| { |
| te_modifier[2] = float(n_te_id + 1) * 0.0325f; |
| } |
| |
| if (n_vs_subroutine == 0) |
| { |
| vs_modifier[0] = float(n_vs_id + 1) * 0.125f; |
| } |
| else |
| { |
| vs_modifier[0] = float(n_vs_id + 1) * 0.0125f; |
| } |
| |
| /* Determine the expected color */ |
| for (unsigned int n_component = 0; n_component < 4 /* rgba */; ++n_component) |
| { |
| expected_color[n_component] = fs_modifier[n_component] + gs_modifier[n_component] + tc_modifier[n_component] + |
| te_modifier[n_component] + vs_modifier[n_component]; |
| } |
| |
| /* Verify all read texels are valid */ |
| const float epsilon = 1e-5f; |
| bool should_continue = true; |
| |
| for (unsigned int y = 0; y < m_to_height && should_continue; ++y) |
| { |
| const float* row_ptr = (const float*)m_read_buffer + y * m_to_width * 4; /* rgba */ |
| |
| for (unsigned int x = 0; x < m_to_width && should_continue; ++x) |
| { |
| const float* texel_ptr = row_ptr + x * 4; /* rgba */ |
| |
| if (de::abs(texel_ptr[0] - expected_color[0]) > epsilon || |
| de::abs(texel_ptr[1] - expected_color[1]) > epsilon || |
| de::abs(texel_ptr[2] - expected_color[2]) > epsilon || |
| de::abs(texel_ptr[3] - expected_color[3]) > epsilon) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Invalid texel rendered at (" << x << ", " << y |
| << ") for " |
| "the following configuration: " |
| "n_fs_id:" |
| << n_fs_id << " n_fs_subroutine:" << n_fs_subroutine << " n_gs_id:" << n_gs_id |
| << " n_gs_subroutine:" << n_gs_subroutine << " n_tc_id:" << n_tc_id |
| << " n_tc_subroutine:" << n_tc_subroutine << " n_te_id:" << n_te_id |
| << " n_te_subroutine:" << n_te_subroutine << " n_vs_id:" << n_vs_id |
| << " n_vs_subroutine:" << n_vs_subroutine << "; expected:" |
| "(" |
| << expected_color[0] << ", " << expected_color[1] << ", " << expected_color[2] |
| << ", " << expected_color[3] << "), found:" |
| "(" |
| << texel_ptr[0] << ", " << texel_ptr[1] << ", " << texel_ptr[2] << ", " |
| << texel_ptr[3] << ")." << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| should_continue = false; |
| } |
| } /* for (all columns) */ |
| } /* for (all rows) */ |
| } |
| |
| /** Constructor |
| * |
| * @param context CTS context |
| **/ |
| FunctionalTest14_15::FunctionalTest14_15(deqp::Context& context) |
| : TestCase(context, "structure_parameters_program_binary", "Verify structures can be used as parameters") |
| , m_uniform_location(0) |
| { |
| } |
| |
| /** Execute test |
| * |
| * @return tcu::TestNode::STOP |
| **/ |
| tcu::TestNode::IterateResult FunctionalTest14_15::iterate() |
| { |
| static const GLchar* vertex_shader_code = |
| "#version 400 core\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "struct data\n" |
| "{\n" |
| " uint r;\n" |
| " uint g;\n" |
| " uint b;\n" |
| " uint a;\n" |
| "};\n" |
| "\n" |
| "subroutine void routine_type_1(in data iparam, out data oparam);\n" |
| "subroutine void routine_type_2(inout data arg);\n" |
| "\n" |
| "subroutine (routine_type_1) void invert(in data iparam, out data oparam)\n" |
| "{\n" |
| " oparam.r = iparam.a;\n" |
| " oparam.g = iparam.b;\n" |
| " oparam.b = iparam.g;\n" |
| " oparam.a = iparam.r;\n" |
| "}\n" |
| "\n" |
| "subroutine (routine_type_1) void increment(in data iparam, out data oparam)\n" |
| "{\n" |
| " oparam.r = 1 + iparam.r;\n" |
| " oparam.g = 1 + iparam.g;\n" |
| " oparam.b = 1 + iparam.b;\n" |
| " oparam.a = 1 + iparam.a;\n" |
| "}\n" |
| "\n" |
| "subroutine (routine_type_2) void div_by_2(inout data arg)\n" |
| "{\n" |
| " arg.r = arg.r / 2;\n" |
| " arg.g = arg.g / 2;\n" |
| " arg.b = arg.b / 2;\n" |
| " arg.a = arg.a / 2;\n" |
| "}\n" |
| "\n" |
| "subroutine (routine_type_2) void decrement(inout data arg)\n" |
| "{\n" |
| " arg.r = arg.r - 1;\n" |
| " arg.g = arg.g - 1;\n" |
| " arg.b = arg.b - 1;\n" |
| " arg.a = arg.a - 1;\n" |
| "}\n" |
| "\n" |
| "subroutine uniform routine_type_1 routine_1;\n" |
| "subroutine uniform routine_type_2 routine_2;\n" |
| "\n" |
| "uniform uvec4 uni_input;\n" |
| "\n" |
| "out uvec4 out_routine_1;\n" |
| "out uvec4 out_routine_2;\n" |
| "\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " data routine_1_input;\n" |
| " data routine_1_output;\n" |
| " data routine_2_arg;\n" |
| "\n" |
| " routine_1_input.r = uni_input.r;\n" |
| " routine_1_input.g = uni_input.g;\n" |
| " routine_1_input.b = uni_input.b;\n" |
| " routine_1_input.a = uni_input.a;\n" |
| "\n" |
| " routine_2_arg.r = uni_input.r;\n" |
| " routine_2_arg.g = uni_input.g;\n" |
| " routine_2_arg.b = uni_input.b;\n" |
| " routine_2_arg.a = uni_input.a;\n" |
| "\n" |
| " routine_1(routine_1_input, routine_1_output);\n" |
| " routine_2(routine_2_arg);\n" |
| "\n" |
| " out_routine_1.r = routine_1_output.r;\n" |
| " out_routine_1.g = routine_1_output.g;\n" |
| " out_routine_1.b = routine_1_output.b;\n" |
| " out_routine_1.a = routine_1_output.a;\n" |
| "\n" |
| " out_routine_2.r = routine_2_arg.r;\n" |
| " out_routine_2.g = routine_2_arg.g;\n" |
| " out_routine_2.b = routine_2_arg.b;\n" |
| " out_routine_2.a = routine_2_arg.a;\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* subroutine_names[][2] = { { "invert", "increment" }, { "div_by_2", "decrement" } }; |
| static const GLuint n_subroutine_types = sizeof(subroutine_names) / sizeof(subroutine_names[0]); |
| |
| static const GLchar* subroutine_uniform_names[] = { "routine_1", "routine_2" }; |
| static const GLuint n_subroutine_uniform_names = |
| sizeof(subroutine_uniform_names) / sizeof(subroutine_uniform_names[0]); |
| |
| static const GLchar* uniform_name = "uni_input"; |
| static const GLchar* varying_names[] = { "out_routine_1", "out_routine_2" }; |
| |
| static const GLuint n_varying_names = sizeof(varying_names) / sizeof(varying_names[0]); |
| static const GLuint transform_feedback_buffer_size = n_varying_names * 4 * sizeof(GLuint); |
| |
| /* Test data */ |
| static const Utils::vec4<GLuint> uni_input[] = { Utils::vec4<GLuint>(8, 64, 4096, 16777216), |
| Utils::vec4<GLuint>(8, 64, 4096, 16777216) }; |
| |
| static const Utils::vec4<GLuint> out_routine_1[] = { Utils::vec4<GLuint>(16777216, 4096, 64, 8), |
| Utils::vec4<GLuint>(9, 65, 4097, 16777217) }; |
| |
| static const Utils::vec4<GLuint> out_routine_2[] = { Utils::vec4<GLuint>(4, 32, 2048, 8388608), |
| Utils::vec4<GLuint>(7, 63, 4095, 16777215) }; |
| |
| static const GLuint n_test_cases = 2; |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* GL objects */ |
| Utils::program program(m_context); |
| Utils::buffer transform_feedback_buffer(m_context); |
| Utils::vertexArray vao(m_context); |
| |
| bool is_program_binary_supported = program.isProgramBinarySupported(); |
| |
| /* Init GL objects */ |
| program.build(0 /* cs */, 0 /* fs */, 0 /* gs */, 0 /* tcs */, 0 /* test */, vertex_shader_code, |
| varying_names /* varying_names */, n_varying_names /* n_varyings */); |
| |
| /* Do not execute the test if GL_ARB_get_program_binary is not supported */ |
| if (true == is_program_binary_supported) |
| { |
| /* Get subroutine indices */ |
| for (GLuint type = 0; type < n_subroutine_types; ++type) |
| { |
| m_initial_subroutine_indices[type][0] = |
| program.getSubroutineIndex(subroutine_names[type][0], GL_VERTEX_SHADER); |
| |
| m_initial_subroutine_indices[type][1] = |
| program.getSubroutineIndex(subroutine_names[type][1], GL_VERTEX_SHADER); |
| } |
| |
| /* Get subroutine uniform locations */ |
| for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform) |
| { |
| m_initial_subroutine_uniform_locations[uniform] = |
| program.getSubroutineUniformLocation(subroutine_uniform_names[uniform], GL_VERTEX_SHADER); |
| } |
| |
| /* Delete program and recreate it from binary */ |
| std::vector<GLubyte> program_binary; |
| GLenum binary_format; |
| |
| program.getBinary(program_binary, binary_format); |
| program.remove(); |
| program.createFromBinary(program_binary, binary_format); |
| } |
| |
| program.use(); |
| |
| vao.generate(); |
| vao.bind(); |
| |
| transform_feedback_buffer.generate(); |
| transform_feedback_buffer.update(GL_TRANSFORM_FEEDBACK_BUFFER, transform_feedback_buffer_size, 0 /* data */, |
| GL_DYNAMIC_COPY); |
| transform_feedback_buffer.bindRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0, transform_feedback_buffer_size); |
| |
| /* Get subroutine indices */ |
| for (GLuint type = 0; type < n_subroutine_types; ++type) |
| { |
| m_subroutine_indices[type][0] = program.getSubroutineIndex(subroutine_names[type][0], GL_VERTEX_SHADER); |
| m_subroutine_indices[type][1] = program.getSubroutineIndex(subroutine_names[type][1], GL_VERTEX_SHADER); |
| } |
| |
| /* Get subroutine uniform locations */ |
| for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform) |
| { |
| m_subroutine_uniform_locations[uniform] = |
| program.getSubroutineUniformLocation(subroutine_uniform_names[uniform], GL_VERTEX_SHADER); |
| } |
| |
| /* Get uniform locations */ |
| m_uniform_location = program.getUniformLocation(uniform_name); |
| |
| /* Test */ |
| bool result = true; |
| |
| /* Test program binary */ |
| if (true == is_program_binary_supported) |
| { |
| /* Test indices and locations */ |
| if (false == testIndicesAndLocations()) |
| { |
| static const GLuint n_subroutines_per_type = 2; |
| |
| m_context.getTestContext().getLog() << tcu::TestLog::Message |
| << "Error. Subroutine indices or subroutine uniform location changed." |
| << tcu::TestLog::EndMessage; |
| |
| for (GLuint type = 0; type < n_subroutine_types; ++type) |
| { |
| for (GLuint i = 0; i < n_subroutines_per_type; ++i) |
| { |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "Subroutine: " << subroutine_names[type][i] |
| << " index: " << m_subroutine_indices[type][i] |
| << " initial index: " << m_initial_subroutine_indices[type][i] << tcu::TestLog::EndMessage; |
| } |
| } |
| |
| for (GLuint uniform = 0; uniform < n_subroutine_uniform_names; ++uniform) |
| { |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "Subroutine uniform: " << subroutine_uniform_names[uniform] |
| << " location: " << m_subroutine_uniform_locations[uniform] |
| << " initial location: " << m_initial_subroutine_uniform_locations[uniform] |
| << tcu::TestLog::EndMessage; |
| } |
| |
| result = false; |
| } |
| |
| /* Test draw with deafult set of subroutines */ |
| if (false == testDefaultSubroutineSet(uni_input[0], out_routine_1, out_routine_2)) |
| { |
| result = false; |
| } |
| } |
| |
| for (GLuint i = 0; i < n_test_cases; ++i) |
| { |
| if (false == testDraw(i, uni_input[i], out_routine_1[i], out_routine_2[i])) |
| { |
| result = false; |
| } |
| } |
| |
| /* Set result */ |
| if (true == result) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| /* Done */ |
| return tcu::TestNode::STOP; |
| } |
| |
| /** Execute draw call and verify results |
| * |
| * @param uni_input Input data |
| * @param expected_routine_1_result Set of expected results of "routine_1" |
| * @param expected_routine_2_result Set of expected results of "routine_2" |
| * |
| * @return true if test pass, false otherwise |
| **/ |
| bool FunctionalTest14_15::testDefaultSubroutineSet(const Utils::vec4<glw::GLuint>& uni_input, |
| const Utils::vec4<glw::GLuint> expected_routine_1_result[2], |
| const Utils::vec4<glw::GLuint> expected_routine_2_result[2]) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| bool result = true; |
| |
| /* Set up input data uniforms */ |
| gl.uniform4ui(m_uniform_location, uni_input.m_x, uni_input.m_y, uni_input.m_z, uni_input.m_w); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f"); |
| |
| /* Execute draw call with transform feedback */ |
| gl.beginTransformFeedback(GL_POINTS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); |
| |
| gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); |
| |
| gl.endTransformFeedback(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); |
| |
| /* Capture results */ |
| GLuint* feedback_data = (GLuint*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); |
| |
| Utils::vec4<GLuint> routine_1_result; |
| Utils::vec4<GLuint> routine_2_result; |
| |
| routine_1_result.m_x = feedback_data[0 + 0]; |
| routine_1_result.m_y = feedback_data[0 + 1]; |
| routine_1_result.m_z = feedback_data[0 + 2]; |
| routine_1_result.m_w = feedback_data[0 + 3]; |
| |
| routine_2_result.m_x = feedback_data[4 + 0]; |
| routine_2_result.m_y = feedback_data[4 + 1]; |
| routine_2_result.m_z = feedback_data[4 + 2]; |
| routine_2_result.m_w = feedback_data[4 + 3]; |
| |
| /* Unmap buffer */ |
| gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); |
| |
| /* Verifiy */ |
| result = result && |
| ((routine_1_result == expected_routine_1_result[0]) || (routine_1_result == expected_routine_1_result[1])); |
| |
| result = result && |
| ((routine_2_result == expected_routine_2_result[0]) || (routine_2_result == expected_routine_2_result[1])); |
| |
| /* Log error if any */ |
| if (false == result) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result." |
| << tcu::TestLog::EndMessage; |
| |
| tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; |
| |
| message << "Routine_1, result: "; |
| |
| routine_1_result.log(message); |
| |
| message << "Routine_2, result: "; |
| |
| routine_2_result.log(message); |
| |
| message << tcu::TestLog::EndMessage; |
| } |
| |
| /* Done */ |
| return result; |
| } |
| |
| /** Execute draw call and verify results |
| * |
| * @param routine_configuration Subroutine "type" ordinal |
| * @param uni_input Input data |
| * @param expected_routine_1_result Expected results of "routine_1" |
| * @param expected_routine_2_result Expected results of "routine_2" |
| * |
| * @return true if test pass, false otherwise |
| **/ |
| bool FunctionalTest14_15::testDraw(glw::GLuint routine_configuration, const Utils::vec4<glw::GLuint>& uni_input, |
| const Utils::vec4<glw::GLuint>& expected_routine_1_result, |
| const Utils::vec4<glw::GLuint>& expected_routine_2_result) const |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| bool result = true; |
| GLuint subroutine_indices[2]; |
| static const GLuint n_subroutine_uniforms = sizeof(subroutine_indices) / sizeof(subroutine_indices[0]); |
| |
| /* Set up input data uniforms */ |
| gl.uniform4ui(m_uniform_location, uni_input.m_x, uni_input.m_y, uni_input.m_z, uni_input.m_w); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Uniform4f"); |
| |
| /* Prepare subroutine uniform data */ |
| for (GLuint i = 0; i < n_subroutine_uniforms; ++i) |
| { |
| const GLuint location = m_subroutine_uniform_locations[i]; |
| |
| subroutine_indices[location] = m_subroutine_indices[i][routine_configuration]; |
| } |
| |
| /* Set up subroutine uniforms */ |
| gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, n_subroutine_uniforms, &subroutine_indices[0]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UniformSubroutinesuiv"); |
| |
| /* Execute draw call with transform feedback */ |
| gl.beginTransformFeedback(GL_POINTS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback"); |
| |
| gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays"); |
| |
| gl.endTransformFeedback(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback"); |
| |
| /* Capture results */ |
| GLuint* feedback_data = (GLuint*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "MapBuffer"); |
| |
| Utils::vec4<GLuint> routine_1_result; |
| Utils::vec4<GLuint> routine_2_result; |
| |
| routine_1_result.m_x = feedback_data[0 + 0]; |
| routine_1_result.m_y = feedback_data[0 + 1]; |
| routine_1_result.m_z = feedback_data[0 + 2]; |
| routine_1_result.m_w = feedback_data[0 + 3]; |
| |
| routine_2_result.m_x = feedback_data[4 + 0]; |
| routine_2_result.m_y = feedback_data[4 + 1]; |
| routine_2_result.m_z = feedback_data[4 + 2]; |
| routine_2_result.m_w = feedback_data[4 + 3]; |
| |
| /* Unmap buffer */ |
| gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer"); |
| |
| /* Verifiy */ |
| result = result && (routine_1_result == expected_routine_1_result); |
| result = result && (routine_2_result == expected_routine_2_result); |
| |
| /* Log error if any */ |
| if (false == result) |
| { |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Error. Invalid result." |
| << tcu::TestLog::EndMessage; |
| |
| tcu::MessageBuilder message = m_context.getTestContext().getLog() << tcu::TestLog::Message; |
| |
| message << "Routine_1, result: "; |
| |
| routine_1_result.log(message); |
| |
| message << ", expected: "; |
| |
| expected_routine_1_result.log(message); |
| |
| message << "Routine_2, result: "; |
| |
| routine_2_result.log(message); |
| |
| message << ", expected: "; |
| |
| expected_routine_2_result.log(message); |
| |
| message << tcu::TestLog::EndMessage; |
| } |
| |
| /* Done */ |
| return result; |
| } |
| |
| /** Verify initial and current values of subroutine indices and subroutines uniform locations |
| * |
| * @return true if test pass, false otherwise |
| **/ |
| bool FunctionalTest14_15::testIndicesAndLocations() const |
| { |
| static const GLuint n_subroutine_types = 2; |
| bool result = true; |
| |
| /* Verify subroutine indices */ |
| for (GLuint type = 0; type < n_subroutine_types; ++type) |
| { |
| result = result && (m_subroutine_indices[type][0] == m_initial_subroutine_indices[type][0]); |
| result = result && (m_subroutine_indices[type][1] == m_initial_subroutine_indices[type][1]); |
| } |
| |
| /* Verify subroutine uniform locations */ |
| for (GLuint uniform = 0; uniform < n_subroutine_types; ++uniform) |
| { |
| result = result && (m_subroutine_uniform_locations[uniform] == m_initial_subroutine_uniform_locations[uniform]); |
| } |
| |
| return result; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| * |
| **/ |
| FunctionalTest16::FunctionalTest16(deqp::Context& context) |
| : TestCase(context, "subroutine_uniform_reset", |
| "Checks that when the active program for a shader stage is re-linke or " |
| "changed by a call to UseProgram, BindProgramPipeline, or UseProgramStages," |
| " subroutine uniforms for that stage are reset to arbitrarily chosen default " |
| "functions with compatible subroutine types.") |
| , m_are_pipeline_objects_supported(false) |
| , m_has_test_passed(true) |
| { |
| memset(m_fs_ids, 0, sizeof(m_fs_ids)); |
| memset(m_gs_ids, 0, sizeof(m_gs_ids)); |
| memset(m_po_ids, 0, sizeof(m_po_ids)); |
| memset(m_tc_ids, 0, sizeof(m_tc_ids)); |
| memset(m_te_ids, 0, sizeof(m_te_ids)); |
| memset(m_vs_ids, 0, sizeof(m_vs_ids)); |
| |
| memset(m_fs_po_ids, 0, sizeof(m_fs_po_ids)); |
| memset(m_gs_po_ids, 0, sizeof(m_gs_po_ids)); |
| memset(m_pipeline_object_ids, 0, sizeof(m_pipeline_object_ids)); |
| memset(m_tc_po_ids, 0, sizeof(m_tc_po_ids)); |
| memset(m_te_po_ids, 0, sizeof(m_te_po_ids)); |
| memset(m_vs_po_ids, 0, sizeof(m_vs_po_ids)); |
| } |
| |
| /** Deinitializes all GL objects that may have been created during test execution. */ |
| void FunctionalTest16::deinit() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| for (unsigned int n_id = 0; n_id < 2; ++n_id) |
| { |
| if (m_fs_ids[n_id] != 0) |
| { |
| gl.deleteShader(m_fs_ids[n_id]); |
| |
| m_fs_ids[n_id] = 0; |
| } |
| |
| if (m_fs_po_ids[n_id] != 0) |
| { |
| gl.deleteProgram(m_fs_po_ids[n_id]); |
| |
| m_fs_po_ids[n_id] = 0; |
| } |
| |
| if (m_gs_ids[n_id] != 0) |
| { |
| gl.deleteShader(m_gs_ids[n_id]); |
| |
| m_gs_ids[n_id] = 0; |
| } |
| |
| if (m_gs_po_ids[n_id] != 0) |
| { |
| gl.deleteProgram(m_gs_po_ids[n_id]); |
| |
| m_gs_po_ids[n_id] = 0; |
| } |
| |
| if (m_pipeline_object_ids[n_id] != 0) |
| { |
| gl.deleteProgramPipelines(1 /* n */, m_pipeline_object_ids + n_id); |
| } |
| |
| if (m_po_ids[n_id] != 0) |
| { |
| gl.deleteProgram(m_po_ids[n_id]); |
| |
| m_po_ids[n_id] = 0; |
| } |
| |
| if (m_tc_ids[n_id] != 0) |
| { |
| gl.deleteShader(m_tc_ids[n_id]); |
| |
| m_tc_ids[n_id] = 0; |
| } |
| |
| if (m_tc_po_ids[n_id] != 0) |
| { |
| gl.deleteProgram(m_tc_po_ids[n_id]); |
| |
| m_tc_po_ids[n_id] = 0; |
| } |
| |
| if (m_te_ids[n_id] != 0) |
| { |
| gl.deleteShader(m_te_ids[n_id]); |
| |
| m_te_ids[n_id] = 0; |
| } |
| |
| if (m_te_po_ids[n_id] != 0) |
| { |
| gl.deleteProgram(m_te_po_ids[n_id]); |
| |
| m_te_po_ids[n_id] = 0; |
| } |
| |
| if (m_vs_ids[n_id] != 0) |
| { |
| gl.deleteShader(m_vs_ids[n_id]); |
| |
| m_vs_ids[n_id] = 0; |
| } |
| |
| if (m_vs_po_ids[n_id] != 0) |
| { |
| gl.deleteProgram(m_vs_po_ids[n_id]); |
| |
| m_vs_po_ids[n_id] = 0; |
| } |
| } /* for (both IDs) */ |
| } |
| |
| /** Retrieves body of a shader that should be used for user-specified shader stage. |
| * This function returns slightly different implementations, depending on index of |
| * the program/pipeline object the shader will be used for. |
| * |
| * @param shader_stage Stage the shader body is to be returned for. |
| * @param n_id Index of the shader (as per description). |
| * |
| * @return Requested string. |
| **/ |
| std::string FunctionalTest16::getShaderBody(const Utils::_shader_stage& shader_stage, const unsigned int& n_id) const |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n"; |
| |
| switch (shader_stage) |
| { |
| case Utils::SHADER_STAGE_VERTEX: |
| { |
| result_sstream << "out gl_PerVertex { vec4 gl_Position; } ;\n"; |
| break; |
| } |
| case Utils::SHADER_STAGE_GEOMETRY: |
| { |
| result_sstream << "layout(points) in;\n" |
| "layout(points, max_vertices = 1) out;\n"; |
| result_sstream << "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n"; |
| result_sstream << "out gl_PerVertex { vec4 gl_Position; } ;\n"; |
| break; |
| } |
| |
| case Utils::SHADER_STAGE_TESSELLATION_CONTROL: |
| { |
| result_sstream << "layout(vertices = 4) out;\n"; |
| result_sstream << "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n"; |
| result_sstream << "out gl_PerVertex { vec4 gl_Position; } gl_out[];\n"; |
| break; |
| } |
| |
| case Utils::SHADER_STAGE_TESSELLATION_EVALUATION: |
| { |
| result_sstream << "layout(quads) in;\n"; |
| result_sstream << "in gl_PerVertex { vec4 gl_Position; } gl_in[];\n"; |
| result_sstream << "out gl_PerVertex { vec4 gl_Position; };\n"; |
| break; |
| } |
| |
| default: |
| break; |
| } /* switch (shader_stage) */ |
| |
| result_sstream << "\n" |
| "subroutine void subroutineType (inout vec4 result);\n" |
| "subroutine vec4 subroutineType2(in vec4 data);\n" |
| "\n" |
| "subroutine(subroutineType) void function1(inout vec4 result)\n" |
| "{\n" |
| " result += vec4(" |
| << (n_id + 1) << ", " << (n_id + 2) << ", " << (n_id + 3) << ", " << (n_id + 4) |
| << ");\n" |
| "}\n" |
| "subroutine(subroutineType) void function2(inout vec4 result)\n" |
| "{\n" |
| " result += vec4(" |
| << (n_id + 2) << ", " << (n_id + 3) << ", " << (n_id + 4) << ", " << (n_id + 5) |
| << ");\n" |
| "}\n" |
| "\n" |
| "subroutine(subroutineType2) vec4 function3(in vec4 data)\n" |
| "{\n" |
| " return data * data;\n" |
| "}\n" |
| "subroutine(subroutineType2) vec4 function4(in vec4 data)\n" |
| "{\n" |
| " return data + data;\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineType subroutine1;\n" |
| "subroutine uniform subroutineType subroutine2;\n" |
| "subroutine uniform subroutineType2 subroutine3;\n" |
| "subroutine uniform subroutineType2 subroutine4;\n" |
| "\n"; |
| |
| if (shader_stage == Utils::SHADER_STAGE_FRAGMENT) |
| { |
| result_sstream << "out vec4 result;\n"; |
| } |
| |
| result_sstream << "void main()\n" |
| "{\n"; |
| |
| switch (shader_stage) |
| { |
| case Utils::SHADER_STAGE_FRAGMENT: |
| { |
| result_sstream << " result = vec4(0);\n" |
| << " subroutine1(result);\n" |
| " subroutine2(result);\n" |
| " result = subroutine3(result) + subroutine4(result);\n"; |
| |
| break; |
| } |
| |
| case Utils::SHADER_STAGE_GEOMETRY: |
| { |
| result_sstream << " gl_Position = vec4(0);\n" |
| " subroutine1(gl_Position);\n" |
| " subroutine2(gl_Position);\n" |
| " gl_Position = subroutine3(gl_Position) + subroutine4(gl_Position);\n" |
| " EmitVertex();\n"; |
| |
| break; |
| } |
| |
| case Utils::SHADER_STAGE_TESSELLATION_CONTROL: |
| { |
| result_sstream << " gl_out[gl_InvocationID].gl_Position = vec4(0);\n" |
| " subroutine1(gl_out[gl_InvocationID].gl_Position);\n" |
| " subroutine2(gl_out[gl_InvocationID].gl_Position);\n" |
| " gl_out[gl_InvocationID].gl_Position = subroutine3(gl_in[0].gl_Position) + " |
| "subroutine4(gl_in[0].gl_Position);\n"; |
| |
| break; |
| } |
| |
| case Utils::SHADER_STAGE_VERTEX: |
| case Utils::SHADER_STAGE_TESSELLATION_EVALUATION: |
| { |
| result_sstream << " gl_Position = vec4(0);\n" |
| " subroutine1(gl_Position);\n" |
| " subroutine2(gl_Position);\n" |
| " gl_Position = subroutine3(gl_Position) + subroutine4(gl_Position);\n"; |
| |
| break; |
| } |
| |
| default: |
| break; |
| } /* switch (shader_stage) */ |
| |
| result_sstream << "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Initializes all objects required to run the test. */ |
| void FunctionalTest16::initTest() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| for (unsigned int n_id = 0; n_id < 2 /* test program/shader objects */; ++n_id) |
| { |
| const std::string fs_body = getShaderBody(Utils::SHADER_STAGE_FRAGMENT, n_id); |
| const std::string gs_body = getShaderBody(Utils::SHADER_STAGE_GEOMETRY, n_id); |
| const std::string tc_body = getShaderBody(Utils::SHADER_STAGE_TESSELLATION_CONTROL, n_id); |
| const std::string te_body = getShaderBody(Utils::SHADER_STAGE_TESSELLATION_EVALUATION, n_id); |
| const std::string vs_body = getShaderBody(Utils::SHADER_STAGE_VERTEX, n_id); |
| |
| if (!Utils::buildProgram(gl, vs_body, tc_body, te_body, gs_body, fs_body, DE_NULL, /* xfb_varyings */ |
| DE_NULL, /* n_xfb_varyings */ |
| m_vs_ids + n_id, m_tc_ids + n_id, m_te_ids + n_id, m_gs_ids + n_id, m_fs_ids + n_id, |
| m_po_ids + n_id)) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Failed to build test program object, index:" |
| "[" |
| << n_id << "]" << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Failed to build a test program"); |
| } |
| |
| if (m_are_pipeline_objects_supported) |
| { |
| /* Initialize shader program objects */ |
| const char* fs_body_raw_ptr = fs_body.c_str(); |
| const char* gs_body_raw_ptr = gs_body.c_str(); |
| glw::GLint link_status[5] = { GL_FALSE }; |
| const char* tc_body_raw_ptr = tc_body.c_str(); |
| const char* te_body_raw_ptr = te_body.c_str(); |
| const char* vs_body_raw_ptr = vs_body.c_str(); |
| |
| m_fs_po_ids[n_id] = gl.createShaderProgramv(GL_FRAGMENT_SHADER, 1 /* count */, &fs_body_raw_ptr); |
| m_gs_po_ids[n_id] = gl.createShaderProgramv(GL_GEOMETRY_SHADER, 1 /* count */, &gs_body_raw_ptr); |
| m_tc_po_ids[n_id] = gl.createShaderProgramv(GL_TESS_CONTROL_SHADER, 1 /* count */, &tc_body_raw_ptr); |
| m_te_po_ids[n_id] = gl.createShaderProgramv(GL_TESS_EVALUATION_SHADER, 1 /* count */, &te_body_raw_ptr); |
| m_vs_po_ids[n_id] = gl.createShaderProgramv(GL_VERTEX_SHADER, 1 /* count */, &vs_body_raw_ptr); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShaderProgramv() call failed."); |
| |
| gl.getProgramiv(m_fs_po_ids[n_id], GL_LINK_STATUS, link_status + 0); |
| gl.getProgramiv(m_gs_po_ids[n_id], GL_LINK_STATUS, link_status + 1); |
| gl.getProgramiv(m_tc_po_ids[n_id], GL_LINK_STATUS, link_status + 2); |
| gl.getProgramiv(m_te_po_ids[n_id], GL_LINK_STATUS, link_status + 3); |
| gl.getProgramiv(m_vs_po_ids[n_id], GL_LINK_STATUS, link_status + 4); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed."); |
| |
| if (link_status[0] == GL_FALSE) |
| TCU_FAIL("Fragment shader program failed to link"); |
| if (link_status[1] == GL_FALSE) |
| TCU_FAIL("Geometry shader program failed to link"); |
| if (link_status[2] == GL_FALSE) |
| TCU_FAIL("Tessellation control shader program failed to link"); |
| if (link_status[3] == GL_FALSE) |
| TCU_FAIL("Tessellation evaluation shader program failed to link"); |
| if (link_status[4] == GL_FALSE) |
| TCU_FAIL("Vertex shader program failed to link"); |
| |
| /* Initialize pipeline program object */ |
| gl.genProgramPipelines(1 /* n */, m_pipeline_object_ids + n_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGenProgramPipelines() call failed."); |
| |
| gl.useProgramStages(m_pipeline_object_ids[n_id], GL_FRAGMENT_SHADER_BIT, m_fs_po_ids[n_id]); |
| gl.useProgramStages(m_pipeline_object_ids[n_id], GL_GEOMETRY_SHADER_BIT, m_gs_po_ids[n_id]); |
| gl.useProgramStages(m_pipeline_object_ids[n_id], GL_TESS_CONTROL_SHADER_BIT, m_tc_po_ids[n_id]); |
| gl.useProgramStages(m_pipeline_object_ids[n_id], GL_TESS_EVALUATION_SHADER_BIT, m_te_po_ids[n_id]); |
| gl.useProgramStages(m_pipeline_object_ids[n_id], GL_VERTEX_SHADER_BIT, m_vs_po_ids[n_id]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); |
| } |
| |
| /* Retrieve subroutine locations */ |
| struct _item |
| { |
| glw::GLuint po_id; |
| _shader_stage& stage; |
| glw::GLuint so_id; |
| glw::GLenum so_type; |
| } items[] = { |
| { m_po_ids[n_id], m_po_descriptors[n_id].fragment, m_fs_ids[n_id], GL_FRAGMENT_SHADER }, |
| { m_po_ids[n_id], m_po_descriptors[n_id].geometry, m_gs_ids[n_id], GL_GEOMETRY_SHADER }, |
| { m_po_ids[n_id], m_po_descriptors[n_id].tess_control, m_tc_ids[n_id], GL_TESS_CONTROL_SHADER }, |
| { m_po_ids[n_id], m_po_descriptors[n_id].tess_evaluation, m_te_ids[n_id], GL_TESS_EVALUATION_SHADER }, |
| { m_po_ids[n_id], m_po_descriptors[n_id].vertex, m_vs_ids[n_id], GL_VERTEX_SHADER }, |
| |
| { m_fs_po_ids[n_id], m_fs_po_descriptors[n_id], m_fs_po_ids[n_id], GL_FRAGMENT_SHADER }, |
| { m_gs_po_ids[n_id], m_gs_po_descriptors[n_id], m_gs_po_ids[n_id], GL_GEOMETRY_SHADER }, |
| { m_tc_po_ids[n_id], m_tc_po_descriptors[n_id], m_tc_po_ids[n_id], GL_TESS_CONTROL_SHADER }, |
| { m_te_po_ids[n_id], m_te_po_descriptors[n_id], m_te_po_ids[n_id], GL_TESS_EVALUATION_SHADER }, |
| { m_vs_po_ids[n_id], m_vs_po_descriptors[n_id], m_vs_po_ids[n_id], GL_VERTEX_SHADER }, |
| }; |
| const unsigned int n_items = sizeof(items) / sizeof(items[0]); |
| |
| for (unsigned int n_item = 0; n_item < n_items; ++n_item) |
| { |
| _item& current_item = items[n_item]; |
| |
| current_item.stage.function1_index = |
| gl.getSubroutineIndex(current_item.po_id, current_item.so_type, "function1"); |
| current_item.stage.function2_index = |
| gl.getSubroutineIndex(current_item.po_id, current_item.so_type, "function2"); |
| current_item.stage.function3_index = |
| gl.getSubroutineIndex(current_item.po_id, current_item.so_type, "function3"); |
| current_item.stage.function4_index = |
| gl.getSubroutineIndex(current_item.po_id, current_item.so_type, "function4"); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() call(s) failed."); |
| |
| if (current_item.stage.function1_index == GL_INVALID_INDEX || |
| current_item.stage.function2_index == GL_INVALID_INDEX || |
| current_item.stage.function3_index == GL_INVALID_INDEX || |
| current_item.stage.function4_index == GL_INVALID_INDEX) |
| { |
| TCU_FAIL("Subroutine name was not recognized."); |
| } |
| |
| current_item.stage.subroutine1_uniform_location = |
| gl.getSubroutineUniformLocation(current_item.po_id, current_item.so_type, "subroutine1"); |
| current_item.stage.subroutine2_uniform_location = |
| gl.getSubroutineUniformLocation(current_item.po_id, current_item.so_type, "subroutine2"); |
| current_item.stage.subroutine3_uniform_location = |
| gl.getSubroutineUniformLocation(current_item.po_id, current_item.so_type, "subroutine3"); |
| current_item.stage.subroutine4_uniform_location = |
| gl.getSubroutineUniformLocation(current_item.po_id, current_item.so_type, "subroutine4"); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineUniformLocation() call(s) failed."); |
| |
| if (current_item.stage.subroutine1_uniform_location == -1 || |
| current_item.stage.subroutine2_uniform_location == -1 || |
| current_item.stage.subroutine3_uniform_location == -1 || |
| current_item.stage.subroutine4_uniform_location == -1) |
| { |
| TCU_FAIL("Subroutine uniform name was not recognized."); |
| } |
| |
| if (m_po_ids[n_id] == current_item.po_id) |
| { |
| gl.useProgram(current_item.po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); |
| } |
| else |
| { |
| /* Temporarily bind the program pipeline. */ |
| gl.bindProgramPipeline(m_pipeline_object_ids[n_id]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed."); |
| } |
| |
| gl.getUniformSubroutineuiv(current_item.so_type, current_item.stage.subroutine1_uniform_location, |
| ¤t_item.stage.default_subroutine1_value); |
| gl.getUniformSubroutineuiv(current_item.so_type, current_item.stage.subroutine2_uniform_location, |
| ¤t_item.stage.default_subroutine2_value); |
| gl.getUniformSubroutineuiv(current_item.so_type, current_item.stage.subroutine3_uniform_location, |
| ¤t_item.stage.default_subroutine3_value); |
| gl.getUniformSubroutineuiv(current_item.so_type, current_item.stage.subroutine4_uniform_location, |
| ¤t_item.stage.default_subroutine4_value); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformSubroutineuiv() call(s) failed."); |
| |
| current_item.stage.gl_stage = current_item.so_type; |
| |
| if (m_po_ids[n_id] != current_item.po_id) |
| { |
| /* Unbind the program pipeline object */ |
| gl.bindProgramPipeline(0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed."); |
| } |
| } /* for (all items) */ |
| |
| /* Make sure the default subroutine choices are valid. */ |
| verifySubroutineUniformValues( |
| TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT, /* makes the verification routine use program object descriptor */ |
| n_id, SUBROUTINE_UNIFORMS_SET_TO_VALID_VALUES); |
| |
| if (m_are_pipeline_objects_supported) |
| { |
| gl.useProgram(0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); |
| |
| gl.bindProgramPipeline(m_pipeline_object_ids[n_id]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed."); |
| { |
| verifySubroutineUniformValues( |
| TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_PIPELINE_OBJECT, /* makes the verification routine use pipeline object descriptor */ |
| n_id, SUBROUTINE_UNIFORMS_SET_TO_VALID_VALUES); |
| } |
| gl.bindProgramPipeline(0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed."); |
| } |
| } /* for (both program descriptors) */ |
| } |
| |
| /** Retrieves IDs of shaders OR shader program objects, depending on which of the two |
| * the caller requests for. |
| * |
| * @param retrieve_program_object_shader_ids true if the caller wishes to retrieve shader object IDs, |
| * false to return shader program IDs. |
| * @param n_id Index of the program/pipeline object the shaders |
| * are a part of. |
| * @param out_shader_stages Deref will be used to store exactly five IDs. Must not |
| * be NULL. |
| **/ |
| void FunctionalTest16::getShaderStages(bool retrieve_program_object_shader_ids, const unsigned int& n_id, |
| const _shader_stage** out_shader_stages) const |
| { |
| if (retrieve_program_object_shader_ids) |
| { |
| out_shader_stages[0] = &m_po_descriptors[n_id].vertex; |
| out_shader_stages[1] = &m_po_descriptors[n_id].tess_control; |
| out_shader_stages[2] = &m_po_descriptors[n_id].tess_evaluation; |
| out_shader_stages[3] = &m_po_descriptors[n_id].geometry; |
| out_shader_stages[4] = &m_po_descriptors[n_id].fragment; |
| } |
| else |
| { |
| out_shader_stages[0] = m_vs_po_descriptors + n_id; |
| out_shader_stages[1] = m_tc_po_descriptors + n_id; |
| out_shader_stages[2] = m_te_po_descriptors + n_id; |
| out_shader_stages[3] = m_gs_po_descriptors + n_id; |
| out_shader_stages[4] = m_fs_po_descriptors + n_id; |
| } |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult FunctionalTest16::iterate() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| m_are_pipeline_objects_supported = |
| m_context.getContextInfo().isExtensionSupported("GL_ARB_separate_shader_objects"); |
| |
| /* Initialize GL objects required to run the test */ |
| initTest(); |
| |
| /* Iterate over both pipelines/programs and verify that calling glUseProgram() / |
| * glBindProgramPipeline() / glUseProgramStages() resets subroutine uniform configuration. |
| */ |
| for (int test_case = static_cast<int>(TEST_CASE_FIRST); test_case != static_cast<int>(TEST_CASE_COUNT); ++test_case) |
| { |
| if (static_cast<_test_case>(test_case) != TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT && |
| !m_are_pipeline_objects_supported) |
| { |
| /* Current test case requires GL_ARB_separate_shader_objects support which is |
| * unavaiable on the platform that we're testing |
| */ |
| continue; |
| } |
| |
| for (unsigned int n_object_id = 0; n_object_id < 2; /* pipeline/program objects allocated for the test */ |
| ++n_object_id) |
| { |
| /* Verify that currently reported subroutine uniform values are equal to default values */ |
| if (test_case == TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT) |
| { |
| gl.useProgram(m_po_ids[n_object_id]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed"); |
| } |
| else |
| { |
| gl.bindProgramPipeline(m_pipeline_object_ids[n_object_id]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call failed"); |
| } |
| |
| verifySubroutineUniformValues(static_cast<_test_case>(test_case), n_object_id, |
| SUBROUTINE_UNIFORMS_SET_TO_DEFAULT_VALUES); |
| |
| /* Re-configure subroutine uniforms so that they point to different subroutines than |
| * the default ones. |
| */ |
| const _shader_stage* stages[5 /* fs+gs+tc+te+vs */] = { DE_NULL }; |
| |
| getShaderStages(static_cast<_test_case>(test_case) == TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT, |
| n_object_id, stages); |
| |
| for (unsigned int n_stage = 0; n_stage < 5 /* fs+gs+tc+te+vs stages */; ++n_stage) |
| { |
| const _shader_stage& current_stage = *(stages[n_stage]); |
| glw::GLuint subroutine_configuration[4] = { GL_INVALID_INDEX }; |
| |
| subroutine_configuration[0] = |
| (current_stage.default_subroutine1_value == current_stage.function1_index) ? |
| current_stage.function2_index : |
| current_stage.function1_index; |
| subroutine_configuration[1] = |
| (current_stage.default_subroutine2_value == current_stage.function1_index) ? |
| current_stage.function2_index : |
| current_stage.function1_index; |
| subroutine_configuration[2] = |
| (current_stage.default_subroutine3_value == current_stage.function3_index) ? |
| current_stage.function4_index : |
| current_stage.function3_index; |
| subroutine_configuration[3] = |
| (current_stage.default_subroutine4_value == current_stage.function3_index) ? |
| current_stage.function4_index : |
| current_stage.function3_index; |
| |
| gl.uniformSubroutinesuiv(current_stage.gl_stage, 4 /* count */, subroutine_configuration); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformSubroutinesuiv() call failed."); |
| } /* for (all stages) */ |
| |
| verifySubroutineUniformValues(static_cast<_test_case>(test_case), n_object_id, |
| SUBROUTINE_UNIFORMS_SET_TO_NONDEFAULT_VALUES); |
| |
| /* Execute test case-specific code */ |
| _shader_stage cached_shader_stage_data; |
| bool stage_reset_status[Utils::SHADER_STAGE_COUNT] = { false, false, false, false, false }; |
| bool uses_stage_reset_status = false; |
| |
| switch (test_case) |
| { |
| case TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT: |
| { |
| /* Switch to a different program object and then back to current PO. |
| * Subroutine uniforms should be back at their default settings, instead of |
| * the ones we've just set. |
| */ |
| gl.useProgram(m_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]); |
| gl.useProgram(m_po_ids[n_object_id]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call(s) failed."); |
| |
| break; |
| } |
| |
| case TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_PIPELINE_OBJECT: |
| { |
| /* Switch to a different pipeline object and then back to the current one. |
| * Subroutine uniforms should be back at their default settings, instead of |
| * the ones we've just set. |
| */ |
| gl.bindProgramPipeline( |
| m_pipeline_object_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]); |
| gl.bindProgramPipeline(m_pipeline_object_ids[n_object_id]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindProgramPipeline() call(s) failed."); |
| |
| break; |
| } |
| |
| case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_FRAGMENT_STAGE: |
| { |
| /* Change the fragment shader stage to a different one. |
| * |
| * Note: We also need to update internal descriptor since the subroutine/uniform |
| * locations may be different between the two programs. |
| */ |
| gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_FRAGMENT_SHADER_BIT, |
| m_fs_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); |
| |
| cached_shader_stage_data = m_fs_po_descriptors[n_object_id]; |
| m_fs_po_descriptors[n_object_id] = m_fs_po_descriptors[(n_object_id + 1) % 2]; |
| |
| stage_reset_status[Utils::SHADER_STAGE_FRAGMENT] = true; |
| uses_stage_reset_status = true; |
| |
| break; |
| } |
| |
| case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_GEOMETRY_STAGE: |
| { |
| /* Change the geometry shader stage to a different one. |
| * |
| * Note: We also need to update internal descriptor since the subroutine/uniform |
| * locations may be different between the two programs. |
| */ |
| gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_GEOMETRY_SHADER_BIT, |
| m_gs_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); |
| |
| cached_shader_stage_data = m_gs_po_descriptors[n_object_id]; |
| m_gs_po_descriptors[n_object_id] = m_gs_po_descriptors[(n_object_id + 1) % 2]; |
| |
| stage_reset_status[Utils::SHADER_STAGE_GEOMETRY] = true; |
| uses_stage_reset_status = true; |
| |
| break; |
| } |
| |
| case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_TESS_CONTROL_STAGE: |
| { |
| /* Change the tessellation control shader stage to a different one. |
| * |
| * Note: We also need to update internal descriptor since the subroutine/uniform |
| * locations may be different between the two programs. |
| */ |
| gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_TESS_CONTROL_SHADER_BIT, |
| m_tc_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); |
| |
| cached_shader_stage_data = m_tc_po_descriptors[n_object_id]; |
| m_tc_po_descriptors[n_object_id] = m_tc_po_descriptors[(n_object_id + 1) % 2]; |
| |
| stage_reset_status[Utils::SHADER_STAGE_TESSELLATION_CONTROL] = true; |
| uses_stage_reset_status = true; |
| |
| break; |
| } |
| |
| case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_TESS_EVALUATION_STAGE: |
| { |
| /* Change the tessellation evaluation shader stage to a different one. |
| * |
| * Note: We also need to update internal descriptor since the subroutine/uniform |
| * locations may be different between the two programs. |
| */ |
| gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_TESS_EVALUATION_SHADER_BIT, |
| m_te_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); |
| |
| cached_shader_stage_data = m_te_po_descriptors[n_object_id]; |
| m_te_po_descriptors[n_object_id] = m_te_po_descriptors[(n_object_id + 1) % 2]; |
| |
| stage_reset_status[Utils::SHADER_STAGE_TESSELLATION_EVALUATION] = true; |
| uses_stage_reset_status = true; |
| |
| break; |
| } |
| |
| case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_VERTEX_STAGE: |
| { |
| /* Change the vertex shader stage to a different one. |
| * |
| * Note: We also need to update internal descriptor since the subroutine/uniform |
| * locations may be different between the two programs. |
| */ |
| gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_VERTEX_SHADER_BIT, |
| m_vs_po_ids[(n_object_id + 1) % 2 /* objects allocated for the test */]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); |
| |
| cached_shader_stage_data = m_vs_po_descriptors[n_object_id]; |
| m_vs_po_descriptors[n_object_id] = m_vs_po_descriptors[(n_object_id + 1) % 2]; |
| |
| stage_reset_status[Utils::SHADER_STAGE_VERTEX] = true; |
| uses_stage_reset_status = true; |
| |
| break; |
| } |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized test case"); |
| } |
| } /* switch (test_case) */ |
| |
| /* Verify the subroutine uniform values are valid */ |
| if (!uses_stage_reset_status) |
| { |
| verifySubroutineUniformValues(static_cast<_test_case>(test_case), n_object_id, |
| SUBROUTINE_UNIFORMS_SET_TO_DEFAULT_VALUES); |
| } |
| else |
| { |
| const _shader_stage* shader_stages[Utils::SHADER_STAGE_COUNT] = { DE_NULL }; |
| |
| getShaderStages(static_cast<_test_case>(test_case) == TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT, |
| n_object_id, shader_stages); |
| |
| for (unsigned int n_shader_stage = 0; n_shader_stage < Utils::SHADER_STAGE_COUNT; ++n_shader_stage) |
| { |
| const _shader_stage& current_shader_stage = *(shader_stages[n_shader_stage]); |
| |
| if (stage_reset_status[n_shader_stage]) |
| { |
| verifySubroutineUniformValuesForShaderStage(current_shader_stage, |
| SUBROUTINE_UNIFORMS_SET_TO_DEFAULT_VALUES); |
| } |
| else |
| { |
| verifySubroutineUniformValuesForShaderStage(current_shader_stage, |
| SUBROUTINE_UNIFORMS_SET_TO_NONDEFAULT_VALUES); |
| } |
| } /* for (all shader stages) */ |
| } |
| |
| /* Revert the changes some of the test cases appied */ |
| switch (test_case) |
| { |
| case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_FRAGMENT_STAGE: |
| { |
| gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_FRAGMENT_SHADER_BIT, |
| m_fs_po_ids[n_object_id]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); |
| |
| m_fs_po_descriptors[n_object_id] = cached_shader_stage_data; |
| |
| break; |
| } |
| |
| case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_GEOMETRY_STAGE: |
| { |
| gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_GEOMETRY_SHADER_BIT, |
| m_gs_po_ids[n_object_id]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); |
| |
| m_gs_po_descriptors[n_object_id] = cached_shader_stage_data; |
| |
| break; |
| } |
| |
| case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_TESS_CONTROL_STAGE: |
| { |
| gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_TESS_CONTROL_SHADER_BIT, |
| m_tc_po_ids[n_object_id]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); |
| |
| m_tc_po_descriptors[n_object_id] = cached_shader_stage_data; |
| |
| break; |
| } |
| |
| case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_TESS_EVALUATION_STAGE: |
| { |
| gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_TESS_EVALUATION_SHADER_BIT, |
| m_te_po_ids[n_object_id]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); |
| |
| m_te_po_descriptors[n_object_id] = cached_shader_stage_data; |
| |
| break; |
| } |
| |
| case TEST_CASE_SWITCH_TO_DIFFERENT_PIPELINE_VERTEX_STAGE: |
| { |
| gl.useProgramStages(m_pipeline_object_ids[n_object_id], GL_VERTEX_SHADER_BIT, m_vs_po_ids[n_object_id]); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgramStages() call failed."); |
| |
| m_vs_po_descriptors[n_object_id] = cached_shader_stage_data; |
| |
| break; |
| } |
| |
| default: |
| break; |
| } /* switch (test_case) */ |
| |
| } /* for (all program object descriptors) */ |
| |
| /* Unbind the program object */ |
| gl.useProgram(0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); |
| } /* for (all test cases) */ |
| |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Verifies the subroutine uniform values reported by GL implementation. Depending on the test case, |
| * it will either query program object stages or separate shader objects. |
| * |
| * @param test_case Test case the verification is to be performed for. |
| * @param n_id Index of the program/pipeline object to use for the verification |
| * @param verification Verification method. |
| */ |
| void FunctionalTest16::verifySubroutineUniformValues(const _test_case& test_case, const unsigned int& n_id, |
| const _subroutine_uniform_value_verification& verification) |
| { |
| const _shader_stage* stages[] = { |
| DE_NULL, /* fragment shader stage slot */ |
| DE_NULL, /* geometry shader stage slot */ |
| DE_NULL, /* tess control shader stage slot */ |
| DE_NULL, /* tess eval shader stage slot */ |
| DE_NULL /* vertex shader stage slot */ |
| }; |
| const unsigned int n_stages = sizeof(stages) / sizeof(stages[0]); |
| |
| /* Verify that currently reported subroutine uniform values are equal to default values */ |
| getShaderStages(test_case == TEST_CASE_SWITCH_TO_DIFFERENT_PROGRAM_OBJECT, n_id, stages); |
| |
| for (unsigned int n_stage = 0; n_stage < n_stages; ++n_stage) |
| { |
| const _shader_stage& current_stage = *(stages[n_stage]); |
| |
| verifySubroutineUniformValuesForShaderStage(current_stage, verification); |
| } /* for (all items) */ |
| } |
| |
| /** Verifies the subroutine uniform values reported by GL implementation for user-specified |
| * shader stage. If the verification fails, m_has_test_passed will be set to false. |
| * |
| * @param shader_stage Descriptor of a shader stage that should be used for the process. |
| * @param verification Type of verification that should be performed. |
| * |
| **/ |
| void FunctionalTest16::verifySubroutineUniformValuesForShaderStage( |
| const _shader_stage& shader_stage, const _subroutine_uniform_value_verification& verification) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| glw::GLuint result_values[4] = { 0 }; |
| |
| gl.getUniformSubroutineuiv(shader_stage.gl_stage, shader_stage.subroutine1_uniform_location, result_values + 0); |
| gl.getUniformSubroutineuiv(shader_stage.gl_stage, shader_stage.subroutine2_uniform_location, result_values + 1); |
| gl.getUniformSubroutineuiv(shader_stage.gl_stage, shader_stage.subroutine3_uniform_location, result_values + 2); |
| gl.getUniformSubroutineuiv(shader_stage.gl_stage, shader_stage.subroutine4_uniform_location, result_values + 3); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformSubroutineuiv() call(s) failed."); |
| |
| if (verification == SUBROUTINE_UNIFORMS_SET_TO_VALID_VALUES) |
| { |
| if (!((result_values[0] == (GLuint)shader_stage.subroutine1_uniform_location || |
| result_values[0] == (GLuint)shader_stage.subroutine2_uniform_location) && |
| (result_values[1] == (GLuint)shader_stage.subroutine1_uniform_location || |
| result_values[1] == (GLuint)shader_stage.subroutine2_uniform_location) && |
| (result_values[2] == (GLuint)shader_stage.subroutine3_uniform_location || |
| result_values[2] == (GLuint)shader_stage.subroutine4_uniform_location) && |
| (result_values[3] == (GLuint)shader_stage.subroutine3_uniform_location || |
| result_values[3] == (GLuint)shader_stage.subroutine4_uniform_location))) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "SUBROUTINE_UNIFORMS_SET_TO_VALID_VALUES validation failed. " |
| "Shader stage:[" |
| << Utils::getShaderStageStringFromGLEnum(shader_stage.gl_stage) << "], " |
| "expected data:[" |
| << shader_stage.subroutine1_uniform_location << " OR " |
| << shader_stage.subroutine2_uniform_location << " x 2, " |
| << shader_stage.subroutine3_uniform_location << " OR " |
| << shader_stage.subroutine4_uniform_location << " x 2], " |
| "found data:[" |
| << result_values[0] << ", " << result_values[1] << ", " << result_values[2] << ", " |
| << result_values[3] << "]." << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| } |
| else if (verification == SUBROUTINE_UNIFORMS_SET_TO_DEFAULT_VALUES) |
| { |
| if (result_values[0] != shader_stage.default_subroutine1_value || |
| result_values[1] != shader_stage.default_subroutine2_value || |
| result_values[2] != shader_stage.default_subroutine3_value || |
| result_values[3] != shader_stage.default_subroutine4_value) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "SUBROUTINE_UNIFORMS_SET_TO_DEFAULT_VALUES validation failed. " |
| "Shader stage:[" |
| << Utils::getShaderStageStringFromGLEnum(shader_stage.gl_stage) << "], " |
| "expected data:[" |
| << shader_stage.default_subroutine1_value << ", " |
| << shader_stage.default_subroutine2_value << ", " |
| << shader_stage.default_subroutine3_value << ", " |
| << shader_stage.default_subroutine4_value << "], " |
| "found data:[" |
| << result_values[0] << ", " << result_values[1] << ", " << result_values[2] << ", " |
| << result_values[3] << "]." << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| } |
| else |
| { |
| DE_ASSERT(verification == SUBROUTINE_UNIFORMS_SET_TO_NONDEFAULT_VALUES); |
| |
| if (result_values[0] == shader_stage.default_subroutine1_value || |
| result_values[1] == shader_stage.default_subroutine2_value || |
| result_values[2] == shader_stage.default_subroutine3_value || |
| result_values[3] == shader_stage.default_subroutine4_value) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "SUBROUTINE_UNIFORMS_SET_TO_NONDEFAULT_VALUES validation failed. " |
| "Shader stage:[" |
| << Utils::getShaderStageStringFromGLEnum(shader_stage.gl_stage) << "], " |
| "expected data:![" |
| << shader_stage.default_subroutine1_value << ", " |
| << shader_stage.default_subroutine2_value << ", " |
| << shader_stage.default_subroutine3_value << ", " |
| << shader_stage.default_subroutine4_value << "], " |
| "found data:[" |
| << result_values[0] << ", " << result_values[1] << ", " << result_values[2] << ", " |
| << result_values[3] << "]." << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| } |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| * |
| **/ |
| FunctionalTest17::FunctionalTest17(deqp::Context& context) |
| : TestCase(context, "same_subroutine_and_subroutine_uniform_but_different_type_used_in_all_stages", |
| "Creates a program which uses the same subroutine and subroutine uniform " |
| "names for every stage (types of subroutines are different in each stage) " |
| "and then makes sure that such program compiles and works as expected.") |
| , m_fbo_id(0) |
| , m_fs_id(0) |
| , m_gs_id(0) |
| , m_has_test_passed(true) |
| , m_po_id(0) |
| , m_tc_id(0) |
| , m_te_id(0) |
| , m_to_data(DE_NULL) |
| , m_to_height(4) /* arbitrary value */ |
| , m_to_id(0) |
| , m_to_width(4) /* arbitrary value */ |
| , m_vao_id(0) |
| , m_vs_id(0) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Deinitializes all GL objects that may have been created during test execution. */ |
| void FunctionalTest17::deinit() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_fbo_id != 0) |
| { |
| gl.deleteFramebuffers(1, &m_fbo_id); |
| |
| m_fbo_id = 0; |
| } |
| |
| if (m_fs_id != 0) |
| { |
| gl.deleteShader(m_fs_id); |
| |
| m_fs_id = 0; |
| } |
| |
| if (m_gs_id != 0) |
| { |
| gl.deleteShader(m_gs_id); |
| |
| m_gs_id = 0; |
| } |
| |
| if (m_po_id != 0) |
| { |
| gl.deleteProgram(m_po_id); |
| |
| m_po_id = 0; |
| } |
| |
| if (m_tc_id != 0) |
| { |
| gl.deleteShader(m_tc_id); |
| |
| m_tc_id = 0; |
| } |
| |
| if (m_te_id != 0) |
| { |
| gl.deleteShader(m_te_id); |
| |
| m_te_id = 0; |
| } |
| |
| if (m_to_data != DE_NULL) |
| { |
| delete[] m_to_data; |
| |
| m_to_data = DE_NULL; |
| } |
| |
| if (m_to_id != 0) |
| { |
| gl.deleteTextures(1, &m_to_id); |
| |
| m_to_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; |
| } |
| |
| /* Restore original GL configuration */ |
| gl.patchParameteri(GL_PATCH_VERTICES, 3); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glPatchParameteri() call failed."); |
| |
| gl.pixelStorei(GL_PACK_ALIGNMENT, 4); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei() call failed."); |
| } |
| |
| /** Retrieves body of a fragment shader that should be used by the test program. |
| * |
| * @return Requested string. |
| **/ |
| std::string FunctionalTest17::getFragmentShaderBody() const |
| { |
| return "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "in GS_DATA\n" |
| "{\n" |
| " vec4 gs_data;\n" |
| " vec4 tc_data;\n" |
| " vec4 te_data;\n" |
| " vec4 vs_data;\n" |
| "} gs;\n" |
| "\n" |
| "out vec4 result;\n" |
| "\n" |
| "subroutine void subroutineTypeFS(out vec4 result);\n" |
| "\n" |
| "subroutine(subroutineTypeFS) void subroutine1(out vec4 result)\n" |
| "{\n" |
| " result = vec4(5, 6, 7, 8);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineTypeFS function;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " vec4 fs_data;\n" |
| "\n" |
| " function(fs_data);\n" |
| " result = gs.gs_data + gs.tc_data + gs.te_data + gs.vs_data + fs_data;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves body of a geometry shader that should be used by the test program. |
| * |
| * @return Requested string. |
| **/ |
| std::string FunctionalTest17::getGeometryShaderBody() const |
| { |
| return "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout(points) in;\n" |
| "layout(triangle_strip, max_vertices = 4) out;\n" |
| "\n" |
| "subroutine void subroutineTypeGS(out vec4 result);\n" |
| "\n" |
| "subroutine(subroutineTypeGS) void subroutine1(out vec4 result)\n" |
| "{\n" |
| " result = vec4(4, 5, 6, 7);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineTypeGS function;\n" |
| "\n" |
| "in TE_DATA\n" |
| "{\n" |
| " vec4 tc_data;\n" |
| " vec4 te_data;\n" |
| " vec4 vs_data;\n" |
| "} te[];\n" |
| "\n" |
| "out GS_DATA\n" |
| "{\n" |
| " vec4 gs_data;\n" |
| " vec4 tc_data;\n" |
| " vec4 te_data;\n" |
| " vec4 vs_data;\n" |
| "} result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " function(result.gs_data);\n" |
| " gl_Position = vec4(1, -1, 0, 1);\n" |
| " result.tc_data = te[0].tc_data;\n" |
| " result.te_data = te[0].te_data;\n" |
| " result.vs_data = te[0].vs_data;\n" |
| " EmitVertex();\n" |
| "\n" |
| " function(result.gs_data);\n" |
| " gl_Position = vec4(-1, -1, 0, 1);\n" |
| " result.tc_data = te[0].tc_data;\n" |
| " result.te_data = te[0].te_data;\n" |
| " result.vs_data = te[0].vs_data;\n" |
| " EmitVertex();\n" |
| "\n" |
| " function(result.gs_data);\n" |
| " gl_Position = vec4(1, 1, 0, 1);\n" |
| " result.tc_data = te[0].tc_data;\n" |
| " result.te_data = te[0].te_data;\n" |
| " result.vs_data = te[0].vs_data;\n" |
| " EmitVertex();\n" |
| "\n" |
| " function(result.gs_data);\n" |
| " gl_Position = vec4(-1, 1, 0, 1);\n" |
| " result.tc_data = te[0].tc_data;\n" |
| " result.te_data = te[0].te_data;\n" |
| " result.vs_data = te[0].vs_data;\n" |
| " EmitVertex();\n" |
| " EndPrimitive();\n" |
| "}\n"; |
| } |
| |
| /** Retrieves body of a tessellation control shader that should be used by the test program. |
| * |
| * @return Requested string. |
| **/ |
| std::string FunctionalTest17::getTessellationControlShaderBody() const |
| { |
| return "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout (vertices = 4) out;\n" |
| "\n" |
| "subroutine void subroutineTypeTC(out vec4 result);\n" |
| "\n" |
| "subroutine(subroutineTypeTC) void subroutine1(out vec4 result)\n" |
| "{\n" |
| " result = vec4(2, 3, 4, 5);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineTypeTC function;\n" |
| "\n" |
| "in VS_DATA\n" |
| "{\n" |
| " vec4 vs_data;\n" |
| "} vs[];\n" |
| "\n" |
| "out TC_DATA\n" |
| "{\n" |
| " vec4 tc_data;\n" |
| " vec4 vs_data;\n" |
| "} result[];\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_TessLevelInner[0] = 1.0;\n" |
| " gl_TessLevelInner[1] = 1.0;\n" |
| " gl_TessLevelOuter[0] = 1.0;\n" |
| " gl_TessLevelOuter[1] = 1.0;\n" |
| " gl_TessLevelOuter[2] = 1.0;\n" |
| " gl_TessLevelOuter[3] = 1.0;\n" |
| "\n" |
| " function(result[gl_InvocationID].tc_data);\n" |
| " result[gl_InvocationID].vs_data = vs[gl_InvocationID].vs_data;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves body of a tessellation evaluation shader that should be used |
| * by the test program. |
| * |
| * @return Requested string. |
| **/ |
| std::string FunctionalTest17::getTessellationEvaluationShaderBody() const |
| { |
| return "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout (quads, point_mode) in;\n" |
| "\n" |
| "subroutine void subroutineTypeTE(out vec4 result);\n" |
| "\n" |
| "subroutine(subroutineTypeTE) void subroutine1(out vec4 result)\n" |
| "{\n" |
| " result = vec4(3, 4, 5, 6);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineTypeTE function;\n" |
| "\n" |
| "in TC_DATA\n" |
| "{\n" |
| " vec4 tc_data;\n" |
| " vec4 vs_data;\n" |
| "} tc[];\n" |
| "\n" |
| "out TE_DATA\n" |
| "{\n" |
| " vec4 tc_data;\n" |
| " vec4 te_data;\n" |
| " vec4 vs_data;\n" |
| "} result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " result.vs_data = tc[0].vs_data;\n" |
| " result.tc_data = tc[0].tc_data;\n" |
| " function(result.te_data);\n" |
| "}\n"; |
| } |
| |
| /** Retrieves body of a vertex shader that should be used by the test program. |
| * |
| * @return Requested string. |
| **/ |
| std::string FunctionalTest17::getVertexShaderBody() const |
| { |
| return "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "out VS_DATA\n" |
| "{\n" |
| " vec4 vs_data;\n" |
| "} result;\n" |
| "\n" |
| "subroutine void subroutineTypeVS(out vec4 result);\n" |
| "\n" |
| "subroutine(subroutineTypeVS) void subroutine1(out vec4 result)\n" |
| "{\n" |
| " result = vec4(1, 2, 3, 4);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineTypeVS function;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " function(result.vs_data);\n" |
| "}\n"; |
| } |
| |
| /** Initializes all buffers and GL objects required to run the test. */ |
| void FunctionalTest17::initTest() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Configure GL_PATCH_VERTICES so that TC only takes a single patch vertex */ |
| gl.patchParameteri(GL_PATCH_VERTICES, 1); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glPatchParameteri() call failed."); |
| |
| /* Generate & bind a VAO */ |
| 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 test program object */ |
| std::string fs_body = getFragmentShaderBody(); |
| std::string gs_body = getGeometryShaderBody(); |
| std::string tc_body = getTessellationControlShaderBody(); |
| std::string te_body = getTessellationEvaluationShaderBody(); |
| std::string vs_body = getVertexShaderBody(); |
| |
| if (!Utils::buildProgram(gl, vs_body, tc_body, te_body, gs_body, fs_body, DE_NULL, /* xfb_varyings */ |
| DE_NULL, /* n_xfb_varyings */ |
| &m_vs_id, &m_tc_id, &m_te_id, &m_gs_id, &m_fs_id, &m_po_id)) |
| { |
| TCU_FAIL("Failed to link test program object"); |
| } |
| |
| /* Set up a texture object that will be used as a color attachment */ |
| gl.genTextures(1, &m_to_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() call failed."); |
| |
| gl.bindTexture(GL_TEXTURE_2D, m_to_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() call failed."); |
| |
| gl.texStorage2D(GL_TEXTURE_2D, 1, /* levels */ |
| GL_RGBA32F, m_to_width, m_to_height); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() call failed."); |
| |
| /* Set up FBO */ |
| gl.genFramebuffers(1, &m_fbo_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() call failed."); |
| |
| gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() call failed."); |
| |
| gl.framebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_to_id, 0 /* level */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() call failed."); |
| |
| /* Make sure glReadPixels() does not return misaligned data */ |
| gl.pixelStorei(GL_PACK_ALIGNMENT, 1); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei() call failed."); |
| |
| /* Initialize a buffer that will be used to store rendered data */ |
| m_to_data = new float[m_to_width * m_to_height * 4 /* rgba */]; |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult FunctionalTest17::iterate() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| initTest(); |
| |
| /* Use the test program to render a full-screen test quad */ |
| gl.useProgram(m_po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); |
| |
| gl.drawArrays(GL_PATCHES, 0 /* first */, 1 /* count */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed."); |
| |
| /* Read back the data that was rendered */ |
| gl.readPixels(0, /* x */ |
| 0, /* y */ |
| m_to_width, m_to_height, GL_RGBA, GL_FLOAT, m_to_data); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glReaDPixels() call failed."); |
| |
| /* Verify the data */ |
| verifyRenderedData(); |
| |
| /** All done */ |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Verifies the data that have been rendered by the test program. |
| * |
| * It is assumed the rendered data have already been copied to |
| * m_to_data. |
| * |
| * If the rendered data is found to be invalid, m_has_test_passed |
| * will be set to false. |
| **/ |
| void FunctionalTest17::verifyRenderedData() |
| { |
| const float epsilon = 1e-5f; |
| const float expected_data[4] = { 15.0f, 20.0f, 25.0f, 30.0f }; |
| |
| for (unsigned int y = 0; y < m_to_height && m_has_test_passed; ++y) |
| { |
| const float* row_ptr = m_to_data + y * 4 /* rgba */ * m_to_width; |
| |
| for (unsigned int x = 0; x < m_to_width && m_has_test_passed; ++x) |
| { |
| const float* pixel_ptr = row_ptr + 4 /* rgba */ * x; |
| |
| if (de::abs(pixel_ptr[0] - expected_data[0]) > epsilon || |
| de::abs(pixel_ptr[1] - expected_data[1]) > epsilon || |
| de::abs(pixel_ptr[2] - expected_data[2]) > epsilon || |
| de::abs(pixel_ptr[3] - expected_data[3]) > epsilon) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Invalid texel found at (" << x << ", " << y |
| << "): " |
| "expected:(" |
| << expected_data[0] << ", " << expected_data[1] << ", " << expected_data[2] << ", " |
| << expected_data[3] << "), found:(" << pixel_ptr[0] << ", " << pixel_ptr[1] << ", " |
| << pixel_ptr[2] << ", " << pixel_ptr[3] << ")." << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| } /* for (all columns) */ |
| } /* for (all rows) */ |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| * |
| **/ |
| FunctionalTest18_19::FunctionalTest18_19(deqp::Context& context) |
| : TestCase(context, "control_flow_and_returned_subroutine_values_used_as_subroutine_input", |
| "Makes sure that calling a subroutine with argument value returned by " |
| "another subroutine works correctly. Also checks that subroutine and " |
| "subroutine uniforms work as expected when used in connection with control " |
| "flow functions.") |
| , m_has_test_passed(true) |
| , m_n_points_to_draw(16) /* arbitrary value */ |
| , m_po_id(0) |
| , m_po_subroutine_divide_by_two_location(GL_INVALID_INDEX) |
| , m_po_subroutine_multiply_by_four_location(GL_INVALID_INDEX) |
| , m_po_subroutine_returns_false_location(GL_INVALID_INDEX) |
| , m_po_subroutine_returns_true_location(GL_INVALID_INDEX) |
| , m_po_subroutine_uniform_bool_operator1(-1) |
| , m_po_subroutine_uniform_bool_operator2(-1) |
| , m_po_subroutine_uniform_vec4_processor1(-1) |
| , m_po_subroutine_uniform_vec4_processor2(-1) |
| , m_xfb_bo_id(0) |
| , m_vao_id(0) |
| , m_vs_id(0) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** De-initializes all GL objects that may have been created during test execution */ |
| void FunctionalTest18_19::deinit() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| 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; |
| } |
| |
| if (m_xfb_bo_id != 0) |
| { |
| gl.deleteBuffers(1, &m_xfb_bo_id); |
| |
| m_xfb_bo_id = 0; |
| } |
| } |
| |
| /** Executes a single test iteration using user-specified properties. If the |
| * iterations fails, m_has_test_passed is set to false. |
| * |
| * @param bool_operator1_subroutine_location Location of a subroutine to be assigned to |
| * bool_operator1 subroutine uniform. |
| * @param bool_operator2_subroutine_location Location of a subroutine to be assigned to |
| * bool_operator2 subroutine uniform. |
| * @param vec4_operator1_subroutine_location Location of a subroutine to be assigned to |
| * vec4_operator1 subroutine uniform. |
| * @param vec4_operator2_subroutine_location Location of a subroutine to be assigned to |
| * vec4_operator2 subroutine uniform. |
| &**/ |
| void FunctionalTest18_19::executeTest(glw::GLuint bool_operator1_subroutine_location, |
| glw::GLuint bool_operator2_subroutine_location, |
| glw::GLuint vec4_operator1_subroutine_location, |
| glw::GLuint vec4_operator2_subroutine_location) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Set up subroutines */ |
| glw::GLuint subroutine_configuration[4 /* total number of subroutines */] = { 0 }; |
| |
| subroutine_configuration[m_po_subroutine_uniform_bool_operator1] = bool_operator1_subroutine_location; |
| subroutine_configuration[m_po_subroutine_uniform_bool_operator2] = bool_operator2_subroutine_location; |
| subroutine_configuration[m_po_subroutine_uniform_vec4_processor1] = vec4_operator1_subroutine_location; |
| subroutine_configuration[m_po_subroutine_uniform_vec4_processor2] = vec4_operator2_subroutine_location; |
| |
| gl.useProgram(m_po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed"); |
| |
| gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, 4 /* count */, subroutine_configuration); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformSubroutinesuiv() call failed"); |
| |
| /* Draw test-specific number of points */ |
| gl.beginTransformFeedback(GL_POINTS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed"); |
| { |
| gl.drawArrays(GL_POINTS, 0 /* first */, m_n_points_to_draw); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed"); |
| } |
| gl.endTransformFeedback(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed"); |
| |
| /* Map the BO storage into process space */ |
| const glw::GLvoid* xfb_data_ptr = gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer() call failed."); |
| |
| verifyXFBData(xfb_data_ptr, bool_operator1_subroutine_location, bool_operator2_subroutine_location, |
| vec4_operator1_subroutine_location, vec4_operator2_subroutine_location); |
| |
| /* Unmap BO storage */ |
| gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed."); |
| } |
| |
| /** Retrieves body of a vertex shader to be used by the test. */ |
| std::string FunctionalTest18_19::getVertexShaderBody() const |
| { |
| return "#version 400\n" |
| "\n" |
| "subroutine bool bool_processor();\n" |
| "subroutine vec4 vec4_processor(in vec4 iparam);\n" |
| "\n" |
| "subroutine(bool_processor) bool returnsFalse()\n" |
| "{\n" |
| " return false;\n" |
| "}\n" |
| "\n" |
| "subroutine(bool_processor) bool returnsTrue()\n" |
| "{\n" |
| " return true;\n" |
| "}\n" |
| "\n" |
| "subroutine(vec4_processor) vec4 divideByTwo(in vec4 iparam)\n" |
| "{\n" |
| " return iparam * vec4(0.5);\n" |
| "}\n" |
| "\n" |
| "subroutine(vec4_processor) vec4 multiplyByFour(in vec4 iparam)\n" |
| "{\n" |
| " return iparam * vec4(4.0);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform bool_processor bool_operator1;\n" |
| "subroutine uniform bool_processor bool_operator2;\n" |
| "subroutine uniform vec4_processor vec4_operator1;\n" |
| "subroutine uniform vec4_processor vec4_operator2;\n" |
| "\n" |
| "out float result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " if (bool_operator1() )\n" |
| " {\n" |
| " float value = float( (3 * gl_VertexID + 1) * 2);\n" |
| "\n" |
| " while (bool_operator1() )\n" |
| " {\n" |
| " value /= float(gl_VertexID + 2);\n" |
| "\n" |
| " if (value <= 1.0f) break;\n" |
| " }\n" |
| "\n" |
| " result = value;\n" |
| " }\n" |
| " else\n" |
| " {\n" |
| " vec4 value = vec4(gl_VertexID, gl_VertexID + 1,\n" |
| " gl_VertexID + 2, gl_VertexID + 3);\n" |
| "\n" |
| " switch (gl_VertexID % 2)\n" |
| " {\n" |
| " case 0:\n" |
| " {\n" |
| " for (int iteration = 0; iteration < gl_VertexID && bool_operator2(); ++iteration)\n" |
| " {\n" |
| " value = vec4_operator2(vec4_operator1(value));\n" |
| " }\n" |
| "\n" |
| " break;\n" |
| " }\n" |
| "\n" |
| " case 1:\n" |
| " {\n" |
| " for (int iteration = 0; iteration < gl_VertexID * 2; ++iteration)\n" |
| " {\n" |
| " value = vec4_operator1(vec4_operator2(value));\n" |
| " }\n" |
| "\n" |
| " break;\n" |
| " }\n" |
| " }\n" |
| "\n" |
| " result = value.x + value.y + value.z + value.w;\n" |
| "\n" |
| " }\n" |
| "}\n"; |
| } |
| |
| /** Initializes all GL objects required to run the test. */ |
| void FunctionalTest18_19::initTest() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| const char* varyings[1] = { "result" }; |
| std::string vs_body = getVertexShaderBody(); |
| const unsigned int n_varyings = sizeof(varyings) / sizeof(varyings[0]); |
| |
| if (!Utils::buildProgram(gl, vs_body, "", /* tc_body */ |
| "", /* te_body */ |
| "", /* gs_body */ |
| "", /* fs_body */ |
| varyings, n_varyings, &m_vs_id, DE_NULL, /* out_tc_id */ |
| DE_NULL, /* out_te_id */ |
| DE_NULL, /* out_gs_id */ |
| DE_NULL, /* out_fs_id */ |
| &m_po_id)) |
| { |
| TCU_FAIL("Failed to build test program object"); |
| } |
| |
| /* Retrieve subroutine & subroutine uniform locations */ |
| m_po_subroutine_divide_by_two_location = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "divideByTwo"); |
| m_po_subroutine_multiply_by_four_location = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "multiplyByFour"); |
| m_po_subroutine_returns_false_location = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "returnsFalse"); |
| m_po_subroutine_returns_true_location = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "returnsTrue"); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() call(s) failed"); |
| |
| if (m_po_subroutine_divide_by_two_location == GL_INVALID_INDEX || |
| m_po_subroutine_multiply_by_four_location == GL_INVALID_INDEX || |
| m_po_subroutine_returns_false_location == GL_INVALID_INDEX || |
| m_po_subroutine_returns_true_location == GL_INVALID_INDEX) |
| { |
| TCU_FAIL("glGetSubroutineIndex() returned GL_INVALID_INDEX for a valid subroutine"); |
| } |
| |
| m_po_subroutine_uniform_bool_operator1 = |
| gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "bool_operator1"); |
| m_po_subroutine_uniform_bool_operator2 = |
| gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "bool_operator2"); |
| m_po_subroutine_uniform_vec4_processor1 = |
| gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "vec4_operator1"); |
| m_po_subroutine_uniform_vec4_processor2 = |
| gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "vec4_operator2"); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineUniformLocation() call(s) failed"); |
| |
| if (m_po_subroutine_uniform_bool_operator1 == -1 || m_po_subroutine_uniform_bool_operator2 == -1 || |
| m_po_subroutine_uniform_vec4_processor1 == -1 || m_po_subroutine_uniform_vec4_processor2 == -1) |
| { |
| TCU_FAIL("glGetSubroutineUniformLocation() returned -1 for an active subroutine uniform"); |
| } |
| |
| /* Set up XFB BO */ |
| const unsigned int bo_size = static_cast<unsigned int>(sizeof(float) * m_n_points_to_draw); |
| |
| gl.genBuffers(1, &m_xfb_bo_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed."); |
| |
| gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_xfb_bo_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed."); |
| |
| gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* index */, m_xfb_bo_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed."); |
| |
| gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, bo_size, DE_NULL /* data */, GL_STATIC_COPY); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed."); |
| |
| /* Set up a VAO */ |
| 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."); |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult FunctionalTest18_19::iterate() |
| { |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* Initialize all GL objects required to run the test */ |
| initTest(); |
| |
| /* Iterate over all subroutine permutations */ |
| const glw::GLuint subroutine_bool_operators[] = { m_po_subroutine_returns_false_location, |
| m_po_subroutine_returns_true_location }; |
| const unsigned int n_subroutine_bool_operators = |
| sizeof(subroutine_bool_operators) / sizeof(subroutine_bool_operators[0]); |
| |
| const glw::GLuint subroutine_vec4_operators[] = { m_po_subroutine_divide_by_two_location, |
| m_po_subroutine_multiply_by_four_location }; |
| const unsigned int n_subroutine_vec4_operators = |
| sizeof(subroutine_vec4_operators) / sizeof(subroutine_vec4_operators[0]); |
| |
| for (unsigned int n_subroutine_uniform_bool_operator1 = 0; |
| n_subroutine_uniform_bool_operator1 < n_subroutine_bool_operators; ++n_subroutine_uniform_bool_operator1) |
| { |
| for (unsigned int n_subroutine_uniform_bool_operator2 = 0; |
| n_subroutine_uniform_bool_operator2 < n_subroutine_bool_operators; ++n_subroutine_uniform_bool_operator2) |
| { |
| for (unsigned int n_subroutine_uniform_vec4_operator1 = 0; |
| n_subroutine_uniform_vec4_operator1 < n_subroutine_vec4_operators; |
| ++n_subroutine_uniform_vec4_operator1) |
| { |
| for (unsigned int n_subroutine_uniform_vec4_operator2 = 0; |
| n_subroutine_uniform_vec4_operator2 < n_subroutine_vec4_operators; |
| ++n_subroutine_uniform_vec4_operator2) |
| { |
| executeTest(subroutine_bool_operators[n_subroutine_uniform_bool_operator1], |
| subroutine_bool_operators[n_subroutine_uniform_bool_operator2], |
| subroutine_vec4_operators[n_subroutine_uniform_vec4_operator1], |
| subroutine_vec4_operators[n_subroutine_uniform_vec4_operator2]); |
| } /* for (all subroutine vec4 operator subroutines used for processor2) */ |
| } /* for (all subroutine vec4 operator subroutines used for processor1) */ |
| } /* for (all subroutine bool operator subroutines used for operator2) */ |
| } /* for (all subroutine bool operator subroutines used for operator1) */ |
| |
| /* All done */ |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Divides input argument by two. The result value is returned to the |
| * caller. |
| * |
| * @param data Input value. |
| * |
| * @return As per description. |
| **/ |
| tcu::Vec4 FunctionalTest18_19::vec4operator_div2(tcu::Vec4 data) |
| { |
| return data * 0.5f; |
| } |
| |
| /** Multiplies input argument by four. The result value is returned to the |
| * caller. |
| * |
| * @param data Input value. |
| * |
| * @return As per description. |
| **/ |
| tcu::Vec4 FunctionalTest18_19::vec4operator_mul4(tcu::Vec4 data) |
| { |
| return data * 4.0f; |
| } |
| |
| /** Verifies data XFBed out by the vertex shader. It is assumed the subroutines were configured |
| * as per passed arguments, prior to the draw call. |
| * |
| * If the result data is found to be invalid, m_has_test_passed is set to false. |
| * |
| * @param data XFBed data. |
| * @param bool_operator1_subroutine_location Location of a subroutine to be assigned to |
| * bool_operator1 subroutine uniform. |
| * @param bool_operator2_subroutine_location Location of a subroutine to be assigned to |
| * bool_operator2 subroutine uniform. |
| * @param vec4_operator1_subroutine_location Location of a subroutine to be assigned to |
| * vec4_operator1 subroutine uniform. |
| * @param vec4_operator2_subroutine_location Location of a subroutine to be assigned to |
| * vec4_operator2 subroutine uniform. |
| */ |
| void FunctionalTest18_19::verifyXFBData(const glw::GLvoid* data, glw::GLuint bool_operator1_subroutine_location, |
| glw::GLuint bool_operator2_subroutine_location, |
| glw::GLuint vec4_operator1_subroutine_location, |
| glw::GLuint vec4_operator2_subroutine_location) |
| { |
| bool bool_operator1_result = false; |
| bool bool_operator2_result = false; |
| const float epsilon = 1e-5f; |
| PFNVEC4OPERATORPROC pVec4Operator1 = NULL; |
| PFNVEC4OPERATORPROC pVec4Operator2 = NULL; |
| const glw::GLfloat* traveller_ptr = (const glw::GLfloat*)data; |
| |
| bool_operator1_result = (bool_operator1_subroutine_location == m_po_subroutine_returns_true_location); |
| bool_operator2_result = (bool_operator2_subroutine_location == m_po_subroutine_returns_true_location); |
| pVec4Operator1 = (vec4_operator1_subroutine_location == m_po_subroutine_divide_by_two_location) ? |
| vec4operator_div2 : |
| vec4operator_mul4; |
| pVec4Operator2 = (vec4_operator2_subroutine_location == m_po_subroutine_divide_by_two_location) ? |
| vec4operator_div2 : |
| vec4operator_mul4; |
| |
| for (unsigned int n_vertex = 0; n_vertex < m_n_points_to_draw; ++n_vertex) |
| { |
| float expected_value = 0.0f; |
| |
| if (bool_operator1_result) |
| { |
| float value = float((3 * n_vertex + 1) * 2); |
| |
| while (bool_operator1_result) |
| { |
| value /= float(n_vertex + 2); |
| |
| if (value <= 1.0f) |
| break; |
| } |
| |
| expected_value = value; |
| } |
| else |
| { |
| tcu::Vec4 value((float)n_vertex, (float)n_vertex + 1, (float)n_vertex + 2, (float)n_vertex + 3); |
| |
| switch (n_vertex % 2) |
| { |
| case 0: |
| { |
| for (unsigned int iteration = 0; iteration < n_vertex && bool_operator2_result; ++iteration) |
| { |
| value = pVec4Operator2(pVec4Operator1(value)); |
| } |
| |
| break; |
| } |
| |
| case 1: |
| { |
| for (unsigned int iteration = 0; iteration < n_vertex * 2; ++iteration) |
| { |
| value = pVec4Operator1(pVec4Operator2(value)); |
| } |
| |
| break; |
| } |
| } /* switch (n_vertex % 2) */ |
| |
| expected_value = value.x() + value.y() + value.z() + value.w(); |
| } |
| |
| if (de::abs(expected_value - *traveller_ptr) > epsilon) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "XFBed data was found to be invalid at index [" << n_vertex |
| << "]" |
| "for the following subroutine location configuration:" |
| " bool_operator1_subroutine_location:[" |
| << bool_operator1_subroutine_location << "]" |
| " bool_operator2_subroutine_location:[" |
| << bool_operator2_subroutine_location << "]" |
| " vec4_operator1_subroutine_location:[" |
| << vec4_operator1_subroutine_location << "]" |
| " vec4_operator2_subroutine_location:[" |
| << vec4_operator2_subroutine_location << "];" |
| " expected data:" |
| << expected_value << ", found:" << *traveller_ptr << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| ++traveller_ptr; |
| } /* for (all drawn points) */ |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| * |
| **/ |
| NegativeTest1::NegativeTest1(deqp::Context& context) |
| : TestCase(context, "subroutine_errors", "Verifies all GL_INVALID_OPERATION, GL_INVALID_VALUE, GL_INVALID ENUM " |
| "errors related to subroutine usage are properly generated.") |
| , m_has_test_passed(true) |
| , m_po_active_subroutine_uniform_locations(0) |
| , m_po_active_subroutine_uniforms(0) |
| , m_po_active_subroutines(0) |
| , m_po_subroutine_uniform_function_index(-1) |
| , m_po_subroutine_uniform_function2_index(-1) |
| , m_po_subroutine_test1_index(GL_INVALID_INDEX) |
| , m_po_subroutine_test2_index(GL_INVALID_INDEX) |
| , m_po_subroutine_test3_index(GL_INVALID_INDEX) |
| , m_po_not_linked_id(0) |
| , m_po_id(0) |
| , m_vs_id(0) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Deinitializes all GL objects that may have been created during |
| * test execution. |
| **/ |
| void NegativeTest1::deinit() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_po_id != 0) |
| { |
| gl.deleteProgram(m_po_id); |
| |
| m_po_id = 0; |
| } |
| |
| if (m_po_not_linked_id != 0) |
| { |
| gl.deleteProgram(m_po_not_linked_id); |
| |
| m_po_not_linked_id = 0; |
| } |
| |
| if (m_vs_id != 0) |
| { |
| gl.deleteShader(m_vs_id); |
| |
| m_vs_id = 0; |
| } |
| } |
| |
| /** Initializes all GL objects required to run the test. */ |
| void NegativeTest1::initTest() |
| { |
| glw::GLint compile_status = GL_FALSE; |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Create program objects */ |
| m_po_not_linked_id = gl.createProgram(); |
| m_po_id = gl.createProgram(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call(s) failed."); |
| |
| /* Create vertex shader object */ |
| m_vs_id = gl.createShader(GL_VERTEX_SHADER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed."); |
| |
| /* Set up vertex shader */ |
| const char* vs_body = "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "subroutine void subroutineType (out ivec2 arg);\n" |
| "subroutine void subroutineType2(out ivec4 arg);\n" |
| "\n" |
| "subroutine(subroutineType) void test1(out ivec2 arg)\n" |
| "{\n" |
| " arg = ivec2(1, 2);\n" |
| "}\n" |
| "subroutine(subroutineType) void test2(out ivec2 arg)\n" |
| "{\n" |
| " arg = ivec2(3,4);\n" |
| "}\n" |
| "subroutine(subroutineType2) void test3(out ivec4 arg)\n" |
| "{\n" |
| " arg = ivec4(1, 2, 3, 4);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineType function;\n" |
| "subroutine uniform subroutineType2 function2;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " ivec2 test;\n" |
| " ivec4 test2;\n" |
| "\n" |
| " function(test);\n" |
| "\n" |
| " if (test.x > 2)\n" |
| " {\n" |
| " gl_Position = vec4(1);\n" |
| " }\n" |
| " else\n" |
| " {\n" |
| " function2(test2);\n" |
| "\n" |
| " gl_Position = vec4(float(test2.x) );\n" |
| " }\n" |
| "}\n"; |
| |
| gl.shaderSource(m_vs_id, 1 /* count */, &vs_body, DE_NULL /* length */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed"); |
| |
| gl.compileShader(m_vs_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed"); |
| |
| gl.getShaderiv(m_vs_id, GL_COMPILE_STATUS, &compile_status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed"); |
| |
| if (compile_status == GL_FALSE) |
| { |
| TCU_FAIL("Shader compilation failed"); |
| } |
| |
| /* Set up & link the test program object */ |
| glw::GLint link_status = GL_FALSE; |
| |
| gl.attachShader(m_po_id, m_vs_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed."); |
| |
| gl.linkProgram(m_po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() call failed."); |
| |
| gl.getProgramiv(m_po_id, GL_LINK_STATUS, &link_status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed."); |
| |
| if (link_status == GL_FALSE) |
| { |
| TCU_FAIL("Program linking failed"); |
| } |
| |
| /* Query test program object's properties */ |
| gl.getProgramStageiv(m_po_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS, |
| &m_po_active_subroutine_uniform_locations); |
| gl.getProgramStageiv(m_po_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINE_UNIFORMS, &m_po_active_subroutine_uniforms); |
| gl.getProgramStageiv(m_po_id, GL_VERTEX_SHADER, GL_ACTIVE_SUBROUTINES, &m_po_active_subroutines); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramStageiv() call(s) failed."); |
| |
| if (m_po_active_subroutine_uniform_locations != 2) |
| { |
| TCU_FAIL("Invalid GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS value returned"); |
| } |
| |
| m_po_subroutine_test1_index = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "test1"); |
| m_po_subroutine_test2_index = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "test2"); |
| m_po_subroutine_test3_index = gl.getSubroutineIndex(m_po_id, GL_VERTEX_SHADER, "test3"); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineIndex() call(s) failed."); |
| |
| if (m_po_subroutine_test1_index == GL_INVALID_INDEX || m_po_subroutine_test2_index == GL_INVALID_INDEX || |
| m_po_subroutine_test3_index == GL_INVALID_INDEX) |
| { |
| TCU_FAIL("Invalid subroutine index returned"); |
| } |
| |
| m_po_subroutine_uniform_function_index = gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "function"); |
| m_po_subroutine_uniform_function2_index = gl.getSubroutineUniformLocation(m_po_id, GL_VERTEX_SHADER, "function2"); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetSubroutineUniformLocation() call(s) failed."); |
| |
| if (m_po_subroutine_uniform_function_index == -1 || m_po_subroutine_uniform_function2_index == -1) |
| { |
| TCU_FAIL("Invalid subroutine uniform index returned"); |
| } |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult NegativeTest1::iterate() |
| { |
| glw::GLenum error_code = GL_NO_ERROR; |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* Initialize GL objects required to run the test */ |
| initTest(); |
| |
| /* The error INVALID_OPERATION is generated by GetSubroutineUniformLocation |
| * if the program object identified by <program> has not been successfully |
| * linked. |
| */ |
| gl.getSubroutineUniformLocation(m_po_not_linked_id, GL_FRAGMENT_SHADER, "subroutine_uniform_name"); |
| |
| error_code = gl.getError(); |
| |
| if (error_code != GL_INVALID_OPERATION) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "glGetSubroutineUniformLocation() does not generate GL_INVALID_OPERATION " |
| "error code when called for a non-linked program object." |
| << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| /* The error INVALID_VALUE is generated by GetActiveSubroutineUniformiv or |
| * GetActiveSubroutineUniformName if <index> is greater than or equal to the |
| * value of ACTIVE_SUBROUTINE_UNIFORMS for the shader stage. |
| */ |
| glw::GLint temp_length = 0; |
| glw::GLint temp_values = 0; |
| |
| gl.getActiveSubroutineUniformiv(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutine_uniforms, |
| GL_NUM_COMPATIBLE_SUBROUTINES, &temp_values); |
| error_code = gl.getError(); |
| |
| if (error_code == GL_INVALID_VALUE) |
| { |
| gl.getActiveSubroutineUniformiv(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutine_uniforms + 1, |
| GL_NUM_COMPATIBLE_SUBROUTINES, &temp_values); |
| |
| error_code = gl.getError(); |
| } |
| |
| if (error_code != GL_INVALID_VALUE) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "glGetActiveSubroutineUniformiv() does not generate GL_INVALID_VALUE " |
| "when passed <index> argument that is greater than or equal to " |
| "the value of GL_ACTIVE_SUBROUTINE_UNIFORMS." |
| << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| gl.getActiveSubroutineUniformName(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutine_uniforms, 0, /* bufsize */ |
| &temp_length, DE_NULL); /* name */ |
| error_code = gl.getError(); |
| |
| if (error_code == GL_INVALID_VALUE) |
| { |
| gl.getActiveSubroutineUniformName(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutine_uniforms + 1, |
| 0, /* bufsize */ |
| &temp_length, DE_NULL); /* name */ |
| |
| error_code = gl.getError(); |
| } |
| |
| if (error_code != GL_INVALID_VALUE) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "glGetActiveSubroutineUniformName() does not generate GL_INVALID_VALUE " |
| "when passed <index> argument that is greater than or equal to " |
| "the value of GL_ACTIVE_SUBROUTINE_UNIFORMS." |
| << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| /* The error INVALID_VALUE is generated by GetActiveSubroutineName if <index> |
| * is greater than or equal to the value of ACTIVE_SUBROUTINES for the shader |
| * stage. |
| */ |
| gl.getActiveSubroutineName(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutines, 0, /* bufsize */ |
| &temp_length, DE_NULL); /* name */ |
| error_code = gl.getError(); |
| |
| if (error_code == GL_INVALID_VALUE) |
| { |
| gl.getActiveSubroutineName(m_po_id, GL_VERTEX_SHADER, m_po_active_subroutines + 1, 0, /* bufsize */ |
| &temp_length, DE_NULL); /* name */ |
| |
| error_code = gl.getError(); |
| } |
| |
| if (error_code != GL_INVALID_VALUE) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "glGetActiveSubroutineName() does not generate GL_INVALID_VALUE " |
| "when passed <index> argument that is greater than or equal to " |
| "the value of GL_ACTIVE_SUBROUTINES." |
| << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| /* The error INVALID_VALUE is generated by UniformSubroutinesuiv if <count> |
| * is not equal to the value of ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS for the |
| * shader stage <shadertype>. |
| */ |
| glw::GLuint index = 0; |
| |
| gl.useProgram(m_po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); |
| |
| gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations - 1, &index); |
| error_code = gl.getError(); |
| |
| if (error_code == GL_INVALID_VALUE) |
| { |
| gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations + 1, &index); |
| |
| error_code = gl.getError(); |
| } |
| |
| if (error_code != GL_INVALID_VALUE) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "glUniformSubroutinesiv() does not generate GL_INVALID_VALUE " |
| "when passed <count> argument that is not equal to the value of " |
| "GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS." |
| << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| /* The error INVALID_VALUE is generated by UniformSubroutinesuiv if any value |
| * in <indices> is greater than or equal to the value of ACTIVE_SUBROUTINES |
| * for the shader stage. |
| */ |
| glw::GLuint invalid_subroutine_indices[4] = { (GLuint)m_po_active_subroutines, (GLuint)m_po_active_subroutines, |
| (GLuint)m_po_active_subroutines + 1, |
| (GLuint)m_po_active_subroutines + 1 }; |
| |
| gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations, /* count */ |
| invalid_subroutine_indices + 0); |
| error_code = gl.getError(); |
| |
| if (error_code == GL_INVALID_VALUE) |
| { |
| gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations, |
| invalid_subroutine_indices + 2); |
| |
| error_code = gl.getError(); |
| } |
| |
| if (error_code != GL_INVALID_VALUE) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "glUniformSubroutinesuiv() does not generate GL_INVALID_VALUE " |
| "when the value passed via <indices> argument is greater than " |
| "or equal to the value of GL_ACTIVE_SUBROUTINES." |
| << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| /* The error INVALID_OPERATION is generated by UniformSubroutinesuiv() if any |
| * subroutine index in <indices> identifies a subroutine not associated with |
| * the type of the subroutine uniform variable assigned to the corresponding |
| * location. |
| */ |
| glw::GLuint invalid_subroutine_indices2[2] = { m_po_subroutine_test1_index, m_po_subroutine_test1_index }; |
| |
| gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations, invalid_subroutine_indices2); |
| error_code = gl.getError(); |
| |
| if (error_code != GL_INVALID_OPERATION) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "glUniformSubroutinesuiv() does not generate GL_INVALID_OPERATION " |
| "when the subroutine index passed via <indices> argument identifies" |
| "a subroutine not associated with the type of the subroutine uniform " |
| "assigned to the corresponding location." |
| << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| /* The error INVALID_OPERATION is generated by UniformSubroutinesuiv if no |
| * program is active. |
| */ |
| glw::GLuint valid_subroutine_locations[2] = { 0 }; |
| |
| valid_subroutine_locations[m_po_subroutine_uniform_function_index] = m_po_subroutine_test1_index; |
| valid_subroutine_locations[m_po_subroutine_uniform_function2_index] = m_po_subroutine_test3_index; |
| |
| gl.useProgram(0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); |
| |
| gl.uniformSubroutinesuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations, valid_subroutine_locations); |
| error_code = gl.getError(); |
| |
| if (error_code != GL_INVALID_OPERATION) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "glUniformSubroutinesuiv() does not generate GL_INVALID_OPERATION " |
| "when called without an active program object." |
| << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| /* The error INVALID_VALUE is generated by GetUniformSubroutineuiv if |
| * <location> is greater than or equal to the value of |
| * ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS for the shader stage. |
| */ |
| glw::GLuint temp_value = 0; |
| |
| gl.useProgram(m_po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed."); |
| |
| gl.getUniformSubroutineuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations, &temp_value); |
| error_code = gl.getError(); |
| |
| if (error_code == GL_INVALID_VALUE) |
| { |
| gl.getUniformSubroutineuiv(GL_VERTEX_SHADER, m_po_active_subroutine_uniform_locations + 1, &temp_value); |
| error_code = gl.getError(); |
| } |
| |
| if (error_code != GL_INVALID_VALUE) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "glGetUniformSubroutineuiv() does not generate GL_INVALID_VALUE " |
| "when called for location that is greater than or equal to the value " |
| "of GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS." |
| << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| /* The error INVALID_OPERATION is generated by GetUniformSubroutineuiv if no |
| * program is active for the shader stage identified by <shadertype>. |
| */ |
| const glw::GLenum undefined_shader_stages[] = { GL_FRAGMENT_SHADER, GL_GEOMETRY_SHADER, GL_TESS_CONTROL_SHADER, |
| GL_TESS_EVALUATION_SHADER }; |
| const unsigned int n_undefined_shader_stages = sizeof(undefined_shader_stages) / sizeof(undefined_shader_stages[0]); |
| |
| for (unsigned int n_undefined_shader_stage = 0; n_undefined_shader_stage < n_undefined_shader_stages; |
| ++n_undefined_shader_stage) |
| { |
| glw::GLenum shader_stage = undefined_shader_stages[n_undefined_shader_stage]; |
| |
| gl.getUniformSubroutineuiv(shader_stage, 0, /* location */ |
| &temp_value); |
| error_code = gl.getError(); |
| |
| if (error_code != GL_INVALID_OPERATION) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "glGetUniformSubroutineuiv() does not generate GL_INVALID_OPERATION " |
| "when called for a shader stage that is not defined for active " |
| "program object." |
| << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| } /* for (all undefined shader stages) */ |
| |
| /* All done */ |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Constructor |
| * |
| * @param context Rendering context. |
| * |
| **/ |
| NegativeTest2::NegativeTest2(deqp::Context& context) |
| : TestCase(context, "subroutine_uniform_scope", "Verifies subroutine uniforms declared in shader stage A" |
| "cannot be accessed from a different stage.") |
| , m_fs_id(0) |
| , m_gs_id(0) |
| , m_has_test_passed(true) |
| , m_po_id(0) |
| , m_tc_id(0) |
| , m_te_id(0) |
| , m_vs_id(0) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Deinitializes all GL objects that may have been created during test execution */ |
| void NegativeTest2::deinit() |
| { |
| deinitGLObjects(); |
| } |
| |
| /** Deinitializes all GL objects that may have been created during test execution */ |
| void NegativeTest2::deinitGLObjects() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_fs_id != 0) |
| { |
| gl.deleteShader(m_fs_id); |
| |
| m_fs_id = 0; |
| } |
| |
| if (m_gs_id != 0) |
| { |
| gl.deleteShader(m_gs_id); |
| |
| m_gs_id = 0; |
| } |
| |
| if (m_tc_id != 0) |
| { |
| gl.deleteShader(m_tc_id); |
| |
| m_tc_id = 0; |
| } |
| |
| if (m_te_id != 0) |
| { |
| gl.deleteShader(m_te_id); |
| |
| m_te_id = 0; |
| } |
| |
| if (m_vs_id != 0) |
| { |
| gl.deleteShader(m_vs_id); |
| |
| m_vs_id = 0; |
| } |
| |
| if (m_po_id != 0) |
| { |
| gl.deleteProgram(m_po_id); |
| |
| m_po_id = 0; |
| } |
| } |
| |
| /** Builds an offending program object and tries to link it. We're either expecting |
| * a compile-time or link-time error here. |
| * |
| * If the program object builds successfully, the test has failed. |
| * |
| * @param referencing_stage Shader stage which defines a subroutine uniform that |
| * should be called from fragment/geometry/tess control/ |
| * tess evaluation/vertex shader stages. |
| * |
| **/ |
| void NegativeTest2::executeTestCase(const Utils::_shader_stage& referencing_stage) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| const std::string fs_body = getFragmentShaderBody(referencing_stage); |
| const std::string gs_body = getGeometryShaderBody(referencing_stage); |
| const std::string tc_body = getTessellationControlShaderBody(referencing_stage); |
| const std::string te_body = getTessellationEvaluationShaderBody(referencing_stage); |
| const std::string vs_body = getVertexShaderBody(referencing_stage); |
| |
| if (Utils::buildProgram(gl, vs_body, tc_body, te_body, gs_body, fs_body, NULL, /* xfb_varyings */ |
| 0, /* n_xfb_varyings */ |
| &m_vs_id, &m_tc_id, &m_te_id, &m_gs_id, &m_fs_id, &m_po_id)) |
| { |
| /* Test program should not have built correctly ! */ |
| m_testCtx.getLog() << tcu::TestLog::Message << "In the following program, one of the stages references " |
| "a subroutine that is defined in another stage. This " |
| "is forbidden by the specification.\n" |
| "\n" |
| "Vertex shader:\n\n" |
| << vs_body.c_str() << "\n\nTessellation control shader:\n\n" |
| << tc_body.c_str() << "\n\nTessellation evaluation shader:\n\n" |
| << te_body.c_str() << "\n\nGeometry shader:\n\n" |
| << gs_body.c_str() << "\n\nFragment shader:\n\n" |
| << fs_body.c_str() << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } /* if (test program was built successfully) */ |
| |
| /* Release the shaders & the program object that buildProgram() created */ |
| deinitGLObjects(); |
| } |
| |
| /** Retrieves an offending fragment shader body. |
| * |
| * @param referencing_stage Shader stage which defines the subroutine uniform that |
| * will be called from fragment shader. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest2::getFragmentShaderBody(const Utils::_shader_stage& referencing_stage) const |
| { |
| std::stringstream result; |
| |
| /* Form the pre-amble */ |
| result << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "subroutine void testSubroutineType(out vec4 test_argument);\n" |
| "\n" |
| /* Define a subroutine */ |
| "subroutine(testSubroutineType) void fs_subroutine(out vec4 test_argument)\n" |
| "{\n" |
| " test_argument = vec4(1, 0, 0, 0);\n" |
| "}\n" |
| "\n" |
| /* Define output variables */ |
| "out vec4 result;\n" |
| "\n" |
| /* Define uniforms */ |
| "subroutine uniform testSubroutineType test_fs_subroutine;\n" |
| "\n" |
| /* Define main() */ |
| "void main()\n" |
| "{\n" |
| " " |
| << getSubroutineUniformName(referencing_stage) << "(result);\n" |
| "}\n"; |
| |
| return result.str(); |
| } |
| |
| /** Retrieves an offending geometry shader body. |
| * |
| * @param referencing_stage Shader stage which defines the subroutine uniform that |
| * will be called from geometry shader. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest2::getGeometryShaderBody(const Utils::_shader_stage& referencing_stage) const |
| { |
| std::stringstream result; |
| |
| /* Form the pre-amble */ |
| result << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "subroutine void testSubroutineType(out vec4 test_argument);\n" |
| "\n" |
| "layout(points) in;\n" |
| "layout(points, max_vertices = 1) out;\n" |
| "\n" |
| /* Define a subroutine */ |
| "subroutine(testSubroutineType) void gs_subroutine(out vec4 test_argument)\n" |
| "{\n" |
| " test_argument = vec4(0, 1, 1, 1);\n" |
| "}\n" |
| "\n" |
| /* Define output variables */ |
| "out vec4 result;\n" |
| "\n" |
| /* Define uniforms */ |
| "subroutine uniform testSubroutineType test_gs_subroutine;\n" |
| "\n" |
| /* Define main() */ |
| "void main()\n" |
| "{\n" |
| " " |
| << getSubroutineUniformName(referencing_stage) << "(result);\n" |
| "}\n"; |
| |
| return result.str(); |
| } |
| |
| /** Retrieves name of the subroutine uniform that is defined in user-specified |
| * shader stage. |
| * |
| * @param stage Shader stage to retrieve the subroutine uniform name for. |
| * |
| * @return As per description. |
| **/ |
| std::string NegativeTest2::getSubroutineUniformName(const Utils::_shader_stage& stage) const |
| { |
| std::string result = "?"; |
| |
| switch (stage) |
| { |
| case Utils::SHADER_STAGE_FRAGMENT: |
| { |
| result = "test_fs_subroutine"; |
| |
| break; |
| } |
| |
| case Utils::SHADER_STAGE_GEOMETRY: |
| { |
| result = "test_gs_subroutine"; |
| |
| break; |
| } |
| |
| case Utils::SHADER_STAGE_TESSELLATION_CONTROL: |
| { |
| result = "test_tc_subroutine"; |
| |
| break; |
| } |
| |
| case Utils::SHADER_STAGE_TESSELLATION_EVALUATION: |
| { |
| result = "test_te_subroutine"; |
| |
| break; |
| } |
| |
| case Utils::SHADER_STAGE_VERTEX: |
| { |
| result = "test_vs_subroutine"; |
| |
| break; |
| } |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized shader stage requested"); |
| } |
| } /* switch (stage) */ |
| |
| return result; |
| } |
| |
| /** Retrieves an offending tessellation control shader body. |
| * |
| * @param referencing_stage Shader stage which defines the subroutine uniform that |
| * will be called from tessellation control shader. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest2::getTessellationControlShaderBody(const Utils::_shader_stage& referencing_stage) const |
| { |
| std::stringstream result; |
| |
| /* Form the pre-amble */ |
| result << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout(vertices = 4) out;\n" |
| "\n" |
| "subroutine void testSubroutineType(out vec4 test_argument);\n" |
| "\n" |
| /* Define a subroutine */ |
| "subroutine(testSubroutineType) void tc_subroutine(out vec4 test_argument)\n" |
| "{\n" |
| " test_argument = vec4(0, 0, 1, 0);\n" |
| "}\n" |
| "\n" |
| /* Define uniforms */ |
| "subroutine uniform testSubroutineType test_tc_subroutine;\n" |
| "\n" |
| /* Define main() */ |
| "void main()\n" |
| "{\n" |
| " " |
| << getSubroutineUniformName(referencing_stage) << "(gl_out[gl_InvocationID].gl_Position);\n" |
| "}\n"; |
| |
| return result.str(); |
| } |
| |
| /** Retrieves an offending tessellation evaluation shader body. |
| * |
| * @param referencing_stage Shader stage which defines the subroutine uniform that |
| * will be called from tessellation evaluation shader. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest2::getTessellationEvaluationShaderBody(const Utils::_shader_stage& referencing_stage) const |
| { |
| std::stringstream result; |
| |
| /* Form the pre-amble */ |
| result << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout(quads) in;\n" |
| "\n" |
| "subroutine void testSubroutineType(out vec4 test_argument);\n" |
| "\n" |
| /* Define a subroutine */ |
| "subroutine(testSubroutineType) void te_subroutine(out vec4 test_argument)\n" |
| "{\n" |
| " test_argument = vec4(1, 1, 1, 1);\n" |
| "}\n" |
| "\n" |
| /* Define uniforms */ |
| "subroutine uniform testSubroutineType test_te_subroutine;\n" |
| "\n" |
| /* Define main() */ |
| "void main()\n" |
| "{\n" |
| " " |
| << getSubroutineUniformName(referencing_stage) << "(gl_Position);\n" |
| "}\n"; |
| |
| return result.str(); |
| } |
| |
| /** Retrieves an offending vertex shader body. |
| * |
| * @param referencing_stage Shader stage which defines the subroutine uniform that |
| * will be called from vertex shader. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest2::getVertexShaderBody(const Utils::_shader_stage& referencing_stage) const |
| { |
| std::stringstream result; |
| |
| /* Form the pre-amble */ |
| result << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "subroutine void testSubroutineType(out vec4 test_argument);\n" |
| "\n" |
| /* Define a subroutine */ |
| "subroutine(testSubroutineType) void vs_subroutine(out vec4 test_argument)\n" |
| "{\n" |
| " test_argument = vec4(0, 1, 0, 0);\n" |
| "}\n" |
| "\n" |
| /* Define uniforms */ |
| "subroutine uniform testSubroutineType test_vs_subroutine;\n" |
| "\n" |
| /* Define main() */ |
| "void main()\n" |
| "{\n" |
| " " |
| << getSubroutineUniformName(referencing_stage) << "(gl_Position);\n" |
| "}\n"; |
| |
| return result.str(); |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult NegativeTest2::iterate() |
| { |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* Iterate over all shader stages and execute the checks */ |
| for (int referencing_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST); |
| referencing_stage < static_cast<int>(Utils::SHADER_STAGE_COUNT); ++referencing_stage) |
| { |
| executeTestCase(static_cast<Utils::_shader_stage>(referencing_stage)); |
| } /* for (all test cases) */ |
| |
| /* All done */ |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| * |
| **/ |
| NegativeTest3::NegativeTest3(deqp::Context& context) |
| : TestCase(context, "missing_subroutine_keyword", "Verifies that subroutine keyword is necessary when declaring a " |
| "subroutine uniforn and a compilation error occurs without it.") |
| , m_has_test_passed(true) |
| , m_so_id(0) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Deinitializes all GL objects that may have been created during test execution */ |
| void NegativeTest3::deinit() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_so_id != 0) |
| { |
| gl.deleteShader(m_so_id); |
| |
| m_so_id = 0; |
| } |
| } |
| |
| /** Verifies that broken shader (for user-specified shader stage) does not compile. |
| * |
| * @param shader_stage Shader stage to use for the test. |
| **/ |
| void NegativeTest3::executeTest(const Utils::_shader_stage& shader_stage) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Generate a new shader object */ |
| m_so_id = gl.createShader(Utils::getGLenumForShaderStage(shader_stage)); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed."); |
| |
| /* Assign body to the shader */ |
| std::string body; |
| const char* body_raw_ptr = DE_NULL; |
| |
| switch (shader_stage) |
| { |
| case Utils::SHADER_STAGE_VERTEX: |
| body = getVertexShaderBody(); |
| break; |
| case Utils::SHADER_STAGE_TESSELLATION_CONTROL: |
| body = getTessellationControlShaderBody(); |
| break; |
| case Utils::SHADER_STAGE_TESSELLATION_EVALUATION: |
| body = getTessellationEvaluationShaderBody(); |
| break; |
| case Utils::SHADER_STAGE_GEOMETRY: |
| body = getGeometryShaderBody(); |
| break; |
| case Utils::SHADER_STAGE_FRAGMENT: |
| body = getFragmentShaderBody(); |
| break; |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized shader stage requested"); |
| } |
| } /* switch (shader_stage) */ |
| |
| body_raw_ptr = body.c_str(); |
| |
| gl.shaderSource(m_so_id, 1 /* count */, &body_raw_ptr, DE_NULL /* length */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed."); |
| |
| /* Try to compile the shader */ |
| glw::GLint compile_status = 0; |
| |
| gl.compileShader(m_so_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed."); |
| |
| gl.getShaderiv(m_so_id, GL_COMPILE_STATUS, &compile_status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed."); |
| |
| if (compile_status == GL_TRUE) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "The following shader was expected to fail to compile but was " |
| "accepted by the compiler:\n" |
| "\n" |
| << body.c_str() << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| /* Good to release the shader at this point */ |
| gl.deleteShader(m_so_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteShader() call failed."); |
| } |
| |
| /** Retrieves body of a broken fragment shader. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest3::getFragmentShaderBody() const |
| { |
| return "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "subroutine void testSubroutineType(inout vec4 test);\n" |
| "\n" |
| "void testSubroutine1(inout vec4 test)\n" |
| "{\n" |
| " test += vec4(3, 4, 5, 6);\n" |
| "}\n" |
| "\n" |
| "uniform testSubroutineType subroutineFunction;\n" |
| "out vec4 result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " vec4 test = vec4(2, 3, 4, 5);\n" |
| "\n" |
| " subroutineFunction(test);\n" |
| "\n" |
| " result = test;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves body of a broken geometry shader. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest3::getGeometryShaderBody() const |
| { |
| return "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout(points) in;\n" |
| "layout(points, max_vertices = 1) out;\n" |
| "\n" |
| "subroutine void testSubroutineType(inout vec4 test);\n" |
| "\n" |
| "void testSubroutine1(inout vec4 test)\n" |
| "{\n" |
| " test += vec4(3, 4, 5, 6);\n" |
| "}\n" |
| "\n" |
| "uniform testSubroutineType subroutineFunction;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " vec4 test = vec4(2, 3, 4, 5);\n" |
| "\n" |
| " subroutineFunction(test);\n" |
| "\n" |
| " gl_Position = test;\n" |
| " EmitVertex();\n" |
| "}\n"; |
| } |
| |
| /** Retrieves body of a broken tessellation control shader. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest3::getTessellationControlShaderBody() const |
| { |
| return "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout(vertices=4) out;\n" |
| "\n" |
| "subroutine void testSubroutineType(inout vec4 test);\n" |
| "\n" |
| "void testSubroutine1(inout vec4 test)\n" |
| "{\n" |
| " test += vec4(1, 2, 3, 4);\n" |
| "}\n" |
| "\n" |
| "uniform testSubroutineType subroutineFunction;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " vec4 test = vec4(0, 1, 2, 3);\n" |
| "\n" |
| " subroutineFunction(test);\n" |
| "\n" |
| " gl_out[gl_InvocationID].gl_Position = test;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves body of a broken tessellation evaluation shader. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest3::getTessellationEvaluationShaderBody() const |
| { |
| return "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout(quads) in;\n" |
| "\n" |
| "subroutine void testSubroutineType(inout vec4 test);\n" |
| "\n" |
| "void testSubroutine1(inout vec4 test)\n" |
| "{\n" |
| " test += vec4(2, 3, 4, 5);\n" |
| "}\n" |
| "\n" |
| "uniform testSubroutineType subroutineFunction;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " vec4 test = vec4(1, 2, 3, 4);\n" |
| "\n" |
| " subroutineFunction(test);\n" |
| "\n" |
| " gl_Position = test;\n" |
| "}\n"; |
| } |
| |
| /** Retrieves body of a broken vertex shader. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest3::getVertexShaderBody() const |
| { |
| return "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "subroutine void testSubroutineType(inout vec4 test);\n" |
| "\n" |
| "void testSubroutine1(inout vec4 test)\n" |
| "{\n" |
| " test += vec4(0, 1, 2, 3);\n" |
| "}\n" |
| "\n" |
| "uniform testSubroutineType subroutineFunction;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " subroutineFunction(gl_Position);\n" |
| "}\n"; |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult NegativeTest3::iterate() |
| { |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* Iterate over all shader stages */ |
| for (int shader_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST); |
| shader_stage < static_cast<int>(Utils::SHADER_STAGE_COUNT); ++shader_stage) |
| { |
| executeTest(static_cast<Utils::_shader_stage>(shader_stage)); |
| } /* for (all shader stages) */ |
| |
| /* Done */ |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| * |
| **/ |
| NegativeTest4::NegativeTest4(deqp::Context& context) |
| : TestCase(context, "subroutines_incompatible_with_subroutine_type", |
| "Verifies that a compile-time error is generated when arguments and " |
| "return type do not match beween the function and each associated " |
| "subroutine type.") |
| , m_has_test_passed(true) |
| , m_so_id(0) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Deinitializes GL objects that may have been created during test |
| * execution. |
| **/ |
| void NegativeTest4::deinit() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_so_id != 0) |
| { |
| gl.deleteShader(m_so_id); |
| |
| m_so_id = 0; |
| } |
| } |
| |
| /** Retrieves body of a shader of user-specified type that should be used |
| * for a single test iteration. The shader will define user-specified number |
| * of subroutine types, with the last type either defining an additional argument |
| * or using a different return type. |
| * A subroutine (claimed compatible with *all* subroutine types) will also be |
| * defined in the shader. |
| * |
| * @param shader_stage Shader stage to use for the query. |
| * @param n_subroutine_types Overall number of subroutine types that will be |
| * declared & used in the shader. Please see description |
| * for more details. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest4::getShaderBody(const Utils::_shader_stage& shader_stage, |
| const unsigned int& n_subroutine_types, const _test_case& test_case) const |
| { |
| std::stringstream result_sstream; |
| |
| /* Form the pre-amble */ |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n"; |
| |
| /* Inject stage-specific code */ |
| switch (shader_stage) |
| { |
| case Utils::SHADER_STAGE_GEOMETRY: |
| { |
| result_sstream << "layout (points) in;\n" |
| "layout (points, max_vertices = 1) out;\n" |
| "\n"; |
| |
| break; |
| } |
| |
| case Utils::SHADER_STAGE_TESSELLATION_CONTROL: |
| { |
| result_sstream << "layout (vertices = 4) out;\n" |
| "\n"; |
| |
| break; |
| } |
| |
| case Utils::SHADER_STAGE_TESSELLATION_EVALUATION: |
| { |
| result_sstream << "layout (quads) in;\n" |
| "\n"; |
| |
| break; |
| } |
| |
| default: |
| break; |
| } /* switch (shader_stage) */ |
| |
| /* Insert subroutine type declarations */ |
| for (unsigned int n_subroutine_type = 0; n_subroutine_type < n_subroutine_types - 1; ++n_subroutine_type) |
| { |
| result_sstream << "subroutine void subroutineType" << n_subroutine_type << "(inout vec3 argument);\n"; |
| } /* for (all subroutine types) */ |
| |
| switch (test_case) |
| { |
| case TEST_CASE_INCOMPATIBLE_ARGUMENT_LIST: |
| { |
| result_sstream << "subroutine void subroutineType" << (n_subroutine_types - 1) |
| << "(inout vec3 argument, out vec4 argument2);\n"; |
| |
| break; |
| } |
| |
| case TEST_CASE_INCOMPATIBLE_RETURN_TYPE: |
| { |
| result_sstream << "subroutine int subroutineType" << (n_subroutine_types - 1) << "(inout vec3 argument);\n"; |
| |
| break; |
| } |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized test case"); |
| } |
| } /* switch (test_case) */ |
| |
| /* Insert subroutine declarations */ |
| result_sstream << "subroutine("; |
| |
| for (unsigned int n_subroutine_type = 0; n_subroutine_type < n_subroutine_types; ++n_subroutine_type) |
| { |
| result_sstream << "subroutineType" << n_subroutine_type; |
| |
| if (n_subroutine_type != (n_subroutine_types - 1)) |
| { |
| result_sstream << ", "; |
| } |
| } /* for (all subroutine types) */ |
| |
| result_sstream << ") void function(inout vec3 argument)\n" |
| "{\n" |
| " argument = vec3(1, 2, 3);\n" |
| "}\n" |
| "\n"; |
| |
| /* Insert remaining required stage-specific bits */ |
| switch (shader_stage) |
| { |
| case Utils::SHADER_STAGE_FRAGMENT: |
| { |
| result_sstream << "out vec4 result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " result = vec4(1, 2, 3, 4);\n" |
| "}\n"; |
| |
| break; |
| } |
| |
| case Utils::SHADER_STAGE_GEOMETRY: |
| { |
| result_sstream << "void main()\n" |
| "{\n" |
| " gl_Position = vec4(1, 2, 3, 4);\n" |
| " EmitVertex();\n" |
| "}\n"; |
| |
| break; |
| } |
| |
| case Utils::SHADER_STAGE_TESSELLATION_CONTROL: |
| { |
| result_sstream << "void main()\n" |
| "{\n" |
| " gl_TessLevelInner[0] = 1;\n" |
| " gl_TessLevelInner[1] = 1;\n" |
| " gl_TessLevelOuter[0] = 1;\n" |
| " gl_TessLevelOuter[1] = 1;\n" |
| " gl_TessLevelOuter[2] = 1;\n" |
| " gl_TessLevelOuter[3] = 1;\n" |
| " gl_out[gl_InvocationID].gl_Position = vec4(2, 3, 4, 5);\n" |
| "}\n"; |
| |
| break; |
| } |
| |
| case Utils::SHADER_STAGE_TESSELLATION_EVALUATION: |
| case Utils::SHADER_STAGE_VERTEX: |
| { |
| result_sstream << "void main()\n" |
| "{\n" |
| " gl_Position = vec4(1, 2, 3, 4);\n" |
| "}\n"; |
| |
| break; |
| } |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized shader stage"); |
| } |
| } /* switch (shader_stage) */ |
| |
| return result_sstream.str(); |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult NegativeTest4::iterate() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* Iterate over all shader stages.. */ |
| for (int shader_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST); |
| shader_stage != static_cast<int>(Utils::SHADER_STAGE_COUNT); ++shader_stage) |
| { |
| /* For each shader stage, we will be trying to compile a number of invalid shaders. |
| * Each shader defines N different subroutine types. (N-1) of them are compatible |
| * with a subroutine, but exactly 1 will be mismatched. The test passes if GLSL |
| * compiler correctly detects that all shaders we will be trying to compile are |
| * broken. |
| */ |
| const glw::GLenum shader_type = Utils::getGLenumForShaderStage(static_cast<Utils::_shader_stage>(shader_stage)); |
| |
| for (unsigned int n_subroutine_types = 1; n_subroutine_types < 6; /* arbitrary number */ |
| ++n_subroutine_types) |
| { |
| for (int test_case = static_cast<int>(TEST_CASE_FIRST); test_case != static_cast<int>(TEST_CASE_COUNT); |
| ++test_case) |
| { |
| std::string body; |
| const char* body_raw_ptr = NULL; |
| glw::GLint compile_status = GL_FALSE; |
| |
| body = getShaderBody(static_cast<Utils::_shader_stage>(shader_stage), n_subroutine_types, |
| static_cast<_test_case>(test_case)); |
| body_raw_ptr = body.c_str(); |
| |
| /* Try to compile the shader */ |
| m_so_id = gl.createShader(shader_type); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed"); |
| |
| gl.shaderSource(m_so_id, 1 /* count */, &body_raw_ptr, DE_NULL); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed"); |
| |
| gl.compileShader(m_so_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed"); |
| |
| gl.getShaderiv(m_so_id, GL_COMPILE_STATUS, &compile_status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed."); |
| |
| if (compile_status == GL_TRUE) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "A malformed " |
| << Utils::getShaderStageString(static_cast<Utils::_shader_stage>(shader_stage)) |
| << " compiled successfully " |
| "(" |
| << n_subroutine_types << " subroutine types " |
| "were defined)." |
| << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| /* Release the object */ |
| gl.deleteShader(m_so_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteShader() call failed."); |
| } /* for (all test cases) */ |
| } /* for (a number of different subroutine type declarations) */ |
| } /* for (all shader stages) */ |
| |
| /* Done */ |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| * |
| **/ |
| NegativeTest5::NegativeTest5(deqp::Context& context) |
| : TestCase(context, "subroutine_uniform_wo_matching_subroutines", |
| "Verifies that a link- or compile-time error occurs when " |
| "trying to link a program with no subroutine for subroutine " |
| "uniform variable.") |
| , m_fs_id(0) |
| , m_gs_id(0) |
| , m_has_test_passed(true) |
| , m_po_id(0) |
| , m_tc_id(0) |
| , m_te_id(0) |
| , m_vs_id(0) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Deinitializes all GL objects that may have been created during test execution */ |
| void NegativeTest5::deinit() |
| { |
| deinitIteration(); |
| } |
| |
| /** Deinitializes all GL objects that may have been created during a single test |
| * iteration. |
| ***/ |
| void NegativeTest5::deinitIteration() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_fs_id != 0) |
| { |
| gl.deleteShader(m_fs_id); |
| |
| m_fs_id = 0; |
| } |
| |
| if (m_gs_id != 0) |
| { |
| gl.deleteShader(m_gs_id); |
| |
| m_gs_id = 0; |
| } |
| |
| if (m_po_id != 0) |
| { |
| gl.deleteProgram(m_po_id); |
| |
| m_po_id = 0; |
| } |
| |
| if (m_tc_id != 0) |
| { |
| gl.deleteShader(m_tc_id); |
| |
| m_tc_id = 0; |
| } |
| |
| if (m_te_id != 0) |
| { |
| gl.deleteShader(m_te_id); |
| |
| m_te_id = 0; |
| } |
| |
| if (m_vs_id != 0) |
| { |
| gl.deleteShader(m_vs_id); |
| |
| m_vs_id = 0; |
| } |
| } |
| |
| /** Executes a single test iteration. |
| * |
| * If the iteration fails, m_has_test_passed will be set to false. |
| * |
| * @param shader_stage Shader stage, for which a subroutine uniform should be |
| * declared in the shader without a matching subroutine. |
| **/ |
| void NegativeTest5::executeIteration(const Utils::_shader_stage& shader_stage) |
| { |
| std::string fs_body = getFragmentShaderBody(shader_stage == Utils::SHADER_STAGE_FRAGMENT); |
| std::string gs_body = getGeometryShaderBody(shader_stage == Utils::SHADER_STAGE_GEOMETRY); |
| std::string tc_body = getTessellationControlShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_CONTROL); |
| std::string te_body = |
| getTessellationEvaluationShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_EVALUATION); |
| std::string vs_body = getVertexShaderBody(shader_stage == Utils::SHADER_STAGE_VERTEX); |
| |
| if (Utils::buildProgram(m_context.getRenderContext().getFunctions(), vs_body, tc_body, te_body, gs_body, fs_body, |
| DE_NULL, /* xfb_varyings */ |
| DE_NULL, /* n_xfb_varyings */ |
| &m_vs_id, &m_tc_id, &m_te_id, &m_gs_id, &m_fs_id, &m_po_id)) |
| { |
| /* None of the test programs should ever build successfully */ |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "A program object, consisting of the following shaders, has linked" |
| " correctly. One of the shaders defines a subroutine uniform but does " |
| "not implement any function that matches subroutine type of the uniform." |
| " This should have resulted in a compilation/link-time error.\n" |
| "\n" |
| "Vertex shader:\n" |
| "\n" |
| << vs_body << "\n" |
| "Tessellation control shader:\n" |
| "\n" |
| << tc_body << "\n" |
| "Tessellation evaluation shader:\n" |
| "\n" |
| << te_body << "\n" |
| "Geometry shader:\n" |
| "\n" |
| << gs_body << "\n" |
| "Fragment shader:\n" |
| "\n" |
| << fs_body << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| } |
| |
| /** Retrieves fragment shader body. |
| * |
| * @param include_invalid_subroutine_uniform_declaration true if the shader should declare |
| * a subroutine uniform without |
| * a matching subroutine, false otherwise. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest5::getFragmentShaderBody(bool include_invalid_subroutine_uniform_declaration) const |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n"; |
| |
| if (include_invalid_subroutine_uniform_declaration) |
| { |
| result_sstream << "subroutine void subroutineTestTypeFS(out vec4 test);\n" |
| "\n" |
| "subroutine uniform subroutineTestTypeFS test_subroutineFS;\n"; |
| }; |
| |
| result_sstream << "\n" |
| "out vec4 result;\n" |
| "\n" |
| "void main()\n" |
| "{\n"; |
| |
| if (include_invalid_subroutine_uniform_declaration) |
| { |
| result_sstream << " test_subroutineFS(result);\n"; |
| } |
| else |
| { |
| result_sstream << " result = vec4(0, 1, 2, 3);\n"; |
| } |
| |
| result_sstream << "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves geometry shader body. |
| * |
| * @param include_invalid_subroutine_uniform_declaration true if the shader should declare |
| * a subroutine uniform without |
| * a matching subroutine, false otherwise. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest5::getGeometryShaderBody(bool include_invalid_subroutine_uniform_declaration) const |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout (points) in;\n" |
| "layout (points, max_vertices = 1) out;\n" |
| "\n"; |
| |
| if (include_invalid_subroutine_uniform_declaration) |
| { |
| result_sstream << "subroutine void subroutineTestTypeGS(out vec4 test);\n" |
| "\n" |
| "subroutine uniform subroutineTestTypeGS test_subroutineGS;\n"; |
| }; |
| |
| result_sstream << "\n" |
| "void main()\n" |
| "{\n"; |
| |
| if (include_invalid_subroutine_uniform_declaration) |
| { |
| result_sstream << " test_subroutineGS(gl_Position);\n"; |
| } |
| else |
| { |
| result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; |
| } |
| |
| result_sstream << "EmitVertex();\n" |
| "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves tessellation control shader body. |
| * |
| * @param include_invalid_subroutine_uniform_declaration true if the shader should declare |
| * a subroutine uniform without |
| * a matching subroutine, false otherwise. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest5::getTessellationControlShaderBody(bool include_invalid_subroutine_uniform_declaration) const |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout (vertices = 4) out;\n" |
| "\n"; |
| |
| if (include_invalid_subroutine_uniform_declaration) |
| { |
| result_sstream << "subroutine void subroutineTestTypeTC(out vec4 test);\n" |
| "\n" |
| "subroutine uniform subroutineTestTypeTC test_subroutineTC;\n"; |
| }; |
| |
| result_sstream << "\n" |
| "void main()\n" |
| "{\n"; |
| |
| if (include_invalid_subroutine_uniform_declaration) |
| { |
| result_sstream << " test_subroutineTC(gl_out[gl_InvocationID].gl_Position);\n"; |
| } |
| else |
| { |
| result_sstream << " gl_out[gl_InvocationID].gl_Position = vec4(0, 1, 2, 3);\n"; |
| } |
| |
| result_sstream << "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves tessellation evaluation body. |
| * |
| * @param include_invalid_subroutine_uniform_declaration true if the shader should declare |
| * a subroutine uniform without |
| * a matching subroutine, false otherwise. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest5::getTessellationEvaluationShaderBody( |
| bool include_invalid_subroutine_uniform_declaration) const |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout (quads) in;\n" |
| "\n"; |
| |
| if (include_invalid_subroutine_uniform_declaration) |
| { |
| result_sstream << "subroutine void subroutineTestTypeTE(out vec4 test);\n" |
| "\n" |
| "subroutine uniform subroutineTestTypeTE test_subroutineTE;\n"; |
| }; |
| |
| result_sstream << "\n" |
| "void main()\n" |
| "{\n"; |
| |
| if (include_invalid_subroutine_uniform_declaration) |
| { |
| result_sstream << " test_subroutineTE(gl_Position);\n"; |
| } |
| else |
| { |
| result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; |
| } |
| |
| result_sstream << "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves vertex shader body. |
| * |
| * @param include_invalid_subroutine_uniform_declaration true if the shader should declare |
| * a subroutine uniform without |
| * a matching subroutine, false otherwise. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest5::getVertexShaderBody(bool include_invalid_subroutine_uniform_declaration) const |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n"; |
| |
| if (include_invalid_subroutine_uniform_declaration) |
| { |
| result_sstream << "subroutine void subroutineTestTypeVS(out vec4 test);\n" |
| "\n" |
| "subroutine uniform subroutineTestTypeVS test_subroutineVS;\n"; |
| }; |
| |
| result_sstream << "\n" |
| "void main()\n" |
| "{\n"; |
| |
| if (include_invalid_subroutine_uniform_declaration) |
| { |
| result_sstream << " test_subroutineVS(gl_Position);\n"; |
| } |
| else |
| { |
| result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; |
| } |
| |
| result_sstream << "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult NegativeTest5::iterate() |
| { |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* Iterate over all shader stages. Iteration-specific shader stage defines a subroutine type & |
| * a corresponding subroutine uniform, for which no compatible subroutines are available. All |
| * other shader stages are defined correctly. |
| */ |
| for (int shader_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST); |
| shader_stage < static_cast<int>(Utils::SHADER_STAGE_COUNT); ++shader_stage) |
| { |
| executeIteration(static_cast<Utils::_shader_stage>(shader_stage)); |
| deinitIteration(); |
| } /* for (all shader stages) */ |
| |
| /* All done */ |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| * |
| **/ |
| NegativeTest6::NegativeTest6(deqp::Context& context) |
| : TestCase(context, "two_duplicate_functions_one_being_a_subroutine", |
| "Verifies that a link- or compile-time error occurs if any shader in " |
| "a program object includes two functions with the same name and one " |
| "of which is associated with a subroutine type.") |
| , m_fs_id(0) |
| , m_gs_id(0) |
| , m_has_test_passed(true) |
| , m_po_id(0) |
| , m_tc_id(0) |
| , m_te_id(0) |
| , m_vs_id(0) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Deinitializes all GL objects that may have been created during test execution */ |
| void NegativeTest6::deinit() |
| { |
| deinitIteration(); |
| } |
| |
| /** Deinitializes all GL objects that may have been created during a single test |
| * iteration. |
| ***/ |
| void NegativeTest6::deinitIteration() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_fs_id != 0) |
| { |
| gl.deleteShader(m_fs_id); |
| |
| m_fs_id = 0; |
| } |
| |
| if (m_gs_id != 0) |
| { |
| gl.deleteShader(m_gs_id); |
| |
| m_gs_id = 0; |
| } |
| |
| if (m_po_id != 0) |
| { |
| gl.deleteProgram(m_po_id); |
| |
| m_po_id = 0; |
| } |
| |
| if (m_tc_id != 0) |
| { |
| gl.deleteShader(m_tc_id); |
| |
| m_tc_id = 0; |
| } |
| |
| if (m_te_id != 0) |
| { |
| gl.deleteShader(m_te_id); |
| |
| m_te_id = 0; |
| } |
| |
| if (m_vs_id != 0) |
| { |
| gl.deleteShader(m_vs_id); |
| |
| m_vs_id = 0; |
| } |
| } |
| |
| /** Executes a single test iteration. |
| * |
| * If the iteration fails, m_has_test_passed will be set to false. |
| * |
| * @param shader_stage Shader stage, for which two duplicate functions |
| * (one additionally marked as subroutine) should |
| * be defined. |
| **/ |
| void NegativeTest6::executeIteration(const Utils::_shader_stage& shader_stage) |
| { |
| std::string fs_body = getFragmentShaderBody(shader_stage == Utils::SHADER_STAGE_FRAGMENT); |
| std::string gs_body = getGeometryShaderBody(shader_stage == Utils::SHADER_STAGE_GEOMETRY); |
| std::string tc_body = getTessellationControlShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_CONTROL); |
| std::string te_body = |
| getTessellationEvaluationShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_EVALUATION); |
| std::string vs_body = getVertexShaderBody(shader_stage == Utils::SHADER_STAGE_VERTEX); |
| |
| if (Utils::buildProgram(m_context.getRenderContext().getFunctions(), vs_body, tc_body, te_body, gs_body, fs_body, |
| DE_NULL, /* xfb_varyings */ |
| DE_NULL, /* n_xfb_varyings */ |
| &m_vs_id, &m_tc_id, &m_te_id, &m_gs_id, &m_fs_id, &m_po_id)) |
| { |
| /* None of the test programs should ever build successfully */ |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "A program object, consisting of the following shaders, has linked" |
| " correctly. This is invalid, because one of the shaders defines two" |
| " functions with the same name, with an exception that one of the" |
| " functions is marked as a subroutine.\n" |
| "\n" |
| "Vertex shader:\n" |
| "\n" |
| << vs_body << "\n" |
| "Tessellation control shader:\n" |
| "\n" |
| << tc_body << "\n" |
| "Tessellation evaluation shader:\n" |
| "\n" |
| << te_body << "\n" |
| "Geometry shader:\n" |
| "\n" |
| << gs_body << "\n" |
| "Fragment shader:\n" |
| "\n" |
| << fs_body << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| } |
| |
| /** Retrieves fragment shader body. |
| * |
| * @param include_invalid_declaration true if the shader should include duplicate function |
| * declaration. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest6::getFragmentShaderBody(bool include_invalid_declaration) const |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << "subroutine void subroutineTestTypeFS(out vec4 test);\n" |
| "\n" |
| "subroutine(subroutineTestTypeFS) void test_impl1(out vec4 test)\n" |
| "{\n" |
| " test = vec4(1, 2, 3, 4);\n" |
| "}\n" |
| "\n" |
| "void test_impl1(out vec4 test)\n" |
| "{\n" |
| " test = vec4(2, 3, 4, 5);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineTestTypeFS test_subroutineFS;\n"; |
| }; |
| |
| result_sstream << "\n" |
| "out vec4 result;\n" |
| "\n" |
| "void main()\n" |
| "{\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << " test_subroutineFS(result);\n"; |
| } |
| else |
| { |
| result_sstream << " result = vec4(0, 1, 2, 3);\n"; |
| } |
| |
| result_sstream << "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves geometry shader body. |
| * |
| * @param include_invalid_declaration true if the shader should include duplicate function |
| * declaration. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest6::getGeometryShaderBody(bool include_invalid_declaration) const |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout (points) in;\n" |
| "layout (points, max_vertices = 1) out;\n" |
| "\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << "subroutine void subroutineTestTypeGS(out vec4 test);\n" |
| "\n" |
| "subroutine(subroutineTestTypeGS) void test_impl1(out vec4 test)\n" |
| "{\n" |
| " test = vec4(1, 2, 3, 4);\n" |
| "}\n" |
| "\n" |
| "void test_impl1(out vec4 test)\n" |
| "{\n" |
| " test = vec4(2, 3, 4, 5);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineTestTypeGS test_subroutineGS;\n"; |
| }; |
| |
| result_sstream << "\n" |
| "void main()\n" |
| "{\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << " test_subroutineGS(gl_Position);\n"; |
| } |
| else |
| { |
| result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; |
| } |
| |
| result_sstream << "EmitVertex();\n" |
| "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves tessellation control shader body. |
| * |
| * @param include_invalid_declaration true if the shader should include duplicate function |
| * declaration. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest6::getTessellationControlShaderBody(bool include_invalid_declaration) const |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout (vertices = 4) out;\n" |
| "\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << "subroutine void subroutineTestTypeTC(out vec4 test);\n" |
| "\n" |
| "subroutine(subroutineTestTypeTC) void test_impl1(out vec4 test)\n" |
| "{\n" |
| " test = vec4(1, 2, 3, 4);\n" |
| "}\n" |
| "\n" |
| "void test_impl1(out vec4 test)\n" |
| "{\n" |
| " test = vec4(2, 3, 4, 5);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineTestTypeTC test_subroutineTC;\n"; |
| }; |
| |
| result_sstream << "\n" |
| "void main()\n" |
| "{\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << " test_subroutineTC(gl_out[gl_InvocationID].gl_Position);\n"; |
| } |
| else |
| { |
| result_sstream << " gl_out[gl_InvocationID].gl_Position = vec4(0, 1, 2, 3);\n"; |
| } |
| |
| result_sstream << "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves tessellation evaluation body. |
| * |
| * @param include_invalid_declaration true if the shader should include duplicate function |
| * declaration. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest6::getTessellationEvaluationShaderBody(bool include_invalid_declaration) const |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout (quads) in;\n" |
| "\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << "subroutine void subroutineTestTypeTE(out vec4 test);\n" |
| "\n" |
| "subroutine(subroutineTestTypeTE) void test_impl1(out vec4 test)\n" |
| "{\n" |
| " test = vec4(1, 2, 3, 4);\n" |
| "}\n" |
| "\n" |
| "void test_impl1(out vec4 test)\n" |
| "{\n" |
| " test = vec4(2, 3, 4, 5);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineTestTypeTE test_subroutineTE;\n"; |
| }; |
| |
| result_sstream << "\n" |
| "void main()\n" |
| "{\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << " test_subroutineTE(gl_Position);\n"; |
| } |
| else |
| { |
| result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; |
| } |
| |
| result_sstream << "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves vertex shader body. |
| * |
| * @param include_invalid_declaration true if the shader should include duplicate function |
| * declaration. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest6::getVertexShaderBody(bool include_invalid_declaration) const |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << "subroutine void subroutineTestTypeVS(out vec4 test);\n" |
| "\n" |
| "subroutine(subroutineTestTypeVS) void test_impl1(out vec4 test)\n" |
| "{\n" |
| " test = vec4(1, 2, 3, 4);\n" |
| "}\n" |
| "\n" |
| "void test_impl1(out vec4 test)\n" |
| "{\n" |
| " test = vec4(2, 3, 4, 5);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineTestTypeVS test_subroutineVS;\n"; |
| }; |
| |
| result_sstream << "\n" |
| "void main()\n" |
| "{\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << " test_subroutineVS(gl_Position);\n"; |
| } |
| else |
| { |
| result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; |
| } |
| |
| result_sstream << "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult NegativeTest6::iterate() |
| { |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* Iterate over all shader stages. In each iteration, we will inject invalid |
| * duplicate function declarations to iteration-specific shader stage. All other |
| * shader stages will be assigned valid bodies. Test should fail if the program |
| * links successfully. |
| */ |
| for (int shader_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST); |
| shader_stage < static_cast<int>(Utils::SHADER_STAGE_COUNT); ++shader_stage) |
| { |
| executeIteration(static_cast<Utils::_shader_stage>(shader_stage)); |
| deinitIteration(); |
| } /* for (all shader stages) */ |
| |
| /* All done */ |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Constructor |
| * |
| * @param context CTS context |
| **/ |
| NegativeTest7::NegativeTest7(deqp::Context& context) |
| : TestCase(context, "recursion", "Verify that it is not possible to build program with recursing subroutines") |
| , m_program_id(0) |
| , m_vertex_shader_id(0) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Deinitializes all GL objects that may have been created during test execution |
| * |
| **/ |
| void NegativeTest7::deinit() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_program_id != 0) |
| { |
| gl.deleteProgram(m_program_id); |
| |
| m_program_id = 0; |
| } |
| |
| if (m_vertex_shader_id != 0) |
| { |
| gl.deleteShader(m_vertex_shader_id); |
| |
| m_vertex_shader_id = 0; |
| } |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| **/ |
| tcu::TestNode::IterateResult NegativeTest7::iterate() |
| { |
| static const GLchar* vertex_shader_with_static_recursion = |
| "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "subroutine vec4 routine_type(in vec4 data, in uint control);\n" |
| "\n" |
| "subroutine (routine_type) vec4 power_routine(in vec4 data, in uint control)\n" |
| "{\n" |
| " if (0 != control)\n" |
| " {\n" |
| " return data * power_routine(data, control - 1);\n" |
| " }\n" |
| " else\n" |
| " {\n" |
| " return vec4(1, 1, 1, 1);\n" |
| " }\n" |
| "}\n" |
| "\n" |
| "subroutine (routine_type) vec4 select_routine(in vec4 data, in uint control)\n" |
| "{\n" |
| " if (0 == control)\n" |
| " {\n" |
| " return data.rrrr;\n" |
| " }\n" |
| " else if (1 == control)\n" |
| " {\n" |
| " return data.gggg;\n" |
| " }\n" |
| " else if (2 == control)\n" |
| " {\n" |
| " return data.bbbb;\n" |
| " }\n" |
| " else\n" |
| " {\n" |
| " return data.aaaa;\n" |
| " }\n" |
| "}\n" |
| "\n" |
| "subroutine uniform routine_type routine;\n" |
| "\n" |
| "uniform vec4 uni_value;\n" |
| "uniform uint uni_control;\n" |
| "\n" |
| "out vec4 out_result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " out_result = routine(uni_value, uni_control);\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* vertex_shader_with_dynamic_recursion = |
| "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "subroutine vec4 routine_type(in vec4 data);\n" |
| "\n" |
| "subroutine uniform routine_type routine;\n" |
| "\n" |
| "subroutine (routine_type) vec4 div_by_2(in vec4 data)\n" |
| "{\n" |
| " return data / 2;\n" |
| "}\n" |
| "\n" |
| "subroutine (routine_type) vec4 div_routine_result_by_2(in vec4 data)\n" |
| "{\n" |
| " return routine(data) / 2;\n" |
| "}\n" |
| "\n" |
| "uniform vec4 uni_value;\n" |
| "\n" |
| "out vec4 out_result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " out_result = routine(uni_value);\n" |
| "}\n" |
| "\n"; |
| |
| static const GLchar* vertex_shader_with_subroutine_function_recursion = |
| "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "subroutine vec4 routine_type(in vec4 data);\n" |
| "\n" |
| "subroutine uniform routine_type routine;\n" |
| "\n" |
| "vec4 function(in vec4 data)\n" |
| "{\n" |
| " return routine(data) + vec4(0.5, 0.5, 0.5, 0.5);\n" |
| "}\n" |
| "\n" |
| "subroutine (routine_type) vec4 routine_a(in vec4 data)\n" |
| "{\n" |
| " return function(data) / 2;\n" |
| "}\n" |
| "\n" |
| "subroutine (routine_type) vec4 routine_b(in vec4 data)\n" |
| "{\n" |
| " return routine_a(data) * 2;\n" |
| "}\n" |
| "\n" |
| "uniform vec4 uni_value;\n" |
| "\n" |
| "out vec4 out_result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " out_result = routine(uni_value);\n" |
| "}\n" |
| "\n"; |
| |
| bool result = true; |
| |
| if (false == test(vertex_shader_with_subroutine_function_recursion, "routine_a")) |
| { |
| result = false; |
| } |
| |
| if (false == test(vertex_shader_with_dynamic_recursion, "div_routine_result_by_2")) |
| { |
| result = false; |
| } |
| |
| if (false == test(vertex_shader_with_static_recursion, "power_routine")) |
| { |
| result = false; |
| } |
| |
| /* Set result */ |
| if (true == result) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| /* Done */ |
| return tcu::TestNode::STOP; |
| } |
| |
| /** Try to build program from vertex shader code. |
| * |
| * @param vertex_shader_code Source code of vertex shader |
| * @param name_of_recursive_routine Name of subroutine that should cause link failure due to recursion |
| * |
| * @return true build process failed, false otherwise |
| **/ |
| bool NegativeTest7::test(const GLchar* vertex_shader_code, const GLchar* name_of_recursive_routine) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| bool result = true; |
| static const GLchar* varying_name = "out_result"; |
| |
| /* Try to build program */ |
| if (true == Utils::buildProgram(gl, vertex_shader_code, "", "", "", "", &varying_name /* varying_names */, |
| 1 /* n_varyings */, &m_vertex_shader_id, 0, 0, 0, 0, &m_program_id)) |
| { |
| /* Success is considered an error */ |
| |
| Utils::program program(m_context); |
| GLuint index = 0; |
| |
| program.build(0, 0, 0, 0, 0, vertex_shader_code, 0, 0); |
| |
| /* Verify that recursive subroutine is active */ |
| try |
| { |
| index = program.getSubroutineIndex(name_of_recursive_routine, GL_VERTEX_SHADER); |
| } |
| catch (const std::exception& exc) |
| { |
| /* Something wrong with shader or compilation */ |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "It is expected that subroutine: \n" |
| << name_of_recursive_routine |
| << " is considered active. This subroutine is potentially recursive and should cause link failure." |
| << tcu::TestLog::EndMessage; |
| |
| throw exc; |
| } |
| |
| /* Subsoutine is active, however linking should fail */ |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "Error. Program with potentially recursive subroutine, " |
| << name_of_recursive_routine << ", which is active, index: " << index << ", has been built successfully.\n" |
| << vertex_shader_code << tcu::TestLog::EndMessage; |
| |
| result = false; |
| } |
| |
| /* Delete program and shader */ |
| deinit(); |
| |
| /* Done */ |
| return result; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| * |
| **/ |
| NegativeTest8::NegativeTest8(deqp::Context& context) |
| : TestCase(context, "subroutine_wo_body", "Verifies that a compile- or link-time error occurs if a function " |
| "declared as a subroutine does not include a body.") |
| , m_fs_id(0) |
| , m_gs_id(0) |
| , m_has_test_passed(true) |
| , m_po_id(0) |
| , m_tc_id(0) |
| , m_te_id(0) |
| , m_vs_id(0) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Deinitializes all GL objects that may have been created during test execution */ |
| void NegativeTest8::deinit() |
| { |
| deinitIteration(); |
| } |
| |
| /** Deinitializes all GL objects that may have been created during a single test |
| * iteration. |
| ***/ |
| void NegativeTest8::deinitIteration() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_fs_id != 0) |
| { |
| gl.deleteShader(m_fs_id); |
| |
| m_fs_id = 0; |
| } |
| |
| if (m_gs_id != 0) |
| { |
| gl.deleteShader(m_gs_id); |
| |
| m_gs_id = 0; |
| } |
| |
| if (m_po_id != 0) |
| { |
| gl.deleteProgram(m_po_id); |
| |
| m_po_id = 0; |
| } |
| |
| if (m_tc_id != 0) |
| { |
| gl.deleteShader(m_tc_id); |
| |
| m_tc_id = 0; |
| } |
| |
| if (m_te_id != 0) |
| { |
| gl.deleteShader(m_te_id); |
| |
| m_te_id = 0; |
| } |
| |
| if (m_vs_id != 0) |
| { |
| gl.deleteShader(m_vs_id); |
| |
| m_vs_id = 0; |
| } |
| } |
| |
| /** Executes a single test iteration. |
| * |
| * If the iteration fails, m_has_test_passed will be set to false. |
| * |
| * @param shader_stage Shader stage, for which two duplicate functions |
| * (one additionally marked as subroutine) should |
| * be defined. |
| **/ |
| void NegativeTest8::executeIteration(const Utils::_shader_stage& shader_stage) |
| { |
| std::string fs_body = getFragmentShaderBody(shader_stage == Utils::SHADER_STAGE_FRAGMENT); |
| std::string gs_body = getGeometryShaderBody(shader_stage == Utils::SHADER_STAGE_GEOMETRY); |
| std::string tc_body = getTessellationControlShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_CONTROL); |
| std::string te_body = |
| getTessellationEvaluationShaderBody(shader_stage == Utils::SHADER_STAGE_TESSELLATION_EVALUATION); |
| std::string vs_body = getVertexShaderBody(shader_stage == Utils::SHADER_STAGE_VERTEX); |
| |
| if (Utils::buildProgram(m_context.getRenderContext().getFunctions(), vs_body, tc_body, te_body, gs_body, fs_body, |
| DE_NULL, /* xfb_varyings */ |
| DE_NULL, /* n_xfb_varyings */ |
| &m_vs_id, &m_tc_id, &m_te_id, &m_gs_id, &m_fs_id, &m_po_id)) |
| { |
| /* None of the test programs should ever build successfully */ |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "A program object consisting of FS+GS+TC+TE+VS stages has linked successfully, " |
| "even though one of the shaders only defines a subroutine that lacks any body." |
| "\n" |
| "Vertex shader:\n" |
| "\n" |
| << vs_body << "\n" |
| "Tessellation control shader:\n" |
| "\n" |
| << tc_body << "\n" |
| "Tessellation evaluation shader:\n" |
| "\n" |
| << te_body << "\n" |
| "Geometry shader:\n" |
| "\n" |
| << gs_body << "\n" |
| "Fragment shader:\n" |
| "\n" |
| << fs_body << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| } |
| |
| /** Retrieves fragment shader body. |
| * |
| * @param include_invalid_declaration true if a subroutine prototype should be included in |
| * the shader, false to skip it. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest8::getFragmentShaderBody(bool include_invalid_declaration) const |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << "subroutine void subroutineTestTypeFS(out vec4 test);\n" |
| "\n" |
| "subroutine(subroutineTestTypeFS) void test_impl1(out vec4 test);\n" |
| "\n" |
| "subroutine uniform subroutineTestTypeFS test_subroutineFS;\n"; |
| }; |
| |
| result_sstream << "\n" |
| "out vec4 result;\n" |
| "\n" |
| "void main()\n" |
| "{\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << " test_subroutineFS(result);\n"; |
| } |
| else |
| { |
| result_sstream << " result = vec4(0, 1, 2, 3);\n"; |
| } |
| |
| result_sstream << "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves geometry shader body. |
| * |
| * @param include_invalid_declaration true if a subroutine prototype should be included in |
| * the shader, false to skip it. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest8::getGeometryShaderBody(bool include_invalid_declaration) const |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout (points) in;\n" |
| "layout (points, max_vertices = 1) out;\n" |
| "\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << "subroutine void subroutineTestTypeGS(out vec4 test);\n" |
| "\n" |
| "subroutine(subroutineTestTypeGS) void test_impl1(out vec4 test);\n" |
| "\n" |
| "subroutine uniform subroutineTestTypeGS test_subroutineGS;\n"; |
| }; |
| |
| result_sstream << "\n" |
| "void main()\n" |
| "{\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << " test_subroutineGS(gl_Position);\n"; |
| } |
| else |
| { |
| result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; |
| } |
| |
| result_sstream << "EmitVertex();\n" |
| "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves tessellation control shader body. |
| * |
| * @param include_invalid_declaration true if a subroutine prototype should be included in |
| * the shader, false to skip it. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest8::getTessellationControlShaderBody(bool include_invalid_declaration) const |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout (vertices = 4) out;\n" |
| "\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << "subroutine void subroutineTestTypeTC(out vec4 test);\n" |
| "\n" |
| "subroutine(subroutineTestTypeTC) void test_impl1(out vec4 test);\n" |
| "\n" |
| "subroutine uniform subroutineTestTypeTC test_subroutineTC;\n"; |
| }; |
| |
| result_sstream << "\n" |
| "void main()\n" |
| "{\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << " test_subroutineTC(gl_out[gl_InvocationID].gl_Position);\n"; |
| } |
| else |
| { |
| result_sstream << " gl_out[gl_InvocationID].gl_Position = vec4(0, 1, 2, 3);\n"; |
| } |
| |
| result_sstream << "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves tessellation evaluation body. |
| * |
| * @param include_invalid_declaration true if a subroutine prototype should be included in |
| * the shader, false to skip it. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest8::getTessellationEvaluationShaderBody(bool include_invalid_declaration) const |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout (quads) in;\n" |
| "\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << "subroutine void subroutineTestTypeTE(out vec4 test);\n" |
| "\n" |
| "subroutine(subroutineTestTypeTE) void test_impl1(out vec4 test);\n" |
| "\n" |
| "subroutine uniform subroutineTestTypeTE test_subroutineTE;\n"; |
| }; |
| |
| result_sstream << "\n" |
| "void main()\n" |
| "{\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << " test_subroutineTE(gl_Position);\n"; |
| } |
| else |
| { |
| result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; |
| } |
| |
| result_sstream << "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves vertex shader body. |
| * |
| * @param include_invalid_declaration true if a subroutine prototype should be included in |
| * the shader, false to skip it. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest8::getVertexShaderBody(bool include_invalid_declaration) const |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << "subroutine void subroutineTestTypeVS(out vec4 test);\n" |
| "\n" |
| "subroutine(subroutineTestTypeVS) void test_impl1(out vec4 test);\n" |
| "\n" |
| "subroutine uniform subroutineTestTypeVS test_subroutineVS;\n"; |
| }; |
| |
| result_sstream << "\n" |
| "void main()\n" |
| "{\n"; |
| |
| if (include_invalid_declaration) |
| { |
| result_sstream << " test_subroutineVS(gl_Position);\n"; |
| } |
| else |
| { |
| result_sstream << " gl_Position = vec4(0, 1, 2, 3);\n"; |
| } |
| |
| result_sstream << "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult NegativeTest8::iterate() |
| { |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* Iterate over all shader stages. For each iteration, iteration-specific shader stage |
| * will feature an invalid subroutine definition. Other shader stages will be assigned |
| * valid bodies. The test fails if a program built of such shaders links successfully. |
| */ |
| for (int shader_stage = static_cast<int>(Utils::SHADER_STAGE_FIRST); |
| shader_stage < static_cast<int>(Utils::SHADER_STAGE_COUNT); ++shader_stage) |
| { |
| executeIteration(static_cast<Utils::_shader_stage>(shader_stage)); |
| deinitIteration(); |
| } /* for (all shader stages) */ |
| |
| /* All done */ |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| **/ |
| NegativeTest9::NegativeTest9(deqp::Context& context) |
| : TestCase(context, "subroutines_cannot_be_assigned_float_int_values_or_be_compared", |
| "Make sure it is not possible to assign float/int to subroutine " |
| "uniform and that subroutine uniform values cannot be compared.") |
| , m_has_test_passed(true) |
| , m_po_id(0) |
| , m_vs_id(0) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Deinitializes any GL objects that may have been created during |
| * test execution. |
| **/ |
| void NegativeTest9::deinit() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_po_id != 0) |
| { |
| gl.deleteProgram(m_po_id); |
| |
| m_po_id = 0; |
| } |
| |
| if (m_vs_id != 0) |
| { |
| gl.deleteShader(m_vs_id); |
| |
| m_vs_id = 0; |
| } |
| } |
| |
| /** Returns a literal corresponding to user-specified test case enum. |
| * |
| * @param test_case As per description. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest9::getTestCaseString(const _test_case& test_case) |
| { |
| std::string result = "?"; |
| |
| switch (test_case) |
| { |
| case TEST_CASE_INVALID_FLOAT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT: |
| result = "TEST_CASE_INVALID_FLOAT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT"; |
| break; |
| case TEST_CASE_INVALID_INT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT: |
| result = "TEST_CASE_INVALID_INT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT"; |
| break; |
| case TEST_CASE_INVALID_SUBROUTINE_UNIFORM_VALUE_COMPARISON: |
| result = "TEST_CASE_INVALID_SUBROUTINE_UNIFORM_VALUE_COMPARISON"; |
| break; |
| default: |
| break; |
| } |
| |
| return result; |
| } |
| |
| /** Retrieves vertex shader body for user-specified test case. |
| * |
| * @param test_case As per description. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest9::getVertexShader(const _test_case& test_case) |
| { |
| std::stringstream result_sstream; |
| |
| /* Form pre-amble */ |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| /* Define a subroutine */ |
| "subroutine void subroutineType(inout vec4 test);\n" |
| "\n" |
| "subroutine(subroutineType) void test_function(inout vec4 test)\n" |
| "{\n" |
| " test += vec4(0, 1, 2, 3);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineType function;\n" |
| "\n"; |
| |
| /* Include case-specific implementation */ |
| switch (test_case) |
| { |
| case TEST_CASE_INVALID_FLOAT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT: |
| { |
| result_sstream << "void main()\n" |
| "{\n" |
| " function = 1.0f;\n" |
| "\n" |
| " function(gl_Position);\n" |
| "}\n"; |
| |
| break; |
| } |
| |
| case TEST_CASE_INVALID_INT_TO_SUBROUTINE_UNIFORM_ASSIGNMENT: |
| { |
| result_sstream << "void main()\n" |
| "{\n" |
| " function = 1;\n" |
| "\n" |
| " function(gl_Position);\n" |
| "}\n"; |
| |
| break; |
| } |
| |
| case TEST_CASE_INVALID_SUBROUTINE_UNIFORM_VALUE_COMPARISON: |
| { |
| result_sstream << "subroutine uniform subroutineType function2;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " if (function == function2)\n" |
| " {\n" |
| " function(gl_Position);\n" |
| " }\n" |
| " else\n" |
| " {\n" |
| " function2(gl_Position);\n" |
| " }\n" |
| "}\n"; |
| |
| break; |
| } |
| |
| default: |
| break; |
| } /* switch (test_case) */ |
| |
| /* Done */ |
| return result_sstream.str(); |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult NegativeTest9::iterate() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* Iterate over all test cases */ |
| for (int test_case = static_cast<int>(TEST_CASE_FIRST); test_case != static_cast<int>(TEST_CASE_COUNT); ++test_case) |
| { |
| /* Try to build a program object using invalid vertex shader, specific to the |
| * iteration we're currently in */ |
| std::string vs_body = getVertexShader(static_cast<_test_case>(test_case)); |
| |
| if (ShaderSubroutine::Utils::buildProgram(gl, vs_body, "", /* tc_body */ |
| "", /* te_body */ |
| "", /* gs_body */ |
| "", /* fs_body */ |
| DE_NULL, /* xfb_varyings */ |
| 0, /* n_xfb_varyings */ |
| &m_vs_id, DE_NULL, /* out_tc_id */ |
| DE_NULL, /* out_te_id */ |
| DE_NULL, /* out_gs_id */ |
| DE_NULL, /* out_fs_id */ |
| &m_po_id)) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "A program object was successfully built for [" |
| << getTestCaseString(static_cast<_test_case>(test_case)) |
| << "] test case, even though it was invalid." << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| /* Delete any objects that may have been created */ |
| deinit(); |
| } /* for (all test cases) */ |
| |
| /** All done */ |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| **/ |
| NegativeTest10::NegativeTest10(deqp::Context& context) |
| : TestCase(context, "function_overloading_forbidden_for_subroutines", |
| "Check that an overloaded function cannot be declared with subroutine and " |
| "a program will fail to compile or link if any shader or stage contains" |
| " two or more functions with the same name if the name is associated with" |
| " a subroutine type.") |
| , m_has_test_passed(true) |
| , m_fs_id(0) |
| , m_gs_id(0) |
| , m_po_id(0) |
| , m_tc_id(0) |
| , m_te_id(0) |
| , m_vs_id(0) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Deinitializes any GL objects that may have been created during |
| * test execution. |
| **/ |
| void NegativeTest10::deinit() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_fs_id != 0) |
| { |
| gl.deleteShader(m_fs_id); |
| |
| m_fs_id = 0; |
| } |
| |
| if (m_gs_id != 0) |
| { |
| gl.deleteShader(m_gs_id); |
| |
| m_gs_id = 0; |
| } |
| |
| if (m_po_id != 0) |
| { |
| gl.deleteProgram(m_po_id); |
| |
| m_po_id = 0; |
| } |
| |
| if (m_tc_id != 0) |
| { |
| gl.deleteShader(m_tc_id); |
| |
| m_tc_id = 0; |
| } |
| |
| if (m_te_id != 0) |
| { |
| gl.deleteShader(m_te_id); |
| |
| m_te_id = 0; |
| } |
| |
| if (m_vs_id != 0) |
| { |
| gl.deleteShader(m_vs_id); |
| |
| m_vs_id = 0; |
| } |
| } |
| |
| /** Retrieves fragment shader that should be used for the purpose of the test. |
| * An overloaded version of a subroutine function is inserted if |
| * @param include_duplicate_function flag is set to true. |
| * |
| * @param include_duplicate_function As per description. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest10::getFragmentShader(bool include_duplicate_function) |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "subroutine void subroutineType(inout vec4 test);\n" |
| "\n" |
| "subroutine(subroutineType) void test_function(inout vec4 test)\n" |
| "{\n" |
| " test = vec4(2, 3, 4, 5);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineType function;\n" |
| "out vec4 result;\n" |
| "\n"; |
| |
| if (include_duplicate_function) |
| { |
| result_sstream << "void test_function(inout vec4 test)\n" |
| "{\n" |
| " test = vec4(3, 4, 5, 6);\n" |
| "}\n" |
| "\n"; |
| } |
| |
| result_sstream << "void main()\n" |
| "{\n" |
| " test_function(result);\n" |
| "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves geometry shader that should be used for the purpose of the test. |
| * An overloaded version of a subroutine function is inserted if |
| * @param include_duplicate_function flag is set to true. |
| * |
| * @param include_duplicate_function As per description. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest10::getGeometryShader(bool include_duplicate_function) |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout (triangles) in;\n" |
| "layout (triangle_strip, max_vertices = 4) out;\n" |
| "\n" |
| "subroutine void subroutineType(inout vec4 test);\n" |
| "\n" |
| "subroutine(subroutineType) void test_function(inout vec4 test)\n" |
| "{\n" |
| " test = vec4(2, 3, 4, 5);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineType function;\n" |
| "\n"; |
| |
| if (include_duplicate_function) |
| { |
| result_sstream << "void test_function(inout vec4 test)\n" |
| "{\n" |
| " test = vec4(3, 4, 5, 6);\n" |
| "}\n" |
| "\n"; |
| } |
| |
| result_sstream << "void main()\n" |
| "{\n" |
| " function(gl_Position);\n" |
| " EmitVertex();\n" |
| " EndPrimitive();\n" |
| "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves tess control shader that should be used for the purpose of the test. |
| * An overloaded version of a subroutine function is inserted if |
| * @param include_duplicate_function flag is set to true. |
| * |
| * @param include_duplicate_function As per description. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest10::getTessellationControlShader(bool include_duplicate_function) |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout (vertices = 4) out;\n" |
| "\n" |
| "subroutine void subroutineType(inout vec4 test);\n" |
| "\n" |
| "subroutine(subroutineType) void test_function(inout vec4 test)\n" |
| "{\n" |
| " test = vec4(2, 3, 4, 5);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineType function;\n" |
| "\n"; |
| |
| if (include_duplicate_function) |
| { |
| result_sstream << "void test_function(inout vec4 test)\n" |
| "{\n" |
| " test = vec4(3, 4, 5, 6);\n" |
| "}\n" |
| "\n"; |
| } |
| |
| result_sstream << "void main()\n" |
| "{\n" |
| " vec4 temp;\n" |
| "\n" |
| " function(temp);\n" |
| "\n" |
| " gl_out[gl_InvocationID].gl_Position = temp;\n" |
| " gl_TessLevelInner[0] = temp.x;\n" |
| " gl_TessLevelInner[1] = temp.y;\n" |
| " gl_TessLevelOuter[0] = temp.z;\n" |
| " gl_TessLevelOuter[1] = temp.w;\n" |
| " gl_TessLevelOuter[2] = temp.x;\n" |
| " gl_TessLevelOuter[3] = temp.y;\n" |
| "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves tess evaluation shader that should be used for the purpose of the test. |
| * An overloaded version of a subroutine function is inserted if |
| * @param include_duplicate_function flag is set to true. |
| * |
| * @param include_duplicate_function As per description. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest10::getTessellationEvaluationShader(bool include_duplicate_function) |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "layout (quads) in;\n" |
| "\n" |
| "subroutine void subroutineType(inout vec4 test);\n" |
| "\n" |
| "subroutine(subroutineType) void test_function(inout vec4 test)\n" |
| "{\n" |
| " test = vec4(2, 3, 4, 5);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineType function;\n" |
| "\n"; |
| |
| if (include_duplicate_function) |
| { |
| result_sstream << "void test_function(inout vec4 test)\n" |
| "{\n" |
| " test = vec4(3, 4, 5, 6);\n" |
| "}\n" |
| "\n"; |
| } |
| |
| result_sstream << "void main()\n" |
| "{\n" |
| " vec4 temp;\n" |
| "\n" |
| " function(temp);\n" |
| "\n" |
| " gl_Position = temp;\n" |
| "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Retrieves vertex shader that should be used for the purpose of the test. |
| * An overloaded version of a subroutine function is inserted if |
| * @param include_duplicate_function flag is set to true. |
| * |
| * @param include_duplicate_function As per description. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest10::getVertexShader(bool include_duplicate_function) |
| { |
| std::stringstream result_sstream; |
| |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| "subroutine void subroutineType(inout vec4 test);\n" |
| "\n" |
| "subroutine(subroutineType) void test_function(inout vec4 test)\n" |
| "{\n" |
| " test = vec4(2, 3, 4, 5);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineType function;\n" |
| "\n"; |
| |
| if (include_duplicate_function) |
| { |
| result_sstream << "void test_function(inout vec4 test)\n" |
| "{\n" |
| " test = vec4(3, 4, 5, 6);\n" |
| "}\n" |
| "\n"; |
| } |
| |
| result_sstream << "void main()\n" |
| "{\n" |
| " function(gl_Position);\n" |
| "}\n"; |
| |
| return result_sstream.str(); |
| } |
| |
| /** Fills m_test_cases field with test case descriptors */ |
| void NegativeTest10::initTestCases() |
| { |
| /* For each test case, only one shader stage should define a function that |
| * has already been defined as a subroutine. */ |
| for (int offending_shader_stage_it = static_cast<int>(Utils::SHADER_STAGE_FIRST); |
| offending_shader_stage_it != static_cast<int>(Utils::SHADER_STAGE_COUNT); ++offending_shader_stage_it) |
| { |
| Utils::_shader_stage offending_shader_stage = static_cast<Utils::_shader_stage>(offending_shader_stage_it); |
| /* Form the test case descriptor */ |
| std::stringstream name_sstream; |
| _test_case test_case; |
| |
| name_sstream << "Broken shader stage:" << Utils::getShaderStageString(offending_shader_stage); |
| |
| test_case.fs_body = getFragmentShader(offending_shader_stage == Utils::SHADER_STAGE_FRAGMENT); |
| test_case.gs_body = getGeometryShader(offending_shader_stage == Utils::SHADER_STAGE_GEOMETRY); |
| test_case.name = name_sstream.str(); |
| test_case.tc_body = |
| getTessellationControlShader(offending_shader_stage == Utils::SHADER_STAGE_TESSELLATION_CONTROL); |
| test_case.te_body = |
| getTessellationEvaluationShader(offending_shader_stage == Utils::SHADER_STAGE_TESSELLATION_EVALUATION); |
| test_case.vs_body = getVertexShader(offending_shader_stage == Utils::SHADER_STAGE_VERTEX); |
| |
| m_test_cases.push_back(test_case); |
| } |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult NegativeTest10::iterate() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* Form test cases */ |
| initTestCases(); |
| |
| /* Iterate over all test cases */ |
| for (_test_cases_const_iterator test_case_iterator = m_test_cases.begin(); test_case_iterator != m_test_cases.end(); |
| ++test_case_iterator) |
| { |
| const _test_case& test_case = *test_case_iterator; |
| |
| /* Try to build the program object */ |
| if (ShaderSubroutine::Utils::buildProgram(gl, test_case.vs_body, test_case.tc_body, test_case.te_body, |
| test_case.gs_body, test_case.fs_body, DE_NULL, /* xfb_varyings */ |
| 0, /* n_xfb_varyings */ |
| &m_vs_id, (test_case.tc_body.length() > 0) ? &m_tc_id : DE_NULL, |
| (test_case.te_body.length() > 0) ? &m_te_id : DE_NULL, |
| (test_case.gs_body.length() > 0) ? &m_gs_id : DE_NULL, |
| (test_case.fs_body.length() > 0) ? &m_fs_id : DE_NULL, &m_po_id)) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "A program object was successfully built for [" |
| << test_case.name << "] test case, even though it was invalid." |
| << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| /* Delete any objects that may have been created */ |
| deinit(); |
| } /* for (all test cases) */ |
| |
| /** All done */ |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| **/ |
| NegativeTest11::NegativeTest11(deqp::Context& context) |
| : TestCase(context, "subroutine_uniforms_used_for_sampling_atomic_image_functions", |
| "Tries to use subroutine uniforms in invalid way in sampling, " |
| "atomic and image functions. Verifies that compile- or link-time " |
| "error occurs.") |
| , m_has_test_passed(true) |
| , m_po_id(0) |
| , m_vs_id(0) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Deinitializes any GL objects that may have been created during |
| * test execution. |
| **/ |
| void NegativeTest11::deinit() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_po_id != 0) |
| { |
| gl.deleteProgram(m_po_id); |
| |
| m_po_id = 0; |
| } |
| |
| if (m_vs_id != 0) |
| { |
| gl.deleteShader(m_vs_id); |
| |
| m_vs_id = 0; |
| } |
| } |
| |
| /** Returns a literal corresponding to user-specified test case enum. |
| * |
| * @param test_case As per description. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest11::getTestCaseString(const _test_case& test_case) |
| { |
| std::string result = "?"; |
| |
| switch (test_case) |
| { |
| case TEST_CASE_INVALID_TEXTURE_SAMPLING_ATTEMPT: |
| result = "TEST_CASE_INVALID_TEXTURE_SAMPLING_ATTEMPT"; |
| break; |
| case TEST_CASE_INVALID_ATOMIC_COUNTER_USAGE_ATTEMPT: |
| result = "TEST_CASE_INVALID_ATOMIC_COUNTER_USAGE_ATTEMPT"; |
| break; |
| case TEST_CASE_INVALID_IMAGE_FUNCTION_USAGE_ATTEMPT: |
| result = "TEST_CASE_INVALID_IMAGE_FUNCTION_USAGE_ATTEMPT"; |
| break; |
| default: |
| break; |
| } |
| |
| return result; |
| } |
| |
| /** Retrieves vertex shader body for user-specified test case. |
| * |
| * @param test_case As per description. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest11::getVertexShader(const _test_case& test_case) |
| { |
| std::stringstream result_sstream; |
| |
| /* Form pre-amble */ |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n"; |
| |
| if (test_case == TEST_CASE_INVALID_ATOMIC_COUNTER_USAGE_ATTEMPT) |
| { |
| result_sstream << "#extension GL_ARB_shader_atomic_counters : require\n"; |
| } |
| |
| result_sstream << "\n" |
| /* Define a subroutine */ |
| "subroutine void subroutineType(inout vec4 test);\n" |
| "\n" |
| "subroutine(subroutineType) void test_function(inout vec4 test)\n" |
| "{\n" |
| " test += vec4(0, 1, 2, 3);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineType function;\n" |
| "\n" |
| |
| /* Define main() body */ |
| "void main()\n" |
| "{\n"; |
| |
| /* Implement case-specific behavior */ |
| switch (test_case) |
| { |
| case TEST_CASE_INVALID_ATOMIC_COUNTER_USAGE_ATTEMPT: |
| { |
| result_sstream << "if (atomicCounter(function) > 2)\n" |
| "{\n" |
| " gl_Position = vec4(1);\n" |
| "}\n"; |
| |
| break; |
| } |
| |
| case TEST_CASE_INVALID_IMAGE_FUNCTION_USAGE_ATTEMPT: |
| { |
| result_sstream << "imageStore(function, vec2(0.0, 1.0), vec4(1.0) );\n"; |
| |
| break; |
| } |
| |
| case TEST_CASE_INVALID_TEXTURE_SAMPLING_ATTEMPT: |
| { |
| result_sstream << "gl_Position = texture(function, vec2(1.0) );\n"; |
| |
| break; |
| } |
| |
| default: |
| break; |
| } /* switch (test_case) */ |
| |
| /* Close main() body */ |
| result_sstream << "}\n"; |
| |
| /* Done */ |
| return result_sstream.str(); |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult NegativeTest11::iterate() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* Iterate over all test cases */ |
| for (int test_case = static_cast<int>(TEST_CASE_FIRST); test_case != static_cast<int>(TEST_CASE_COUNT); ++test_case) |
| { |
| if (static_cast<_test_case>(test_case) == TEST_CASE_INVALID_ATOMIC_COUNTER_USAGE_ATTEMPT && |
| !m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_atomic_counters")) |
| { |
| /* This iteration requires atomic counter support that this GL implementation |
| * is not capable of. Skip the iteration |
| */ |
| continue; |
| } |
| |
| /* Try to build a program object using invalid vertex shader, specific to the |
| * iteration we're currently in */ |
| std::string vs_body = getVertexShader(static_cast<_test_case>(test_case)); |
| |
| if (ShaderSubroutine::Utils::buildProgram(gl, vs_body, "", /* tc_body */ |
| "", /* te_body */ |
| "", /* gs_body */ |
| "", /* fs_body */ |
| DE_NULL, /* xfb_varyings */ |
| 0, /* n_xfb_varyings */ |
| &m_vs_id, DE_NULL, /* out_tc_id */ |
| DE_NULL, /* out_te_id */ |
| DE_NULL, /* out_gs_id */ |
| DE_NULL, /* out_fs_id */ |
| &m_po_id)) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "A program object was successfully built for [" |
| << getTestCaseString(static_cast<_test_case>(test_case)) |
| << "] test case, even though it was invalid." << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| /* Delete any objects that may have been created */ |
| deinit(); |
| } /* for (all test cases) */ |
| |
| /** All done */ |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| **/ |
| NegativeTest12::NegativeTest12(deqp::Context& context) |
| : TestCase(context, "subroutines_not_allowed_as_variables_constructors_and_argument_or_return_types", |
| "Verifies that it is not allowed to use subroutine type for " |
| "local/global variables, constructors or argument/return type.") |
| , m_has_test_passed(true) |
| , m_po_id(0) |
| , m_vs_id(0) |
| { |
| /* Left blank intentionally */ |
| } |
| |
| /** Deinitializes any GL objects that may have been created during |
| * test execution. |
| **/ |
| void NegativeTest12::deinit() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| if (m_po_id != 0) |
| { |
| gl.deleteProgram(m_po_id); |
| |
| m_po_id = 0; |
| } |
| |
| if (m_vs_id != 0) |
| { |
| gl.deleteShader(m_vs_id); |
| |
| m_vs_id = 0; |
| } |
| } |
| |
| /** Returns a literal corresponding to user-specified test case enum. |
| * |
| * @param test_case As per description. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest12::getTestCaseString(const _test_case& test_case) |
| { |
| std::string result = "?"; |
| |
| switch (test_case) |
| { |
| case TEST_CASE_INVALID_LOCAL_SUBROUTINE_VARIABLE: |
| result = "TEST_CASE_INVALID_LOCAL_SUBROUTINE_VARIABLE"; |
| break; |
| case TEST_CASE_INVALID_GLOBAL_SUBROUTINE_VARIABLE: |
| result = "TEST_CASE_INVALID_GLOBAL_SUBROUTINE_VARIABLE"; |
| break; |
| case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR: |
| result = "TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR"; |
| break; |
| case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_ARGUMENT: |
| result = "TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_ARGUMENT"; |
| break; |
| case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_RETURN_TYPE: |
| result = "TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_RETURN_TYPE"; |
| break; |
| default: |
| break; |
| } |
| |
| return result; |
| } |
| |
| /** Retrieves vertex shader body for user-specified test case. |
| * |
| * @param test_case As per description. |
| * |
| * @return Requested string. |
| **/ |
| std::string NegativeTest12::getVertexShader(const _test_case& test_case) |
| { |
| std::stringstream result_sstream; |
| |
| /* Form pre-amble */ |
| result_sstream << "#version 400\n" |
| "\n" |
| "#extension GL_ARB_shader_subroutine : require\n" |
| "\n" |
| /* Define a subroutine */ |
| "subroutine void subroutineType(inout vec4 test);\n" |
| "\n" |
| "subroutine(subroutineType) void test_function(inout vec4 test)\n" |
| "{\n" |
| " test += vec4(0, 1, 2, 3);\n" |
| "}\n" |
| "\n" |
| "subroutine uniform subroutineType function;\n" |
| "\n"; |
| |
| /* Include case-specific implementation */ |
| switch (test_case) |
| { |
| case TEST_CASE_INVALID_LOCAL_SUBROUTINE_VARIABLE: |
| { |
| result_sstream << "void main()\n" |
| "{\n" |
| " subroutine subroutineType function2;\n" |
| " vec4 result;\n" |
| "\n" |
| " function2(result);\n" |
| " gl_Position = result;\n" |
| "}\n"; |
| |
| break; |
| } |
| |
| case TEST_CASE_INVALID_GLOBAL_SUBROUTINE_VARIABLE: |
| { |
| result_sstream << "subroutine subroutineType function2;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " vec4 result;\n" |
| "\n" |
| " function2(result);\n" |
| " gl_Position = result;\n" |
| "}\n"; |
| |
| break; |
| } |
| |
| case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR: |
| { |
| result_sstream << "void main()\n" |
| "{\n" |
| " subroutineType(function);\n" |
| "}\n"; |
| |
| break; |
| } |
| |
| case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_ARGUMENT: |
| { |
| result_sstream << "vec4 test_function(subroutineType argument)\n" |
| "{\n" |
| " vec4 result = vec4(1, 2, 3, 4);\n" |
| "\n" |
| " argument(result);\n" |
| "\n" |
| " return result;\n" |
| "}\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " test_function(function);\n" |
| "}\n"; |
| |
| break; |
| } |
| |
| case TEST_CASE_SUBROUTINE_USED_AS_CONSTRUCTOR_RETURN_TYPE: |
| { |
| result_sstream << "subroutineType test_function()\n" |
| "{\n" |
| " return function;\n" |
| "}\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " test_function()(gl_Position);\n" |
| "}\n"; |
| |
| break; |
| } |
| |
| default: |
| break; |
| } /* switch (test_case) */ |
| |
| /* Done */ |
| return result_sstream.str(); |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult NegativeTest12::iterate() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Do not execute the test if GL_ARB_shader_subroutine is not supported */ |
| if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_subroutine")) |
| { |
| throw tcu::NotSupportedError("GL_ARB_shader_subroutine is not supported."); |
| } |
| |
| /* Iterate over all test cases */ |
| for (int test_case = static_cast<int>(TEST_CASE_FIRST); test_case != static_cast<int>(TEST_CASE_COUNT); ++test_case) |
| { |
| /* Try to build a program object using invalid vertex shader, specific to the |
| * iteration we're currently in */ |
| std::string vs_body = getVertexShader(static_cast<_test_case>(test_case)); |
| |
| if (ShaderSubroutine::Utils::buildProgram(gl, vs_body, "", /* tc_body */ |
| "", /* te_body */ |
| "", /* gs_body */ |
| "", /* fs_body */ |
| DE_NULL, /* xfb_varyings */ |
| 0, /* n_xfb_varyings */ |
| &m_vs_id, DE_NULL, /* out_tc_id */ |
| DE_NULL, /* out_te_id */ |
| DE_NULL, /* out_gs_id */ |
| DE_NULL, /* out_fs_id */ |
| &m_po_id)) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "A program object was successfully built for [" |
| << getTestCaseString(static_cast<_test_case>(test_case)) |
| << "] test case, even though it was invalid." << tcu::TestLog::EndMessage; |
| |
| m_has_test_passed = false; |
| } |
| |
| /* Delete any objects that may have been created */ |
| deinit(); |
| } /* for (all test cases) */ |
| |
| /** All done */ |
| if (m_has_test_passed) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| return STOP; |
| } |
| |
| } /* ShaderSubroutine */ |
| |
| /** Constructor. |
| * |
| * @param context Rendering context. |
| **/ |
| ShaderSubroutineTests::ShaderSubroutineTests(deqp::Context& context) |
| : TestCaseGroup(context, "shader_subroutine", "Verifies \"shader_subroutine\" functionality") |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Initializes a texture_storage_multisample test group. |
| * |
| **/ |
| void ShaderSubroutineTests::init(void) |
| { |
| addChild(new ShaderSubroutine::APITest1(m_context)); |
| addChild(new ShaderSubroutine::APITest2(m_context)); |
| addChild(new ShaderSubroutine::FunctionalTest1_2(m_context)); |
| addChild(new ShaderSubroutine::FunctionalTest3_4(m_context)); |
| addChild(new ShaderSubroutine::FunctionalTest5(m_context)); |
| addChild(new ShaderSubroutine::FunctionalTest6(m_context)); |
| addChild(new ShaderSubroutine::FunctionalTest7_8(m_context)); |
| addChild(new ShaderSubroutine::FunctionalTest9(m_context)); |
| addChild(new ShaderSubroutine::FunctionalTest10(m_context)); |
| addChild(new ShaderSubroutine::FunctionalTest11(m_context)); |
| addChild(new ShaderSubroutine::FunctionalTest12(m_context)); |
| addChild(new ShaderSubroutine::FunctionalTest13(m_context)); |
| addChild(new ShaderSubroutine::FunctionalTest14_15(m_context)); |
| addChild(new ShaderSubroutine::FunctionalTest16(m_context)); |
| addChild(new ShaderSubroutine::FunctionalTest17(m_context)); |
| addChild(new ShaderSubroutine::FunctionalTest18_19(m_context)); |
| addChild(new ShaderSubroutine::NegativeTest1(m_context)); |
| addChild(new ShaderSubroutine::NegativeTest2(m_context)); |
| addChild(new ShaderSubroutine::NegativeTest3(m_context)); |
| addChild(new ShaderSubroutine::NegativeTest4(m_context)); |
| addChild(new ShaderSubroutine::NegativeTest5(m_context)); |
| addChild(new ShaderSubroutine::NegativeTest6(m_context)); |
| addChild(new ShaderSubroutine::NegativeTest7(m_context)); |
| addChild(new ShaderSubroutine::NegativeTest8(m_context)); |
| addChild(new ShaderSubroutine::NegativeTest9(m_context)); |
| addChild(new ShaderSubroutine::NegativeTest10(m_context)); |
| addChild(new ShaderSubroutine::NegativeTest11(m_context)); |
| addChild(new ShaderSubroutine::NegativeTest12(m_context)); |
| } |
| |
| } /* glcts namespace */ |