#ifndef _GL3CTEXTURESIZEPROMOTION_HPP #define _GL3CTEXTURESIZEPROMOTION_HPP /*------------------------------------------------------------------------- * OpenGL Conformance Test Suite * ----------------------------- * * Copyright (c) 2015-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 gl3cTextureSizePromotionTests.hpp * \brief Declares test classes for testing of texture internal format promotion mechanism. */ /*-------------------------------------------------------------------*/ #include "glcTestCase.hpp" #include "glwDefs.hpp" #include "glwEnums.hpp" #include "tcuDefs.hpp" #include "tcuVector.hpp" namespace gl3cts { namespace TextureSizePromotion { /** Test group class for texture size promotion tests */ class Tests : public deqp::TestCaseGroup { public: /* Public member functions. */ Tests(deqp::Context& context); //!< Constructor. virtual ~Tests() { } //!< Destructor virtual void init(void); //!< Initialization member function. private: /* Private member functions. */ Tests(const Tests&); //!< Default copy constructor. Tests& operator=(const Tests&); //!< Default assign constructor. }; /** Functional Test Class * * This test verifies that implementation correctly selects sizes and types * when sized internal format is requested for a texture. * * This test should be executed only if context is at least 3.1. * * Steps: * - prepare a source texture so that each channel is filled with specific value; * - execute GetTexLevelPrameter to query all TEXTURE_*_SIZE and TEXTURE_*_TYPE * s corresponding with internal format of source texture; It is * expected that: * * reported sizes will be at least as specified; * * reported types will be exactly as specified; * - for each channel [R, G, B, A]: * * prepare a 2D single channeled texture with format matching sampled * channel and set it up as output color in framebuffer; * * prepare a program that will implement the following snippet in the * fragment stage and output the value of result: * * result = texelFetch(source).C; * * * clear output texture; * * draw a full-screen quad; * * verify that the output texture is filled with correct value; * * Value is correct when: * - it matches value assigned to the specified channel; * - it is one for missing alpha channel; * - it is zero for missing channel; * - it is one for ONE; * - it is zero for ZERO. * * Repeat the steps for all supported sized internal formats and targets. * * Depth-stencil textures can be sampled only via RED channel. Test should set * DEPTH_STENCIL_TEXTURE_MODE to select which channel will be accessed. * * For multisampled targets maximum supported number of samples should be used * and fetch should be done to last sample. * * Support of multisampled targets by TexParameter* routines was introduced in * extension GL_ARB_texture_storage_multisample, which is part of core * specification since 4.3. * * List of required texture formats was changed in 4.4. Therefore the list of * "supported sized internal formats" depends on context version. */ class FunctionalTest : public deqp::TestCase { public: /* Public member functions. */ FunctionalTest(deqp::Context& context); //!< Functional test constructor. virtual tcu::TestNode::IterateResult iterate(); //!< Member function to iterate over test cases. private: /* Private member variables. */ glw::GLuint m_vao; //!< Vertex Array Object name. glw::GLuint m_source_texture; //!< Source Texture Object name. glw::GLuint m_destination_texture; //!< Destination Texture Object name. glw::GLuint m_framebuffer; //!< Framebuffer Object name. glw::GLuint m_program; //!< Program Object name. glw::GLint m_max_samples; //!< Maximum samples available for usage in multisampled targets. /* Private type definitions. */ /** Texture Internal Format Description structure */ struct TextureInternalFormatDescriptor { glu::ContextType required_by_context; //!< Minimum context version by which format is required. glw::GLenum internal_format; //!< Texture internal format. const glw::GLchar* internal_format_name; //!< String representing texture internal format. bool is_sRGB; //!< Is this format described in sRGB space. bool is_color_renderable; //!< Is this format color renderable. glw::GLint min_red_size; //!< Minimum required red component resolution (in bits). glw::GLint min_green_size; //!< Minimum required green component resolution (in bits). glw::GLint min_blue_size; //!< Minimum required blue component resolution (in bits). glw::GLint min_alpha_size; //!< Minimum required alpha component resolution (in bits). glw::GLint min_depth_size; //!< Minimum required depth component resolution (in bits). glw::GLint min_stencil_size; //!< Minimum required stencil component resolution (in bits). glw::GLenum expected_red_type; //!< Expected type of red component. glw::GLenum expected_green_type; //!< Expected type of green component. glw::GLenum expected_blue_type; //!< Expected type of blue component. glw::GLenum expected_alpha_type; //!< Expected type of alpha component. glw::GLenum expected_depth_type; //!< Expected type of depth component. }; /** Color channels enumeration */ enum ColorChannelSelector { RED_COMPONENT, //!< Red component. GREEN_COMPONENT, //!< Green component. BLUE_COMPONENT, //!< Blue component. ALPHA_COMPONENT, //!< Alpha component (must be last color channel). COMPONENTS_COUNT //!< Number of components. }; /* Private class' static constants. */ static const glw::GLfloat s_source_texture_data_f[]; //!< Source texture for floating point type internal formats. static const glw::GLfloat s_source_texture_data_n[]; //!< Source texture for unsigned normalized integer type internal formats. static const glw::GLfloat s_source_texture_data_sn[]; //!< Source texture for signed normalized integer type internal formats. static const glw::GLint s_source_texture_data_i[]; //!< Source texture for signed integer type internal formats. static const glw::GLuint s_source_texture_data_ui[]; //!< Source texture for unsigned integer type internal formats. static const glw::GLuint s_source_texture_size; //!< Linear size of the source texture. static const glw::GLfloat s_destination_texture_data_f []; //!< Destination texture data (to be sure that it was overwritten) for floating point and normalized types internal formats. static const glw::GLint s_destination_texture_data_i []; //!< Destination texture data (to be sure that it was overwritten) signed integer type internal formats. static const glw::GLuint s_destination_texture_data_ui []; //!< Destination texture data (to be sure that it was overwritten) unsigned integer type internal formats. static const glw::GLenum s_source_texture_targets[]; //!< Targets to be tested. static const glw::GLchar* s_source_texture_targets_names[]; //!< Targets' names (strings) for logging purpose. static const glw::GLuint s_source_texture_targets_count; //!< Number of targets to be tested. static const glw::GLchar* s_color_channel_names[]; //!< Color channel names (like in enum) for logging purpose. static const glw::GLchar* s_vertex_shader_code; //!< Vertex shader source code for drawing quad depending on vertex ID of triangle strip. static const glw::GLchar* s_fragment_shader_template; //!< Fragment shader source code template. static const TextureInternalFormatDescriptor s_formats[]; //!< List of internal formats (and their descriptions) to be tested by Functional Test. static const glw::GLuint s_formats_size; //!< number of internal format to be tested. /* Private member functions. */ /** Generate and bind an empty Vertex Array Object. */ void prepareVertexArrayObject(); /** Generate, bind and upload source texture. * * @param [in] descriptor Internal format description. * @param [in] target Texture target to be used. */ void prepareSourceTexture(TextureInternalFormatDescriptor descriptor, glw::GLenum target); /** Generate, bind and clean destination texture. * * @param [in] descriptor Internal format description. * @param [in] target Texture target to be used. */ void prepareDestinationTextureAndFramebuffer(TextureInternalFormatDescriptor descriptor, glw::GLenum target); /** Preprocess, compile and linke GLSL program. * * @param [in] target Texture target to be used. * @param [in] descriptor Internal format description. * @param [in] channel Color channel to be tested. * * @return Program name on success, 0 on failure. */ glw::GLuint prepareProgram(glw::GLenum target, TextureInternalFormatDescriptor descriptor, ColorChannelSelector channel); /** Use GLSL program with source and destination textures. * * @param [in] target Texture target to be used. */ void makeProgramAndSourceTextureActive(glw::GLenum target); /** Check source texture queries. * * @param [in] descriptor Internal format description. * @param [in] target Texture target to be used. */ bool checkSourceTextureSizeAndType(TextureInternalFormatDescriptor descriptor, glw::GLenum target); /** Draw quad using GL_TRIANGLE_STRIP. */ void drawQuad(); /** Check rendered destination texture to match expected values. * * @param [in] descriptor Internal format description. * @param [in] channel Used color channel. * @param [in] target Texture target to be used. * @param [in] target_name Texture target name for logging purposes. * * @return True if fetched value matches expected value within the range of precission, false otherwise. */ bool checkDestinationTexture(TextureInternalFormatDescriptor descriptor, ColorChannelSelector channel, glw::GLenum target, const glw::GLchar* target_name); /** Clean source texture object. */ void cleanSourceTexture(); /** Clean framebuffer object. */ void cleanFramebuffer(); /** Clean destination texture object. */ void cleanDestinationTexture(); /** Clean program object. */ void cleanProgram(); /** Clean vertex array object object. */ void cleanVertexArrayObject(); /** Choose internal format of destination texture for rendered source texture. * * @param [in] descriptor Internal format description. */ glw::GLenum getDestinationFormatForChannel(TextureInternalFormatDescriptor descriptor); /** Is internal format a floating type. * * @param [in] descriptor Internal format description. * * @return True if internal format is floating point type, false otherwise. */ bool isFloatType(TextureInternalFormatDescriptor descriptor); /** Is internal format a fixed signed type. * * @param [in] descriptor Internal format description. * * @return True if internal format is fixed signed type, false otherwise. */ bool isFixedSignedType(TextureInternalFormatDescriptor descriptor); /** Is internal format a fixed unsigned type. * * @param [in] descriptor Internal format description. * * @return True if internal format is fixed unsigned type, false otherwise. */ bool isFixedUnsignedType(TextureInternalFormatDescriptor descriptor); /** Is internal format a signed integral type. * * @param [in] descriptor Internal format description. * * @return True if internal format is integral signed type, false otherwise. */ bool isIntegerSignedType(TextureInternalFormatDescriptor descriptor); /** Is internal format an unsigned integral type. * * @param [in] descriptor Internal format description. * * @return True if internal format is integral unsigned type, false otherwise. */ bool isIntegerUnsignedType(TextureInternalFormatDescriptor descriptor); /** Is internal format a depth type. * * @param [in] descriptor Internal format description. * * @return True if internal format is depth type, false otherwise. */ bool isDepthType(TextureInternalFormatDescriptor descriptor); /** Is internal format a stencil type. * * @param [in] descriptor Internal format description. * * @return True if internal format is stencil type, false otherwise. */ bool isStencilType(TextureInternalFormatDescriptor descriptor); /** Is channel of internal format a none type (does not appear in the texture internal format). * * @param [in] descriptor Internal format description. * @param [in] channel Color channel to be queried. * * @return True if internal format is none type, false otherwise. */ bool isChannelTypeNone(TextureInternalFormatDescriptor descriptor, ColorChannelSelector channel); /** Calculate minimal required precission for internal format's channel. * * @note It is needed only for floating point and normalized fixed point types. * * @param [in] descriptor Internal format description. * @param [in] channel Color channel to be queried. * * @return Minimum precission. */ glw::GLfloat getMinPrecision(TextureInternalFormatDescriptor descriptor, ColorChannelSelector channel); /** Is target multisample. * * @param [in] target Target. * * @return True if target is multisampled, false otherwise. */ bool isTargetMultisampled(glw::GLenum target); /** Render data to the source texture for multisampled texture. * * @param [in] descriptor Internal format description. * @param [in] target Texture target to be used. */ void renderDataIntoMultisampledTexture(TextureInternalFormatDescriptor descriptor, glw::GLenum target); /** Convert value from sRGB space to linear space. * * @param [in] value Value to be converted (sRGB space). * * @return Converted value (linear space). */ float convert_from_sRGB(float value); }; /* class TextureSizePromotion */ namespace Utilities { /** Build a GLSL program * * @param [in] gl OpenGL Functions Access. * @param [in] log Log outut. * @param [in] vertex_shader_source Pointer to C string of the vertex shader or NULL if not used. * @param [in] fragment_shader_source Pointer to C string of the fragment shader or NULL if not used. * * @return OpenGL program shader ID or zero if error had occured. */ glw::GLuint buildProgram(glw::Functions const& gl, tcu::TestLog& log, glw::GLchar const* const vertex_shader_source, glw::GLchar const* const fragment_shader_source); /** Preprocess source string by replacing key tokens with new values. * * @param [in] source Source string. * @param [in] key Key, substring to be replaced. * @param [in] value Value, substring to be substituted in place of key. * * @return Preprocessed string. */ std::string preprocessString(std::string source, std::string key, std::string value); /** @brief Convert an integer to a string. * * @param [in] i Integer to be converted. * * @return String representing integer. */ std::string itoa(glw::GLint i); } } /* TextureSizePromotion namespace */ } /* gl3cts namespace */ #endif // _GL3CTEXTURESIZEPROMOTION_HPP