Safe Haskell	None
Language	Haskell2010

Graphics.Vulkan.Core10.Pipeline

Synopsis

newtype VkBlendFactor = VkBlendFactor Int32
pattern VK_BLEND_FACTOR_ZERO :: VkBlendFactor
pattern VK_BLEND_FACTOR_ONE :: VkBlendFactor
pattern VK_BLEND_FACTOR_SRC_COLOR :: VkBlendFactor
pattern VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR :: VkBlendFactor
pattern VK_BLEND_FACTOR_DST_COLOR :: VkBlendFactor
pattern VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR :: VkBlendFactor
pattern VK_BLEND_FACTOR_SRC_ALPHA :: VkBlendFactor
pattern VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA :: VkBlendFactor
pattern VK_BLEND_FACTOR_DST_ALPHA :: VkBlendFactor
pattern VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA :: VkBlendFactor
pattern VK_BLEND_FACTOR_CONSTANT_COLOR :: VkBlendFactor
pattern VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR :: VkBlendFactor
pattern VK_BLEND_FACTOR_CONSTANT_ALPHA :: VkBlendFactor
pattern VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA :: VkBlendFactor
pattern VK_BLEND_FACTOR_SRC_ALPHA_SATURATE :: VkBlendFactor
pattern VK_BLEND_FACTOR_SRC1_COLOR :: VkBlendFactor
pattern VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR :: VkBlendFactor
pattern VK_BLEND_FACTOR_SRC1_ALPHA :: VkBlendFactor
pattern VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA :: VkBlendFactor
newtype VkBlendOp = VkBlendOp Int32
pattern VK_BLEND_OP_ADD :: VkBlendOp
pattern VK_BLEND_OP_SUBTRACT :: VkBlendOp
pattern VK_BLEND_OP_REVERSE_SUBTRACT :: VkBlendOp
pattern VK_BLEND_OP_MIN :: VkBlendOp
pattern VK_BLEND_OP_MAX :: VkBlendOp
newtype VkCompareOp = VkCompareOp Int32
pattern VK_COMPARE_OP_NEVER :: VkCompareOp
pattern VK_COMPARE_OP_LESS :: VkCompareOp
pattern VK_COMPARE_OP_EQUAL :: VkCompareOp
pattern VK_COMPARE_OP_LESS_OR_EQUAL :: VkCompareOp
pattern VK_COMPARE_OP_GREATER :: VkCompareOp
pattern VK_COMPARE_OP_NOT_EQUAL :: VkCompareOp
pattern VK_COMPARE_OP_GREATER_OR_EQUAL :: VkCompareOp
pattern VK_COMPARE_OP_ALWAYS :: VkCompareOp
newtype VkDynamicState = VkDynamicState Int32
pattern VK_DYNAMIC_STATE_VIEWPORT :: VkDynamicState
pattern VK_DYNAMIC_STATE_SCISSOR :: VkDynamicState
pattern VK_DYNAMIC_STATE_LINE_WIDTH :: VkDynamicState
pattern VK_DYNAMIC_STATE_DEPTH_BIAS :: VkDynamicState
pattern VK_DYNAMIC_STATE_BLEND_CONSTANTS :: VkDynamicState
pattern VK_DYNAMIC_STATE_DEPTH_BOUNDS :: VkDynamicState
pattern VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK :: VkDynamicState
pattern VK_DYNAMIC_STATE_STENCIL_WRITE_MASK :: VkDynamicState
pattern VK_DYNAMIC_STATE_STENCIL_REFERENCE :: VkDynamicState
newtype VkPolygonMode = VkPolygonMode Int32
pattern VK_POLYGON_MODE_FILL :: VkPolygonMode
pattern VK_POLYGON_MODE_LINE :: VkPolygonMode
pattern VK_POLYGON_MODE_POINT :: VkPolygonMode
newtype VkFrontFace = VkFrontFace Int32
pattern VK_FRONT_FACE_COUNTER_CLOCKWISE :: VkFrontFace
pattern VK_FRONT_FACE_CLOCKWISE :: VkFrontFace
newtype VkLogicOp = VkLogicOp Int32
pattern VK_LOGIC_OP_CLEAR :: VkLogicOp
pattern VK_LOGIC_OP_AND :: VkLogicOp
pattern VK_LOGIC_OP_AND_REVERSE :: VkLogicOp
pattern VK_LOGIC_OP_COPY :: VkLogicOp
pattern VK_LOGIC_OP_AND_INVERTED :: VkLogicOp
pattern VK_LOGIC_OP_NO_OP :: VkLogicOp
pattern VK_LOGIC_OP_XOR :: VkLogicOp
pattern VK_LOGIC_OP_OR :: VkLogicOp
pattern VK_LOGIC_OP_NOR :: VkLogicOp
pattern VK_LOGIC_OP_EQUIVALENT :: VkLogicOp
pattern VK_LOGIC_OP_INVERT :: VkLogicOp
pattern VK_LOGIC_OP_OR_REVERSE :: VkLogicOp
pattern VK_LOGIC_OP_COPY_INVERTED :: VkLogicOp
pattern VK_LOGIC_OP_OR_INVERTED :: VkLogicOp
pattern VK_LOGIC_OP_NAND :: VkLogicOp
pattern VK_LOGIC_OP_SET :: VkLogicOp
newtype VkPrimitiveTopology = VkPrimitiveTopology Int32
pattern VK_PRIMITIVE_TOPOLOGY_POINT_LIST :: VkPrimitiveTopology
pattern VK_PRIMITIVE_TOPOLOGY_LINE_LIST :: VkPrimitiveTopology
pattern VK_PRIMITIVE_TOPOLOGY_LINE_STRIP :: VkPrimitiveTopology
pattern VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST :: VkPrimitiveTopology
pattern VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP :: VkPrimitiveTopology
pattern VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN :: VkPrimitiveTopology
pattern VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY :: VkPrimitiveTopology
pattern VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY :: VkPrimitiveTopology
pattern VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY :: VkPrimitiveTopology
pattern VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY :: VkPrimitiveTopology
pattern VK_PRIMITIVE_TOPOLOGY_PATCH_LIST :: VkPrimitiveTopology
newtype VkStencilOp = VkStencilOp Int32
pattern VK_STENCIL_OP_KEEP :: VkStencilOp
pattern VK_STENCIL_OP_ZERO :: VkStencilOp
pattern VK_STENCIL_OP_REPLACE :: VkStencilOp
pattern VK_STENCIL_OP_INCREMENT_AND_CLAMP :: VkStencilOp
pattern VK_STENCIL_OP_DECREMENT_AND_CLAMP :: VkStencilOp
pattern VK_STENCIL_OP_INVERT :: VkStencilOp
pattern VK_STENCIL_OP_INCREMENT_AND_WRAP :: VkStencilOp
pattern VK_STENCIL_OP_DECREMENT_AND_WRAP :: VkStencilOp
newtype VkVertexInputRate = VkVertexInputRate Int32
pattern VK_VERTEX_INPUT_RATE_VERTEX :: VkVertexInputRate
pattern VK_VERTEX_INPUT_RATE_INSTANCE :: VkVertexInputRate
newtype VkPipelineDepthStencilStateCreateFlags = VkPipelineDepthStencilStateCreateFlags VkFlags
newtype VkPipelineDynamicStateCreateFlags = VkPipelineDynamicStateCreateFlags VkFlags
newtype VkPipelineColorBlendStateCreateFlags = VkPipelineColorBlendStateCreateFlags VkFlags
newtype VkPipelineMultisampleStateCreateFlags = VkPipelineMultisampleStateCreateFlags VkFlags
newtype VkPipelineRasterizationStateCreateFlags = VkPipelineRasterizationStateCreateFlags VkFlags
newtype VkPipelineViewportStateCreateFlags = VkPipelineViewportStateCreateFlags VkFlags
newtype VkPipelineTessellationStateCreateFlags = VkPipelineTessellationStateCreateFlags VkFlags
newtype VkPipelineInputAssemblyStateCreateFlags = VkPipelineInputAssemblyStateCreateFlags VkFlags
newtype VkPipelineVertexInputStateCreateFlags = VkPipelineVertexInputStateCreateFlags VkFlags
newtype VkPipelineShaderStageCreateFlags = VkPipelineShaderStageCreateFlags VkFlags
newtype VkShaderStageFlagBits = VkShaderStageFlagBits VkFlags
pattern VK_SHADER_STAGE_VERTEX_BIT :: VkShaderStageFlagBits
pattern VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT :: VkShaderStageFlagBits
pattern VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT :: VkShaderStageFlagBits
pattern VK_SHADER_STAGE_GEOMETRY_BIT :: VkShaderStageFlagBits
pattern VK_SHADER_STAGE_FRAGMENT_BIT :: VkShaderStageFlagBits
pattern VK_SHADER_STAGE_COMPUTE_BIT :: VkShaderStageFlagBits
pattern VK_SHADER_STAGE_ALL_GRAPHICS :: VkShaderStageFlagBits
pattern VK_SHADER_STAGE_ALL :: VkShaderStageFlagBits
newtype VkPipelineCreateFlagBits = VkPipelineCreateFlagBits VkFlags
pattern VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT :: VkPipelineCreateFlagBits
pattern VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT :: VkPipelineCreateFlagBits
pattern VK_PIPELINE_CREATE_DERIVATIVE_BIT :: VkPipelineCreateFlagBits
newtype VkColorComponentFlagBits = VkColorComponentFlagBits VkFlags
pattern VK_COLOR_COMPONENT_R_BIT :: VkColorComponentFlagBits
pattern VK_COLOR_COMPONENT_G_BIT :: VkColorComponentFlagBits
pattern VK_COLOR_COMPONENT_B_BIT :: VkColorComponentFlagBits
pattern VK_COLOR_COMPONENT_A_BIT :: VkColorComponentFlagBits
newtype VkCullModeFlagBits = VkCullModeFlagBits VkFlags
pattern VK_CULL_MODE_FRONT_BIT :: VkCullModeFlagBits
pattern VK_CULL_MODE_BACK_BIT :: VkCullModeFlagBits
pattern VK_CULL_MODE_NONE :: VkCullModeFlagBits
pattern VK_CULL_MODE_FRONT_AND_BACK :: VkCullModeFlagBits
type VkPipeline = Ptr VkPipeline_T
type VkPipelineLayout = Ptr VkPipelineLayout_T
type VkRenderPass = Ptr VkRenderPass_T
vkCreateGraphicsPipelines :: ("device" ::: VkDevice) -> ("pipelineCache" ::: VkPipelineCache) -> ("createInfoCount" ::: Word32) -> ("pCreateInfos" ::: Ptr VkGraphicsPipelineCreateInfo) -> ("pAllocator" ::: Ptr VkAllocationCallbacks) -> ("pPipelines" ::: Ptr VkPipeline) -> IO VkResult
vkCreateComputePipelines :: ("device" ::: VkDevice) -> ("pipelineCache" ::: VkPipelineCache) -> ("createInfoCount" ::: Word32) -> ("pCreateInfos" ::: Ptr VkComputePipelineCreateInfo) -> ("pAllocator" ::: Ptr VkAllocationCallbacks) -> ("pPipelines" ::: Ptr VkPipeline) -> IO VkResult
vkDestroyPipeline :: ("device" ::: VkDevice) -> ("pipeline" ::: VkPipeline) -> ("pAllocator" ::: Ptr VkAllocationCallbacks) -> IO ()
data VkOffset2D = VkOffset2D {
- vkX :: Int32
- vkY :: Int32
}
data VkExtent2D = VkExtent2D {
- vkWidth :: Word32
- vkHeight :: Word32
}
data VkViewport = VkViewport {
- vkX :: CFloat
- vkY :: CFloat
- vkWidth :: CFloat
- vkHeight :: CFloat
- vkMinDepth :: CFloat
- vkMaxDepth :: CFloat
}
data VkRect2D = VkRect2D {
- vkOffset :: VkOffset2D
- vkExtent :: VkExtent2D
}
data VkSpecializationMapEntry = VkSpecializationMapEntry {
- vkConstantID :: Word32
- vkOffset :: Word32
- vkSize :: CSize
}
data VkSpecializationInfo = VkSpecializationInfo {
- vkMapEntryCount :: Word32
- vkPMapEntries :: Ptr VkSpecializationMapEntry
- vkDataSize :: CSize
- vkPData :: Ptr ()
}
data VkPipelineShaderStageCreateInfo = VkPipelineShaderStageCreateInfo {
- vkSType :: VkStructureType
- vkPNext :: Ptr ()
- vkFlags :: VkPipelineShaderStageCreateFlags
- vkStage :: VkShaderStageFlagBits
- vkModule :: VkShaderModule
- vkPName :: Ptr CChar
- vkPSpecializationInfo :: Ptr VkSpecializationInfo
}
data VkComputePipelineCreateInfo = VkComputePipelineCreateInfo {
- vkSType :: VkStructureType
- vkPNext :: Ptr ()
- vkFlags :: VkPipelineCreateFlags
- vkStage :: VkPipelineShaderStageCreateInfo
- vkLayout :: VkPipelineLayout
- vkBasePipelineHandle :: VkPipeline
- vkBasePipelineIndex :: Int32
}
data VkVertexInputBindingDescription = VkVertexInputBindingDescription {
- vkBinding :: Word32
- vkStride :: Word32
- vkInputRate :: VkVertexInputRate
}
data VkVertexInputAttributeDescription = VkVertexInputAttributeDescription {
- vkLocation :: Word32
- vkBinding :: Word32
- vkFormat :: VkFormat
- vkOffset :: Word32
}
data VkPipelineVertexInputStateCreateInfo = VkPipelineVertexInputStateCreateInfo {
- vkSType :: VkStructureType
- vkPNext :: Ptr ()
- vkFlags :: VkPipelineVertexInputStateCreateFlags
- vkVertexBindingDescriptionCount :: Word32
- vkPVertexBindingDescriptions :: Ptr VkVertexInputBindingDescription
- vkVertexAttributeDescriptionCount :: Word32
- vkPVertexAttributeDescriptions :: Ptr VkVertexInputAttributeDescription
}
data VkPipelineInputAssemblyStateCreateInfo = VkPipelineInputAssemblyStateCreateInfo {
- vkSType :: VkStructureType
- vkPNext :: Ptr ()
- vkFlags :: VkPipelineInputAssemblyStateCreateFlags
- vkTopology :: VkPrimitiveTopology
- vkPrimitiveRestartEnable :: VkBool32
}
data VkPipelineTessellationStateCreateInfo = VkPipelineTessellationStateCreateInfo {
- vkSType :: VkStructureType
- vkPNext :: Ptr ()
- vkFlags :: VkPipelineTessellationStateCreateFlags
- vkPatchControlPoints :: Word32
}
data VkPipelineViewportStateCreateInfo = VkPipelineViewportStateCreateInfo {
- vkSType :: VkStructureType
- vkPNext :: Ptr ()
- vkFlags :: VkPipelineViewportStateCreateFlags
- vkViewportCount :: Word32
- vkPViewports :: Ptr VkViewport
- vkScissorCount :: Word32
- vkPScissors :: Ptr VkRect2D
}
data VkPipelineRasterizationStateCreateInfo = VkPipelineRasterizationStateCreateInfo {
- vkSType :: VkStructureType
- vkPNext :: Ptr ()
- vkFlags :: VkPipelineRasterizationStateCreateFlags
- vkDepthClampEnable :: VkBool32
- vkRasterizerDiscardEnable :: VkBool32
- vkPolygonMode :: VkPolygonMode
- vkCullMode :: VkCullModeFlags
- vkFrontFace :: VkFrontFace
- vkDepthBiasEnable :: VkBool32
- vkDepthBiasConstantFactor :: CFloat
- vkDepthBiasClamp :: CFloat
- vkDepthBiasSlopeFactor :: CFloat
- vkLineWidth :: CFloat
}
data VkPipelineMultisampleStateCreateInfo = VkPipelineMultisampleStateCreateInfo {
- vkSType :: VkStructureType
- vkPNext :: Ptr ()
- vkFlags :: VkPipelineMultisampleStateCreateFlags
- vkRasterizationSamples :: VkSampleCountFlagBits
- vkSampleShadingEnable :: VkBool32
- vkMinSampleShading :: CFloat
- vkPSampleMask :: Ptr VkSampleMask
- vkAlphaToCoverageEnable :: VkBool32
- vkAlphaToOneEnable :: VkBool32
}
data VkPipelineColorBlendAttachmentState = VkPipelineColorBlendAttachmentState {
- vkBlendEnable :: VkBool32
- vkSrcColorBlendFactor :: VkBlendFactor
- vkDstColorBlendFactor :: VkBlendFactor
- vkColorBlendOp :: VkBlendOp
- vkSrcAlphaBlendFactor :: VkBlendFactor
- vkDstAlphaBlendFactor :: VkBlendFactor
- vkAlphaBlendOp :: VkBlendOp
- vkColorWriteMask :: VkColorComponentFlags
}
data VkPipelineColorBlendStateCreateInfo = VkPipelineColorBlendStateCreateInfo {
- vkSType :: VkStructureType
- vkPNext :: Ptr ()
- vkFlags :: VkPipelineColorBlendStateCreateFlags
- vkLogicOpEnable :: VkBool32
- vkLogicOp :: VkLogicOp
- vkAttachmentCount :: Word32
- vkPAttachments :: Ptr VkPipelineColorBlendAttachmentState
- vkBlendConstants :: Vector 4 CFloat
}
data VkPipelineDynamicStateCreateInfo = VkPipelineDynamicStateCreateInfo {
- vkSType :: VkStructureType
- vkPNext :: Ptr ()
- vkFlags :: VkPipelineDynamicStateCreateFlags
- vkDynamicStateCount :: Word32
- vkPDynamicStates :: Ptr VkDynamicState
}
data VkStencilOpState = VkStencilOpState {
- vkFailOp :: VkStencilOp
- vkPassOp :: VkStencilOp
- vkDepthFailOp :: VkStencilOp
- vkCompareOp :: VkCompareOp
- vkCompareMask :: Word32
- vkWriteMask :: Word32
- vkReference :: Word32
}
data VkPipelineDepthStencilStateCreateInfo = VkPipelineDepthStencilStateCreateInfo {
- vkSType :: VkStructureType
- vkPNext :: Ptr ()
- vkFlags :: VkPipelineDepthStencilStateCreateFlags
- vkDepthTestEnable :: VkBool32
- vkDepthWriteEnable :: VkBool32
- vkDepthCompareOp :: VkCompareOp
- vkDepthBoundsTestEnable :: VkBool32
- vkStencilTestEnable :: VkBool32
- vkFront :: VkStencilOpState
- vkBack :: VkStencilOpState
- vkMinDepthBounds :: CFloat
- vkMaxDepthBounds :: CFloat
}
data VkGraphicsPipelineCreateInfo = VkGraphicsPipelineCreateInfo {
- vkSType :: VkStructureType
- vkPNext :: Ptr ()
- vkFlags :: VkPipelineCreateFlags
- vkStageCount :: Word32
- vkPStages :: Ptr VkPipelineShaderStageCreateInfo
- vkPVertexInputState :: Ptr VkPipelineVertexInputStateCreateInfo
- vkPInputAssemblyState :: Ptr VkPipelineInputAssemblyStateCreateInfo
- vkPTessellationState :: Ptr VkPipelineTessellationStateCreateInfo
- vkPViewportState :: Ptr VkPipelineViewportStateCreateInfo
- vkPRasterizationState :: Ptr VkPipelineRasterizationStateCreateInfo
- vkPMultisampleState :: Ptr VkPipelineMultisampleStateCreateInfo
- vkPDepthStencilState :: Ptr VkPipelineDepthStencilStateCreateInfo
- vkPColorBlendState :: Ptr VkPipelineColorBlendStateCreateInfo
- vkPDynamicState :: Ptr VkPipelineDynamicStateCreateInfo
- vkLayout :: VkPipelineLayout
- vkRenderPass :: VkRenderPass
- vkSubpass :: Word32
- vkBasePipelineHandle :: VkPipeline
- vkBasePipelineIndex :: Int32
}
type VkPipelineCreateFlags = VkPipelineCreateFlagBits
type VkColorComponentFlags = VkColorComponentFlagBits
type VkCullModeFlags = VkCullModeFlagBits
type VkSampleMask = Word32

Documentation

newtype VkBlendFactor Source #

VkBlendFactor - Framebuffer blending factors

Description

The semantics of each enum value is described in the table below:

VkBlendFactor	RGB Blend Factors (Sr,Sg,Sb) or (Dr,Dg,Db)	Alpha Blend Factor (Sa or Da)
`VK_BLEND_FACTOR_ZERO`	(0,0,0)	0
`VK_BLEND_FACTOR_ONE`	(1,1,1)	1
`VK_BLEND_FACTOR_SRC_COLOR`	(Rs0,Gs0,Bs0)	As0
`VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR`	(1-Rs0,1-Gs0,1-Bs0)	1-As0
`VK_BLEND_FACTOR_DST_COLOR`	(Rd,Gd,Bd)	Ad
`VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR`	(1-Rd,1-Gd,1-Bd)	1-Ad
`VK_BLEND_FACTOR_SRC_ALPHA`	(As0,As0,As0)	As0
`VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA`	(1-As0,1-As0,1-As0)	1-As0
`VK_BLEND_FACTOR_DST_ALPHA`	(Ad,Ad,Ad)	Ad
`VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA`	(1-Ad,1-Ad,1-Ad)	1-Ad
`VK_BLEND_FACTOR_CONSTANT_COLOR`	(Rc,Gc,Bc)	Ac
`VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR`	(1-Rc,1-Gc,1-Bc)	1-Ac
`VK_BLEND_FACTOR_CONSTANT_ALPHA`	(Ac,Ac,Ac)	Ac
`VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA`	(1-Ac,1-Ac,1-Ac)	1-Ac
`VK_BLEND_FACTOR_SRC_ALPHA_SATURATE`	(f,f,f); f = min(As0,1-Ad)	1
`VK_BLEND_FACTOR_SRC1_COLOR`	(Rs1,Gs1,Bs1)	As1
`VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR`	(1-Rs1,1-Gs1,1-Bs1)	1-As1
`VK_BLEND_FACTOR_SRC1_ALPHA`	(As1,As1,As1)	As1
`VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA`	(1-As1,1-As1,1-As1)	1-As1

Blend Factors

In this table, the following conventions are used:

Rs0,Gs0,Bs0 and As0 represent the first source color R, G, B, and A components, respectively, for the fragment output location corresponding to the color attachment being blended.
Rs1,Gs1,Bs1 and As1 represent the second source color R, G, B, and A components, respectively, used in dual source blending modes, for the fragment output location corresponding to the color attachment being blended.
Rd,Gd,Bd and Ad represent the R, G, B, and A components of the destination color. That is, the color currently in the corresponding color attachment for this fragment/sample.
Rc,Gc,Bc and Ac represent the blend constant R, G, B, and A components, respectively.

Description

The semantics of each basic blend operations is described in the table below:

VkBlendOp	RGB Components	Alpha Component

Basic Blend Operations

In this table, the following conventions are used:

Rs0, Gs0, Bs0 and As0 represent the first source color R, G, B, and A components, respectively.
Rd, Gd, Bd and Ad represent the R, G, B, and A components of the destination color. That is, the color currently in the corresponding color attachment for this fragment/sample.
Sr, Sg, Sb and Sa represent the source blend factor R, G, B, and A components, respectively.
Dr, Dg, Db and Da represent the destination blend factor R, G, B, and A components, respectively.

The blending operation produces a new set of values R, G, B and A, which are written to the framebuffer attachment. If blending is not enabled for this attachment, then R, G, B and A are assigned Rs0, Gs0, Bs0 and As0, respectively.

If the color attachment is fixed-point, the components of the source and destination values and blend factors are each clamped to [0,1] or [-1,1] respectively for an unsigned normalized or signed normalized color attachment prior to evaluating the blend operations. If the color attachment is floating-point, no clamping occurs.

Description

VK_POLYGON_MODE_POINT specifies that polygon vertices are drawn as points.

VK_POLYGON_MODE_LINE specifies that polygon edges are drawn as line segments.
VK_POLYGON_MODE_FILL specifies that polygons are rendered using the polygon rasterization rules in this section.
VK_POLYGON_MODE_FILL_RECTANGLE_NV specifies that polygons are rendered using polygon rasterization rules, modified to consider a sample within the primitive if the sample location is inside the axis-aligned bounding box of the triangle after projection. Note that the barycentric weights used in attribute interpolation can extend outside the range [0,1] when these primitives are shaded. Special treatment is given to a sample position on the boundary edge of the bounding box. In such a case, if two rectangles lie on either side of a common edge (with identical endpoints) on which a sample position lies, then exactly one of the triangles must produce a fragment that covers that sample during rasterization.
Polygons rendered in VK_POLYGON_MODE_FILL_RECTANGLE_NV mode may be clipped by the frustum or by user clip planes. If clipping is applied, the triangle is culled rather than clipped.
Area calculation and facingness are determined for VK_POLYGON_MODE_FILL_RECTANGLE_NV mode using the triangle’s vertices.

These modes affect only the final rasterization of polygons: in particular, a polygon’s vertices are shaded and the polygon is clipped and possibly culled before these modes are applied.

Description

VK_FRONT_FACE_COUNTER_CLOCKWISE specifies that a triangle with positive area is considered front-facing.

VK_FRONT_FACE_CLOCKWISE specifies that a triangle with negative area is considered front-facing.

Any triangle which is not front-facing is back-facing, including zero-area triangles.

Description

The logical operations supported by Vulkan are summarized in the following table in which

¬ is bitwise invert,
∧ is bitwise and,
∨ is bitwise or,
⊕ is bitwise exclusive or,
s is the fragment’s Rs0, Gs0, Bs0 or As0 component value for the fragment output corresponding to the color attachment being updated, and
d is the color attachment’s R, G, B or A component value:

Mode	Operation
`VK_LOGIC_OP_CLEAR`	0

| VK_LOGIC_OP_AND | s ∧ d | +-----------------------------------+-----------------------------------+ | VK_LOGIC_OP_AND_REVERSE | s ∧ ¬ d | +-----------------------------------+-----------------------------------+ | VK_LOGIC_OP_COPY | s | +-----------------------------------+-----------------------------------+ | VK_LOGIC_OP_AND_INVERTED | ¬ s ∧ d | +-----------------------------------+-----------------------------------+ | VK_LOGIC_OP_NO_OP | d | +-----------------------------------+-----------------------------------+ | VK_LOGIC_OP_XOR | s ⊕ d | +-----------------------------------+-----------------------------------+ | VK_LOGIC_OP_OR | s ∨ d | +-----------------------------------+-----------------------------------+ | VK_LOGIC_OP_NOR | ¬ (s ∨ d) | +-----------------------------------+-----------------------------------+ | VK_LOGIC_OP_EQUIVALENT | ¬ (s ⊕ d) | +-----------------------------------+-----------------------------------+ | VK_LOGIC_OP_INVERT | ¬ d | +-----------------------------------+-----------------------------------+ | VK_LOGIC_OP_OR_REVERSE | s ∨ ¬ d | +-----------------------------------+-----------------------------------+ | VK_LOGIC_OP_COPY_INVERTED | ¬ s | +-----------------------------------+-----------------------------------+ | VK_LOGIC_OP_OR_INVERTED | ¬ s ∨ d | +-----------------------------------+-----------------------------------+ | VK_LOGIC_OP_NAND | ¬ (s ∧ d) | +-----------------------------------+-----------------------------------+ | VK_LOGIC_OP_SET | all 1s | +-----------------------------------+-----------------------------------+

Logical Operations

The result of the logical operation is then written to the color attachment as controlled by the component write mask, described in Blend Operations.

Description

VK_STENCIL_OP_KEEP keeps the current value.

VK_STENCIL_OP_ZERO sets the value to 0.
VK_STENCIL_OP_REPLACE sets the value to reference.
VK_STENCIL_OP_INCREMENT_AND_CLAMP increments the current value and clamps to the maximum representable unsigned value.
VK_STENCIL_OP_DECREMENT_AND_CLAMP decrements the current value and clamps to 0.
VK_STENCIL_OP_INVERT bitwise-inverts the current value.
VK_STENCIL_OP_INCREMENT_AND_WRAP increments the current value and wraps to 0 when the maximum value would have been exceeded.
VK_STENCIL_OP_DECREMENT_AND_WRAP decrements the current value and wraps to the maximum possible value when the value would go below 0.

For purposes of increment and decrement, the stencil bits are considered as an unsigned integer.

If the stencil test fails, the sample’s coverage bit is cleared in the fragment. If there is no stencil framebuffer attachment, stencil modification cannot occur, and it is as if the stencil tests always pass.

If the stencil test passes, the writeMask member of the VkStencilOpState structures controls how the updated stencil value is written to the stencil framebuffer attachment.

The least significant s bits of writeMask, where s is the number of bits in the stencil framebuffer attachment, specify an integer mask. Where a 1 appears in this mask, the corresponding bit in the stencil value in the depth/stencil attachment is written; where a 0 appears, the bit is not written. The writeMask value uses either the front-facing or back-facing state based on the facingness of the fragment. Fragments generated by front-facing primitives use the front mask and fragments generated by back-facing primitives use the back mask.

Description

VkPipelineDepthStencilStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

Description

VkPipelineDynamicStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

Description

VkPipelineColorBlendStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

Description

VkPipelineMultisampleStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

Description

VkPipelineRasterizationStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

Description

VkPipelineViewportStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

Description

VkPipelineTessellationStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

Description

VkPipelineInputAssemblyStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

Description

VkPipelineVertexInputStateCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

Description

VkPipelineShaderStageCreateFlags is a bitmask type for setting a mask, but is currently reserved for future use.

Description

VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT specifies that the created pipeline will not be optimized. Using this flag may reduce the time taken to create the pipeline.

VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT specifies that the pipeline to be created is allowed to be the parent of a pipeline that will be created in a subsequent call to vkCreateGraphicsPipelines or vkCreateComputePipelines.
VK_PIPELINE_CREATE_DERIVATIVE_BIT specifies that the pipeline to be created will be a child of a previously created parent pipeline.
VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT specifies that any shader input variables decorated as DeviceIndex will be assigned values as if they were decorated as ViewIndex.
VK_PIPELINE_CREATE_DISPATCH_BASE specifies that a compute pipeline can be used with vkCmdDispatchBase with a non-zero base workgroup.

It is valid to set both VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT and VK_PIPELINE_CREATE_DERIVATIVE_BIT. This allows a pipeline to be both a parent and possibly a child in a pipeline hierarchy. See Pipeline Derivatives for more information.

Description

VK_COLOR_COMPONENT_R_BIT specifies that the R value is written to the color attachment for the appropriate sample. Otherwise, the value in memory is unmodified.

VK_COLOR_COMPONENT_G_BIT specifies that the G value is written to the color attachment for the appropriate sample. Otherwise, the value in memory is unmodified.
VK_COLOR_COMPONENT_B_BIT specifies that the B value is written to the color attachment for the appropriate sample. Otherwise, the value in memory is unmodified.
VK_COLOR_COMPONENT_A_BIT specifies that the A value is written to the color attachment for the appropriate sample. Otherwise, the value in memory is unmodified.

The color write mask operation is applied regardless of whether blending is enabled.

Description

VK_CULL_MODE_NONE specifies that no triangles are discarded

VK_CULL_MODE_FRONT_BIT specifies that front-facing triangles are discarded
VK_CULL_MODE_BACK_BIT specifies that back-facing triangles are discarded
VK_CULL_MODE_FRONT_AND_BACK specifies that all triangles are discarded.

Following culling, fragments are produced for any triangles which have not been discarded.

Parameters

device is the logical device that creates the graphics pipelines.

pipelineCache is either VK_NULL_HANDLE, indicating that pipeline caching is disabled; or the handle of a valid pipeline cache object, in which case use of that cache is enabled for the duration of the command.
createInfoCount is the length of the pCreateInfos and pPipelines arrays.
pCreateInfos is an array of VkGraphicsPipelineCreateInfo structures.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pPipelines is a pointer to an array in which the resulting graphics pipeline objects are returned.

Description

The VkGraphicsPipelineCreateInfo structure includes an array of shader create info structures containing all the desired active shader stages, as well as creation info to define all relevant fixed-function stages, and a pipeline layout.

Valid Usage

If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element

If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set

Valid Usage (Implicit)

device must be a valid VkDevice handle

If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle
pCreateInfos must be a valid pointer to an array of createInfoCount valid VkGraphicsPipelineCreateInfo structures
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pPipelines must be a valid pointer to an array of createInfoCount VkPipeline handles
createInfoCount must be greater than 0
If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device

Return Codes

[Success] - VK_SUCCESS

[Failure] - VK_ERROR_OUT_OF_HOST_MEMORY

```
VK_ERROR_OUT_OF_DEVICE_MEMORY
```
```
VK_ERROR_INVALID_SHADER_NV
```

Parameters

device is the logical device that creates the compute pipelines.

pipelineCache is either VK_NULL_HANDLE, indicating that pipeline caching is disabled; or the handle of a valid pipeline cache object, in which case use of that cache is enabled for the duration of the command.
createInfoCount is the length of the pCreateInfos and pPipelines arrays.
pCreateInfos is an array of VkComputePipelineCreateInfo structures.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.
pPipelines is a pointer to an array in which the resulting compute pipeline objects are returned.

Valid Usage

If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the basePipelineIndex member of that same element is not -1, basePipelineIndex must be less than the index into pCreateInfos that corresponds to that element

If the flags member of any element of pCreateInfos contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, the base pipeline must have been created with the VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT flag set

Valid Usage (Implicit)

device must be a valid VkDevice handle

If pipelineCache is not VK_NULL_HANDLE, pipelineCache must be a valid VkPipelineCache handle
pCreateInfos must be a valid pointer to an array of createInfoCount valid VkComputePipelineCreateInfo structures
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
pPipelines must be a valid pointer to an array of createInfoCount VkPipeline handles
createInfoCount must be greater than 0
If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device

Return Codes

[Success] - VK_SUCCESS

[Failure] - VK_ERROR_OUT_OF_HOST_MEMORY

```
VK_ERROR_OUT_OF_DEVICE_MEMORY
```
```
VK_ERROR_INVALID_SHADER_NV
```

Parameters

device is the logical device that destroys the pipeline.

pipeline is the handle of the pipeline to destroy.
pAllocator controls host memory allocation as described in the Memory Allocation chapter.

Valid Usage

All submitted commands that refer to pipeline must have completed execution

If VkAllocationCallbacks were provided when pipeline was created, a compatible set of callbacks must be provided here
If no VkAllocationCallbacks were provided when pipeline was created, pAllocator must be NULL

Valid Usage (Implicit)

device must be a valid VkDevice handle

If pipeline is not VK_NULL_HANDLE, pipeline must be a valid VkPipeline handle
If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
If pipeline is a valid handle, it must have been created, allocated, or retrieved from device

Host Synchronization

Host access to pipeline must be externally synchronized

Description

The framebuffer depth coordinate zf may be represented using either a fixed-point or floating-point representation. However, a floating-point representation must be used if the depth/stencil attachment has a floating-point depth component. If an m-bit fixed-point representation is used, we assume that it represents each value \(\frac{k}{2^m - 1}\), where k ∈ { 0, 1, …, 2m-1 }, as k (e.g. 1.0 is represented in binary as a string of all ones).

The viewport parameters shown in the above equations are found from these values as

ox = x + width / 2
oy = y + height / 2
oz = minDepth
px = width
py = height
pz = maxDepth - minDepth.

The application can specify a negative term for height, which has the effect of negating the y coordinate in clip space before performing the transform. When using a negative height, the application should also adjust the y value to point to the lower left corner of the viewport instead of the upper left corner. Using the negative height allows the application to avoid having to negate the y component of the Position output from the last vertex processing stage in shaders that also target other graphics APIs.

The width and height of the implementation-dependent maximum viewport dimensions must be greater than or equal to the width and height of the largest image which can be created and attached to a framebuffer.

The floating-point viewport bounds are represented with an implementation-dependent precision.

Valid Usage

width must be greater than 0.0

width must be less than or equal to VkPhysicalDeviceLimits::maxViewportDimensions[0]
The absolute value of height must be less than or equal to VkPhysicalDeviceLimits::maxViewportDimensions[1]
x must be greater than or equal to viewportBoundsRange[0]
(x + width) must be less than or equal to viewportBoundsRange[1]
y must be greater than or equal to viewportBoundsRange[0]
y must be less than or equal to viewportBoundsRange[1]
(y + height) must be greater than or equal to viewportBoundsRange[0]
(y + height) must be less than or equal to viewportBoundsRange[1]
Unless {html_spec_relative}#VK_EXT_depth_range_unrestricted extension is enabled minDepth must be between 0.0 and 1.0, inclusive
Unless {html_spec_relative}#VK_EXT_depth_range_unrestricted extension is enabled maxDepth must be between 0.0 and 1.0, inclusive

Description

If a constantID value is not a specialization constant ID used in the shader, that map entry does not affect the behavior of the pipeline.

Valid Usage

For a constantID specialization constant declared in a shader, size must match the byte size of the constantID. If the specialization constant is of type boolean, size must be the byte size of VkBool32

Description

pMapEntries points to a structure of type VkSpecializationMapEntry.

Valid Usage

The offset member of each element of pMapEntries must be less than dataSize

The size member of each element of pMapEntries must be less than or equal to dataSize minus offset
If mapEntryCount is not 0, pMapEntries must be a valid pointer to an array of mapEntryCount valid VkSpecializationMapEntry structures

Valid Usage (Implicit)

If dataSize is not 0, pData must be a valid pointer to an array of dataSize bytes

Description

The parameters basePipelineHandle and basePipelineIndex are described in more detail in Pipeline Derivatives.

stage points to a structure of type VkPipelineShaderStageCreateInfo.

Valid Usage

If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a compute VkPipeline

If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command’s pCreateInfos parameter
If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE
If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1
The stage member of stage must be VK_SHADER_STAGE_COMPUTE_BIT
The shader code for the entry point identified by stage and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter
layout must be consistent with the layout of the compute shader specified in stage
The number of resources in layout accessible to the compute shader stage must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources

Valid Usage (Implicit)

sType must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO

pNext must be NULL
flags must be a valid combination of VkPipelineCreateFlagBits values
stage must be a valid VkPipelineShaderStageCreateInfo structure
layout must be a valid VkPipelineLayout handle
Both of basePipelineHandle, and layout that are valid handles must have been created, allocated, or retrieved from the same VkDevice

Description

Restarting the assembly of primitives discards the most recent index values if those elements formed an incomplete primitive, and restarts the primitive assembly using the subsequent indices, but only assembling the immediately following element through the end of the originally specified elements. The primitive restart index value comparison is performed before adding the vertexOffset value to the index value.

Valid Usage

If topology is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY or VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, primitiveRestartEnable must be VK_FALSE

If the geometry shaders feature is not enabled, topology must not be any of VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY
If the tessellation shaders feature is not enabled, topology must not be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST

Valid Usage (Implicit)

sType must be VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO

pNext must be NULL
flags must be 0
topology must be a valid VkPrimitiveTopology value

Description

The application can also add a VkPipelineRasterizationStateRasterizationOrderAMD structure to the pNext chain of a VkPipelineRasterizationStateCreateInfo structure. This structure enables selecting the rasterization order to use when rendering with the corresponding graphics pipeline as described in Rasterization Order.

Valid Usage

If the depth clamping feature is not enabled, depthClampEnable must be VK_FALSE

If the non-solid fill modes feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL or VK_POLYGON_MODE_FILL_RECTANGLE_NV
If the {html_spec_relative}#VK_NV_fill_rectangle extension is not enabled, polygonMode must not be VK_POLYGON_MODE_FILL_RECTANGLE_NV

Valid Usage (Implicit)

sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO

Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineRasterizationConservativeStateCreateInfoEXT or VkPipelineRasterizationStateRasterizationOrderAMD
Each sType member in the pNext chain must be unique
flags must be 0
polygonMode must be a valid VkPolygonMode value
cullMode must be a valid combination of VkCullModeFlagBits values
frontFace must be a valid VkFrontFace value

Description

Each element of the pAttachments array is a VkPipelineColorBlendAttachmentState structure specifying per-target blending state for each individual color attachment. If the independent blending feature is not enabled on the device, all VkPipelineColorBlendAttachmentState elements in the pAttachments array must be identical.

Valid Usage

If the independent blending feature is not enabled, all elements of pAttachments must be identical

If the logic operations feature is not enabled, logicOpEnable must be VK_FALSE
If logicOpEnable is VK_TRUE, logicOp must be a valid VkLogicOp value

Valid Usage (Implicit)

sType must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO

pNext must be NULL or a pointer to a valid instance of VkPipelineColorBlendAdvancedStateCreateInfoEXT
flags must be 0
If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkPipelineColorBlendAttachmentState structures

Description

The parameters basePipelineHandle and basePipelineIndex are described in more detail in Pipeline Derivatives.

pStages points to an array of VkPipelineShaderStageCreateInfo structures, which were previously described in Compute Pipelines.

pDynamicState points to a structure of type VkPipelineDynamicStateCreateInfo.

If any shader stage fails to compile, the compile log will be reported back to the application, and VK_ERROR_INVALID_SHADER_NV will be generated.

Valid Usage

If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is -1, basePipelineHandle must be a valid handle to a graphics VkPipeline

If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is VK_NULL_HANDLE, basePipelineIndex must be a valid index into the calling command’s pCreateInfos parameter
If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineIndex is not -1, basePipelineHandle must be VK_NULL_HANDLE
If flags contains the VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and basePipelineHandle is not VK_NULL_HANDLE, basePipelineIndex must be -1
The stage member of each element of pStages must be unique
The stage member of one element of pStages must be VK_SHADER_STAGE_VERTEX_BIT
The stage member of each element of pStages must not be VK_SHADER_STAGE_COMPUTE_BIT
If pStages includes a tessellation control shader stage, it must include a tessellation evaluation shader stage
If pStages includes a tessellation evaluation shader stage, it must include a tessellation control shader stage
If pStages includes a tessellation control shader stage and a tessellation evaluation shader stage, pTessellationState must be a valid pointer to a valid VkPipelineTessellationStateCreateInfo structure
If pStages includes tessellation shader stages, the shader code of at least one stage must contain an OpExecutionMode instruction that specifies the type of subdivision in the pipeline
If pStages includes tessellation shader stages, and the shader code of both stages contain an OpExecutionMode instruction that specifies the type of subdivision in the pipeline, they must both specify the same subdivision mode
If pStages includes tessellation shader stages, the shader code of at least one stage must contain an OpExecutionMode instruction that specifies the output patch size in the pipeline
If pStages includes tessellation shader stages, and the shader code of both contain an OpExecutionMode instruction that specifies the out patch size in the pipeline, they must both specify the same patch size
If pStages includes tessellation shader stages, the topology member of pInputAssembly must be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST
If the topology member of pInputAssembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, pStages must include tessellation shader stages
If pStages includes a geometry shader stage, and does not include any tessellation shader stages, its shader code must contain an OpExecutionMode instruction that specifies an input primitive type that is compatible with the primitive topology specified in pInputAssembly
If pStages includes a geometry shader stage, and also includes tessellation shader stages, its shader code must contain an OpExecutionMode instruction that specifies an input primitive type that is compatible with the primitive topology that is output by the tessellation stages
If pStages includes a fragment shader stage and a geometry shader stage, and the fragment shader code reads from an input variable that is decorated with PrimitiveID, then the geometry shader code must write to a matching output variable, decorated with PrimitiveID, in all execution paths
If pStages includes a fragment shader stage, its shader code must not read from any input attachment that is defined as VK_ATTACHMENT_UNUSED in subpass
The shader code for the entry points identified by pStages, and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter
If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL in the VkAttachmentReference defined by subpass, the depthWriteEnable member of pDepthStencilState must be VK_FALSE
If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL in the VkAttachmentReference defined by subpass, the failOp, passOp and depthFailOp members of each of the front and back members of pDepthStencilState must be VK_STENCIL_OP_KEEP
If rasterization is not disabled and the subpass uses color attachments, then for each color attachment in the subpass the blendEnable member of the corresponding element of the pAttachment member of pColorBlendState must be VK_FALSE if the format of the attachment does not support color blend operations, as specified by the VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT flag in VkFormatProperties::linearTilingFeatures or VkFormatProperties::optimalTilingFeatures returned by vkGetPhysicalDeviceFormatProperties
If rasterization is not disabled and the subpass uses color attachments, the attachmentCount member of pColorBlendState must be equal to the colorAttachmentCount used to create subpass
If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT, the pViewports member of pViewportState must be a valid pointer to an array of pViewportState::viewportCount VkViewport structures
If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SCISSOR, the pScissors member of pViewportState must be a valid pointer to an array of pViewportState::scissorCount VkRect2D structures
If the wide lines feature is not enabled, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_LINE_WIDTH, the lineWidth member of pRasterizationState must be 1.0
If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, pViewportState must be a valid pointer to a valid VkPipelineViewportStateCreateInfo structure
If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, pMultisampleState must be a valid pointer to a valid VkPipelineMultisampleStateCreateInfo structure
If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, and subpass uses a depth/stencil attachment, pDepthStencilState must be a valid pointer to a valid VkPipelineDepthStencilStateCreateInfo structure
If the rasterizerDiscardEnable member of pRasterizationState is VK_FALSE, and subpass uses color attachments, pColorBlendState must be a valid pointer to a valid VkPipelineColorBlendStateCreateInfo structure
If the depth bias clamping feature is not enabled, no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BIAS, and the depthBiasEnable member of pRasterizationState is VK_TRUE, the depthBiasClamp member of pRasterizationState must be 0.0
If the {html_spec_relative}#VK_EXT_depth_range_unrestricted extension is not enabled and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BOUNDS, and the depthBoundsTestEnable member of pDepthStencilState is VK_TRUE, the minDepthBounds and maxDepthBounds members of pDepthStencilState must be between 0.0 and 1.0, inclusive
If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationGridSize.width must evenly divide VkMultisamplePropertiesEXT::sampleLocationGridSize.width as returned by vkGetPhysicalDeviceMultisamplePropertiesEXT with a samples parameter equaling rasterizationSamples
If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationGridSize.height must evenly divide VkMultisamplePropertiesEXT::sampleLocationGridSize.height as returned by vkGetPhysicalDeviceMultisamplePropertiesEXT with a samples parameter equaling rasterizationSamples
If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples
If the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, the fragment shader code must not statically use the extended instruction InterpolateAtSample
layout must be consistent with all shaders specified in pStages
If subpass uses color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must equal the maximum of the sample counts of those subpass attachments
If subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled, then the rasterizationSamples member of pMultisampleState must be the same as the sample count of the depth/stencil attachment
If subpass has any color attachments, then the rasterizationSamples member of pMultisampleState must be greater than or equal to the sample count for those subpass attachments
If subpass does not use any color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must follow the rules for a zero-attachment subpass
subpass must be a valid subpass within renderPass
If the renderPass has multiview enabled and subpass has more than one bit set in the view mask and multiviewTessellationShader is not enabled, then pStages must not include tessellation shaders.
If the renderPass has multiview enabled and subpass has more than one bit set in the view mask and multiviewGeometryShader is not enabled, then pStages must not include a geometry shader.
If the renderPass has multiview enabled and subpass has more than one bit set in the view mask, shaders in the pipeline must not write to the Layer built-in output
If the renderPass has multiview enabled, then all shaders must not include variables decorated with the Layer built-in decoration in their interfaces.
flags must not contain the VK_PIPELINE_CREATE_DISPATCH_BASE flag.
If pStages includes a fragment shader stage and an input attachment was referenced by the VkRenderPassInputAttachmentAspectCreateInfo at renderPass create time, its shader code must not read from any aspect that was not specified in the aspectMask of the corresponding VkInputAttachmentAspectReference structure.
The number of resources in layout accessible to each shader stage that is used by the pipeline must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources
If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, and the viewportWScalingEnable member of a VkPipelineViewportWScalingStateCreateInfoNV structure, chained to the pNext chain of pViewportState, is VK_TRUE, the pViewportWScalings member of the VkPipelineViewportWScalingStateCreateInfoNV must be a pointer to an array of VkPipelineViewportWScalingStateCreateInfoNV::viewportCount valid VkViewportWScalingNV structures

Valid Usage (Implicit)

sType must be VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO

pNext must be NULL or a pointer to a valid instance of VkPipelineDiscardRectangleStateCreateInfoEXT
flags must be a valid combination of VkPipelineCreateFlagBits values
pStages must be a valid pointer to an array of stageCount valid VkPipelineShaderStageCreateInfo structures
pVertexInputState must be a valid pointer to a valid VkPipelineVertexInputStateCreateInfo structure
pInputAssemblyState must be a valid pointer to a valid VkPipelineInputAssemblyStateCreateInfo structure
pRasterizationState must be a valid pointer to a valid VkPipelineRasterizationStateCreateInfo structure
If pDynamicState is not NULL, pDynamicState must be a valid pointer to a valid VkPipelineDynamicStateCreateInfo structure
layout must be a valid VkPipelineLayout handle
renderPass must be a valid VkRenderPass handle
stageCount must be greater than 0
Each of basePipelineHandle, layout, and renderPass that are valid handles must have been created, allocated, or retrieved from the same VkDevice

Description

VkPipelineCreateFlags is a bitmask type for setting a mask of zero or more VkPipelineCreateFlagBits.

Description

VkColorComponentFlags is a bitmask type for setting a mask of zero or more VkColorComponentFlagBits.

Description

VkCullModeFlags is a bitmask type for setting a mask of zero or more VkCullModeFlagBits.

Eq VkBlendFactor Source #
Instance details Methods (==) :: VkBlendFactor -> VkBlendFactor -> Bool # (/=) :: VkBlendFactor -> VkBlendFactor -> Bool #
Ord VkBlendFactor Source #
Instance details Methods compare :: VkBlendFactor -> VkBlendFactor -> Ordering # (<) :: VkBlendFactor -> VkBlendFactor -> Bool # (<=) :: VkBlendFactor -> VkBlendFactor -> Bool # (>) :: VkBlendFactor -> VkBlendFactor -> Bool # (>=) :: VkBlendFactor -> VkBlendFactor -> Bool # max :: VkBlendFactor -> VkBlendFactor -> VkBlendFactor # min :: VkBlendFactor -> VkBlendFactor -> VkBlendFactor #
Read VkBlendFactor Source #
Instance details Methods readsPrec :: Int -> ReadS VkBlendFactor # readList :: ReadS [VkBlendFactor] # readPrec :: ReadPrec VkBlendFactor # readListPrec :: ReadPrec [VkBlendFactor] #
Show VkBlendFactor Source #
Instance details Methods showsPrec :: Int -> VkBlendFactor -> ShowS # show :: VkBlendFactor -> String # showList :: [VkBlendFactor] -> ShowS #
Storable VkBlendFactor Source #
Instance details Methods sizeOf :: VkBlendFactor -> Int # alignment :: VkBlendFactor -> Int # peekElemOff :: Ptr VkBlendFactor -> Int -> IO VkBlendFactor # pokeElemOff :: Ptr VkBlendFactor -> Int -> VkBlendFactor -> IO () # peekByteOff :: Ptr b -> Int -> IO VkBlendFactor # pokeByteOff :: Ptr b -> Int -> VkBlendFactor -> IO () # peek :: Ptr VkBlendFactor -> IO VkBlendFactor # poke :: Ptr VkBlendFactor -> VkBlendFactor -> IO () #

Eq VkBlendOp Source #
Instance details Methods (==) :: VkBlendOp -> VkBlendOp -> Bool # (/=) :: VkBlendOp -> VkBlendOp -> Bool #
Ord VkBlendOp Source #
Instance details Methods compare :: VkBlendOp -> VkBlendOp -> Ordering # (<) :: VkBlendOp -> VkBlendOp -> Bool # (<=) :: VkBlendOp -> VkBlendOp -> Bool # (>) :: VkBlendOp -> VkBlendOp -> Bool # (>=) :: VkBlendOp -> VkBlendOp -> Bool # max :: VkBlendOp -> VkBlendOp -> VkBlendOp # min :: VkBlendOp -> VkBlendOp -> VkBlendOp #
Read VkBlendOp Source #
Instance details Methods readsPrec :: Int -> ReadS VkBlendOp # readList :: ReadS [VkBlendOp] # readPrec :: ReadPrec VkBlendOp # readListPrec :: ReadPrec [VkBlendOp] #
Show VkBlendOp Source #
Instance details Methods showsPrec :: Int -> VkBlendOp -> ShowS # show :: VkBlendOp -> String # showList :: [VkBlendOp] -> ShowS #
Storable VkBlendOp Source #
Instance details Methods sizeOf :: VkBlendOp -> Int # alignment :: VkBlendOp -> Int # peekElemOff :: Ptr VkBlendOp -> Int -> IO VkBlendOp # pokeElemOff :: Ptr VkBlendOp -> Int -> VkBlendOp -> IO () # peekByteOff :: Ptr b -> Int -> IO VkBlendOp # pokeByteOff :: Ptr b -> Int -> VkBlendOp -> IO () # peek :: Ptr VkBlendOp -> IO VkBlendOp # poke :: Ptr VkBlendOp -> VkBlendOp -> IO () #

Eq VkCompareOp Source #
Instance details Methods (==) :: VkCompareOp -> VkCompareOp -> Bool # (/=) :: VkCompareOp -> VkCompareOp -> Bool #
Ord VkCompareOp Source #
Instance details Methods compare :: VkCompareOp -> VkCompareOp -> Ordering # (<) :: VkCompareOp -> VkCompareOp -> Bool # (<=) :: VkCompareOp -> VkCompareOp -> Bool # (>) :: VkCompareOp -> VkCompareOp -> Bool # (>=) :: VkCompareOp -> VkCompareOp -> Bool # max :: VkCompareOp -> VkCompareOp -> VkCompareOp # min :: VkCompareOp -> VkCompareOp -> VkCompareOp #
Read VkCompareOp Source #
Instance details Methods readsPrec :: Int -> ReadS VkCompareOp # readList :: ReadS [VkCompareOp] # readPrec :: ReadPrec VkCompareOp # readListPrec :: ReadPrec [VkCompareOp] #
Show VkCompareOp Source #
Instance details Methods showsPrec :: Int -> VkCompareOp -> ShowS # show :: VkCompareOp -> String # showList :: [VkCompareOp] -> ShowS #
Storable VkCompareOp Source #
Instance details Methods sizeOf :: VkCompareOp -> Int # alignment :: VkCompareOp -> Int # peekElemOff :: Ptr VkCompareOp -> Int -> IO VkCompareOp # pokeElemOff :: Ptr VkCompareOp -> Int -> VkCompareOp -> IO () # peekByteOff :: Ptr b -> Int -> IO VkCompareOp # pokeByteOff :: Ptr b -> Int -> VkCompareOp -> IO () # peek :: Ptr VkCompareOp -> IO VkCompareOp # poke :: Ptr VkCompareOp -> VkCompareOp -> IO () #

Eq VkDynamicState Source #
Instance details Methods (==) :: VkDynamicState -> VkDynamicState -> Bool # (/=) :: VkDynamicState -> VkDynamicState -> Bool #
Ord VkDynamicState Source #
Instance details Methods compare :: VkDynamicState -> VkDynamicState -> Ordering # (<) :: VkDynamicState -> VkDynamicState -> Bool # (<=) :: VkDynamicState -> VkDynamicState -> Bool # (>) :: VkDynamicState -> VkDynamicState -> Bool # (>=) :: VkDynamicState -> VkDynamicState -> Bool # max :: VkDynamicState -> VkDynamicState -> VkDynamicState # min :: VkDynamicState -> VkDynamicState -> VkDynamicState #
Read VkDynamicState Source #
Instance details Methods readsPrec :: Int -> ReadS VkDynamicState # readList :: ReadS [VkDynamicState] # readPrec :: ReadPrec VkDynamicState # readListPrec :: ReadPrec [VkDynamicState] #
Show VkDynamicState Source #
Instance details Methods showsPrec :: Int -> VkDynamicState -> ShowS # show :: VkDynamicState -> String # showList :: [VkDynamicState] -> ShowS #
Storable VkDynamicState Source #
Instance details Methods sizeOf :: VkDynamicState -> Int # alignment :: VkDynamicState -> Int # peekElemOff :: Ptr VkDynamicState -> Int -> IO VkDynamicState # pokeElemOff :: Ptr VkDynamicState -> Int -> VkDynamicState -> IO () # peekByteOff :: Ptr b -> Int -> IO VkDynamicState # pokeByteOff :: Ptr b -> Int -> VkDynamicState -> IO () # peek :: Ptr VkDynamicState -> IO VkDynamicState # poke :: Ptr VkDynamicState -> VkDynamicState -> IO () #

Eq VkPolygonMode Source #
Instance details Methods (==) :: VkPolygonMode -> VkPolygonMode -> Bool # (/=) :: VkPolygonMode -> VkPolygonMode -> Bool #
Ord VkPolygonMode Source #
Instance details Methods compare :: VkPolygonMode -> VkPolygonMode -> Ordering # (<) :: VkPolygonMode -> VkPolygonMode -> Bool # (<=) :: VkPolygonMode -> VkPolygonMode -> Bool # (>) :: VkPolygonMode -> VkPolygonMode -> Bool # (>=) :: VkPolygonMode -> VkPolygonMode -> Bool # max :: VkPolygonMode -> VkPolygonMode -> VkPolygonMode # min :: VkPolygonMode -> VkPolygonMode -> VkPolygonMode #
Read VkPolygonMode Source #
Instance details Methods readsPrec :: Int -> ReadS VkPolygonMode # readList :: ReadS [VkPolygonMode] # readPrec :: ReadPrec VkPolygonMode # readListPrec :: ReadPrec [VkPolygonMode] #
Show VkPolygonMode Source #
Instance details Methods showsPrec :: Int -> VkPolygonMode -> ShowS # show :: VkPolygonMode -> String # showList :: [VkPolygonMode] -> ShowS #
Storable VkPolygonMode Source #
Instance details Methods sizeOf :: VkPolygonMode -> Int # alignment :: VkPolygonMode -> Int # peekElemOff :: Ptr VkPolygonMode -> Int -> IO VkPolygonMode # pokeElemOff :: Ptr VkPolygonMode -> Int -> VkPolygonMode -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPolygonMode # pokeByteOff :: Ptr b -> Int -> VkPolygonMode -> IO () # peek :: Ptr VkPolygonMode -> IO VkPolygonMode # poke :: Ptr VkPolygonMode -> VkPolygonMode -> IO () #

Eq VkFrontFace Source #
Instance details Methods (==) :: VkFrontFace -> VkFrontFace -> Bool # (/=) :: VkFrontFace -> VkFrontFace -> Bool #
Ord VkFrontFace Source #
Instance details Methods compare :: VkFrontFace -> VkFrontFace -> Ordering # (<) :: VkFrontFace -> VkFrontFace -> Bool # (<=) :: VkFrontFace -> VkFrontFace -> Bool # (>) :: VkFrontFace -> VkFrontFace -> Bool # (>=) :: VkFrontFace -> VkFrontFace -> Bool # max :: VkFrontFace -> VkFrontFace -> VkFrontFace # min :: VkFrontFace -> VkFrontFace -> VkFrontFace #
Read VkFrontFace Source #
Instance details Methods readsPrec :: Int -> ReadS VkFrontFace # readList :: ReadS [VkFrontFace] # readPrec :: ReadPrec VkFrontFace # readListPrec :: ReadPrec [VkFrontFace] #
Show VkFrontFace Source #
Instance details Methods showsPrec :: Int -> VkFrontFace -> ShowS # show :: VkFrontFace -> String # showList :: [VkFrontFace] -> ShowS #
Storable VkFrontFace Source #
Instance details Methods sizeOf :: VkFrontFace -> Int # alignment :: VkFrontFace -> Int # peekElemOff :: Ptr VkFrontFace -> Int -> IO VkFrontFace # pokeElemOff :: Ptr VkFrontFace -> Int -> VkFrontFace -> IO () # peekByteOff :: Ptr b -> Int -> IO VkFrontFace # pokeByteOff :: Ptr b -> Int -> VkFrontFace -> IO () # peek :: Ptr VkFrontFace -> IO VkFrontFace # poke :: Ptr VkFrontFace -> VkFrontFace -> IO () #

Eq VkLogicOp Source #
Instance details Methods (==) :: VkLogicOp -> VkLogicOp -> Bool # (/=) :: VkLogicOp -> VkLogicOp -> Bool #
Ord VkLogicOp Source #
Instance details Methods compare :: VkLogicOp -> VkLogicOp -> Ordering # (<) :: VkLogicOp -> VkLogicOp -> Bool # (<=) :: VkLogicOp -> VkLogicOp -> Bool # (>) :: VkLogicOp -> VkLogicOp -> Bool # (>=) :: VkLogicOp -> VkLogicOp -> Bool # max :: VkLogicOp -> VkLogicOp -> VkLogicOp # min :: VkLogicOp -> VkLogicOp -> VkLogicOp #
Read VkLogicOp Source #
Instance details Methods readsPrec :: Int -> ReadS VkLogicOp # readList :: ReadS [VkLogicOp] # readPrec :: ReadPrec VkLogicOp # readListPrec :: ReadPrec [VkLogicOp] #
Show VkLogicOp Source #
Instance details Methods showsPrec :: Int -> VkLogicOp -> ShowS # show :: VkLogicOp -> String # showList :: [VkLogicOp] -> ShowS #
Storable VkLogicOp Source #
Instance details Methods sizeOf :: VkLogicOp -> Int # alignment :: VkLogicOp -> Int # peekElemOff :: Ptr VkLogicOp -> Int -> IO VkLogicOp # pokeElemOff :: Ptr VkLogicOp -> Int -> VkLogicOp -> IO () # peekByteOff :: Ptr b -> Int -> IO VkLogicOp # pokeByteOff :: Ptr b -> Int -> VkLogicOp -> IO () # peek :: Ptr VkLogicOp -> IO VkLogicOp # poke :: Ptr VkLogicOp -> VkLogicOp -> IO () #

Eq VkPrimitiveTopology Source #
Instance details Methods (==) :: VkPrimitiveTopology -> VkPrimitiveTopology -> Bool # (/=) :: VkPrimitiveTopology -> VkPrimitiveTopology -> Bool #
Ord VkPrimitiveTopology Source #
Instance details Methods compare :: VkPrimitiveTopology -> VkPrimitiveTopology -> Ordering # (<) :: VkPrimitiveTopology -> VkPrimitiveTopology -> Bool # (<=) :: VkPrimitiveTopology -> VkPrimitiveTopology -> Bool # (>) :: VkPrimitiveTopology -> VkPrimitiveTopology -> Bool # (>=) :: VkPrimitiveTopology -> VkPrimitiveTopology -> Bool # max :: VkPrimitiveTopology -> VkPrimitiveTopology -> VkPrimitiveTopology # min :: VkPrimitiveTopology -> VkPrimitiveTopology -> VkPrimitiveTopology #
Read VkPrimitiveTopology Source #
Instance details Methods readsPrec :: Int -> ReadS VkPrimitiveTopology # readList :: ReadS [VkPrimitiveTopology] # readPrec :: ReadPrec VkPrimitiveTopology # readListPrec :: ReadPrec [VkPrimitiveTopology] #
Show VkPrimitiveTopology Source #
Instance details Methods showsPrec :: Int -> VkPrimitiveTopology -> ShowS # show :: VkPrimitiveTopology -> String # showList :: [VkPrimitiveTopology] -> ShowS #
Storable VkPrimitiveTopology Source #
Instance details Methods sizeOf :: VkPrimitiveTopology -> Int # alignment :: VkPrimitiveTopology -> Int # peekElemOff :: Ptr VkPrimitiveTopology -> Int -> IO VkPrimitiveTopology # pokeElemOff :: Ptr VkPrimitiveTopology -> Int -> VkPrimitiveTopology -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPrimitiveTopology # pokeByteOff :: Ptr b -> Int -> VkPrimitiveTopology -> IO () # peek :: Ptr VkPrimitiveTopology -> IO VkPrimitiveTopology # poke :: Ptr VkPrimitiveTopology -> VkPrimitiveTopology -> IO () #

Eq VkStencilOp Source #
Instance details Methods (==) :: VkStencilOp -> VkStencilOp -> Bool # (/=) :: VkStencilOp -> VkStencilOp -> Bool #
Ord VkStencilOp Source #
Instance details Methods compare :: VkStencilOp -> VkStencilOp -> Ordering # (<) :: VkStencilOp -> VkStencilOp -> Bool # (<=) :: VkStencilOp -> VkStencilOp -> Bool # (>) :: VkStencilOp -> VkStencilOp -> Bool # (>=) :: VkStencilOp -> VkStencilOp -> Bool # max :: VkStencilOp -> VkStencilOp -> VkStencilOp # min :: VkStencilOp -> VkStencilOp -> VkStencilOp #
Read VkStencilOp Source #
Instance details Methods readsPrec :: Int -> ReadS VkStencilOp # readList :: ReadS [VkStencilOp] # readPrec :: ReadPrec VkStencilOp # readListPrec :: ReadPrec [VkStencilOp] #
Show VkStencilOp Source #
Instance details Methods showsPrec :: Int -> VkStencilOp -> ShowS # show :: VkStencilOp -> String # showList :: [VkStencilOp] -> ShowS #
Storable VkStencilOp Source #
Instance details Methods sizeOf :: VkStencilOp -> Int # alignment :: VkStencilOp -> Int # peekElemOff :: Ptr VkStencilOp -> Int -> IO VkStencilOp # pokeElemOff :: Ptr VkStencilOp -> Int -> VkStencilOp -> IO () # peekByteOff :: Ptr b -> Int -> IO VkStencilOp # pokeByteOff :: Ptr b -> Int -> VkStencilOp -> IO () # peek :: Ptr VkStencilOp -> IO VkStencilOp # poke :: Ptr VkStencilOp -> VkStencilOp -> IO () #

Eq VkVertexInputRate Source #
Instance details Methods (==) :: VkVertexInputRate -> VkVertexInputRate -> Bool # (/=) :: VkVertexInputRate -> VkVertexInputRate -> Bool #
Ord VkVertexInputRate Source #
Instance details Methods compare :: VkVertexInputRate -> VkVertexInputRate -> Ordering # (<) :: VkVertexInputRate -> VkVertexInputRate -> Bool # (<=) :: VkVertexInputRate -> VkVertexInputRate -> Bool # (>) :: VkVertexInputRate -> VkVertexInputRate -> Bool # (>=) :: VkVertexInputRate -> VkVertexInputRate -> Bool # max :: VkVertexInputRate -> VkVertexInputRate -> VkVertexInputRate # min :: VkVertexInputRate -> VkVertexInputRate -> VkVertexInputRate #
Read VkVertexInputRate Source #
Instance details Methods readsPrec :: Int -> ReadS VkVertexInputRate # readList :: ReadS [VkVertexInputRate] # readPrec :: ReadPrec VkVertexInputRate # readListPrec :: ReadPrec [VkVertexInputRate] #
Show VkVertexInputRate Source #
Instance details Methods showsPrec :: Int -> VkVertexInputRate -> ShowS # show :: VkVertexInputRate -> String # showList :: [VkVertexInputRate] -> ShowS #
Storable VkVertexInputRate Source #
Instance details Methods sizeOf :: VkVertexInputRate -> Int # alignment :: VkVertexInputRate -> Int # peekElemOff :: Ptr VkVertexInputRate -> Int -> IO VkVertexInputRate # pokeElemOff :: Ptr VkVertexInputRate -> Int -> VkVertexInputRate -> IO () # peekByteOff :: Ptr b -> Int -> IO VkVertexInputRate # pokeByteOff :: Ptr b -> Int -> VkVertexInputRate -> IO () # peek :: Ptr VkVertexInputRate -> IO VkVertexInputRate # poke :: Ptr VkVertexInputRate -> VkVertexInputRate -> IO () #

Eq VkPipelineDepthStencilStateCreateFlags Source #
Instance details Methods (==) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> Bool # (/=) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> Bool #
Ord VkPipelineDepthStencilStateCreateFlags Source #
Instance details Methods compare :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> Ordering # (<) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> Bool # (<=) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> Bool # (>) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> Bool # (>=) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> Bool # max :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # min :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags #
Read VkPipelineDepthStencilStateCreateFlags Source #
Instance details Methods readsPrec :: Int -> ReadS VkPipelineDepthStencilStateCreateFlags # readList :: ReadS [VkPipelineDepthStencilStateCreateFlags] # readPrec :: ReadPrec VkPipelineDepthStencilStateCreateFlags # readListPrec :: ReadPrec [VkPipelineDepthStencilStateCreateFlags] #
Show VkPipelineDepthStencilStateCreateFlags Source #
Instance details Methods showsPrec :: Int -> VkPipelineDepthStencilStateCreateFlags -> ShowS # show :: VkPipelineDepthStencilStateCreateFlags -> String # showList :: [VkPipelineDepthStencilStateCreateFlags] -> ShowS #
Storable VkPipelineDepthStencilStateCreateFlags Source #
Instance details Methods sizeOf :: VkPipelineDepthStencilStateCreateFlags -> Int # alignment :: VkPipelineDepthStencilStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineDepthStencilStateCreateFlags -> Int -> IO VkPipelineDepthStencilStateCreateFlags # pokeElemOff :: Ptr VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineDepthStencilStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineDepthStencilStateCreateFlags -> IO () # peek :: Ptr VkPipelineDepthStencilStateCreateFlags -> IO VkPipelineDepthStencilStateCreateFlags # poke :: Ptr VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> IO () #
Bits VkPipelineDepthStencilStateCreateFlags Source #
Instance details Methods (.&.) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # (.\|.) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # xor :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # complement :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags # shift :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # rotate :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # zeroBits :: VkPipelineDepthStencilStateCreateFlags # bit :: Int -> VkPipelineDepthStencilStateCreateFlags # setBit :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # clearBit :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # complementBit :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # testBit :: VkPipelineDepthStencilStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineDepthStencilStateCreateFlags -> Maybe Int # bitSize :: VkPipelineDepthStencilStateCreateFlags -> Int # isSigned :: VkPipelineDepthStencilStateCreateFlags -> Bool # shiftL :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # unsafeShiftL :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # shiftR :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # unsafeShiftR :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # rotateL :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # rotateR :: VkPipelineDepthStencilStateCreateFlags -> Int -> VkPipelineDepthStencilStateCreateFlags # popCount :: VkPipelineDepthStencilStateCreateFlags -> Int #
FiniteBits VkPipelineDepthStencilStateCreateFlags Source #
Instance details Methods finiteBitSize :: VkPipelineDepthStencilStateCreateFlags -> Int # countLeadingZeros :: VkPipelineDepthStencilStateCreateFlags -> Int # countTrailingZeros :: VkPipelineDepthStencilStateCreateFlags -> Int #

Eq VkPipelineDynamicStateCreateFlags Source #
Instance details Methods (==) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> Bool # (/=) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> Bool #
Ord VkPipelineDynamicStateCreateFlags Source #
Instance details Methods compare :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> Ordering # (<) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> Bool # (<=) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> Bool # (>) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> Bool # (>=) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> Bool # max :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # min :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags #
Read VkPipelineDynamicStateCreateFlags Source #
Instance details Methods readsPrec :: Int -> ReadS VkPipelineDynamicStateCreateFlags # readList :: ReadS [VkPipelineDynamicStateCreateFlags] # readPrec :: ReadPrec VkPipelineDynamicStateCreateFlags # readListPrec :: ReadPrec [VkPipelineDynamicStateCreateFlags] #
Show VkPipelineDynamicStateCreateFlags Source #
Instance details Methods showsPrec :: Int -> VkPipelineDynamicStateCreateFlags -> ShowS # show :: VkPipelineDynamicStateCreateFlags -> String # showList :: [VkPipelineDynamicStateCreateFlags] -> ShowS #
Storable VkPipelineDynamicStateCreateFlags Source #
Instance details Methods sizeOf :: VkPipelineDynamicStateCreateFlags -> Int # alignment :: VkPipelineDynamicStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineDynamicStateCreateFlags -> Int -> IO VkPipelineDynamicStateCreateFlags # pokeElemOff :: Ptr VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineDynamicStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineDynamicStateCreateFlags -> IO () # peek :: Ptr VkPipelineDynamicStateCreateFlags -> IO VkPipelineDynamicStateCreateFlags # poke :: Ptr VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> IO () #
Bits VkPipelineDynamicStateCreateFlags Source #
Instance details Methods (.&.) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # (.\|.) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # xor :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # complement :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags # shift :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # rotate :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # zeroBits :: VkPipelineDynamicStateCreateFlags # bit :: Int -> VkPipelineDynamicStateCreateFlags # setBit :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # clearBit :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # complementBit :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # testBit :: VkPipelineDynamicStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineDynamicStateCreateFlags -> Maybe Int # bitSize :: VkPipelineDynamicStateCreateFlags -> Int # isSigned :: VkPipelineDynamicStateCreateFlags -> Bool # shiftL :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # unsafeShiftL :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # shiftR :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # unsafeShiftR :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # rotateL :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # rotateR :: VkPipelineDynamicStateCreateFlags -> Int -> VkPipelineDynamicStateCreateFlags # popCount :: VkPipelineDynamicStateCreateFlags -> Int #
FiniteBits VkPipelineDynamicStateCreateFlags Source #
Instance details Methods finiteBitSize :: VkPipelineDynamicStateCreateFlags -> Int # countLeadingZeros :: VkPipelineDynamicStateCreateFlags -> Int # countTrailingZeros :: VkPipelineDynamicStateCreateFlags -> Int #

Eq VkPipelineColorBlendStateCreateFlags Source #
Instance details Methods (==) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> Bool # (/=) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> Bool #
Ord VkPipelineColorBlendStateCreateFlags Source #
Instance details Methods compare :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> Ordering # (<) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> Bool # (<=) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> Bool # (>) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> Bool # (>=) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> Bool # max :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # min :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags #
Read VkPipelineColorBlendStateCreateFlags Source #
Instance details Methods readsPrec :: Int -> ReadS VkPipelineColorBlendStateCreateFlags # readList :: ReadS [VkPipelineColorBlendStateCreateFlags] # readPrec :: ReadPrec VkPipelineColorBlendStateCreateFlags # readListPrec :: ReadPrec [VkPipelineColorBlendStateCreateFlags] #
Show VkPipelineColorBlendStateCreateFlags Source #
Instance details Methods showsPrec :: Int -> VkPipelineColorBlendStateCreateFlags -> ShowS # show :: VkPipelineColorBlendStateCreateFlags -> String # showList :: [VkPipelineColorBlendStateCreateFlags] -> ShowS #
Storable VkPipelineColorBlendStateCreateFlags Source #
Instance details Methods sizeOf :: VkPipelineColorBlendStateCreateFlags -> Int # alignment :: VkPipelineColorBlendStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineColorBlendStateCreateFlags -> Int -> IO VkPipelineColorBlendStateCreateFlags # pokeElemOff :: Ptr VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineColorBlendStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineColorBlendStateCreateFlags -> IO () # peek :: Ptr VkPipelineColorBlendStateCreateFlags -> IO VkPipelineColorBlendStateCreateFlags # poke :: Ptr VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> IO () #
Bits VkPipelineColorBlendStateCreateFlags Source #
Instance details Methods (.&.) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # (.\|.) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # xor :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # complement :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags # shift :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # rotate :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # zeroBits :: VkPipelineColorBlendStateCreateFlags # bit :: Int -> VkPipelineColorBlendStateCreateFlags # setBit :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # clearBit :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # complementBit :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # testBit :: VkPipelineColorBlendStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineColorBlendStateCreateFlags -> Maybe Int # bitSize :: VkPipelineColorBlendStateCreateFlags -> Int # isSigned :: VkPipelineColorBlendStateCreateFlags -> Bool # shiftL :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # unsafeShiftL :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # shiftR :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # unsafeShiftR :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # rotateL :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # rotateR :: VkPipelineColorBlendStateCreateFlags -> Int -> VkPipelineColorBlendStateCreateFlags # popCount :: VkPipelineColorBlendStateCreateFlags -> Int #
FiniteBits VkPipelineColorBlendStateCreateFlags Source #
Instance details Methods finiteBitSize :: VkPipelineColorBlendStateCreateFlags -> Int # countLeadingZeros :: VkPipelineColorBlendStateCreateFlags -> Int # countTrailingZeros :: VkPipelineColorBlendStateCreateFlags -> Int #

Eq VkPipelineMultisampleStateCreateFlags Source #
Instance details Methods (==) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> Bool # (/=) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> Bool #
Ord VkPipelineMultisampleStateCreateFlags Source #
Instance details Methods compare :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> Ordering # (<) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> Bool # (<=) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> Bool # (>) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> Bool # (>=) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> Bool # max :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # min :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags #
Read VkPipelineMultisampleStateCreateFlags Source #
Instance details Methods readsPrec :: Int -> ReadS VkPipelineMultisampleStateCreateFlags # readList :: ReadS [VkPipelineMultisampleStateCreateFlags] # readPrec :: ReadPrec VkPipelineMultisampleStateCreateFlags # readListPrec :: ReadPrec [VkPipelineMultisampleStateCreateFlags] #
Show VkPipelineMultisampleStateCreateFlags Source #
Instance details Methods showsPrec :: Int -> VkPipelineMultisampleStateCreateFlags -> ShowS # show :: VkPipelineMultisampleStateCreateFlags -> String # showList :: [VkPipelineMultisampleStateCreateFlags] -> ShowS #
Storable VkPipelineMultisampleStateCreateFlags Source #
Instance details Methods sizeOf :: VkPipelineMultisampleStateCreateFlags -> Int # alignment :: VkPipelineMultisampleStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineMultisampleStateCreateFlags -> Int -> IO VkPipelineMultisampleStateCreateFlags # pokeElemOff :: Ptr VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineMultisampleStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineMultisampleStateCreateFlags -> IO () # peek :: Ptr VkPipelineMultisampleStateCreateFlags -> IO VkPipelineMultisampleStateCreateFlags # poke :: Ptr VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> IO () #
Bits VkPipelineMultisampleStateCreateFlags Source #
Instance details Methods (.&.) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # (.\|.) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # xor :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # complement :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags # shift :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # rotate :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # zeroBits :: VkPipelineMultisampleStateCreateFlags # bit :: Int -> VkPipelineMultisampleStateCreateFlags # setBit :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # clearBit :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # complementBit :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # testBit :: VkPipelineMultisampleStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineMultisampleStateCreateFlags -> Maybe Int # bitSize :: VkPipelineMultisampleStateCreateFlags -> Int # isSigned :: VkPipelineMultisampleStateCreateFlags -> Bool # shiftL :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # unsafeShiftL :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # shiftR :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # unsafeShiftR :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # rotateL :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # rotateR :: VkPipelineMultisampleStateCreateFlags -> Int -> VkPipelineMultisampleStateCreateFlags # popCount :: VkPipelineMultisampleStateCreateFlags -> Int #
FiniteBits VkPipelineMultisampleStateCreateFlags Source #
Instance details Methods finiteBitSize :: VkPipelineMultisampleStateCreateFlags -> Int # countLeadingZeros :: VkPipelineMultisampleStateCreateFlags -> Int # countTrailingZeros :: VkPipelineMultisampleStateCreateFlags -> Int #

Eq VkPipelineRasterizationStateCreateFlags Source #
Instance details Methods (==) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> Bool # (/=) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> Bool #
Ord VkPipelineRasterizationStateCreateFlags Source #
Instance details Methods compare :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> Ordering # (<) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> Bool # (<=) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> Bool # (>) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> Bool # (>=) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> Bool # max :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # min :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags #
Read VkPipelineRasterizationStateCreateFlags Source #
Instance details Methods readsPrec :: Int -> ReadS VkPipelineRasterizationStateCreateFlags # readList :: ReadS [VkPipelineRasterizationStateCreateFlags] # readPrec :: ReadPrec VkPipelineRasterizationStateCreateFlags # readListPrec :: ReadPrec [VkPipelineRasterizationStateCreateFlags] #
Show VkPipelineRasterizationStateCreateFlags Source #
Instance details Methods showsPrec :: Int -> VkPipelineRasterizationStateCreateFlags -> ShowS # show :: VkPipelineRasterizationStateCreateFlags -> String # showList :: [VkPipelineRasterizationStateCreateFlags] -> ShowS #
Storable VkPipelineRasterizationStateCreateFlags Source #
Instance details Methods sizeOf :: VkPipelineRasterizationStateCreateFlags -> Int # alignment :: VkPipelineRasterizationStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineRasterizationStateCreateFlags -> Int -> IO VkPipelineRasterizationStateCreateFlags # pokeElemOff :: Ptr VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineRasterizationStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineRasterizationStateCreateFlags -> IO () # peek :: Ptr VkPipelineRasterizationStateCreateFlags -> IO VkPipelineRasterizationStateCreateFlags # poke :: Ptr VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> IO () #
Bits VkPipelineRasterizationStateCreateFlags Source #
Instance details Methods (.&.) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # (.\|.) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # xor :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # complement :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags # shift :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # rotate :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # zeroBits :: VkPipelineRasterizationStateCreateFlags # bit :: Int -> VkPipelineRasterizationStateCreateFlags # setBit :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # clearBit :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # complementBit :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # testBit :: VkPipelineRasterizationStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineRasterizationStateCreateFlags -> Maybe Int # bitSize :: VkPipelineRasterizationStateCreateFlags -> Int # isSigned :: VkPipelineRasterizationStateCreateFlags -> Bool # shiftL :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # unsafeShiftL :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # shiftR :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # unsafeShiftR :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # rotateL :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # rotateR :: VkPipelineRasterizationStateCreateFlags -> Int -> VkPipelineRasterizationStateCreateFlags # popCount :: VkPipelineRasterizationStateCreateFlags -> Int #
FiniteBits VkPipelineRasterizationStateCreateFlags Source #
Instance details Methods finiteBitSize :: VkPipelineRasterizationStateCreateFlags -> Int # countLeadingZeros :: VkPipelineRasterizationStateCreateFlags -> Int # countTrailingZeros :: VkPipelineRasterizationStateCreateFlags -> Int #

Eq VkPipelineViewportStateCreateFlags Source #
Instance details Methods (==) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> Bool # (/=) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> Bool #
Ord VkPipelineViewportStateCreateFlags Source #
Instance details Methods compare :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> Ordering # (<) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> Bool # (<=) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> Bool # (>) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> Bool # (>=) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> Bool # max :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # min :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags #
Read VkPipelineViewportStateCreateFlags Source #
Instance details Methods readsPrec :: Int -> ReadS VkPipelineViewportStateCreateFlags # readList :: ReadS [VkPipelineViewportStateCreateFlags] # readPrec :: ReadPrec VkPipelineViewportStateCreateFlags # readListPrec :: ReadPrec [VkPipelineViewportStateCreateFlags] #
Show VkPipelineViewportStateCreateFlags Source #
Instance details Methods showsPrec :: Int -> VkPipelineViewportStateCreateFlags -> ShowS # show :: VkPipelineViewportStateCreateFlags -> String # showList :: [VkPipelineViewportStateCreateFlags] -> ShowS #
Storable VkPipelineViewportStateCreateFlags Source #
Instance details Methods sizeOf :: VkPipelineViewportStateCreateFlags -> Int # alignment :: VkPipelineViewportStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineViewportStateCreateFlags -> Int -> IO VkPipelineViewportStateCreateFlags # pokeElemOff :: Ptr VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineViewportStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineViewportStateCreateFlags -> IO () # peek :: Ptr VkPipelineViewportStateCreateFlags -> IO VkPipelineViewportStateCreateFlags # poke :: Ptr VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> IO () #
Bits VkPipelineViewportStateCreateFlags Source #
Instance details Methods (.&.) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # (.\|.) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # xor :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # complement :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags # shift :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # rotate :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # zeroBits :: VkPipelineViewportStateCreateFlags # bit :: Int -> VkPipelineViewportStateCreateFlags # setBit :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # clearBit :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # complementBit :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # testBit :: VkPipelineViewportStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineViewportStateCreateFlags -> Maybe Int # bitSize :: VkPipelineViewportStateCreateFlags -> Int # isSigned :: VkPipelineViewportStateCreateFlags -> Bool # shiftL :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # unsafeShiftL :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # shiftR :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # unsafeShiftR :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # rotateL :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # rotateR :: VkPipelineViewportStateCreateFlags -> Int -> VkPipelineViewportStateCreateFlags # popCount :: VkPipelineViewportStateCreateFlags -> Int #
FiniteBits VkPipelineViewportStateCreateFlags Source #
Instance details Methods finiteBitSize :: VkPipelineViewportStateCreateFlags -> Int # countLeadingZeros :: VkPipelineViewportStateCreateFlags -> Int # countTrailingZeros :: VkPipelineViewportStateCreateFlags -> Int #

Eq VkPipelineTessellationStateCreateFlags Source #
Instance details Methods (==) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> Bool # (/=) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> Bool #
Ord VkPipelineTessellationStateCreateFlags Source #
Instance details Methods compare :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> Ordering # (<) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> Bool # (<=) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> Bool # (>) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> Bool # (>=) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> Bool # max :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # min :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags #
Read VkPipelineTessellationStateCreateFlags Source #
Instance details Methods readsPrec :: Int -> ReadS VkPipelineTessellationStateCreateFlags # readList :: ReadS [VkPipelineTessellationStateCreateFlags] # readPrec :: ReadPrec VkPipelineTessellationStateCreateFlags # readListPrec :: ReadPrec [VkPipelineTessellationStateCreateFlags] #
Show VkPipelineTessellationStateCreateFlags Source #
Instance details Methods showsPrec :: Int -> VkPipelineTessellationStateCreateFlags -> ShowS # show :: VkPipelineTessellationStateCreateFlags -> String # showList :: [VkPipelineTessellationStateCreateFlags] -> ShowS #
Storable VkPipelineTessellationStateCreateFlags Source #
Instance details Methods sizeOf :: VkPipelineTessellationStateCreateFlags -> Int # alignment :: VkPipelineTessellationStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineTessellationStateCreateFlags -> Int -> IO VkPipelineTessellationStateCreateFlags # pokeElemOff :: Ptr VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineTessellationStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineTessellationStateCreateFlags -> IO () # peek :: Ptr VkPipelineTessellationStateCreateFlags -> IO VkPipelineTessellationStateCreateFlags # poke :: Ptr VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> IO () #
Bits VkPipelineTessellationStateCreateFlags Source #
Instance details Methods (.&.) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # (.\|.) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # xor :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # complement :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags # shift :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # rotate :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # zeroBits :: VkPipelineTessellationStateCreateFlags # bit :: Int -> VkPipelineTessellationStateCreateFlags # setBit :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # clearBit :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # complementBit :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # testBit :: VkPipelineTessellationStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineTessellationStateCreateFlags -> Maybe Int # bitSize :: VkPipelineTessellationStateCreateFlags -> Int # isSigned :: VkPipelineTessellationStateCreateFlags -> Bool # shiftL :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # unsafeShiftL :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # shiftR :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # unsafeShiftR :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # rotateL :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # rotateR :: VkPipelineTessellationStateCreateFlags -> Int -> VkPipelineTessellationStateCreateFlags # popCount :: VkPipelineTessellationStateCreateFlags -> Int #
FiniteBits VkPipelineTessellationStateCreateFlags Source #
Instance details Methods finiteBitSize :: VkPipelineTessellationStateCreateFlags -> Int # countLeadingZeros :: VkPipelineTessellationStateCreateFlags -> Int # countTrailingZeros :: VkPipelineTessellationStateCreateFlags -> Int #

Eq VkPipelineInputAssemblyStateCreateFlags Source #
Instance details Methods (==) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> Bool # (/=) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> Bool #
Ord VkPipelineInputAssemblyStateCreateFlags Source #
Instance details Methods compare :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> Ordering # (<) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> Bool # (<=) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> Bool # (>) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> Bool # (>=) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> Bool # max :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # min :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags #
Read VkPipelineInputAssemblyStateCreateFlags Source #
Instance details Methods readsPrec :: Int -> ReadS VkPipelineInputAssemblyStateCreateFlags # readList :: ReadS [VkPipelineInputAssemblyStateCreateFlags] # readPrec :: ReadPrec VkPipelineInputAssemblyStateCreateFlags # readListPrec :: ReadPrec [VkPipelineInputAssemblyStateCreateFlags] #
Show VkPipelineInputAssemblyStateCreateFlags Source #
Instance details Methods showsPrec :: Int -> VkPipelineInputAssemblyStateCreateFlags -> ShowS # show :: VkPipelineInputAssemblyStateCreateFlags -> String # showList :: [VkPipelineInputAssemblyStateCreateFlags] -> ShowS #
Storable VkPipelineInputAssemblyStateCreateFlags Source #
Instance details Methods sizeOf :: VkPipelineInputAssemblyStateCreateFlags -> Int # alignment :: VkPipelineInputAssemblyStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineInputAssemblyStateCreateFlags -> Int -> IO VkPipelineInputAssemblyStateCreateFlags # pokeElemOff :: Ptr VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineInputAssemblyStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineInputAssemblyStateCreateFlags -> IO () # peek :: Ptr VkPipelineInputAssemblyStateCreateFlags -> IO VkPipelineInputAssemblyStateCreateFlags # poke :: Ptr VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> IO () #
Bits VkPipelineInputAssemblyStateCreateFlags Source #
Instance details Methods (.&.) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # (.\|.) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # xor :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # complement :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags # shift :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # rotate :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # zeroBits :: VkPipelineInputAssemblyStateCreateFlags # bit :: Int -> VkPipelineInputAssemblyStateCreateFlags # setBit :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # clearBit :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # complementBit :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # testBit :: VkPipelineInputAssemblyStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineInputAssemblyStateCreateFlags -> Maybe Int # bitSize :: VkPipelineInputAssemblyStateCreateFlags -> Int # isSigned :: VkPipelineInputAssemblyStateCreateFlags -> Bool # shiftL :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # unsafeShiftL :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # shiftR :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # unsafeShiftR :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # rotateL :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # rotateR :: VkPipelineInputAssemblyStateCreateFlags -> Int -> VkPipelineInputAssemblyStateCreateFlags # popCount :: VkPipelineInputAssemblyStateCreateFlags -> Int #
FiniteBits VkPipelineInputAssemblyStateCreateFlags Source #
Instance details Methods finiteBitSize :: VkPipelineInputAssemblyStateCreateFlags -> Int # countLeadingZeros :: VkPipelineInputAssemblyStateCreateFlags -> Int # countTrailingZeros :: VkPipelineInputAssemblyStateCreateFlags -> Int #

Eq VkPipelineVertexInputStateCreateFlags Source #
Instance details Methods (==) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> Bool # (/=) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> Bool #
Ord VkPipelineVertexInputStateCreateFlags Source #
Instance details Methods compare :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> Ordering # (<) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> Bool # (<=) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> Bool # (>) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> Bool # (>=) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> Bool # max :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # min :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags #
Read VkPipelineVertexInputStateCreateFlags Source #
Instance details Methods readsPrec :: Int -> ReadS VkPipelineVertexInputStateCreateFlags # readList :: ReadS [VkPipelineVertexInputStateCreateFlags] # readPrec :: ReadPrec VkPipelineVertexInputStateCreateFlags # readListPrec :: ReadPrec [VkPipelineVertexInputStateCreateFlags] #
Show VkPipelineVertexInputStateCreateFlags Source #
Instance details Methods showsPrec :: Int -> VkPipelineVertexInputStateCreateFlags -> ShowS # show :: VkPipelineVertexInputStateCreateFlags -> String # showList :: [VkPipelineVertexInputStateCreateFlags] -> ShowS #
Storable VkPipelineVertexInputStateCreateFlags Source #
Instance details Methods sizeOf :: VkPipelineVertexInputStateCreateFlags -> Int # alignment :: VkPipelineVertexInputStateCreateFlags -> Int # peekElemOff :: Ptr VkPipelineVertexInputStateCreateFlags -> Int -> IO VkPipelineVertexInputStateCreateFlags # pokeElemOff :: Ptr VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineVertexInputStateCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineVertexInputStateCreateFlags -> IO () # peek :: Ptr VkPipelineVertexInputStateCreateFlags -> IO VkPipelineVertexInputStateCreateFlags # poke :: Ptr VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> IO () #
Bits VkPipelineVertexInputStateCreateFlags Source #
Instance details Methods (.&.) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # (.\|.) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # xor :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # complement :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags # shift :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # rotate :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # zeroBits :: VkPipelineVertexInputStateCreateFlags # bit :: Int -> VkPipelineVertexInputStateCreateFlags # setBit :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # clearBit :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # complementBit :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # testBit :: VkPipelineVertexInputStateCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineVertexInputStateCreateFlags -> Maybe Int # bitSize :: VkPipelineVertexInputStateCreateFlags -> Int # isSigned :: VkPipelineVertexInputStateCreateFlags -> Bool # shiftL :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # unsafeShiftL :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # shiftR :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # unsafeShiftR :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # rotateL :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # rotateR :: VkPipelineVertexInputStateCreateFlags -> Int -> VkPipelineVertexInputStateCreateFlags # popCount :: VkPipelineVertexInputStateCreateFlags -> Int #
FiniteBits VkPipelineVertexInputStateCreateFlags Source #
Instance details Methods finiteBitSize :: VkPipelineVertexInputStateCreateFlags -> Int # countLeadingZeros :: VkPipelineVertexInputStateCreateFlags -> Int # countTrailingZeros :: VkPipelineVertexInputStateCreateFlags -> Int #

Eq VkPipelineShaderStageCreateFlags Source #
Instance details Methods (==) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> Bool # (/=) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> Bool #
Ord VkPipelineShaderStageCreateFlags Source #
Instance details Methods compare :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> Ordering # (<) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> Bool # (<=) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> Bool # (>) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> Bool # (>=) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> Bool # max :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # min :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags #
Read VkPipelineShaderStageCreateFlags Source #
Instance details Methods readsPrec :: Int -> ReadS VkPipelineShaderStageCreateFlags # readList :: ReadS [VkPipelineShaderStageCreateFlags] # readPrec :: ReadPrec VkPipelineShaderStageCreateFlags # readListPrec :: ReadPrec [VkPipelineShaderStageCreateFlags] #
Show VkPipelineShaderStageCreateFlags Source #
Instance details Methods showsPrec :: Int -> VkPipelineShaderStageCreateFlags -> ShowS # show :: VkPipelineShaderStageCreateFlags -> String # showList :: [VkPipelineShaderStageCreateFlags] -> ShowS #
Storable VkPipelineShaderStageCreateFlags Source #
Instance details Methods sizeOf :: VkPipelineShaderStageCreateFlags -> Int # alignment :: VkPipelineShaderStageCreateFlags -> Int # peekElemOff :: Ptr VkPipelineShaderStageCreateFlags -> Int -> IO VkPipelineShaderStageCreateFlags # pokeElemOff :: Ptr VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineShaderStageCreateFlags # pokeByteOff :: Ptr b -> Int -> VkPipelineShaderStageCreateFlags -> IO () # peek :: Ptr VkPipelineShaderStageCreateFlags -> IO VkPipelineShaderStageCreateFlags # poke :: Ptr VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> IO () #
Bits VkPipelineShaderStageCreateFlags Source #
Instance details Methods (.&.) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # (.\|.) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # xor :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # complement :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags # shift :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # rotate :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # zeroBits :: VkPipelineShaderStageCreateFlags # bit :: Int -> VkPipelineShaderStageCreateFlags # setBit :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # clearBit :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # complementBit :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # testBit :: VkPipelineShaderStageCreateFlags -> Int -> Bool # bitSizeMaybe :: VkPipelineShaderStageCreateFlags -> Maybe Int # bitSize :: VkPipelineShaderStageCreateFlags -> Int # isSigned :: VkPipelineShaderStageCreateFlags -> Bool # shiftL :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # unsafeShiftL :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # shiftR :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # unsafeShiftR :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # rotateL :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # rotateR :: VkPipelineShaderStageCreateFlags -> Int -> VkPipelineShaderStageCreateFlags # popCount :: VkPipelineShaderStageCreateFlags -> Int #
FiniteBits VkPipelineShaderStageCreateFlags Source #
Instance details Methods finiteBitSize :: VkPipelineShaderStageCreateFlags -> Int # countLeadingZeros :: VkPipelineShaderStageCreateFlags -> Int # countTrailingZeros :: VkPipelineShaderStageCreateFlags -> Int #

Eq VkShaderStageFlagBits Source #
Instance details Methods (==) :: VkShaderStageFlagBits -> VkShaderStageFlagBits -> Bool # (/=) :: VkShaderStageFlagBits -> VkShaderStageFlagBits -> Bool #
Ord VkShaderStageFlagBits Source #
Instance details Methods compare :: VkShaderStageFlagBits -> VkShaderStageFlagBits -> Ordering # (<) :: VkShaderStageFlagBits -> VkShaderStageFlagBits -> Bool # (<=) :: VkShaderStageFlagBits -> VkShaderStageFlagBits -> Bool # (>) :: VkShaderStageFlagBits -> VkShaderStageFlagBits -> Bool # (>=) :: VkShaderStageFlagBits -> VkShaderStageFlagBits -> Bool # max :: VkShaderStageFlagBits -> VkShaderStageFlagBits -> VkShaderStageFlagBits # min :: VkShaderStageFlagBits -> VkShaderStageFlagBits -> VkShaderStageFlagBits #
Read VkShaderStageFlagBits Source #
Instance details Methods readsPrec :: Int -> ReadS VkShaderStageFlagBits # readList :: ReadS [VkShaderStageFlagBits] # readPrec :: ReadPrec VkShaderStageFlagBits # readListPrec :: ReadPrec [VkShaderStageFlagBits] #
Show VkShaderStageFlagBits Source #
Instance details Methods showsPrec :: Int -> VkShaderStageFlagBits -> ShowS # show :: VkShaderStageFlagBits -> String # showList :: [VkShaderStageFlagBits] -> ShowS #
Storable VkShaderStageFlagBits Source #
Instance details Methods sizeOf :: VkShaderStageFlagBits -> Int # alignment :: VkShaderStageFlagBits -> Int # peekElemOff :: Ptr VkShaderStageFlagBits -> Int -> IO VkShaderStageFlagBits # pokeElemOff :: Ptr VkShaderStageFlagBits -> Int -> VkShaderStageFlagBits -> IO () # peekByteOff :: Ptr b -> Int -> IO VkShaderStageFlagBits # pokeByteOff :: Ptr b -> Int -> VkShaderStageFlagBits -> IO () # peek :: Ptr VkShaderStageFlagBits -> IO VkShaderStageFlagBits # poke :: Ptr VkShaderStageFlagBits -> VkShaderStageFlagBits -> IO () #
Bits VkShaderStageFlagBits Source #
Instance details Methods (.&.) :: VkShaderStageFlagBits -> VkShaderStageFlagBits -> VkShaderStageFlagBits # (.\|.) :: VkShaderStageFlagBits -> VkShaderStageFlagBits -> VkShaderStageFlagBits # xor :: VkShaderStageFlagBits -> VkShaderStageFlagBits -> VkShaderStageFlagBits # complement :: VkShaderStageFlagBits -> VkShaderStageFlagBits # shift :: VkShaderStageFlagBits -> Int -> VkShaderStageFlagBits # rotate :: VkShaderStageFlagBits -> Int -> VkShaderStageFlagBits # zeroBits :: VkShaderStageFlagBits # bit :: Int -> VkShaderStageFlagBits # setBit :: VkShaderStageFlagBits -> Int -> VkShaderStageFlagBits # clearBit :: VkShaderStageFlagBits -> Int -> VkShaderStageFlagBits # complementBit :: VkShaderStageFlagBits -> Int -> VkShaderStageFlagBits # testBit :: VkShaderStageFlagBits -> Int -> Bool # bitSizeMaybe :: VkShaderStageFlagBits -> Maybe Int # bitSize :: VkShaderStageFlagBits -> Int # isSigned :: VkShaderStageFlagBits -> Bool # shiftL :: VkShaderStageFlagBits -> Int -> VkShaderStageFlagBits # unsafeShiftL :: VkShaderStageFlagBits -> Int -> VkShaderStageFlagBits # shiftR :: VkShaderStageFlagBits -> Int -> VkShaderStageFlagBits # unsafeShiftR :: VkShaderStageFlagBits -> Int -> VkShaderStageFlagBits # rotateL :: VkShaderStageFlagBits -> Int -> VkShaderStageFlagBits # rotateR :: VkShaderStageFlagBits -> Int -> VkShaderStageFlagBits # popCount :: VkShaderStageFlagBits -> Int #
FiniteBits VkShaderStageFlagBits Source #
Instance details Methods finiteBitSize :: VkShaderStageFlagBits -> Int # countLeadingZeros :: VkShaderStageFlagBits -> Int # countTrailingZeros :: VkShaderStageFlagBits -> Int #

Eq VkPipelineCreateFlagBits Source #
Instance details Methods (==) :: VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits -> Bool # (/=) :: VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits -> Bool #
Ord VkPipelineCreateFlagBits Source #
Instance details Methods compare :: VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits -> Ordering # (<) :: VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits -> Bool # (<=) :: VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits -> Bool # (>) :: VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits -> Bool # (>=) :: VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits -> Bool # max :: VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits # min :: VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits #
Read VkPipelineCreateFlagBits Source #
Instance details Methods readsPrec :: Int -> ReadS VkPipelineCreateFlagBits # readList :: ReadS [VkPipelineCreateFlagBits] # readPrec :: ReadPrec VkPipelineCreateFlagBits # readListPrec :: ReadPrec [VkPipelineCreateFlagBits] #
Show VkPipelineCreateFlagBits Source #
Instance details Methods showsPrec :: Int -> VkPipelineCreateFlagBits -> ShowS # show :: VkPipelineCreateFlagBits -> String # showList :: [VkPipelineCreateFlagBits] -> ShowS #
Storable VkPipelineCreateFlagBits Source #
Instance details Methods sizeOf :: VkPipelineCreateFlagBits -> Int # alignment :: VkPipelineCreateFlagBits -> Int # peekElemOff :: Ptr VkPipelineCreateFlagBits -> Int -> IO VkPipelineCreateFlagBits # pokeElemOff :: Ptr VkPipelineCreateFlagBits -> Int -> VkPipelineCreateFlagBits -> IO () # peekByteOff :: Ptr b -> Int -> IO VkPipelineCreateFlagBits # pokeByteOff :: Ptr b -> Int -> VkPipelineCreateFlagBits -> IO () # peek :: Ptr VkPipelineCreateFlagBits -> IO VkPipelineCreateFlagBits # poke :: Ptr VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits -> IO () #
Bits VkPipelineCreateFlagBits Source #
Instance details Methods (.&.) :: VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits # (.\|.) :: VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits # xor :: VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits # complement :: VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits # shift :: VkPipelineCreateFlagBits -> Int -> VkPipelineCreateFlagBits # rotate :: VkPipelineCreateFlagBits -> Int -> VkPipelineCreateFlagBits # zeroBits :: VkPipelineCreateFlagBits # bit :: Int -> VkPipelineCreateFlagBits # setBit :: VkPipelineCreateFlagBits -> Int -> VkPipelineCreateFlagBits # clearBit :: VkPipelineCreateFlagBits -> Int -> VkPipelineCreateFlagBits # complementBit :: VkPipelineCreateFlagBits -> Int -> VkPipelineCreateFlagBits # testBit :: VkPipelineCreateFlagBits -> Int -> Bool # bitSizeMaybe :: VkPipelineCreateFlagBits -> Maybe Int # bitSize :: VkPipelineCreateFlagBits -> Int # isSigned :: VkPipelineCreateFlagBits -> Bool # shiftL :: VkPipelineCreateFlagBits -> Int -> VkPipelineCreateFlagBits # unsafeShiftL :: VkPipelineCreateFlagBits -> Int -> VkPipelineCreateFlagBits # shiftR :: VkPipelineCreateFlagBits -> Int -> VkPipelineCreateFlagBits # unsafeShiftR :: VkPipelineCreateFlagBits -> Int -> VkPipelineCreateFlagBits # rotateL :: VkPipelineCreateFlagBits -> Int -> VkPipelineCreateFlagBits # rotateR :: VkPipelineCreateFlagBits -> Int -> VkPipelineCreateFlagBits # popCount :: VkPipelineCreateFlagBits -> Int #
FiniteBits VkPipelineCreateFlagBits Source #
Instance details Methods finiteBitSize :: VkPipelineCreateFlagBits -> Int # countLeadingZeros :: VkPipelineCreateFlagBits -> Int # countTrailingZeros :: VkPipelineCreateFlagBits -> Int #

Eq VkColorComponentFlagBits Source #
Instance details Methods (==) :: VkColorComponentFlagBits -> VkColorComponentFlagBits -> Bool # (/=) :: VkColorComponentFlagBits -> VkColorComponentFlagBits -> Bool #
Ord VkColorComponentFlagBits Source #
Instance details Methods compare :: VkColorComponentFlagBits -> VkColorComponentFlagBits -> Ordering # (<) :: VkColorComponentFlagBits -> VkColorComponentFlagBits -> Bool # (<=) :: VkColorComponentFlagBits -> VkColorComponentFlagBits -> Bool # (>) :: VkColorComponentFlagBits -> VkColorComponentFlagBits -> Bool # (>=) :: VkColorComponentFlagBits -> VkColorComponentFlagBits -> Bool # max :: VkColorComponentFlagBits -> VkColorComponentFlagBits -> VkColorComponentFlagBits # min :: VkColorComponentFlagBits -> VkColorComponentFlagBits -> VkColorComponentFlagBits #
Read VkColorComponentFlagBits Source #
Instance details Methods readsPrec :: Int -> ReadS VkColorComponentFlagBits # readList :: ReadS [VkColorComponentFlagBits] # readPrec :: ReadPrec VkColorComponentFlagBits # readListPrec :: ReadPrec [VkColorComponentFlagBits] #
Show VkColorComponentFlagBits Source #
Instance details Methods showsPrec :: Int -> VkColorComponentFlagBits -> ShowS # show :: VkColorComponentFlagBits -> String # showList :: [VkColorComponentFlagBits] -> ShowS #
Storable VkColorComponentFlagBits Source #
Instance details Methods sizeOf :: VkColorComponentFlagBits -> Int # alignment :: VkColorComponentFlagBits -> Int # peekElemOff :: Ptr VkColorComponentFlagBits -> Int -> IO VkColorComponentFlagBits # pokeElemOff :: Ptr VkColorComponentFlagBits -> Int -> VkColorComponentFlagBits -> IO () # peekByteOff :: Ptr b -> Int -> IO VkColorComponentFlagBits # pokeByteOff :: Ptr b -> Int -> VkColorComponentFlagBits -> IO () # peek :: Ptr VkColorComponentFlagBits -> IO VkColorComponentFlagBits # poke :: Ptr VkColorComponentFlagBits -> VkColorComponentFlagBits -> IO () #
Bits VkColorComponentFlagBits Source #
Instance details Methods (.&.) :: VkColorComponentFlagBits -> VkColorComponentFlagBits -> VkColorComponentFlagBits # (.\|.) :: VkColorComponentFlagBits -> VkColorComponentFlagBits -> VkColorComponentFlagBits # xor :: VkColorComponentFlagBits -> VkColorComponentFlagBits -> VkColorComponentFlagBits # complement :: VkColorComponentFlagBits -> VkColorComponentFlagBits # shift :: VkColorComponentFlagBits -> Int -> VkColorComponentFlagBits # rotate :: VkColorComponentFlagBits -> Int -> VkColorComponentFlagBits # zeroBits :: VkColorComponentFlagBits # bit :: Int -> VkColorComponentFlagBits # setBit :: VkColorComponentFlagBits -> Int -> VkColorComponentFlagBits # clearBit :: VkColorComponentFlagBits -> Int -> VkColorComponentFlagBits # complementBit :: VkColorComponentFlagBits -> Int -> VkColorComponentFlagBits # testBit :: VkColorComponentFlagBits -> Int -> Bool # bitSizeMaybe :: VkColorComponentFlagBits -> Maybe Int # bitSize :: VkColorComponentFlagBits -> Int # isSigned :: VkColorComponentFlagBits -> Bool # shiftL :: VkColorComponentFlagBits -> Int -> VkColorComponentFlagBits # unsafeShiftL :: VkColorComponentFlagBits -> Int -> VkColorComponentFlagBits # shiftR :: VkColorComponentFlagBits -> Int -> VkColorComponentFlagBits # unsafeShiftR :: VkColorComponentFlagBits -> Int -> VkColorComponentFlagBits # rotateL :: VkColorComponentFlagBits -> Int -> VkColorComponentFlagBits # rotateR :: VkColorComponentFlagBits -> Int -> VkColorComponentFlagBits # popCount :: VkColorComponentFlagBits -> Int #
FiniteBits VkColorComponentFlagBits Source #
Instance details Methods finiteBitSize :: VkColorComponentFlagBits -> Int # countLeadingZeros :: VkColorComponentFlagBits -> Int # countTrailingZeros :: VkColorComponentFlagBits -> Int #

Eq VkCullModeFlagBits Source #
Instance details Methods (==) :: VkCullModeFlagBits -> VkCullModeFlagBits -> Bool # (/=) :: VkCullModeFlagBits -> VkCullModeFlagBits -> Bool #
Ord VkCullModeFlagBits Source #
Instance details Methods compare :: VkCullModeFlagBits -> VkCullModeFlagBits -> Ordering # (<) :: VkCullModeFlagBits -> VkCullModeFlagBits -> Bool # (<=) :: VkCullModeFlagBits -> VkCullModeFlagBits -> Bool # (>) :: VkCullModeFlagBits -> VkCullModeFlagBits -> Bool # (>=) :: VkCullModeFlagBits -> VkCullModeFlagBits -> Bool # max :: VkCullModeFlagBits -> VkCullModeFlagBits -> VkCullModeFlagBits # min :: VkCullModeFlagBits -> VkCullModeFlagBits -> VkCullModeFlagBits #
Read VkCullModeFlagBits Source #
Instance details Methods readsPrec :: Int -> ReadS VkCullModeFlagBits # readList :: ReadS [VkCullModeFlagBits] # readPrec :: ReadPrec VkCullModeFlagBits # readListPrec :: ReadPrec [VkCullModeFlagBits] #
Show VkCullModeFlagBits Source #
Instance details Methods showsPrec :: Int -> VkCullModeFlagBits -> ShowS # show :: VkCullModeFlagBits -> String # showList :: [VkCullModeFlagBits] -> ShowS #
Storable VkCullModeFlagBits Source #
Instance details Methods sizeOf :: VkCullModeFlagBits -> Int # alignment :: VkCullModeFlagBits -> Int # peekElemOff :: Ptr VkCullModeFlagBits -> Int -> IO VkCullModeFlagBits # pokeElemOff :: Ptr VkCullModeFlagBits -> Int -> VkCullModeFlagBits -> IO () # peekByteOff :: Ptr b -> Int -> IO VkCullModeFlagBits # pokeByteOff :: Ptr b -> Int -> VkCullModeFlagBits -> IO () # peek :: Ptr VkCullModeFlagBits -> IO VkCullModeFlagBits # poke :: Ptr VkCullModeFlagBits -> VkCullModeFlagBits -> IO () #
Bits VkCullModeFlagBits Source #
Instance details Methods (.&.) :: VkCullModeFlagBits -> VkCullModeFlagBits -> VkCullModeFlagBits # (.\|.) :: VkCullModeFlagBits -> VkCullModeFlagBits -> VkCullModeFlagBits # xor :: VkCullModeFlagBits -> VkCullModeFlagBits -> VkCullModeFlagBits # complement :: VkCullModeFlagBits -> VkCullModeFlagBits # shift :: VkCullModeFlagBits -> Int -> VkCullModeFlagBits # rotate :: VkCullModeFlagBits -> Int -> VkCullModeFlagBits # zeroBits :: VkCullModeFlagBits # bit :: Int -> VkCullModeFlagBits # setBit :: VkCullModeFlagBits -> Int -> VkCullModeFlagBits # clearBit :: VkCullModeFlagBits -> Int -> VkCullModeFlagBits # complementBit :: VkCullModeFlagBits -> Int -> VkCullModeFlagBits # testBit :: VkCullModeFlagBits -> Int -> Bool # bitSizeMaybe :: VkCullModeFlagBits -> Maybe Int # bitSize :: VkCullModeFlagBits -> Int # isSigned :: VkCullModeFlagBits -> Bool # shiftL :: VkCullModeFlagBits -> Int -> VkCullModeFlagBits # unsafeShiftL :: VkCullModeFlagBits -> Int -> VkCullModeFlagBits # shiftR :: VkCullModeFlagBits -> Int -> VkCullModeFlagBits # unsafeShiftR :: VkCullModeFlagBits -> Int -> VkCullModeFlagBits # rotateL :: VkCullModeFlagBits -> Int -> VkCullModeFlagBits # rotateR :: VkCullModeFlagBits -> Int -> VkCullModeFlagBits # popCount :: VkCullModeFlagBits -> Int #
FiniteBits VkCullModeFlagBits Source #
Instance details Methods finiteBitSize :: VkCullModeFlagBits -> Int # countLeadingZeros :: VkCullModeFlagBits -> Int # countTrailingZeros :: VkCullModeFlagBits -> Int #

VkOffset2D
Fields vkX :: Int32 `x` is the x offset. vkY :: Int32 `y` is the y offset.

Documentation

Description

See Also

Description

See Also

See Also

See Also

Description

See Also

Description

See Also

Description

See Also

See Also

Description

See Also

See Also

Description

See Also

Description

See Also

Description

See Also

Description

See Also

Description

See Also

Description

See Also

Description

See Also

Description

See Also

Description

See Also

Description

See Also

See Also

Description

See Also

Description

See Also

Description

See Also

See Also

See Also

See Also

Parameters

Description

Valid Usage

Valid Usage (Implicit)

Return Codes

See Also

Parameters

Valid Usage

Valid Usage (Implicit)

Return Codes

See Also

Parameters

Valid Usage

Valid Usage (Implicit)

Host Synchronization

See Also

See Also

See Also

Description

Valid Usage

See Also

See Also

Description

Valid Usage

See Also

Description

Valid Usage

Valid Usage (Implicit)

See Also

Valid Usage

Valid Usage (Implicit)

See Also

Description

Eq VkOffset2D Source #
Instance details Methods (==) :: VkOffset2D -> VkOffset2D -> Bool # (/=) :: VkOffset2D -> VkOffset2D -> Bool #
Show VkOffset2D Source #
Instance details Methods showsPrec :: Int -> VkOffset2D -> ShowS # show :: VkOffset2D -> String # showList :: [VkOffset2D] -> ShowS #
Storable VkOffset2D Source #
Instance details Methods sizeOf :: VkOffset2D -> Int # alignment :: VkOffset2D -> Int # peekElemOff :: Ptr VkOffset2D -> Int -> IO VkOffset2D # pokeElemOff :: Ptr VkOffset2D -> Int -> VkOffset2D -> IO () # peekByteOff :: Ptr b -> Int -> IO VkOffset2D # pokeByteOff :: Ptr b -> Int -> VkOffset2D -> IO () # peek :: Ptr VkOffset2D -> IO VkOffset2D # poke :: Ptr VkOffset2D -> VkOffset2D -> IO () #

VkExtent2D
Fields vkWidth :: Word32 `width` is the width of the extent. vkHeight :: Word32 `height` is the height of the extent.

Eq VkExtent2D Source #
Instance details Methods (==) :: VkExtent2D -> VkExtent2D -> Bool # (/=) :: VkExtent2D -> VkExtent2D -> Bool #
Show VkExtent2D Source #
Instance details Methods showsPrec :: Int -> VkExtent2D -> ShowS # show :: VkExtent2D -> String # showList :: [VkExtent2D] -> ShowS #
Storable VkExtent2D Source #
Instance details Methods sizeOf :: VkExtent2D -> Int # alignment :: VkExtent2D -> Int # peekElemOff :: Ptr VkExtent2D -> Int -> IO VkExtent2D # pokeElemOff :: Ptr VkExtent2D -> Int -> VkExtent2D -> IO () # peekByteOff :: Ptr b -> Int -> IO VkExtent2D # pokeByteOff :: Ptr b -> Int -> VkExtent2D -> IO () # peek :: Ptr VkExtent2D -> IO VkExtent2D # poke :: Ptr VkExtent2D -> VkExtent2D -> IO () #

VkViewport
Fields vkX :: CFloat `x` and `y` are the viewport’s upper left corner (x,y). vkY :: CFloat vkWidth :: CFloat `width` and `height` are the viewport’s width and height, respectively. vkHeight :: CFloat vkMinDepth :: CFloat `minDepth` and `maxDepth` are the depth range for the viewport. It is valid for `minDepth` to be greater than or equal to `maxDepth`. vkMaxDepth :: CFloat

Eq VkViewport Source #
Instance details Methods (==) :: VkViewport -> VkViewport -> Bool # (/=) :: VkViewport -> VkViewport -> Bool #
Show VkViewport Source #
Instance details Methods showsPrec :: Int -> VkViewport -> ShowS # show :: VkViewport -> String # showList :: [VkViewport] -> ShowS #
Storable VkViewport Source #
Instance details Methods sizeOf :: VkViewport -> Int # alignment :: VkViewport -> Int # peekElemOff :: Ptr VkViewport -> Int -> IO VkViewport # pokeElemOff :: Ptr VkViewport -> Int -> VkViewport -> IO () # peekByteOff :: Ptr b -> Int -> IO VkViewport # pokeByteOff :: Ptr b -> Int -> VkViewport -> IO () # peek :: Ptr VkViewport -> IO VkViewport # poke :: Ptr VkViewport -> VkViewport -> IO () #

VkRect2D
Fields vkOffset :: VkOffset2D `offset` is a `VkOffset2D` specifying the rectangle offset. vkExtent :: VkExtent2D `extent` is a `VkExtent2D` specifying the rectangle extent.

Eq VkRect2D Source #
Instance details Methods (==) :: VkRect2D -> VkRect2D -> Bool # (/=) :: VkRect2D -> VkRect2D -> Bool #
Show VkRect2D Source #
Instance details Methods showsPrec :: Int -> VkRect2D -> ShowS # show :: VkRect2D -> String # showList :: [VkRect2D] -> ShowS #
Storable VkRect2D Source #
Instance details Methods sizeOf :: VkRect2D -> Int # alignment :: VkRect2D -> Int # peekElemOff :: Ptr VkRect2D -> Int -> IO VkRect2D # pokeElemOff :: Ptr VkRect2D -> Int -> VkRect2D -> IO () # peekByteOff :: Ptr b -> Int -> IO VkRect2D # pokeByteOff :: Ptr b -> Int -> VkRect2D -> IO () # peek :: Ptr VkRect2D -> IO VkRect2D # poke :: Ptr VkRect2D -> VkRect2D -> IO () #

VkSpecializationMapEntry
Fields vkConstantID :: Word32 `constantID` is the ID of the specialization constant in SPIR-V. vkOffset :: Word32 `offset` is the byte offset of the specialization constant value within the supplied data buffer. vkSize :: CSize `size` is the byte size of the specialization constant value within the supplied data buffer.

Eq VkSpecializationMapEntry Source #
Instance details Methods (==) :: VkSpecializationMapEntry -> VkSpecializationMapEntry -> Bool # (/=) :: VkSpecializationMapEntry -> VkSpecializationMapEntry -> Bool #
Show VkSpecializationMapEntry Source #
Instance details Methods showsPrec :: Int -> VkSpecializationMapEntry -> ShowS # show :: VkSpecializationMapEntry -> String # showList :: [VkSpecializationMapEntry] -> ShowS #
Storable VkSpecializationMapEntry Source #
Instance details Methods sizeOf :: VkSpecializationMapEntry -> Int # alignment :: VkSpecializationMapEntry -> Int # peekElemOff :: Ptr VkSpecializationMapEntry -> Int -> IO VkSpecializationMapEntry # pokeElemOff :: Ptr VkSpecializationMapEntry -> Int -> VkSpecializationMapEntry -> IO () # peekByteOff :: Ptr b -> Int -> IO VkSpecializationMapEntry # pokeByteOff :: Ptr b -> Int -> VkSpecializationMapEntry -> IO () # peek :: Ptr VkSpecializationMapEntry -> IO VkSpecializationMapEntry # poke :: Ptr VkSpecializationMapEntry -> VkSpecializationMapEntry -> IO () #

Eq VkSpecializationInfo Source #
Instance details Methods (==) :: VkSpecializationInfo -> VkSpecializationInfo -> Bool # (/=) :: VkSpecializationInfo -> VkSpecializationInfo -> Bool #
Show VkSpecializationInfo Source #
Instance details Methods showsPrec :: Int -> VkSpecializationInfo -> ShowS # show :: VkSpecializationInfo -> String # showList :: [VkSpecializationInfo] -> ShowS #
Storable VkSpecializationInfo Source #
Instance details Methods sizeOf :: VkSpecializationInfo -> Int # alignment :: VkSpecializationInfo -> Int # peekElemOff :: Ptr VkSpecializationInfo -> Int -> IO VkSpecializationInfo # pokeElemOff :: Ptr VkSpecializationInfo -> Int -> VkSpecializationInfo -> IO () # peekByteOff :: Ptr b -> Int -> IO VkSpecializationInfo # pokeByteOff :: Ptr b -> Int -> VkSpecializationInfo -> IO () # peek :: Ptr VkSpecializationInfo -> IO VkSpecializationInfo # poke :: Ptr VkSpecializationInfo -> VkSpecializationInfo -> IO () #