HORIZON HASKELLDocslts/ghc-10.0.x8174fa42026-10-11Search names, modules, packages, or :: a typeCtrl K

GHC 10.0.0.20260917 · lts/ghc-10.0.x · 8174fa4 · 2026-10-11

Modulevulkan-3.27GHC2021

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

Vulkan Version 1.1      and

VK_KHR_dynamic_rendering or Vulkan Version 1.3

API Interactions

  • Interacts with VK_VERSION_1_1

  • Interacts with VK_VERSION_1_3

  • Interacts with VK_EXT_blend_operation_advanced

  • Interacts with VK_EXT_conservative_rasterization

  • Interacts with VK_EXT_depth_clamp_control

  • Interacts with VK_EXT_depth_clip_control

  • Interacts with VK_EXT_depth_clip_enable

  • Interacts with VK_EXT_fragment_density_map

  • Interacts with VK_EXT_line_rasterization

  • Interacts with VK_EXT_mesh_shader

  • Interacts with VK_EXT_provoking_vertex

  • Interacts with VK_EXT_sample_locations

  • Interacts with VK_EXT_subgroup_size_control

  • Interacts with VK_EXT_transform_feedback

  • Interacts with VK_KHR_device_group

  • Interacts with VK_KHR_fragment_shading_rate

  • Interacts with VK_NV_clip_space_w_scaling

  • Interacts with VK_NV_coverage_reduction_mode

  • Interacts with VK_NV_fragment_coverage_to_color

  • Interacts with VK_NV_framebuffer_mixed_samples

  • Interacts with VK_NV_mesh_shader

  • Interacts with VK_NV_representative_fragment_test

  • Interacts with VK_NV_shading_rate_image

  • Interacts with VK_NV_viewport_swizzle

Contact
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

  • Caterina Shablia, 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

New Commands

If VK_EXT_blend_operation_advanced is supported:

If VK_EXT_conservative_rasterization is supported:

If VK_EXT_depth_clamp_control is supported:

If VK_EXT_depth_clip_control is supported:

If VK_EXT_depth_clip_enable is supported:

If VK_EXT_line_rasterization is supported:

If VK_EXT_provoking_vertex is supported:

If VK_EXT_sample_locations is supported:

If VK_EXT_transform_feedback is supported:

If VK_NV_clip_space_w_scaling is supported:

If VK_NV_coverage_reduction_mode is supported:

If VK_NV_fragment_coverage_to_color is supported:

If VK_NV_framebuffer_mixed_samples is supported:

If VK_NV_representative_fragment_test is supported:

If VK_NV_shading_rate_image is supported:

If VK_NV_viewport_swizzle is supported:

New Structures

New Enums

New Bitmasks

New Enum Constants

If VK_EXT_fragment_density_map is supported:

If VK_EXT_mesh_shader or VK_NV_mesh_shader is supported:

If VK_EXT_subgroup_size_control or Vulkan Version 1.3 is supported:

If VK_KHR_device_group or Vulkan Version 1.1 is supported:

If VK_KHR_fragment_shading_rate is supported:

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

No cross-references are available

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.

  • 24 types
  • 55 values
  • Packagevulkan-3.27
  • Exports122
  • LanguageGHC2021
  • LicenceBSD-3-Clause
  • SourceVK_EXT_shader_object.hs
valuecreateShadersEXT
  1. :: MonadIO io
  2. => Device

    device is the logical device that creates the shader objects.

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

    pCreateInfos is a pointer to an array of ShaderCreateInfoEXT structures.

  4. -> "allocator" ::: Maybe AllocationCallbacks

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

  5. -> io (Result, "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

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
Failure

See Also

VK_EXT_shader_object, AllocationCallbacks, Device, ShaderCreateInfoEXT, ShaderEXT

valuewithShadersEXT
  1. :: MonadIO io
  2. => Device
  3. -> Vector (SomeStruct ShaderCreateInfoEXT)
  4. -> Maybe AllocationCallbacks
  5. -> io (Result, Vector ShaderEXT) -> ((Result, Vector ShaderEXT) -> io ()) -> r
  6. -> 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.

valuedestroyShaderEXT
  1. :: MonadIO io
  2. => Device

    device is the logical device that destroys the shader object.

  3. -> ShaderEXT

    shader is the handle of the shader object to destroy.

  4. -> "allocator" ::: Maybe AllocationCallbacks

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

  5. -> 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

  • 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

  • If shader is not NULL_HANDLE, shader must be a valid ShaderEXT handle

  • If pAllocator is not NULL, pAllocator must be a valid pointer to a valid AllocationCallbacks structure

  • If shader is a valid handle, it 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

valuegetShaderBinaryDataEXT
  1. :: MonadIO io
  2. => Device

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

  3. -> ShaderEXT

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

  4. -> 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 application 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.

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 in its entirety.

This behavior is not consistent with the behavior described in Opaque Binary Data Results, for historical reasons.

If the amount of data available is larger than the passed pDataSize, the query returns a INCOMPLETE success status instead of a ERROR_NOT_ENOUGH_SPACE_KHR error status.

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

  • 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
Failure

See Also

VK_EXT_shader_object, Device, ShaderEXT

valuecmdBindShadersEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "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.

  4. -> "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.

  5. -> 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

Valid Usage (Implicit)

  • 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 QUEUE_COMPUTE_BIT, or QUEUE_GRAPHICS_BIT 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

VK_QUEUE_COMPUTE_BIT VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdBindShadersEXT is not affected by conditional rendering

See Also

VK_EXT_shader_object, CommandBuffer, ShaderEXT, ShaderStageFlagBits

datadata 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. If the application wishes to use a Device with any features described by PhysicalDeviceShaderObjectFeaturesEXT, it must add an instance of the structure, with the desired feature members set to TRUE, to the pNext chain of DeviceCreateInfo when creating the Device.

Structure Chaining

Extends the structures

See Also

VK_EXT_shader_object, Bool32, StructureType

Constructors

Instances6Eq, Show, Storable, FromCStruct, ToCStruct, Zero
datadata 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.

Structure Chaining

Extends the structure

See Also

VK_EXT_shader_object, StructureType

Constructors

Instances5Show, Storable, FromCStruct, ToCStruct, Zero
datadata ShaderCreateInfoEXT (es :: [Type])
#

VkShaderCreateInfoEXT - Structure specifying parameters of a newly created shader

Description

When determining pipeline layout compatibility, compatibility is determined as if a the shader was created with a pipeline layout object that was created with identical values of setLayoutCount, pSetLayouts, pushConstantRangeCount, and pPushConstantRanges, and with PipelineLayoutCreateInfo::flags set to 0. If flags includes SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT, the shader is not considered created with a pipeline layout.

When specifying descriptor heap mappings, only mappings corresponding to bindings that are actually present in the SPIR-V shader affect compilation. Mappings are ignored when codeType is SHADER_CODE_TYPE_BINARY_EXT. The resulting compiled binary from two different SPIR-V shaders which would have identical bit patterns must remain identical even if the mapping entries vary in any of the following ways:

  • Different numbers of unused mapping structures

  • Different binding counts for unused bindings

  • Unused parameters in mapping structures (e.g. sampler offsets)

  • Ignored parameters in mapping structures

  • Different order of mapping structures, used or unused

Calculating the same offset in a mapping via different parameter values is not guaranteed to provide identical results.

Valid Usage

Valid Usage (Implicit)

See Also

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

Constructors

Instances5Extensible, Show, FromCStruct, ToCStruct, Zero
newtypenewtype ShaderCreateFlagBitsEXT
#

VkShaderCreateFlagBitsEXT - Bitmask controlling how a shader object is created

Description

See Also

VK_EXT_shader_object, ShaderCreateFlagsEXT

Constructors

Instances8Eq, Ord, Read, Show, Bits, FiniteBits, …
newtypenewtype ShaderCodeTypeEXT
#

VkShaderCodeTypeEXT - Indicate a shader code type

Description

See Also

VK_EXT_shader_object, ShaderCreateInfoEXT

Constructors

Instances6Eq, Ord, Read, Show, Storable, Zero
newtypenewtype ShaderEXT
#

VkShaderEXT - Opaque handle to a shader object

See Also

VK_DEFINE_NON_DISPATCHABLE_HANDLE, VK_EXT_shader_object, GeneratedCommandsShaderInfoEXT, IndirectExecutionSetShaderInfoEXT, WriteIndirectExecutionSetShaderEXT, cmdBindShadersEXT, createShadersEXT, destroyShaderEXT, getShaderBinaryDataEXT

Constructors

Instances7Eq, Ord, Show, Storable, HasObjectType, IsHandle, …
datadata ViewportSwizzleNV
#

VkViewportSwizzleNV - Structure specifying a viewport swizzle

Valid Usage (Implicit)

See Also

VK_NV_viewport_swizzle, PipelineViewportSwizzleStateCreateInfoNV, ViewportCoordinateSwizzleNV, cmdSetViewportSwizzleNV

Constructors

Instances6Eq, Show, Storable, FromCStruct, ToCStruct, Zero
datadata ColorBlendEquationEXT
#

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

Valid Usage

Valid Usage (Implicit)

  • 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

Instances6Eq, Show, Storable, FromCStruct, ToCStruct, Zero
datadata ColorBlendAdvancedEXT
#

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

Valid Usage

Valid Usage (Implicit)

  • advancedBlendOp must be a valid BlendOp value

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, BlendOp, BlendOverlapEXT, Bool32, cmdSetColorBlendAdvancedEXT

Constructors

  • ColorBlendAdvancedEXT
    • 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 that 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.

Instances6Eq, Show, Storable, FromCStruct, ToCStruct, Zero
datadata VertexInputBindingDescription2EXT
#

VkVertexInputBindingDescription2EXT - Structure specifying the extended vertex input binding description

Valid Usage

Valid Usage (Implicit)

See Also

VK_EXT_shader_object, VK_EXT_vertex_input_dynamic_state, StructureType, VertexInputRate, cmdSetVertexInputEXT

Constructors

Instances6Eq, Show, Storable, FromCStruct, ToCStruct, Zero
datadata VertexInputAttributeDescription2EXT
#

VkVertexInputAttributeDescription2EXT - Structure specifying the extended vertex input attribute description

Valid Usage

Valid Usage (Implicit)

  • format must be a valid Format value

See Also

VK_EXT_shader_object, VK_EXT_vertex_input_dynamic_state, Format, StructureType, cmdSetVertexInputEXT

Constructors

Instances6Eq, Show, Storable, FromCStruct, ToCStruct, Zero
datadata DepthClampRangeEXT
#

VkDepthClampRangeEXT - Structure specifying a depth clamp range

Valid Usage

  • minDepthClamp must be less than or equal to maxDepthClamp

  • If the VK_EXT_depth_range_unrestricted extension is not enabled, minDepthClamp must be greater than or equal to 0.0

  • If the VK_EXT_depth_range_unrestricted extension is not enabled, maxDepthClamp must be less than or equal to 1.0

See Also

VK_EXT_depth_clamp_control, PipelineViewportDepthClampControlCreateInfoEXT, cmdSetDepthClampRangeEXT

Constructors

Instances6Eq, Show, Storable, FromCStruct, ToCStruct, Zero
valuecmdSetPatchControlPointsEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "patchControlPoints" ::: Word32

    patchControlPoints specifies the number of control points per patch.

  4. -> 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

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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetPatchControlPointsEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state2, VK_EXT_shader_object, CommandBuffer

valuecmdSetLogicOpEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> LogicOp

    logicOp specifies the logical operation to apply for blend state.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetLogicOpEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state2, VK_EXT_shader_object, CommandBuffer, LogicOp

valuecmdSetTessellationDomainOriginEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> TessellationDomainOrigin

    domainOrigin specifies the origin of the tessellation domain space.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetTessellationDomainOriginEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_KHR_maintenance2, VK_VERSION_1_1, CommandBuffer, TessellationDomainOrigin

valuecmdSetDepthClampEnableEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "depthClampEnable" ::: Bool

    depthClampEnable specifies whether depth clamping is enabled.

  4. -> 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.

If the maintenance11 feature is enabled, the above statement is further clarified to state that the depth clipping state is only affected by the current value of depthClampEnable if the pipeline was not created with the PipelineRasterizationDepthClipStateCreateInfoEXT structure. If PipelineRasterizationDepthClipStateCreateInfoEXT was included in the pipeline creation then the depth clipping state is set explicitly by PipelineRasterizationDepthClipStateCreateInfoEXT::depthClipEnable and not changed when the depth clamping state is modified.

Valid Usage

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetDepthClampEnableEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, Bool32, CommandBuffer

valuecmdSetPolygonModeEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> PolygonMode

    polygonMode specifies polygon mode.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetPolygonModeEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, CommandBuffer, PolygonMode

valuecmdSetRasterizationSamplesEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "rasterizationSamples" ::: SampleCountFlagBits

    rasterizationSamples specifies rasterizationSamples.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetRasterizationSamplesEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, CommandBuffer, SampleCountFlagBits

valuecmdSetSampleMaskEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "samples" ::: SampleCountFlagBits

    samples specifies the number of sample bits in the pSampleMask.

  4. -> "sampleMask" ::: Vector SampleMask

    pSampleMask is a pointer to an array of SampleMask values, where the array size is based on the samples parameter. If the maintenance10 feature is enabled, and this parameter is set to NULL, it is treated as if the mask has all bits set to 1.

  5. -> 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

  • pSampleMask must not be NULL if the maintenance10 feature is not enabled

Valid Usage (Implicit)

  • samples must be a valid SampleCountFlagBits value

  • If pSampleMask is not NULL, 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 QUEUE_GRAPHICS_BIT 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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetSampleMaskEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, CommandBuffer, SampleCountFlagBits, SampleMask

valuecmdSetAlphaToCoverageEnableEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "alphaToCoverageEnable" ::: Bool

    alphaToCoverageEnable specifies the alphaToCoverageEnable state.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetAlphaToCoverageEnableEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, Bool32, CommandBuffer

valuecmdSetAlphaToOneEnableEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "alphaToOneEnable" ::: Bool

    alphaToOneEnable specifies the alphaToOneEnable state.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetAlphaToOneEnableEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, Bool32, CommandBuffer

valuecmdSetLogicOpEnableEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "logicOpEnable" ::: Bool

    logicOpEnable specifies whether logical operations are enabled.

  4. -> 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

  • If the logicOp feature is not enabled, logicOpEnable must be FALSE

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetLogicOpEnableEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, Bool32, CommandBuffer

valuecmdSetColorBlendEnableEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "firstAttachment" ::: Word32

    firstAttachment the first color attachment the color blending enable applies.

  4. -> "colorBlendEnables" ::: Vector Bool

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

  5. -> 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

Valid Usage (Implicit)

  • 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 QUEUE_GRAPHICS_BIT 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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetColorBlendEnableEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, Bool32, CommandBuffer

valuecmdSetColorBlendEquationEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "firstAttachment" ::: Word32

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

  4. -> "colorBlendEquations" ::: Vector ColorBlendEquationEXT

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

  5. -> 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

Valid Usage (Implicit)

  • 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 QUEUE_GRAPHICS_BIT 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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetColorBlendEquationEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, ColorBlendEquationEXT, CommandBuffer

valuecmdSetColorWriteMaskEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "firstAttachment" ::: Word32

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

  4. -> "colorWriteMasks" ::: Vector ColorComponentFlags

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

  5. -> 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.

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

Valid Usage (Implicit)

  • 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 QUEUE_GRAPHICS_BIT 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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetColorWriteMaskEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, ColorComponentFlags, CommandBuffer

valuecmdSetRasterizationStreamEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "rasterizationStream" ::: Word32

    rasterizationStream specifies the rasterizationStream state.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetRasterizationStreamEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_EXT_transform_feedback, CommandBuffer

valuecmdSetConservativeRasterizationModeEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> ConservativeRasterizationModeEXT

    conservativeRasterizationMode specifies the conservativeRasterizationMode state.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetConservativeRasterizationModeEXT is not affected by conditional rendering

See Also

VK_EXT_conservative_rasterization, VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, CommandBuffer, ConservativeRasterizationModeEXT

valuecmdSetExtraPrimitiveOverestimationSizeEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "extraPrimitiveOverestimationSize" ::: Float

    extraPrimitiveOverestimationSize specifies the extraPrimitiveOverestimationSize.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetExtraPrimitiveOverestimationSizeEXT is not affected by conditional rendering

See Also

VK_EXT_conservative_rasterization, VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, CommandBuffer

valuecmdSetDepthClipEnableEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "depthClipEnable" ::: Bool

    depthClipEnable specifies whether depth clipping is enabled.

  4. -> 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. If PipelineRasterizationDepthClipStateCreateInfoEXT was not specified, depth clipping is set to the inverse of the current value of depthClampEnable.

Valid Usage

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetDepthClipEnableEXT is not affected by conditional rendering

See Also

VK_EXT_depth_clip_enable, VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, Bool32, CommandBuffer

valuecmdSetSampleLocationsEnableEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "sampleLocationsEnable" ::: Bool

    sampleLocationsEnable specifies the sampleLocationsEnable state.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetSampleLocationsEnableEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_sample_locations, VK_EXT_shader_object, Bool32, CommandBuffer

valuecmdSetColorBlendAdvancedEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "firstAttachment" ::: Word32

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

  4. -> "colorBlendAdvanced" ::: Vector ColorBlendAdvancedEXT

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

  5. -> 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

Valid Usage (Implicit)

  • 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 QUEUE_GRAPHICS_BIT 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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetColorBlendAdvancedEXT is not affected by conditional rendering

See Also

VK_EXT_blend_operation_advanced, VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, ColorBlendAdvancedEXT, CommandBuffer

valuecmdSetProvokingVertexModeEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> ProvokingVertexModeEXT

    provokingVertexMode specifies the provokingVertexMode state.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetProvokingVertexModeEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_provoking_vertex, VK_EXT_shader_object, CommandBuffer, ProvokingVertexModeEXT

valuecmdSetLineRasterizationModeEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> LineRasterizationModeEXT

    lineRasterizationMode specifies the lineRasterizationMode state.

  4. -> 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 PipelineRasterizationLineStateCreateInfo::lineRasterizationMode value used to create the currently active pipeline.

Valid Usage

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetLineRasterizationModeEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_line_rasterization, VK_EXT_shader_object, CommandBuffer, LineRasterizationMode

valuecmdSetLineStippleEnableEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "stippledLineEnable" ::: Bool

    stippledLineEnable specifies the stippledLineEnable state.

  4. -> 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 PipelineRasterizationLineStateCreateInfo::stippledLineEnable value used to create the currently active pipeline.

Valid Usage

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetLineStippleEnableEXT is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_line_rasterization, VK_EXT_shader_object, Bool32, CommandBuffer

valuecmdSetDepthClipNegativeOneToOneEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "negativeOneToOne" ::: Bool

    negativeOneToOne specifies the negativeOneToOne state.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetDepthClipNegativeOneToOneEXT is not affected by conditional rendering

See Also

VK_EXT_depth_clip_control, VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, Bool32, CommandBuffer

valuecmdSetViewportWScalingEnableNV
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "viewportWScalingEnable" ::: Bool

    viewportWScalingEnable specifies the viewportWScalingEnable state.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetViewportWScalingEnableNV is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_clip_space_w_scaling, Bool32, CommandBuffer

valuecmdSetViewportSwizzleNV
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "firstViewport" ::: Word32

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

  4. -> "viewportSwizzles" ::: Vector ViewportSwizzleNV

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

  5. -> 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

Valid Usage (Implicit)

  • 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 QUEUE_GRAPHICS_BIT 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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetViewportSwizzleNV is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_viewport_swizzle, CommandBuffer, ViewportSwizzleNV

valuecmdSetCoverageToColorEnableNV
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "coverageToColorEnable" ::: Bool

    coverageToColorEnable specifies the coverageToColorEnable state.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetCoverageToColorEnableNV is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_fragment_coverage_to_color, Bool32, CommandBuffer

valuecmdSetCoverageToColorLocationNV
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "coverageToColorLocation" ::: Word32

    coverageToColorLocation specifies the coverageToColorLocation state.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetCoverageToColorLocationNV is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_fragment_coverage_to_color, CommandBuffer

valuecmdSetCoverageModulationModeNV
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> CoverageModulationModeNV

    coverageModulationMode specifies the coverageModulationMode state.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetCoverageModulationModeNV is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_framebuffer_mixed_samples, CommandBuffer, CoverageModulationModeNV

valuecmdSetCoverageModulationTableEnableNV
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "coverageModulationTableEnable" ::: Bool

    coverageModulationTableEnable specifies the coverageModulationTableEnable state.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetCoverageModulationTableEnableNV is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_framebuffer_mixed_samples, Bool32, CommandBuffer

valuecmdSetCoverageModulationTableNV
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "coverageModulationTable" ::: Vector Float

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

  4. -> 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

Valid Usage (Implicit)

  • 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 QUEUE_GRAPHICS_BIT 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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetCoverageModulationTableNV is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_framebuffer_mixed_samples, CommandBuffer

valuecmdSetShadingRateImageEnableNV
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "shadingRateImageEnable" ::: Bool

    shadingRateImageEnable specifies the shadingRateImageEnable state.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetShadingRateImageEnableNV is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_shading_rate_image, Bool32, CommandBuffer

valuecmdSetCoverageReductionModeNV
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> CoverageReductionModeNV

    coverageReductionMode specifies the coverageReductionMode state.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetCoverageReductionModeNV is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_coverage_reduction_mode, CommandBuffer, CoverageReductionModeNV

valuecmdSetRepresentativeFragmentTestEnableNV
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "representativeFragmentTestEnable" ::: Bool

    representativeFragmentTestEnable specifies the representativeFragmentTestEnable state.

  4. -> 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

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetRepresentativeFragmentTestEnableNV is not affected by conditional rendering

See Also

VK_EXT_extended_dynamic_state3, VK_EXT_shader_object, VK_NV_representative_fragment_test, Bool32, CommandBuffer

valuecmdSetVertexInputEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> "vertexBindingDescriptions" ::: Vector VertexInputBindingDescription2EXT

    pVertexBindingDescriptions is a pointer to an array of VertexInputBindingDescription2EXT structures.

  4. -> "vertexAttributeDescriptions" ::: Vector VertexInputAttributeDescription2EXT

    pVertexAttributeDescriptions is a pointer to an array of VertexInputAttributeDescription2EXT structures.

  5. -> 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.

The vertex attribute description for any location in the range [0,PhysicalDeviceLimits::maxVertexInputAttributes) not specified in the pVertexAttributeDescriptions array becomes undefined.

Valid Usage

  • 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)

  • 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 QUEUE_GRAPHICS_BIT 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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetVertexInputEXT is not affected by conditional rendering

See Also

VK_EXT_shader_object, VK_EXT_vertex_input_dynamic_state, CommandBuffer, VertexInputAttributeDescription2EXT, VertexInputBindingDescription2EXT

valuecmdSetDepthClampRangeEXT
  1. :: MonadIO io
  2. => CommandBuffer

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

  3. -> DepthClampModeEXT

    depthClampMode determines how the clamp range is determined for each viewport.

  4. -> "depthClampRange" ::: Maybe DepthClampRangeEXT

    pDepthClampRange sets the depth clamp range for all viewports if depthClampMode is DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT.

  5. -> io ()
#

vkCmdSetDepthClampRangeEXT - Set the viewport depth clamp range dynamically for a command buffer

Description

This command sets the viewport depth clamp range for subsequent drawing commands when drawing using shader objects, or when the graphics pipeline is created with DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT set in PipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the PipelineViewportDepthClampControlCreateInfoEXT::depthClampMode value used to create the currently active pipeline.

Valid Usage

Valid Usage (Implicit)

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

VK_QUEUE_GRAPHICS_BIT

State

Conditional Rendering

vkCmdSetDepthClampRangeEXT is not affected by conditional rendering

See Also

VK_EXT_depth_clamp_control, VK_EXT_shader_object, CommandBuffer, DepthClampModeEXT, DepthClampRangeEXT

newtypenewtype 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

Instances6Eq, Ord, Read, Show, Storable, Zero
newtypenewtype 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

Instances6Eq, Ord, Read, Show, Storable, Zero
newtypenewtype CoverageModulationModeNV
#

VkCoverageModulationModeNV - Specify the coverage modulation mode

Description

See Also

VK_NV_framebuffer_mixed_samples, PipelineCoverageModulationStateCreateInfoNV, cmdSetCoverageModulationModeNV

Constructors

Instances6Eq, Ord, Read, Show, Storable, Zero
newtypenewtype CoverageReductionModeNV
#

VkCoverageReductionModeNV - Specify the coverage reduction mode

Description

  • 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.

  • 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.

See Also

VK_NV_coverage_reduction_mode, FramebufferMixedSamplesCombinationNV, PipelineCoverageReductionStateCreateInfoNV, cmdSetCoverageReductionModeNV

Constructors

Instances6Eq, Ord, Read, Show, Storable, Zero
newtypenewtype ConservativeRasterizationModeEXT
#

VkConservativeRasterizationModeEXT - Specify the conservative rasterization mode

Description

See Also

VK_EXT_conservative_rasterization, PipelineRasterizationConservativeStateCreateInfoEXT, cmdSetConservativeRasterizationModeEXT

Constructors

Instances6Eq, Ord, Read, Show, Storable, Zero
newtypenewtype 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

Instances6Eq, Ord, Read, Show, Storable, Zero
newtypenewtype DepthClampModeEXT
#

VkDepthClampModeEXT - Modes that determine the depth clamp range

Description

  • DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT specifies that the depth clamp range follows the viewport depth range. The depth clamp range of each viewport will implicitly be set to zmin = min(n,f) and zmax = max(n,f), where n and f are the minDepth and maxDepth depth range values of the viewport.

See Also

VK_EXT_depth_clamp_control, PipelineViewportDepthClampControlCreateInfoEXT, cmdSetDepthClampRangeEXT

Constructors

Instances6Eq, Ord, Read, Show, Storable, Zero