• Home
• org.lwjgl
• lwjgl-vulkan
• 3.1.6
• source code
• NVXDeviceGeneratedCommands.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.NVXDeviceGeneratedCommands 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 java.nio.*;

import org.lwjgl.*;

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 the device to generate a number of critical commands for command buffers.
 * 
 * 
When rendering a large number of objects, the device can be leveraged to implement a number of critical functions, like updating matrices, or implementing occlusion culling, frustum culling, front to back sorting, etc. Implementing those on the device does not require any special extension, since an application is free to define its own data structure, and just process them using shaders.
 * 
 * 
However, if the application desires to quickly kick off the rendering of the final stream of objects, then unextended Vulkan forces the application to read back the processed stream and issue graphics command from the host. For very large scenes, the synchronization overhead, and cost to generate the command buffer can become the bottleneck. This extension allows an application to generate a device side stream of state changes and commands, and convert it efficiently into a command buffer without having to read it back on the host.
 * 
 * 
Furthermore, it allows incremental changes to such command buffers by manipulating only partial sections of a command stream -- for example pipeline bindings. Unextended Vulkan requires re-creation of entire command buffers in such scenario, or updates synchronized on the host.
 * 
 * 
The intended usage for this extension is for the application to:
 * 
 * 

 * 
create its objects as in unextended Vulkan
 * 
create a {@code VkObjectTableNVX}, and register the various Vulkan objects that are needed to evaluate the input parameters.
 * 
create a {@code VkIndirectCommandsLayoutNVX}, which lists the {@code VkIndirectCommandsTokenTypeNVX} it wants to dynamically change as atomic command sequence. This step likely involves some internal device code compilation, since the intent is for the GPU to generate the command buffer in the pipeline.
 * 
fill the input buffers with the data for each of the inputs it needs. Each input is an array that will be filled with an index in the object table, instead of using CPU pointers.
 * 
set up a target secondary command buffer
 * 
reserve command buffer space via {@link #vkCmdReserveSpaceForCommandsNVX CmdReserveSpaceForCommandsNVX} in a target command buffer at the position you want the generated commands to be executed.
 * 
call {@link #vkCmdProcessCommandsNVX CmdProcessCommandsNVX} to create the actual device commands for all sequences based on the array contents into a provided target command buffer.
 * 
execute the target command buffer like a regular secondary command buffer
 * 
 * 
 * 
For each draw/dispatch, the following can be specified:
 * 
 * 

 * 
a different pipeline state object
 * 
a number of descriptor sets, with dynamic offsets
 * 
a number of vertex buffer bindings, with an optional dynamic offset
 * 
a different index buffer, with an optional dynamic offset
 * 
 * 
 * 
Applications should register a small number of objects, and use dynamic offsets whenever possible.
 * 
 * 
While the GPU can be faster than a CPU to generate the commands, it may not happen asynchronously, therefore the primary use-case is generating "{@code less}" total work (occlusion culling, classification to use specialized shaders, etc.).
 * 
 * 
Example Code
 * 
 * 
Open-Source samples illustrating the usage of the extension can be found at the following locations:
 * 
 * 
https://github.com/nvpro-samples/gl_vk_threaded_cadscene/blob/master/doc/vulkan_nvxdevicegenerated.md
 * 
 * 
https://github.com/NVIDIAGameWorks/GraphicsSamples/tree/master/samples/vk10-kepler/BasicDeviceGeneratedCommandsVk
 * 
 * 
 *   // setup secondary command buffer
 *     vkBeginCommandBuffer(generatedCmdBuffer, &beginInfo);
 *     ... setup its state as usual
 * 
 *   // insert the reservation (there can only be one per command buffer)
 *   // where the generated calls should be filled into
 *     VkCmdReserveSpaceForCommandsInfoNVX reserveInfo = { VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX };
 *     reserveInfo.objectTable = objectTable;
 *     reserveInfo.indirectCommandsLayout = deviceGeneratedLayout;
 *     reserveInfo.maxSequencesCount = myCount;
 *     vkCmdReserveSpaceForCommandsNVX(generatedCmdBuffer, &reserveInfo);
 * 
 *     vkEndCommandBuffer(generatedCmdBuffer);
 * 
 *   // trigger the generation at some point in another primary command buffer
 *     VkCmdProcessCommandsInfoNVX processInfo = { VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX };
 *     processInfo.objectTable = objectTable;
 *     processInfo.indirectCommandsLayout = deviceGeneratedLayout;
 *     processInfo.maxSequencesCount = myCount;
 *     // set the target of the generation (if null we would directly execute with mainCmd)
 *     processInfo.targetCommandBuffer = generatedCmdBuffer;
 *     // provide input data
 *     processInfo.indirectCommandsTokenCount = 3;
 *     processInfo.pIndirectCommandsTokens = myTokens;
 * 
 *   // If you modify the input buffer data referenced by VkCmdProcessCommandsInfoNVX,
 *   // ensure you have added the appropriate barriers prior generation process.
 *   // When regenerating the content of the same reserved space, ensure prior operations have completed
 * 
 *     VkMemoryBarrier memoryBarrier = { VK_STRUCTURE_TYPE_MEMORY_BARRIER };
 *     memoryBarrier.srcAccessMask = ...;
 *     memoryBarrier.dstAccessMask = VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX;
 * 
 *     vkCmdPipelineBarrier(mainCmd,
 *                          // srcStageMaskVK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
 *                          // dstStageMaskVK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX,
 *                          // dependencyFlags0,
 *                          // memoryBarrierCount1,
 *                          // pMemoryBarriers&memoryBarrier,
 *                          ...);
 * 
 *     vkCmdProcessCommandsNVX(mainCmd, &processInfo);
 *     ...
 *   // execute the secondary command buffer and ensure the processing that modifies command-buffer content
 *   // has completed
 * 
 *     memoryBarrier.srcAccessMask = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX;
 *     memoryBarrier.dstAccessMask = VK_ACCESS_INDIRECT_COMMAND_READ_BIT;
 * 
 *     vkCmdPipelineBarrier(mainCmd,
 *                          // srcStageMaskVK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX,
 *                          // dstStageMaskVK_PIPELINE_STAGE_DRAW_INDIRECT_BIT,
 *                          // dependencyFlags0,
 *                          // memoryBarrierCount1,
 *                          // pMemoryBarriers&memoryBarrier,
 *                          ...)
 *     vkCmdExecuteCommands(mainCmd, 1, &generatedCmdBuffer);
 * 
 * 

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

 * 
Requires Vulkan 1.0
 * 
 * 
Contact
 * 

 * 
Christoph Kubisch @pixeljetstream
 * 
 * 
Last Modified Date
 * 
2017-07-25
 * 
Contributors
 * 

 * 
Pierre Boudier, NVIDIA
 * 
Christoph Kubisch, NVIDIA
 * 
Mathias Schott, NVIDIA
 * 
Jeff Bolz, NVIDIA
 * 
Eric Werness, NVIDIA
 * 
Detlef Roettger, NVIDIA
 * 
Daniel Koch, NVIDIA
 * 
Chris Hebert, NVIDIA
 * 
 * 
 */
public class NVXDeviceGeneratedCommands {

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

    /** The extension name. */
    public static final String VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME = "VK_NVX_device_generated_commands";

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

     * 
{@link #VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX}
     * 
{@link #VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX}
     * 
{@link #VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX}
     * 
{@link #VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX}
     * 
{@link #VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX}
     * 
{@link #VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX             = 1000086000,
        VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
        VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX            = 1000086002,
        VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX  = 1000086003,
        VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX     = 1000086004,
        VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX   = 1000086005;

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

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

     * 
{@link #VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX ACCESS_COMMAND_PROCESS_READ_BIT_NVX}
     * 
{@link #VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX}
     * 
     */
    public static final int
        VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX  = 0x20000,
        VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x40000;

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

     * 
{@link #VK_OBJECT_TYPE_OBJECT_TABLE_NVX OBJECT_TYPE_OBJECT_TABLE_NVX}
     * 
{@link #VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX}
     * 
     */
    public static final int
        VK_OBJECT_TYPE_OBJECT_TABLE_NVX             = 1000086000,
        VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001;

    /**
     * VkIndirectCommandsLayoutUsageFlagBitsNVX - Bitmask specifying allowed usage of a indirect commands layout
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX} indicates that the processing of sequences can happen at an implementation-dependent order, which is not guaranteed to be coherent across multiple invocations.
     * 
{@link #VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX} indicates that there is likely a high difference between allocated number of sequences and actually used.
     * 
{@link #VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX} indicates that there are likely many draw or dispatch calls that are zero-sized (zero grid dimension, no primitives to render).
     * 
{@link #VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX} indicates that the input data for the sequences is not implicitly indexed from 0..sequencesUsed but a user provided {@code VkBuffer} encoding the index is provided.
     * 
     * 
     * 
See Also
     * 
     * 
{@code VkIndirectCommandsLayoutUsageFlagsNVX}
     */
    public static final int
        VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x1,
        VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX    = 0x2,
        VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX    = 0x4,
        VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX   = 0x8;

    /**
     * VkObjectEntryUsageFlagBitsNVX - Bitmask specifying allowed usage of an object entry
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX} indicates that the resource is bound to {@link VK10#VK_PIPELINE_BIND_POINT_GRAPHICS PIPELINE_BIND_POINT_GRAPHICS}
     * 
{@link #VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX} indicates that the resource is bound to {@link VK10#VK_PIPELINE_BIND_POINT_COMPUTE PIPELINE_BIND_POINT_COMPUTE}
     * 
     * 
     * 
See Also
     * 
     * 
{@code VkObjectEntryUsageFlagsNVX}
     */
    public static final int
        VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x1,
        VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX  = 0x2;

    /**
     * VkIndirectCommandsTokenTypeNVX - Enum specifying
     * 
     * 
Description
     * 
     * 
Supported indirect command tokens
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
Token type
Equivalent command
{@link #VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX}
{@link VK10#vkCmdBindPipeline CmdBindPipeline}
{@link #VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX}
{@link VK10#vkCmdBindDescriptorSets CmdBindDescriptorSets}
{@link #VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX}
{@link VK10#vkCmdBindIndexBuffer CmdBindIndexBuffer}
{@link #VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX}
{@link VK10#vkCmdBindVertexBuffers CmdBindVertexBuffers}
{@link #VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX}
{@link VK10#vkCmdPushConstants CmdPushConstants}
{@link #VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX}
{@link VK10#vkCmdDrawIndexedIndirect CmdDrawIndexedIndirect}
{@link #VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX}
{@link VK10#vkCmdDrawIndirect CmdDrawIndirect}
{@link #VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX}
{@link VK10#vkCmdDispatchIndirect CmdDispatchIndirect}
     * 
     * 
See Also
     * 
     * 
{@link VkIndirectCommandsLayoutTokenNVX}, {@link VkIndirectCommandsTokenNVX}
     */
    public static final int
        VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX       = 0,
        VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1,
        VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX   = 2,
        VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX  = 3,
        VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX  = 4,
        VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX   = 5,
        VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX           = 6,
        VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX       = 7;

    /**
     * VkObjectEntryTypeNVX - Enum specifying object table entry type
     * 
     * 
Description
     * 
     * 

     * 
{@link #VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX} indicates a {@code VkDescriptorSet} resource entry that is registered via {@link VkObjectTableDescriptorSetEntryNVX}.
     * 
{@link #VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX OBJECT_ENTRY_TYPE_PIPELINE_NVX} indicates a {@code VkPipeline} resource entry that is registered via {@link VkObjectTablePipelineEntryNVX}.
     * 
{@link #VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX} indicates a {@code VkBuffer} resource entry that is registered via {@link VkObjectTableIndexBufferEntryNVX}.
     * 
{@link #VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX} indicates a {@code VkBuffer} resource entry that is registered via {@link VkObjectTableVertexBufferEntryNVX}.
     * 
{@link #VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX} indicates the resource entry is registered via {@link VkObjectTablePushConstantEntryNVX}.
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkObjectTableCreateInfoNVX}, {@link VkObjectTableDescriptorSetEntryNVX}, {@link VkObjectTableEntryNVX}, {@link VkObjectTableIndexBufferEntryNVX}, {@link VkObjectTablePipelineEntryNVX}, {@link VkObjectTablePushConstantEntryNVX}, {@link VkObjectTableVertexBufferEntryNVX}, {@link #vkUnregisterObjectsNVX UnregisterObjectsNVX}
     */
    public static final int
        VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0,
        VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX       = 1,
        VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX   = 2,
        VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX  = 3,
        VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX  = 4;

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

    static boolean isAvailable(VKCapabilitiesInstance caps) {
        return checkFunctions(
            caps.vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX
        );
    }

    static boolean isAvailable(VKCapabilitiesInstance capsInstance, VKCapabilitiesDevice caps) {
        return isAvailable(capsInstance) && checkFunctions(
            caps.vkCmdProcessCommandsNVX, caps.vkCmdReserveSpaceForCommandsNVX, caps.vkCreateIndirectCommandsLayoutNVX, caps.vkDestroyIndirectCommandsLayoutNVX, 
            caps.vkCreateObjectTableNVX, caps.vkDestroyObjectTableNVX, caps.vkRegisterObjectsNVX, caps.vkUnregisterObjectsNVX
        );
    }

    // --- [ vkCmdProcessCommandsNVX ] ---

    /** Unsafe version of: {@link #vkCmdProcessCommandsNVX CmdProcessCommandsNVX} */
    public static void nvkCmdProcessCommandsNVX(VkCommandBuffer commandBuffer, long pProcessCommandsInfo) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdProcessCommandsNVX;
        if (CHECKS) {
            check(__functionAddress);
            VkCmdProcessCommandsInfoNVX.validate(pProcessCommandsInfo);
        }
        callPPV(__functionAddress, commandBuffer.address(), pProcessCommandsInfo);
    }

    /**
     * Performs the generation of commands on the device.
     * 
     * 
C Specification
     * 
     * 
The actual generation on the device is handled with:
     * 
     * 
     * void vkCmdProcessCommandsNVX(
     *     VkCommandBuffer                             commandBuffer,
     *     const VkCmdProcessCommandsInfoNVX*          pProcessCommandsInfo);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * 
{@code pProcessCommandsInfo} must be a valid pointer to a valid {@link VkCmdProcessCommandsInfoNVX} structure
     * 
{@code commandBuffer} must be in the recording state
     * 
The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics, or compute operations
     * 
This command must only be called inside of a render pass instance
     * 
     * 
     * 
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
Pipeline Type
Primary Secondary
Inside
Graphics Compute

     * 
     * 
See Also
     * 
     * 
{@link VkCmdProcessCommandsInfoNVX}
     *
     * @param commandBuffer        the primary command buffer in which the generation process takes space.
     * @param pProcessCommandsInfo a pointer to an instance of the {@link VkCmdProcessCommandsInfoNVX} structure containing parameters affecting the processing of commands.
     */
    public static void vkCmdProcessCommandsNVX(VkCommandBuffer commandBuffer, @NativeType("const VkCmdProcessCommandsInfoNVX *") VkCmdProcessCommandsInfoNVX pProcessCommandsInfo) {
        nvkCmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo.address());
    }

    // --- [ vkCmdReserveSpaceForCommandsNVX ] ---

    /** Unsafe version of: {@link #vkCmdReserveSpaceForCommandsNVX CmdReserveSpaceForCommandsNVX} */
    public static void nvkCmdReserveSpaceForCommandsNVX(VkCommandBuffer commandBuffer, long pReserveSpaceInfo) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdReserveSpaceForCommandsNVX;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPV(__functionAddress, commandBuffer.address(), pReserveSpaceInfo);
    }

    /**
     * Perform a reservation of command buffer space.
     * 
     * 
C Specification
     * 
     * 
Command space for generated commands recorded into a secondary command buffer must be reserved by calling:
     * 
     * 
     * void vkCmdReserveSpaceForCommandsNVX(
     *     VkCommandBuffer                             commandBuffer,
     *     const VkCmdReserveSpaceForCommandsInfoNVX*  pReserveSpaceInfo);
     * 
     * 
Valid Usage
     * 
     * 

     * 
The provided {@code commandBuffer} must not have had a prior space reservation since its creation or the last reset.
     * 
The state of the {@code commandBuffer} must be legal to execute all commands within the sequence provided by the {@code indirectCommandsLayout} member of {@code pProcessCommandsInfo}.
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * 
{@code pReserveSpaceInfo} must be a valid pointer to a valid {@link VkCmdReserveSpaceForCommandsInfoNVX} structure
     * 
{@code commandBuffer} must be in the recording state
     * 
The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics, or compute operations
     * 
This command must only be called inside of a render pass instance
     * 
{@code commandBuffer} must be a secondary {@code VkCommandBuffer}
     * 
     * 
     * 
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
Pipeline Type
Secondary
Inside
Graphics Compute

     * 
     * 
See Also
     * 
     * 
{@link VkCmdReserveSpaceForCommandsInfoNVX}
     *
     * @param commandBuffer     the secondary command buffer in which the space for device-generated commands is reserved.
     * @param pReserveSpaceInfo 
     */
    public static void vkCmdReserveSpaceForCommandsNVX(VkCommandBuffer commandBuffer, @NativeType("const VkCmdReserveSpaceForCommandsInfoNVX *") VkCmdReserveSpaceForCommandsInfoNVX pReserveSpaceInfo) {
        nvkCmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo.address());
    }

    // --- [ vkCreateIndirectCommandsLayoutNVX ] ---

    /** Unsafe version of: {@link #vkCreateIndirectCommandsLayoutNVX CreateIndirectCommandsLayoutNVX} */
    public static int nvkCreateIndirectCommandsLayoutNVX(VkDevice device, long pCreateInfo, long pAllocator, long pIndirectCommandsLayout) {
        long __functionAddress = device.getCapabilities().vkCreateIndirectCommandsLayoutNVX;
        if (CHECKS) {
            check(__functionAddress);
            VkIndirectCommandsLayoutCreateInfoNVX.validate(pCreateInfo);
            if (pAllocator != NULL) { VkAllocationCallbacks.validate(pAllocator); }
        }
        return callPPPPI(__functionAddress, device.address(), pCreateInfo, pAllocator, pIndirectCommandsLayout);
    }

    /**
     * Create an indirect command layout object.
     * 
     * 
C Specification
     * 
     * 
Indirect command layouts are created by:
     * 
     * 
     * VkResult vkCreateIndirectCommandsLayoutNVX(
     *     VkDevice                                    device,
     *     const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
     *     const VkAllocationCallbacks*                pAllocator,
     *     VkIndirectCommandsLayoutNVX*                pIndirectCommandsLayout);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code pCreateInfo} must be a valid pointer to a valid {@link VkIndirectCommandsLayoutCreateInfoNVX} structure
     * 
If {@code pAllocator} is not {@code NULL}, {@code pAllocator} must be a valid pointer to a valid {@link VkAllocationCallbacks} structure
     * 
{@code pIndirectCommandsLayout} must be a valid pointer to a {@code VkIndirectCommandsLayoutNVX} handle
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link VK10#VK_SUCCESS SUCCESS}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
     * 
{@link VK10#VK_ERROR_OUT_OF_DEVICE_MEMORY ERROR_OUT_OF_DEVICE_MEMORY}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkAllocationCallbacks}, {@link VkIndirectCommandsLayoutCreateInfoNVX}
     *
     * @param device                  the logical device that creates the object table.
     * @param pCreateInfo             a pointer to an instance of the {@link VkObjectTableCreateInfoNVX} structure containing parameters affecting creation of the table.
     * @param pAllocator              controls host memory allocation as described in the Memory Allocation chapter.
     * @param pIndirectCommandsLayout points to a {@code VkObjectTableNVX} handle in which the resulting object table is returned.
     */
    @NativeType("VkResult")
    public static int vkCreateIndirectCommandsLayoutNVX(VkDevice device, @NativeType("const VkIndirectCommandsLayoutCreateInfoNVX *") VkIndirectCommandsLayoutCreateInfoNVX pCreateInfo, @Nullable @NativeType("const VkAllocationCallbacks *") VkAllocationCallbacks pAllocator, @NativeType("VkIndirectCommandsLayoutNVX *") LongBuffer pIndirectCommandsLayout) {
        if (CHECKS) {
            check(pIndirectCommandsLayout, 1);
        }
        return nvkCreateIndirectCommandsLayoutNVX(device, pCreateInfo.address(), memAddressSafe(pAllocator), memAddress(pIndirectCommandsLayout));
    }

    // --- [ vkDestroyIndirectCommandsLayoutNVX ] ---

    /** Unsafe version of: {@link #vkDestroyIndirectCommandsLayoutNVX DestroyIndirectCommandsLayoutNVX} */
    public static void nvkDestroyIndirectCommandsLayoutNVX(VkDevice device, long indirectCommandsLayout, long pAllocator) {
        long __functionAddress = device.getCapabilities().vkDestroyIndirectCommandsLayoutNVX;
        if (CHECKS) {
            check(__functionAddress);
            if (pAllocator != NULL) { VkAllocationCallbacks.validate(pAllocator); }
        }
        callPJPV(__functionAddress, device.address(), indirectCommandsLayout, pAllocator);
    }

    /**
     * Destroy a object table.
     * 
     * 
C Specification
     * 
     * 
Indirect command layouts are destroyed by:
     * 
     * 
     * void vkDestroyIndirectCommandsLayoutNVX(
     *     VkDevice                                    device,
     *     VkIndirectCommandsLayoutNVX                 indirectCommandsLayout,
     *     const VkAllocationCallbacks*                pAllocator);
     * 
     * 
Valid Usage
     * 
     * 

     * 
All submitted commands that refer to {@code indirectCommandsLayout} must have completed execution
     * 
If {@link VkAllocationCallbacks} were provided when {@code objectTable} was created, a compatible set of callbacks must be provided here
     * 
If no {@link VkAllocationCallbacks} were provided when {@code objectTable} was created, {@code pAllocator} must be {@code NULL}
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code indirectCommandsLayout} must be a valid {@code VkIndirectCommandsLayoutNVX} handle
     * 
If {@code pAllocator} is not {@code NULL}, {@code pAllocator} must be a valid pointer to a valid {@link VkAllocationCallbacks} structure
     * 
{@code indirectCommandsLayout} must have been created, allocated, or retrieved from {@code device}
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkAllocationCallbacks}
     *
     * @param device                 the logical device that destroys the layout.
     * @param indirectCommandsLayout the table to destroy.
     * @param pAllocator             controls host memory allocation as described in the Memory Allocation chapter.
     */
    public static void vkDestroyIndirectCommandsLayoutNVX(VkDevice device, @NativeType("VkIndirectCommandsLayoutNVX") long indirectCommandsLayout, @Nullable @NativeType("const VkAllocationCallbacks *") VkAllocationCallbacks pAllocator) {
        nvkDestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, memAddressSafe(pAllocator));
    }

    // --- [ vkCreateObjectTableNVX ] ---

    /** Unsafe version of: {@link #vkCreateObjectTableNVX CreateObjectTableNVX} */
    public static int nvkCreateObjectTableNVX(VkDevice device, long pCreateInfo, long pAllocator, long pObjectTable) {
        long __functionAddress = device.getCapabilities().vkCreateObjectTableNVX;
        if (CHECKS) {
            check(__functionAddress);
            VkObjectTableCreateInfoNVX.validate(pCreateInfo);
            if (pAllocator != NULL) { VkAllocationCallbacks.validate(pAllocator); }
        }
        return callPPPPI(__functionAddress, device.address(), pCreateInfo, pAllocator, pObjectTable);
    }

    /**
     * Create an object table.
     * 
     * 
C Specification
     * 
     * 
To create object tables, call:
     * 
     * 
     * VkResult vkCreateObjectTableNVX(
     *     VkDevice                                    device,
     *     const VkObjectTableCreateInfoNVX*           pCreateInfo,
     *     const VkAllocationCallbacks*                pAllocator,
     *     VkObjectTableNVX*                           pObjectTable);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code pCreateInfo} must be a valid pointer to a valid {@link VkObjectTableCreateInfoNVX} structure
     * 
If {@code pAllocator} is not {@code NULL}, {@code pAllocator} must be a valid pointer to a valid {@link VkAllocationCallbacks} structure
     * 
{@code pObjectTable} must be a valid pointer to a {@code VkObjectTableNVX} handle
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link VK10#VK_SUCCESS SUCCESS}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
     * 
{@link VK10#VK_ERROR_OUT_OF_DEVICE_MEMORY ERROR_OUT_OF_DEVICE_MEMORY}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkAllocationCallbacks}, {@link VkObjectTableCreateInfoNVX}
     *
     * @param device       the logical device that creates the object table.
     * @param pCreateInfo  a pointer to an instance of the {@link VkObjectTableCreateInfoNVX} structure containing parameters affecting creation of the table.
     * @param pAllocator   controls host memory allocation as described in the Memory Allocation chapter.
     * @param pObjectTable points to a {@code VkObjectTableNVX} handle in which the resulting object table is returned.
     */
    @NativeType("VkResult")
    public static int vkCreateObjectTableNVX(VkDevice device, @NativeType("const VkObjectTableCreateInfoNVX *") VkObjectTableCreateInfoNVX pCreateInfo, @Nullable @NativeType("const VkAllocationCallbacks *") VkAllocationCallbacks pAllocator, @NativeType("VkObjectTableNVX *") LongBuffer pObjectTable) {
        if (CHECKS) {
            check(pObjectTable, 1);
        }
        return nvkCreateObjectTableNVX(device, pCreateInfo.address(), memAddressSafe(pAllocator), memAddress(pObjectTable));
    }

    // --- [ vkDestroyObjectTableNVX ] ---

    /** Unsafe version of: {@link #vkDestroyObjectTableNVX DestroyObjectTableNVX} */
    public static void nvkDestroyObjectTableNVX(VkDevice device, long objectTable, long pAllocator) {
        long __functionAddress = device.getCapabilities().vkDestroyObjectTableNVX;
        if (CHECKS) {
            check(__functionAddress);
            if (pAllocator != NULL) { VkAllocationCallbacks.validate(pAllocator); }
        }
        callPJPV(__functionAddress, device.address(), objectTable, pAllocator);
    }

    /**
     * Destroy a object table.
     * 
     * 
C Specification
     * 
     * 
To destroy an object table, call:
     * 
     * 
     * void vkDestroyObjectTableNVX(
     *     VkDevice                                    device,
     *     VkObjectTableNVX                            objectTable,
     *     const VkAllocationCallbacks*                pAllocator);
     * 
     * 
Valid Usage
     * 
     * 

     * 
All submitted commands that refer to {@code objectTable} must have completed execution.
     * 
If {@link VkAllocationCallbacks} were provided when {@code objectTable} was created, a compatible set of callbacks must be provided here.
     * 
If no {@link VkAllocationCallbacks} were provided when {@code objectTable} was created, {@code pAllocator} must be {@code NULL}.
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code objectTable} must be a valid {@code VkObjectTableNVX} handle
     * 
If {@code pAllocator} is not {@code NULL}, {@code pAllocator} must be a valid pointer to a valid {@link VkAllocationCallbacks} structure
     * 
{@code objectTable} must have been created, allocated, or retrieved from {@code device}
     * 
     * 
     * 
Host Synchronization
     * 
     * 

     * 
Host access to {@code objectTable} must be externally synchronized
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkAllocationCallbacks}
     *
     * @param device      the logical device that destroys the table.
     * @param objectTable the table to destroy.
     * @param pAllocator  controls host memory allocation as described in the Memory Allocation chapter.
     */
    public static void vkDestroyObjectTableNVX(VkDevice device, @NativeType("VkObjectTableNVX") long objectTable, @Nullable @NativeType("const VkAllocationCallbacks *") VkAllocationCallbacks pAllocator) {
        nvkDestroyObjectTableNVX(device, objectTable, memAddressSafe(pAllocator));
    }

    // --- [ vkRegisterObjectsNVX ] ---

    /**
     * Unsafe version of: {@link #vkRegisterObjectsNVX RegisterObjectsNVX}
     *
     * @param objectCount the number of resources to register.
     */
    public static int nvkRegisterObjectsNVX(VkDevice device, long objectTable, int objectCount, long ppObjectTableEntries, long pObjectIndices) {
        long __functionAddress = device.getCapabilities().vkRegisterObjectsNVX;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPJPPI(__functionAddress, device.address(), objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
    }

    /**
     * Register resource bindings in an object table.
     * 
     * 
C Specification
     * 
     * 
Resource bindings of Vulkan objects are registered at an arbitrary ftext:uint32_t index within an object table. As long as the object table references such objects, they must not be deleted.
     * 
     * 
     * VkResult vkRegisterObjectsNVX(
     *     VkDevice                                    device,
     *     VkObjectTableNVX                            objectTable,
     *     uint32_t                                    objectCount,
     *     const VkObjectTableEntryNVX* const*         ppObjectTableEntries,
     *     const uint32_t*                             pObjectIndices);
     * 
     * 
Valid Usage
     * 
     * 

     * 
The contents of {@code pObjectTableEntry} must yield plausible bindings supported by the device.
     * 
At any {@code pObjectIndices} there must not be a registered resource already.
     * 
Any value inside {@code pObjectIndices} must be below the appropriate {@link VkObjectTableCreateInfoNVX}{@code ::pObjectEntryCounts} limits provided at {@code objectTable} creation time.
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code objectTable} must be a valid {@code VkObjectTableNVX} handle
     * 
{@code ppObjectTableEntries} must be a valid pointer to an array of {@code objectCount} valid {@link VkObjectTableEntryNVX} structures
     * 
{@code pObjectIndices} must be a valid pointer to an array of {@code objectCount} {@code uint32_t} values
     * 
{@code objectCount} must be greater than 0
     * 
{@code objectTable} must have been created, allocated, or retrieved from {@code device}
     * 
     * 
     * 
Host Synchronization
     * 
     * 

     * 
Host access to {@code objectTable} must be externally synchronized
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link VK10#VK_SUCCESS SUCCESS}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
     * 
{@link VK10#VK_ERROR_OUT_OF_DEVICE_MEMORY ERROR_OUT_OF_DEVICE_MEMORY}
     * 
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkObjectTableEntryNVX}
     *
     * @param device               the logical device that creates the object table.
     * @param objectTable          the table for which the resources are registered.
     * @param ppObjectTableEntries provides an array for detailed binding informations, each array element is a pointer to a struct of type {@link VkObjectTablePipelineEntryNVX}, {@link VkObjectTableDescriptorSetEntryNVX}, {@link VkObjectTableVertexBufferEntryNVX}, {@link VkObjectTableIndexBufferEntryNVX} or {@link VkObjectTablePushConstantEntryNVX} (see below for details).
     * @param pObjectIndices       are the indices at which each resource is registered.
     */
    @NativeType("VkResult")
    public static int vkRegisterObjectsNVX(VkDevice device, @NativeType("VkObjectTableNVX") long objectTable, @NativeType("const VkObjectTableEntryNVX * const *") PointerBuffer ppObjectTableEntries, @NativeType("const uint32_t *") IntBuffer pObjectIndices) {
        if (CHECKS) {
            check(pObjectIndices, ppObjectTableEntries.remaining());
        }
        return nvkRegisterObjectsNVX(device, objectTable, ppObjectTableEntries.remaining(), memAddress(ppObjectTableEntries), memAddress(pObjectIndices));
    }

    // --- [ vkUnregisterObjectsNVX ] ---

    /**
     * Unsafe version of: {@link #vkUnregisterObjectsNVX UnregisterObjectsNVX}
     *
     * @param objectCount the number of resources being removed from the object table.
     */
    public static int nvkUnregisterObjectsNVX(VkDevice device, long objectTable, int objectCount, long pObjectEntryTypes, long pObjectIndices) {
        long __functionAddress = device.getCapabilities().vkUnregisterObjectsNVX;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPJPPI(__functionAddress, device.address(), objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
    }

    /**
     * Unregister resource bindings in an object table.
     * 
     * 
C Specification
     * 
     * 
Use the following command to unregister resources from an object table:
     * 
     * 
     * VkResult vkUnregisterObjectsNVX(
     *     VkDevice                                    device,
     *     VkObjectTableNVX                            objectTable,
     *     uint32_t                                    objectCount,
     *     const VkObjectEntryTypeNVX*                 pObjectEntryTypes,
     *     const uint32_t*                             pObjectIndices);
     * 
     * 
Valid Usage
     * 
     * 

     * 
At any {@code pObjectIndices} there must be a registered resource already.
     * 
The {@code pObjectEntryTypes} of the resource at {@code pObjectIndices} must match.
     * 
All operations on the device using the registered resource must have been completed.
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code device} must be a valid {@code VkDevice} handle
     * 
{@code objectTable} must be a valid {@code VkObjectTableNVX} handle
     * 
{@code pObjectEntryTypes} must be a valid pointer to an array of {@code objectCount} valid {@code VkObjectEntryTypeNVX} values
     * 
{@code pObjectIndices} must be a valid pointer to an array of {@code objectCount} {@code uint32_t} values
     * 
{@code objectCount} must be greater than 0
     * 
{@code objectTable} must have been created, allocated, or retrieved from {@code device}
     * 
     * 
     * 
Host Synchronization
     * 
     * 

     * 
Host access to {@code objectTable} must be externally synchronized
     * 
     * 
     * 
Return Codes
     * 
     * 

     * 
On success, this command returns
     * 

     * 
{@link VK10#VK_SUCCESS SUCCESS}
     * 
     * 
On failure, this command returns
     * 

     * 
{@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
     * 
{@link VK10#VK_ERROR_OUT_OF_DEVICE_MEMORY ERROR_OUT_OF_DEVICE_MEMORY}
     * 
     * 
     *
     * @param device            the logical device that creates the object table.
     * @param objectTable       the table from which the resources are unregistered.
     * @param pObjectEntryTypes 
     * @param pObjectIndices    provides the array of object indices to be removed.
     */
    @NativeType("VkResult")
    public static int vkUnregisterObjectsNVX(VkDevice device, @NativeType("VkObjectTableNVX") long objectTable, @NativeType("const VkObjectEntryTypeNVX *") IntBuffer pObjectEntryTypes, @NativeType("const uint32_t *") IntBuffer pObjectIndices) {
        if (CHECKS) {
            check(pObjectIndices, pObjectEntryTypes.remaining());
        }
        return nvkUnregisterObjectsNVX(device, objectTable, pObjectEntryTypes.remaining(), memAddress(pObjectEntryTypes), memAddress(pObjectIndices));
    }

    // --- [ vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX ] ---

    /** Unsafe version of: {@link #vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX GetPhysicalDeviceGeneratedCommandsPropertiesNVX} */
    public static void nvkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(VkPhysicalDevice physicalDevice, long pFeatures, long pLimits) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPPV(__functionAddress, physicalDevice.address(), pFeatures, pLimits);
    }

    /**
     * Returns device-generated commands related properties of a physical device.
     * 
     * 
C Specification
     * 
     * 
To query the support of related features and limitations, call:
     * 
     * 
     * void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
     *     VkPhysicalDevice                            physicalDevice,
     *     VkDeviceGeneratedCommandsFeaturesNVX*       pFeatures,
     *     VkDeviceGeneratedCommandsLimitsNVX*         pLimits);
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
     * 
{@code pFeatures} must be a valid pointer to a {@link VkDeviceGeneratedCommandsFeaturesNVX} structure
     * 
{@code pLimits} must be a valid pointer to a {@link VkDeviceGeneratedCommandsLimitsNVX} structure
     * 
     * 
     * 
See Also
     * 
     * 
{@link VkDeviceGeneratedCommandsFeaturesNVX}, {@link VkDeviceGeneratedCommandsLimitsNVX}
     *
     * @param physicalDevice the handle to the physical device whose properties will be queried.
     * @param pFeatures      points to an instance of the {@link VkDeviceGeneratedCommandsFeaturesNVX} structure, that will be filled with returned information.
     * @param pLimits        points to an instance of the {@link VkDeviceGeneratedCommandsLimitsNVX} structure, that will be filled with returned information.
     */
    public static void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(VkPhysicalDevice physicalDevice, @NativeType("VkDeviceGeneratedCommandsFeaturesNVX *") VkDeviceGeneratedCommandsFeaturesNVX pFeatures, @NativeType("VkDeviceGeneratedCommandsLimitsNVX *") VkDeviceGeneratedCommandsLimitsNVX pLimits) {
        nvkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(physicalDevice, pFeatures.address(), pLimits.address());
    }

    /** Array version of: {@link #vkCreateIndirectCommandsLayoutNVX CreateIndirectCommandsLayoutNVX} */
    @NativeType("VkResult")
    public static int vkCreateIndirectCommandsLayoutNVX(VkDevice device, @NativeType("const VkIndirectCommandsLayoutCreateInfoNVX *") VkIndirectCommandsLayoutCreateInfoNVX pCreateInfo, @Nullable @NativeType("const VkAllocationCallbacks *") VkAllocationCallbacks pAllocator, @NativeType("VkIndirectCommandsLayoutNVX *") long[] pIndirectCommandsLayout) {
        long __functionAddress = device.getCapabilities().vkCreateIndirectCommandsLayoutNVX;
        if (CHECKS) {
            check(__functionAddress);
            check(pIndirectCommandsLayout, 1);
            VkIndirectCommandsLayoutCreateInfoNVX.validate(pCreateInfo.address());
            if (pAllocator != null) { VkAllocationCallbacks.validate(pAllocator.address()); }
        }
        return callPPPPI(__functionAddress, device.address(), pCreateInfo.address(), memAddressSafe(pAllocator), pIndirectCommandsLayout);
    }

    /** Array version of: {@link #vkCreateObjectTableNVX CreateObjectTableNVX} */
    @NativeType("VkResult")
    public static int vkCreateObjectTableNVX(VkDevice device, @NativeType("const VkObjectTableCreateInfoNVX *") VkObjectTableCreateInfoNVX pCreateInfo, @Nullable @NativeType("const VkAllocationCallbacks *") VkAllocationCallbacks pAllocator, @NativeType("VkObjectTableNVX *") long[] pObjectTable) {
        long __functionAddress = device.getCapabilities().vkCreateObjectTableNVX;
        if (CHECKS) {
            check(__functionAddress);
            check(pObjectTable, 1);
            VkObjectTableCreateInfoNVX.validate(pCreateInfo.address());
            if (pAllocator != null) { VkAllocationCallbacks.validate(pAllocator.address()); }
        }
        return callPPPPI(__functionAddress, device.address(), pCreateInfo.address(), memAddressSafe(pAllocator), pObjectTable);
    }

    /** Array version of: {@link #vkRegisterObjectsNVX RegisterObjectsNVX} */
    @NativeType("VkResult")
    public static int vkRegisterObjectsNVX(VkDevice device, @NativeType("VkObjectTableNVX") long objectTable, @NativeType("const VkObjectTableEntryNVX * const *") PointerBuffer ppObjectTableEntries, @NativeType("const uint32_t *") int[] pObjectIndices) {
        long __functionAddress = device.getCapabilities().vkRegisterObjectsNVX;
        if (CHECKS) {
            check(__functionAddress);
            check(pObjectIndices, ppObjectTableEntries.remaining());
        }
        return callPJPPI(__functionAddress, device.address(), objectTable, ppObjectTableEntries.remaining(), memAddress(ppObjectTableEntries), pObjectIndices);
    }

    /** Array version of: {@link #vkUnregisterObjectsNVX UnregisterObjectsNVX} */
    @NativeType("VkResult")
    public static int vkUnregisterObjectsNVX(VkDevice device, @NativeType("VkObjectTableNVX") long objectTable, @NativeType("const VkObjectEntryTypeNVX *") int[] pObjectEntryTypes, @NativeType("const uint32_t *") int[] pObjectIndices) {
        long __functionAddress = device.getCapabilities().vkUnregisterObjectsNVX;
        if (CHECKS) {
            check(__functionAddress);
            check(pObjectIndices, pObjectEntryTypes.length);
        }
        return callPJPPI(__functionAddress, device.address(), objectTable, pObjectEntryTypes.length, pObjectEntryTypes, pObjectIndices);
    }

}