| /*------------------------------------------------------------------------- |
| * 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 esextcGPUShader5TextureGatherOffset.cpp |
| * \brief gpu_shader5 extension - texture gather offset tests (Test 9 and 10) |
| */ /*-------------------------------------------------------------------*/ |
| |
| #include "esextcGPUShader5TextureGatherOffset.hpp" |
| |
| #include "gluContextInfo.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| #include "tcuTestLog.hpp" |
| |
| #include <cstdlib> |
| #include <cstring> |
| #include <sstream> |
| |
| namespace glcts |
| { |
| |
| /* Fragment Shader for GPUShader5TextureGatherOffsetTestBase */ |
| const glw::GLchar* const GPUShader5TextureGatherOffsetTestBase::m_fragment_shader_code = |
| "${VERSION}\n" |
| "\n" |
| "${GPU_SHADER5_REQUIRE}\n" |
| "\n" |
| "precision highp float;\n" |
| "\n" |
| "layout(location = 0) out vec4 fs_out_color;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " fs_out_color = vec4(1, 1, 1, 1);\n" |
| "}\n"; |
| |
| /* Vertex Shader for GPUShader5TextureGatherOffsetColor2DRepeatCaseTest */ |
| const glw::GLchar* const GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::m_vertex_shader_code = |
| "${VERSION}\n" |
| "\n" |
| "${GPU_SHADER5_REQUIRE}\n" |
| "\n" |
| "precision highp float;\n" |
| "precision highp isampler2D;\n" |
| "\n" |
| "uniform isampler2D sampler;\n" |
| "\n" |
| "in ivec2 offsets;\n" |
| "in vec2 texCoords;\n" |
| "\n" |
| "flat out ivec4 without_offset_0;\n" |
| "flat out ivec4 without_offset_1;\n" |
| "flat out ivec4 without_offset_2;\n" |
| "flat out ivec4 without_offset_3;\n" |
| "\n" |
| "flat out ivec4 with_offset_0;\n" |
| "flat out ivec4 with_offset_1;\n" |
| "flat out ivec4 with_offset_2;\n" |
| "flat out ivec4 with_offset_3;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " without_offset_0 = textureGather (sampler, texCoords, 0);\n" |
| " without_offset_1 = textureGather (sampler, texCoords, 1);\n" |
| " without_offset_2 = textureGather (sampler, texCoords, 2);\n" |
| " without_offset_3 = textureGather (sampler, texCoords, 3);\n" |
| "\n" |
| " with_offset_0 = textureGatherOffset(sampler, texCoords, offsets, 0);\n" |
| " with_offset_1 = textureGatherOffset(sampler, texCoords, offsets, 1);\n" |
| " with_offset_2 = textureGatherOffset(sampler, texCoords, offsets, 2);\n" |
| " with_offset_3 = textureGatherOffset(sampler, texCoords, offsets, 3);\n" |
| "}\n"; |
| |
| /* Vertex Shader for GPUShader5TextureGatherOffsetColor2DArrayCaseTest */ |
| const glw::GLchar* const GPUShader5TextureGatherOffsetColor2DArrayCaseTest::m_vertex_shader_code = |
| "${VERSION}\n" |
| "\n" |
| "${GPU_SHADER5_REQUIRE}\n" |
| "\n" |
| "precision highp float;\n" |
| "precision highp isampler2DArray;\n" |
| "\n" |
| "uniform isampler2DArray sampler;\n" |
| "\n" |
| "in ivec2 offsets;\n" |
| "in vec3 texCoords;\n" |
| "\n" |
| "flat out ivec4 without_offset_0;\n" |
| "flat out ivec4 without_offset_1;\n" |
| "flat out ivec4 without_offset_2;\n" |
| "flat out ivec4 without_offset_3;\n" |
| "\n" |
| "flat out ivec4 with_offset_0;\n" |
| "flat out ivec4 with_offset_1;\n" |
| "flat out ivec4 with_offset_2;\n" |
| "flat out ivec4 with_offset_3;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " without_offset_0 = textureGather (sampler, texCoords, 0);\n" |
| " without_offset_1 = textureGather (sampler, texCoords, 1);\n" |
| " without_offset_2 = textureGather (sampler, texCoords, 2);\n" |
| " without_offset_3 = textureGather (sampler, texCoords, 3);\n" |
| "\n" |
| " with_offset_0 = textureGatherOffset(sampler, texCoords, offsets, 0);\n" |
| " with_offset_1 = textureGatherOffset(sampler, texCoords, offsets, 1);\n" |
| " with_offset_2 = textureGatherOffset(sampler, texCoords, offsets, 2);\n" |
| " with_offset_3 = textureGatherOffset(sampler, texCoords, offsets, 3);\n" |
| "}\n"; |
| |
| /* Vertex Shader for GPUShader5TextureGatherOffsetColor2DClampToBorderCaseTest */ |
| const glw::GLchar* const GPUShader5TextureGatherOffsetColor2DClampToBorderCaseTest::m_vertex_shader_code = |
| "${VERSION}\n" |
| "\n" |
| "${GPU_SHADER5_REQUIRE}\n" |
| "\n" |
| "precision highp float;\n" |
| "precision highp isampler2D;\n" |
| "\n" |
| "uniform isampler2D sampler;\n" |
| "\n" |
| "in ivec2 offsets;\n" |
| "in vec2 texCoords;\n" |
| "\n" |
| "flat out ivec4 without_offset_0;\n" |
| "flat out ivec4 without_offset_1;\n" |
| "flat out ivec4 without_offset_2;\n" |
| "flat out ivec4 without_offset_3;\n" |
| "\n" |
| "flat out ivec4 with_offset_0;\n" |
| "flat out ivec4 with_offset_1;\n" |
| "flat out ivec4 with_offset_2;\n" |
| "flat out ivec4 with_offset_3;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " vec2 floorTexCoords = floor(texCoords);\n" |
| " vec2 fractTexCoords = texCoords - floorTexCoords;\n" |
| "\n" |
| " without_offset_0 = textureGather (sampler, fractTexCoords, 0);\n" |
| " without_offset_1 = textureGather (sampler, fractTexCoords, 1);\n" |
| "\n" |
| " without_offset_2 = ivec4(int(floorTexCoords.x));\n" |
| " without_offset_3 = ivec4(int(floorTexCoords.y));\n" |
| "\n" |
| " with_offset_0 = textureGatherOffset(sampler, texCoords, offsets, 0);\n" |
| " with_offset_1 = textureGatherOffset(sampler, texCoords, offsets, 1);\n" |
| " with_offset_2 = textureGatherOffset(sampler, texCoords, offsets, 2);\n" |
| " with_offset_3 = textureGatherOffset(sampler, texCoords, offsets, 3);\n" |
| "}\n"; |
| |
| /* Vertex Shader for GPUShader5TextureGatherOffsetColor2DClampToEdgeCaseTest */ |
| const glw::GLchar* const GPUShader5TextureGatherOffsetColor2DClampToEdgeCaseTest::m_vertex_shader_code = |
| "${VERSION}\n" |
| "\n" |
| "${GPU_SHADER5_REQUIRE}\n" |
| "\n" |
| "precision highp float;\n" |
| "precision highp isampler2D;\n" |
| "\n" |
| "uniform isampler2D sampler;\n" |
| "uniform isampler2D reference_sampler;\n" |
| "\n" |
| "in ivec2 offsets;\n" |
| "in vec2 texCoords;\n" |
| "\n" |
| "flat out ivec4 without_offset_0;\n" |
| "flat out ivec4 without_offset_1;\n" |
| "flat out ivec4 without_offset_2;\n" |
| "flat out ivec4 without_offset_3;\n" |
| "\n" |
| "flat out ivec4 with_offset_0;\n" |
| "flat out ivec4 with_offset_1;\n" |
| "flat out ivec4 with_offset_2;\n" |
| "flat out ivec4 with_offset_3;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " vec2 floorTexCoords = floor(texCoords);\n" |
| " vec2 fractTexCoords = texCoords - floorTexCoords;\n" |
| "\n" |
| " without_offset_0 = textureGather (reference_sampler, fractTexCoords, 0);\n" |
| " without_offset_1 = textureGather (reference_sampler, fractTexCoords, 1);\n" |
| "\n" |
| " without_offset_2 = ivec4(int(floorTexCoords.x));\n" |
| " without_offset_3 = ivec4(int(floorTexCoords.y));\n" |
| "\n" |
| " with_offset_0 = textureGatherOffset(sampler, texCoords, offsets, 0);\n" |
| " with_offset_1 = textureGatherOffset(sampler, texCoords, offsets, 1);\n" |
| " with_offset_2 = textureGatherOffset(sampler, texCoords, offsets, 2);\n" |
| " with_offset_3 = textureGatherOffset(sampler, texCoords, offsets, 3);\n" |
| "}\n"; |
| |
| /* Vertex Shader for GPUShader5TextureGatherOffsetColor2DOffsetsCaseTest */ |
| const glw::GLchar* const GPUShader5TextureGatherOffsetColor2DOffsetsCaseTest::m_vertex_shader_code_preamble = |
| "${VERSION}\n" |
| "\n" |
| "${GPU_SHADER5_REQUIRE}\n" |
| "\n" |
| "precision highp float;\n" |
| "precision highp isampler2D;\n" |
| "\n" |
| "uniform isampler2D sampler;\n" |
| "\n" |
| "in vec2 texCoords;\n" |
| "\n" |
| "flat out ivec4 without_offset_0;\n" |
| "flat out ivec4 without_offset_1;\n" |
| "flat out ivec4 without_offset_2;\n" |
| "flat out ivec4 without_offset_3;\n" |
| "\n" |
| "flat out ivec4 with_offset_0;\n" |
| "flat out ivec4 with_offset_1;\n" |
| "flat out ivec4 with_offset_2;\n" |
| "flat out ivec4 with_offset_3;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " const ivec2 offsets[4] = \n"; |
| |
| const glw::GLchar* const GPUShader5TextureGatherOffsetColor2DOffsetsCaseTest::m_vertex_shader_code_body = |
| "\n" |
| " without_offset_0 = textureGather (sampler, texCoords, 0);\n" |
| " without_offset_1 = textureGather (sampler, texCoords, 1);\n" |
| " without_offset_2 = textureGather (sampler, texCoords, 2);\n" |
| " without_offset_3 = textureGather (sampler, texCoords, 3);\n" |
| "\n" |
| " with_offset_0 = textureGatherOffsets(sampler, texCoords, offsets, 0);\n" |
| " with_offset_1 = textureGatherOffsets(sampler, texCoords, offsets, 1);\n" |
| " with_offset_2 = textureGatherOffsets(sampler, texCoords, offsets, 2);\n" |
| " with_offset_3 = textureGatherOffsets(sampler, texCoords, offsets, 3);\n" |
| "}\n"; |
| |
| /* Vertex Shader for GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest */ |
| const glw::GLchar* const GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::m_vertex_shader_code = |
| "${VERSION}\n" |
| "\n" |
| "${GPU_SHADER5_REQUIRE}\n" |
| "\n" |
| "precision highp float;\n" |
| "precision highp sampler2DShadow;\n" |
| "\n" |
| "uniform sampler2DShadow sampler;\n" |
| "\n" |
| "in ivec2 offsets;\n" |
| "in vec2 texCoords;\n" |
| "\n" |
| "flat out ivec4 with_offset;\n" |
| "flat out ivec4 without_offset;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " ivec2 texture_size = textureSize(sampler, 0 /* lod */);\n" |
| " float step = 1.0f / float(texture_size.x);\n" |
| "\n" |
| " without_offset = ivec4(0, 0, 0, 0);\n" |
| " with_offset = ivec4(0, 0, 0, 0);\n" |
| "\n" |
| " for (int x = 0; x < texture_size.x; ++x)\n" |
| " {\n" |
| " float refZ = float(x) * step;\n" |
| "\n" |
| " without_offset += ivec4(textureGather (sampler, texCoords, refZ));\n" |
| " with_offset += ivec4(textureGatherOffset(sampler, texCoords, refZ, offsets));\n" |
| " }\n" |
| "}\n"; |
| |
| /* Vertex Shader for GPUShader5TextureGatherOffsetDepth2DRepeatYCaseTest */ |
| const glw::GLchar* const GPUShader5TextureGatherOffsetDepth2DRepeatYCaseTest::m_vertex_shader_code = |
| "${VERSION}\n" |
| "\n" |
| "${GPU_SHADER5_REQUIRE}\n" |
| "\n" |
| "precision highp float;\n" |
| "precision highp sampler2DShadow;\n" |
| "\n" |
| "uniform sampler2DShadow sampler;\n" |
| "\n" |
| "in ivec2 offsets;\n" |
| "in vec2 texCoords;\n" |
| "\n" |
| "flat out ivec4 without_offset;\n" |
| "flat out ivec4 with_offset;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " ivec2 texture_size = textureSize(sampler, 0 /* lod */);\n" |
| " float step = 1.0f / float(texture_size.y);\n" |
| "\n" |
| " without_offset = ivec4(0, 0, 0, 0);\n" |
| " with_offset = ivec4(0, 0, 0, 0);\n" |
| "\n" |
| " for (int y = 0; y < texture_size.y; ++y)\n" |
| " {\n" |
| " float refZ = float(y) * step;\n" |
| "\n" |
| " without_offset += ivec4(textureGather (sampler, texCoords, refZ));\n" |
| " with_offset += ivec4(textureGatherOffset(sampler, texCoords, refZ, offsets));\n" |
| " }\n" |
| "}\n"; |
| |
| /* Vertex Shader for GPUShader5TextureGatherOffsetDepth2DArrayCaseTest */ |
| const glw::GLchar* const GPUShader5TextureGatherOffsetDepth2DArrayCaseTest::m_vertex_shader_code = |
| "${VERSION}\n" |
| "\n" |
| "${GPU_SHADER5_REQUIRE}\n" |
| "\n" |
| "precision highp float;\n" |
| "precision highp sampler2DArrayShadow;\n" |
| "\n" |
| "uniform sampler2DArrayShadow sampler;\n" |
| "\n" |
| "in ivec2 offsets;\n" |
| "in vec3 texCoords;\n" |
| "\n" |
| "flat out ivec4 without_offset;\n" |
| "flat out ivec4 with_offset;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " ivec3 texture_size = textureSize(sampler, 0 /* lod */);\n" |
| " float step = 1.0f / float(texture_size.x);\n" |
| "\n" |
| " without_offset = ivec4(0, 0, 0, 0);\n" |
| " with_offset = ivec4(0, 0, 0, 0);\n" |
| "\n" |
| " for (int x = 0; x < texture_size.x; ++x)\n" |
| " {\n" |
| " float refZ = float(x) * step;\n" |
| "\n" |
| " without_offset += ivec4(textureGather (sampler, texCoords, refZ));\n" |
| " with_offset += ivec4(textureGatherOffset(sampler, texCoords, refZ, offsets));\n" |
| " }\n" |
| "}\n"; |
| |
| /* Vertex Shader for GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest */ |
| const glw::GLchar* const GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest::m_vertex_shader_code = |
| "${VERSION}\n" |
| "\n" |
| "${GPU_SHADER5_REQUIRE}\n" |
| "\n" |
| "precision highp float;\n" |
| "precision highp sampler2DShadow;\n" |
| "\n" |
| "uniform sampler2DShadow sampler;\n" |
| "\n" |
| "in ivec2 offsets;\n" |
| "in vec2 texCoords;\n" |
| "\n" |
| "flat out ivec4 with_offset;\n" |
| "flat out ivec4 without_offset;\n" |
| "flat out ivec4 floor_tex_coord;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " ivec2 texture_size = textureSize(sampler, 0 /* lod */);\n" |
| " float step = 1.0f / float(texture_size.x);\n" |
| "\n" |
| " vec2 floorTexCoords = floor(texCoords);\n" |
| " vec2 fractTexCoords = texCoords - floorTexCoords;\n" |
| "\n" |
| " floor_tex_coord = ivec4(ivec2(floorTexCoords.xy), 0, 0);\n" |
| "\n" |
| " without_offset = ivec4(0, 0, 0, 0);\n" |
| " with_offset = ivec4(0, 0, 0, 0);\n" |
| "\n" |
| " for (int x = 0; x < texture_size.x; ++x)\n" |
| " {\n" |
| " float refZ = float(x) * step;\n" |
| "\n" |
| " without_offset += ivec4(textureGather (sampler, fractTexCoords, refZ));\n" |
| " with_offset += ivec4(textureGatherOffset(sampler, texCoords, refZ, offsets));\n" |
| " }\n" |
| "}\n"; |
| |
| /* Vertex Shader for GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest */ |
| const glw::GLchar* const GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest::m_vertex_shader_code = |
| "${VERSION}\n" |
| "\n" |
| "${GPU_SHADER5_REQUIRE}\n" |
| "\n" |
| "precision highp float;\n" |
| "precision highp sampler2DShadow;\n" |
| "\n" |
| "uniform sampler2DShadow sampler;\n" |
| "uniform sampler2DShadow reference_sampler;\n" |
| "\n" |
| "in ivec2 offsets;\n" |
| "in vec2 texCoords;\n" |
| "\n" |
| "flat out ivec4 with_offset;\n" |
| "flat out ivec4 without_offset;\n" |
| "flat out ivec4 floor_tex_coord;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " ivec2 texture_size = textureSize(sampler, 0 /* lod */);\n" |
| " float step = 1.0f / float(texture_size.x);\n" |
| "\n" |
| " vec2 floorTexCoords = floor(texCoords);\n" |
| " vec2 fractTexCoords = texCoords - floorTexCoords;\n" |
| "\n" |
| " floor_tex_coord = ivec4(ivec2(floorTexCoords.xy), 0, 0);\n" |
| "\n" |
| " without_offset = ivec4(0, 0, 0, 0);\n" |
| " with_offset = ivec4(0, 0, 0, 0);\n" |
| "\n" |
| " for (int x = 0; x < texture_size.x; ++x)\n" |
| " {\n" |
| " float refZ = float(x) * step;\n" |
| "\n" |
| " without_offset += ivec4(textureGather (reference_sampler, fractTexCoords, refZ));\n" |
| " with_offset += ivec4(textureGatherOffset(sampler, texCoords, refZ, offsets));\n" |
| " }\n" |
| "}\n"; |
| |
| /* Vertex Shader for GPUShader5TextureGatherOffsetDepth2DOffsetsCaseTest */ |
| const glw::GLchar* const GPUShader5TextureGatherOffsetDepth2DOffsetsCaseTest::m_vertex_shader_code_preamble = |
| "${VERSION}\n" |
| "\n" |
| "${GPU_SHADER5_REQUIRE}\n" |
| "\n" |
| "precision highp float;\n" |
| "precision highp sampler2DShadow;\n" |
| "\n" |
| "uniform sampler2DShadow sampler;\n" |
| "\n" |
| "in vec2 texCoords;\n" |
| "\n" |
| "flat out ivec4 without_offset;\n" |
| "flat out ivec4 with_offset;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " const ivec2 offsets[4] =\n"; |
| |
| const glw::GLchar* const GPUShader5TextureGatherOffsetDepth2DOffsetsCaseTest::m_vertex_shader_code_body = |
| "\n" |
| " ivec2 texture_size = textureSize(sampler, 0 /* lod */);\n" |
| " float step = 1.0f / float(texture_size.x);\n" |
| "\n" |
| " without_offset = ivec4(0, 0, 0, 0);\n" |
| " with_offset = ivec4(0, 0, 0, 0);\n" |
| "\n" |
| " for (int x = 0; x < texture_size.x; ++x)\n" |
| " {\n" |
| " float refZ = float(x) * step;\n" |
| "\n" |
| " without_offset += ivec4(textureGather (sampler, texCoords, refZ));\n" |
| " with_offset += ivec4(textureGatherOffsets(sampler, texCoords, refZ, offsets));\n" |
| " }\n" |
| "}\n"; |
| |
| /* Constants for GPUShader5TextureGatherOffsetTestBase */ |
| const glw::GLchar* const GPUShader5TextureGatherOffsetTestBase::m_coordinates_attribute_name = "texCoords"; |
| const int GPUShader5TextureGatherOffsetTestBase::m_coordinate_resolution = 1024; |
| const int GPUShader5TextureGatherOffsetTestBase::m_max_coordinate_value = 8; |
| const int GPUShader5TextureGatherOffsetTestBase::m_min_coordinate_value = -8; |
| const unsigned int GPUShader5TextureGatherOffsetTestBase::m_n_components_per_varying = 4; |
| const unsigned int GPUShader5TextureGatherOffsetTestBase::m_n_texture_array_length = 4; |
| const unsigned int GPUShader5TextureGatherOffsetTestBase::m_n_vertices = 128; |
| const glw::GLchar* const GPUShader5TextureGatherOffsetTestBase::m_sampler_uniform_name = "sampler"; |
| const glw::GLchar* const GPUShader5TextureGatherOffsetTestBase::m_reference_sampler_uniform_name = "reference_sampler"; |
| |
| /* Constants for GPUShader5TextureGatherOffsetColorTestBase */ |
| const unsigned int GPUShader5TextureGatherOffsetColorTestBase::m_texture_size = 64; |
| |
| /* Constants for GPUShader5TextureGatherOffsetDepthTestBase */ |
| const unsigned int GPUShader5TextureGatherOffsetDepthTestBase::m_texture_size = 64; |
| |
| /* Constants for GPUShader5TextureGatherOffsetColor2DRepeatCaseTest */ |
| const glw::GLchar* const GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::m_offsets_attribute_name = "offsets"; |
| const unsigned int GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::m_n_offsets_components = 2; |
| |
| /* Constants for GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest */ |
| const glw::GLchar* const GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::m_offsets_attribute_name = "offsets"; |
| const unsigned int GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::m_n_offsets_components = 2; |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| **/ |
| GPUShader5TextureGatherOffsetTestBase::GPUShader5TextureGatherOffsetTestBase(Context& context, |
| const ExtParameters& extParams, |
| const char* name, const char* description) |
| : TestCaseBase(context, extParams, name, description) |
| , m_min_texture_gather_offset(0) |
| , m_max_texture_gather_offset(0) |
| , m_fragment_shader_id(0) |
| , m_program_object_id(0) |
| , m_vertex_shader_id(0) |
| , m_vertex_array_object_id(0) |
| , m_texture_object_id(0) |
| , m_sampler_object_id(0) |
| , m_is_texture_array(0) |
| , m_texture_bytes_per_pixel(0) |
| , m_texture_format(0) |
| , m_texture_internal_format(0) |
| , m_texture_type(0) |
| , m_texture_size(0) |
| , m_texture_wrap_mode(0) |
| , m_transform_feedback_buffer_size(0) |
| , m_transform_feedback_buffer_object_id(0) |
| , m_n_coordinates_components(0) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Deinitializes GLES objects created during the test. |
| * |
| */ |
| void GPUShader5TextureGatherOffsetTestBase::deinit() |
| { |
| /* GL */ |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Bind default values */ |
| gl.useProgram(0); |
| gl.bindVertexArray(0); |
| gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* offset */, 0 /* id */); |
| gl.bindBuffer(GL_ARRAY_BUFFER, 0); |
| |
| /* Delete everything */ |
| if (0 != m_vertex_array_object_id) |
| { |
| gl.deleteVertexArrays(1, &m_vertex_array_object_id); |
| |
| m_vertex_array_object_id = 0; |
| } |
| |
| if (0 != m_transform_feedback_buffer_object_id) |
| { |
| gl.deleteBuffers(1, &m_transform_feedback_buffer_object_id); |
| |
| m_transform_feedback_buffer_object_id = 0; |
| } |
| |
| if (false == m_vertex_buffer_ids.empty()) |
| { |
| gl.deleteBuffers((glw::GLsizei)m_vertex_buffer_ids.size(), &m_vertex_buffer_ids[0]); |
| } |
| |
| if (0 != m_program_object_id) |
| { |
| gl.deleteProgram(m_program_object_id); |
| |
| m_program_object_id = 0; |
| } |
| |
| if (0 != m_fragment_shader_id) |
| { |
| gl.deleteShader(m_fragment_shader_id); |
| |
| m_fragment_shader_id = 0; |
| } |
| |
| if (0 != m_vertex_shader_id) |
| { |
| gl.deleteShader(m_vertex_shader_id); |
| |
| m_vertex_shader_id = 0; |
| } |
| |
| if (0 != m_texture_object_id) |
| { |
| gl.deleteTextures(1, &m_texture_object_id); |
| |
| m_texture_object_id = 0; |
| } |
| |
| if (0 != m_sampler_object_id) |
| { |
| gl.deleteSamplers(1, &m_sampler_object_id); |
| |
| m_sampler_object_id = 0; |
| } |
| |
| /* Deinitialize base */ |
| TestCaseBase::deinit(); |
| } |
| |
| /** Initializes GLES objects used during the test. |
| * |
| */ |
| void GPUShader5TextureGatherOffsetTestBase::initTest() |
| { |
| /* This test should only run if EXT_gpu_shader5 is supported */ |
| if (true != m_is_gpu_shader5_supported) |
| { |
| throw tcu::NotSupportedError(GPU_SHADER5_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__); |
| } |
| |
| /* GL */ |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Get minimum and maximum texture gather offsets */ |
| gl.getIntegerv(GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET, &m_min_texture_gather_offset); |
| gl.getIntegerv(GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET, &m_max_texture_gather_offset); |
| |
| GLU_EXPECT_NO_ERROR( |
| gl.getError(), |
| "Failed to get value of GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET or GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET"); |
| |
| /* Get details for transform feedback from child class */ |
| getTransformFeedBackDetails(m_transform_feedback_buffer_size, m_captured_varying_names); |
| |
| /* Get shaders' code from children class */ |
| getShaderParts(m_vertex_shader_parts); |
| |
| /* Create program and shaders */ |
| m_program_object_id = gl.createProgram(); |
| |
| m_fragment_shader_id = gl.createShader(GL_FRAGMENT_SHADER); |
| m_vertex_shader_id = gl.createShader(GL_VERTEX_SHADER); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create program or shader object(s)"); |
| |
| /* Set up transform feedback */ |
| gl.transformFeedbackVaryings(m_program_object_id, (glw::GLsizei)m_captured_varying_names.size(), |
| &m_captured_varying_names[0], GL_INTERLEAVED_ATTRIBS); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() call failed"); |
| |
| /* Build program */ |
| if (false == buildProgram(m_program_object_id, m_fragment_shader_id, 1 /* number of FS parts */, |
| &m_fragment_shader_code, m_vertex_shader_id, (unsigned int)m_vertex_shader_parts.size(), |
| &m_vertex_shader_parts[0])) |
| { |
| TCU_FAIL("Could not create program from valid vertex/geometry/fragment shader"); |
| } |
| |
| /* Set program as active */ |
| gl.useProgram(m_program_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed"); |
| |
| /* Generate and bind VAO */ |
| gl.genVertexArrays(1, &m_vertex_array_object_id); |
| gl.bindVertexArray(m_vertex_array_object_id); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create vertex array object"); |
| |
| /* Generate, bind and allocate buffer */ |
| gl.genBuffers(1, &m_transform_feedback_buffer_object_id); |
| gl.bindBuffer(GL_ARRAY_BUFFER, m_transform_feedback_buffer_object_id); |
| gl.bufferData(GL_ARRAY_BUFFER, m_transform_feedback_buffer_size, 0 /* no start data */, GL_STATIC_DRAW); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create buffer object"); |
| |
| gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_transform_feedback_buffer_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed"); |
| |
| /* Create and fill texture */ |
| prepareTexture(); |
| |
| /* Let inheriting class prepare test specific input for program */ |
| prepareProgramInput(); |
| } |
| |
| /** Executes the test. |
| * Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise. |
| * |
| * @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again. |
| * |
| * Note the function throws exception should an error occur! |
| **/ |
| tcu::TestCase::IterateResult GPUShader5TextureGatherOffsetTestBase::iterate() |
| { |
| initTest(); |
| |
| /* Retrieve ES entrypoints */ |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Verification result */ |
| bool result = false; |
| |
| /* Setup transform feedback */ |
| gl.enable(GL_RASTERIZER_DISCARD); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable(GL_RASTERIZER_DISCARD) call failed"); |
| |
| gl.beginTransformFeedback(GL_POINTS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed"); |
| { |
| /* Draw */ |
| gl.drawArrays(GL_POINTS, 0 /* first */, m_n_vertices); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed"); |
| } |
| /* Stop transform feedback */ |
| gl.endTransformFeedback(); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed"); |
| |
| gl.disable(GL_RASTERIZER_DISCARD); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable(GL_RASTERIZER_DISCARD) call failed"); |
| |
| /* Map transfrom feedback results */ |
| const void* transform_feedback_data = gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* offset */, |
| m_transform_feedback_buffer_size, GL_MAP_READ_BIT); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not map the buffer object into process space"); |
| |
| /* Verify data extracted from transfrom feedback */ |
| result = verifyResult(transform_feedback_data); |
| |
| /* Unmap transform feedback buffer */ |
| gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Error unmapping the buffer object"); |
| |
| /* Verify results */ |
| if (true != result) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| else |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| |
| return STOP; |
| } |
| |
| /** Logs array of ints |
| * Format: description ( e1 e2 ... eN ) |
| * |
| * @param data Array of ints |
| * @param length Number of elements to log |
| * @param description Description string |
| **/ |
| void GPUShader5TextureGatherOffsetTestBase::logArray(const glw::GLint* data, unsigned int length, |
| const char* description) |
| { |
| /* Message object */ |
| tcu::MessageBuilder message = m_testCtx.getLog() << tcu::TestLog::Message; |
| |
| /* Adds description */ |
| message << description; |
| |
| /* Begin array */ |
| message << "( "; |
| |
| /* For each varying */ |
| for (unsigned int i = 0; i < length; ++i) |
| { |
| message << data[i] << " "; |
| } |
| |
| /* End array */ |
| message << ") "; |
| |
| message << tcu::TestLog::EndMessage; |
| } |
| |
| /** Logs coordinates for vertex at given index |
| * Format: Texture coordinates (range [0:1]): [x, y, .. ] |
| * |
| * @param index Index of vertex |
| **/ |
| void GPUShader5TextureGatherOffsetTestBase::logCoordinates(unsigned int index) |
| { |
| /* Message object */ |
| tcu::MessageBuilder message = m_testCtx.getLog() << tcu::TestLog::Message; |
| |
| /* Begin array */ |
| message << "Texture coordinates (range [0:1]): ["; |
| |
| /* Component index */ |
| unsigned int i = 0; |
| |
| while (1) |
| { |
| message << m_coordinates_buffer_data[index * m_n_coordinates_components + i]; |
| |
| i += 1; |
| |
| if (i >= m_n_coordinates_components) |
| { |
| break; |
| } |
| else |
| { |
| message << ", "; |
| } |
| } |
| |
| /* End array */ |
| message << "]" << tcu::TestLog::EndMessage; |
| } |
| |
| /** Prepare buffers for vertex attributes |
| * |
| **/ |
| void GPUShader5TextureGatherOffsetTestBase::prepareProgramInput() |
| { |
| /* GL */ |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Get vertex buffer infos from child class */ |
| prepareVertexBuffersData(m_vertex_buffer_infos); |
| |
| /* Prepare info for coordinates */ |
| prepareVertexBufferInfoForCoordinates(); |
| |
| /* Constant for number of vertex buffers */ |
| const unsigned int n_vertex_buffers = (unsigned int)m_vertex_buffer_infos.size(); |
| |
| /* Prepare storage for vertex buffer ids */ |
| m_vertex_buffer_ids.resize(n_vertex_buffers); |
| |
| /* Generate buffers */ |
| gl.genBuffers(n_vertex_buffers, &m_vertex_buffer_ids[0]); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create vertex buffers"); |
| |
| /* Setup each vertex buffer */ |
| for (unsigned int i = 0; i < n_vertex_buffers; ++i) |
| { |
| /* References for i-th vertex buffer */ |
| glw::GLuint vertex_buffer_id = m_vertex_buffer_ids[i]; |
| VertexBufferInfo& vertex_buffer_info = m_vertex_buffer_infos[i]; |
| |
| /* Get attribute location */ |
| glw::GLint attribute_location = |
| gl.getAttribLocation(m_program_object_id, m_vertex_buffer_infos[i].attribute_name); |
| |
| if ((-1 == attribute_location) || (GL_NO_ERROR != gl.getError())) |
| { |
| TCU_FAIL("Failed to get location of attribute"); |
| } |
| |
| /* Setup buffer for offsets attribute */ |
| gl.bindBuffer(GL_ARRAY_BUFFER, vertex_buffer_id); |
| gl.bufferData(GL_ARRAY_BUFFER, vertex_buffer_info.data_size, vertex_buffer_info.data, GL_STATIC_DRAW); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to fill vertex buffer with data"); |
| |
| /* Setup attribute */ |
| gl.enableVertexAttribArray(attribute_location); |
| |
| if (GL_INT == vertex_buffer_info.type) |
| { |
| gl.vertexAttribIPointer(attribute_location, vertex_buffer_info.n_components, vertex_buffer_info.type, |
| 0 /* stride */, 0 /* offset */); |
| } |
| else |
| { |
| gl.vertexAttribPointer(attribute_location, vertex_buffer_info.n_components, vertex_buffer_info.type, |
| GL_FALSE /* normalization */, 0 /* stride */, 0 /* offset */); |
| } |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to setup vertex attribute arrays"); |
| } |
| |
| /* Get sampler location */ |
| glw::GLint sampler_location = gl.getUniformLocation(m_program_object_id, m_sampler_uniform_name); |
| |
| if ((-1 == sampler_location) || (GL_NO_ERROR != gl.getError())) |
| { |
| TCU_FAIL("Failed to get location of uniform \"sampler\""); |
| } |
| |
| /* Set uniform at sampler location value to index of first texture unit */ |
| gl.uniform1i(sampler_location, 0 /* first texture unit */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set uniform value"); |
| |
| if (GL_CLAMP_TO_EDGE == m_texture_wrap_mode) |
| { |
| /* Get reference_sampler location */ |
| glw::GLint reference_sampler_location = |
| gl.getUniformLocation(m_program_object_id, m_reference_sampler_uniform_name); |
| |
| if ((-1 == reference_sampler_location) || (GL_NO_ERROR != gl.getError())) |
| { |
| TCU_FAIL("Failed to get location of uniform \"reference sampler\""); |
| } |
| |
| /* Set uniform at reference_sampler location value to index of second texture unit */ |
| gl.uniform1i(reference_sampler_location, 1 /* second texture unit */); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set uniform value"); |
| } |
| } |
| |
| /** Prepare texture and bind it to sampler |
| * |
| **/ |
| void GPUShader5TextureGatherOffsetTestBase::prepareTexture() |
| { |
| /* Retrieve ES entrypoints */ |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| /* Get texture info from child class */ |
| getTextureInfo(m_texture_size, m_texture_internal_format, m_texture_format, m_texture_type, |
| m_texture_bytes_per_pixel); |
| |
| isTextureArray(m_is_texture_array); |
| getTextureWrapMode(m_texture_wrap_mode); |
| |
| /* Verify that recieved texture parameters are valid */ |
| glw::GLint max_texture_size = 0; |
| |
| gl.getIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_TEXTURE_SIZE pname"); |
| |
| if (m_texture_size > (glw::GLuint)max_texture_size) |
| { |
| throw tcu::NotSupportedError("Required texture dimmensions exceeds GL_MAX_TEXTURE_SIZE limit", "", __FILE__, |
| __LINE__); |
| } |
| |
| /* Activate first texture unit */ |
| gl.activeTexture(GL_TEXTURE0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture(GL_TEXTURE0) failed"); |
| |
| /* Generate and allocate texture */ |
| gl.genTextures(1, &m_texture_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() call failed"); |
| |
| if (true == m_is_texture_array) |
| { |
| gl.bindTexture(GL_TEXTURE_2D_ARRAY, m_texture_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() call failed"); |
| |
| gl.texStorage3D(GL_TEXTURE_2D_ARRAY, 1 /* levels */, m_texture_internal_format, m_texture_size, m_texture_size, |
| m_n_texture_array_length); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage3D() call failed"); |
| } |
| else |
| { |
| gl.bindTexture(GL_TEXTURE_2D, m_texture_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() call failed"); |
| |
| gl.texStorage2D(GL_TEXTURE_2D, 1 /* levels */, m_texture_internal_format, m_texture_size, m_texture_size); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() call failed"); |
| } |
| |
| /* Storage for texture data */ |
| std::vector<glw::GLubyte> texture_data; |
| |
| texture_data.resize(m_texture_size * m_texture_size * m_texture_bytes_per_pixel); |
| |
| /* Let child class prepare data for texture */ |
| prepareTextureData(&texture_data[0]); |
| |
| /* Update texture data */ |
| if (true == m_is_texture_array) |
| { |
| for (unsigned int z = 0; z < m_n_texture_array_length; ++z) |
| { |
| gl.texSubImage3D(GL_TEXTURE_2D_ARRAY, 0 /* level */, 0 /* x */, 0 /* y */, z, m_texture_size, |
| m_texture_size, 1 /* depth */, m_texture_format, m_texture_type, &texture_data[0]); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to update texture data"); |
| } |
| } |
| else |
| { |
| gl.texSubImage2D(GL_TEXTURE_2D, 0 /* level */, 0 /* x */, 0 /* y */, m_texture_size, m_texture_size, |
| m_texture_format, m_texture_type, &texture_data[0]); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to update texture data"); |
| } |
| |
| /* Set shadow comparison, filtering and wrap modes */ |
| glw::GLenum texture_target; |
| |
| if (true == m_is_texture_array) |
| { |
| texture_target = GL_TEXTURE_2D_ARRAY; |
| } |
| else |
| { |
| texture_target = GL_TEXTURE_2D; |
| } |
| |
| /* Storage for border color */ |
| glw::GLfloat color[4]; |
| |
| /* Get border color */ |
| getBorderColor(color); |
| |
| gl.texParameteri(texture_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| gl.texParameteri(texture_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| gl.texParameteri(texture_target, GL_TEXTURE_WRAP_S, m_texture_wrap_mode); |
| gl.texParameteri(texture_target, GL_TEXTURE_WRAP_T, m_texture_wrap_mode); |
| gl.texParameteri(texture_target, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); |
| gl.texParameteri(texture_target, GL_TEXTURE_COMPARE_FUNC, GL_LESS); |
| |
| /* Set border color when "clamp to border" mode is selected */ |
| if (m_glExtTokens.CLAMP_TO_BORDER == m_texture_wrap_mode) |
| { |
| gl.texParameterfv(texture_target, m_glExtTokens.TEXTURE_BORDER_COLOR, color); |
| } |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set texture parameters"); |
| |
| /* Setup texture unit for reference_sampler */ |
| if (GL_CLAMP_TO_EDGE == m_texture_wrap_mode) |
| { |
| /* Activate second texture unit */ |
| gl.activeTexture(GL_TEXTURE1); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture(GL_TEXTURE1) failed"); |
| |
| /* Bind texture */ |
| gl.bindTexture(texture_target, m_texture_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture failed"); |
| |
| /* Generate sampler */ |
| gl.genSamplers(1, &m_sampler_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to generate sampler"); |
| |
| /* Bind sampler to second texture unit */ |
| gl.bindSampler(1, m_sampler_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to bind sampler to unit 1"); |
| |
| /* Set sampler parameters */ |
| gl.samplerParameteri(m_sampler_object_id, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| gl.samplerParameteri(m_sampler_object_id, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| gl.samplerParameteri(m_sampler_object_id, GL_TEXTURE_WRAP_S, m_glExtTokens.CLAMP_TO_BORDER); |
| gl.samplerParameteri(m_sampler_object_id, GL_TEXTURE_WRAP_T, m_glExtTokens.CLAMP_TO_BORDER); |
| gl.samplerParameteri(m_sampler_object_id, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); |
| gl.samplerParameteri(m_sampler_object_id, GL_TEXTURE_COMPARE_FUNC, GL_LESS); |
| gl.samplerParameterfv(m_sampler_object_id, m_glExtTokens.TEXTURE_BORDER_COLOR, color); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set sampler parameters"); |
| } |
| } |
| |
| /** Prepare buffer for texture coordinates |
| * |
| **/ |
| void GPUShader5TextureGatherOffsetTestBase::prepareVertexBufferInfoForCoordinates() |
| { |
| /* Select proper number of components */ |
| if (true == m_is_texture_array) |
| { |
| m_n_coordinates_components = 3; |
| } |
| else |
| { |
| m_n_coordinates_components = 2; |
| } |
| |
| /* Prepare storage for texture coordinates */ |
| m_coordinates_buffer_data.resize(m_n_vertices * m_n_coordinates_components); |
| |
| /* Variables for calculation of texture coordiantes' range and offsets */ |
| const float coordinate_denominator = m_coordinate_resolution; |
| int x_modulus; |
| float x_offset; |
| float x_range; |
| int y_modulus; |
| float y_offset; |
| float y_range; |
| |
| /* Calculation of texture coordiantes' range and offsets */ |
| x_range = m_max_coordinate_value - m_min_coordinate_value; |
| y_range = m_max_coordinate_value - m_min_coordinate_value; |
| |
| x_offset = m_min_coordinate_value; |
| y_offset = m_min_coordinate_value; |
| |
| x_range *= coordinate_denominator; |
| y_range *= coordinate_denominator; |
| |
| x_modulus = (int)x_range; |
| y_modulus = (int)y_range; |
| |
| /* Prepare texture coordinates */ |
| if (true == m_is_texture_array) |
| { |
| /* First four coordinates are corners, each comes from unique level */ |
| setCoordinatesData(0.0f, 0.0f, 0.0f, 0); |
| setCoordinatesData(0.0f, 1.0f, 1.0f, 1); |
| setCoordinatesData(1.0f, 0.0f, 2.0f, 2); |
| setCoordinatesData(1.0f, 1.0f, 3.0f, 3); |
| |
| /* Generate rest of texture coordinates */ |
| for (unsigned int i = 4; i < m_n_vertices; ++i) |
| { |
| const glw::GLfloat coord_x = ((float)(rand() % x_modulus)) / coordinate_denominator + x_offset; |
| const glw::GLfloat coord_y = ((float)(rand() % y_modulus)) / coordinate_denominator + y_offset; |
| const glw::GLfloat coord_z = |
| ((float)(rand() % m_n_texture_array_length * m_coordinate_resolution)) / coordinate_denominator; |
| |
| setCoordinatesData(coord_x, coord_y, coord_z, i); |
| } |
| } |
| else |
| { |
| /* First four coordinates are corners */ |
| setCoordinatesData(0.0f, 0.0f, 0); |
| setCoordinatesData(0.0f, 1.0f, 1); |
| setCoordinatesData(1.0f, 0.0f, 2); |
| setCoordinatesData(1.0f, 1.0f, 3); |
| |
| /* Generate rest of texture coordinates */ |
| for (unsigned int i = 4; i < m_n_vertices; ++i) |
| { |
| const glw::GLfloat coord_x = ((float)(rand() % x_modulus)) / coordinate_denominator + x_offset; |
| const glw::GLfloat coord_y = ((float)(rand() % y_modulus)) / coordinate_denominator + y_offset; |
| |
| setCoordinatesData(coord_x, coord_y, i); |
| } |
| } |
| |
| /* Setup coordinates VB info */ |
| VertexBufferInfo info; |
| |
| info.attribute_name = m_coordinates_attribute_name; |
| info.n_components = m_n_coordinates_components; |
| info.type = GL_FLOAT; |
| info.data = &m_coordinates_buffer_data[0]; |
| info.data_size = (glw::GLuint)(m_coordinates_buffer_data.size() * sizeof(glw::GLfloat)); |
| |
| /* Store results */ |
| m_vertex_buffer_infos.push_back(info); |
| } |
| |
| /** Set 2D texture coordinate for vertex at given index |
| * |
| * @param x X coordinate |
| * @param y Y coordinate |
| * @param index Index of vertex |
| **/ |
| void GPUShader5TextureGatherOffsetTestBase::setCoordinatesData(glw::GLfloat x, glw::GLfloat y, unsigned int index) |
| { |
| const unsigned int vertex_offset = m_n_coordinates_components * index; |
| |
| m_coordinates_buffer_data[vertex_offset + 0] = x; |
| m_coordinates_buffer_data[vertex_offset + 1] = y; |
| } |
| |
| /** Set 3D texture coordinate for vertex at given index |
| * |
| * @param x X coordinate |
| * @param y Y coordinate |
| * @param z Z coordinate |
| * @param index Index of vertex |
| **/ |
| void GPUShader5TextureGatherOffsetTestBase::setCoordinatesData(glw::GLfloat x, glw::GLfloat y, glw::GLfloat z, |
| unsigned int index) |
| { |
| const unsigned int vertex_offset = m_n_coordinates_components * index; |
| |
| m_coordinates_buffer_data[vertex_offset + 0] = x; |
| m_coordinates_buffer_data[vertex_offset + 1] = y; |
| m_coordinates_buffer_data[vertex_offset + 2] = z; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| **/ |
| GPUShader5TextureGatherOffsetColorTestBase::GPUShader5TextureGatherOffsetColorTestBase(Context& context, |
| const ExtParameters& extParams, |
| const char* name, |
| const char* description) |
| : GPUShader5TextureGatherOffsetTestBase(context, extParams, name, description), m_n_varyings_per_vertex(0) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Provides color that will be used as border color for "clamp to border" mode |
| * |
| * @param out_color Color |
| **/ |
| void GPUShader5TextureGatherOffsetColorTestBase::getBorderColor(glw::GLfloat out_color[4]) |
| { |
| out_color[0] = -1.0f; |
| out_color[1] = -1.0f; |
| out_color[2] = -1.0f; |
| out_color[3] = -1.0f; |
| } |
| |
| /** Provides informations required to create texture |
| * |
| * @param out_size Size of texture |
| * @param out_texture_internal_format Internal format of texture |
| * @param out_texture_format Format of texture |
| * @param out_texture_type Type of texture |
| * @param out_bytes_per_pixel Bytes per pixel |
| **/ |
| void GPUShader5TextureGatherOffsetColorTestBase::getTextureInfo(glw::GLuint& out_size, |
| glw::GLenum& out_texture_internal_format, |
| glw::GLenum& out_texture_format, |
| glw::GLenum& out_texture_type, |
| glw::GLuint& out_bytes_per_pixel) |
| { |
| out_size = m_texture_size; |
| out_texture_internal_format = GL_RGBA32I; |
| out_texture_format = GL_RGBA_INTEGER; |
| out_texture_type = GL_INT; |
| out_bytes_per_pixel = 4 * sizeof(glw::GLint); /* RGBA * int */ |
| } |
| |
| /** Get wrap mode for texture |
| * |
| * @param out_wrap_mode Wrap mode |
| **/ |
| void GPUShader5TextureGatherOffsetColorTestBase::getTextureWrapMode(glw::GLenum& out_wrap_mode) |
| { |
| out_wrap_mode = GL_REPEAT; |
| } |
| |
| /** Get size of buffer used as output from transform feedback and names of varyings |
| * |
| * @param out_buffer_size Size of buffer |
| * @param out_captured_varyings Names of varyings |
| **/ |
| void GPUShader5TextureGatherOffsetColorTestBase::getTransformFeedBackDetails( |
| glw::GLuint& out_buffer_size, std::vector<const glw::GLchar*>& out_captured_varyings) |
| { |
| out_captured_varyings.reserve(8); |
| out_captured_varyings.push_back("without_offset_0"); |
| out_captured_varyings.push_back("with_offset_0"); |
| out_captured_varyings.push_back("without_offset_1"); |
| out_captured_varyings.push_back("with_offset_1"); |
| out_captured_varyings.push_back("without_offset_2"); |
| out_captured_varyings.push_back("with_offset_2"); |
| out_captured_varyings.push_back("without_offset_3"); |
| out_captured_varyings.push_back("with_offset_3"); |
| |
| m_n_varyings_per_vertex = (unsigned int)out_captured_varyings.size(); |
| |
| out_buffer_size = static_cast<glw::GLuint>(m_n_vertices * m_n_varyings_per_vertex * m_n_components_per_varying * |
| sizeof(glw::GLint)); |
| } |
| |
| /** Check if texture array is required |
| * |
| * @param out_is_texture_array Set to true if texture array is required, false otherwise |
| **/ |
| void GPUShader5TextureGatherOffsetColorTestBase::isTextureArray(bool& out_is_texture_array) |
| { |
| out_is_texture_array = false; |
| } |
| |
| /** Prepare texture data as expected by all cases in test 9. |
| * Each texel is assigned {x, y, x, y}, where x and y are coordinates of texel. |
| * |
| * @param data Storage space for texture data |
| **/ |
| void GPUShader5TextureGatherOffsetColorTestBase::prepareTextureData(glw::GLubyte* data) |
| { |
| /* Data pointer */ |
| glw::GLint* texture_data = (glw::GLint*)data; |
| |
| /* Constants */ |
| const unsigned int n_components_per_pixel = 4; |
| const unsigned int line_size = n_components_per_pixel * m_texture_size; |
| |
| /* Prepare texture's data */ |
| for (unsigned int y = 0; y < m_texture_size; ++y) |
| { |
| for (unsigned int x = 0; x < m_texture_size; ++x) |
| { |
| const unsigned int pixel_offset = y * line_size + x * n_components_per_pixel; |
| |
| /* texel.r = x, texel.g = y */ |
| texture_data[pixel_offset + 0] = x; |
| texture_data[pixel_offset + 1] = y; |
| |
| /* texel.b = x, texel.a = y */ |
| texture_data[pixel_offset + 2] = x; |
| texture_data[pixel_offset + 3] = y; |
| } |
| } |
| } |
| |
| /** Verification of results |
| * |
| * @param result Pointer to data mapped from transform feedback buffer. Size of |
| * data is equal to buffer_size set by getTransformFeedbackBufferSize |
| * |
| * @return true Result match expected value |
| * false Result has wrong value |
| **/ |
| bool GPUShader5TextureGatherOffsetColorTestBase::verifyResult(const void* result_data) |
| { |
| /* All data stored in data are ints */ |
| glw::GLint* results = (glw::GLint*)result_data; |
| |
| /* Verification result */ |
| bool result = true; |
| |
| /* Constants for data offsets calculation */ |
| const unsigned int vertex_size_in_results_buffer = m_n_varyings_per_vertex * m_n_components_per_varying; |
| const unsigned int bytes_per_varying = m_n_components_per_varying * sizeof(glw::GLint); |
| const unsigned int vertex_varying_0_offset = 0; |
| const unsigned int vertex_varying_1_offset = vertex_varying_0_offset + 2 * m_n_components_per_varying; |
| const unsigned int vertex_varying_2_offset = vertex_varying_1_offset + 2 * m_n_components_per_varying; |
| const unsigned int vertex_varying_3_offset = vertex_varying_2_offset + 2 * m_n_components_per_varying; |
| const unsigned int with_offset_offset = m_n_components_per_varying; |
| const unsigned int without_offset_offset = 0; |
| |
| /* For each vertex */ |
| for (unsigned int vertex = 0; vertex < m_n_vertices; ++vertex) |
| { |
| CapturedVaryings captured_data; |
| |
| /* Pointers to all varyings for given vertex */ |
| const glw::GLint* without_offset_0 = |
| results + vertex_varying_0_offset + (vertex * vertex_size_in_results_buffer) + without_offset_offset; |
| const glw::GLint* with_offset_0 = |
| results + vertex_varying_0_offset + (vertex * vertex_size_in_results_buffer) + with_offset_offset; |
| |
| const glw::GLint* without_offset_1 = |
| results + vertex_varying_1_offset + (vertex * vertex_size_in_results_buffer) + without_offset_offset; |
| const glw::GLint* with_offset_1 = |
| results + vertex_varying_1_offset + (vertex * vertex_size_in_results_buffer) + with_offset_offset; |
| |
| const glw::GLint* without_offset_2 = |
| results + vertex_varying_2_offset + (vertex * vertex_size_in_results_buffer) + without_offset_offset; |
| const glw::GLint* with_offset_2 = |
| results + vertex_varying_2_offset + (vertex * vertex_size_in_results_buffer) + with_offset_offset; |
| |
| const glw::GLint* without_offset_3 = |
| results + vertex_varying_3_offset + (vertex * vertex_size_in_results_buffer) + without_offset_offset; |
| const glw::GLint* with_offset_3 = |
| results + vertex_varying_3_offset + (vertex * vertex_size_in_results_buffer) + with_offset_offset; |
| |
| /* Copy captured varyings to captured_data instance */ |
| memcpy(captured_data.without_offset_0, without_offset_0, bytes_per_varying); |
| memcpy(captured_data.without_offset_1, without_offset_1, bytes_per_varying); |
| memcpy(captured_data.without_offset_2, without_offset_2, bytes_per_varying); |
| memcpy(captured_data.without_offset_3, without_offset_3, bytes_per_varying); |
| |
| memcpy(captured_data.with_offset_0, with_offset_0, bytes_per_varying); |
| memcpy(captured_data.with_offset_1, with_offset_1, bytes_per_varying); |
| memcpy(captured_data.with_offset_2, with_offset_2, bytes_per_varying); |
| memcpy(captured_data.with_offset_3, with_offset_3, bytes_per_varying); |
| |
| /* Let child class check if result is ok */ |
| const bool is_result_ok = checkResult(captured_data, vertex, m_texture_size); |
| |
| /* Do not break on first error */ |
| if (false == is_result_ok) |
| { |
| result = false; |
| } |
| } |
| |
| /* Done */ |
| return result; |
| } |
| |
| /** Logs data captured varyings |
| * |
| * @param varyings Instance of capturedVaryings to be logged |
| **/ |
| void GPUShader5TextureGatherOffsetColorTestBase::logVaryings(const CapturedVaryings& varyings) |
| { |
| logArray(varyings.without_offset_0, m_n_components_per_varying, "Without offset X: "); |
| |
| logArray(varyings.without_offset_1, m_n_components_per_varying, "Without offset Y: "); |
| |
| logArray(varyings.without_offset_2, m_n_components_per_varying, "Without offset Z: "); |
| |
| logArray(varyings.without_offset_3, m_n_components_per_varying, "Without offset W: "); |
| |
| logArray(varyings.with_offset_0, m_n_components_per_varying, "With offset X: "); |
| |
| logArray(varyings.with_offset_1, m_n_components_per_varying, "With offset Y: "); |
| |
| logArray(varyings.with_offset_2, m_n_components_per_varying, "With offset Z: "); |
| |
| logArray(varyings.with_offset_3, m_n_components_per_varying, "With offset W: "); |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| **/ |
| GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::GPUShader5TextureGatherOffsetColor2DRepeatCaseTest( |
| Context& context, const ExtParameters& extParams, const char* name, const char* description) |
| : GPUShader5TextureGatherOffsetColorTestBase(context, extParams, name, description) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Get parts of vertex shader |
| * |
| * @param out_vertex_shader_parts Vector of vertex shader parts |
| **/ |
| void GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::getShaderParts( |
| std::vector<const glw::GLchar*>& out_vertex_shader_parts) |
| { |
| out_vertex_shader_parts.push_back(m_vertex_shader_code); |
| } |
| |
| /** Prepare test specific data, that will be used as vertex attributes |
| * |
| * @param vertex_buffer_infos Vector of vertexBufferInfo instances |
| **/ |
| void GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::prepareVertexBuffersData( |
| std::vector<VertexBufferInfo>& vertex_buffer_infos) |
| { |
| /* Constats for offsets and size of buffer */ |
| const unsigned int n_total_components = m_n_vertices * m_n_offsets_components; |
| |
| /* Limits used to generate offsets */ |
| const glw::GLint min_ptgo = m_min_texture_gather_offset; |
| const glw::GLint max_ptgo = m_max_texture_gather_offset; |
| |
| /* Storage for offsets */ |
| m_offsets_buffer_data.resize(n_total_components); |
| |
| /* Set the seed for random number generator */ |
| randomSeed(1); |
| |
| /* Generate offsets */ |
| for (unsigned int i = 0; i < n_total_components; ++i) |
| { |
| m_offsets_buffer_data[i] = |
| static_cast<glw::GLint>(randomFormula(static_cast<glw::GLuint>(max_ptgo - min_ptgo + 1))) + min_ptgo; |
| } |
| |
| /* Setup offsets VB info */ |
| VertexBufferInfo info; |
| |
| info.attribute_name = m_offsets_attribute_name; |
| info.n_components = m_n_offsets_components; |
| info.type = GL_INT; |
| info.data = &m_offsets_buffer_data[0]; |
| info.data_size = (glw::GLuint)(m_offsets_buffer_data.size() * sizeof(glw::GLint)); |
| |
| /* Add VB info to vector */ |
| vertex_buffer_infos.push_back(info); |
| } |
| |
| /** Check if data captured for vertex at index are as expected |
| * |
| * @param captured_data Instance of capturedVaryings for vertex at index |
| * @param index Index of vertex |
| * @param texture_size Size of texture |
| * |
| * @return True Results match expected values |
| * False Results do not match expected values |
| **/ |
| bool GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::checkResult(const CapturedVaryings& captured_data, |
| unsigned int index, unsigned int tex_size) |
| { |
| /* Signed int value has to be used with operator % in order to work as expected */ |
| const glw::GLint texture_size = (glw::GLint)tex_size; |
| |
| /* Get offsets for vertex */ |
| glw::GLint x_offset; |
| glw::GLint y_offset; |
| |
| getOffsets(x_offset, y_offset, index); |
| |
| /* Roll x offsets around left edge when negative */ |
| if (0 > x_offset) |
| { |
| x_offset = x_offset % texture_size; |
| x_offset += texture_size; |
| } |
| |
| /* Roll y offsets around top edge when negative */ |
| if (0 > y_offset) |
| { |
| y_offset = y_offset % texture_size; |
| y_offset += texture_size; |
| } |
| |
| /* Storage for expected values of with_offset varyings */ |
| glw::GLint expected_values_0[m_n_components_per_varying]; |
| glw::GLint expected_values_1[m_n_components_per_varying]; |
| glw::GLint expected_values_2[m_n_components_per_varying]; |
| glw::GLint expected_values_3[m_n_components_per_varying]; |
| |
| /* Calculate expected values of with_offset varyings */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| expected_values_0[i] = ((x_offset + captured_data.without_offset_0[i]) % texture_size); |
| expected_values_1[i] = ((y_offset + captured_data.without_offset_1[i]) % texture_size); |
| expected_values_2[i] = ((x_offset + captured_data.without_offset_2[i]) % texture_size); |
| expected_values_3[i] = ((y_offset + captured_data.without_offset_3[i]) % texture_size); |
| } |
| |
| /* Verify that expected_values match those in with_offset varyings */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| if ((captured_data.with_offset_0[i] != expected_values_0[i]) || |
| (captured_data.with_offset_1[i] != expected_values_1[i]) || |
| (captured_data.with_offset_2[i] != expected_values_2[i]) || |
| (captured_data.with_offset_3[i] != expected_values_3[i])) |
| { |
| /* Log invalid results */ |
| m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", ""); |
| |
| logCoordinates(index); |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage; |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset |
| << tcu::TestLog::EndMessage; |
| |
| logVaryings(captured_data); |
| |
| m_testCtx.getLog() << tcu::TestLog::EndSection; |
| |
| /* Done */ |
| return false; |
| } |
| } |
| |
| /* Done */ |
| return true; |
| } |
| |
| /** Get offsets for vertex at index |
| * |
| * @param out_x_offset X offset |
| * @param out_y_offset Y offset |
| * @param index Index of vertex |
| **/ |
| void GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::getOffsets(glw::GLint& out_x_offset, glw::GLint& out_y_offset, |
| unsigned int index) |
| { |
| out_x_offset = m_offsets_buffer_data[index * m_n_offsets_components + 0]; |
| out_y_offset = m_offsets_buffer_data[index * m_n_offsets_components + 1]; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| **/ |
| GPUShader5TextureGatherOffsetColor2DArrayCaseTest::GPUShader5TextureGatherOffsetColor2DArrayCaseTest( |
| Context& context, const ExtParameters& extParams, const char* name, const char* description) |
| : GPUShader5TextureGatherOffsetColor2DRepeatCaseTest(context, extParams, name, description) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Get parts of vertex shader |
| * |
| * @param out_vertex_shader_parts Vector of vertex shader parts |
| **/ |
| void GPUShader5TextureGatherOffsetColor2DArrayCaseTest::getShaderParts( |
| std::vector<const glw::GLchar*>& out_vertex_shader_parts) |
| { |
| out_vertex_shader_parts.push_back(m_vertex_shader_code); |
| } |
| |
| /** Check if texture array is required |
| * |
| * @param out_is_texture_array Set to true if texture array is required, false otherwise |
| **/ |
| void GPUShader5TextureGatherOffsetColor2DArrayCaseTest::isTextureArray(bool& out_is_texture_array) |
| { |
| out_is_texture_array = true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| **/ |
| GPUShader5TextureGatherOffsetColor2DClampToBorderCaseTest::GPUShader5TextureGatherOffsetColor2DClampToBorderCaseTest( |
| Context& context, const ExtParameters& extParams, const char* name, const char* description) |
| : GPUShader5TextureGatherOffsetColor2DRepeatCaseTest(context, extParams, name, description) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Get wrap mode for texture |
| * |
| * @param out_wrap_mode Wrap mode |
| **/ |
| void GPUShader5TextureGatherOffsetColor2DClampToBorderCaseTest::getTextureWrapMode(glw::GLenum& out_wrap_mode) |
| { |
| out_wrap_mode = m_glExtTokens.CLAMP_TO_BORDER; |
| } |
| |
| /** Get parts of vertex shader |
| * |
| * @param out_vertex_shader_parts Vector of vertex shader parts |
| **/ |
| void GPUShader5TextureGatherOffsetColor2DClampToBorderCaseTest::getShaderParts( |
| std::vector<const glw::GLchar*>& out_vertex_shader_parts) |
| { |
| out_vertex_shader_parts.push_back(m_vertex_shader_code); |
| } |
| |
| /** Check if data captured for vertex at index are as expected |
| * |
| * @param captured_data Instance of capturedVaryings for vertex at index |
| * @param index Index of vertex |
| * @param texture_size Size of texture |
| * |
| * @return True Results match expected values |
| * False Results do not match expected values |
| **/ |
| bool GPUShader5TextureGatherOffsetColor2DClampToBorderCaseTest::checkResult(const CapturedVaryings& captured_data, |
| unsigned int index, |
| unsigned int texture_size) |
| { |
| /* Get offsets for vertex */ |
| glw::GLint x_offset; |
| glw::GLint y_offset; |
| |
| getOffsets(x_offset, y_offset, index); |
| |
| /* Storage for expected values of with_offset varyings */ |
| glw::GLint expected_values_0[m_n_components_per_varying]; |
| glw::GLint expected_values_1[m_n_components_per_varying]; |
| glw::GLint expected_values_2[m_n_components_per_varying]; |
| glw::GLint expected_values_3[m_n_components_per_varying]; |
| |
| /* Storage for with_offset values */ |
| glw::GLint with_offset_0[m_n_components_per_varying]; |
| glw::GLint with_offset_1[m_n_components_per_varying]; |
| glw::GLint with_offset_2[m_n_components_per_varying]; |
| glw::GLint with_offset_3[m_n_components_per_varying]; |
| |
| /* Index of first not clamped texel in without_offset set*/ |
| int not_clamped_texel_index = -1; |
| |
| /* X and Y offsets of texels in 2x2 set */ |
| static const glw::GLint gather_offsets_x[] = { 0, 1, 1, 0 }; |
| static const glw::GLint gather_offsets_y[] = { 1, 1, 0, 0 }; |
| |
| /* Find first not clamped texel in without_offset set */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| if ((0 <= captured_data.without_offset_0[i]) && (0 <= captured_data.without_offset_1[i])) |
| { |
| not_clamped_texel_index = i; |
| break; |
| } |
| } |
| |
| if (-1 == not_clamped_texel_index) |
| { |
| /* Log problem with sampler */ |
| m_testCtx.getLog() << tcu::TestLog::Section("Unexpected sampling results", ""); |
| |
| logCoordinates(index); |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage; |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset |
| << tcu::TestLog::EndMessage; |
| |
| logVaryings(captured_data); |
| |
| m_testCtx.getLog() << tcu::TestLog::EndSection; |
| |
| TCU_FAIL("Unexpected sampling results"); |
| } |
| |
| /* Fraction part of position for lower left texel without_offset set */ |
| const glw::GLint fract_position_x = |
| captured_data.without_offset_0[not_clamped_texel_index] - gather_offsets_x[not_clamped_texel_index]; |
| const glw::GLint fract_position_y = |
| captured_data.without_offset_1[not_clamped_texel_index] - gather_offsets_y[not_clamped_texel_index]; |
| |
| /* Absolute position of lower left corner in without_offset set */ |
| const glw::GLint absolute_position_x = fract_position_x + captured_data.without_offset_2[0] * (int)texture_size; |
| const glw::GLint absolute_position_y = fract_position_y + captured_data.without_offset_3[0] * (int)texture_size; |
| |
| /* Calculate absolute position for all texels in without_offset set */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| expected_values_0[i] = absolute_position_x + gather_offsets_x[i]; |
| expected_values_1[i] = absolute_position_y + gather_offsets_y[i]; |
| expected_values_2[i] = absolute_position_x + gather_offsets_x[i]; |
| expected_values_3[i] = absolute_position_y + gather_offsets_y[i]; |
| } |
| |
| /* Modify "border color" to -1 in with_offset set */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| with_offset_0[i] = 0 <= captured_data.with_offset_0[i] ? captured_data.with_offset_0[i] : -1; |
| with_offset_1[i] = 0 <= captured_data.with_offset_1[i] ? captured_data.with_offset_1[i] : -1; |
| with_offset_2[i] = 0 <= captured_data.with_offset_2[i] ? captured_data.with_offset_2[i] : -1; |
| with_offset_3[i] = 0 <= captured_data.with_offset_3[i] ? captured_data.with_offset_3[i] : -1; |
| } |
| |
| /* Apply offsets to absolute positions of without_offset */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| expected_values_0[i] += x_offset; |
| expected_values_1[i] += y_offset; |
| expected_values_2[i] += x_offset; |
| expected_values_3[i] += y_offset; |
| |
| /* Set to -1, when point defined by expected_values_01 is outside of texture */ |
| if ((0 > expected_values_0[i]) || (((glw::GLint)texture_size) <= expected_values_0[i]) || |
| (0 > expected_values_1[i]) || (((glw::GLint)texture_size) <= expected_values_1[i])) |
| { |
| expected_values_0[i] = -1; |
| expected_values_1[i] = -1; |
| } |
| |
| /* Set to -1, when point defined by expected_values_23 is outside of texture */ |
| if ((0 > expected_values_2[i]) || (((glw::GLint)texture_size) <= expected_values_2[i]) || |
| (0 > expected_values_3[i]) || (((glw::GLint)texture_size) <= expected_values_3[i])) |
| { |
| expected_values_2[i] = -1; |
| expected_values_3[i] = -1; |
| } |
| } |
| |
| /* Verify that expected_values match those in with_offset varyings */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| if ((with_offset_0[i] != expected_values_0[i]) || (with_offset_1[i] != expected_values_1[i]) || |
| (with_offset_2[i] != expected_values_2[i]) || (with_offset_3[i] != expected_values_3[i])) |
| { |
| /* Log invalid results */ |
| m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", ""); |
| |
| logCoordinates(index); |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage; |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset |
| << tcu::TestLog::EndMessage; |
| |
| logVaryings(captured_data); |
| |
| m_testCtx.getLog() << tcu::TestLog::EndSection; |
| |
| /* Done */ |
| return false; |
| } |
| } |
| |
| /* Done */ |
| return true; |
| } |
| |
| /** Initializes GLES objects used during the test. |
| * |
| */ |
| void GPUShader5TextureGatherOffsetColor2DClampToBorderCaseTest::initTest(void) |
| { |
| /* Check if texture_border_clamp extension is supported */ |
| if (!m_is_texture_border_clamp_supported) |
| { |
| throw tcu::NotSupportedError(TEXTURE_BORDER_CLAMP_NOT_SUPPORTED, "", __FILE__, __LINE__); |
| } |
| |
| GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::initTest(); |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| **/ |
| GPUShader5TextureGatherOffsetColor2DClampToEdgeCaseTest::GPUShader5TextureGatherOffsetColor2DClampToEdgeCaseTest( |
| Context& context, const ExtParameters& extParams, const char* name, const char* description) |
| : GPUShader5TextureGatherOffsetColor2DRepeatCaseTest(context, extParams, name, description) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Get wrap mode for texture |
| * |
| * @param out_wrap_mode Wrap mode |
| **/ |
| void GPUShader5TextureGatherOffsetColor2DClampToEdgeCaseTest::getTextureWrapMode(glw::GLenum& out_wrap_mode) |
| { |
| out_wrap_mode = GL_CLAMP_TO_EDGE; |
| } |
| |
| /** Get parts of vertex shader |
| * |
| * @param out_vertex_shader_parts Vector of vertex shader parts |
| **/ |
| void GPUShader5TextureGatherOffsetColor2DClampToEdgeCaseTest::getShaderParts( |
| std::vector<const glw::GLchar*>& out_vertex_shader_parts) |
| { |
| out_vertex_shader_parts.push_back(m_vertex_shader_code); |
| } |
| |
| /** Clamps value to specified range |
| * |
| * @param value Value to be clamped |
| * @param min Minimum of range |
| * @param max Maximum of range |
| **/ |
| template <typename T> |
| void clamp(T& value, const T min, const T max) |
| { |
| if (min > value) |
| { |
| value = min; |
| } |
| else if (max < value) |
| { |
| value = max; |
| } |
| } |
| |
| /** Check if data captured for vertex at index are as expected |
| * |
| * @param captured_data Instance of capturedVaryings for vertex at index |
| * @param index Index of vertex |
| * @param texture_size Size of texture |
| * |
| * @return True Results match expected values |
| * False Results do not match expected values |
| **/ |
| bool GPUShader5TextureGatherOffsetColor2DClampToEdgeCaseTest::checkResult(const CapturedVaryings& captured_data, |
| unsigned int index, unsigned int texture_size) |
| { |
| /* Get offsets for vertex */ |
| glw::GLint x_offset; |
| glw::GLint y_offset; |
| |
| getOffsets(x_offset, y_offset, index); |
| |
| /* Storage for expected values of with_offset varyings */ |
| glw::GLint expected_values_0[m_n_components_per_varying]; |
| glw::GLint expected_values_1[m_n_components_per_varying]; |
| glw::GLint expected_values_2[m_n_components_per_varying]; |
| glw::GLint expected_values_3[m_n_components_per_varying]; |
| |
| /* Index of first not clamped texel in without_offset set*/ |
| int not_clamped_texel_index = -1; |
| |
| /* X and Y offsets of texels in 2x2 set */ |
| static const glw::GLint gather_offsets_x[] = { 0, 1, 1, 0 }; |
| static const glw::GLint gather_offsets_y[] = { 1, 1, 0, 0 }; |
| |
| /* Find first not clamped texel in without_offset set */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| if ((0 <= captured_data.without_offset_0[i]) && (0 <= captured_data.without_offset_1[i])) |
| { |
| not_clamped_texel_index = i; |
| break; |
| } |
| } |
| |
| if (-1 == not_clamped_texel_index) |
| { |
| /* Log problem with sampler */ |
| m_testCtx.getLog() << tcu::TestLog::Section("Unexpected sampling results", ""); |
| |
| logCoordinates(index); |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage; |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset |
| << tcu::TestLog::EndMessage; |
| |
| logVaryings(captured_data); |
| |
| m_testCtx.getLog() << tcu::TestLog::EndSection; |
| |
| TCU_FAIL("Unexpected sampling results"); |
| } |
| |
| /* Fraction part of position for lower left texel without_offset set */ |
| const glw::GLint fract_position_x = |
| captured_data.without_offset_0[not_clamped_texel_index] - gather_offsets_x[not_clamped_texel_index]; |
| const glw::GLint fract_position_y = |
| captured_data.without_offset_1[not_clamped_texel_index] - gather_offsets_y[not_clamped_texel_index]; |
| |
| /* Absolute position of lower left corner in without_offset set */ |
| const glw::GLint absolute_position_x = fract_position_x + captured_data.without_offset_2[0] * (int)texture_size; |
| const glw::GLint absolute_position_y = fract_position_y + captured_data.without_offset_3[0] * (int)texture_size; |
| |
| /* Calculate absolute position for all texels in without_offset set */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| expected_values_0[i] = absolute_position_x + gather_offsets_x[i]; |
| expected_values_1[i] = absolute_position_y + gather_offsets_y[i]; |
| expected_values_2[i] = absolute_position_x + gather_offsets_x[i]; |
| expected_values_3[i] = absolute_position_y + gather_offsets_y[i]; |
| } |
| |
| /* Apply offsets to absolute positions of without_offset */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| expected_values_0[i] += x_offset; |
| expected_values_1[i] += y_offset; |
| expected_values_2[i] += x_offset; |
| expected_values_3[i] += y_offset; |
| |
| /* Clamp value when point is outside of texture */ |
| clamp(expected_values_0[i], 0, ((glw::GLint)texture_size) - 1); |
| clamp(expected_values_1[i], 0, ((glw::GLint)texture_size) - 1); |
| clamp(expected_values_2[i], 0, ((glw::GLint)texture_size) - 1); |
| clamp(expected_values_3[i], 0, ((glw::GLint)texture_size) - 1); |
| } |
| |
| /* Verify that expected_values match those in with_offset varyings */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| if ((captured_data.with_offset_0[i] != expected_values_0[i]) || |
| (captured_data.with_offset_1[i] != expected_values_1[i]) || |
| (captured_data.with_offset_2[i] != expected_values_2[i]) || |
| (captured_data.with_offset_3[i] != expected_values_3[i])) |
| { |
| /* Log invalid results */ |
| m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", ""); |
| |
| logCoordinates(index); |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage; |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset |
| << tcu::TestLog::EndMessage; |
| |
| logVaryings(captured_data); |
| |
| m_testCtx.getLog() << tcu::TestLog::EndSection; |
| |
| /* Done */ |
| return false; |
| } |
| } |
| |
| /* Done */ |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| **/ |
| GPUShader5TextureGatherOffsetColor2DOffsetsCaseTest::GPUShader5TextureGatherOffsetColor2DOffsetsCaseTest( |
| Context& context, const ExtParameters& extParams, const char* name, const char* description) |
| : GPUShader5TextureGatherOffsetColorTestBase(context, extParams, name, description) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Get parts of vertex shader |
| * |
| * @param out_vertex_shader_parts Vector of vertex shader parts |
| **/ |
| void GPUShader5TextureGatherOffsetColor2DOffsetsCaseTest::getShaderParts( |
| std::vector<const glw::GLchar*>& out_vertex_shader_parts) |
| { |
| std::stringstream stream; |
| |
| stream << " ivec2[4]( ivec2( " << m_min_texture_gather_offset << ", " << m_min_texture_gather_offset |
| << "),\n"; |
| stream << " ivec2( " << m_min_texture_gather_offset << ", " << m_max_texture_gather_offset |
| << "),\n"; |
| stream << " ivec2( " << m_max_texture_gather_offset << ", " << m_min_texture_gather_offset |
| << "),\n"; |
| stream << " ivec2( " << m_max_texture_gather_offset << ", " << m_max_texture_gather_offset |
| << "));\n"; |
| |
| m_vertex_shader_code_offsets = stream.str(); |
| |
| out_vertex_shader_parts.push_back(m_vertex_shader_code_preamble); |
| out_vertex_shader_parts.push_back(m_vertex_shader_code_offsets.c_str()); |
| out_vertex_shader_parts.push_back(m_vertex_shader_code_body); |
| } |
| |
| /** Prepare test specific data, that will be used as vertex attributes |
| * |
| * @param vertex_buffer_infos Vector of vertexBufferInfo instances |
| **/ |
| void GPUShader5TextureGatherOffsetColor2DOffsetsCaseTest::prepareVertexBuffersData( |
| std::vector<VertexBufferInfo>& vertex_buffer_infos) |
| { |
| DE_UNREF(vertex_buffer_infos); |
| |
| /* Nothing to be done here */ |
| } |
| |
| /** Check if data captured for vertex at index are as expected |
| * |
| * @param captured_data Instance of capturedVaryings for vertex at index |
| * @param index Index of vertex |
| * @param texture_size Size of texture |
| * |
| * @return True Results match expected values |
| * False Results do not match expected values |
| **/ |
| bool GPUShader5TextureGatherOffsetColor2DOffsetsCaseTest::checkResult(const CapturedVaryings& captured_data, |
| unsigned int index, unsigned int tex_size) |
| { |
| /* Signed int value has to be used with operator % in order to work as expected */ |
| const glw::GLint texture_size = (glw::GLint)tex_size; |
| |
| /* X and Y offsets */ |
| glw::GLint x_offsets[m_n_components_per_varying] = { |
| m_min_texture_gather_offset, m_min_texture_gather_offset, m_max_texture_gather_offset, |
| m_max_texture_gather_offset, |
| }; |
| |
| glw::GLint y_offsets[m_n_components_per_varying] = { |
| m_min_texture_gather_offset, m_max_texture_gather_offset, m_min_texture_gather_offset, |
| m_max_texture_gather_offset, |
| }; |
| |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| /* Roll x offsets around left edge when negative */ |
| if (0 > x_offsets[i]) |
| { |
| x_offsets[i] = x_offsets[i] % texture_size; |
| x_offsets[i] += texture_size; |
| } |
| |
| /* Roll y offsets around top edge when negative */ |
| if (0 > y_offsets[i]) |
| { |
| y_offsets[i] = y_offsets[i] % texture_size; |
| y_offsets[i] += texture_size; |
| } |
| } |
| |
| /* Storage for expected values of with_offset varyings */ |
| glw::GLint expected_values_0[m_n_components_per_varying]; |
| glw::GLint expected_values_1[m_n_components_per_varying]; |
| glw::GLint expected_values_2[m_n_components_per_varying]; |
| glw::GLint expected_values_3[m_n_components_per_varying]; |
| |
| /* Calculate expected values of with_offset varyings */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| expected_values_0[i] = ((x_offsets[i] + captured_data.without_offset_0[3]) % texture_size); |
| expected_values_1[i] = ((y_offsets[i] + captured_data.without_offset_1[3]) % texture_size); |
| expected_values_2[i] = ((x_offsets[i] + captured_data.without_offset_2[3]) % texture_size); |
| expected_values_3[i] = ((y_offsets[i] + captured_data.without_offset_3[3]) % texture_size); |
| } |
| |
| /* Verify that expected_values match those in with_offset varyings */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| if ((captured_data.with_offset_0[i] != expected_values_0[i]) || |
| (captured_data.with_offset_1[i] != expected_values_1[i]) || |
| (captured_data.with_offset_2[i] != expected_values_2[i]) || |
| (captured_data.with_offset_3[i] != expected_values_3[i])) |
| { |
| /* Log invalid results */ |
| m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", ""); |
| |
| logCoordinates(index); |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage; |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " |
| << "(" << x_offsets[0] << ", " << y_offsets[0] << ") " |
| << "(" << x_offsets[1] << ", " << y_offsets[1] << ") " |
| << "(" << x_offsets[2] << ", " << y_offsets[2] << ") " |
| << "(" << x_offsets[3] << ", " << y_offsets[3] << ") " << tcu::TestLog::EndMessage; |
| |
| logVaryings(captured_data); |
| |
| m_testCtx.getLog() << tcu::TestLog::EndSection; |
| |
| /* Done */ |
| return false; |
| } |
| } |
| |
| /* Done */ |
| return true; |
| } |
| |
| /** Initializes GLES objects used during the test. |
| * |
| */ |
| void GPUShader5TextureGatherOffsetColor2DClampToEdgeCaseTest::initTest(void) |
| { |
| /* Check if texture_border_clamp extension is supported */ |
| if (!m_is_texture_border_clamp_supported) |
| { |
| throw tcu::NotSupportedError(TEXTURE_BORDER_CLAMP_NOT_SUPPORTED, "", __FILE__, __LINE__); |
| } |
| |
| GPUShader5TextureGatherOffsetColor2DRepeatCaseTest::initTest(); |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| **/ |
| GPUShader5TextureGatherOffsetDepthTestBase::GPUShader5TextureGatherOffsetDepthTestBase(Context& context, |
| const ExtParameters& extParams, |
| const char* name, |
| const char* description) |
| : GPUShader5TextureGatherOffsetTestBase(context, extParams, name, description), m_n_varyings_per_vertex(0) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Provides color that will be used as border color for "clamp to border" mode |
| * |
| * @param out_color Color |
| **/ |
| void GPUShader5TextureGatherOffsetDepthTestBase::getBorderColor(glw::GLfloat out_color[4]) |
| { |
| out_color[0] = 1.0f; |
| out_color[1] = 1.0f; |
| out_color[2] = 1.0f; |
| out_color[3] = 1.0f; |
| } |
| |
| /** Provides informations required to create texture |
| * |
| * @param out_width Size of texture |
| * @param out_texture_internal_format Internal format of texture |
| * @param out_texture_format Format of texture |
| * @param out_texture_type Type of texture |
| * @param out_bytes_per_pixel Bytes per pixel |
| **/ |
| void GPUShader5TextureGatherOffsetDepthTestBase::getTextureInfo(glw::GLuint& out_width, |
| glw::GLenum& out_texture_internal_format, |
| glw::GLenum& out_texture_format, |
| glw::GLenum& out_texture_type, |
| glw::GLuint& out_bytes_per_pixel) |
| { |
| out_width = m_texture_size; |
| out_texture_internal_format = GL_DEPTH_COMPONENT32F; |
| out_texture_format = GL_DEPTH_COMPONENT; |
| out_texture_type = GL_FLOAT; |
| out_bytes_per_pixel = 1 * sizeof(glw::GLfloat); /* Depth * float */ |
| } |
| |
| /** Get wrap mode for texture |
| * |
| * @param out_wrap_mode Wrap mode |
| **/ |
| void GPUShader5TextureGatherOffsetDepthTestBase::getTextureWrapMode(glw::GLenum& out_wrap_mode) |
| { |
| out_wrap_mode = GL_REPEAT; |
| } |
| |
| /** Get size of buffer used as output from transform feedback and names of varyings |
| * |
| * @param out_buffer_size Size of buffer |
| * @param out_captured_varyings Names of varyings |
| **/ |
| void GPUShader5TextureGatherOffsetDepthTestBase::getTransformFeedBackDetails( |
| glw::GLuint& out_buffer_size, std::vector<const glw::GLchar*>& out_captured_varyings) |
| { |
| getVaryings(out_captured_varyings); |
| |
| m_n_varyings_per_vertex = (unsigned int)out_captured_varyings.size(); |
| |
| out_buffer_size = static_cast<glw::GLuint>(m_n_vertices * m_n_varyings_per_vertex * m_n_components_per_varying * |
| sizeof(glw::GLint)); |
| } |
| |
| /** Check if texture array is required |
| * |
| * @param out_is_texture_array Set to true if texture array is required, false otherwise |
| **/ |
| void GPUShader5TextureGatherOffsetDepthTestBase::isTextureArray(bool& out_is_texture_array) |
| { |
| out_is_texture_array = false; |
| } |
| |
| /** Prepare texture data as expected by all cases in test 10. |
| * Each texel is assigned value of { x / texture_size } |
| * |
| * @param data Storage space for texture data |
| **/ |
| void GPUShader5TextureGatherOffsetDepthTestBase::prepareTextureData(glw::GLubyte* data) |
| { |
| /* Data pointer */ |
| glw::GLfloat* texture_data = (glw::GLfloat*)data; |
| |
| /* Constants */ |
| const unsigned int n_components_per_pixel = 1; |
| const unsigned int line_size = n_components_per_pixel * m_texture_size; |
| const glw::GLfloat step = 1.0f / ((float)m_texture_size); |
| |
| /* Prepare texture's data */ |
| for (unsigned int y = 0; y < m_texture_size; ++y) |
| { |
| for (unsigned int x = 0; x < m_texture_size; ++x) |
| { |
| const glw::GLfloat depth = ((float)x) * step; |
| const unsigned int pixel_offset = y * line_size + x * n_components_per_pixel; |
| |
| /* texel.depth = depth */ |
| texture_data[pixel_offset] = depth; |
| } |
| } |
| } |
| |
| /** Verification of results |
| * |
| * @param result Pointer to data mapped from transform feedback buffer. |
| * Size of data is equal to buffer_size set by getTransformFeedbackBufferSize |
| * |
| * @return true Result match expected value |
| * false Result has wrong value |
| **/ |
| bool GPUShader5TextureGatherOffsetDepthTestBase::verifyResult(const void* result_data) |
| { |
| /* All data stored in data are ints */ |
| glw::GLint* results = (glw::GLint*)result_data; |
| |
| /* Verification result */ |
| bool result = true; |
| |
| /* Constants for data offsets calculation */ |
| const unsigned int bytes_per_varying = m_n_components_per_varying * sizeof(glw::GLfloat); |
| const unsigned int vertex_size_in_results_buffer = m_n_varyings_per_vertex * m_n_components_per_varying; |
| const unsigned int with_offset_offset = m_n_components_per_varying; |
| const unsigned int without_offset_offset = 0; |
| const unsigned int floor_tex_coord_offset = with_offset_offset + m_n_components_per_varying; |
| |
| /* For each vertex */ |
| for (unsigned int vertex = 0; vertex < m_n_vertices; ++vertex) |
| { |
| CapturedVaryings captured_data; |
| |
| /* Pointers to all varyings for given vertex */ |
| const glw::GLint* without_offset = results + (vertex * vertex_size_in_results_buffer) + without_offset_offset; |
| const glw::GLint* with_offset = results + (vertex * vertex_size_in_results_buffer) + with_offset_offset; |
| const glw::GLint* floor_tex_coord = results + (vertex * vertex_size_in_results_buffer) + floor_tex_coord_offset; |
| |
| /* Copy captured varyings to captured_data instance */ |
| memcpy(captured_data.without_offset, without_offset, bytes_per_varying); |
| memcpy(captured_data.with_offset, with_offset, bytes_per_varying); |
| if (3 <= m_n_varyings_per_vertex) |
| { |
| memcpy(captured_data.floor_tex_coord, floor_tex_coord, bytes_per_varying); |
| } |
| |
| /* Let child class check if result is ok */ |
| const bool is_result_ok = checkResult(captured_data, vertex, m_texture_size); |
| |
| /* Do not break on first error */ |
| if (false == is_result_ok) |
| { |
| result = false; |
| } |
| } |
| |
| /* Done */ |
| return result; |
| } |
| |
| /** Provides names of varyings to be captured by test |
| * |
| * @param out_captured_varyings Vector of varyings' names |
| **/ |
| void GPUShader5TextureGatherOffsetDepthTestBase::getVaryings(std::vector<const glw::GLchar*>& out_captured_varyings) |
| { |
| out_captured_varyings.push_back("without_offset"); |
| out_captured_varyings.push_back("with_offset"); |
| } |
| |
| /** Logs data captured varyings |
| * |
| * @param varyings Instance of capturedVaryings to be logged |
| **/ |
| void GPUShader5TextureGatherOffsetDepthTestBase::logVaryings(const CapturedVaryings& varyings) |
| { |
| logArray(varyings.without_offset, m_n_components_per_varying, "Without offset: "); |
| |
| logArray(varyings.with_offset, m_n_components_per_varying, "With offset: "); |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| **/ |
| GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest( |
| Context& context, const ExtParameters& extParams, const char* name, const char* description) |
| : GPUShader5TextureGatherOffsetDepthTestBase(context, extParams, name, description) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Get parts of vertex shader |
| * |
| * @param out_vertex_shader_parts Vector of vertex shader parts |
| **/ |
| void GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::getShaderParts( |
| std::vector<const glw::GLchar*>& out_vertex_shader_parts) |
| { |
| out_vertex_shader_parts.push_back(m_vertex_shader_code); |
| } |
| |
| /** Prepare test specific data, that will be used as vertex attributes |
| * |
| * @param vertex_buffer_infos Vector of vertexBufferInfo instances |
| **/ |
| void GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::prepareVertexBuffersData( |
| std::vector<VertexBufferInfo>& vertex_buffer_infos) |
| { |
| /* Constants for offsets and size of buffer */ |
| const unsigned int n_total_components = m_n_vertices * m_n_offsets_components; |
| |
| /* Limits used to generate offsets */ |
| const glw::GLint min_ptgo = m_min_texture_gather_offset; |
| const glw::GLint max_ptgo = m_max_texture_gather_offset; |
| |
| /* Storage for offsets */ |
| m_offsets_buffer_data.resize(n_total_components); |
| |
| /* Generate offsets */ |
| for (unsigned int i = 0; i < n_total_components; ++i) |
| { |
| m_offsets_buffer_data[i] = (rand() % (max_ptgo - min_ptgo + 1)) + min_ptgo; |
| } |
| |
| /* Setup offsets VB info */ |
| VertexBufferInfo info; |
| |
| info.attribute_name = m_offsets_attribute_name; |
| info.n_components = m_n_offsets_components; |
| info.type = GL_INT; |
| info.data = &m_offsets_buffer_data[0]; |
| info.data_size = (glw::GLuint)(m_offsets_buffer_data.size() * sizeof(glw::GLint)); |
| |
| /* Add VB info to vector */ |
| vertex_buffer_infos.push_back(info); |
| } |
| |
| /** Check if data captured for vertex at index are as expected |
| * |
| * @param captured_data Instance of capturedVaryings for vertex at index |
| * @param index Index of vertex |
| * @param texture_size Size of texture |
| * |
| * @return True Results match expected values |
| * False Results do not match expected values |
| **/ |
| bool GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::checkResult(const CapturedVaryings& captured_data, |
| unsigned int index, unsigned int tex_size) |
| { |
| /* Signed int value has to be used with operator % in order to work as expected */ |
| const glw::GLint texture_size = (glw::GLint)tex_size; |
| |
| /* Get offsets for vertex */ |
| glw::GLint x_offset; |
| glw::GLint y_offset; |
| |
| getOffsets(x_offset, y_offset, index); |
| |
| /* Roll x offsets around left edge when negative */ |
| if (0 > x_offset) |
| { |
| x_offset = x_offset % texture_size; |
| x_offset += texture_size; |
| } |
| |
| /* Storage for expected values of with_offset varyings */ |
| glw::GLint expected_values[m_n_components_per_varying]; |
| |
| /* Calculate expected values of with_offset varyings */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| expected_values[i] = ((x_offset + captured_data.without_offset[i]) % texture_size); |
| } |
| |
| /* Verify that expected_values match those in with_offset varyings */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| if (captured_data.with_offset[i] != expected_values[i]) |
| { |
| /* Log invalid results */ |
| m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", ""); |
| |
| logCoordinates(index); |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage; |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset |
| << tcu::TestLog::EndMessage; |
| |
| logVaryings(captured_data); |
| |
| m_testCtx.getLog() << tcu::TestLog::EndSection; |
| |
| /* Done */ |
| return false; |
| } |
| } |
| |
| /* Done */ |
| return true; |
| } |
| |
| /** Get offsets for vertex at index |
| * |
| * @param out_x_offset X offset |
| * @param out_y_offset Y offset |
| * @param index Index of vertex |
| **/ |
| void GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::getOffsets(glw::GLint& out_x_offset, glw::GLint& out_y_offset, |
| unsigned int index) |
| { |
| out_x_offset = m_offsets_buffer_data[index * m_n_offsets_components + 0]; |
| out_y_offset = m_offsets_buffer_data[index * m_n_offsets_components + 1]; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| **/ |
| GPUShader5TextureGatherOffsetDepth2DRepeatYCaseTest::GPUShader5TextureGatherOffsetDepth2DRepeatYCaseTest( |
| Context& context, const ExtParameters& extParams, const char* name, const char* description) |
| : GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest(context, extParams, name, description) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Get parts of vertex shader |
| * |
| * @param out_vertex_shader_parts Vector of vertex shader parts |
| **/ |
| void GPUShader5TextureGatherOffsetDepth2DRepeatYCaseTest::getShaderParts( |
| std::vector<const glw::GLchar*>& out_vertex_shader_parts) |
| { |
| out_vertex_shader_parts.push_back(m_vertex_shader_code); |
| } |
| |
| /** Prepare texture data as expected by case "Repeat the same test for Y axis." of test 10. |
| * Each texel is assigned value of { y / texture_size } |
| * |
| * @param data Storage space for texture data |
| **/ |
| void GPUShader5TextureGatherOffsetDepth2DRepeatYCaseTest::prepareTextureData(glw::GLubyte* data) |
| { |
| /* Data pointer */ |
| glw::GLfloat* texture_data = (glw::GLfloat*)data; |
| |
| /* Get texture info from GPUShader5TextureGatherOffsetDepthTestBase */ |
| glw::GLuint texture_size; |
| glw::GLenum ignored_texture_internal_format; |
| glw::GLenum ignored_texture_format; |
| glw::GLenum ignored_texture_type; |
| glw::GLuint ignored_bytes_per_pixel; |
| |
| getTextureInfo(texture_size, ignored_texture_internal_format, ignored_texture_format, ignored_texture_type, |
| ignored_bytes_per_pixel); |
| |
| /* Constants */ |
| const unsigned int n_components_per_pixel = 1; |
| const unsigned int line_size = n_components_per_pixel * texture_size; |
| const glw::GLfloat step = 1.0f / ((float)texture_size); |
| |
| /* Prepare texture's data */ |
| for (unsigned int y = 0; y < texture_size; ++y) |
| { |
| const glw::GLfloat depth = ((float)y) * step; |
| |
| for (unsigned int x = 0; x < texture_size; ++x) |
| { |
| const unsigned int pixel_offset = y * line_size + x * n_components_per_pixel; |
| |
| /* texel.depth = depth */ |
| texture_data[pixel_offset] = depth; |
| } |
| } |
| } |
| |
| /** Check if data captured for vertex at index are as expected |
| * |
| * @param captured_data Instance of capturedVaryings for vertex at index |
| * @param index Index of vertex |
| * @param texture_size Size of texture |
| * |
| * @return True Results match expected values |
| * False Results do not match expected values |
| **/ |
| bool GPUShader5TextureGatherOffsetDepth2DRepeatYCaseTest::checkResult(const CapturedVaryings& captured_data, |
| unsigned int index, unsigned int tex_size) |
| { |
| /* Signed int value has to be used with operator % in order to work as expected */ |
| const glw::GLint texture_size = (glw::GLint)tex_size; |
| |
| /* Get offsets for vertex */ |
| glw::GLint x_offset; |
| glw::GLint y_offset; |
| |
| getOffsets(x_offset, y_offset, index); |
| |
| /* Roll y offsets around left edge when negative */ |
| if (0 > y_offset) |
| { |
| y_offset = y_offset % texture_size; |
| y_offset += texture_size; |
| } |
| |
| /* Storage for expected values of with_offset varyings */ |
| glw::GLint expected_values[m_n_components_per_varying]; |
| |
| /* Calculate expected values of with_offset varyings */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| expected_values[i] = ((y_offset + captured_data.without_offset[i]) % texture_size); |
| } |
| |
| /* Verify that expected_values match those in with_offset varyings */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| if (captured_data.with_offset[i] != expected_values[i]) |
| { |
| /* Log invalid results */ |
| m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", ""); |
| |
| logCoordinates(index); |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage; |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset |
| << tcu::TestLog::EndMessage; |
| |
| logVaryings(captured_data); |
| |
| m_testCtx.getLog() << tcu::TestLog::EndSection; |
| |
| /* Done */ |
| return false; |
| } |
| } |
| |
| /* Done */ |
| return true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| **/ |
| GPUShader5TextureGatherOffsetDepth2DArrayCaseTest::GPUShader5TextureGatherOffsetDepth2DArrayCaseTest( |
| Context& context, const ExtParameters& extParams, const char* name, const char* description) |
| : GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest(context, extParams, name, description) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Get parts of vertex shader |
| * |
| * @param out_vertex_shader_parts Vector of vertex shader parts |
| **/ |
| void GPUShader5TextureGatherOffsetDepth2DArrayCaseTest::getShaderParts( |
| std::vector<const glw::GLchar*>& out_vertex_shader_parts) |
| { |
| out_vertex_shader_parts.push_back(m_vertex_shader_code); |
| } |
| |
| /** Check if texture array is required |
| * |
| * @param out_is_texture_array Set to true if texture array is required, false otherwise |
| **/ |
| void GPUShader5TextureGatherOffsetDepth2DArrayCaseTest::isTextureArray(bool& out_is_texture_array) |
| { |
| out_is_texture_array = true; |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| **/ |
| GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest::GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest( |
| Context& context, const ExtParameters& extParams, const char* name, const char* description) |
| : GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest(context, extParams, name, description) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Get wrap mode for texture |
| * |
| * @param out_wrap_mode Wrap mode |
| **/ |
| void GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest::getTextureWrapMode(glw::GLenum& out_wrap_mode) |
| { |
| out_wrap_mode = m_glExtTokens.CLAMP_TO_BORDER; |
| } |
| |
| /** Provides names of varyings to be captured by test |
| * |
| * @param out_captured_varyings Vector of varyings' names |
| **/ |
| void GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest::getVaryings( |
| std::vector<const glw::GLchar*>& out_captured_varyings) |
| { |
| out_captured_varyings.push_back("without_offset"); |
| out_captured_varyings.push_back("with_offset"); |
| out_captured_varyings.push_back("floor_tex_coord"); |
| } |
| |
| /** Get parts of vertex shader |
| * |
| * @param out_vertex_shader_parts Vector of vertex shader parts |
| **/ |
| void GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest::getShaderParts( |
| std::vector<const glw::GLchar*>& out_vertex_shader_parts) |
| { |
| out_vertex_shader_parts.push_back(m_vertex_shader_code); |
| } |
| |
| /** Prepare test specific data, that will be used as vertex attributes |
| * |
| * @param vertex_buffer_infos Vector of vertexBufferInfo instances |
| **/ |
| void GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest::prepareVertexBuffersData( |
| std::vector<VertexBufferInfo>& vertex_buffer_infos) |
| { |
| /* Constats for offsets and size of buffer */ |
| const unsigned int n_total_components = m_n_vertices * m_n_offsets_components; |
| |
| /* Limits used to generate offsets */ |
| const glw::GLint min_ptgo = m_min_texture_gather_offset; |
| const glw::GLint max_ptgo = m_max_texture_gather_offset; |
| |
| /* Storage for offsets */ |
| m_offsets_buffer_data.resize(n_total_components); |
| |
| /* Generate offsets */ |
| for (unsigned int i = 0; i < n_total_components; ++i) |
| { |
| if (0 == i % 2) |
| { |
| m_offsets_buffer_data[i] = (rand() % (max_ptgo - min_ptgo + 1)) + min_ptgo; |
| } |
| else |
| { |
| /* y offsets must be set to 0*/ |
| m_offsets_buffer_data[i] = 0; |
| } |
| } |
| |
| /* Setup offsets VB info */ |
| VertexBufferInfo info; |
| |
| info.attribute_name = m_offsets_attribute_name; |
| info.n_components = m_n_offsets_components; |
| info.type = GL_INT; |
| info.data = &m_offsets_buffer_data[0]; |
| info.data_size = (glw::GLuint)(m_offsets_buffer_data.size() * sizeof(glw::GLint)); |
| |
| /* Add VB info to vector */ |
| vertex_buffer_infos.push_back(info); |
| } |
| |
| /** Check if data captured for vertex at index are as expected |
| * |
| * @param captured_data Instance of capturedVaryings for vertex at index |
| * @param index Index of vertex |
| * @param texture_size Size of texture |
| * |
| * @return True Results match expected values |
| * False Results do not match expected values |
| **/ |
| bool GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest::checkResult(const CapturedVaryings& captured_data, |
| unsigned int index, |
| unsigned int texture_size) |
| { |
| /* Get offsets for vertex */ |
| glw::GLint x_offset; |
| glw::GLint y_offset; |
| |
| getOffsets(x_offset, y_offset, index); |
| |
| /* Storage for expected values of with_offset varyings */ |
| glw::GLint expected_values[m_n_components_per_varying]; |
| |
| /* Index of first not clamped texel in without_offset set*/ |
| int not_clamped_texel_index = -1; |
| |
| /* X offsets of texels in 2x2 set */ |
| static const glw::GLint gather_offsets_x[] = { 0, 1, 1, 0 }; |
| |
| /* Find first not clamped texel in without_offset set */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| if ((int)texture_size != captured_data.without_offset[i]) |
| { |
| not_clamped_texel_index = i; |
| break; |
| } |
| } |
| |
| if (-1 == not_clamped_texel_index) |
| { |
| /* Log problem with sampler */ |
| m_testCtx.getLog() << tcu::TestLog::Section("Unexpected sampling results", ""); |
| |
| logCoordinates(index); |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage; |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset |
| << tcu::TestLog::EndMessage; |
| |
| logVaryings(captured_data); |
| |
| m_testCtx.getLog() << tcu::TestLog::EndSection; |
| |
| TCU_FAIL("Unexpected sampling results"); |
| } |
| |
| /* Fraction part of position for lower left texel without_offset set */ |
| const glw::GLint fract_position_x = |
| captured_data.without_offset[not_clamped_texel_index] - gather_offsets_x[not_clamped_texel_index]; |
| |
| /* Absolute position of lower left corner in without_offset set */ |
| const glw::GLint absolute_position_x = fract_position_x + captured_data.floor_tex_coord[0] * (int)texture_size; |
| |
| /* Wraping matrix */ |
| glw::GLint wrap_matrix[4] = { 0 }; |
| |
| /* Index of value in without_offset set, that should be check for being clamped */ |
| glw::GLint wrap_value_to_check_indices[4] = { 3, 2, 1, 0 }; |
| |
| /* Get value from without_offset to check for clamping */ |
| glw::GLint wrap_value_to_check = captured_data.without_offset[wrap_value_to_check_indices[not_clamped_texel_index]]; |
| |
| /* Setup wrap_matrix */ |
| switch (not_clamped_texel_index) |
| { |
| case 0: |
| case 1: |
| wrap_matrix[0] = 0; |
| wrap_matrix[1] = 0; |
| |
| if ((glw::GLint)texture_size == wrap_value_to_check) |
| { |
| wrap_matrix[2] = -1; |
| wrap_matrix[3] = -1; |
| } |
| break; |
| case 2: |
| case 3: |
| wrap_matrix[2] = 0; |
| wrap_matrix[3] = 0; |
| |
| if ((glw::GLint)texture_size == wrap_value_to_check) |
| { |
| wrap_matrix[0] = 1; |
| wrap_matrix[1] = 1; |
| } |
| break; |
| } |
| |
| /* Apply integral part of texture coordinates to wrap_matrix */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| wrap_matrix[i] += captured_data.floor_tex_coord[1]; |
| } |
| |
| /* For each texel in without_offset set calculate absolute position and apply offset */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| expected_values[i] = absolute_position_x + gather_offsets_x[i]; |
| expected_values[i] += x_offset; |
| |
| /* Set to texture_size when point is outside of texture */ |
| if ((0 > expected_values[i]) || (((glw::GLint)texture_size) < expected_values[i]) || (0 != wrap_matrix[i])) |
| { |
| expected_values[i] = texture_size; |
| } |
| } |
| |
| /* Verify that expected_values match those in with_offset varyings */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| if (captured_data.with_offset[i] != expected_values[i]) |
| { |
| /* Log invalid results */ |
| m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", ""); |
| |
| logCoordinates(index); |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage; |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset |
| << tcu::TestLog::EndMessage; |
| |
| logVaryings(captured_data); |
| |
| m_testCtx.getLog() << tcu::TestLog::EndSection; |
| |
| /* Done */ |
| return false; |
| } |
| } |
| |
| /* Done */ |
| return true; |
| } |
| |
| /** Initializes GLES objects used during the test. |
| * |
| */ |
| void GPUShader5TextureGatherOffsetDepth2DClampToBorderCaseTest::initTest(void) |
| { |
| /* Check if texture_border_clamp extension is supported */ |
| if (!m_is_texture_border_clamp_supported) |
| { |
| throw tcu::NotSupportedError(TEXTURE_BORDER_CLAMP_NOT_SUPPORTED, "", __FILE__, __LINE__); |
| } |
| |
| GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::initTest(); |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| **/ |
| GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest::GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest( |
| Context& context, const ExtParameters& extParams, const char* name, const char* description) |
| : GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest(context, extParams, name, description) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Get wrap mode for texture |
| * |
| * @param out_wrap_mode Wrap mode |
| **/ |
| void GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest::getTextureWrapMode(glw::GLenum& out_wrap_mode) |
| { |
| out_wrap_mode = GL_CLAMP_TO_EDGE; |
| } |
| |
| /** Get parts of vertex shader |
| * |
| * @param out_vertex_shader_parts Vector of vertex shader parts |
| **/ |
| void GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest::getShaderParts( |
| std::vector<const glw::GLchar*>& out_vertex_shader_parts) |
| { |
| out_vertex_shader_parts.push_back(m_vertex_shader_code); |
| } |
| |
| /** Check if data captured for vertex at index are as expected |
| * |
| * @param captured_data Instance of capturedVaryings for vertex at index |
| * @param index Index of vertex |
| * @param texture_size Size of texture |
| * |
| * @return True Results match expected values |
| * False Results do not match expected values |
| **/ |
| bool GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest::checkResult(const CapturedVaryings& captured_data, |
| unsigned int index, unsigned int texture_size) |
| { |
| /* Get offsets for vertex */ |
| glw::GLint x_offset; |
| glw::GLint y_offset; |
| |
| getOffsets(x_offset, y_offset, index); |
| |
| /* Storage for expected values of with_offset varyings */ |
| glw::GLint expected_values[m_n_components_per_varying]; |
| |
| /* Index of first not clamped texel in without_offset set*/ |
| int not_clamped_texel_index = -1; |
| |
| /* X offsets of texels in 2x2 set */ |
| static const glw::GLint gather_offsets_x[] = { 0, 1, 1, 0 }; |
| |
| /* Find first not clamped texel in without_offset set */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| if ((int)texture_size != captured_data.without_offset[i]) |
| { |
| not_clamped_texel_index = i; |
| break; |
| } |
| } |
| |
| if (-1 == not_clamped_texel_index) |
| { |
| /* Log problem with sampler */ |
| m_testCtx.getLog() << tcu::TestLog::Section("Unexpected sampling results", ""); |
| |
| logCoordinates(index); |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage; |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset |
| << tcu::TestLog::EndMessage; |
| |
| logVaryings(captured_data); |
| |
| m_testCtx.getLog() << tcu::TestLog::EndSection; |
| |
| TCU_FAIL("Unexpected sampling results"); |
| } |
| |
| /* Fraction part of position for lower left texel without_offset set */ |
| const glw::GLint fract_position_x = |
| captured_data.without_offset[not_clamped_texel_index] - gather_offsets_x[not_clamped_texel_index]; |
| |
| /* Absolute position of lower left corner in without_offset set */ |
| const glw::GLint absolute_position_x = fract_position_x + captured_data.floor_tex_coord[0] * (int)texture_size; |
| |
| /* Calculate expected values of with_offset varyings */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| expected_values[i] = absolute_position_x + gather_offsets_x[i]; |
| expected_values[i] += x_offset; |
| |
| /* Clamp when point is outside of texture */ |
| clamp(expected_values[i], 0, ((glw::GLint)texture_size) - 1); |
| } |
| |
| /* Verify that expected_values match those in with_offset varyings */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| if (captured_data.with_offset[i] != expected_values[i]) |
| { |
| /* Log invalid results */ |
| m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", ""); |
| |
| logCoordinates(index); |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Texture size: " << texture_size << tcu::TestLog::EndMessage; |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Offsets: " << x_offset << ", " << y_offset |
| << tcu::TestLog::EndMessage; |
| |
| logVaryings(captured_data); |
| |
| m_testCtx.getLog() << tcu::TestLog::EndSection; |
| |
| /* Done */ |
| return false; |
| } |
| } |
| |
| /* Done */ |
| return true; |
| } |
| |
| /** Provides names of varyings to be captured by test |
| * |
| * @param out_captured_varyings Vector of varyings' names |
| **/ |
| void GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest::getVaryings( |
| std::vector<const glw::GLchar*>& out_captured_varyings) |
| { |
| out_captured_varyings.push_back("without_offset"); |
| out_captured_varyings.push_back("with_offset"); |
| out_captured_varyings.push_back("floor_tex_coord"); |
| } |
| |
| /** Initializes GLES objects used during the test. |
| * |
| */ |
| void GPUShader5TextureGatherOffsetDepth2DClampToEdgeCaseTest::initTest(void) |
| { |
| /* Check if texture_border_clamp extension is supported */ |
| if (!m_is_texture_border_clamp_supported) |
| { |
| throw tcu::NotSupportedError(TEXTURE_BORDER_CLAMP_NOT_SUPPORTED, "", __FILE__, __LINE__); |
| } |
| |
| GPUShader5TextureGatherOffsetDepth2DRepeatCaseTest::initTest(); |
| } |
| |
| /** Constructor |
| * |
| * @param context Test context |
| * @param name Test case's name |
| * @param description Test case's description |
| **/ |
| GPUShader5TextureGatherOffsetDepth2DOffsetsCaseTest::GPUShader5TextureGatherOffsetDepth2DOffsetsCaseTest( |
| Context& context, const ExtParameters& extParams, const char* name, const char* description) |
| : GPUShader5TextureGatherOffsetDepthTestBase(context, extParams, name, description) |
| { |
| /* Nothing to be done here */ |
| } |
| |
| /** Get parts of vertex shader |
| * |
| * @param out_vertex_shader_parts Vector of vertex shader parts |
| **/ |
| void GPUShader5TextureGatherOffsetDepth2DOffsetsCaseTest::getShaderParts( |
| std::vector<const glw::GLchar*>& out_vertex_shader_parts) |
| { |
| std::stringstream stream; |
| |
| stream << " ivec2[4]( ivec2( " << m_min_texture_gather_offset << ", " << m_min_texture_gather_offset |
| << "),\n"; |
| stream << " ivec2( " << m_min_texture_gather_offset << ", " << m_max_texture_gather_offset |
| << "),\n"; |
| stream << " ivec2( " << m_max_texture_gather_offset << ", " << m_min_texture_gather_offset |
| << "),\n"; |
| stream << " ivec2( " << m_max_texture_gather_offset << ", " << m_max_texture_gather_offset |
| << "));\n"; |
| |
| m_vertex_shader_code_offsets = stream.str(); |
| |
| out_vertex_shader_parts.push_back(m_vertex_shader_code_preamble); |
| out_vertex_shader_parts.push_back(m_vertex_shader_code_offsets.c_str()); |
| out_vertex_shader_parts.push_back(m_vertex_shader_code_body); |
| } |
| |
| /** Prepare test specific data, that will be used as vertex attributes |
| * |
| * @param vertex_buffer_infos Vector of vertexBufferInfo instances |
| **/ |
| void GPUShader5TextureGatherOffsetDepth2DOffsetsCaseTest::prepareVertexBuffersData( |
| std::vector<VertexBufferInfo>& vertex_buffer_infos) |
| { |
| DE_UNREF(vertex_buffer_infos); |
| |
| /* Nothing to be done here */ |
| } |
| |
| /** Check if data captured for vertex at index are as expected |
| * |
| * @param captured_data Instance of capturedVaryings for vertex at index |
| * @param index Index of vertex |
| * @param texture_size Size of texture |
| * |
| * @return True Results match expected values |
| * False Results do not match expected values |
| **/ |
| bool GPUShader5TextureGatherOffsetDepth2DOffsetsCaseTest::checkResult(const CapturedVaryings& captured_data, |
| unsigned int index, unsigned int tex_size) |
| { |
| /* Signed int value has to be used with operator % in order to work as expected */ |
| const glw::GLint texture_size = (glw::GLint)tex_size; |
| |
| /* X and Y offsets */ |
| glw::GLint x_offsets[m_n_components_per_varying] = { |
| m_min_texture_gather_offset, m_min_texture_gather_offset, m_max_texture_gather_offset, |
| m_max_texture_gather_offset, |
| }; |
| |
| glw::GLint y_offsets[m_n_components_per_varying] = { |
| m_min_texture_gather_offset, m_max_texture_gather_offset, m_min_texture_gather_offset, |
| m_max_texture_gather_offset, |
| }; |
| |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| /* Roll x offsets around left edge when negative */ |
| if (0 > x_offsets[i]) |
| { |
| x_offsets[i] = x_offsets[i] % texture_size; |
| x_offsets[i] += texture_size; |
| } |
| } |
| |
| /* Storage for expected values of with_offset varyings */ |
| glw::GLint expected_values[m_n_components_per_varying]; |
| |
| /* Calculate expected values of with_offset varyings */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| expected_values[i] = ((x_offsets[i] + captured_data.without_offset[3]) % texture_size); |
| } |
| |
| /* Verify that expected_values match those in with_offset varyings */ |
| for (unsigned int i = 0; i < m_n_components_per_varying; ++i) |
| { |
| if (captured_data.with_offset[i] != expected_values[i]) |
| { |
| /* Log invalid results */ |
| m_testCtx.getLog() << tcu::TestLog::Section("Invalid result", ""); |
| |
| logCoordinates( |
