| #ifndef _ESEXTCDRAWELEMENTSBASEVERTEXTESTS_HPP |
| #define _ESEXTCDRAWELEMENTSBASEVERTEXTESTS_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 esextcDrawElementsBaseVertexTests.hpp |
| * \brief Declares test classes that verify conformance of the |
| * "draw elements base vertex" functionality for both |
| * ES and GL. |
| */ /*-------------------------------------------------------------------*/ |
| #include <memory.h> |
| |
| #include "glcTestCase.hpp" |
| #include "glwDefs.hpp" |
| #include "tcuDefs.hpp" |
| #include <string.h> |
| |
| #include "../esextcTestCaseBase.hpp" |
| |
| namespace glcts |
| { |
| using deqp::Context; |
| using deqp::TestCaseGroup; |
| |
| /** Base test class implementation for "draw elements base vertex" functionality |
| * conformance tests. |
| * |
| * Functional tests fill m_test_cases instance with test case descriptors, |
| * and then call base class' executeTestCases() method to process these |
| * test cases. The base class also initializes all required function |
| * pointers and reassures that no test cases which are dependent on other |
| * ES extensions are not executed, if any of these extensions are not |
| * supported. |
| */ |
| class DrawElementsBaseVertexTestBase : public TestCaseBase |
| { |
| public: |
| /* Public methods */ |
| DrawElementsBaseVertexTestBase(glcts::Context& context, const ExtParameters& extParams, const char* name, |
| const char* description); |
| |
| protected: |
| /* Protected type definitions */ |
| /** Defines a draw call type that should be used for a single |
| * test case iteration. |
| */ |
| enum _function_type |
| { |
| FUNCTION_GL_DRAW_ELEMENTS_BASE_VERTEX, |
| FUNCTION_GL_DRAW_ELEMENTS_INSTANCED_BASE_VERTEX, |
| FUNCTION_GL_DRAW_RANGE_ELEMENTS_BASE_VERTEX, |
| FUNCTION_GL_MULTI_DRAW_ELEMENTS_BASE_VERTEX, |
| |
| FUNCTION_COUNT |
| }; |
| |
| /** Defines a single test case. Each functional test fills the |
| * m_test_cases vector with test case descriptors, which are |
| * then traversed by base class'executeTestCases() method. |
| */ |
| typedef struct _test_case |
| { |
| glw::GLint basevertex; /* Tells the value of <basevertex> argument for the tested |
| * basevertex draw call. */ |
| _function_type function_type; /* Tells the type of the basevertex draw call that should |
| * be used for the described iteration. */ |
| const glw::GLuint* index_offset; /* Tells the value of <indices> argument for both basevertex |
| * and regular draw calls */ |
| glw::GLenum index_type; /* GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT or GL_UNSIGNED_INT */ |
| glw::GLuint range_start; /* The range start for DrawRangeElements */ |
| glw::GLuint range_end; /* The range end for DrawRangeElements */ |
| glw::GLsizei multi_draw_call_count_array[3]; /* an array of three elements storing "count" arguments |
| * for multi draw calls used to generate contents of both |
| * textures. */ |
| glw::GLuint* multi_draw_call_indices_array[3]; /* an array of three elements holding "indices" arguments |
| * for multi draw call used rto generate contents of base |
| * texture */ |
| glw::GLenum primitive_mode; /* Tells the primitive type that should be used for both |
| * types of draw calls. */ |
| glw::GLuint regular_draw_call_offset; /* offset to be used for non-basevertex draw calls made |
| * to generate reference texture contents. This value will |
| * be added to test_case.index_offset for non-basevertex |
| * draw calls. */ |
| glw::GLuint* regular_draw_call_offset2; /* offset to be used for non-basevertex draw calls made |
| * to generate reference texture contents. This value will |
| * NOT be added to test_case.index_offset for non-basevertex |
| * draw calls. */ |
| glw::GLenum regular_draw_call_index_type; /* index type to be used for non-basevertex draw calls made |
| * to generate reference texture contents. The index type |
| is differenet with base draw call in overflow test.*/ |
| glw::GLuint** regular_multi_draw_call_offseted_array[3]; /* an array of three elements storing offsets for the |
| * multi draw call used to generate reference texture |
| * contents */ |
| bool should_base_texture_match_reference_texture; /* Tells if the iteration passes if the base and the reference |
| * texture are a match (true), or if it should only pass if |
| * contents of the textures are different. */ |
| bool use_clientside_index_data; /* Tells if the index data should be taken from a client-side |
| * buffer, or from a VBO */ |
| bool use_clientside_vertex_data; /* Tells if the vertex (color & position) data should be taken |
| * from a client-side buffer, or from a VBO */ |
| bool use_geometry_shader_stage; /* Tells if the program object used for the iteration should |
| * include geometry shader */ |
| bool use_tessellation_shader_stage; /* Tells if the program object used for the iteration should |
| * include tessellation control & evaluation shaders. */ |
| bool use_vertex_attrib_binding; /* Tells if the iteration should use vertex attribute bindings |
| * instead of setting vertex attribute arrays with |
| * glVertexAttribPointer() call(s) */ |
| bool use_overflow_test_vertices; |
| |
| /** Constructor */ |
| _test_case() |
| : basevertex(0) |
| , function_type(FUNCTION_COUNT) |
| , index_offset(NULL) |
| , index_type(0) |
| , range_start(0) |
| , range_end(0) |
| , primitive_mode((glw::GLenum)-1) |
| , regular_draw_call_offset(0) |
| , regular_draw_call_offset2(NULL) |
| , regular_draw_call_index_type(0) |
| , should_base_texture_match_reference_texture(false) |
| , use_clientside_index_data(false) |
| , use_clientside_vertex_data(false) |
| , use_geometry_shader_stage(false) |
| , use_tessellation_shader_stage(false) |
| , use_vertex_attrib_binding(false) |
| , use_overflow_test_vertices(false) |
| { |
| memset(multi_draw_call_count_array, 0, sizeof(multi_draw_call_count_array)); |
| memset(multi_draw_call_indices_array, 0, sizeof(multi_draw_call_indices_array)); |
| memset(regular_multi_draw_call_offseted_array, 0, sizeof(regular_multi_draw_call_offseted_array)); |
| } |
| } _test_case; |
| |
| /** Type definitions for test case container */ |
| typedef std::vector<_test_case> _test_cases; |
| typedef _test_cases::const_iterator _test_cases_const_iterator; |
| typedef _test_cases::iterator _test_cases_iterator; |
| |
| /* Protected methods */ |
| void compareBaseAndReferenceTextures(bool should_be_equal); |
| |
| void computeVBODataOffsets(bool use_clientside_index_data, bool use_clientside_vertex_data); |
| |
| virtual void deinit(); |
| |
| void executeTestCases(); |
| |
| std::string getFunctionName(_function_type function_type); |
| |
| virtual void init(); |
| |
| void setUpFunctionalTestObjects(bool use_clientside_vertex_data, bool use_clientside_index_data, |
| bool use_tessellation_shader_stage, bool use_geometry_shader_stage, |
| bool use_vertex_attrib_binding, bool use_overflow_test_vertices); |
| |
| virtual void deinitPerTestObjects(); |
| |
| void setUpNegativeTestObjects(bool use_clientside_vertex_data, bool use_clientside_index_data); |
| |
| /* Protected variables */ |
| bool m_is_draw_elements_base_vertex_supported; /* Corresponds to GL_EXT_draw_elements_base_vertex availability |
| * under ES contexts and to GL_ARB_draw_elements_base_vertex |
| * availability under GL contexts. |
| */ |
| bool m_is_ext_multi_draw_arrays_supported; /* Corresponds to GL_EXT_multi_draw_arrays availability under |
| * both ES and GL contexts. |
| */ |
| bool m_is_geometry_shader_supported; /* Corresponds to GL_EXT_geometry_shader availability under |
| * ES contexts and to GL_ARB_geometry_shader4 availability under |
| * GL contexts. |
| */ |
| bool m_is_tessellation_shader_supported; /* Corresponds to GL_EXT_tessellation_shader availability under |
| * ES contexts and to GL_ARB_tessellation_shader availability |
| * under GL contexts. |
| */ |
| bool m_is_vertex_attrib_binding_supported; /* Corresponds to GL_ARB_vertex_attrib_binding availability under |
| * GL contexts. Under ES always set to true, since the conformance |
| * tests are only run for >= ES 3.1 contexts, where VAA bindings |
| * are core functionality. |
| */ |
| |
| glw::GLuint m_bo_id; |
| glw::GLuint m_bo_id_2; |
| glw::GLuint m_fbo_id; |
| glw::GLuint m_fs_id; |
| glw::GLuint m_gs_id; |
| glw::GLuint m_po_id; |
| glw::GLint m_po_color_attribute_location; |
| bool m_po_uses_gs_stage; |
| bool m_po_uses_tc_te_stages; |
| bool m_po_uses_vertex_attrib_binding; |
| glw::GLint m_po_vertex_attribute_location; |
| glw::GLuint m_tc_id; |
| glw::GLuint m_te_id; |
| glw::GLuint m_to_base_id; |
| glw::GLuint m_to_ref_id; |
| glw::GLuint m_vao_id; |
| glw::GLuint m_vs_id; |
| |
| const glw::GLuint* m_bo_functional2_data_index; /* Holds functional second index data set data */ |
| unsigned int m_bo_functional2_data_index_size; /* Holds size of functional second index data set */ |
| const glw::GLfloat* m_bo_functional2_data_vertex; /* Holds functional second vertex data set data */ |
| unsigned int m_bo_functional2_data_vertex_size; /* Holds size of functional second vertex data set */ |
| const glw::GLubyte* m_bo_functional3_data_index; /* Holds functional third index data set data */ |
| unsigned int m_bo_functional3_data_index_size; /* Holds size of functional third index data set */ |
| const glw::GLushort* m_bo_functional4_data_index; /* Holds functional fourth index data set data */ |
| unsigned int m_bo_functional4_data_index_size; /* Holds size of functional fourth index data set */ |
| const glw::GLuint* m_bo_functional5_data_index; /* Holds functional fifth index data set data */ |
| unsigned int m_bo_functional5_data_index_size; /* Holds size of functional fifth index data set */ |
| const glw::GLfloat* m_bo_functional_data_color; /* Holds functional first color data set data */ |
| unsigned int m_bo_functional_data_color_size; /* Holds size of functional first color data set */ |
| const glw::GLuint* m_bo_functional_data_index; /* Holds functional first index data set data */ |
| unsigned int m_bo_functional_data_index_size; /* Holds size of functional first index data set */ |
| const glw::GLfloat* m_bo_functional_data_vertex; /* Holds functional first vertex data set data */ |
| unsigned int m_bo_functional_data_vertex_size; /* Holds size of functional first vertex data set */ |
| const glw::GLuint* m_bo_negative_data_index; /* Holds negative index data set data */ |
| unsigned int m_bo_negative_data_index_size; /* Holds size of negative index data set */ |
| const glw::GLfloat* m_bo_negative_data_vertex; /* Holds negative vertex data set data */ |
| unsigned int m_bo_negative_data_vertex_size; /* Holds size of negative vertex data set */ |
| const glw::GLfloat* m_draw_call_color_offset; /* Either holds buffer object storage offset to color data set OR |
| * is a raw pointer to the color data store. Actual contents |
| * is iteration-dependent */ |
| const glw::GLuint* m_draw_call_index_offset; /* Either holds buffer object storage offset to first index data set OR |
| * is a raw pointer to the index data store. Actual contents |
| * is iteration-dependent */ |
| const glw::GLuint* |
| m_draw_call_index2_offset; /* Either holds buffer object storage offset to second index data set OR |
| * is a raw pointer to the index data store. Actual contents |
| * is iteration-dependent */ |
| const glw::GLubyte* |
| m_draw_call_index3_offset; /* Either holds buffer object storage offset to third index data set OR |
| * is a raw pointer to the index data store. Actual contents |
| * is iteration-dependent */ |
| const glw::GLushort* |
| m_draw_call_index4_offset; /* Either holds buffer object storage offset to fourth index data set OR |
| * is a raw pointer to the index data store. Actual contents |
| * is iteration-dependent */ |
| const glw::GLuint* |
| m_draw_call_index5_offset; /* Either holds buffer object storage offset to fifth index data set OR |
| * is a raw pointer to the index data store. Actual contents |
| * is iteration-dependent */ |
| const glw::GLfloat* |
| m_draw_call_vertex_offset; /* Either holds buffer object storage offset to first vertex data set OR |
| * is a raw pointer to the first vertex data store. Actual contents |
| * is iteration-dependent */ |
| const glw::GLfloat* |
| m_draw_call_vertex2_offset; /* Either holds buffer object storage offset to second vertex data set OR |
| * is a raw pointer to the second vertex data store. Actual contents |
| * is iteration-dependent */ |
| |
| _test_cases m_test_cases; /* Holds all test cases */ |
| |
| private: |
| /* Private methods */ |
| void buildProgram(const char* fs_code, const char* vs_code, const char* tc_code, const char* te_code, |
| const char* gs_code); |
| void deinitProgramAndShaderObjects(); |
| |
| /* Private data */ |
| const unsigned int m_to_height; |
| const unsigned int m_to_width; |
| |
| unsigned char* m_to_base_data; |
| unsigned char* m_to_ref_data; |
| }; |
| |
| /** Implements functional Tests I, II, III and IV. For clarity, the description |
| * of these functional tests is included below. |
| * |
| * (note: the description below refers to ES entry-points, but these are |
| * replaced with GL equivalents under GL contexts) |
| * |
| * Functional Test I: |
| * |
| * I.1. Define vertex coordinates and corresponding indices array (as shown |
| * above). |
| * I.1.a. Render a triangle to texture using glDrawElementsBaseVertexEXT() |
| * call. Use '10' for the 'basevertex' argument value. Use process-side |
| * memory to store vertex coordinates and index data. Assert that |
| * data read from the result texture is the same as for reference texture. |
| * I.1.b. Repeat the test (I.1.a.) for glDrawRangeElementsBaseVertexEXT(). |
| * I.1.c. Repeat the test (I.1.a.) for glDrawElementsInstancedBaseVertexEXT(): |
| * draw 3 instances of triangle object, compare with a corresponding |
| * texture. |
| * I.1.d. If EXT_multi_draw_arrays extension is supported, repeat the test |
| * (I.1.a.) for glMultiDrawElementsBaseVertexEXT(). |
| * |
| * Functional Test II: |
| * |
| * II.1. Repeat the tests (I.1) using buffer object storing vertex coordinates |
| * attached to GL_ARRAY_BUFFER buffer binding point and client-side |
| * memory to store indices. |
| * II.2. Repeat the tests (I.1) using client-side memory to store vertex |
| * coordinates and a buffer object holding index data attached to |
| * GL_ELEMENT_ARRAY_BUFFER buffer binding point. |
| * II.3. Repeat the tests (I.1) using buffer object storing vertex coordinates |
| * attached to GL_ARRAY_BUFFER buffer binding point and |
| * a buffer object holding index data attached to GL_ELEMENT_ARRAY_BUFFER |
| * buffer binding point. |
| * |
| * Functional Test III: |
| * |
| * III.1. Repeat the tests (I.1 - II.3) using '0' for the 'basevertex' argument |
| * value. Assert that data read from the result texture differs from |
| * the reference texture. |
| * |
| * Functional Test IV: |
| * |
| * IV.1. Repeat the tests (I.1 - II.3) using '10' for 'basevertex' |
| * argument value, but this time use different indices array (values |
| * that should be used for element indices are: 10, 11, 12). Assert |
| * that data read from the result texture differs from the reference |
| * texture. |
| * |
| * |
| **/ |
| class DrawElementsBaseVertexFunctionalCorrectBaseVertexBehavior : public DrawElementsBaseVertexTestBase |
| { |
| public: |
| /* Public methods */ |
| DrawElementsBaseVertexFunctionalCorrectBaseVertexBehavior(Context& context, const ExtParameters& extParams); |
| |
| virtual tcu::TestNode::IterateResult iterate(); |
| |
| private: |
| /* Private methods */ |
| void setUpTestCases(); |
| }; |
| |
| /** Implements Functional Test V. For clarity, the description is included below: |
| * |
| * (note: the description below refers to ES entry-points, but these are |
| * replaced with GL equivalents under GL contexts) |
| * |
| * V.1. Define new vertex coordinates array so that the triangle coordinates |
| * are placed at the beginning of the array (starting at element of index |
| * 0). The rest of the array should be filled with random values, but |
| * must not duplicate the requested triangle coordinates (as presented |
| * in the new_vertices array). |
| * V.1.a. Render a triangle to texture using glDrawElementsBaseVertexEXT() |
| * call. Use '5' for the 'basevertex' argument value. The client-side |
| * memory should be used to store vertex coordinates and client-side |
| * memory to store indices. Assert that data read from the result |
| * texture differs from the reference texture. |
| * V.1.b. Repeat the test (V.1.a.) for glDrawRangeElementsBaseVertexEXT(). |
| * V.1.c. Repeat the test (V.1.a.) for glDrawElementsInstancedBaseVertexEXT(): |
| * draw 3 instances of triangle object, compare with a corresponding |
| * texture. |
| * V.1.d. If EXT_multi_draw_arrays extension is supported, repeat the test |
| * (V.1.a.) for glMultiDrawElementsBaseVertexEXT(). |
| * V.2. Repeat the tests (V.1) using buffer object holding vertex coordinates |
| * data attached to GL_ARRAY_BUFFER buffer binding point and client-side |
| * memory to store indices. |
| * V.3. Repeat the tests (V.1) using client-side memory to store vertex |
| * coordinates and a buffer object holding index data attached to |
| * GL_ELEMENT_ARRAY_BUFFER buffer binding point. |
| * V.4. Repeat the tests (V.1) using buffer object holding vertex coordinates |
| * attached to GL_ARRAY_BUFFER buffer binding point and |
| * a buffer object holding index data attached to GL_ELEMENT_ARRAY_BUFFER |
| * buffer binding point. |
| * |
| */ |
| class DrawElementsBaseVertexFunctionalCorrectBaseVertexBehavior2 : public DrawElementsBaseVertexTestBase |
| { |
| public: |
| /* Public methods */ |
| DrawElementsBaseVertexFunctionalCorrectBaseVertexBehavior2(Context& context, const ExtParameters& extParams); |
| |
| virtual tcu::TestNode::IterateResult iterate(); |
| |
| private: |
| /* Private methods */ |
| void setUpTestCases(); |
| }; |
| |
| /** Implements Functional Test VIII. For clarity, the description is included below: |
| * |
| * (note: the description below refers to ES entry-points, but these are |
| * replaced with GL equivalents under GL contexts) |
| * |
| * VIII.1. Test whether glDraw*BaseVertexEXT() works correctly when |
| * 'basevertex' parameter value is negative (however the condition |
| * "indices[i] + basevertex >= 0" must always be met, otherwise the |
| * behaviour is undefined and should not be tested). |
| * Use vertices array (as declared above) to store vertex coordinates |
| * data: triangle vertex coordinates are declared at the beginning |
| * of the array, the rest of the array is filled with random values. |
| * Index array should store 3 values: 10, 11, 12. |
| * VIII.1.a. Execute glDrawElementsBaseVertexEXT() using '-10' for the |
| * 'basevertex' argument value. Use data described in the example. |
| * Use client-side memory to store the index data. |
| * Assert that the result texture does not differ from a reference |
| * texture object (which we get by calling a simple glDrawArrays() |
| * command with the same settings as described for this test case). |
| * VIII.1.b. Repeat the tests (VIII.1.a.) for |
| * glDrawRangeElementsBaseVertexEXT(). |
| * VIII.1.c. Repeat the tests (VIII.1.a.) for |
| * glDrawElementsInstancedBaseVertexEXT(): |
| * draw 3 instances of triangle object, compare with a corresponding |
| * texture. |
| * VIII.1.d. If EXT_multi_draw_arrays extension is supported, repeat the test |
| * (VIII.1.a.) for glMultiDrawElementsBaseVertexEXT(). |
| * VIII.2. Repeat the tests (VIII.1) using a buffer object holding index data |
| * attached to GL_ELEMENT_ARRAY_BUFFER buffer binding point. |
| * |
| */ |
| class DrawElementsBaseVertexFunctionalCorrectBaseVertexBehaviorUnderflow : public DrawElementsBaseVertexTestBase |
| { |
| public: |
| /* Public methods */ |
| DrawElementsBaseVertexFunctionalCorrectBaseVertexBehaviorUnderflow(Context& context, |
| const ExtParameters& extParams); |
| |
| virtual tcu::TestNode::IterateResult iterate(); |
| |
| private: |
| /* Private methods */ |
| void setUpTestCases(); |
| }; |
| |
| /** Implements Functional Test IX. For clarity, the description is included below: |
| * |
| * (note: the description below refers to ES entry-points, but these are |
| * replaced with GL equivalents under GL contexts) |
| * |
| * IX.1. Test whether glDraw*BaseVertexEXT() works correctly when |
| * ("indices[i]" + "basevertex") is larger than the maximum value |
| * representable by "type". |
| * Use vertices array (as declared above) to store vertex coordinates |
| * data: triangle vertex coordinates are declared at the beginning |
| * of the array, the rest of the array is filled with random values. |
| * Index array should store 3 values: 0, 1, 2. |
| * Use "basevertex" argument value that equals to (maximum value |
| * representable by a type + 1). |
| * IX.1.a. Execute glDrawElementsBaseVertexEXT() using 'basevertex' argument |
| * that equals to (maximum value representable by a type + 1). |
| * Use data described in the example. Use client-side memory to store |
| * the index data. |
| * Assert that the result texture does not differ from a reference |
| * texture object (which we get by calling a simple glDrawArrays() |
| * command with the same settings as described for this test case). |
| * The test should be executed for all of the types listed below: |
| * - GL_UNSIGNED_BYTE, |
| * - GL_UNSIGNED_SHORT. |
| * GL_UNSIGNED_INT is excluded from the test. |
| * IX.1.b. Repeat the tests (IX.1.a.) for |
| * glDrawRangeElementsBaseVertexEXT(). "start" and "end" should be |
| * equal to 0 and 3 accordingly. |
| * IX.1.c. Repeat the tests (IX.1.a.) for |
| * glDrawElementsInstancedBaseVertexEXT(): |
| * draw 3 instances of triangle object, compare with a corresponding |
| * texture. |
| * IX.1.d. If EXT_multi_draw_arrays extension is supported, repeat the test |
| * (IX.1.a.) for glMultiDrawElementsBaseVertexEXT(). |
| * IX.2. Repeat the tests (IX.1) using a buffer object holding index data |
| * attached to GL_ELEMENT_ARRAY_BUFFER buffer binding point. |
| * IX.3. Repeat the above tests (IX.1 - IX.2), but this time indices array |
| * should store 4 values: 0, 1, 2, 3. 'basevertex' argument should be |
| * equal to (maximum value representable by a type + 2). |
| * Assert that the result texture differs from a reference one. |
| * |
| */ |
| class DrawElementsBaseVertexFunctionalCorrectBaseVertexBehaviorOverflow : public DrawElementsBaseVertexTestBase |
| { |
| public: |
| /* Public methods */ |
| DrawElementsBaseVertexFunctionalCorrectBaseVertexBehaviorOverflow(Context& context, const ExtParameters& extParams); |
| |
| virtual tcu::TestNode::IterateResult iterate(); |
| |
| private: |
| /* Private methods */ |
| void setUpTestCases(); |
| }; |
| |
| /** Implements Functional Test VI. For clarity, the description is included below: |
| * |
| * (note: the description below refers to ES entry-points, but these are |
| * replaced with GL equivalents under GL contexts) |
| * |
| * VI.1. If EXT_tessellation_shader extension is supported, test whether |
| * the tessellation works correctly when glDraw*BaseVertexEXT() |
| * entry-points are used. |
| * Draw a single patch consisting of 3 patch vertices. In Tessellation |
| * Control shader, set gl_TessLevelInner[0], gl_TessLevelOuter[1], |
| * gl_TessLevelOuter[2] to 3. |
| * In the Tessellation Evaluation shader, define |
| * layout(triangles, equal_spacing, cw) in; |
| * Coordinates generated by the tessellator should be stored in gl_Position, |
| * after having been adjusted to completely fit the screen space. |
| * Set different color for each vertex. As a result we expect |
| * a multi-colored triangle to be drawn into the result texture. |
| * VI.1.a. Execute glDrawElementsBaseVertexEXT() using '10' for the 'basevertex' |
| * argument value. Use data described in the example. Use client-side |
| * memory to store vertex coordinates and client-side memory to store |
| * indices. Assert that the result texture does not differ from reference |
| * texture (which we get by calling a simple glDrawArrays() command with |
| * the same settings as described for this test case). |
| * VI.1.b. Repeat the tests (VI.1.a.) for |
| * glDrawRangeElementsBaseVertexEXT(). |
| * VI.1.c. Repeat the tests (VI.1.a.) for |
| * glDrawElementsInstancedBaseVertexEXT(): |
| * draw 3 instances of triangle object, compare with a corresponding |
| * texture. |
| * VI.1.d. If EXT_multi_draw_arrays extension is supported, repeat the test |
| * (VI.1.a.) for glMultiDrawElementsBaseVertexEXT(). |
| * VI.2. Repeat the tests (VI.1) using buffer object holding vertex |
| * coordinates attached to GL_ARRAY_BUFFER buffer binding point and |
| * client-side memory to store indices. |
| * VI.3. Repeat the tests (VI.1) using client-side memory to store vertex |
| * coordinates and a buffer object holding index data attached to |
| * GL_ELEMENT_ARRAY_BUFFER buffer binding point. |
| * VI.4. Repeat the tests (VI.1) using buffer object holding vertex |
| * coordinates attached to GL_ARRAY_BUFFER buffer binding point and |
| * a buffer object holding index data attached to |
| * GL_ELEMENT_ARRAY_BUFFER buffer binding point. |
| * VI.5. Repeat the tests (VI.1 - VI.4) using '0' for the 'basevertex' |
| * argument value. Assert that data read from the result texture |
| * differs from the reference texture. |
| * VI.6 Add Geometry Shader Execution step before the fragment operation |
| * are handled. The shader should output input triangles, with negated |
| * y component. Repeat tests (VI.1 - VI.5). |
| * The new reference texture should be prepared (a multi-colored triangle |
| * rendered based on the assumption described in the test case, with |
| * a simple glDrawArrays() call). |
| * |
| */ |
| class DrawElementsBaseVertexFunctionalCorrectBaseVertexBehaviorAEPShaderStages : public DrawElementsBaseVertexTestBase |
| { |
| public: |
| /* Public methods */ |
| DrawElementsBaseVertexFunctionalCorrectBaseVertexBehaviorAEPShaderStages(Context& context, |
| const ExtParameters& extParams); |
| |
| virtual tcu::TestNode::IterateResult iterate(); |
| |
| private: |
| /* Private methods */ |
| void setUpTestCases(); |
| }; |
| |
| /** Implements Negative Test IV. For clarity, the description is included below: |
| * |
| * (note: the description below refers to ES entry-points, but these are |
| * replaced with GL equivalents under GL contexts) |
| * |
| * IV.1. Check if proper error code is generated when transform feedback is |
| * active and not paused. |
| * IV.1.a. Generate, bind and begin transform feedback prepared to record |
| * GL_TRIANGLES type of primitives. Execute glDrawElementsBaseVertexEXT() |
| * as shown in the description. Expect GL_INVALID_OPERATION to be |
| * generated. |
| * IV.1.b. Repeat the test (IV.1.a.) for glDrawRangeElementsBaseVertexEXT(). |
| * IV.1.c. Repeat the test (IV.1.a.) for glDrawElementsInstancedBaseVertexEXT(). |
| * |
| */ |
| class DrawElementsBaseVertexNegativeActiveTransformFeedbackTest : public DrawElementsBaseVertexTestBase |
| { |
| public: |
| /* Public methods */ |
| DrawElementsBaseVertexNegativeActiveTransformFeedbackTest(Context& context, const ExtParameters& extParams); |
| |
| virtual void deinit(); |
| virtual void init(); |
| virtual tcu::TestNode::IterateResult iterate(); |
| |
| private: |
| /* Private variables */ |
| glw::GLuint m_bo_tf_result_id; |
| |
| /* Private methods */ |
| virtual void deinitPerTestObjects(); |
| }; |
| |
| /** Implements Negative Test I.2 and II.1, II.2, II.3 (for the original test). |
| * For clarity, the description is included below: |
| * |
| * (note: the description below refers to ES entry-points, but these are |
| * replaced with GL equivalents under GL contexts) |
| * |
| * I.2. Check if proper error code is generated when 'count' argument is |
| * invalid. |
| * I.2.a. Prepare the environment as described above. Execute |
| * glDrawElementsBaseVertexEXT() using '-1' as 'count' argument value. |
| * Expect GL_INVALID_VALUE error to be generated. |
| * I.2.b. Repeat the test (I.2.a.) for glDrawRangeElementsBaseVertexEXT(). |
| * I.2.c. Repeat the test (I.2.a.) for glDrawElementsInstancedBaseVertexEXT(). |
| * I.2.d. If EXT_multi_draw_arrays extension is supported, repeat the test |
| * (I.2.a.) for glMultiDrawElementsBaseVertexEXT(). |
| * |
| * II.1. Repeat the tests (I.1 - I.6) using client-side memory to store indices |
| * and buffer object storing vertex coordinates attached to |
| * GL_ARRAY_BUFFER buffer binding point. |
| * |
| * II.2. Repeat the tests (I.1 - I.6) when a buffer object holding index data |
| * is attached to GL_ELEMENT_ARRAY_BUFFER buffer binding point and |
| * client-side memory is used to store vertex coordinates. Replace |
| * value of 'indices' argument from the functions described above |
| * with NULL. |
| * |
| * II.3. Repeat the tests (I.1 - I.6) when a buffer object storing index data |
| * is attached to GL_ELEMENT_ARRAY_BUFFER buffer binding point and |
| * buffer object storing vertex coordinates data is attached to |
| * GL_ARRAY_BUFFER buffer binding point. |
| * Replace value of 'indices' argument from the functions described |
| * above with NULL. |
| */ |
| class DrawElementsBaseVertexNegativeInvalidCountArgumentTest : public DrawElementsBaseVertexTestBase |
| { |
| public: |
| /* Public methods */ |
| DrawElementsBaseVertexNegativeInvalidCountArgumentTest(Context& context, const ExtParameters& extParams); |
| |
| virtual tcu::TestNode::IterateResult iterate(); |
| }; |
| |
| /** Implements Negative Test I.6 and II.1, II.2, II.3 (for the original test). |
| * For clarity, the description for I.6 is included below. II.1, II.2 and II.3 |
| * have already been cited above. |
| * |
| * (note: the description below refers to ES entry-points, but these are |
| * replaced with GL equivalents under GL contexts) |
| * |
| * I.6 Check if proper error code is generated when 'instancecount' argument |
| * value is invalid for glDrawElementsInstancedBaseVertexEXT() call. |
| * Prepare the environment as described above. The client-side memory |
| * should be used in the draw calls to store vertex coordinates and |
| * indices data. Execute glDrawElementsInstancedBaseVertexEXT() using |
| * '-1' for 'instancecount' argument value. Expect GL_INVALID_VALUE |
| * to be generated. |
| * |
| */ |
| class DrawElementsBaseVertexNegativeInvalidInstanceCountArgumentTest : public DrawElementsBaseVertexTestBase |
| { |
| public: |
| /* Public methods */ |
| DrawElementsBaseVertexNegativeInvalidInstanceCountArgumentTest(Context& context, const ExtParameters& extParams); |
| |
| virtual tcu::TestNode::IterateResult iterate(); |
| }; |
| |
| /** Implements Negative Test I.1 and II.1, II.2, II.3 (for the original test). |
| * For clarity, the description for I.1 is included below. II.1, II.2 and II.3 |
| * have already been cited above. |
| * |
| * (note: the description below refers to ES entry-points, but these are |
| * replaced with GL equivalents under GL contexts) |
| * |
| * I.1. Check if proper error code is generated when 'mode' argument is |
| * invalid. The client-side memory should be used in the draw calls to |
| * store vertex coordinates and indices data. |
| * I.1.a. Prepare the environment as described above. Execute |
| * glDrawElementsBaseVertexEXT() using GL_NONE for 'mode' argument |
| * value. Expect GL_INVALID_ENUM error to be generated. |
| * I.1.b. Repeat the test (I.1.a.) for glDrawRangeElementsBaseVertexEXT(). |
| * I.1.c. Repeat the test (I.1.a.) for glDrawElementsInstancedBaseVertexEXT(). |
| * I.1.d. If EXT_multi_draw_arrays extension is supported, repeat the test |
| * (I.1.a.) for glMultiDrawElementsBaseVertexEXT(). |
| * |
| */ |
| class DrawElementsBaseVertexNegativeInvalidModeArgumentTest : public DrawElementsBaseVertexTestBase |
| { |
| public: |
| /* Public methods */ |
| DrawElementsBaseVertexNegativeInvalidModeArgumentTest(Context& context, const ExtParameters& extParams); |
| |
| virtual tcu::TestNode::IterateResult iterate(); |
| }; |
| |
| /** Implements Negative Test I.4 and II.1, II.2, II.3 (for the original test). |
| * For clarity, the description for I.4 is included below. II.1, II.2 and II.3 |
| * have already been cited above. |
| * |
| * (note: the description below refers to ES entry-points, but these are |
| * replaced with GL equivalents under GL contexts) |
| * |
| * I.4 Check if proper error code is generated when 'primcount' argument is |
| * invalid. If EXT_multi_draw_arrays extension is supported, prepare |
| * the environment as described above, execute |
| * glMultiDrawElementsBaseVertexEXT() with negative 'primcount' value. |
| * The client-side memory should be used in the draw calls to store |
| * vertex coordinates and indices data. Expect GL_INVALID_VALUE error |
| * to be generated. |
| * |
| */ |
| class DrawElementsBaseVertexNegativeInvalidPrimcountArgumentTest : public DrawElementsBaseVertexTestBase |
| { |
| public: |
| /* Public methods */ |
| DrawElementsBaseVertexNegativeInvalidPrimcountArgumentTest(Context& context, const ExtParameters& extParams); |
| |
| virtual tcu::TestNode::IterateResult iterate(); |
| }; |
| |
| /** Implements Negative Test I.5 and II.1, II.2, II.3 (for the original test). |
| * For clarity, the description for I.5 is included below. II.1, II.2 and II.3 |
| * have already been cited above. |
| * |
| * (note: the description below refers to ES entry-points, but these are |
| * replaced with GL equivalents under GL contexts) |
| * |
| * I.5 Check if proper error code is generated when 'start' and 'end' |
| * arguments combination is invalid for glDrawRangeElementsBaseVertexEXT() |
| * call. Prepare the environment as described above. Execute the |
| * glDrawRangeElementsBaseVertexEXT() using '3' for 'start' and '0' |
| * for 'end' argument values. The client-side memory should be used in the |
| * draw calls to store vertex coordinates and indices data. Expect |
| * GL_INVALID_VALUE to be generated. |
| * |
| */ |
| class DrawElementsBaseVertexNegativeInvalidStartEndArgumentsTest : public DrawElementsBaseVertexTestBase |
| { |
| public: |
| /* Public methods */ |
| DrawElementsBaseVertexNegativeInvalidStartEndArgumentsTest(Context& context, const ExtParameters& extParams); |
| |
| virtual tcu::TestNode::IterateResult iterate(); |
| }; |
| |
| /** Implements Negative Test I.3 and II.1, II.2, II.3 (for the original test). |
| * For clarity, the description for I.3 is included below. II.1, II.2 and II.3 |
| * have already been cited above. |
| * |
| * (note: the description below refers to ES entry-points, but these are |
| * replaced with GL equivalents under GL contexts) |
| * |
| * I.3. Check if proper error code is generated when 'type' argument is |
| * invalid. The client-side memory should be used in the draw calls to |
| * store vertex coordinates and indices data. |
| * I.3.a. Prepare the environment as described above. Execute |
| * glDrawElementsBaseVertexEXT() using 'GL_NONE' as 'type' argument |
| * value. Expect GL_INVALID_ENUM error to be generated. |
| * I.3.b. Repeat the test (I.3.a.) for glDrawRangeElementsBaseVertexEXT(). |
| * I.3.c. Repeat the test (I.3.a.) for glDrawElementsInstancedBaseVertexEXT(). |
| * I.3.d. If EXT_multi_draw_arrays extension is supported, repeat the test |
| * (I.3.a.) for glMultiDrawElementsBaseVertexEXT(). |
| * |
| */ |
| class DrawElementsBaseVertexNegativeInvalidTypeArgumentTest : public DrawElementsBaseVertexTestBase |
| { |
| public: |
| /* Public methods */ |
| DrawElementsBaseVertexNegativeInvalidTypeArgumentTest(Context& context, const ExtParameters& extParams); |
| |
| virtual tcu::TestNode::IterateResult iterate(); |
| }; |
| |
| /** Implements Negative Test III. For clarity, the description is included below: |
| * |
| * (note: the description below refers to ES entry-points, but these are |
| * replaced with GL equivalents under GL contexts) |
| * |
| * III.1. Check if proper error code is generated when element array buffer |
| * object is mapped for the draw call. |
| * III.1.a. Call glMapBufferRange() to map the element array buffer object |
| * that stores vertex indices used in the draw call. Execute |
| * glDrawElementsBaseVertexEXT() as shown in the description using |
| * element array buffer object as a vertex indices data source |
| * (the buffer object which is currently mapped). The client-side |
| * memory should be used to store vertex coordinates. Expect |
| * GL_INVALID_OPERATION to be generated. |
| * III.1.b. Repeat the test (III.1.a.) for glDrawRangeElementsBaseVertexEXT(). |
| * III.1.c. Repeat the test (III.1.a.) for glDrawElementsInstancedBaseVertexEXT(). |
| * III.1.d. Repeat the test (III.1.a - III.1.c) with buffer object holding |
| * vertex coordinates attached to GL_ARRAY_BUFFER buffer binding point. |
| * |
| */ |
| class DrawElementsBaseVertexNegativeMappedBufferObjectsTest : public DrawElementsBaseVertexTestBase |
| { |
| public: |
| /* Public methods */ |
| DrawElementsBaseVertexNegativeMappedBufferObjectsTest(Context& context, const ExtParameters& extParams); |
| |
| virtual tcu::TestNode::IterateResult iterate(); |
| }; |
| |
| /** Test group which encapsulates all conformance tests for "draw elements base vertex" |
| * functionality. |
| */ |
| class DrawElementsBaseVertexTests : public glcts::TestCaseGroupBase |
| { |
| public: |
| /* Public methods */ |
| DrawElementsBaseVertexTests(glcts::Context& context, const ExtParameters& extParams); |
| |
| void init(void); |
| |
| private: |
| DrawElementsBaseVertexTests(const DrawElementsBaseVertexTests& other); |
| DrawElementsBaseVertexTests& operator=(const DrawElementsBaseVertexTests& other); |
| }; |
| |
| } /* glcts namespace */ |
| |
| #endif // _ESEXTCDRAWELEMENTSBASEVERTEXTESTS_HPP |
