external/vulkancts/modules/vulkan/query_pool/vktQueryPoolCreateInfoUtil.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015 The Khronos Group Inc.
   6  * Copyright (c) 2015 Intel Corporation
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and/or associated documentation files (the
  10  * "Materials"), to deal in the Materials without restriction, including
  11  * without limitation the rights to use, copy, modify, merge, publish,
  12  * distribute, sublicense, and/or sell copies of the Materials, and to
  13  * permit persons to whom the Materials are furnished to do so, subject to
  14  * the following conditions:
  15  *
  16  * The above copyright notice(s) and this permission notice shall be included
  17  * in all copies or substantial portions of the Materials.
  18  *
  19  * The Materials are Confidential Information as defined by the
  20  * Khronos Membership Agreement until designated non-confidential by Khronos,
  21  * at which point this condition clause shall be removed.
  22  *
  23  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  26  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  27  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  28  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  29  * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
  30  *
  31  *//*!
  32  * \file
  33  * \brief CreateInfo utilities
  34  *//*--------------------------------------------------------------------*/
  35
  36 #include "vktQueryPoolCreateInfoUtil.hpp"
  37
  38 #include "vkImageUtil.hpp"
  39
  40 namespace vkt
  41 {
  42 namespace QueryPool
  43 {
  44
  45 ImageSubresourceRange::ImageSubresourceRange (vk::VkImageAspectFlags    _aspectMask,
  46                                                                                           deUint32                                      _baseMipLevel,
  47                                                                                           deUint32                                      _levelCount,
  48                                                                                           deUint32                                      _baseArrayLayer,
  49                                                                                           deUint32                                      _layerCount)
  50 {
  51         aspectMask              = _aspectMask;
  52         baseMipLevel    = _baseMipLevel;
  53         levelCount              = _levelCount;
  54         baseArrayLayer  = _baseArrayLayer;
  55         layerCount              = _layerCount;
  56 }
  57
  58 ComponentMapping::ComponentMapping (vk::VkComponentSwizzle _r,
  59                                                                     vk::VkComponentSwizzle _g,
  60                                                                     vk::VkComponentSwizzle _b,
  61                                                                     vk::VkComponentSwizzle _a)
  62 {
  63         r = _r;
  64         g = _g;
  65         b = _b;
  66         a = _a;
  67 }
  68
  69 ImageViewCreateInfo::ImageViewCreateInfo (vk::VkImage                                                   _image,
  70                                                                                   vk::VkImageViewType                                   _viewType,
  71                                                                                   vk::VkFormat                                                  _format,
  72                                                                                   const vk::VkImageSubresourceRange&    _subresourceRange,
  73                                                                                   const vk::VkComponentMapping&                 _components,
  74                                                                                   vk::VkImageViewCreateFlags                    _flags)
  75 {
  76         sType = vk::VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
  77         pNext = DE_NULL;
  78         flags                           = 0u;
  79         image                           = _image;
  80         viewType                        = _viewType;
  81         format                          = _format;
  82         components.r            = _components.r;
  83         components.g            = _components.g;
  84         components.b            = _components.b;
  85         components.a            = _components.a;
  86         subresourceRange        = _subresourceRange;
  87         flags                           = _flags;
  88 }
  89
  90 ImageViewCreateInfo::ImageViewCreateInfo (vk::VkImage                                   _image,
  91                                                                                   vk::VkImageViewType                   _viewType,
  92                                                                                   vk::VkFormat                                  _format,
  93                                                                                   const vk::VkComponentMapping& _components,
  94                                                                                   vk::VkImageViewCreateFlags    _flags)
  95 {
  96         sType = vk::VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
  97         pNext = DE_NULL;
  98         flags                   = 0u;
  99         image                   = _image;
 100         viewType                = _viewType;
 101         format                  = _format;
 102         components.r    = _components.r;
 103         components.g    = _components.g;
 104         components.b    = _components.b;
 105         components.a    = _components.a;
 106
 107         vk::VkImageAspectFlags aspectFlags;
 108         const tcu::TextureFormat tcuFormat = vk::mapVkFormat(_format);
 109
 110         switch (tcuFormat.order)
 111         {
 112                 case tcu::TextureFormat::D:
 113                         aspectFlags = vk::VK_IMAGE_ASPECT_DEPTH_BIT;
 114                         break;
 115                 case tcu::TextureFormat::S:
 116                         aspectFlags = vk::VK_IMAGE_ASPECT_STENCIL_BIT;
 117                         break;
 118                 case tcu::TextureFormat::DS:
 119                         aspectFlags = vk::VK_IMAGE_ASPECT_STENCIL_BIT | vk::VK_IMAGE_ASPECT_DEPTH_BIT;
 120                         break;
 121                 default:
 122                         aspectFlags = vk::VK_IMAGE_ASPECT_COLOR_BIT;
 123                         break;
 124         }
 125
 126         subresourceRange = ImageSubresourceRange(aspectFlags);;
 127         flags = _flags;
 128 }
 129
 130 BufferViewCreateInfo::BufferViewCreateInfo (vk::VkBuffer        _buffer,
 131                                                                                         vk::VkFormat            _format,
 132                                                                                         vk::VkDeviceSize _offset,
 133                                                                                         vk::VkDeviceSize _range)
 134 {
 135         sType = vk::VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
 136         pNext = DE_NULL;
 137
 138         flags   = 0u;
 139         buffer  = _buffer;
 140         format  = _format;
 141         offset  = _offset;
 142         range   = _range;
 143 }
 144
 145 BufferCreateInfo::BufferCreateInfo (vk::VkDeviceSize            _size,
 146                                                                         vk::VkBufferUsageFlags  _usage,
 147                                                                         vk::VkSharingMode               _sharingMode,
 148                                                                         deUint32                                _queueFamilyIndexCount,
 149                                                                         const deUint32*                 _pQueueFamilyIndices,
 150                                                                         vk::VkBufferCreateFlags _flags)
 151 {
 152         sType = vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
 153         pNext = DE_NULL;
 154         size                                    = _size;
 155         usage                                   = _usage;
 156         flags                                   = _flags;
 157         sharingMode                             = _sharingMode;
 158         queueFamilyIndexCount   = _queueFamilyIndexCount;
 159
 160         if (_queueFamilyIndexCount)
 161         {
 162                 m_queueFamilyIndices = std::vector<deUint32>(
 163                         _pQueueFamilyIndices, _pQueueFamilyIndices + _queueFamilyIndexCount);
 164                 pQueueFamilyIndices = &m_queueFamilyIndices[0];
 165         }
 166         else
 167         {
 168                 pQueueFamilyIndices = _pQueueFamilyIndices;
 169         }
 170 }
 171
 172 BufferCreateInfo::BufferCreateInfo (const BufferCreateInfo &other)
 173 {
 174         sType                                   = other.sType;
 175         pNext                                   = other.pNext;
 176         size                                    = other.size;
 177         usage                                   = other.usage;
 178         flags                                   = other.flags;
 179         sharingMode                             = other.sharingMode;
 180         queueFamilyIndexCount   = other.queueFamilyIndexCount;
 181
 182         m_queueFamilyIndices    = other.m_queueFamilyIndices;
 183         DE_ASSERT(m_queueFamilyIndices.size() == queueFamilyIndexCount);
 184
 185         if (m_queueFamilyIndices.size())
 186         {
 187                 pQueueFamilyIndices = &m_queueFamilyIndices[0];
 188         }
 189         else
 190         {
 191                 pQueueFamilyIndices = DE_NULL;
 192         }
 193 }
 194
 195 BufferCreateInfo & BufferCreateInfo::operator= (const BufferCreateInfo &other)
 196 {
 197         sType                                           = other.sType;
 198         pNext                                           = other.pNext;
 199         size                                            = other.size;
 200         usage                                           = other.usage;
 201         flags                                           = other.flags;
 202         sharingMode                                     = other.sharingMode;
 203         queueFamilyIndexCount           = other.queueFamilyIndexCount;
 204
 205         m_queueFamilyIndices            = other.m_queueFamilyIndices;
 206
 207         DE_ASSERT(m_queueFamilyIndices.size() == queueFamilyIndexCount);
 208
 209         if (m_queueFamilyIndices.size())
 210         {
 211                 pQueueFamilyIndices = &m_queueFamilyIndices[0];
 212         }
 213         else
 214         {
 215                 pQueueFamilyIndices = DE_NULL;
 216         }
 217
 218         return *this;
 219 }
 220
 221 ImageCreateInfo::ImageCreateInfo (vk::VkImageType                       _imageType,
 222                                                                   vk::VkFormat                          _format,
 223                                                                   vk::VkExtent3D                        _extent,
 224                                                                   deUint32                                      _mipLevels,
 225                                                                   deUint32                                      _arrayLayers,
 226                                                                   vk::VkSampleCountFlagBits     _samples,
 227                                                                   vk::VkImageTiling                     _tiling,
 228                                                                   vk::VkImageUsageFlags         _usage,
 229                                                                   vk::VkSharingMode                     _sharingMode,
 230                                                                   deUint32                                      _queueFamilyIndexCount,
 231                                                                   const deUint32*                       _pQueueFamilyIndices,
 232                                                                   vk::VkImageCreateFlags        _flags,
 233                                                                   vk::VkImageLayout                     _initialLayout)
 234 {
 235         if (_queueFamilyIndexCount)
 236         {
 237                 m_queueFamilyIndices = std::vector<deUint32>(_pQueueFamilyIndices, _pQueueFamilyIndices + _queueFamilyIndexCount);
 238         }
 239
 240         sType = vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
 241         pNext = DE_NULL;
 242         flags                                   = _flags;
 243         imageType                               = _imageType;
 244         format                                  = _format;
 245         extent                                  = _extent;
 246         mipLevels                               = _mipLevels;
 247         arrayLayers                             = _arrayLayers;
 248         samples                                 = _samples;
 249         tiling                                  = _tiling;
 250         usage                                   = _usage;
 251         sharingMode                             = _sharingMode;
 252         queueFamilyIndexCount   = _queueFamilyIndexCount;
 253
 254         if (m_queueFamilyIndices.size())
 255         {
 256                 pQueueFamilyIndices = &m_queueFamilyIndices[0];
 257         }
 258         else
 259         {
 260                 pQueueFamilyIndices = DE_NULL;
 261         }
 262         initialLayout   = _initialLayout;
 263 }
 264
 265 FramebufferCreateInfo::FramebufferCreateInfo (vk::VkRenderPass                                          _renderPass,
 266                                                                                           const std::vector<vk::VkImageView>&   atachments,
 267                                                                                           deUint32                                                              _width,
 268                                                                                           deUint32                                                              _height,
 269                                                                                           deUint32                                                              _layers)
 270 {
 271         sType = vk::VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
 272         pNext = DE_NULL;
 273         flags = 0u;
 274
 275         renderPass              = _renderPass;
 276         attachmentCount = static_cast<deUint32>(atachments.size());
 277
 278         if (attachmentCount)
 279         {
 280                 pAttachments = const_cast<vk::VkImageView *>(&atachments[0]);
 281         }
 282
 283         width   = _width;
 284         height  = _height;
 285         layers  = _layers;
 286 }
 287
 288 RenderPassCreateInfo::RenderPassCreateInfo (const std::vector<vk::VkAttachmentDescription>&     attachments,
 289                                                                                         const std::vector<vk::VkSubpassDescription>&    subpasses,
 290                                                                                         const std::vector<vk::VkSubpassDependency>&             dependiences)
 291
 292         : m_attachments                 (attachments.begin(), attachments.end())
 293         , m_subpasses                   (subpasses.begin(), subpasses.end())
 294         , m_dependiences                (dependiences.begin(), dependiences.end())
 295         , m_attachmentsStructs  (m_attachments.begin(), m_attachments.end())
 296         , m_subpassesStructs    (m_subpasses.begin(), m_subpasses.end())
 297         , m_dependiencesStructs (m_dependiences.begin(), m_dependiences.end())
 298 {
 299         sType = vk::VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
 300         pNext = DE_NULL;
 301         flags = 0;
 302
 303         attachmentCount = static_cast<deUint32>(m_attachments.size());
 304         pAttachments    = &m_attachmentsStructs[0];
 305         subpassCount    = static_cast<deUint32>(m_subpasses.size());
 306         pSubpasses              = &m_subpassesStructs[0];
 307         dependencyCount = static_cast<deUint32>(m_dependiences.size());
 308         pDependencies   = &m_dependiencesStructs[0];
 309 }
 310
 311 RenderPassCreateInfo::RenderPassCreateInfo (deUint32                                                    _attachmentCount,
 312                                                                                         const vk::VkAttachmentDescription*      _pAttachments,
 313                                                                                         deUint32                                                        _subpassCount,
 314                                                                                         const vk::VkSubpassDescription*         _pSubpasses,
 315                                                                                         deUint32                                                        _dependencyCount,
 316                                                                                         const vk::VkSubpassDependency*          _pDependiences)
 317 {
 318
 319         m_attachments   = std::vector<AttachmentDescription>(_pAttachments, _pAttachments + _attachmentCount);
 320         m_subpasses             = std::vector<SubpassDescription>(_pSubpasses, _pSubpasses + _subpassCount);
 321         m_dependiences  = std::vector<SubpassDependency>(_pDependiences, _pDependiences + _dependencyCount);
 322
 323         m_attachmentsStructs    = std::vector<vk::VkAttachmentDescription>      (m_attachments.begin(),         m_attachments.end());
 324         m_subpassesStructs              = std::vector<vk::VkSubpassDescription>         (m_subpasses.begin(),           m_subpasses.end());
 325         m_dependiencesStructs   = std::vector<vk::VkSubpassDependency>          (m_dependiences.begin(),        m_dependiences.end());
 326
 327         sType = vk::VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
 328         pNext = DE_NULL;
 329         flags = 0;
 330
 331         attachmentCount = static_cast<deUint32>(m_attachments.size());
 332
 333         if (attachmentCount)
 334         {
 335                 pAttachments = &m_attachmentsStructs[0];
 336         }
 337         else
 338         {
 339                 pAttachments = DE_NULL;
 340         }
 341
 342         subpassCount = static_cast<deUint32>(m_subpasses.size());
 343
 344         if (subpassCount)
 345         {
 346                 pSubpasses = &m_subpassesStructs[0];
 347         }
 348         else
 349         {
 350                 pSubpasses = DE_NULL;
 351         }
 352
 353         dependencyCount = static_cast<deUint32>(m_dependiences.size());
 354
 355         if (dependencyCount)
 356         {
 357                 pDependencies = &m_dependiencesStructs[0];
 358         }
 359         else
 360         {
 361                 pDependencies = DE_NULL;
 362         }
 363 }
 364
 365 void
 366 RenderPassCreateInfo::addAttachment (vk::VkAttachmentDescription attachment)
 367 {
 368
 369         m_attachments.push_back(attachment);
 370         m_attachmentsStructs    = std::vector<vk::VkAttachmentDescription>(m_attachments.begin(), m_attachments.end());
 371         attachmentCount                 = static_cast<deUint32>(m_attachments.size());
 372         pAttachments                    = &m_attachmentsStructs[0];
 373 }
 374
 375 void
 376 RenderPassCreateInfo::addSubpass (vk::VkSubpassDescription subpass)
 377 {
 378
 379         m_subpasses.push_back(subpass);
 380         m_subpassesStructs      = std::vector<vk::VkSubpassDescription>(m_subpasses.begin(), m_subpasses.end());
 381         subpassCount            = static_cast<deUint32>(m_subpasses.size());
 382         pSubpasses                      = &m_subpassesStructs[0];
 383 }
 384
 385 void
 386 RenderPassCreateInfo::addDependency (vk::VkSubpassDependency dependency)
 387 {
 388
 389         m_dependiences.push_back(dependency);
 390         m_dependiencesStructs   = std::vector<vk::VkSubpassDependency>(m_dependiences.begin(), m_dependiences.end());
 391
 392         dependencyCount                 = static_cast<deUint32>(m_dependiences.size());
 393         pDependencies                   = &m_dependiencesStructs[0];
 394 }
 395
 396 RenderPassBeginInfo::RenderPassBeginInfo (vk::VkRenderPass                                              _renderPass,
 397                                                                                   vk::VkFramebuffer                                             _framebuffer,
 398                                                                                   vk::VkRect2D                                                  _renderArea,
 399                                                                                   const std::vector<vk::VkClearValue>&  _clearValues)
 400 {
 401
 402         m_clearValues   = _clearValues;
 403
 404         sType                   = vk::VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
 405         pNext                   = DE_NULL;
 406         renderPass              = _renderPass;
 407         framebuffer             = _framebuffer;
 408         renderArea              = _renderArea;
 409         clearValueCount = static_cast<deUint32>(m_clearValues.size());
 410         pClearValues    = m_clearValues.size() ? &m_clearValues[0] : DE_NULL;
 411 }
 412
 413 CmdPoolCreateInfo::CmdPoolCreateInfo (deUint32 _queueFamilyIndex, unsigned int _flags)
 414 {
 415         sType = vk::VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
 416         pNext = DE_NULL;
 417
 418         queueFamilyIndex = _queueFamilyIndex;
 419         flags                           = _flags;
 420 }
 421
 422 AttachmentDescription::AttachmentDescription (vk::VkFormat                              _format,
 423                                                                                           vk::VkSampleCountFlagBits     _samples,
 424                                                                                           vk::VkAttachmentLoadOp        _loadOp,
 425                                                                                           vk::VkAttachmentStoreOp       _storeOp,
 426                                                                                           vk::VkAttachmentLoadOp        _stencilLoadOp,
 427                                                                                           vk::VkAttachmentStoreOp       _stencilStoreOp,
 428                                                                                           vk::VkImageLayout                     _initialLayout,
 429                                                                                           vk::VkImageLayout                     _finalLayout)
 430 {
 431         flags = 0;
 432         format                  = _format;
 433         samples                 = _samples;
 434         loadOp                  = _loadOp;
 435         storeOp                 = _storeOp;
 436         stencilLoadOp   = _stencilLoadOp;
 437         stencilStoreOp  = _stencilStoreOp;
 438         initialLayout   = _initialLayout;
 439         finalLayout             = _finalLayout;
 440 }
 441
 442 AttachmentDescription::AttachmentDescription (const vk::VkAttachmentDescription& rhs)
 443 {
 444         flags                   = rhs.flags;
 445         format                  = rhs.format;
 446         samples                 = rhs.samples;
 447         loadOp                  = rhs.loadOp;
 448         storeOp                 = rhs.storeOp;
 449         stencilLoadOp   = rhs.stencilLoadOp;
 450         stencilStoreOp  = rhs.stencilStoreOp;
 451         initialLayout   = rhs.initialLayout;
 452         finalLayout             = rhs.finalLayout;
 453 }
 454
 455 AttachmentReference::AttachmentReference (deUint32 _attachment, vk::VkImageLayout _layout)
 456 {
 457         attachment      = _attachment;
 458         layout          = _layout;
 459 }
 460
 461 AttachmentReference::AttachmentReference (void)
 462 {
 463         attachment = vk::VK_ATTACHMENT_UNUSED;
 464         layout = vk::VK_IMAGE_LAYOUT_UNDEFINED;
 465 }
 466
 467 SubpassDescription::SubpassDescription (vk::VkPipelineBindPoint                         _pipelineBindPoint,
 468                                                                                 vk::VkSubpassDescriptionFlags           _flags,
 469                                                                                 deUint32                                                        _inputAttachmentCount,
 470                                                                                 const vk::VkAttachmentReference*        _inputAttachments,
 471                                                                                 deUint32                                                        _colorAttachmentCount,
 472                                                                                 const vk::VkAttachmentReference*        _colorAttachments,
 473                                                                                 const vk::VkAttachmentReference*        _resolveAttachments,
 474                                                                                 vk::VkAttachmentReference                       depthStencilAttachment,
 475                                                                                 deUint32                                                        _preserveAttachmentCount,
 476                                                                                 const deUint32*                                         _preserveAttachments)
 477 {
 478         m_inputAttachments = std::vector<vk::VkAttachmentReference>(_inputAttachments, _inputAttachments + _inputAttachmentCount);
 479         m_colorAttachments = std::vector<vk::VkAttachmentReference>(_colorAttachments, _colorAttachments + _colorAttachmentCount);
 480
 481         if (_resolveAttachments)
 482                 m_resolveAttachments = std::vector<vk::VkAttachmentReference>(_resolveAttachments, _resolveAttachments + _colorAttachmentCount);
 483
 484         m_preserveAttachments = std::vector<deUint32>(_preserveAttachments, _preserveAttachments + _preserveAttachmentCount);
 485
 486         m_depthStencilAttachment = depthStencilAttachment;
 487
 488         flags                                   = _flags;
 489         pipelineBindPoint               = _pipelineBindPoint;
 490         inputAttachmentCount    = _inputAttachmentCount;
 491         pInputAttachments               = DE_NULL;
 492         colorAttachmentCount    = _colorAttachmentCount;
 493         pColorAttachments               = DE_NULL;
 494         pResolveAttachments             = DE_NULL;
 495         pDepthStencilAttachment = &m_depthStencilAttachment;
 496         pPreserveAttachments    = DE_NULL;
 497         preserveAttachmentCount = _preserveAttachmentCount;
 498
 499         if (!m_inputAttachments.empty())
 500                 pInputAttachments = &m_inputAttachments[0];
 501
 502         if (!m_colorAttachments.empty())
 503                 pColorAttachments = &m_colorAttachments[0];
 504
 505         if (!m_resolveAttachments.empty())
 506                 pResolveAttachments = &m_resolveAttachments[0];
 507
 508         if (!m_preserveAttachments.empty())
 509                 pPreserveAttachments = &m_preserveAttachments[0];
 510 }
 511
 512 SubpassDescription::SubpassDescription (const vk::VkSubpassDescription& rhs)
 513 {
 514         *static_cast<vk::VkSubpassDescription*>(this) = rhs;
 515
 516         m_inputAttachments = std::vector<vk::VkAttachmentReference>(
 517                 rhs.pInputAttachments, rhs.pInputAttachments + rhs.inputAttachmentCount);
 518
 519         m_colorAttachments = std::vector<vk::VkAttachmentReference>(
 520                 rhs.pColorAttachments, rhs.pColorAttachments + rhs.colorAttachmentCount);
 521
 522         if (rhs.pResolveAttachments)
 523                 m_resolveAttachments = std::vector<vk::VkAttachmentReference>(
 524                         rhs.pResolveAttachments, rhs.pResolveAttachments + rhs.colorAttachmentCount);
 525
 526         m_preserveAttachments = std::vector<deUint32>(
 527                 rhs.pPreserveAttachments, rhs.pPreserveAttachments + rhs.preserveAttachmentCount);
 528
 529         if (rhs.pDepthStencilAttachment)
 530                 m_depthStencilAttachment = *rhs.pDepthStencilAttachment;
 531
 532         if (!m_inputAttachments.empty())
 533                 pInputAttachments = &m_inputAttachments[0];
 534
 535         if (!m_colorAttachments.empty())
 536                 pColorAttachments = &m_colorAttachments[0];
 537
 538         if (!m_resolveAttachments.empty())
 539                 pResolveAttachments = &m_resolveAttachments[0];
 540
 541         pDepthStencilAttachment = &m_depthStencilAttachment;
 542
 543         if (!m_preserveAttachments.empty())
 544                 pPreserveAttachments = &m_preserveAttachments[0];
 545 }
 546
 547 SubpassDescription::SubpassDescription (const SubpassDescription& rhs) {
 548         *this = rhs;
 549 }
 550
 551 SubpassDescription& SubpassDescription::operator= (const SubpassDescription& rhs)
 552 {
 553         *static_cast<vk::VkSubpassDescription*>(this) = rhs;
 554
 555         m_inputAttachments              = rhs.m_inputAttachments;
 556         m_colorAttachments              = rhs.m_colorAttachments;
 557         m_resolveAttachments    = rhs.m_resolveAttachments;
 558         m_preserveAttachments   = rhs.m_preserveAttachments;
 559         m_depthStencilAttachment = rhs.m_depthStencilAttachment;
 560
 561         if (!m_inputAttachments.empty())
 562                 pInputAttachments = &m_inputAttachments[0];
 563
 564         if (!m_colorAttachments.empty())
 565                 pColorAttachments = &m_colorAttachments[0];
 566
 567         if (!m_resolveAttachments.empty())
 568                 pResolveAttachments = &m_resolveAttachments[0];
 569
 570         pDepthStencilAttachment = &m_depthStencilAttachment;
 571
 572         if (!m_preserveAttachments.empty())
 573                 pPreserveAttachments = &m_preserveAttachments[0];
 574
 575         return *this;
 576 }
 577
 578 SubpassDependency::SubpassDependency (deUint32                                  _srcSubpass,
 579                                                                           deUint32                                      _dstSubpass,
 580                                                                           vk::VkPipelineStageFlags      _srcStageMask,
 581                                                                           vk::VkPipelineStageFlags      _dstStageMask,
 582                                                                           vk::VkAccessFlags                     _srcAccessMask,
 583                                                                           vk::VkAccessFlags                     _dstAccessMask,
 584                                                                           vk::VkDependencyFlags         _dependencyFlags)
 585 {
 586         srcSubpass              = _srcSubpass;
 587         dstSubpass              = _dstSubpass;
 588         srcStageMask    = _srcStageMask;
 589         dstStageMask    = _dstStageMask;
 590         srcAccessMask   = _srcAccessMask;
 591         dstAccessMask   = _dstAccessMask;
 592         dependencyFlags = _dependencyFlags;
 593 }
 594
 595 SubpassDependency::SubpassDependency (const vk::VkSubpassDependency& rhs)
 596 {
 597         srcSubpass              = rhs.srcSubpass;
 598         dstSubpass              = rhs.dstSubpass;
 599         srcStageMask    = rhs.srcStageMask;
 600         dstStageMask    = rhs.dstStageMask;
 601         srcAccessMask   = rhs.srcAccessMask;
 602         dstAccessMask   = rhs.dstAccessMask;
 603         dependencyFlags = rhs.dependencyFlags;
 604 }
 605
 606 CmdBufferBeginInfo::CmdBufferBeginInfo (vk::VkCommandBufferUsageFlags _flags)
 607 {
 608         sType                           = vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
 609         pNext                           = DE_NULL;
 610         flags                           = _flags;
 611         pInheritanceInfo        = DE_NULL;
 612 }
 613
 614 DescriptorPoolCreateInfo::DescriptorPoolCreateInfo (const std::vector<vk::VkDescriptorPoolSize>&        poolSizeCounts,
 615                                                                                                         vk::VkDescriptorPoolCreateFlags                                 _flags,
 616                                                                                                         deUint32                                                                                _maxSets)
 617         : m_poolSizeCounts(poolSizeCounts)
 618 {
 619         sType = vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
 620         pNext = DE_NULL;
 621         flags                   = _flags;
 622         maxSets                 = _maxSets;
 623         poolSizeCount   = static_cast<deUint32>(m_poolSizeCounts.size());
 624         pPoolSizes              = &m_poolSizeCounts[0];
 625 }
 626
 627 DescriptorPoolCreateInfo& DescriptorPoolCreateInfo::addDescriptors (vk::VkDescriptorType type, deUint32 count)
 628 {
 629         vk::VkDescriptorPoolSize descriptorTypeCount = { type, count };
 630         m_poolSizeCounts.push_back(descriptorTypeCount);
 631
 632         poolSizeCount   = static_cast<deUint32>(m_poolSizeCounts.size());
 633         pPoolSizes              = &m_poolSizeCounts[0];
 634
 635         return *this;
 636 }
 637
 638 DescriptorSetLayoutCreateInfo::DescriptorSetLayoutCreateInfo (deUint32 _bindingCount, const vk::VkDescriptorSetLayoutBinding* _pBindings)
 639 {
 640         sType = vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
 641         pNext = DE_NULL;
 642         flags = 0;
 643         bindingCount = _bindingCount;
 644         pBindings        = _pBindings;
 645 }
 646
 647 PipelineLayoutCreateInfo::PipelineLayoutCreateInfo (deUint32                                                    _descriptorSetCount,
 648                                                                                                         const vk::VkDescriptorSetLayout*        _pSetLayouts,
 649                                                                                                         deUint32                                                        _pushConstantRangeCount,
 650                                                                                                         const vk::VkPushConstantRange*          _pPushConstantRanges)
 651         : m_pushConstantRanges(_pPushConstantRanges, _pPushConstantRanges + _pushConstantRangeCount)
 652 {
 653         for (unsigned int i = 0; i < _descriptorSetCount; i++)
 654         {
 655                 m_setLayouts.push_back(_pSetLayouts[i]);
 656         }
 657
 658         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
 659         pNext = DE_NULL;
 660
 661         flags                                   = 0u;
 662         setLayoutCount                  = static_cast<deUint32>(m_setLayouts.size());
 663         pSetLayouts                             = setLayoutCount > 0 ? &m_setLayouts[0] : DE_NULL;
 664         pushConstantRangeCount  = static_cast<deUint32>(m_pushConstantRanges.size());
 665
 666         if (m_pushConstantRanges.size())
 667         {
 668                 pPushConstantRanges = &m_pushConstantRanges[0];
 669         }
 670         else
 671         {
 672                 pPushConstantRanges = DE_NULL;
 673         }
 674 }
 675
 676 PipelineLayoutCreateInfo::PipelineLayoutCreateInfo (const std::vector<vk::VkDescriptorSetLayout>&       setLayouts,
 677                                                                                                         deUint32                                                                                _pushConstantRangeCount,
 678                                                                                                         const vk::VkPushConstantRange*                                  _pPushConstantRanges)
 679         : m_setLayouts                  (setLayouts)
 680         , m_pushConstantRanges  (_pPushConstantRanges, _pPushConstantRanges + _pushConstantRangeCount)
 681 {
 682         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
 683         pNext = DE_NULL;
 684
 685         flags                   = 0u;
 686         setLayoutCount  = static_cast<deUint32>(m_setLayouts.size());
 687
 688         if (setLayoutCount)
 689         {
 690                 pSetLayouts = &m_setLayouts[0];
 691         }
 692         else
 693         {
 694                 pSetLayouts = DE_NULL;
 695         }
 696
 697         pushConstantRangeCount = static_cast<deUint32>(m_pushConstantRanges.size());
 698         if (pushConstantRangeCount)
 699         {
 700                 pPushConstantRanges = &m_pushConstantRanges[0];
 701         }
 702         else
 703         {
 704                 pPushConstantRanges = DE_NULL;
 705         }
 706 }
 707
 708 PipelineCreateInfo::PipelineShaderStage::PipelineShaderStage (vk::VkShaderModule _module, const char* _pName, vk::VkShaderStageFlagBits _stage)
 709 {
 710         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
 711         pNext = DE_NULL;
 712         flags = 0u;
 713         stage                           = _stage;
 714         module                          = _module;
 715         pName                           = _pName;
 716         pSpecializationInfo = DE_NULL;
 717 }
 718
 719 PipelineCreateInfo::VertexInputState::VertexInputState (deUint32                                                                                _vertexBindingDescriptionCount,
 720                                                                                                                 const vk::VkVertexInputBindingDescription*              _pVertexBindingDescriptions,
 721                                                                                                                 deUint32                                                                                _vertexAttributeDescriptionCount,
 722                                                                                                                 const vk::VkVertexInputAttributeDescription*    _pVertexAttributeDescriptions)
 723 {
 724         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
 725         pNext = DE_NULL;
 726         flags                                                   = 0u;
 727         vertexBindingDescriptionCount   = _vertexBindingDescriptionCount;
 728         pVertexBindingDescriptions              = _pVertexBindingDescriptions;
 729         vertexAttributeDescriptionCount = _vertexAttributeDescriptionCount;
 730         pVertexAttributeDescriptions    = _pVertexAttributeDescriptions;
 731 }
 732
 733 PipelineCreateInfo::InputAssemblerState::InputAssemblerState (vk::VkPrimitiveTopology   _topology,
 734                                                                                                                           vk::VkBool32                          _primitiveRestartEnable)
 735 {
 736         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
 737         pNext = DE_NULL;
 738         flags                                   = 0u;
 739         topology                                = _topology;
 740         primitiveRestartEnable  = _primitiveRestartEnable;
 741 }
 742
 743 PipelineCreateInfo::TessellationState::TessellationState (deUint32 _patchControlPoints)
 744 {
 745         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
 746         pNext = DE_NULL;
 747         flags                           = 0u;
 748         patchControlPoints      = _patchControlPoints;
 749 }
 750
 751 PipelineCreateInfo::ViewportState::ViewportState (deUint32                                              _viewportCount,
 752                                                                                                   std::vector<vk::VkViewport>   _viewports,
 753                                                                                                   std::vector<vk::VkRect2D>             _scissors)
 754 {
 755         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
 756         pNext = DE_NULL;
 757         flags                   = 0u;
 758         viewportCount   = _viewportCount;
 759         scissorCount    = _viewportCount;
 760
 761         if (!_viewports.size())
 762         {
 763                 m_viewports.resize(viewportCount);
 764                 deMemset(&m_viewports[0], 0, sizeof(m_viewports[0]) * m_viewports.size());
 765         }
 766         else
 767         {
 768                 m_viewports = _viewports;
 769         }
 770
 771         if (!_scissors.size())
 772         {
 773                 m_scissors.resize(scissorCount);
 774                 deMemset(&m_scissors[0], 0, sizeof(m_scissors[0]) * m_scissors.size());
 775         }
 776         else
 777         {
 778                 m_scissors = _scissors;
 779         }
 780
 781         pViewports      = &m_viewports[0];
 782         pScissors       = &m_scissors[0];
 783 }
 784
 785 PipelineCreateInfo::ViewportState::ViewportState (const ViewportState& other)
 786 {
 787         sType                   = other.sType;
 788         pNext                   = other.pNext;
 789         flags                   = other.flags;
 790         viewportCount   = other.viewportCount;
 791         scissorCount    = other.scissorCount;
 792
 793         m_viewports = std::vector<vk::VkViewport>(other.pViewports, other.pViewports + viewportCount);
 794         m_scissors      = std::vector<vk::VkRect2D>(other.pScissors, other.pScissors + scissorCount);
 795
 796         pViewports      = &m_viewports[0];
 797         pScissors       = &m_scissors[0];
 798 }
 799
 800 PipelineCreateInfo::ViewportState& PipelineCreateInfo::ViewportState::operator= (const ViewportState& other)
 801 {
 802         sType                   = other.sType;
 803         pNext                   = other.pNext;
 804         flags                   = other.flags;
 805         viewportCount   = other.viewportCount;
 806         scissorCount    = other.scissorCount;
 807
 808         m_viewports             = std::vector<vk::VkViewport>(other.pViewports, other.pViewports + scissorCount);
 809         m_scissors              = std::vector<vk::VkRect2D>(other.pScissors, other.pScissors + scissorCount);
 810
 811         pViewports              = &m_viewports[0];
 812         pScissors               = &m_scissors[0];
 813         return *this;
 814 }
 815
 816 PipelineCreateInfo::RasterizerState::RasterizerState (vk::VkBool32                      _depthClampEnable,
 817                                                                                                           vk::VkBool32                  _rasterizerDiscardEnable,
 818                                                                                                           vk::VkPolygonMode             _polygonMode,
 819                                                                                                           vk::VkCullModeFlags   _cullMode,
 820                                                                                                           vk::VkFrontFace               _frontFace,
 821                                                                                                           vk::VkBool32                  _depthBiasEnable,
 822                                                                                                           float                                 _depthBiasConstantFactor,
 823                                                                                                           float                                 _depthBiasClamp,
 824                                                                                                           float                                 _depthBiasSlopeFactor,
 825                                                                                                           float                                 _lineWidth)
 826 {
 827         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
 828         pNext = DE_NULL;
 829         flags                                   = 0u;
 830         depthClampEnable                = _depthClampEnable;
 831         rasterizerDiscardEnable = _rasterizerDiscardEnable;
 832         polygonMode                             = _polygonMode;
 833         cullMode                                = _cullMode;
 834         frontFace                               = _frontFace;
 835
 836         depthBiasEnable                 = _depthBiasEnable;
 837         depthBiasConstantFactor = _depthBiasConstantFactor;
 838         depthBiasClamp                  = _depthBiasClamp;
 839         depthBiasSlopeFactor    = _depthBiasSlopeFactor;
 840         lineWidth                               = _lineWidth;
 841 }
 842
 843 PipelineCreateInfo::MultiSampleState::MultiSampleState (vk::VkSampleCountFlagBits                               _rasterizationSamples,
 844                                                                                                                 vk::VkBool32                                                    _sampleShadingEnable,
 845                                                                                                                 float                                                                   _minSampleShading,
 846                                                                                                                 const std::vector<vk::VkSampleMask>&    _sampleMask,
 847                                                                                                                 bool                                                                    _alphaToCoverageEnable,
 848                                                                                                                 bool                                                                    _alphaToOneEnable)
 849         : m_sampleMask(_sampleMask)
 850 {
 851         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
 852         pNext = DE_NULL;
 853         flags                                   = 0u;
 854         rasterizationSamples    = _rasterizationSamples;
 855         sampleShadingEnable             = _sampleShadingEnable;
 856         minSampleShading                = _minSampleShading;
 857         pSampleMask                             = &m_sampleMask[0];
 858         alphaToCoverageEnable   = _alphaToCoverageEnable;
 859         alphaToOneEnable                = _alphaToOneEnable;
 860 }
 861
 862 PipelineCreateInfo::MultiSampleState::MultiSampleState (const MultiSampleState& other)
 863 {
 864         sType                                   = other.sType;
 865         pNext                                   = other.pNext;
 866         flags                                   = other.flags;
 867         rasterizationSamples    = other.rasterizationSamples;
 868         sampleShadingEnable             = other.sampleShadingEnable;
 869         minSampleShading                = other.minSampleShading;
 870
 871         const size_t sampleMaskArrayLen = (sizeof(vk::VkSampleMask) * 8 + other.rasterizationSamples) / (sizeof(vk::VkSampleMask) * 8);
 872
 873         m_sampleMask    = std::vector<vk::VkSampleMask>(other.pSampleMask, other.pSampleMask + sampleMaskArrayLen);
 874         pSampleMask             = &m_sampleMask[0];
 875 }
 876
 877 PipelineCreateInfo::MultiSampleState& PipelineCreateInfo::MultiSampleState::operator= (const MultiSampleState& other)
 878 {
 879         sType = other.sType;
 880         pNext = other.pNext;
 881         flags                                   = other.flags;
 882         rasterizationSamples    = other.rasterizationSamples;
 883         sampleShadingEnable             = other.sampleShadingEnable;
 884         minSampleShading                = other.minSampleShading;
 885
 886         const size_t sampleMaskArrayLen = (sizeof(vk::VkSampleMask) * 8 + other.rasterizationSamples) / (sizeof(vk::VkSampleMask) * 8);
 887
 888         m_sampleMask    = std::vector<vk::VkSampleMask>(other.pSampleMask, other.pSampleMask + sampleMaskArrayLen);
 889         pSampleMask             = &m_sampleMask[0];
 890
 891         return *this;
 892 }
 893
 894 PipelineCreateInfo::ColorBlendState::ColorBlendState (const std::vector<vk::VkPipelineColorBlendAttachmentState>&       _attachments,
 895                                                                                                           vk::VkBool32                                                                                                  _logicOpEnable,
 896                                                                                                           vk::VkLogicOp                                                                                                 _logicOp)
 897         : m_attachments(_attachments)
 898 {
 899         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
 900         pNext = DE_NULL;
 901         flags                                   = 0u;
 902         logicOpEnable                   = _logicOpEnable;
 903         logicOp                                 = _logicOp;
 904         attachmentCount                 = static_cast<deUint32>(m_attachments.size());
 905         pAttachments                    = &m_attachments[0];
 906 }
 907
 908 PipelineCreateInfo::ColorBlendState::ColorBlendState (deUint32                                                                                  _attachmentCount,
 909                                                                                                           const vk::VkPipelineColorBlendAttachmentState*        _attachments,
 910                                                                                                           vk::VkBool32                                                                          _logicOpEnable,
 911                                                                                                           vk::VkLogicOp                                                                         _logicOp)
 912         : m_attachments(_attachments, _attachments + _attachmentCount)
 913 {
 914         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
 915         pNext   = DE_NULL;
 916         flags                                   = 0u;
 917         logicOpEnable                   = _logicOpEnable;
 918         logicOp                                 = _logicOp;
 919         attachmentCount                 = static_cast<deUint32>(m_attachments.size());
 920         pAttachments                    = &m_attachments[0];
 921 }
 922
 923 PipelineCreateInfo::ColorBlendState::ColorBlendState (const vk::VkPipelineColorBlendStateCreateInfo& createInfo)
 924         : m_attachments (createInfo.pAttachments, createInfo.pAttachments + createInfo.attachmentCount)
 925 {
 926         sType = createInfo.sType;
 927         pNext = createInfo.pNext;
 928         flags                                   = createInfo.flags;
 929         logicOpEnable                   = createInfo.logicOpEnable;
 930         logicOp                                 = createInfo.logicOp;
 931         attachmentCount                 = static_cast<deUint32>(m_attachments.size());
 932         pAttachments                    = &m_attachments[0];
 933 }
 934
 935 PipelineCreateInfo::ColorBlendState::ColorBlendState (const ColorBlendState& createInfo, std::vector<float> _blendConstants)
 936         : m_attachments (createInfo.pAttachments, createInfo.pAttachments + createInfo.attachmentCount)
 937 {
 938         sType = createInfo.sType;
 939         pNext = createInfo.pNext;
 940         flags                                   = createInfo.flags;
 941         logicOpEnable                   = createInfo.logicOpEnable;
 942         logicOp                                 = createInfo.logicOp;
 943         attachmentCount                 = static_cast<deUint32>(m_attachments.size());
 944         pAttachments                    = &m_attachments[0];
 945         deMemcpy(blendConstants, &_blendConstants[0], 4 * sizeof(float));
 946 }
 947
 948 PipelineCreateInfo::ColorBlendState::Attachment::Attachment (vk::VkBool32               _blendEnable,
 949                                                                                                                          vk::VkBlendFactor      _srcColorBlendFactor,
 950                                                                                                                          vk::VkBlendFactor      _dstColorBlendFactor,
 951                                                                                                                          vk::VkBlendOp          _colorBlendOp,
 952                                                                                                                          vk::VkBlendFactor      _srcAlphaBlendFactor,
 953                                                                                                                          vk::VkBlendFactor      _dstAlphaBlendFactor,
 954                                                                                                                          vk::VkBlendOp          _alphaBlendOp,
 955                                                                                                                          deUint8                        _colorWriteMask)
 956 {
 957         blendEnable                     = _blendEnable;
 958         srcColorBlendFactor     = _srcColorBlendFactor;
 959         dstColorBlendFactor     = _dstColorBlendFactor;
 960         colorBlendOp            = _colorBlendOp;
 961         srcAlphaBlendFactor     = _srcAlphaBlendFactor;
 962         dstAlphaBlendFactor     = _dstAlphaBlendFactor;
 963         alphaBlendOp            = _alphaBlendOp;
 964         colorWriteMask  = _colorWriteMask;
 965 }
 966
 967 PipelineCreateInfo::DepthStencilState::StencilOpState::StencilOpState (vk::VkStencilOp  _failOp,
 968                                                                                                                                            vk::VkStencilOp      _passOp,
 969                                                                                                                                            vk::VkStencilOp      _depthFailOp,
 970                                                                                                                                            vk::VkCompareOp      _compareOp,
 971                                                                                                                                            deUint32                     _compareMask,
 972                                                                                                                                            deUint32                     _writeMask,
 973                                                                                                                                            deUint32                     _reference)
 974 {
 975         failOp          = _failOp;
 976         passOp          = _passOp;
 977         depthFailOp     = _depthFailOp;
 978         compareOp       = _compareOp;
 979
 980         compareMask     = _compareMask;
 981         writeMask       = _writeMask;
 982         reference       = _reference;
 983 }
 984
 985 PipelineCreateInfo::DepthStencilState::DepthStencilState (vk::VkBool32          _depthTestEnable,
 986                                                                                                                   vk::VkBool32          _depthWriteEnable,
 987                                                                                                                   vk::VkCompareOp       _depthCompareOp,
 988                                                                                                                   vk::VkBool32          _depthBoundsTestEnable,
 989                                                                                                                   vk::VkBool32          _stencilTestEnable,
 990                                                                                                                   StencilOpState        _front,
 991                                                                                                                   StencilOpState        _back,
 992                                                                                                                   float                         _minDepthBounds,
 993                                                                                                                   float                         _maxDepthBounds)
 994 {
 995         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
 996         pNext = DE_NULL;
 997         flags                                   = 0u;
 998         depthTestEnable                 = _depthTestEnable;
 999         depthWriteEnable                = _depthWriteEnable;
1000         depthCompareOp                  = _depthCompareOp;
1001         depthBoundsTestEnable   = _depthBoundsTestEnable;
1002         stencilTestEnable               = _stencilTestEnable;
1003         front   = _front;
1004         back    = _back;
1005
1006         minDepthBounds = _minDepthBounds;
1007         maxDepthBounds = _maxDepthBounds;
1008 }
1009
1010 PipelineCreateInfo::DynamicState::DynamicState (const std::vector<vk::VkDynamicState>& _dynamicStates)
1011 {
1012         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
1013         pNext = DE_NULL;
1014         flags = 0u;
1015
1016         if (!_dynamicStates.size())
1017         {
1018                 for (size_t i = 0; i < vk::VK_DYNAMIC_STATE_LAST; ++i)
1019                 {
1020                         m_dynamicStates.push_back(static_cast<vk::VkDynamicState>(i));
1021                 }
1022         }
1023         else
1024                 m_dynamicStates = _dynamicStates;
1025
1026         dynamicStateCount = static_cast<deUint32>(m_dynamicStates.size());
1027         pDynamicStates = &m_dynamicStates[0];
1028 }
1029
1030 PipelineCreateInfo::DynamicState::DynamicState (const DynamicState &other)
1031 {
1032         sType = other.sType;
1033         pNext = other.pNext;
1034         flags = other.flags;
1035
1036         dynamicStateCount = other.dynamicStateCount;
1037
1038         m_dynamicStates = std::vector<vk::VkDynamicState>(other.pDynamicStates, other.pDynamicStates + dynamicStateCount);
1039         pDynamicStates = &m_dynamicStates[0];
1040 }
1041
1042 PipelineCreateInfo::DynamicState& PipelineCreateInfo::DynamicState::operator= (const DynamicState& other)
1043 {
1044         sType = other.sType;
1045         pNext = other.pNext;
1046         flags = other.flags;
1047
1048         dynamicStateCount = other.dynamicStateCount;
1049
1050         m_dynamicStates = std::vector<vk::VkDynamicState>(other.pDynamicStates, other.pDynamicStates + dynamicStateCount);
1051         pDynamicStates = &m_dynamicStates[0];
1052
1053         return *this;
1054 }
1055
1056 PipelineCreateInfo::PipelineCreateInfo (vk::VkPipelineLayout            _layout,
1057                                                                                 vk::VkRenderPass                        _renderPass,
1058                                                                                 int                                                     _subpass,
1059                                                                                 vk::VkPipelineCreateFlags       _flags)
1060 {
1061         deMemset(static_cast<vk::VkGraphicsPipelineCreateInfo *>(this), 0,
1062                 sizeof(vk::VkGraphicsPipelineCreateInfo));
1063
1064         sType = vk::VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
1065         pNext = DE_NULL;
1066         flags                           = _flags;
1067         renderPass                      = _renderPass;
1068         subpass                         = _subpass;
1069         layout                          = _layout;
1070         basePipelineHandle      = DE_NULL;
1071         basePipelineIndex       = 0;
1072         pDynamicState           = DE_NULL;
1073 }
1074
1075 PipelineCreateInfo& PipelineCreateInfo::addShader (const vk::VkPipelineShaderStageCreateInfo& shader)
1076 {
1077         m_shaders.push_back(shader);
1078
1079         stageCount      = static_cast<deUint32>(m_shaders.size());
1080         pStages         = &m_shaders[0];
1081
1082         return *this;
1083 }
1084
1085 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineVertexInputStateCreateInfo& state)
1086 {
1087         m_vertexInputState      = state;
1088         pVertexInputState       = &m_vertexInputState;
1089
1090         return *this;
1091 }
1092
1093 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineInputAssemblyStateCreateInfo& state)
1094 {
1095         m_inputAssemblyState = state;
1096         pInputAssemblyState = &m_inputAssemblyState;
1097
1098         return *this;
1099 }
1100
1101 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineColorBlendStateCreateInfo& state)
1102 {
1103         m_colorBlendStateAttachments    = std::vector<vk::VkPipelineColorBlendAttachmentState>(state.pAttachments, state.pAttachments + state.attachmentCount);
1104         m_colorBlendState                               = state;
1105         m_colorBlendState.pAttachments  = &m_colorBlendStateAttachments[0];
1106         pColorBlendState                                = &m_colorBlendState;
1107
1108         return *this;
1109 }
1110
1111 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineViewportStateCreateInfo& state)
1112 {
1113         m_viewports                                     = std::vector<vk::VkViewport>(state.pViewports, state.pViewports + state.viewportCount);
1114         m_scissors                                      = std::vector<vk::VkRect2D>(state.pScissors, state.pScissors + state.scissorCount);
1115         m_viewportState                         = state;
1116         m_viewportState.pViewports      = &m_viewports[0];
1117         m_viewportState.pScissors       = &m_scissors[0];
1118         pViewportState                          = &m_viewportState;
1119
1120         return *this;
1121 }
1122
1123 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineDepthStencilStateCreateInfo& state)
1124 {
1125         m_dynamicDepthStencilState      = state;
1126         pDepthStencilState                      = &m_dynamicDepthStencilState;
1127         return *this;
1128 }
1129
1130 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineTessellationStateCreateInfo& state)
1131 {
1132         m_tessState                     = state;
1133         pTessellationState      = &m_tessState;
1134
1135         return *this;
1136 }
1137
1138 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineRasterizationStateCreateInfo& state)
1139 {
1140         m_rasterState           = state;
1141         pRasterizationState     = &m_rasterState;
1142
1143         return *this;
1144 }
1145
1146 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineMultisampleStateCreateInfo& state)
1147 {
1148
1149         const size_t sampleMaskArrayLen = (sizeof(vk::VkSampleMask) * 8 + state.rasterizationSamples) / ( sizeof(vk::VkSampleMask) * 8 );
1150         m_multisampleStateSampleMask    = std::vector<vk::VkSampleMask>(state.pSampleMask, state.pSampleMask + sampleMaskArrayLen);
1151         m_multisampleState                              = state;
1152         m_multisampleState.pSampleMask  = &m_multisampleStateSampleMask[0];
1153         pMultisampleState                               = &m_multisampleState;
1154
1155         return *this;
1156 }
1157 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineDynamicStateCreateInfo& state)
1158 {
1159         m_dynamicStates                                 = std::vector<vk::VkDynamicState>(state.pDynamicStates, state.pDynamicStates + state.dynamicStateCount);
1160         m_dynamicState                                  = state;
1161         m_dynamicState.pDynamicStates   = &m_dynamicStates[0];
1162         pDynamicState                                   = &m_dynamicState;
1163
1164         return *this;
1165 }
1166
1167 SamplerCreateInfo::SamplerCreateInfo (vk::VkFilter                              _magFilter,
1168                                                                           vk::VkFilter                          _minFilter,
1169                                                                           vk::VkSamplerMipmapMode       _mipmapMode,
1170                                                                           vk::VkSamplerAddressMode      _addressModeU,
1171                                                                           vk::VkSamplerAddressMode      _addressModeV,
1172                                                                           vk::VkSamplerAddressMode      _addressModeW,
1173                                                                           float                                         _mipLodBias,
1174                                                                           vk::VkBool32                          _anisotropyEnable,
1175                                                                           float                                         _maxAnisotropy,
1176                                                                           vk::VkBool32                          _compareEnable,
1177                                                                           vk::VkCompareOp                       _compareOp,
1178                                                                           float                                         _minLod,
1179                                                                           float                                         _maxLod,
1180                                                                           vk::VkBorderColor                     _borderColor,
1181                                                                           vk::VkBool32                          _unnormalizedCoordinates)
1182 {
1183         sType                                   = vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
1184         pNext                                   = DE_NULL;
1185         flags                                   = 0u;
1186         magFilter                               = _magFilter;
1187         minFilter                               = _minFilter;
1188         mipmapMode                              = _mipmapMode;
1189         addressModeU                    = _addressModeU;
1190         addressModeV                    = _addressModeV;
1191         addressModeW                    = _addressModeW;
1192         mipLodBias                              = _mipLodBias;
1193         anisotropyEnable                = _anisotropyEnable;
1194         maxAnisotropy                   = _maxAnisotropy;
1195         compareEnable                   = _compareEnable;
1196         compareOp                               = _compareOp;
1197         minLod                                  = _minLod;
1198         maxLod                                  = _maxLod;
1199         borderColor                             = _borderColor;
1200         unnormalizedCoordinates = _unnormalizedCoordinates;
1201 }
1202
1203 } // QueryPool
1204 } // vkt