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

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