1 #ifndef _GL4CENHANCEDLAYOUTSTESTS_HPP 2 #define _GL4CENHANCEDLAYOUTSTESTS_HPP 3 /*------------------------------------------------------------------------- 4 * OpenGL Conformance Test Suite 5 * ----------------------------- 6 * 7 * Copyright (c) 2015-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 gl4cEnhancedLayoutsTests.hpp 28 * \brief Declares test classes for "Enhanced Layouts" functionality. 29 */ /*-------------------------------------------------------------------*/ 30 31 #include "glcTestCase.hpp" 32 #include "glwDefs.hpp" 33 34 namespace tcu 35 { 36 class MessageBuilder; 37 } /* namespace tcu */ 38 39 namespace gl4cts 40 { 41 42 namespace EnhancedLayouts 43 { 44 namespace Utils 45 { 46 /** Represents data type 47 * 48 **/ 49 struct Type 50 { 51 public: 52 enum TYPES 53 { 54 Float, 55 Double, 56 Int, 57 Uint, 58 }; 59 60 /* Public methods */ 61 /* Functionality */ 62 std::vector<glw::GLubyte> GenerateData() const; 63 std::vector<glw::GLubyte> GenerateDataPacked() const; 64 glw::GLuint GetActualAlignment(glw::GLuint align, bool is_array) const; 65 glw::GLuint GetBaseAlignment(bool is_array) const; 66 std::string GetGLSLConstructor(const glw::GLvoid* data) const; 67 const glw::GLchar* GetGLSLTypeName() const; 68 glw::GLuint GetLocations(bool is_vs_input = false) const; 69 glw::GLuint GetSize(const bool is_std140 = false) const; 70 glw::GLenum GetTypeGLenum() const; 71 glw::GLuint GetNumComponents() const; 72 std::vector<glw::GLuint> GetValidComponents() const; 73 74 /* Public static routines */ 75 /* Functionality */ 76 static glw::GLuint CalculateStd140Stride(glw::GLuint alignment, glw::GLuint n_columns, 77 glw::GLuint n_array_elements); 78 79 static bool DoesTypeSupportMatrix(TYPES type); 80 81 static glw::GLuint GetActualOffset(glw::GLuint start_offset, glw::GLuint actual_alignment); 82 83 static Type GetType(TYPES basic_type, glw::GLuint n_columns, glw::GLuint n_rows); 84 85 static glw::GLuint GetTypeSize(TYPES type); 86 87 /* GL gets */ 88 static glw::GLenum GetTypeGLenum(TYPES type); 89 90 static bool CanTypesShareLocation(TYPES first, TYPES second); 91 92 /* Public fields */ 93 TYPES m_basic_type; 94 glw::GLuint m_n_columns; 95 glw::GLuint m_n_rows; 96 97 /* Public constants */ 98 static const Type _double; 99 static const Type dmat2; 100 static const Type dmat2x3; 101 static const Type dmat2x4; 102 static const Type dmat3x2; 103 static const Type dmat3; 104 static const Type dmat3x4; 105 static const Type dmat4x2; 106 static const Type dmat4x3; 107 static const Type dmat4; 108 static const Type dvec2; 109 static const Type dvec3; 110 static const Type dvec4; 111 static const Type _float; 112 static const Type _int; 113 static const Type ivec2; 114 static const Type ivec3; 115 static const Type ivec4; 116 static const Type mat2; 117 static const Type mat2x3; 118 static const Type mat2x4; 119 static const Type mat3x2; 120 static const Type mat3; 121 static const Type mat3x4; 122 static const Type mat4x2; 123 static const Type mat4x3; 124 static const Type mat4; 125 static const Type vec2; 126 static const Type vec3; 127 static const Type vec4; 128 static const Type uint; 129 static const Type uvec2; 130 static const Type uvec3; 131 static const Type uvec4; 132 }; 133 134 /** Represents buffer instance 135 * Provides basic buffer functionality 136 **/ 137 class Buffer 138 { 139 public: 140 /* Public enums */ 141 enum BUFFERS 142 { 143 Array, 144 Element, 145 Shader_Storage, 146 Texture, 147 Transform_feedback, 148 Uniform, 149 }; 150 151 enum USAGE 152 { 153 DynamicCopy, 154 DynamicDraw, 155 DynamicRead, 156 StaticCopy, 157 StaticDraw, 158 StaticRead, 159 StreamCopy, 160 StreamDraw, 161 StreamRead, 162 }; 163 164 enum ACCESS 165 { 166 ReadOnly, 167 WriteOnly, 168 ReadWrite, 169 }; 170 171 /* Public methods */ 172 /* Ctr & Dtr */ 173 Buffer(deqp::Context& context); 174 ~Buffer(); 175 176 /* Init & Release */ 177 void Init(BUFFERS buffer, USAGE usage, glw::GLsizeiptr size, glw::GLvoid* data); 178 void Release(); 179 180 /* Functionality */ 181 void Bind() const; 182 void BindBase(glw::GLuint index) const; 183 184 void BindRange(glw::GLuint index, glw::GLintptr offset, glw::GLsizeiptr size) const; 185 186 void Data(USAGE usage, glw::GLsizeiptr size, glw::GLvoid* data); 187 188 glw::GLvoid* Map(ACCESS access); 189 190 void SubData(glw::GLintptr offset, glw::GLsizeiptr size, glw::GLvoid* data); 191 192 void UnMap(); 193 194 /* Public static routines */ 195 /* Functionality */ 196 static void Bind(const glw::Functions& gl, glw::GLuint id, BUFFERS buffer); 197 198 static void BindBase(const glw::Functions& gl, glw::GLuint id, BUFFERS buffer, glw::GLuint index); 199 200 static void BindRange(const glw::Functions& gl, glw::GLuint id, BUFFERS buffer, glw::GLuint index, 201 glw::GLintptr offset, glw::GLsizeiptr size); 202 203 static void Data(const glw::Functions& gl, BUFFERS buffer, USAGE usage, glw::GLsizeiptr size, glw::GLvoid* data); 204 205 static void Generate(const glw::Functions& gl, glw::GLuint& out_id); 206 207 static void* Map(const glw::Functions& gl, BUFFERS buffer, ACCESS access); 208 209 static void SubData(const glw::Functions& gl, BUFFERS buffer, glw::GLintptr offset, glw::GLsizeiptr size, 210 glw::GLvoid* data); 211 212 static void UnMap(const glw::Functions& gl, BUFFERS buffer); 213 214 /* GL gets */ 215 static glw::GLenum GetAccessGLenum(ACCESS access); 216 static glw::GLenum GetBufferGLenum(BUFFERS buffer); 217 static glw::GLenum GetUsageGLenum(USAGE usage); 218 219 /* Gets */ 220 static const glw::GLchar* GetBufferName(BUFFERS buffer); 221 222 /* Public fields */ 223 glw::GLuint m_id; 224 225 /* Public constants */ 226 static const glw::GLuint m_invalid_id; 227 228 /* Buffer type maybe changed for different cases*/ 229 BUFFERS m_buffer; 230 231 private: 232 /* Private fields */ 233 deqp::Context& m_context; 234 }; 235 236 /** Represents framebuffer 237 * Provides basic functionality 238 **/ 239 class Framebuffer 240 { 241 public: 242 /* Public methods */ 243 /* Ctr & Dtr */ 244 Framebuffer(deqp::Context& context); 245 ~Framebuffer(); 246 247 /* Init & Release */ 248 void Init(); 249 void Release(); 250 251 /* Functionality */ 252 void AttachTexture(glw::GLenum attachment, glw::GLuint texture_id, glw::GLuint width, glw::GLuint height); 253 254 void Bind(); 255 void Clear(glw::GLenum mask); 256 257 void ClearColor(glw::GLfloat red, glw::GLfloat green, glw::GLfloat blue, glw::GLfloat alpha); 258 259 /* Public static routines */ 260 static void AttachTexture(const glw::Functions& gl, glw::GLenum attachment, glw::GLuint texture_id, 261 glw::GLuint width, glw::GLuint height); 262 263 static void Bind(const glw::Functions& gl, glw::GLuint id); 264 265 static void Clear(const glw::Functions& gl, glw::GLenum mask); 266 267 static void ClearColor(const glw::Functions& gl, glw::GLfloat red, glw::GLfloat green, glw::GLfloat blue, 268 glw::GLfloat alpha); 269 270 static void Generate(const glw::Functions& gl, glw::GLuint& out_id); 271 272 /* Public fields */ 273 glw::GLuint m_id; 274 275 /* Public constants */ 276 static const glw::GLuint m_invalid_id; 277 278 private: 279 /* Private fields */ 280 deqp::Context& m_context; 281 }; 282 283 /** Represents shader instance. 284 * Provides basic functionality for shaders. 285 **/ 286 class Shader 287 { 288 public: 289 /* Public enums */ 290 enum STAGES 291 { 292 COMPUTE = 0, 293 VERTEX, 294 TESS_CTRL, 295 TESS_EVAL, 296 GEOMETRY, 297 FRAGMENT, 298 299 /* */ 300 STAGE_MAX 301 }; 302 303 /* Public types */ 304 305 class InvalidSourceException : public std::exception 306 { 307 public: 308 InvalidSourceException(const glw::GLchar* error_message, const std::string& source, STAGES stage); 309 ~InvalidSourceException()310 virtual ~InvalidSourceException() throw() 311 { 312 } 313 314 virtual const char* what() const throw(); 315 316 void log(deqp::Context& context) const; 317 318 std::string m_message; 319 std::string m_source; 320 STAGES m_stage; 321 }; 322 323 /* Public methods */ 324 /* Ctr & Dtr */ 325 Shader(deqp::Context& context); 326 ~Shader(); 327 328 /* Init & Realese */ 329 void Init(STAGES stage, const std::string& source); 330 void Release(); 331 332 /* Public static routines */ 333 /* Functionality */ 334 static void Compile(const glw::Functions& gl, glw::GLuint id); 335 336 static void Create(const glw::Functions& gl, STAGES stage, glw::GLuint& out_id); 337 338 static void Source(const glw::Functions& gl, glw::GLuint id, const std::string& source); 339 340 /* GL gets */ 341 static glw::GLenum GetShaderStageGLenum(STAGES stage); 342 343 /* Get stage name */ 344 static const glw::GLchar* GetStageName(STAGES stage); 345 346 /* Logs sources */ 347 static void LogSource(deqp::Context& context, const std::string& source, STAGES stage); 348 349 /* Public fields */ 350 glw::GLuint m_id; 351 352 /* Public constants */ 353 static const glw::GLuint m_invalid_id; 354 355 private: 356 /* Private types */ 357 class CompilationException : public std::exception 358 { 359 public: 360 CompilationException(const glw::GLchar* message); 361 ~CompilationException()362 virtual ~CompilationException() throw() 363 { 364 } 365 366 virtual const char* what() const throw(); 367 368 std::string m_message; 369 }; 370 371 /* Private fields */ 372 deqp::Context& m_context; 373 }; 374 375 /* Forward declaration */ 376 struct Interface; 377 378 /** Represents GLSL variable 379 * 380 **/ 381 struct Variable 382 { 383 public: 384 /* Typedefs */ 385 typedef std::vector<Variable> Vector; 386 typedef std::vector<Variable*> PtrVector; 387 388 /* Enums */ 389 enum STORAGE 390 { 391 VARYING_INPUT, 392 VARYING_OUTPUT, 393 UNIFORM, 394 SSB, 395 MEMBER, 396 397 /* */ 398 STORAGE_MAX 399 }; 400 401 enum VARYING_DIRECTION 402 { 403 INPUT, 404 OUTPUT, 405 }; 406 407 enum FLAVOUR 408 { 409 BASIC, 410 ARRAY, 411 INDEXED_BY_INVOCATION_ID, 412 }; 413 414 /**/ 415 enum TYPE 416 { 417 BUILTIN, 418 INTERFACE, 419 }; 420 421 /* Types */ 422 struct Descriptor 423 { 424 /* */ 425 typedef std::vector<Descriptor> Vector; 426 427 /* */ 428 Descriptor(const glw::GLchar* name, const glw::GLchar* qualifiers, glw::GLint expected_component, 429 glw::GLint expected_location, const Type& type, glw::GLboolean normalized, 430 glw::GLuint n_array_elements, glw::GLint expected_stride_of_element, glw::GLuint offset); 431 432 Descriptor(const glw::GLchar* name, const glw::GLchar* qualifiers, glw::GLint expected_componenet, 433 glw::GLint expected_location, Interface* interface, glw::GLuint n_array_elements, 434 glw::GLint expected_stride_of_element, glw::GLuint offset); 435 436 /* */ 437 std::string GetDefinition(FLAVOUR flavour, STORAGE storage) const; 438 439 /* */ 440 glw::GLint m_expected_component; 441 glw::GLint m_expected_location; 442 glw::GLint m_expected_stride_of_element; 443 glw::GLuint m_n_array_elements; 444 std::string m_name; 445 glw::GLboolean m_normalized; 446 glw::GLuint m_offset; 447 std::string m_qualifiers; 448 449 TYPE m_type; 450 union { 451 Type m_builtin; 452 Interface* m_interface; 453 }; 454 }; 455 456 /* Constructors */ 457 template <typename T> Variablegl4cts::EnhancedLayouts::Utils::Variable458 Variable(const glw::GLchar* name, const glw::GLchar* qualifiers, glw::GLint expected_component, 459 glw::GLint expected_location, const Type& type, glw::GLboolean normalized, glw::GLuint n_array_elements, 460 glw::GLint expected_stride_of_element, glw::GLuint offset, const T* data, size_t data_size, 461 STORAGE storage) 462 : m_data((glw::GLvoid*)data) 463 , m_data_size(data_size) 464 , m_descriptor(name, qualifiers, expected_component, expected_location, type, normalized, n_array_elements, 465 expected_stride_of_element, offset) 466 , m_storage(storage) 467 { 468 } 469 470 template <typename T> Variablegl4cts::EnhancedLayouts::Utils::Variable471 Variable(const glw::GLchar* name, const glw::GLchar* qualifiers, glw::GLint expected_component, 472 glw::GLint expected_location, Interface* interface, glw::GLuint n_array_elements, 473 glw::GLint expected_stride_of_element, glw::GLuint offset, const T* data, size_t data_size, 474 STORAGE storage) 475 : m_data((glw::GLvoid*)data) 476 , m_data_size(data_size) 477 , m_descriptor(name, qualifiers, expected_component, expected_location, interface, n_array_elements, 478 expected_stride_of_element, offset) 479 , m_storage(storage) 480 { 481 } 482 483 Variable(const Variable& var); 484 485 /* Functionality */ 486 std::string GetDefinition(FLAVOUR flavour) const; 487 glw::GLuint GetSize() const; 488 glw::GLuint GetStride() const; 489 bool IsBlock() const; 490 bool IsStruct() const; 491 /* Static routines */ 492 static FLAVOUR GetFlavour(Shader::STAGES stage, VARYING_DIRECTION direction); 493 static std::string GetReference(const std::string& parent_name, const Descriptor& variable, FLAVOUR flavour, 494 glw::GLuint array_index); 495 496 /* Fields */ 497 glw::GLvoid* m_data; 498 size_t m_data_size; 499 Descriptor m_descriptor; 500 STORAGE m_storage; 501 502 /* Constants */ 503 static const glw::GLint m_automatic_location; 504 }; 505 506 /* Define the methods NAME, that will add new variable to VECTOR with STORAGE set */ 507 #define DEFINE_VARIABLE_CLASS(NAME, STORAGE, VECTOR) \ 508 template <typename T> \ 509 Variable* NAME(const glw::GLchar* name, const glw::GLchar* qualifiers, glw::GLint expected_component, \ 510 glw::GLint expected_location, const Type& type, glw::GLboolean normalized, \ 511 glw::GLuint n_array_elements, glw::GLint expected_stride_of_element, glw::GLuint offset, \ 512 const T* data, size_t data_size) \ 513 { \ 514 Variable* var = new Variable(name, qualifiers, expected_component, expected_location, type, normalized, \ 515 n_array_elements, expected_stride_of_element, offset, data, data_size, STORAGE); \ 516 if (0 == var) \ 517 { \ 518 TCU_FAIL("Memory allocation"); \ 519 } \ 520 VECTOR.push_back(var); \ 521 return VECTOR.back(); \ 522 } \ 523 \ 524 template <typename T> \ 525 Variable* NAME(const glw::GLchar* name, const glw::GLchar* qualifiers, glw::GLint expected_component, \ 526 glw::GLint expected_location, Interface* interface, glw::GLuint n_array_elements, \ 527 glw::GLint expected_stride_of_element, glw::GLuint offset, const T* data, size_t data_size) \ 528 { \ 529 Variable* var = new Variable(name, qualifiers, expected_component, expected_location, interface, \ 530 n_array_elements, expected_stride_of_element, offset, data, data_size, STORAGE); \ 531 if (0 == var) \ 532 { \ 533 TCU_FAIL("Memory allocation"); \ 534 } \ 535 VECTOR.push_back(var); \ 536 return VECTOR.back(); \ 537 } 538 539 /** Represents structures and block 540 * 541 **/ 542 struct Interface 543 { 544 public: 545 /* Typedefs */ 546 typedef std::vector<Interface> Vector; 547 typedef std::vector<Interface*> PtrVector; 548 549 /**/ 550 enum TYPE 551 { 552 STRUCT, 553 BLOCK 554 }; 555 556 /* Constructor */ 557 Interface(const glw::GLchar* name, TYPE type); 558 559 /* */ 560 Variable::Descriptor* Member(const glw::GLchar* name, const glw::GLchar* qualifiers, glw::GLint expected_component, 561 glw::GLint expected_location, const Type& type, glw::GLboolean normalized, 562 glw::GLuint n_array_elements, glw::GLint expected_stride_of_element, 563 glw::GLuint offset); 564 Variable::Descriptor* Member(const glw::GLchar* name, const glw::GLchar* qualifiers, glw::GLint expected_component, 565 glw::GLint expected_location, Interface* interface, glw::GLuint n_array_elements, 566 glw::GLint expected_stride_of_element, glw::GLuint offset); 567 568 /**/ 569 Variable::Descriptor* AddMember(const Variable::Descriptor& member); 570 571 std::string GetDefinition() const; 572 573 /**/ 574 Variable::Descriptor::Vector m_members; 575 std::string m_name; 576 TYPE m_type; 577 }; 578 579 struct ShaderInterface 580 { 581 ShaderInterface(Shader::STAGES stage); 582 583 DEFINE_VARIABLE_CLASS(Input, Variable::VARYING_INPUT, m_inputs) 584 DEFINE_VARIABLE_CLASS(Output, Variable::VARYING_OUTPUT, m_outputs) 585 DEFINE_VARIABLE_CLASS(Uniform, Variable::UNIFORM, m_uniforms) 586 DEFINE_VARIABLE_CLASS(SSB, Variable::SSB, m_ssb_blocks) 587 588 /**/ 589 std::string GetDefinitionsGlobals() const; 590 std::string GetDefinitionsInputs() const; 591 std::string GetDefinitionsOutputs() const; 592 std::string GetDefinitionsSSBs() const; 593 std::string GetDefinitionsUniforms() const; 594 595 std::string m_globals; 596 Variable::PtrVector m_inputs; 597 Variable::PtrVector m_outputs; 598 Variable::PtrVector m_uniforms; 599 Variable::PtrVector m_ssb_blocks; 600 601 Shader::STAGES m_stage; 602 }; 603 604 struct VaryingConnection 605 { 606 /* */ 607 typedef std::vector<VaryingConnection> Vector; 608 609 /* */ 610 VaryingConnection(Variable* in, Variable* out); 611 612 /* */ 613 Variable* m_in; 614 Variable* m_out; 615 }; 616 617 struct VaryingPassthrough 618 { 619 /* */ 620 void Add(Shader::STAGES stage, Variable* in, Variable* out); 621 622 VaryingConnection::Vector& Get(Shader::STAGES stage); 623 624 /**/ 625 VaryingConnection::Vector m_fragment; 626 VaryingConnection::Vector m_geometry; 627 VaryingConnection::Vector m_tess_ctrl; 628 VaryingConnection::Vector m_tess_eval; 629 VaryingConnection::Vector m_vertex; 630 }; 631 632 struct ProgramInterface 633 { 634 635 /* */ 636 ProgramInterface(); 637 ~ProgramInterface(); 638 639 /* */ 640 Interface* AddInterface(const glw::GLchar* name, Interface::TYPE type); 641 Interface* Block(const glw::GLchar* name); 642 Interface* GetBlock(const glw::GLchar* name); 643 ShaderInterface& GetShaderInterface(Shader::STAGES stage); 644 const ShaderInterface& GetShaderInterface(Shader::STAGES stage) const; 645 Interface* GetStructure(const glw::GLchar* name); 646 Interface* Structure(const glw::GLchar* name); 647 648 /**/ 649 std::string GetDefinitionsStructures() const; 650 std::string GetInterfaceForStage(Shader::STAGES stage) const; 651 652 /* */ 653 Interface* CloneBlockForStage(const Interface& block, Shader::STAGES stage, Variable::STORAGE storage, 654 const glw::GLchar* prefix); 655 void CloneVertexInterface(VaryingPassthrough& variable_pass); 656 657 /* */ 658 static const glw::GLchar* GetStagePrefix(Shader::STAGES stage, Variable::STORAGE storage); 659 660 /* */ 661 Interface::PtrVector m_structures; 662 Interface::PtrVector m_blocks; 663 664 ShaderInterface m_compute; 665 ShaderInterface m_vertex; 666 ShaderInterface m_tess_ctrl; 667 ShaderInterface m_tess_eval; 668 ShaderInterface m_geometry; 669 ShaderInterface m_fragment; 670 671 //Variable::Vector m_fragment_outputs; 672 //Variable::PtrVector m_captured_varyings; 673 674 private: 675 /* */ 676 void cloneVariableForStage(const Variable& variable, Shader::STAGES stage, const glw::GLchar* prefix, 677 VaryingPassthrough& varying_passthrough); 678 Variable* cloneVariableForStage(const Variable& variable, Shader::STAGES stage, Variable::STORAGE storage, 679 const glw::GLchar* prefix); 680 void replaceBinding(Variable& variable, Shader::STAGES stage); 681 }; 682 683 /** Represents program pipeline 684 * 685 **/ 686 class Pipeline 687 { 688 public: 689 /* Public methods */ 690 /* Ctr & Dtr */ 691 Pipeline(deqp::Context& context); 692 ~Pipeline(); 693 694 /* Init & Release */ 695 void Init(); 696 void Release(); 697 698 /* Functionality */ 699 void Bind(); 700 void UseProgramStages(glw::GLuint program_id, glw::GLenum stages); 701 702 /* Public static routines */ 703 /* Functionality */ 704 void Bind(const glw::Functions& gl, glw::GLuint id); 705 void UseProgramStages(const glw::Functions& gl, glw::GLuint id, glw::GLuint program_id, glw::GLenum stages); 706 707 /* Public fields */ 708 glw::GLuint m_id; 709 710 /* Public constants */ 711 static const glw::GLuint m_invalid_id; 712 713 private: 714 /* Private fields */ 715 deqp::Context& m_context; 716 }; 717 718 /** Represents program instance. 719 * Provides basic functionality 720 **/ 721 class Program 722 { 723 public: 724 /* Public types */ 725 class BuildException : public std::exception 726 { 727 public: 728 BuildException(const glw::GLchar* error_message, const std::string compute_shader, 729 const std::string fragment_shader, const std::string geometry_shader, 730 const std::string tess_ctrl_shader, const std::string tess_eval_shader, 731 const std::string vertex_shader); ~BuildException()732 virtual ~BuildException() throw() 733 { 734 } 735 736 virtual const char* what() const throw(); 737 738 void log(deqp::Context& context) const; 739 740 std::string m_error_message; 741 std::string m_compute_shader; 742 std::string m_fragment_shader; 743 std::string m_geometry_shader; 744 std::string m_tess_ctrl_shader; 745 std::string m_tess_eval_shader; 746 std::string m_vertex_shader; 747 }; 748 749 typedef std::vector<std::string> NameVector; 750 751 /* Public methods */ 752 /* Ctr & Dtr */ 753 Program(deqp::Context& context); 754 ~Program(); 755 756 /* Init & Release */ 757 void Init(const std::string& compute_shader, const std::string& fragment_shader, const std::string& geometry_shader, 758 const std::string& tessellation_control_shader, const std::string& tessellation_evaluation_shader, 759 const std::string& vertex_shader, const NameVector& captured_varyings, bool capture_interleaved, 760 bool is_separable); 761 762 void Init(const std::string& compute_shader, const std::string& fragment_shader, const std::string& geometry_shader, 763 const std::string& tessellation_control_shader, const std::string& tessellation_evaluation_shader, 764 const std::string& vertex_shader, bool is_separable); 765 766 void Release(); 767 768 /* Functionality */ 769 void GetActiveUniformsiv(glw::GLsizei count, const glw::GLuint* indices, glw::GLenum pname, 770 glw::GLint* params) const; 771 772 glw::GLint GetAttribLocation(const std::string& name) const; 773 774 void GetResource(glw::GLenum interface, glw::GLuint index, glw::GLenum property, glw::GLsizei buf_size, 775 glw::GLint* params) const; 776 777 glw::GLuint GetResourceIndex(const std::string& name, glw::GLenum interface) const; 778 779 void GetUniformIndices(glw::GLsizei count, const glw::GLchar** names, glw::GLuint* indices) const; 780 781 glw::GLint GetUniformLocation(const std::string& name) const; 782 void Use() const; 783 784 /* Public static routines */ 785 /* Functionality */ 786 static void Attach(const glw::Functions& gl, glw::GLuint program_id, glw::GLuint shader_id); 787 788 static void Capture(const glw::Functions& gl, glw::GLuint id, const NameVector& captured_varyings, 789 bool capture_interleaved); 790 791 static void Create(const glw::Functions& gl, glw::GLuint& out_id); 792 793 static void GetActiveUniformsiv(const glw::Functions& gl, glw::GLuint program_id, glw::GLsizei count, 794 const glw::GLuint* indices, glw::GLenum pname, glw::GLint* params); 795 796 static void GetUniformIndices(const glw::Functions& gl, glw::GLuint program_id, glw::GLsizei count, 797 const glw::GLchar** names, glw::GLuint* indices); 798 799 static void Link(const glw::Functions& gl, glw::GLuint id); 800 801 static void Uniform(const glw::Functions& gl, const Type& type, glw::GLsizei count, glw::GLint location, 802 const glw::GLvoid* data); 803 804 static void Use(const glw::Functions& gl, glw::GLuint id); 805 806 /* Get locations */ 807 static glw::GLint GetAttribLocation(const glw::Functions& gl, glw::GLuint id, const std::string& name); 808 809 static void GetResource(const glw::Functions& gl, glw::GLuint id, glw::GLenum interface, glw::GLuint index, 810 glw::GLenum property, glw::GLsizei buf_size, glw::GLint* params); 811 812 static glw::GLuint GetResourceIndex(const glw::Functions& gl, glw::GLuint id, const std::string& name, 813 glw::GLenum interface); 814 815 static glw::GLint GetUniformLocation(const glw::Functions& gl, glw::GLuint id, const std::string& name); 816 817 /* Public fields */ 818 glw::GLuint m_id; 819 820 Shader m_compute; 821 Shader m_fragment; 822 Shader m_geometry; 823 Shader m_tess_ctrl; 824 Shader m_tess_eval; 825 Shader m_vertex; 826 827 /* Public constants */ 828 static const glw::GLuint m_invalid_id; 829 830 private: 831 /* Private types */ 832 class LinkageException : public std::exception 833 { 834 public: 835 LinkageException(const glw::GLchar* error_message); 836 ~LinkageException()837 virtual ~LinkageException() throw() 838 { 839 } 840 841 virtual const char* what() const throw(); 842 843 std::string m_error_message; 844 }; 845 846 /* Private fields */ 847 deqp::Context& m_context; 848 }; 849 850 class Texture 851 { 852 public: 853 /* Public enums */ 854 enum TYPES 855 { 856 TEX_BUFFER, 857 TEX_2D, 858 TEX_2D_RECT, 859 TEX_2D_ARRAY, 860 TEX_3D, 861 TEX_CUBE, 862 TEX_1D, 863 TEX_1D_ARRAY, 864 }; 865 866 /* Public methods */ 867 /* Ctr & Dtr */ 868 Texture(deqp::Context& context); 869 ~Texture(); 870 871 /* Init & Release */ 872 void Init(TYPES tex_type, glw::GLuint width, glw::GLuint height, glw::GLuint depth, glw::GLenum internal_format, 873 glw::GLenum format, glw::GLenum type, glw::GLvoid* data); 874 875 void Init(glw::GLenum internal_format, glw::GLuint buffer_id); 876 877 void Release(); 878 879 /* Functionality */ 880 void Bind() const; 881 void Get(glw::GLenum format, glw::GLenum type, glw::GLvoid* out_data) const; 882 883 /* Public static routines */ 884 /* Functionality */ 885 static void Bind(const glw::Functions& gl, glw::GLuint id, TYPES tex_type); 886 887 static void Generate(const glw::Functions& gl, glw::GLuint& out_id); 888 889 static void Get(const glw::Functions& gl, TYPES tex_type, glw::GLenum format, glw::GLenum type, 890 glw::GLvoid* out_data); 891 892 static void Storage(const glw::Functions& gl, TYPES tex_type, glw::GLuint width, glw::GLuint height, 893 glw::GLuint depth, glw::GLenum internal_format); 894 895 static void TexBuffer(const glw::Functions& gl, glw::GLenum internal_format, glw::GLuint& buffer_id); 896 897 static void Update(const glw::Functions& gl, TYPES tex_type, glw::GLuint width, glw::GLuint height, 898 glw::GLuint depth, glw::GLenum format, glw::GLenum type, glw::GLvoid* data); 899 900 /* GL gets */ 901 static glw::GLenum GetTargetGLenum(TYPES tex_type); 902 903 /* Public fields */ 904 glw::GLuint m_id; 905 906 /* Public constants */ 907 static const glw::GLuint m_invalid_id; 908 909 private: 910 deqp::Context& m_context; 911 TYPES m_type; 912 }; 913 914 /** Represents Vertex array object 915 * Provides basic functionality 916 **/ 917 class VertexArray 918 { 919 public: 920 /* Public methods */ 921 /* Ctr & Dtr */ 922 VertexArray(deqp::Context& Context); 923 ~VertexArray(); 924 925 /* Init & Release */ 926 void Init(); 927 //void Init(const ProgramInterface& program_interface, 928 // glw::GLuint vertex_buffer, 929 // glw::GLuint index_buffer); 930 void Release(); 931 932 void Attribute(glw::GLuint index, const Type& type, glw::GLuint n_array_elements, glw::GLboolean normalized, 933 glw::GLsizei stride, const glw::GLvoid* pointer); 934 935 void Bind(); 936 937 /* Public static methods */ 938 static void AttribPointer(const glw::Functions& gl, glw::GLuint index, const Type& type, 939 glw::GLuint n_array_elements, glw::GLboolean normalized, glw::GLsizei stride, 940 const glw::GLvoid* pointer); 941 942 static void Bind(const glw::Functions& gl, glw::GLuint id); 943 944 static void Disable(const glw::Functions& gl, glw::GLuint index, const Type& type, glw::GLuint n_array_elements); 945 946 static void Divisor(const glw::Functions& gl, glw::GLuint index, glw::GLuint divisor); 947 948 static void Enable(const glw::Functions& gl, glw::GLuint index, const Type& type, glw::GLuint n_array_elements); 949 950 static void Generate(const glw::Functions& gl, glw::GLuint& out_id); 951 952 /* Public fields */ 953 glw::GLuint m_id; 954 955 /* Public constants */ 956 static const glw::GLuint m_invalid_id; 957 958 private: 959 deqp::Context& m_context; 960 }; 961 962 /* UniformN*v prototypes */ 963 typedef GLW_APICALL void(GLW_APIENTRY* uniformNdv)(glw::GLint, glw::GLsizei, const glw::GLdouble*); 964 typedef GLW_APICALL void(GLW_APIENTRY* uniformNfv)(glw::GLint, glw::GLsizei, const glw::GLfloat*); 965 typedef GLW_APICALL void(GLW_APIENTRY* uniformNiv)(glw::GLint, glw::GLsizei, const glw::GLint*); 966 typedef GLW_APICALL void(GLW_APIENTRY* uniformNuiv)(glw::GLint, glw::GLsizei, const glw::GLuint*); 967 typedef GLW_APICALL void(GLW_APIENTRY* uniformMatrixNdv)(glw::GLint, glw::GLsizei, glw::GLboolean, 968 const glw::GLdouble*); 969 typedef GLW_APICALL void(GLW_APIENTRY* uniformMatrixNfv)(glw::GLint, glw::GLsizei, glw::GLboolean, const glw::GLfloat*); 970 971 /* Public static methods */ 972 /* UniformN*v routine getters */ 973 uniformNdv getUniformNdv(const glw::Functions& gl, glw::GLuint n_rows); 974 uniformNfv getUniformNfv(const glw::Functions& gl, glw::GLuint n_rows); 975 uniformNiv getUniformNiv(const glw::Functions& gl, glw::GLuint n_rows); 976 uniformNuiv getUniformNuiv(const glw::Functions& gl, glw::GLuint n_rows); 977 uniformMatrixNdv getUniformMatrixNdv(const glw::Functions& gl, glw::GLuint n_columns, glw::GLuint n_rows); 978 uniformMatrixNfv getUniformMatrixNfv(const glw::Functions& gl, glw::GLuint n_columns, glw::GLuint n_rows); 979 980 /* Stuff */ 981 bool checkProgramInterface(const ProgramInterface& program_interface, Program& program, std::stringstream& stream); 982 983 bool isExtensionSupported(deqp::Context& context, const glw::GLchar* extension_name); 984 985 bool isGLVersionAtLeast(const glw::Functions& gl, glw::GLint required_major, glw::GLint required_minor); 986 987 void replaceToken(const glw::GLchar* token, size_t& search_position, const glw::GLchar* text, std::string& string); 988 989 void replaceAllTokens(const glw::GLchar* token, const glw::GLchar* text, std::string& string); 990 991 glw::GLuint roundUpToPowerOf2(glw::GLuint value); 992 993 void insertElementOfList(const glw::GLchar* element, const glw::GLchar* separator, size_t& search_position, 994 std::string& string); 995 996 void endList(const glw::GLchar* separator, size_t& search_position, std::string& string); 997 } /* Utils namespace */ 998 999 /** Base class for tests **/ 1000 class TestBase : public deqp::TestCase 1001 { 1002 public: 1003 /* Public methods */ 1004 TestBase(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description); 1005 ~TestBase()1006 virtual ~TestBase() 1007 { 1008 } 1009 1010 /* Public methods inherited from TestCase */ 1011 virtual tcu::TestNode::IterateResult iterate(void); 1012 1013 protected: 1014 /* Methods to be implemented by child class */ 1015 virtual std::string getTestCaseName(glw::GLuint test_case_index); 1016 virtual glw::GLuint getTestCaseNumber(); 1017 virtual bool testCase(glw::GLuint test_case_index) = 0; 1018 virtual void testInit(); 1019 1020 /* Routines avaiable for children */ 1021 glw::GLuint calculateStride(const Utils::Interface& interface) const; 1022 void generateData(const Utils::Interface& interface, glw::GLuint offset, std::vector<glw::GLubyte>& out_data) const; 1023 1024 glw::GLint getLastInputLocation(Utils::Shader::STAGES stage, const Utils::Type& type, glw::GLuint array_lenth, bool ignore_prev_stage); 1025 1026 glw::GLint getLastOutputLocation(Utils::Shader::STAGES stage, const Utils::Type& type, glw::GLuint array_lenth, bool ignore_next_stage); 1027 1028 Utils::Type getType(glw::GLuint index) const; 1029 std::string getTypeName(glw::GLuint index) const; 1030 glw::GLuint getTypesNumber() const; 1031 1032 bool isFlatRequired(Utils::Shader::STAGES stage, const Utils::Type& type, Utils::Variable::STORAGE storage, 1033 const bool coherent = false) const; 1034 1035 private: 1036 /* Private methods */ 1037 bool test(); 1038 }; 1039 1040 /** Base class for test doing Buffer alghorithm **/ 1041 class BufferTestBase : public TestBase 1042 { 1043 public: 1044 /* Public methods */ 1045 BufferTestBase(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description); 1046 ~BufferTestBase()1047 virtual ~BufferTestBase() 1048 { 1049 } 1050 1051 protected: 1052 /* */ 1053 struct bufferDescriptor 1054 { 1055 /* Typedefs */ 1056 typedef std::vector<bufferDescriptor> Vector; 1057 1058 /* Fileds */ 1059 std::vector<glw::GLubyte> m_expected_data; 1060 std::vector<glw::GLubyte> m_initial_data; 1061 glw::GLuint m_index; 1062 Utils::Buffer::BUFFERS m_target; 1063 1064 /* Constants */ 1065 static const glw::GLuint m_non_indexed; 1066 }; 1067 1068 class bufferCollection 1069 { 1070 public: 1071 struct pair 1072 { 1073 Utils::Buffer* m_buffer; 1074 bufferDescriptor* m_descriptor; 1075 }; 1076 1077 ~bufferCollection(); 1078 1079 typedef std::vector<pair> Vector; 1080 1081 Vector m_vector; 1082 }; 1083 1084 virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index); 1085 1086 virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors); 1087 1088 virtual void getCapturedVaryings(glw::GLuint test_case_index, Utils::Program::NameVector& captured_varyings, glw::GLint* xfb_components); 1089 1090 virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments, 1091 std::string& out_calculations); 1092 1093 virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage, 1094 std::string& out_interface); 1095 1096 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 1097 1098 virtual bool inspectProgram(glw::GLuint test_case_index, Utils::Program& program, std::stringstream& out_stream); 1099 1100 virtual bool testCase(glw::GLuint test_case_index); 1101 virtual bool verifyBuffers(bufferCollection& buffers); 1102 1103 private: 1104 void cleanBuffers(); 1105 std::string getShaderTemplate(Utils::Shader::STAGES stage); 1106 void prepareBuffer(Utils::Buffer& buffer, bufferDescriptor& descriptor); 1107 void prepareBuffers(bufferDescriptor::Vector& descriptors, bufferCollection& out_buffers); 1108 1109 /* */ 1110 }; 1111 1112 class NegativeTestBase : public TestBase 1113 { 1114 public: 1115 /* Public methods */ 1116 NegativeTestBase(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description); 1117 ~NegativeTestBase()1118 virtual ~NegativeTestBase() 1119 { 1120 } 1121 1122 protected: 1123 /* Methods to be implemented by child class */ 1124 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage) = 0; 1125 virtual bool isComputeRelevant(glw::GLuint test_case_index); 1126 virtual bool isFailureExpected(glw::GLuint test_case_index); 1127 virtual bool isSeparable(const glw::GLuint test_case_index); 1128 virtual bool testCase(glw::GLuint test_case_index); 1129 }; 1130 1131 /** Base class for test doing Texture algorithm **/ 1132 class TextureTestBase : public TestBase 1133 { 1134 public: 1135 /* Public methods */ 1136 TextureTestBase(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description); 1137 ~TextureTestBase()1138 virtual ~TextureTestBase() 1139 { 1140 } 1141 1142 protected: 1143 /* Methods to be implemented by child class */ 1144 virtual bool checkResults(glw::GLuint test_case_index, Utils::Texture& color_0); 1145 1146 virtual void executeDispatchCall(glw::GLuint test_case_index); 1147 virtual void executeDrawCall(glw::GLuint test_case_index); 1148 1149 virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1150 Utils::VaryingPassthrough& varying_passthrough); 1151 1152 virtual std::string getPassSnippet(glw::GLuint test_case_index, Utils::VaryingPassthrough& varying_passthrough, 1153 Utils::Shader::STAGES stage); 1154 1155 virtual std::string getVerificationSnippet(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1156 Utils::Shader::STAGES stage); 1157 1158 virtual bool isComputeRelevant(glw::GLuint test_case_index); 1159 virtual bool isDrawRelevant(glw::GLuint test_case_index); 1160 1161 virtual void prepareAttributes(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1162 Utils::Buffer& buffer, Utils::VertexArray& vao); 1163 1164 virtual void prepareAttribLocation(Utils::Program& program, Utils::ProgramInterface& program_interface); 1165 1166 virtual void prepareFragmentDataLoc(Utils::Program& program, Utils::ProgramInterface& program_interface); 1167 1168 virtual void prepareFramebuffer(Utils::Framebuffer& framebuffer, Utils::Texture& color_0_texture); 1169 1170 virtual void prepareImage(glw::GLint location, Utils::Texture& image_texture) const; 1171 1172 virtual void prepareSSBs(glw::GLuint test_case_index, Utils::ShaderInterface& si, Utils::Program& program, 1173 Utils::Buffer& buffer); 1174 1175 virtual void prepareSSBs(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1176 Utils::Program& program, Utils::Buffer& cs_buffer); 1177 1178 virtual void prepareSSBs(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1179 Utils::Program& program, Utils::Buffer& fs_buffer, Utils::Buffer& gs_buffer, 1180 Utils::Buffer& tcs_buffer, Utils::Buffer& tes_buffer, Utils::Buffer& vs_buffer); 1181 1182 virtual void prepareUniforms(glw::GLuint test_case_index, Utils::ShaderInterface& si, Utils::Program& program, 1183 Utils::Buffer& buffer); 1184 1185 virtual void prepareUniforms(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1186 Utils::Program& program, Utils::Buffer& cs_buffer); 1187 1188 virtual void prepareUniforms(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1189 Utils::Program& program, Utils::Buffer& fs_buffer, Utils::Buffer& gs_buffer, 1190 Utils::Buffer& tcs_buffer, Utils::Buffer& tes_buffer, Utils::Buffer& vs_buffer); 1191 1192 virtual void prepareUniforms(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1193 Utils::Program& fs_program, Utils::Program& gs_program, Utils::Program& tcs_program, 1194 Utils::Program& tes_program, Utils::Program& vs_program, Utils::Buffer& fs_buffer, 1195 Utils::Buffer& gs_buffer, Utils::Buffer& tcs_buffer, Utils::Buffer& tes_buffer, 1196 Utils::Buffer& vs_buffer); 1197 //virtual void prepareDrawPrograms (glw::GLuint test_case_index, 1198 // Utils::Program& fragment, 1199 // Utils::Program& geometry, 1200 // Utils::Program& tess_ctrl, 1201 // Utils::Program& tess_eval, 1202 // Utils::Program& vertex); 1203 virtual bool testCase(glw::GLuint test_case_index); 1204 virtual bool testMonolithic(glw::GLuint test_case_index); 1205 virtual bool testSeparable(glw::GLuint test_case_index); 1206 virtual bool useComponentQualifier(glw::GLuint test_case_index); 1207 virtual bool useMonolithicProgram(glw::GLuint test_case_index); 1208 1209 /* Protected constants */ 1210 static const glw::GLuint m_width; 1211 static const glw::GLuint m_height; 1212 1213 private: 1214 std::string getShaderSource(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1215 Utils::VaryingPassthrough& varying_passthrough, Utils::Shader::STAGES stage); 1216 1217 const glw::GLchar* getShaderTemplate(Utils::Shader::STAGES stage); 1218 1219 std::string getVariablePassthrough(const std::string& in_parent_name, 1220 const Utils::Variable::Descriptor& in_variable, 1221 Utils::Variable::FLAVOUR in_flavour, const std::string& out_parent_name, 1222 const Utils::Variable::Descriptor& out_variable, 1223 Utils::Variable::FLAVOUR out_flavour); 1224 1225 std::string getVariableVerification(const std::string& parent_name, const glw::GLvoid* data, 1226 const Utils::Variable::Descriptor& variable, Utils::Variable::FLAVOUR flavour); 1227 1228 void prepareSSB(Utils::Program& program, Utils::Variable& variable, Utils::Buffer& buffer); 1229 1230 void prepareUniform(Utils::Program& program, Utils::Variable& variable, Utils::Buffer& buffer); 1231 }; 1232 1233 /** Implementation of test APIConstantValues. Description follows: 1234 * 1235 * Test verifies values of the following constants are at least as specified: 1236 * - MAX_TRANSFORM_FEEDBACK_BUFFERS - 4, 1237 * - MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS - 64. 1238 **/ 1239 class APIConstantValuesTest : public deqp::TestCase 1240 { 1241 public: 1242 /* Public methods */ 1243 APIConstantValuesTest(deqp::Context& context); ~APIConstantValuesTest()1244 virtual ~APIConstantValuesTest() 1245 { 1246 } 1247 1248 /* Public methods inherited from TestCase */ 1249 virtual tcu::TestNode::IterateResult iterate(void); 1250 }; 1251 1252 /** Implementation of test APIErrors. Description follows: 1253 * 1254 * Test verifies that errors are generated as specified: 1255 * - GetProgramInterfaceiv should generate INVALID_OPERATION when 1256 * <programInterface> is TRANSFORM_FEEDBACK_BUFFER and <pname> is 1257 * MAX_NAME_LENGTH; 1258 * - GetProgramResourceIndex should generate INVALID_ENUM when 1259 * <programInterface> is TRANSFORM_FEEDBACK_BUFFER; 1260 * - GetProgramResourceName should generate INVALID_ENUM when 1261 * <programInterface> is TRANSFORM_FEEDBACK_BUFFER; 1262 **/ 1263 class APIErrorsTest : public deqp::TestCase 1264 { 1265 public: 1266 /* Public methods */ 1267 APIErrorsTest(deqp::Context& context); ~APIErrorsTest()1268 virtual ~APIErrorsTest() 1269 { 1270 } 1271 1272 /* Public methods inherited from TestCase */ 1273 virtual tcu::TestNode::IterateResult iterate(void); 1274 1275 private: 1276 void checkError(glw::GLenum expected_error, const glw::GLchar* message, bool& test_result); 1277 }; 1278 1279 /** Implementation of test GLSLContantValues. Description follows: 1280 * 1281 * Test verifies values of the following symbols: 1282 * 1283 * GL_ARB_enhanced_layouts, 1284 * gl_MaxTransformFeedbackBuffers, 1285 * gl_MaxTransformFeedbackInterleavedComponents. 1286 * 1287 * This test implements Texture algorithm. Test following code snippet: 1288 * 1289 * if (1 != GL_ARB_enhanced_layouts) 1290 * { 1291 * result = 0; 1292 * } 1293 * else if (MAX_TRANSFORM_FEEDBACK_BUFFERS 1294 * != gl_MaxTransformFeedbackBuffers) 1295 * { 1296 * result = 0; 1297 * } 1298 * else if (MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 1299 * != gl_MaxTransformFeedbackInterleavedComponents) 1300 * { 1301 * result = 0; 1302 * } 1303 **/ 1304 class GLSLContantValuesTest : public TextureTestBase 1305 { 1306 public: 1307 GLSLContantValuesTest(deqp::Context& context); ~GLSLContantValuesTest()1308 ~GLSLContantValuesTest() 1309 { 1310 } 1311 1312 protected: 1313 virtual std::string getVerificationSnippet(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1314 Utils::Shader::STAGES stage); 1315 1316 virtual bool isComputeRelevant(glw::GLuint test_case_index); 1317 }; 1318 1319 /** Implementation of test GLSLContantImmutablity. Description follows: 1320 * 1321 * Test verifies that values of the following symbols cannot be changed in 1322 * shader: 1323 * 1324 * GL_ARB_enhanced_layouts, 1325 * gl_MaxTransformFeedbackBuffers, 1326 * gl_MaxTransformFeedbackInterleavedComponents. 1327 * 1328 * Compile following code snippet: 1329 * 1330 * CONSTANT = 3; 1331 * 1332 * It is expected that compilation will fail. Test each shader stage 1333 * separately. Test each constant separately. 1334 **/ 1335 class GLSLContantImmutablityTest : public NegativeTestBase 1336 { 1337 public: 1338 /* Public methods */ 1339 GLSLContantImmutablityTest(deqp::Context& context); 1340 ~GLSLContantImmutablityTest()1341 virtual ~GLSLContantImmutablityTest() 1342 { 1343 } 1344 1345 protected: 1346 /* Methods to be implemented by child class */ 1347 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 1348 1349 virtual std::string getTestCaseName(glw::GLuint test_case_index); 1350 virtual glw::GLuint getTestCaseNumber(); 1351 virtual bool isComputeRelevant(glw::GLuint test_case_index); 1352 virtual void testInit(); 1353 1354 private: 1355 /* Private enums */ 1356 enum CONSTANTS 1357 { 1358 GL_ARB_ENHANCED_LAYOUTS, 1359 GL_MAX_XFB, 1360 GL_MAX_XFB_INT_COMP, 1361 1362 /* */ 1363 CONSTANTS_MAX, 1364 }; 1365 1366 /* Private types */ 1367 struct testCase 1368 { 1369 CONSTANTS m_constant; 1370 Utils::Shader::STAGES m_stage; 1371 }; 1372 1373 /* Private methods */ 1374 const glw::GLchar* getConstantName(CONSTANTS constant); 1375 1376 /* Private fields */ 1377 std::vector<testCase> m_test_cases; 1378 }; 1379 1380 /** Implementation of test GLSLConstantIntegralExpression. Description follows: 1381 * 1382 * Check that following symbols can be used as integral constant expressions: 1383 * 1384 * GL_ARB_enhanced_layouts, 1385 * gl_MaxTransformFeedbackBuffers, 1386 * gl_MaxTransformFeedbackInterleavedComponents. 1387 * 1388 * Test implement Texture algorithm. Test following code snippet: 1389 * 1390 * uniform uint goku [GL_ARB_enhanced_layouts / GOKU_DIV]; 1391 * uniform uint gohan[gl_MaxTransformFeedbackBuffers / GOHAN_DIV]; 1392 * uniform uint goten[gl_MaxTransformFeedbackInterleavedComponents / 1393 * GOTEN_DIV]; 1394 * 1395 * for (i = 0; i < goku.length; ++i) 1396 * goku_sum += goku[i]; 1397 * 1398 * for (i = 0; i < gohan.length; ++i) 1399 * gohan_sum += gohan[i]; 1400 * 1401 * for (i = 0; i < goten.length; ++i) 1402 * goten_sum += goten[i]; 1403 * 1404 * if ( (expected_goku_sum == goku_sum) && 1405 * (expected_gohan_sum == gohan_sum) && 1406 * (expected_goten_sum == goten_sum) ) 1407 * result = 1; 1408 * else 1409 * result = 0; 1410 * 1411 * Select DIV values so as array lengths are below 16. 1412 **/ 1413 class GLSLConstantIntegralExpressionTest : public TextureTestBase 1414 { 1415 public: 1416 /* Public methods */ 1417 GLSLConstantIntegralExpressionTest(deqp::Context& context); 1418 ~GLSLConstantIntegralExpressionTest()1419 virtual ~GLSLConstantIntegralExpressionTest() 1420 { 1421 } 1422 1423 protected: 1424 /* Protected methods */ 1425 virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1426 Utils::VaryingPassthrough& varying_passthrough); 1427 1428 virtual std::string getVerificationSnippet(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1429 Utils::Shader::STAGES stage); 1430 1431 virtual void prepareUniforms(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1432 Utils::Program& program, Utils::Buffer& cs_buffer); 1433 1434 virtual void prepareUniforms(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1435 Utils::Program& program, Utils::Buffer& fs_buffer, Utils::Buffer& gs_buffer, 1436 Utils::Buffer& tcs_buffer, Utils::Buffer& tes_buffer, Utils::Buffer& vs_buffer); 1437 1438 private: 1439 glw::GLint m_gohan_length; 1440 glw::GLint m_goten_length; 1441 }; 1442 1443 /** Implementation of test UniformBlockMemberOffsetAndAlign. Description follows: 1444 * 1445 * Test verifies that: 1446 * - offset and align qualifiers are respected for uniform block members, 1447 * - align qualifier is ignored if value is too small, 1448 * - align qualifier accepts values bigger than size of base type, 1449 * - manual and automatic offsets and alignments can be mixed. 1450 * 1451 * This test implement Texture algorithm. Test following code snippet: 1452 * 1453 * const int basic_size = sizeof(basic_type_of(type)); 1454 * const int type_size = sizeof(type); 1455 * const int type_align = roundUpToPowerOf2(type_size); 1456 * 1457 * layout (std140, offset = 0) uniform Block { 1458 * layout(align = 8 * basic_size) type at_first_offset; 1459 * layout(offset = type_size, align = basic_size / 2) 1460 * type at_second_offset; 1461 * layout(align = 2 * type_align) type at_third_offset; 1462 * layout(offset = 3 * type_align + type_size) 1463 * type at_fourth_offset; 1464 * type at_fifth_offset; 1465 * type at_sixth_offset[2]; 1466 * layout(align = 8 * basic_size) type at_eight_offset; 1467 * }; 1468 * 1469 * if ( (at_first_offset == at_eight_offset ) && 1470 * (at_second_offset == at_sixth_offset[1]) && 1471 * (at_third_offset == at_sixth_offset[0]) && 1472 * (at_fourth_offset == at_fifth_offset ) ) 1473 * result = 1; 1474 * else 1475 * result = 0; 1476 * 1477 * Additionally inspect program to verify that all block members: 1478 * - are reported, 1479 * - have correct offsets. 1480 * 1481 * Test should be executed for all types. 1482 **/ 1483 class UniformBlockMemberOffsetAndAlignTest : public TextureTestBase 1484 { 1485 public: 1486 /* Public methods */ 1487 UniformBlockMemberOffsetAndAlignTest(deqp::Context& context); 1488 ~UniformBlockMemberOffsetAndAlignTest()1489 virtual ~UniformBlockMemberOffsetAndAlignTest() 1490 { 1491 } 1492 1493 protected: 1494 /* Protected methods */ 1495 virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1496 Utils::VaryingPassthrough& varying_passthrough); 1497 1498 virtual std::string getTestCaseName(glw::GLuint test_case_index); 1499 virtual glw::GLuint getTestCaseNumber(); 1500 1501 virtual std::string getVerificationSnippet(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1502 Utils::Shader::STAGES stage); 1503 1504 private: 1505 std::vector<glw::GLubyte> m_data; 1506 }; 1507 1508 /** Implementation of test UniformBlockLayoutQualifierConflict. Description follows: 1509 * 1510 * Test verifies that offset and align can only be used on members of blocks 1511 * declared as std140. 1512 * 1513 * Test following code snippet with all shader stages: 1514 * 1515 * layout(QUALIFIER) uniform Block { 1516 * layout(offset = 16) vec4 boy; 1517 * layout(align = 48) vec4 man; 1518 * }; 1519 * 1520 * Test following block qualifiers and all types: 1521 * 1522 * default - meaning not declared by shader 1523 * std140, 1524 * shared, 1525 * packed. 1526 * 1527 * Qualifier std430 is not allowed for uniform blocks. 1528 * 1529 * Test expect that only case using std140 will compile and link successfully, 1530 * while the rest will fail to compile or link. 1531 **/ 1532 class UniformBlockLayoutQualifierConflictTest : public NegativeTestBase 1533 { 1534 public: 1535 /* Public methods */ 1536 UniformBlockLayoutQualifierConflictTest(deqp::Context& context); 1537 ~UniformBlockLayoutQualifierConflictTest()1538 virtual ~UniformBlockLayoutQualifierConflictTest() 1539 { 1540 } 1541 1542 protected: 1543 /* Methods to be implemented by child class */ 1544 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 1545 1546 virtual std::string getTestCaseName(glw::GLuint test_case_index); 1547 virtual glw::GLuint getTestCaseNumber(); 1548 1549 virtual bool isComputeRelevant(glw::GLuint test_case_index); 1550 virtual bool isFailureExpected(glw::GLuint test_case_index); 1551 virtual void testInit(); 1552 1553 private: 1554 /* Private enums */ 1555 enum QUALIFIERS 1556 { 1557 DEFAULT, 1558 STD140, 1559 SHARED, 1560 PACKED, 1561 1562 /* */ 1563 QUALIFIERS_MAX, 1564 }; 1565 1566 /* Private types */ 1567 struct testCase 1568 { 1569 QUALIFIERS m_qualifier; 1570 Utils::Shader::STAGES m_stage; 1571 }; 1572 1573 /* Private methods */ 1574 const glw::GLchar* getQualifierName(QUALIFIERS qualifier); 1575 1576 /* Private fields */ 1577 std::vector<testCase> m_test_cases; 1578 }; 1579 1580 /** Implementation of test UniformBlockMemberInvalidOffsetAlignment. Description follows: 1581 * 1582 * Test verifies that offset alignment rules are enforced. 1583 * 1584 * Declare uniform block, which contains following member declaration: 1585 * 1586 * layout(offset = X) type block_member 1587 * 1588 * Shader compilation is expected to fail for any X that is not a multiple of 1589 * the base alignment of type. 1590 * Test all offsets covering locations first and one before last: 1591 * 1592 * <0, sizeof(type)> 1593 * <MAX_UNIFORM_BLOCK_SIZE - 2 * sizeof(type), 1594 * MAX_UNIFORM_BLOCK_SIZE - sizeof(type)> 1595 * 1596 * Test all shader stages. Test all types. Each case should be tested 1597 * separately. 1598 **/ 1599 class UniformBlockMemberInvalidOffsetAlignmentTest : public NegativeTestBase 1600 { 1601 public: 1602 /* Public methods */ 1603 UniformBlockMemberInvalidOffsetAlignmentTest(deqp::Context& context); 1604 1605 UniformBlockMemberInvalidOffsetAlignmentTest(deqp::Context& context, const glw::GLchar* name, 1606 const glw::GLchar* description); 1607 ~UniformBlockMemberInvalidOffsetAlignmentTest()1608 virtual ~UniformBlockMemberInvalidOffsetAlignmentTest() 1609 { 1610 } 1611 1612 protected: 1613 /* Methods to be implemented by child class */ 1614 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 1615 1616 virtual std::string getTestCaseName(glw::GLuint test_case_index); 1617 virtual glw::GLuint getTestCaseNumber(); 1618 virtual glw::GLint getMaxBlockSize(); 1619 virtual bool isComputeRelevant(glw::GLuint test_case_index); 1620 virtual bool isFailureExpected(glw::GLuint test_case_index); 1621 virtual bool isStageSupported(Utils::Shader::STAGES stage); 1622 virtual void testInit(); 1623 1624 protected: 1625 /* Protected types */ 1626 struct testCase 1627 { 1628 glw::GLuint m_offset; 1629 bool m_should_fail; 1630 Utils::Shader::STAGES m_stage; 1631 Utils::Type m_type; 1632 }; 1633 1634 /* Protected fields */ 1635 std::vector<testCase> m_test_cases; 1636 }; 1637 1638 /** Implementation of test UniformBlockMemberOverlappingOffsets. Description follows: 1639 * 1640 * Test verifies that block members cannot overlap. 1641 * 1642 * Use following code snippet: 1643 * 1644 * layout (std140) uniform Block { 1645 * layout (offset = boy_offset) boy_type boy; 1646 * layout (offset = man_offset) man_type man; 1647 * }; 1648 * 1649 * It is expected that overlapping members will cause compilation failure. 1650 * 1651 * There are three cases to test: 1652 * 1653 * - when member is declared with the same offset as already declared 1654 * member, 1655 * - when member is declared with offset that lay in the middle of already 1656 * declared member, 1657 * - when member is declared with offset just before already declared 1658 * member and there is not enough space. 1659 * 1660 * Test all shader stages. Test all types. Test cases separately. 1661 * 1662 * Note that not all type combinations let to test all three cases, e.g. 1663 * vec4 and float. 1664 **/ 1665 class UniformBlockMemberOverlappingOffsetsTest : public NegativeTestBase 1666 { 1667 public: 1668 /* Public methods */ 1669 UniformBlockMemberOverlappingOffsetsTest(deqp::Context& context); 1670 1671 UniformBlockMemberOverlappingOffsetsTest(deqp::Context& context, const glw::GLchar* name, 1672 const glw::GLchar* description); 1673 ~UniformBlockMemberOverlappingOffsetsTest()1674 virtual ~UniformBlockMemberOverlappingOffsetsTest() 1675 { 1676 } 1677 1678 protected: 1679 /* Methods to be implemented by child class */ 1680 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 1681 1682 virtual std::string getTestCaseName(glw::GLuint test_case_index); 1683 virtual glw::GLuint getTestCaseNumber(); 1684 virtual bool isComputeRelevant(glw::GLuint test_case_index); 1685 virtual bool isStageSupported(Utils::Shader::STAGES stage); 1686 virtual void testInit(); 1687 1688 protected: 1689 /* Protected types */ 1690 struct testCase 1691 { 1692 glw::GLuint m_boy_offset; 1693 Utils::Type m_boy_type; 1694 glw::GLuint m_man_offset; 1695 Utils::Type m_man_type; 1696 Utils::Shader::STAGES m_stage; 1697 }; 1698 1699 /* Protected methods */ 1700 glw::GLuint gcd(glw::GLuint a, glw::GLuint b); 1701 glw::GLuint lcm(glw::GLuint a, glw::GLuint b); 1702 1703 /* Protected fields */ 1704 std::vector<testCase> m_test_cases; 1705 }; 1706 1707 /** Implementation of test UniformBlockMemberAlignNonPowerOf2. Description follows: 1708 * 1709 * Test verifies that align qualifier must use power of 2. 1710 * 1711 * Test following code snippet: 1712 * 1713 * layout (std140, offset = 8) uniform Block { 1714 * vec4 boy; 1715 * layout (align = man_alignment) type man; 1716 * }; 1717 * 1718 * It is expected that compilation will fail whenever man_alignment is not 1719 * a power of 2. 1720 * 1721 * Test all alignment in range <0, sizeof(dmat4)>. Test all shader stages. 1722 * Test all types. 1723 **/ 1724 class UniformBlockMemberAlignNonPowerOf2Test : public NegativeTestBase 1725 { 1726 public: 1727 /* Public methods */ 1728 UniformBlockMemberAlignNonPowerOf2Test(deqp::Context& context); 1729 1730 UniformBlockMemberAlignNonPowerOf2Test(deqp::Context& context, const glw::GLchar* name, 1731 const glw::GLchar* description); 1732 ~UniformBlockMemberAlignNonPowerOf2Test()1733 virtual ~UniformBlockMemberAlignNonPowerOf2Test() 1734 { 1735 } 1736 1737 protected: 1738 /* Methods to be implemented by child class */ 1739 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 1740 1741 virtual std::string getTestCaseName(glw::GLuint test_case_index); 1742 virtual glw::GLuint getTestCaseNumber(); 1743 virtual bool isComputeRelevant(glw::GLuint test_case_index); 1744 virtual bool isFailureExpected(glw::GLuint test_case_index); 1745 virtual bool isStageSupported(Utils::Shader::STAGES stage); 1746 virtual void testInit(); 1747 1748 protected: 1749 /* Protected types */ 1750 struct testCase 1751 { 1752 glw::GLuint m_alignment; 1753 Utils::Type m_type; 1754 bool m_should_fail; 1755 Utils::Shader::STAGES m_stage; 1756 }; 1757 1758 /* Protected methods */ 1759 bool isPowerOf2(glw::GLuint val); 1760 1761 /* Protected fields */ 1762 std::vector<testCase> m_test_cases; 1763 }; 1764 1765 /** Implementation of test UniformBlockAlignment. Description follows: 1766 * 1767 * UniformBlockAlignment 1768 * 1769 * Test verifies that align qualifier is applied to block members as specified. 1770 * 1771 * This test implements Texture algorithm. Test following code snippet: 1772 * 1773 * struct Data { 1774 * vec4 vector; 1775 * float scalar; 1776 * }; 1777 * 1778 * layout (std140, offset = 8, align = 64) uniform Block { 1779 * vec4 first; 1780 * Data second; 1781 * Data third[2]; 1782 * vec4 fourth[3]; 1783 * layout (align = 16) vec4 fifth[2]; 1784 * Data sixth; 1785 * }; 1786 * 1787 * Verify that all uniforms have correct values. Additionally inspect program 1788 * to check that all offsets are as expected. 1789 **/ 1790 class UniformBlockAlignmentTest : public TextureTestBase 1791 { 1792 public: 1793 /* Public methods */ 1794 UniformBlockAlignmentTest(deqp::Context& context); 1795 ~UniformBlockAlignmentTest()1796 virtual ~UniformBlockAlignmentTest() 1797 { 1798 } 1799 1800 protected: 1801 /* Protected methods */ 1802 virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1803 Utils::VaryingPassthrough& varying_passthrough); 1804 1805 private: 1806 std::vector<glw::GLubyte> m_data; 1807 }; 1808 1809 /** Implementation of test SSBMemberOffsetAndAlign. Description follows: 1810 * 1811 * Test verifies that: 1812 * - offset and align qualifiers are respected for shader storage block 1813 * members, 1814 * - align qualifier is ignored if value is too small, 1815 * - align qualifier accepts values bigger than size of base type, 1816 * - manual and automatic offsets and alignments can be mixed. 1817 * 1818 * Modify UniformBlockMemberOffsetAndAlign to test shader storage block instead 1819 * of uniform block. 1820 **/ 1821 class SSBMemberOffsetAndAlignTest : public TextureTestBase 1822 { 1823 public: 1824 /* Public methods */ 1825 SSBMemberOffsetAndAlignTest(deqp::Context& context); ~SSBMemberOffsetAndAlignTest()1826 virtual ~SSBMemberOffsetAndAlignTest() 1827 { 1828 } 1829 1830 protected: 1831 /* Protected methods */ 1832 virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1833 Utils::VaryingPassthrough& varying_passthrough); 1834 1835 virtual std::string getTestCaseName(glw::GLuint test_case_index); 1836 virtual glw::GLuint getTestCaseNumber(); 1837 1838 virtual std::string getVerificationSnippet(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 1839 Utils::Shader::STAGES stage); 1840 1841 virtual bool isDrawRelevant(glw::GLuint test_case_index); 1842 1843 private: 1844 std::vector<glw::GLubyte> m_data; 1845 }; 1846 1847 /** Implementation of test SSBLayoutQualifierConflict. Description follows: 1848 * 1849 * Test verifies that offset and align can only be used on members of blocks 1850 * declared as std140 or std430. 1851 * 1852 * Modify UniformBlockMemberOffsetAndAlign to test shader storage block instead 1853 * of uniform block. 1854 * 1855 * Qualifier std430 is allowed for shader storage blocks, it should be included 1856 * in test. It is expected that std430 case will build successfully. 1857 **/ 1858 class SSBLayoutQualifierConflictTest : public NegativeTestBase 1859 { 1860 public: 1861 /* Public methods */ 1862 SSBLayoutQualifierConflictTest(deqp::Context& context); 1863 ~SSBLayoutQualifierConflictTest()1864 virtual ~SSBLayoutQualifierConflictTest() 1865 { 1866 } 1867 1868 protected: 1869 /* Methods to be implemented by child class */ 1870 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 1871 1872 virtual std::string getTestCaseName(glw::GLuint test_case_index); 1873 virtual glw::GLuint getTestCaseNumber(); 1874 virtual bool isComputeRelevant(glw::GLuint test_case_index); 1875 virtual bool isFailureExpected(glw::GLuint test_case_index); 1876 virtual void testInit(); 1877 1878 private: 1879 /* Private enums */ 1880 enum QUALIFIERS 1881 { 1882 DEFAULT, 1883 STD140, 1884 STD430, 1885 SHARED, 1886 PACKED, 1887 1888 /* */ 1889 QUALIFIERS_MAX, 1890 }; 1891 1892 /* Private types */ 1893 struct testCase 1894 { 1895 QUALIFIERS m_qualifier; 1896 Utils::Shader::STAGES m_stage; 1897 }; 1898 1899 /* Private methods */ 1900 const glw::GLchar* getQualifierName(QUALIFIERS qualifier); 1901 bool isStageSupported(Utils::Shader::STAGES stage); 1902 1903 /* Private fields */ 1904 std::vector<testCase> m_test_cases; 1905 }; 1906 1907 /** Implementation of test SSBMemberInvalidOffsetAlignment. Description follows: 1908 * 1909 * Test verifies that offset alignment rules are enforced. 1910 * 1911 * Modify UniformBlockMemberInvalidOffsetAlignment to test shader 1912 * storage block against MAX_SHADER_STORAGE_BLOCK_SIZE instead of 1913 * uniform block 1914 **/ 1915 class SSBMemberInvalidOffsetAlignmentTest : public UniformBlockMemberInvalidOffsetAlignmentTest 1916 { 1917 public: 1918 /* Public methods */ 1919 SSBMemberInvalidOffsetAlignmentTest(deqp::Context& context); 1920 ~SSBMemberInvalidOffsetAlignmentTest()1921 virtual ~SSBMemberInvalidOffsetAlignmentTest() 1922 { 1923 } 1924 1925 protected: 1926 /* Methods to be implemented by child class */ 1927 virtual glw::GLint getMaxBlockSize(); 1928 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 1929 1930 virtual bool isStageSupported(Utils::Shader::STAGES stage); 1931 }; 1932 1933 /** Implementation of test SSBMemberOverlappingOffsets. Description follows: 1934 * 1935 * Test verifies that block members cannot overlap. 1936 * 1937 * Modify UniformBlockMemberOverlappingOffsets to test shader storage block 1938 * instead of uniform block. 1939 **/ 1940 class SSBMemberOverlappingOffsetsTest : public UniformBlockMemberOverlappingOffsetsTest 1941 { 1942 public: 1943 /* Public methods */ 1944 SSBMemberOverlappingOffsetsTest(deqp::Context& context); ~SSBMemberOverlappingOffsetsTest()1945 virtual ~SSBMemberOverlappingOffsetsTest() 1946 { 1947 } 1948 1949 protected: 1950 /* Methods to be implemented by child class */ 1951 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 1952 1953 virtual bool isStageSupported(Utils::Shader::STAGES stage); 1954 }; 1955 1956 /** Implementation of test SSBMemberAlignNonPowerOf2. Description follows: 1957 * 1958 * Test verifies that align qualifier must use power of 2. 1959 * 1960 * Modify UniformBlockMemberAlignNonPowerOf2 to test shader storage block 1961 * instead of uniform block. 1962 **/ 1963 class SSBMemberAlignNonPowerOf2Test : public UniformBlockMemberAlignNonPowerOf2Test 1964 { 1965 public: 1966 /* Public methods */ 1967 SSBMemberAlignNonPowerOf2Test(deqp::Context& context); 1968 ~SSBMemberAlignNonPowerOf2Test()1969 virtual ~SSBMemberAlignNonPowerOf2Test() 1970 { 1971 } 1972 1973 protected: 1974 /* Methods to be implemented by child class */ 1975 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 1976 1977 virtual bool isStageSupported(Utils::Shader::STAGES stage); 1978 }; 1979 1980 /** Implementation of test SSBAlignment. Description follows: 1981 * 1982 * Test verifies that align qualifier is applied to block members as specified. 1983 * 1984 * Modify UniformBlockAlignment to test shader storage block instead 1985 * of uniform block. 1986 **/ 1987 class SSBAlignmentTest : public TextureTestBase 1988 { 1989 public: 1990 /* Public methods */ 1991 SSBAlignmentTest(deqp::Context& context); 1992 ~SSBAlignmentTest()1993 virtual ~SSBAlignmentTest() 1994 { 1995 } 1996 1997 protected: 1998 /* Protected methods */ 1999 virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 2000 Utils::VaryingPassthrough& varying_passthrough); 2001 2002 virtual bool isDrawRelevant(glw::GLuint test_case_index); 2003 2004 private: 2005 std::vector<glw::GLubyte> m_data; 2006 }; 2007 2008 /** Implementation of test VaryingLocations. Description follows: 2009 * 2010 * Test verifies that "varying" locations are assigned as declared in shader. 2011 * 2012 * This test implements Texture algorithm. Use separate shader objects instead 2013 * of monolithic program. Test following code snippet: 2014 * 2015 * layout(location = 0) in type input_at_first_location; 2016 * layout(location = last_input) in type input_at_last_location; 2017 * layout(location = 1) out type output_at_first_location; 2018 * layout(location = last_output) out type output_at_last_location; 2019 * 2020 * output_at_first_location = input_at_first_location; 2021 * output_at_last_location = input_at_last_location; 2022 * 2023 * if ( (EXPECTED_VALUE == input_at_first_location) && 2024 * (EXPECTED_VALUE == input_at_last_location) ) 2025 * { 2026 * result = 1; 2027 * } 2028 * 2029 * Additionally inspect program to check that all locations are as expected. 2030 * 2031 * Test all types. Test all shader stages. 2032 **/ 2033 class VaryingLocationsTest : public TextureTestBase 2034 { 2035 public: 2036 VaryingLocationsTest(deqp::Context& context); 2037 2038 VaryingLocationsTest(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description); 2039 ~VaryingLocationsTest()2040 ~VaryingLocationsTest() 2041 { 2042 } 2043 2044 protected: 2045 /* Protected methods */ 2046 virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 2047 Utils::VaryingPassthrough& varying_passthrough); 2048 2049 virtual std::string getTestCaseName(glw::GLuint test_case_index); 2050 virtual glw::GLuint getTestCaseNumber(); 2051 virtual bool isComputeRelevant(glw::GLuint test_case_index); 2052 virtual bool useMonolithicProgram(glw::GLuint test_case_index); 2053 2054 /* To be implemented by children */ 2055 virtual void prepareShaderStage(Utils::Shader::STAGES stage, const Utils::Type& type, 2056 Utils::ProgramInterface& program_interface, 2057 Utils::VaryingPassthrough& varying_passthrough); 2058 2059 /* Protected methods */ 2060 std::string prepareGlobals(glw::GLint last_in_loc, glw::GLint last_out_loc); 2061 2062 /* Protected fields */ 2063 std::vector<glw::GLubyte> m_first_data; 2064 std::vector<glw::GLubyte> m_last_data; 2065 }; 2066 2067 /** Implementation of test VertexAttribLocations. Description follows: 2068 * 2069 * Test verifies that drawing operations provide vertex attributes at expected 2070 * locations. 2071 * 2072 * This test implements Texture algorithm. Use separate shader objects instead 2073 * of monolithic program. Tessellation stages are not necessary and can be 2074 * omitted. Test following code snippet: 2075 * 2076 * layout (location = 2) in uint vertex_index; 2077 * layout (location = 5) in uint instance_index; 2078 * 2079 * if ( (gl_VertexID == vertex_index) && 2080 * (gl_InstanceID == instance_index) ) 2081 * { 2082 * result = 1; 2083 * } 2084 * 2085 * Test following Draw* operations: 2086 * - DrawArrays, 2087 * - DrawArraysInstanced, 2088 * - DrawElements, 2089 * - DrawElementsBaseVertex, 2090 * - DrawElementsInstanced, 2091 * - DrawElementsInstancedBaseInstance, 2092 * - DrawElementsInstancedBaseVertex, 2093 * - DrawElementsInstancedBaseVertexBaseInstance. 2094 * 2095 * Number of drawn instances should be equal 4. base_vertex parameter should be 2096 * set to 4. base_instance should be set to 2. 2097 * 2098 * Values provided for "vertex_index" should match index of vertex. Values 2099 * provided for "instance_index" should match index of instance 2100 * (use VertexAttribDivisor). 2101 **/ 2102 class VertexAttribLocationsTest : public TextureTestBase 2103 { 2104 public: 2105 VertexAttribLocationsTest(deqp::Context& context); 2106 ~VertexAttribLocationsTest()2107 ~VertexAttribLocationsTest() 2108 { 2109 } 2110 2111 protected: 2112 /* Protected methods */ 2113 virtual void executeDrawCall(glw::GLuint test_case_index); 2114 2115 virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 2116 Utils::VaryingPassthrough& varying_passthrough); 2117 2118 virtual std::string getTestCaseName(glw::GLuint test_case_index); 2119 virtual glw::GLuint getTestCaseNumber(); 2120 2121 virtual std::string getVerificationSnippet(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 2122 Utils::Shader::STAGES stage); 2123 2124 virtual bool isComputeRelevant(glw::GLuint test_case_index); 2125 2126 virtual void prepareAttributes(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 2127 Utils::Buffer& buffer, Utils::VertexArray& vao); 2128 2129 virtual bool useMonolithicProgram(glw::GLuint test_case_index); 2130 2131 private: 2132 /* Private enums */ 2133 enum TESTCASES 2134 { 2135 DRAWARRAYS, 2136 DRAWARRAYSINSTANCED, 2137 DRAWELEMENTS, 2138 DRAWELEMENTSBASEVERTEX, 2139 DRAWELEMENTSINSTANCED, 2140 DRAWELEMENTSINSTANCEDBASEINSTANCE, 2141 DRAWELEMENTSINSTANCEDBASEVERTEX, 2142 DRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCE, 2143 2144 /* */ 2145 TESTCASES_MAX 2146 }; 2147 2148 /* Private constants */ 2149 static const glw::GLuint m_base_vertex; 2150 static const glw::GLuint m_base_instance; 2151 static const glw::GLuint m_loc_vertex; 2152 static const glw::GLuint m_loc_instance; 2153 static const glw::GLuint m_n_instances; 2154 }; 2155 2156 /** Implementation of test VaryingArrayLocations. Description follows: 2157 * 2158 * VaryingArrayLocations 2159 * 2160 * Test verifies that locations of arrays of "varying" are assigned as declared 2161 * in shader. 2162 * 2163 * This test implements Texture algorithm. Use separate shader objects instead 2164 * of monolithic program. Test following code snippet: 2165 * 2166 * layout(location = 0) in type in_at_first_loc[FIRST_LENGTH]; 2167 * layout(location = last_input) in type in_at_last_loc[LAST_LENGTH]; 2168 * layout(location = 1) out type out_at_first_loc[FIRST_LENGTH]; 2169 * layout(location = last_output) out type out_at_last_loc[LAST_LENGTH]; 2170 * 2171 * for (uint i = 0u; i < in_at_first_loc.length(); ++i) 2172 * { 2173 * out_at_first_loc[i] = in_at_first_loc[i]; 2174 * 2175 * if (EXPECTED_VALUE[i] != in_at_first_loc[i]) 2176 * { 2177 * result = 0; 2178 * } 2179 * } 2180 * 2181 * for (uint i = 0u; i < in_at_last_loc.length(); ++i) 2182 * { 2183 * out_at_last_loc[i] = in_at_last_loc[i]; 2184 * 2185 * if (EXPECTED_VALUE[i] != in_at_last_loc[i]) 2186 * { 2187 * result = 0; 2188 * } 2189 * } 2190 * 2191 * FIRST_LENGTH and LAST_LENGTH values should be selected so as not to exceed 2192 * limits. 2193 * 2194 * Additionally inspect program to check that all locations are as expected. 2195 * 2196 * Test all types. Test all shader stages. 2197 **/ 2198 class VaryingArrayLocationsTest : public VaryingLocationsTest 2199 { 2200 public: 2201 VaryingArrayLocationsTest(deqp::Context& context); 2202 ~VaryingArrayLocationsTest()2203 ~VaryingArrayLocationsTest() 2204 { 2205 } 2206 2207 protected: 2208 /* Protected methods */ 2209 virtual void prepareShaderStage(Utils::Shader::STAGES stage, const Utils::Type& type, 2210 Utils::ProgramInterface& program_interface, 2211 Utils::VaryingPassthrough& varying_passthrough); 2212 }; 2213 2214 /** Implementation of test VaryingStructureLocations. Description follows: 2215 * 2216 * Test verifies that structures locations are as expected. 2217 * 2218 * This test implements Texture algorithm. Use separate shader objects instead 2219 * of monolithic program. Test following code snippet: 2220 * 2221 * struct Data 2222 * { 2223 * type single; 2224 * type array[ARRAY_LENGTH]; 2225 * }; 2226 * 2227 * layout (location = INPUT_LOCATION) in Data input[VARYING_LENGTH]; 2228 * layout (location = OUTPUT_LOCATION) out Data output[VARYING_LENGTH]; 2229 * 2230 * if ( (EXPECTED_VALUE == input[0].single) && 2231 * (EXPECTED_VALUE == input[0].array[0]) && 2232 * (EXPECTED_VALUE == input[0].array[last]) && 2233 * (EXPECTED_VALUE == input[last].single) && 2234 * (EXPECTED_VALUE == input[last].array[0]) && 2235 * (EXPECTED_VALUE == input[last].array[last]) ) 2236 * { 2237 * result = 1; 2238 * } 2239 * 2240 * output[0].single = input[0].single; 2241 * output[0].array[0] = input[0].array[0]; 2242 * output[0].array[last] = input[0].array[last]; 2243 * output[last].single = input[last].single; 2244 * output[last].array[0] = input[last].array[0]; 2245 * output[last].array[last] = input[last].array[last]; 2246 * 2247 * Select array lengths and locations so as no limits are exceeded. 2248 **/ 2249 2250 class VaryingStructureLocationsTest : public TextureTestBase 2251 { 2252 public: 2253 VaryingStructureLocationsTest(deqp::Context& context); 2254 ~VaryingStructureLocationsTest()2255 ~VaryingStructureLocationsTest() 2256 { 2257 } 2258 2259 protected: 2260 /* Protected methods */ 2261 virtual std::string getPassSnippet(glw::GLuint test_case_index, Utils::VaryingPassthrough& varying_passthrough, 2262 Utils::Shader::STAGES stage); 2263 2264 virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 2265 Utils::VaryingPassthrough& varying_passthrough); 2266 2267 virtual std::string getTestCaseName(glw::GLuint test_case_index); 2268 virtual glw::GLuint getTestCaseNumber(); 2269 virtual bool isComputeRelevant(glw::GLuint test_case_index); 2270 virtual bool useMonolithicProgram(glw::GLuint test_case_index); 2271 2272 /* Protected fields */ 2273 std::vector<glw::GLubyte> m_single_data; 2274 std::vector<glw::GLubyte> m_array_data; 2275 std::vector<glw::GLubyte> m_data; 2276 }; 2277 2278 /** Implementation of test VaryingStructureMemberLocation. Description follows: 2279 * 2280 * Test verifies that it is not allowed to declare structure member at specific 2281 * location. 2282 * 2283 * Test following code snippet: 2284 * 2285 * struct Data 2286 * { 2287 * vec4 gohan; 2288 * layout (location = LOCATION) vec4 goten; 2289 * } 2290 * 2291 * in Data goku; 2292 * 2293 * Select LOCATION so as not to exceed limits. Test all shader stages. Test 2294 * both in and out varyings. 2295 * 2296 * It is expected that compilation will fail. 2297 **/ 2298 class VaryingStructureMemberLocationTest : public NegativeTestBase 2299 { 2300 public: 2301 VaryingStructureMemberLocationTest(deqp::Context& context); 2302 ~VaryingStructureMemberLocationTest()2303 ~VaryingStructureMemberLocationTest() 2304 { 2305 } 2306 2307 protected: 2308 /* Methods to be implemented by child class */ 2309 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 2310 2311 virtual std::string getTestCaseName(glw::GLuint test_case_index); 2312 virtual glw::GLuint getTestCaseNumber(); 2313 virtual bool isComputeRelevant(glw::GLuint test_case_index); 2314 virtual void testInit(); 2315 2316 private: 2317 /* Private types */ 2318 struct testCase 2319 { 2320 bool m_is_input; 2321 Utils::Shader::STAGES m_stage; 2322 }; 2323 2324 /* Private fields */ 2325 std::vector<testCase> m_test_cases; 2326 }; 2327 2328 /** Implementation of test VaryingBlockLocations. Description follows: 2329 * 2330 * Test verifies that "block varyings" locations are as expected. 2331 * 2332 * This test implements Texture algorithm. Use separate shader objects instead 2333 * of monolithic program. Test following code snippet: 2334 * 2335 * layout (location = GOKU_LOCATION) in Goku 2336 * { 2337 * vec4 gohan; 2338 * layout (location = GOTEN_LOCATION) vec4 goten; 2339 * vec4 chichi; 2340 * }; 2341 * 2342 * layout (location = VEGETA_LOCATION) out Vegeta 2343 * { 2344 * vec4 trunks; 2345 * layout (location = BRA_LOCATION) vec4 bra; 2346 * vec4 bulma; 2347 * }; 2348 * 2349 * if ( (EXPECTED_VALUE == gohan) && 2350 * (EXPECTED_VALUE == goten) && 2351 * (EXPECTED_VALUE == chichi) ) 2352 * { 2353 * result = 1; 2354 * } 2355 * 2356 * trunks = gohan; 2357 * bra = goten; 2358 * bulma = chichi; 2359 * 2360 * Select all locations so as not to cause any conflicts or exceed limits. 2361 **/ 2362 class VaryingBlockLocationsTest : public TextureTestBase 2363 { 2364 public: 2365 VaryingBlockLocationsTest(deqp::Context& context); ~VaryingBlockLocationsTest()2366 ~VaryingBlockLocationsTest() 2367 { 2368 } 2369 2370 protected: 2371 /* Protected methods */ 2372 virtual std::string getPassSnippet(glw::GLuint test_case_index, Utils::VaryingPassthrough& varying_passthrough, 2373 Utils::Shader::STAGES stage); 2374 2375 virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 2376 Utils::VaryingPassthrough& varying_passthrough); 2377 2378 virtual bool isComputeRelevant(glw::GLuint test_case_index); 2379 virtual bool useMonolithicProgram(glw::GLuint test_case_index); 2380 2381 /* Protected fields */ 2382 std::vector<glw::GLubyte> m_third_data; 2383 std::vector<glw::GLubyte> m_fourth_data; 2384 std::vector<glw::GLubyte> m_fifth_data; 2385 std::vector<glw::GLubyte> m_data; 2386 }; 2387 2388 /** Implementation of test VaryingBlockMemberLocations. Description follows: 2389 * 2390 * Test verifies that it is a compilation error to declare some of block 2391 * members with location qualifier, but not all, when there is no "block level" 2392 * location qualifier. 2393 * 2394 * Test following code snippets: 2395 * 2396 * in Goku 2397 * { 2398 * vec4 gohan; 2399 * layout (location = GOTEN_LOCATION) vec4 goten; 2400 * vec4 chichi; 2401 * }; 2402 * 2403 * , 2404 * 2405 * in Goku 2406 * { 2407 * layout (location = GOHAN_LOCATION) vec4 gohan; 2408 * layout (location = GOTEN_LOCATION) vec4 goten; 2409 * layout (location = CHICHI_LOCATION) vec4 chichi; 2410 * }; 2411 * 2412 * Select all locations so as not to exceed any limits. 2413 * 2414 * It is expected that compilation of first snippet will fail. Compilation of 2415 * second snippet should be successful. 2416 * 2417 * Test all shader stages. Test both in and out blocks. 2418 **/ 2419 class VaryingBlockMemberLocationsTest : public NegativeTestBase 2420 { 2421 public: 2422 /* Public methods */ 2423 VaryingBlockMemberLocationsTest(deqp::Context& context); 2424 ~VaryingBlockMemberLocationsTest()2425 virtual ~VaryingBlockMemberLocationsTest() 2426 { 2427 } 2428 2429 protected: 2430 /* Methods to be implemented by child class */ 2431 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 2432 2433 virtual std::string getTestCaseName(glw::GLuint test_case_index); 2434 virtual glw::GLuint getTestCaseNumber(); 2435 virtual bool isComputeRelevant(glw::GLuint test_case_index); 2436 virtual bool isFailureExpected(glw::GLuint test_case_index); 2437 virtual void testInit(); 2438 2439 private: 2440 /* Private types */ 2441 struct testCase 2442 { 2443 bool m_is_input; 2444 bool m_qualify_all; 2445 Utils::Shader::STAGES m_stage; 2446 }; 2447 2448 /* Private fields */ 2449 std::vector<testCase> m_test_cases; 2450 }; 2451 2452 /** Implementation of test VaryingBlockAutomaticMemberLocations. Description follows: 2453 * 2454 * Test verifies that compiler will assign subsequent locations to block 2455 * members. 2456 * 2457 * Test following code snippet: 2458 * 2459 * layout (location = 2) in DBZ 2460 * { 2461 * vec4 goku; // 2 2462 * vec4 gohan[GOHAN_LENGTH]; // 3 2463 * vec4 goten; // 3 + GOHAN_LENGTH 2464 * layout (location = 1) vec4 chichi; // 1 2465 * vec4 pan; // 2; ERROR location 2 used twice 2466 * }; 2467 * 2468 * Test all shader stages. Test both in and out blocks. 2469 * 2470 * It is expected that build process will fail. 2471 **/ 2472 class VaryingBlockAutomaticMemberLocationsTest : public NegativeTestBase 2473 { 2474 public: 2475 /* Public methods */ 2476 VaryingBlockAutomaticMemberLocationsTest(deqp::Context& context); 2477 ~VaryingBlockAutomaticMemberLocationsTest()2478 virtual ~VaryingBlockAutomaticMemberLocationsTest() 2479 { 2480 } 2481 2482 protected: 2483 /* Methods to be implemented by child class */ 2484 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 2485 2486 virtual std::string getTestCaseName(glw::GLuint test_case_index); 2487 virtual glw::GLuint getTestCaseNumber(); 2488 virtual bool isComputeRelevant(glw::GLuint test_case_index); 2489 virtual void testInit(); 2490 2491 private: 2492 /* Private types */ 2493 struct testCase 2494 { 2495 bool m_is_input; 2496 Utils::Shader::STAGES m_stage; 2497 }; 2498 2499 /* Private fields */ 2500 std::vector<testCase> m_test_cases; 2501 }; 2502 2503 /** Implementation of test VaryingLocationLimit. Description follows: 2504 * 2505 * Test verifies that "location" qualifier cannot exceed limits. 2506 * 2507 * Test following code snippet: 2508 * 2509 * layout (location = LAST + 1) in type goku; 2510 * 2511 * LAST should be set to index of last available location. 2512 * 2513 * Test all types. Test all shader stages. Test both in and out varyings. 2514 * 2515 * It is expected that shader compilation will fail. 2516 **/ 2517 class VaryingLocationLimitTest : public NegativeTestBase 2518 { 2519 public: 2520 /* Public methods */ 2521 VaryingLocationLimitTest(deqp::Context& context); 2522 ~VaryingLocationLimitTest()2523 virtual ~VaryingLocationLimitTest() 2524 { 2525 } 2526 2527 protected: 2528 /* Methods to be implemented by child class */ 2529 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 2530 2531 virtual std::string getTestCaseName(glw::GLuint test_case_index); 2532 virtual glw::GLuint getTestCaseNumber(); 2533 virtual bool isComputeRelevant(glw::GLuint test_case_index); 2534 virtual bool isSeparable(const glw::GLuint test_case_index); 2535 virtual void testInit(); 2536 2537 private: 2538 /* Private types */ 2539 struct testCase 2540 { 2541 bool m_is_input; 2542 Utils::Type m_type; 2543 Utils::Shader::STAGES m_stage; 2544 }; 2545 2546 /* Private fields */ 2547 std::vector<testCase> m_test_cases; 2548 }; 2549 2550 /** Implementation of test VaryingComponents. Description follows: 2551 * 2552 * VaryingComponents 2553 * 2554 * Test verifies that "varying" can be assigned to specific components. 2555 * 2556 * Modify VaryingLocations to test all possible combinations of components 2557 * layout: 2558 * - g64vec2 2559 * - g64scalar, g64scalar 2560 * - gvec4 2561 * - scalar, gvec3 2562 * - gvec3, scalar 2563 * - gvec2, gvec2 2564 * - gvec2, scalar, scalar 2565 * - scalar, gvec2, scalar 2566 * - scalar, scalar, gvec2 2567 * - scalar, scalar, scalar, scalar. 2568 * 2569 * Additionally inspect program to check that all locations and components are 2570 * as expected. 2571 **/ 2572 class VaryingComponentsTest : public VaryingLocationsTest 2573 { 2574 public: 2575 VaryingComponentsTest(deqp::Context& context); 2576 2577 VaryingComponentsTest(deqp::Context& context, const glw::GLchar* test_name, const glw::GLchar* test_description); 2578 ~VaryingComponentsTest()2579 ~VaryingComponentsTest() 2580 { 2581 } 2582 2583 protected: 2584 /* Protected methods */ 2585 virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 2586 Utils::VaryingPassthrough& varying_passthrough); 2587 2588 virtual std::string getTestCaseName(glw::GLuint test_case_index); 2589 virtual glw::GLuint getTestCaseNumber(); 2590 virtual void testInit(); 2591 virtual bool useComponentQualifier(glw::GLuint test_case_index); 2592 2593 /* To be implemented by children */ 2594 virtual glw::GLuint getArrayLength(); 2595 2596 private: 2597 /* Private enums */ 2598 enum COMPONENTS_LAYOUT 2599 { 2600 G64VEC2, 2601 G64SCALAR_G64SCALAR, 2602 GVEC4, 2603 SCALAR_GVEC3, 2604 GVEC3_SCALAR, 2605 GVEC2_GVEC2, 2606 GVEC2_SCALAR_SCALAR, 2607 SCALAR_GVEC2_SCALAR, 2608 SCALAR_SCALAR_GVEC2, 2609 SCALAR_SCALAR_SCALAR_SCALAR, 2610 }; 2611 2612 /* Private struct */ 2613 struct descriptor 2614 { 2615 void assign(glw::GLint component, const glw::GLchar* component_str, glw::GLint location, 2616 const glw::GLchar* location_str, glw::GLuint n_rows, const glw::GLchar* name); 2617 2618 glw::GLint m_component; 2619 const glw::GLchar* m_component_str; 2620 glw::GLint m_location; 2621 const glw::GLchar* m_location_str; 2622 glw::GLuint m_n_rows; 2623 const glw::GLchar* m_name; 2624 }; 2625 2626 struct testCase 2627 { 2628 testCase(COMPONENTS_LAYOUT layout, Utils::Type::TYPES type); 2629 2630 COMPONENTS_LAYOUT m_layout; 2631 Utils::Type::TYPES m_type; 2632 }; 2633 2634 /* Private routines */ 2635 std::string prepareGlobals(glw::GLuint last_in_location, glw::GLuint last_out_location); 2636 2637 std::string prepareName(const glw::GLchar* name, glw::GLint location, glw::GLint component, 2638 Utils::Shader::STAGES stage, Utils::Variable::STORAGE storage); 2639 2640 std::string prepareQualifiers(const glw::GLchar* location, const glw::GLchar* component, 2641 const glw::GLchar* interpolation); 2642 2643 using VaryingLocationsTest::prepareShaderStage; 2644 2645 void prepareShaderStage(Utils::Shader::STAGES stage, const Utils::Type& vector_type, 2646 Utils::ProgramInterface& program_interface, const testCase& test_case, 2647 Utils::VaryingPassthrough& varying_passthrough); 2648 2649 Utils::Variable* prepareVarying(const Utils::Type& basic_type, const descriptor& desc, 2650 const glw::GLchar* interpolation, Utils::ShaderInterface& si, 2651 Utils::Shader::STAGES stage, Utils::Variable::STORAGE storage); 2652 2653 /* Private fields */ 2654 std::vector<testCase> m_test_cases; 2655 std::vector<glw::GLubyte> m_data; 2656 }; 2657 2658 /** Implementation of test VaryingArrayComponents. Description follows: 2659 * 2660 * Test verifies that arrays of "varyings" can be assigned to specific 2661 * components. 2662 * 2663 * Modify VaryingComponents similarly to VaryingArrayLocations. 2664 **/ 2665 class VaryingArrayComponentsTest : public VaryingComponentsTest 2666 { 2667 public: 2668 VaryingArrayComponentsTest(deqp::Context& context); 2669 ~VaryingArrayComponentsTest()2670 ~VaryingArrayComponentsTest() 2671 { 2672 } 2673 2674 protected: 2675 /* Protected methods */ 2676 virtual glw::GLuint getArrayLength(); 2677 }; 2678 2679 /** Implementation of test VaryingInvalidValueComponent. Description follows: 2680 * 2681 * Test verifies that it is not allowed to use some component values 2682 * with specific types. 2683 * 2684 * Test following code snippets: 2685 * 2686 * layout (location = 1, component = COMPONENT) in type gohan; 2687 * 2688 * and 2689 * 2690 * layout (location = 1, component = COMPONENT) in type gohan[LENGTH]; 2691 * 2692 * Select COMPONENT so it is an invalid value either due the specific 2693 * restrictions of each type, eg. 2 for vec4, which overflows the 2694 * amount of components in a location. Select array length so as to 2695 * not exceed limits of available locations. 2696 * 2697 * Test all types. Test all shader stages. Test both in and out varyings. 2698 * 2699 * It is expected that build process will fail. 2700 **/ 2701 class VaryingInvalidValueComponentTest : public NegativeTestBase 2702 { 2703 public: 2704 /* Public methods */ 2705 VaryingInvalidValueComponentTest(deqp::Context& context); 2706 ~VaryingInvalidValueComponentTest()2707 virtual ~VaryingInvalidValueComponentTest() 2708 { 2709 } 2710 2711 protected: 2712 /* Methods to be implemented by child class */ 2713 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 2714 2715 virtual std::string getTestCaseName(glw::GLuint test_case_index); 2716 virtual glw::GLuint getTestCaseNumber(); 2717 virtual bool isComputeRelevant(glw::GLuint test_case_index); 2718 virtual void testInit(); 2719 2720 private: 2721 /* Private types */ 2722 struct testCase 2723 { 2724 glw::GLuint m_component; 2725 bool m_is_input; 2726 bool m_is_array; 2727 Utils::Shader::STAGES m_stage; 2728 Utils::Type m_type; 2729 }; 2730 2731 /* Private fields */ 2732 std::vector<testCase> m_test_cases; 2733 }; 2734 2735 /** Implementation of test VaryingExceedingComponents. Description follows: 2736 * 2737 * Test verifies that it is not allowed to use a value that exceeds 2738 * the amount of possible components in a location. 2739 * 2740 * Test following code snippets: 2741 * 2742 * layout (location = 1, component = 4) in type gohan; 2743 * 2744 * and 2745 * 2746 * layout (location = 1, component = 4) in type gohan[LENGTH]; 2747 * 2748 * Select array length so as to not exceed limits of available locations. 2749 * 2750 * Test all types. Test all shader stages. Test both in and out varyings. 2751 * 2752 * It is expected that build process will fail. 2753 **/ 2754 class VaryingExceedingComponentsTest : public NegativeTestBase 2755 { 2756 public: 2757 /* Public methods */ 2758 VaryingExceedingComponentsTest(deqp::Context& context); 2759 ~VaryingExceedingComponentsTest()2760 virtual ~VaryingExceedingComponentsTest() 2761 { 2762 } 2763 2764 protected: 2765 /* Methods to be implemented by child class */ 2766 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 2767 2768 virtual std::string getTestCaseName(glw::GLuint test_case_index); 2769 virtual glw::GLuint getTestCaseNumber(); 2770 virtual bool isComputeRelevant(glw::GLuint test_case_index); 2771 virtual void testInit(); 2772 2773 private: 2774 /* Private types */ 2775 struct testCase 2776 { 2777 bool m_is_input; 2778 bool m_is_array; 2779 Utils::Shader::STAGES m_stage; 2780 Utils::Type m_type; 2781 }; 2782 2783 /* Private fields */ 2784 std::vector<testCase> m_test_cases; 2785 }; 2786 2787 /** Implementation of test VaryingComponentWithoutLocation. Description follows: 2788 * 2789 * Test verifies that "component" qualifier cannot be used without "location" 2790 * qualifier. 2791 * 2792 * Test following code snippet: 2793 * 2794 * layout (component = COMPONENT) in type goku; 2795 * 2796 * Test all types. Test all valid COMPONENT values. Test all shader stages. 2797 * Test both in and out varyings. 2798 * 2799 * It is expected that shader compilation will fail. 2800 **/ 2801 class VaryingComponentWithoutLocationTest : public NegativeTestBase 2802 { 2803 public: 2804 /* Public methods */ 2805 VaryingComponentWithoutLocationTest(deqp::Context& context); 2806 ~VaryingComponentWithoutLocationTest()2807 virtual ~VaryingComponentWithoutLocationTest() 2808 { 2809 } 2810 2811 protected: 2812 /* Methods to be implemented by child class */ 2813 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 2814 2815 virtual std::string getTestCaseName(glw::GLuint test_case_index); 2816 virtual glw::GLuint getTestCaseNumber(); 2817 virtual bool isComputeRelevant(glw::GLuint test_case_index); 2818 virtual void testInit(); 2819 2820 private: 2821 /* Private types */ 2822 struct testCase 2823 { 2824 glw::GLuint m_component; 2825 bool m_is_input; 2826 Utils::Shader::STAGES m_stage; 2827 Utils::Type m_type; 2828 }; 2829 2830 /* Private fields */ 2831 std::vector<testCase> m_test_cases; 2832 }; 2833 2834 /** Implementation of test VaryingComponentOfInvalidType. Description follows: 2835 * 2836 * Test verifies that it is not allowed to declare matrix, struct, block and 2837 * array of those at specific component. 2838 * 2839 * Test following code snippets: 2840 * 2841 * layout (location = 0, component = COMPONENT) in matrix_type varying; 2842 * 2843 * , 2844 * 2845 * layout (location = 0, component = COMPONENT) 2846 * in matrix_type varying[LENGTH]; 2847 * 2848 * , 2849 * 2850 * layout (location = 0, component = COMPONENT) in Block 2851 * { 2852 * type member; 2853 * }; 2854 * 2855 * , 2856 * 2857 * layout (location = 0, component = COMPONENT) in Block 2858 * { 2859 * type member; 2860 * } block[LENGTH]; 2861 * 2862 * , 2863 * 2864 * struct Data 2865 * { 2866 * type member; 2867 * }; 2868 * 2869 * layout (location = 0, component = COMPONENT) in Data varying; 2870 * 2871 * and 2872 * 2873 * struct Data 2874 * { 2875 * type member; 2876 * }; 2877 * 2878 * layout (location = 0, component = COMPONENT) in Data varying[LENGTH]; 2879 * 2880 * Test all types. Test all shader stages. Test both in and out varyings. 2881 * 2882 * It is expected that build process will fail. 2883 **/ 2884 class VaryingComponentOfInvalidTypeTest : public NegativeTestBase 2885 { 2886 public: 2887 /* Public methods */ 2888 VaryingComponentOfInvalidTypeTest(deqp::Context& context); 2889 ~VaryingComponentOfInvalidTypeTest()2890 virtual ~VaryingComponentOfInvalidTypeTest() 2891 { 2892 } 2893 2894 protected: 2895 /* Methods to be implemented by child class */ 2896 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 2897 2898 virtual std::string getTestCaseName(glw::GLuint test_case_index); 2899 virtual glw::GLuint getTestCaseNumber(); 2900 2901 virtual bool isComputeRelevant(glw::GLuint test_case_index); 2902 virtual void testInit(); 2903 2904 private: 2905 /* Private enums */ 2906 enum CASES 2907 { 2908 MATRIX = 0, 2909 DVEC3_DVEC4, 2910 BLOCK, 2911 STRUCT, 2912 2913 /* */ 2914 MAX_CASES 2915 }; 2916 2917 /* Private types */ 2918 struct testCase 2919 { 2920 CASES m_case; 2921 glw::GLuint m_component; 2922 bool m_is_array; 2923 bool m_is_input; 2924 Utils::Shader::STAGES m_stage; 2925 Utils::Type m_type; 2926 }; 2927 2928 /* Private fields */ 2929 std::vector<testCase> m_test_cases; 2930 }; 2931 2932 /** Implementation of test InputComponentAliasing. Description follows: 2933 * 2934 * Test verifies that component aliasing cause compilation or linking error. 2935 * 2936 * Test following code snippet: 2937 * 2938 * layout (location = 1, component = GOHAN_COMPONENT) in type gohan; 2939 * layout (location = 1, component = GOTEN_COMPONENT) in type goten; 2940 * 2941 * if (EXPECTED_VALUE == gohan) 2942 * { 2943 * result = 1; 2944 * } 2945 * 2946 * Test all components combinations that cause aliasing. Test all types. Test 2947 * all shader stages. It is expected that build process will fail. 2948 * 2949 * Vertex shader allows component aliasing on input as long as only one of the 2950 * attributes is used in each execution path. Test vertex shader stage with two 2951 * variants: 2952 * - first as presented above, 2953 * - second, where "result = 1;" is replaced with "result = goten;". 2954 * In first case build process should succeed, in the second case build process 2955 * should fail. 2956 **/ 2957 class InputComponentAliasingTest : public NegativeTestBase 2958 { 2959 public: 2960 /* Public methods */ 2961 InputComponentAliasingTest(deqp::Context& context); 2962 ~InputComponentAliasingTest()2963 virtual ~InputComponentAliasingTest() 2964 { 2965 } 2966 2967 protected: 2968 /* Methods to be implemented by child class */ 2969 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 2970 2971 virtual std::string getTestCaseName(glw::GLuint test_case_index); 2972 virtual glw::GLuint getTestCaseNumber(); 2973 2974 virtual bool isComputeRelevant(glw::GLuint test_case_index); 2975 virtual bool isFailureExpected(glw::GLuint test_case_index); 2976 virtual void testInit(); 2977 2978 private: 2979 /* Private types */ 2980 struct testCase 2981 { 2982 glw::GLuint m_component_gohan; 2983 glw::GLuint m_component_goten; 2984 Utils::Shader::STAGES m_stage; 2985 Utils::Type m_type; 2986 }; 2987 2988 /* Private fields */ 2989 std::vector<testCase> m_test_cases; 2990 }; 2991 2992 /** Implementation of test OutputComponentAliasing. Description follows: 2993 * 2994 * Test verifies that component aliasing cause compilation or linking error. 2995 * 2996 * Test following code snippet: 2997 * 2998 * layout (location = 1, component = GOHAN_COMPONENT) out type gohan; 2999 * layout (location = 1, component = GOTEN_COMPONENT) out type goten; 3000 * 3001 * gohan = GOHAN_VALUE; 3002 * goten = GOTEN_VALUE; 3003 * 3004 * Test all components combinations that cause aliasing. Test all types. Test 3005 * all shader stages. It is expected that build process will fail. 3006 **/ 3007 class OutputComponentAliasingTest : public NegativeTestBase 3008 { 3009 public: 3010 /* Public methods */ 3011 OutputComponentAliasingTest(deqp::Context& context); 3012 ~OutputComponentAliasingTest()3013 virtual ~OutputComponentAliasingTest() 3014 { 3015 } 3016 3017 protected: 3018 /* Methods to be implemented by child class */ 3019 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 3020 3021 virtual std::string getTestCaseName(glw::GLuint test_case_index); 3022 virtual glw::GLuint getTestCaseNumber(); 3023 virtual bool isComputeRelevant(glw::GLuint test_case_index); 3024 virtual void testInit(); 3025 3026 private: 3027 /* Private types */ 3028 struct testCase 3029 { 3030 glw::GLuint m_component_gohan; 3031 glw::GLuint m_component_goten; 3032 Utils::Shader::STAGES m_stage; 3033 Utils::Type m_type; 3034 }; 3035 3036 /* Private fields */ 3037 std::vector<testCase> m_test_cases; 3038 }; 3039 3040 /** Implementation of test VaryingLocationAliasingWithMixedTypes. Description follows: 3041 * 3042 * Test verifies that it is not allowed to mix integer and float base types at 3043 * aliased location. 3044 * 3045 * Test following code snippet: 3046 * 3047 * layout (location = 1, component = GOHAN_COMPONENT) in gohan_type gohan; 3048 * layout (location = 1, component = GOTEN_COMPONENT) in goten_type goten; 3049 * 3050 * Test all components combinations that do not cause component aliasing. Test 3051 * all types combinations that cause float/integer conflict. Test all shader 3052 * stages. Test both in and out varyings. 3053 * 3054 * It is expected that build process will fail. 3055 **/ 3056 class VaryingLocationAliasingWithMixedTypesTest : public NegativeTestBase 3057 { 3058 public: 3059 /* Public methods */ 3060 VaryingLocationAliasingWithMixedTypesTest(deqp::Context& context); 3061 ~VaryingLocationAliasingWithMixedTypesTest()3062 virtual ~VaryingLocationAliasingWithMixedTypesTest() 3063 { 3064 } 3065 3066 protected: 3067 /* Methods to be implemented by child class */ 3068 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 3069 3070 virtual std::string getTestCaseName(glw::GLuint test_case_index); 3071 virtual glw::GLuint getTestCaseNumber(); 3072 virtual bool isComputeRelevant(glw::GLuint test_case_index); 3073 virtual void testInit(); 3074 3075 private: 3076 /* Private types */ 3077 struct testCase 3078 { 3079 glw::GLuint m_component_gohan; 3080 glw::GLuint m_component_goten; 3081 bool m_is_input; 3082 Utils::Shader::STAGES m_stage; 3083 Utils::Type m_type_gohan; 3084 Utils::Type m_type_goten; 3085 }; 3086 3087 /* Private fields */ 3088 std::vector<testCase> m_test_cases; 3089 }; 3090 3091 /** Implementation of test VaryingLocationAliasingWithMixedInterpolation. Description follows: 3092 * 3093 * Test verifies that it is not allowed to mix interpolation methods at aliased 3094 * location. 3095 * 3096 * Test following code snippet: 3097 * 3098 * layout (location = 1, component = GOHAN_COMPONENT) 3099 * GOHAN_INTERPOLATION in type gohan; 3100 * layout (location = 1, component = GOTEN_COMPONENT) 3101 * GOTEN_INTERPOLATION in type goten; 3102 * 3103 * Test all interpolation combinations that cause conflict. Select components 3104 * so as not to cause component aliasing. Test all types. Test all shader 3105 * stages. Test both in and out varyings. 3106 * 3107 * Note, that vertex shader's input and fragment shader's output cannot be 3108 * qualified with interpolation method. 3109 * 3110 * It is expected that build process will fail. 3111 **/ 3112 class VaryingLocationAliasingWithMixedInterpolationTest : public NegativeTestBase 3113 { 3114 public: 3115 /* Public methods */ 3116 VaryingLocationAliasingWithMixedInterpolationTest(deqp::Context& context); 3117 ~VaryingLocationAliasingWithMixedInterpolationTest()3118 virtual ~VaryingLocationAliasingWithMixedInterpolationTest() 3119 { 3120 } 3121 3122 protected: 3123 /* Methods to be implemented by child class */ 3124 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 3125 3126 virtual std::string getTestCaseName(glw::GLuint test_case_index); 3127 virtual glw::GLuint getTestCaseNumber(); 3128 virtual bool isComputeRelevant(glw::GLuint test_case_index); 3129 virtual void testInit(); 3130 3131 private: 3132 enum INTERPOLATIONS 3133 { 3134 SMOOTH = 0, 3135 FLAT, 3136 NO_PERSPECTIVE, 3137 3138 /* */ 3139 INTERPOLATION_MAX 3140 }; 3141 3142 /* Private types */ 3143 struct testCase 3144 { 3145 glw::GLuint m_component_gohan; 3146 glw::GLuint m_component_goten; 3147 INTERPOLATIONS m_interpolation_gohan; 3148 INTERPOLATIONS m_interpolation_goten; 3149 bool m_is_input; 3150 Utils::Shader::STAGES m_stage; 3151 Utils::Type m_type_gohan; 3152 Utils::Type m_type_goten; 3153 }; 3154 3155 /* Private routines */ 3156 const glw::GLchar* getInterpolationQualifier(INTERPOLATIONS interpolation); 3157 3158 /* Private fields */ 3159 std::vector<testCase> m_test_cases; 3160 }; 3161 3162 /** Implementation of test VaryingLocationAliasingWithMixedAuxiliaryStorage. Description follows: 3163 * 3164 * Test verifies that it is not allowed to mix auxiliary storage at aliased 3165 * location. 3166 * 3167 * Test following code snippet: 3168 * 3169 * layout (location = 1, component = GOHAN_COMPONENT) 3170 * GOHAN_AUXILIARY in type gohan; 3171 * layout (location = 1, component = GOTEN_COMPONENT) 3172 * GOTEN_AUXILIARY in type goten; 3173 * 3174 * Test all auxiliary storage combinations that cause conflict. Select 3175 * components so as not to cause component aliasing. Test all types. Test all 3176 * shader stages. Test both in and out varyings. 3177 * 3178 * It is expected that build process will fail. 3179 **/ 3180 class VaryingLocationAliasingWithMixedAuxiliaryStorageTest : public NegativeTestBase 3181 { 3182 public: 3183 /* Public methods */ 3184 VaryingLocationAliasingWithMixedAuxiliaryStorageTest(deqp::Context& context); 3185 ~VaryingLocationAliasingWithMixedAuxiliaryStorageTest()3186 virtual ~VaryingLocationAliasingWithMixedAuxiliaryStorageTest() 3187 { 3188 } 3189 3190 protected: 3191 /* Methods to be implemented by child class */ 3192 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 3193 3194 virtual std::string getTestCaseName(glw::GLuint test_case_index); 3195 virtual glw::GLuint getTestCaseNumber(); 3196 virtual bool isComputeRelevant(glw::GLuint test_case_index); 3197 virtual void testInit(); 3198 3199 private: 3200 enum AUXILIARIES 3201 { 3202 NONE = 0, 3203 PATCH, 3204 CENTROID, 3205 SAMPLE, 3206 3207 /* */ 3208 AUXILIARY_MAX 3209 }; 3210 3211 /* Private types */ 3212 struct testCase 3213 { 3214 glw::GLuint m_component_gohan; 3215 glw::GLuint m_component_goten; 3216 AUXILIARIES m_aux_gohan; 3217 AUXILIARIES m_aux_goten; 3218 bool m_is_input; 3219 Utils::Shader::STAGES m_stage; 3220 Utils::Type m_type_gohan; 3221 Utils::Type m_type_goten; 3222 }; 3223 3224 /* Private routines */ 3225 const glw::GLchar* getAuxiliaryQualifier(AUXILIARIES aux); 3226 3227 /* Private fields */ 3228 std::vector<testCase> m_test_cases; 3229 }; 3230 3231 /** Implementation of test VertexAttribLocationAPI. Description follows: 3232 * 3233 * Test verifies that vertex attribute location API works as expected. 3234 * 3235 * This test implements Texture algorithm. Tessellation shaders are not 3236 * necessary and can be omitted. Test following code snippet in vertex shader: 3237 * 3238 * layout (location = GOKU_LOCATION) in vec4 goku; 3239 * in vec4 gohan; 3240 * in vec4 goten; 3241 * in vec4 chichi; 3242 * 3243 * if ( (EXPECTED_VALUE == goku) && 3244 * (EXPECTED_VALUE == gohan) && 3245 * (EXPECTED_VALUE == gotan) && 3246 * (EXPECTED_VALUE == chichi) ) 3247 * { 3248 * result = 1; 3249 * } 3250 * 3251 * After compilation, before program is linked, specify locations for goku, 3252 * and goten with glBindAttribLocation. Specify different location than the one 3253 * used in shader. 3254 * 3255 * Select all locations so as not to exceed any limits. 3256 * 3257 * Additionally inspect program to verify that: 3258 * - goku location is as specified in shader text, 3259 * - goten location is as specified with API. 3260 **/ 3261 class VertexAttribLocationAPITest : public TextureTestBase 3262 { 3263 public: 3264 VertexAttribLocationAPITest(deqp::Context& context); 3265 ~VertexAttribLocationAPITest()3266 ~VertexAttribLocationAPITest() 3267 { 3268 } 3269 3270 protected: 3271 /* Protected methods */ 3272 virtual void prepareAttribLocation(Utils::Program& program, Utils::ProgramInterface& program_interface); 3273 3274 virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 3275 Utils::VaryingPassthrough& varying_passthrough); 3276 3277 virtual bool isComputeRelevant(glw::GLuint test_case_index); 3278 3279 private: 3280 /* Private fields */ 3281 std::vector<glw::GLubyte> m_goku_data; 3282 std::vector<glw::GLubyte> m_gohan_data; 3283 std::vector<glw::GLubyte> m_goten_data; 3284 std::vector<glw::GLubyte> m_chichi_data; 3285 3286 /* Private constants */ 3287 static const glw::GLuint m_goten_location; 3288 }; 3289 /** Implementation of test FragmentDataLocationAPI. Description follows: 3290 * 3291 * Test verifies that fragment data location API works as expected. 3292 * 3293 * This test implements Texture algorithm. Tessellation shaders are not 3294 * necessary and can be omitted. "result" is not necessary and can be omitted. 3295 * Test following code snippet in fragment shader: 3296 * 3297 * layout (location = GOKU_LOCATION) out vec4 goku; 3298 * out vec4 gohan; 3299 * out vec4 goten; 3300 * out vec4 chichi; 3301 * 3302 * goku = EXPECTED_VALUE; 3303 * gohan = EXPECTED_VALUE; 3304 * goten = EXPECTED_VALUE; 3305 * chichi = EXPECTED_VALUE; 3306 * 3307 * After compilation, before program is linked, specify locations for goku, 3308 * and goten with glBindFragDataLocation. Specify different location than the 3309 * one used in shader. 3310 * 3311 * Select all locations so as not to exceed any limits. 3312 * 3313 * Additionally inspect program to verify that: 3314 * - goku location is as specified in shader text, 3315 * - goten location is as specified with API. 3316 **/ 3317 class FragmentDataLocationAPITest : public TextureTestBase 3318 { 3319 public: 3320 FragmentDataLocationAPITest(deqp::Context& context); 3321 ~FragmentDataLocationAPITest()3322 ~FragmentDataLocationAPITest() 3323 { 3324 } 3325 3326 protected: 3327 /* Protected methods */ 3328 virtual bool checkResults(glw::GLuint test_case_index, Utils::Texture& color_0); 3329 3330 virtual std::string getPassSnippet(glw::GLuint test_case_index, Utils::VaryingPassthrough& varying_passthrough, 3331 Utils::Shader::STAGES stage); 3332 3333 virtual void getProgramInterface(glw::GLuint test_case_index, Utils::ProgramInterface& program_interface, 3334 Utils::VaryingPassthrough& varying_passthrough); 3335 3336 virtual bool isComputeRelevant(glw::GLuint test_case_index); 3337 3338 virtual void prepareFragmentDataLoc(Utils::Program& program, Utils::ProgramInterface& program_interface); 3339 3340 virtual void prepareFramebuffer(Utils::Framebuffer& framebuffer, Utils::Texture& color_0_texture); 3341 3342 private: 3343 /* Private fields */ 3344 Utils::Texture m_goku; 3345 Utils::Texture m_gohan; 3346 Utils::Texture m_goten; 3347 Utils::Texture m_chichi; 3348 3349 glw::GLint m_goku_location; 3350 glw::GLint m_gohan_location; 3351 glw::GLint m_chichi_location; 3352 3353 /* Private constants */ 3354 static const glw::GLuint m_goten_location; 3355 }; 3356 3357 /** Implementation of test XFBInput. Description follows: 3358 * 3359 * Test verifies that using xfb_buffer, xfb_stride or xfb_offset qualifiers on 3360 * input variables will cause failure of build process. 3361 * 3362 * Test all shader stages. 3363 **/ 3364 class XFBInputTest : public NegativeTestBase 3365 { 3366 public: 3367 /* Public methods */ 3368 XFBInputTest(deqp::Context& context); ~XFBInputTest()3369 virtual ~XFBInputTest() 3370 { 3371 } 3372 3373 protected: 3374 /* Methods to be implemented by child class */ 3375 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 3376 3377 virtual std::string getTestCaseName(glw::GLuint test_case_index); 3378 virtual glw::GLuint getTestCaseNumber(); 3379 virtual bool isComputeRelevant(glw::GLuint test_case_index); 3380 virtual void testInit(); 3381 3382 private: 3383 enum QUALIFIERS 3384 { 3385 BUFFER = 0, 3386 STRIDE, 3387 OFFSET, 3388 3389 /* */ 3390 QUALIFIERS_MAX 3391 }; 3392 3393 /* Private types */ 3394 struct testCase 3395 { 3396 QUALIFIERS m_qualifier; 3397 Utils::Shader::STAGES m_stage; 3398 }; 3399 3400 /* Private fields */ 3401 std::vector<testCase> m_test_cases; 3402 }; 3403 3404 /** Implementation of test XFBAllStages. Description follows: 3405 * 3406 * Test verifies that only outputs from last stage processing primitives can be 3407 * captured with XFB. 3408 * 3409 * This test implements Buffer algorithm. Rasterization can be discarded. 3410 * 3411 * At each stage declare a single active output variable qualified with 3412 * xfb_buffer and xfb_offset = 0. Use separate buffers for each stage. 3413 * 3414 * Test pass if outputs from geometry shader are captured, while outputs from: 3415 * vertex and tessellation stages are ignored. 3416 **/ 3417 class XFBAllStagesTest : public BufferTestBase 3418 { 3419 public: 3420 XFBAllStagesTest(deqp::Context& context); 3421 ~XFBAllStagesTest()3422 ~XFBAllStagesTest() 3423 { 3424 } 3425 3426 protected: 3427 /* Protected methods */ 3428 virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors); 3429 3430 virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments, 3431 std::string& out_calculations); 3432 3433 virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage, 3434 std::string& out_interface); 3435 3436 private: 3437 /* Constants */ 3438 static const glw::GLuint m_gs_index; 3439 }; 3440 3441 /** Implementation of test XFBStrideOfEmptyList. Description follows: 3442 * 3443 * Test verifies correct behavior when xfb_stride qualifier is specified 3444 * but no variables are qualified with xfb_offset. 3445 * 3446 * Test implements Buffer algorithm. Rasterization can be discarded. 3447 * 3448 * Test following code snippet: 3449 * 3450 * layout (xfb_buffer = 1, xfb_stride = 64) out; 3451 * 3452 * Moreover program should output something to xfb at index 0 3453 * 3454 * Test following cases: 3455 * 1 Provide buffers to XFB at index 0 and 1 3456 * 2 Provide buffer to XFB at index 1, index 0 should be missing 3457 * 3 Provide buffer to XFB at index 0, index 1 should be missing 3458 * 3459 * It is expected that: 3460 * - BeginTransformFeedback operation will report GL_INVALID_OPERATION in case 2 3461 * - XFB at index 1 will not be modified in cases 1 and 3. 3462 **/ 3463 3464 class XFBStrideOfEmptyListTest : public BufferTestBase 3465 { 3466 public: 3467 XFBStrideOfEmptyListTest(deqp::Context& context); 3468 ~XFBStrideOfEmptyListTest()3469 ~XFBStrideOfEmptyListTest() 3470 { 3471 } 3472 3473 protected: 3474 /* Protected methods */ 3475 using BufferTestBase::executeDrawCall; 3476 virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index); 3477 3478 virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors); 3479 3480 virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments, 3481 std::string& out_calculations); 3482 3483 virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage, 3484 std::string& out_interface); 3485 3486 virtual std::string getTestCaseName(glw::GLuint test_case_index); 3487 virtual glw::GLuint getTestCaseNumber(); 3488 3489 private: 3490 enum CASES 3491 { 3492 VALID = 0, 3493 FIRST_MISSING, 3494 SECOND_MISSING, 3495 }; 3496 3497 /* Private constants */ 3498 static const glw::GLuint m_stride; 3499 }; 3500 3501 /** Implementation of test XFBStrideOfEmptyListAndAPI. Description follows: 3502 * 3503 * Test verifies that xfb_stride qualifier is not overridden by API. 3504 * 3505 * Test implements Buffer algorithm. Rasterization can be discarded. 3506 * 3507 * Test following code snippet: 3508 * 3509 * layout (xfb_buffer = 0, xfb_stride = 64) out; 3510 * 3511 * Moreover program should output something to xfb at index 1 3512 3513 * Use TransformFeedbackVaryings to declare a single vec4 output variable to be 3514 * captured. 3515 * 3516 * Test following cases: 3517 * 1 Provide buffers to XFB at index 0 and 1 3518 * 2 Provide buffer to XFB at index 1, index 0 should be missing 3519 * 3 Provide buffer to XFB at index 0, index 1 should be missing 3520 * 3521 * It is expected that: 3522 * - BeginTransformFeedback operation will report GL_INVALID_OPERATION in cases 3523 * 2 and 3, 3524 * - XFB at index 0 will not be modified in case 1. 3525 **/ 3526 class XFBStrideOfEmptyListAndAPITest : public BufferTestBase 3527 { 3528 public: 3529 XFBStrideOfEmptyListAndAPITest(deqp::Context& context); 3530 ~XFBStrideOfEmptyListAndAPITest()3531 ~XFBStrideOfEmptyListAndAPITest() 3532 { 3533 } 3534 3535 protected: 3536 /* Protected methods */ 3537 using BufferTestBase::executeDrawCall; 3538 virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index); 3539 virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors); 3540 3541 virtual void getCapturedVaryings(glw::GLuint test_case_index, Utils::Program::NameVector& captured_varyings, glw::GLint* xfb_components); 3542 3543 virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments, 3544 std::string& out_calculations); 3545 3546 virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage, 3547 std::string& out_interface); 3548 3549 virtual std::string getTestCaseName(glw::GLuint test_case_index); 3550 virtual glw::GLuint getTestCaseNumber(); 3551 3552 private: 3553 enum CASES 3554 { 3555 VALID = 0, 3556 FIRST_MISSING, 3557 SECOND_MISSING, 3558 }; 3559 3560 /* Private constants */ 3561 static const glw::GLuint m_stride; 3562 }; 3563 3564 /** Implementation of test XFBTooSmallStride. Description follows: 3565 * 3566 * Test verifies that build process fails when xfb_stride qualifier sets not 3567 * enough space for all variables. 3568 * 3569 * Test following code snippets: 3570 * 3571 * layout (xfb_buffer = 0, xfb_stride = 40) out; 3572 * 3573 * layout (xfb_offset = 32) out vec4 goku; 3574 * 3575 * goku = EXPECTED_VALUE. 3576 * 3577 * , 3578 * 3579 * layout (xfb_buffer = 0, xfb_stride = 28) out; 3580 * 3581 * layout (xfb_offset = 16, xfb_stride = 28) out vec4 goku; 3582 * 3583 * goku = EXPECTED_VALUE. 3584 * 3585 * , 3586 * 3587 * layout (xfb_buffer = 0, xfb_stride = 32) out; 3588 * 3589 * layout (xfb_offset = 0) out Goku { 3590 * vec4 gohan; 3591 * vec4 goten; 3592 * vec4 chichi; 3593 * }; 3594 * 3595 * gohan = EXPECTED_VALUE; 3596 * goten = EXPECTED_VALUE; 3597 * chichi = EXPECTED_VALUE; 3598 * 3599 * , 3600 * 3601 * layout (xfb_buffer = 0, xfb_stride = 32) out; 3602 * 3603 * layout (xfb_offset = 16) out vec4 goku[4]; 3604 * 3605 * goku[0] = EXPECTED_VALUE. 3606 * goku[1] = EXPECTED_VALUE. 3607 * goku[2] = EXPECTED_VALUE. 3608 * goku[3] = EXPECTED_VALUE. 3609 * 3610 * It is expected that build process will fail. 3611 * 3612 * Test all shader stages. 3613 **/ 3614 class XFBTooSmallStrideTest : public NegativeTestBase 3615 { 3616 public: 3617 /* Public methods */ 3618 XFBTooSmallStrideTest(deqp::Context& context); 3619 ~XFBTooSmallStrideTest()3620 virtual ~XFBTooSmallStrideTest() 3621 { 3622 } 3623 3624 protected: 3625 /* Methods to be implemented by child class */ 3626 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 3627 3628 virtual std::string getTestCaseName(glw::GLuint test_case_index); 3629 virtual glw::GLuint getTestCaseNumber(); 3630 virtual bool isComputeRelevant(glw::GLuint test_case_index); 3631 virtual void testInit(); 3632 3633 private: 3634 enum CASES 3635 { 3636 OFFSET = 0, 3637 STRIDE, 3638 BLOCK, 3639 ARRAY, 3640 3641 /* */ 3642 CASE_MAX 3643 }; 3644 3645 /* Private types */ 3646 struct testCase 3647 { 3648 CASES m_case; 3649 Utils::Shader::STAGES m_stage; 3650 }; 3651 3652 /* Private fields */ 3653 std::vector<testCase> m_test_cases; 3654 }; 3655 3656 /** Implementation of test XFBVariableStride. Description follows: 3657 * 3658 * Test verifies that xfb_stride qualifier change stride of output variable. 3659 * 3660 * Test following code snippets: 3661 * 3662 * layout (xfb_stride = sizeof(type)) out; 3663 * 3664 * layout (xfb_offset = 0) out type goku; 3665 * 3666 * and 3667 * 3668 * layout (xfb_stride = sizeof(type)) out; 3669 * 3670 * layout (xfb_offset = 0) out type goku; 3671 * layout (xfb_offset = sizeof(type)) out type vegeta; 3672 * 3673 * It is expected that: 3674 * - first snippet will build successfully, 3675 * - second snippet will fail to build. 3676 * 3677 * Test all types. Test all shader stages. 3678 **/ 3679 class XFBVariableStrideTest : public NegativeTestBase 3680 { 3681 public: 3682 /* Public methods */ 3683 XFBVariableStrideTest(deqp::Context& context); ~XFBVariableStrideTest()3684 virtual ~XFBVariableStrideTest() 3685 { 3686 } 3687 3688 protected: 3689 /* Methods to be implemented by child class */ 3690 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 3691 3692 virtual std::string getTestCaseName(glw::GLuint test_case_index); 3693 virtual glw::GLuint getTestCaseNumber(); 3694 virtual bool isComputeRelevant(glw::GLuint test_case_index); 3695 virtual bool isFailureExpected(glw::GLuint test_case_index); 3696 virtual void testInit(); 3697 3698 private: 3699 enum CASES 3700 { 3701 VALID = 0, 3702 INVALID, 3703 3704 /* */ 3705 CASE_MAX 3706 }; 3707 3708 /* Private types */ 3709 struct testCase 3710 { 3711 CASES m_case; 3712 Utils::Shader::STAGES m_stage; 3713 Utils::Type m_type; 3714 }; 3715 3716 /* Private fields */ 3717 std::vector<testCase> m_test_cases; 3718 }; 3719 3720 /** Implementation of test XFBBlockStride. Description follows: 3721 * 3722 * Test verifies that xfb_stride qualifier change stride of output block. 3723 * 3724 * Test following code snippet: 3725 * 3726 * layout (xfb_offset = 0, xfb_stride = 128) out Goku { 3727 * vec4 gohan; 3728 * vec4 goten; 3729 * vec4 chichi; 3730 * }; 3731 * 3732 * Inspect program to check if Goku stride is 128 units. 3733 * 3734 * Test all shader stages. 3735 **/ 3736 class XFBBlockStrideTest : public TestBase 3737 { 3738 public: 3739 /* Public methods */ 3740 XFBBlockStrideTest(deqp::Context& context); 3741 ~XFBBlockStrideTest()3742 virtual ~XFBBlockStrideTest() 3743 { 3744 } 3745 3746 protected: 3747 /* Methods to be implemented by child class */ 3748 virtual std::string getTestCaseName(glw::GLuint test_case_index); 3749 virtual glw::GLuint getTestCaseNumber(); 3750 virtual bool testCase(glw::GLuint test_case_index); 3751 virtual void testInit(); 3752 3753 private: 3754 /* Private methods */ 3755 std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 3756 3757 bool inspectProgram(Utils::Program& program); 3758 3759 /* Private fields */ 3760 std::vector<Utils::Shader::STAGES> m_test_cases; 3761 }; 3762 3763 /** Implementation of test XFBBlockMemberStride. Description follows: 3764 * 3765 * Test verifies that xfb_stride qualifier change stride of output block 3766 * member. 3767 * 3768 * This test implements Buffer algorithm. Rasterization can be discarded. Test 3769 * following code snippet: 3770 * 3771 * layout (xfb_offset = 0) out Goku { 3772 * vec4 gohan; 3773 * layout (xfb_stride = 32) vec4 goten; 3774 * vec4 chichi; 3775 * }; 3776 * 3777 * gohan = EXPECTED_VALUE; 3778 * goten = EXPECTED_VALUE; 3779 * chichi = EXPECTED_VALUE; 3780 * 3781 * Test pass if: 3782 * - goten stride is reported as 32, 3783 * - chichi offset is reported as 48, 3784 * - values captured for all members match expected values, 3785 * - part of memory reserved for goten, that is not used, is not modified. 3786 **/ 3787 class XFBBlockMemberStrideTest : public BufferTestBase 3788 { 3789 public: 3790 XFBBlockMemberStrideTest(deqp::Context& context); ~XFBBlockMemberStrideTest()3791 ~XFBBlockMemberStrideTest() 3792 { 3793 } 3794 3795 protected: 3796 /* Protected methods */ 3797 virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors); 3798 3799 virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments, 3800 std::string& out_calculations); 3801 3802 virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage, 3803 std::string& out_interface); 3804 3805 virtual bool inspectProgram(glw::GLuint test_case_index, Utils::Program& program, std::stringstream& out_stream); 3806 }; 3807 3808 /** Implementation of test XFBDuplicatedStride. Description follows: 3809 * 3810 * Test verifies that conflicting xfb_stride qualifiers cause build process 3811 * failure. 3812 * 3813 * Test following code snippets: 3814 * 3815 * layout (xfb_buffer = 0, xfb_stride = 64) out; 3816 * layout (xfb_buffer = 0, xfb_stride = 64) out; 3817 * 3818 * and 3819 * 3820 * layout (xfb_buffer = 0, xfb_stride = 64) out; 3821 * layout (xfb_buffer = 0, xfb_stride = 128) out; 3822 * 3823 * It is expected that: 3824 * - first snippet will build successfully, 3825 * - second snippet will fail to build. 3826 **/ 3827 class XFBDuplicatedStrideTest : public NegativeTestBase 3828 { 3829 public: 3830 /* Public methods */ 3831 XFBDuplicatedStrideTest(deqp::Context& context); 3832 ~XFBDuplicatedStrideTest()3833 virtual ~XFBDuplicatedStrideTest() 3834 { 3835 } 3836 3837 protected: 3838 /* Methods to be implemented by child class */ 3839 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 3840 3841 virtual std::string getTestCaseName(glw::GLuint test_case_index); 3842 virtual glw::GLuint getTestCaseNumber(); 3843 virtual bool isComputeRelevant(glw::GLuint test_case_index); 3844 virtual bool isFailureExpected(glw::GLuint test_case_index); 3845 virtual void testInit(); 3846 3847 private: 3848 enum CASES 3849 { 3850 VALID = 0, 3851 INVALID, 3852 3853 /* */ 3854 CASE_MAX 3855 }; 3856 3857 /* Private types */ 3858 struct testCase 3859 { 3860 CASES m_case; 3861 Utils::Shader::STAGES m_stage; 3862 }; 3863 3864 /* Private fields */ 3865 std::vector<testCase> m_test_cases; 3866 }; 3867 3868 /** Implementation of test XFBGetProgramResourceAPI. Description follows: 3869 * 3870 * Test verifies that GetProgramResource* API work as expected for transform 3871 * feedback. 3872 * 3873 * Test results of following queries: 3874 * - OFFSET, 3875 * - TRANSFORM_FEEDBACK_BUFFER_INDEX, 3876 * - TRANSFORM_FEEDBACK_BUFFER_STRIDE, 3877 * - TYPE. 3878 * 3879 * Test following cases: 3880 * - captured varyings are declared with API, TransformFeedbackVaryings 3881 * with INTERLEAVED_ATTRIBS, 3882 * - captured varyings are declared with API, TransformFeedbackVaryings 3883 * with SEPARATE_ATTRIBS, 3884 * - captured varyings are declared with "xfb" qualifiers. 3885 * 3886 * Following layout should be used in cases of INTERLEAVED_ATTRIBS and "xfb" 3887 * qualifiers: 3888 * | var 0 | var 1 | var 2 | var 3 3889 * buffer 0 | used | used | empty | used 3890 * buffer 1 | empty | used | empty | empty 3891 * 3892 * In "xfb" qualifiers case, use following snippet: 3893 * 3894 * layout (xfb_buffer = 1, xfb_stride = 4 * sizeof(type)) out; 3895 * 3896 * Declaration in shader should use following order: 3897 * buffer_0_var_1 3898 * buffer_1_var_1 3899 * buffer_0_var_3 3900 * buffer_0_var_0 3901 * 3902 * To make sure that captured varyings are active, they should be assigned. 3903 * 3904 * Test all types. Test all shader stages. 3905 **/ 3906 class XFBGetProgramResourceAPITest : public TestBase 3907 { 3908 public: 3909 /* Public methods */ 3910 XFBGetProgramResourceAPITest(deqp::Context& context); 3911 ~XFBGetProgramResourceAPITest()3912 virtual ~XFBGetProgramResourceAPITest() 3913 { 3914 } 3915 3916 protected: 3917 /* Methods to be implemented by child class */ 3918 virtual std::string getTestCaseName(glw::GLuint test_case_index); 3919 virtual glw::GLuint getTestCaseNumber(); 3920 virtual bool testCase(glw::GLuint test_case_index); 3921 virtual void testInit(); 3922 virtual void insertSkipComponents(int num_components, Utils::Program::NameVector& varyings); 3923 3924 private: 3925 /* Private enums */ 3926 enum CASES 3927 { 3928 INTERLEAVED, 3929 SEPARATED, 3930 XFB, 3931 }; 3932 3933 /* Private types */ 3934 struct test_Case 3935 { 3936 CASES m_case; 3937 Utils::Shader::STAGES m_stage; 3938 Utils::Type m_type; 3939 }; 3940 3941 /* Private methods */ 3942 std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 3943 3944 bool inspectProgram(glw::GLuint test_case_index, Utils::Program& program); 3945 3946 /* Private fields */ 3947 std::vector<test_Case> m_test_cases; 3948 }; 3949 3950 /** Implementation of test XFBOverrideQualifiersWithAPI. Description follows: 3951 * 3952 * Test verifies that API is ignored, when qualifiers are in use. 3953 * 3954 * This test follows Buffer algorithm. Rasterization can disabled. Test 3955 * following code snippet: 3956 * 3957 * layout (xfb_offset = 2 * sizeof(type)) out type vegeta; 3958 * out type trunks; 3959 * layout (xfb_offset = 0) out type goku; 3960 * out type gohan; 3961 * 3962 * vegeta = EXPECTED_VALUE; 3963 * trunks = EXPECTED_VALUE; 3964 * goku = EXPECTED_VALUE; 3965 * gohan = EXPECTED_VALUE; 3966 * 3967 * Use API, TransformFeedbackVaryings, to specify trunks and gohan as outputs 3968 * to be captured. 3969 * 3970 * Test pass if: 3971 * - correct values are captured for vegeta and goku, 3972 * - trunks and gohan are not captured, 3973 * - correct stride is reported. 3974 * 3975 * Test all types. Test all shader stages. 3976 **/ 3977 class XFBOverrideQualifiersWithAPITest : public BufferTestBase 3978 { 3979 public: 3980 XFBOverrideQualifiersWithAPITest(deqp::Context& context); 3981 ~XFBOverrideQualifiersWithAPITest()3982 ~XFBOverrideQualifiersWithAPITest() 3983 { 3984 } 3985 3986 protected: 3987 /* Protected methods */ 3988 virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors); 3989 3990 virtual void getCapturedVaryings(glw::GLuint test_case_index, Utils::Program::NameVector& captured_varyings, glw::GLint* xfb_components); 3991 3992 virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments, 3993 std::string& out_calculations); 3994 3995 virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage, 3996 std::string& out_interface); 3997 3998 virtual std::string getTestCaseName(glw::GLuint test_case_index); 3999 virtual glw::GLuint getTestCaseNumber(); 4000 4001 virtual bool inspectProgram(glw::GLuint test_case_index, Utils::Program& program, std::stringstream& out_stream); 4002 }; 4003 4004 /** Implementation of test XFBVertexStreams. Description follows: 4005 * 4006 * Test verifies that "xfb" qualifiers work as expected with multiple output 4007 * streams. 4008 * 4009 * Test implements Buffer algorithm. Rasterization can be discarded. 4010 * 4011 * Test following code snippet: 4012 * 4013 * layout (xfb_buffer = 1, xfb_stride = 64) out; 4014 * layout (xfb_buffer = 2, xfb_stride = 64) out; 4015 * layout (xfb_buffer = 3, xfb_stride = 64) out; 4016 * 4017 * layout (stream = 0, xfb_buffer = 1, xfb_offset = 48) out vec4 goku; 4018 * layout (stream = 0, xfb_buffer = 1, xfb_offset = 32) out vec4 gohan; 4019 * layout (stream = 0, xfb_buffer = 1, xfb_offset = 16) out vec4 goten; 4020 * layout (stream = 1, xfb_buffer = 3, xfb_offset = 48) out vec4 picolo; 4021 * layout (stream = 1, xfb_buffer = 3, xfb_offset = 32) out vec4 vegeta; 4022 * layout (stream = 2, xfb_buffer = 2, xfb_offset = 32) out vec4 bulma; 4023 * 4024 * goku = EXPECTED_VALUE; 4025 * gohan = EXPECTED_VALUE; 4026 * goten = EXPECTED_VALUE; 4027 * picolo = EXPECTED_VALUE; 4028 * vegeta = EXPECTED_VALUE; 4029 * bulma = EXPECTED_VALUE; 4030 * 4031 * Test pass if all captured outputs have expected values. 4032 **/ 4033 class XFBVertexStreamsTest : public BufferTestBase 4034 { 4035 public: 4036 XFBVertexStreamsTest(deqp::Context& context); 4037 ~XFBVertexStreamsTest()4038 ~XFBVertexStreamsTest() 4039 { 4040 } 4041 4042 protected: 4043 /* Protected methods */ 4044 virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors); 4045 4046 virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments, 4047 std::string& out_calculations); 4048 4049 virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage, 4050 std::string& out_interface); 4051 }; 4052 4053 /** Implementation of test XFBMultipleVertexStreams. Description follows: 4054 * 4055 * Test verifies that outputs from single stream must be captured with single 4056 * xfb binding. 4057 * 4058 * Test following code snippet: 4059 * 4060 * layout (xfb_buffer = 1, xfb_stride = 64) out; 4061 * layout (xfb_buffer = 3, xfb_stride = 64) out; 4062 * 4063 * layout (stream = 0, xfb_buffer = 1, xfb_offset = 48) out vec4 goku; 4064 * layout (stream = 1, xfb_buffer = 1, xfb_offset = 32) out vec4 gohan; 4065 * layout (stream = 2, xfb_buffer = 1, xfb_offset = 16) out vec4 goten; 4066 * 4067 * It is expected that linking of program will fail. 4068 **/ 4069 class XFBMultipleVertexStreamsTest : public NegativeTestBase 4070 { 4071 public: 4072 /* Public methods */ 4073 XFBMultipleVertexStreamsTest(deqp::Context& context); 4074 ~XFBMultipleVertexStreamsTest()4075 virtual ~XFBMultipleVertexStreamsTest() 4076 { 4077 } 4078 4079 protected: 4080 /* Methods to be implemented by child class */ 4081 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 4082 4083 virtual bool isComputeRelevant(glw::GLuint test_case_index); 4084 }; 4085 4086 /** Implementation of test XFBExceedBufferLimit. Description follows: 4087 * 4088 * Test verifies that MAX_TRANSFORM_FEEDBACK_BUFFERS limit is respected. 4089 * 4090 * Test following code snippets: 4091 * 4092 * layout (xfb_buffer = MAX_TRANSFORM_FEEDBACK_BUFFERS) out; 4093 * 4094 * , 4095 * 4096 * layout (xfb_buffer = MAX_TRANSFORM_FEEDBACK_BUFFERS) out vec4 output; 4097 * 4098 * and 4099 * 4100 * layout (xfb_buffer = MAX_TRANSFORM_FEEDBACK_BUFFERS) out Block { 4101 * vec4 member; 4102 * }; 4103 * 4104 * It is expected that build process will fail. 4105 * 4106 * Test all shader stages. 4107 **/ 4108 class XFBExceedBufferLimitTest : public NegativeTestBase 4109 { 4110 public: 4111 /* Public methods */ 4112 XFBExceedBufferLimitTest(deqp::Context& context); ~XFBExceedBufferLimitTest()4113 virtual ~XFBExceedBufferLimitTest() 4114 { 4115 } 4116 4117 protected: 4118 /* Methods to be implemented by child class */ 4119 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 4120 4121 virtual std::string getTestCaseName(glw::GLuint test_case_index); 4122 virtual glw::GLuint getTestCaseNumber(); 4123 virtual bool isComputeRelevant(glw::GLuint test_case_index); 4124 virtual void testInit(); 4125 4126 private: 4127 enum CASES 4128 { 4129 BLOCK = 0, 4130 GLOBAL, 4131 VECTOR, 4132 4133 /* */ 4134 CASE_MAX 4135 }; 4136 4137 /* Private types */ 4138 struct testCase 4139 { 4140 CASES m_case; 4141 Utils::Shader::STAGES m_stage; 4142 }; 4143 4144 /* Private fields */ 4145 std::vector<testCase> m_test_cases; 4146 }; 4147 4148 /** Implementation of test XFBExceedOffsetLimit. Description follows: 4149 * 4150 * Test verifies that MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS limit is 4151 * respected. 4152 * 4153 * Test following code snippets: 4154 * 4155 * layout (xfb_buffer = 0, xfb_stride = MAX_SIZE + 16) out; 4156 * 4157 * , 4158 * 4159 * layout (xfb_buffer = 0, xfb_offset = MAX_SIZE + 16) out vec4 output; 4160 * 4161 * and 4162 * 4163 * layout (xfb_buffer = 0, xfb_offset = MAX_SIZE + 16) out Block 4164 * { 4165 * vec4 member; 4166 * }; 4167 * 4168 * where MAX_SIZE is the maximum supported size of transform feedback buffer, 4169 * which should be equal to: 4170 * 4171 * MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS * sizeof(float) 4172 * 4173 * It is expected that build process will fail. 4174 * 4175 * Test all shader stages. 4176 **/ 4177 class XFBExceedOffsetLimitTest : public NegativeTestBase 4178 { 4179 public: 4180 /* Public methods */ 4181 XFBExceedOffsetLimitTest(deqp::Context& context); ~XFBExceedOffsetLimitTest()4182 virtual ~XFBExceedOffsetLimitTest() 4183 { 4184 } 4185 4186 protected: 4187 /* Methods to be implemented by child class */ 4188 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 4189 4190 virtual std::string getTestCaseName(glw::GLuint test_case_index); 4191 virtual glw::GLuint getTestCaseNumber(); 4192 virtual bool isComputeRelevant(glw::GLuint test_case_index); 4193 virtual void testInit(); 4194 4195 private: 4196 enum CASES 4197 { 4198 BLOCK = 0, 4199 GLOBAL, 4200 VECTOR, 4201 4202 /* */ 4203 CASE_MAX 4204 }; 4205 4206 /* Private types */ 4207 struct testCase 4208 { 4209 CASES m_case; 4210 Utils::Shader::STAGES m_stage; 4211 }; 4212 4213 /* Private fields */ 4214 std::vector<testCase> m_test_cases; 4215 }; 4216 4217 /** Implementation of test XFBGlobalBuffer. Description follows: 4218 * 4219 * Test verifies that global setting of xfb_buffer qualifier work as expected. 4220 * 4221 * This test implements Buffer algorithm. Rasterization can be discarded. Test 4222 * following code snippet: 4223 * 4224 * layout (xfb_buffer = 3) out; 4225 * 4226 * layout ( xfb_offset = 2 * sizeof(type)) out type chichi; 4227 * layout (xfb_buffer = 1, xfb_offset = 0) out type bulma; 4228 * layout (xfb_buffer = 1, xfb_offset = sizeof(type)) out Vegeta { 4229 * type trunks; 4230 * type bra; 4231 * }; 4232 * layout ( xfb_offset = 0) out Goku { 4233 * type gohan; 4234 * type goten; 4235 * }; 4236 * 4237 * chichi = EXPECTED_VALUE; 4238 * bulma = EXPECTED_VALUE; 4239 * trunks = EXPECTED_VALUE; 4240 * bra = EXPECTED_VALUE; 4241 * gohan = EXPECTED_VALUE; 4242 * goten = EXPECTED_VALUE; 4243 * 4244 * Test pass if all captured outputs have expected values. 4245 * 4246 * Test all shader stages. Test all types. 4247 **/ 4248 class XFBGlobalBufferTest : public BufferTestBase 4249 { 4250 public: 4251 XFBGlobalBufferTest(deqp::Context& context); 4252 ~XFBGlobalBufferTest()4253 ~XFBGlobalBufferTest() 4254 { 4255 } 4256 4257 protected: 4258 /* Protected methods */ 4259 virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors); 4260 4261 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 4262 4263 virtual std::string getTestCaseName(glw::GLuint test_case_index); 4264 virtual glw::GLuint getTestCaseNumber(); 4265 virtual void testInit(); 4266 4267 private: 4268 /* Private types */ 4269 struct _testCase 4270 { 4271 Utils::Shader::STAGES m_stage; 4272 Utils::Type m_type; 4273 }; 4274 4275 /* Private fields */ 4276 std::vector<_testCase> m_test_cases; 4277 }; 4278 4279 /** Implementation of test XFBStride. Description follows: 4280 * 4281 * Test verifies that expected stride values are used. 4282 * 4283 * Test following code snippet: 4284 * 4285 * layout (xfb_offset = 0) out type output; 4286 * 4287 * output = EXPECTED_VALUE; 4288 * 4289 * Test all types. Test all shader stages. 4290 **/ 4291 class XFBStrideTest : public BufferTestBase 4292 { 4293 public: 4294 XFBStrideTest(deqp::Context& context); ~XFBStrideTest()4295 ~XFBStrideTest() 4296 { 4297 } 4298 4299 protected: 4300 /* Protected methods */ 4301 using BufferTestBase::executeDrawCall; 4302 4303 virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index); 4304 virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors); 4305 4306 virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments, 4307 std::string& out_calculations); 4308 4309 virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage, 4310 std::string& out_interface); 4311 4312 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 4313 4314 virtual std::string getTestCaseName(glw::GLuint test_case_index); 4315 virtual glw::GLuint getTestCaseNumber(); 4316 virtual void testInit(); 4317 4318 private: 4319 /* Private types */ 4320 struct testCase 4321 { 4322 Utils::Shader::STAGES m_stage; 4323 Utils::Type m_type; 4324 }; 4325 4326 /* Private fields */ 4327 std::vector<testCase> m_test_cases; 4328 }; 4329 4330 /** Implementation of test XFBBlockMemberBuffer. Description follows: 4331 * 4332 * Test verifies that member of block have to use same buffer as block. 4333 * 4334 * Test following code snippet: 4335 * 4336 * layout (xfb_offset = 0) out Goku 4337 * { 4338 * vec4 gohan; 4339 * layout (xfb_buffer = 1) vec4 goten; 4340 * }; 4341 * 4342 * It is expected that compilation will fail. 4343 * 4344 * Test all shader stages. 4345 **/ 4346 class XFBBlockMemberBufferTest : public NegativeTestBase 4347 { 4348 public: 4349 /* Public methods */ 4350 XFBBlockMemberBufferTest(deqp::Context& context); 4351 ~XFBBlockMemberBufferTest()4352 virtual ~XFBBlockMemberBufferTest() 4353 { 4354 } 4355 4356 protected: 4357 /* Methods to be implemented by child class */ 4358 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 4359 4360 virtual std::string getTestCaseName(glw::GLuint test_case_index); 4361 virtual glw::GLuint getTestCaseNumber(); 4362 virtual bool isComputeRelevant(glw::GLuint test_case_index); 4363 virtual void testInit(); 4364 4365 private: 4366 /* Private types */ 4367 struct testCase 4368 { 4369 Utils::Shader::STAGES m_stage; 4370 }; 4371 4372 /* Private fields */ 4373 std::vector<testCase> m_test_cases; 4374 }; 4375 4376 /** Implementation of test XFBOutputOverlapping. Description follows: 4377 * 4378 * Test verifies that overlapped outputs are reported as errors by compiler. 4379 * 4380 * Test following code snippet: 4381 * 4382 * layout (xfb_offset = 0) out type gohan; 4383 * layout (xfb_offset = 0.5 * sizeof(type)) out type goten; 4384 * 4385 * gohan = EXPECTED_VALUE; 4386 * goten = EXPECTED_VALUE; 4387 * 4388 * It is expected that compilation will fail. 4389 * 4390 * Test all shader stages. Test all types. 4391 **/ 4392 class XFBOutputOverlappingTest : public NegativeTestBase 4393 { 4394 public: 4395 /* Public methods */ 4396 XFBOutputOverlappingTest(deqp::Context& context); 4397 ~XFBOutputOverlappingTest()4398 virtual ~XFBOutputOverlappingTest() 4399 { 4400 } 4401 4402 protected: 4403 /* Methods to be implemented by child class */ 4404 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 4405 4406 virtual std::string getTestCaseName(glw::GLuint test_case_index); 4407 virtual glw::GLuint getTestCaseNumber(); 4408 virtual bool isComputeRelevant(glw::GLuint test_case_index); 4409 virtual void testInit(); 4410 4411 private: 4412 /* Private types */ 4413 struct testCase 4414 { 4415 glw::GLuint m_offset; 4416 Utils::Shader::STAGES m_stage; 4417 Utils::Type m_type; 4418 }; 4419 4420 /* Private fields */ 4421 std::vector<testCase> m_test_cases; 4422 }; 4423 4424 /** Implementation of test XFBInvalidOffsetAlignment. Description follows: 4425 * 4426 * Test verifies that invalidly aligned outputs cause a failure to build 4427 * process. 4428 * 4429 * Test following code snippet: 4430 * 4431 * layout (xfb_offset = OFFSET) out type goku; 4432 * 4433 * goku = EXPECTED_VALUE; 4434 * 4435 * Select OFFSET values so as to cause invalid alignment. Inspect program to 4436 * verify offset of goku. 4437 * 4438 * Test all shader stages. Test all types. Test all offsets in range: 4439 * (sizeof(type), 2 * sizeof(type)). 4440 **/ 4441 class XFBInvalidOffsetAlignmentTest : public NegativeTestBase 4442 { 4443 public: 4444 /* Public methods */ 4445 XFBInvalidOffsetAlignmentTest(deqp::Context& context); 4446 ~XFBInvalidOffsetAlignmentTest()4447 virtual ~XFBInvalidOffsetAlignmentTest() 4448 { 4449 } 4450 4451 protected: 4452 /* Methods to be implemented by child class */ 4453 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 4454 4455 virtual std::string getTestCaseName(glw::GLuint test_case_index); 4456 virtual glw::GLuint getTestCaseNumber(); 4457 virtual bool isComputeRelevant(glw::GLuint test_case_index); 4458 virtual void testInit(); 4459 4460 private: 4461 /* Private types */ 4462 struct testCase 4463 { 4464 glw::GLuint m_offset; 4465 Utils::Shader::STAGES m_stage; 4466 Utils::Type m_type; 4467 }; 4468 4469 /* Private fields */ 4470 std::vector<testCase> m_test_cases; 4471 }; 4472 4473 /** Implementation of test XFBCaptureInactiveOutputVariable. Description follows: 4474 * 4475 * Test verifies behavior of inactive outputs. 4476 * 4477 * This test implements Buffer algorithm. Rasterization can be disabled. Draw 4478 * two vertices instead of one. Test following code snippet: 4479 * 4480 * layout (xfb_offset = 16) out vec4 goku; 4481 * layout (xfb_offset = 32) out vec4 gohan; 4482 * layout (xfb_offset = 0) out vec4 goten; 4483 * 4484 * gohan = EXPECTED_VALUE; 4485 * goten = EXPECTED_VALUE; 4486 * 4487 * Test pass if: 4488 * - values captured for goten and gohan are as expected, 4489 * - goku value is undefined 4490 * - stride is 3 * sizeof(vec4) - 48 4491 * 4492 * Test all shader stages. 4493 **/ 4494 class XFBCaptureInactiveOutputVariableTest : public BufferTestBase 4495 { 4496 public: 4497 XFBCaptureInactiveOutputVariableTest(deqp::Context& context); ~XFBCaptureInactiveOutputVariableTest()4498 ~XFBCaptureInactiveOutputVariableTest() 4499 { 4500 } 4501 4502 protected: 4503 /* Protected methods */ 4504 using BufferTestBase::executeDrawCall; 4505 virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index); 4506 virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors); 4507 4508 virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments, 4509 std::string& out_calculations); 4510 4511 virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage, 4512 std::string& out_interface); 4513 4514 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 4515 4516 virtual std::string getTestCaseName(glw::GLuint test_case_index); 4517 virtual glw::GLuint getTestCaseNumber(); 4518 4519 virtual bool inspectProgram(glw::GLuint test_case_index, Utils::Program& program, std::stringstream& out_stream); 4520 4521 virtual bool verifyBuffers(bufferCollection& buffers); 4522 4523 private: 4524 enum test_cases 4525 { 4526 TEST_VS = 0, 4527 TEST_TES, 4528 TEST_GS, 4529 4530 /* */ 4531 TEST_MAX 4532 }; 4533 }; 4534 4535 /** Implementation of test XFBCaptureInactiveOutputComponent. Description follows: 4536 * 4537 * Test verifies behavior of inactive component. 4538 * 4539 * This test implements Buffer algorithm. Rasterization can be disabled. Draw 4540 * two vertices instead of one. Test following code snippet: 4541 * 4542 * layout (xfb_offset = 32) out vec4 goku; 4543 * layout (xfb_offset = 0) out vec4 gohan; 4544 * layout (xfb_offset = 16) out vec4 goten; 4545 * layout (xfb_offset = 48) out vec4 chichi; 4546 * layout (xfb_offset = 112) out vec4 vegeta; 4547 * layout (xfb_offset = 96) out vec4 trunks; 4548 * layout (xfb_offset = 80) out vec4 bra; 4549 * layout (xfb_offset = 64) out vec4 bulma; 4550 * 4551 * goku.x = EXPECTED_VALUE; 4552 * goku.z = EXPECTED_VALUE; 4553 * gohan.y = EXPECTED_VALUE; 4554 * gohan.w = EXPECTED_VALUE; 4555 * goten.x = EXPECTED_VALUE; 4556 * goten.y = EXPECTED_VALUE; 4557 * chichi.z = EXPECTED_VALUE; 4558 * chichi.w = EXPECTED_VALUE; 4559 * vegeta.x = EXPECTED_VALUE; 4560 * trunks.y = EXPECTED_VALUE; 4561 * bra.z = EXPECTED_VALUE; 4562 * bulma.w = EXPECTED_VALUE; 4563 * 4564 * Test pass when captured values of all assigned components match expected 4565 * values, while not assigned ones are undefined. 4566 * 4567 * Test all shader stages. 4568 **/ 4569 class XFBCaptureInactiveOutputComponentTest : public BufferTestBase 4570 { 4571 public: 4572 XFBCaptureInactiveOutputComponentTest(deqp::Context& context); ~XFBCaptureInactiveOutputComponentTest()4573 ~XFBCaptureInactiveOutputComponentTest() 4574 { 4575 } 4576 4577 protected: 4578 /* Protected methods */ 4579 using BufferTestBase::executeDrawCall; 4580 virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index); 4581 4582 virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors); 4583 4584 virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments, 4585 std::string& out_calculations); 4586 4587 virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage, 4588 std::string& out_interface); 4589 4590 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 4591 4592 virtual std::string getTestCaseName(glw::GLuint test_case_index); 4593 virtual glw::GLuint getTestCaseNumber(); 4594 virtual bool verifyBuffers(bufferCollection& buffers); 4595 4596 private: 4597 enum test_cases 4598 { 4599 TEST_VS = 0, 4600 TEST_TES, 4601 TEST_GS, 4602 4603 /* */ 4604 TEST_MAX 4605 }; 4606 }; 4607 4608 /** Implementation of test XFBCaptureInactiveOutputBlockMember. Description follows: 4609 * 4610 * Test verifies behaviour of inactive block member. 4611 * 4612 * This test implements Buffer algorithm. Rasterization can be disabled. Draw 4613 * two vertices instead of one. Test following code snippet: 4614 * 4615 * layout (xfb_offset = 16) out Goku { 4616 * vec4 gohan; 4617 * vec4 goten; 4618 * vec4 chichi; 4619 * }; 4620 * 4621 * gohan = EXPECTED_VALUE; 4622 * chichi = EXPECTED_VALUE; 4623 * 4624 * Test pass when captured values of gohan and chichi match expected values. 4625 * It is expected that goten will receive undefined value. 4626 * 4627 * Test all shader stages. 4628 **/ 4629 class XFBCaptureInactiveOutputBlockMemberTest : public BufferTestBase 4630 { 4631 public: 4632 XFBCaptureInactiveOutputBlockMemberTest(deqp::Context& context); 4633 ~XFBCaptureInactiveOutputBlockMemberTest()4634 ~XFBCaptureInactiveOutputBlockMemberTest() 4635 { 4636 } 4637 4638 protected: 4639 /* Protected methods */ 4640 using BufferTestBase::executeDrawCall; 4641 virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index); 4642 virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors); 4643 4644 virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments, 4645 std::string& out_calculations); 4646 4647 virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage, 4648 std::string& out_interface); 4649 4650 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 4651 4652 virtual std::string getTestCaseName(glw::GLuint test_case_index); 4653 virtual glw::GLuint getTestCaseNumber(); 4654 virtual bool verifyBuffers(bufferCollection& buffers); 4655 4656 private: 4657 enum test_cases 4658 { 4659 TEST_VS = 0, 4660 TEST_TES, 4661 TEST_GS, 4662 4663 /* */ 4664 TEST_MAX 4665 }; 4666 }; 4667 4668 /** Implementation of test XFBCaptureStruct. Description follows: 4669 * 4670 * Test verifies that structures are captured as expected. 4671 * 4672 * This test implements Buffer algorithm. Rasterization can be disabled. Draw 4673 * two vertices instead of one. Test following code snippet: 4674 * 4675 * struct Goku { 4676 * vec4 gohan; 4677 * vec4 goten; 4678 * vec4 chichi; 4679 * }; 4680 * 4681 * layout (xfb_offset = 16) out Goku goku; 4682 * 4683 * goku.gohan = EXPECTED_VALUE; 4684 * goku.chichi = EXPECTED_VALUE; 4685 * 4686 * Test pass when captured values of gohan and chichi match expected values. 4687 * It is expected that goten will receive undefined value. 4688 * 4689 * Test all shader stages. 4690 **/ 4691 class XFBCaptureStructTest : public BufferTestBase 4692 { 4693 public: 4694 XFBCaptureStructTest(deqp::Context& context); 4695 ~XFBCaptureStructTest()4696 ~XFBCaptureStructTest() 4697 { 4698 } 4699 4700 protected: 4701 /* Protected methods */ 4702 using BufferTestBase::executeDrawCall; 4703 virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index); 4704 4705 virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors); 4706 4707 virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments, 4708 std::string& out_calculations); 4709 4710 virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage, 4711 std::string& out_interface); 4712 4713 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 4714 4715 virtual std::string getTestCaseName(glw::GLuint test_case_index); 4716 virtual glw::GLuint getTestCaseNumber(); 4717 virtual bool verifyBuffers(bufferCollection& buffers); 4718 4719 private: 4720 enum test_cases 4721 { 4722 TEST_VS = 0, 4723 TEST_TES, 4724 TEST_GS, 4725 4726 /* */ 4727 TEST_MAX 4728 }; 4729 }; 4730 4731 /** Implementation of test XFBCaptureUnsizedArray. Description follows: 4732 * 4733 * Test verifies this is not allowed to qualify unsized array with "xfb". 4734 * 4735 * Test following code snippet: 4736 * 4737 * layout (xfb_offset = 0) out vec4 goku[]; 4738 * 4739 * goku[0] = EXPECTED_VALUE; 4740 * 4741 * It is expected that compilation will fail. 4742 * 4743 * Test all shader stages. 4744 **/ 4745 class XFBCaptureUnsizedArrayTest : public NegativeTestBase 4746 { 4747 public: 4748 /* Public methods */ 4749 XFBCaptureUnsizedArrayTest(deqp::Context& context); ~XFBCaptureUnsizedArrayTest()4750 virtual ~XFBCaptureUnsizedArrayTest() 4751 { 4752 } 4753 4754 protected: 4755 /* Methods to be implemented by child class */ 4756 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 4757 4758 virtual std::string getTestCaseName(glw::GLuint test_case_index); 4759 virtual glw::GLuint getTestCaseNumber(); 4760 virtual bool isComputeRelevant(glw::GLuint test_case_index); 4761 virtual void testInit(); 4762 4763 private: 4764 /* Private types */ 4765 struct testCase 4766 { 4767 Utils::Shader::STAGES m_stage; 4768 }; 4769 4770 /* Private fields */ 4771 std::vector<testCase> m_test_cases; 4772 }; 4773 4774 /** Implementation of test XFBExplicitLocationTest. Description follows: 4775 * 4776 * Test verifies that explicit location on matrices and arrays does not impact xfb output. 4777 * 4778 * Test following code snippet: 4779 * 4780 * layout (location = 0, xfb_offset = 0) out vec2 goku[3]; 4781 * 4782 * Is expected to have the same output as: 4783 * 4784 * layout (xfb_offset = 0) out vec2 goku[3]; 4785 * 4786 * While explicit location does impact varyings layout of matrices and arrays, see 4787 * Ref. GLSL 4.60, Section 4.4.2. "Output Layout Qualifiers" - it shall not impact 4788 * xfb output. 4789 * 4790 * Test all shader stages. 4791 **/ 4792 class XFBExplicitLocationTest : public BufferTestBase 4793 { 4794 public: 4795 XFBExplicitLocationTest(deqp::Context& context); ~XFBExplicitLocationTest()4796 ~XFBExplicitLocationTest() 4797 { 4798 } 4799 4800 protected: 4801 /* Protected methods */ 4802 using BufferTestBase::executeDrawCall; 4803 4804 virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index); 4805 virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors); 4806 4807 virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments, 4808 std::string& out_calculations); 4809 4810 virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage, 4811 std::string& out_interface); 4812 4813 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 4814 4815 virtual std::string getTestCaseName(glw::GLuint test_case_index); 4816 virtual glw::GLuint getTestCaseNumber(); 4817 virtual void testInit(); 4818 4819 private: 4820 /* Private types */ 4821 struct testCase 4822 { 4823 Utils::Shader::STAGES m_stage; 4824 Utils::Type m_type; 4825 glw::GLuint m_array_size; 4826 }; 4827 4828 /* Private fields */ 4829 std::vector<testCase> m_test_cases; 4830 }; 4831 4832 /** Implementation of test XFBExplicitLocationStructTest. Description follows: 4833 * 4834 * Test verifies that explicit location on struct does not impact xfb output. 4835 * 4836 * Test following code snippet: 4837 * struct TestStruct { 4838 * float a; 4839 * double b; 4840 * }; 4841 * 4842 * layout (location = 0, xfb_offset = 0) flat out TestStruct goku; 4843 * 4844 * Is expected to have the same output as: 4845 * 4846 * layout (xfb_offset = 0) flat out TestStruct goku; 4847 * 4848 * While explicit location does impact varyings layout of structs, see 4849 * Ref. GLSL 4.60, Section 4.4.2. "Output Layout Qualifiers" - it shall not impact 4850 * xfb output. 4851 * 4852 * Test all shader stages. 4853 **/ 4854 class XFBExplicitLocationStructTest : public BufferTestBase 4855 { 4856 public: 4857 XFBExplicitLocationStructTest(deqp::Context& context); ~XFBExplicitLocationStructTest()4858 ~XFBExplicitLocationStructTest() 4859 { 4860 } 4861 4862 protected: 4863 /* Protected methods */ 4864 using BufferTestBase::executeDrawCall; 4865 4866 virtual bool executeDrawCall(bool tesEnabled, glw::GLuint test_case_index); 4867 virtual void getBufferDescriptors(glw::GLuint test_case_index, bufferDescriptor::Vector& out_descriptors); 4868 4869 virtual void getShaderBody(glw::GLuint test_case_index, Utils::Shader::STAGES stage, std::string& out_assignments, 4870 std::string& out_calculations); 4871 4872 virtual void getShaderInterface(glw::GLuint test_case_index, Utils::Shader::STAGES stage, 4873 std::string& out_interface); 4874 4875 virtual std::string getShaderSource(glw::GLuint test_case_index, Utils::Shader::STAGES stage); 4876 4877 virtual std::string getTestCaseName(glw::GLuint test_case_index); 4878 virtual glw::GLuint getTestCaseNumber(); 4879 virtual void testInit(); 4880 4881 private: 4882 /* Private types */ 4883 4884 struct testType 4885 { 4886 Utils::Type m_type; 4887 glw::GLuint m_array_size; 4888 }; 4889 4890 struct testCase 4891 { 4892 Utils::Shader::STAGES m_stage; 4893 std::vector<testType> m_types; 4894 bool m_nested_struct; 4895 }; 4896 4897 /* Private fields */ 4898 std::vector<testCase> m_test_cases; 4899 }; 4900 4901 } /* EnhancedLayouts namespace */ 4902 4903 /** Group class for Shader Language 420Pack conformance tests */ 4904 class EnhancedLayoutsTests : public deqp::TestCaseGroup 4905 { 4906 public: 4907 /* Public methods */ 4908 EnhancedLayoutsTests(deqp::Context& context); 4909 ~EnhancedLayoutsTests(void)4910 virtual ~EnhancedLayoutsTests(void) 4911 { 4912 } 4913 4914 virtual void init(void); 4915 4916 private: 4917 /* Private methods */ 4918 EnhancedLayoutsTests(const EnhancedLayoutsTests& other); 4919 EnhancedLayoutsTests& operator=(const EnhancedLayoutsTests& other); 4920 }; 4921 4922 } // gl4cts 4923 4924 #endif // _GL4CENHANCEDLAYOUTSTESTS_HPP 4925