Vulkan.Extensions.VK_EXT_shader_object

Name

VK_EXT_shader_object - device extension

VK_EXT_shader_object

Name String

VK_EXT_shader_object

Extension Type

Device extension

Registered Extension Number

483

Revision

1

Ratification Status

Ratified

Extension and Version Dependencies

VK_KHR_get_physical_device_properties2      or

Version 1.1 and

VK_KHR_dynamic_rendering      or

Version 1.3

Contact

• Daniel Story @daniel-story%0A*Here describe the issue or question you have about the VK_EXT_shader_object extension*

Extension Proposal

VK_EXT_shader_object

Other Extension Metadata

Last Modified Date

2023-03-30

Interactions and External Dependencies

• Interacts with VK_EXT_extended_dynamic_state
• Interacts with VK_EXT_extended_dynamic_state2
• Interacts with VK_EXT_extended_dynamic_state3
• Interacts with VK_EXT_vertex_input_dynamic_state

IP Status

No known IP claims.

Contributors

• Piers Daniell, NVIDIA
• Sandy Jamieson, Nintendo
• Žiga Markuš, LunarG
• Tobias Hector, AMD
• Alex Walters, Imagination
• Shahbaz Youssefi, Google
• Ralph Potter, Samsung
• Jan-Harald Fredriksen, ARM
• Connor Abott, Valve
• Arseny Kapoulkine, Roblox
• Patrick Doane, Activision
• Jeff Leger, Qualcomm
• Stu Smith, AMD
• Chris Glover, Google
• Ricardo Garcia, Igalia
• Faith Ekstrand, Collabora
• Timur Kristóf, Valve
• Constantine Shablya, Collabora
• Daniel Koch, NVIDIA
• Alyssa Rosenzweig, Collabora
• Mike Blumenkrantz, Valve
• Samuel Pitoiset, Valve
• Qun Lin, AMD
• Spencer Fricke, LunarG
• Soroush Faghihi Kashani, Imagination

Description

This extension introduces a new ShaderEXT object type which represents a single compiled shader stage. Shader objects provide a more flexible alternative to Pipeline objects, which may be helpful in certain use cases.

New Object Types

• ShaderEXT

New Commands

• cmdBindShadersEXT

• cmdBindVertexBuffers2EXT
• cmdSetAlphaToCoverageEnableEXT
• cmdSetAlphaToOneEnableEXT
• cmdSetColorBlendAdvancedEXT
• cmdSetColorBlendEnableEXT
• cmdSetColorBlendEquationEXT
• cmdSetColorWriteMaskEXT
• cmdSetConservativeRasterizationModeEXT
• cmdSetCullModeEXT
• cmdSetDepthBiasEnableEXT
• cmdSetDepthBoundsTestEnableEXT
• cmdSetDepthClampEnableEXT
• cmdSetDepthClipEnableEXT
• cmdSetDepthClipNegativeOneToOneEXT
• cmdSetDepthCompareOpEXT
• cmdSetDepthTestEnableEXT
• cmdSetDepthWriteEnableEXT
• cmdSetExtraPrimitiveOverestimationSizeEXT
• cmdSetFrontFaceEXT
• cmdSetLineRasterizationModeEXT
• cmdSetLineStippleEnableEXT
• cmdSetLogicOpEXT
• cmdSetLogicOpEnableEXT
• cmdSetPatchControlPointsEXT
• cmdSetPolygonModeEXT
• cmdSetPrimitiveRestartEnableEXT
• cmdSetPrimitiveTopologyEXT
• cmdSetProvokingVertexModeEXT
• cmdSetRasterizationSamplesEXT
• cmdSetRasterizationStreamEXT
• cmdSetRasterizerDiscardEnableEXT
• cmdSetSampleLocationsEnableEXT
• cmdSetSampleMaskEXT
• cmdSetScissorWithCountEXT
• cmdSetStencilOpEXT
• cmdSetStencilTestEnableEXT
• cmdSetTessellationDomainOriginEXT
• cmdSetVertexInputEXT
• cmdSetViewportWithCountEXT
• createShadersEXT
• destroyShaderEXT
• getShaderBinaryDataEXT

If VK_NV_clip_space_w_scaling is supported:

• cmdSetViewportWScalingEnableNV

If VK_NV_coverage_reduction_mode is supported:

• cmdSetCoverageReductionModeNV

If VK_NV_fragment_coverage_to_color is supported:

• cmdSetCoverageToColorEnableNV
• cmdSetCoverageToColorLocationNV

If VK_NV_framebuffer_mixed_samples is supported:

• cmdSetCoverageModulationModeNV
• cmdSetCoverageModulationTableEnableNV
• cmdSetCoverageModulationTableNV

If VK_NV_representative_fragment_test is supported:

• cmdSetRepresentativeFragmentTestEnableNV

If VK_NV_shading_rate_image is supported:

• cmdSetShadingRateImageEnableNV

If VK_NV_viewport_swizzle is supported:

• cmdSetViewportSwizzleNV

New Structures

• ColorBlendAdvancedEXT

• ColorBlendEquationEXT
• ShaderCreateInfoEXT
• VertexInputAttributeDescription2EXT
• VertexInputBindingDescription2EXT

• Extending PhysicalDeviceFeatures2, DeviceCreateInfo:

  • PhysicalDeviceShaderObjectFeaturesEXT

• Extending PhysicalDeviceProperties2:

  • PhysicalDeviceShaderObjectPropertiesEXT

• Extending PipelineShaderStageCreateInfo, ShaderCreateInfoEXT:

  • ShaderRequiredSubgroupSizeCreateInfoEXT

New Enums

• ShaderCodeTypeEXT

• ShaderCreateFlagBitsEXT

New Bitmasks

• ShaderCreateFlagsEXT

New Enum Constants

• EXT_SHADER_OBJECT_EXTENSION_NAME

• EXT_SHADER_OBJECT_SPEC_VERSION

• Extending ObjectType:

  • OBJECT_TYPE_SHADER_EXT

• Extending Result:

  • ERROR_INCOMPATIBLE_SHADER_BINARY_EXT

• Extending StructureType:

  • STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT
  • STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT
  • STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT
  • STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT
  • STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT
  • STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT

If VK_EXT_fragment_density_map is supported:

• Extending ShaderCreateFlagBitsEXT:

  • SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT

If VK_EXT_mesh_shader or VK_NV_mesh_shader is supported:

• Extending ShaderCreateFlagBitsEXT:

  • SHADER_CREATE_NO_TASK_SHADER_BIT_EXT

If VK_EXT_subgroup_size_control or Version 1.3 is supported:

• Extending ShaderCreateFlagBitsEXT:

  • SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT
  • SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT

If VK_KHR_device_group or Version 1.1 is supported:

• Extending ShaderCreateFlagBitsEXT:

  • SHADER_CREATE_DISPATCH_BASE_BIT_EXT

If VK_KHR_fragment_shading_rate is supported:

• Extending ShaderCreateFlagBitsEXT:

  • SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT

Examples

Example 1

Create linked pair of vertex and fragment shaders.

// Logical device created with the shaderObject feature enabled
VkDevice device;

// SPIR-V shader code for a vertex shader, along with its size in bytes
void* pVertexSpirv;
size_t vertexSpirvSize;

// SPIR-V shader code for a fragment shader, along with its size in bytes
void* pFragmentSpirv;
size_t fragmentSpirvSize;

// Descriptor set layout compatible with the shaders
VkDescriptorSetLayout descriptorSetLayout;

VkShaderCreateInfoEXT shaderCreateInfos[2] =
{
    {
        .sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT,
        .pNext = NULL,
        .flags = VK_SHADER_CREATE_LINK_STAGE_BIT_EXT,
        .stage = VK_SHADER_STAGE_VERTEX_BIT,
        .nextStage = VK_SHADER_STAGE_FRAGMENT_BIT,
        .codeType = VK_SHADER_CODE_TYPE_SPIRV_EXT,
        .codeSize = vertexSpirvSize,
        .pCode = pVertexSpirv,
        .pName = "main",
        .setLayoutCount = 1,
        .pSetLayouts = &descriptorSetLayout;
        .pushConstantRangeCount = 0,
        .pPushConstantRanges = NULL,
        .pSpecializationInfo = NULL
    },
    {
        .sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT,
        .pNext = NULL,
        .flags = VK_SHADER_CREATE_LINK_STAGE_BIT_EXT,
        .stage = VK_SHADER_STAGE_FRAGMENT_BIT,
        .nextStage = 0,
        .codeType = VK_SHADER_CODE_TYPE_SPIRV_EXT,
        .codeSize = fragmentSpirvSize,
        .pCode = pFragmentSpirv,
        .pName = "main",
        .setLayoutCount = 1,
        .pSetLayouts = &descriptorSetLayout;
        .pushConstantRangeCount = 0,
        .pPushConstantRanges = NULL,
        .pSpecializationInfo = NULL
    }
};

VkResult result;
VkShaderEXT shaders[2];

result = vkCreateShadersEXT(device, 2, &shaderCreateInfos, NULL, shaders);
if (result != VK_SUCCESS)
{
    // Handle error
}

Later, during command buffer recording, bind the linked shaders and draw.

// Command buffer in the recording state
VkCommandBuffer commandBuffer;

// Vertex and fragment shader objects created above
VkShaderEXT shaders[2];

// Assume vertex buffers, descriptor sets, etc. have been bound, and existing
// state setting commands have been called to set all required state

const VkShaderStageFlagBits stages[2] =
{
    VK_SHADER_STAGE_VERTEX_BIT,
    VK_SHADER_STAGE_FRAGMENT_BIT
};

// Bind linked shaders
vkCmdBindShadersEXT(commandBuffer, 2, stages, shaders);

// Equivalent to the previous line. Linked shaders can be bound one at a time,
// in any order:
// vkCmdBindShadersEXT(commandBuffer, 1, &stages[1], &shaders[1]);
// vkCmdBindShadersEXT(commandBuffer, 1, &stages[0], &shaders[0]);

// The above is sufficient to draw if the device was created with the
// tessellationShader and geometryShader features disabled. Otherwise, since
// those stages should not execute, vkCmdBindShadersEXT() must be called at
// least once with each of their stages in pStages before drawing:

const VkShaderStageFlagBits unusedStages[3] =
{
    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
    VK_SHADER_STAGE_GEOMETRY_BIT
};

// NULL pShaders is equivalent to an array of stageCount VK_NULL_HANDLE values,
// meaning no shaders are bound to those stages, and that any previously bound
// shaders are unbound
vkCmdBindShadersEXT(commandBuffer, 3, unusedStages, NULL);

// Graphics shader objects may only be used to draw inside dynamic render pass
// instances begun with vkCmdBeginRendering(), assume one has already been begun

// Draw a triangle
vkCmdDraw(commandBuffer, 3, 1, 0, 0);

Example 2

Create unlinked vertex, geometry, and fragment shaders.

// Logical device created with the shaderObject feature enabled
VkDevice device;

// SPIR-V shader code for vertex shaders, along with their sizes in bytes
void* pVertexSpirv[2];
size_t vertexSpirvSize[2];

// SPIR-V shader code for a geometry shader, along with its size in bytes
void pGeometrySpirv;
size_t geometrySpirvSize;

// SPIR-V shader code for fragment shaders, along with their sizes in bytes
void* pFragmentSpirv[2];
size_t fragmentSpirvSize[2];

// Descriptor set layout compatible with the shaders
VkDescriptorSetLayout descriptorSetLayout;

VkShaderCreateInfoEXT shaderCreateInfos[5] =
{
    // Stage order does not matter
    {
        .sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT,
        .pNext = NULL,
        .flags = 0,
        .stage = VK_SHADER_STAGE_GEOMETRY_BIT,
        .nextStage = VK_SHADER_STAGE_FRAGMENT_BIT,
        .codeType = VK_SHADER_CODE_TYPE_SPIRV_EXT,
        .codeSize = pGeometrySpirv,
        .pCode = geometrySpirvSize,
        .pName = "main",
        .setLayoutCount = 1,
        .pSetLayouts = &descriptorSetLayout;
        .pushConstantRangeCount = 0,
        .pPushConstantRanges = NULL,
        .pSpecializationInfo = NULL
    },
    {
        .sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT,
        .pNext = NULL,
        .flags = 0,
        .stage = VK_SHADER_STAGE_VERTEX_BIT,
        .nextStage = VK_SHADER_STAGE_GEOMETRY_BIT,
        .codeType = VK_SHADER_CODE_TYPE_SPIRV_EXT,
        .codeSize = vertexSpirvSize[0],
        .pCode = pVertexSpirv[0],
        .pName = "main",
        .setLayoutCount = 1,
        .pSetLayouts = &descriptorSetLayout;
        .pushConstantRangeCount = 0,
        .pPushConstantRanges = NULL,
        .pSpecializationInfo = NULL
    },
    {
        .sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT,
        .pNext = NULL,
        .flags = 0,
        .stage = VK_SHADER_STAGE_FRAGMENT_BIT,
        .nextStage = 0,
        .codeType = VK_SHADER_CODE_TYPE_SPIRV_EXT,
        .codeSize = fragmentSpirvSize[0],
        .pCode = pFragmentSpirv[0],
        .pName = "main",
        .setLayoutCount = 1,
        .pSetLayouts = &descriptorSetLayout;
        .pushConstantRangeCount = 0,
        .pPushConstantRanges = NULL,
        .pSpecializationInfo = NULL
    },
    {
        .sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT,
        .pNext = NULL,
        .flags = 0,
        .stage = VK_SHADER_STAGE_FRAGMENT_BIT,
        .nextStage = 0,
        .codeType = VK_SHADER_CODE_TYPE_SPIRV_EXT,
        .codeSize = fragmentSpirvSize[1],
        .pCode = pFragmentSpirv[1],
        .pName = "main",
        .setLayoutCount = 1,
        .pSetLayouts = &descriptorSetLayout;
        .pushConstantRangeCount = 0,
        .pPushConstantRanges = NULL,
        .pSpecializationInfo = NULL
    },
    {
        .sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT,
        .pNext = NULL,
        .flags = 0,
        .stage = VK_SHADER_STAGE_VERTEX_BIT,
        // Suppose we want this vertex shader to be able to be followed by
        // either a geometry shader or fragment shader:
        .nextStage = VK_SHADER_STAGE_GEOMETRY_BIT | VK_SHADER_STAGE_FRAGMENT_BIT,
        .codeType = VK_SHADER_CODE_TYPE_SPIRV_EXT,
        .codeSize = vertexSpirvSize[1],
        .pCode = pVertexSpirv[1],
        .pName = "main",
        .setLayoutCount = 1,
        .pSetLayouts = &descriptorSetLayout;
        .pushConstantRangeCount = 0,
        .pPushConstantRanges = NULL,
        .pSpecializationInfo = NULL
    }
};

VkResult result;
VkShaderEXT shaders[5];

result = vkCreateShadersEXT(device, 5, &shaderCreateInfos, NULL, shaders);
if (result != VK_SUCCESS)
{
    // Handle error
}

Later, during command buffer recording, bind the linked shaders in different combinations and draw.

// Command buffer in the recording state
VkCommandBuffer commandBuffer;

// Vertex, geometry, and fragment shader objects created above
VkShaderEXT shaders[5];

// Assume vertex buffers, descriptor sets, etc. have been bound, and existing
// state setting commands have been called to set all required state

const VkShaderStageFlagBits stages[3] =
{
    // Any order is allowed
    VK_SHADER_STAGE_FRAGMENT_BIT,
    VK_SHADER_STAGE_VERTEX_BIT,
    VK_SHADER_STAGE_GEOMETRY_BIT,
};

VkShaderEXT bindShaders[3] =
{
    shaders[2], // FS
    shaders[1], // VS
    shaders[0]  // GS
};

// Bind unlinked shaders
vkCmdBindShadersEXT(commandBuffer, 3, stages, bindShaders);

// Assume the tessellationShader feature is disabled, so vkCmdBindShadersEXT()
// need not have been called with either tessellation stage

// Graphics shader objects may only be used to draw inside dynamic render pass
// instances begun with vkCmdBeginRendering(), assume one has already been begun

// Draw a triangle
vkCmdDraw(commandBuffer, 3, 1, 0, 0);

// Bind a different unlinked fragment shader
const VkShaderStageFlagBits fragmentStage = VK_SHADER_STAGE_FRAGMENT_BIT;
vkCmdBindShadersEXT(commandBuffer, 1, &fragmentStage, &shaders[3]);

// Draw another triangle
vkCmdDraw(commandBuffer, 3, 1, 0, 0);

// Bind a different unlinked vertex shader
const VkShaderStageFlagBits vertexStage = VK_SHADER_STAGE_VERTEX_BIT;
vkCmdBindShadersEXT(commandBuffer, 1, &vertexStage, &shaders[4]);

// Draw another triangle
vkCmdDraw(commandBuffer, 3, 1, 0, 0);

Version History

• Revision 1, 2023-03-30 (Daniel Story)

  • Initial draft

See Also

ColorBlendAdvancedEXT, ColorBlendEquationEXT, PhysicalDeviceShaderObjectFeaturesEXT, PhysicalDeviceShaderObjectPropertiesEXT, ShaderCodeTypeEXT, ShaderCreateFlagBitsEXT, ShaderCreateFlagsEXT, ShaderCreateInfoEXT, ShaderEXT, ShaderRequiredSubgroupSizeCreateInfoEXT, VertexInputAttributeDescription2EXT, VertexInputBindingDescription2EXT, cmdBindShadersEXT, cmdBindVertexBuffers2EXT, cmdSetAlphaToCoverageEnableEXT, cmdSetAlphaToOneEnableEXT, cmdSetColorBlendAdvancedEXT, cmdSetColorBlendEnableEXT, cmdSetColorBlendEquationEXT, cmdSetColorWriteMaskEXT, cmdSetConservativeRasterizationModeEXT, cmdSetCullModeEXT, cmdSetDepthBiasEnableEXT, cmdSetDepthBoundsTestEnableEXT, cmdSetDepthClampEnableEXT, cmdSetDepthClipEnableEXT, cmdSetDepthClipNegativeOneToOneEXT, cmdSetDepthCompareOpEXT, cmdSetDepthTestEnableEXT, cmdSetDepthWriteEnableEXT, cmdSetExtraPrimitiveOverestimationSizeEXT, cmdSetFrontFaceEXT, cmdSetLineRasterizationModeEXT, cmdSetLineStippleEnableEXT, cmdSetLogicOpEXT, cmdSetLogicOpEnableEXT, cmdSetPatchControlPointsEXT, cmdSetPolygonModeEXT, cmdSetPrimitiveRestartEnableEXT, cmdSetPrimitiveTopologyEXT, cmdSetProvokingVertexModeEXT, cmdSetRasterizationSamplesEXT, cmdSetRasterizationStreamEXT, cmdSetRasterizerDiscardEnableEXT, cmdSetSampleLocationsEnableEXT, cmdSetSampleMaskEXT, cmdSetScissorWithCountEXT, cmdSetStencilOpEXT, cmdSetStencilTestEnableEXT, cmdSetTessellationDomainOriginEXT, cmdSetVertexInputEXT, cmdSetViewportWithCountEXT, createShadersEXT, destroyShaderEXT, getShaderBinaryDataEXT

Document Notes

For more information, see the Vulkan Specification

This page is a generated document. Fixes and changes should be made to the generator scripts, not directly.

Documentation

createShadersEXT

Arguments

:: forall io. MonadIO io

=> Device

device is the logical device that creates the shader objects.

-> ("createInfos" ::: Vector (SomeStruct ShaderCreateInfoEXT))

pCreateInfos is a pointer to an array of ShaderCreateInfoEXT structures.

-> ("allocator" ::: Maybe AllocationCallbacks)

pAllocator controls host memory allocation as described in the Memory Allocation chapter.

-> io ("shaders" ::: Vector ShaderEXT)

vkCreateShadersEXT - Create one or more new shaders

Description

When this function returns, whether or not it succeeds, it is guaranteed that every element of pShaders will have been overwritten by either NULL_HANDLE or a valid ShaderEXT handle.

This means that whenever shader creation fails, the application can determine which shader the returned error pertains to by locating the first NULL_HANDLE element in pShaders. It also means that an application can reliably clean up from a failed call by iterating over the pShaders array and destroying every element that is not NULL_HANDLE.

Valid Usage

• The shaderObject feature must be enabled

• If createInfoCount is 1, there must be no element of pCreateInfos whose flags member includes SHADER_CREATE_LINK_STAGE_BIT_EXT
• If the flags member of any element of pCreateInfos includes SHADER_CREATE_LINK_STAGE_BIT_EXT, the flags member of all other elements of pCreateInfos whose stage is SHADER_STAGE_VERTEX_BIT, SHADER_STAGE_TESSELLATION_CONTROL_BIT, SHADER_STAGE_TESSELLATION_EVALUATION_BIT, SHADER_STAGE_GEOMETRY_BIT, or SHADER_STAGE_FRAGMENT_BIT must also include SHADER_CREATE_LINK_STAGE_BIT_EXT
• If the flags member of any element of pCreateInfos includes SHADER_CREATE_LINK_STAGE_BIT_EXT, the flags member of all other elements of pCreateInfos whose stage is SHADER_STAGE_TASK_BIT_EXT or SHADER_STAGE_MESH_BIT_EXT must also include SHADER_CREATE_LINK_STAGE_BIT_EXT
• If the flags member of any element of pCreateInfos whose stage is SHADER_STAGE_TASK_BIT_EXT or SHADER_STAGE_MESH_BIT_EXT includes SHADER_CREATE_LINK_STAGE_BIT_EXT, there must be no member of pCreateInfos whose stage is SHADER_STAGE_VERTEX_BIT and whose flags member includes SHADER_CREATE_LINK_STAGE_BIT_EXT
• If there is any element of pCreateInfos whose stage is SHADER_STAGE_MESH_BIT_EXT and whose flags member includes both SHADER_CREATE_LINK_STAGE_BIT_EXT and SHADER_CREATE_NO_TASK_SHADER_BIT_EXT, there must be no element of pCreateInfos whose stage is SHADER_STAGE_TASK_BIT_EXT and whose flags member includes SHADER_CREATE_LINK_STAGE_BIT_EXT
• For each element of pCreateInfos whose flags member includes SHADER_CREATE_LINK_STAGE_BIT_EXT, if there is any other element of pCreateInfos whose stage is logically later than the stage of the former and whose flags member also includes SHADER_CREATE_LINK_STAGE_BIT_EXT, the nextStage of the former must be equal to the stage of the element with the logically earliest stage following the stage of the former whose flags member also includes SHADER_CREATE_LINK_STAGE_BIT_EXT
• The stage member of each element of pCreateInfos whose flags member includes SHADER_CREATE_LINK_STAGE_BIT_EXT must be unique
• The codeType member of all elements of pCreateInfos whose flags member includes SHADER_CREATE_LINK_STAGE_BIT_EXT must be the same
• If pCreateInfos contains elements with both SHADER_STAGE_TESSELLATION_CONTROL_BIT and SHADER_STAGE_TESSELLATION_EVALUATION_BIT, both elements' flags include SHADER_CREATE_LINK_STAGE_BIT_EXT, both elements' codeType is SHADER_CODE_TYPE_SPIRV_EXT, and the SHADER_STAGE_TESSELLATION_CONTROL_BIT stage’s pCode contains an OpExecutionMode instruction specifying the type of subdivision, it must match the subdivision type specified in the SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage
• If pCreateInfos contains elements with both SHADER_STAGE_TESSELLATION_CONTROL_BIT and SHADER_STAGE_TESSELLATION_EVALUATION_BIT, both elements' flags include SHADER_CREATE_LINK_STAGE_BIT_EXT, both elements' codeType is SHADER_CODE_TYPE_SPIRV_EXT, and the SHADER_STAGE_TESSELLATION_CONTROL_BIT stage’s pCode contains an OpExecutionMode instruction specifying the orientation of triangles, it must match the triangle orientation specified in the SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage
• If pCreateInfos contains elements with both SHADER_STAGE_TESSELLATION_CONTROL_BIT and SHADER_STAGE_TESSELLATION_EVALUATION_BIT, both elements' flags include SHADER_CREATE_LINK_STAGE_BIT_EXT, both elements' codeType is SHADER_CODE_TYPE_SPIRV_EXT, and the SHADER_STAGE_TESSELLATION_CONTROL_BIT stage’s pCode contains an OpExecutionMode instruction specifying PointMode, the SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage must also contain an OpExecutionMode instruction specifying PointMode
• If pCreateInfos contains elements with both SHADER_STAGE_TESSELLATION_CONTROL_BIT and SHADER_STAGE_TESSELLATION_EVALUATION_BIT, both elements' flags include SHADER_CREATE_LINK_STAGE_BIT_EXT, both elements' codeType is SHADER_CODE_TYPE_SPIRV_EXT, and the SHADER_STAGE_TESSELLATION_CONTROL_BIT stage’s pCode contains an OpExecutionMode instruction specifying the spacing of segments on the edges of tessellated primitives, it must match the segment spacing specified in the SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage
• If pCreateInfos contains elements with both SHADER_STAGE_TESSELLATION_CONTROL_BIT and SHADER_STAGE_TESSELLATION_EVALUATION_BIT, both elements' flags include SHADER_CREATE_LINK_STAGE_BIT_EXT, both elements' codeType is SHADER_CODE_TYPE_SPIRV_EXT, and the SHADER_STAGE_TESSELLATION_CONTROL_BIT stage’s pCode contains an OpExecutionMode instruction specifying the output patch size, it must match the output patch size specified in the SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage

Valid Usage (Implicit)

• device must be a valid Device handle

• pCreateInfos must be a valid pointer to an array of createInfoCount valid ShaderCreateInfoEXT structures
• If pAllocator is not NULL, pAllocator must be a valid pointer to a valid AllocationCallbacks structure
• pShaders must be a valid pointer to an array of createInfoCount ShaderEXT handles
• createInfoCount must be greater than 0

Return Codes

Success

• SUCCESS

Failure

• ERROR_OUT_OF_HOST_MEMORY
• ERROR_OUT_OF_DEVICE_MEMORY
• ERROR_INITIALIZATION_FAILED
• ERROR_INCOMPATIBLE_SHADER_BINARY_EXT

See Also

VK_EXT_shader_object, AllocationCallbacks, Device, ShaderCreateInfoEXT, ShaderEXT

withShadersEXT :: forall io r. MonadIO io => Device -> Vector (SomeStruct ShaderCreateInfoEXT) -> Maybe AllocationCallbacks -> (io (Vector ShaderEXT) -> (Vector ShaderEXT -> io ()) -> r) -> r

A convenience wrapper to make a compatible pair of calls to createShadersEXT and destroyShaderEXT

To ensure that destroyShaderEXT is always called: pass bracket (or the allocate function from your favourite resource management library) as the last argument. To just extract the pair pass (,) as the last argument.

destroyShaderEXT

Arguments

:: forall io. MonadIO io

=> Device

device is the logical device that destroys the shader object.

-> ShaderEXT

shader is the handle of the shader object to destroy.

-> ("allocator" ::: Maybe AllocationCallbacks)

pAllocator controls host memory allocation as described in the Memory Allocation chapter.

-> io ()

vkDestroyShaderEXT - Destroy a shader object

Description

Destroying a shader object used by one or more command buffers in the recording or executable state causes those command buffers to move into the invalid state.

Valid Usage

• The shaderObject feature must be enabled

• All submitted commands that refer to shader must have completed execution
• If AllocationCallbacks were provided when shader was created, a compatible set of callbacks must be provided here
• If no AllocationCallbacks were provided when shader was created, pAllocator must be NULL

Valid Usage (Implicit)

• device must be a valid Device handle

• shader must be a valid ShaderEXT handle
• If pAllocator is not NULL, pAllocator must be a valid pointer to a valid AllocationCallbacks structure
• shader must have been created, allocated, or retrieved from device

Host Synchronization

• Host access to shader must be externally synchronized

See Also

VK_EXT_shader_object, AllocationCallbacks, Device, ShaderEXT

getShaderBinaryDataEXT

Arguments

:: forall io. MonadIO io

=> Device

device is the logical device that shader object was created from.

-> ShaderEXT

shader is the shader object to retrieve binary shader code from.

-> io (Result, "data" ::: ByteString)

vkGetShaderBinaryDataEXT - Get the binary shader code from a shader object

Description

If pData is NULL, then the size of the binary shader code of the shader object, in bytes, is returned in pDataSize. Otherwise, pDataSize must point to a variable set by the user to the size of the buffer, in bytes, pointed to by pData, and on return the variable is overwritten with the amount of data actually written to pData. If pDataSize is less than the size of the binary shader code, nothing is written to pData, and INCOMPLETE will be returned instead of SUCCESS.

Note

The behavior of this command when pDataSize is too small differs from how some other getter-type commands work in Vulkan. Because shader binary data is only usable in its entirety, it would never be useful for the implementation to return partial data. Because of this, nothing is written to pData unless pDataSize is large enough to fit the data it its entirety.

Binary shader code retrieved using getShaderBinaryDataEXT can be passed to a subsequent call to createShadersEXT on a compatible physical device by specifying SHADER_CODE_TYPE_BINARY_EXT in the codeType member of ShaderCreateInfoEXT.

The shader code returned by repeated calls to this function with the same ShaderEXT is guaranteed to be invariant for the lifetime of the ShaderEXT object.

Valid Usage

• The shaderObject feature must be enabled

• If pData is not NULL, it must be aligned to 16 bytes

Valid Usage (Implicit)

• device must be a valid Device handle

• shader must be a valid ShaderEXT handle
• pDataSize must be a valid pointer to a size_t value
• If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of pDataSize bytes
• shader must have been created, allocated, or retrieved from device

Return Codes

Success

• SUCCESS
• INCOMPLETE

Failure

• ERROR_OUT_OF_HOST_MEMORY
• ERROR_OUT_OF_DEVICE_MEMORY

See Also

VK_EXT_shader_object, Device, ShaderEXT

cmdBindShadersEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer that the shader object will be bound to.

-> ("stages" ::: Vector ShaderStageFlagBits)

pStages is a pointer to an array of ShaderStageFlagBits values specifying one stage per array index that is affected by the corresponding value in the pShaders array.

-> ("shaders" ::: Vector ShaderEXT)

pShaders is a pointer to an array of ShaderEXT handles and/or NULL_HANDLE values describing the shader binding operations to be performed on each stage in pStages.

-> io ()

vkCmdBindShadersEXT - Bind shader objects to a command buffer

Description

When binding linked shaders, an application may bind them in any combination of one or more calls to cmdBindShadersEXT (i.e., shaders that were created linked together do not need to be bound in the same cmdBindShadersEXT call).

Any shader object bound to a particular stage may be unbound by setting its value in pShaders to NULL_HANDLE. If pShaders is NULL, cmdBindShadersEXT behaves as if pShaders was an array of stageCount NULL_HANDLE values (i.e., any shaders bound to the stages specified in pStages are unbound).

Valid Usage

• The shaderObject feature must be enabled

• Every element of pStages must be unique
• pStages must not contain SHADER_STAGE_ALL_GRAPHICS or SHADER_STAGE_ALL
• pStages must not contain SHADER_STAGE_RAYGEN_BIT_KHR, SHADER_STAGE_ANY_HIT_BIT_KHR, SHADER_STAGE_CLOSEST_HIT_BIT_KHR, SHADER_STAGE_MISS_BIT_KHR, SHADER_STAGE_INTERSECTION_BIT_KHR, or SHADER_STAGE_CALLABLE_BIT_KHR
• pStages must not contain SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI
• pStages must not contain SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI
• For each element of pStages, if pShaders is not NULL, and the element of the pShaders array with the same index is not NULL_HANDLE, it must have been created with a stage equal to the corresponding element of pStages
• If pStages contains both SHADER_STAGE_TASK_BIT_EXT and SHADER_STAGE_VERTEX_BIT, and pShaders is not NULL, and the same index in pShaders as SHADER_STAGE_TASK_BIT_EXT in pStages is not NULL_HANDLE, the same index in pShaders as SHADER_STAGE_VERTEX_BIT in pStages must be NULL_HANDLE
• If pStages contains both SHADER_STAGE_MESH_BIT_EXT and SHADER_STAGE_VERTEX_BIT, and pShaders is not NULL, and the same index in pShaders as SHADER_STAGE_MESH_BIT_EXT in pStages is not NULL_HANDLE, the same index in pShaders as SHADER_STAGE_VERTEX_BIT in pStages must be NULL_HANDLE
• If the tessellationShader feature is not enabled, and pStages contains SHADER_STAGE_TESSELLATION_CONTROL_BIT or SHADER_STAGE_TESSELLATION_EVALUATION_BIT, and pShaders is not NULL, the same index or indices in pShaders must be NULL_HANDLE
• If the geometryShader feature is not enabled, and pStages contains SHADER_STAGE_GEOMETRY_BIT, and pShaders is not NULL, the same index in pShaders must be NULL_HANDLE
• If the taskShader feature is not enabled, and pStages contains SHADER_STAGE_TASK_BIT_EXT, and pShaders is not NULL, the same index in pShaders must be NULL_HANDLE
• If the meshShader feature is not enabled, and pStages contains SHADER_STAGE_MESH_BIT_EXT, and pShaders is not NULL, the same index in pShaders must be NULL_HANDLE
• If pStages contains SHADER_STAGE_COMPUTE_BIT, the CommandPool that commandBuffer was allocated from must support compute operations
• If pStages contains SHADER_STAGE_VERTEX_BIT, SHADER_STAGE_TESSELLATION_CONTROL_BIT, SHADER_STAGE_TESSELLATION_EVALUATION_BIT, SHADER_STAGE_GEOMETRY_BIT, or SHADER_STAGE_FRAGMENT_BIT, the CommandPool that commandBuffer was allocated from must support graphics operations
• If pStages contains SHADER_STAGE_MESH_BIT_EXT or SHADER_STAGE_TASK_BIT_EXT, the CommandPool that commandBuffer was allocated from must support graphics operations

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• pStages must be a valid pointer to an array of stageCount valid ShaderStageFlagBits values
• If pShaders is not NULL, pShaders must be a valid pointer to an array of stageCount valid or NULL_HANDLE ShaderEXT handles
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics, or compute operations
• This command must only be called outside of a video coding scope
• stageCount must be greater than 0
• Both of commandBuffer, and the elements of pShaders that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same Device

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics Compute	State

See Also

VK_EXT_shader_object, CommandBuffer, ShaderEXT, ShaderStageFlagBits

pattern STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT :: StructureType

data PhysicalDeviceShaderObjectFeaturesEXT

VkPhysicalDeviceShaderObjectFeaturesEXT - Structure describing whether shader objects can be supported by an implementation

Members

This structure describes the following feature:

Description

If the PhysicalDeviceShaderObjectFeaturesEXT structure is included in the pNext chain of the PhysicalDeviceFeatures2 structure passed to getPhysicalDeviceFeatures2, it is filled in to indicate whether each corresponding feature is supported. PhysicalDeviceShaderObjectFeaturesEXT can also be used in the pNext chain of DeviceCreateInfo to selectively enable these features.

Valid Usage (Implicit)

See Also

VK_EXT_shader_object, Bool32, StructureType

Constructors

PhysicalDeviceShaderObjectFeaturesEXT

Fields

• shaderObject :: Bool

  shaderObject indicates whether the implementation supports shader objects.

Instances

Storable PhysicalDeviceShaderObjectFeaturesEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

sizeOf :: PhysicalDeviceShaderObjectFeaturesEXT -> Int

alignment :: PhysicalDeviceShaderObjectFeaturesEXT -> Int

peekElemOff :: Ptr PhysicalDeviceShaderObjectFeaturesEXT -> Int -> IO PhysicalDeviceShaderObjectFeaturesEXT

pokeElemOff :: Ptr PhysicalDeviceShaderObjectFeaturesEXT -> Int -> PhysicalDeviceShaderObjectFeaturesEXT -> IO ()

peekByteOff :: Ptr b -> Int -> IO PhysicalDeviceShaderObjectFeaturesEXT

pokeByteOff :: Ptr b -> Int -> PhysicalDeviceShaderObjectFeaturesEXT -> IO ()

peek :: Ptr PhysicalDeviceShaderObjectFeaturesEXT -> IO PhysicalDeviceShaderObjectFeaturesEXT

poke :: Ptr PhysicalDeviceShaderObjectFeaturesEXT -> PhysicalDeviceShaderObjectFeaturesEXT -> IO ()

Show PhysicalDeviceShaderObjectFeaturesEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

showsPrec :: Int -> PhysicalDeviceShaderObjectFeaturesEXT -> ShowS

show :: PhysicalDeviceShaderObjectFeaturesEXT -> String

showList :: [PhysicalDeviceShaderObjectFeaturesEXT] -> ShowS

Eq PhysicalDeviceShaderObjectFeaturesEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

(==) :: PhysicalDeviceShaderObjectFeaturesEXT -> PhysicalDeviceShaderObjectFeaturesEXT -> Bool

(/=) :: PhysicalDeviceShaderObjectFeaturesEXT -> PhysicalDeviceShaderObjectFeaturesEXT -> Bool

FromCStruct PhysicalDeviceShaderObjectFeaturesEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

peekCStruct :: Ptr PhysicalDeviceShaderObjectFeaturesEXT -> IO PhysicalDeviceShaderObjectFeaturesEXT

ToCStruct PhysicalDeviceShaderObjectFeaturesEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

withCStruct :: PhysicalDeviceShaderObjectFeaturesEXT -> (Ptr PhysicalDeviceShaderObjectFeaturesEXT -> IO b) -> IO b

pokeCStruct :: Ptr PhysicalDeviceShaderObjectFeaturesEXT -> PhysicalDeviceShaderObjectFeaturesEXT -> IO b -> IO b

withZeroCStruct :: (Ptr PhysicalDeviceShaderObjectFeaturesEXT -> IO b) -> IO b

pokeZeroCStruct :: Ptr PhysicalDeviceShaderObjectFeaturesEXT -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero PhysicalDeviceShaderObjectFeaturesEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

zero :: PhysicalDeviceShaderObjectFeaturesEXT

data PhysicalDeviceShaderObjectPropertiesEXT

VkPhysicalDeviceShaderObjectPropertiesEXT - Structure describing shader object properties supported by an implementation

Description

The purpose and usage of the values of this structure are described in greater detail in Binary Shader Compatibility.

If the PhysicalDeviceShaderObjectPropertiesEXT structure is included in the pNext chain of the PhysicalDeviceProperties2 structure passed to getPhysicalDeviceProperties2, it is filled in with each corresponding implementation-dependent property.

Valid Usage (Implicit)

See Also

VK_EXT_shader_object, StructureType

Constructors

PhysicalDeviceShaderObjectPropertiesEXT

Fields

• shaderBinaryUUID :: ByteString

  shaderBinaryUUID is an array of UUID_SIZE uint8_t values representing a universally unique identifier for one or more implementations whose shader binaries are guaranteed to be compatible with each other.

• shaderBinaryVersion :: Word32

  shaderBinaryVersion is an unsigned integer incremented to represent backwards compatible differences between implementations with the same shaderBinaryUUID.

Instances

Storable PhysicalDeviceShaderObjectPropertiesEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

sizeOf :: PhysicalDeviceShaderObjectPropertiesEXT -> Int

alignment :: PhysicalDeviceShaderObjectPropertiesEXT -> Int

peekElemOff :: Ptr PhysicalDeviceShaderObjectPropertiesEXT -> Int -> IO PhysicalDeviceShaderObjectPropertiesEXT

pokeElemOff :: Ptr PhysicalDeviceShaderObjectPropertiesEXT -> Int -> PhysicalDeviceShaderObjectPropertiesEXT -> IO ()

peekByteOff :: Ptr b -> Int -> IO PhysicalDeviceShaderObjectPropertiesEXT

pokeByteOff :: Ptr b -> Int -> PhysicalDeviceShaderObjectPropertiesEXT -> IO ()

peek :: Ptr PhysicalDeviceShaderObjectPropertiesEXT -> IO PhysicalDeviceShaderObjectPropertiesEXT

poke :: Ptr PhysicalDeviceShaderObjectPropertiesEXT -> PhysicalDeviceShaderObjectPropertiesEXT -> IO ()

Show PhysicalDeviceShaderObjectPropertiesEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

showsPrec :: Int -> PhysicalDeviceShaderObjectPropertiesEXT -> ShowS

show :: PhysicalDeviceShaderObjectPropertiesEXT -> String

showList :: [PhysicalDeviceShaderObjectPropertiesEXT] -> ShowS

FromCStruct PhysicalDeviceShaderObjectPropertiesEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

peekCStruct :: Ptr PhysicalDeviceShaderObjectPropertiesEXT -> IO PhysicalDeviceShaderObjectPropertiesEXT

ToCStruct PhysicalDeviceShaderObjectPropertiesEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

withCStruct :: PhysicalDeviceShaderObjectPropertiesEXT -> (Ptr PhysicalDeviceShaderObjectPropertiesEXT -> IO b) -> IO b

pokeCStruct :: Ptr PhysicalDeviceShaderObjectPropertiesEXT -> PhysicalDeviceShaderObjectPropertiesEXT -> IO b -> IO b

withZeroCStruct :: (Ptr PhysicalDeviceShaderObjectPropertiesEXT -> IO b) -> IO b

pokeZeroCStruct :: Ptr PhysicalDeviceShaderObjectPropertiesEXT -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero PhysicalDeviceShaderObjectPropertiesEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

zero :: PhysicalDeviceShaderObjectPropertiesEXT

data ShaderCreateInfoEXT (es :: [Type])

VkShaderCreateInfoEXT - Structure specifying parameters of a newly created shader

Valid Usage

• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, codeSize must be a multiple of 4

• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, pCode must point to valid SPIR-V code, formatted and packed as described by the Khronos SPIR-V Specification
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, pCode must adhere to the validation rules described by the Validation Rules within a Module section of the SPIR-V Environment appendix
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, pCode must declare the Shader capability for SPIR-V code
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, pCode must not declare any capability that is not supported by the API, as described by the Capabilities section of the SPIR-V Environment appendix
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, and pCode declares any of the capabilities listed in the SPIR-V Environment appendix, one of the corresponding requirements must be satisfied
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, pCode must not declare any SPIR-V extension that is not supported by the API, as described by the Extension section of the SPIR-V Environment appendix
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, and pCode declares any of the SPIR-V extensions listed in the SPIR-V Environment appendix, one of the corresponding requirements must be satisfied
• If stage is not SHADER_STAGE_TASK_BIT_EXT, SHADER_STAGE_MESH_BIT_EXT, SHADER_STAGE_VERTEX_BIT, SHADER_STAGE_TESSELLATION_CONTROL_BIT, SHADER_STAGE_TESSELLATION_EVALUATION_BIT, SHADER_STAGE_GEOMETRY_BIT, or SHADER_STAGE_FRAGMENT_BIT, flags must not include SHADER_CREATE_LINK_STAGE_BIT_EXT
• If stage is not SHADER_STAGE_FRAGMENT_BIT, flags must not include SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT
• If the attachmentFragmentShadingRate feature is not enabled, flags must not include SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT
• If stage is not SHADER_STAGE_FRAGMENT_BIT, flags must not include SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT
• If the fragmentDensityMap feature is not enabled, flags must not include SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT
• If flags includes SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT, the subgroupSizeControl feature must be enabled
• If flags includes SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT, the computeFullSubgroups feature must be enabled
• If flags includes SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT, stage must be one of SHADER_STAGE_MESH_BIT_EXT, SHADER_STAGE_TASK_BIT_EXT, or SHADER_STAGE_COMPUTE_BIT
• If stage is not SHADER_STAGE_COMPUTE_BIT, flags must not include SHADER_CREATE_DISPATCH_BASE_BIT_EXT
• If stage is not SHADER_STAGE_MESH_BIT_EXT, flags must not include SHADER_CREATE_NO_TASK_SHADER_BIT_EXT
• If flags includes both SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT and SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT, the local workgroup size in the X dimension of the shader must be a multiple of maxSubgroupSize
• If flags includes SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT but not SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT and no ShaderRequiredSubgroupSizeCreateInfoEXT structure is included in the pNext chain, the local workgroup size in the X dimension of the shader must be a multiple of subgroupSize
• stage must not be SHADER_STAGE_ALL_GRAPHICS or SHADER_STAGE_ALL
• If the tessellationShader feature is not enabled, stage must not be SHADER_STAGE_TESSELLATION_CONTROL_BIT or SHADER_STAGE_TESSELLATION_EVALUATION_BIT
• If the geometryShader feature is not enabled, stage must not be SHADER_STAGE_GEOMETRY_BIT
• If the taskShader feature is not enabled, stage must not be SHADER_STAGE_TASK_BIT_EXT
• If the meshShader feature is not enabled, stage must not be SHADER_STAGE_MESH_BIT_EXT
• stage must not be SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI
• stage must not be SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI
• If stage is SHADER_STAGE_VERTEX_BIT, nextStage must not include any bits other than SHADER_STAGE_TESSELLATION_CONTROL_BIT, SHADER_STAGE_GEOMETRY_BIT, and SHADER_STAGE_FRAGMENT_BIT
• If the tessellationShader feature is not enabled, nextStage must not include SHADER_STAGE_TESSELLATION_CONTROL_BIT or SHADER_STAGE_TESSELLATION_EVALUATION_BIT
• If the geometryShader feature is not enabled, nextStage must not include SHADER_STAGE_GEOMETRY_BIT
• If stage is SHADER_STAGE_TESSELLATION_CONTROL_BIT, nextStage must not include any bits other than SHADER_STAGE_TESSELLATION_EVALUATION_BIT
• If stage is SHADER_STAGE_TESSELLATION_EVALUATION_BIT, nextStage must not include any bits other than SHADER_STAGE_GEOMETRY_BIT and SHADER_STAGE_FRAGMENT_BIT
• If stage is SHADER_STAGE_GEOMETRY_BIT, nextStage must not include any bits other than SHADER_STAGE_FRAGMENT_BIT
• If stage is SHADER_STAGE_FRAGMENT_BIT or SHADER_STAGE_COMPUTE_BIT, nextStage must be 0
• If stage is SHADER_STAGE_TASK_BIT_EXT, nextStage must not include any bits other than SHADER_STAGE_MESH_BIT_EXT
• If stage is SHADER_STAGE_MESH_BIT_EXT, nextStage must not include any bits other than SHADER_STAGE_FRAGMENT_BIT
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, pName must be the name of an OpEntryPoint in pCode with an execution model that matches stage
• If codeType is SHADER_CODE_TYPE_BINARY_EXT, pCode must be aligned to 16 bytes
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, pCode must be aligned to 4 bytes
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, and 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 PhysicalDeviceLimits::maxClipDistances
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, and 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 PhysicalDeviceLimits::maxCullDistances
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, and 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 PhysicalDeviceLimits::maxCombinedClipAndCullDistances
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, and 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 PhysicalDeviceLimits::maxSampleMaskWords
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, and stage is SHADER_STAGE_VERTEX_BIT, the identified entry point must not include any input variable in its interface that is decorated with CullDistance
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, and stage is SHADER_STAGE_TESSELLATION_CONTROL_BIT or SHADER_STAGE_TESSELLATION_EVALUATION_BIT, and the identified entry point has an OpExecutionMode instruction specifying a patch size with OutputVertices, the patch size must be greater than 0 and less than or equal to PhysicalDeviceLimits::maxTessellationPatchSize
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, and stage is SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction specifying a maximum output vertex count that is greater than 0 and less than or equal to PhysicalDeviceLimits::maxGeometryOutputVertices
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, and stage is SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction specifying an invocation count that is greater than 0 and less than or equal to PhysicalDeviceLimits::maxGeometryShaderInvocations
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, and stage is a pre-rasterization shader stage, 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 codeType is SHADER_CODE_TYPE_SPIRV_EXT, and stage is a pre-rasterization shader stage, 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 codeType is SHADER_CODE_TYPE_SPIRV_EXT, and stage is SHADER_STAGE_FRAGMENT_BIT, the identified entry point must not include any output variables in its interface decorated with CullDistance
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, and stage is SHADER_STAGE_FRAGMENT_BIT, and the identified entry point writes to FragDepth in any execution path, all execution paths that are not exclusive to helper invocations must either discard the fragment, or write or initialize the value of FragDepth
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, the shader code in pCode must be valid as described by the Khronos SPIR-V Specification after applying the specializations provided in pSpecializationInfo, if any, and then converting all specialization constants into fixed constants
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, and stage is SHADER_STAGE_TESSELLATION_EVALUATION_BIT, pCode must contain an OpExecutionMode instruction specifying the type of subdivision
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, and stage is SHADER_STAGE_TESSELLATION_EVALUATION_BIT, pCode must contain an OpExecutionMode instruction specifying the orientation of triangles generated by the tessellator
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, and stage is SHADER_STAGE_TESSELLATION_EVALUATION_BIT, pCode must contain an OpExecutionMode instruction specifying the spacing of segments on the edges of tessellated primitives
• If codeType is SHADER_CODE_TYPE_SPIRV_EXT, and stage is SHADER_STAGE_TESSELLATION_EVALUATION_BIT, pCode must contain an OpExecutionMode instruction specifying the output patch size

Valid Usage (Implicit)

• sType must be STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT

• pNext must be NULL or a pointer to a valid instance of PipelineShaderStageRequiredSubgroupSizeCreateInfo
• The sType value of each struct in the pNext chain must be unique
• flags must be a valid combination of ShaderCreateFlagBitsEXT values
• stage must be a valid ShaderStageFlagBits value
• nextStage must be a valid combination of ShaderStageFlagBits values
• codeType must be a valid ShaderCodeTypeEXT value
• pCode must be a valid pointer to an array of codeSize bytes
• If pName is not NULL, pName must be a null-terminated UTF-8 string
• If setLayoutCount is not 0, and pSetLayouts is not NULL, pSetLayouts must be a valid pointer to an array of setLayoutCount valid DescriptorSetLayout handles
• If pushConstantRangeCount is not 0, and pPushConstantRanges is not NULL, pPushConstantRanges must be a valid pointer to an array of pushConstantRangeCount valid PushConstantRange structures
• If pSpecializationInfo is not NULL, pSpecializationInfo must be a valid pointer to a valid SpecializationInfo structure
• codeSize must be greater than 0

See Also

VK_EXT_shader_object, DescriptorSetLayout, PushConstantRange, ShaderCodeTypeEXT, ShaderCreateFlagsEXT, ShaderStageFlagBits, ShaderStageFlags, SpecializationInfo, StructureType, createShadersEXT

Constructors

ShaderCreateInfoEXT

Fields

• next :: Chain es

  pNext is NULL or a pointer to a structure extending this structure.

• flags :: ShaderCreateFlagsEXT

  flags is a bitmask of ShaderCreateFlagBitsEXT describing additional parameters of the shader.

• stage :: ShaderStageFlagBits

  stage is a ShaderStageFlagBits value specifying a single shader stage.

• nextStage :: ShaderStageFlags

  nextStage is a bitmask of ShaderStageFlagBits specifying zero or stages which may be used as a logically next bound stage when drawing with the shader bound.

• codeType :: ShaderCodeTypeEXT

  codeType is a ShaderCodeTypeEXT value specifying the type of the shader code pointed to be pCode.

• codeSize :: Word64

  codeSize is the size in bytes of the shader code pointed to be pCode.

• code :: Ptr ()

  pCode is a pointer to the shader code to use to create the shader.

• name :: Maybe ByteString

  pName is a pointer to a null-terminated UTF-8 string specifying the entry point name of the shader for this stage.

• setLayoutCount :: Word32

  setLayoutCount is the number of descriptor set layouts pointed to by pSetLayouts.

• setLayouts :: Vector DescriptorSetLayout

  pSetLayouts is a pointer to an array of DescriptorSetLayout objects used by the shader stage.

• pushConstantRangeCount :: Word32

  pushConstantRangeCount is the number of push constant ranges pointed to by pPushConstantRanges.

• pushConstantRanges :: Vector PushConstantRange

  pPushConstantRanges is a pointer to an array of PushConstantRange structures used by the shader stage.

• specializationInfo :: Maybe SpecializationInfo

  pSpecializationInfo is a pointer to a SpecializationInfo structure, as described in Specialization Constants, or NULL.

Instances

Extensible ShaderCreateInfoEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

extensibleTypeName :: String

getNext :: forall (es :: [Type]). ShaderCreateInfoEXT es -> Chain es

setNext :: forall (ds :: [Type]) (es :: [TYPE LiftedRep]). ShaderCreateInfoEXT ds -> Chain es -> ShaderCreateInfoEXT es

extends :: forall e b proxy. Typeable e => proxy e -> (Extends ShaderCreateInfoEXT e => b) -> Maybe b

Show (Chain es) => Show (ShaderCreateInfoEXT es)

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

showsPrec :: Int -> ShaderCreateInfoEXT es -> ShowS

show :: ShaderCreateInfoEXT es -> String

showList :: [ShaderCreateInfoEXT es] -> ShowS

(Extendss ShaderCreateInfoEXT es, PeekChain es) => FromCStruct (ShaderCreateInfoEXT es)

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

peekCStruct :: Ptr (ShaderCreateInfoEXT es) -> IO (ShaderCreateInfoEXT es)

(Extendss ShaderCreateInfoEXT es, PokeChain es) => ToCStruct (ShaderCreateInfoEXT es)

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

withCStruct :: ShaderCreateInfoEXT es -> (Ptr (ShaderCreateInfoEXT es) -> IO b) -> IO b

pokeCStruct :: Ptr (ShaderCreateInfoEXT es) -> ShaderCreateInfoEXT es -> IO b -> IO b

withZeroCStruct :: (Ptr (ShaderCreateInfoEXT es) -> IO b) -> IO b

pokeZeroCStruct :: Ptr (ShaderCreateInfoEXT es) -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

es ~ ('[] :: [Type]) => Zero (ShaderCreateInfoEXT es)

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

zero :: ShaderCreateInfoEXT es

type ShaderCreateFlagsEXT = ShaderCreateFlagBitsEXT

newtype ShaderCreateFlagBitsEXT

VkShaderCreateFlagBitsEXT - Bitmask controlling how a shader object is created

See Also

VK_EXT_shader_object, ShaderCreateFlagsEXT

Constructors

ShaderCreateFlagBitsEXT Flags

Bundled Patterns

pattern SHADER_CREATE_LINK_STAGE_BIT_EXT :: ShaderCreateFlagBitsEXT

SHADER_CREATE_LINK_STAGE_BIT_EXT specifies that a shader is linked to all other shaders created in the same createShadersEXT call whose ShaderCreateInfoEXT structures' flags include SHADER_CREATE_LINK_STAGE_BIT_EXT.

pattern SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT :: ShaderCreateFlagBitsEXT

SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT specifies that a fragment shader can be used with a fragment density map attachment.

pattern SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT :: ShaderCreateFlagBitsEXT

SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT specifies that a fragment shader can be used with a fragment shading rate attachment.

pattern SHADER_CREATE_DISPATCH_BASE_BIT_EXT :: ShaderCreateFlagBitsEXT

SHADER_CREATE_DISPATCH_BASE_BIT_EXT specifies that a compute shader can be used with cmdDispatchBase with a non-zero base workgroup.

pattern SHADER_CREATE_NO_TASK_SHADER_BIT_EXT :: ShaderCreateFlagBitsEXT

SHADER_CREATE_NO_TASK_SHADER_BIT_EXT specifies that a mesh shader must only be used without a task shader. Otherwise, the mesh shader must only be used with a task shader.

pattern SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT :: ShaderCreateFlagBitsEXT

SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT specifies that the subgroup sizes must be launched with all invocations active in a task, mesh, or compute shader.

pattern SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT :: ShaderCreateFlagBitsEXT

SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT specifies that the SubgroupSize may vary in a task, mesh, or compute shader.

Instances

Storable ShaderCreateFlagBitsEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

sizeOf :: ShaderCreateFlagBitsEXT -> Int

alignment :: ShaderCreateFlagBitsEXT -> Int

peekElemOff :: Ptr ShaderCreateFlagBitsEXT -> Int -> IO ShaderCreateFlagBitsEXT

pokeElemOff :: Ptr ShaderCreateFlagBitsEXT -> Int -> ShaderCreateFlagBitsEXT -> IO ()

peekByteOff :: Ptr b -> Int -> IO ShaderCreateFlagBitsEXT

pokeByteOff :: Ptr b -> Int -> ShaderCreateFlagBitsEXT -> IO ()

peek :: Ptr ShaderCreateFlagBitsEXT -> IO ShaderCreateFlagBitsEXT

poke :: Ptr ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT -> IO ()

Bits ShaderCreateFlagBitsEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

(.&.) :: ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT

(.|.) :: ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT

xor :: ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT

complement :: ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT

shift :: ShaderCreateFlagBitsEXT -> Int -> ShaderCreateFlagBitsEXT

rotate :: ShaderCreateFlagBitsEXT -> Int -> ShaderCreateFlagBitsEXT

zeroBits :: ShaderCreateFlagBitsEXT

bit :: Int -> ShaderCreateFlagBitsEXT

setBit :: ShaderCreateFlagBitsEXT -> Int -> ShaderCreateFlagBitsEXT

clearBit :: ShaderCreateFlagBitsEXT -> Int -> ShaderCreateFlagBitsEXT

complementBit :: ShaderCreateFlagBitsEXT -> Int -> ShaderCreateFlagBitsEXT

testBit :: ShaderCreateFlagBitsEXT -> Int -> Bool

bitSizeMaybe :: ShaderCreateFlagBitsEXT -> Maybe Int

bitSize :: ShaderCreateFlagBitsEXT -> Int

isSigned :: ShaderCreateFlagBitsEXT -> Bool

shiftL :: ShaderCreateFlagBitsEXT -> Int -> ShaderCreateFlagBitsEXT

unsafeShiftL :: ShaderCreateFlagBitsEXT -> Int -> ShaderCreateFlagBitsEXT

shiftR :: ShaderCreateFlagBitsEXT -> Int -> ShaderCreateFlagBitsEXT

unsafeShiftR :: ShaderCreateFlagBitsEXT -> Int -> ShaderCreateFlagBitsEXT

rotateL :: ShaderCreateFlagBitsEXT -> Int -> ShaderCreateFlagBitsEXT

rotateR :: ShaderCreateFlagBitsEXT -> Int -> ShaderCreateFlagBitsEXT

popCount :: ShaderCreateFlagBitsEXT -> Int

FiniteBits ShaderCreateFlagBitsEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

finiteBitSize :: ShaderCreateFlagBitsEXT -> Int

countLeadingZeros :: ShaderCreateFlagBitsEXT -> Int

countTrailingZeros :: ShaderCreateFlagBitsEXT -> Int

Read ShaderCreateFlagBitsEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

readsPrec :: Int -> ReadS ShaderCreateFlagBitsEXT

readList :: ReadS [ShaderCreateFlagBitsEXT]

readPrec :: ReadPrec ShaderCreateFlagBitsEXT

readListPrec :: ReadPrec [ShaderCreateFlagBitsEXT]

Show ShaderCreateFlagBitsEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

showsPrec :: Int -> ShaderCreateFlagBitsEXT -> ShowS

show :: ShaderCreateFlagBitsEXT -> String

showList :: [ShaderCreateFlagBitsEXT] -> ShowS

Eq ShaderCreateFlagBitsEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

(==) :: ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT -> Bool

(/=) :: ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT -> Bool

Ord ShaderCreateFlagBitsEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

compare :: ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT -> Ordering

(<) :: ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT -> Bool

(<=) :: ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT -> Bool

(>) :: ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT -> Bool

(>=) :: ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT -> Bool

max :: ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT

min :: ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT -> ShaderCreateFlagBitsEXT

Zero ShaderCreateFlagBitsEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

zero :: ShaderCreateFlagBitsEXT

newtype ShaderCodeTypeEXT

VkShaderCodeTypeEXT - Indicate a shader code type

See Also

VK_EXT_shader_object, ShaderCreateInfoEXT

Constructors

ShaderCodeTypeEXT Int32

Bundled Patterns

pattern SHADER_CODE_TYPE_BINARY_EXT :: ShaderCodeTypeEXT

SHADER_CODE_TYPE_BINARY_EXT specifies shader code in an opaque, implementation-defined binary format specific to the physical device.

pattern SHADER_CODE_TYPE_SPIRV_EXT :: ShaderCodeTypeEXT

SHADER_CODE_TYPE_SPIRV_EXT specifies shader code in SPIR-V format.

Instances

Storable ShaderCodeTypeEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

sizeOf :: ShaderCodeTypeEXT -> Int

alignment :: ShaderCodeTypeEXT -> Int

peekElemOff :: Ptr ShaderCodeTypeEXT -> Int -> IO ShaderCodeTypeEXT

pokeElemOff :: Ptr ShaderCodeTypeEXT -> Int -> ShaderCodeTypeEXT -> IO ()

peekByteOff :: Ptr b -> Int -> IO ShaderCodeTypeEXT

pokeByteOff :: Ptr b -> Int -> ShaderCodeTypeEXT -> IO ()

peek :: Ptr ShaderCodeTypeEXT -> IO ShaderCodeTypeEXT

poke :: Ptr ShaderCodeTypeEXT -> ShaderCodeTypeEXT -> IO ()

Read ShaderCodeTypeEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

readsPrec :: Int -> ReadS ShaderCodeTypeEXT

readList :: ReadS [ShaderCodeTypeEXT]

readPrec :: ReadPrec ShaderCodeTypeEXT

readListPrec :: ReadPrec [ShaderCodeTypeEXT]

Show ShaderCodeTypeEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

showsPrec :: Int -> ShaderCodeTypeEXT -> ShowS

show :: ShaderCodeTypeEXT -> String

showList :: [ShaderCodeTypeEXT] -> ShowS

Eq ShaderCodeTypeEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

(==) :: ShaderCodeTypeEXT -> ShaderCodeTypeEXT -> Bool

(/=) :: ShaderCodeTypeEXT -> ShaderCodeTypeEXT -> Bool

Ord ShaderCodeTypeEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

compare :: ShaderCodeTypeEXT -> ShaderCodeTypeEXT -> Ordering

(<) :: ShaderCodeTypeEXT -> ShaderCodeTypeEXT -> Bool

(<=) :: ShaderCodeTypeEXT -> ShaderCodeTypeEXT -> Bool

(>) :: ShaderCodeTypeEXT -> ShaderCodeTypeEXT -> Bool

(>=) :: ShaderCodeTypeEXT -> ShaderCodeTypeEXT -> Bool

max :: ShaderCodeTypeEXT -> ShaderCodeTypeEXT -> ShaderCodeTypeEXT

min :: ShaderCodeTypeEXT -> ShaderCodeTypeEXT -> ShaderCodeTypeEXT

Zero ShaderCodeTypeEXT

Defined in Vulkan.Extensions.VK_EXT_shader_object

Methods

zero :: ShaderCodeTypeEXT

type ShaderRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo

type EXT_SHADER_OBJECT_SPEC_VERSION = 1

pattern EXT_SHADER_OBJECT_SPEC_VERSION :: forall a. Integral a => a

type EXT_SHADER_OBJECT_EXTENSION_NAME = "VK_EXT_shader_object"

pattern EXT_SHADER_OBJECT_EXTENSION_NAME :: forall a. (Eq a, IsString a) => a

newtype ShaderEXT

VkShaderEXT - Opaque handle to a shader object

See Also

VK_EXT_shader_object, cmdBindShadersEXT, createShadersEXT, destroyShaderEXT, getShaderBinaryDataEXT

Constructors

ShaderEXT Word64

Instances

Storable ShaderEXT

Defined in Vulkan.Extensions.Handles

Methods

sizeOf :: ShaderEXT -> Int

alignment :: ShaderEXT -> Int

peekElemOff :: Ptr ShaderEXT -> Int -> IO ShaderEXT

pokeElemOff :: Ptr ShaderEXT -> Int -> ShaderEXT -> IO ()

peekByteOff :: Ptr b -> Int -> IO ShaderEXT

pokeByteOff :: Ptr b -> Int -> ShaderEXT -> IO ()

peek :: Ptr ShaderEXT -> IO ShaderEXT

poke :: Ptr ShaderEXT -> ShaderEXT -> IO ()

Show ShaderEXT

Defined in Vulkan.Extensions.Handles

Methods

showsPrec :: Int -> ShaderEXT -> ShowS

show :: ShaderEXT -> String

showList :: [ShaderEXT] -> ShowS

Eq ShaderEXT

Defined in Vulkan.Extensions.Handles

Methods

(==) :: ShaderEXT -> ShaderEXT -> Bool

(/=) :: ShaderEXT -> ShaderEXT -> Bool

Ord ShaderEXT

Defined in Vulkan.Extensions.Handles

Methods

compare :: ShaderEXT -> ShaderEXT -> Ordering

(<) :: ShaderEXT -> ShaderEXT -> Bool

(<=) :: ShaderEXT -> ShaderEXT -> Bool

(>) :: ShaderEXT -> ShaderEXT -> Bool

(>=) :: ShaderEXT -> ShaderEXT -> Bool

max :: ShaderEXT -> ShaderEXT -> ShaderEXT

min :: ShaderEXT -> ShaderEXT -> ShaderEXT

HasObjectType ShaderEXT

Defined in Vulkan.Extensions.Handles

Methods

objectTypeAndHandle :: ShaderEXT -> (ObjectType, Word64)

IsHandle ShaderEXT

Defined in Vulkan.Extensions.Handles

Zero ShaderEXT

Defined in Vulkan.Extensions.Handles

Methods

zero :: ShaderEXT

data ViewportSwizzleNV

VkViewportSwizzleNV - Structure specifying a viewport swizzle

Valid Usage (Implicit)

See Also

VK_NV_viewport_swizzle, PipelineViewportSwizzleStateCreateInfoNV, ViewportCoordinateSwizzleNV, cmdSetViewportSwizzleNV

Constructors

ViewportSwizzleNV

Fields

• x :: ViewportCoordinateSwizzleNV

  x is a ViewportCoordinateSwizzleNV value specifying the swizzle operation to apply to the x component of the primitive

  x must be a valid ViewportCoordinateSwizzleNV value

• y :: ViewportCoordinateSwizzleNV

  y is a ViewportCoordinateSwizzleNV value specifying the swizzle operation to apply to the y component of the primitive

  y must be a valid ViewportCoordinateSwizzleNV value

• z :: ViewportCoordinateSwizzleNV

  z is a ViewportCoordinateSwizzleNV value specifying the swizzle operation to apply to the z component of the primitive

  z must be a valid ViewportCoordinateSwizzleNV value

• w :: ViewportCoordinateSwizzleNV

  w is a ViewportCoordinateSwizzleNV value specifying the swizzle operation to apply to the w component of the primitive

  w must be a valid ViewportCoordinateSwizzleNV value

Instances

Storable ViewportSwizzleNV

Defined in Vulkan.Extensions.VK_NV_viewport_swizzle

Methods

sizeOf :: ViewportSwizzleNV -> Int

alignment :: ViewportSwizzleNV -> Int

peekElemOff :: Ptr ViewportSwizzleNV -> Int -> IO ViewportSwizzleNV

pokeElemOff :: Ptr ViewportSwizzleNV -> Int -> ViewportSwizzleNV -> IO ()

peekByteOff :: Ptr b -> Int -> IO ViewportSwizzleNV

pokeByteOff :: Ptr b -> Int -> ViewportSwizzleNV -> IO ()

peek :: Ptr ViewportSwizzleNV -> IO ViewportSwizzleNV

poke :: Ptr ViewportSwizzleNV -> ViewportSwizzleNV -> IO ()

Show ViewportSwizzleNV

Defined in Vulkan.Extensions.VK_NV_viewport_swizzle

Methods

showsPrec :: Int -> ViewportSwizzleNV -> ShowS

show :: ViewportSwizzleNV -> String

showList :: [ViewportSwizzleNV] -> ShowS

Eq ViewportSwizzleNV

Defined in Vulkan.Extensions.VK_NV_viewport_swizzle

Methods

(==) :: ViewportSwizzleNV -> ViewportSwizzleNV -> Bool

(/=) :: ViewportSwizzleNV -> ViewportSwizzleNV -> Bool

FromCStruct ViewportSwizzleNV

Defined in Vulkan.Extensions.VK_NV_viewport_swizzle

Methods

peekCStruct :: Ptr ViewportSwizzleNV -> IO ViewportSwizzleNV

ToCStruct ViewportSwizzleNV

Defined in Vulkan.Extensions.VK_NV_viewport_swizzle

Methods

withCStruct :: ViewportSwizzleNV -> (Ptr ViewportSwizzleNV -> IO b) -> IO b

pokeCStruct :: Ptr ViewportSwizzleNV -> ViewportSwizzleNV -> IO b -> IO b

withZeroCStruct :: (Ptr ViewportSwizzleNV -> IO b) -> IO b

pokeZeroCStruct :: Ptr ViewportSwizzleNV -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero ViewportSwizzleNV

Defined in Vulkan.Extensions.VK_NV_viewport_swizzle

Methods

zero :: ViewportSwizzleNV

data ColorBlendEquationEXT

VkColorBlendEquationEXT - Structure specifying the color blend factors and operations for an attachment

Valid Usage

• If the dualSrcBlend feature is not enabled, srcColorBlendFactor must not be BLEND_FACTOR_SRC1_COLOR, BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, BLEND_FACTOR_SRC1_ALPHA, or BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA

• If the dualSrcBlend feature is not enabled, dstColorBlendFactor must not be BLEND_FACTOR_SRC1_COLOR, BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, BLEND_FACTOR_SRC1_ALPHA, or BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
• If the dualSrcBlend feature is not enabled, srcAlphaBlendFactor must not be BLEND_FACTOR_SRC1_COLOR, BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, BLEND_FACTOR_SRC1_ALPHA, or BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
• If the dualSrcBlend feature is not enabled, dstAlphaBlendFactor must not be BLEND_FACTOR_SRC1_COLOR, BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, BLEND_FACTOR_SRC1_ALPHA, or BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
• colorBlendOp and alphaBlendOp must not be BLEND_OP_ZERO_EXT, BLEND_OP_SRC_EXT, BLEND_OP_DST_EXT, BLEND_OP_SRC_OVER_EXT, BLEND_OP_DST_OVER_EXT, BLEND_OP_SRC_IN_EXT, BLEND_OP_DST_IN_EXT, BLEND_OP_SRC_OUT_EXT, BLEND_OP_DST_OUT_EXT, BLEND_OP_SRC_ATOP_EXT, BLEND_OP_DST_ATOP_EXT, BLEND_OP_XOR_EXT, BLEND_OP_MULTIPLY_EXT, BLEND_OP_SCREEN_EXT, BLEND_OP_OVERLAY_EXT, BLEND_OP_DARKEN_EXT, BLEND_OP_LIGHTEN_EXT, BLEND_OP_COLORDODGE_EXT, BLEND_OP_COLORBURN_EXT, BLEND_OP_HARDLIGHT_EXT, BLEND_OP_SOFTLIGHT_EXT, BLEND_OP_DIFFERENCE_EXT, BLEND_OP_EXCLUSION_EXT, BLEND_OP_INVERT_EXT, BLEND_OP_INVERT_RGB_EXT, BLEND_OP_LINEARDODGE_EXT, BLEND_OP_LINEARBURN_EXT, BLEND_OP_VIVIDLIGHT_EXT, BLEND_OP_LINEARLIGHT_EXT, BLEND_OP_PINLIGHT_EXT, BLEND_OP_HARDMIX_EXT, BLEND_OP_HSL_HUE_EXT, BLEND_OP_HSL_SATURATION_EXT, BLEND_OP_HSL_COLOR_EXT, BLEND_OP_HSL_LUMINOSITY_EXT, BLEND_OP_PLUS_EXT, BLEND_OP_PLUS_CLAMPED_EXT, BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, BLEND_OP_PLUS_DARKER_EXT, BLEND_OP_MINUS_EXT, BLEND_OP_MINUS_CLAMPED_EXT, BLEND_OP_CONTRAST_EXT, BLEND_OP_INVERT_OVG_EXT, BLEND_OP_RED_EXT, BLEND_OP_GREEN_EXT, or BLEND_OP_BLUE_EXT
• If the VK_KHR_portability_subset extension is enabled, and PhysicalDevicePortabilitySubsetFeaturesKHR::constantAlphaColorBlendFactors is FALSE, srcColorBlendFactor must not be BLEND_FACTOR_CONSTANT_ALPHA or BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA
• If the VK_KHR_portability_subset extension is enabled, and PhysicalDevicePortabilitySubsetFeaturesKHR::constantAlphaColorBlendFactors is FALSE, dstColorBlendFactor must not be BLEND_FACTOR_CONSTANT_ALPHA or BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA

Valid Usage (Implicit)

• srcColorBlendFactor must be a valid BlendFactor value

• dstColorBlendFactor must be a valid BlendFactor value
• colorBlendOp must be a valid BlendOp value
• srcAlphaBlendFactor must be a valid BlendFactor value
• dstAlphaBlendFactor must be a valid BlendFactor value
• alphaBlendOp must be a valid BlendOp value

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, BlendFactor, BlendOp, cmdSetColorBlendEquationEXT

Constructors

ColorBlendEquationEXT

Fields

• srcColorBlendFactor :: BlendFactor

  srcColorBlendFactor selects which blend factor is used to determine the source factors (Sr,Sg,Sb).

• dstColorBlendFactor :: BlendFactor

  dstColorBlendFactor selects which blend factor is used to determine the destination factors (Dr,Dg,Db).

• colorBlendOp :: BlendOp

  colorBlendOp selects which blend operation is used to calculate the RGB values to write to the color attachment.

• srcAlphaBlendFactor :: BlendFactor

  srcAlphaBlendFactor selects which blend factor is used to determine the source factor Sa.

• dstAlphaBlendFactor :: BlendFactor

  dstAlphaBlendFactor selects which blend factor is used to determine the destination factor Da.

• alphaBlendOp :: BlendOp

  alphaBlendOp selects which blend operation is use to calculate the alpha values to write to the color attachment.

Instances

Storable ColorBlendEquationEXT

Defined in Vulkan.Extensions.VK_EXT_extended_dynamic_state3

Methods

sizeOf :: ColorBlendEquationEXT -> Int

alignment :: ColorBlendEquationEXT -> Int

peekElemOff :: Ptr ColorBlendEquationEXT -> Int -> IO ColorBlendEquationEXT

pokeElemOff :: Ptr ColorBlendEquationEXT -> Int -> ColorBlendEquationEXT -> IO ()

peekByteOff :: Ptr b -> Int -> IO ColorBlendEquationEXT

pokeByteOff :: Ptr b -> Int -> ColorBlendEquationEXT -> IO ()

peek :: Ptr ColorBlendEquationEXT -> IO ColorBlendEquationEXT

poke :: Ptr ColorBlendEquationEXT -> ColorBlendEquationEXT -> IO ()

Show ColorBlendEquationEXT

Defined in Vulkan.Extensions.VK_EXT_extended_dynamic_state3

Methods

showsPrec :: Int -> ColorBlendEquationEXT -> ShowS

show :: ColorBlendEquationEXT -> String

showList :: [ColorBlendEquationEXT] -> ShowS

Eq ColorBlendEquationEXT

Defined in Vulkan.Extensions.VK_EXT_extended_dynamic_state3

Methods

(==) :: ColorBlendEquationEXT -> ColorBlendEquationEXT -> Bool

(/=) :: ColorBlendEquationEXT -> ColorBlendEquationEXT -> Bool

FromCStruct ColorBlendEquationEXT

Defined in Vulkan.Extensions.VK_EXT_extended_dynamic_state3

Methods

peekCStruct :: Ptr ColorBlendEquationEXT -> IO ColorBlendEquationEXT

ToCStruct ColorBlendEquationEXT

Defined in Vulkan.Extensions.VK_EXT_extended_dynamic_state3

Methods

withCStruct :: ColorBlendEquationEXT -> (Ptr ColorBlendEquationEXT -> IO b) -> IO b

pokeCStruct :: Ptr ColorBlendEquationEXT -> ColorBlendEquationEXT -> IO b -> IO b

withZeroCStruct :: (Ptr ColorBlendEquationEXT -> IO b) -> IO b

pokeZeroCStruct :: Ptr ColorBlendEquationEXT -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero ColorBlendEquationEXT

Defined in Vulkan.Extensions.VK_EXT_extended_dynamic_state3

Methods

zero :: ColorBlendEquationEXT

data ColorBlendAdvancedEXT

VkColorBlendAdvancedEXT - Structure specifying the advanced blend operation parameters for an attachment

Valid Usage

• If the non-premultiplied source color property is not supported, srcPremultiplied must be TRUE

• If the non-premultiplied destination color property is not supported, dstPremultiplied must be TRUE
• If the correlated overlap property is not supported, blendOverlap must be BLEND_OVERLAP_UNCORRELATED_EXT

Valid Usage (Implicit)

• advancedBlendOp must be a valid BlendOp value

• blendOverlap must be a valid BlendOverlapEXT value

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, BlendOp, BlendOverlapEXT, Bool32, cmdSetColorBlendAdvancedEXT

Constructors

ColorBlendAdvancedEXT

Fields

• advancedBlendOp :: BlendOp

  advancedBlendOp selects which blend operation is used to calculate the RGB values to write to the color attachment.

• srcPremultiplied :: Bool

  srcPremultiplied specifies whether the source color of the blend operation is treated as premultiplied.

• dstPremultiplied :: Bool

  dstPremultiplied specifies whether the destination color of the blend operation is treated as premultiplied.

• blendOverlap :: BlendOverlapEXT

  blendOverlap is a BlendOverlapEXT value specifying how the source and destination sample’s coverage is correlated.

• clampResults :: Bool

  clampResults specifies the results must be clamped to the [0,1] range before writing to the attachment, which is useful when the attachment format is not normalized fixed-point.

Instances

Storable ColorBlendAdvancedEXT

Defined in Vulkan.Extensions.VK_EXT_extended_dynamic_state3

Methods

sizeOf :: ColorBlendAdvancedEXT -> Int

alignment :: ColorBlendAdvancedEXT -> Int

peekElemOff :: Ptr ColorBlendAdvancedEXT -> Int -> IO ColorBlendAdvancedEXT

pokeElemOff :: Ptr ColorBlendAdvancedEXT -> Int -> ColorBlendAdvancedEXT -> IO ()

peekByteOff :: Ptr b -> Int -> IO ColorBlendAdvancedEXT

pokeByteOff :: Ptr b -> Int -> ColorBlendAdvancedEXT -> IO ()

peek :: Ptr ColorBlendAdvancedEXT -> IO ColorBlendAdvancedEXT

poke :: Ptr ColorBlendAdvancedEXT -> ColorBlendAdvancedEXT -> IO ()

Show ColorBlendAdvancedEXT

Defined in Vulkan.Extensions.VK_EXT_extended_dynamic_state3

Methods

showsPrec :: Int -> ColorBlendAdvancedEXT -> ShowS

show :: ColorBlendAdvancedEXT -> String

showList :: [ColorBlendAdvancedEXT] -> ShowS

Eq ColorBlendAdvancedEXT

Defined in Vulkan.Extensions.VK_EXT_extended_dynamic_state3

Methods

(==) :: ColorBlendAdvancedEXT -> ColorBlendAdvancedEXT -> Bool

(/=) :: ColorBlendAdvancedEXT -> ColorBlendAdvancedEXT -> Bool

FromCStruct ColorBlendAdvancedEXT

Defined in Vulkan.Extensions.VK_EXT_extended_dynamic_state3

Methods

peekCStruct :: Ptr ColorBlendAdvancedEXT -> IO ColorBlendAdvancedEXT

ToCStruct ColorBlendAdvancedEXT

Defined in Vulkan.Extensions.VK_EXT_extended_dynamic_state3

Methods

withCStruct :: ColorBlendAdvancedEXT -> (Ptr ColorBlendAdvancedEXT -> IO b) -> IO b

pokeCStruct :: Ptr ColorBlendAdvancedEXT -> ColorBlendAdvancedEXT -> IO b -> IO b

withZeroCStruct :: (Ptr ColorBlendAdvancedEXT -> IO b) -> IO b

pokeZeroCStruct :: Ptr ColorBlendAdvancedEXT -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero ColorBlendAdvancedEXT

Defined in Vulkan.Extensions.VK_EXT_extended_dynamic_state3

Methods

zero :: ColorBlendAdvancedEXT

data VertexInputBindingDescription2EXT

VkVertexInputBindingDescription2EXT - Structure specifying the extended vertex input binding description

Valid Usage

• binding must be less than PhysicalDeviceLimits::maxVertexInputBindings

• stride must be less than or equal to PhysicalDeviceLimits::maxVertexInputBindingStride
• If the vertexAttributeInstanceRateZeroDivisor feature is not enabled, divisor must not be 0
• If the vertexAttributeInstanceRateDivisor feature is not enabled, divisor must be 1
• divisor must be a value between 0 and PhysicalDeviceVertexAttributeDivisorPropertiesEXT::maxVertexAttribDivisor, inclusive
• If divisor is not 1 then inputRate must be of type VERTEX_INPUT_RATE_INSTANCE

Valid Usage (Implicit)

• sType must be STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT

• inputRate must be a valid VertexInputRate value

See Also

VK_EXT_shader_object, VK_EXT_vertex_input_dynamic_state, StructureType, VertexInputRate, cmdSetVertexInputEXT

Constructors

VertexInputBindingDescription2EXT

Fields

• binding :: Word32

  binding is the binding number that this structure describes.

• stride :: Word32

  stride is the byte stride between consecutive elements within the buffer.

• inputRate :: VertexInputRate

  inputRate is a VertexInputRate value specifying whether vertex attribute addressing is a function of the vertex index or of the instance index.

• divisor :: Word32

  divisor is the number of successive instances that will use the same value of the vertex attribute when instanced rendering is enabled. This member can be set to a value other than 1 if the vertexAttributeInstanceRateDivisor feature is enabled. For example, if the divisor is N, the same vertex attribute will be applied to N successive instances before moving on to the next vertex attribute. The maximum value of divisor is implementation-dependent and can be queried using PhysicalDeviceVertexAttributeDivisorPropertiesEXT::maxVertexAttribDivisor. A value of 0 can be used for the divisor if the vertexAttributeInstanceRateZeroDivisor feature is enabled. In this case, the same vertex attribute will be applied to all instances.

Instances

Storable VertexInputBindingDescription2EXT

Defined in Vulkan.Extensions.VK_EXT_vertex_input_dynamic_state

Methods

sizeOf :: VertexInputBindingDescription2EXT -> Int

alignment :: VertexInputBindingDescription2EXT -> Int

peekElemOff :: Ptr VertexInputBindingDescription2EXT -> Int -> IO VertexInputBindingDescription2EXT

pokeElemOff :: Ptr VertexInputBindingDescription2EXT -> Int -> VertexInputBindingDescription2EXT -> IO ()

peekByteOff :: Ptr b -> Int -> IO VertexInputBindingDescription2EXT

pokeByteOff :: Ptr b -> Int -> VertexInputBindingDescription2EXT -> IO ()

peek :: Ptr VertexInputBindingDescription2EXT -> IO VertexInputBindingDescription2EXT

poke :: Ptr VertexInputBindingDescription2EXT -> VertexInputBindingDescription2EXT -> IO ()

Show VertexInputBindingDescription2EXT

Defined in Vulkan.Extensions.VK_EXT_vertex_input_dynamic_state

Methods

showsPrec :: Int -> VertexInputBindingDescription2EXT -> ShowS

show :: VertexInputBindingDescription2EXT -> String

showList :: [VertexInputBindingDescription2EXT] -> ShowS

Eq VertexInputBindingDescription2EXT

Defined in Vulkan.Extensions.VK_EXT_vertex_input_dynamic_state

Methods

(==) :: VertexInputBindingDescription2EXT -> VertexInputBindingDescription2EXT -> Bool

(/=) :: VertexInputBindingDescription2EXT -> VertexInputBindingDescription2EXT -> Bool

FromCStruct VertexInputBindingDescription2EXT

Defined in Vulkan.Extensions.VK_EXT_vertex_input_dynamic_state

Methods

peekCStruct :: Ptr VertexInputBindingDescription2EXT -> IO VertexInputBindingDescription2EXT

ToCStruct VertexInputBindingDescription2EXT

Defined in Vulkan.Extensions.VK_EXT_vertex_input_dynamic_state

Methods

withCStruct :: VertexInputBindingDescription2EXT -> (Ptr VertexInputBindingDescription2EXT -> IO b) -> IO b

pokeCStruct :: Ptr VertexInputBindingDescription2EXT -> VertexInputBindingDescription2EXT -> IO b -> IO b

withZeroCStruct :: (Ptr VertexInputBindingDescription2EXT -> IO b) -> IO b

pokeZeroCStruct :: Ptr VertexInputBindingDescription2EXT -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero VertexInputBindingDescription2EXT

Defined in Vulkan.Extensions.VK_EXT_vertex_input_dynamic_state

Methods

zero :: VertexInputBindingDescription2EXT

data VertexInputAttributeDescription2EXT

VkVertexInputAttributeDescription2EXT - Structure specifying the extended vertex input attribute description

Valid Usage

• location must be less than PhysicalDeviceLimits::maxVertexInputAttributes

• binding must be less than PhysicalDeviceLimits::maxVertexInputBindings
• offset must be less than or equal to PhysicalDeviceLimits::maxVertexInputAttributeOffset
• The format features of format must contain FORMAT_FEATURE_VERTEX_BUFFER_BIT
• If the VK_KHR_portability_subset extension is enabled, and PhysicalDevicePortabilitySubsetFeaturesKHR::vertexAttributeAccessBeyondStride is FALSE, the sum of offset plus the size of the vertex attribute data described by format must not be greater than stride in the VertexInputBindingDescription2EXT referenced in binding

Valid Usage (Implicit)

• sType must be STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT

• format must be a valid Format value

See Also

VK_EXT_shader_object, VK_EXT_vertex_input_dynamic_state, Format, StructureType, cmdSetVertexInputEXT

Constructors

VertexInputAttributeDescription2EXT

Fields

• location :: Word32

  location is the shader input location number for this attribute.

• binding :: Word32

  binding is the binding number which this attribute takes its data from.

• format :: Format

  format is the size and type of the vertex attribute data.

• offset :: Word32

  offset is a byte offset of this attribute relative to the start of an element in the vertex input binding.

Instances

Storable VertexInputAttributeDescription2EXT

Defined in Vulkan.Extensions.VK_EXT_vertex_input_dynamic_state

Methods

sizeOf :: VertexInputAttributeDescription2EXT -> Int

alignment :: VertexInputAttributeDescription2EXT -> Int

peekElemOff :: Ptr VertexInputAttributeDescription2EXT -> Int -> IO VertexInputAttributeDescription2EXT

pokeElemOff :: Ptr VertexInputAttributeDescription2EXT -> Int -> VertexInputAttributeDescription2EXT -> IO ()

peekByteOff :: Ptr b -> Int -> IO VertexInputAttributeDescription2EXT

pokeByteOff :: Ptr b -> Int -> VertexInputAttributeDescription2EXT -> IO ()

peek :: Ptr VertexInputAttributeDescription2EXT -> IO VertexInputAttributeDescription2EXT

poke :: Ptr VertexInputAttributeDescription2EXT -> VertexInputAttributeDescription2EXT -> IO ()

Show VertexInputAttributeDescription2EXT

Defined in Vulkan.Extensions.VK_EXT_vertex_input_dynamic_state

Methods

showsPrec :: Int -> VertexInputAttributeDescription2EXT -> ShowS

show :: VertexInputAttributeDescription2EXT -> String

showList :: [VertexInputAttributeDescription2EXT] -> ShowS

Eq VertexInputAttributeDescription2EXT

Defined in Vulkan.Extensions.VK_EXT_vertex_input_dynamic_state

Methods

(==) :: VertexInputAttributeDescription2EXT -> VertexInputAttributeDescription2EXT -> Bool

(/=) :: VertexInputAttributeDescription2EXT -> VertexInputAttributeDescription2EXT -> Bool

FromCStruct VertexInputAttributeDescription2EXT

Defined in Vulkan.Extensions.VK_EXT_vertex_input_dynamic_state

Methods

peekCStruct :: Ptr VertexInputAttributeDescription2EXT -> IO VertexInputAttributeDescription2EXT

ToCStruct VertexInputAttributeDescription2EXT

Defined in Vulkan.Extensions.VK_EXT_vertex_input_dynamic_state

Methods

withCStruct :: VertexInputAttributeDescription2EXT -> (Ptr VertexInputAttributeDescription2EXT -> IO b) -> IO b

pokeCStruct :: Ptr VertexInputAttributeDescription2EXT -> VertexInputAttributeDescription2EXT -> IO b -> IO b

withZeroCStruct :: (Ptr VertexInputAttributeDescription2EXT -> IO b) -> IO b

pokeZeroCStruct :: Ptr VertexInputAttributeDescription2EXT -> IO b -> IO b

cStructSize :: Int

cStructAlignment :: Int

Zero VertexInputAttributeDescription2EXT

Defined in Vulkan.Extensions.VK_EXT_vertex_input_dynamic_state

Methods

zero :: VertexInputAttributeDescription2EXT

cmdSetPatchControlPointsEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("patchControlPoints" ::: Word32)

patchControlPoints specifies the number of control points per patch.

-> io ()

vkCmdSetPatchControlPointsEXT - Specify the number of control points per patch dynamically for a command buffer

Description

This command sets the number of control points per patch for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineTessellationStateCreateInfo::patchControlPoints value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState2PatchControlPoints feature is enabled
  • The shaderObject feature is enabled

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

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state2, VK_EXT_shader_object, CommandBuffer

cmdSetLogicOpEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> LogicOp

logicOp specifies the logical operation to apply for blend state.

-> io ()

vkCmdSetLogicOpEXT - Select which logical operation to apply for blend state dynamically for a command buffer

Description

This command sets the logical operation for blend state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_LOGIC_OP_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineColorBlendStateCreateInfo::logicOp value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState2LogicOp feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• logicOp must be a valid LogicOp value
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state2, VK_EXT_shader_object, CommandBuffer, LogicOp

cmdSetTessellationDomainOriginEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> TessellationDomainOrigin

domainOrigin specifies the origin of the tessellation domain space.

-> io ()

vkCmdSetTessellationDomainOriginEXT - Specify the origin of the tessellation domain space dynamically for a command buffer

Description

This command sets the origin of the tessellation domain space for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineTessellationDomainOriginStateCreateInfo::domainOrigin value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3TessellationDomainOrigin feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• domainOrigin must be a valid TessellationDomainOrigin value
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, CommandBuffer, TessellationDomainOrigin

cmdSetDepthClampEnableEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("depthClampEnable" ::: Bool)

depthClampEnable specifies whether depth clamping is enabled.

-> io ()

vkCmdSetDepthClampEnableEXT - Specify dynamically whether depth clamping is enabled in the command buffer

Description

This command sets whether depth clamping is enabled or disabled for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineRasterizationStateCreateInfo::depthClampEnable value used to create the currently active pipeline.

If the depth clamping state is changed dynamically, and the pipeline was not created with DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT enabled, then depth clipping is enabled when depth clamping is disabled and vice versa.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3DepthClampEnable feature is enabled
  • The shaderObject feature is enabled

• If the depthClamp feature is not enabled, depthClampEnable must be FALSE

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, Bool32, CommandBuffer

cmdSetPolygonModeEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> PolygonMode

polygonMode specifies polygon mode.

-> io ()

vkCmdSetPolygonModeEXT - Specify polygon mode dynamically for a command buffer

Description

This command sets the polygon mode for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_POLYGON_MODE_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineRasterizationStateCreateInfo::polygonMode value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3PolygonMode feature is enabled
  • The shaderObject feature is enabled

• If the fillModeNonSolid feature is not enabled, polygonMode must be POLYGON_MODE_FILL or POLYGON_MODE_FILL_RECTANGLE_NV
• If the VK_NV_fill_rectangle extension is not enabled, polygonMode must not be POLYGON_MODE_FILL_RECTANGLE_NV

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• polygonMode must be a valid PolygonMode value
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, CommandBuffer, PolygonMode

cmdSetRasterizationSamplesEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("rasterizationSamples" ::: SampleCountFlagBits)

rasterizationSamples specifies rasterizationSamples.

-> io ()

vkCmdSetRasterizationSamplesEXT - Specify the rasterization samples dynamically for a command buffer

Description

This command sets the rasterizationSamples for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineMultisampleStateCreateInfo::rasterizationSamples value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3RasterizationSamples feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• rasterizationSamples must be a valid SampleCountFlagBits value
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, CommandBuffer, SampleCountFlagBits

cmdSetSampleMaskEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("samples" ::: SampleCountFlagBits)

samples specifies the number of sample bits in the pSampleMask.

-> ("sampleMask" ::: Vector SampleMask)

pSampleMask is a pointer to an array of SampleMask values, where the array size is based on the samples parameter.

-> io ()

vkCmdSetSampleMaskEXT - Specify the sample mask dynamically for a command buffer

Description

This command sets the sample mask for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_SAMPLE_MASK_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineMultisampleStateCreateInfo::pSampleMask value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3SampleMask feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• samples must be a valid SampleCountFlagBits value
• pSampleMask must be a valid pointer to an array of \(\lceil{\mathit{samples} \over 32}\rceil\) SampleMask values
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, CommandBuffer, SampleCountFlagBits, SampleMask

cmdSetAlphaToCoverageEnableEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("alphaToCoverageEnable" ::: Bool)

alphaToCoverageEnable specifies the alphaToCoverageEnable state.

-> io ()

vkCmdSetAlphaToCoverageEnableEXT - Specify the alpha to coverage enable state dynamically for a command buffer

Description

This command sets the alphaToCoverageEnable state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineMultisampleStateCreateInfo::alphaToCoverageEnable value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3AlphaToCoverageEnable feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, Bool32, CommandBuffer

cmdSetAlphaToOneEnableEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("alphaToOneEnable" ::: Bool)

alphaToOneEnable specifies the alphaToOneEnable state.

-> io ()

vkCmdSetAlphaToOneEnableEXT - Specify the alpha to one enable state dynamically for a command buffer

Description

This command sets the alphaToOneEnable state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineMultisampleStateCreateInfo::alphaToOneEnable value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3AlphaToOneEnable feature is enabled
  • The shaderObject feature is enabled

• If the alphaToOne feature is not enabled, alphaToOneEnable must be FALSE

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, Bool32, CommandBuffer

cmdSetLogicOpEnableEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("logicOpEnable" ::: Bool)

logicOpEnable specifies whether logical operations are enabled.

-> io ()

vkCmdSetLogicOpEnableEXT - Specify dynamically whether logical operations are enabled for a command buffer

Description

This command sets whether logical operations are enabled for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineColorBlendStateCreateInfo::logicOpEnable value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3LogicOpEnable feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, Bool32, CommandBuffer

cmdSetColorBlendEnableEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("firstAttachment" ::: Word32)

firstAttachment the first color attachment the color blending enable applies.

-> ("colorBlendEnables" ::: Vector Bool)

pColorBlendEnables an array of booleans to indicate whether color blending is enabled for the corresponding attachment.

-> io ()

vkCmdSetColorBlendEnableEXT - Specify the blendEnable for each attachment dynamically for a command buffer

Description

This command sets the color blending enable of the specified color attachments for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineColorBlendAttachmentState::blendEnable values used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3ColorBlendEnable feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• pColorBlendEnables must be a valid pointer to an array of attachmentCount Bool32 values
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope
• attachmentCount must be greater than 0

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, Bool32, CommandBuffer

cmdSetColorBlendEquationEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("firstAttachment" ::: Word32)

firstAttachment the first color attachment the color blend factors and operations apply to.

-> ("colorBlendEquations" ::: Vector ColorBlendEquationEXT)

pColorBlendEquations an array of ColorBlendEquationEXT structs that specify the color blend factors and operations for the corresponding attachments.

-> io ()

vkCmdSetColorBlendEquationEXT - Specify the blend factors and operations dynamically for a command buffer

Description

This command sets the color blending factors and operations of the specified attachments for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineColorBlendAttachmentState::srcColorBlendFactor, PipelineColorBlendAttachmentState::dstColorBlendFactor, PipelineColorBlendAttachmentState::colorBlendOp, PipelineColorBlendAttachmentState::srcAlphaBlendFactor, PipelineColorBlendAttachmentState::dstAlphaBlendFactor, and PipelineColorBlendAttachmentState::alphaBlendOp values used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3ColorBlendEquation feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• pColorBlendEquations must be a valid pointer to an array of attachmentCount valid ColorBlendEquationEXT structures
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope
• attachmentCount must be greater than 0

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, ColorBlendEquationEXT, CommandBuffer

cmdSetColorWriteMaskEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("firstAttachment" ::: Word32)

firstAttachment the first color attachment the color write masks apply to.

-> ("colorWriteMasks" ::: Vector ColorComponentFlags)

pColorWriteMasks an array of ColorComponentFlags values that specify the color write masks of the corresponding attachments.

-> io ()

vkCmdSetColorWriteMaskEXT - Specify the color write masks for each attachment dynamically for a command buffer

Description

This command sets the color write masks of the specified attachments for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_COLOR_WRITE_MASK_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineColorBlendAttachmentState::colorWriteMask values used to create the currently active pipeline.

Note

Formats with bits that are shared between components specified by ColorComponentFlagBits, such as FORMAT_E5B9G9R9_UFLOAT_PACK32, cannot have their channels individually masked by this functionality; either all components that share bits have to be enabled, or none of them.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3ColorWriteMask feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• pColorWriteMasks must be a valid pointer to an array of attachmentCount valid combinations of ColorComponentFlagBits values
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope
• attachmentCount must be greater than 0

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, ColorComponentFlags, CommandBuffer

cmdSetRasterizationStreamEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("rasterizationStream" ::: Word32)

rasterizationStream specifies the rasterizationStream state.

-> io ()

vkCmdSetRasterizationStreamEXT - Specify the rasterization stream dynamically for a command buffer

Description

This command sets the rasterizationStream state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_RASTERIZATION_STREAM_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3RasterizationStream feature is enabled
  • The shaderObject feature is enabled

• The transformFeedback feature must be enabled
• rasterizationStream must be less than PhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams
• rasterizationStream must be zero if PhysicalDeviceTransformFeedbackPropertiesEXT::transformFeedbackRasterizationStreamSelect is FALSE

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, CommandBuffer

cmdSetConservativeRasterizationModeEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ConservativeRasterizationModeEXT

conservativeRasterizationMode specifies the conservativeRasterizationMode state.

-> io ()

vkCmdSetConservativeRasterizationModeEXT - Specify the conservative rasterization mode dynamically for a command buffer

Description

This command sets the conservativeRasterizationMode state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineRasterizationConservativeStateCreateInfoEXT::conservativeRasterizationMode value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3ConservativeRasterizationMode feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• conservativeRasterizationMode must be a valid ConservativeRasterizationModeEXT value
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, CommandBuffer, ConservativeRasterizationModeEXT

cmdSetExtraPrimitiveOverestimationSizeEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("extraPrimitiveOverestimationSize" ::: Float)

extraPrimitiveOverestimationSize specifies the extraPrimitiveOverestimationSize.

-> io ()

vkCmdSetExtraPrimitiveOverestimationSizeEXT - Specify the conservative rasterization extra primitive overestimation size dynamically for a command buffer

Description

This command sets the extraPrimitiveOverestimationSize for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineRasterizationConservativeStateCreateInfoEXT::extraPrimitiveOverestimationSize value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3ExtraPrimitiveOverestimationSize feature is enabled
  • The shaderObject feature is enabled

• extraPrimitiveOverestimationSize must be in the range of 0.0 to PhysicalDeviceConservativeRasterizationPropertiesEXT::maxExtraPrimitiveOverestimationSize inclusive

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, CommandBuffer

cmdSetDepthClipEnableEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("depthClipEnable" ::: Bool)

depthClipEnable specifies whether depth clipping is enabled.

-> io ()

vkCmdSetDepthClipEnableEXT - Specify dynamically whether depth clipping is enabled in the command buffer

Description

This command sets whether depth clipping is enabled or disabled for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineRasterizationDepthClipStateCreateInfoEXT::depthClipEnable value used to create the currently active pipeline, or is set to the inverse of PipelineRasterizationStateCreateInfo::depthClampEnable if PipelineRasterizationDepthClipStateCreateInfoEXT is not specified.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3DepthClipEnable feature is enabled
  • The shaderObject feature is enabled

• The depthClipEnable feature must be enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, Bool32, CommandBuffer

cmdSetSampleLocationsEnableEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("sampleLocationsEnable" ::: Bool)

sampleLocationsEnable specifies the sampleLocationsEnable state.

-> io ()

vkCmdSetSampleLocationsEnableEXT - Specify the samples locations enable state dynamically for a command buffer

Description

This command sets the sampleLocationsEnable state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3SampleLocationsEnable feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, Bool32, CommandBuffer

cmdSetColorBlendAdvancedEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("firstAttachment" ::: Word32)

firstAttachment the first color attachment the advanced blend parameters apply to.

-> ("colorBlendAdvanced" ::: Vector ColorBlendAdvancedEXT)

pColorBlendAdvanced an array of ColorBlendAdvancedEXT structs that specify the advanced color blend parameters for the corresponding attachments.

-> io ()

vkCmdSetColorBlendAdvancedEXT - Specify the advanced color blend state dynamically for a command buffer

Description

This command sets the advanced blend operation parameters of the specified attachments for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineColorBlendAdvancedStateCreateInfoEXT::srcPremultiplied, PipelineColorBlendAdvancedStateCreateInfoEXT::dstPremultiplied, and PipelineColorBlendAdvancedStateCreateInfoEXT::blendOverlap values used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3ColorBlendAdvanced feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• pColorBlendAdvanced must be a valid pointer to an array of attachmentCount valid ColorBlendAdvancedEXT structures
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope
• attachmentCount must be greater than 0

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, ColorBlendAdvancedEXT, CommandBuffer

cmdSetProvokingVertexModeEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ProvokingVertexModeEXT

provokingVertexMode specifies the provokingVertexMode state.

-> io ()

vkCmdSetProvokingVertexModeEXT - Specify the provoking vertex mode dynamically for a command buffer

Description

This command sets the provokingVertexMode state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineRasterizationProvokingVertexStateCreateInfoEXT::provokingVertexMode value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3ProvokingVertexMode feature is enabled
  • The shaderObject feature is enabled

• If provokingVertexMode is PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT, then the provokingVertexLast feature must be enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• provokingVertexMode must be a valid ProvokingVertexModeEXT value
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, CommandBuffer, ProvokingVertexModeEXT

cmdSetLineRasterizationModeEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> LineRasterizationModeEXT

lineRasterizationMode specifies the lineRasterizationMode state.

-> io ()

vkCmdSetLineRasterizationModeEXT - Specify the line rasterization mode dynamically for a command buffer

Description

This command sets the lineRasterizationMode state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineRasterizationLineStateCreateInfoEXT::lineRasterizationMode value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3LineRasterizationMode feature is enabled
  • The shaderObject feature is enabled

• If lineRasterizationMode is LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the rectangularLines feature must be enabled
• If lineRasterizationMode is LINE_RASTERIZATION_MODE_BRESENHAM_EXT, then the bresenhamLines feature must be enabled
• If lineRasterizationMode is LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT, then the smoothLines feature must be enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• lineRasterizationMode must be a valid LineRasterizationModeEXT value
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, CommandBuffer, LineRasterizationModeEXT

cmdSetLineStippleEnableEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("stippledLineEnable" ::: Bool)

stippledLineEnable specifies the stippledLineEnable state.

-> io ()

vkCmdSetLineStippleEnableEXT - Specify the line stipple enable dynamically for a command buffer

Description

This command sets the stippledLineEnable state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineRasterizationLineStateCreateInfoEXT::stippledLineEnable value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3LineStippleEnable feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, Bool32, CommandBuffer

cmdSetDepthClipNegativeOneToOneEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("negativeOneToOne" ::: Bool)

negativeOneToOne specifies the negativeOneToOne state.

-> io ()

vkCmdSetDepthClipNegativeOneToOneEXT - Specify the negative one to one depth clip mode dynamically for a command buffer

Description

This command sets the negativeOneToOne state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineViewportDepthClipControlCreateInfoEXT::negativeOneToOne value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3DepthClipNegativeOneToOne feature is enabled
  • The shaderObject feature is enabled

• The depthClipControl feature must be enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, Bool32, CommandBuffer

cmdSetViewportWScalingEnableNV

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("viewportWScalingEnable" ::: Bool)

viewportWScalingEnable specifies the viewportWScalingEnable state.

-> io ()

vkCmdSetViewportWScalingEnableNV - Specify the viewport W scaling enable state dynamically for a command buffer

Description

This command sets the viewportWScalingEnable state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineViewportWScalingStateCreateInfoNV::viewportWScalingEnable value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3ViewportWScalingEnable feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_clip_space_w_scaling, Bool32, CommandBuffer

cmdSetViewportSwizzleNV

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("firstViewport" ::: Word32)

firstViewport is the index of the first viewport whose parameters are updated by the command.

-> ("viewportSwizzles" ::: Vector ViewportSwizzleNV)

pViewportSwizzles is a pointer to an array of ViewportSwizzleNV structures specifying viewport swizzles.

-> io ()

vkCmdSetViewportSwizzleNV - Specify the viewport swizzle state dynamically for a command buffer

Description

This command sets the viewport swizzle state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineViewportSwizzleStateCreateInfoNV::viewportCount, and PipelineViewportSwizzleStateCreateInfoNV::pViewportSwizzles values used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3ViewportSwizzle feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• pViewportSwizzles must be a valid pointer to an array of viewportCount valid ViewportSwizzleNV structures
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope
• viewportCount must be greater than 0

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_viewport_swizzle, CommandBuffer, ViewportSwizzleNV

cmdSetCoverageToColorEnableNV

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("coverageToColorEnable" ::: Bool)

coverageToColorEnable specifies the coverageToColorEnable state.

-> io ()

vkCmdSetCoverageToColorEnableNV - Specify the coverage to color enable state dynamically for a command buffer

Description

This command sets the coverageToColorEnable state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineCoverageToColorStateCreateInfoNV::coverageToColorEnable value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3CoverageToColorEnable feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_fragment_coverage_to_color, Bool32, CommandBuffer

cmdSetCoverageToColorLocationNV

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("coverageToColorLocation" ::: Word32)

coverageToColorLocation specifies the coverageToColorLocation state.

-> io ()

vkCmdSetCoverageToColorLocationNV - Specify the coverage to color location dynamically for a command buffer

Description

This command sets the coverageToColorLocation state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineCoverageToColorStateCreateInfoNV::coverageToColorLocation value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3CoverageToColorLocation feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_fragment_coverage_to_color, CommandBuffer

cmdSetCoverageModulationModeNV

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> CoverageModulationModeNV

coverageModulationMode specifies the coverageModulationMode state.

-> io ()

vkCmdSetCoverageModulationModeNV - Specify the coverage modulation mode dynamically for a command buffer

Description

This command sets the coverageModulationMode state for subsequent drawing commands when drawing using shader objects, or the graphics pipeline is created with DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineCoverageModulationStateCreateInfoNV::coverageModulationMode value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3CoverageModulationMode feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• coverageModulationMode must be a valid CoverageModulationModeNV value
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_framebuffer_mixed_samples, CommandBuffer, CoverageModulationModeNV

cmdSetCoverageModulationTableEnableNV

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("coverageModulationTableEnable" ::: Bool)

coverageModulationTableEnable specifies the coverageModulationTableEnable state.

-> io ()

vkCmdSetCoverageModulationTableEnableNV - Specify the coverage modulation table enable state dynamically for a command buffer

Description

This command sets the coverageModulationTableEnable state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineCoverageModulationStateCreateInfoNV::coverageModulationTableEnable value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3CoverageModulationTableEnable feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_framebuffer_mixed_samples, Bool32, CommandBuffer

cmdSetCoverageModulationTableNV

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("coverageModulationTable" ::: Vector Float)

pCoverageModulationTable specifies the table of modulation factors containing a value for each number of covered samples.

-> io ()

vkCmdSetCoverageModulationTableNV - Specify the coverage modulation table dynamically for a command buffer

Description

This command sets the table of modulation factors for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineCoverageModulationStateCreateInfoNV::coverageModulationTableCount, and PipelineCoverageModulationStateCreateInfoNV::pCoverageModulationTable values used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3CoverageModulationTable feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• pCoverageModulationTable must be a valid pointer to an array of coverageModulationTableCount float values
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope
• coverageModulationTableCount must be greater than 0

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_framebuffer_mixed_samples, CommandBuffer

cmdSetShadingRateImageEnableNV

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("shadingRateImageEnable" ::: Bool)

shadingRateImageEnable specifies the shadingRateImageEnable state.

-> io ()

vkCmdSetShadingRateImageEnableNV - Specify the shading rate image enable state dynamically for a command buffer

Description

This command sets the shadingRateImageEnable state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineViewportShadingRateImageStateCreateInfoNV::shadingRateImageEnable value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3ShadingRateImageEnable feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_shading_rate_image, Bool32, CommandBuffer

cmdSetCoverageReductionModeNV

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> CoverageReductionModeNV

coverageReductionMode specifies the coverageReductionMode state.

-> io ()

vkCmdSetCoverageReductionModeNV - Specify the coverage reduction mode dynamically for a command buffer

Description

This command sets the coverageReductionMode state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineCoverageReductionStateCreateInfoNV::coverageReductionMode value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3CoverageReductionMode feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• coverageReductionMode must be a valid CoverageReductionModeNV value
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_coverage_reduction_mode, CommandBuffer, CoverageReductionModeNV

cmdSetRepresentativeFragmentTestEnableNV

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("representativeFragmentTestEnable" ::: Bool)

representativeFragmentTestEnable specifies the representativeFragmentTestEnable state.

-> io ()

vkCmdSetRepresentativeFragmentTestEnableNV - Specify the representative fragment test enable dynamically for a command buffer

Description

This command sets the representativeFragmentTestEnable state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineRepresentativeFragmentTestStateCreateInfoNV::representativeFragmentTestEnable value used to create the currently active pipeline.

Valid Usage

• At least one of the following must be true:

  • The extendedDynamicState3RepresentativeFragmentTestEnable feature is enabled
  • The shaderObject feature is enabled

Valid Usage (Implicit)

• commandBuffer must be a valid CommandBuffer handle

• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_representative_fragment_test, Bool32, CommandBuffer

cmdSetVertexInputEXT

Arguments

:: forall io. MonadIO io

=> CommandBuffer

commandBuffer is the command buffer into which the command will be recorded.

-> ("vertexBindingDescriptions" ::: Vector VertexInputBindingDescription2EXT)

pVertexBindingDescriptions is a pointer to an array of VertexInputBindingDescription2EXT structures.

-> ("vertexAttributeDescriptions" ::: Vector VertexInputAttributeDescription2EXT)

pVertexAttributeDescriptions is a pointer to an array of VertexInputAttributeDescription2EXT structures.

-> io ()

vkCmdSetVertexInputEXT - Set the vertex input state dynamically for a command buffer

Description

This command sets the vertex input attribute and vertex input binding descriptions state for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_VERTEX_INPUT_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the GraphicsPipelineCreateInfo::pVertexInputState values used to create the currently active pipeline.

If drawing using shader objects, or if the bound pipeline state object was also created with the DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE dynamic state enabled, then cmdBindVertexBuffers2 can be used instead of cmdSetVertexInputEXT to dynamically set the stride.

Valid Usage

• Either the vertexInputDynamicState feature or the shaderObject feature or both must be enabled

• vertexBindingDescriptionCount must be less than or equal to PhysicalDeviceLimits::maxVertexInputBindings
• vertexAttributeDescriptionCount must be less than or equal to PhysicalDeviceLimits::maxVertexInputAttributes
• For every binding specified by each element of pVertexAttributeDescriptions, a VertexInputBindingDescription2EXT 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)

• commandBuffer must be a valid CommandBuffer handle

• If vertexBindingDescriptionCount is not 0, pVertexBindingDescriptions must be a valid pointer to an array of vertexBindingDescriptionCount valid VertexInputBindingDescription2EXT structures
• If vertexAttributeDescriptionCount is not 0, pVertexAttributeDescriptions must be a valid pointer to an array of vertexAttributeDescriptionCount valid VertexInputAttributeDescription2EXT structures
• commandBuffer must be in the recording state
• The CommandPool that commandBuffer was allocated from must support graphics operations
• This command must only be called outside of a video coding scope

Host Synchronization

• Host access to commandBuffer must be externally synchronized

• Host access to the CommandPool that commandBuffer was allocated from must be externally synchronized

Command Properties

'

Command Buffer Levels	Render Pass Scope	Video Coding Scope	Supported Queue Types	Command Type
Primary Secondary	Both	Outside	Graphics	State

See Also

VK_EXT_shader_object, VK_EXT_vertex_input_dynamic_state, CommandBuffer, VertexInputAttributeDescription2EXT, VertexInputBindingDescription2EXT

newtype ViewportCoordinateSwizzleNV

VkViewportCoordinateSwizzleNV - Specify how a viewport coordinate is swizzled

Description

These values are described in detail in Viewport Swizzle.

See Also

VK_NV_viewport_swizzle, ViewportSwizzleNV

Constructors

ViewportCoordinateSwizzleNV Int32

Bundled Patterns

pattern VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV :: ViewportCoordinateSwizzleNV

pattern VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV :: ViewportCoordinateSwizzleNV

pattern VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV :: ViewportCoordinateSwizzleNV

pattern VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV :: ViewportCoordinateSwizzleNV

pattern VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV :: ViewportCoordinateSwizzleNV

pattern VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV :: ViewportCoordinateSwizzleNV

pattern VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV :: ViewportCoordinateSwizzleNV

pattern VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV :: ViewportCoordinateSwizzleNV

Instances

Storable ViewportCoordinateSwizzleNV

Defined in Vulkan.Extensions.VK_NV_viewport_swizzle

Methods

sizeOf :: ViewportCoordinateSwizzleNV -> Int

alignment :: ViewportCoordinateSwizzleNV -> Int

peekElemOff :: Ptr ViewportCoordinateSwizzleNV -> Int -> IO ViewportCoordinateSwizzleNV

pokeElemOff :: Ptr ViewportCoordinateSwizzleNV -> Int -> ViewportCoordinateSwizzleNV -> IO ()

peekByteOff :: Ptr b -> Int -> IO ViewportCoordinateSwizzleNV

pokeByteOff :: Ptr b -> Int -> ViewportCoordinateSwizzleNV -> IO ()

peek :: Ptr ViewportCoordinateSwizzleNV -> IO ViewportCoordinateSwizzleNV

poke :: Ptr ViewportCoordinateSwizzleNV -> ViewportCoordinateSwizzleNV -> IO ()

Read ViewportCoordinateSwizzleNV

Defined in Vulkan.Extensions.VK_NV_viewport_swizzle

Methods

readsPrec :: Int -> ReadS ViewportCoordinateSwizzleNV

readList :: ReadS [ViewportCoordinateSwizzleNV]

readPrec :: ReadPrec ViewportCoordinateSwizzleNV

readListPrec :: ReadPrec [ViewportCoordinateSwizzleNV]

Show ViewportCoordinateSwizzleNV

Defined in Vulkan.Extensions.VK_NV_viewport_swizzle

Methods

showsPrec :: Int -> ViewportCoordinateSwizzleNV -> ShowS

show :: ViewportCoordinateSwizzleNV -> String

showList :: [ViewportCoordinateSwizzleNV] -> ShowS

Eq ViewportCoordinateSwizzleNV

Defined in Vulkan.Extensions.VK_NV_viewport_swizzle

Methods

(==) :: ViewportCoordinateSwizzleNV -> ViewportCoordinateSwizzleNV -> Bool

(/=) :: ViewportCoordinateSwizzleNV -> ViewportCoordinateSwizzleNV -> Bool

Ord ViewportCoordinateSwizzleNV

Defined in Vulkan.Extensions.VK_NV_viewport_swizzle

Methods

compare :: ViewportCoordinateSwizzleNV -> ViewportCoordinateSwizzleNV -> Ordering

(<) :: ViewportCoordinateSwizzleNV -> ViewportCoordinateSwizzleNV -> Bool

(<=) :: ViewportCoordinateSwizzleNV -> ViewportCoordinateSwizzleNV -> Bool

(>) :: ViewportCoordinateSwizzleNV -> ViewportCoordinateSwizzleNV -> Bool

(>=) :: ViewportCoordinateSwizzleNV -> ViewportCoordinateSwizzleNV -> Bool

max :: ViewportCoordinateSwizzleNV -> ViewportCoordinateSwizzleNV -> ViewportCoordinateSwizzleNV

min :: ViewportCoordinateSwizzleNV -> ViewportCoordinateSwizzleNV -> ViewportCoordinateSwizzleNV

Zero ViewportCoordinateSwizzleNV

Defined in Vulkan.Extensions.VK_NV_viewport_swizzle

Methods

zero :: ViewportCoordinateSwizzleNV

newtype BlendOverlapEXT

VkBlendOverlapEXT - Enumerant specifying the blend overlap parameter

Description

'

Overlap Mode	Weighting Equations
BLEND_OVERLAP_UNCORRELATED_EXT	\[ \begin{aligned} p_0(A_s,A_d) & = A_sA_d \\ p_1(A_s,A_d) & = A_s(1-A_d) \\ p_2(A_s,A_d) & = A_d(1-A_s) \\ \end{aligned}\]
BLEND_OVERLAP_CONJOINT_EXT	\[ \begin{aligned} p_0(A_s,A_d) & = min(A_s,A_d) \\ p_1(A_s,A_d) & = max(A_s-A_d,0) \\ p_2(A_s,A_d) & = max(A_d-A_s,0) \\ \end{aligned}\]
BLEND_OVERLAP_DISJOINT_EXT	\[ \begin{aligned} p_0(A_s,A_d) & = max(A_s+A_d-1,0) \\ p_1(A_s,A_d) & = min(A_s,1-A_d) \\ p_2(A_s,A_d) & = min(A_d,1-A_s) \\ \end{aligned}\]

Advanced Blend Overlap Modes

See Also

VK_EXT_blend_operation_advanced, ColorBlendAdvancedEXT, PipelineColorBlendAdvancedStateCreateInfoEXT

Constructors

BlendOverlapEXT Int32

Bundled Patterns

pattern BLEND_OVERLAP_UNCORRELATED_EXT :: BlendOverlapEXT

BLEND_OVERLAP_UNCORRELATED_EXT specifies that there is no correlation between the source and destination coverage.

pattern BLEND_OVERLAP_DISJOINT_EXT :: BlendOverlapEXT

BLEND_OVERLAP_DISJOINT_EXT specifies that the source and destination coverage are considered to have minimal overlap.

pattern BLEND_OVERLAP_CONJOINT_EXT :: BlendOverlapEXT

BLEND_OVERLAP_CONJOINT_EXT specifies that the source and destination coverage are considered to have maximal overlap.

Instances

Storable BlendOverlapEXT

Defined in Vulkan.Extensions.VK_EXT_blend_operation_advanced

Methods

sizeOf :: BlendOverlapEXT -> Int

alignment :: BlendOverlapEXT -> Int

peekElemOff :: Ptr BlendOverlapEXT -> Int -> IO BlendOverlapEXT

pokeElemOff :: Ptr BlendOverlapEXT -> Int -> BlendOverlapEXT -> IO ()

peekByteOff :: Ptr b -> Int -> IO BlendOverlapEXT

pokeByteOff :: Ptr b -> Int -> BlendOverlapEXT -> IO ()

peek :: Ptr BlendOverlapEXT -> IO BlendOverlapEXT

poke :: Ptr BlendOverlapEXT -> BlendOverlapEXT -> IO ()

Read BlendOverlapEXT

Defined in Vulkan.Extensions.VK_EXT_blend_operation_advanced

Methods

readsPrec :: Int -> ReadS BlendOverlapEXT

readList :: ReadS [BlendOverlapEXT]

readPrec :: ReadPrec BlendOverlapEXT

readListPrec :: ReadPrec [BlendOverlapEXT]

Show BlendOverlapEXT

Defined in Vulkan.Extensions.VK_EXT_blend_operation_advanced

Methods

showsPrec :: Int -> BlendOverlapEXT -> ShowS

show :: BlendOverlapEXT -> String

showList :: [BlendOverlapEXT] -> ShowS

Eq BlendOverlapEXT

Defined in Vulkan.Extensions.VK_EXT_blend_operation_advanced

Methods

(==) :: BlendOverlapEXT -> BlendOverlapEXT -> Bool

(/=) :: BlendOverlapEXT -> BlendOverlapEXT -> Bool

Ord BlendOverlapEXT

Defined in Vulkan.Extensions.VK_EXT_blend_operation_advanced

Methods

compare :: BlendOverlapEXT -> BlendOverlapEXT -> Ordering

(<) :: BlendOverlapEXT -> BlendOverlapEXT -> Bool

(<=) :: BlendOverlapEXT -> BlendOverlapEXT -> Bool

(>) :: BlendOverlapEXT -> BlendOverlapEXT -> Bool

(>=) :: BlendOverlapEXT -> BlendOverlapEXT -> Bool

max :: BlendOverlapEXT -> BlendOverlapEXT -> BlendOverlapEXT

min :: BlendOverlapEXT -> BlendOverlapEXT -> BlendOverlapEXT

Zero BlendOverlapEXT

Defined in Vulkan.Extensions.VK_EXT_blend_operation_advanced

Methods

zero :: BlendOverlapEXT

newtype CoverageModulationModeNV

VkCoverageModulationModeNV - Specify the coverage modulation mode

See Also

VK_NV_framebuffer_mixed_samples, PipelineCoverageModulationStateCreateInfoNV, cmdSetCoverageModulationModeNV

Constructors

CoverageModulationModeNV Int32

Bundled Patterns

pattern COVERAGE_MODULATION_MODE_NONE_NV :: CoverageModulationModeNV

COVERAGE_MODULATION_MODE_NONE_NV specifies that no components are multiplied by the modulation factor.

pattern COVERAGE_MODULATION_MODE_RGB_NV :: CoverageModulationModeNV

COVERAGE_MODULATION_MODE_RGB_NV specifies that the red, green, and blue components are multiplied by the modulation factor.

pattern COVERAGE_MODULATION_MODE_ALPHA_NV :: CoverageModulationModeNV

COVERAGE_MODULATION_MODE_ALPHA_NV specifies that the alpha component is multiplied by the modulation factor.

pattern COVERAGE_MODULATION_MODE_RGBA_NV :: CoverageModulationModeNV

COVERAGE_MODULATION_MODE_RGBA_NV specifies that all components are multiplied by the modulation factor.

Instances

Storable CoverageModulationModeNV

Defined in Vulkan.Extensions.VK_NV_framebuffer_mixed_samples

Methods

sizeOf :: CoverageModulationModeNV -> Int

alignment :: CoverageModulationModeNV -> Int

peekElemOff :: Ptr CoverageModulationModeNV -> Int -> IO CoverageModulationModeNV

pokeElemOff :: Ptr CoverageModulationModeNV -> Int -> CoverageModulationModeNV -> IO ()

peekByteOff :: Ptr b -> Int -> IO CoverageModulationModeNV

pokeByteOff :: Ptr b -> Int -> CoverageModulationModeNV -> IO ()

peek :: Ptr CoverageModulationModeNV -> IO CoverageModulationModeNV

poke :: Ptr CoverageModulationModeNV -> CoverageModulationModeNV -> IO ()

Read CoverageModulationModeNV

Defined in Vulkan.Extensions.VK_NV_framebuffer_mixed_samples

Methods

readsPrec :: Int -> ReadS CoverageModulationModeNV

readList :: ReadS [CoverageModulationModeNV]

readPrec :: ReadPrec CoverageModulationModeNV

readListPrec :: ReadPrec [CoverageModulationModeNV]

Show CoverageModulationModeNV

Defined in Vulkan.Extensions.VK_NV_framebuffer_mixed_samples

Methods

showsPrec :: Int -> CoverageModulationModeNV -> ShowS

show :: CoverageModulationModeNV -> String

showList :: [CoverageModulationModeNV] -> ShowS

Eq CoverageModulationModeNV

Defined in Vulkan.Extensions.VK_NV_framebuffer_mixed_samples

Methods

(==) :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool

(/=) :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool

Ord CoverageModulationModeNV

Defined in Vulkan.Extensions.VK_NV_framebuffer_mixed_samples

Methods

compare :: CoverageModulationModeNV -> CoverageModulationModeNV -> Ordering

(<) :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool

(<=) :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool

(>) :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool

(>=) :: CoverageModulationModeNV -> CoverageModulationModeNV -> Bool

max :: CoverageModulationModeNV -> CoverageModulationModeNV -> CoverageModulationModeNV

min :: CoverageModulationModeNV -> CoverageModulationModeNV -> CoverageModulationModeNV

Zero CoverageModulationModeNV

Defined in Vulkan.Extensions.VK_NV_framebuffer_mixed_samples

Methods

zero :: CoverageModulationModeNV

newtype CoverageReductionModeNV

VkCoverageReductionModeNV - Specify the coverage reduction mode

See Also

VK_NV_coverage_reduction_mode, FramebufferMixedSamplesCombinationNV, PipelineCoverageReductionStateCreateInfoNV, cmdSetCoverageReductionModeNV

Constructors

CoverageReductionModeNV Int32

Bundled Patterns

pattern COVERAGE_REDUCTION_MODE_MERGE_NV :: CoverageReductionModeNV

COVERAGE_REDUCTION_MODE_MERGE_NV specifies that each color sample will be associated with an implementation-dependent subset of samples in the pixel coverage. If any of those associated samples are covered, the color sample is covered.

pattern COVERAGE_REDUCTION_MODE_TRUNCATE_NV :: CoverageReductionModeNV

COVERAGE_REDUCTION_MODE_TRUNCATE_NV specifies that for color samples present in the color attachments, a color sample is covered if the pixel coverage sample with the same sample index i is covered; other pixel coverage samples are discarded.

Instances

Storable CoverageReductionModeNV

Defined in Vulkan.Extensions.VK_NV_coverage_reduction_mode

Methods

sizeOf :: CoverageReductionModeNV -> Int

alignment :: CoverageReductionModeNV -> Int

peekElemOff :: Ptr CoverageReductionModeNV -> Int -> IO CoverageReductionModeNV

pokeElemOff :: Ptr CoverageReductionModeNV -> Int -> CoverageReductionModeNV -> IO ()

peekByteOff :: Ptr b -> Int -> IO CoverageReductionModeNV

pokeByteOff :: Ptr b -> Int -> CoverageReductionModeNV -> IO ()

peek :: Ptr CoverageReductionModeNV -> IO CoverageReductionModeNV

poke :: Ptr CoverageReductionModeNV -> CoverageReductionModeNV -> IO ()

Read CoverageReductionModeNV

Defined in Vulkan.Extensions.VK_NV_coverage_reduction_mode

Methods

readsPrec :: Int -> ReadS CoverageReductionModeNV

readList :: ReadS [CoverageReductionModeNV]

readPrec :: ReadPrec CoverageReductionModeNV

readListPrec :: ReadPrec [CoverageReductionModeNV]

Show CoverageReductionModeNV

Defined in Vulkan.Extensions.VK_NV_coverage_reduction_mode

Methods

showsPrec :: Int -> CoverageReductionModeNV -> ShowS

show :: CoverageReductionModeNV -> String

showList :: [CoverageReductionModeNV] -> ShowS

Eq CoverageReductionModeNV

Defined in Vulkan.Extensions.VK_NV_coverage_reduction_mode

Methods

(==) :: CoverageReductionModeNV -> CoverageReductionModeNV -> Bool

(/=) :: CoverageReductionModeNV -> CoverageReductionModeNV -> Bool

Ord CoverageReductionModeNV

Defined in Vulkan.Extensions.VK_NV_coverage_reduction_mode

Methods

compare :: CoverageReductionModeNV -> CoverageReductionModeNV -> Ordering

(<) :: CoverageReductionModeNV -> CoverageReductionModeNV -> Bool

(<=) :: CoverageReductionModeNV -> CoverageReductionModeNV -> Bool

(>) :: CoverageReductionModeNV -> CoverageReductionModeNV -> Bool

(>=) :: CoverageReductionModeNV -> CoverageReductionModeNV -> Bool

max :: CoverageReductionModeNV -> CoverageReductionModeNV -> CoverageReductionModeNV

min :: CoverageReductionModeNV -> CoverageReductionModeNV -> CoverageReductionModeNV

Zero CoverageReductionModeNV

Defined in Vulkan.Extensions.VK_NV_coverage_reduction_mode

Methods

zero :: CoverageReductionModeNV

newtype ConservativeRasterizationModeEXT

VkConservativeRasterizationModeEXT - Specify the conservative rasterization mode

See Also

VK_EXT_conservative_rasterization, PipelineRasterizationConservativeStateCreateInfoEXT, cmdSetConservativeRasterizationModeEXT

Constructors

ConservativeRasterizationModeEXT Int32

Bundled Patterns

pattern CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT :: ConservativeRasterizationModeEXT

CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT specifies that conservative rasterization is disabled and rasterization proceeds as normal.

pattern CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT :: ConservativeRasterizationModeEXT

CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT specifies that conservative rasterization is enabled in overestimation mode.

pattern CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT :: ConservativeRasterizationModeEXT

CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT specifies that conservative rasterization is enabled in underestimation mode.

Instances

Storable ConservativeRasterizationModeEXT

Defined in Vulkan.Extensions.VK_EXT_conservative_rasterization

Methods

sizeOf :: ConservativeRasterizationModeEXT -> Int

alignment :: ConservativeRasterizationModeEXT -> Int

peekElemOff :: Ptr ConservativeRasterizationModeEXT -> Int -> IO ConservativeRasterizationModeEXT

pokeElemOff :: Ptr ConservativeRasterizationModeEXT -> Int -> ConservativeRasterizationModeEXT -> IO ()

peekByteOff :: Ptr b -> Int -> IO ConservativeRasterizationModeEXT

pokeByteOff :: Ptr b -> Int -> ConservativeRasterizationModeEXT -> IO ()

peek :: Ptr ConservativeRasterizationModeEXT -> IO ConservativeRasterizationModeEXT

poke :: Ptr ConservativeRasterizationModeEXT -> ConservativeRasterizationModeEXT -> IO ()

Read ConservativeRasterizationModeEXT

Defined in Vulkan.Extensions.VK_EXT_conservative_rasterization

Methods

readsPrec :: Int -> ReadS ConservativeRasterizationModeEXT

readList :: ReadS [ConservativeRasterizationModeEXT]

readPrec :: ReadPrec ConservativeRasterizationModeEXT

readListPrec :: ReadPrec [ConservativeRasterizationModeEXT]

Show ConservativeRasterizationModeEXT

Defined in Vulkan.Extensions.VK_EXT_conservative_rasterization

Methods

showsPrec :: Int -> ConservativeRasterizationModeEXT -> ShowS

show :: ConservativeRasterizationModeEXT -> String

showList :: [ConservativeRasterizationModeEXT] -> ShowS

Eq ConservativeRasterizationModeEXT

Defined in Vulkan.Extensions.VK_EXT_conservative_rasterization

Methods

(==) :: ConservativeRasterizationModeEXT -> ConservativeRasterizationModeEXT -> Bool

(/=) :: ConservativeRasterizationModeEXT -> ConservativeRasterizationModeEXT -> Bool

Ord ConservativeRasterizationModeEXT

Defined in Vulkan.Extensions.VK_EXT_conservative_rasterization

Methods

compare :: ConservativeRasterizationModeEXT -> ConservativeRasterizationModeEXT -> Ordering

(<) :: ConservativeRasterizationModeEXT -> ConservativeRasterizationModeEXT -> Bool

(<=) :: ConservativeRasterizationModeEXT -> ConservativeRasterizationModeEXT -> Bool

(>) :: ConservativeRasterizationModeEXT -> ConservativeRasterizationModeEXT -> Bool

(>=) :: ConservativeRasterizationModeEXT -> ConservativeRasterizationModeEXT -> Bool

max :: ConservativeRasterizationModeEXT -> ConservativeRasterizationModeEXT -> ConservativeRasterizationModeEXT

min :: ConservativeRasterizationModeEXT -> ConservativeRasterizationModeEXT -> ConservativeRasterizationModeEXT

Zero ConservativeRasterizationModeEXT

Defined in Vulkan.Extensions.VK_EXT_conservative_rasterization

Methods

zero :: ConservativeRasterizationModeEXT

newtype LineRasterizationModeEXT

VkLineRasterizationModeEXT - Line rasterization modes

See Also

VK_EXT_line_rasterization, PipelineRasterizationLineStateCreateInfoEXT, cmdSetLineRasterizationModeEXT

Constructors

LineRasterizationModeEXT Int32

Bundled Patterns

pattern LINE_RASTERIZATION_MODE_DEFAULT_EXT :: LineRasterizationModeEXT

LINE_RASTERIZATION_MODE_DEFAULT_EXT is equivalent to LINE_RASTERIZATION_MODE_RECTANGULAR_EXT if PhysicalDeviceLimits::strictLines is TRUE, otherwise lines are drawn as non-strictLines parallelograms. Both of these modes are defined in Basic Line Segment Rasterization.

pattern LINE_RASTERIZATION_MODE_RECTANGULAR_EXT :: LineRasterizationModeEXT

LINE_RASTERIZATION_MODE_RECTANGULAR_EXT specifies lines drawn as if they were rectangles extruded from the line

pattern LINE_RASTERIZATION_MODE_BRESENHAM_EXT :: LineRasterizationModeEXT

LINE_RASTERIZATION_MODE_BRESENHAM_EXT specifies lines drawn by determining which pixel diamonds the line intersects and exits, as defined in Bresenham Line Segment Rasterization.

pattern LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT :: LineRasterizationModeEXT

LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT specifies lines drawn if they were rectangles extruded from the line, with alpha falloff, as defined in Smooth Lines.

Instances

Storable LineRasterizationModeEXT

Defined in Vulkan.Extensions.VK_EXT_line_rasterization

Methods

sizeOf :: LineRasterizationModeEXT -> Int

alignment :: LineRasterizationModeEXT -> Int

peekElemOff :: Ptr LineRasterizationModeEXT -> Int -> IO LineRasterizationModeEXT

pokeElemOff :: Ptr LineRasterizationModeEXT -> Int -> LineRasterizationModeEXT -> IO ()

peekByteOff :: Ptr b -> Int -> IO LineRasterizationModeEXT

pokeByteOff :: Ptr b -> Int -> LineRasterizationModeEXT -> IO ()

peek :: Ptr LineRasterizationModeEXT -> IO LineRasterizationModeEXT

poke :: Ptr LineRasterizationModeEXT -> LineRasterizationModeEXT -> IO ()

Read LineRasterizationModeEXT

Defined in Vulkan.Extensions.VK_EXT_line_rasterization

Methods

readsPrec :: Int -> ReadS LineRasterizationModeEXT

readList :: ReadS [LineRasterizationModeEXT]

readPrec :: ReadPrec LineRasterizationModeEXT

readListPrec :: ReadPrec [LineRasterizationModeEXT]

Show LineRasterizationModeEXT

Defined in Vulkan.Extensions.VK_EXT_line_rasterization

Methods

showsPrec :: Int -> LineRasterizationModeEXT -> ShowS

show :: LineRasterizationModeEXT -> String

showList :: [LineRasterizationModeEXT] -> ShowS

Eq LineRasterizationModeEXT

Defined in Vulkan.Extensions.VK_EXT_line_rasterization

Methods

(==) :: LineRasterizationModeEXT -> LineRasterizationModeEXT -> Bool

(/=) :: LineRasterizationModeEXT -> LineRasterizationModeEXT -> Bool

Ord LineRasterizationModeEXT

Defined in Vulkan.Extensions.VK_EXT_line_rasterization

Methods

compare :: LineRasterizationModeEXT -> LineRasterizationModeEXT -> Ordering

(<) :: LineRasterizationModeEXT -> LineRasterizationModeEXT -> Bool

(<=) :: LineRasterizationModeEXT -> LineRasterizationModeEXT -> Bool

(>) :: LineRasterizationModeEXT -> LineRasterizationModeEXT -> Bool

(>=) :: LineRasterizationModeEXT -> LineRasterizationModeEXT -> Bool

max :: LineRasterizationModeEXT -> LineRasterizationModeEXT -> LineRasterizationModeEXT

min :: LineRasterizationModeEXT -> LineRasterizationModeEXT -> LineRasterizationModeEXT

Zero LineRasterizationModeEXT

Defined in Vulkan.Extensions.VK_EXT_line_rasterization

Methods

zero :: LineRasterizationModeEXT

newtype ProvokingVertexModeEXT

VkProvokingVertexModeEXT - Specify which vertex in a primitive is the provoking vertex

Description

These modes are described more precisely in Primitive Topologies.

See Also

VK_EXT_provoking_vertex, PipelineRasterizationProvokingVertexStateCreateInfoEXT, cmdSetProvokingVertexModeEXT

Constructors

ProvokingVertexModeEXT Int32

Bundled Patterns

pattern PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT :: ProvokingVertexModeEXT

PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT specifies that the provoking vertex is the first non-adjacency vertex in the list of vertices used by a primitive.

pattern PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT :: ProvokingVertexModeEXT

PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT specifies that the provoking vertex is the last non-adjacency vertex in the list of vertices used by a primitive.

Instances

Storable ProvokingVertexModeEXT

Defined in Vulkan.Extensions.VK_EXT_provoking_vertex

Methods

sizeOf :: ProvokingVertexModeEXT -> Int

alignment :: ProvokingVertexModeEXT -> Int

peekElemOff :: Ptr ProvokingVertexModeEXT -> Int -> IO ProvokingVertexModeEXT

pokeElemOff :: Ptr ProvokingVertexModeEXT -> Int -> ProvokingVertexModeEXT -> IO ()

peekByteOff :: Ptr b -> Int -> IO ProvokingVertexModeEXT

pokeByteOff :: Ptr b -> Int -> ProvokingVertexModeEXT -> IO ()

peek :: Ptr ProvokingVertexModeEXT -> IO ProvokingVertexModeEXT

poke :: Ptr ProvokingVertexModeEXT -> ProvokingVertexModeEXT -> IO ()

Read ProvokingVertexModeEXT

Defined in Vulkan.Extensions.VK_EXT_provoking_vertex

Methods

readsPrec :: Int -> ReadS ProvokingVertexModeEXT

readList :: ReadS [ProvokingVertexModeEXT]

readPrec :: ReadPrec ProvokingVertexModeEXT

readListPrec :: ReadPrec [ProvokingVertexModeEXT]

Show ProvokingVertexModeEXT

Defined in Vulkan.Extensions.VK_EXT_provoking_vertex

Methods

showsPrec :: Int -> ProvokingVertexModeEXT -> ShowS

show :: ProvokingVertexModeEXT -> String

showList :: [ProvokingVertexModeEXT] -> ShowS

Eq ProvokingVertexModeEXT

Defined in Vulkan.Extensions.VK_EXT_provoking_vertex

Methods

(==) :: ProvokingVertexModeEXT -> ProvokingVertexModeEXT -> Bool

(/=) :: ProvokingVertexModeEXT -> ProvokingVertexModeEXT -> Bool

Ord ProvokingVertexModeEXT

Defined in Vulkan.Extensions.VK_EXT_provoking_vertex

Methods

compare :: ProvokingVertexModeEXT -> ProvokingVertexModeEXT -> Ordering

(<) :: ProvokingVertexModeEXT -> ProvokingVertexModeEXT -> Bool

(<=) :: ProvokingVertexModeEXT -> ProvokingVertexModeEXT -> Bool

(>) :: ProvokingVertexModeEXT -> ProvokingVertexModeEXT -> Bool

(>=) :: ProvokingVertexModeEXT -> ProvokingVertexModeEXT -> Bool

max :: ProvokingVertexModeEXT -> ProvokingVertexModeEXT -> ProvokingVertexModeEXT

min :: ProvokingVertexModeEXT -> ProvokingVertexModeEXT -> ProvokingVertexModeEXT

Zero ProvokingVertexModeEXT

Defined in Vulkan.Extensions.VK_EXT_provoking_vertex

Methods

zero :: ProvokingVertexModeEXT

cmdSetCullModeEXT :: MonadIO io => CommandBuffer -> CullModeFlags -> io ()

cmdSetFrontFaceEXT :: MonadIO io => CommandBuffer -> FrontFace -> io ()

cmdSetPrimitiveTopologyEXT :: MonadIO io => CommandBuffer -> PrimitiveTopology -> io ()

cmdSetViewportWithCountEXT :: MonadIO io => CommandBuffer -> ("viewports" ::: Vector Viewport) -> io ()

cmdSetScissorWithCountEXT :: MonadIO io => CommandBuffer -> ("scissors" ::: Vector Rect2D) -> io ()

cmdBindVertexBuffers2EXT :: MonadIO io => CommandBuffer -> ("firstBinding" ::: Word32) -> ("buffers" ::: Vector Buffer) -> ("offsets" ::: Vector DeviceSize) -> ("sizes" ::: Vector DeviceSize) -> ("strides" ::: Vector DeviceSize) -> io ()

cmdSetDepthTestEnableEXT :: MonadIO io => CommandBuffer -> ("depthTestEnable" ::: Bool) -> io ()

cmdSetDepthWriteEnableEXT :: MonadIO io => CommandBuffer -> ("depthWriteEnable" ::: Bool) -> io ()

cmdSetDepthCompareOpEXT :: MonadIO io => CommandBuffer -> ("depthCompareOp" ::: CompareOp) -> io ()

cmdSetDepthBoundsTestEnableEXT :: MonadIO io => CommandBuffer -> ("depthBoundsTestEnable" ::: Bool) -> io ()

cmdSetStencilTestEnableEXT :: MonadIO io => CommandBuffer -> ("stencilTestEnable" ::: Bool) -> io ()

cmdSetStencilOpEXT :: MonadIO io => CommandBuffer -> ("faceMask" ::: StencilFaceFlags) -> ("failOp" ::: StencilOp) -> ("passOp" ::: StencilOp) -> ("depthFailOp" ::: StencilOp) -> CompareOp -> io ()

cmdSetRasterizerDiscardEnableEXT :: MonadIO io => CommandBuffer -> ("rasterizerDiscardEnable" ::: Bool) -> io ()

cmdSetDepthBiasEnableEXT :: MonadIO io => CommandBuffer -> ("depthBiasEnable" ::: Bool) -> io ()

cmdSetPrimitiveRestartEnableEXT :: MonadIO io => CommandBuffer -> ("primitiveRestartEnable" ::: Bool) -> io ()