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