| #ifndef _ESEXTCTEXTUREBORDERCLAMPSAMPLINGTEXTURE_HPP |
| #define _ESEXTCTEXTUREBORDERCLAMPSAMPLINGTEXTURE_HPP |
| /*------------------------------------------------------------------------- |
| * 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 esextcTextureBorderClampSamplingTexture.hpp |
| * \brief Verify that sampling a texture with GL_CLAMP_TO_BORDER_EXT |
| * wrap mode enabled gives correct results (Test 7) |
| */ /*-------------------------------------------------------------------*/ |
| |
| #include "../esextcTestCaseBase.hpp" |
| #include "glwEnums.hpp" |
| #include <vector> |
| |
| namespace glcts |
| { |
| |
| /** Class to store test configuration |
| */ |
| template <typename InputType, typename OutputType> |
| class TestConfiguration |
| { |
| public: |
| /* Public functions */ |
| TestConfiguration(glw::GLsizei nInputComponents, glw::GLsizei nOutputComponents, glw::GLenum target, |
| glw::GLenum inputInternalFormat, glw::GLenum outputInternalFormat, glw::GLenum filtering, |
| glw::GLenum inputFormat, glw::GLenum outputFormat, glw::GLuint width, glw::GLuint height, |
| glw::GLuint depth, InputType initValue, InputType initBorderColor, OutputType expectedValue, |
| OutputType expectedBorderColor, glw::GLenum inputType, glw::GLenum outputType); |
| |
| TestConfiguration(const TestConfiguration& configuration); |
| |
| virtual ~TestConfiguration() |
| { |
| } |
| |
| inline glw::GLsizei get_n_in_components(void) const |
| { |
| return m_n_in_components; |
| } |
| inline glw::GLsizei get_n_out_components(void) const |
| { |
| return m_n_out_components; |
| } |
| inline glw::GLenum get_target(void) const |
| { |
| return m_target; |
| } |
| inline glw::GLenum get_input_internal_format(void) const |
| { |
| return m_input_internal_format; |
| } |
| inline glw::GLenum get_output_internal_format(void) const |
| { |
| return m_output_internal_format; |
| } |
| inline glw::GLenum get_filtering(void) const |
| { |
| return m_filtering; |
| } |
| inline glw::GLenum get_input_format(void) const |
| { |
| return m_input_format; |
| } |
| inline glw::GLenum get_output_format(void) const |
| { |
| return m_output_format; |
| } |
| inline glw::GLuint get_width(void) const |
| { |
| return m_width; |
| } |
| inline glw::GLuint get_height(void) const |
| { |
| return m_height; |
| } |
| inline glw::GLuint get_depth(void) const |
| { |
| return m_depth; |
| } |
| inline InputType get_init_value(void) const |
| { |
| return m_init_value; |
| } |
| inline InputType get_init_border_color(void) const |
| { |
| return m_init_border_color; |
| } |
| inline OutputType get_expected_value(void) const |
| { |
| return m_expected_value; |
| } |
| inline OutputType get_expected_border_color(void) const |
| { |
| return m_expected_border_color; |
| } |
| inline glw::GLenum get_input_type(void) const |
| { |
| return m_input_type; |
| } |
| inline glw::GLenum get_output_type(void) const |
| { |
| return m_output_type; |
| } |
| |
| private: |
| /* Private variables */ |
| glw::GLsizei m_n_in_components; |
| glw::GLsizei m_n_out_components; |
| glw::GLenum m_target; |
| glw::GLenum m_input_internal_format; |
| glw::GLenum m_output_internal_format; |
| glw::GLenum m_filtering; |
| glw::GLenum m_input_format; |
| glw::GLenum m_output_format; |
| glw::GLuint m_width; |
| glw::GLuint m_height; |
| glw::GLuint m_depth; |
| InputType m_init_value; |
| InputType m_init_border_color; |
| OutputType m_expected_value; |
| OutputType m_expected_border_color; |
| glw::GLenum m_input_type; |
| glw::GLenum m_output_type; |
| }; |
| |
| /* Implementation of Test 7 from CTS_EXT_texture_border_clamp. Description follows |
| * |
| * Verify that sampling a texture with GL_CLAMP_TO_BORDER_EXT wrap mode |
| * enabled for all R/S/T dimensions gives correct results. |
| * |
| * Category: Functional test; |
| * |
| * Suggested priority: Must-have. |
| * |
| * This test should iterate over the following texture targets supported by |
| * ES3.1: |
| * |
| * - 2D textures; |
| * - 2D array textures; |
| * - 3D textures; |
| * |
| * (note that cube-map texture targets are left out, as seamless filtering |
| * renders the border color effectively useless) |
| * |
| * For each texture target, the test should iterate over the following the |
| * set of internal formats: |
| * |
| * - GL_RGBA32F; |
| * - GL_R32UI; |
| * - GL_R32I; |
| * - GL_RGBA8; |
| * - GL_DEPTH_COMPONENT32F; |
| * - GL_DEPTH_COMPONENT16; |
| * - At least one compressed internal format described in the extension |
| * specification. |
| * |
| * Note: For glCompressedTexImage2D() or glCompressedTexImage3D() calls, |
| * it is expected that predefined valid blobs will be used. |
| * |
| * The texture size used in the test should be 256x256 for 2d textures, |
| * 256x256x6 for 2d array textures and 3d textures (smaller sizes are |
| * allowed for compressed internal format). |
| * |
| * For each texture we should have two iterations, one with GL_LINEAR |
| * minification filtering, the second with GL_NEAREST minification |
| * filtering. |
| * |
| * Reference texture data should be as follows: |
| * |
| * * Floating-point: (0.0, 0.0, 0.0, 0.0); |
| * * Unsigned integer: (0); |
| * * Signed integer: (0); |
| * * Normalized fixed-point: (0, 0, 0, 0); |
| * * Depth (floating-point): (0.0); |
| * * Depth (unsigned short): (0); |
| * |
| * The border color should be set to: |
| * |
| * * Floating-point: (1.0, 1.0, 1.0, 1.0); |
| * * Unsigned integer: (255, 255, 255, 255); |
| * * Signed integer: (255, 255, 255, 255); |
| * * Normalized fixed-point: (255, 255, 255, 255); |
| * * Depth (floating-point): (1.0, 1.0, 1.0, 1.0); |
| * * Depth (unsigned short): (255, 255, 255, 255); |
| * |
| * In each iteration, the test should render a full-screen quad to |
| * a two-dimensional texture of resolution 256x256 (smaller sizes are |
| * allowed for compressed internal format) and internal format |
| * compatible with the format of the texture used in this iteration |
| * (we take into account that values stored in floating-point textures |
| * are bigger than 0.0 and smaller than 1.0): |
| * |
| * - GL_RGBA8; |
| * - GL_R32UI; |
| * - GL_R32I; |
| * - GL_RGBA8; |
| * - GL_R8; |
| * - GL_R8; |
| * |
| * The following UVs should be outputted by the vertex shader: |
| * |
| * - (-1, -1) for bottom-left corner of the viewport; |
| * - (-1, 2) for top-left corner of the viewport; |
| * - ( 2, 2) for top-right corner of the viewport; |
| * - ( 2, -1) for bottom-right corner of the viewport; |
| * |
| * The fragment shader should sample an iteration-specific texture sampler |
| * at given UV location. The shader should output the result of this |
| * sampling as the color value. |
| * |
| * The test succeeds, if result texture is valid for all texture target + |
| * internal format combinations. |
| * |
| * Verification process for each iteration should be as follows: |
| * |
| * 1) Download rendered data to process space; |
| * 2) The expected rendering outcome for GL_NEAREST minification filtering |
| * is as depicted below: |
| * |
| * (-1, -1) (0, -1) (1, -1) (2, -1) |
| * *-------+-------+-------* |
| * | | | | |
| * | BC | BC | BC | |
| * | | | | |
| * (-1, 0) +-------+-------+-------+ (2, 0) |
| * | | | | |
| * | BC | 0 | BC | |
| * | | | | |
| * (-1, 1) +-------+-------+-------+ (2, 1) |
| * | | | | |
| * | BC | BC | BC | |
| * | | | | |
| * *-------+-------+-------* |
| * (-1, 2) (0, 2) (1, 2) (2, 2) |
| * |
| * BC means the border color for the used internal format. |
| * |
| * Values in the brackets correspond to UV space. Top-left corner corresponds |
| * to bottom-left corner of the data in GL orientation (that is: as retrieved |
| * by glReadPixels() call). |
| * |
| * Note for 2D array texture: assuming a texture of depth n_layers, |
| * for which 0..n_layers-1 have been defined (inclusive), the test should |
| * sample data from -1, 0 .. n_layers layers. It is expected that for sampling |
| * outside of <0, n_layers-1> set of layers the layer number will be clamped |
| * the the range <0, n_layers-1>. This means that result textures for border |
| * cases should be the same as for sampling from inside of <0, n_layers-1> |
| * range. |
| * |
| * Note for 3D texture: assuming a texture of depth n_layers, |
| * for which 0..n_layers-1 have been defined (inclusive), the test should |
| * sample data from -1, 0 .. n_layers layers. It is expected that sampling |
| * outside <0, n_layers-1> set of layers or slices of the texture should |
| * return the border color defined for the texture object being sampled. |
| * This means that result textures for border cases should be completely |
| * filled with BC color. |
| * |
| * Iteration passes if centres of all rectangles contain the correct colors. |
| * |
| * 3) The expected rendering outcome for GL_LINEAR minification filtering is |
| * to some extent similar to the one for GL_NEAREST, with the difference that |
| * the transition between 0 and BC values is smooth (some values in between 0 |
| * and BC may appear on the edge of the rectangles). For this case we need |
| * a different way of checking if the rendering outcome is correct. We should |
| * start in the middle of the texture and check values of texels moving in four |
| * directions - to the left, right, bottom, top. In each direction the values of |
| * the texels should form a monotonically increasing series. |
| */ |
| template <typename InputType, typename OutputType> |
| class TextureBorderClampSamplingTexture : public TestCaseBase |
| { |
| public: |
| /* Public methods */ |
| TextureBorderClampSamplingTexture(Context& context, const ExtParameters& extParams, const char* name, |
| const char* description, |
| const TestConfiguration<InputType, OutputType>& configuration); |
| |
| virtual ~TextureBorderClampSamplingTexture() |
| { |
| } |
| |
| virtual void deinit(void); |
| virtual IterateResult iterate(void); |
| |
| private: |
| /* Private methods */ |
| void initTest(void); |
| void setInitData(std::vector<InputType>& buffer); |
| void checkFramebufferStatus(glw::GLenum framebuffer); |
| bool checkResult(OutputType expectedValue, OutputType expectedBorderColor, glw::GLint layer); |
| bool checkNearest(std::vector<OutputType>& buffer, OutputType expectedValue, OutputType expectedBorderColor, |
| glw::GLint layer); |
| bool checkLinear(std::vector<OutputType>& buffer, glw::GLint layer); |
| void createTextures(void); |
| glw::GLfloat getCoordinateValue(glw::GLint index); |
| std::string getFragmentShaderCode(void); |
| std::string getVertexShaderCode(void); |
| glw::GLint getStartingLayerIndex(); |
| glw::GLint getLastLayerIndex(); |
| |
| /* Private variables */ |
| glw::GLint m_attr_position_location; |
| glw::GLint m_attr_texcoord_location; |
| glw::GLuint m_fbo_id; |
| glw::GLuint m_fs_id; |
| glw::GLuint m_po_id; |
| glw::GLuint m_sampler_id; |
| TestConfiguration<InputType, OutputType> m_test_configuration; |
| glw::GLuint m_input_to_id; |
| glw::GLuint m_output_to_id; |
| glw::GLuint m_position_vbo_id; |
| glw::GLuint m_text_coord_vbo_id; |
| glw::GLuint m_vs_id; |
| glw::GLuint m_vao_id; |
| |
| /* Private static variables */ |
| static const glw::GLuint m_texture_unit; |
| }; |
| |
| } // namespace glcts |
| |
| #endif // _ESEXTCTEXTUREBORDERCLAMPSAMPLINGTEXTURE_HPP |
