Safe Haskell	None
Language	Haskell2010

Graphics.Vulkan.Core10.Pipeline

Synopsis

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 | Alpha  |
|                                         | (Sr,Sg,Sb) or     | Blend  |
|                                         | (Dr,Dg,Db)        | 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-Bs | 1-As0  |
|                                         | 0)                |        |
+-----------------------------------------+-------------------+--------+
| @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-As | 1-As0  |
|                                         | 0)                |        |
+-----------------------------------------+-------------------+--------+
| @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_COL | (1-Rc,1-Gc,1-Bc)  | 1-Ac   |
| OR@                                     |                   |        |
+-----------------------------------------+-------------------+--------+
| @VK_BLEND_FACTOR_CONSTANT_ALPHA@        | (Ac,Ac,Ac)        | Ac     |
+-----------------------------------------+-------------------+--------+
| @VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALP | (1-Ac,1-Ac,1-Ac)  | 1-Ac   |
| HA@                                     |                   |        |
+-----------------------------------------+-------------------+--------+
| @VK_BLEND_FACTOR_SRC_ALPHA_SATURATE@    | (f,f,f); f =      | 1      |
|                                         | min(As0,1-Ad)     |        |
+-----------------------------------------+-------------------+--------+
| @VK_BLEND_FACTOR_SRC1_COLOR@            | (Rs1,Gs1,Bs1)     | As1    |
+-----------------------------------------+-------------------+--------+
| @VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR@  | (1-Rs1,1-Gs1,1-Bs | 1-As1  |
|                                         | 1)                |        |
+-----------------------------------------+-------------------+--------+
| @VK_BLEND_FACTOR_SRC1_ALPHA@            | (As1,As1,As1)     | As1    |
+-----------------------------------------+-------------------+--------+
| @VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA@  | (1-As1,1-As1,1-As | 1-As1  |
|                                         | 1)                |        |
+-----------------------------------------+-------------------+--------+

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      |
+===============================+====================+================+
| @VK_BLEND_OP_ADD@             | R = Rs0 × Sr + Rd  | A = As0 × Sa + |
|                               | × Dr               | Ad × Da        |
|                               | G = Gs0 × Sg + Gd  |                |
|                               | × Dg               |                |
|                               | B = Bs0 × Sb + Bd  |                |
|                               | × Db               |                |
+-------------------------------+--------------------+----------------+
| @VK_BLEND_OP_SUBTRACT@        | R = Rs0 × Sr - Rd  | A = As0 × Sa - |
|                               | × Dr               | Ad × Da        |
|                               | G = Gs0 × Sg - Gd  |                |
|                               | × Dg               |                |
|                               | B = Bs0 × Sb - Bd  |                |
|                               | × Db               |                |
+-------------------------------+--------------------+----------------+
| @VK_BLEND_OP_REVERSE_SUBTRACT | R = Rd × Dr - Rs0  | A = Ad × Da -  |
| @                             | × Sr               | As0 × Sa       |
|                               | G = Gd × Dg - Gs0  |                |
|                               | × Sg               |                |
|                               | B = Bd × Db - Bs0  |                |
|                               | × Sb               |                |
+-------------------------------+--------------------+----------------+
| @VK_BLEND_OP_MIN@             | R = min(Rs0,Rd)    | A =            |
|                               | G = min(Gs0,Gd)    | min(As0,Ad)    |
|                               | B = min(Bs0,Bd)    |                |
+-------------------------------+--------------------+----------------+
| @VK_BLEND_OP_MAX@             | R = max(Rs0,Rd)    | A =            |
|                               | G = max(Gs0,Gd)    | max(As0,Ad)    |
|                               | B = max(Bs0,Bd)    |                |
+-------------------------------+--------------------+----------------+

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.

Description

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.

Description

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.

Description

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

Valid Usage

If the geometry shaders feature is not enabled, stage must not be VK_SHADER_STAGE_GEOMETRY_BIT

If the tessellation shaders feature is not enabled, stage must not be VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT
stage must not be VK_SHADER_STAGE_ALL_GRAPHICS, or VK_SHADER_STAGE_ALL
pName must be the name of an OpEntryPoint in module with an execution model that matches stage
If the identified entry point includes any variable in its interface that is declared with the ClipDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxClipDistances
If the identified entry point includes any variable in its interface that is declared with the CullDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxCullDistances
If the identified entry point includes any variables in its interface that are declared with the ClipDistance or CullDistance BuiltIn decoration, those variables must not have array sizes which sum to more than VkPhysicalDeviceLimits::maxCombinedClipAndCullDistances
If the identified entry point includes any variable in its interface that is declared with the SampleMask BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxSampleMaskWords
If stage is VK_SHADER_STAGE_VERTEX_BIT, the identified entry point must not include any input variable in its interface that is decorated with CullDistance
If stage is VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, and the identified entry point has an OpExecutionMode instruction that specifies a patch size with OutputVertices, the patch size must be greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize
If stage is VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction that specifies a maximum output vertex count that is greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxGeometryOutputVertices
If stage is VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction that specifies an invocation count that is greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxGeometryShaderInvocations
If stage is VK_SHADER_STAGE_GEOMETRY_BIT, and the identified entry point writes to Layer for any primitive, it must write the same value to Layer for all vertices of a given primitive
If stage is VK_SHADER_STAGE_GEOMETRY_BIT, and the identified entry point writes to ViewportIndex for any primitive, it must write the same value to ViewportIndex for all vertices of a given primitive
If stage is VK_SHADER_STAGE_FRAGMENT_BIT, the identified entry point must not include any output variables in its interface decorated with CullDistance
If stage is VK_SHADER_STAGE_FRAGMENT_BIT, and the identified entry point writes to FragDepth in any execution path, it must write to FragDepth in all execution paths
If stage is VK_SHADER_STAGE_FRAGMENT_BIT, and the identified entry point writes to FragStencilRefEXT in any execution path, it must write to FragStencilRefEXT in all execution paths

Valid Usage (Implicit)

sType must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO

pNext must be NULL
flags must be 0
stage must be a valid VkShaderStageFlagBits value
module must be a valid VkShaderModule handle
pName must be a null-terminated UTF-8 string
If pSpecializationInfo is not NULL, pSpecializationInfo must be a valid pointer to a valid VkSpecializationInfo structure

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

Valid Usage

binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings

stride must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindingStride

Valid Usage (Implicit)

inputRate must be a valid VkVertexInputRate value

Description

Valid Usage

location must be less than VkPhysicalDeviceLimits::maxVertexInputAttributes

binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings
offset must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributeOffset
format must be allowed as a vertex buffer format, as specified by the VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT flag in VkFormatProperties::bufferFeatures returned by vkGetPhysicalDeviceFormatProperties

Valid Usage (Implicit)

format must be a valid VkFormat value

Description

Valid Usage

vertexBindingDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings

vertexAttributeDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributes
For every binding specified by each element of pVertexAttributeDescriptions, a VkVertexInputBindingDescription must exist in pVertexBindingDescriptions with the same value of binding
All elements of pVertexBindingDescriptions must describe distinct binding numbers
All elements of pVertexAttributeDescriptions must describe distinct attribute locations

Valid Usage (Implicit)

sType must be VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO

pNext must be NULL or a pointer to a valid instance of VkPipelineVertexInputDivisorStateCreateInfoEXT
flags must be 0
If vertexBindingDescriptionCount is not 0, pVertexBindingDescriptions must be a valid pointer to an array of vertexBindingDescriptionCount valid VkVertexInputBindingDescription structures
If vertexAttributeDescriptionCount is not 0, pVertexAttributeDescriptions must be a valid pointer to an array of vertexAttributeDescriptionCount valid VkVertexInputAttributeDescription structures

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

Valid Usage

patchControlPoints must be greater than zero and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize

Valid Usage (Implicit)

sType must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO

pNext must be NULL or a pointer to a valid instance of VkPipelineTessellationDomainOriginStateCreateInfo
flags must be 0

Description

Valid Usage

If the multiple viewports feature is not enabled, viewportCount must be 1

If the multiple viewports feature is not enabled, scissorCount must be 1
viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive
scissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive
scissorCount and viewportCount must be identical
If the viewportWScalingEnable member of a VkPipelineViewportWScalingStateCreateInfoNV structure chained to the pNext chain is VK_TRUE, the viewportCount member of the VkPipelineViewportWScalingStateCreateInfoNV structure must be equal to viewportCount

Valid Usage (Implicit)

sType must be VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_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 VkPipelineViewportSwizzleStateCreateInfoNV or VkPipelineViewportWScalingStateCreateInfoNV
Each sType member in the pNext chain must be unique
flags must be 0
viewportCount must be greater than 0
scissorCount must be greater than 0

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

Valid Usage

If the sample rate shading feature is not enabled, sampleShadingEnable must be VK_FALSE

If the alpha to one feature is not enabled, alphaToOneEnable must be VK_FALSE
minSampleShading must be in the range [0,1]
If the subpass has any color attachments and rasterizationSamples is greater than the number of color samples, then sampleShadingEnable must be VK_FALSE

Valid Usage (Implicit)

sType must be VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_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 VkPipelineCoverageModulationStateCreateInfoNV, VkPipelineCoverageToColorStateCreateInfoNV, or VkPipelineSampleLocationsStateCreateInfoEXT
Each sType member in the pNext chain must be unique
flags must be 0
rasterizationSamples must be a valid VkSampleCountFlagBits value
If pSampleMask is not NULL, pSampleMask must be a valid pointer to an array of \(\\lceil{\\mathit{rasterizationSamples} \\over 32}\\rceil\) VkSampleMask values

Description

Valid Usage

If the dual source blending feature is not enabled, srcColorBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA

If the dual source blending feature is not enabled, dstColorBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
If the dual source blending feature is not enabled, srcAlphaBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
If the dual source blending feature is not enabled, dstAlphaBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
If either of colorBlendOp or alphaBlendOp is an advanced blend operation, then colorBlendOp must equal alphaBlendOp
If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendIndependentBlend is VK_FALSE and colorBlendOp is an advanced blend operation, then colorBlendOp must be the same for all attachments.
If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendIndependentBlend is VK_FALSE and alphaBlendOp is an advanced blend operation, then alphaBlendOp must be the same for all attachments.
If VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendAllOperations is VK_FALSE, then colorBlendOp must not be VK_BLEND_OP_ZERO_EXT, VK_BLEND_OP_SRC_EXT, VK_BLEND_OP_DST_EXT, VK_BLEND_OP_SRC_OVER_EXT, VK_BLEND_OP_DST_OVER_EXT, VK_BLEND_OP_SRC_IN_EXT, VK_BLEND_OP_DST_IN_EXT, VK_BLEND_OP_SRC_OUT_EXT, VK_BLEND_OP_DST_OUT_EXT, VK_BLEND_OP_SRC_ATOP_EXT, VK_BLEND_OP_DST_ATOP_EXT, VK_BLEND_OP_XOR_EXT, VK_BLEND_OP_INVERT_EXT, VK_BLEND_OP_INVERT_RGB_EXT, VK_BLEND_OP_LINEARDODGE_EXT, VK_BLEND_OP_LINEARBURN_EXT, VK_BLEND_OP_VIVIDLIGHT_EXT, VK_BLEND_OP_LINEARLIGHT_EXT, VK_BLEND_OP_PINLIGHT_EXT, VK_BLEND_OP_HARDMIX_EXT, VK_BLEND_OP_PLUS_EXT, VK_BLEND_OP_PLUS_CLAMPED_EXT, VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, VK_BLEND_OP_PLUS_DARKER_EXT, VK_BLEND_OP_MINUS_EXT, VK_BLEND_OP_MINUS_CLAMPED_EXT, VK_BLEND_OP_CONTRAST_EXT, VK_BLEND_OP_INVERT_OVG_EXT, VK_BLEND_OP_RED_EXT, VK_BLEND_OP_GREEN_EXT, or VK_BLEND_OP_BLUE_EXT
If colorBlendOp or alphaBlendOp is an advanced blend operation, then VkSubpassDescription::colorAttachmentCount of the subpass this pipeline is compiled against must be less than or equal to VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::advancedBlendMaxColorAttachments

Valid Usage (Implicit)

srcColorBlendFactor must be a valid VkBlendFactor value

dstColorBlendFactor must be a valid VkBlendFactor value
colorBlendOp must be a valid VkBlendOp value
srcAlphaBlendFactor must be a valid VkBlendFactor value
dstAlphaBlendFactor must be a valid VkBlendFactor value
alphaBlendOp must be a valid VkBlendOp value
colorWriteMask must be a valid combination of VkColorComponentFlagBits values

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

Valid Usage

Each element of pDynamicStates must be unique

Valid Usage (Implicit)

sType must be VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO

pNext must be NULL
flags must be 0
pDynamicStates must be a valid pointer to an array of dynamicStateCount valid VkDynamicState values
dynamicStateCount must be greater than 0

Description

Valid Usage (Implicit)

failOp must be a valid VkStencilOp value

passOp must be a valid VkStencilOp value
depthFailOp must be a valid VkStencilOp value
compareOp must be a valid VkCompareOp value

Description

Valid Usage

If the depth bounds testing feature is not enabled, depthBoundsTestEnable must be VK_FALSE

Valid Usage (Implicit)

sType must be VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO

pNext must be NULL
flags must be 0
depthCompareOp must be a valid VkCompareOp value
front must be a valid VkStencilOpState structure
back must be a valid VkStencilOpState structure

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 #
Methods (==) :: VkBlendFactor -> VkBlendFactor -> Bool # (/=) :: VkBlendFactor -> VkBlendFactor -> Bool #
Ord VkBlendFactor Source #
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 #
Methods readsPrec :: Int -> ReadS VkBlendFactor # readList :: ReadS [VkBlendFactor] # readPrec :: ReadPrec VkBlendFactor # readListPrec :: ReadPrec [VkBlendFactor] #
Show VkBlendFactor Source #
Methods showsPrec :: Int -> VkBlendFactor -> ShowS # show :: VkBlendFactor -> String # showList :: [VkBlendFactor] -> ShowS #
Storable VkBlendFactor Source #
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 #
Methods (==) :: VkBlendOp -> VkBlendOp -> Bool # (/=) :: VkBlendOp -> VkBlendOp -> Bool #
Ord VkBlendOp Source #
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 #
Methods readsPrec :: Int -> ReadS VkBlendOp # readList :: ReadS [VkBlendOp] # readPrec :: ReadPrec VkBlendOp # readListPrec :: ReadPrec [VkBlendOp] #
Show VkBlendOp Source #
Methods showsPrec :: Int -> VkBlendOp -> ShowS # show :: VkBlendOp -> String # showList :: [VkBlendOp] -> ShowS #
Storable VkBlendOp Source #
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 #
Methods (==) :: VkCompareOp -> VkCompareOp -> Bool # (/=) :: VkCompareOp -> VkCompareOp -> Bool #
Ord VkCompareOp Source #
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 #
Methods readsPrec :: Int -> ReadS VkCompareOp # readList :: ReadS [VkCompareOp] # readPrec :: ReadPrec VkCompareOp # readListPrec :: ReadPrec [VkCompareOp] #
Show VkCompareOp Source #
Methods showsPrec :: Int -> VkCompareOp -> ShowS # show :: VkCompareOp -> String # showList :: [VkCompareOp] -> ShowS #
Storable VkCompareOp Source #
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 #
Methods (==) :: VkDynamicState -> VkDynamicState -> Bool # (/=) :: VkDynamicState -> VkDynamicState -> Bool #
Ord VkDynamicState Source #
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 #
Methods readsPrec :: Int -> ReadS VkDynamicState # readList :: ReadS [VkDynamicState] # readPrec :: ReadPrec VkDynamicState # readListPrec :: ReadPrec [VkDynamicState] #
Show VkDynamicState Source #
Methods showsPrec :: Int -> VkDynamicState -> ShowS # show :: VkDynamicState -> String # showList :: [VkDynamicState] -> ShowS #
Storable VkDynamicState Source #
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 #
Methods (==) :: VkPolygonMode -> VkPolygonMode -> Bool # (/=) :: VkPolygonMode -> VkPolygonMode -> Bool #
Ord VkPolygonMode Source #
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 #
Methods readsPrec :: Int -> ReadS VkPolygonMode # readList :: ReadS [VkPolygonMode] # readPrec :: ReadPrec VkPolygonMode # readListPrec :: ReadPrec [VkPolygonMode] #
Show VkPolygonMode Source #
Methods showsPrec :: Int -> VkPolygonMode -> ShowS # show :: VkPolygonMode -> String # showList :: [VkPolygonMode] -> ShowS #
Storable VkPolygonMode Source #
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 #
Methods (==) :: VkFrontFace -> VkFrontFace -> Bool # (/=) :: VkFrontFace -> VkFrontFace -> Bool #
Ord VkFrontFace Source #
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 #
Methods readsPrec :: Int -> ReadS VkFrontFace # readList :: ReadS [VkFrontFace] # readPrec :: ReadPrec VkFrontFace # readListPrec :: ReadPrec [VkFrontFace] #
Show VkFrontFace Source #
Methods showsPrec :: Int -> VkFrontFace -> ShowS # show :: VkFrontFace -> String # showList :: [VkFrontFace] -> ShowS #
Storable VkFrontFace Source #
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 #
Methods (==) :: VkLogicOp -> VkLogicOp -> Bool # (/=) :: VkLogicOp -> VkLogicOp -> Bool #
Ord VkLogicOp Source #
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 #
Methods readsPrec :: Int -> ReadS VkLogicOp # readList :: ReadS [VkLogicOp] # readPrec :: ReadPrec VkLogicOp # readListPrec :: ReadPrec [VkLogicOp] #
Show VkLogicOp Source #
Methods showsPrec :: Int -> VkLogicOp -> ShowS # show :: VkLogicOp -> String # showList :: [VkLogicOp] -> ShowS #
Storable VkLogicOp Source #
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 #
Methods (==) :: VkPrimitiveTopology -> VkPrimitiveTopology -> Bool # (/=) :: VkPrimitiveTopology -> VkPrimitiveTopology -> Bool #
Ord VkPrimitiveTopology Source #
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 #
Methods readsPrec :: Int -> ReadS VkPrimitiveTopology # readList :: ReadS [VkPrimitiveTopology] # readPrec :: ReadPrec VkPrimitiveTopology # readListPrec :: ReadPrec [VkPrimitiveTopology] #
Show VkPrimitiveTopology Source #
Methods showsPrec :: Int -> VkPrimitiveTopology -> ShowS # show :: VkPrimitiveTopology -> String # showList :: [VkPrimitiveTopology] -> ShowS #
Storable VkPrimitiveTopology Source #
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 #
Methods (==) :: VkStencilOp -> VkStencilOp -> Bool # (/=) :: VkStencilOp -> VkStencilOp -> Bool #
Ord VkStencilOp Source #
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 #
Methods readsPrec :: Int -> ReadS VkStencilOp # readList :: ReadS [VkStencilOp] # readPrec :: ReadPrec VkStencilOp # readListPrec :: ReadPrec [VkStencilOp] #
Show VkStencilOp Source #
Methods showsPrec :: Int -> VkStencilOp -> ShowS # show :: VkStencilOp -> String # showList :: [VkStencilOp] -> ShowS #
Storable VkStencilOp Source #
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 #
Methods (==) :: VkVertexInputRate -> VkVertexInputRate -> Bool # (/=) :: VkVertexInputRate -> VkVertexInputRate -> Bool #
Ord VkVertexInputRate Source #
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 #
Methods readsPrec :: Int -> ReadS VkVertexInputRate # readList :: ReadS [VkVertexInputRate] # readPrec :: ReadPrec VkVertexInputRate # readListPrec :: ReadPrec [VkVertexInputRate] #
Show VkVertexInputRate Source #
Methods showsPrec :: Int -> VkVertexInputRate -> ShowS # show :: VkVertexInputRate -> String # showList :: [VkVertexInputRate] -> ShowS #
Storable VkVertexInputRate Source #
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 #
Methods (==) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> Bool # (/=) :: VkPipelineDepthStencilStateCreateFlags -> VkPipelineDepthStencilStateCreateFlags -> Bool #
Ord VkPipelineDepthStencilStateCreateFlags Source #
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 #
Methods readsPrec :: Int -> ReadS VkPipelineDepthStencilStateCreateFlags # readList :: ReadS [VkPipelineDepthStencilStateCreateFlags] # readPrec :: ReadPrec VkPipelineDepthStencilStateCreateFlags # readListPrec :: ReadPrec [VkPipelineDepthStencilStateCreateFlags] #
Show VkPipelineDepthStencilStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineDepthStencilStateCreateFlags -> ShowS # show :: VkPipelineDepthStencilStateCreateFlags -> String # showList :: [VkPipelineDepthStencilStateCreateFlags] -> ShowS #
Storable VkPipelineDepthStencilStateCreateFlags Source #
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 #
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 #
Methods finiteBitSize :: VkPipelineDepthStencilStateCreateFlags -> Int # countLeadingZeros :: VkPipelineDepthStencilStateCreateFlags -> Int # countTrailingZeros :: VkPipelineDepthStencilStateCreateFlags -> Int #

Eq VkPipelineDynamicStateCreateFlags Source #
Methods (==) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> Bool # (/=) :: VkPipelineDynamicStateCreateFlags -> VkPipelineDynamicStateCreateFlags -> Bool #
Ord VkPipelineDynamicStateCreateFlags Source #
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 #
Methods readsPrec :: Int -> ReadS VkPipelineDynamicStateCreateFlags # readList :: ReadS [VkPipelineDynamicStateCreateFlags] # readPrec :: ReadPrec VkPipelineDynamicStateCreateFlags # readListPrec :: ReadPrec [VkPipelineDynamicStateCreateFlags] #
Show VkPipelineDynamicStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineDynamicStateCreateFlags -> ShowS # show :: VkPipelineDynamicStateCreateFlags -> String # showList :: [VkPipelineDynamicStateCreateFlags] -> ShowS #
Storable VkPipelineDynamicStateCreateFlags Source #
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 #
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 #
Methods finiteBitSize :: VkPipelineDynamicStateCreateFlags -> Int # countLeadingZeros :: VkPipelineDynamicStateCreateFlags -> Int # countTrailingZeros :: VkPipelineDynamicStateCreateFlags -> Int #

Eq VkPipelineColorBlendStateCreateFlags Source #
Methods (==) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> Bool # (/=) :: VkPipelineColorBlendStateCreateFlags -> VkPipelineColorBlendStateCreateFlags -> Bool #
Ord VkPipelineColorBlendStateCreateFlags Source #
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 #
Methods readsPrec :: Int -> ReadS VkPipelineColorBlendStateCreateFlags # readList :: ReadS [VkPipelineColorBlendStateCreateFlags] # readPrec :: ReadPrec VkPipelineColorBlendStateCreateFlags # readListPrec :: ReadPrec [VkPipelineColorBlendStateCreateFlags] #
Show VkPipelineColorBlendStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineColorBlendStateCreateFlags -> ShowS # show :: VkPipelineColorBlendStateCreateFlags -> String # showList :: [VkPipelineColorBlendStateCreateFlags] -> ShowS #
Storable VkPipelineColorBlendStateCreateFlags Source #
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 #
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 #
Methods finiteBitSize :: VkPipelineColorBlendStateCreateFlags -> Int # countLeadingZeros :: VkPipelineColorBlendStateCreateFlags -> Int # countTrailingZeros :: VkPipelineColorBlendStateCreateFlags -> Int #

Eq VkPipelineMultisampleStateCreateFlags Source #
Methods (==) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> Bool # (/=) :: VkPipelineMultisampleStateCreateFlags -> VkPipelineMultisampleStateCreateFlags -> Bool #
Ord VkPipelineMultisampleStateCreateFlags Source #
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 #
Methods readsPrec :: Int -> ReadS VkPipelineMultisampleStateCreateFlags # readList :: ReadS [VkPipelineMultisampleStateCreateFlags] # readPrec :: ReadPrec VkPipelineMultisampleStateCreateFlags # readListPrec :: ReadPrec [VkPipelineMultisampleStateCreateFlags] #
Show VkPipelineMultisampleStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineMultisampleStateCreateFlags -> ShowS # show :: VkPipelineMultisampleStateCreateFlags -> String # showList :: [VkPipelineMultisampleStateCreateFlags] -> ShowS #
Storable VkPipelineMultisampleStateCreateFlags Source #
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 #
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 #
Methods finiteBitSize :: VkPipelineMultisampleStateCreateFlags -> Int # countLeadingZeros :: VkPipelineMultisampleStateCreateFlags -> Int # countTrailingZeros :: VkPipelineMultisampleStateCreateFlags -> Int #

Eq VkPipelineRasterizationStateCreateFlags Source #
Methods (==) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> Bool # (/=) :: VkPipelineRasterizationStateCreateFlags -> VkPipelineRasterizationStateCreateFlags -> Bool #
Ord VkPipelineRasterizationStateCreateFlags Source #
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 #
Methods readsPrec :: Int -> ReadS VkPipelineRasterizationStateCreateFlags # readList :: ReadS [VkPipelineRasterizationStateCreateFlags] # readPrec :: ReadPrec VkPipelineRasterizationStateCreateFlags # readListPrec :: ReadPrec [VkPipelineRasterizationStateCreateFlags] #
Show VkPipelineRasterizationStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineRasterizationStateCreateFlags -> ShowS # show :: VkPipelineRasterizationStateCreateFlags -> String # showList :: [VkPipelineRasterizationStateCreateFlags] -> ShowS #
Storable VkPipelineRasterizationStateCreateFlags Source #
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 #
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 #
Methods finiteBitSize :: VkPipelineRasterizationStateCreateFlags -> Int # countLeadingZeros :: VkPipelineRasterizationStateCreateFlags -> Int # countTrailingZeros :: VkPipelineRasterizationStateCreateFlags -> Int #

Eq VkPipelineViewportStateCreateFlags Source #
Methods (==) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> Bool # (/=) :: VkPipelineViewportStateCreateFlags -> VkPipelineViewportStateCreateFlags -> Bool #
Ord VkPipelineViewportStateCreateFlags Source #
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 #
Methods readsPrec :: Int -> ReadS VkPipelineViewportStateCreateFlags # readList :: ReadS [VkPipelineViewportStateCreateFlags] # readPrec :: ReadPrec VkPipelineViewportStateCreateFlags # readListPrec :: ReadPrec [VkPipelineViewportStateCreateFlags] #
Show VkPipelineViewportStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineViewportStateCreateFlags -> ShowS # show :: VkPipelineViewportStateCreateFlags -> String # showList :: [VkPipelineViewportStateCreateFlags] -> ShowS #
Storable VkPipelineViewportStateCreateFlags Source #
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 #
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 #
Methods finiteBitSize :: VkPipelineViewportStateCreateFlags -> Int # countLeadingZeros :: VkPipelineViewportStateCreateFlags -> Int # countTrailingZeros :: VkPipelineViewportStateCreateFlags -> Int #

Eq VkPipelineTessellationStateCreateFlags Source #
Methods (==) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> Bool # (/=) :: VkPipelineTessellationStateCreateFlags -> VkPipelineTessellationStateCreateFlags -> Bool #
Ord VkPipelineTessellationStateCreateFlags Source #
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 #
Methods readsPrec :: Int -> ReadS VkPipelineTessellationStateCreateFlags # readList :: ReadS [VkPipelineTessellationStateCreateFlags] # readPrec :: ReadPrec VkPipelineTessellationStateCreateFlags # readListPrec :: ReadPrec [VkPipelineTessellationStateCreateFlags] #
Show VkPipelineTessellationStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineTessellationStateCreateFlags -> ShowS # show :: VkPipelineTessellationStateCreateFlags -> String # showList :: [VkPipelineTessellationStateCreateFlags] -> ShowS #
Storable VkPipelineTessellationStateCreateFlags Source #
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 #
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 #
Methods finiteBitSize :: VkPipelineTessellationStateCreateFlags -> Int # countLeadingZeros :: VkPipelineTessellationStateCreateFlags -> Int # countTrailingZeros :: VkPipelineTessellationStateCreateFlags -> Int #

Eq VkPipelineInputAssemblyStateCreateFlags Source #
Methods (==) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> Bool # (/=) :: VkPipelineInputAssemblyStateCreateFlags -> VkPipelineInputAssemblyStateCreateFlags -> Bool #
Ord VkPipelineInputAssemblyStateCreateFlags Source #
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 #
Methods readsPrec :: Int -> ReadS VkPipelineInputAssemblyStateCreateFlags # readList :: ReadS [VkPipelineInputAssemblyStateCreateFlags] # readPrec :: ReadPrec VkPipelineInputAssemblyStateCreateFlags # readListPrec :: ReadPrec [VkPipelineInputAssemblyStateCreateFlags] #
Show VkPipelineInputAssemblyStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineInputAssemblyStateCreateFlags -> ShowS # show :: VkPipelineInputAssemblyStateCreateFlags -> String # showList :: [VkPipelineInputAssemblyStateCreateFlags] -> ShowS #
Storable VkPipelineInputAssemblyStateCreateFlags Source #
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 #
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 #
Methods finiteBitSize :: VkPipelineInputAssemblyStateCreateFlags -> Int # countLeadingZeros :: VkPipelineInputAssemblyStateCreateFlags -> Int # countTrailingZeros :: VkPipelineInputAssemblyStateCreateFlags -> Int #

Eq VkPipelineVertexInputStateCreateFlags Source #
Methods (==) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> Bool # (/=) :: VkPipelineVertexInputStateCreateFlags -> VkPipelineVertexInputStateCreateFlags -> Bool #
Ord VkPipelineVertexInputStateCreateFlags Source #
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 #
Methods readsPrec :: Int -> ReadS VkPipelineVertexInputStateCreateFlags # readList :: ReadS [VkPipelineVertexInputStateCreateFlags] # readPrec :: ReadPrec VkPipelineVertexInputStateCreateFlags # readListPrec :: ReadPrec [VkPipelineVertexInputStateCreateFlags] #
Show VkPipelineVertexInputStateCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineVertexInputStateCreateFlags -> ShowS # show :: VkPipelineVertexInputStateCreateFlags -> String # showList :: [VkPipelineVertexInputStateCreateFlags] -> ShowS #
Storable VkPipelineVertexInputStateCreateFlags Source #
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 #
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 #
Methods finiteBitSize :: VkPipelineVertexInputStateCreateFlags -> Int # countLeadingZeros :: VkPipelineVertexInputStateCreateFlags -> Int # countTrailingZeros :: VkPipelineVertexInputStateCreateFlags -> Int #

Eq VkPipelineShaderStageCreateFlags Source #
Methods (==) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> Bool # (/=) :: VkPipelineShaderStageCreateFlags -> VkPipelineShaderStageCreateFlags -> Bool #
Ord VkPipelineShaderStageCreateFlags Source #
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 #
Methods readsPrec :: Int -> ReadS VkPipelineShaderStageCreateFlags # readList :: ReadS [VkPipelineShaderStageCreateFlags] # readPrec :: ReadPrec VkPipelineShaderStageCreateFlags # readListPrec :: ReadPrec [VkPipelineShaderStageCreateFlags] #
Show VkPipelineShaderStageCreateFlags Source #
Methods showsPrec :: Int -> VkPipelineShaderStageCreateFlags -> ShowS # show :: VkPipelineShaderStageCreateFlags -> String # showList :: [VkPipelineShaderStageCreateFlags] -> ShowS #
Storable VkPipelineShaderStageCreateFlags Source #
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 #
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 #
Methods finiteBitSize :: VkPipelineShaderStageCreateFlags -> Int # countLeadingZeros :: VkPipelineShaderStageCreateFlags -> Int # countTrailingZeros :: VkPipelineShaderStageCreateFlags -> Int #

Eq VkShaderStageFlagBits Source #
Methods (==) :: VkShaderStageFlagBits -> VkShaderStageFlagBits -> Bool # (/=) :: VkShaderStageFlagBits -> VkShaderStageFlagBits -> Bool #
Ord VkShaderStageFlagBits Source #
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 #
Methods readsPrec :: Int -> ReadS VkShaderStageFlagBits # readList :: ReadS [VkShaderStageFlagBits] # readPrec :: ReadPrec VkShaderStageFlagBits # readListPrec :: ReadPrec [VkShaderStageFlagBits] #
Show VkShaderStageFlagBits Source #
Methods showsPrec :: Int -> VkShaderStageFlagBits -> ShowS # show :: VkShaderStageFlagBits -> String # showList :: [VkShaderStageFlagBits] -> ShowS #
Storable VkShaderStageFlagBits Source #
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 #
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 #
Methods finiteBitSize :: VkShaderStageFlagBits -> Int # countLeadingZeros :: VkShaderStageFlagBits -> Int # countTrailingZeros :: VkShaderStageFlagBits -> Int #

Eq VkPipelineCreateFlagBits Source #
Methods (==) :: VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits -> Bool # (/=) :: VkPipelineCreateFlagBits -> VkPipelineCreateFlagBits -> Bool #
Ord VkPipelineCreateFlagBits Source #
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 #
Methods readsPrec :: Int -> ReadS VkPipelineCreateFlagBits # readList :: ReadS [VkPipelineCreateFlagBits] # readPrec :: ReadPrec VkPipelineCreateFlagBits # readListPrec :: ReadPrec [VkPipelineCreateFlagBits] #
Show VkPipelineCreateFlagBits Source #
Methods showsPrec :: Int -> VkPipelineCreateFlagBits -> ShowS # show :: VkPipelineCreateFlagBits -> String # showList :: [VkPipelineCreateFlagBits] -> ShowS #
Storable VkPipelineCreateFlagBits Source #
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 #
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 #
Methods finiteBitSize :: VkPipelineCreateFlagBits -> Int # countLeadingZeros :: VkPipelineCreateFlagBits -> Int # countTrailingZeros :: VkPipelineCreateFlagBits -> Int #

Eq VkColorComponentFlagBits Source #
Methods (==) :: VkColorComponentFlagBits -> VkColorComponentFlagBits -> Bool # (/=) :: VkColorComponentFlagBits -> VkColorComponentFlagBits -> Bool #
Ord VkColorComponentFlagBits Source #
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 #
Methods readsPrec :: Int -> ReadS VkColorComponentFlagBits # readList :: ReadS [VkColorComponentFlagBits] # readPrec :: ReadPrec VkColorComponentFlagBits # readListPrec :: ReadPrec [VkColorComponentFlagBits] #
Show VkColorComponentFlagBits Source #
Methods showsPrec :: Int -> VkColorComponentFlagBits -> ShowS # show :: VkColorComponentFlagBits -> String # showList :: [VkColorComponentFlagBits] -> ShowS #
Storable VkColorComponentFlagBits Source #
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 #
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 #
Methods finiteBitSize :: VkColorComponentFlagBits -> Int # countLeadingZeros :: VkColorComponentFlagBits -> Int # countTrailingZeros :: VkColorComponentFlagBits -> Int #

Eq VkCullModeFlagBits Source #
Methods (==) :: VkCullModeFlagBits -> VkCullModeFlagBits -> Bool # (/=) :: VkCullModeFlagBits -> VkCullModeFlagBits -> Bool #
Ord VkCullModeFlagBits Source #
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 #
Methods readsPrec :: Int -> ReadS VkCullModeFlagBits # readList :: ReadS [VkCullModeFlagBits] # readPrec :: ReadPrec VkCullModeFlagBits # readListPrec :: ReadPrec [VkCullModeFlagBits] #
Show VkCullModeFlagBits Source #
Methods showsPrec :: Int -> VkCullModeFlagBits -> ShowS # show :: VkCullModeFlagBits -> String # showList :: [VkCullModeFlagBits] -> ShowS #
Storable VkCullModeFlagBits Source #
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 #
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 #
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

Description

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

Description

See Also

Description

See Also

Description

See Also

Parameters

Description

Valid Usage

Valid Usage (Implicit)

Return Codes

See Also

Parameters

Description

Valid Usage

Valid Usage (Implicit)

Return Codes

See Also

Parameters

Description

Valid Usage

Valid Usage (Implicit)

Host Synchronization

See Also

Description

See Also

Description

See Also

Description

Valid Usage

See Also

Description

See Also

Description

Valid Usage

Eq VkOffset2D Source #
Methods (==) :: VkOffset2D -> VkOffset2D -> Bool # (/=) :: VkOffset2D -> VkOffset2D -> Bool #
Show VkOffset2D Source #
Methods showsPrec :: Int -> VkOffset2D -> ShowS # show :: VkOffset2D -> String # showList :: [VkOffset2D] -> ShowS #
Storable VkOffset2D Source #
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 #
Methods (==) :: VkExtent2D -> VkExtent2D -> Bool # (/=) :: VkExtent2D -> VkExtent2D -> Bool #
Show VkExtent2D Source #
Methods showsPrec :: Int -> VkExtent2D -> ShowS # show :: VkExtent2D -> String # showList :: [VkExtent2D] -> ShowS #
Storable VkExtent2D Source #
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 #
Methods (==) :: VkViewport -> VkViewport -> Bool # (/=) :: VkViewport -> VkViewport -> Bool #
Show VkViewport Source #
Methods showsPrec :: Int -> VkViewport -> ShowS # show :: VkViewport -> String # showList :: [VkViewport] -> ShowS #
Storable VkViewport Source #
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 #
Methods (==) :: VkRect2D -> VkRect2D -> Bool # (/=) :: VkRect2D -> VkRect2D -> Bool #
Show VkRect2D Source #
Methods showsPrec :: Int -> VkRect2D -> ShowS # show :: VkRect2D -> String # showList :: [VkRect2D] -> ShowS #
Storable VkRect2D Source #
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 #
Methods (==) :: VkSpecializationMapEntry -> VkSpecializationMapEntry -> Bool # (/=) :: VkSpecializationMapEntry -> VkSpecializationMapEntry -> Bool #
Show VkSpecializationMapEntry Source #
Methods showsPrec :: Int -> VkSpecializationMapEntry -> ShowS # show :: VkSpecializationMapEntry -> String # showList :: [VkSpecializationMapEntry] -> ShowS #
Storable VkSpecializationMapEntry Source #
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 #
Methods (==) :: VkSpecializationInfo -> VkSpecializationInfo -> Bool # (/=) :: VkSpecializationInfo -> VkSpecializationInfo -> Bool #
Show VkSpecializationInfo Source #
Methods showsPrec :: Int -> VkSpecializationInfo -> ShowS # show :: VkSpecializationInfo -> String # showList :: [VkSpecializationInfo] -> ShowS #
Storable VkSpecializationInfo Source #
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 () #