external/vulkancts/modules/vulkan/dynamic-state/vktDynamicStateCreateInfoUtil.cpp

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