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

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