Package org.lwjgl.vulkan

Class EXTShaderObject

java.lang.Object
org.lwjgl.vulkan.EXTShaderObject
public class EXTShaderObject extends Object
This extension introduces a new VkShaderEXT object type which represents a single compiled shader stage. Shader objects provide a more flexible alternative to VkPipeline objects, which may be helpful in certain use cases.
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);
Name String
VK_EXT_shader_object
Extension Type
Device extension
Registered Extension Number
483
Revision
1
Extension and Version Dependencies
VK_KHR_get_physical_device_properties2 or Version 1.1 and VK_KHR_dynamic_rendering or 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
IP Status
No known IP claims.
Contributors
  • Piers Daniell, NVIDIA
  • Sandy Jamieson, Nintendo
  • Žiga Markuš, LunarG
  • Tobias Hector, AMD
  • Alex Walters, Imagination
  • Shahbaz Youssefi, Google
  • Ralph Potter, Samsung
  • Jan-Harald Fredriksen, ARM
  • Connor Abott, Valve
  • Arseny Kapoulkine, Roblox
  • Patrick Doane, Activision
  • Jeff Leger, Qualcomm
  • Stu Smith, AMD
  • Chris Glover, Google
  • Ricardo Garcia, Igalia
  • Faith Ekstrand, Collabora
  • Timur Kristóf, Valve
  • Constantine Shablya, Collabora
  • Daniel Koch, NVIDIA
  • Alyssa Rosenzweig, Collabora
  • Mike Blumenkrantz, Valve
  • Samuel Pitoiset, Valve
  • Qun Lin, AMD
  • Spencer Fricke, LunarG
  • Soroush Faghihi Kashani, Imagination

  • Field Details

  • Method Details

    • nvkCreateShadersEXT

      public static int nvkCreateShadersEXT(org.lwjgl.vulkan.VkDevice device, int createInfoCount, long pCreateInfos, long pAllocator, long pShaders)
      Unsafe version of: CreateShadersEXT
      Parameters:
      createInfoCount - the length of the pCreateInfos and pShaders arrays.

    • vkCreateShadersEXT

      public static int vkCreateShadersEXT(org.lwjgl.vulkan.VkDevice device, VkShaderCreateInfoEXT.Buffer pCreateInfos, @Nullable VkAllocationCallbacks pAllocator, LongBuffer pShaders)
      Create one or more new shaders.
      C Specification

      To create one or more shader objects, call:

      
 VkResult vkCreateShadersEXT(
     VkDevice                                    device,
     uint32_t                                    createInfoCount,
     const VkShaderCreateInfoEXT*                pCreateInfos,
     const VkAllocationCallbacks*                pAllocator,
     VkShaderEXT*                                pShaders);
      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 VkShaderEXT 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 VkDevice handle
      • pCreateInfos must be a valid pointer to an array of createInfoCount valid VkShaderCreateInfoEXT structures
      • If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure
      • pShaders must be a valid pointer to an array of createInfoCount VkShaderEXT handles
      • createInfoCount must be greater than 0
      Return Codes
      On success, this command returns
      On failure, this command returns
      See Also

      VkAllocationCallbacks, VkShaderCreateInfoEXT

      Parameters:
      device - the logical device that creates the shader objects.
      pCreateInfos - a pointer to an array of VkShaderCreateInfoEXT structures.
      pAllocator - controls host memory allocation as described in the Memory Allocation chapter.
      pShaders - a pointer to an array of VkShaderEXT handles in which the resulting shader objects are returned.

    • nvkDestroyShaderEXT

      public static void nvkDestroyShaderEXT(org.lwjgl.vulkan.VkDevice device, long shader, long pAllocator)
      Unsafe version of: DestroyShaderEXT

    • vkDestroyShaderEXT

      public static void vkDestroyShaderEXT(org.lwjgl.vulkan.VkDevice device, long shader, @Nullable VkAllocationCallbacks pAllocator)
      Destroy a shader object.
      C Specification

      To destroy a shader object, call:

      
 void vkDestroyShaderEXT(
     VkDevice                                    device,
     VkShaderEXT                                 shader,
     const VkAllocationCallbacks*                pAllocator);
      Description

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

      Valid Usage
      • The shaderObject feature must be enabled
      • All submitted commands that refer to shader must have completed execution
      • If VkAllocationCallbacks were provided when shader was created, a compatible set of callbacks must be provided here
      • If no VkAllocationCallbacks were provided when shader was created, pAllocator must be NULL
      Valid Usage (Implicit)
      • device must be a valid VkDevice handle
      • If shader is not NULL_HANDLE, shader must be a valid VkShaderEXT handle
      • If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks 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

      VkAllocationCallbacks

      Parameters:
      device - the logical device that destroys the shader object.
      shader - the handle of the shader object to destroy.
      pAllocator - controls host memory allocation as described in the Memory Allocation chapter.

    • nvkGetShaderBinaryDataEXT

      public static int nvkGetShaderBinaryDataEXT(org.lwjgl.vulkan.VkDevice device, long shader, long pDataSize, long pData)
      Unsafe version of: GetShaderBinaryDataEXT
      Parameters:
      pDataSize - a pointer to a size_t value related to the size of the binary shader code, as described below.

    • vkGetShaderBinaryDataEXT

      public static int vkGetShaderBinaryDataEXT(org.lwjgl.vulkan.VkDevice device, long shader, org.lwjgl.PointerBuffer pDataSize, @Nullable ByteBuffer pData)
      Get the binary shader code from a shader object.
      C Specification

      Binary shader code can be retrieved from a shader object using the command:

      
 VkResult vkGetShaderBinaryDataEXT(
     VkDevice                                    device,
     VkShaderEXT                                 shader,
     size_t*                                     pDataSize,
     void*                                       pData);
      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.

      Note

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

      Binary shader code retrieved using vkGetShaderBinaryDataEXT 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 VkShaderCreateInfoEXT.

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

      Valid Usage
      • The shaderObject feature must be enabled
      • If pData is not NULL, it must be aligned to 16 bytes
      Valid Usage (Implicit)
      • device must be a valid VkDevice handle
      • shader must be a valid VkShaderEXT 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
      On success, this command returns
      On failure, this command returns
      Parameters:
      device - the logical device that shader object was created from.
      shader - the shader object to retrieve binary shader code from.
      pDataSize - a pointer to a size_t value related to the size of the binary shader code, as described below.
      pData - either NULL or a pointer to a buffer.

    • nvkCmdBindShadersEXT

      public static void nvkCmdBindShadersEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int stageCount, long pStages, long pShaders)
      Unsafe version of: CmdBindShadersEXT
      Parameters:
      stageCount - the length of the pStages and pShaders arrays.

    • vkCmdBindShadersEXT

      public static void vkCmdBindShadersEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, IntBuffer pStages, LongBuffer pShaders)
      Bind shader objects to a command buffer.
      C Specification

      Once shader objects have been created, they can be bound to the command buffer using the command:

      
 void vkCmdBindShadersEXT(
     VkCommandBuffer                             commandBuffer,
     uint32_t                                    stageCount,
     const VkShaderStageFlagBits*                pStages,
     const VkShaderEXT*                          pShaders);
      Description

      When binding linked shaders, an application may bind them in any combination of one or more calls to vkCmdBindShadersEXT (i.e., shaders that were created linked together do not need to be bound in the same vkCmdBindShadersEXT 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, vkCmdBindShadersEXT 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)
      • commandBuffer must be a valid VkCommandBuffer handle
      • pStages must be a valid pointer to an array of stageCount valid VkShaderStageFlagBits values
      • If pShaders is not NULL, pShaders must be a valid pointer to an array of stageCount valid or NULL_HANDLE VkShaderEXT handles
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations
      • This command must only be called outside of a video coding scope
      • stageCount must be greater than 0
      • Both of commandBuffer, and the elements of pShaders that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphics ComputeState
      Parameters:
      commandBuffer - the command buffer that the shader object will be bound to.
      pStages - a pointer to an array of VkShaderStageFlagBits values specifying one stage per array index that is affected by the corresponding value in the pShaders array.
      pShaders - a pointer to an array of VkShaderEXT handles and/or NULL_HANDLE values describing the shader binding operations to be performed on each stage in pStages.

    • vkCmdSetCullModeEXT

      public static void vkCmdSetCullModeEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int cullMode)
      See CmdSetCullMode.
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      cullMode - specifies the cull mode property to use for drawing.

    • vkCmdSetFrontFaceEXT

      public static void vkCmdSetFrontFaceEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int frontFace)
      See CmdSetFrontFace.
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      frontFace - a VkFrontFace value specifying the front-facing triangle orientation to be used for culling.

    • vkCmdSetPrimitiveTopologyEXT

      public static void vkCmdSetPrimitiveTopologyEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int primitiveTopology)
      See CmdSetPrimitiveTopology.
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      primitiveTopology - specifies the primitive topology to use for drawing.

    • nvkCmdSetViewportWithCountEXT

      public static void nvkCmdSetViewportWithCountEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int viewportCount, long pViewports)
      Unsafe version of: CmdSetViewportWithCountEXT
      Parameters:
      viewportCount - specifies the viewport count.

    • vkCmdSetViewportWithCountEXT

      public static void vkCmdSetViewportWithCountEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, VkViewport.Buffer pViewports)
      See CmdSetViewportWithCount.
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      pViewports - specifies the viewports to use for drawing.

    • nvkCmdSetScissorWithCountEXT

      public static void nvkCmdSetScissorWithCountEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int scissorCount, long pScissors)
      Unsafe version of: CmdSetScissorWithCountEXT
      Parameters:
      scissorCount - specifies the scissor count.

    • vkCmdSetScissorWithCountEXT

      public static void vkCmdSetScissorWithCountEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, VkRect2D.Buffer pScissors)
      See CmdSetScissorWithCount.
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      pScissors - specifies the scissors to use for drawing.

    • nvkCmdBindVertexBuffers2EXT

      public static void nvkCmdBindVertexBuffers2EXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int firstBinding, int bindingCount, long pBuffers, long pOffsets, long pSizes, long pStrides)
      Unsafe version of: CmdBindVertexBuffers2EXT
      Parameters:
      bindingCount - the number of vertex input bindings whose state is updated by the command.

    • vkCmdBindVertexBuffers2EXT

      public static void vkCmdBindVertexBuffers2EXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int firstBinding, LongBuffer pBuffers, LongBuffer pOffsets, @Nullable LongBuffer pSizes, @Nullable LongBuffer pStrides)
      See CmdBindVertexBuffers2.
      Parameters:
      commandBuffer - the command buffer into which the command is recorded.
      firstBinding - the index of the first vertex input binding whose state is updated by the command.
      pBuffers - a pointer to an array of buffer handles.
      pOffsets - a pointer to an array of buffer offsets.
      pSizes - NULL or a pointer to an array of the size in bytes of vertex data bound from pBuffers.
      pStrides - NULL or a pointer to an array of buffer strides.

    • vkCmdSetDepthTestEnableEXT

      public static void vkCmdSetDepthTestEnableEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean depthTestEnable)
      See CmdSetDepthTestEnable.
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      depthTestEnable - specifies if the depth test is enabled.

    • vkCmdSetDepthWriteEnableEXT

      public static void vkCmdSetDepthWriteEnableEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean depthWriteEnable)
      See CmdSetDepthWriteEnable.
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      depthWriteEnable - specifies if depth writes are enabled.

    • vkCmdSetDepthCompareOpEXT

      public static void vkCmdSetDepthCompareOpEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int depthCompareOp)
      See CmdSetDepthCompareOp.
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      depthCompareOp - a VkCompareOp value specifying the comparison operator used for the Depth Comparison step of the depth test.

    • vkCmdSetDepthBoundsTestEnableEXT

      public static void vkCmdSetDepthBoundsTestEnableEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean depthBoundsTestEnable)
      See CmdSetDepthBoundsTestEnable.
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      depthBoundsTestEnable - specifies if the depth bounds test is enabled.

    • vkCmdSetStencilTestEnableEXT

      public static void vkCmdSetStencilTestEnableEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean stencilTestEnable)
      See CmdSetStencilTestEnable.
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      stencilTestEnable - specifies if the stencil test is enabled.

    • vkCmdSetStencilOpEXT

      public static void vkCmdSetStencilOpEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int faceMask, int failOp, int passOp, int depthFailOp, int compareOp)
      See CmdSetStencilOp.
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      faceMask - a bitmask of VkStencilFaceFlagBits specifying the set of stencil state for which to update the stencil operation.
      failOp - a VkStencilOp value specifying the action performed on samples that fail the stencil test.
      passOp - a VkStencilOp value specifying the action performed on samples that pass both the depth and stencil tests.
      depthFailOp - a VkStencilOp value specifying the action performed on samples that pass the stencil test and fail the depth test.
      compareOp - a VkCompareOp value specifying the comparison operator used in the stencil test.

    • nvkCmdSetVertexInputEXT

      public static void nvkCmdSetVertexInputEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int vertexBindingDescriptionCount, long pVertexBindingDescriptions, int vertexAttributeDescriptionCount, long pVertexAttributeDescriptions)
      Unsafe version of: CmdSetVertexInputEXT
      Parameters:
      vertexBindingDescriptionCount - the number of vertex binding descriptions provided in pVertexBindingDescriptions.
      vertexAttributeDescriptionCount - the number of vertex attribute descriptions provided in pVertexAttributeDescriptions.

    • vkCmdSetVertexInputEXT

      public static void vkCmdSetVertexInputEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, @Nullable VkVertexInputBindingDescription2EXT.Buffer pVertexBindingDescriptions, @Nullable VkVertexInputAttributeDescription2EXT.Buffer pVertexAttributeDescriptions)
      Set the vertex input state dynamically for a command buffer.
      C Specification

      To dynamically set the vertex input attribute and vertex input binding descriptions, call:

      
 void vkCmdSetVertexInputEXT(
     VkCommandBuffer                             commandBuffer,
     uint32_t                                    vertexBindingDescriptionCount,
     const VkVertexInputBindingDescription2EXT*  pVertexBindingDescriptions,
     uint32_t                                    vertexAttributeDescriptionCount,
     const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkGraphicsPipelineCreateInfo::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 vkCmdSetVertexInputEXT to dynamically set the stride.

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

      Valid Usage
      • Either the vertexInputDynamicState feature or the shaderObject feature or both must be enabled
      • vertexBindingDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings
      • vertexAttributeDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputAttributes
      • For every binding specified by each element of pVertexAttributeDescriptions, a VkVertexInputBindingDescription2EXT must exist in pVertexBindingDescriptions with the same value of binding
      • All elements of pVertexBindingDescriptions must describe distinct binding numbers
      • All elements of pVertexAttributeDescriptions must describe distinct attribute locations
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • If vertexBindingDescriptionCount is not 0, pVertexBindingDescriptions must be a valid pointer to an array of vertexBindingDescriptionCount valid VkVertexInputBindingDescription2EXT structures
      • If vertexAttributeDescriptionCount is not 0, pVertexAttributeDescriptions must be a valid pointer to an array of vertexAttributeDescriptionCount valid VkVertexInputAttributeDescription2EXT structures
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      See Also

      VkVertexInputAttributeDescription2EXT, VkVertexInputBindingDescription2EXT

      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      pVertexBindingDescriptions - a pointer to an array of VkVertexInputBindingDescription2EXT structures.
      pVertexAttributeDescriptions - a pointer to an array of VkVertexInputAttributeDescription2EXT structures.

    • vkCmdSetPatchControlPointsEXT

      public static void vkCmdSetPatchControlPointsEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int patchControlPoints)
      Specify the number of control points per patch dynamically for a command buffer.
      C Specification

      To dynamically set the number of control points per patch, call:

      
 void vkCmdSetPatchControlPointsEXT(
     VkCommandBuffer                             commandBuffer,
     uint32_t                                    patchControlPoints);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineTessellationStateCreateInfo::patchControlPoints value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      patchControlPoints - specifies the number of control points per patch.

    • vkCmdSetRasterizerDiscardEnableEXT

      public static void vkCmdSetRasterizerDiscardEnableEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean rasterizerDiscardEnable)
      See CmdSetRasterizerDiscardEnable.
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      rasterizerDiscardEnable - controls whether primitives are discarded immediately before the rasterization stage.

    • vkCmdSetDepthBiasEnableEXT

      public static void vkCmdSetDepthBiasEnableEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean depthBiasEnable)
      See CmdSetDepthBiasEnable.
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      depthBiasEnable - controls whether to bias fragment depth values.

    • vkCmdSetLogicOpEXT

      public static void vkCmdSetLogicOpEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int logicOp)
      Select which logical operation to apply for blend state dynamically for a command buffer.
      C Specification

      To dynamically set the logical operation to apply for blend state, call:

      
 void vkCmdSetLogicOpEXT(
     VkCommandBuffer                             commandBuffer,
     VkLogicOp                                   logicOp);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineColorBlendStateCreateInfo::logicOp value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • logicOp must be a valid VkLogicOp value
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      logicOp - specifies the logical operation to apply for blend state.

    • vkCmdSetPrimitiveRestartEnableEXT

      public static void vkCmdSetPrimitiveRestartEnableEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean primitiveRestartEnable)
      See CmdSetPrimitiveRestartEnable.
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      primitiveRestartEnable - controls whether a special vertex index value is treated as restarting the assembly of primitives. It behaves in the same way as VkPipelineInputAssemblyStateCreateInfo::primitiveRestartEnable

    • vkCmdSetTessellationDomainOriginEXT

      public static void vkCmdSetTessellationDomainOriginEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int domainOrigin)
      Specify the origin of the tessellation domain space dynamically for a command buffer.
      C Specification

      To dynamically set the origin of the tessellation domain space, call:

      
 void vkCmdSetTessellationDomainOriginEXT(
     VkCommandBuffer                             commandBuffer,
     VkTessellationDomainOrigin                  domainOrigin);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineTessellationDomainOriginStateCreateInfo::domainOrigin value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • domainOrigin must be a valid VkTessellationDomainOrigin value
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      domainOrigin - specifies the origin of the tessellation domain space.

    • vkCmdSetDepthClampEnableEXT

      public static void vkCmdSetDepthClampEnableEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean depthClampEnable)
      Specify dynamically whether depth clamping is enabled in the command buffer.
      C Specification

      To dynamically set enable or disable depth clamping, call:

      
 void vkCmdSetDepthClampEnableEXT(
     VkCommandBuffer                             commandBuffer,
     VkBool32                                    depthClampEnable);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineRasterizationStateCreateInfo::depthClampEnable value used to create the currently active pipeline.

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

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      depthClampEnable - specifies whether depth clamping is enabled.

    • vkCmdSetPolygonModeEXT

      public static void vkCmdSetPolygonModeEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int polygonMode)
      Specify polygon mode dynamically for a command buffer.
      C Specification

      To dynamically set the polygon mode, call:

      
 void vkCmdSetPolygonModeEXT(
     VkCommandBuffer                             commandBuffer,
     VkPolygonMode                               polygonMode);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineRasterizationStateCreateInfo::polygonMode value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • polygonMode must be a valid VkPolygonMode value
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      polygonMode - specifies polygon mode.

    • vkCmdSetRasterizationSamplesEXT

      public static void vkCmdSetRasterizationSamplesEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int rasterizationSamples)
      Specify the rasterization samples dynamically for a command buffer.
      C Specification

      To dynamically set the rasterizationSamples, call:

      
 void vkCmdSetRasterizationSamplesEXT(
     VkCommandBuffer                             commandBuffer,
     VkSampleCountFlagBits                       rasterizationSamples);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineMultisampleStateCreateInfo::rasterizationSamples value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • rasterizationSamples must be a valid VkSampleCountFlagBits value
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      rasterizationSamples - specifies rasterizationSamples.

    • nvkCmdSetSampleMaskEXT

      public static void nvkCmdSetSampleMaskEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int samples, long pSampleMask)
      Unsafe version of: CmdSetSampleMaskEXT

    • vkCmdSetSampleMaskEXT

      public static void vkCmdSetSampleMaskEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int samples, IntBuffer pSampleMask)
      Specify the sample mask dynamically for a command buffer.
      C Specification

      To dynamically set the sample mask, call:

      
 void vkCmdSetSampleMaskEXT(
     VkCommandBuffer                             commandBuffer,
     VkSampleCountFlagBits                       samples,
     const VkSampleMask*                         pSampleMask);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineMultisampleStateCreateInfo::pSampleMask value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • samples must be a valid VkSampleCountFlagBits value
      • pSampleMask must be a valid pointer to an array of ceil(samples / 32) VkSampleMask values
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      samples - specifies the number of sample bits in the pSampleMask.
      pSampleMask - a pointer to an array of VkSampleMask values, where the array size is based on the samples parameter.

    • vkCmdSetAlphaToCoverageEnableEXT

      public static void vkCmdSetAlphaToCoverageEnableEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean alphaToCoverageEnable)
      Specify the alpha to coverage enable state dynamically for a command buffer.
      C Specification

      To dynamically set the alphaToCoverageEnable state, call:

      
 void vkCmdSetAlphaToCoverageEnableEXT(
     VkCommandBuffer                             commandBuffer,
     VkBool32                                    alphaToCoverageEnable);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineMultisampleStateCreateInfo::alphaToCoverageEnable value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      alphaToCoverageEnable - specifies the alphaToCoverageEnable state.

    • vkCmdSetAlphaToOneEnableEXT

      public static void vkCmdSetAlphaToOneEnableEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean alphaToOneEnable)
      Specify the alpha to one enable state dynamically for a command buffer.
      C Specification

      To dynamically set the alphaToOneEnable state, call:

      
 void vkCmdSetAlphaToOneEnableEXT(
     VkCommandBuffer                             commandBuffer,
     VkBool32                                    alphaToOneEnable);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineMultisampleStateCreateInfo::alphaToOneEnable value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      alphaToOneEnable - specifies the alphaToOneEnable state.

    • vkCmdSetLogicOpEnableEXT

      public static void vkCmdSetLogicOpEnableEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean logicOpEnable)
      Specify dynamically whether logical operations are enabled for a command buffer.
      C Specification

      To dynamically set whether logical operations are enabled, call:

      
 void vkCmdSetLogicOpEnableEXT(
     VkCommandBuffer                             commandBuffer,
     VkBool32                                    logicOpEnable);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineColorBlendStateCreateInfo::logicOpEnable value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      logicOpEnable - specifies whether logical operations are enabled.

    • nvkCmdSetColorBlendEnableEXT

      public static void nvkCmdSetColorBlendEnableEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int firstAttachment, int attachmentCount, long pColorBlendEnables)
      Unsafe version of: CmdSetColorBlendEnableEXT
      Parameters:
      attachmentCount - the number of color blending enables in the pColorBlendEnables array.

    • vkCmdSetColorBlendEnableEXT

      public static void vkCmdSetColorBlendEnableEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int firstAttachment, IntBuffer pColorBlendEnables)
      Specify the blendEnable for each attachment dynamically for a command buffer.
      C Specification

      To dynamically set blendEnable, call:

      
 void vkCmdSetColorBlendEnableEXT(
     VkCommandBuffer                             commandBuffer,
     uint32_t                                    firstAttachment,
     uint32_t                                    attachmentCount,
     const VkBool32*                             pColorBlendEnables);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineColorBlendAttachmentState::blendEnable values used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • pColorBlendEnables must be a valid pointer to an array of attachmentCount VkBool32 values
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      • attachmentCount must be greater than 0
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      firstAttachment - the first color attachment the color blending enable applies.
      pColorBlendEnables - an array of booleans to indicate whether color blending is enabled for the corresponding attachment.

    • nvkCmdSetColorBlendEquationEXT

      public static void nvkCmdSetColorBlendEquationEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int firstAttachment, int attachmentCount, long pColorBlendEquations)
      Unsafe version of: CmdSetColorBlendEquationEXT
      Parameters:
      attachmentCount - the number of VkColorBlendEquationEXT elements in the pColorBlendEquations array.

    • vkCmdSetColorBlendEquationEXT

      public static void vkCmdSetColorBlendEquationEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int firstAttachment, VkColorBlendEquationEXT.Buffer pColorBlendEquations)
      Specify the blend factors and operations dynamically for a command buffer.
      C Specification

      To dynamically set color blend factors and operations, call:

      
 void vkCmdSetColorBlendEquationEXT(
     VkCommandBuffer                             commandBuffer,
     uint32_t                                    firstAttachment,
     uint32_t                                    attachmentCount,
     const VkColorBlendEquationEXT*              pColorBlendEquations);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineColorBlendAttachmentState::srcColorBlendFactor, VkPipelineColorBlendAttachmentState::dstColorBlendFactor, VkPipelineColorBlendAttachmentState::colorBlendOp, VkPipelineColorBlendAttachmentState::srcAlphaBlendFactor, VkPipelineColorBlendAttachmentState::dstAlphaBlendFactor, and VkPipelineColorBlendAttachmentState::alphaBlendOp values used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • pColorBlendEquations must be a valid pointer to an array of attachmentCount valid VkColorBlendEquationEXT structures
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      • attachmentCount must be greater than 0
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      See Also

      VkColorBlendEquationEXT

      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      firstAttachment - the first color attachment the color blend factors and operations apply to.
      pColorBlendEquations - an array of VkColorBlendEquationEXT structs that specify the color blend factors and operations for the corresponding attachments.

    • nvkCmdSetColorWriteMaskEXT

      public static void nvkCmdSetColorWriteMaskEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int firstAttachment, int attachmentCount, long pColorWriteMasks)
      Unsafe version of: CmdSetColorWriteMaskEXT
      Parameters:
      attachmentCount - the number of VkColorComponentFlags values in the pColorWriteMasks array.

    • vkCmdSetColorWriteMaskEXT

      public static void vkCmdSetColorWriteMaskEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int firstAttachment, IntBuffer pColorWriteMasks)
      Specify the color write masks for each attachment dynamically for a command buffer.
      C Specification

      To dynamically set the color write masks, call:

      
 void vkCmdSetColorWriteMaskEXT(
     VkCommandBuffer                             commandBuffer,
     uint32_t                                    firstAttachment,
     uint32_t                                    attachmentCount,
     const VkColorComponentFlags*                pColorWriteMasks);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineColorBlendAttachmentState::colorWriteMask values used to create the currently active pipeline.

      Note

      Formats with bits that are shared between components specified by VkColorComponentFlagBits, 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)
      • commandBuffer must be a valid VkCommandBuffer handle
      • pColorWriteMasks must be a valid pointer to an array of attachmentCount valid combinations of VkColorComponentFlagBits values
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      • attachmentCount must be greater than 0
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      firstAttachment - the first color attachment the color write masks apply to.
      pColorWriteMasks - an array of VkColorComponentFlags values that specify the color write masks of the corresponding attachments.

    • vkCmdSetRasterizationStreamEXT

      public static void vkCmdSetRasterizationStreamEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int rasterizationStream)
      Specify the rasterization stream dynamically for a command buffer.
      C Specification

      To dynamically set the rasterizationStream state, call:

      
 void vkCmdSetRasterizationStreamEXT(
     VkCommandBuffer                             commandBuffer,
     uint32_t                                    rasterizationStream);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      rasterizationStream - specifies the rasterizationStream state.

    • vkCmdSetConservativeRasterizationModeEXT

      public static void vkCmdSetConservativeRasterizationModeEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int conservativeRasterizationMode)
      Specify the conservative rasterization mode dynamically for a command buffer.
      C Specification

      To dynamically set the conservativeRasterizationMode, call:

      
 void vkCmdSetConservativeRasterizationModeEXT(
     VkCommandBuffer                             commandBuffer,
     VkConservativeRasterizationModeEXT          conservativeRasterizationMode);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineRasterizationConservativeStateCreateInfoEXT::conservativeRasterizationMode value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • conservativeRasterizationMode must be a valid VkConservativeRasterizationModeEXT value
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      conservativeRasterizationMode - specifies the conservativeRasterizationMode state.

    • vkCmdSetExtraPrimitiveOverestimationSizeEXT

      public static void vkCmdSetExtraPrimitiveOverestimationSizeEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize)
      Specify the conservative rasterization extra primitive overestimation size dynamically for a command buffer.
      C Specification

      To dynamically set the extraPrimitiveOverestimationSize, call:

      
 void vkCmdSetExtraPrimitiveOverestimationSizeEXT(
     VkCommandBuffer                             commandBuffer,
     float                                       extraPrimitiveOverestimationSize);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineRasterizationConservativeStateCreateInfoEXT::extraPrimitiveOverestimationSize value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      extraPrimitiveOverestimationSize - specifies the extraPrimitiveOverestimationSize.

    • vkCmdSetDepthClipEnableEXT

      public static void vkCmdSetDepthClipEnableEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean depthClipEnable)
      Specify dynamically whether depth clipping is enabled in the command buffer.
      C Specification

      To dynamically set enable or disable depth clipping, call:

      
 void vkCmdSetDepthClipEnableEXT(
     VkCommandBuffer                             commandBuffer,
     VkBool32                                    depthClipEnable);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineRasterizationDepthClipStateCreateInfoEXT::depthClipEnable value used to create the currently active pipeline, or by the inverse of VkPipelineRasterizationStateCreateInfo::depthClampEnable if VkPipelineRasterizationDepthClipStateCreateInfoEXT is not specified.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      depthClipEnable - specifies whether depth clipping is enabled.

    • vkCmdSetSampleLocationsEnableEXT

      public static void vkCmdSetSampleLocationsEnableEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean sampleLocationsEnable)
      Specify the samples locations enable state dynamically for a command buffer.
      C Specification

      To dynamically set the sampleLocationsEnable state, call:

      
 void vkCmdSetSampleLocationsEnableEXT(
     VkCommandBuffer                             commandBuffer,
     VkBool32                                    sampleLocationsEnable);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      sampleLocationsEnable - specifies the sampleLocationsEnable state.

    • nvkCmdSetColorBlendAdvancedEXT

      public static void nvkCmdSetColorBlendAdvancedEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int firstAttachment, int attachmentCount, long pColorBlendAdvanced)
      Unsafe version of: CmdSetColorBlendAdvancedEXT
      Parameters:
      attachmentCount - the number of VkColorBlendAdvancedEXT elements in the pColorBlendAdvanced array.

    • vkCmdSetColorBlendAdvancedEXT

      public static void vkCmdSetColorBlendAdvancedEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int firstAttachment, VkColorBlendAdvancedEXT.Buffer pColorBlendAdvanced)
      Specify the advanced color blend state dynamically for a command buffer.
      C Specification

      To dynamically set the advanced blend state, call:

      
 void vkCmdSetColorBlendAdvancedEXT(
     VkCommandBuffer                             commandBuffer,
     uint32_t                                    firstAttachment,
     uint32_t                                    attachmentCount,
     const VkColorBlendAdvancedEXT*              pColorBlendAdvanced);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineColorBlendAdvancedStateCreateInfoEXT::srcPremultiplied, VkPipelineColorBlendAdvancedStateCreateInfoEXT::dstPremultiplied, and VkPipelineColorBlendAdvancedStateCreateInfoEXT::blendOverlap values used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • pColorBlendAdvanced must be a valid pointer to an array of attachmentCount valid VkColorBlendAdvancedEXT structures
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      • attachmentCount must be greater than 0
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      See Also

      VkColorBlendAdvancedEXT

      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      firstAttachment - the first color attachment the advanced blend parameters apply to.
      pColorBlendAdvanced - an array of VkColorBlendAdvancedEXT structs that specify the advanced color blend parameters for the corresponding attachments.

    • vkCmdSetProvokingVertexModeEXT

      public static void vkCmdSetProvokingVertexModeEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int provokingVertexMode)
      Specify the provoking vertex mode dynamically for a command buffer.
      C Specification

      To dynamically set the provokingVertexMode state, call:

      
 void vkCmdSetProvokingVertexModeEXT(
     VkCommandBuffer                             commandBuffer,
     VkProvokingVertexModeEXT                    provokingVertexMode);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::provokingVertexMode value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • provokingVertexMode must be a valid VkProvokingVertexModeEXT value
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      provokingVertexMode - specifies the provokingVertexMode state.

    • vkCmdSetLineRasterizationModeEXT

      public static void vkCmdSetLineRasterizationModeEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int lineRasterizationMode)
      Specify the line rasterization mode dynamically for a command buffer.
      C Specification

      To dynamically set the lineRasterizationMode state, call:

      
 void vkCmdSetLineRasterizationModeEXT(
     VkCommandBuffer                             commandBuffer,
     VkLineRasterizationModeEXT                  lineRasterizationMode);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineRasterizationLineStateCreateInfo::lineRasterizationMode value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • lineRasterizationMode must be a valid VkLineRasterizationModeEXT value
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      lineRasterizationMode - specifies the lineRasterizationMode state.

    • vkCmdSetLineStippleEnableEXT

      public static void vkCmdSetLineStippleEnableEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean stippledLineEnable)
      Specify the line stipple enable dynamically for a command buffer.
      C Specification

      To dynamically set the stippledLineEnable state, call:

      
 void vkCmdSetLineStippleEnableEXT(
     VkCommandBuffer                             commandBuffer,
     VkBool32                                    stippledLineEnable);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineRasterizationLineStateCreateInfo::stippledLineEnable value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      stippledLineEnable - specifies the stippledLineEnable state.

    • vkCmdSetDepthClipNegativeOneToOneEXT

      public static void vkCmdSetDepthClipNegativeOneToOneEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean negativeOneToOne)
      Specify the negative one to one depth clip mode dynamically for a command buffer.
      C Specification

      To dynamically set negativeOneToOne, call:

      
 void vkCmdSetDepthClipNegativeOneToOneEXT(
     VkCommandBuffer                             commandBuffer,
     VkBool32                                    negativeOneToOne);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineViewportDepthClipControlCreateInfoEXT::negativeOneToOne value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      negativeOneToOne - specifies the negativeOneToOne state.

    • vkCmdSetViewportWScalingEnableNV

      public static void vkCmdSetViewportWScalingEnableNV(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean viewportWScalingEnable)
      Specify the viewport W scaling enable state dynamically for a command buffer.
      C Specification

      To dynamically set the viewportWScalingEnable state, call:

      
 void vkCmdSetViewportWScalingEnableNV(
     VkCommandBuffer                             commandBuffer,
     VkBool32                                    viewportWScalingEnable);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineViewportWScalingStateCreateInfoNV::viewportWScalingEnable value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      viewportWScalingEnable - specifies the viewportWScalingEnable state.

    • nvkCmdSetViewportSwizzleNV

      public static void nvkCmdSetViewportSwizzleNV(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int firstViewport, int viewportCount, long pViewportSwizzles)
      Unsafe version of: CmdSetViewportSwizzleNV
      Parameters:
      viewportCount - the number of viewports whose parameters are updated by the command.

    • vkCmdSetViewportSwizzleNV

      public static void vkCmdSetViewportSwizzleNV(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int firstViewport, VkViewportSwizzleNV.Buffer pViewportSwizzles)
      Specify the viewport swizzle state dynamically for a command buffer.
      C Specification

      To dynamically set the viewport swizzle state, call:

      
 void vkCmdSetViewportSwizzleNV(
     VkCommandBuffer                             commandBuffer,
     uint32_t                                    firstViewport,
     uint32_t                                    viewportCount,
     const VkViewportSwizzleNV*                  pViewportSwizzles);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount, and VkPipelineViewportSwizzleStateCreateInfoNV::pViewportSwizzles values used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • pViewportSwizzles must be a valid pointer to an array of viewportCount valid VkViewportSwizzleNV structures
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      • viewportCount must be greater than 0
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      See Also

      VkViewportSwizzleNV

      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      firstViewport - the index of the first viewport whose parameters are updated by the command.
      pViewportSwizzles - a pointer to an array of VkViewportSwizzleNV structures specifying viewport swizzles.

    • vkCmdSetCoverageToColorEnableNV

      public static void vkCmdSetCoverageToColorEnableNV(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean coverageToColorEnable)
      Specify the coverage to color enable state dynamically for a command buffer.
      C Specification

      To dynamically set the coverageToColorEnable state, call:

      
 void vkCmdSetCoverageToColorEnableNV(
     VkCommandBuffer                             commandBuffer,
     VkBool32                                    coverageToColorEnable);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineCoverageToColorStateCreateInfoNV::coverageToColorEnable value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      coverageToColorEnable - specifies the coverageToColorEnable state.

    • vkCmdSetCoverageToColorLocationNV

      public static void vkCmdSetCoverageToColorLocationNV(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int coverageToColorLocation)
      Specify the coverage to color location dynamically for a command buffer.
      C Specification

      To dynamically set the coverageToColorLocation state, call:

      
 void vkCmdSetCoverageToColorLocationNV(
     VkCommandBuffer                             commandBuffer,
     uint32_t                                    coverageToColorLocation);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineCoverageToColorStateCreateInfoNV::coverageToColorLocation value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      coverageToColorLocation - specifies the coverageToColorLocation state.

    • vkCmdSetCoverageModulationModeNV

      public static void vkCmdSetCoverageModulationModeNV(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int coverageModulationMode)
      Specify the coverage modulation mode dynamically for a command buffer.
      C Specification

      To dynamically set the coverageModulationMode state, call:

      
 void vkCmdSetCoverageModulationModeNV(
     VkCommandBuffer                             commandBuffer,
     VkCoverageModulationModeNV                  coverageModulationMode);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineCoverageModulationStateCreateInfoNV::coverageModulationMode value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • coverageModulationMode must be a valid VkCoverageModulationModeNV value
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      coverageModulationMode - specifies the coverageModulationMode state.

    • vkCmdSetCoverageModulationTableEnableNV

      public static void vkCmdSetCoverageModulationTableEnableNV(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean coverageModulationTableEnable)
      Specify the coverage modulation table enable state dynamically for a command buffer.
      C Specification

      To dynamically set the coverageModulationTableEnable state, call:

      
 void vkCmdSetCoverageModulationTableEnableNV(
     VkCommandBuffer                             commandBuffer,
     VkBool32                                    coverageModulationTableEnable);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineCoverageModulationStateCreateInfoNV::coverageModulationTableEnable value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      coverageModulationTableEnable - specifies the coverageModulationTableEnable state.

    • nvkCmdSetCoverageModulationTableNV

      public static void nvkCmdSetCoverageModulationTableNV(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int coverageModulationTableCount, long pCoverageModulationTable)
      Unsafe version of: CmdSetCoverageModulationTableNV
      Parameters:
      coverageModulationTableCount - specifies the number of elements in pCoverageModulationTable.

    • vkCmdSetCoverageModulationTableNV

      public static void vkCmdSetCoverageModulationTableNV(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, FloatBuffer pCoverageModulationTable)
      Specify the coverage modulation table dynamically for a command buffer.
      C Specification

      To dynamically set the pCoverageModulationTable state, call:

      
 void vkCmdSetCoverageModulationTableNV(
     VkCommandBuffer                             commandBuffer,
     uint32_t                                    coverageModulationTableCount,
     const float*                                pCoverageModulationTable);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineCoverageModulationStateCreateInfoNV::coverageModulationTableCount, and VkPipelineCoverageModulationStateCreateInfoNV::pCoverageModulationTable values used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • pCoverageModulationTable must be a valid pointer to an array of coverageModulationTableCount float values
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      • coverageModulationTableCount must be greater than 0
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      pCoverageModulationTable - specifies the table of modulation factors containing a value for each number of covered samples.

    • vkCmdSetShadingRateImageEnableNV

      public static void vkCmdSetShadingRateImageEnableNV(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean shadingRateImageEnable)
      Specify the shading rate image enable state dynamically for a command buffer.
      C Specification

      To dynamically set the shadingRateImageEnable state, call:

      
 void vkCmdSetShadingRateImageEnableNV(
     VkCommandBuffer                             commandBuffer,
     VkBool32                                    shadingRateImageEnable);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineViewportShadingRateImageStateCreateInfoNV::shadingRateImageEnable value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      shadingRateImageEnable - specifies the shadingRateImageEnable state.

    • vkCmdSetRepresentativeFragmentTestEnableNV

      public static void vkCmdSetRepresentativeFragmentTestEnableNV(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, boolean representativeFragmentTestEnable)
      Specify the representative fragment test enable dynamically for a command buffer.
      C Specification

      To dynamically set the representativeFragmentTestEnable state, call:

      
 void vkCmdSetRepresentativeFragmentTestEnableNV(
     VkCommandBuffer                             commandBuffer,
     VkBool32                                    representativeFragmentTestEnable);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineRepresentativeFragmentTestStateCreateInfoNV::representativeFragmentTestEnable value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      representativeFragmentTestEnable - specifies the representativeFragmentTestEnable state.

    • vkCmdSetCoverageReductionModeNV

      public static void vkCmdSetCoverageReductionModeNV(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int coverageReductionMode)
      Specify the coverage reduction mode dynamically for a command buffer.
      C Specification

      To dynamically set the coverageReductionMode state, call:

      
 void vkCmdSetCoverageReductionModeNV(
     VkCommandBuffer                             commandBuffer,
     VkCoverageReductionModeNV                   coverageReductionMode);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineCoverageReductionStateCreateInfoNV::coverageReductionMode value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • coverageReductionMode must be a valid VkCoverageReductionModeNV value
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      coverageReductionMode - specifies the coverageReductionMode state.

    • nvkCmdSetDepthClampRangeEXT

      public static void nvkCmdSetDepthClampRangeEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int depthClampMode, long pDepthClampRange)
      Unsafe version of: CmdSetDepthClampRangeEXT

    • vkCmdSetDepthClampRangeEXT

      public static void vkCmdSetDepthClampRangeEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int depthClampMode, @Nullable VkDepthClampRangeEXT pDepthClampRange)
      Set the viewport depth clamp range dynamically for a command buffer.
      C Specification

      To dynamically set the viewport depth clamp range parameters, call:

      
 void vkCmdSetDepthClampRangeEXT(
     VkCommandBuffer                             commandBuffer,
     VkDepthClampModeEXT                         depthClampMode,
     const VkDepthClampRangeEXT*                 pDepthClampRange);
      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 VkPipelineDynamicStateCreateInfo::pDynamicStates. Otherwise, this state is specified by the VkPipelineViewportDepthClampControlCreateInfoEXT::depthClampMode value used to create the currently active pipeline.

      Valid Usage
      Valid Usage (Implicit)
      • commandBuffer must be a valid VkCommandBuffer handle
      • depthClampMode must be a valid VkDepthClampModeEXT value
      • If pDepthClampRange is not NULL, pDepthClampRange must be a valid pointer to a valid VkDepthClampRangeEXT structure
      • commandBuffer must be in the recording state
      • The VkCommandPool that commandBuffer was allocated from must support graphics operations
      • This command must only be called outside of a video coding scope
      Host Synchronization
      • Host access to commandBuffer must be externally synchronized
      • Host access to the VkCommandPool that commandBuffer was allocated from must be externally synchronized
      Command Properties
      Command Buffer LevelsRender Pass ScopeVideo Coding ScopeSupported Queue TypesCommand Type
      Primary SecondaryBothOutsideGraphicsState
      See Also

      VkDepthClampRangeEXT

      Parameters:
      commandBuffer - the command buffer into which the command will be recorded.
      depthClampMode - determines how the clamp range is determined for each viewport.
      pDepthClampRange - sets the depth clamp range for all viewports if depthClampMode is DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT.

    • vkCreateShadersEXT

      public static int vkCreateShadersEXT(org.lwjgl.vulkan.VkDevice device, VkShaderCreateInfoEXT.Buffer pCreateInfos, @Nullable VkAllocationCallbacks pAllocator, long[] pShaders)
      Array version of: CreateShadersEXT

    • vkCmdBindShadersEXT

      public static void vkCmdBindShadersEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int[] pStages, long[] pShaders)
      Array version of: CmdBindShadersEXT

    • vkCmdBindVertexBuffers2EXT

      public static void vkCmdBindVertexBuffers2EXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int firstBinding, long[] pBuffers, long[] pOffsets, long @Nullable [] pSizes, long @Nullable [] pStrides)
      Array version of: CmdBindVertexBuffers2EXT

    • vkCmdSetSampleMaskEXT

      public static void vkCmdSetSampleMaskEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int samples, int[] pSampleMask)
      Array version of: CmdSetSampleMaskEXT

    • vkCmdSetColorBlendEnableEXT

      public static void vkCmdSetColorBlendEnableEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int firstAttachment, int[] pColorBlendEnables)
      Array version of: CmdSetColorBlendEnableEXT

    • vkCmdSetColorWriteMaskEXT

      public static void vkCmdSetColorWriteMaskEXT(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, int firstAttachment, int[] pColorWriteMasks)
      Array version of: CmdSetColorWriteMaskEXT

    • vkCmdSetCoverageModulationTableNV

      public static void vkCmdSetCoverageModulationTableNV(org.lwjgl.vulkan.VkCommandBuffer commandBuffer, float[] pCoverageModulationTable)
      Array version of: CmdSetCoverageModulationTableNV