| #ifndef _GL4CTEXTUREVIEWTESTS_HPP |
| #define _GL4CTEXTUREVIEWTESTS_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 gl4cTextureViewTests.hpp |
| * \brief Declares test classes for "texture view" functionality. |
| */ /*-------------------------------------------------------------------*/ |
| |
| #include "glcTestCase.hpp" |
| #include "glwDefs.hpp" |
| #include "glwEnums.hpp" |
| #include "tcuDefs.hpp" |
| #include "tcuVector.hpp" |
| |
| namespace gl4cts |
| { |
| namespace TextureView |
| { |
| |
| enum _format |
| { |
| FORMAT_FLOAT, |
| FORMAT_RGBE, |
| FORMAT_SIGNED_INTEGER, |
| FORMAT_SNORM, |
| FORMAT_UNORM, |
| FORMAT_UNSIGNED_INTEGER, |
| |
| FORMAT_UNDEFINED |
| }; |
| |
| enum _sampler_type |
| { |
| SAMPLER_TYPE_FLOAT, |
| SAMPLER_TYPE_SIGNED_INTEGER, |
| SAMPLER_TYPE_UNSIGNED_INTEGER, |
| |
| SAMPLER_TYPE_UNDEFINED |
| }; |
| |
| enum _view_class |
| { |
| VIEW_CLASS_FIRST, |
| |
| VIEW_CLASS_128_BITS = VIEW_CLASS_FIRST, |
| VIEW_CLASS_96_BITS, |
| VIEW_CLASS_64_BITS, |
| VIEW_CLASS_48_BITS, |
| VIEW_CLASS_32_BITS, |
| VIEW_CLASS_24_BITS, |
| VIEW_CLASS_16_BITS, |
| VIEW_CLASS_8_BITS, |
| VIEW_CLASS_RGTC1_RED, |
| VIEW_CLASS_RGTC2_RG, |
| VIEW_CLASS_BPTC_UNORM, |
| VIEW_CLASS_BPTC_FLOAT, |
| |
| /* Always last */ |
| VIEW_CLASS_COUNT, |
| VIEW_CLASS_UNDEFINED = VIEW_CLASS_COUNT |
| }; |
| |
| } // namespace TextureView |
| |
| /** Helper class that implements various methods used across all Texture View tests. */ |
| class TextureViewUtilities |
| { |
| public: |
| /* Public type definitions */ |
| typedef glw::GLenum _original_texture_internalformat; |
| typedef glw::GLenum _original_texture_target; |
| typedef glw::GLenum _view_texture_internalformat; |
| typedef glw::GLenum _view_texture_target; |
| typedef std::pair<_original_texture_internalformat, _view_texture_internalformat> _internalformat_pair; |
| typedef std::vector<glw::GLenum> _internalformats; |
| typedef _internalformats::const_iterator _internalformats_const_iterator; |
| typedef _internalformats::iterator _internalformats_iterator; |
| typedef std::pair<_original_texture_target, _view_texture_target> _texture_target_pair; |
| typedef std::vector<_internalformat_pair> _compatible_internalformat_pairs; |
| typedef _compatible_internalformat_pairs::const_iterator _compatible_internalformat_pairs_const_iterator; |
| typedef std::vector<_texture_target_pair> _compatible_texture_target_pairs; |
| typedef _compatible_texture_target_pairs::const_iterator _compatible_texture_target_pairs_const_iterator; |
| typedef std::vector<_internalformat_pair> _incompatible_internalformat_pairs; |
| typedef _incompatible_internalformat_pairs::const_iterator _incompatible_internalformat_pairs_const_iterator; |
| typedef _incompatible_internalformat_pairs::iterator _incompatible_internalformat_pairs_iterator; |
| typedef std::vector<_texture_target_pair> _incompatible_texture_target_pairs; |
| typedef _incompatible_texture_target_pairs::const_iterator _incompatible_texture_target_pairs_const_iterator; |
| typedef _incompatible_texture_target_pairs::iterator _incompatible_texture_target_pairs_iterator; |
| |
| /* Public methods */ |
| |
| static unsigned int getAmountOfComponentsForInternalformat(const glw::GLenum internalformat); |
| |
| static unsigned int getBlockSizeForCompressedInternalformat(const glw::GLenum internalformat); |
| |
| static void getComponentSizeForInternalformat(const glw::GLenum internalformat, unsigned int* out_rgba_size); |
| |
| static void getComponentSizeForType(const glw::GLenum type, unsigned int* out_rgba_size); |
| |
| static const char* getErrorCodeString(const glw::GLint error_code); |
| |
| static TextureView::_format getFormatOfInternalformat(const glw::GLenum internalformat); |
| |
| static glw::GLenum getGLFormatOfInternalformat(const glw::GLenum internalformat); |
| |
| static const char* getGLSLDataTypeForSamplerType(const TextureView::_sampler_type sampler_type, |
| const unsigned int n_components); |
| |
| static const char* getGLSLTypeForSamplerType(const TextureView::_sampler_type sampler_type); |
| |
| static _incompatible_internalformat_pairs getIllegalTextureAndViewInternalformatCombinations(); |
| |
| static _incompatible_texture_target_pairs getIllegalTextureAndViewTargetCombinations(); |
| |
| static _internalformats getInternalformatsFromViewClass(TextureView::_view_class view_class); |
| |
| static const char* getInternalformatString(const glw::GLenum internalformat); |
| |
| static _compatible_internalformat_pairs getLegalTextureAndViewInternalformatCombinations(); |
| |
| static _compatible_texture_target_pairs getLegalTextureAndViewTargetCombinations(); |
| |
| static void getMajorMinorVersionFromContextVersion(const glu::ContextType& context_type, |
| glw::GLint* out_major_version, glw::GLint* out_minor_version); |
| |
| static TextureView::_sampler_type getSamplerTypeForInternalformat(const glw::GLenum internalformat); |
| |
| static unsigned int getTextureDataSize(const glw::GLenum internalformat, const glw::GLenum type, |
| const unsigned int width, const unsigned int height); |
| |
| static const char* getTextureTargetString(const glw::GLenum texture_target); |
| |
| static glw::GLenum getTypeCompatibleWithInternalformat(const glw::GLenum internalformat); |
| |
| static TextureView::_view_class getViewClassForInternalformat(const glw::GLenum internalformat); |
| |
| static void initTextureStorage(const glw::Functions& gl, bool init_mutable_to, glw::GLenum texture_target, |
| glw::GLint texture_depth, glw::GLint texture_height, glw::GLint texture_width, |
| glw::GLenum texture_internalformat, glw::GLenum texture_format, |
| glw::GLenum texture_type, unsigned int n_levels_needed, |
| unsigned int n_cubemaps_needed, glw::GLint bo_id); |
| |
| static bool isInternalformatCompatibleForTextureView(glw::GLenum original_internalformat, |
| glw::GLenum view_internalformat); |
| |
| static bool isInternalformatCompressed(const glw::GLenum internalformat); |
| |
| static bool isInternalformatSRGB(const glw::GLenum internalformat); |
| |
| static bool isInternalformatSupported(glw::GLenum internalformat, const glw::GLint major_version, |
| const glw::GLint minor_version); |
| |
| static bool isLegalTextureTargetForTextureView(glw::GLenum original_texture_target, |
| glw::GLenum view_texture_target); |
| }; |
| |
| /** |
| * 1. Make sure glGetTexParameterfv() and glGetTexParameteriv() report |
| * correct values for the following texture view-specific |
| * properties: |
| * |
| * * GL_TEXTURE_IMMUTABLE_LEVELS; (in texture view-specific context |
| * only) |
| * * GL_TEXTURE_VIEW_MIN_LAYER; |
| * * GL_TEXTURE_VIEW_MIN_LEVEL; |
| * * GL_TEXTURE_VIEW_NUM_LAYERS; |
| * * GL_TEXTURE_VIEW_NUM_LEVELS; |
| * |
| * These properties should be set to 0 (or GL_FALSE) by default. |
| * For textures created with glTexStorage() and glTextureView() |
| * functions, language from bullet (11) of GL_ARB_texture_view |
| * extension specification applies, as well as "Texture Views" |
| * section 8.18 of OpenGL 4.3 Core Profile specification. |
| * |
| * The conformance test should check values of the aforementioned |
| * properties for the following objects: |
| * |
| * 1) mutable texture objects generated with glTexImage*D() calls, |
| * then bound to all supported texture targets (as described |
| * under (*) ). |
| * 2) immutable texture objects generated with glTexStorage*D() calls |
| * for all supported texture targets (as described under (*) ). |
| * 3) texture views using all texture targets (as described under |
| * (*) ) compatible with parent texture object's texture target. |
| * All texture targets should be considered for the parent object. |
| * 4) texture views created on top of texture views described in 3). |
| * |
| * For texture view cases, the test should verify that: |
| * |
| * 1) GL_TEXTURE_VIEW_NUM_LAYERS and GL_TEXTURE_VIEW_NUM_LEVELS are |
| * clamped as specified for cases where <numlayers> or <numlevels> |
| * arguments used for glTextureView() calls exceed beyond the |
| * original texture. |
| * 2) GL_TEXTURE_VIEW_MIN_LEVEL is set to <minlevel> + value of |
| * GL_TEXTURE_VIEW_MIN_LEVEL from the original texture. |
| * 3) GL_TEXTURE_VIEW_MIN_LAYER is set to <minlayer> + value of |
| * GL_TEXTURE_VIEW_MIN_LAYER from the original texture. |
| * 4) GL_TEXTURE_VIEW_NUM_LEVELS is set to the lesser of <numlevels> |
| * and the value of original texture's GL_TEXTURE_VIEW_NUM_LEVELS |
| * minus <minlevels>. |
| * 5) GL_TEXTURE_VIEW_NUM_LAYERS is set to the lesser of <numlayers> |
| * and the value of original texture's GL_TEXTURE_VIEW_NUM_LAYERS |
| * minus <minlayer>. |
| * |
| * A single configuration of a texture object and a texture view |
| * for each valid texture target should be considered for the |
| * purpose of the test. |
| * |
| * (*) Texture targets to use: |
| * |
| * * GL_TEXTURE_1D; |
| * * GL_TEXTURE_1D_ARRAY; |
| * * GL_TEXTURE_2D; |
| * * GL_TEXTURE_2D_ARRAY; |
| * * GL_TEXTURE_2D_MULTISAMPLE; |
| * * GL_TEXTURE_2D_MULTISAMPLE_ARRAY; |
| * * GL_TEXTURE_3D; |
| * * GL_TEXTURE_CUBE_MAP; |
| * * GL_TEXTURE_CUBE_MAP_ARRAY; |
| * * GL_TEXTURE_RECTANGLE; |
| **/ |
| class TextureViewTestGetTexParameter : public deqp::TestCase |
| { |
| public: |
| /* Public methods */ |
| TextureViewTestGetTexParameter(deqp::Context& context); |
| |
| virtual ~TextureViewTestGetTexParameter() |
| { |
| } |
| |
| virtual void deinit(); |
| virtual tcu::TestNode::IterateResult iterate(); |
| |
| private: |
| /* Private type definitions */ |
| enum _test_texture_type |
| { |
| TEST_TEXTURE_TYPE_NO_STORAGE_ALLOCATED, |
| TEST_TEXTURE_TYPE_IMMUTABLE_TEXTURE_OBJECT, |
| TEST_TEXTURE_TYPE_MUTABLE_TEXTURE_OBJECT, |
| TEST_TEXTURE_TYPE_TEXTURE_VIEW_CREATED_FROM_IMMUTABLE_TEXTURE_OBJECT, |
| TEST_TEXTURE_TYPE_TEXTURE_VIEW_CREATED_FROM_TEXTURE_VIEW, |
| |
| /* Always last */ |
| TEST_TEXTURE_TYPE_UNDEFINED |
| }; |
| |
| struct _test_run |
| { |
| glw::GLint expected_n_immutable_levels; |
| glw::GLint expected_n_min_layer; |
| glw::GLint expected_n_min_level; |
| glw::GLint expected_n_num_layers; |
| glw::GLint expected_n_num_levels; |
| |
| glw::GLuint parent_texture_object_id; |
| glw::GLuint texture_view_object_created_from_immutable_to_id; |
| glw::GLuint texture_view_object_created_from_view_to_id; |
| |
| glw::GLenum texture_target; |
| _test_texture_type texture_type; |
| |
| /* Constructor */ |
| _test_run() |
| { |
| expected_n_immutable_levels = 0; |
| expected_n_min_layer = 0; |
| expected_n_min_level = 0; |
| expected_n_num_layers = 0; |
| expected_n_num_levels = 0; |
| |
| parent_texture_object_id = 0; |
| texture_view_object_created_from_immutable_to_id = 0; |
| texture_view_object_created_from_view_to_id = 0; |
| |
| texture_target = GL_NONE; |
| texture_type = TEST_TEXTURE_TYPE_UNDEFINED; |
| } |
| }; |
| |
| typedef std::vector<_test_run> _test_runs; |
| typedef _test_runs::const_iterator _test_runs_const_iterator; |
| typedef _test_runs::iterator _test_runs_iterator; |
| |
| /* Private methods */ |
| void initTestRuns(); |
| |
| /* Private fields */ |
| _test_runs m_test_runs; |
| }; |
| |
| /** Verify glTextureView() generates errors as described in the |
| * specification: |
| * |
| * a) GL_INVALID_VALUE should be generated if <texture> is 0. |
| * b) GL_INVALID_OPERATION should be generated if <texture> is not |
| * a valid name returned by glGenTextures(). |
| * c) GL_INVALID_OPERATION should be generated if <texture> has |
| * already been bound and given a target. |
| * d) GL_INVALID_VALUE should be generated if <origtexture> is not |
| * the name of a texture object. |
| * e) GL_INVALID_OPERATION error should be generated if <origtexture> |
| * is a mutable texture object. |
| * f) GL_INVALID_OPERATION error should be generated whenever the |
| * application tries to generate a texture view for a target |
| * that is incompatible with original texture's target. (as per |
| * table 8.20 from OpenGL 4.4 specification) |
| * |
| * NOTE: All invalid original+view texture target combinations |
| * should be checked. |
| * |
| * g) GL_INVALID_OPERATION error should be generated whenever the |
| * application tries to create a texture view, internal format |
| * of which can be found in table 8.21 of OpenGL 4.4 |
| * specification, and the texture view's internal format is |
| * incompatible with parent object's internal format. Both |
| * textures and views should be used as parent objects for the |
| * purpose of the test. |
| * |
| * NOTE: All invalid texture view internal formats should be |
| * checked for all applicable original object's internal |
| * formats. |
| * |
| * h) GL_INVALID_OPERATION error should be generated whenever the |
| * application tries to create a texture view using an internal |
| * format that does not match the original texture's, and the |
| * original texture's internalformat cannot be found in table |
| * 8.21 of OpenGL 4.4 specification. |
| * |
| * NOTE: All required base, sized and compressed texture internal |
| * formats (as described in section 8.5.1 and table 8.14 |
| * of OpenGL 4.4 specification) that cannot be found in |
| * table 8.21 should be considered for the purpose of this |
| * test. |
| * |
| * i) GL_INVALID_VALUE error should be generated if <minlevel> is |
| * larger than the greatest level of <origtexture>. |
| * j) GL_INVALID_VALUE error should be generated if <minlayer> is |
| * larger than the greatest layer of <origtexture>. |
| * k) GL_INVALID_VALUE error should be generated if <target> is |
| * GL_TEXTURE_CUBE_MAP and <numlayers> is not 6. |
| * l) GL_INVALID_VALUE error should be generated if <target> is |
| * GL_TEXTURE_CUBE_MAP_ARRAY and <numlayers> is not a multiple |
| * of 6. |
| * m) GL_INVALID_VALUE error should be generated if <target> is |
| * GL_TEXTURE_1D and <numlayers> is not 1; |
| * n) GL_INVALID_VALUE error should be generated if <target> is |
| * GL_TEXTURE_2D and <numlayers> is not 1; |
| * o) GL_INVALID_VALUE error should be generated if <target> is |
| * GL_TEXTURE_3D and <numlayers> is not 1; |
| * p) GL_INVALID_VALUE error should be generated if <target> is |
| * GL_TEXTURE_RECTANGLE and <numlayers> is not 1; |
| * q) GL_INVALID_VALUE error should be generated if <target> is |
| * GL_TEXTURE_2D_MULTISAMPLE and <numlayers> is not 1; |
| * r) GL_INVALID_OPERATION error should be generated if <target> is |
| * GL_TEXTURE_CUBE_MAP and original texture's width does not |
| * match original texture's height for all levels. |
| * s) GL_INVALID_OPERATION error should be generated if <target> is |
| * GL_TEXTURE_CUBE_MAP_ARRAY and original texture's width does |
| * not match original texture's height for all levels. |
| * |
| * NOTE: GL_INVALID_OPERATION error should also be generated for cases |
| * when any of the original texture's dimension is larger |
| * than the maximum supported corresponding dimension of the |
| * new target, but that condition can be very tricky to test |
| * in a portable manner. Hence, the conformance test will |
| * not verify if the error is generated as specified. |
| * |
| **/ |
| class TextureViewTestErrors : public deqp::TestCase |
| { |
| public: |
| /* Public methods */ |
| TextureViewTestErrors(deqp::Context& context); |
| |
| virtual ~TextureViewTestErrors() |
| { |
| } |
| |
| virtual void deinit(); |
| |
| virtual tcu::TestNode::IterateResult iterate(); |
| |
| private: |
| /* Private fields */ |
| glw::GLuint m_bo_id; |
| glw::GLuint m_reference_immutable_to_1d_id; |
| glw::GLuint m_reference_immutable_to_2d_id; |
| glw::GLuint m_reference_immutable_to_2d_array_id; |
| glw::GLuint m_reference_immutable_to_2d_array_32_by_33_id; |
| glw::GLuint m_reference_immutable_to_2d_multisample_id; |
| glw::GLuint m_reference_immutable_to_3d_id; |
| glw::GLuint m_reference_immutable_to_cube_map_id; |
| glw::GLuint m_reference_immutable_to_cube_map_array_id; |
| glw::GLuint m_reference_immutable_to_rectangle_id; |
| glw::GLuint m_reference_mutable_to_2d_id; |
| glw::GLuint m_test_modified_to_id_1; |
| glw::GLuint m_test_modified_to_id_2; |
| glw::GLuint m_test_modified_to_id_3; |
| glw::GLuint m_view_bound_to_id; |
| glw::GLuint m_view_never_bound_to_id; |
| }; |
| |
| /** Verify that sampling data from texture views, that use internal |
| * format which is compatible with the original texture's internal |
| * format, works correctly. |
| * |
| * For simplicity, both the parent object and its corresponding |
| * view should use the same GL_RGBA8 internal format. Both texture |
| * and view should be used as parent objects for the purpose of |
| * the test. |
| * |
| * The test should iterate over all texture targets enlisted in |
| * table 8.20 from OpenGL 4.4 specification, excluding GL_TEXTURE_BUFFER. |
| * For each such texture target, an immutable texture object that |
| * will be used as original object should be created. The object |
| * should be defined as follows: |
| * |
| * a) For 1D texture targets, width of 4 should be used. |
| * b) For 2D texture targets, width and height of 4 should be used. |
| * c) For 3D texture targets, depth, width and height of 4 should |
| * be used; |
| * d) Cube-map texture objects should use a 4x4 face size; |
| * e) Arrayed 1D/2D/cube-map texture objects should have a depth |
| * of 4. |
| * f) Each slice/face/layer-face mip-map should be filled with |
| * a static color. If original texture is multi-sampled, subsequent |
| * samples should be assigned a different color. Exact R/G/B/A |
| * intensities are arbitrary but they must be unique across all |
| * mip-maps and samples considered for a particular iteration. |
| * Mip-maps should *not* be generated - instead, it is expected |
| * the test will fill them manually with content using API (for |
| * non-multisampled cases), or by means of a simple FS+VS |
| * program (for multisampled render targets). |
| * |
| * For each such original texture object, texture views should be |
| * created for all compatible texture targets. These views should |
| * be configured as below: |
| * |
| * * minlayer: 1 (for arrayed/cube-map/cube-map arrayed views), |
| * 0 otherwise; |
| * * numlayers: 12 (for cube-map arrayed views), |
| * 6 (for cube-map views) |
| * 2 (for arrayed views), |
| * 1 otherwise; |
| * |
| * * minlevel: 1; |
| * * numlevels: 2; |
| * |
| * For testing purposes, the test should use the following rendering |
| * stages (forming a program object): |
| * |
| * - Vertex shader; |
| * - Tessellation control; |
| * - Tessellation evaluation; |
| * - Geometry shader; (should output a triangle strip forming |
| * a full-screen quad); |
| * - Fragment shader; |
| * |
| * In each stage (excluding fragment shader), as many samples as |
| * available (for multisample views) OR a single texel should be |
| * sampled at central (0.5, 0.5, ...) location using textureLod(). |
| * The data should then be compared with reference values and the |
| * validation result should be passed to next stage using |
| * an output variable. Subsequent stages should pass validation results |
| * from all previous stages to following stages until geometry shader |
| * stage is reached. The information should be captured by the test |
| * using XFB and verified. |
| * Fragment shader should output a green colour, if the sampling |
| * operation returned a valid set of colors for (U, V) location, |
| * corresponding to rasterized fragment location, red otherwise. |
| * |
| * The test passes if the sampling operation worked correctly in |
| * all stages for all texture's internal format+view's internal |
| * format combinations. |
| * |
| **/ |
| class TextureViewTestViewSampling : public deqp::TestCase |
| { |
| public: |
| /* Public methods */ |
| TextureViewTestViewSampling(deqp::Context& context); |
| |
| virtual tcu::TestNode::IterateResult iterate(); |
| |
| protected: |
| /* Protected methods */ |
| virtual void deinit(); |
| |
| private: |
| /* Private type declarations */ |
| struct _reference_color_storage |
| { |
| tcu::Vec4* data; |
| |
| unsigned int n_faces; |
| unsigned int n_layers; |
| unsigned int n_mipmaps; |
| unsigned int n_samples; |
| |
| /** Constructor. |
| * |
| * @param in_n_faces Amount of faces to initialize the storage for. |
| * Must not be 0. |
| * @param in_n_layers Amount of layers to initialize the storage for. |
| * Must not be 0. |
| * @param in_n_mipmaps Amount of mip-maps to initialize the storage for. |
| * Must not be 0. |
| * @param in_n_samples Amount of samples to initialize the storage for. |
| * Must not be 0. |
| **/ |
| explicit _reference_color_storage(const unsigned int in_n_faces, const unsigned int in_n_layers, |
| const unsigned int in_n_mipmaps, const unsigned int in_n_samples) |
| { |
| DE_ASSERT(in_n_faces != 0); |
| DE_ASSERT(in_n_layers != 0); |
| DE_ASSERT(in_n_mipmaps != 0); |
| DE_ASSERT(in_n_samples != 0); |
| |
| n_faces = in_n_faces; |
| n_layers = in_n_layers; |
| n_mipmaps = in_n_mipmaps; |
| n_samples = in_n_samples; |
| |
| data = new tcu::Vec4[in_n_faces * in_n_layers * in_n_mipmaps * in_n_samples]; |
| } |
| |
| /** Destructor */ |
| ~_reference_color_storage() |
| { |
| if (data != DE_NULL) |
| { |
| delete[] data; |
| |
| data = DE_NULL; |
| } |
| } |
| }; |
| |
| /* Private methods */ |
| void deinitIterationSpecificProgramAndShaderObjects(); |
| void deinitPerSampleFillerProgramAndShaderObjects(); |
| void deinitTextureObjects(); |
| bool executeTest(); |
| void initIterationSpecificProgramObject(); |
| void initParentTextureContents(); |
| void initPerSampleFillerProgramObject(); |
| void initTest(); |
| |
| void initTextureObject(bool is_view_texture, glw::GLenum texture_target, glw::GLenum view_texture_target); |
| |
| tcu::Vec4 getRandomReferenceColor(); |
| |
| tcu::Vec4 getReferenceColor(unsigned int n_layer, unsigned int n_face, unsigned int n_mipmap, |
| unsigned int n_sample); |
| |
| glw::GLint getMaxConformantSampleCount(glw::GLenum target, glw::GLenum internalFormat); |
| |
| void resetReferenceColorStorage(unsigned int n_layers, unsigned int n_faces, unsigned int n_mipmaps, |
| unsigned int n_samples); |
| |
| void setReferenceColor(unsigned int n_layer, unsigned int n_face, unsigned int n_mipmap, unsigned int n_sample, |
| tcu::Vec4 color); |
| |
| /* Private variables */ |
| glw::GLuint m_bo_id; |
| glw::GLuint m_fs_id; |
| glw::GLuint m_gs_id; |
| glw::GLuint m_po_id; |
| glw::GLint m_po_lod_location; |
| glw::GLint m_po_n_face_location; |
| glw::GLint m_po_reference_colors_location; |
| glw::GLint m_po_texture_location; |
| glw::GLint m_po_z_float_location; |
| glw::GLint m_po_z_int_location; |
| glw::GLuint m_tc_id; |
| glw::GLuint m_te_id; |
| glw::GLuint m_vs_id; |
| |
| glw::GLuint m_per_sample_filler_fs_id; |
| glw::GLuint m_per_sample_filler_gs_id; |
| glw::GLuint m_per_sample_filler_po_id; |
| glw::GLint m_per_sample_filler_po_layer_id_location; |
| glw::GLint m_per_sample_filler_po_reference_colors_location; |
| glw::GLuint m_per_sample_filler_vs_id; |
| |
| glw::GLuint m_result_to_id; |
| glw::GLuint m_to_id; |
| glw::GLuint m_view_to_id; |
| |
| glw::GLuint m_fbo_id; |
| glw::GLuint m_vao_id; |
| |
| glw::GLint m_max_color_texture_samples_gl_value; |
| |
| glw::GLuint m_iteration_parent_texture_depth; |
| glw::GLuint m_iteration_parent_texture_height; |
| glw::GLuint m_iteration_parent_texture_n_levels; |
| glw::GLuint m_iteration_parent_texture_n_samples; |
| glw::GLenum m_iteration_parent_texture_target; |
| glw::GLuint m_iteration_parent_texture_width; |
| glw::GLuint m_iteration_view_texture_minlayer; |
| glw::GLuint m_iteration_view_texture_numlayers; |
| glw::GLuint m_iteration_view_texture_minlevel; |
| glw::GLuint m_iteration_view_texture_numlevels; |
| glw::GLenum m_iteration_view_texture_target; |
| |
| const glw::GLuint m_reference_texture_depth; |
| const glw::GLuint m_reference_texture_height; |
| const glw::GLuint m_reference_texture_n_mipmaps; |
| const glw::GLuint m_reference_texture_width; |
| |
| _reference_color_storage* m_reference_color_storage; |
| unsigned char* m_result_data; |
| }; |
| |
| /** Verify view class functionality. |
| * |
| * Consider all view classes presented in table 8.20 of OpenGL 4.4 |
| * Specification. For each view class, consider all internal format |
| * combinations for the purpose of the test. |
| * |
| * For each internal format, a texture object of specified internal |
| * format and of 2x2 base mip-map resolution should be used. |
| * |
| * For each internal format, a program object consisting of a vertex |
| * shader stage should be used. The shader should sample all 4 texels |
| * of the view and store retrieved data in output variables. |
| * These values should then be XFBed to the test. |
| * |
| * The test passes if all retrieved values for all pairs considered |
| * are found to be valid. |
| * |
| **/ |
| class TextureViewTestViewClasses : public deqp::TestCase |
| { |
| public: |
| /* Public methods */ |
| TextureViewTestViewClasses(deqp::Context& context); |
| |
| virtual tcu::TestNode::IterateResult iterate(); |
| |
| protected: |
| /* Protected methods */ |
| virtual void deinit(); |
| |
| private: |
| /* Private methods */ |
| void getComponentDataForByteAlignedInternalformat(const unsigned char* data, const unsigned int n_components, |
| const unsigned int* component_sizes, |
| const TextureView::_format format, void* result); |
| |
| void initBufferObject(glw::GLenum texture_internalformat, glw::GLenum view_internalformat); |
| |
| void initProgramObject(glw::GLenum texture_internalformat, glw::GLenum view_internalformat); |
| |
| void initTest(); |
| |
| void initTextureObject(bool should_init_parent_texture, glw::GLenum texture_internalformat, |
| glw::GLenum view_internalformat); |
| |
| void verifyResultData(glw::GLenum texture_internalformat, glw::GLenum view_internalformat, |
| const unsigned char* texture_data_ptr, const unsigned char* view_data_ptr); |
| |
| /* Private fields */ |
| glw::GLuint m_bo_id; |
| glw::GLuint m_po_id; |
| glw::GLuint m_to_id; |
| glw::GLuint m_to_temp_id; |
| glw::GLuint m_vao_id; |
| glw::GLuint m_view_to_id; |
| glw::GLuint m_vs_id; |
| |
| unsigned char* m_decompressed_mipmap_data; |
| unsigned char* m_mipmap_data; |
| |
| unsigned int m_bo_size; |
| bool m_has_test_failed; |
| const unsigned int m_texture_height; |
| const glw::GLenum m_texture_unit_for_parent_texture; |
| const glw::GLenum m_texture_unit_for_view_texture; |
| const unsigned int m_texture_width; |
| unsigned int m_view_data_offset; |
| }; |
| |
| /** |
| * Verify view/parent texture coherency. |
| * |
| * Consider an original 2D texture of 64x64 base mip-map resolution, |
| * using GL_RGBA8 internal format, filled with horizontal linear |
| * gradient from (0.0, 0.1, 1.0, 1.0) to (1.0, 0.9, 0.0, 0.0). |
| * All subsequent mip-maps are to be generated by glGenerateMipmap(). |
| * |
| * A 2D texture view should be generated from this texture, using |
| * mipmaps from levels 1 to 2 (inclusive). |
| * |
| * The test should verify the following scenarios are handled |
| * correctly by GL implementation: |
| * |
| * 1) glTexSubImage2D() should be used on the view to replace portion |
| * of the gradient with a static color. A vertex shader should |
| * then be used to sample the parent texture at central |
| * location of that sub-region and verify it has been replaced |
| * with the static color. Result of the comparison (true/false) |
| * should be XFBed and verified by the test; *No* memory barrier |
| * is to be used between the first two steps. |
| * 2) The view should be updated as in step 1), with glTexSubImage2D() |
| * being replaced with glBlitFramebuffer(). A texture filled |
| * with a static color should be used as a source for the blitting |
| * operation. |
| * 3) A program object should be used to fill the view with |
| * reversed (1.0, 0.9, 0.0, 0.0)->(0.0, 0.1, 1.0, 1.0) gradient. |
| * Contents of the parent texture should then be validated with |
| * another program object and the result should be verified by |
| * XFBing the comparison outcome, similar to what has been |
| * described for step 1). Again, *no* memory barrier is to be |
| * used in-between. |
| * 4) The view should be bound to an image unit. The contents of |
| * that view should then be completely replaced with the reversed |
| * gradient by doing a sufficient amount of writes, assuming each vertex |
| * shader invocation performs a single store operation in an |
| * unique location. A GL_TEXTURE_FETCH_BARRIER_BIT memory |
| * barrier should be issued. The contents of the parent texture |
| * should then be verified, as described in step 1) and 3). |
| * 5) The view should be updated as in step 4). However, this time |
| * a GL_TEXTURE_UPDATE_BARRIER_BIT memory barrier should be issued. |
| * The contents of the parent texture should then be read with |
| * a glGetTexImage() call and verified by the test. |
| * |
| * (NOTE: cases 4) and 5) should only be executed on implementations |
| * reporting GL_ARB_shader_image_load_store extension |
| * support, owing to lack of glMemoryBarrier() support |
| * in OpenGL 4.0) |
| * |
| * 6), 7), 8), 9) Execute tests 1), 2), 3), 4), 5), replacing "texture |
| * views" with "parent textures" and "parent textures" |
| * with "texture views". |
| */ |
| class TextureViewTestCoherency : public deqp::TestCase |
| { |
| public: |
| /* Public methods */ |
| TextureViewTestCoherency(deqp::Context& context); |
| |
| virtual void deinit(); |
| virtual tcu::TestNode::IterateResult iterate(); |
| |
| private: |
| /* Private type definitions */ |
| enum _barrier_type |
| { |
| BARRIER_TYPE_NONE, |
| BARRIER_TYPE_TEXTURE_FETCH_BARRIER_BIT, |
| BARRIER_TYPE_TEXTURE_UPDATE_BUFFER_BIT |
| }; |
| |
| enum _texture_type |
| { |
| TEXTURE_TYPE_PARENT_TEXTURE, |
| TEXTURE_TYPE_TEXTURE_VIEW, |
| TEXTURE_TYPE_IMAGE |
| }; |
| |
| enum _verification_mean |
| { |
| VERIFICATION_MEAN_PROGRAM, |
| VERIFICATION_MEAN_GLGETTEXIMAGE |
| }; |
| |
| /* Private methods */ |
| void checkAPICallCoherency(_texture_type texture_type, bool should_use_glTexSubImage2D); |
| |
| void checkProgramWriteCoherency(_texture_type texture_type, bool should_use_images, _barrier_type barrier_type, |
| _verification_mean verification_mean); |
| |
| unsigned char* getHorizontalGradientData() const; |
| |
| void getReadPropertiesForTextureType(_texture_type texture_type, glw::GLuint* out_to_id, |
| unsigned int* out_read_lod) const; |
| |
| unsigned char* getStaticColorTextureData(unsigned int width, unsigned int height) const; |
| |
| void getWritePropertiesForTextureType(_texture_type texture_type, glw::GLuint* out_to_id, unsigned int* out_width, |
| unsigned int* out_height) const; |
| |
| void initBufferObjects(); |
| void initFBO(); |
| void initPrograms(); |
| void initTextureContents(); |
| void initTextures(); |
| void initVAO(); |
| |
| /* Private fields */ |
| bool m_are_images_supported; |
| glw::GLuint m_bo_id; |
| glw::GLuint m_draw_fbo_id; |
| glw::GLuint m_gradient_verification_po_id; |
| glw::GLint m_gradient_verification_po_sample_exact_uv_location; |
| glw::GLint m_gradient_verification_po_lod_location; |
| glw::GLint m_gradient_verification_po_texture_location; |
| glw::GLuint m_gradient_verification_vs_id; |
| glw::GLint m_gradient_image_write_image_size_location; |
| glw::GLuint m_gradient_image_write_po_id; |
| glw::GLuint m_gradient_image_write_vs_id; |
| glw::GLuint m_gradient_write_po_id; |
| glw::GLuint m_gradient_write_fs_id; |
| glw::GLuint m_gradient_write_vs_id; |
| glw::GLuint m_read_fbo_id; |
| glw::GLuint m_static_to_id; |
| glw::GLuint m_to_id; |
| glw::GLuint m_vao_id; |
| glw::GLuint m_view_to_id; |
| glw::GLint m_verification_po_expected_color_location; |
| glw::GLint m_verification_po_lod_location; |
| glw::GLuint m_verification_po_id; |
| glw::GLuint m_verification_vs_id; |
| |
| unsigned char m_static_color_byte[4 /* rgba */]; |
| float m_static_color_float[4 /* rgba */]; |
| |
| const unsigned int m_static_texture_height; |
| const unsigned int m_static_texture_width; |
| const unsigned int m_texture_height; |
| const unsigned int m_texture_n_components; |
| const unsigned int m_texture_n_levels; |
| const unsigned int m_texture_width; |
| }; |
| |
| /** Verify GL_TEXTURE_BASE_LEVEL and GL_TEXTURE_MAX_LEVEL are |
| * interpreted relative to the view, not to the original data |
| * store. |
| * |
| * Consider original 2D texture of 64x64 base mip-map resolution, |
| * using GL_RGBA8 internal format, filled with: |
| * |
| * * horizontal linear gradient from (0.0, 0.1, 0,2, 0.3) to |
| * (1.0, 0.9, 0.8, 0.7) at level 0; |
| * * horizontal linear gradient from (0.1, 0.2, 0.3, 0.4) to |
| * (0.9, 0.8, 0.7, 0.6) at level 1; |
| * * horizontal linear gradient from (0.2, 0.3, 0.4, 0.5) to |
| * (0.8, 0.7, 0.6, 0.5) at level 2; |
| * * ..and so on. |
| * |
| * GL_TEXTURE_BASE_LEVEL of the texture should be set at 2, |
| * GL_TEXTURE_MAX_LEVEL of the texture should be set at 4. |
| * |
| * A 2D texture view should be generated from this texture, using |
| * mipmaps from 0 to 5 (inclusive). |
| * |
| * GL_TEXTURE_BASE_LEVEL of the view should be set at 1, |
| * GL_TEXTURE_MAX_LEVEL of the view should be set at 2. |
| * |
| * The test should perform the following: |
| * |
| * 1) First, a FS+VS program should be executed twice. The vertex |
| * shader should output 4 vertices forming a triangle-strip, forming |
| * a quad spanning from (-1, -1, 0, 1) to (1, 1, 0, 1). Each |
| * vertex should be assigned a corresponding UV location. |
| * The fragment shader should sample input texture view with |
| * textureLod() at fragment-specific UV using LOD 0 in the |
| * first run, and LOD 1 in the second run. |
| * The sampled vec4 should be written into a draw buffer, to which |
| * a texture has been attached of exactly the same resolution |
| * and internal format as the input texture view's mip-map being |
| * processed at the time of invocation. |
| * |
| * This pass should provide us with LOD 0 and LOD 1 texture data, |
| * as configured with GL_TEXTURE_BASE_LEVEL and |
| * GL_TEXTURE_MAX_LEVEL view parameters. |
| * |
| * 2) Having executed the aforementioned program, the test should |
| * download the textures that step 1 has rendered to using |
| * glGetTexImage() and verify correct mipmaps have been sampled |
| * by textureLod(). |
| * |
| * Test passes if the retrieved texture data is valid. |
| **/ |
| class TextureViewTestBaseAndMaxLevels : public deqp::TestCase |
| { |
| public: |
| /* Public methods */ |
| TextureViewTestBaseAndMaxLevels(deqp::Context& context); |
| |
| virtual void deinit(); |
| virtual tcu::TestNode::IterateResult iterate(); |
| |
| private: |
| /* Private methods */ |
| void initProgram(); |
| void initTest(); |
| void initTextures(); |
| |
| /* Private fields */ |
| const unsigned int m_texture_height; |
| const unsigned int m_texture_n_components; |
| const unsigned int m_texture_n_levels; |
| const unsigned int m_texture_width; |
| const unsigned int m_view_height; |
| const unsigned int m_view_width; |
| |
| unsigned char* m_layer_data_lod0; |
| unsigned char* m_layer_data_lod1; |
| |
| glw::GLuint m_fbo_id; |
| glw::GLuint m_fs_id; |
| glw::GLuint m_po_id; |
| glw::GLint m_po_lod_index_uniform_location; |
| glw::GLint m_po_to_sampler_uniform_location; |
| glw::GLuint m_result_to_id; |
| glw::GLuint m_to_id; |
| glw::GLuint m_vao_id; |
| glw::GLuint m_view_to_id; |
| glw::GLuint m_vs_id; |
| }; |
| |
| /** Verify texture view reference counting is implemented correctly. |
| * |
| * Parent texture object A should be an immutable 2D texture of |
| * 64x64 resolution and of GL_RGBA8 internalformat. Each mip-map |
| * should be filled with a different static color. |
| * |
| * View B should be created from texture A, and view C should be |
| * instantiated from view B. The views should use the same texture |
| * target and internalformat as texture A. <minlayer> and <minlevel> |
| * values of 0 should be used for view generation. All available |
| * texture layers and levels should be used for the views. |
| * |
| * The test should: |
| * |
| * a) Sample the texture and both views, make sure correct data can |
| * be sampled in VS stage; |
| * b) Delete texture A; |
| * c) Sample both views, make sure correct data can be sampled in |
| * VS stage; |
| * d) Delete view B; |
| * e) Sample view C, make sure correct data can be sampled in VS |
| * stage; |
| * |
| * A program object consisting only of vertex shader should be used |
| * by the test. The shader should sample all mip-maps of the bound |
| * texture at (0.5, 0.5) and compare the retrieved texels against |
| * reference values. Comparison outcome should be XFBed back to |
| * the test implementation. |
| * |
| * Test passes if the sampling operation is reported to work |
| * correctly for all steps. |
| * |
| **/ |
| class TextureViewTestReferenceCounting : public deqp::TestCase |
| { |
| public: |
| /* Public methods */ |
| TextureViewTestReferenceCounting(deqp::Context& context); |
| |
| virtual void deinit(); |
| virtual tcu::TestNode::IterateResult iterate(); |
| |
| private: |
| /* Private type definitions */ |
| struct _norm_vec4 |
| { |
| unsigned char rgba[4]; |
| |
| /* Constructor |
| * |
| * @param r Red value to store for the component |
| * @param g Green value to store for the component |
| * @param b Blue value to store for the component |
| * @param a Alpha value to store for the component. |
| */ |
| explicit _norm_vec4(unsigned char r, unsigned char g, unsigned char b, unsigned char a) |
| { |
| rgba[0] = r; |
| rgba[1] = g; |
| rgba[2] = b; |
| rgba[3] = a; |
| } |
| }; |
| |
| /* Private methods */ |
| void initProgram(); |
| void initTest(); |
| void initTextures(); |
| void initXFB(); |
| |
| /* Private variables */ |
| glw::GLuint m_bo_id; |
| glw::GLuint m_parent_to_id; |
| glw::GLuint m_po_id; |
| glw::GLint m_po_expected_texel_uniform_location; |
| glw::GLint m_po_lod_uniform_location; |
| glw::GLuint m_vao_id; |
| glw::GLuint m_view_to_id; |
| glw::GLuint m_view_view_to_id; |
| glw::GLuint m_vs_id; |
| |
| const glw::GLuint m_texture_height; |
| const glw::GLuint m_texture_n_levels; |
| const glw::GLuint m_texture_width; |
| |
| std::vector<_norm_vec4> m_mipmap_colors; |
| }; |
| |
| /** Group class for texture view conformance tests */ |
| class TextureViewTests : public deqp::TestCaseGroup |
| { |
| public: |
| /* Public methods */ |
| TextureViewTests(deqp::Context& context); |
| virtual ~TextureViewTests() |
| { |
| } |
| |
| virtual void init(void); |
| |
| private: |
| /* Private methods */ |
| TextureViewTests(const TextureViewTests&); |
| TextureViewTests& operator=(const TextureViewTests&); |
| }; |
| |
| } /* gl4cts namespace */ |
| |
| #endif // _GL4CTEXTUREVIEWTESTS_HPP |