• Home
• org.lwjgl
• lwjgl-vulkan
• 3.3.0
• source code
• NVShadingRateImage.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.lwjgl.vulkan.NVShadingRateImage Maven / Gradle / Ivy

/*
 * Copyright LWJGL. All rights reserved.
 * License terms: https://www.lwjgl.org/license
 * MACHINE GENERATED FILE, DO NOT EDIT
 */
package org.lwjgl.vulkan;

import javax.annotation.*;

import org.lwjgl.system.*;

import static org.lwjgl.system.Checks.*;
import static org.lwjgl.system.JNI.*;
import static org.lwjgl.system.MemoryUtil.*;

/**
 * This extension allows applications to use a variable shading rate when processing fragments of rasterized primitives. By default, Vulkan will spawn one fragment shader for each pixel covered by a primitive. In this extension, applications can bind a shading rate image that can be used to vary the number of fragment shader invocations across the framebuffer. Some portions of the screen may be configured to spawn up to 16 fragment shaders for each pixel, while other portions may use a single fragment shader invocation for a 4x4 block of pixels. This can be useful for use cases like eye tracking, where the portion of the framebuffer that the user is looking at directly can be processed at high frequency, while distant corners of the image can be processed at lower frequency. Each texel in the shading rate image represents a fixed-size rectangle in the framebuffer, covering 16x16 pixels in the initial implementation of this extension. When rasterizing a primitive covering one of these rectangles, the Vulkan implementation reads a texel in the bound shading rate image and looks up the fetched value in a palette to determine a base shading rate.
 * 
 * 
In addition to the API support controlling rasterization, this extension also adds Vulkan support for the {@code SPV_NV_shading_rate} extension to SPIR-V. That extension provides two fragment shader variable decorations that allow fragment shaders to determine the shading rate used for processing the fragment:
 * 
 * 

 * 
{@code FragmentSizeNV}, which indicates the width and height of the set of pixels processed by the fragment shader.
 * 
{@code InvocationsPerPixel}, which indicates the maximum number of fragment shader invocations that could be spawned for the pixel(s) covered by the fragment.
 * 
 * 
 * 
When using SPIR-V in conjunction with the OpenGL Shading Language (GLSL), the fragment shader capabilities are provided by the {@code GL_NV_shading_rate_image} language extension and correspond to the built-in variables {@code gl_FragmentSizeNV} and {@code gl_InvocationsPerPixelNV}, respectively.
 * 
 * 
VK_NV_shading_rate_image
 * 
 * 

 * 
Name String
 * 
{@code VK_NV_shading_rate_image}
 * 
Extension Type
 * 
Device extension
 * 
Registered Extension Number
 * 
165
 * 
Revision
 * 
3
 * 
Extension and Version Dependencies
 * 

 * 
Requires Vulkan 1.0
 * 
Requires {@link KHRGetPhysicalDeviceProperties2 VK_KHR_get_physical_device_properties2}
 * 
 * 
Contact
 * 

 * 
Pat Brown nvpbrown
 * 
 * 
 * 
 * 
Other Extension Metadata
 * 
 * 

 * 
Last Modified Date
 * 
2019-07-18
 * 
Interactions and External Dependencies
 * 

 * 
This extension requires {@code SPV_NV_shading_rate}
 * 
This extension provides API support for {@code GL_NV_shading_rate_image}
 * 
 * 
Contributors
 * 

 * 
Pat Brown, NVIDIA
 * 
Carsten Rohde, NVIDIA
 * 
Jeff Bolz, NVIDIA
 * 
Daniel Koch, NVIDIA
 * 
Mathias Schott, NVIDIA
 * 
Matthew Netsch, Qualcomm Technologies, Inc.
 * 
 * 
 */
public class NVShadingRateImage {

    /** The extension specification version. */
    public static final int VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION = 3;

    /** The extension name. */
    public static final String VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME = "VK_NV_shading_rate_image";

    /**
     * Extends {@code VkStructureType}.
     * 
     * 
Enum values:
     * 
     * 

     * 
{@link #VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV}
     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV}
     * 
{@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV}
     * 
{@link #VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV  = 1000164000,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV             = 1000164001,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV           = 1000164002,
        VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005;

    /** Extends {@code VkImageLayout}. */
    public static final int VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = 1000164003;

    /**
     * Extends {@code VkDynamicState}.
     * 
     * 
Enum values:
     * 
     * 

     * 
{@link #VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV}
     * 
{@link #VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV}
     * 
     */
    public static final int
        VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004,
        VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV  = 1000164006;

    /** Extends {@code VkAccessFlagBits}. */
    public static final int VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = 0x800000;

    /** Extends {@code VkImageUsageFlagBits}. */
    public static final int VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = 0x100;

    /** Extends {@code VkPipelineStageFlagBits}. */
    public static final int VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = 0x400000;

    /**
     * VkShadingRatePaletteEntryNV - Shading rate image palette entry types
     * 
     * 
Description
     * 
     * 
The following table indicates the width and height (in pixels) of each fragment generated using the indicated shading rate, as well as the maximum number of fragment shader invocations launched for each fragment. When processing regions of a primitive that have a shading rate of {@link #VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV}, no fragments will be generated in that region.
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
Shading Rate
Width
Height
Invocations
{@link #VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV}
0
0
0
{@link #VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV}
1
1
16
{@link #VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV}
1
1
8
{@link #VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV}
1
1
4
{@link #VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV}
1
1
2
{@link #VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV}
1
1
1
{@link #VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV}
2
1
1
{@link #VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV}
1
2
1
{@link #VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV}
2
2
1
{@link #VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV}
4
2
1
{@link #VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV}
2
4
1
{@link #VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV}
4
4
1
     * 
     * 
See Also
     * 
     * 
{@link VkCoarseSampleOrderCustomNV}, {@link VkShadingRatePaletteNV}
     */
    public static final int
        VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV              = 0,
        VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV    = 1,
        VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV     = 2,
        VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV     = 3,
        VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV     = 4,
        VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV      = 5,
        VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6,
        VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7,
        VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8,
        VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9,
        VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10,
        VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11;

    /**
     * VkCoarseSampleOrderTypeNV - Shading rate image sample ordering types
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV} specifies that coverage samples will be ordered in an implementation-dependent manner.
     * 
{@link #VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV} specifies that coverage samples will be ordered according to the array of custom orderings provided in either the {@code pCustomSampleOrders} member of {@link VkPipelineViewportCoarseSampleOrderStateCreateInfoNV} or the {@code pCustomSampleOrders} member of {@link #vkCmdSetCoarseSampleOrderNV CmdSetCoarseSampleOrderNV}.
     * 
{@link #VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV} specifies that coverage samples will be ordered sequentially, sorted first by pixel coordinate (in row-major order) and then by sample index.
     * 
{@link #VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV} specifies that coverage samples will be ordered sequentially, sorted first by sample index and then by pixel coordinate (in row-major order).
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkPipelineViewportCoarseSampleOrderStateCreateInfoNV}, {@link #vkCmdSetCoarseSampleOrderNV CmdSetCoarseSampleOrderNV}
     */
    public static final int
        VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV      = 0,
        VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV       = 1,
        VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV  = 2,
        VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3;

    protected NVShadingRateImage() {
        throw new UnsupportedOperationException();
    }

    // --- [ vkCmdBindShadingRateImageNV ] ---

    /**
     * Bind a shading rate image on a command buffer.
     * 
     * 
C Specification
     * 
     * 
When shading rate image usage is enabled in the bound pipeline, the pipeline uses a shading rate image specified by the command:
     * 
     * 

     * void vkCmdBindShadingRateImageNV(
     *     VkCommandBuffer                             commandBuffer,
     *     VkImageView                                 imageView,
     *     VkImageLayout                               imageLayout);
     * 
     * 
Valid Usage
     * 
     * 

     * 
The shading rate image feature must be enabled
     * 
If {@code imageView} is not {@link VK10#VK_NULL_HANDLE NULL_HANDLE}, it must be a valid {@code VkImageView} handle of type {@link VK10#VK_IMAGE_VIEW_TYPE_2D IMAGE_VIEW_TYPE_2D} or {@link VK10#VK_IMAGE_VIEW_TYPE_2D_ARRAY IMAGE_VIEW_TYPE_2D_ARRAY}
     * 
If {@code imageView} is not {@link VK10#VK_NULL_HANDLE NULL_HANDLE}, it must have a format of {@link VK10#VK_FORMAT_R8_UINT FORMAT_R8_UINT}
     * 
If {@code imageView} is not {@link VK10#VK_NULL_HANDLE NULL_HANDLE}, it must have been created with a {@code usage} value including {@link #VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV}
     * 
If {@code imageView} is not {@link VK10#VK_NULL_HANDLE NULL_HANDLE}, {@code imageLayout} must match the actual {@code VkImageLayout} of each subresource accessible from {@code imageView} at the time the subresource is accessed
     * 
If {@code imageView} is not {@link VK10#VK_NULL_HANDLE NULL_HANDLE}, {@code imageLayout} must be {@link #VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV} or {@link VK10#VK_IMAGE_LAYOUT_GENERAL IMAGE_LAYOUT_GENERAL}
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * 
If {@code imageView} is not {@link VK10#VK_NULL_HANDLE NULL_HANDLE}, {@code imageView} must be a valid {@code VkImageView} handle
     * 
{@code imageLayout} must be a valid {@code VkImageLayout} value
     * 
{@code commandBuffer} must be in the recording state
     * 
The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics operations
     * 
Both of {@code commandBuffer}, and {@code imageView} that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same {@code VkDevice}
     * 
     * 
     * 
Host Synchronization
     * 
     * 

     * 
Host access to {@code commandBuffer} must be externally synchronized
     * 
Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
     * 
     * 
     * 
Command Properties
     * 
     * 
     * 
     * 
     * 
Command Buffer Levels
Render Pass Scope
Supported Queue Types
Primary Secondary
Both
Graphics
     *
     * @param commandBuffer the command buffer into which the command will be recorded.
     * @param imageView     an image view handle specifying the shading rate image. {@code imageView} may be set to {@link VK10#VK_NULL_HANDLE NULL_HANDLE}, which is equivalent to specifying a view of an image filled with zero values.
     * @param imageLayout   the layout that the image subresources accessible from {@code imageView} will be in when the shading rate image is accessed.
     */
    public static void vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, @NativeType("VkImageView") long imageView, @NativeType("VkImageLayout") int imageLayout) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdBindShadingRateImageNV;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPJV(commandBuffer.address(), imageView, imageLayout, __functionAddress);
    }

    // --- [ vkCmdSetViewportShadingRatePaletteNV ] ---

    /**
     * Unsafe version of: {@link #vkCmdSetViewportShadingRatePaletteNV CmdSetViewportShadingRatePaletteNV}
     *
     * @param viewportCount the number of viewports whose shading rate palettes are updated by the command.
     */
    public static void nvkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, int firstViewport, int viewportCount, long pShadingRatePalettes) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdSetViewportShadingRatePaletteNV;
        if (CHECKS) {
            check(__functionAddress);
            Struct.validate(pShadingRatePalettes, viewportCount, VkShadingRatePaletteNV.SIZEOF, VkShadingRatePaletteNV::validate);
        }
        callPPV(commandBuffer.address(), firstViewport, viewportCount, pShadingRatePalettes, __functionAddress);
    }

    /**
     * Set shading rate image palettes dynamically for a command buffer.
     * 
     * 
C Specification
     * 
     * 
To dynamically set the per-viewport shading rate image palettes, call:
     * 
     * 

     * void vkCmdSetViewportShadingRatePaletteNV(
     *     VkCommandBuffer                             commandBuffer,
     *     uint32_t                                    firstViewport,
     *     uint32_t                                    viewportCount,
     *     const VkShadingRatePaletteNV*               pShadingRatePalettes);
     * 
     * 
Description
     * 
     * 
This command sets the per-viewport shading rate image palettes for subsequent drawing commands when the graphics pipeline is created with {@link #VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV} set in {@link VkPipelineDynamicStateCreateInfo}{@code ::pDynamicStates}. Otherwise, this state is specified by the {@link VkPipelineViewportShadingRateImageStateCreateInfoNV}{@code ::pShadingRatePalettes} values used to create the currently active pipeline.
     * 
     * 
Valid Usage
     * 
     * 

     * 
The shading rate image feature must be enabled
     * 
The sum of {@code firstViewport} and {@code viewportCount} must be between 1 and {@link VkPhysicalDeviceLimits}{@code ::maxViewports}, inclusive
     * 
If the multiple viewports feature is not enabled, {@code firstViewport} must be 0
     * 
If the multiple viewports feature is not enabled, {@code viewportCount} must be 1
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * 
{@code pShadingRatePalettes} must be a valid pointer to an array of {@code viewportCount} valid {@link VkShadingRatePaletteNV} structures
     * 
{@code commandBuffer} must be in the recording state
     * 
The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics operations
     * 
{@code viewportCount} must be greater than 0
     * 
     * 
     * 
Host Synchronization
     * 
     * 

     * 
Host access to {@code commandBuffer} must be externally synchronized
     * 
Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
     * 
     * 
     * 
Command Properties
     * 
     * 
     * 
     * 
     * 
Command Buffer Levels
Render Pass Scope
Supported Queue Types
Primary Secondary
Both
Graphics
     * 
     * 
See Also
     * 
     * 
{@link VkShadingRatePaletteNV}
     *
     * @param commandBuffer        the command buffer into which the command will be recorded.
     * @param firstViewport        the index of the first viewport whose shading rate palette is updated by the command.
     * @param pShadingRatePalettes a pointer to an array of {@link VkShadingRatePaletteNV} structures defining the palette for each viewport.
     */
    public static void vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, @NativeType("uint32_t") int firstViewport, @NativeType("VkShadingRatePaletteNV const *") VkShadingRatePaletteNV.Buffer pShadingRatePalettes) {
        nvkCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, pShadingRatePalettes.remaining(), pShadingRatePalettes.address());
    }

    // --- [ vkCmdSetCoarseSampleOrderNV ] ---

    /**
     * Unsafe version of: {@link #vkCmdSetCoarseSampleOrderNV CmdSetCoarseSampleOrderNV}
     *
     * @param customSampleOrderCount specifies the number of custom sample orderings to use when ordering coverage samples.
     */
    public static void nvkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, int sampleOrderType, int customSampleOrderCount, long pCustomSampleOrders) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdSetCoarseSampleOrderNV;
        if (CHECKS) {
            check(__functionAddress);
            if (pCustomSampleOrders != NULL) { Struct.validate(pCustomSampleOrders, customSampleOrderCount, VkCoarseSampleOrderCustomNV.SIZEOF, VkCoarseSampleOrderCustomNV::validate); }
        }
        callPPV(commandBuffer.address(), sampleOrderType, customSampleOrderCount, pCustomSampleOrders, __functionAddress);
    }

    /**
     * Set order of coverage samples for coarse fragments dynamically for a command buffer.
     * 
     * 
C Specification
     * 
     * 
To dynamically set the order of coverage samples in fragments larger than one pixel, call:
     * 
     * 

     * void vkCmdSetCoarseSampleOrderNV(
     *     VkCommandBuffer                             commandBuffer,
     *     VkCoarseSampleOrderTypeNV                   sampleOrderType,
     *     uint32_t                                    customSampleOrderCount,
     *     const VkCoarseSampleOrderCustomNV*          pCustomSampleOrders);
     * 
     * 
Description
     * 
     * 
If {@code sampleOrderType} is {@link #VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV}, the coverage sample order used for any combination of fragment area and coverage sample count not enumerated in {@code pCustomSampleOrders} will be identical to that used for {@link #VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV}.
     * 
     * 
This command sets the order of coverage samples for subsequent drawing commands when the graphics pipeline is created with {@link #VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV} set in {@link VkPipelineDynamicStateCreateInfo}{@code ::pDynamicStates}. Otherwise, this state is specified by the {@link VkPipelineViewportCoarseSampleOrderStateCreateInfoNV} values used to create the currently active pipeline.
     * 
     * 
Valid Usage
     * 
     * 

     * 
If {@code sampleOrderType} is not {@link #VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV}, {@code customSamplerOrderCount} must be 0
     * 
The array {@code pCustomSampleOrders} must not contain two structures with matching values for both the {@code shadingRate} and {@code sampleCount} members
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * 
{@code sampleOrderType} must be a valid {@code VkCoarseSampleOrderTypeNV} value
     * 
If {@code customSampleOrderCount} is not 0, {@code pCustomSampleOrders} must be a valid pointer to an array of {@code customSampleOrderCount} valid {@link VkCoarseSampleOrderCustomNV} structures
     * 
{@code commandBuffer} must be in the recording state
     * 
The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics operations
     * 
     * 
     * 
Host Synchronization
     * 
     * 

     * 
Host access to {@code commandBuffer} must be externally synchronized
     * 
Host access to the {@code VkCommandPool} that {@code commandBuffer} was allocated from must be externally synchronized
     * 
     * 
     * 
Command Properties
     * 
     * 
     * 
     * 
     * 
Command Buffer Levels
Render Pass Scope
Supported Queue Types
Primary Secondary
Both
Graphics
     * 
     * 
See Also
     * 
     * 
{@link VkCoarseSampleOrderCustomNV}
     *
     * @param commandBuffer       the command buffer into which the command will be recorded.
     * @param sampleOrderType     specifies the mechanism used to order coverage samples in fragments larger than one pixel.
     * @param pCustomSampleOrders a pointer to an array of {@link VkCoarseSampleOrderCustomNV} structures, each of which specifies the coverage sample order for a single combination of fragment area and coverage sample count.
     */
    public static void vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, @NativeType("VkCoarseSampleOrderTypeNV") int sampleOrderType, @Nullable @NativeType("VkCoarseSampleOrderCustomNV const *") VkCoarseSampleOrderCustomNV.Buffer pCustomSampleOrders) {
        nvkCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, remainingSafe(pCustomSampleOrders), memAddressSafe(pCustomSampleOrders));
    }

}