| #ifndef _VKTDRAWCREATEINFOUTIL_HPP |
| #define _VKTDRAWCREATEINFOUTIL_HPP |
| /*------------------------------------------------------------------------ |
| * Vulkan Conformance Tests |
| * ------------------------ |
| * |
| * Copyright (c) 2015 The Khronos Group Inc. |
| * Copyright (c) 2015 Intel Corporation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief CreateInfo utilities |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "vkDefs.hpp" |
| #include "tcuVector.hpp" |
| #include "deSharedPtr.hpp" |
| #include <vector> |
| |
| namespace vkt |
| { |
| namespace Draw |
| { |
| |
| class ImageSubresourceRange : public vk::VkImageSubresourceRange |
| { |
| public: |
| ImageSubresourceRange (vk::VkImageAspectFlags aspectMask, |
| deUint32 baseMipLevel = 0, |
| deUint32 levelCount = 1, |
| deUint32 baseArrayLayer = 0, |
| deUint32 layerCount = 1); |
| }; |
| |
| class ComponentMapping : public vk::VkComponentMapping |
| { |
| public: |
| ComponentMapping (vk::VkComponentSwizzle r = vk::VK_COMPONENT_SWIZZLE_R, |
| vk::VkComponentSwizzle g = vk::VK_COMPONENT_SWIZZLE_G, |
| vk::VkComponentSwizzle b = vk::VK_COMPONENT_SWIZZLE_B, |
| vk::VkComponentSwizzle a = vk::VK_COMPONENT_SWIZZLE_A); |
| }; |
| |
| class ImageViewCreateInfo : public vk::VkImageViewCreateInfo |
| { |
| public: |
| ImageViewCreateInfo (vk::VkImage image, |
| vk::VkImageViewType viewType, |
| vk::VkFormat format, |
| const vk::VkImageSubresourceRange& subresourceRange, |
| const vk::VkComponentMapping& components = ComponentMapping(), |
| vk::VkImageViewCreateFlags flags = 0); |
| |
| ImageViewCreateInfo (vk::VkImage image, |
| vk::VkImageViewType viewType, |
| vk::VkFormat format, |
| const vk::VkComponentMapping& components = ComponentMapping(), |
| vk::VkImageViewCreateFlags flags = 0); |
| }; |
| |
| class BufferViewCreateInfo : public vk::VkBufferViewCreateInfo |
| { |
| public: |
| BufferViewCreateInfo (vk::VkBuffer buffer, |
| vk::VkFormat format, |
| vk::VkDeviceSize offset, |
| vk::VkDeviceSize range); |
| }; |
| |
| class BufferCreateInfo : public vk::VkBufferCreateInfo |
| { |
| public: |
| BufferCreateInfo (vk::VkDeviceSize size, |
| vk::VkBufferCreateFlags usage, |
| vk::VkSharingMode sharingMode = vk::VK_SHARING_MODE_EXCLUSIVE, |
| deUint32 queueFamilyIndexCount = 0, |
| const deUint32* pQueueFamilyIndices = DE_NULL, |
| vk::VkBufferCreateFlags flags = 0); |
| |
| BufferCreateInfo (const BufferCreateInfo& other); |
| BufferCreateInfo& operator= (const BufferCreateInfo& other); |
| |
| private: |
| std::vector<deUint32> m_queueFamilyIndices; |
| }; |
| |
| class ImageCreateInfo : public vk::VkImageCreateInfo |
| { |
| public: |
| ImageCreateInfo (vk::VkImageType imageType, |
| vk::VkFormat format, |
| vk::VkExtent3D extent, |
| deUint32 mipLevels, |
| deUint32 arrayLayers, |
| vk::VkSampleCountFlagBits samples, |
| vk::VkImageTiling tiling, |
| vk::VkImageUsageFlags usage, |
| vk::VkSharingMode sharingMode = vk::VK_SHARING_MODE_EXCLUSIVE, |
| deUint32 queueFamilyIndexCount = 0, |
| const deUint32* pQueueFamilyIndices = DE_NULL, |
| vk::VkImageCreateFlags flags = 0, |
| vk::VkImageLayout initialLayout = vk::VK_IMAGE_LAYOUT_UNDEFINED); |
| |
| private: |
| ImageCreateInfo (const ImageCreateInfo& other); |
| ImageCreateInfo& operator= (const ImageCreateInfo& other); |
| |
| std::vector<deUint32> m_queueFamilyIndices; |
| }; |
| |
| class FramebufferCreateInfo : public vk::VkFramebufferCreateInfo |
| { |
| public: |
| FramebufferCreateInfo (vk::VkRenderPass renderPass, |
| const std::vector<vk::VkImageView>& attachments, |
| deUint32 width, |
| deUint32 height, |
| deUint32 layers); |
| }; |
| |
| class AttachmentDescription : public vk::VkAttachmentDescription |
| { |
| public: |
| AttachmentDescription (vk::VkFormat format, |
| vk::VkSampleCountFlagBits samples, |
| vk::VkAttachmentLoadOp loadOp, |
| vk::VkAttachmentStoreOp storeOp, |
| vk::VkAttachmentLoadOp stencilLoadOp, |
| vk::VkAttachmentStoreOp stencilStoreOp, |
| vk::VkImageLayout initialLayout, |
| vk::VkImageLayout finalLayout); |
| |
| AttachmentDescription (const vk::VkAttachmentDescription &); |
| }; |
| |
| class AttachmentReference : public vk::VkAttachmentReference |
| { |
| public: |
| AttachmentReference (deUint32 attachment, vk::VkImageLayout layout); |
| AttachmentReference (void); |
| }; |
| |
| class SubpassDescription : public vk::VkSubpassDescription |
| { |
| public: |
| SubpassDescription (vk::VkPipelineBindPoint pipelineBindPoint, |
| vk::VkSubpassDescriptionFlags flags, |
| deUint32 inputAttachmentCount, |
| const vk::VkAttachmentReference* inputAttachments, |
| deUint32 colorAttachmentCount, |
| const vk::VkAttachmentReference* colorAttachments, |
| const vk::VkAttachmentReference* resolveAttachments, |
| vk::VkAttachmentReference depthStencilAttachment, |
| deUint32 preserveAttachmentCount, |
| const deUint32* preserveAttachments); |
| |
| SubpassDescription (const vk::VkSubpassDescription& other); |
| SubpassDescription (const SubpassDescription& other); |
| SubpassDescription& operator= (const SubpassDescription& other); |
| |
| private: |
| std::vector<vk::VkAttachmentReference> m_inputAttachments; |
| std::vector<vk::VkAttachmentReference> m_colorAttachments; |
| std::vector<vk::VkAttachmentReference> m_resolveAttachments; |
| std::vector<deUint32> m_preserveAttachments; |
| |
| vk::VkAttachmentReference m_depthStencilAttachment; |
| }; |
| |
| class SubpassDependency : public vk::VkSubpassDependency |
| { |
| public: |
| SubpassDependency ( deUint32 srcSubpass, |
| deUint32 dstSubpass, |
| vk::VkPipelineStageFlags srcStageMask, |
| vk::VkPipelineStageFlags dstStageMask, |
| vk::VkAccessFlags srcAccessMask, |
| vk::VkAccessFlags dstAccessMask, |
| vk::VkDependencyFlags dependencyFlags); |
| |
| SubpassDependency (const vk::VkSubpassDependency& other); |
| }; |
| |
| class RenderPassCreateInfo : public vk::VkRenderPassCreateInfo |
| { |
| public: |
| RenderPassCreateInfo (const std::vector<vk::VkAttachmentDescription>& attachments, |
| const std::vector<vk::VkSubpassDescription>& subpasses, |
| const std::vector<vk::VkSubpassDependency>& dependiences = std::vector<vk::VkSubpassDependency>()); |
| |
| RenderPassCreateInfo (deUint32 attachmentCount = 0, |
| const vk::VkAttachmentDescription* pAttachments = DE_NULL, |
| deUint32 subpassCount = 0, |
| const vk::VkSubpassDescription* pSubpasses = DE_NULL, |
| deUint32 dependencyCount = 0, |
| const vk::VkSubpassDependency* pDependiences = DE_NULL); |
| |
| void addAttachment (vk::VkAttachmentDescription attachment); |
| void addSubpass (vk::VkSubpassDescription subpass); |
| void addDependency (vk::VkSubpassDependency dependency); |
| |
| private: |
| std::vector<AttachmentDescription> m_attachments; |
| std::vector<SubpassDescription> m_subpasses; |
| std::vector<SubpassDependency> m_dependiences; |
| |
| std::vector<vk::VkAttachmentDescription> m_attachmentsStructs; |
| std::vector<vk::VkSubpassDescription> m_subpassesStructs; |
| std::vector<vk::VkSubpassDependency> m_dependiencesStructs; |
| |
| RenderPassCreateInfo (const RenderPassCreateInfo &other); //Not allowed! |
| RenderPassCreateInfo& operator= (const RenderPassCreateInfo &other); //Not allowed! |
| }; |
| |
| class RenderPassBeginInfo : public vk::VkRenderPassBeginInfo |
| { |
| public: |
| RenderPassBeginInfo (vk::VkRenderPass renderPass, |
| vk::VkFramebuffer framebuffer, |
| vk::VkRect2D renderArea, |
| const std::vector<vk::VkClearValue>& clearValues = std::vector<vk::VkClearValue>()); |
| |
| private: |
| std::vector<vk::VkClearValue> m_clearValues; |
| |
| RenderPassBeginInfo (const RenderPassBeginInfo& other); //Not allowed! |
| RenderPassBeginInfo& operator= (const RenderPassBeginInfo& other); //Not allowed! |
| }; |
| |
| class CmdPoolCreateInfo : public vk::VkCommandPoolCreateInfo |
| { |
| public: |
| CmdPoolCreateInfo (deUint32 queueFamilyIndex, |
| vk::VkCommandPoolCreateFlags flags = vk::VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT); |
| }; |
| |
| class CmdBufferBeginInfo : public vk::VkCommandBufferBeginInfo |
| { |
| public: |
| CmdBufferBeginInfo (vk::VkCommandBufferUsageFlags flags = 0); |
| }; |
| |
| class DescriptorPoolSize : public vk::VkDescriptorPoolSize |
| { |
| public: |
| DescriptorPoolSize (vk::VkDescriptorType _type, deUint32 _descriptorCount) |
| { |
| type = _type; |
| descriptorCount = _descriptorCount; |
| } |
| }; |
| |
| class DescriptorPoolCreateInfo : public vk::VkDescriptorPoolCreateInfo |
| { |
| public: |
| DescriptorPoolCreateInfo (const std::vector<vk::VkDescriptorPoolSize>& poolSizeCounts, |
| vk::VkDescriptorPoolCreateFlags flags, |
| deUint32 maxSets); |
| |
| DescriptorPoolCreateInfo& addDescriptors (vk::VkDescriptorType type, deUint32 count); |
| |
| private: |
| std::vector<vk::VkDescriptorPoolSize> m_poolSizeCounts; |
| }; |
| |
| class DescriptorSetLayoutCreateInfo : public vk::VkDescriptorSetLayoutCreateInfo |
| { |
| public: |
| DescriptorSetLayoutCreateInfo (deUint32 bindingCount, const vk::VkDescriptorSetLayoutBinding* pBindings); |
| }; |
| |
| class PipelineLayoutCreateInfo : public vk::VkPipelineLayoutCreateInfo |
| { |
| public: |
| PipelineLayoutCreateInfo (deUint32 descriptorSetCount, |
| const vk::VkDescriptorSetLayout* pSetLayouts, |
| deUint32 pushConstantRangeCount = 0, |
| const vk::VkPushConstantRange* pPushConstantRanges = DE_NULL); |
| |
| PipelineLayoutCreateInfo (const std::vector<vk::VkDescriptorSetLayout>& setLayouts = std::vector<vk::VkDescriptorSetLayout>(), |
| deUint32 pushConstantRangeCount = 0, |
| const vk::VkPushConstantRange* pPushConstantRanges = DE_NULL); |
| |
| private: |
| std::vector<vk::VkDescriptorSetLayout> m_setLayouts; |
| std::vector<vk::VkPushConstantRange> m_pushConstantRanges; |
| }; |
| |
| class PipelineCreateInfo : public vk::VkGraphicsPipelineCreateInfo |
| { |
| public: |
| class VertexInputState : public vk::VkPipelineVertexInputStateCreateInfo |
| { |
| public: |
| VertexInputState (deUint32 vertexBindingDescriptionCount = 0, |
| const vk::VkVertexInputBindingDescription* pVertexBindingDescriptions = NULL, |
| deUint32 vertexAttributeDescriptionCount = 0, |
| const vk::VkVertexInputAttributeDescription* pVertexAttributeDescriptions = NULL); |
| |
| VertexInputState& addDivisors (deUint32 vertexBindingDivisorCount = 0, |
| const vk::VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors = NULL); |
| |
| vk::VkPipelineVertexInputDivisorStateCreateInfoEXT m_divisorState; |
| }; |
| |
| class InputAssemblerState : public vk::VkPipelineInputAssemblyStateCreateInfo |
| { |
| public: |
| InputAssemblerState (vk::VkPrimitiveTopology topology, vk::VkBool32 primitiveRestartEnable = false); |
| }; |
| |
| class TessellationState : public vk::VkPipelineTessellationStateCreateInfo |
| { |
| public: |
| TessellationState (deUint32 patchControlPoints = 0); |
| }; |
| |
| class ViewportState : public vk::VkPipelineViewportStateCreateInfo |
| { |
| public: |
| ViewportState (deUint32 viewportCount, |
| std::vector<vk::VkViewport> viewports = std::vector<vk::VkViewport>(0), |
| std::vector<vk::VkRect2D> scissors = std::vector<vk::VkRect2D>(0)); |
| |
| ViewportState (const ViewportState& other); |
| ViewportState& operator= (const ViewportState& other); |
| |
| std::vector<vk::VkViewport> m_viewports; |
| std::vector<vk::VkRect2D> m_scissors; |
| }; |
| |
| class RasterizerState : public vk::VkPipelineRasterizationStateCreateInfo |
| { |
| public: |
| RasterizerState (vk::VkBool32 depthClampEnable = false, |
| vk::VkBool32 rasterizerDiscardEnable = false, |
| vk::VkPolygonMode polygonMode = vk::VK_POLYGON_MODE_FILL, |
| vk::VkCullModeFlags cullMode = vk::VK_CULL_MODE_NONE, |
| vk::VkFrontFace frontFace = vk::VK_FRONT_FACE_CLOCKWISE, |
| vk::VkBool32 depthBiasEnable = true, |
| float depthBiasConstantFactor = 0.0f, |
| float depthBiasClamp = 0.0f, |
| float depthBiasSlopeFactor = 0.0f, |
| float lineWidth = 1.0f); |
| }; |
| |
| class MultiSampleState : public vk::VkPipelineMultisampleStateCreateInfo |
| { |
| public: |
| MultiSampleState (vk::VkSampleCountFlagBits rasterizationSamples = vk::VK_SAMPLE_COUNT_1_BIT, |
| vk::VkBool32 sampleShadingEnable = false, |
| float minSampleShading = 0.0f, |
| const std::vector<vk::VkSampleMask>& sampleMask = std::vector<vk::VkSampleMask>(1, 0xffffffffu), |
| bool alphaToCoverageEnable = false, |
| bool alphaToOneEnable = false); |
| |
| MultiSampleState (const MultiSampleState& other); |
| MultiSampleState& operator= (const MultiSampleState& other); |
| |
| private: |
| std::vector<vk::VkSampleMask> m_sampleMask; |
| }; |
| |
| class ColorBlendState : public vk::VkPipelineColorBlendStateCreateInfo |
| { |
| public: |
| class Attachment : public vk::VkPipelineColorBlendAttachmentState |
| { |
| public: |
| Attachment (vk::VkBool32 blendEnable = false, |
| vk::VkBlendFactor srcColorBlendFactor = vk::VK_BLEND_FACTOR_SRC_COLOR, |
| vk::VkBlendFactor dstColorBlendFactor = vk::VK_BLEND_FACTOR_DST_COLOR, |
| vk::VkBlendOp colorBlendOp = vk::VK_BLEND_OP_ADD, |
| vk::VkBlendFactor srcAlphaBlendFactor = vk::VK_BLEND_FACTOR_SRC_COLOR, |
| vk::VkBlendFactor dstAlphaBlendFactor = vk::VK_BLEND_FACTOR_DST_COLOR, |
| vk::VkBlendOp alphaBlendOp = vk::VK_BLEND_OP_ADD, |
| vk::VkColorComponentFlags colorWriteMask = vk::VK_COLOR_COMPONENT_R_BIT| |
| vk::VK_COLOR_COMPONENT_G_BIT| |
| vk::VK_COLOR_COMPONENT_B_BIT| |
| vk::VK_COLOR_COMPONENT_A_BIT); |
| }; |
| |
| ColorBlendState (const std::vector<vk::VkPipelineColorBlendAttachmentState>& attachments, |
| vk::VkBool32 alphaToCoverageEnable = false, |
| vk::VkLogicOp logicOp = vk::VK_LOGIC_OP_COPY); |
| |
| ColorBlendState (deUint32 attachmentCount, |
| const vk::VkPipelineColorBlendAttachmentState* attachments, |
| vk::VkBool32 logicOpEnable = false, |
| vk::VkLogicOp logicOp = vk::VK_LOGIC_OP_COPY); |
| |
| ColorBlendState (const vk::VkPipelineColorBlendStateCreateInfo& createInfo); |
| ColorBlendState (const ColorBlendState& createInfo, |
| std::vector<float> blendConstants = std::vector<float>(4)); |
| |
| private: |
| std::vector<vk::VkPipelineColorBlendAttachmentState> m_attachments; |
| }; |
| |
| class DepthStencilState : public vk::VkPipelineDepthStencilStateCreateInfo |
| { |
| public: |
| class StencilOpState : public vk::VkStencilOpState |
| { |
| public: |
| StencilOpState (vk::VkStencilOp failOp = vk::VK_STENCIL_OP_REPLACE, |
| vk::VkStencilOp passOp = vk::VK_STENCIL_OP_REPLACE, |
| vk::VkStencilOp depthFailOp = vk::VK_STENCIL_OP_REPLACE, |
| vk::VkCompareOp compareOp = vk::VK_COMPARE_OP_ALWAYS, |
| deUint32 compareMask = 0xffffffffu, |
| deUint32 writeMask = 0xffffffffu, |
| deUint32 reference = 0u); |
| }; |
| |
| DepthStencilState (vk::VkBool32 depthTestEnable = false, |
| vk::VkBool32 depthWriteEnable = false, |
| vk::VkCompareOp depthCompareOp = vk::VK_COMPARE_OP_ALWAYS, |
| vk::VkBool32 depthBoundsTestEnable = false, |
| vk::VkBool32 stencilTestEnable = false, |
| StencilOpState front = StencilOpState(), |
| StencilOpState back = StencilOpState(), |
| float minDepthBounds = 0.0f, |
| float maxDepthBounds = 1.0f); |
| }; |
| |
| class PipelineShaderStage : public vk::VkPipelineShaderStageCreateInfo |
| { |
| public: |
| PipelineShaderStage (vk::VkShaderModule shaderModule, const char* pName, vk::VkShaderStageFlagBits stage); |
| }; |
| |
| class DynamicState : public vk::VkPipelineDynamicStateCreateInfo |
| { |
| public: |
| DynamicState (const std::vector<vk::VkDynamicState>& dynamicStates = std::vector<vk::VkDynamicState>(0)); |
| |
| DynamicState (const DynamicState& other); |
| DynamicState& operator= (const DynamicState& other); |
| |
| std::vector<vk::VkDynamicState> m_dynamicStates; |
| }; |
| |
| PipelineCreateInfo (vk::VkPipelineLayout layout, |
| vk::VkRenderPass renderPass, |
| int subpass, |
| vk::VkPipelineCreateFlags flags); |
| |
| PipelineCreateInfo& addShader (const vk::VkPipelineShaderStageCreateInfo& shader); |
| |
| PipelineCreateInfo& addState (const vk::VkPipelineVertexInputStateCreateInfo& state); |
| PipelineCreateInfo& addState (const vk::VkPipelineInputAssemblyStateCreateInfo& state); |
| PipelineCreateInfo& addState (const vk::VkPipelineColorBlendStateCreateInfo& state); |
| PipelineCreateInfo& addState (const vk::VkPipelineViewportStateCreateInfo& state); |
| PipelineCreateInfo& addState (const vk::VkPipelineDepthStencilStateCreateInfo& state); |
| PipelineCreateInfo& addState (const vk::VkPipelineTessellationStateCreateInfo& state); |
| PipelineCreateInfo& addState (const vk::VkPipelineRasterizationStateCreateInfo& state); |
| PipelineCreateInfo& addState (const vk::VkPipelineMultisampleStateCreateInfo& state); |
| PipelineCreateInfo& addState (const vk::VkPipelineDynamicStateCreateInfo& state); |
| |
| private: |
| std::vector<vk::VkPipelineShaderStageCreateInfo> m_shaders; |
| |
| vk::VkPipelineVertexInputStateCreateInfo m_vertexInputState; |
| vk::VkPipelineInputAssemblyStateCreateInfo m_inputAssemblyState; |
| std::vector<vk::VkPipelineColorBlendAttachmentState> m_colorBlendStateAttachments; |
| vk::VkPipelineColorBlendStateCreateInfo m_colorBlendState; |
| vk::VkPipelineViewportStateCreateInfo m_viewportState; |
| vk::VkPipelineDepthStencilStateCreateInfo m_dynamicDepthStencilState; |
| vk::VkPipelineTessellationStateCreateInfo m_tessState; |
| vk::VkPipelineRasterizationStateCreateInfo m_rasterState; |
| vk::VkPipelineMultisampleStateCreateInfo m_multisampleState; |
| vk::VkPipelineDynamicStateCreateInfo m_dynamicState; |
| |
| std::vector<vk::VkDynamicState> m_dynamicStates; |
| std::vector<vk::VkViewport> m_viewports; |
| std::vector<vk::VkRect2D> m_scissors; |
| std::vector<vk::VkSampleMask> m_multisampleStateSampleMask; |
| }; |
| |
| class SamplerCreateInfo : public vk::VkSamplerCreateInfo |
| { |
| public: |
| SamplerCreateInfo (vk::VkFilter magFilter = vk::VK_FILTER_NEAREST, |
| vk::VkFilter minFilter = vk::VK_FILTER_NEAREST, |
| vk::VkSamplerMipmapMode mipmapMode = vk::VK_SAMPLER_MIPMAP_MODE_NEAREST, |
| vk::VkSamplerAddressMode addressU = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, |
| vk::VkSamplerAddressMode addressV = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, |
| vk::VkSamplerAddressMode addressW = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, |
| float mipLodBias = 0.0f, |
| vk::VkBool32 anisotropyEnable = VK_FALSE, |
| float maxAnisotropy = 1.0f, |
| vk::VkBool32 compareEnable = false, |
| vk::VkCompareOp compareOp = vk::VK_COMPARE_OP_ALWAYS, |
| float minLod = 0.0f, |
| float maxLod = 16.0f, |
| vk::VkBorderColor borderColor = vk::VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE, |
| vk::VkBool32 unnormalizedCoordinates = false); |
| }; |
| |
| } // Draw |
| } // vkt |
| |
| #endif // _VKTDRAWCREATEINFOUTIL_HPP |