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
 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,\r
 635                                                                                 vk::VkQueryControlFlags                         _queryFlags,\r
 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
 684 PipelineLayoutCreateInfo::PipelineLayoutCreateInfo (deUint32                                                    _descriptorSetCount,
 685                                                                                                         const vk::VkDescriptorSetLayout*        _pSetLayouts,
 686                                                                                                         deUint32                                                        _pushConstantRangeCount,
 687                                                                                                         const vk::VkPushConstantRange*          _pPushConstantRanges)
 688         : m_pushConstantRanges(_pPushConstantRanges, _pPushConstantRanges + _pushConstantRangeCount)
 689 {
 690         for (unsigned int i = 0; i < _descriptorSetCount; i++)
 691         {
 692                 m_setLayouts.push_back(_pSetLayouts[i]);
 693         }
 694
 695         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
 696         pNext = DE_NULL;
 697         setLayoutCount                  = static_cast<deUint32>(m_setLayouts.size());
 698         pSetLayouts                             = setLayoutCount > 0 ? &m_setLayouts[0] : DE_NULL;
 699         pushConstantRangeCount  = static_cast<deUint32>(m_pushConstantRanges.size());
 700
 701         if (m_pushConstantRanges.size()) {
 702                 pPushConstantRanges = &m_pushConstantRanges[0];
 703         }
 704         else
 705         {
 706                 pPushConstantRanges = DE_NULL;
 707         }
 708 }
 709
 710 PipelineLayoutCreateInfo::PipelineLayoutCreateInfo (const std::vector<vk::VkDescriptorSetLayout>&       setLayouts,
 711                                                                                                         deUint32                                                                                _pushConstantRangeCount,
 712                                                                                                         const vk::VkPushConstantRange*                                  _pPushConstantRanges)
 713         : m_setLayouts                  (setLayouts)
 714         , m_pushConstantRanges  (_pPushConstantRanges, _pPushConstantRanges + _pushConstantRangeCount)
 715 {
 716         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
 717         pNext = DE_NULL;
 718
 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
 741 PipelineCreateInfo::PipelineShaderStage::PipelineShaderStage (vk::VkShaderModule _module, const char* _pName, vk::VkShaderStageFlagBits _stage)
 742 {
 743         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
 744         pNext = DE_NULL;
 745         flags = 0u;
 746         stage                           = _stage;
 747         module                          = _module;
 748         pName                           = _pName;
 749         pSpecializationInfo = DE_NULL;
 750 }
 751
 752 PipelineCreateInfo::VertexInputState::VertexInputState (deUint32                                                                                _vertexBindingDescriptionCount,
 753                                                                                                                 const vk::VkVertexInputBindingDescription*              _pVertexBindingDescriptions,
 754                                                                                                                 deUint32                                                                                _vertexAttributeDescriptionCount,
 755                                                                                                                 const vk::VkVertexInputAttributeDescription*    _pVertexAttributeDescriptions)
 756 {
 757         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
 758         pNext = DE_NULL;
 759         flags                                                   = 0u;
 760         vertexBindingDescriptionCount   = _vertexBindingDescriptionCount;
 761         pVertexBindingDescriptions              = _pVertexBindingDescriptions;
 762         vertexAttributeDescriptionCount = _vertexAttributeDescriptionCount;
 763         pVertexAttributeDescriptions    = _pVertexAttributeDescriptions;
 764 }
 765
 766 PipelineCreateInfo::InputAssemblerState::InputAssemblerState (vk::VkPrimitiveTopology   _topology,
 767                                                                                                                           vk::VkBool32                          _primitiveRestartEnable)
 768 {
 769         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
 770         pNext = DE_NULL;
 771         flags                                   = 0u;
 772         topology                                = _topology;
 773         primitiveRestartEnable  = _primitiveRestartEnable;
 774 }
 775
 776 PipelineCreateInfo::TesselationState::TesselationState (deUint32 _patchControlPoints)
 777 {
 778         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
 779         pNext = DE_NULL;
 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         viewportCount   = other.viewportCount;
 822         scissorCount    = other.scissorCount;
 823
 824         m_viewports = std::vector<vk::VkViewport>(other.pViewports, other.pViewports + viewportCount);
 825         m_scissors      = std::vector<vk::VkRect2D>(other.pScissors, other.pScissors + scissorCount);
 826
 827         pViewports      = &m_viewports[0];
 828         pScissors       = &m_scissors[0];
 829 }
 830
 831 PipelineCreateInfo::ViewportState & PipelineCreateInfo::ViewportState::operator= (const ViewportState &other)
 832 {
 833         sType                   = other.sType;
 834         pNext                   = other.pNext;
 835         viewportCount   = other.viewportCount;
 836         scissorCount    = other.scissorCount;
 837
 838         m_viewports             = std::vector<vk::VkViewport>(other.pViewports, other.pViewports + scissorCount);
 839         m_scissors              = std::vector<vk::VkRect2D>(other.pScissors, other.pScissors + scissorCount);
 840
 841         pViewports              = &m_viewports[0];
 842         pScissors               = &m_scissors[0];
 843         return *this;
 844 }
 845
 846 PipelineCreateInfo::RasterizerState::RasterizerState (vk::VkBool32                      _depthClampEnable,
 847                                                                                                           vk::VkBool32                  _rasterizerDiscardEnable,
 848                                                                                                           vk::VkPolygonMode             _polygonMode,
 849                                                                                                           vk::VkCullModeFlags   _cullMode,
 850                                                                                                           vk::VkFrontFace               _frontFace,
 851                                                                                                           vk::VkBool32                  _depthBiasEnable,
 852                                                                                                           float                                 _depthBiasConstantFactor,
 853                                                                                                           float                                 _depthBiasClamp,
 854                                                                                                           float                                 _depthBiasSlopeFactor,
 855                                                                                                           float                                 _lineWidth)
 856 {
 857         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
 858         pNext = DE_NULL;
 859         flags                                   = 0u;
 860         depthClampEnable                = _depthClampEnable;
 861         rasterizerDiscardEnable = _rasterizerDiscardEnable;
 862         polygonMode                             = _polygonMode;
 863         cullMode                                = _cullMode;
 864         frontFace                               = _frontFace;
 865
 866         depthBiasEnable                 = _depthBiasEnable;
 867         depthBiasConstantFactor = _depthBiasConstantFactor;
 868         depthBiasClamp                  = _depthBiasClamp;
 869         depthBiasSlopeFactor    = _depthBiasSlopeFactor;
 870         lineWidth                               = _lineWidth;
 871 }
 872
 873 PipelineCreateInfo::MultiSampleState::MultiSampleState (vk::VkSampleCountFlagBits                               _rasterizationSamples,
 874                                                                                                                 vk::VkBool32                                                    _sampleShadingEnable,
 875                                                                                                                 float                                                                   _minSampleShading,
 876                                                                                                                 const std::vector<vk::VkSampleMask>&    _sampleMask,
 877                                                                                                                 bool                                                                    _alphaToCoverageEnable,
 878                                                                                                                 bool                                                                    _alphaToOneEnable)
 879         : m_sampleMask(_sampleMask)
 880 {
 881         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
 882         pNext = DE_NULL;
 883         flags                                   = 0u;
 884         rasterizationSamples    = _rasterizationSamples;
 885         sampleShadingEnable             = _sampleShadingEnable;
 886         minSampleShading                = _minSampleShading;
 887         pSampleMask                             = &m_sampleMask[0];
 888         alphaToCoverageEnable   = _alphaToCoverageEnable;
 889         alphaToOneEnable                = _alphaToOneEnable;
 890 }
 891
 892 PipelineCreateInfo::MultiSampleState::MultiSampleState (const MultiSampleState &other)
 893 {
 894         sType                                   = other.sType;
 895         pNext                                   = other.pNext;
 896         rasterizationSamples    = other.rasterizationSamples;
 897         sampleShadingEnable             = other.sampleShadingEnable;
 898         minSampleShading                = other.minSampleShading;
 899
 900         const size_t sampleMaskArrayLen = (sizeof(vk::VkSampleMask) * 8 + other.rasterizationSamples) / (sizeof(vk::VkSampleMask) * 8);
 901
 902         m_sampleMask    = std::vector<vk::VkSampleMask>(other.pSampleMask, other.pSampleMask + sampleMaskArrayLen);
 903         pSampleMask             = &m_sampleMask[0];
 904 }
 905
 906 PipelineCreateInfo::MultiSampleState& PipelineCreateInfo::MultiSampleState::operator= (const MultiSampleState & other)
 907 {
 908         sType = other.sType;
 909         pNext = other.pNext;
 910         rasterizationSamples    = other.rasterizationSamples;
 911         sampleShadingEnable             = other.sampleShadingEnable;
 912         minSampleShading                = other.minSampleShading;
 913
 914         const size_t sampleMaskArrayLen = (sizeof(vk::VkSampleMask) * 8 + other.rasterizationSamples) / (sizeof(vk::VkSampleMask) * 8);
 915
 916         m_sampleMask    = std::vector<vk::VkSampleMask>(other.pSampleMask, other.pSampleMask + sampleMaskArrayLen);
 917         pSampleMask             = &m_sampleMask[0];
 918
 919         return *this;
 920 }
 921
 922 PipelineCreateInfo::ColorBlendState::ColorBlendState (const std::vector<vk::VkPipelineColorBlendAttachmentState>&       _attachments,
 923                                                                                                           vk::VkBool32                                                                                                  _logicOpEnable,
 924                                                                                                           vk::VkLogicOp                                                                                                 _logicOp)
 925         : m_attachments(_attachments)
 926 {
 927         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
 928         pNext = DE_NULL;
 929         flags                                   = 0u;
 930         logicOpEnable                   = _logicOpEnable;
 931         logicOp                                 = _logicOp;
 932         attachmentCount                 = static_cast<deUint32>(m_attachments.size());
 933         pAttachments                    = &m_attachments[0];
 934 }
 935
 936 PipelineCreateInfo::ColorBlendState::ColorBlendState (deUint32                                                                                  _attachmentCount,
 937                                                                                                           const vk::VkPipelineColorBlendAttachmentState*        _attachments,
 938                                                                                                           vk::VkBool32                                                                          _logicOpEnable,
 939                                                                                                           vk::VkLogicOp                                                                         _logicOp)
 940         : m_attachments(_attachments, _attachments + _attachmentCount)
 941 {
 942         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
 943         pNext   = DE_NULL;
 944         logicOpEnable                   = _logicOpEnable;
 945         logicOp                                 = _logicOp;
 946         attachmentCount                 = static_cast<deUint32>(m_attachments.size());
 947         pAttachments                    = &m_attachments[0];
 948 }
 949
 950 PipelineCreateInfo::ColorBlendState::ColorBlendState (const vk::VkPipelineColorBlendStateCreateInfo &createInfo)
 951         : m_attachments (createInfo.pAttachments, createInfo.pAttachments + createInfo.attachmentCount)
 952 {
 953         sType = createInfo.sType;
 954         pNext = createInfo.pNext;
 955         logicOpEnable                   = createInfo.logicOpEnable;
 956         logicOp                                 = createInfo.logicOp;
 957         attachmentCount                 = static_cast<deUint32>(m_attachments.size());
 958         pAttachments                    = &m_attachments[0];
 959 }
 960
 961 PipelineCreateInfo::ColorBlendState::ColorBlendState (const ColorBlendState &createInfo, std::vector<float> _blendConstants)
 962         : m_attachments (createInfo.pAttachments, createInfo.pAttachments + createInfo.attachmentCount)
 963 {
 964         sType = createInfo.sType;
 965         pNext = createInfo.pNext;
 966         logicOpEnable                   = createInfo.logicOpEnable;
 967         logicOp                                 = createInfo.logicOp;
 968         attachmentCount                 = static_cast<deUint32>(m_attachments.size());
 969         pAttachments                    = &m_attachments[0];
 970         deMemcpy(blendConstants, &_blendConstants[0], 4 * sizeof(float));
 971 }
 972
 973 PipelineCreateInfo::ColorBlendState::Attachment::Attachment (vk::VkBool32               _blendEnable,
 974                                                                                                                          vk::VkBlendFactor      _srcColorBlendFactor,
 975                                                                                                                          vk::VkBlendFactor      _dstColorBlendFactor,
 976                                                                                                                          vk::VkBlendOp          _colorBlendOp,
 977                                                                                                                          vk::VkBlendFactor      _srcAlphaBlendFactor,
 978                                                                                                                          vk::VkBlendFactor      _dstAlphaBlendFactor,
 979                                                                                                                          vk::VkBlendOp          _alphaBlendOp,
 980                                                                                                                          deUint8                        _colorWriteMask)
 981 {
 982         blendEnable                     = _blendEnable;
 983         srcColorBlendFactor     = _srcColorBlendFactor;
 984         dstColorBlendFactor     = _dstColorBlendFactor;
 985         colorBlendOp            = _colorBlendOp;
 986         srcAlphaBlendFactor     = _srcAlphaBlendFactor;
 987         dstAlphaBlendFactor     = _dstAlphaBlendFactor;
 988         alphaBlendOp            = _alphaBlendOp;
 989         colorWriteMask  = _colorWriteMask;
 990 }
 991
 992 PipelineCreateInfo::DepthStencilState::StencilOpState::StencilOpState (vk::VkStencilOp  _failOp,
 993                                                                                                                                            vk::VkStencilOp      _passOp,
 994                                                                                                                                            vk::VkStencilOp      _depthFailOp,
 995                                                                                                                                            vk::VkCompareOp      _compareOp,
 996                                                                                                                                            deUint32                     _compareMask,
 997                                                                                                                                            deUint32                     _writeMask,
 998                                                                                                                                            deUint32                     _reference)
 999 {
1000         failOp          = _failOp;
1001         passOp          = _passOp;
1002         depthFailOp     = _depthFailOp;
1003         compareOp       = _compareOp;
1004
1005         compareMask     = _compareMask;
1006         writeMask       = _writeMask;
1007         reference       = _reference;
1008 }
1009
1010 PipelineCreateInfo::DepthStencilState::DepthStencilState (vk::VkBool32          _depthTestEnable,
1011                                                                                                                   vk::VkBool32          _depthWriteEnable,
1012                                                                                                                   vk::VkCompareOp       _depthCompareOp,
1013                                                                                                                   vk::VkBool32          _depthBoundsTestEnable,
1014                                                                                                                   vk::VkBool32          _stencilTestEnable,
1015                                                                                                                   StencilOpState        _front,
1016                                                                                                                   StencilOpState        _back,
1017                                                                                                                   float                         _minDepthBounds,
1018                                                                                                                   float                         _maxDepthBounds)
1019 {
1020         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
1021         pNext = DE_NULL;
1022         flags                                   = 0u;
1023         depthTestEnable                 = _depthTestEnable;
1024         depthWriteEnable                = _depthWriteEnable;
1025         depthCompareOp                  = _depthCompareOp;
1026         depthBoundsTestEnable   = _depthBoundsTestEnable;
1027         stencilTestEnable               = _stencilTestEnable;
1028         front   = _front;
1029         back    = _back;
1030
1031         minDepthBounds = _minDepthBounds;
1032         maxDepthBounds = _maxDepthBounds;
1033 }
1034
1035 PipelineCreateInfo::DynamicState::DynamicState (const std::vector<vk::VkDynamicState>& _dynamicStates)
1036 {
1037         sType = vk::VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
1038         pNext = DE_NULL;
1039
1040         if (!_dynamicStates.size())
1041         {
1042                 for (size_t i = 0; i < vk::VK_DYNAMIC_STATE_LAST; ++i)
1043                 {
1044                         m_dynamicStates.push_back(static_cast<vk::VkDynamicState>(i));
1045                 }
1046         }
1047         else
1048                 m_dynamicStates = _dynamicStates;
1049
1050         dynamicStateCount = static_cast<deUint32>(m_dynamicStates.size());
1051         pDynamicStates = &m_dynamicStates[0];
1052 }
1053
1054 PipelineCreateInfo::DynamicState::DynamicState (const DynamicState &other)
1055 {
1056         sType = other.sType;
1057         pNext = other.pNext;
1058
1059         dynamicStateCount = other.dynamicStateCount;
1060
1061         m_dynamicStates = std::vector<vk::VkDynamicState>(other.pDynamicStates, other.pDynamicStates + dynamicStateCount);
1062         pDynamicStates = &m_dynamicStates[0];
1063 }
1064
1065 PipelineCreateInfo::DynamicState & PipelineCreateInfo::DynamicState::operator= (const DynamicState &other)
1066 {
1067         sType = other.sType;
1068         pNext = other.pNext;
1069
1070         dynamicStateCount = other.dynamicStateCount;
1071
1072         m_dynamicStates = std::vector<vk::VkDynamicState>(other.pDynamicStates, other.pDynamicStates + dynamicStateCount);
1073         pDynamicStates = &m_dynamicStates[0];
1074
1075         return *this;
1076 }
1077
1078 PipelineCreateInfo::PipelineCreateInfo (vk::VkPipelineLayout            _layout,
1079                                                                                 vk::VkRenderPass                        _renderPass,
1080                                                                                 int                                                     _subpass,
1081                                                                                 vk::VkPipelineCreateFlags       _flags)
1082 {
1083         deMemset(static_cast<vk::VkGraphicsPipelineCreateInfo *>(this), 0,
1084                 sizeof(vk::VkGraphicsPipelineCreateInfo));
1085
1086         sType = vk::VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
1087         pNext = DE_NULL;
1088         flags                           = _flags;
1089         renderPass                      = _renderPass;
1090         subpass                         = _subpass;
1091         layout                          = _layout;
1092         basePipelineHandle      = DE_NULL;
1093         basePipelineIndex       = 0;
1094         pDynamicState           = DE_NULL;
1095 }
1096
1097 PipelineCreateInfo& PipelineCreateInfo::addShader (const vk::VkPipelineShaderStageCreateInfo &shader)
1098 {
1099         m_shaders.push_back(shader);
1100
1101         stageCount      = static_cast<deUint32>(m_shaders.size());
1102         pStages         = &m_shaders[0];
1103
1104         return *this;
1105 }
1106
1107 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineVertexInputStateCreateInfo& state)
1108 {
1109         m_vertexInputState      = state;
1110         pVertexInputState       = &m_vertexInputState;
1111
1112         return *this;
1113 }
1114
1115 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineInputAssemblyStateCreateInfo& state)
1116 {
1117         m_inputAssemblyState = state;
1118         pInputAssemblyState = &m_inputAssemblyState;
1119
1120         return *this;
1121 }
1122
1123 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineColorBlendStateCreateInfo& state)
1124 {
1125         m_colorBlendStateAttachments    = std::vector<vk::VkPipelineColorBlendAttachmentState>(state.pAttachments, state.pAttachments + state.attachmentCount);
1126         m_colorBlendState                               = state;
1127         m_colorBlendState.pAttachments  = &m_colorBlendStateAttachments[0];
1128         pColorBlendState                                = &m_colorBlendState;
1129
1130         return *this;
1131 }
1132
1133 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineViewportStateCreateInfo& state)
1134 {
1135         m_viewports                                     = std::vector<vk::VkViewport>(state.pViewports, state.pViewports + state.viewportCount);
1136         m_scissors                                      = std::vector<vk::VkRect2D>(state.pScissors, state.pScissors + state.scissorCount);
1137         m_viewportState                         = state;
1138         m_viewportState.pViewports      = &m_viewports[0];
1139         m_viewportState.pScissors       = &m_scissors[0];
1140         pViewportState                          = &m_viewportState;
1141
1142         return *this;
1143 }
1144
1145 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineDepthStencilStateCreateInfo& state)
1146 {
1147         m_dynamicDepthStencilState      = state;
1148         pDepthStencilState                      = &m_dynamicDepthStencilState;
1149         return *this;
1150 }
1151
1152 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineTessellationStateCreateInfo& state)
1153 {
1154         m_tessState                     = state;
1155         pTessellationState      = &m_tessState;
1156
1157         return *this;
1158 }
1159
1160 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineRasterizationStateCreateInfo& state)
1161 {
1162         m_rasterState           = state;
1163         pRasterizationState     = &m_rasterState;
1164
1165         return *this;
1166 }
1167
1168 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineMultisampleStateCreateInfo& state)
1169 {
1170
1171         const size_t sampleMaskArrayLen = (sizeof(vk::VkSampleMask) * 8 + state.rasterizationSamples) / ( sizeof(vk::VkSampleMask) * 8 );
1172         m_multisampleStateSampleMask    = std::vector<vk::VkSampleMask>(state.pSampleMask, state.pSampleMask + sampleMaskArrayLen);
1173         m_multisampleState                              = state;
1174         m_multisampleState.pSampleMask  = &m_multisampleStateSampleMask[0];
1175         pMultisampleState                               = &m_multisampleState;
1176
1177         return *this;
1178 }
1179 PipelineCreateInfo& PipelineCreateInfo::addState (const vk::VkPipelineDynamicStateCreateInfo& state)
1180 {
1181         m_dynamicStates                                 = std::vector<vk::VkDynamicState>(state.pDynamicStates, state.pDynamicStates + state.dynamicStateCount);
1182         m_dynamicState                                  = state;
1183         m_dynamicState.pDynamicStates   = &m_dynamicStates[0];
1184         pDynamicState                                   = &m_dynamicState;
1185
1186         return *this;
1187 }
1188
1189 SamplerCreateInfo::SamplerCreateInfo (vk::VkFilter                              _magFilter,
1190                                                                          vk::VkFilter                           _minFilter,
1191                                                                          vk::VkSamplerMipmapMode        _mipmapMode,
1192                                                                          vk::VkSamplerAddressMode       _addressModeU,
1193                                                                          vk::VkSamplerAddressMode       _addressModeV,
1194                                                                          vk::VkSamplerAddressMode       _addressModeW,
1195                                                                          float                                          _mipLodBias,
1196                                                                          float                                          _maxAnisotropy,
1197                                                                          vk::VkBool32                           _compareEnable,
1198                                                                          vk::VkCompareOp                        _compareOp,
1199                                                                          float                                          _minLod,
1200                                                                          float                                          _maxLod,
1201                                                                          vk::VkBorderColor                      _borderColor,
1202                                                                          vk::VkBool32                           _unnormalizedCoordinates)
1203 {
1204         sType                                   = vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
1205         pNext                                   = DE_NULL;
1206         flags                                   = 0u;
1207         magFilter                               = _magFilter;
1208         minFilter                               = _minFilter;
1209         mipmapMode                              = _mipmapMode;
1210         addressModeU                    = _addressModeU;
1211         addressModeV                    = _addressModeV;
1212         addressModeW                    = _addressModeW;
1213         mipLodBias                              = _mipLodBias;
1214         maxAnisotropy                   = _maxAnisotropy;
1215         compareEnable                   = _compareEnable;
1216         compareOp                               = _compareOp;
1217         minLod                                  = _minLod;
1218         maxLod                                  = _maxLod;
1219         borderColor                             = _borderColor;
1220         unnormalizedCoordinates = _unnormalizedCoordinates;
1221 }
1222
1223 } // Draw
1224 } // vkt