1 #ifndef _GL4CGPUSHADERFP64TESTS_HPP 2 #define _GL4CGPUSHADERFP64TESTS_HPP 3 /*------------------------------------------------------------------------- 4 * OpenGL Conformance Test Suite 5 * ----------------------------- 6 * 7 * Copyright (c) 2014-2016 The Khronos Group Inc. 8 * 9 * Licensed under the Apache License, Version 2.0 (the "License"); 10 * you may not use this file except in compliance with the License. 11 * You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 * 21 */ /*! 22 * \file 23 * \brief 24 */ /*-------------------------------------------------------------------*/ 25 26 /** 27 * \file gl4cGPUShaderFP64Tests.hpp 28 * \brief Declares test classes for "GPU Shader FP64" functionality. 29 */ /*-------------------------------------------------------------------*/ 30 31 #include "glcTestCase.hpp" 32 #include "glwDefs.hpp" 33 #include "glwEnums.hpp" 34 #include "tcuDefs.hpp" 35 #include "tcuVector.hpp" 36 #include <queue> 37 38 namespace gl4cts 39 { 40 class Utils 41 { 42 public: 43 /* Public type definitions */ 44 45 /** Store information about program object 46 * 47 **/ 48 struct programInfo 49 { 50 programInfo(deqp::Context& context); 51 ~programInfo(); 52 53 void build(const glw::GLchar* compute_shader_code, const glw::GLchar* fragment_shader_code, 54 const glw::GLchar* geometry_shader_code, const glw::GLchar* tesselation_control_shader_code, 55 const glw::GLchar* tesselation_evaluation_shader_code, const glw::GLchar* vertex_shader_code, 56 const glw::GLchar* const* varying_names, glw::GLuint n_varying_names); 57 58 void compile(glw::GLuint shader_id, const glw::GLchar* shader_code) const; 59 60 void link() const; 61 62 static const glw::GLenum ARB_COMPUTE_SHADER; 63 64 deqp::Context& m_context; 65 66 glw::GLuint m_compute_shader_id; 67 glw::GLuint m_fragment_shader_id; 68 glw::GLuint m_geometry_shader_id; 69 glw::GLuint m_program_object_id; 70 glw::GLuint m_tesselation_control_shader_id; 71 glw::GLuint m_tesselation_evaluation_shader_id; 72 glw::GLuint m_vertex_shader_id; 73 }; 74 75 /* Defines GLSL variable type */ 76 enum _variable_type 77 { 78 VARIABLE_TYPE_BOOL, 79 VARIABLE_TYPE_BVEC2, 80 VARIABLE_TYPE_BVEC3, 81 VARIABLE_TYPE_BVEC4, 82 VARIABLE_TYPE_DOUBLE, 83 VARIABLE_TYPE_DMAT2, 84 VARIABLE_TYPE_DMAT2X3, 85 VARIABLE_TYPE_DMAT2X4, 86 VARIABLE_TYPE_DMAT3, 87 VARIABLE_TYPE_DMAT3X2, 88 VARIABLE_TYPE_DMAT3X4, 89 VARIABLE_TYPE_DMAT4, 90 VARIABLE_TYPE_DMAT4X2, 91 VARIABLE_TYPE_DMAT4X3, 92 VARIABLE_TYPE_DVEC2, 93 VARIABLE_TYPE_DVEC3, 94 VARIABLE_TYPE_DVEC4, 95 VARIABLE_TYPE_FLOAT, 96 VARIABLE_TYPE_INT, 97 VARIABLE_TYPE_IVEC2, 98 VARIABLE_TYPE_IVEC3, 99 VARIABLE_TYPE_IVEC4, 100 VARIABLE_TYPE_MAT2, 101 VARIABLE_TYPE_MAT2X3, 102 VARIABLE_TYPE_MAT2X4, 103 VARIABLE_TYPE_MAT3, 104 VARIABLE_TYPE_MAT3X2, 105 VARIABLE_TYPE_MAT3X4, 106 VARIABLE_TYPE_MAT4, 107 VARIABLE_TYPE_MAT4X2, 108 VARIABLE_TYPE_MAT4X3, 109 VARIABLE_TYPE_UINT, 110 VARIABLE_TYPE_UVEC2, 111 VARIABLE_TYPE_UVEC3, 112 VARIABLE_TYPE_UVEC4, 113 VARIABLE_TYPE_VEC2, 114 VARIABLE_TYPE_VEC3, 115 VARIABLE_TYPE_VEC4, 116 117 /* Always last */ 118 VARIABLE_TYPE_UNKNOWN 119 }; 120 121 /* Public static methods */ 122 static _variable_type getBaseVariableType(_variable_type type); 123 static unsigned int getBaseVariableTypeComponentSize(_variable_type type); 124 static unsigned char getComponentAtIndex(unsigned int index); 125 126 static _variable_type getDoubleVariableType(glw::GLuint n_columns, glw::GLuint n_rows); 127 128 static std::string getFPVariableTypeStringForVariableType(_variable_type type); 129 static glw::GLenum getGLDataTypeOfBaseVariableType(_variable_type type); 130 static glw::GLenum getGLDataTypeOfVariableType(_variable_type type); 131 132 static _variable_type getIntVariableType(glw::GLuint n_columns, glw::GLuint n_rows); 133 134 static unsigned int getNumberOfColumnsForVariableType(_variable_type type); 135 static unsigned int getNumberOfComponentsForVariableType(_variable_type type); 136 static unsigned int getNumberOfLocationsUsedByDoublePrecisionVariableType(_variable_type type); 137 static unsigned int getNumberOfRowsForVariableType(_variable_type type); 138 139 static _variable_type getPostMatrixMultiplicationVariableType(_variable_type type_matrix_a, 140 _variable_type type_matrix_b); 141 142 static std::string getStringForVariableTypeValue(_variable_type type, const unsigned char* data_ptr); 143 144 static _variable_type getTransposedMatrixVariableType(_variable_type type); 145 146 static _variable_type getUintVariableType(glw::GLuint n_columns, glw::GLuint n_rows); 147 148 static std::string getVariableTypeString(_variable_type type); 149 150 static bool isGLVersionAtLeast(const glw::Functions& gl, glw::GLint required_major, glw::GLint required_minor); 151 152 static bool isMatrixVariableType(_variable_type type); 153 static bool isScalarVariableType(_variable_type type); 154 155 static void replaceToken(const glw::GLchar* token, size_t& search_position, const glw::GLchar* text, 156 std::string& string); 157 }; 158 159 /** Make sure errors as per spec are generated for new entry-points. 160 * 161 * a) Make sure GL_INVALID_OPERATION is generated by glUniform*() and 162 * glUniformMatrix*() functions if there is no current program object. 163 * b) Make sure GL_INVALID_OPERATION is generated by glUniform*() if 164 * the size of the uniform variable declared in the shader does not 165 * match the size indicated by the command. 166 * c) Make sure GL_INVALID_OPERATION is generated if glUniform*() and 167 * glUniformMatrix*() are used to load a uniform variable of type 168 * bool, bvec2, bvec3, bvec4, float, int, ivec2, ivec3, ivec4, 169 * unsigned int, uvec2, uvec3, uvec4, vec2, vec3, vec4 or an array 170 * of these. 171 * d) Make sure GL_INVALID_OPERATION is generated if glUniform*() and 172 * glUniformMatrix*() are used to load incompatible double-typed 173 * uniforms, as presented below: 174 * 175 * I. double-typed uniform configured by glUniform2d(); 176 * II. double-typed uniform configured by glUniform3d(); 177 * III. double-typed uniform configured by glUniform4d(); 178 * IV. double-typed uniform configured by glUniformMatrix*(); 179 * V. dvec2-typed uniform configured by glUniform1d(); 180 * VI. dvec2-typed uniform configured by glUniform3d(); 181 * VII. dvec2-typed uniform configured by glUniform4d(); 182 * VIII. dvec2-typed uniform configured by glUniformMatrix*(); 183 * 184 * (etc.) 185 * 186 * e) Make sure GL_INVALID_OPERATION is generated if <location> of 187 * glUniform*() and glUniformMatrix*() is an invalid uniform 188 * location for the current program object and location is not 189 * equal to -1. 190 * f) Make sure GL_INVALID_VALUE is generated if <count> of 191 * glUniform*() (*dv() functions only) and glUniformMatrix*() is 192 * negative. 193 * g) Make sure GL_INVALID_OPERATION is generated if <count> of 194 * glUniform*() (*dv() functions only) and glUniformMatrix*() is 195 * greater than 1 and the indicated uniform variable is not an 196 * array variable. 197 * h) Make sure GL_INVALID_OPERATION is generated if a sampler is 198 * loaded by glUniform*() and glUniformMatrix*(). 199 * i) Make sure GL_INVALID_OPERATION is generated if glUniform*() and 200 * glUniformMatrix*() is used to load values for uniforms of 201 * boolean types. 202 */ 203 class GPUShaderFP64Test1 : public deqp::TestCase 204 { 205 public: 206 /* Public methods */ 207 GPUShaderFP64Test1(deqp::Context& context); 208 209 void deinit(); 210 virtual tcu::TestNode::IterateResult iterate(); 211 212 /* Private type definitions */ 213 private: 214 typedef enum { 215 UNIFORM_FUNCTION_FIRST, 216 217 UNIFORM_FUNCTION_1D = UNIFORM_FUNCTION_FIRST, 218 UNIFORM_FUNCTION_1DV, 219 UNIFORM_FUNCTION_2D, 220 UNIFORM_FUNCTION_2DV, 221 UNIFORM_FUNCTION_3D, 222 UNIFORM_FUNCTION_3DV, 223 UNIFORM_FUNCTION_4D, 224 UNIFORM_FUNCTION_4DV, 225 226 UNIFORM_FUNCTION_MATRIX2DV, 227 UNIFORM_FUNCTION_MATRIX2X3DV, 228 UNIFORM_FUNCTION_MATRIX2X4DV, 229 UNIFORM_FUNCTION_MATRIX3DV, 230 UNIFORM_FUNCTION_MATRIX3X2DV, 231 UNIFORM_FUNCTION_MATRIX3X4DV, 232 UNIFORM_FUNCTION_MATRIX4DV, 233 UNIFORM_FUNCTION_MATRIX4X2DV, 234 UNIFORM_FUNCTION_MATRIX4X3DV, 235 236 /* Always last */ 237 UNIFORM_FUNCTION_COUNT 238 } _uniform_function; 239 240 /* Private methods */ 241 const char* getUniformFunctionString(_uniform_function func); 242 const char* getUniformNameForLocation(glw::GLint location); 243 void initTest(); 244 bool isMatrixUniform(glw::GLint uniform_location); 245 bool isMatrixUniformFunction(_uniform_function func); 246 bool verifyErrorGenerationWhenCallingDoubleUniformFunctionsForBooleans(); 247 bool verifyErrorGenerationWhenCallingDoubleUniformFunctionsForSamplers(); 248 bool verifyErrorGenerationWhenCallingDoubleUniformFunctionsWithInvalidCount(); 249 bool verifyErrorGenerationWhenCallingDoubleUniformFunctionsWithInvalidLocation(); 250 bool verifyErrorGenerationWhenCallingDoubleUniformFunctionsWithNegativeCount(); 251 bool verifyErrorGenerationWhenCallingMismatchedDoubleUniformFunctions(); 252 bool verifyErrorGenerationWhenCallingSizeMismatchedUniformFunctions(); 253 bool verifyErrorGenerationWhenCallingTypeMismatchedUniformFunctions(); 254 bool verifyErrorGenerationWhenUniformFunctionsCalledWithoutActivePO(); 255 256 /* Private fields */ 257 bool m_has_test_passed; 258 glw::GLint m_po_bool_arr_uniform_location; 259 glw::GLint m_po_bool_uniform_location; 260 glw::GLint m_po_bvec2_arr_uniform_location; 261 glw::GLint m_po_bvec2_uniform_location; 262 glw::GLint m_po_bvec3_arr_uniform_location; 263 glw::GLint m_po_bvec3_uniform_location; 264 glw::GLint m_po_bvec4_arr_uniform_location; 265 glw::GLint m_po_bvec4_uniform_location; 266 glw::GLint m_po_dmat2_arr_uniform_location; 267 glw::GLint m_po_dmat2_uniform_location; 268 glw::GLint m_po_dmat2x3_arr_uniform_location; 269 glw::GLint m_po_dmat2x3_uniform_location; 270 glw::GLint m_po_dmat2x4_arr_uniform_location; 271 glw::GLint m_po_dmat2x4_uniform_location; 272 glw::GLint m_po_dmat3_arr_uniform_location; 273 glw::GLint m_po_dmat3_uniform_location; 274 glw::GLint m_po_dmat3x2_arr_uniform_location; 275 glw::GLint m_po_dmat3x2_uniform_location; 276 glw::GLint m_po_dmat3x4_arr_uniform_location; 277 glw::GLint m_po_dmat3x4_uniform_location; 278 glw::GLint m_po_dmat4_arr_uniform_location; 279 glw::GLint m_po_dmat4_uniform_location; 280 glw::GLint m_po_dmat4x2_arr_uniform_location; 281 glw::GLint m_po_dmat4x2_uniform_location; 282 glw::GLint m_po_dmat4x3_arr_uniform_location; 283 glw::GLint m_po_dmat4x3_uniform_location; 284 glw::GLint m_po_double_arr_uniform_location; 285 glw::GLint m_po_double_uniform_location; 286 glw::GLint m_po_dvec2_arr_uniform_location; 287 glw::GLint m_po_dvec2_uniform_location; 288 glw::GLint m_po_dvec3_arr_uniform_location; 289 glw::GLint m_po_dvec3_uniform_location; 290 glw::GLint m_po_dvec4_arr_uniform_location; 291 glw::GLint m_po_dvec4_uniform_location; 292 glw::GLint m_po_float_arr_uniform_location; 293 glw::GLint m_po_float_uniform_location; 294 glw::GLint m_po_int_arr_uniform_location; 295 glw::GLint m_po_int_uniform_location; 296 glw::GLint m_po_ivec2_arr_uniform_location; 297 glw::GLint m_po_ivec2_uniform_location; 298 glw::GLint m_po_ivec3_arr_uniform_location; 299 glw::GLint m_po_ivec3_uniform_location; 300 glw::GLint m_po_ivec4_arr_uniform_location; 301 glw::GLint m_po_ivec4_uniform_location; 302 glw::GLint m_po_sampler_uniform_location; 303 glw::GLint m_po_uint_arr_uniform_location; 304 glw::GLint m_po_uint_uniform_location; 305 glw::GLint m_po_uvec2_arr_uniform_location; 306 glw::GLint m_po_uvec2_uniform_location; 307 glw::GLint m_po_uvec3_arr_uniform_location; 308 glw::GLint m_po_uvec3_uniform_location; 309 glw::GLint m_po_uvec4_arr_uniform_location; 310 glw::GLint m_po_uvec4_uniform_location; 311 glw::GLint m_po_vec2_arr_uniform_location; 312 glw::GLint m_po_vec2_uniform_location; 313 glw::GLint m_po_vec3_arr_uniform_location; 314 glw::GLint m_po_vec3_uniform_location; 315 glw::GLint m_po_vec4_arr_uniform_location; 316 glw::GLint m_po_vec4_uniform_location; 317 glw::GLuint m_po_id; 318 glw::GLuint m_vs_id; 319 }; 320 321 /** Implements "Subtest 2" from CTS_ARB_gpu_shader_fp64, description follows: 322 * Make sure that it is possible to use: 323 * 324 * a) up to (GL_MAX_VERTEX_UNIFORM_COMPONENTS / 2) double uniforms 325 * in a default uniform block of a vertex shader; 326 * b) up to (GL_MAX_VERTEX_UNIFORM_COMPONENTS / 4) dvec2 uniforms 327 * in a default uniform block of a vertex shader; 328 * c) up to (GL_MAX_VERTEX_UNIFORM_COMPONENTS / 6) dvec3 uniforms 329 * in a default uniform block of a vertex shader; 330 * d) up to (GL_MAX_VERTEX_UNIFORM_COMPONENTS / 8) dvec4 uniforms 331 * in a default uniform block of a vertex shader; 332 * e) up to (GL_MAX_VERTEX_UNIFORM_COMPONENTS / 16) dmat2, dmat2x3, 333 * dmat2x4, dmat3x2, dmat4x2 uniforms in a default uniform block 334 * of a vertex shader; (each type tested in a separate shader) 335 * f) up to (GL_MAX_VERTEX_UNIFORM_COMPONENTS / 24) dmat3, dmat3x4, 336 * dmat4x3 uniforms in a default uniform block of a vertex shader; 337 * (each type tested in a separate shader) 338 * g) up to (GL_MAX_VERTEX_UNIFORM_COMPONENTS / 32) dmat4 uniforms 339 * in a default uniform block of a vertex shader; 340 * h) arrayed cases of a)-g), where the array size is 3 and the 341 * amount of uniforms that can be supported should be divided 342 * by three as well. 343 * i) cases a)-h), where "vertex shader" is replaced by "fragment 344 * shader" and GL_MAX_VERTEX_UNIFORM_COMPONENTS is changed to 345 * GL_MAX_FRAGMENT_UNIFORM_COMPONENTS; 346 * j) cases a)-h) where "vertex shader" is replaced by "geometry 347 * shader" and GL_MAX_VERTEX_UNIFORM_COMPONENTS is changed to 348 * GL_MAX_GEOMETRY_UNIFORM_COMPONENTS; 349 * k) cases a)-h) where "vertex shader" is replaced by "compute 350 * shader" and GL_MAX_VERTEX_UNIFORM_COMPONENTS is changed to 351 * GL_MAX_COMPUTE_UNIFORM_COMPONENTS; 352 * l) cases a)-h) where "vertex shader" is replaced by "tessellation 353 * control shader" and GL_MAX_VERTEX_UNIFORM_COMPONENTS is changed 354 * to GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS; 355 * m) cases a)-h) where "vertex shader" is replaced by "tessellation 356 * evaluation shader" and GL_MAX_VERTEX_UNIFORM_COMPONENTS is 357 * changed to GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS; 358 * 359 * For each case considered, the test should only define uniforms 360 * for the stage the test is dealing with. 361 * 362 * All uniform components considered as a whole should be assigned 363 * unique values, where the very first uniform component is set to 364 * a value of 1, the one following set to 2, the one afterward set 365 * to 3, and so on. 366 * 367 * For "vertex shader" cases, the test should work by creating 368 * a program object, to which a vertex shader (as per test case) 369 * would be attached. The shader would then read all the uniforms, 370 * verify their values are correct and then set an output bool 371 * variable to true if the validation passed, false otherwise. 372 * The test should draw 1024 points, XFB the contents of the output 373 * variable and verify the result. 374 * 375 * For "geometry shader" cases, the test should create a program object 376 * and attach vertex and geometry shaders to it. The vertex shader 377 * should set gl_Position to (1, 0, 0, 1). The geometry shader 378 * should accept points on input and emit 1 point, read all the 379 * uniforms, verify their values are correct and then set an output 380 * bool variable to true if the validation passed, false otherwise. 381 * The test should draw 1024 points, XFB the contents of the output 382 * variable and verify the result. 383 * 384 * For "tessellation control shader" cases, the test should create 385 * a program object and attach vertex and tessellation control shaders 386 * to the program object. The vertex shader should set gl_Position 387 * to (1, 0, 0, 1). The tessellation control shader should output 388 * a single vertex per patch and set all inner/outer tessellation. 389 * levels to 1. The shader should read all the uniforms, verify 390 * their values are correct and then set an output per-vertex bool 391 * variable to true if the validation passed, false otherwise. The 392 * test should draw 1024 patches, XFB the contents of the output 393 * variable and verify the result. 394 * 395 * For "tessellation evaluation shader" cases, the test should create 396 * a program object and attach vertex, tessellation control and 397 * tessellation evaluation shaders to the program object. The vertex 398 * shader should set gl_Position to (1, 0, 0, 1). The tessellation 399 * control shader should behave as in "tessellation control shader" 400 * case. The tessellation evaluation shader should accept isolines 401 * and work in point mode. The shader should read all the uniforms, 402 * verify their values are correct and then set an output 403 * bool variable to true if the validation passed, false otherwise. 404 * The test should draw 1024 patches, XFB the contents of the output 405 * variable and verify the result. 406 * 407 * For "fragment shader" cases, the test should create a program object 408 * and attach vertex and fragment shaders to the program object. The 409 * vertex shader should set gl_Position to 4 different values 410 * (depending on gl_VertexID value), defining screen-space corners 411 * for a GL_TRIANGLE_FAN-based draw call. The fragment shader should 412 * read all the uniforms, verify their values are correct and then 413 * set the output color to vec4(1) if the validation passed, vec4(0) 414 * otherwise. The test should draw 4 vertices making up a triangle fan, 415 * read the rasterized image and confirm the result. 416 * 417 * For all cases apart from "fragment shader", the test should also 418 * verify that glGetTransformFeedbackVarying() reports correct 419 * properties for the uniforms. 420 * 421 * The test should also verify that in all cases glGetActiveUniform() 422 * reports correct properties for all the defined uniforms. 423 **/ 424 class GPUShaderFP64Test2 : public deqp::TestCase 425 { 426 public: 427 /* Public methods */ 428 GPUShaderFP64Test2(deqp::Context& context); 429 430 virtual void deinit(); 431 virtual tcu::TestNode::IterateResult iterate(); 432 433 private: 434 /* Private types */ 435 typedef glw::GLint captured_varying_type; 436 typedef void(GLW_APIENTRY* arbDispatchComputeFunc)(glw::GLuint num_groups_x, glw::GLuint num_groups_y, 437 glw::GLuint num_groups_z); 438 439 /** Shader stage enumeration 440 * 441 */ 442 enum shaderStage 443 { 444 COMPUTE_SHADER, 445 FRAGMENT_SHADER, 446 GEOMETRY_SHADER, 447 TESS_CTRL_SHADER, 448 TESS_EVAL_SHADER, 449 VERTEX_SHADER, 450 }; 451 452 /** Store details about uniform type 453 * 454 **/ 455 struct uniformTypeDetails 456 { 457 uniformTypeDetails(glw::GLuint n_columns, glw::GLuint n_rows); 458 459 glw::GLuint m_n_columns; 460 glw::GLuint m_n_rows; 461 glw::GLenum m_type; 462 std::string m_type_name; 463 }; 464 465 /** Store details about uniform 466 * 467 **/ 468 struct uniformDetails 469 { 470 glw::GLuint m_array_stride; 471 glw::GLuint m_matrix_stride; 472 glw::GLuint m_offset; 473 }; 474 475 /* Provate methods */ 476 glw::GLenum getCapturedPrimitiveType(shaderStage shader_stage) const; 477 glw::GLenum getDrawPrimitiveType(shaderStage shader_stage) const; 478 glw::GLuint getMaxUniformComponents(shaderStage shader_stage) const; 479 glw::GLuint getMaxUniformBlockSize() const; 480 glw::GLuint getRequiredComponentsNumber(const uniformTypeDetails& uniform_type) const; 481 glw::GLuint getUniformTypeMemberSize(const uniformTypeDetails& uniform_type) const; 482 glw::GLuint getAmountUniforms(shaderStage shader_stage, const uniformTypeDetails& uniform_type) const; 483 const glw::GLchar* getShaderStageName(shaderStage shader_stage) const; 484 485 void inspectProgram(glw::GLuint program_id, glw::GLint n_uniforms, const uniformTypeDetails& uniform_type, 486 glw::GLint& out_buffer_size, uniformDetails& out_offsets, 487 glw::GLuint uniform_block_index) const; 488 489 void prepareBoilerplateShader(const glw::GLchar* stage_specific_layout, const glw::GLchar* stage_specific_main_body, 490 std::string& out_source_code) const; 491 492 void prepareProgram(shaderStage shader_stage, const uniformTypeDetails& uniform_type, 493 Utils::programInfo& out_program_info) const; 494 495 void prepareShaderStages(); 496 497 void prepareTestShader(const glw::GLchar* stage_specific_layout, const glw::GLchar* uniform_definitions, 498 const glw::GLchar* in_variable_definitions, const glw::GLchar* out_variable_definitions, 499 const glw::GLchar* uniform_verification, const glw::GLchar* stage_specific_main_body, 500 std::string& out_source_code) const; 501 502 void prepareTestComputeShader(const glw::GLchar* uniform_definitions, const glw::GLchar* uniform_verification, 503 std::string& out_source_code) const; 504 505 void prepareUniformDefinitions(shaderStage shader_stage, const uniformTypeDetails& uniform_type, 506 std::string& out_source_code) const; 507 508 void prepareUniforms(shaderStage shader_stage, const uniformTypeDetails& uniform_type, 509 const Utils::programInfo& program_info) const; 510 511 void prepareUniformTypes(); 512 513 void prepareUniformVerification(shaderStage shader_stage, const uniformTypeDetails& uniform_type, 514 std::string& out_source_code) const; 515 516 bool test(shaderStage shader_stage, const uniformTypeDetails& uniform_type) const; 517 518 void testBegin(glw::GLuint program_id, shaderStage shader_stage) const; 519 520 void testEnd(shaderStage shader_stage) const; 521 void testInit(); 522 bool verifyResults(shaderStage shader_stage) const; 523 524 /* Private constants */ 525 static const glw::GLuint m_n_captured_results; 526 static const glw::GLint m_result_failure; 527 static const glw::GLint m_result_success; 528 static const glw::GLuint m_texture_width; 529 static const glw::GLuint m_texture_height; 530 static const glw::GLuint m_transform_feedback_buffer_size; 531 532 static const glw::GLchar* m_uniform_block_name; 533 534 static const glw::GLenum ARB_MAX_COMPUTE_UNIFORM_COMPONENTS; 535 536 /* Private fields */ 537 arbDispatchComputeFunc m_pDispatchCompute; 538 539 std::vector<shaderStage> m_shader_stages; 540 std::vector<uniformTypeDetails> m_uniform_types; 541 542 glw::GLuint m_framebuffer_id; 543 glw::GLuint m_texture_id; 544 glw::GLuint m_transform_feedback_buffer_id; 545 glw::GLuint m_uniform_buffer_id; 546 glw::GLuint m_vertex_array_object_id; 547 }; 548 549 /** Implements "Subtest 3" from CTS_ARB_gpu_shader_fp64, description follows: 550 * 551 * Make sure it is possible to use new types for member declaration 552 * in a named uniform block. 553 * The following members should be defined in the block: 554 * 555 * ivec3 dummy1[3]; 556 * double double_value; 557 * bool dummy2; 558 * dvec2 dvec2_value; 559 * bvec3 dummy3; 560 * dvec3 dvec3_value; 561 * int dummy4[3]; 562 * dvec4 dvec4_value; 563 * bool dummy5; 564 * bool dummy6[2]; 565 * dmat2 dmat2_value; 566 * dmat3 dmat3_value; 567 * bool dummy7; 568 * dmat4 dmat4_value; 569 * dmat2x3 dmat2x3_value; 570 * uvec3 dummy8; 571 * dmat2x4 dmat2x4_value; 572 * dmat3x2 dmat3x2_value; 573 * bool dummy9; 574 * dmat3x4 dmat3x4_value; 575 * int dummy10; 576 * dmat4x2 dmat4x2_value; 577 * dmat4x3 dmat4x3_value; 578 * 579 * std140, packed and shared layout qualifiers should be tested 580 * separately. 581 * 582 * For the purpose of the test, a buffer object, storage of which 583 * is to be used for the uniform buffer, should be filled with 584 * predefined values at member-specific offsets. These values 585 * should then be read in each shader stage covered by the test 586 * and verified. 587 * 588 * For std140 layout qualifier, the test should additionally verify 589 * the offsets assigned by GL implementation are as per specification. 590 * 591 * The following shader stages should be defined for a program object 592 * to be used by the test: 593 * 594 * 1) Vertex shader stage; 595 * 2) Geometry shader stage; 596 * 3) Tessellation control shader stage; 597 * 4) Tessellation evaluation shader stage; 598 * 5) Fragment shader stage; 599 * 600 * Vertex shader stage should set a stage-specific bool variable to 601 * true if all uniform buffer members are assigned valid values, 602 * false otherwise. 603 * 604 * Geometry shader stage should take points on input and emit a single 605 * point. Similarly to vertex shader stage, it should set a stage-specific 606 * bool variable to true, if all uniform buffer members are determined 607 * to expose valid values, false otherwise. 608 * Geometry shader stage should pass the result value from the vertex 609 * shader stage down the rendering pipeline using a new output variable, 610 * set to the value of the variable exposed by vertex shader stage. 611 * 612 * Tessellation control shader stage should set all inner/outer 613 * tessellation levels to 1 and output 1 vertex per patch. 614 * The verification should be carried out as in previous stages. 615 * TC shader stage should also define stage-specific output variables 616 * for vertex and geometry shader stages and set them to relevant 617 * values, similar to what's been described for geometry shader stage. 618 * 619 * Tessellation evaluation shader stage should take quads on 620 * input. It should be constructed in a way that will make it 621 * generate a quad that occupies whole screen-space. This is necessary 622 * to perform validation of the input variables in fragment shader 623 * stage. 624 * The verification should be carried out as in previous stages. 625 * TE stage should pass down validation results from previous stages 626 * in a similar manner as was described for TC shader stage. 627 * 628 * Fragment shader stage should verify all the uniform buffer members 629 * carry valid values. Upon success, it should output vec4(1) to the 630 * only output variable. Otherwise, it should set it to vec4(0). 631 * 632 * XFB should be used to read all the output variables defined in TE 633 * stage that carry result information from all the rendering stages 634 * until tessellation evaluation shader stage. The test passes, if 635 * all result values are set to true and the draw buffer is filled 636 * with vec4(1). 637 **/ 638 class GPUShaderFP64Test3 : public deqp::TestCase 639 { 640 public: 641 /* Public methods */ 642 GPUShaderFP64Test3(deqp::Context&); 643 virtual ~GPUShaderFP64Test3() 644 { 645 } 646 647 /* Public methods inherited from TestCase */ 648 virtual void deinit(void); 649 virtual tcu::TestNode::IterateResult iterate(void); 650 651 private: 652 /* Private types */ 653 654 /** Enumerate shader stages 655 * 656 **/ 657 enum shaderStage 658 { 659 FRAGMENT_SHADER, 660 GEOMETRY_SHADER, 661 TESS_CONTROL_SHADER, 662 TESS_EVAL_SHADER, 663 VERTEX_SHADER, 664 }; 665 666 /** Enumerate buffer data layouts 667 * 668 **/ 669 enum uniformDataLayout 670 { 671 PACKED, 672 SHARED, 673 STD140, 674 }; 675 676 /** Store details about "double precision" uniforms 677 * 678 **/ 679 struct uniformDetails 680 { 681 uniformDetails(glw::GLint expected_std140_offset, const glw::GLchar* name, glw::GLuint n_columns, 682 glw::GLuint n_elements, const glw::GLchar* type_name) 683 : m_expected_std140_offset(expected_std140_offset) 684 , m_name(name) 685 , m_n_columns(n_columns) 686 , m_n_elements(n_elements) 687 , m_type_name(type_name) 688 { 689 /* Nothing to be done */ 690 } 691 692 glw::GLint m_expected_std140_offset; 693 const glw::GLchar* m_name; 694 glw::GLuint m_n_columns; 695 glw::GLuint m_n_elements; 696 const glw::GLchar* m_type_name; 697 }; 698 699 /** Store details about program object 700 * 701 **/ 702 struct programInfo 703 { 704 705 programInfo(); 706 707 void compile(deqp::Context& context, glw::GLuint shader_id, const glw::GLchar* shader_code) const; 708 709 void deinit(deqp::Context& context); 710 711 void init(deqp::Context& context, const std::vector<uniformDetails> m_uniform_details, 712 const glw::GLchar* fragment_shader_code, const glw::GLchar* geometry_shader_code, 713 const glw::GLchar* tesselation_control_shader_code, 714 const glw::GLchar* tesselation_evaluation_shader_code, const glw::GLchar* vertex_shader_code); 715 716 void link(deqp::Context& context) const; 717 718 static const glw::GLint m_invalid_uniform_offset; 719 static const glw::GLint m_invalid_uniform_matrix_stride; 720 static const glw::GLint m_non_matrix_uniform_matrix_stride; 721 722 glw::GLuint m_fragment_shader_id; 723 glw::GLuint m_geometry_shader_id; 724 glw::GLuint m_program_object_id; 725 glw::GLuint m_tesselation_control_shader_id; 726 glw::GLuint m_tesselation_evaluation_shader_id; 727 glw::GLuint m_vertex_shader_id; 728 729 glw::GLint m_buffer_size; 730 glw::GLuint m_uniform_block_index; 731 732 std::vector<glw::GLint> m_uniform_offsets; 733 std::vector<glw::GLint> m_uniform_matrix_strides; 734 }; 735 736 /* Private methods */ 737 glw::GLdouble getExpectedValue(glw::GLuint type_ordinal, glw::GLuint element) const; 738 const programInfo& getProgramInfo(uniformDataLayout uniform_data_layout) const; 739 const glw::GLchar* getUniformLayoutName(uniformDataLayout uniform_data_layout) const; 740 741 void prepareProgram(programInfo& program_info, uniformDataLayout uniform_data_layout) const; 742 743 bool prepareUniformBuffer(const programInfo& program_info, bool verify_offsets) const; 744 745 void testInit(); 746 bool test(uniformDataLayout uniform_data_layout) const; 747 bool verifyResults() const; 748 749 void writeMainBody(std::ostream& stream, shaderStage shader_stage) const; 750 751 void writePreamble(std::ostream& stream, shaderStage shader_stage) const; 752 753 void writeUniformBlock(std::ostream& stream, uniformDataLayout uniform_data_layout) const; 754 755 void writeVaryingDeclarations(std::ostream& stream, shaderStage shader_stage) const; 756 757 void writeVaryingPassthrough(std::ostream& stream, shaderStage shader_stage) const; 758 759 /* Private fields */ 760 /* Constants */ 761 static const glw::GLuint m_result_failure; 762 static const glw::GLuint m_result_success; 763 764 static const glw::GLchar* m_uniform_block_name; 765 static const glw::GLchar* m_uniform_block_instance_name; 766 767 static const glw::GLchar* m_varying_name_fs_out_fs_result; 768 static const glw::GLchar* m_varying_name_gs_fs_gs_result; 769 static const glw::GLchar* m_varying_name_gs_fs_tcs_result; 770 static const glw::GLchar* m_varying_name_gs_fs_tes_result; 771 static const glw::GLchar* m_varying_name_gs_fs_vs_result; 772 static const glw::GLchar* m_varying_name_tcs_tes_tcs_result; 773 static const glw::GLchar* m_varying_name_tcs_tes_vs_result; 774 static const glw::GLchar* m_varying_name_tes_gs_tcs_result; 775 static const glw::GLchar* m_varying_name_tes_gs_tes_result; 776 static const glw::GLchar* m_varying_name_tes_gs_vs_result; 777 static const glw::GLchar* m_varying_name_vs_tcs_vs_result; 778 779 /* GL objects */ 780 glw::GLuint m_color_texture_id; 781 glw::GLuint m_framebuffer_id; 782 glw::GLuint m_transform_feedback_buffer_id; 783 glw::GLuint m_uniform_buffer_id; 784 glw::GLuint m_vertex_array_object_id; 785 786 /* Random values used by getExpectedValue */ 787 glw::GLdouble m_base_element; 788 glw::GLdouble m_base_type_ordinal; 789 790 /* Program details, one per data layout */ 791 programInfo m_packed_program; 792 programInfo m_shared_program; 793 programInfo m_std140_program; 794 795 /* Storage for uniforms' details */ 796 std::vector<uniformDetails> m_uniform_details; 797 }; 798 799 /** Make sure glGetUniformdv() reports correct values, as assigned 800 * by corresponding glUniform*() functions, for the following 801 * uniform types: 802 * 803 * a) double; 804 * b) dvec2; 805 * c) dvec3; 806 * d) dvec4; 807 * e) Arrays of a)-d); 808 * f) a)-d) defined in single-dimensional arrays built of the same 809 * structure. 810 * 811 * These uniforms should be defined in the default uniform block, 812 * separately in each stage defined for the following program 813 * objects: 814 * 815 * a) A program object consisting of a fragment, geometry, tessellation 816 * control, tessellation evaluation, vertex shader stages. 817 * b) A program object consisting of a compute shader stage. 818 * 819 * If GL_ARB_program_interface_query is supported, the test should 820 * also verify that the following API functions work correctly with 821 * the described uniforms: 822 * 823 * - glGetProgramResourceiv() (query GL_TYPE and GL_ARRAY_SIZE 824 * properties of GL_UNIFORM interface 825 * for all uniforms); 826 * - glGetProgramResourceIndex() (use GL_UNIFORM interface) 827 * - glGetProgramResourceName() (use GL_UNIFORM interface) 828 * 829 * To verify the values returned by these functions, values returned 830 * by relevant glGetUniform*() API functions should be used as 831 * reference. 832 */ 833 class GPUShaderFP64Test4 : public deqp::TestCase 834 { 835 public: 836 /* Public methods */ 837 GPUShaderFP64Test4(deqp::Context& context); 838 839 virtual void deinit(); 840 virtual tcu::TestNode::IterateResult iterate(); 841 842 private: 843 /* Private type definitions */ 844 /* Defines a type used as a data container for one of the test cases */ 845 typedef std::pair<glw::GLint /* uniform location */, double* /* value(s) assigned */> uniform_value_pair; 846 847 /* Holds uniform locations & associated values. used by one of the test cases */ 848 struct _data 849 { 850 _data(); 851 852 double uniform_double; 853 double uniform_double_arr[2]; 854 double uniform_dvec2[2]; 855 double uniform_dvec2_arr[4]; 856 double uniform_dvec3[3]; 857 double uniform_dvec3_arr[6]; 858 double uniform_dvec4[4]; 859 double uniform_dvec4_arr[8]; 860 861 glw::GLint uniform_location_double; 862 glw::GLint uniform_location_double_arr[2]; 863 glw::GLint uniform_location_dvec2; 864 glw::GLint uniform_location_dvec2_arr[2]; 865 glw::GLint uniform_location_dvec3; 866 glw::GLint uniform_location_dvec3_arr[2]; 867 glw::GLint uniform_location_dvec4; 868 glw::GLint uniform_location_dvec4_arr[2]; 869 }; 870 871 /** Holds uniform location & properties information. Used by one of the test cases. */ 872 struct _program_interface_query_test_item 873 { 874 glw::GLint expected_array_size; 875 std::string name; 876 glw::GLenum expected_type; 877 glw::GLint location; 878 }; 879 880 /** Holds information on all uniforms defined for a single shader stage. */ 881 struct _stage_data 882 { 883 _data uniform_structure_arrays[2]; 884 _data uniforms; 885 }; 886 887 /* Private methods */ 888 void generateUniformValues(); 889 void initProgramObjects(); 890 void initTest(); 891 void initUniformValues(); 892 bool verifyProgramInterfaceQuerySupport(); 893 bool verifyUniformValues(); 894 895 /* Private declarations */ 896 bool m_has_test_passed; 897 char* m_uniform_name_buffer; 898 899 glw::GLuint m_cs_id; 900 glw::GLuint m_fs_id; 901 glw::GLuint m_gs_id; 902 glw::GLuint m_po_cs_id; 903 glw::GLuint m_po_noncs_id; 904 glw::GLuint m_tc_id; 905 glw::GLuint m_te_id; 906 glw::GLuint m_vs_id; 907 908 _stage_data m_data_cs; 909 _stage_data m_data_fs; 910 _stage_data m_data_gs; 911 _stage_data m_data_tc; 912 _stage_data m_data_te; 913 _stage_data m_data_vs; 914 }; 915 916 /** Make sure the following implicit conversion work correctly: 917 * 918 * a) int -> double; 919 * b) ivec2 -> dvec2; 920 * c) ivec3 -> dvec3; 921 * d) ivec4 -> dvec4; 922 * e) uint -> double; 923 * f) uvec2 -> dvec2; 924 * g) uvec3 -> dvec3; 925 * h) uvec4 -> dvec4; 926 * i) float -> double; 927 * j) vec2 -> dvec2; 928 * k) vec3 -> dvec3; 929 * l) vec4 -> dvec4; 930 * m) mat2 -> dmat2; 931 * n) mat3 -> dmat3; 932 * o) mat4 -> dmat4; 933 * p) mat2x3 -> dmat2x3; 934 * q) mat2x4 -> dmat2x4; 935 * r) mat3x2 -> dmat3x2; 936 * s) mat3x4 -> dmat3x4; 937 * t) max4x2 -> dmat4x2; 938 * u) mat4x3 -> dmat4x3; 939 * 940 * The test should also verify the following explicit conversions 941 * are supported (that is: when the right-side value is used as 942 * an argument to a constructor of left-side type): 943 * 944 * a) int -> double; 945 * b) uint -> double; 946 * c) float -> double; 947 * d) double -> int; 948 * e) double -> uint; 949 * f) double -> float; 950 * g) double -> bool; 951 * h) bool -> double; 952 * 953 * For each conversion, the test should create a program object and 954 * attach a vertex shader to it. 955 * The shader should define an uniform named "base_value", with 956 * its type dependent on the type defined left-side for particular 957 * case, as defined below: 958 * 959 * [base_value type: bool] 960 * bool 961 * 962 * [base_value type: double] 963 * double 964 * 965 * [base_value type: int] 966 * int, ivec2, ivec3, ivec4 967 * 968 * [base_value type: uint] 969 * uint, uvec2, uvec3, uvec4 970 * 971 * [base_value type: float] 972 * float, vec2, vec3, vec4, 973 * mat2, mat3, mat4, mat2x3, 974 * mat2x4, mat3x2, mat3x4, mat4x2, 975 * mat4x3 976 * 977 * For each tested pair, it should build the "source" value/vector/matrix 978 * by taking the value specified in uniform of the same type as the one 979 * that is to be used as source, and use it for zeroth component. First 980 * component should be larger by one, second component should be bigger 981 * by two, and so on. 982 * Once the source value/vector/matrix is defined, the casting operation 983 * should be performed, giving a "destination" value/vector/matrix of 984 * type as defined for particular case. 985 * The resulting value should be XFBed out to the test implementation. 986 * The comparison should be performed on CPU to ensure validity of 987 * the resulting data. 988 * 989 * A swizzling operator should be used where possible when setting 990 * the output variables to additionally check that swizzling works 991 * correctly for multi-component double-precision types. 992 * 993 * The program object should be used for the following base values: 994 * 995 * a) -25.12065 996 * b) 0.0 997 * c) 0.001 998 * d) 1.0 999 * e) 256.78901 1000 * 1001 * An epsilon of 1e-5 should be used for floating-point comparisons. 1002 **/ 1003 class GPUShaderFP64Test5 : public deqp::TestCase 1004 { 1005 public: 1006 /* Public methods */ 1007 GPUShaderFP64Test5(deqp::Context& context); 1008 1009 virtual void deinit(); 1010 virtual tcu::TestNode::IterateResult iterate(); 1011 1012 private: 1013 /* Private type definitions */ 1014 /* Defines swizzle operators used by shaders generated by the test */ 1015 enum _swizzle_type 1016 { 1017 SWIZZLE_TYPE_NONE, 1018 1019 SWIZZLE_TYPE_XWZY, 1020 SWIZZLE_TYPE_XZXY, 1021 SWIZZLE_TYPE_XZY, 1022 SWIZZLE_TYPE_XZYW, 1023 1024 SWIZZLE_TYPE_Y, 1025 SWIZZLE_TYPE_YX, 1026 SWIZZLE_TYPE_YXX, 1027 SWIZZLE_TYPE_YXXY, 1028 1029 SWIZZLE_TYPE_Z, 1030 SWIZZLE_TYPE_ZY, 1031 1032 SWIZZLE_TYPE_W, 1033 SWIZZLE_TYPE_WX, 1034 }; 1035 1036 /* Defines cast type to be used for specific test case */ 1037 enum _test_case_type 1038 { 1039 TEST_CASE_TYPE_EXPLICIT, 1040 TEST_CASE_TYPE_IMPLICIT, 1041 1042 /* Always last */ 1043 TEST_CASE_TYPE_UNKNOWN 1044 }; 1045 1046 /* Holds a complete description of a single test case */ 1047 struct _test_case 1048 { 1049 _test_case_type type; 1050 1051 Utils::_variable_type src_type; 1052 Utils::_variable_type dst_type; 1053 1054 std::string shader_body; 1055 }; 1056 1057 /* Private methods */ 1058 bool executeIteration(const _test_case& test_case); 1059 1060 void getSwizzleTypeProperties(_swizzle_type type, std::string* out_swizzle_string, unsigned int* out_n_components, 1061 unsigned int* out_component_order); 1062 1063 std::string getVertexShaderBody(const _test_case& test_case); 1064 void initIteration(_test_case& test_case); 1065 void initTest(); 1066 1067 bool verifyXFBData(const unsigned char* data_ptr, const _test_case& test_case); 1068 1069 void deinitInteration(); 1070 1071 /* Private declarations */ 1072 unsigned char* m_base_value_bo_data; 1073 glw::GLuint m_base_value_bo_id; 1074 bool m_has_test_passed; 1075 glw::GLint m_po_base_value_attribute_location; 1076 glw::GLint m_po_id; 1077 glw::GLuint m_vao_id; 1078 glw::GLint m_vs_id; 1079 glw::GLuint m_xfb_bo_id; 1080 unsigned int m_xfb_bo_size; 1081 1082 float m_base_values[5]; /* as per test spec */ 1083 _swizzle_type m_swizzle_matrix[4 /* max number of dst components */][4 /* max number of src components */]; 1084 }; 1085 1086 /** The test should verify it is a compilation error to perform the 1087 * following casts in the shader: 1088 * 1089 * a) int [2] -> double; 1090 * b) ivec2 [2] -> dvec2; 1091 * c) ivec3 [2] -> dvec3; 1092 * d) ivec4 [2] -> dvec4; 1093 * e) uint [2] -> double; 1094 * f) uvec2 [2] -> dvec2; 1095 * g) uvec3 [2] -> dvec3; 1096 * h) uvec4 [2] -> dvec4; 1097 * i) float [2] -> double; 1098 * j) vec2 [2] -> dvec2; 1099 * k) vec3 [2] -> dvec3; 1100 * l) vec4 [2] -> dvec4; 1101 * m) mat2 [2] -> dmat2; 1102 * n) mat3 [2] -> dmat3; 1103 * o) mat4 [2] -> dmat4; 1104 * p) mat2x3[2] -> dmat2x3; 1105 * q) mat2x4[2] -> dmat2x4; 1106 * r) mat3x2[2] -> dmat3x2; 1107 * s) mat3x4[2] -> dmat3x4; 1108 * t) mat4x2[2] -> dmat4x2; 1109 * u) mat4x3[2] -> dmat4x3; 1110 * 1111 * The test should also attempt to cast all types defined left-side 1112 * in a)-u) to structures, where the only variable embedded inside 1113 * the structure would be defined on the right-side of the test 1114 * case considered. 1115 * 1116 * The following shader stages should be considered for the purpose 1117 * of the test: 1118 * 1119 * 1) Fragment shader stage; 1120 * 2) Geometry shader stage; 1121 * 3) Tessellation control shader stage; 1122 * 4) Tessellation evaluation shader stage; 1123 * 5) Vertex shader stage; 1124 * 6) Compute shader stage; 1125 **/ 1126 class GPUShaderFP64Test6 : public deqp::TestCase 1127 { 1128 public: 1129 /* Public methods */ 1130 GPUShaderFP64Test6(deqp::Context& context); 1131 1132 virtual void deinit(); 1133 virtual tcu::TestNode::IterateResult iterate(); 1134 1135 private: 1136 /* Private type definitions */ 1137 1138 /* Holds a complete description of a single test case */ 1139 struct _test_case 1140 { 1141 unsigned int src_array_size; 1142 Utils::_variable_type src_type; 1143 Utils::_variable_type dst_type; 1144 1145 bool wrap_dst_type_in_structure; 1146 1147 std::string cs_shader_body; 1148 std::string fs_shader_body; 1149 std::string gs_shader_body; 1150 std::string tc_shader_body; 1151 std::string te_shader_body; 1152 std::string vs_shader_body; 1153 }; 1154 1155 /* Private methods */ 1156 bool executeIteration(const _test_case& test_case); 1157 std::string getComputeShaderBody(const _test_case& test_case); 1158 std::string getFragmentShaderBody(const _test_case& test_case); 1159 std::string getGeometryShaderBody(const _test_case& test_case); 1160 std::string getTessellationControlShaderBody(const _test_case& test_case); 1161 std::string getTessellationEvaluationShaderBody(const _test_case& test_case); 1162 std::string getVertexShaderBody(const _test_case& test_case); 1163 1164 void initTest(); 1165 void initIteration(_test_case& test_case); 1166 1167 /* Private declarations */ 1168 glw::GLuint m_cs_id; 1169 glw::GLuint m_fs_id; 1170 glw::GLuint m_gs_id; 1171 glw::GLuint m_tc_id; 1172 glw::GLuint m_te_id; 1173 glw::GLuint m_vs_id; 1174 1175 bool m_has_test_passed; 1176 }; 1177 1178 /** Make sure that double-precision types (double, dvec2, dvec3, 1179 * dvec4, dmat2, dmat3, dmat4, dmat2x3, dmat2x4, dmat3x2, dmat3x4, 1180 * dmat4x2, dmat4x2) and arrays of those: 1181 * 1182 * a) can be used as varyings (excl. vertex shader inputs *if* 1183 * GL_ARB_vertex_attrib_64bit support is *not* reported, and 1184 * fragment shader outputs; 'flat' layout qualifier should be 1185 * used for transferring data to fragment shader stage); 1186 * b) cannot be used as fragment shader output; (compilation error 1187 * expected). 1188 * c) cannot be used as fragment shader input if 'flat' layout 1189 * qualifier is missing) 1190 * 1191 * For case a), the following shader stages should be defined for 1192 * a single program object: 1193 * 1194 * 1) Vertex shader stage; 1195 * 2) Geometry shader stage; 1196 * 3) Tessellation control shader stage; 1197 * 4) Tessellation evaluation shader stage; 1198 * 5) Fragment shader stage; 1199 * 1200 * Vertex shader stage should define a single output variable for 1201 * each type considered. Each component of these output variables 1202 * should be set to predefined unique values. 1203 * Geometry shader stage should take points on input and emit a single 1204 * point. It should take all input variables from the previous stage, 1205 * add a predefined value to each component and pass it down the 1206 * rendering pipeline. 1207 * Tessellation control shader stage should set all inner/outer 1208 * tessellation levels to 1 and output 1 vertex per patch. 1209 * It should take all input variables from the previous stage, 1210 * add a predefined value to each component and pass it to 1211 * tessellation evaluation stage by using per-vertex outputs. 1212 * Tessellation evaluation shader stage should take quads on 1213 * input. It should also define all relevant input variables, as 1214 * defined by previous stage, add a predefined value to each 1215 * component and pass it to geometry shader stage. Finally, it 1216 * should be constructed in a way that will make it generate 1217 * a quad that occupies whole screen-space. This is necessary 1218 * to perform validation of the input variables in fragment shader 1219 * stage. 1220 * Fragment shader stage should take all inputs, as defined as 1221 * outputs in tessellation evaluation shader stage. It should 1222 * verify all the inputs carry valid values. Upon success, it 1223 * should output vec4(1) to the only output variable. Otherwise, 1224 * it should set it to vec4(0). 1225 **/ 1226 class GPUShaderFP64Test7 : public deqp::TestCase 1227 { 1228 public: 1229 /* Public methods */ 1230 GPUShaderFP64Test7(deqp::Context& context); 1231 1232 virtual void deinit(); 1233 virtual tcu::TestNode::IterateResult iterate(); 1234 1235 private: 1236 /* Private type definitions */ 1237 struct _variable 1238 { 1239 glw::GLint attribute_location; 1240 unsigned int array_size; 1241 Utils::_variable_type type; 1242 }; 1243 1244 typedef std::vector<_variable> _variables; 1245 typedef _variables::const_iterator _variables_const_iterator; 1246 1247 /* Private methods */ 1248 bool buildTestProgram(_variables& variables); 1249 bool compileShader(glw::GLint shader_id, const std::string& body); 1250 void configureXFBBuffer(const _variables& variables); 1251 bool executeFunctionalTest(_variables& variables); 1252 void generateXFBVaryingNames(const _variables& variables); 1253 1254 std::string getCodeOfFragmentShaderWithNonFlatDoublePrecisionInput(Utils::_variable_type input_variable_type, 1255 unsigned int array_size); 1256 1257 std::string getCodeOfFragmentShaderWithDoublePrecisionOutput(Utils::_variable_type output_variable_type, 1258 unsigned int array_size); 1259 1260 std::string getFragmentShaderBody(const _variables& variables); 1261 std::string getGeometryShaderBody(const _variables& variables); 1262 std::string getTessellationControlShaderBody(const _variables& variables); 1263 std::string getTessellationEvaluationShaderBody(const _variables& variables); 1264 1265 std::string getVariableDeclarations(const char* prefix, const _variables& variables, 1266 const char* layout_qualifier = ""); 1267 1268 std::string getVertexShaderBody(const _variables& variables); 1269 void initTest(); 1270 void logVariableContents(const _variables& variables); 1271 void releaseXFBVaryingNames(); 1272 void setInputAttributeValues(const _variables& variables); 1273 1274 /* Private declarations */ 1275 bool m_are_double_inputs_supported; 1276 std::string m_current_fs_body; 1277 std::string m_current_gs_body; 1278 std::string m_current_tc_body; 1279 std::string m_current_te_body; 1280 std::string m_current_vs_body; 1281 glw::GLuint m_fbo_id; 1282 glw::GLint m_fs_id; 1283 glw::GLint m_gs_id; 1284 bool m_has_test_passed; 1285 glw::GLint m_n_max_components_per_stage; 1286 unsigned int m_n_xfb_varyings; 1287 glw::GLint m_po_id; 1288 glw::GLint m_tc_id; 1289 glw::GLint m_te_id; 1290 glw::GLuint m_to_id; 1291 unsigned char* m_to_data; 1292 unsigned int m_to_height; 1293 unsigned int m_to_width; 1294 glw::GLuint m_xfb_bo_id; 1295 glw::GLchar** m_xfb_varyings; 1296 glw::GLuint m_vao_id; 1297 glw::GLint m_vs_id; 1298 }; 1299 1300 /** Make sure that all constructors valid for double-precision 1301 * vector/matrix types are accepted by the GLSL compiler for 1302 * all six shader stages. 1303 * 1304 * The test passes if all shaders compile successfully. 1305 **/ 1306 class GPUShaderFP64Test8 : public deqp::TestCase 1307 { 1308 public: 1309 /* Public methods */ 1310 GPUShaderFP64Test8(deqp::Context& context); 1311 1312 virtual void deinit(); 1313 virtual tcu::TestNode::IterateResult iterate(); 1314 1315 private: 1316 /* Private type definitions */ 1317 typedef std::vector<Utils::_variable_type> _argument_list; 1318 typedef _argument_list::const_iterator _argument_list_const_iterator; 1319 typedef std::vector<_argument_list> _argument_lists; 1320 typedef _argument_lists::const_iterator _argument_lists_const_iterator; 1321 1322 /* Holds a complete description of a single test case */ 1323 struct _argument_list_tree_node; 1324 1325 typedef std::vector<_argument_list_tree_node*> _argument_list_tree_nodes; 1326 typedef _argument_list_tree_nodes::const_iterator _argument_list_tree_nodes_const_iterator; 1327 typedef std::queue<_argument_list_tree_node*> _argument_list_tree_node_queue; 1328 1329 struct _argument_list_tree_node 1330 { 1331 _argument_list_tree_nodes children; 1332 int n_components_used; 1333 _argument_list_tree_node* parent; 1334 Utils::_variable_type type; 1335 1336 ~_argument_list_tree_node() 1337 { 1338 while (children.size() > 0) 1339 { 1340 _argument_list_tree_node* node_ptr = children.back(); 1341 1342 children.pop_back(); 1343 1344 delete node_ptr; 1345 node_ptr = NULL; 1346 } 1347 } 1348 }; 1349 1350 struct _test_case 1351 { 1352 _argument_list argument_list; 1353 Utils::_variable_type type; 1354 1355 std::string cs_shader_body; 1356 std::string fs_shader_body; 1357 std::string gs_shader_body; 1358 std::string tc_shader_body; 1359 std::string te_shader_body; 1360 std::string vs_shader_body; 1361 }; 1362 1363 /* Private methods */ 1364 bool executeIteration(const _test_case& test_case); 1365 _argument_lists getArgumentListsForVariableType(const Utils::_variable_type& variable_type); 1366 std::string getComputeShaderBody(const _test_case& test_case); 1367 std::string getFragmentShaderBody(const _test_case& test_case); 1368 std::string getGeneralBody(const _test_case& test_case); 1369 std::string getGeometryShaderBody(const _test_case& test_case); 1370 std::string getTessellationControlShaderBody(const _test_case& test_case); 1371 std::string getTessellationEvaluationShaderBody(const _test_case& test_case); 1372 std::string getVertexShaderBody(const _test_case& test_case); 1373 1374 void initTest(); 1375 void initIteration(_test_case& test_case); 1376 1377 /* Private declarations */ 1378 glw::GLuint m_cs_id; 1379 glw::GLuint m_fs_id; 1380 glw::GLuint m_gs_id; 1381 glw::GLuint m_tc_id; 1382 glw::GLuint m_te_id; 1383 glw::GLuint m_vs_id; 1384 1385 bool m_has_test_passed; 1386 }; 1387 1388 /** Make sure that the following operators work correctly for 1389 * double-precision floating-point scalars, vectors and matrices: 1390 * 1391 * a) + (addition) 1392 * b) - (subtraction) 1393 * c) * (multiplication) 1394 * d) / (division) 1395 * e) - (negation) 1396 * f) -- (pre-decrementation and post-decrementation) 1397 * g) ++ (pre-incrementation and post-incrementation) 1398 * 1399 * Furthermore, the following relational operators should also be 1400 * tested for double-precision floating-point expressions: 1401 * 1402 * a) < (less than) 1403 * b) <= (less than or equal) 1404 * c) > (greater than) 1405 * d) >= (greater than or equal) 1406 * 1407 * For each double-precision floating-point type, the test should 1408 * create a program object, to which it should then attach 1409 * a vertex shader, body of which was adjusted to handle case-specific 1410 * type. The shader should use all the operators and operations 1411 * described above. The result value should be XFBed out to the 1412 * test for verification. 1413 * 1414 * For relational operators, both cases described below should be 1415 * tested: 1416 * 1417 * a) fundamental type of the two operands should match without 1418 * any implicit type conversion involved in the process; 1419 * b) fundamental type of the two operands should match after an 1420 * implicit type conversion (use some of the casts enlisted for 1421 * test 6). 1422 * 1423 * The test passes if the returned set of values was correct for 1424 * all the types considered. Assume epsilon value of 1e-5. 1425 * 1426 **/ 1427 class GPUShaderFP64Test9 : public deqp::TestCase 1428 { 1429 public: 1430 /* Public methods */ 1431 GPUShaderFP64Test9(deqp::Context& context); 1432 1433 void deinit(); 1434 virtual tcu::TestNode::IterateResult iterate(); 1435 1436 private: 1437 /* Private type definitions */ 1438 typedef enum { 1439 OPERATION_TYPE_ADDITION, 1440 OPERATION_TYPE_DIVISION, 1441 OPERATION_TYPE_MULTIPLICATION, 1442 OPERATION_TYPE_SUBTRACTION, 1443 OPERATION_TYPE_PRE_DECREMENTATION, 1444 OPERATION_TYPE_PRE_INCREMENTATION, 1445 OPERATION_TYPE_POST_DECREMENTATION, 1446 OPERATION_TYPE_POST_INCREMENTATION, 1447 1448 /* Always last */ 1449 OPERATION_TYPE_COUNT 1450 } _operation_type; 1451 1452 struct _test_case 1453 { 1454 _operation_type operation_type; 1455 Utils::_variable_type result_variable_type; 1456 std::string vs_body; 1457 Utils::_variable_type variable_type; 1458 }; 1459 1460 /* Private methods */ 1461 bool executeTestIteration(const _test_case& test_case); 1462 1463 void getMatrixMultiplicationResult(const Utils::_variable_type& matrix_a_type, 1464 const std::vector<double>& matrix_a_data, 1465 const Utils::_variable_type& matrix_b_type, 1466 const std::vector<double>& matrix_b_data, double* out_result_ptr); 1467 1468 const char* getOperatorForOperationType(const _operation_type& operation_type); 1469 std::string getOperationTypeString(const _operation_type& operation_type); 1470 std::string getVertexShaderBody(_test_case& test_case); 1471 void initTest(); 1472 void initTestIteration(_test_case& test_case); 1473 1474 bool verifyXFBData(const _test_case& test_case, const unsigned char* xfb_data); 1475 1476 /* Private fields */ 1477 bool m_has_test_passed; 1478 glw::GLuint m_po_id; 1479 glw::GLuint m_xfb_bo_id; 1480 glw::GLuint m_vao_id; 1481 glw::GLuint m_vs_id; 1482 }; 1483 1484 /** Group class for GPU Shader FP64 conformance tests */ 1485 class GPUShaderFP64Tests : public deqp::TestCaseGroup 1486 { 1487 public: 1488 /* Public methods */ 1489 GPUShaderFP64Tests(deqp::Context& context); 1490 virtual ~GPUShaderFP64Tests() 1491 { 1492 } 1493 1494 virtual void init(void); 1495 1496 private: 1497 /* Private methods */ 1498 GPUShaderFP64Tests(const GPUShaderFP64Tests&); 1499 GPUShaderFP64Tests& operator=(const GPUShaderFP64Tests&); 1500 }; 1501 1502 } /* gl4cts namespace */ 1503 1504 #endif // _GL4CGPUSHADERFP64TESTS_HPP 1505
