external/vulkancts/modules/vulkan/shaderrender/vktShaderRender.hpp

   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         // Default wertex and fragment grid sizes are used by a large collection of tests
 441         // to generate input sets. Some tests might change their behavior if the
 442         // default grid size values are altered, so care should be taken to confirm that
 443         // any changes to default values do not produce regressions.
 444         // If a particular tests needs to use a different grid size value, rather than
 445         // modifying the default grid size values for all tests, it is recommended that
 446         // the test specifies the required grid size using the gridSize parameter in the
 447         // ShaderRenderCaseInstance constuctor instead.
 448         enum
 449         {
 450                 GRID_SIZE_DEFAULTS                      = 0,
 451                 GRID_SIZE_DEFAULT_VERTEX        = 90,
 452                 GRID_SIZE_DEFAULT_FRAGMENT      = 4,
 453         };
 454
 455                                                                                                                 ShaderRenderCaseInstance        (Context&                                       context);
 456                                                                                                                 ShaderRenderCaseInstance        (Context&                                       context,
 457                                                                                                                                                                         const bool                                      isVertexCase,
 458                                                                                                                                                                         const ShaderEvaluator&          evaluator,
 459                                                                                                                                                                         const UniformSetup&                     uniformSetup,
 460                                                                                                                                                                         const AttributeSetupFunc        attribFunc,
 461                                                                                                                                                                         const ImageBackingMode          imageBackingMode = IMAGE_BACKING_MODE_REGULAR,
 462                                                                                                                                                                         const deUint32                          gridSize = static_cast<deUint32>(GRID_SIZE_DEFAULTS));
 463
 464         virtual                                                                                         ~ShaderRenderCaseInstance       (void);
 465         virtual tcu::TestStatus                                                         iterate                                         (void);
 466
 467         void                                                                                            addAttribute                            (deUint32                       bindingLocation,
 468                                                                                                                                                                         vk::VkFormat            format,
 469                                                                                                                                                                         deUint32                        sizePerElement,
 470                                                                                                                                                                         deUint32                        count,
 471                                                                                                                                                                         const void*                     data);
 472         void                                                                                            useAttribute                            (deUint32                       bindingLocation,
 473                                                                                                                                                                         BaseAttributeType       type);
 474
 475         template<typename T>
 476         void                                                                                            addUniform                                      (deUint32                               bindingLocation,
 477                                                                                                                                                                         vk::VkDescriptorType    descriptorType,
 478                                                                                                                                                                         const T&                                data);
 479         void                                                                                            addUniform                                      (deUint32                               bindingLocation,
 480                                                                                                                                                                         vk::VkDescriptorType    descriptorType,
 481                                                                                                                                                                         size_t                                  dataSize,
 482                                                                                                                                                                         const void*                             data);
 483         void                                                                                            useUniform                                      (deUint32                               bindingLocation,
 484                                                                                                                                                                         BaseUniformType                 type);
 485         void                                                                                            useSampler                                      (deUint32                               bindingLocation,
 486                                                                                                                                                                         deUint32                                textureId);
 487
 488         static const tcu::Vec4                                                          getDefaultConstCoords           (void) { return tcu::Vec4(0.125f, 0.25f, 0.5f, 1.0f); }
 489         void                                                                                            setPushConstantRanges           (const deUint32 rangeCount, const vk::VkPushConstantRange* const pcRanges);
 490         virtual void                                                                            updatePushConstants                     (vk::VkCommandBuffer commandBuffer, vk::VkPipelineLayout pipelineLayout);
 491
 492 protected:
 493                                                                                                                 ShaderRenderCaseInstance        (Context&                                       context,
 494                                                                                                                                                                          const bool                                     isVertexCase,
 495                                                                                                                                                                          const ShaderEvaluator*         evaluator,
 496                                                                                                                                                                          const UniformSetup*            uniformSetup,
 497                                                                                                                                                                          const AttributeSetupFunc       attribFunc,
 498                                                                                                                                                                          const ImageBackingMode         imageBackingMode = IMAGE_BACKING_MODE_REGULAR,
 499                                                                                                                                                                          const deUint32                         gridSize = static_cast<deUint32>(GRID_SIZE_DEFAULTS));
 500
 501         virtual void                                                                            setup                                           (void);
 502         virtual void                                                                            setupUniforms                           (const tcu::Vec4& constCoords);
 503         virtual void                                                                            setupDefaultInputs                      (void);
 504
 505         void                                                                                            render                                          (deUint32                                       numVertices,
 506                                                                                                                                                                          deUint32                                       numTriangles,
 507                                                                                                                                                                          const deUint16*                        indices,
 508                                                                                                                                                                          const tcu::Vec4&                       constCoords             = getDefaultConstCoords());
 509
 510         void                                                                                            render                                          (deUint32                                       numVertices,
 511                                                                                                                                                                          deUint32                                       numIndices,
 512                                                                                                                                                                          const deUint16*                        indices,
 513                                                                                                                                                                          vk::VkPrimitiveTopology        topology,
 514                                                                                                                                                                          const tcu::Vec4&                       constCoords             = getDefaultConstCoords());
 515
 516         const tcu::TextureLevel&                                                        getResultImage                          (void) const { return m_resultImage; }
 517
 518         const tcu::UVec2                                                                        getViewportSize                         (void) const;
 519
 520         void                                                                                            setSampleCount                          (vk::VkSampleCountFlagBits sampleCount);
 521
 522         bool                                                                                            isMultiSampling                         (void) const;
 523
 524         ImageBackingMode                                                                        m_imageBackingMode;
 525
 526         deUint32                                                                                        m_quadGridSize;
 527 private:
 528
 529         struct SparseContext
 530         {
 531                                                                                         SparseContext   (vkt::Context& context);
 532
 533                 vkt::Context&                                           m_context;
 534                 const deUint32                                          m_queueFamilyIndex;
 535                 vk::Unique<vk::VkDevice>                        m_device;
 536                 vk::DeviceDriver                                        m_deviceInterface;
 537                 const vk::VkQueue                                       m_queue;
 538                 const de::UniquePtr<vk::Allocator>      m_allocator;
 539         private:
 540                 vk::Move<vk::VkDevice>                          createDevice    (void) const;
 541                 vk::Allocator*                                          createAllocator (void) const;
 542
 543         };
 544
 545         de::UniquePtr<SparseContext>                                            m_sparseContext;
 546 protected:
 547         vk::Allocator&                                                                          m_memAlloc;
 548         const tcu::Vec4                                                                         m_clearColor;
 549         const bool                                                                                      m_isVertexCase;
 550
 551         std::vector<tcu::Mat4>                                                          m_userAttribTransforms;
 552         std::vector<TextureBindingSp>                                           m_textures;
 553
 554         std::string                                                                                     m_vertexShaderName;
 555         std::string                                                                                     m_fragmentShaderName;
 556         tcu::UVec2                                                                                      m_renderSize;
 557         vk::VkFormat                                                                            m_colorFormat;
 558
 559 private:
 560         typedef std::vector<tcu::ConstPixelBufferAccess>        TextureLayerData;
 561         typedef std::vector<TextureLayerData>                           TextureData;
 562
 563         void                                                                                            uploadImage                                     (const tcu::TextureFormat&              texFormat,
 564                                                                                                                                                                          const TextureData&                             textureData,
 565                                                                                                                                                                          const tcu::Sampler&                    refSampler,
 566                                                                                                                                                                          deUint32                                               mipLevels,
 567                                                                                                                                                                          deUint32                                               arrayLayers,
 568                                                                                                                                                                          vk::VkImage                                    destImage);
 569
 570         void                                                                                            clearImage                                      (const tcu::Sampler&                    refSampler,
 571                                                                                                                                                                          deUint32                                               mipLevels,
 572                                                                                                                                                                          deUint32                                               arrayLayers,
 573                                                                                                                                                                          vk::VkImage                                    destImage);
 574
 575         void                                                                                            checkSparseSupport                      (const vk::VkImageCreateInfo&   imageInfo) const;
 576
 577         void                                                                                            uploadSparseImage                       (const tcu::TextureFormat&              texFormat,
 578                                                                                                                                                                          const TextureData&                             textureData,
 579                                                                                                                                                                          const tcu::Sampler&                    refSampler,
 580                                                                                                                                                                          const deUint32                                 mipLevels,
 581                                                                                                                                                                          const deUint32                                 arrayLayers,
 582                                                                                                                                                                          const vk::VkImage                              sparseImage,
 583                                                                                                                                                                          const vk::VkImageCreateInfo&   imageCreateInfo,
 584                                                                                                                                                                          const tcu::UVec3                               texSize);
 585
 586         void                                                                                            createSamplerUniform            (deUint32                                               bindingLocation,
 587                                                                                                                                                                          TextureBinding::Type                   textureType,
 588                                                                                                                                                                          TextureBinding::Init                   textureInit,
 589                                                                                                                                                                          const tcu::TextureFormat&              texFormat,
 590                                                                                                                                                                          const tcu::UVec3                               texSize,
 591                                                                                                                                                                          const TextureData&                             textureData,
 592                                                                                                                                                                          const tcu::Sampler&                    refSampler,
 593                                                                                                                                                                          deUint32                                               mipLevels,
 594                                                                                                                                                                          deUint32                                               arrayLayers,
 595                                                                                                                                                                          TextureBinding::Parameters             textureParams);
 596
 597         void                                                                                            setupUniformData                        (deUint32 bindingLocation, size_t size, const void* dataPtr);
 598
 599         void                                                                                            computeVertexReference          (tcu::Surface& result, const QuadGrid& quadGrid);
 600         void                                                                                            computeFragmentReference        (tcu::Surface& result, const QuadGrid& quadGrid);
 601         bool                                                                                            compareImages                           (const tcu::Surface&    resImage,
 602                                                                                                                                                                          const tcu::Surface&    refImage,
 603                                                                                                                                                                          float                                  errorThreshold);
 604
 605 private:
 606         const ShaderEvaluator*                                                          m_evaluator;
 607         const UniformSetup*                                                                     m_uniformSetup;
 608         const AttributeSetupFunc                                                        m_attribFunc;
 609         de::MovePtr<QuadGrid>                                                           m_quadGrid;
 610         tcu::TextureLevel                                                                       m_resultImage;
 611
 612         struct EnabledBaseAttribute
 613         {
 614                 deUint32                        location;
 615                 BaseAttributeType       type;
 616         };
 617         std::vector<EnabledBaseAttribute>                                       m_enabledBaseAttributes;
 618
 619         de::MovePtr<vk::DescriptorSetLayoutBuilder>                     m_descriptorSetLayoutBuilder;
 620         de::MovePtr<vk::DescriptorPoolBuilder>                          m_descriptorPoolBuilder;
 621         de::MovePtr<vk::DescriptorSetUpdateBuilder>                     m_descriptorSetUpdateBuilder;
 622
 623         typedef de::SharedPtr<vk::Unique<vk::VkBuffer> >                VkBufferSp;
 624         typedef de::SharedPtr<vk::Unique<vk::VkImage> >                 VkImageSp;
 625         typedef de::SharedPtr<vk::Unique<vk::VkImageView> >             VkImageViewSp;
 626         typedef de::SharedPtr<vk::Unique<vk::VkSampler> >               VkSamplerSp;
 627         typedef de::SharedPtr<vk::Allocation>                                   AllocationSp;
 628
 629         class UniformInfo
 630         {
 631         public:
 632                                                                         UniformInfo             (void) {}
 633                 virtual                                         ~UniformInfo    (void) {}
 634
 635                 vk::VkDescriptorType            type;
 636                 deUint32                                        location;
 637         };
 638
 639         class BufferUniform : public UniformInfo
 640         {
 641         public:
 642                                                                         BufferUniform   (void) {}
 643                 virtual                                         ~BufferUniform  (void) {}
 644
 645                 VkBufferSp                                      buffer;
 646                 AllocationSp                            alloc;
 647                 vk::VkDescriptorBufferInfo      descriptor;
 648         };
 649
 650         class SamplerUniform : public UniformInfo
 651         {
 652         public:
 653                                                                         SamplerUniform  (void) {}
 654                 virtual                                         ~SamplerUniform (void) {}
 655
 656                 VkImageSp                                       image;
 657                 VkImageViewSp                           imageView;
 658                 VkSamplerSp                                     sampler;
 659                 AllocationSp                            alloc;
 660                 vk::VkDescriptorImageInfo       descriptor;
 661         };
 662
 663         typedef de::SharedPtr<de::UniquePtr<UniformInfo> >      UniformInfoSp;
 664         std::vector<UniformInfoSp>                                                      m_uniformInfos;
 665
 666         std::vector< de::SharedPtr<vk::Allocation> >            m_allocations;
 667
 668         std::vector<vk::VkVertexInputBindingDescription>        m_vertexBindingDescription;
 669         std::vector<vk::VkVertexInputAttributeDescription>      m_vertexAttributeDescription;
 670
 671         std::vector<VkBufferSp>                                                         m_vertexBuffers;
 672         std::vector<AllocationSp>                                                       m_vertexBufferAllocs;
 673
 674         vk::VkSampleCountFlagBits                                                       m_sampleCount;
 675         std::vector<vk::VkPushConstantRange>                            m_pushConstantRanges;
 676
 677         // Wrapper functions around m_context calls to support sparse cases.
 678         vk::VkDevice                                                                            getDevice                                               (void) const;
 679         deUint32                                                                                        getUniversalQueueFamilyIndex    (void) const;
 680         const vk::DeviceInterface&                                                      getDeviceInterface                              (void) const;
 681         vk::VkQueue                                                                                     getUniversalQueue                               (void) const;
 682         vk::VkPhysicalDevice                                                            getPhysicalDevice                               (void) const;
 683         const vk::InstanceInterface&                                            getInstanceInterface                    (void) const;
 684         SparseContext*                                                                          createSparseContext                             (void) const;
 685         vk::Allocator&                                                                          getAllocator                                    (void) const;
 686 };
 687
 688 template<typename T>
 689 void ShaderRenderCaseInstance::addUniform (deUint32 bindingLocation, vk::VkDescriptorType descriptorType, const T& data)
 690 {
 691         addUniform(bindingLocation, descriptorType, sizeof(T), &data);
 692 }
 693
 694 } // sr
 695 } // vkt
 696
 697 #endif // _VKTSHADERRENDER_HPP