| /*------------------------------------------------------------------------- |
| * 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 es31cTextureStorageMultisampleGetActiveUniformTests.cpp |
| * \brief Implements conformance tests that check whether glGetActiveUniform() |
| * works correctly with multisample texture samplers. (ES3.1 only) |
| */ /*-------------------------------------------------------------------*/ |
| |
| #include "es31cTextureStorageMultisampleGetActiveUniformTests.hpp" |
| #include "gluContextInfo.hpp" |
| #include "gluDefs.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| #include "tcuRenderTarget.hpp" |
| #include "tcuTestLog.hpp" |
| |
| #include <string.h> |
| #include <string> |
| #include <vector> |
| |
| namespace glcts |
| { |
| |
| /* Constants */ |
| const char* MultisampleTextureGetActiveUniformSamplersTest::fs_body = |
| "#version 310 es\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "uniform highp sampler2DMS fs_sampler_2d_multisample;\n" |
| "uniform highp usampler2DMS fs_sampler_2d_multisample_uint;\n" |
| "uniform highp isampler2DMS fs_sampler_2d_multisample_int;\n" |
| "\n" |
| "out vec4 result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " vec4 sampler2DMS_value = texelFetch(fs_sampler_2d_multisample, ivec2(0), 0);\n" |
| " uvec4 usampler2DMS_value = texelFetch(fs_sampler_2d_multisample_uint, ivec2(0), 0);\n" |
| " ivec4 isampler2DMS_value = texelFetch(fs_sampler_2d_multisample_int, ivec2(0), 0);\n" |
| "\n" |
| " result = sampler2DMS_value +\n" |
| " vec4(usampler2DMS_value) +\n" |
| " vec4(isampler2DMS_value);\n" |
| "}\n"; |
| |
| const char* MultisampleTextureGetActiveUniformSamplersTest::fs_body_oes = |
| "#version 310 es\n" |
| "\n" |
| "#extension GL_OES_texture_storage_multisample_2d_array : enable\n" |
| "precision highp float;\n" |
| "\n" |
| "uniform highp sampler2DMS fs_sampler_2d_multisample;\n" |
| "uniform highp sampler2DMSArray fs_sampler_2d_multisample_array;\n" |
| "uniform highp usampler2DMS fs_sampler_2d_multisample_uint;\n" |
| "uniform highp usampler2DMSArray fs_sampler_2d_multisample_array_uint;\n" |
| "uniform highp isampler2DMS fs_sampler_2d_multisample_int;\n" |
| "uniform highp isampler2DMSArray fs_sampler_2d_multisample_array_int;\n" |
| "\n" |
| "out vec4 result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " vec4 sampler2DMS_value = texelFetch(fs_sampler_2d_multisample, ivec2(0), 0);\n" |
| " vec4 sampler2DMSArray_value = texelFetch(fs_sampler_2d_multisample_array, ivec3(0), 0);\n" |
| " uvec4 usampler2DMS_value = texelFetch(fs_sampler_2d_multisample_uint, ivec2(0), 0);\n" |
| " uvec4 usampler2DMSArray_value = texelFetch(fs_sampler_2d_multisample_array_uint, ivec3(0), 0);\n" |
| " ivec4 isampler2DMS_value = texelFetch(fs_sampler_2d_multisample_int, ivec2(0), 0);\n" |
| " ivec4 isampler2DMSArray_value = texelFetch(fs_sampler_2d_multisample_array_int, ivec3(0), 0);\n" |
| "\n" |
| " result = sampler2DMS_value + sampler2DMSArray_value +\n" |
| " vec4(usampler2DMS_value) + vec4(usampler2DMSArray_value) +\n" |
| " vec4(isampler2DMS_value) + vec4(isampler2DMSArray_value);\n" |
| "}\n"; |
| |
| const char* MultisampleTextureGetActiveUniformSamplersTest::vs_body = |
| "#version 310 es\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "uniform highp sampler2DMS vs_sampler_2d_multisample;\n" |
| "uniform highp usampler2DMS vs_sampler_2d_multisample_uint;\n" |
| "uniform highp isampler2DMS vs_sampler_2d_multisample_int;\n" |
| "\n" |
| "out vec4 result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " vec4 sampler2DMS_value = texelFetch(vs_sampler_2d_multisample, ivec2(0), 0);\n" |
| " uvec4 usampler2DMS_value = texelFetch(vs_sampler_2d_multisample_uint, ivec2(0), 0);\n" |
| " ivec4 isampler2DMS_value = texelFetch(vs_sampler_2d_multisample_int, ivec2(0), 0);\n" |
| "\n" |
| " gl_Position = sampler2DMS_value +\n" |
| " vec4(usampler2DMS_value) +\n" |
| " vec4(isampler2DMS_value);\n" |
| "}\n"; |
| |
| const char* MultisampleTextureGetActiveUniformSamplersTest::vs_body_oes = |
| "#version 310 es\n" |
| "\n" |
| "#extension GL_OES_texture_storage_multisample_2d_array : enable\n" |
| "precision highp float;\n" |
| "\n" |
| "uniform highp sampler2DMS vs_sampler_2d_multisample;\n" |
| "uniform highp sampler2DMSArray vs_sampler_2d_multisample_array;\n" |
| "uniform highp usampler2DMS vs_sampler_2d_multisample_uint;\n" |
| "uniform highp usampler2DMSArray vs_sampler_2d_multisample_array_uint;\n" |
| "uniform highp isampler2DMS vs_sampler_2d_multisample_int;\n" |
| "uniform highp isampler2DMSArray vs_sampler_2d_multisample_array_int;\n" |
| "\n" |
| "out vec4 result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " vec4 sampler2DMS_value = texelFetch(vs_sampler_2d_multisample, ivec2(0), 0);\n" |
| " vec4 sampler2DMSArray_value = texelFetch(vs_sampler_2d_multisample_array, ivec3(0), 0);\n" |
| " uvec4 usampler2DMS_value = texelFetch(vs_sampler_2d_multisample_uint, ivec2(0), 0);\n" |
| " uvec4 usampler2DMSArray_value = texelFetch(vs_sampler_2d_multisample_array_uint, ivec3(0), 0);\n" |
| " ivec4 isampler2DMS_value = texelFetch(vs_sampler_2d_multisample_int, ivec2(0), 0);\n" |
| " ivec4 isampler2DMSArray_value = texelFetch(vs_sampler_2d_multisample_array_int, ivec3(0), 0);\n" |
| "\n" |
| " gl_Position = sampler2DMS_value + sampler2DMSArray_value +\n" |
| " vec4(usampler2DMS_value) + vec4(usampler2DMSArray_value) +\n" |
| " vec4(isampler2DMS_value) + vec4(isampler2DMSArray_value);\n" |
| "}\n"; |
| |
| /** Constructor. |
| * |
| * @param context Rendering context handle. |
| **/ |
| MultisampleTextureGetActiveUniformSamplersTest::MultisampleTextureGetActiveUniformSamplersTest(Context& context) |
| : TestCase(context, "multisample_texture_samplers", "Verifies multisample texture samplers are reported correctly") |
| , fs_id(0) |
| , gl_oes_texture_storage_multisample_2d_array_supported(GL_FALSE) |
| , po_id(0) |
| , vs_id(0) |
| { |
| /* Left blank on purpose */ |
| } |
| |
| /** Deinitializes ES objects created during test execution */ |
| void MultisampleTextureGetActiveUniformSamplersTest::deinit() |
| { |
| /* Call base class' deinit() */ |
| TestCase::deinit(); |
| } |
| |
| /** Initializes test-specific ES objects */ |
| void MultisampleTextureGetActiveUniformSamplersTest::initInternals() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| fs_id = gl.createShader(GL_FRAGMENT_SHADER); |
| po_id = gl.createProgram(); |
| vs_id = gl.createShader(GL_VERTEX_SHADER); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Shader or program creation failed"); |
| } |
| |
| /** Removes test-specific ES objects */ |
| void MultisampleTextureGetActiveUniformSamplersTest::deinitInternals() |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.deleteShader(fs_id); |
| gl.deleteProgram(po_id); |
| gl.deleteShader(vs_id); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Shader or program delete failed"); |
| } |
| |
| /** Executes test iteration. |
| * |
| * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. |
| */ |
| tcu::TestNode::IterateResult MultisampleTextureGetActiveUniformSamplersTest::iterate() |
| { |
| gl_oes_texture_storage_multisample_2d_array_supported = |
| m_context.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"); |
| |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| initInternals(); |
| |
| /* Configure the test program object */ |
| gl.attachShader(po_id, fs_id); |
| gl.attachShader(po_id, vs_id); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not configure the test program object"); |
| |
| /* Compile the fragment shader */ |
| glw::GLint compile_status = GL_FALSE; |
| |
| if (gl_oes_texture_storage_multisample_2d_array_supported) |
| { |
| gl.shaderSource(fs_id, 1, /* count */ |
| &fs_body_oes, NULL); /* length */ |
| } |
| else |
| { |
| gl.shaderSource(fs_id, 1, /* count */ |
| &fs_body, NULL); /* length */ |
| } |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed."); |
| |
| gl.compileShader(fs_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed."); |
| |
| gl.getShaderiv(fs_id, GL_COMPILE_STATUS, &compile_status); |
| |
| if (compile_status != GL_TRUE) |
| { |
| TCU_FAIL("Fragment shader compilation failed."); |
| } |
| |
| if (gl_oes_texture_storage_multisample_2d_array_supported) |
| { |
| /* Compile the vertex shader */ |
| gl.shaderSource(vs_id, 1, /* count */ |
| &vs_body_oes, NULL); /* length */ |
| } |
| else |
| { |
| /* Compile the vertex shader */ |
| gl.shaderSource(vs_id, 1, /* count */ |
| &vs_body, NULL); /* length */ |
| } |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed."); |
| |
| gl.compileShader(vs_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed."); |
| |
| gl.getShaderiv(vs_id, GL_COMPILE_STATUS, &compile_status); |
| |
| if (compile_status != GL_TRUE) |
| { |
| char temp[1024]; |
| |
| gl.getShaderInfoLog(vs_id, 1024, 0, temp); |
| |
| TCU_FAIL("Vertex shader compilation failed."); |
| } |
| |
| /* Link the test program object */ |
| glw::GLint link_status = GL_FALSE; |
| |
| gl.linkProgram(po_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() call failed."); |
| |
| gl.getProgramiv(po_id, GL_LINK_STATUS, &link_status); |
| |
| if (link_status != GL_TRUE) |
| { |
| TCU_FAIL("Program linking failed."); |
| } |
| |
| /* Retrieve amount of active uniforms */ |
| glw::GLint n_active_uniforms = 0; |
| |
| gl.getProgramiv(po_id, GL_ACTIVE_UNIFORMS, &n_active_uniforms); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call (GL_ACTIVE_UNIFORMS) failed."); |
| |
| /* Allocate a buffer that will hold uniform names */ |
| glw::GLint max_active_uniform_length = 0; |
| char* uniform_name = NULL; |
| |
| gl.getProgramiv(po_id, GL_ACTIVE_UNIFORM_MAX_LENGTH, &max_active_uniform_length); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call (GL_ACTIVE_UNIFORM_MAX_LENGTH) failed."); |
| |
| uniform_name = new char[max_active_uniform_length]; |
| |
| /* Prepare an array of booleans. Each cell, set to false by default, will tell |
| * whether a corresponding uniform has already been reported. |
| */ |
| enum |
| { |
| SHADER_UNIFORM_FS_MULTISAMPLE, |
| SHADER_UNIFORM_FS_MULTISAMPLE_ARRAY, |
| SHADER_UNIFORM_FS_MULTISAMPLE_UINT, |
| SHADER_UNIFORM_FS_MULTISAMPLE_ARRAY_UINT, |
| SHADER_UNIFORM_FS_MULTISAMPLE_INT, |
| SHADER_UNIFORM_FS_MULTISAMPLE_ARRAY_INT, |
| |
| SHADER_UNIFORM_VS_MULTISAMPLE, |
| SHADER_UNIFORM_VS_MULTISAMPLE_ARRAY, |
| SHADER_UNIFORM_VS_MULTISAMPLE_UINT, |
| SHADER_UNIFORM_VS_MULTISAMPLE_ARRAY_UINT, |
| SHADER_UNIFORM_VS_MULTISAMPLE_INT, |
| SHADER_UNIFORM_VS_MULTISAMPLE_ARRAY_INT, |
| |
| SHADER_UNIFORM_COUNT |
| }; |
| |
| bool shader_uniform_reported_status[SHADER_UNIFORM_COUNT]; |
| |
| memset(shader_uniform_reported_status, 0, sizeof(shader_uniform_reported_status)); |
| |
| /* Iterate through all active uniforms. */ |
| for (int n_uniform = 0; n_uniform < n_active_uniforms; ++n_uniform) |
| { |
| glw::GLint uniform_size = 0; |
| glw::GLenum uniform_type = GL_NONE; |
| |
| /* Retrieve uniform properties */ |
| gl.getActiveUniform(po_id, n_uniform, max_active_uniform_length, NULL, /* length */ |
| &uniform_size, &uniform_type, uniform_name); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveUniform() call failed"); |
| |
| /* Check if the reported name is valid and that the type and size |
| * retrieved matches the uniform. |
| * Also verify that the uniform has not been already reported. |
| */ |
| if (strcmp(uniform_name, "fs_sampler_2d_multisample") == 0) |
| { |
| if (shader_uniform_reported_status[SHADER_UNIFORM_FS_MULTISAMPLE]) |
| { |
| TCU_FAIL("fs_sampler_2d_multisample uniform is reported more than once"); |
| } |
| |
| if (uniform_type != GL_SAMPLER_2D_MULTISAMPLE) |
| { |
| TCU_FAIL("Invalid uniform type reported for fs_sampler_2d_multisample uniform"); |
| } |
| |
| shader_uniform_reported_status[SHADER_UNIFORM_FS_MULTISAMPLE] = true; |
| } |
| else if (strcmp(uniform_name, "fs_sampler_2d_multisample_array") == 0) |
| { |
| if (gl_oes_texture_storage_multisample_2d_array_supported) |
| { |
| if (shader_uniform_reported_status[SHADER_UNIFORM_FS_MULTISAMPLE_ARRAY]) |
| { |
| TCU_FAIL("fs_sampler_2d_multisample_array uniform is reported more than once"); |
| } |
| |
| if (uniform_type != GL_SAMPLER_2D_MULTISAMPLE_ARRAY_OES) |
| { |
| TCU_FAIL("Invalid uniform type reported for fs_sampler_2d_multisample_array uniform"); |
| } |
| |
| shader_uniform_reported_status[SHADER_UNIFORM_FS_MULTISAMPLE_ARRAY] = true; |
| } |
| else |
| { |
| TCU_FAIL("Unsupported active uniform type reported."); |
| } |
| } |
| else if (strcmp(uniform_name, "fs_sampler_2d_multisample_uint") == 0) |
| { |
| if (shader_uniform_reported_status[SHADER_UNIFORM_FS_MULTISAMPLE_UINT]) |
| { |
| TCU_FAIL("fs_sampler_2d_multisample_uint uniform is reported more than once"); |
| } |
| |
| if (uniform_type != GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE) |
| { |
| TCU_FAIL("Invalid uniform type reported for fs_sampler_2d_multisample_uint uniform"); |
| } |
| |
| shader_uniform_reported_status[SHADER_UNIFORM_FS_MULTISAMPLE_UINT] = true; |
| } |
| else if (strcmp(uniform_name, "fs_sampler_2d_multisample_array_uint") == 0) |
| { |
| if (gl_oes_texture_storage_multisample_2d_array_supported) |
| { |
| if (shader_uniform_reported_status[SHADER_UNIFORM_FS_MULTISAMPLE_ARRAY_UINT]) |
| { |
| TCU_FAIL("fs_sampler_2d_multisample_array_uint uniform is reported more than once"); |
| } |
| |
| if (uniform_type != GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES) |
| { |
| TCU_FAIL("Invalid uniform type reported for fs_sampler_2d_multisample_array_uint uniform"); |
| } |
| |
| shader_uniform_reported_status[SHADER_UNIFORM_FS_MULTISAMPLE_ARRAY_UINT] = true; |
| } |
| else |
| { |
| TCU_FAIL("Unsupported active uniform type reported."); |
| } |
| } |
| else if (strcmp(uniform_name, "fs_sampler_2d_multisample_int") == 0) |
| { |
| if (shader_uniform_reported_status[SHADER_UNIFORM_FS_MULTISAMPLE_INT]) |
| { |
| TCU_FAIL("fs_sampler_2d_multisample_int uniform is reported more than once"); |
| } |
| |
| if (uniform_type != GL_INT_SAMPLER_2D_MULTISAMPLE) |
| { |
| TCU_FAIL("Invalid uniform type reported for fs_sampler_2d_multisample_int uniform"); |
| } |
| |
| shader_uniform_reported_status[SHADER_UNIFORM_FS_MULTISAMPLE_INT] = true; |
| } |
| else if (strcmp(uniform_name, "fs_sampler_2d_multisample_array_int") == 0) |
| { |
| if (gl_oes_texture_storage_multisample_2d_array_supported) |
| { |
| if (shader_uniform_reported_status[SHADER_UNIFORM_FS_MULTISAMPLE_ARRAY_INT]) |
| { |
| TCU_FAIL("fs_sampler_2d_multisample_array_int uniform is reported more than once"); |
| } |
| |
| if (uniform_type != GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES) |
| { |
| TCU_FAIL("Invalid uniform type reported for fs_sampler_2d_multisample_array_int uniform"); |
| } |
| |
| shader_uniform_reported_status[SHADER_UNIFORM_FS_MULTISAMPLE_ARRAY_INT] = true; |
| } |
| else |
| { |
| TCU_FAIL("Unsupported active uniform type reported."); |
| } |
| } |
| else if (strcmp(uniform_name, "vs_sampler_2d_multisample") == 0) |
| { |
| if (shader_uniform_reported_status[SHADER_UNIFORM_VS_MULTISAMPLE]) |
| { |
| TCU_FAIL("vs_sampler_2d_multisample uniform is reported more than once"); |
| } |
| |
| if (uniform_type != GL_SAMPLER_2D_MULTISAMPLE) |
| { |
| TCU_FAIL("Invalid uniform type reported for vs_sampler_2d_multisample uniform"); |
| } |
| |
| shader_uniform_reported_status[SHADER_UNIFORM_VS_MULTISAMPLE] = true; |
| } |
| else if (strcmp(uniform_name, "vs_sampler_2d_multisample_array") == 0) |
| { |
| if (gl_oes_texture_storage_multisample_2d_array_supported) |
| { |
| if (shader_uniform_reported_status[SHADER_UNIFORM_VS_MULTISAMPLE_ARRAY]) |
| { |
| TCU_FAIL("vs_sampler_2d_multisample_array uniform is reported more than once"); |
| } |
| |
| if (uniform_type != GL_SAMPLER_2D_MULTISAMPLE_ARRAY_OES) |
| { |
| TCU_FAIL("Invalid uniform type reported for vs_sampler_2d_multisample_array uniform"); |
| } |
| |
| shader_uniform_reported_status[SHADER_UNIFORM_VS_MULTISAMPLE_ARRAY] = true; |
| } |
| else |
| { |
| TCU_FAIL("Unsupported active uniform type reported."); |
| } |
| } |
| else if (strcmp(uniform_name, "vs_sampler_2d_multisample_uint") == 0) |
| { |
| if (shader_uniform_reported_status[SHADER_UNIFORM_VS_MULTISAMPLE_UINT]) |
| { |
| TCU_FAIL("vs_sampler_2d_multisample_uint uniform is reported more than once"); |
| } |
| |
| if (uniform_type != GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE) |
| { |
| TCU_FAIL("Invalid uniform type reported for vs_sampler_2d_multisample_uint uniform"); |
| } |
| |
| shader_uniform_reported_status[SHADER_UNIFORM_VS_MULTISAMPLE_UINT] = true; |
| } |
| else if (strcmp(uniform_name, "vs_sampler_2d_multisample_array_uint") == 0) |
| { |
| if (gl_oes_texture_storage_multisample_2d_array_supported) |
| { |
| if (shader_uniform_reported_status[SHADER_UNIFORM_VS_MULTISAMPLE_ARRAY_UINT]) |
| { |
| TCU_FAIL("vs_sampler_2d_multisample_array_uint uniform is reported more than once"); |
| } |
| |
| if (uniform_type != GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES) |
| { |
| TCU_FAIL("Invalid uniform type reported for vs_sampler_2d_multisample_array_uint uniform"); |
| } |
| |
| shader_uniform_reported_status[SHADER_UNIFORM_VS_MULTISAMPLE_ARRAY_UINT] = true; |
| } |
| else |
| { |
| TCU_FAIL("Unsupported active uniform type reported."); |
| } |
| } |
| else if (strcmp(uniform_name, "vs_sampler_2d_multisample_int") == 0) |
| { |
| if (shader_uniform_reported_status[SHADER_UNIFORM_VS_MULTISAMPLE_INT]) |
| { |
| TCU_FAIL("vs_sampler_2d_multisample_int uniform is reported more than once"); |
| } |
| |
| if (uniform_type != GL_INT_SAMPLER_2D_MULTISAMPLE) |
| { |
| TCU_FAIL("Invalid uniform type reported for vs_sampler_2d_multisample_int uniform"); |
| } |
| |
| shader_uniform_reported_status[SHADER_UNIFORM_VS_MULTISAMPLE_INT] = true; |
| } |
| else if (strcmp(uniform_name, "vs_sampler_2d_multisample_array_int") == 0) |
| { |
| if (gl_oes_texture_storage_multisample_2d_array_supported) |
| { |
| if (shader_uniform_reported_status[SHADER_UNIFORM_VS_MULTISAMPLE_ARRAY_INT]) |
| { |
| TCU_FAIL("vs_sampler_2d_multisample_array_int uniform is reported more than once"); |
| } |
| |
| if (uniform_type != GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES) |
| { |
| TCU_FAIL("Invalid uniform type reported for vs_sampler_2d_multisample_array_int uniform"); |
| } |
| |
| shader_uniform_reported_status[SHADER_UNIFORM_VS_MULTISAMPLE_ARRAY_INT] = true; |
| } |
| else |
| { |
| TCU_FAIL("Unsupported active uniform type reported."); |
| } |
| } |
| else |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Unrecognized active uniform [" << uniform_name |
| << "] of type [" << uniform_type << "] was reported." << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL("Unrecognized active uniform type reported."); |
| } |
| } /* for (all active uniforms) */ |
| |
| /* sampler2DMSArray, isampler2DMSArray and usampler2DMSArray are part of the |
| * OES_texture_storage_multisample_2d_array extension and should only be reported |
| * if the extension is supported */ |
| bool expected_result[SHADER_UNIFORM_COUNT] = { 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0 }; |
| bool expected_result_oes[SHADER_UNIFORM_COUNT] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; |
| |
| /* Make sure all sampler uniforms we were expecting have been reported */ |
| for (unsigned int n_sampler_type = 0; n_sampler_type < SHADER_UNIFORM_COUNT; ++n_sampler_type) |
| { |
| if (gl_oes_texture_storage_multisample_2d_array_supported) |
| { |
| if (shader_uniform_reported_status[n_sampler_type] != expected_result_oes[n_sampler_type]) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Sampler type [" << n_sampler_type |
| << "] has not been reported by glGetActiveUniform()." << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL( |
| "At least one expected multisample texture sampler has not been reported by glGetActiveUniform()"); |
| } |
| } |
| else |
| { |
| if (shader_uniform_reported_status[n_sampler_type] != expected_result[n_sampler_type]) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Sampler type [" << n_sampler_type |
| << "] has not been reported by glGetActiveUniform()." << tcu::TestLog::EndMessage; |
| |
| TCU_FAIL( |
| "At least one expected multisample texture sampler has not been reported by glGetActiveUniform()"); |
| } |
| } |
| } /* for (all shader uniform types) */ |
| |
| /* Done */ |
| deinitInternals(); |
| delete[] uniform_name; |
| uniform_name = NULL; |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| |
| } /* glcts namespace */ |