1 #ifndef _VKTSHADERRENDER_HPP 2 #define _VKTSHADERRENDER_HPP 3 /*------------------------------------------------------------------------ 4 * Vulkan Conformance Tests 5 * ------------------------ 6 * 7 * Copyright (c) 2015 The Khronos Group Inc. 8 * Copyright (c) 2015 Samsung Electronics Co., Ltd. 9 * 10 * Licensed under the Apache License, Version 2.0 (the "License"); 11 * you may not use this file except in compliance with the License. 12 * You may obtain a copy of the License at 13 * 14 * http://www.apache.org/licenses/LICENSE-2.0 15 * 16 * Unless required by applicable law or agreed to in writing, software 17 * distributed under the License is distributed on an "AS IS" BASIS, 18 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 19 * See the License for the specific language governing permissions and 20 * limitations under the License. 21 * 22 *//*! 23 * \file 24 * \brief Vulkan ShaderRenderCase 25 *//*--------------------------------------------------------------------*/ 26 27 #include "tcuTexture.hpp" 28 #include "tcuSurface.hpp" 29 30 #include "deMemory.h" 31 #include "deSharedPtr.hpp" 32 #include "deUniquePtr.hpp" 33 34 #include "vkDefs.hpp" 35 #include "vkRefUtil.hpp" 36 #include "vkPrograms.hpp" 37 #include "vkRef.hpp" 38 #include "vkMemUtil.hpp" 39 #include "vkBuilderUtil.hpp" 40 #include "vkTypeUtil.hpp" 41 #include "vkPlatform.hpp" 42 43 #include "vktTestCaseUtil.hpp" 44 45 namespace vkt 46 { 47 namespace sr 48 { 49 50 class LineStream 51 { 52 public: 53 LineStream (int indent = 0) { m_indent = indent; } 54 ~LineStream (void) {} 55 56 const char* str (void) const { m_string = m_stream.str(); return m_string.c_str(); } 57 LineStream& operator<< (const char* line) { for (int i = 0; i < m_indent; i++) { m_stream << "\t"; } m_stream << line << "\n"; return *this; } 58 59 private: 60 int m_indent; 61 std::ostringstream m_stream; 62 mutable std::string m_string; 63 }; 64 65 class QuadGrid; 66 class ShaderRenderCaseInstance; 67 68 class TextureBinding 69 { 70 public: 71 enum Type 72 { 73 TYPE_NONE = 0, 74 TYPE_1D, 75 TYPE_2D, 76 TYPE_3D, 77 TYPE_CUBE_MAP, 78 TYPE_1D_ARRAY, 79 TYPE_2D_ARRAY, 80 TYPE_CUBE_ARRAY, 81 82 TYPE_LAST 83 }; 84 85 enum Init 86 { 87 INIT_UPLOAD_DATA, 88 INIT_CLEAR, 89 90 INIT_LAST 91 }; 92 93 struct Parameters 94 { 95 deUint32 baseMipLevel; 96 vk::VkComponentMapping componentMapping; 97 vk::VkSampleCountFlagBits samples; 98 Init initialization; 99 100 Parameters (deUint32 baseMipLevel_ = 0, 101 vk::VkComponentMapping componentMapping_ = vk::makeComponentMappingRGBA(), 102 vk::VkSampleCountFlagBits samples_ = vk::VK_SAMPLE_COUNT_1_BIT, 103 Init initialization_ = INIT_UPLOAD_DATA) 104 : baseMipLevel (baseMipLevel_) 105 , componentMapping (componentMapping_) 106 , samples (samples_) 107 , initialization (initialization_) 108 { 109 } 110 }; 111 112 TextureBinding (const tcu::Archive& archive, 113 const char* filename, 114 const Type type, 115 const tcu::Sampler& sampler); 116 117 TextureBinding (const tcu::Texture1D* tex1D, const tcu::Sampler& sampler); 118 TextureBinding (const tcu::Texture2D* tex2D, const tcu::Sampler& sampler); 119 TextureBinding (const tcu::Texture3D* tex3D, const tcu::Sampler& sampler); 120 TextureBinding (const tcu::TextureCube* texCube, const tcu::Sampler& sampler); 121 TextureBinding (const tcu::Texture1DArray* tex1DArray, const tcu::Sampler& sampler); 122 TextureBinding (const tcu::Texture2DArray* tex2DArray, const tcu::Sampler& sampler); 123 TextureBinding (const tcu::TextureCubeArray* texCubeArray, const tcu::Sampler& sampler); 124 125 ~TextureBinding (void); 126 127 Type getType (void) const { return m_type; } 128 const tcu::Sampler& getSampler (void) const { return m_sampler; } 129 130 const tcu::Texture1D& get1D (void) const { DE_ASSERT(getType() == TYPE_1D && m_binding.tex1D != NULL); return *m_binding.tex1D; } 131 const tcu::Texture2D& get2D (void) const { DE_ASSERT(getType() == TYPE_2D && m_binding.tex2D != NULL); return *m_binding.tex2D; } 132 const tcu::Texture3D& get3D (void) const { DE_ASSERT(getType() == TYPE_3D && m_binding.tex3D != NULL); return *m_binding.tex3D; } 133 const tcu::TextureCube& getCube (void) const { DE_ASSERT(getType() == TYPE_CUBE_MAP && m_binding.texCube != NULL); return *m_binding.texCube; } 134 const tcu::Texture1DArray& get1DArray (void) const { DE_ASSERT(getType() == TYPE_1D_ARRAY && m_binding.tex1DArray != NULL); return *m_binding.tex1DArray; } 135 const tcu::Texture2DArray& get2DArray (void) const { DE_ASSERT(getType() == TYPE_2D_ARRAY && m_binding.tex2DArray != NULL); return *m_binding.tex2DArray; } 136 const tcu::TextureCubeArray& getCubeArray (void) const { DE_ASSERT(getType() == TYPE_CUBE_ARRAY && m_binding.texCubeArray != NULL); return *m_binding.texCubeArray; } 137 138 void setParameters (const Parameters& params) { m_params = params; } 139 const Parameters& getParameters (void) const { return m_params; } 140 141 private: 142 TextureBinding (const TextureBinding&); // not allowed! 143 TextureBinding& operator= (const TextureBinding&); // not allowed! 144 145 static de::MovePtr<tcu::Texture2D> loadTexture2D (const tcu::Archive& archive, const char* filename); 146 147 Type m_type; 148 tcu::Sampler m_sampler; 149 Parameters m_params; 150 151 union 152 { 153 const tcu::Texture1D* tex1D; 154 const tcu::Texture2D* tex2D; 155 const tcu::Texture3D* tex3D; 156 const tcu::TextureCube* texCube; 157 const tcu::Texture1DArray* tex1DArray; 158 const tcu::Texture2DArray* tex2DArray; 159 const tcu::TextureCubeArray* texCubeArray; 160 } m_binding; 161 }; 162 163 typedef de::SharedPtr<TextureBinding> TextureBindingSp; 164 165 // ShaderEvalContext. 166 167 class ShaderEvalContext 168 { 169 public: 170 // Limits. 171 enum 172 { 173 MAX_USER_ATTRIBS = 4, 174 MAX_TEXTURES = 4 175 }; 176 177 struct ShaderSampler 178 { 179 tcu::Sampler sampler; 180 const tcu::Texture1D* tex1D; 181 const tcu::Texture2D* tex2D; 182 const tcu::Texture3D* tex3D; 183 const tcu::TextureCube* texCube; 184 const tcu::Texture1DArray* tex1DArray; 185 const tcu::Texture2DArray* tex2DArray; 186 const tcu::TextureCubeArray* texCubeArray; 187 188 inline ShaderSampler (void) 189 : tex1D (DE_NULL) 190 , tex2D (DE_NULL) 191 , tex3D (DE_NULL) 192 , texCube (DE_NULL) 193 , tex1DArray (DE_NULL) 194 , tex2DArray (DE_NULL) 195 , texCubeArray (DE_NULL) 196 { 197 } 198 }; 199 200 ShaderEvalContext (const QuadGrid& quadGrid); 201 ~ShaderEvalContext (void); 202 203 void reset (float sx, float sy); 204 205 // Inputs. 206 tcu::Vec4 coords; 207 tcu::Vec4 unitCoords; 208 tcu::Vec4 constCoords; 209 210 tcu::Vec4 in[MAX_USER_ATTRIBS]; 211 ShaderSampler textures[MAX_TEXTURES]; 212 213 // Output. 214 tcu::Vec4 color; 215 bool isDiscarded; 216 217 // Functions. 218 inline void discard (void) { isDiscarded = true; } 219 tcu::Vec4 texture2D (int unitNdx, const tcu::Vec2& coords); 220 221 private: 222 const QuadGrid& m_quadGrid; 223 }; 224 225 typedef void (*ShaderEvalFunc) (ShaderEvalContext& c); 226 227 inline void evalCoordsPassthroughX (ShaderEvalContext& c) { c.color.x() = c.coords.x(); } 228 inline void evalCoordsPassthroughXY (ShaderEvalContext& c) { c.color.xy() = c.coords.swizzle(0,1); } 229 inline void evalCoordsPassthroughXYZ (ShaderEvalContext& c) { c.color.xyz() = c.coords.swizzle(0,1,2); } 230 inline void evalCoordsPassthrough (ShaderEvalContext& c) { c.color = c.coords; } 231 inline void evalCoordsSwizzleWZYX (ShaderEvalContext& c) { c.color = c.coords.swizzle(3,2,1,0); } 232 233 // ShaderEvaluator 234 // Either inherit a class with overridden evaluate() or just pass in an evalFunc. 235 236 class ShaderEvaluator 237 { 238 public: 239 ShaderEvaluator (void); 240 ShaderEvaluator (const ShaderEvalFunc evalFunc); 241 virtual ~ShaderEvaluator (void); 242 243 virtual void evaluate (ShaderEvalContext& ctx) const; 244 245 private: 246 ShaderEvaluator (const ShaderEvaluator&); // not allowed! 247 ShaderEvaluator& operator= (const ShaderEvaluator&); // not allowed! 248 249 const ShaderEvalFunc m_evalFunc; 250 }; 251 252 // UniformSetup 253 254 typedef void (*UniformSetupFunc) (ShaderRenderCaseInstance& instance, const tcu::Vec4& constCoords); 255 256 class UniformSetup 257 { 258 public: 259 UniformSetup (void); 260 UniformSetup (const UniformSetupFunc setup); 261 virtual ~UniformSetup (void); 262 virtual void setup (ShaderRenderCaseInstance& instance, const tcu::Vec4& constCoords) const; 263 264 private: 265 UniformSetup (const UniformSetup&); // not allowed! 266 UniformSetup& operator= (const UniformSetup&); // not allowed! 267 268 const UniformSetupFunc m_setupFunc; 269 }; 270 271 typedef void (*AttributeSetupFunc) (ShaderRenderCaseInstance& instance, deUint32 numVertices); 272 273 class ShaderRenderCase : public vkt::TestCase 274 { 275 public: 276 ShaderRenderCase (tcu::TestContext& testCtx, 277 const std::string& name, 278 const std::string& description, 279 const bool isVertexCase, 280 const ShaderEvalFunc evalFunc, 281 const UniformSetup* uniformSetup, 282 const AttributeSetupFunc attribFunc); 283 284 ShaderRenderCase (tcu::TestContext& testCtx, 285 const std::string& name, 286 const std::string& description, 287 const bool isVertexCase, 288 const ShaderEvaluator* evaluator, 289 const UniformSetup* uniformSetup, 290 const AttributeSetupFunc attribFunc); 291 292 virtual ~ShaderRenderCase (void); 293 virtual void initPrograms (vk::SourceCollections& programCollection) const; 294 virtual TestInstance* createInstance (Context& context) const; 295 296 protected: 297 std::string m_vertShaderSource; 298 std::string m_fragShaderSource; 299 300 const bool m_isVertexCase; 301 const de::UniquePtr<const ShaderEvaluator> m_evaluator; 302 const de::UniquePtr<const UniformSetup> m_uniformSetup; 303 const AttributeSetupFunc m_attribFunc; 304 }; 305 306 enum BaseUniformType 307 { 308 // Bool 309 UB_FALSE, 310 UB_TRUE, 311 312 // BVec4 313 UB4_FALSE, 314 UB4_TRUE, 315 316 // Integers 317 UI_ZERO, 318 UI_ONE, 319 UI_TWO, 320 UI_THREE, 321 UI_FOUR, 322 UI_FIVE, 323 UI_SIX, 324 UI_SEVEN, 325 UI_EIGHT, 326 UI_ONEHUNDREDONE, 327 328 // IVec2 329 UI2_MINUS_ONE, 330 UI2_ZERO, 331 UI2_ONE, 332 UI2_TWO, 333 UI2_THREE, 334 UI2_FOUR, 335 UI2_FIVE, 336 337 // IVec3 338 UI3_MINUS_ONE, 339 UI3_ZERO, 340 UI3_ONE, 341 UI3_TWO, 342 UI3_THREE, 343 UI3_FOUR, 344 UI3_FIVE, 345 346 // IVec4 347 UI4_MINUS_ONE, 348 UI4_ZERO, 349 UI4_ONE, 350 UI4_TWO, 351 UI4_THREE, 352 UI4_FOUR, 353 UI4_FIVE, 354 355 // Float 356 UF_ZERO, 357 UF_ONE, 358 UF_TWO, 359 UF_THREE, 360 UF_FOUR, 361 UF_FIVE, 362 UF_SIX, 363 UF_SEVEN, 364 UF_EIGHT, 365 366 UF_HALF, 367 UF_THIRD, 368 UF_FOURTH, 369 UF_FIFTH, 370 UF_SIXTH, 371 UF_SEVENTH, 372 UF_EIGHTH, 373 374 // Vec2 375 UV2_MINUS_ONE, 376 UV2_ZERO, 377 UV2_ONE, 378 UV2_TWO, 379 UV2_THREE, 380 381 UV2_HALF, 382 383 // Vec3 384 UV3_MINUS_ONE, 385 UV3_ZERO, 386 UV3_ONE, 387 UV3_TWO, 388 UV3_THREE, 389 390 UV3_HALF, 391 392 // Vec4 393 UV4_MINUS_ONE, 394 UV4_ZERO, 395 UV4_ONE, 396 UV4_TWO, 397 UV4_THREE, 398 399 UV4_HALF, 400 401 UV4_BLACK, 402 UV4_GRAY, 403 UV4_WHITE, 404 405 // Last 406 U_LAST 407 }; 408 409 enum BaseAttributeType 410 { 411 // User attributes 412 A_IN0, 413 A_IN1, 414 A_IN2, 415 A_IN3, 416 417 // Matrices 418 MAT2, 419 MAT2x3, 420 MAT2x4, 421 MAT3x2, 422 MAT3, 423 MAT3x4, 424 MAT4x2, 425 MAT4x3, 426 MAT4 427 }; 428 429 // ShaderRenderCaseInstance. 430 431 class ShaderRenderCaseInstance : public vkt::TestInstance 432 { 433 public: 434 enum ImageBackingMode 435 { 436 IMAGE_BACKING_MODE_REGULAR = 0, 437 IMAGE_BACKING_MODE_SPARSE, 438 }; 439 440 ShaderRenderCaseInstance (Context& context); 441 ShaderRenderCaseInstance (Context& context, 442 const bool isVertexCase, 443 const ShaderEvaluator& evaluator, 444 const UniformSetup& uniformSetup, 445 const AttributeSetupFunc attribFunc, 446 const ImageBackingMode imageBackingMode = IMAGE_BACKING_MODE_REGULAR); 447 448 virtual ~ShaderRenderCaseInstance (void); 449 virtual tcu::TestStatus iterate (void); 450 451 void addAttribute (deUint32 bindingLocation, 452 vk::VkFormat format, 453 deUint32 sizePerElement, 454 deUint32 count, 455 const void* data); 456 void useAttribute (deUint32 bindingLocation, 457 BaseAttributeType type); 458 459 template<typename T> 460 void addUniform (deUint32 bindingLocation, 461 vk::VkDescriptorType descriptorType, 462 const T& data); 463 void addUniform (deUint32 bindingLocation, 464 vk::VkDescriptorType descriptorType, 465 size_t dataSize, 466 const void* data); 467 void useUniform (deUint32 bindingLocation, 468 BaseUniformType type); 469 void useSampler (deUint32 bindingLocation, 470 deUint32 textureId); 471 472 static const tcu::Vec4 getDefaultConstCoords (void) { return tcu::Vec4(0.125f, 0.25f, 0.5f, 1.0f); } 473 void setPushConstantRanges (const deUint32 rangeCount, const vk::VkPushConstantRange* const pcRanges); 474 virtual void updatePushConstants (vk::VkCommandBuffer commandBuffer, vk::VkPipelineLayout pipelineLayout); 475 476 protected: 477 ShaderRenderCaseInstance (Context& context, 478 const bool isVertexCase, 479 const ShaderEvaluator* evaluator, 480 const UniformSetup* uniformSetup, 481 const AttributeSetupFunc attribFunc, 482 const ImageBackingMode imageBackingMode = IMAGE_BACKING_MODE_REGULAR); 483 484 virtual void setup (void); 485 virtual void setupUniforms (const tcu::Vec4& constCoords); 486 virtual void setupDefaultInputs (void); 487 488 void render (deUint32 numVertices, 489 deUint32 numTriangles, 490 const deUint16* indices, 491 const tcu::Vec4& constCoords = getDefaultConstCoords()); 492 493 void render (deUint32 numVertices, 494 deUint32 numIndices, 495 const deUint16* indices, 496 vk::VkPrimitiveTopology topology, 497 const tcu::Vec4& constCoords = getDefaultConstCoords()); 498 499 const tcu::TextureLevel& getResultImage (void) const { return m_resultImage; } 500 501 const tcu::UVec2 getViewportSize (void) const; 502 503 void setSampleCount (vk::VkSampleCountFlagBits sampleCount); 504 505 bool isMultiSampling (void) const; 506 507 ImageBackingMode m_imageBackingMode; 508 private: 509 510 struct SparseContext 511 { 512 SparseContext (vkt::Context& context); 513 514 vkt::Context& m_context; 515 const deUint32 m_queueFamilyIndex; 516 vk::Unique<vk::VkDevice> m_device; 517 vk::DeviceDriver m_deviceInterface; 518 vk::VkQueue m_queue; 519 const de::UniquePtr<vk::Allocator> m_allocator; 520 private: 521 vk::Move<vk::VkDevice> createDevice (void) const; 522 vk::Allocator* createAllocator (void) const; 523 524 }; 525 526 de::UniquePtr<SparseContext> m_sparseContext; 527 protected: 528 vk::Allocator& m_memAlloc; 529 const tcu::Vec4 m_clearColor; 530 const bool m_isVertexCase; 531 532 std::vector<tcu::Mat4> m_userAttribTransforms; 533 std::vector<TextureBindingSp> m_textures; 534 535 std::string m_vertexShaderName; 536 std::string m_fragmentShaderName; 537 tcu::UVec2 m_renderSize; 538 vk::VkFormat m_colorFormat; 539 540 private: 541 typedef std::vector<tcu::ConstPixelBufferAccess> TextureLayerData; 542 typedef std::vector<TextureLayerData> TextureData; 543 544 void uploadImage (const tcu::TextureFormat& texFormat, 545 const TextureData& textureData, 546 const tcu::Sampler& refSampler, 547 deUint32 mipLevels, 548 deUint32 arrayLayers, 549 vk::VkImage destImage); 550 551 void clearImage (const tcu::Sampler& refSampler, 552 deUint32 mipLevels, 553 deUint32 arrayLayers, 554 vk::VkImage destImage); 555 556 void checkSparseSupport (const vk::VkImageType imageType) const; 557 558 void uploadSparseImage (const tcu::TextureFormat& texFormat, 559 const TextureData& textureData, 560 const tcu::Sampler& refSampler, 561 const deUint32 mipLevels, 562 const deUint32 arrayLayers, 563 const vk::VkImage sparseImage, 564 const vk::VkImageCreateInfo& imageCreateInfo, 565 const tcu::UVec3 texSize); 566 567 void createSamplerUniform (deUint32 bindingLocation, 568 TextureBinding::Type textureType, 569 TextureBinding::Init textureInit, 570 const tcu::TextureFormat& texFormat, 571 const tcu::UVec3 texSize, 572 const TextureData& textureData, 573 const tcu::Sampler& refSampler, 574 deUint32 mipLevels, 575 deUint32 arrayLayers, 576 TextureBinding::Parameters textureParams); 577 578 void setupUniformData (deUint32 bindingLocation, size_t size, const void* dataPtr); 579 580 void computeVertexReference (tcu::Surface& result, const QuadGrid& quadGrid); 581 void computeFragmentReference (tcu::Surface& result, const QuadGrid& quadGrid); 582 bool compareImages (const tcu::Surface& resImage, 583 const tcu::Surface& refImage, 584 float errorThreshold); 585 586 private: 587 const ShaderEvaluator* m_evaluator; 588 const UniformSetup* m_uniformSetup; 589 const AttributeSetupFunc m_attribFunc; 590 de::MovePtr<QuadGrid> m_quadGrid; 591 tcu::TextureLevel m_resultImage; 592 593 struct EnabledBaseAttribute 594 { 595 deUint32 location; 596 BaseAttributeType type; 597 }; 598 std::vector<EnabledBaseAttribute> m_enabledBaseAttributes; 599 600 de::MovePtr<vk::DescriptorSetLayoutBuilder> m_descriptorSetLayoutBuilder; 601 de::MovePtr<vk::DescriptorPoolBuilder> m_descriptorPoolBuilder; 602 de::MovePtr<vk::DescriptorSetUpdateBuilder> m_descriptorSetUpdateBuilder; 603 604 typedef de::SharedPtr<vk::Unique<vk::VkBuffer> > VkBufferSp; 605 typedef de::SharedPtr<vk::Unique<vk::VkImage> > VkImageSp; 606 typedef de::SharedPtr<vk::Unique<vk::VkImageView> > VkImageViewSp; 607 typedef de::SharedPtr<vk::Unique<vk::VkSampler> > VkSamplerSp; 608 typedef de::SharedPtr<vk::Allocation> AllocationSp; 609 610 class UniformInfo 611 { 612 public: 613 UniformInfo (void) {} 614 virtual ~UniformInfo (void) {} 615 616 vk::VkDescriptorType type; 617 deUint32 location; 618 }; 619 620 class BufferUniform : public UniformInfo 621 { 622 public: 623 BufferUniform (void) {} 624 virtual ~BufferUniform (void) {} 625 626 VkBufferSp buffer; 627 AllocationSp alloc; 628 vk::VkDescriptorBufferInfo descriptor; 629 }; 630 631 class SamplerUniform : public UniformInfo 632 { 633 public: 634 SamplerUniform (void) {} 635 virtual ~SamplerUniform (void) {} 636 637 VkImageSp image; 638 VkImageViewSp imageView; 639 VkSamplerSp sampler; 640 AllocationSp alloc; 641 vk::VkDescriptorImageInfo descriptor; 642 }; 643 644 typedef de::SharedPtr<de::UniquePtr<UniformInfo> > UniformInfoSp; 645 std::vector<UniformInfoSp> m_uniformInfos; 646 647 std::vector< de::SharedPtr<vk::Allocation> > m_allocations; 648 649 std::vector<vk::VkVertexInputBindingDescription> m_vertexBindingDescription; 650 std::vector<vk::VkVertexInputAttributeDescription> m_vertexAttributeDescription; 651 652 std::vector<VkBufferSp> m_vertexBuffers; 653 std::vector<AllocationSp> m_vertexBufferAllocs; 654 655 vk::VkSampleCountFlagBits m_sampleCount; 656 std::vector<vk::VkPushConstantRange> m_pushConstantRanges; 657 658 // Wrapper functions around m_context calls to support sparse cases. 659 vk::VkDevice getDevice (void) const; 660 deUint32 getUniversalQueueFamilyIndex (void) const; 661 const vk::DeviceInterface& getDeviceInterface (void) const; 662 vk::VkQueue getUniversalQueue (void) const; 663 vk::VkPhysicalDevice getPhysicalDevice (void) const; 664 const vk::InstanceInterface& getInstanceInterface (void) const; 665 SparseContext* createSparseContext (void) const; 666 vk::Allocator& getAllocator (void) const; 667 }; 668 669 template<typename T> 670 void ShaderRenderCaseInstance::addUniform (deUint32 bindingLocation, vk::VkDescriptorType descriptorType, const T& data) 671 { 672 addUniform(bindingLocation, descriptorType, sizeof(T), &data); 673 } 674 675 } // sr 676 } // vkt 677 678 #endif // _VKTSHADERRENDER_HPP 679
