Package org.lwjgl.vulkan

Class HUAWEISubpassShading

  • public class HUAWEISubpassShading
extends java.lang.Object
    This extension allows applications to execute a subpass shading pipeline in a subpass of a render pass in order to save memory bandwidth for algorithms like tile-based deferred rendering and forward plus. A subpass shading pipeline is a pipeline with the compute pipeline ability, allowed to read values from input attachments, and only allowed to be dispatched inside a stand-alone subpass. Its work dimension is defined by the render pass’s render area size. Its workgroup size (width, height) shall be a power-of-two number in width or height, with minimum value from 8, and maximum value shall be decided from the render pass attachments and sample counts but depends on implementation.

    The GlobalInvocationId.xy of a subpass shading pipeline is equal to the FragCoord.xy of a graphic pipeline in the same render pass subtracted the offset of the VkRenderPassBeginInfo::renderArea. GlobalInvocationId.z is mapped to the Layer if VK_EXT_shader_viewport_index_layer is supported. The GlobalInvocationId.xy is equal to the index of the local workgroup multiplied by the size of the local workgroup plus the LocalInvocationId and the offset of the VkRenderPassBeginInfo::renderArea.

    This extension allows a subpass’s pipeline bind point to be PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI.

    Sample Code

    Example of subpass shading in a GLSL shader

    
 #extension GL_HUAWEI_subpass_shading: enable
 #extension GL_KHR_shader_subgroup_arithmetic: enable
 
 layout(constant_id = 0) const uint tileWidth = 8;
 layout(constant_id = 1) const uint tileHeight = 8;
 layout(local_size_x_id = 0, local_size_y_id = 1, local_size_z = 1) in;
 layout (set=0, binding=0, input_attachment_index=0) uniform subpassInput depth;
 
 void main()
 {
   float d = subpassLoad(depth).x;
   float minD = subgroupMin(d);
   float maxD = subgroupMax(d);
 }

    Example of subpass shading dispatching in a subpass

    
 vkCmdNextSubpass(commandBuffer, VK_SUBPASS_CONTENTS_INLINE);
 vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI, subpassShadingPipeline);
 vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI, subpassShadingPipelineLayout,
   firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 vkCmdSubpassShadingHUAWEI(commandBuffer)
 vkCmdEndRenderPass(commandBuffer);

    Example of subpass shading render pass creation

    
 VkAttachmentDescription2 attachments[] = {
   {
     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, NULL,
     0, VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT,
     VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_STORE_OP_DONT_CARE,
     VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_LOAD_OP_DONT_CARE,
     VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
   },
   {
     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, NULL,
     0, VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT,
     VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_STORE_OP_DONT_CARE,
     VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_LOAD_OP_DONT_CARE,
     VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
   },
   {
     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, NULL,
     0, VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT,
     VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_STORE_OP_DONT_CARE,
     VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_LOAD_OP_DONT_CARE,
     VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
   },
   {
     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, NULL,
     0, VK_FORMAT_D24_UNORM_S8_UINT, VK_SAMPLE_COUNT_1_BIT,
     VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_STORE_OP_DONT_CARE,
     VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_LOAD_OP_DONT_CARE,
     VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
   },
   {
     VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, NULL,
     0, VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT,
     VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_STORE_OP_STORE,
     VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_LOAD_OP_DONT_CARE,
     VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
   }
 };
 
 VkAttachmentReference2 gBufferAttachmentReferences[] = {
   { VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, NULL, 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT },
   { VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, NULL, 1, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT },
   { VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, NULL, 2, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT }
 };
 VkAttachmentReference2 gBufferDepthStencilAttachmentReferences =
   { VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, NULL, 3, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_DEPTH_BIT|VK_IMAGE_ASPECT_STENCIL_BIT };
 VkAttachmentReference2 depthInputAttachmentReferences[] = {
   { VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, NULL, 3, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_ASPECT_DEPTH_BIT|VK_IMAGE_ASPECT_STENCIL_BIT };
 };
 VkAttachmentReference2 preserveAttachmentReferences[] = {
   { VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, NULL, 0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT },
   { VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, NULL, 1, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT },
   { VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, NULL, 2, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT },
   { VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, NULL, 3, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_DEPTH_BIT|VK_IMAGE_ASPECT_STENCIL_BIT }
 }; // G buffer including depth/stencil
 VkAttachmentReference2 colorAttachmentReferences[] = {
   { VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, NULL, 4, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT }
 };
 VkAttachmentReference2 resolveAttachmentReference =
   { VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, NULL, 4, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_ASPECT_COLOR_BIT };
 
 VkSubpassDescription2 subpasses[] = {
   {
     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, NULL, 0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0,
     0, NULL, // input
     sizeof(gBufferAttachmentReferences)/sizeof(gBufferAttachmentReferences[0]), gBufferAttachmentReferences, // color
     NULL, &gBufferDepthStencilAttachmentReferences, // resolve & DS
     0, NULL
   },
   {
     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, NULL, 0, VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI , 0,
     sizeof(depthInputAttachmentReferences)/sizeof(depthInputAttachmentReferences[0]), depthInputAttachmentReferences, // input
     0, NULL, // color
     NULL, NULL, // resolve & DS
     sizeof(preserveAttachmentReferences)/sizeof(preserveAttachmentReferences[0]), preserveAttachmentReferences,
   },
   {
     VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, NULL, 0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0,
     sizeof(gBufferAttachmentReferences)/sizeof(gBufferAttachmentReferences[0]), gBufferAttachmentReferences, // input
     sizeof(colorAttachmentReferences)/sizeof(colorAttachmentReferences[0]), colorAttachmentReferences, // color
     &resolveAttachmentReference, &gBufferDepthStencilAttachmentReferences, // resolve & DS
     0, NULL
   },
 };
 
 VkMemoryBarrier2KHR fragmentToSubpassShading = {
   VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR, NULL,
   VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT|VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
   VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI, VK_ACCESS_INPUT_ATTACHMENT_READ_BIT
 };
 
 VkMemoryBarrier2KHR subpassShadingToFragment = {
   VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR, NULL,
   VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI, VK_ACCESS_SHADER_WRITE_BIT,
   VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR, VK_ACCESS_SHADER_READ_BIT
 };
 
 VkSubpassDependency2 dependencies[] = {
   {
     VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, &fragmentToSubpassShading,
     0, 1,
     0, 0, 0, 0,
     0, 0
   },
   {
     VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, &subpassShadingToFragment,
     1, 2,
     0, 0, 0, 0,
     0, 0
   },
 };
 
 VkRenderPassCreateInfo2 renderPassCreateInfo = {
   VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, NULL, 0,
     sizeof(attachments)/sizeof(attachments[0]), attachments,
     sizeof(subpasses)/sizeof(subpasses[0]), subpasses,
     sizeof(dependencies)/sizeof(dependencies[0]), dependencies,
     0, NULL
 };
 VKRenderPass renderPass;
 vkCreateRenderPass2(device, &renderPassCreateInfo, NULL, &renderPass);

    Example of subpass shading pipeline creation

    
 VkExtent2D maxWorkgroupSize;
 
 VkSpecializationMapEntry subpassShadingConstantMapEntries[] = {
   { 0, 0 * sizeof(uint32_t), sizeof(uint32_t) },
   { 1, 1 * sizeof(uint32_t), sizeof(uint32_t) }
 };
 
 VkSpecializationInfo subpassShadingConstants = {
   2, subpassShadingConstantMapEntries,
   sizeof(VkExtent2D), &maxWorkgroupSize
 };
 
 VkSubpassShadingPipelineCreateInfoHUAWEI subpassShadingPipelineCreateInfo {
   VK_STRUCTURE_TYPE_SUBPASSS_SHADING_PIPELINE_CREATE_INFO_HUAWEI, NULL,
   renderPass, 1
 };
 
 VkPipelineShaderStageCreateInfo subpassShadingPipelineStageCreateInfo {
   VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, NULL,
   0, VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI,
   shaderModule, "main",
   &subpassShadingConstants
 };
 
 VkComputePipelineCreateInfo subpassShadingComputePipelineCreateInfo = {
   VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, &subpassShadingPipelineCreateInfo,
   0, &subpassShadingPipelineStageCreateInfo,
   pipelineLayout, basePipelineHandle, basePipelineIndex
 };
 
 VKPipeline pipeline;
 
 vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderPass, &maxWorkgroupSize);
 vkCreateComputePipelines(device, pipelineCache, 1, &subpassShadingComputePipelineCreateInfo, NULL, &pipeline);
    VK_HUAWEI_subpass_shading
    Name String
    VK_HUAWEI_subpass_shading
    Extension Type
    Device extension
    Registered Extension Number
    370
    Revision
    2
    Extension and Version Dependencies
    Contact
    Other Extension Metadata
    Last Modified Date
    2021-06-01
    Interactions and External Dependencies
    Contributors
    • Hueilong Wang

    • Method Detail

      • nvkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI

        public static int nvkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI​(org.lwjgl.vulkan.VkDevice device,
                                                                   long renderpass,
                                                                   long pMaxWorkgroupSize)
        Unsafe version of: GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI

      • vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI

        public static int vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI​(org.lwjgl.vulkan.VkDevice device,
                                                                  long renderpass,
                                                                  VkExtent2D pMaxWorkgroupSize)
        Query maximum supported subpass shading workgroup size for a give render pass.
        C Specification

        A subpass shading pipeline’s workgroup size is a 2D vector with number of power-of-two in width and height. The maximum number of width and height is implementation dependent, and may vary for different formats and sample counts of attachments in a render pass.

        To query the maximum workgroup size, call:

        
 VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
     VkDevice                                    device,
     VkRenderPass                                renderpass,
     VkExtent2D*                                 pMaxWorkgroupSize);
        Valid Usage (Implicit)
        • device must be a valid VkDevice handle
        • renderpass must be a valid VkRenderPass handle
        • pMaxWorkgroupSize must be a valid pointer to a VkExtent2D structure
        • renderpass must have been created, allocated, or retrieved from device
        Return Codes
        On success, this command returns
        On failure, this command returns
        See Also

        VkExtent2D

        Parameters:
        device - a handle to a local device object that was used to create the given render pass.
        pMaxWorkgroupSize - a pointer to a VkExtent2D structure.

      • vkCmdSubpassShadingHUAWEI

        public static void vkCmdSubpassShadingHUAWEI​(org.lwjgl.vulkan.VkCommandBuffer commandBuffer)
        Dispatch compute work items.
        C Specification

        A subpass shading dispatches a compute pipeline work with the work dimension of render area of the calling subpass and work groups are partitioned by specified work group size. Subpass operations like subpassLoad and subpassLoadMS are allowed to be used.

        To record a subpass shading, call:

        
 void vkCmdSubpassShadingHUAWEI(
     VkCommandBuffer                             commandBuffer);
        Description

        When the command is executed, a global workgroup consisting of ceil (render area size / local workgroup size) local workgroups is assembled.

        Valid Usage
        • If a VkSampler created with magFilter or minFilter equal to FILTER_LINEAR and compareEnable equal to FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
        • If a VkSampler created with mipmapMode equal to SAMPLER_MIPMAP_MODE_LINEAR and compareEnable equal to FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
        • If a VkImageView is sampled with depth comparison, the image view’s format features must contain FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT
        • If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
        • If a VkImageView is sampled with FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT
        • Any VkImageView being sampled with FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2
        • Any VkImageView being sampled with FILTER_CUBIC_EXT with a reduction mode of either SAMPLER_REDUCTION_MODE_MIN or SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2
        • Any VkImage created with a VkImageCreateInfo::flags containing IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE
        • Any VkImageView or VkBufferView being written as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown then the view’s format feature must contain FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT
        • Any VkImageView or VkBufferView being read as a storage image or storage texel buffer where the image format field of the OpTypeImage is Unknown then the view’s format feature must contain FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT
        • For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
        • If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline, as described in Pipeline Layout Compatibility
        • Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are statically used by the VkPipeline bound to the pipeline bind point used by this command
        • A valid pipeline must be bound to the pipeline bind point used by this command
        • If the VkPipeline object bound to the pipeline bind point used by this command requires any dynamic state, that state must have been set or inherited (if the VK_NV_inherited_viewport_scissor extension is enabled) for commandBuffer, and done so after any previously bound pipeline with the corresponding state not specified as dynamic
        • There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound
        • If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type IMAGE_VIEW_TYPE_3D, IMAGE_VIEW_TYPE_CUBE, IMAGE_VIEW_TYPE_1D_ARRAY, IMAGE_VIEW_TYPE_2D_ARRAY or IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage
        • If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage
        • If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage
        • If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
        • If the robust buffer access feature is not enabled, and if the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point
        • If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource
        • If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions
        • If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands
        • If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format
        • If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format
        • If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64
        • If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32
        • If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64
        • If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32
        • If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command
        • If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command
        • This command must be called in a subpass with bind point PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI. No draw commands can be called in the same subpass. Only one CmdSubpassShadingHUAWEI command can be called in a subpass
        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 inside of a render pass instance
        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 ScopeSupported Queue Types
        Primary SecondaryInsideGraphics
        Parameters:
        commandBuffer - the command buffer into which the command will be recorded.