| /*------------------------------------------------------------------------- |
| * 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 |
| */ /*-------------------------------------------------------------------*/ |
| |
| #include "gl4cShaderImageSizeTests.hpp" |
| #include "gluContextInfo.hpp" |
| #include "glwEnums.hpp" |
| #include "tcuMatrix.hpp" |
| #include "tcuRenderTarget.hpp" |
| #include "tcuVectorUtil.hpp" |
| #include <assert.h> |
| #include <cstdarg> |
| |
| namespace gl4cts |
| { |
| using namespace glw; |
| |
| namespace |
| { |
| typedef tcu::Vec3 vec3; |
| typedef tcu::Vec4 vec4; |
| typedef tcu::IVec4 ivec4; |
| typedef tcu::UVec4 uvec4; |
| |
| class ShaderImageSizeBase : public deqp::SubcaseBase |
| { |
| virtual std::string Title() |
| { |
| return ""; |
| } |
| |
| virtual std::string Purpose() |
| { |
| return ""; |
| } |
| |
| virtual std::string Method() |
| { |
| return ""; |
| } |
| |
| virtual std::string PassCriteria() |
| { |
| return ""; |
| } |
| |
| public: |
| bool SupportedInVS(int requiredVS) |
| { |
| GLint imagesVS; |
| glGetIntegerv(GL_MAX_VERTEX_IMAGE_UNIFORMS, &imagesVS); |
| if (imagesVS >= requiredVS) |
| return true; |
| else |
| { |
| std::ostringstream reason; |
| reason << "Required " << requiredVS << " VS image uniforms but only " << imagesVS << " available." |
| << std::endl; |
| OutputNotSupported(reason.str()); |
| return false; |
| } |
| } |
| |
| bool SupportedInTCS(int requiredTCS) |
| { |
| GLint imagesTCS; |
| glGetIntegerv(GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS, &imagesTCS); |
| if (imagesTCS >= requiredTCS) |
| return true; |
| else |
| { |
| std::ostringstream reason; |
| reason << "Required " << requiredTCS << " TCS image uniforms but only " << imagesTCS << " available." |
| << std::endl; |
| OutputNotSupported(reason.str()); |
| return false; |
| } |
| } |
| |
| bool SupportedInTES(int requiredTES) |
| { |
| GLint imagesTES; |
| glGetIntegerv(GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS, &imagesTES); |
| if (imagesTES >= requiredTES) |
| return true; |
| else |
| { |
| std::ostringstream reason; |
| reason << "Required " << requiredTES << " TES image uniforms but only " << imagesTES << " available." |
| << std::endl; |
| OutputNotSupported(reason.str()); |
| return false; |
| } |
| } |
| |
| bool SupportedInGS(int requiredGS) |
| { |
| GLint imagesGS; |
| glGetIntegerv(GL_MAX_GEOMETRY_IMAGE_UNIFORMS, &imagesGS); |
| if (imagesGS >= requiredGS) |
| return true; |
| else |
| { |
| std::ostringstream reason; |
| reason << "Required " << requiredGS << " GS image uniforms but only " << imagesGS << " available." |
| << std::endl; |
| OutputNotSupported(reason.str()); |
| return false; |
| } |
| } |
| |
| bool SupportedInStage(int stage, int required) |
| { |
| switch (stage) |
| { |
| case 0: |
| return SupportedInVS(required); |
| case 1: |
| return SupportedInTCS(required); |
| case 2: |
| return SupportedInTES(required); |
| case 3: |
| return SupportedInGS(required); |
| default: |
| return true; |
| } |
| } |
| |
| bool SupportedSamples(int required) |
| { |
| int i; |
| glGetIntegerv(GL_MAX_IMAGE_SAMPLES, &i); |
| if (i >= required) |
| return true; |
| else |
| { |
| std::ostringstream reason; |
| reason << "Required " << required << " image samples but only " << i << " available." << std::endl; |
| OutputNotSupported(reason.str()); |
| return false; |
| } |
| } |
| |
| int getWindowWidth() |
| { |
| const tcu::RenderTarget& renderTarget = m_context.getRenderContext().getRenderTarget(); |
| return renderTarget.getWidth(); |
| } |
| |
| int getWindowHeight() |
| { |
| const tcu::RenderTarget& renderTarget = m_context.getRenderContext().getRenderTarget(); |
| return renderTarget.getHeight(); |
| } |
| |
| inline bool ColorEqual(const vec4& c0, const vec4& c1, const vec4& epsilon) |
| { |
| if (fabs(c0[0] - c1[0]) > epsilon[0]) |
| return false; |
| if (fabs(c0[1] - c1[1]) > epsilon[1]) |
| return false; |
| if (fabs(c0[2] - c1[2]) > epsilon[2]) |
| return false; |
| if (fabs(c0[3] - c1[3]) > epsilon[3]) |
| return false; |
| return true; |
| } |
| |
| template <class T> |
| std::string ToString(T v) |
| { |
| std::ostringstream s; |
| s << "["; |
| for (int i = 0; i < 4; ++i) |
| s << v[i] << (i == 3 ? "" : ","); |
| s << "]"; |
| return s.str(); |
| } |
| |
| bool ValidateReadBuffer(int x, int y, int w, int h, const vec4& expected) |
| { |
| bool status = true; |
| const tcu::RenderTarget& renderTarget = m_context.getRenderContext().getRenderTarget(); |
| const tcu::PixelFormat& pixelFormat = renderTarget.getPixelFormat(); |
| vec4 g_color_eps = vec4( |
| 1.f / static_cast<float>(1 << pixelFormat.redBits), 1.f / static_cast<float>(1 << pixelFormat.greenBits), |
| 1.f / static_cast<float>(1 << pixelFormat.blueBits), 1.f / static_cast<float>(1 << pixelFormat.alphaBits)); |
| |
| std::vector<vec4> fb(w * h); |
| glReadPixels(x, y, w, h, GL_RGBA, GL_FLOAT, &fb[0]); |
| |
| for (int yy = 0; yy < h; ++yy) |
| { |
| for (int xx = 0; xx < w; ++xx) |
| { |
| const int idx = yy * w + xx; |
| if (!ColorEqual(fb[idx], expected, g_color_eps)) |
| { |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "First bad color: " << ToString(fb[idx]) |
| << tcu::TestLog::EndMessage; |
| status = false; |
| return status; |
| } |
| } |
| } |
| return status; |
| } |
| |
| bool CheckProgram(GLuint program) |
| { |
| if (program == 0) |
| return true; |
| GLint status; |
| glGetProgramiv(program, GL_LINK_STATUS, &status); |
| |
| if (status == GL_FALSE) |
| { |
| GLint attached_shaders; |
| glGetProgramiv(program, GL_ATTACHED_SHADERS, &attached_shaders); |
| |
| if (attached_shaders > 0) |
| { |
| std::vector<GLuint> shaders(attached_shaders); |
| glGetAttachedShaders(program, attached_shaders, NULL, &shaders[0]); |
| |
| for (GLint i = 0; i < attached_shaders; ++i) |
| { |
| GLenum type; |
| glGetShaderiv(shaders[i], GL_SHADER_TYPE, reinterpret_cast<GLint*>(&type)); |
| switch (type) |
| { |
| case GL_VERTEX_SHADER: |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "*** Vertex Shader ***" << tcu::TestLog::EndMessage; |
| break; |
| case GL_TESS_CONTROL_SHADER: |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "*** Tessellation Control Shader ***" |
| << tcu::TestLog::EndMessage; |
| break; |
| case GL_TESS_EVALUATION_SHADER: |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "*** Tessellation Evaluation Shader ***" |
| << tcu::TestLog::EndMessage; |
| break; |
| case GL_GEOMETRY_SHADER: |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "*** Geometry Shader ***" << tcu::TestLog::EndMessage; |
| break; |
| case GL_FRAGMENT_SHADER: |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "*** Fragment Shader ***" << tcu::TestLog::EndMessage; |
| break; |
| case GL_COMPUTE_SHADER: |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "*** Compute Shader ***" << tcu::TestLog::EndMessage; |
| break; |
| default: |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "*** Unknown Shader ***" << tcu::TestLog::EndMessage; |
| break; |
| } |
| GLint length; |
| glGetShaderiv(shaders[i], GL_SHADER_SOURCE_LENGTH, &length); |
| if (length > 0) |
| { |
| std::vector<GLchar> source(length); |
| glGetShaderSource(shaders[i], length, NULL, &source[0]); |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << &source[0] << tcu::TestLog::EndMessage; |
| } |
| glGetShaderiv(shaders[i], GL_INFO_LOG_LENGTH, &length); |
| if (length > 0) |
| { |
| std::vector<GLchar> log(length); |
| glGetShaderInfoLog(shaders[i], length, NULL, &log[0]); |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << &log[0] << tcu::TestLog::EndMessage; |
| } |
| } |
| } |
| GLint length; |
| glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length); |
| if (length > 0) |
| { |
| std::vector<GLchar> log(length); |
| glGetProgramInfoLog(program, length, NULL, &log[0]); |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << &log[0] << tcu::TestLog::EndMessage; |
| } |
| } |
| return status == GL_TRUE ? true : false; |
| } |
| }; |
| |
| template <typename T> |
| std::string ImageTypePrefix(); |
| |
| template <> |
| std::string ImageTypePrefix<vec4>() |
| { |
| return ""; |
| } |
| |
| template <> |
| std::string ImageTypePrefix<ivec4>() |
| { |
| return "i"; |
| } |
| |
| template <> |
| std::string ImageTypePrefix<uvec4>() |
| { |
| return "u"; |
| } |
| |
| template <typename T> |
| std::string ImageFormatPostfix(); |
| |
| template <> |
| std::string ImageFormatPostfix<vec4>() |
| { |
| return "f"; |
| } |
| |
| template <> |
| std::string ImageFormatPostfix<ivec4>() |
| { |
| return "i"; |
| } |
| |
| template <> |
| std::string ImageFormatPostfix<uvec4>() |
| { |
| return "ui"; |
| } |
| |
| template <typename T> |
| GLenum TexInternalFormat(); |
| |
| template <> |
| GLenum TexInternalFormat<vec4>() |
| { |
| return GL_RGBA32F; |
| } |
| |
| template <> |
| GLenum TexInternalFormat<ivec4>() |
| { |
| return GL_RGBA32I; |
| } |
| |
| template <> |
| GLenum TexInternalFormat<uvec4>() |
| { |
| return GL_RGBA32UI; |
| } |
| |
| template <typename T> |
| GLenum TexType(); |
| |
| template <> |
| GLenum TexType<vec4>() |
| { |
| return GL_FLOAT; |
| } |
| |
| template <> |
| GLenum TexType<ivec4>() |
| { |
| return GL_INT; |
| } |
| |
| template <> |
| GLenum TexType<uvec4>() |
| { |
| return GL_UNSIGNED_INT; |
| } |
| |
| template <typename T> |
| GLenum TexFormat(); |
| |
| template <> |
| GLenum TexFormat<vec4>() |
| { |
| return GL_RGBA; |
| } |
| |
| template <> |
| GLenum TexFormat<ivec4>() |
| { |
| return GL_RGBA_INTEGER; |
| } |
| |
| template <> |
| GLenum TexFormat<uvec4>() |
| { |
| return GL_RGBA_INTEGER; |
| } |
| //============================================================================= |
| // ImageSizeMachine |
| //----------------------------------------------------------------------------- |
| class ImageSizeMachine : public deqp::GLWrapper |
| { |
| GLuint m_pipeline; |
| GLuint m_program[3]; |
| GLuint m_vertex_array; |
| GLuint m_texture; |
| |
| template <typename T> |
| std::string GenShader(int stage, bool ms_and_1d, bool subroutine) |
| { |
| std::ostringstream os; |
| os << "#version 430 core"; |
| if (stage == 4) |
| { // CS |
| os << NL "#extension GL_ARB_compute_shader : require"; |
| } |
| os << NL "layout(binding = 0, rgba32i) writeonly uniform iimage2D g_result;"; |
| if (ms_and_1d == false) |
| { |
| os << NL "layout(binding = 1, rgba32" << ImageFormatPostfix<T>() << ") uniform " << ImageTypePrefix<T>() |
| << "image2D g_image_2d;" NL "layout(binding = 2, rgba32" << ImageFormatPostfix<T>() << ") uniform " |
| << ImageTypePrefix<T>() << "image3D g_image_3d;" NL "layout(binding = 3, rgba32" |
| << ImageFormatPostfix<T>() << ") uniform " << ImageTypePrefix<T>() |
| << "imageCube g_image_cube;" NL "layout(binding = 4, rgba32" << ImageFormatPostfix<T>() << ") uniform " |
| << ImageTypePrefix<T>() << "imageCubeArray g_image_cube_array;" NL "layout(binding = 5, rgba32" |
| << ImageFormatPostfix<T>() << ") uniform " << ImageTypePrefix<T>() |
| << "image2DRect g_image_rect;" NL "layout(binding = 6, rgba32" << ImageFormatPostfix<T>() << ") uniform " |
| << ImageTypePrefix<T>() << "image2DArray g_image_2d_array;" NL "layout(binding = 7, rgba32" |
| << ImageFormatPostfix<T>() << ") uniform " << ImageTypePrefix<T>() << "imageBuffer g_image_buffer;"; |
| } |
| else |
| { |
| os << NL "layout(binding = 1, rgba32" << ImageFormatPostfix<T>() << ") uniform " << ImageTypePrefix<T>() |
| << "image1D g_image_1d;" NL "layout(binding = 2, rgba32" << ImageFormatPostfix<T>() << ") uniform " |
| << ImageTypePrefix<T>() << "image1DArray g_image_1d_array;" NL "layout(binding = 3, rgba32" |
| << ImageFormatPostfix<T>() << ") uniform " << ImageTypePrefix<T>() |
| << "image2DMS g_image_2dms;" NL "layout(binding = 4, rgba32" << ImageFormatPostfix<T>() << ") uniform " |
| << ImageTypePrefix<T>() << "image2DMSArray g_image_2dms_array;"; |
| } |
| if (subroutine) |
| { |
| os << NL "subroutine void FuncType(int coord);" NL "subroutine uniform FuncType g_func;"; |
| } |
| if (stage == 0) |
| { // VS |
| os << NL "void main() {" NL " int coord = gl_VertexID;"; |
| } |
| else if (stage == 1) |
| { // TCS |
| os << NL "layout(vertices = 1) out;" NL "void main() {" NL " gl_TessLevelInner[0] = 1;" NL |
| " gl_TessLevelInner[1] = 1;" NL " gl_TessLevelOuter[0] = 1;" NL " gl_TessLevelOuter[1] = 1;" NL |
| " gl_TessLevelOuter[2] = 1;" NL " gl_TessLevelOuter[3] = 1;" NL " int coord = gl_PrimitiveID;"; |
| } |
| else if (stage == 2) |
| { // TES |
| os << NL "layout(quads, point_mode) in;" NL "void main() {" NL " int coord = gl_PrimitiveID;"; |
| } |
| else if (stage == 3) |
| { // GS |
| os << NL "layout(points) in;" NL "layout(points, max_vertices = 1) out;" NL "void main() {" NL |
| " int coord = gl_PrimitiveIDIn;"; |
| } |
| else if (stage == 4) |
| { // CS |
| os << NL "layout(local_size_x = 1) in;" NL "void main() {" NL " int coord = int(gl_GlobalInvocationID.x);"; |
| } |
| else if (stage == 5) |
| { // FS |
| os << NL "void main() {" NL " int coord = gl_PrimitiveID;"; |
| } |
| if (subroutine) |
| { |
| os << NL " g_func(coord);" NL "}" NL "subroutine(FuncType) void Func0(int coord) {"; |
| } |
| if (ms_and_1d == false) |
| { |
| os << NL " imageStore(g_result, ivec2(coord, 0), ivec4(imageSize(g_image_2d), 0, 0));" NL |
| " imageStore(g_result, ivec2(coord, 1), ivec4(imageSize(g_image_3d), 0));" NL |
| " imageStore(g_result, ivec2(coord, 2), ivec4(imageSize(g_image_cube), 0, 0));" NL |
| " imageStore(g_result, ivec2(coord, 3), ivec4(imageSize(g_image_cube_array), 0));" NL |
| " imageStore(g_result, ivec2(coord, 4), ivec4(imageSize(g_image_rect), 0, 0));" NL |
| " imageStore(g_result, ivec2(coord, 5), ivec4(imageSize(g_image_2d_array), 0));" NL |
| " imageStore(g_result, ivec2(coord, 6), ivec4(imageSize(g_image_buffer), 0, 0, 0));" NL "}"; |
| } |
| else |
| { |
| os << NL " imageStore(g_result, ivec2(coord, 0), ivec4(imageSize(g_image_1d), 0, 0, 0));" NL |
| " imageStore(g_result, ivec2(coord, 1), ivec4(imageSize(g_image_1d_array), 0, 0));" NL |
| " imageStore(g_result, ivec2(coord, 2), ivec4(imageSize(g_image_2dms), 0, 0));" NL |
| " imageStore(g_result, ivec2(coord, 3), ivec4(imageSize(g_image_2dms_array), 0));" NL |
| " imageStore(g_result, ivec2(coord, 4), ivec4(0));" NL |
| " imageStore(g_result, ivec2(coord, 5), ivec4(0));" NL |
| " imageStore(g_result, ivec2(coord, 6), ivec4(0));" NL "}"; |
| } |
| return os.str(); |
| } |
| |
| bool CheckProgram(GLuint program) |
| { |
| if (program == 0) |
| return true; |
| GLint status; |
| glGetProgramiv(program, GL_LINK_STATUS, &status); |
| |
| if (status == GL_FALSE) |
| { |
| GLint attached_shaders; |
| glGetProgramiv(program, GL_ATTACHED_SHADERS, &attached_shaders); |
| |
| if (attached_shaders > 0) |
| { |
| std::vector<GLuint> shaders(attached_shaders); |
| glGetAttachedShaders(program, attached_shaders, NULL, &shaders[0]); |
| |
| for (GLint i = 0; i < attached_shaders; ++i) |
| { |
| GLenum type; |
| glGetShaderiv(shaders[i], GL_SHADER_TYPE, reinterpret_cast<GLint*>(&type)); |
| switch (type) |
| { |
| case GL_VERTEX_SHADER: |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "*** Vertex Shader ***" << tcu::TestLog::EndMessage; |
| break; |
| case GL_TESS_CONTROL_SHADER: |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "*** Tessellation Control Shader ***" |
| << tcu::TestLog::EndMessage; |
| break; |
| case GL_TESS_EVALUATION_SHADER: |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "*** Tessellation Evaluation Shader ***" |
| << tcu::TestLog::EndMessage; |
| break; |
| case GL_GEOMETRY_SHADER: |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "*** Geometry Shader ***" << tcu::TestLog::EndMessage; |
| break; |
| case GL_FRAGMENT_SHADER: |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "*** Fragment Shader ***" << tcu::TestLog::EndMessage; |
| break; |
| case GL_COMPUTE_SHADER: |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "*** Compute Shader ***" << tcu::TestLog::EndMessage; |
| break; |
| default: |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "*** Unknown Shader ***" << tcu::TestLog::EndMessage; |
| break; |
| } |
| GLint length; |
| glGetShaderiv(shaders[i], GL_SHADER_SOURCE_LENGTH, &length); |
| if (length > 0) |
| { |
| std::vector<GLchar> source(length); |
| glGetShaderSource(shaders[i], length, NULL, &source[0]); |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << &source[0] << tcu::TestLog::EndMessage; |
| } |
| glGetShaderiv(shaders[i], GL_INFO_LOG_LENGTH, &length); |
| if (length > 0) |
| { |
| std::vector<GLchar> log(length); |
| glGetShaderInfoLog(shaders[i], length, NULL, &log[0]); |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << &log[0] << tcu::TestLog::EndMessage; |
| } |
| } |
| } |
| GLint length; |
| glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length); |
| if (length > 0) |
| { |
| std::vector<GLchar> log(length); |
| glGetProgramInfoLog(program, length, NULL, &log[0]); |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << &log[0] << tcu::TestLog::EndMessage; |
| } |
| } |
| return status == GL_TRUE ? true : false; |
| } |
| |
| public: |
| ImageSizeMachine() |
| { |
| glGenProgramPipelines(1, &m_pipeline); |
| memset(m_program, 0, sizeof(m_program)); |
| glGenVertexArrays(1, &m_vertex_array); |
| glGenTextures(1, &m_texture); |
| } |
| |
| ~ImageSizeMachine() |
| { |
| glDeleteProgramPipelines(1, &m_pipeline); |
| for (int i = 0; i < 3; ++i) |
| glDeleteProgram(m_program[i]); |
| glDeleteVertexArrays(1, &m_vertex_array); |
| glDeleteTextures(1, &m_texture); |
| } |
| |
| template <typename T> |
| long Run(int stage, bool ms_and_1d, ivec4 expected_result[7], bool subroutine = false) |
| { |
| if (stage == 0) |
| { // VS |
| std::string vs = GenShader<T>(stage, ms_and_1d, subroutine); |
| const char* const glsl_vs = vs.c_str(); |
| m_program[0] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &glsl_vs); |
| glUseProgramStages(m_pipeline, GL_VERTEX_SHADER_BIT, m_program[0]); |
| } |
| else if (stage == 1) |
| { // TCS |
| const char* const glsl_vs = "#version 430 core" NL "out gl_PerVertex { vec4 gl_Position; };" NL |
| "void main() { gl_Position = vec4(0.0, 0.0, 0.0, 1.0);}"; |
| const char* const glsl_tes = "#version 430 core" NL "layout(quads, point_mode) in;" NL "void main() {}"; |
| std::string tcs = GenShader<T>(stage, ms_and_1d, subroutine); |
| const char* const glsl_tcs = tcs.c_str(); |
| m_program[0] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &glsl_vs); |
| m_program[1] = glCreateShaderProgramv(GL_TESS_CONTROL_SHADER, 1, &glsl_tcs); |
| m_program[2] = glCreateShaderProgramv(GL_TESS_EVALUATION_SHADER, 1, &glsl_tes); |
| glUseProgramStages(m_pipeline, GL_VERTEX_SHADER_BIT, m_program[0]); |
| glUseProgramStages(m_pipeline, GL_TESS_CONTROL_SHADER_BIT, m_program[1]); |
| glUseProgramStages(m_pipeline, GL_TESS_EVALUATION_SHADER_BIT, m_program[2]); |
| } |
| else if (stage == 2) |
| { // TES |
| const char* const glsl_vs = "#version 430 core" NL "out gl_PerVertex { vec4 gl_Position; };" NL |
| "void main() { gl_Position = vec4(0.0, 0.0, 0.0, 1.0);}"; |
| std::string tes = GenShader<T>(stage, ms_and_1d, subroutine); |
| const char* const glsl_tes = tes.c_str(); |
| m_program[0] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &glsl_vs); |
| m_program[1] = glCreateShaderProgramv(GL_TESS_EVALUATION_SHADER, 1, &glsl_tes); |
| glUseProgramStages(m_pipeline, GL_VERTEX_SHADER_BIT, m_program[0]); |
| glUseProgramStages(m_pipeline, GL_TESS_EVALUATION_SHADER_BIT, m_program[1]); |
| } |
| else if (stage == 3) |
| { // GS |
| const char* const glsl_vs = "#version 430 core" NL "out gl_PerVertex { vec4 gl_Position; };" NL |
| "void main() { gl_Position = vec4(0.0, 0.0, 0.0, 1.0);}"; |
| std::string gs = GenShader<T>(stage, ms_and_1d, subroutine); |
| const char* const glsl_gs = gs.c_str(); |
| m_program[0] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &glsl_vs); |
| m_program[1] = glCreateShaderProgramv(GL_GEOMETRY_SHADER, 1, &glsl_gs); |
| glUseProgramStages(m_pipeline, GL_VERTEX_SHADER_BIT, m_program[0]); |
| glUseProgramStages(m_pipeline, GL_GEOMETRY_SHADER_BIT, m_program[1]); |
| } |
| else if (stage == 4) |
| { // CS |
| std::string cs = GenShader<T>(stage, ms_and_1d, subroutine); |
| const char* const glsl_cs = cs.c_str(); |
| m_program[0] = glCreateShaderProgramv(GL_COMPUTE_SHADER, 1, &glsl_cs); |
| glUseProgramStages(m_pipeline, GL_COMPUTE_SHADER_BIT, m_program[0]); |
| } |
| else if (stage == 5) |
| { // FS |
| const char* const glsl_vs = "#version 430 core" NL "out gl_PerVertex { vec4 gl_Position; };" NL |
| "void main() { gl_Position = vec4(0.0, 0.0, 0.0, 1.0);}"; |
| std::string fs = GenShader<T>(stage, ms_and_1d, subroutine); |
| const char* const glsl_fs = fs.c_str(); |
| m_program[0] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &glsl_vs); |
| m_program[1] = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &glsl_fs); |
| glUseProgramStages(m_pipeline, GL_VERTEX_SHADER_BIT, m_program[0]); |
| glUseProgramStages(m_pipeline, GL_FRAGMENT_SHADER_BIT, m_program[1]); |
| } |
| for (int i = 0; i < 3; ++i) |
| { |
| if (!CheckProgram(m_program[i])) |
| return ERROR; |
| } |
| |
| glBindTexture(GL_TEXTURE_2D, m_texture); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| { |
| ivec4 data[7]; |
| for (int i = 0; i < 7; ++i) |
| data[i] = ivec4(100000); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32I, 1, 7, 0, GL_RGBA_INTEGER, GL_INT, &data[0]); |
| } |
| glBindTexture(GL_TEXTURE_2D, 0); |
| |
| glBindImageTexture(0, m_texture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32I); |
| glBindProgramPipeline(m_pipeline); |
| glBindVertexArray(m_vertex_array); |
| if (stage != 5) |
| { |
| glEnable(GL_RASTERIZER_DISCARD); |
| } |
| if (stage == 1 || stage == 2) |
| { // TCS or TES |
| glPatchParameteri(GL_PATCH_VERTICES, 1); |
| glDrawArrays(GL_PATCHES, 0, 1); |
| glPatchParameteri(GL_PATCH_VERTICES, 3); |
| } |
| else if (stage == 4) |
| { // CS |
| glDispatchCompute(1, 1, 1); |
| } |
| else |
| { |
| glDrawArrays(GL_POINTS, 0, 1); |
| } |
| glDisable(GL_RASTERIZER_DISCARD); |
| |
| glBindTexture(GL_TEXTURE_2D, m_texture); |
| glMemoryBarrier(GL_TEXTURE_UPDATE_BARRIER_BIT); |
| { |
| ivec4 data[7]; |
| glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA_INTEGER, GL_INT, &data[0]); |
| for (int i = 0; i < 7; ++i) |
| { |
| if (data[i] != expected_result[i]) |
| { |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "Returned value is: (" << data[i][0] << " " << data[i][1] << " " |
| << data[i][2] << " " << data[i][3] << "). Expected value is: (" << expected_result[i][0] << " " |
| << expected_result[i][1] << " " << expected_result[i][2] << " " << expected_result[i][3] |
| << "). Image unit is: " << (i + 1) << tcu::TestLog::EndMessage; |
| return ERROR; |
| } |
| } |
| } |
| return NO_ERROR; |
| } |
| }; |
| //============================================================================= |
| // 1.1.x.y BasicNonMS |
| //----------------------------------------------------------------------------- |
| |
| template <typename T, int STAGE> |
| class BasicNonMS : public ShaderImageSizeBase |
| { |
| GLuint m_texture[7]; |
| GLuint m_buffer; |
| |
| virtual long Setup() |
| { |
| glGenTextures(7, m_texture); |
| glGenBuffers(1, &m_buffer); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| if (!SupportedInStage(STAGE, 8)) |
| return NOT_SUPPORTED; |
| |
| const GLenum target[7] = { GL_TEXTURE_2D, GL_TEXTURE_3D, |
| GL_TEXTURE_CUBE_MAP, GL_TEXTURE_CUBE_MAP_ARRAY, |
| GL_TEXTURE_RECTANGLE, GL_TEXTURE_2D_ARRAY, |
| GL_TEXTURE_BUFFER }; |
| for (int i = 0; i < 7; ++i) |
| { |
| glBindTexture(target[i], m_texture[i]); |
| if (target[i] != GL_TEXTURE_BUFFER) |
| { |
| glTexParameteri(target[i], GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| glTexParameteri(target[i], GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| } |
| |
| if (i == 0) |
| { |
| glTexStorage2D(target[i], 10, TexInternalFormat<T>(), 512, 128); |
| glBindImageTexture(1, m_texture[i], 1, GL_FALSE, 0, GL_READ_ONLY, TexInternalFormat<T>()); |
| } |
| else if (i == 1) |
| { |
| glTexStorage3D(target[i], 3, TexInternalFormat<T>(), 8, 8, 4); |
| glBindImageTexture(2, m_texture[i], 0, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>()); |
| } |
| else if (i == 2) |
| { |
| glTexStorage2D(target[i], 4, TexInternalFormat<T>(), 16, 16); |
| glBindImageTexture(3, m_texture[i], 0, GL_FALSE, 0, GL_READ_WRITE, TexInternalFormat<T>()); |
| } |
| else if (i == 3) |
| { |
| glTexStorage3D(target[i], 2, TexInternalFormat<T>(), 4, 4, 12); |
| glBindImageTexture(4, m_texture[i], 1, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>()); |
| } |
| else if (i == 4) |
| { |
| glTexStorage2D(target[i], 1, TexInternalFormat<T>(), 16, 8); |
| glBindImageTexture(5, m_texture[i], 0, GL_FALSE, 0, GL_READ_ONLY, TexInternalFormat<T>()); |
| } |
| else if (i == 5) |
| { |
| glTexStorage3D(target[i], 3, TexInternalFormat<T>(), 127, 39, 12); |
| glBindImageTexture(6, m_texture[i], 2, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>()); |
| } |
| else if (i == 6) |
| { |
| std::vector<GLubyte> data(256); |
| glBindBuffer(GL_TEXTURE_BUFFER, m_buffer); |
| glBufferData(GL_TEXTURE_BUFFER, 256, &data[0], GL_STATIC_DRAW); |
| glTexBuffer(GL_TEXTURE_BUFFER, TexInternalFormat<T>(), m_buffer); |
| glBindImageTexture(7, m_texture[i], 0, GL_FALSE, 0, GL_READ_ONLY, TexInternalFormat<T>()); |
| } |
| } |
| ImageSizeMachine machine; |
| ivec4 res[7] = { ivec4(256, 64, 0, 0), ivec4(8, 8, 4, 0), ivec4(16, 16, 0, 0), ivec4(2, 2, 2, 0), |
| ivec4(16, 8, 0, 0), ivec4(31, 9, 12, 0), ivec4(16, 0, 0, 0) }; |
| return machine.Run<T>(STAGE, false, res); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDeleteTextures(7, m_texture); |
| glDeleteBuffers(1, &m_buffer); |
| return NO_ERROR; |
| } |
| }; |
| //============================================================================= |
| // 1.2.x.y BasicMS |
| //----------------------------------------------------------------------------- |
| |
| template <typename T, int STAGE> |
| class BasicMS : public ShaderImageSizeBase |
| { |
| GLuint m_texture[4]; |
| |
| virtual long Setup() |
| { |
| glGenTextures(4, m_texture); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| if (!SupportedInStage(STAGE, 5)) |
| return NOT_SUPPORTED; |
| if (!SupportedSamples(4)) |
| return NOT_SUPPORTED; |
| |
| const GLenum target[4] = { GL_TEXTURE_1D, GL_TEXTURE_1D_ARRAY, GL_TEXTURE_2D_MULTISAMPLE, |
| GL_TEXTURE_2D_MULTISAMPLE_ARRAY }; |
| for (int i = 0; i < 4; ++i) |
| { |
| glBindTexture(target[i], m_texture[i]); |
| if (target[i] == GL_TEXTURE_1D || target[i] == GL_TEXTURE_1D_ARRAY) |
| { |
| glTexParameteri(target[i], GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| glTexParameteri(target[i], GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| } |
| |
| if (i == 0) |
| { |
| glTexStorage1D(target[i], 10, TexInternalFormat<T>(), 512); |
| glBindImageTexture(1, m_texture[i], 6, GL_FALSE, 0, GL_READ_ONLY, TexInternalFormat<T>()); |
| } |
| else if (i == 1) |
| { |
| glTexStorage2D(target[i], 3, TexInternalFormat<T>(), 15, 7); |
| glBindImageTexture(2, m_texture[i], 1, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>()); |
| } |
| else if (i == 2) |
| { |
| glTexImage2DMultisample(target[i], 4, TexInternalFormat<T>(), 17, 19, GL_FALSE); |
| glBindImageTexture(3, m_texture[i], 0, GL_FALSE, 0, GL_READ_WRITE, TexInternalFormat<T>()); |
| } |
| else if (i == 3) |
| { |
| glTexImage3DMultisample(target[i], 4, TexInternalFormat<T>(), 64, 32, 5, GL_FALSE); |
| glBindImageTexture(4, m_texture[i], 0, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>()); |
| } |
| } |
| ImageSizeMachine machine; |
| ivec4 res[7] = { ivec4(8, 0, 0, 0), ivec4(7, 7, 0, 0), ivec4(17, 19, 0, 0), ivec4(64, 32, 5, 0), ivec4(0), |
| ivec4(0), ivec4(0) }; |
| return machine.Run<T>(STAGE, true, res); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDeleteTextures(4, m_texture); |
| return NO_ERROR; |
| } |
| }; |
| //============================================================================= |
| // 2.1 AdvancedChangeSize |
| //----------------------------------------------------------------------------- |
| class AdvancedChangeSize : public ShaderImageSizeBase |
| { |
| GLuint m_pipeline; |
| GLuint m_program[2]; |
| GLuint m_vertex_array; |
| GLuint m_texture[2]; |
| |
| virtual long Setup() |
| { |
| glGenProgramPipelines(1, &m_pipeline); |
| memset(m_program, 0, sizeof(m_program)); |
| glGenVertexArrays(1, &m_vertex_array); |
| glGenTextures(2, m_texture); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| const char* const glsl_vs = "#version 430 core" NL "out gl_PerVertex { vec4 gl_Position; };" NL |
| "const vec2 g_position[3] = { vec2(-1, -1), vec2(3, -1), vec2(-1, 3) };" NL |
| "void main() { gl_Position = vec4(g_position[gl_VertexID], 0, 1); }"; |
| const char* const glsl_fs = |
| "#version 430 core" NL "layout(location = 0) out vec4 g_color;" NL |
| "layout(binding = 0, rgba8) uniform image2D g_image[2];" NL "uniform ivec2 g_expected_size[2];" NL |
| "uniform int g_0 = 0, g_1 = 1;" NL "void main() {" NL " vec4 c = vec4(0, 1, 0, 1);" NL |
| " if (imageSize(g_image[g_0]).xy != g_expected_size[g_0]) c = vec4(1, 0, 0, 1);" NL |
| " if (imageSize(g_image[g_1]).yx != g_expected_size[g_1]) c = vec4(1, 0, 0, 1);" NL " g_color = c;" NL |
| "}"; |
| m_program[0] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &glsl_vs); |
| m_program[1] = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &glsl_fs); |
| for (int i = 0; i < 2; ++i) |
| if (!CheckProgram(m_program[i])) |
| return ERROR; |
| |
| glUseProgramStages(m_pipeline, GL_VERTEX_SHADER_BIT, m_program[0]); |
| glUseProgramStages(m_pipeline, GL_FRAGMENT_SHADER_BIT, m_program[1]); |
| |
| glBindVertexArray(m_vertex_array); |
| glBindProgramPipeline(m_pipeline); |
| |
| int size[2] = { 32, 128 }; |
| for (int i = 0; i < 2; ++i) |
| { |
| glBindTexture(GL_TEXTURE_2D, m_texture[i]); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); |
| glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, size[i], size[i], 0, GL_RGBA, GL_FLOAT, NULL); |
| glBindImageTexture(i, m_texture[i], 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8); |
| } |
| |
| for (int i = 0; i < 3; ++i) |
| { |
| glProgramUniform2i(m_program[1], glGetUniformLocation(m_program[1], "g_expected_size[0]"), size[0], |
| size[0]); |
| glProgramUniform2i(m_program[1], glGetUniformLocation(m_program[1], "g_expected_size[1]"), size[1], |
| size[1]); |
| glClear(GL_COLOR_BUFFER_BIT); |
| glDrawArrays(GL_TRIANGLES, 0, 3); |
| |
| { |
| bool status = true; |
| std::vector<vec3> fb(getWindowWidth() * getWindowHeight()); |
| glReadPixels(0, 0, getWindowWidth(), getWindowHeight(), GL_RGB, GL_FLOAT, &fb[0][0]); |
| if (!ValidateReadBuffer(0, 0, getWindowWidth(), getWindowHeight(), vec4(0, 1, 0, 1))) |
| status = false; |
| if (!status) |
| return ERROR; |
| } |
| |
| size[0] /= 2; |
| size[1] /= 2; |
| |
| glBindTexture(GL_TEXTURE_2D, m_texture[0]); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, size[0], size[0], 0, GL_RGBA, GL_FLOAT, NULL); |
| glBindTexture(GL_TEXTURE_2D, m_texture[1]); |
| glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, size[1], size[1], 0, GL_RGBA, GL_FLOAT, NULL); |
| } |
| return NO_ERROR; |
| } |
| |
| virtual long Cleanup() |
| { |
| glDeleteProgramPipelines(1, &m_pipeline); |
| for (int i = 0; i < 2; ++i) |
| glDeleteProgram(m_program[i]); |
| glDeleteVertexArrays(1, &m_vertex_array); |
| glDeleteTextures(2, m_texture); |
| return NO_ERROR; |
| } |
| }; |
| //============================================================================= |
| // 2.2.x.y AdvancedNonMS |
| //----------------------------------------------------------------------------- |
| |
| template <typename T, int STAGE> |
| class AdvancedNonMS : public ShaderImageSizeBase |
| { |
| GLuint m_texture[7]; |
| GLuint m_buffer; |
| |
| virtual long Setup() |
| { |
| glGenTextures(7, m_texture); |
| glGenBuffers(1, &m_buffer); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| if (!SupportedInStage(STAGE, 8)) |
| return NOT_SUPPORTED; |
| |
| const GLenum target[7] = { GL_TEXTURE_2D_ARRAY, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP_ARRAY, |
| GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_RECTANGLE, GL_TEXTURE_2D_ARRAY, |
| GL_TEXTURE_BUFFER }; |
| for (int i = 0; i < 7; ++i) |
| { |
| glBindTexture(target[i], m_texture[i]); |
| if (target[i] != GL_TEXTURE_BUFFER) |
| { |
| glTexParameteri(target[i], GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| glTexParameteri(target[i], GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| } |
| |
| if (i == 0) |
| { |
| glTexImage3D(target[i], 0, TexInternalFormat<T>(), 2, 2, 7, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glTexImage3D(target[i], 1, TexInternalFormat<T>(), 1, 1, 7, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glBindImageTexture(1, m_texture[i], 1, GL_FALSE, 3, GL_READ_ONLY, TexInternalFormat<T>()); |
| } |
| else if (i == 1) |
| { |
| glTexImage3D(target[i], 0, TexInternalFormat<T>(), 4, 4, 2, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glTexImage3D(target[i], 1, TexInternalFormat<T>(), 2, 2, 1, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glTexImage3D(target[i], 2, TexInternalFormat<T>(), 1, 1, 1, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glBindImageTexture(2, m_texture[i], 1, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>()); |
| } |
| else if (i == 2) |
| { |
| glTexImage3D(target[i], 0, TexInternalFormat<T>(), 2, 2, 12, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glTexImage3D(target[i], 1, TexInternalFormat<T>(), 1, 1, 12, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glBindImageTexture(3, m_texture[i], 0, GL_FALSE, 1, GL_READ_WRITE, TexInternalFormat<T>()); |
| } |
| else if (i == 3) |
| { |
| glTexImage3D(target[i], 0, TexInternalFormat<T>(), 4, 4, 18, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glTexImage3D(target[i], 1, TexInternalFormat<T>(), 2, 2, 18, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glTexImage3D(target[i], 2, TexInternalFormat<T>(), 1, 1, 18, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glBindImageTexture(4, m_texture[i], 1, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>()); |
| } |
| else if (i == 4) |
| { |
| glTexImage2D(target[i], 0, TexInternalFormat<T>(), 123, 11, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glBindImageTexture(5, m_texture[i], 0, GL_FALSE, 0, GL_READ_WRITE, TexInternalFormat<T>()); |
| } |
| else if (i == 5) |
| { |
| glTexImage3D(target[i], 0, TexInternalFormat<T>(), 13, 7, 4, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glTexImage3D(target[i], 1, TexInternalFormat<T>(), 6, 3, 4, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glTexImage3D(target[i], 2, TexInternalFormat<T>(), 3, 1, 4, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glTexImage3D(target[i], 3, TexInternalFormat<T>(), 1, 1, 4, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glBindImageTexture(6, m_texture[i], 1, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>()); |
| } |
| else if (i == 6) |
| { |
| glBindBuffer(GL_TEXTURE_BUFFER, m_buffer); |
| glBufferData(GL_TEXTURE_BUFFER, 1024, NULL, GL_STATIC_DRAW); |
| glTexBufferRange(GL_TEXTURE_BUFFER, TexInternalFormat<T>(), m_buffer, 256, 512); |
| glBindImageTexture(7, m_texture[i], 0, GL_FALSE, 0, GL_WRITE_ONLY, TexInternalFormat<T>()); |
| } |
| } |
| ImageSizeMachine machine; |
| ivec4 res[7] = { ivec4(1, 1, 0, 0), ivec4(2, 2, 1, 0), ivec4(2, 2, 0, 0), ivec4(2, 2, 3, 0), |
| ivec4(123, 11, 0, 0), ivec4(6, 3, 4, 0), ivec4(32, 0, 0, 0) }; |
| return machine.Run<T>(STAGE, false, res, true); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDeleteTextures(7, m_texture); |
| glDeleteBuffers(1, &m_buffer); |
| return NO_ERROR; |
| } |
| }; |
| //============================================================================= |
| // 2.3.x.y AdvancedMS |
| //----------------------------------------------------------------------------- |
| template <typename T, int STAGE> |
| class AdvancedMS : public ShaderImageSizeBase |
| { |
| GLuint m_texture[4]; |
| |
| virtual long Setup() |
| { |
| glGenTextures(4, m_texture); |
| return NO_ERROR; |
| } |
| |
| virtual long Run() |
| { |
| if (!SupportedInStage(STAGE, 5)) |
| return NOT_SUPPORTED; |
| if (!SupportedSamples(4)) |
| return NOT_SUPPORTED; |
| |
| const GLenum target[4] = { GL_TEXTURE_1D, GL_TEXTURE_1D_ARRAY, GL_TEXTURE_2D_MULTISAMPLE_ARRAY, |
| GL_TEXTURE_2D_MULTISAMPLE_ARRAY }; |
| for (int i = 0; i < 4; ++i) |
| { |
| glBindTexture(target[i], m_texture[i]); |
| if (target[i] == GL_TEXTURE_1D || target[i] == GL_TEXTURE_1D_ARRAY) |
| { |
| glTexParameteri(target[i], GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| glTexParameteri(target[i], GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| } |
| |
| if (i == 0) |
| { |
| glTexImage1D(target[i], 0, TexInternalFormat<T>(), 7, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glTexImage1D(target[i], 1, TexInternalFormat<T>(), 3, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glTexImage1D(target[i], 2, TexInternalFormat<T>(), 1, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glBindImageTexture(1, m_texture[i], 1, GL_FALSE, 0, GL_READ_ONLY, TexInternalFormat<T>()); |
| } |
| else if (i == 1) |
| { |
| glTexImage2D(target[i], 0, TexInternalFormat<T>(), 7, 15, 0, TexFormat<T>(), TexType<T>(), NULL); |
| glBindImageTexture(2, m_texture[i], 0, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>()); |
| } |
| else if (i == 2) |
| { |
| glTexImage3DMultisample(target[i], 4, TexInternalFormat<T>(), 7, 9, 3, GL_FALSE); |
| glBindImageTexture(3, m_texture[i], 0, GL_FALSE, 1, GL_READ_WRITE, TexInternalFormat<T>()); |
| } |
| else if (i == 3) |
| { |
| glTexImage3DMultisample(target[i], 4, TexInternalFormat<T>(), 64, 32, 5, GL_FALSE); |
| glBindImageTexture(4, m_texture[i], 0, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>()); |
| } |
| } |
| ImageSizeMachine machine; |
| ivec4 res[7] = { ivec4(3, 0, 0, 0), ivec4(7, 15, 0, 0), ivec4(7, 9, 0, 0), ivec4(64, 32, 5, 0), |
| ivec4(0), ivec4(0), ivec4(0) }; |
| return machine.Run<T>(STAGE, true, res, true); |
| } |
| |
| virtual long Cleanup() |
| { |
| glDeleteTextures(4, m_texture); |
| return NO_ERROR; |
| } |
| }; |
| //============================================================================= |
| // 4.1 NegativeCompileTime |
| //----------------------------------------------------------------------------- |
| class NegativeCompileTime : public ShaderImageSizeBase |
| { |
| virtual long Run() |
| { |
| // '#extension GL_ARB_shader_image_size : require' is missing |
| if (!Compile("#version 420 core" NL "layout(location = 0) out vec4 g_color;" NL |
| "layout(binding = 0, rg16f) uniform image2D g_image;" NL "uniform ivec2 g_expected_size;" NL |
| "void main() {" NL " if (imageSize(g_image) == g_expected_size) g_color = vec4(0, 1, 0, 1);" NL |
| " else g_color = vec4(1, 0, 0, 1);" NL "}")) |
| return ERROR; |
| // imageSize(sampler) |
| if (!Compile("#version 430 core" NL "layout(location = 0) out vec4 g_color;" NL |
| "layout(binding = 0) uniform sampler2D g_sampler;" NL "uniform ivec2 g_expected_size;" NL |
| "void main() {" NL " if (imageSize(g_sampler) == g_expected_size) g_color = vec4(0, 1, 0, 1);" NL |
| " else g_color = vec4(1, 0, 0, 1);" NL "}")) |
| return ERROR; |
| return NO_ERROR; |
| } |
| |
| bool Compile(const std::string& source) |
| { |
| const GLuint sh = glCreateShader(GL_FRAGMENT_SHADER); |
| |
| const char* const src = source.c_str(); |
| glShaderSource(sh, 1, &src, NULL); |
| glCompileShader(sh); |
| |
| GLchar log[1024]; |
| glGetShaderInfoLog(sh, sizeof(log), NULL, log); |
| m_context.getTestContext().getLog() << tcu::TestLog::Message << "Shader Info Log:\n" |
| << log << tcu::TestLog::EndMessage; |
| |
| GLint status; |
| glGetShaderiv(sh, GL_COMPILE_STATUS, &status); |
| glDeleteShader(sh); |
| |
| if (status == GL_TRUE) |
| { |
| m_context.getTestContext().getLog() |
| << tcu::TestLog::Message << "Compilation should fail." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| return true; |
| } |
| }; |
| |
| } // anonymous namespace |
| |
| ShaderImageSizeTests::ShaderImageSizeTests(deqp::Context& context) : TestCaseGroup(context, "shader_image_size", "") |
| { |
| } |
| |
| ShaderImageSizeTests::~ShaderImageSizeTests(void) |
| { |
| } |
| |
| void ShaderImageSizeTests::init() |
| { |
| using namespace deqp; |
| addChild(new TestSubcase(m_context, "basic-nonMS-vs-float", TestSubcase::Create<BasicNonMS<vec4, 0> >)); |
| addChild(new TestSubcase(m_context, "basic-nonMS-vs-int", TestSubcase::Create<BasicNonMS<ivec4, 0> >)); |
| addChild(new TestSubcase(m_context, "basic-nonMS-vs-uint", TestSubcase::Create<BasicNonMS<uvec4, 0> >)); |
| addChild(new TestSubcase(m_context, "basic-nonMS-tcs-float", TestSubcase::Create<BasicNonMS<vec4, 1> >)); |
| addChild(new TestSubcase(m_context, "basic-nonMS-tcs-int", TestSubcase::Create<BasicNonMS<ivec4, 1> >)); |
| addChild(new TestSubcase(m_context, "basic-nonMS-tcs-uint", TestSubcase::Create<BasicNonMS<uvec4, 1> >)); |
| addChild(new TestSubcase(m_context, "basic-nonMS-tes-float", TestSubcase::Create<BasicNonMS<vec4, 2> >)); |
| addChild(new TestSubcase(m_context, "basic-nonMS-tes-int", TestSubcase::Create<BasicNonMS<ivec4, 2> >)); |
| addChild(new TestSubcase(m_context, "basic-nonMS-tes-uint", TestSubcase::Create<BasicNonMS<uvec4, 2> >)); |
| addChild(new TestSubcase(m_context, "basic-nonMS-gs-float", TestSubcase::Create<BasicNonMS<vec4, 3> >)); |
| addChild(new TestSubcase(m_context, "basic-nonMS-gs-int", TestSubcase::Create<BasicNonMS<ivec4, 3> >)); |
| addChild(new TestSubcase(m_context, "basic-nonMS-gs-uint", TestSubcase::Create<BasicNonMS<uvec4, 3> >)); |
| addChild(new TestSubcase(m_context, "basic-nonMS-fs-float", TestSubcase::Create<BasicNonMS<vec4, 5> >)); |
| addChild(new TestSubcase(m_context, "basic-nonMS-fs-int", TestSubcase::Create<BasicNonMS<ivec4, 5> >)); |
| addChild(new TestSubcase(m_context, "basic-nonMS-fs-uint", TestSubcase::Create<BasicNonMS<uvec4, 5> >)); |
| addChild(new TestSubcase(m_context, "basic-nonMS-cs-float", TestSubcase::Create<BasicNonMS<vec4, 4> >)); |
| addChild(new TestSubcase(m_context, "basic-nonMS-cs-int", TestSubcase::Create<BasicNonMS<ivec4, 4> >)); |
| addChild(new TestSubcase(m_context, "basic-nonMS-cs-uint", TestSubcase::Create<BasicNonMS<uvec4, 4> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-vs-float", TestSubcase::Create<BasicMS<vec4, 0> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-vs-int", TestSubcase::Create<BasicMS<ivec4, 0> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-vs-uint", TestSubcase::Create<BasicMS<uvec4, 0> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-tcs-float", TestSubcase::Create<BasicMS<vec4, 1> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-tcs-int", TestSubcase::Create<BasicMS<ivec4, 1> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-tcs-uint", TestSubcase::Create<BasicMS<uvec4, 1> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-tes-float", TestSubcase::Create<BasicMS<vec4, 2> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-tes-int", TestSubcase::Create<BasicMS<ivec4, 2> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-tes-uint", TestSubcase::Create<BasicMS<uvec4, 2> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-gs-float", TestSubcase::Create<BasicMS<vec4, 3> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-gs-int", TestSubcase::Create<BasicMS<ivec4, 3> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-gs-uint", TestSubcase::Create<BasicMS<uvec4, 3> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-fs-float", TestSubcase::Create<BasicMS<vec4, 5> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-fs-int", TestSubcase::Create<BasicMS<ivec4, 5> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-fs-uint", TestSubcase::Create<BasicMS<uvec4, 5> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-cs-float", TestSubcase::Create<BasicMS<vec4, 4> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-cs-int", TestSubcase::Create<BasicMS<ivec4, 4> >)); |
| addChild(new TestSubcase(m_context, "basic-ms-cs-uint", TestSubcase::Create<BasicMS<uvec4, 4> >)); |
| addChild(new TestSubcase(m_context, "advanced-changeSize", TestSubcase::Create<AdvancedChangeSize>)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-vs-float", TestSubcase::Create<AdvancedNonMS<vec4, 0> >)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-vs-int", TestSubcase::Create<AdvancedNonMS<ivec4, 0> >)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-vs-uint", TestSubcase::Create<AdvancedNonMS<uvec4, 0> >)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-tcs-float", TestSubcase::Create<AdvancedNonMS<vec4, 1> >)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-tcs-int", TestSubcase::Create<AdvancedNonMS<ivec4, 1> >)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-tcs-uint", TestSubcase::Create<AdvancedNonMS<uvec4, 1> >)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-tes-float", TestSubcase::Create<AdvancedNonMS<vec4, 2> >)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-tes-int", TestSubcase::Create<AdvancedNonMS<ivec4, 2> >)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-tes-uint", TestSubcase::Create<AdvancedNonMS<uvec4, 2> >)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-gs-float", TestSubcase::Create<AdvancedNonMS<vec4, 3> >)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-gs-int", TestSubcase::Create<AdvancedNonMS<ivec4, 3> >)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-gs-uint", TestSubcase::Create<AdvancedNonMS<uvec4, 3> >)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-fs-float", TestSubcase::Create<AdvancedNonMS<vec4, 5> >)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-fs-int", TestSubcase::Create<AdvancedNonMS<ivec4, 5> >)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-fs-uint", TestSubcase::Create<AdvancedNonMS<uvec4, 5> >)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-cs-float", TestSubcase::Create<AdvancedNonMS<vec4, 4> >)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-cs-int", TestSubcase::Create<AdvancedNonMS<ivec4, 4> >)); |
| addChild(new TestSubcase(m_context, "advanced-nonMS-cs-uint", TestSubcase::Create<AdvancedNonMS<uvec4, 4> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-vs-float", TestSubcase::Create<AdvancedMS<vec4, 0> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-vs-int", TestSubcase::Create<AdvancedMS<ivec4, 0> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-vs-uint", TestSubcase::Create<AdvancedMS<uvec4, 0> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-tcs-float", TestSubcase::Create<AdvancedMS<vec4, 1> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-tcs-int", TestSubcase::Create<AdvancedMS<ivec4, 1> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-tcs-uint", TestSubcase::Create<AdvancedMS<uvec4, 1> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-tes-float", TestSubcase::Create<AdvancedMS<vec4, 2> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-tes-int", TestSubcase::Create<AdvancedMS<ivec4, 2> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-tes-uint", TestSubcase::Create<AdvancedMS<uvec4, 2> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-gs-float", TestSubcase::Create<AdvancedMS<vec4, 3> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-gs-int", TestSubcase::Create<AdvancedMS<ivec4, 3> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-gs-uint", TestSubcase::Create<AdvancedMS<uvec4, 3> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-fs-float", TestSubcase::Create<AdvancedMS<vec4, 5> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-fs-int", TestSubcase::Create<AdvancedMS<ivec4, 5> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-fs-uint", TestSubcase::Create<AdvancedMS<uvec4, 5> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-cs-float", TestSubcase::Create<AdvancedMS<vec4, 4> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-cs-int", TestSubcase::Create<AdvancedMS<ivec4, 4> >)); |
| addChild(new TestSubcase(m_context, "advanced-ms-cs-uint", TestSubcase::Create<AdvancedMS<uvec4, 4> >)); |
| addChild(new TestSubcase(m_context, "negative-compileTime", TestSubcase::Create<NegativeCompileTime>)); |
| } |
| |
| } // namespace gl4cts |
