external/vulkancts/modules/vulkan/draw/vktDrawCreateInfoUtil.hpp

   1 #ifndef _VKTDRAWCREATEINFO_UTIL_HPP
   2 #define _VKTDRAWCREATEINFO_UTIL_HPP
   3 /*------------------------------------------------------------------------
   4  * Vulkan Conformance Tests
   5  * ------------------------
   6  *
   7  * Copyright (c) 2015 The Khronos Group Inc.
   8  * Copyright (c) 2015 Intel Corporation
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a
  11  * copy of this software and/or associated documentation files (the
  12  * "Materials"), to deal in the Materials without restriction, including
  13  * without limitation the rights to use, copy, modify, merge, publish,
  14  * distribute, sublicense, and/or sell copies of the Materials, and to
  15  * permit persons to whom the Materials are furnished to do so, subject to
  16  * the following conditions:
  17  *
  18  * The above copyright notice(s) and this permission notice shall be included
  19  * in all copies or substantial portions of the Materials.
  20  *
  21  * The Materials are Confidential Information as defined by the
  22  * Khronos Membership Agreement until designated non-confidential by Khronos,
  23  * at which point this condition clause shall be removed.
  24  *
  25  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  28  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  29  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  30  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  31  * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
  32  *
  33  *//*!
  34  * \file
  35  * \brief CreateInfo utilities
  36  *//*--------------------------------------------------------------------*/
  37
  38 #include "vkDefs.hpp"
  39 #include "tcuVector.hpp"
  40
  41 #include "deSharedPtr.hpp"
  42
  43 #include <vector>
  44
  45 namespace vkt
  46 {
  47 namespace Draw
  48 {
  49
  50 class ImageSubresourceRange : public vk::VkImageSubresourceRange
  51 {
  52 public:
  53         ImageSubresourceRange ( vk::VkImageAspectFlags  aspectMask,
  54                                                         deUint32                                baseMipLevel    = 0,
  55                                                         deUint32                                levelCount              = 1,
  56                                                         deUint32                                baseArrayLayer  = 0,
  57                                                         deUint32                                layerCount              = 1);
  58 };
  59
  60 class ComponentMapping : public vk::VkComponentMapping
  61 {
  62 public:
  63         ComponentMapping (      vk::VkComponentSwizzle r = vk::VK_COMPONENT_SWIZZLE_R,
  64                                                 vk::VkComponentSwizzle g = vk::VK_COMPONENT_SWIZZLE_G,
  65                                                 vk::VkComponentSwizzle b = vk::VK_COMPONENT_SWIZZLE_B,
  66                                                 vk::VkComponentSwizzle a = vk::VK_COMPONENT_SWIZZLE_A);
  67 };
  68
  69 class ImageViewCreateInfo : public vk::VkImageViewCreateInfo
  70 {
  71 public:
  72         ImageViewCreateInfo (           vk::VkImage                                             image,
  73                                                                 vk::VkImageViewType                             viewType,
  74                                                                 vk::VkFormat                                    format,
  75                                                 const   vk::VkImageSubresourceRange&    subresourceRange,
  76                                                 const   vk::VkComponentMapping&                 components                      = ComponentMapping(),
  77                                                                 vk::VkImageViewCreateFlags              flags                           = 0);
  78
  79         ImageViewCreateInfo (           vk::VkImage                                             image,
  80                                                                 vk::VkImageViewType                             viewType,
  81                                                                 vk::VkFormat                                    format,
  82                                                 const   vk::VkComponentMapping&                 components                      = ComponentMapping(),
  83                                                                 vk::VkImageViewCreateFlags              flags                           = 0);
  84 };
  85
  86 class BufferViewCreateInfo : public vk::VkBufferViewCreateInfo
  87 {
  88 public:
  89         BufferViewCreateInfo (  vk::VkBuffer            buffer,
  90                                                         vk::VkFormat            format,
  91                                                         vk::VkDeviceSize        offset,
  92                                                         vk::VkDeviceSize        range);
  93 };
  94
  95 class BufferCreateInfo : public vk::VkBufferCreateInfo
  96 {
  97 public:
  98         BufferCreateInfo (              vk::VkDeviceSize                        size,
  99                                                         vk::VkBufferCreateFlags         usage,
 100                                                         vk::VkSharingMode                       sharingMode                             = vk::VK_SHARING_MODE_EXCLUSIVE,
 101                                                         deUint32                                        queueFamilyIndexCount   = 0,
 102                                                         const   deUint32*                       pQueueFamilyIndices             = DE_NULL,
 103                                                         vk::VkBufferCreateFlags         flags                                   = 0);
 104
 105         BufferCreateInfo                        (const BufferCreateInfo &other);
 106         BufferCreateInfo &operator=     (const BufferCreateInfo &other);
 107
 108 private:
 109         std::vector<deUint32> m_queueFamilyIndices;
 110 };
 111
 112
 113 class ImageCreateInfo : public vk::VkImageCreateInfo
 114 {
 115 public:
 116         ImageCreateInfo (               vk::VkImageType                         imageType,
 117                                                         vk::VkFormat                            format,
 118                                                         vk::VkExtent3D                          extent,
 119                                                         deUint32                                        mipLevels,
 120                                                         deUint32                                        arrayLayers,
 121                                                         vk::VkSampleCountFlagBits       samples,
 122                                                         vk::VkImageTiling                       tiling,
 123                                                         vk::VkImageUsageFlags           usage,
 124                                                         vk::VkSharingMode                       sharingMode                             = vk::VK_SHARING_MODE_EXCLUSIVE,
 125                                                         deUint32                                        queueFamilyIndexCount   = 0,
 126                                         const   deUint32*                                       pQueueFamilyIndices             = DE_NULL,
 127                                                         vk::VkImageCreateFlags          flags                                   = 0,
 128                                                         vk::VkImageLayout                       initialLayout                   = vk::VK_IMAGE_LAYOUT_UNDEFINED);
 129
 130 private:
 131         ImageCreateInfo                         (const ImageCreateInfo &other);
 132         ImageCreateInfo &operator=      (const ImageCreateInfo &other);
 133
 134         std::vector<deUint32> m_queueFamilyIndices;
 135 };
 136
 137 class FramebufferCreateInfo : public vk::VkFramebufferCreateInfo
 138 {
 139 public:
 140         FramebufferCreateInfo (                 vk::VkRenderPass                                renderPass,
 141                                                         const   std::vector<vk::VkImageView>&   attachments,
 142                                                                         deUint32                                                width,
 143                                                                         deUint32                                                height,
 144                                                                         deUint32                                                layers);
 145 };
 146
 147 class AttachmentDescription : public vk::VkAttachmentDescription
 148 {
 149 public:
 150         AttachmentDescription ( vk::VkFormat                            format,
 151                                                         vk::VkSampleCountFlagBits       samples,
 152                                                         vk::VkAttachmentLoadOp          loadOp,
 153                                                         vk::VkAttachmentStoreOp         storeOp,
 154                                                         vk::VkAttachmentLoadOp          stencilLoadOp,
 155                                                         vk::VkAttachmentStoreOp         stencilStoreOp,
 156                                                         vk::VkImageLayout                       initialLayout,
 157                                                         vk::VkImageLayout                       finalLayout);
 158
 159         AttachmentDescription (const vk::VkAttachmentDescription &);
 160 };
 161
 162 class AttachmentReference : public vk::VkAttachmentReference
 163 {
 164 public:
 165         AttachmentReference (deUint32 attachment, vk::VkImageLayout layout);
 166         AttachmentReference (void);
 167 };
 168
 169 class SubpassDescription : public vk::VkSubpassDescription
 170 {
 171 public:
 172         SubpassDescription (            vk::VkPipelineBindPoint                 pipelineBindPoint,
 173                                                                 vk::VkSubpassDescriptionFlags   flags,
 174                                                                 deUint32                                                inputAttachmentCount,
 175                                                 const   vk::VkAttachmentReference*              inputAttachments,
 176                                                                 deUint32                                                colorAttachmentCount,
 177                                                 const   vk::VkAttachmentReference*              colorAttachments,
 178                                                 const   vk::VkAttachmentReference*              resolveAttachments,
 179                                                                 vk::VkAttachmentReference               depthStencilAttachment,
 180                                                                 deUint32                                                preserveAttachmentCount,
 181                                                 const   vk::VkAttachmentReference*              preserveAttachments);
 182
 183         SubpassDescription                              (const vk::VkSubpassDescription& other);
 184         SubpassDescription                              (const SubpassDescription& other);
 185         SubpassDescription& operator=   (const SubpassDescription& other);
 186
 187 private:
 188         std::vector<vk::VkAttachmentReference>   m_inputAttachments;
 189         std::vector<vk::VkAttachmentReference>   m_colorAttachments;
 190         std::vector<vk::VkAttachmentReference>   m_resolveAttachments;
 191         std::vector<vk::VkAttachmentReference>   m_preserveAttachments;
 192
 193         vk::VkAttachmentReference                               m_depthStencilAttachment;
 194 };
 195
 196 class SubpassDependency : public vk::VkSubpassDependency
 197 {
 198 public:
 199         SubpassDependency (     deUint32                                        srcSubpass,
 200                                                 deUint32                                        dstSubpass,
 201                                                 vk::VkPipelineStageFlags        srcStageMask,
 202                                                 vk::VkPipelineStageFlags        dstStageMask,
 203                                                 vk::VkAccessFlags                       srcAccessMask,
 204                                                 vk::VkAccessFlags                       dstAccessMask,
 205                                                 vk::VkDependencyFlags           dependencyFlags);
 206
 207         SubpassDependency (const vk::VkSubpassDependency& other);
 208 };
 209
 210 class RenderPassCreateInfo : public vk::VkRenderPassCreateInfo
 211 {
 212 public:
 213         RenderPassCreateInfo (  const std::vector<vk::VkAttachmentDescription>& attachments,
 214                                                         const std::vector<vk::VkSubpassDescription>&    subpasses,
 215                                                         const std::vector<vk::VkSubpassDependency>&             dependiences            = std::vector<vk::VkSubpassDependency>());
 216
 217         RenderPassCreateInfo (                  deUint32 attachmentCount                                                = 0,
 218                                                         const   vk::VkAttachmentDescription*    pAttachments    = DE_NULL,
 219                                                                         deUint32                                                subpassCount    = 0,
 220                                                         const   vk::VkSubpassDescription*               pSubpasses              = DE_NULL,
 221                                                                         deUint32                                                dependencyCount = 0,
 222                                                         const   vk::VkSubpassDependency*                pDependiences   = DE_NULL);
 223
 224         void addAttachment      (vk::VkAttachmentDescription attachment);
 225         void addSubpass         (vk::VkSubpassDescription subpass);
 226         void addDependency      (vk::VkSubpassDependency dependency);
 227
 228 private:
 229         std::vector<AttachmentDescription>                      m_attachments;
 230         std::vector<SubpassDescription>                         m_subpasses;
 231         std::vector<SubpassDependency>                          m_dependiences;
 232
 233         std::vector<vk::VkAttachmentDescription>        m_attachmentsStructs;
 234         std::vector<vk::VkSubpassDescription>           m_subpassesStructs;
 235         std::vector<vk::VkSubpassDependency>            m_dependiencesStructs;
 236
 237         RenderPassCreateInfo                    (const RenderPassCreateInfo &other); //Not allowed!
 238         RenderPassCreateInfo &operator= (const RenderPassCreateInfo &other); //Not allowed!
 239 };
 240
 241 class RenderPassBeginInfo : public vk::VkRenderPassBeginInfo
 242 {
 243 public:
 244         RenderPassBeginInfo (                   vk::VkRenderPass                                renderPass,
 245                                                                         vk::VkFramebuffer                               framebuffer,
 246                                                                         vk::VkRect2D                                    renderArea,
 247                                                         const   std::vector<vk::VkClearValue>&  clearValues = std::vector<vk::VkClearValue>());
 248
 249 private:
 250         std::vector<vk::VkClearValue> m_clearValues;
 251
 252         RenderPassBeginInfo                             (const RenderPassBeginInfo &other); //Not allowed!
 253         RenderPassBeginInfo &operator=  (const RenderPassBeginInfo &other); //Not allowed!
 254 };
 255
 256 class CmdPoolCreateInfo : public vk::VkCommandPoolCreateInfo
 257 {
 258 public:
 259         CmdPoolCreateInfo (deUint32 queueFamilyIndex,
 260                 vk::VkCommandPoolCreateFlags flags = vk::VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
 261 };
 262
 263 class CmdBufferBeginInfo : public vk::VkCommandBufferBeginInfo
 264 {
 265 public:
 266         CmdBufferBeginInfo (vk::VkCommandBufferUsageFlags               flags   = 0);
 267         CmdBufferBeginInfo (vk::VkRenderPass                                    renderPass,
 268                                                 deUint32                                                        subpass,
 269                                                 vk::VkFramebuffer                                       framebuffer,
 270                                                 vk::VkCommandBufferUsageFlags           flags                                   = 0,
 271                                                 bool                                                            occlusionQueryEnable    = false,
 272                                                 vk::VkQueryControlFlags                         queryFlags                              = 0u,
 273                                                 vk::VkQueryPipelineStatisticFlags       pipelineStatistics              = 0u);
 274 };
 275
 276
 277 class DescriptorPoolSize : public vk::VkDescriptorPoolSize
 278 {
 279 public:
 280         DescriptorPoolSize (vk::VkDescriptorType _type, deUint32 _descriptorCount)
 281         {
 282                 type                    = _type;
 283                 descriptorCount = _descriptorCount;
 284         }
 285 };
 286
 287 class DescriptorPoolCreateInfo : public vk::VkDescriptorPoolCreateInfo
 288 {
 289 public:
 290         DescriptorPoolCreateInfo (      const   std::vector<vk::VkDescriptorPoolSize>&  poolSizeCounts,\r
 291                                                                                 vk::VkDescriptorPoolCreateFlags flags, \r
 292                                                                                 deUint32 maxSets);
 293
 294         DescriptorPoolCreateInfo& addDescriptors (vk::VkDescriptorType type, deUint32 count);
 295
 296 private:
 297         std::vector<vk::VkDescriptorPoolSize> m_poolSizeCounts;
 298 };
 299
 300
 301 class DescriptorSetLayoutCreateInfo : public vk::VkDescriptorSetLayoutCreateInfo
 302 {
 303 public:
 304         DescriptorSetLayoutCreateInfo (deUint32 bindingCount, const vk::VkDescriptorSetLayoutBinding* pBindings);
 305 };
 306
 307
 308 class PipelineLayoutCreateInfo : public vk::VkPipelineLayoutCreateInfo
 309 {
 310 public:
 311         PipelineLayoutCreateInfo (                      deUint32 descriptorSetCount,
 312                                                                 const   vk::VkDescriptorSetLayout*                              pSetLayouts,
 313                                                                                 deUint32                                                                pushConstantRangeCount  = 0,
 314                                                                                 const vk::VkPushConstantRange*                  pPushConstantRanges             = DE_NULL);
 315
 316         PipelineLayoutCreateInfo (      const   std::vector<vk::VkDescriptorSetLayout>& setLayouts                              = std::vector<vk::VkDescriptorSetLayout>(),
 317                                                                                 deUint32                                                                pushConstantRangeCount  = 0,
 318                                                                 const   vk::VkPushConstantRange*                                pPushConstantRanges             = DE_NULL);
 319
 320 private:
 321         std::vector<vk::VkDescriptorSetLayout>  m_setLayouts;
 322         std::vector<vk::VkPushConstantRange>    m_pushConstantRanges;
 323 };
 324
 325 class PipelineCreateInfo : public vk::VkGraphicsPipelineCreateInfo
 326 {
 327 public:
 328         class VertexInputState : public vk::VkPipelineVertexInputStateCreateInfo
 329         {
 330         public:
 331                 VertexInputState (                      deUint32                                                                vertexBindingDescriptionCount   = 0,
 332                                                         const   vk::VkVertexInputBindingDescription*    pVertexBindingDescriptions              = NULL,
 333                                                                         deUint32                                                                vertexAttributeDescriptionCount = 0,
 334                                                         const   vk::VkVertexInputAttributeDescription*  pVertexAttributeDescriptions    = NULL);
 335         };
 336
 337         class InputAssemblerState : public vk::VkPipelineInputAssemblyStateCreateInfo
 338         {
 339         public:
 340                 InputAssemblerState (vk::VkPrimitiveTopology topology, vk::VkBool32 primitiveRestartEnable = false);
 341         };
 342
 343         class TesselationState : public vk::VkPipelineTessellationStateCreateInfo
 344         {
 345         public:
 346                 TesselationState (deUint32 patchControlPoints = 0);
 347         };
 348
 349         class ViewportState : public vk::VkPipelineViewportStateCreateInfo
 350         {
 351         public:
 352                 ViewportState ( deUint32                                        viewportCount,
 353                                                 std::vector<vk::VkViewport> viewports           = std::vector<vk::VkViewport>(0),
 354                                                 std::vector<vk::VkRect2D>       scissors                = std::vector<vk::VkRect2D>(0));
 355
 356                 ViewportState                           (const ViewportState &other);
 357                 ViewportState &operator=                (const ViewportState &other);
 358
 359                 std::vector<vk::VkViewport> m_viewports;
 360                 std::vector<vk::VkRect2D>       m_scissors;
 361         };
 362
 363         class RasterizerState : public vk::VkPipelineRasterizationStateCreateInfo
 364         {
 365         public:
 366                 RasterizerState (       vk::VkBool32            depthClampEnable                = false,
 367                                                         vk::VkBool32            rasterizerDiscardEnable = false,
 368                                                         vk::VkPolygonMode       polygonMode                             = vk::VK_POLYGON_MODE_FILL,
 369                                                         vk::VkCullModeFlags     cullMode                                = vk::VK_CULL_MODE_NONE,
 370                                                         vk::VkFrontFace         frontFace                               = vk::VK_FRONT_FACE_CLOCKWISE,
 371                                                         vk::VkBool32            depthBiasEnable                 = true,\r
 372                                                         float                           depthBiasConstantFactor = 0.0f,
 373                                                         float                           depthBiasClamp                  = 0.0f,
 374                                                         float                           depthBiasSlopeFactor    = 0.0f,
 375                                                         float                           lineWidth                               = 1.0f);
 376         };
 377
 378         class MultiSampleState : public vk::VkPipelineMultisampleStateCreateInfo
 379         {
 380         public:
 381                 MultiSampleState (                      vk::VkSampleCountFlagBits               rasterizationSamples            = vk::VK_SAMPLE_COUNT_1_BIT,
 382                                                                         vk::VkBool32                                    sampleShadingEnable                     = false,
 383                                                                         float                                                   minSampleShading                        = 0.0f,
 384                                                         const   std::vector<vk::VkSampleMask>&  sampleMask                                      = std::vector<vk::VkSampleMask>(1, 0xffffffff),
 385                                                         bool                                                                    alphaToCoverageEnable           = false,
 386                                                         bool                                                                    alphaToOneEnable                        = false);
 387
 388                 MultiSampleState                        (const MultiSampleState &other);
 389                 MultiSampleState &operator= (const MultiSampleState &other);
 390
 391         private:
 392                 std::vector<vk::VkSampleMask> m_sampleMask;
 393         };
 394
 395         class ColorBlendState : public vk::VkPipelineColorBlendStateCreateInfo
 396         {
 397         public:
 398                 class Attachment : public vk::VkPipelineColorBlendAttachmentState
 399                 {
 400                 public:
 401                         Attachment (vk::VkBool32                blendEnable                     = false,
 402                                                 vk::VkBlendFactor       srcColorBlendFactor     = vk::VK_BLEND_FACTOR_SRC_COLOR,
 403                                                 vk::VkBlendFactor       dstColorBlendFactor     = vk::VK_BLEND_FACTOR_DST_COLOR,
 404                                                 vk::VkBlendOp           colorBlendOp            = vk::VK_BLEND_OP_ADD,
 405                                                 vk::VkBlendFactor       srcAlphaBlendFactor     = vk::VK_BLEND_FACTOR_SRC_COLOR,
 406                                                 vk::VkBlendFactor       dstAlphaBlendFactor     = vk::VK_BLEND_FACTOR_DST_COLOR,
 407                                                 vk::VkBlendOp           alphaBlendOp            = vk::VK_BLEND_OP_ADD,
 408                                                 deUint8                         colorWriteMask  = 0xff);
 409                 };
 410
 411                 ColorBlendState (       const   std::vector<vk::VkPipelineColorBlendAttachmentState>&   attachments,
 412                                                                         vk::VkBool32                                                                                    alphaToCoverageEnable   = false,
 413                                                                         vk::VkLogicOp                                                                                   logicOp                                 = vk::VK_LOGIC_OP_COPY);
 414
 415                 ColorBlendState (                       deUint32                                                                                                attachmentCount,
 416                                                         const   vk::VkPipelineColorBlendAttachmentState*                                attachments,
 417                                                                         vk::VkBool32                                                                                    logicOpEnable                   = false,
 418                                                                         vk::VkLogicOp                                                                                   logicOp                                 = vk::VK_LOGIC_OP_COPY);
 419
 420                 ColorBlendState (const vk::VkPipelineColorBlendStateCreateInfo &createInfo);
 421                 ColorBlendState (const ColorBlendState &createInfo, std::vector<float> blendConstants = std::vector<float>(4));
 422
 423         private:
 424                 std::vector<vk::VkPipelineColorBlendAttachmentState> m_attachments;
 425         };
 426
 427         class DepthStencilState : public vk::VkPipelineDepthStencilStateCreateInfo
 428         {
 429         public:
 430                 class StencilOpState : public vk::VkStencilOpState
 431                 {
 432                 public:
 433                         StencilOpState (vk::VkStencilOp failOp          = vk::VK_STENCIL_OP_REPLACE,
 434                                                         vk::VkStencilOp passOp          = vk::VK_STENCIL_OP_REPLACE,
 435                                                         vk::VkStencilOp depthFailOp     = vk::VK_STENCIL_OP_REPLACE,
 436                                                         vk::VkCompareOp compareOp       = vk::VK_COMPARE_OP_ALWAYS,
 437                                                         deUint32                compareMask     = 0xffffffffu,\r
 438                                                         deUint32                writeMask       = 0xffffffffu,\r
 439                                                         deUint32                reference       = 0);
 440                 };
 441
 442                 DepthStencilState (     vk::VkBool32    depthTestEnable                 = false,
 443                                                         vk::VkBool32    depthWriteEnable                = false,
 444                                                         vk::VkCompareOp depthCompareOp                  = vk::VK_COMPARE_OP_ALWAYS,
 445                                                         vk::VkBool32    depthBoundsTestEnable   = false,
 446                                                         vk::VkBool32    stencilTestEnable               = false,
 447                                                         StencilOpState  front                                   = StencilOpState(),
 448                                                         StencilOpState  back                                    = StencilOpState(),
 449                                                         float                   minDepthBounds                  = -1.0f,
 450                                                         float                   maxDepthBounds                  = 1.0f);
 451         };
 452
 453         class PipelineShaderStage : public vk::VkPipelineShaderStageCreateInfo
 454         {
 455         public:
 456                 PipelineShaderStage (vk::VkShaderModule shaderModule, const char* _pName, vk::VkShaderStageFlagBits stage);
 457         };
 458
 459         class DynamicState : public vk::VkPipelineDynamicStateCreateInfo
 460         {
 461         public:
 462                 DynamicState (const std::vector<vk::VkDynamicState>& dynamicStates = std::vector<vk::VkDynamicState>(0));
 463
 464                 DynamicState                    (const DynamicState &other);
 465                 DynamicState &operator= (const DynamicState &other);
 466
 467                 std::vector<vk::VkDynamicState> m_dynamicStates;
 468         };
 469
 470         PipelineCreateInfo(vk::VkPipelineLayout layout, vk::VkRenderPass renderPass, int subpass, vk::VkPipelineCreateFlags flags);
 471
 472         PipelineCreateInfo& addShader (const vk::VkPipelineShaderStageCreateInfo&               shader);
 473
 474         PipelineCreateInfo& addState (const vk::VkPipelineVertexInputStateCreateInfo&   state);
 475         PipelineCreateInfo& addState (const vk::VkPipelineInputAssemblyStateCreateInfo& state);
 476         PipelineCreateInfo& addState (const vk::VkPipelineColorBlendStateCreateInfo&    state);
 477         PipelineCreateInfo& addState (const vk::VkPipelineViewportStateCreateInfo&              state);
 478         PipelineCreateInfo& addState (const vk::VkPipelineDepthStencilStateCreateInfo&  state);
 479         PipelineCreateInfo& addState (const vk::VkPipelineTessellationStateCreateInfo&  state);
 480         PipelineCreateInfo& addState (const vk::VkPipelineRasterizationStateCreateInfo&         state);
 481         PipelineCreateInfo& addState (const vk::VkPipelineMultisampleStateCreateInfo&   state);
 482         PipelineCreateInfo& addState (const vk::VkPipelineDynamicStateCreateInfo&                               state);
 483
 484 private:
 485         std::vector<vk::VkPipelineShaderStageCreateInfo>                m_shaders;
 486
 487         vk::VkPipelineVertexInputStateCreateInfo                                m_vertexInputState;
 488         vk::VkPipelineInputAssemblyStateCreateInfo                              m_inputAssemblyState;
 489         std::vector<vk::VkPipelineColorBlendAttachmentState>    m_colorBlendStateAttachments;
 490         vk::VkPipelineColorBlendStateCreateInfo                                 m_colorBlendState;
 491         vk::VkPipelineViewportStateCreateInfo                                   m_viewportState;
 492         vk::VkPipelineDepthStencilStateCreateInfo                               m_dynamicDepthStencilState;
 493         vk::VkPipelineTessellationStateCreateInfo                               m_tessState;
 494         vk::VkPipelineRasterizationStateCreateInfo                              m_rasterState;
 495         vk::VkPipelineMultisampleStateCreateInfo                                m_multisampleState;
 496         vk::VkPipelineDynamicStateCreateInfo                                    m_dynamicState;
 497
 498         std::vector<vk::VkDynamicState> m_dynamicStates;
 499
 500         std::vector<vk::VkViewport>             m_viewports;
 501         std::vector<vk::VkRect2D>               m_scissors;
 502
 503         std::vector<vk::VkSampleMask>   m_multisampleStateSampleMask;
 504 };
 505
 506 class SamplerCreateInfo : public vk::VkSamplerCreateInfo
 507 {
 508 public:
 509         SamplerCreateInfo (     vk::VkFilter                            magFilter                               = vk::VK_FILTER_NEAREST,
 510                                                 vk::VkFilter                            minFilter                               = vk::VK_FILTER_NEAREST,
 511                                                 vk::VkSamplerMipmapMode         mipmapMode                              = vk::VK_SAMPLER_MIPMAP_MODE_NEAREST,
 512                                                 vk::VkSamplerAddressMode        addressU                                = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
 513                                                 vk::VkSamplerAddressMode        addressV                                = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
 514                                                 vk::VkSamplerAddressMode        addressW                                = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
 515                                                 float                                           mipLodBias                              = 0.0f,
 516                                                 float                                           maxAnisotropy                   = 1.0f,
 517                                                 vk::VkBool32                            compareEnable                   = false,
 518                                                 vk::VkCompareOp                         compareOp                               = vk::VK_COMPARE_OP_ALWAYS,
 519                                                 float                                           minLod                                  = 0.0f,
 520                                                 float                                           maxLod                                  = 16.0f,
 521                                                 vk::VkBorderColor                       borderColor                             = vk::VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
 522                                                 vk::VkBool32                            unnormalizedCoordinates = false);
 523 };
 524
 525 } // Draw
 526 } // vkt
 527
 528 #endif // _VKTDRAWCREATEINFO_UTIL_HPP