external/vulkancts/modules/vulkan/dynamic_state/vktDynamicStateCreateInfoUtil.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 "vktDynamicStateCreateInfoUtil.hpp"
  37
  38 #include "vkImageUtil.hpp"
  39
  40 namespace vkt
  41 {
  42 namespace DynamicState
  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                 pAttachments = &m_attachmentsStructs[0];
 335         }
 336         else
 337         {
 338                 pAttachments = DE_NULL;
 339         }
 340
 341         subpassCount = static_cast<deUint32>(m_subpasses.size());
 342
 343         if (subpassCount) {
 344                 pSubpasses = &m_subpassesStructs[0];
 345         }
 346         else
 347         {
 348                 pSubpasses = DE_NULL;
 349         }
 350
 351         dependencyCount = static_cast<deUint32>(m_dependiences.size());
 352
 353         if (dependencyCount) {
 354                 pDependencies = &m_dependiencesStructs[0];
 355         }
 356         else
 357         {
 358                 pDependencies = DE_NULL;
 359         }
 360 }
 361
 362 void
 363 RenderPassCreateInfo::addAttachment (vk::VkAttachmentDescription attachment)
 364 {
 365
 366         m_attachments.push_back(attachment);
 367         m_attachmentsStructs    = std::vector<vk::VkAttachmentDescription>(m_attachments.begin(), m_attachments.end());
 368         attachmentCount                 = static_cast<deUint32>(m_attachments.size());
 369         pAttachments                    = &m_attachmentsStructs[0];
 370 }
 371
 372 void
 373 RenderPassCreateInfo::addSubpass (vk::VkSubpassDescription subpass)
 374 {
 375
 376         m_subpasses.push_back(subpass);
 377         m_subpassesStructs      = std::vector<vk::VkSubpassDescription>(m_subpasses.begin(), m_subpasses.end());
 378         subpassCount            = static_cast<deUint32>(m_subpasses.size());
 379         pSubpasses                      = &m_subpassesStructs[0];
 380 }
 381
 382 void
 383 RenderPassCreateInfo::addDependency (vk::VkSubpassDependency dependency)
 384 {
 385
 386         m_dependiences.push_back(dependency);
 387         m_dependiencesStructs   = std::vector<vk::VkSubpassDependency>(m_dependiences.begin(), m_dependiences.end());
 388
 389         dependencyCount                 = static_cast<deUint32>(m_dependiences.size());
 390         pDependencies                   = &m_dependiencesStructs[0];
 391 }
 392
 393 RenderPassBeginInfo::RenderPassBeginInfo (vk::VkRenderPass                                              _renderPass,
 394                                                                                   vk::VkFramebuffer                                             _framebuffer,
 395                                                                                   vk::VkRect2D                                                  _renderArea,
 396                                                                                   const std::vector<vk::VkClearValue>&  _clearValues)
 397 {
 398
 399         m_clearValues   = _clearValues;
 400
 401         sType                   = vk::VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
 402         pNext                   = DE_NULL;
 403         renderPass              = _renderPass;
 404         framebuffer             = _framebuffer;
 405         renderArea              = _renderArea;
 406         clearValueCount = static_cast<deUint32>(m_clearValues.size());
 407         pClearValues    = m_clearValues.size() ? &m_clearValues[0] : DE_NULL;
 408 }
 409
 410 CmdPoolCreateInfo::CmdPoolCreateInfo (deUint32 _queueFamilyIndex, unsigned int _flags)
 411 {
 412         sType = vk::VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
 413         pNext = DE_NULL;
 414
 415         queueFamilyIndex = _queueFamilyIndex;
 416         flags                           = _flags;
 417 }
 418
 419 AttachmentDescription::AttachmentDescription (vk::VkFormat                              _format,
 420                                                                                           vk::VkSampleCountFlagBits     _samples,
 421                                                                                           vk::VkAttachmentLoadOp        _loadOp,
 422                                                                                           vk::VkAttachmentStoreOp       _storeOp,
 423                                                                                           vk::VkAttachmentLoadOp        _stencilLoadOp,
 424                                                                                           vk::VkAttachmentStoreOp       _stencilStoreOp,
 425                                                                                           vk::VkImageLayout                     _initialLayout,
 426                                                                                           vk::VkImageLayout                     _finalLayout)
 427 {
 428         flags = 0;
 429         format                  = _format;
 430         samples                 = _samples;
 431         loadOp                  = _loadOp;
 432         storeOp                 = _storeOp;
 433         stencilLoadOp   = _stencilLoadOp;
 434         stencilStoreOp  = _stencilStoreOp;
 435         initialLayout   = _initialLayout;
 436         finalLayout             = _finalLayout;
 437 }
 438
 439 AttachmentDescription::AttachmentDescription (const vk::VkAttachmentDescription& rhs)
 440 {
 441         flags                   = rhs.flags;
 442         format                  = rhs.format;
 443         samples                 = rhs.samples;
 444         loadOp                  = rhs.loadOp;
 445         storeOp                 = rhs.storeOp;
 446         stencilLoadOp   = rhs.stencilLoadOp;
 447         stencilStoreOp  = rhs.stencilStoreOp;
 448         initialLayout   = rhs.initialLayout;
 449         finalLayout             = rhs.finalLayout;
 450 }
 451
 452 AttachmentReference::AttachmentReference (deUint32 _attachment, vk::VkImageLayout _layout)
 453 {
 454         attachment      = _attachment;
 455         layout          = _layout;
 456 }
 457
 458 AttachmentReference::AttachmentReference (void)
 459 {
 460         attachment = vk::VK_ATTACHMENT_UNUSED;
 461         layout = vk::VK_IMAGE_LAYOUT_UNDEFINED;
 462 }
 463
 464 SubpassDescription::SubpassDescription (vk::VkPipelineBindPoint                         _pipelineBindPoint,
 465                                                                                 vk::VkSubpassDescriptionFlags           _flags,
 466                                                                                 deUint32                                                        _inputAttachmentCount,
 467                                                                                 const vk::VkAttachmentReference*        _inputAttachments,
 468                                                                                 deUint32                                                        _colorAttachmentCount,
 469                                                                                 const vk::VkAttachmentReference*        _colorAttachments,
 470                                                                                 const vk::VkAttachmentReference*        _resolveAttachments,
 471                                                                                 vk::VkAttachmentReference                       depthStencilAttachment,
 472                                                                                 deUint32                                                        _preserveAttachmentCount,
 473                                                                                 const vk::VkAttachmentReference*        _preserveAttachments)
 474 {
 475         m_inputAttachments = std::vector<vk::VkAttachmentReference>(_inputAttachments, _inputAttachments + _inputAttachmentCount);
 476         m_colorAttachments = std::vector<vk::VkAttachmentReference>(_colorAttachments, _colorAttachments + _colorAttachmentCount);
 477
 478         if (_resolveAttachments)
 479         {
 480                 m_resolveAttachments = std::vector<vk::VkAttachmentReference>(_resolveAttachments, _resolveAttachments + _colorAttachmentCount);
 481         }
 482
 483         m_preserveAttachments = std::vector<vk::VkAttachmentReference>(_preserveAttachments, _preserveAttachments + _preserveAttachmentCount);
 484
 485         m_depthStencilAttachment = depthStencilAttachment;
 486
 487         flags = _flags;
 488         pipelineBindPoint               = _pipelineBindPoint;
 489         inputAttachmentCount    = _inputAttachmentCount;
 490         pInputAttachments               = DE_NULL;
 491         colorAttachmentCount    = _colorAttachmentCount;
 492         pColorAttachments               = DE_NULL;
 493         pResolveAttachments             = DE_NULL;
 494         pDepthStencilAttachment = &m_depthStencilAttachment;
 495         pPreserveAttachments    = DE_NULL;
 496         preserveAttachmentCount = _preserveAttachmentCount;
 497
 498         if (m_inputAttachments.size()) {
 499                 pInputAttachments = &m_inputAttachments[0];
 500         }
 501
 502         if (m_colorAttachments.size()) {
 503                 pColorAttachments = &m_colorAttachments[0];
 504         }
 505
 506         if (m_resolveAttachments.size()) {
 507                 pResolveAttachments = &m_resolveAttachments[0];
 508         }
 509
 510         if (m_preserveAttachments.size()) {
 511                 pPreserveAttachments = &m_preserveAttachments[0];
 512         }
 513 }
 514
 515 SubpassDescription::SubpassDescription (const vk::VkSubpassDescription& rhs)
 516 {
 517         *static_cast<vk::VkSubpassDescription*>(this) = rhs;
 518
 519         m_inputAttachments = std::vector<vk::VkAttachmentReference>(
 520                 rhs.pInputAttachments, rhs.pInputAttachments + rhs.inputAttachmentCount);
 521
 522         m_colorAttachments = std::vector<vk::VkAttachmentReference>(
 523                 rhs.pColorAttachments, rhs.pColorAttachments + rhs.colorAttachmentCount);
 524
 525         if (rhs.pResolveAttachments) {
 526                 m_resolveAttachments = std::vector<vk::VkAttachmentReference>(
 527                         rhs.pResolveAttachments, rhs.pResolveAttachments + rhs.colorAttachmentCount);
 528         }
 529         m_preserveAttachments = std::vector<vk::VkAttachmentReference>(
 530                 rhs.pPreserveAttachments, rhs.pPreserveAttachments + rhs.preserveAttachmentCount);
 531
 532         if (rhs.pDepthStencilAttachment)
 533         {
 534                 m_depthStencilAttachment = *rhs.pDepthStencilAttachment;
 535         }
 536
 537         if (m_inputAttachments.size()) {
 538                 pInputAttachments = &m_inputAttachments[0];
 539         }
 540         if (m_colorAttachments.size()) {
 541                 pColorAttachments = &m_colorAttachments[0];
 542         }
 543
 544         if (m_resolveAttachments.size()) {
 545                 pResolveAttachments = &m_resolveAttachments[0];
 546         }
 547
 548         pDepthStencilAttachment = &m_depthStencilAttachment;
 549
 550         if (m_preserveAttachments.size()) {
 551                 pPreserveAttachments = &m_preserveAttachments[0];
 552         }
 553 }
 554
 555 SubpassDescription::SubpassDescription (const SubpassDescription& rhs) {
 556         *this = rhs;
 557 }
 558
 559 SubpassDescription& SubpassDescription::operator= (const SubpassDescription& rhs)
 560 {
 561         *static_cast<vk::VkSubpassDescription*>(this) = rhs;
 562
 563         m_inputAttachments              = rhs.m_inputAttachments;
 564         m_colorAttachments              = rhs.m_colorAttachments;
 565         m_resolveAttachments    = rhs.m_resolveAttachments;
 566         m_preserveAttachments   = rhs.m_preserveAttachments;
 567         m_depthStencilAttachment = rhs.m_depthStencilAttachment;
 568
 569         if (m_inputAttachments.size()) {
 570                 pInputAttachments = &m_inputAttachments[0];
 571         }
 572         if (m_colorAttachments.size()) {
 573                 pColorAttachments = &m_colorAttachments[0];
 574         }
 575
 576         if (m_resolveAttachments.size()) {
 577                 pResolveAttachments = &m_resolveAttachments[0];
 578         }
 579
 580         pDepthStencilAttachment = &m_depthStencilAttachment;
 581
 582         if (m_preserveAttachments.size()) {
 583                 pPreserveAttachments = &m_preserveAttachments[0];
 584         }
 585
 586         return *this;
 587 }
 588
 589 SubpassDependency::SubpassDependency (deUint32                                  _srcSubpass,
 590                                                                           deUint32                                      _dstSubpass,
 591                                                                           vk::VkPipelineStageFlags      _srcStageMask,
 592                                                                           vk::VkPipelineStageFlags      _dstStageMask,
 593                                                                           vk::VkAccessFlags                     _srcAccessMask,
 594                                                                           vk::VkAccessFlags                     _dstAccessMask,
 595                                                                           vk::VkDependencyFlags         _dependencyFlags)
 596 {
 597         srcSubpass              = _srcSubpass;
 598         dstSubpass              = _dstSubpass;
 599         srcStageMask    = _srcStageMask;
 600         dstStageMask    = _dstStageMask;
 601         srcAccessMask   = _srcAccessMask;
 602         dstAccessMask   = _dstAccessMask;
 603         dependencyFlags = _dependencyFlags;
 604 }
 605
 606 SubpassDependency::SubpassDependency (const vk::VkSubpassDependency& rhs)
 607 {
 608         srcSubpass              = rhs.srcSubpass;
 609         dstSubpass              = rhs.dstSubpass;
 610         srcStageMask    = rhs.srcStageMask;
 611         dstStageMask    = rhs.dstStageMask;
 612         srcAccessMask   = rhs.srcAccessMask;
 613         dstAccessMask   = rhs.dstAccessMask;
 614         dependencyFlags = rhs.dependencyFlags;
 615 }
 616
 617 CmdBufferBeginInfo::CmdBufferBeginInfo (vk::VkCommandBufferUsageFlags _flags)
 618 {
 619         sType = vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
 620         pNext = DE_NULL;
 621         renderPass                              = DE_NULL;
 622         subpass                                 = 0;
 623         framebuffer                             = DE_NULL;
 624         flags                                   = _flags;
 625         occlusionQueryEnable    = false;
 626         queryFlags                              = 0u;
 627         pipelineStatistics              = 0u;
 628 }
 629
 630 CmdBufferBeginInfo::CmdBufferBeginInfo (vk::VkRenderPass                                        _renderPass,
 631                                                                                 deUint32                                                        _subpass,
 632                                                                                 vk::VkFramebuffer                                       _framebuffer,
 633                                                                                 vk::VkCommandBufferUsageFlags           _flags,
 634                                                                                 bool                                                            _occlusionQueryEnable,
 635                                                                                 vk::VkQueryControlFlags                         _queryFlags,
 636                                                                                 vk::VkQueryPipelineStatisticFlags       _pipelineStatistics)
 637 {
 638
 639         sType = vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
 640         pNext = DE_NULL;
 641         renderPass                              = _renderPass;
 642         subpass                                 = _subpass;
 643         framebuffer                             = _framebuffer;
 644         flags                                   = _flags;
 645         occlusionQueryEnable    = _occlusionQueryEnable;
 646         queryFlags                              = _queryFlags;
 647         pipelineStatistics              = _pipelineStatistics;
 648 }
 649
 650 DescriptorPoolCreateInfo::DescriptorPoolCreateInfo (const std::vector<vk::VkDescriptorPoolSize>&        poolSizeCounts,
 651                                                                                                         vk::VkDescriptorPoolCreateFlags                                 _flags,
 652                                                                                                         deUint32                                                                                _maxSets)
 653         : m_poolSizeCounts(poolSizeCounts)
 654 {
 655         sType = vk::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
 656         pNext = DE_NULL;
 657         flags                   = _flags;
 658         maxSets                 = _maxSets;
 659         poolSizeCount   = static_cast<deUint32>(m_poolSizeCounts.size());
 660         pPoolSizes              = &m_poolSizeCounts[0];
 661 }
 662
 663 DescriptorPoolCreateInfo& DescriptorPoolCreateInfo::addDescriptors (vk::VkDescriptorType type, deUint32 count)
 664 {
 665         vk::VkDescriptorPoolSize descriptorTypeCount = { type, count };
 666         m_poolSizeCounts.push_back(descriptorTypeCount);
 667
 668         poolSizeCount   = static_cast<deUint32>(m_poolSizeCounts.size());
 669         pPoolSizes              = &m_poolSizeCounts[0];
 670
 671         return *this;
 672 }
 673
 674 DescriptorSetLayoutCreateInfo::DescriptorSetLayoutCreateInfo (deUint32 _bindingCount, const vk::VkDescriptorSetLayoutBinding* _pBindings)
 675 {
 676         sType = vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
 677         pNext = DE_NULL;
 678         flags = 0;
 679         bindingCount = _bindingCount;
 680         pBinding         = _pBindings;
 681 }
 682
 683 PipelineLayoutCreateInfo::PipelineLayoutCreateInfo (deUint32                                                    _descriptorSetCount,
 684                                                                                                         const vk::VkDescriptorSetLayout*        _pSetLayouts,
 685                                                                                                         deUint32                                                        _pushConstantRangeCount,
 686                                                                                                         const vk::VkPushConstantRange*          _pPushConstantRanges)
 687         : m_pushConstantRanges(_pPushConstantRanges, _pPushConstantRanges + _pushConstantRangeCount)
 688 {
 689         for (unsigned int i = 0; i < _descriptorSetCount; i++)
 690         {
 691                 m_setLayouts.push_back(_pSetLayouts[i]);
 692         }
 693
 694         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
 695         pNext = DE_NULL;
 696         setLayoutCount                  = static_cast<deUint32>(m_setLayouts.size());
 697         pSetLayouts                             = setLayoutCount > 0 ? &m_setLayouts[0] : DE_NULL;
 698         pushConstantRangeCount  = static_cast<deUint32>(m_pushConstantRanges.size());
 699
 700         if (m_pushConstantRanges.size()) {
 701                 pPushConstantRanges = &m_pushConstantRanges[0];
 702         }
 703         else
 704         {
 705                 pPushConstantRanges = DE_NULL;
 706         }
 707 }
 708
 709 PipelineLayoutCreateInfo::PipelineLayoutCreateInfo (const std::vector<vk::VkDescriptorSetLayout>&       setLayouts,
 710                                                                                                         deUint32                                                                                _pushConstantRangeCount,
 711                                                                                                         const vk::VkPushConstantRange*                                  _pPushConstantRanges)
 712         : m_setLayouts                  (setLayouts)
 713         , m_pushConstantRanges  (_pPushConstantRanges, _pPushConstantRanges + _pushConstantRangeCount)
 714 {
 715         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
 716         pNext = DE_NULL;
 717
 718         flags                   = 0u;
 719         setLayoutCount  = static_cast<deUint32>(m_setLayouts.size());
 720
 721         if (setLayoutCount)
 722         {
 723                 pSetLayouts = &m_setLayouts[0];
 724         }
 725         else
 726         {
 727                 pSetLayouts = DE_NULL;
 728         }
 729
 730         pushConstantRangeCount = static_cast<deUint32>(m_pushConstantRanges.size());
 731         if (pushConstantRangeCount) {
 732                 pPushConstantRanges = &m_pushConstantRanges[0];
 733         }
 734         else
 735         {
 736                 pPushConstantRanges = DE_NULL;
 737         }
 738 }
 739
 740 PipelineCreateInfo::PipelineShaderStage::PipelineShaderStage (vk::VkShaderModule _module, const char* _pName, vk::VkShaderStageFlagBits _stage)
 741 {
 742         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
 743         pNext = DE_NULL;
 744         flags = 0u;
 745         stage                           = _stage;
 746         module                          = _module;
 747         pName                           = _pName;
 748         pSpecializationInfo = DE_NULL;
 749 }
 750
 751 PipelineCreateInfo::VertexInputState::VertexInputState (deUint32                                                                                _vertexBindingDescriptionCount,
 752                                                                                                                 const vk::VkVertexInputBindingDescription*              _pVertexBindingDescriptions,
 753                                                                                                                 deUint32                                                                                _vertexAttributeDescriptionCount,
 754                                                                                                                 const vk::VkVertexInputAttributeDescription*    _pVertexAttributeDescriptions)
 755 {
 756         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
 757         pNext = DE_NULL;
 758         flags                                                   = 0u;
 759         vertexBindingDescriptionCount   = _vertexBindingDescriptionCount;
 760         pVertexBindingDescriptions              = _pVertexBindingDescriptions;
 761         vertexAttributeDescriptionCount = _vertexAttributeDescriptionCount;
 762         pVertexAttributeDescriptions    = _pVertexAttributeDescriptions;
 763 }
 764
 765 PipelineCreateInfo::InputAssemblerState::InputAssemblerState (vk::VkPrimitiveTopology   _topology,
 766                                                                                                                           vk::VkBool32                          _primitiveRestartEnable)
 767 {
 768         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
 769         pNext = DE_NULL;
 770         flags                                   = 0u;
 771         topology                                = _topology;
 772         primitiveRestartEnable  = _primitiveRestartEnable;
 773 }
 774
 775 PipelineCreateInfo::TesselationState::TesselationState (deUint32 _patchControlPoints)
 776 {
 777         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
 778         pNext = DE_NULL;
 779         flags                           = 0u;
 780         patchControlPoints      = _patchControlPoints;
 781 }
 782
 783 PipelineCreateInfo::ViewportState::ViewportState (deUint32                                              _viewportCount,
 784                                                                                                   std::vector<vk::VkViewport>   _viewports,
 785                                                                                                   std::vector<vk::VkRect2D>             _scissors)
 786 {
 787         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
 788         pNext = DE_NULL;
 789         flags                   = 0u;
 790         viewportCount   = _viewportCount;
 791         scissorCount    = _viewportCount;
 792
 793         if (!_viewports.size())
 794         {
 795                 m_viewports.resize(viewportCount);
 796                 deMemset(&m_viewports[0], 0, sizeof(m_viewports[0]) * m_viewports.size());
 797         }
 798         else
 799         {
 800                 m_viewports = _viewports;
 801         }
 802
 803         if (!_scissors.size())
 804         {
 805                 m_scissors.resize(scissorCount);
 806                 deMemset(&m_scissors[0], 0, sizeof(m_scissors[0]) * m_scissors.size());
 807         }
 808         else
 809         {
 810                 m_scissors = _scissors;
 811         }
 812
 813         pViewports      = &m_viewports[0];
 814         pScissors       = &m_scissors[0];
 815 }
 816
 817 PipelineCreateInfo::ViewportState::ViewportState (const ViewportState& other)
 818 {
 819         sType                   = other.sType;
 820         pNext                   = other.pNext;
 821         flags                   = other.flags;
 822         viewportCount   = other.viewportCount;
 823         scissorCount    = other.scissorCount;
 824
 825         m_viewports = std::vector<vk::VkViewport>(other.pViewports, other.pViewports + viewportCount);
 826         m_scissors      = std::vector<vk::VkRect2D>(other.pScissors, other.pScissors + scissorCount);
 827
 828         pViewports      = &m_viewports[0];
 829         pScissors       = &m_scissors[0];
 830 }
 831
 832 PipelineCreateInfo::ViewportState& PipelineCreateInfo::ViewportState::operator= (const ViewportState& other)
 833 {
 834         sType                   = other.sType;
 835         pNext                   = other.pNext;
 836         flags                   = other.flags;
 837         viewportCount   = other.viewportCount;
 838         scissorCount    = other.scissorCount;
 839
 840         m_viewports             = std::vector<vk::VkViewport>(other.pViewports, other.pViewports + scissorCount);
 841         m_scissors              = std::vector<vk::VkRect2D>(other.pScissors, other.pScissors + scissorCount);
 842
 843         pViewports              = &m_viewports[0];
 844         pScissors               = &m_scissors[0];
 845         return *this;
 846 }
 847
 848 PipelineCreateInfo::RasterizerState::RasterizerState (vk::VkBool32                      _depthClampEnable,
 849                                                                                                           vk::VkBool32                  _rasterizerDiscardEnable,
 850                                                                                                           vk::VkPolygonMode             _polygonMode,
 851                                                                                                           vk::VkCullModeFlags   _cullMode,
 852                                                                                                           vk::VkFrontFace               _frontFace,
 853                                                                                                           vk::VkBool32                  _depthBiasEnable,
 854                                                                                                           float                                 _depthBiasConstantFactor,
 855                                                                                                           float                                 _depthBiasClamp,
 856                                                                                                           float                                 _depthBiasSlopeFactor,
 857                                                                                                           float                                 _lineWidth)
 858 {
 859         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
 860         pNext = DE_NULL;
 861         flags                                   = 0u;
 862         depthClampEnable                = _depthClampEnable;
 863         rasterizerDiscardEnable = _rasterizerDiscardEnable;
 864         polygonMode                             = _polygonMode;
 865         cullMode                                = _cullMode;
 866         frontFace                               = _frontFace;
 867
 868         depthBiasEnable                 = _depthBiasEnable;
 869         depthBiasConstantFactor = _depthBiasConstantFactor;
 870         depthBiasClamp                  = _depthBiasClamp;
 871         depthBiasSlopeFactor    = _depthBiasSlopeFactor;
 872         lineWidth                               = _lineWidth;
 873 }
 874
 875 PipelineCreateInfo::MultiSampleState::MultiSampleState (vk::VkSampleCountFlagBits                               _rasterizationSamples,
 876                                                                                                                 vk::VkBool32                                                    _sampleShadingEnable,
 877                                                                                                                 float                                                                   _minSampleShading,
 878                                                                                                                 const std::vector<vk::VkSampleMask>&    _sampleMask,
 879                                                                                                                 bool                                                                    _alphaToCoverageEnable,
 880                                                                                                                 bool                                                                    _alphaToOneEnable)
 881         : m_sampleMask(_sampleMask)
 882 {
 883         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
 884         pNext = DE_NULL;
 885         flags                                   = 0u;
 886         rasterizationSamples    = _rasterizationSamples;
 887         sampleShadingEnable             = _sampleShadingEnable;
 888         minSampleShading                = _minSampleShading;
 889         pSampleMask                             = &m_sampleMask[0];
 890         alphaToCoverageEnable   = _alphaToCoverageEnable;
 891         alphaToOneEnable                = _alphaToOneEnable;
 892 }
 893
 894 PipelineCreateInfo::MultiSampleState::MultiSampleState (const MultiSampleState& other)
 895 {
 896         sType                                   = other.sType;
 897         pNext                                   = other.pNext;
 898         flags                                   = other.flags;
 899         rasterizationSamples    = other.rasterizationSamples;
 900         sampleShadingEnable             = other.sampleShadingEnable;
 901         minSampleShading                = other.minSampleShading;
 902
 903         const size_t sampleMaskArrayLen = (sizeof(vk::VkSampleMask) * 8 + other.rasterizationSamples) / (sizeof(vk::VkSampleMask) * 8);
 904
 905         m_sampleMask    = std::vector<vk::VkSampleMask>(other.pSampleMask, other.pSampleMask + sampleMaskArrayLen);
 906         pSampleMask             = &m_sampleMask[0];
 907 }
 908
 909 PipelineCreateInfo::MultiSampleState& PipelineCreateInfo::MultiSampleState::operator= (const MultiSampleState& other)
 910 {
 911         sType = other.sType;
 912         pNext = other.pNext;
 913         flags                                   = other.flags;
 914         rasterizationSamples    = other.rasterizationSamples;
 915         sampleShadingEnable             = other.sampleShadingEnable;
 916         minSampleShading                = other.minSampleShading;
 917
 918         const size_t sampleMaskArrayLen = (sizeof(vk::VkSampleMask) * 8 + other.rasterizationSamples) / (sizeof(vk::VkSampleMask) * 8);
 919
 920         m_sampleMask    = std::vector<vk::VkSampleMask>(other.pSampleMask, other.pSampleMask + sampleMaskArrayLen);
 921         pSampleMask             = &m_sampleMask[0];
 922
 923         return *this;
 924 }
 925
 926 PipelineCreateInfo::ColorBlendState::ColorBlendState (const std::vector<vk::VkPipelineColorBlendAttachmentState>&       _attachments,
 927                                                                                                           vk::VkBool32                                                                                                  _logicOpEnable,
 928                                                                                                           vk::VkLogicOp                                                                                                 _logicOp)
 929         : m_attachments(_attachments)
 930 {
 931         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
 932         pNext = DE_NULL;
 933         flags                                   = 0u;
 934         logicOpEnable                   = _logicOpEnable;
 935         logicOp                                 = _logicOp;
 936         attachmentCount                 = static_cast<deUint32>(m_attachments.size());
 937         pAttachments                    = &m_attachments[0];
 938 }
 939
 940 PipelineCreateInfo::ColorBlendState::ColorBlendState (deUint32                                                                                  _attachmentCount,
 941                                                                                                           const vk::VkPipelineColorBlendAttachmentState*        _attachments,
 942                                                                                                           vk::VkBool32                                                                          _logicOpEnable,
 943                                                                                                           vk::VkLogicOp                                                                         _logicOp)
 944         : m_attachments(_attachments, _attachments + _attachmentCount)
 945 {
 946         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
 947         pNext   = DE_NULL;
 948         flags                                   = 0u;
 949         logicOpEnable                   = _logicOpEnable;
 950         logicOp                                 = _logicOp;
 951         attachmentCount                 = static_cast<deUint32>(m_attachments.size());
 952         pAttachments                    = &m_attachments[0];
 953 }
 954
 955 PipelineCreateInfo::ColorBlendState::ColorBlendState (const vk::VkPipelineColorBlendStateCreateInfo& createInfo)
 956         : m_attachments (createInfo.pAttachments, createInfo.pAttachments + createInfo.attachmentCount)
 957 {
 958         sType = createInfo.sType;
 959         pNext = createInfo.pNext;
 960         flags                                   = createInfo.flags;
 961         logicOpEnable                   = createInfo.logicOpEnable;
 962         logicOp                                 = createInfo.logicOp;
 963         attachmentCount                 = static_cast<deUint32>(m_attachments.size());
 964         pAttachments                    = &m_attachments[0];
 965 }
 966
 967 PipelineCreateInfo::ColorBlendState::ColorBlendState (const ColorBlendState& createInfo, std::vector<float> _blendConstants)
 968         : m_attachments (createInfo.pAttachments, createInfo.pAttachments + createInfo.attachmentCount)
 969 {
 970         sType = createInfo.sType;
 971         pNext = createInfo.pNext;
 972         flags                                   = createInfo.flags;
 973         logicOpEnable                   = createInfo.logicOpEnable;
 974         logicOp                                 = createInfo.logicOp;
 975         attachmentCount                 = static_cast<deUint32>(m_attachments.size());
 976         pAttachments                    = &m_attachments[0];
 977         deMemcpy(blendConstants, &_blendConstants[0], 4 * sizeof(float));
 978 }
 979
 980 PipelineCreateInfo::ColorBlendState::Attachment::Attachment (vk::VkBool32               _blendEnable,
 981                                                                                                                          vk::VkBlendFactor      _srcColorBlendFactor,
 982                                                                                                                          vk::VkBlendFactor      _dstColorBlendFactor,
 983                                                                                                                          vk::VkBlendOp          _colorBlendOp,
 984                                                                                                                          vk::VkBlendFactor      _srcAlphaBlendFactor,
 985                                                                                                                          vk::VkBlendFactor      _dstAlphaBlendFactor,
 986                                                                                                                          vk::VkBlendOp          _alphaBlendOp,
 987                                                                                                                          deUint8                        _colorWriteMask)
 988 {
 989         blendEnable                     = _blendEnable;
 990         srcColorBlendFactor     = _srcColorBlendFactor;
 991         dstColorBlendFactor     = _dstColorBlendFactor;
 992         colorBlendOp            = _colorBlendOp;
 993         srcAlphaBlendFactor     = _srcAlphaBlendFactor;
 994         dstAlphaBlendFactor     = _dstAlphaBlendFactor;
 995         alphaBlendOp            = _alphaBlendOp;
 996         colorWriteMask  = _colorWriteMask;
 997 }
 998
 999 PipelineCreateInfo::DepthStencilState::StencilOpState::StencilOpState (vk::VkStencilOp  _failOp,
1000                                                                                                                                            vk::VkStencilOp      _passOp,
1001                                                                                                                                            vk::VkStencilOp      _depthFailOp,
1002                                                                                                                                            vk::VkCompareOp      _compareOp,
1003                                                                                                                                            deUint32                     _compareMask,
1004                                                                                                                                            deUint32                     _writeMask,
1005                                                                                                                                            deUint32                     _reference)
1006 {
1007         failOp          = _failOp;
1008         passOp          = _passOp;
1009         depthFailOp     = _depthFailOp;
1010         compareOp       = _compareOp;
1011
1012         compareMask     = _compareMask;
1013         writeMask       = _writeMask;
1014         reference       = _reference;
1015 }
1016
1017 PipelineCreateInfo::DepthStencilState::DepthStencilState (vk::VkBool32          _depthTestEnable,
1018                                                                                                                   vk::VkBool32          _depthWriteEnable,
1019                                                                                                                   vk::VkCompareOp       _depthCompareOp,
1020                                                                                                                   vk::VkBool32          _depthBoundsTestEnable,
1021                                                                                                                   vk::VkBool32          _stencilTestEnable,
1022                                                                                                                   StencilOpState        _front,
1023                                                                                                                   StencilOpState        _back,
1024                                                                                                                   float                         _minDepthBounds,
1025                                                                                                                   float                         _maxDepthBounds)
1026 {
1027         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
1028         pNext = DE_NULL;
1029         flags                                   = 0u;
1030         depthTestEnable                 = _depthTestEnable;
1031         depthWriteEnable                = _depthWriteEnable;
1032         depthCompareOp                  = _depthCompareOp;
1033         depthBoundsTestEnable   = _depthBoundsTestEnable;
1034         stencilTestEnable               = _stencilTestEnable;
1035         front   = _front;
1036         back    = _back;
1037
1038         minDepthBounds = _minDepthBounds;
1039         maxDepthBounds = _maxDepthBounds;
1040 }
1041
1042 PipelineCreateInfo::DynamicState::DynamicState (const std::vector<vk::VkDynamicState>& _dynamicStates)
1043 {
1044         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
1045         pNext = DE_NULL;
1046         flags = 0u;
1047
1048         if (!_dynamicStates.size())
1049         {
1050                 for (size_t i = 0; i < vk::VK_DYNAMIC_STATE_LAST; ++i)
1051                 {
1052                         m_dynamicStates.push_back(static_cast<vk::VkDynamicState>(i));
1053                 }
1054         }
1055         else
1056                 m_dynamicStates = _dynamicStates;
1057
1058         dynamicStateCount = static_cast<deUint32>(m_dynamicStates.size());
1059         pDynamicStates = &m_dynamicStates[0];
1060 }
1061
1062 PipelineCreateInfo::DynamicState::DynamicState (const DynamicState &other)
1063 {
1064         sType = other.sType;
1065         pNext = other.pNext;
1066         flags = other.flags;
1067
1068         dynamicStateCount = other.dynamicStateCount;
1069
1070         m_dynamicStates = std::vector<vk::VkDynamicState>(other.pDynamicStates, other.pDynamicStates + dynamicStateCount);
1071         pDynamicStates = &m_dynamicStates[0];
1072 }
1073
1074 PipelineCreateInfo::DynamicState& PipelineCreateInfo::DynamicState::operator= (const DynamicState& other)
1075 {
1076         sType = other.sType;
1077         pNext = other.pNext;
1078         flags = other.flags;
1079
1080         dynamicStateCount = other.dynamicStateCount;
1081
1082         m_dynamicStates = std::vector<vk::VkDynamicState>(other.pDynamicStates, other.pDynamicStates + dynamicStateCount);
1083         pDynamicStates = &m_dynamicStates[0];
1084
1085         return *this;
1086 }
1087
1088 PipelineCreateInfo::PipelineCreateInfo (vk::VkPipelineLayout            _layout,
1089                                                                                 vk::VkRenderPass                        _renderPass,
1090                                                                                 int                                                     _subpass,
1091                                                                                 vk::VkPipelineCreateFlags       _flags)
1092 {
1093         deMemset(static_cast<vk::VkGraphicsPipelineCreateInfo *>(this), 0,
1094                 sizeof(vk::VkGraphicsPipelineCreateInfo));
1095
1096         sType = vk::VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
1097         pNext = DE_NULL;
1098         flags                           = _flags;
1099         renderPass                      = _renderPass;
1100         subpass                         = _subpass;
1101         layout                          = _layout;
1102         basePipelineHandle      = DE_NULL;
1103         basePipelineIndex       = 0;
1104         pDynamicState           = DE_NULL;
1105 }
1106
1107 PipelineCreateInfo& PipelineCreateInfo::addShader (const vk::VkPipelineShaderStageCreateInfo& shader)
1108 {
1109         m_shaders.push_back(shader);
1110
1111         stageCount      = static_cast<deUint32>(m_shaders.size());
1112         pStages         = &m_shaders[0];
1113
1114         return *this;
1115 }
1116
1117 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineVertexInputStateCreateInfo& state)
1118 {
1119         m_vertexInputState      = state;
1120         pVertexInputState       = &m_vertexInputState;
1121
1122         return *this;
1123 }
1124
1125 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineInputAssemblyStateCreateInfo& state)
1126 {
1127         m_inputAssemblyState = state;
1128         pInputAssemblyState = &m_inputAssemblyState;
1129
1130         return *this;
1131 }
1132
1133 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineColorBlendStateCreateInfo& state)
1134 {
1135         m_colorBlendStateAttachments    = std::vector<vk::VkPipelineColorBlendAttachmentState>(state.pAttachments, state.pAttachments + state.attachmentCount);
1136         m_colorBlendState                               = state;
1137         m_colorBlendState.pAttachments  = &m_colorBlendStateAttachments[0];
1138         pColorBlendState                                = &m_colorBlendState;
1139
1140         return *this;
1141 }
1142
1143 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineViewportStateCreateInfo& state)
1144 {
1145         m_viewports                                     = std::vector<vk::VkViewport>(state.pViewports, state.pViewports + state.viewportCount);
1146         m_scissors                                      = std::vector<vk::VkRect2D>(state.pScissors, state.pScissors + state.scissorCount);
1147         m_viewportState                         = state;
1148         m_viewportState.pViewports      = &m_viewports[0];
1149         m_viewportState.pScissors       = &m_scissors[0];
1150         pViewportState                          = &m_viewportState;
1151
1152         return *this;
1153 }
1154
1155 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineDepthStencilStateCreateInfo& state)
1156 {
1157         m_dynamicDepthStencilState      = state;
1158         pDepthStencilState                      = &m_dynamicDepthStencilState;
1159         return *this;
1160 }
1161
1162 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineTessellationStateCreateInfo& state)
1163 {
1164         m_tessState                     = state;
1165         pTessellationState      = &m_tessState;
1166
1167         return *this;
1168 }
1169
1170 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineRasterizationStateCreateInfo& state)
1171 {
1172         m_rasterState           = state;
1173         pRasterizationState     = &m_rasterState;
1174
1175         return *this;
1176 }
1177
1178 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineMultisampleStateCreateInfo& state)
1179 {
1180
1181         const size_t sampleMaskArrayLen = (sizeof(vk::VkSampleMask) * 8 + state.rasterizationSamples) / ( sizeof(vk::VkSampleMask) * 8 );
1182         m_multisampleStateSampleMask    = std::vector<vk::VkSampleMask>(state.pSampleMask, state.pSampleMask + sampleMaskArrayLen);
1183         m_multisampleState                              = state;
1184         m_multisampleState.pSampleMask  = &m_multisampleStateSampleMask[0];
1185         pMultisampleState                               = &m_multisampleState;
1186
1187         return *this;
1188 }
1189 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineDynamicStateCreateInfo& state)
1190 {
1191         m_dynamicStates                                 = std::vector<vk::VkDynamicState>(state.pDynamicStates, state.pDynamicStates + state.dynamicStateCount);
1192         m_dynamicState                                  = state;
1193         m_dynamicState.pDynamicStates   = &m_dynamicStates[0];
1194         pDynamicState                                   = &m_dynamicState;
1195
1196         return *this;
1197 }
1198
1199 SamplerCreateInfo::SamplerCreateInfo (vk::VkFilter                              _magFilter,
1200                                                                           vk::VkFilter                          _minFilter,
1201                                                                           vk::VkSamplerMipmapMode       _mipmapMode,
1202                                                                           vk::VkSamplerAddressMode      _addressModeU,
1203                                                                           vk::VkSamplerAddressMode      _addressModeV,
1204                                                                           vk::VkSamplerAddressMode      _addressModeW,
1205                                                                           float                                         _mipLodBias,
1206                                                                           float                                         _maxAnisotropy,
1207                                                                           vk::VkBool32                          _compareEnable,
1208                                                                           vk::VkCompareOp                       _compareOp,
1209                                                                           float                                         _minLod,
1210                                                                           float                                         _maxLod,
1211                                                                           vk::VkBorderColor                     _borderColor,
1212                                                                           vk::VkBool32                          _unnormalizedCoordinates)
1213 {
1214         sType                                   = vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
1215         pNext                                   = DE_NULL;
1216         flags                                   = 0u;
1217         magFilter                               = _magFilter;
1218         minFilter                               = _minFilter;
1219         mipmapMode                              = _mipmapMode;
1220         addressModeU                    = _addressModeU;
1221         addressModeV                    = _addressModeV;
1222         addressModeW                    = _addressModeW;
1223         mipLodBias                              = _mipLodBias;
1224         maxAnisotropy                   = _maxAnisotropy;
1225         compareEnable                   = _compareEnable;
1226         compareOp                               = _compareOp;
1227         minLod                                  = _minLod;
1228         maxLod                                  = _maxLod;
1229         borderColor                             = _borderColor;
1230         unnormalizedCoordinates = _unnormalizedCoordinates;
1231 }
1232 } // DynamicState
1233 } // vkt