• Home
• org.lwjgl
• lwjgl-vulkan
• 3.3.0
• source code
• KHRCopyCommands2.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.KHRCopyCommands2 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 org.lwjgl.system.*;

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

/**
 * This extension provides extensible versions of the Vulkan buffer and image copy commands. The new commands are functionally identical to the core commands, except that their copy parameters are specified using extensible structures that can be used to pass extension-specific information.
 * 
 * 
The following extensible copy commands are introduced with this extension: {@link #vkCmdCopyBuffer2KHR CmdCopyBuffer2KHR}, {@link #vkCmdCopyImage2KHR CmdCopyImage2KHR}, {@link #vkCmdCopyBufferToImage2KHR CmdCopyBufferToImage2KHR}, {@link #vkCmdCopyImageToBuffer2KHR CmdCopyImageToBuffer2KHR}, {@link #vkCmdBlitImage2KHR CmdBlitImage2KHR}, and {@link #vkCmdResolveImage2KHR CmdResolveImage2KHR}. Each command contains an stext:*Info2KHR structure parameter that includes {@code sType}/{@code pNext} members. Lower level structures that describe each region to be copied are also extended with {@code sType}/{@code pNext} members.
 * 
 * 
VK_KHR_copy_commands2
 * 
 * 

 * 
Name String
 * 
{@code VK_KHR_copy_commands2}
 * 
Extension Type
 * 
Device extension
 * 
Registered Extension Number
 * 
338
 * 
Revision
 * 
1
 * 
Extension and Version Dependencies
 * 

 * 
Requires Vulkan 1.0
 * 
 * 
Contact
 * 

 * 
Jeff Leger jackohound
 * 
 * 
 * 
 * 
Other Extension Metadata
 * 
 * 

 * 
Last Modified Date
 * 
2020-07-06
 * 
Interactions and External Dependencies
 * 

 * 
None
 * 
 * 
Contributors
 * 

 * 
Jeff Leger, Qualcomm
 * 
Tobias Hector, AMD
 * 
Jan-Harald Fredriksen, ARM
 * 
Tom Olson, ARM
 * 
 * 
 */
public class KHRCopyCommands2 {

    /** The extension specification version. */
    public static final int VK_KHR_COPY_COMMANDS_2_SPEC_VERSION = 1;

    /** The extension name. */
    public static final String VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME = "VK_KHR_copy_commands2";

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

     * 
{@link #VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR}
     * 
{@link #VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR}
     * 
{@link #VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR}
     * 
{@link #VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR}
     * 
{@link #VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR}
     * 
{@link #VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR}
     * 
{@link #VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR STRUCTURE_TYPE_BUFFER_COPY_2_KHR}
     * 
{@link #VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR STRUCTURE_TYPE_IMAGE_COPY_2_KHR}
     * 
{@link #VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR STRUCTURE_TYPE_IMAGE_BLIT_2_KHR}
     * 
{@link #VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR}
     * 
{@link #VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR          = 1000337000,
        VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR           = 1000337001,
        VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR = 1000337002,
        VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR = 1000337003,
        VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR           = 1000337004,
        VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR        = 1000337005,
        VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR               = 1000337006,
        VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR                = 1000337007,
        VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR                = 1000337008,
        VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR         = 1000337009,
        VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR             = 1000337010;

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

    // --- [ vkCmdCopyBuffer2KHR ] ---

    /** Unsafe version of: {@link #vkCmdCopyBuffer2KHR CmdCopyBuffer2KHR} */
    public static void nvkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, long pCopyBufferInfo) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdCopyBuffer2KHR;
        if (CHECKS) {
            check(__functionAddress);
            VkCopyBufferInfo2KHR.validate(pCopyBufferInfo);
        }
        callPPV(commandBuffer.address(), pCopyBufferInfo, __functionAddress);
    }

    /**
     * Copy data between buffer regions.
     * 
     * 
C Specification
     * 
     * 
To copy data between buffer objects, call:
     * 
     * 

     * void vkCmdCopyBuffer2KHR(
     *     VkCommandBuffer                             commandBuffer,
     *     const VkCopyBufferInfo2KHR*                 pCopyBufferInfo);
     * 
     * 
Description
     * 
     * 
This command is functionally identical to {@link VK10#vkCmdCopyBuffer CmdCopyBuffer}, but includes extensible sub-structures that include {@code sType} and {@code pNext} parameters, allowing them to be more easily extended.
     * 
     * 
Valid Usage
     * 
     * 

     * 
If {@code commandBuffer} is an unprotected command buffer and {@code protectedNoFault} is not supported, {@code srcBuffer} must not be a protected buffer
     * 
If {@code commandBuffer} is an unprotected command buffer and {@code protectedNoFault} is not supported, {@code dstBuffer} must not be a protected buffer
     * 
If {@code commandBuffer} is a protected command buffer and {@code protectedNoFault} is not supported, {@code dstBuffer} must not be an unprotected buffer
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * 
{@code pCopyBufferInfo} must be a valid pointer to a valid {@link VkCopyBufferInfo2KHR} structure
     * 
{@code commandBuffer} must be in the recording state
     * 
The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support transfer, graphics, or compute operations
     * 
This command must only be called outside 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
Primary Secondary
Outside
Transfer Graphics Compute
     * 
     * 
See Also
     * 
     * 
{@link VkCopyBufferInfo2KHR}
     *
     * @param commandBuffer   the command buffer into which the command will be recorded.
     * @param pCopyBufferInfo a pointer to a {@link VkCopyBufferInfo2KHR} structure describing the copy parameters.
     */
    public static void vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, @NativeType("VkCopyBufferInfo2KHR const *") VkCopyBufferInfo2KHR pCopyBufferInfo) {
        nvkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo.address());
    }

    // --- [ vkCmdCopyImage2KHR ] ---

    /** Unsafe version of: {@link #vkCmdCopyImage2KHR CmdCopyImage2KHR} */
    public static void nvkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, long pCopyImageInfo) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdCopyImage2KHR;
        if (CHECKS) {
            check(__functionAddress);
            VkCopyImageInfo2KHR.validate(pCopyImageInfo);
        }
        callPPV(commandBuffer.address(), pCopyImageInfo, __functionAddress);
    }

    /**
     * Copy data between images.
     * 
     * 
C Specification
     * 
     * 
To copy data between image objects, call:
     * 
     * 

     * void vkCmdCopyImage2KHR(
     *     VkCommandBuffer                             commandBuffer,
     *     const VkCopyImageInfo2KHR*                  pCopyImageInfo);
     * 
     * 
Description
     * 
     * 
This command is functionally identical to {@link VK10#vkCmdCopyImage CmdCopyImage}, but includes extensible sub-structures that include {@code sType} and {@code pNext} parameters, allowing them to be more easily extended.
     * 
     * 
Valid Usage
     * 
     * 

     * 
If {@code commandBuffer} is an unprotected command buffer and {@code protectedNoFault} is not supported, {@code srcImage} must not be a protected image
     * 
If {@code commandBuffer} is an unprotected command buffer and {@code protectedNoFault} is not supported, {@code dstImage} must not be a protected image
     * 
If {@code commandBuffer} is a protected command buffer and {@code protectedNoFault} is not supported, {@code dstImage} must not be an unprotected image
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * 
{@code pCopyImageInfo} must be a valid pointer to a valid {@link VkCopyImageInfo2KHR} structure
     * 
{@code commandBuffer} must be in the recording state
     * 
The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support transfer, graphics, or compute operations
     * 
This command must only be called outside 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
Primary Secondary
Outside
Transfer Graphics Compute
     * 
     * 
See Also
     * 
     * 
{@link VkCopyImageInfo2KHR}
     *
     * @param commandBuffer  the command buffer into which the command will be recorded.
     * @param pCopyImageInfo a pointer to a {@link VkCopyImageInfo2KHR} structure describing the copy parameters.
     */
    public static void vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, @NativeType("VkCopyImageInfo2KHR const *") VkCopyImageInfo2KHR pCopyImageInfo) {
        nvkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo.address());
    }

    // --- [ vkCmdCopyBufferToImage2KHR ] ---

    /** Unsafe version of: {@link #vkCmdCopyBufferToImage2KHR CmdCopyBufferToImage2KHR} */
    public static void nvkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, long pCopyBufferToImageInfo) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdCopyBufferToImage2KHR;
        if (CHECKS) {
            check(__functionAddress);
            VkCopyBufferToImageInfo2KHR.validate(pCopyBufferToImageInfo);
        }
        callPPV(commandBuffer.address(), pCopyBufferToImageInfo, __functionAddress);
    }

    /**
     * Copy data from a buffer into an image.
     * 
     * 
C Specification
     * 
     * 
To copy data from a buffer object to an image object, call:
     * 
     * 

     * void vkCmdCopyBufferToImage2KHR(
     *     VkCommandBuffer                             commandBuffer,
     *     const VkCopyBufferToImageInfo2KHR*          pCopyBufferToImageInfo);
     * 
     * 
Description
     * 
     * 
This command is functionally identical to {@link VK10#vkCmdCopyBufferToImage CmdCopyBufferToImage}, but includes extensible sub-structures that include {@code sType} and {@code pNext} parameters, allowing them to be more easily extended.
     * 
     * 
Valid Usage
     * 
     * 

     * 
If {@code commandBuffer} is an unprotected command buffer and {@code protectedNoFault} is not supported, {@code srcBuffer} must not be a protected buffer
     * 
If {@code commandBuffer} is an unprotected command buffer and {@code protectedNoFault} is not supported, {@code dstImage} must not be a protected image
     * 
If {@code commandBuffer} is a protected command buffer and {@code protectedNoFault} is not supported, {@code dstImage} must not be an unprotected image
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * 
{@code pCopyBufferToImageInfo} must be a valid pointer to a valid {@link VkCopyBufferToImageInfo2KHR} structure
     * 
{@code commandBuffer} must be in the recording state
     * 
The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support transfer, graphics, or compute operations
     * 
This command must only be called outside 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
Primary Secondary
Outside
Transfer Graphics Compute
     * 
     * 
See Also
     * 
     * 
{@link VkCopyBufferToImageInfo2KHR}
     *
     * @param commandBuffer          the command buffer into which the command will be recorded.
     * @param pCopyBufferToImageInfo a pointer to a {@link VkCopyBufferToImageInfo2KHR} structure describing the copy parameters.
     */
    public static void vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, @NativeType("VkCopyBufferToImageInfo2KHR const *") VkCopyBufferToImageInfo2KHR pCopyBufferToImageInfo) {
        nvkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo.address());
    }

    // --- [ vkCmdCopyImageToBuffer2KHR ] ---

    /** Unsafe version of: {@link #vkCmdCopyImageToBuffer2KHR CmdCopyImageToBuffer2KHR} */
    public static void nvkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, long pCopyImageToBufferInfo) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdCopyImageToBuffer2KHR;
        if (CHECKS) {
            check(__functionAddress);
            VkCopyImageToBufferInfo2KHR.validate(pCopyImageToBufferInfo);
        }
        callPPV(commandBuffer.address(), pCopyImageToBufferInfo, __functionAddress);
    }

    /**
     * Copy image data into a buffer.
     * 
     * 
C Specification
     * 
     * 
To copy data from an image object to a buffer object, call:
     * 
     * 

     * void vkCmdCopyImageToBuffer2KHR(
     *     VkCommandBuffer                             commandBuffer,
     *     const VkCopyImageToBufferInfo2KHR*          pCopyImageToBufferInfo);
     * 
     * 
Description
     * 
     * 
This command is functionally identical to {@link VK10#vkCmdCopyImageToBuffer CmdCopyImageToBuffer}, but includes extensible sub-structures that include {@code sType} and {@code pNext} parameters, allowing them to be more easily extended.
     * 
     * 
Valid Usage
     * 
     * 

     * 
If {@code commandBuffer} is an unprotected command buffer and {@code protectedNoFault} is not supported, {@code srcImage} must not be a protected image
     * 
If {@code commandBuffer} is an unprotected command buffer and {@code protectedNoFault} is not supported, {@code dstBuffer} must not be a protected buffer
     * 
If {@code commandBuffer} is a protected command buffer and {@code protectedNoFault} is not supported, {@code dstBuffer} must not be an unprotected buffer
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * 
{@code pCopyImageToBufferInfo} must be a valid pointer to a valid {@link VkCopyImageToBufferInfo2KHR} structure
     * 
{@code commandBuffer} must be in the recording state
     * 
The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support transfer, graphics, or compute operations
     * 
This command must only be called outside 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
Primary Secondary
Outside
Transfer Graphics Compute
     * 
     * 
See Also
     * 
     * 
{@link VkCopyImageToBufferInfo2KHR}
     *
     * @param commandBuffer          the command buffer into which the command will be recorded.
     * @param pCopyImageToBufferInfo a pointer to a {@link VkCopyImageToBufferInfo2KHR} structure describing the copy parameters.
     */
    public static void vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, @NativeType("VkCopyImageToBufferInfo2KHR const *") VkCopyImageToBufferInfo2KHR pCopyImageToBufferInfo) {
        nvkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo.address());
    }

    // --- [ vkCmdBlitImage2KHR ] ---

    /** Unsafe version of: {@link #vkCmdBlitImage2KHR CmdBlitImage2KHR} */
    public static void nvkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, long pBlitImageInfo) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdBlitImage2KHR;
        if (CHECKS) {
            check(__functionAddress);
            VkBlitImageInfo2KHR.validate(pBlitImageInfo);
        }
        callPPV(commandBuffer.address(), pBlitImageInfo, __functionAddress);
    }

    /**
     * Copy regions of an image, potentially performing format conversion,.
     * 
     * 
C Specification
     * 
     * 
To copy regions of a source image into a destination image, potentially performing format conversion, arbitrary scaling, and filtering, call:
     * 
     * 

     * void vkCmdBlitImage2KHR(
     *     VkCommandBuffer                             commandBuffer,
     *     const VkBlitImageInfo2KHR*                  pBlitImageInfo);
     * 
     * 
Description
     * 
     * 
This command is functionally identical to {@link VK10#vkCmdBlitImage CmdBlitImage}, but includes extensible sub-structures that include {@code sType} and {@code pNext} parameters, allowing them to be more easily extended.
     * 
     * 
Valid Usage
     * 
     * 

     * 
If {@code commandBuffer} is an unprotected command buffer and {@code protectedNoFault} is not supported, {@code srcImage} must not be a protected image
     * 
If {@code commandBuffer} is an unprotected command buffer and {@code protectedNoFault} is not supported, {@code dstImage} must not be a protected image
     * 
If {@code commandBuffer} is a protected command buffer and {@code protectedNoFault} is not supported, {@code dstImage} must not be an unprotected image
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * 
{@code pBlitImageInfo} must be a valid pointer to a valid {@link VkBlitImageInfo2KHR} structure
     * 
{@code commandBuffer} must be in the recording state
     * 
The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics operations
     * 
This command must only be called outside 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
Primary Secondary
Outside
Graphics
     * 
     * 
See Also
     * 
     * 
{@link VkBlitImageInfo2KHR}
     *
     * @param commandBuffer  the command buffer into which the command will be recorded.
     * @param pBlitImageInfo a pointer to a {@link VkBlitImageInfo2KHR} structure describing the blit parameters.
     */
    public static void vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, @NativeType("VkBlitImageInfo2KHR const *") VkBlitImageInfo2KHR pBlitImageInfo) {
        nvkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo.address());
    }

    // --- [ vkCmdResolveImage2KHR ] ---

    /** Unsafe version of: {@link #vkCmdResolveImage2KHR CmdResolveImage2KHR} */
    public static void nvkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, long pResolveImageInfo) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdResolveImage2KHR;
        if (CHECKS) {
            check(__functionAddress);
            VkResolveImageInfo2KHR.validate(pResolveImageInfo);
        }
        callPPV(commandBuffer.address(), pResolveImageInfo, __functionAddress);
    }

    /**
     * Resolve regions of an image.
     * 
     * 
C Specification
     * 
     * 
To resolve a multisample image to a non-multisample image, call:
     * 
     * 

     * void vkCmdResolveImage2KHR(
     *     VkCommandBuffer                             commandBuffer,
     *     const VkResolveImageInfo2KHR*               pResolveImageInfo);
     * 
     * 
Description
     * 
     * 
This command is functionally identical to {@link VK10#vkCmdResolveImage CmdResolveImage}, but includes extensible sub-structures that include {@code sType} and {@code pNext} parameters, allowing them to be more easily extended.
     * 
     * 
Valid Usage
     * 
     * 

     * 
If {@code commandBuffer} is an unprotected command buffer and {@code protectedNoFault} is not supported, {@code srcImage} must not be a protected image
     * 
If {@code commandBuffer} is an unprotected command buffer and {@code protectedNoFault} is not supported, {@code dstImage} must not be a protected image
     * 
If {@code commandBuffer} is a protected command buffer and {@code protectedNoFault} is not supported, {@code dstImage} must not be an unprotected image
     * 
     * 
     * 
Valid Usage (Implicit)
     * 
     * 

     * 
{@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * 
{@code pResolveImageInfo} must be a valid pointer to a valid {@link VkResolveImageInfo2KHR} structure
     * 
{@code commandBuffer} must be in the recording state
     * 
The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics operations
     * 
This command must only be called outside 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
Primary Secondary
Outside
Graphics
     * 
     * 
See Also
     * 
     * 
{@link VkResolveImageInfo2KHR}
     *
     * @param commandBuffer     the command buffer into which the command will be recorded.
     * @param pResolveImageInfo a pointer to a {@link VkResolveImageInfo2KHR} structure describing the resolve parameters.
     */
    public static void vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, @NativeType("VkResolveImageInfo2KHR const *") VkResolveImageInfo2KHR pResolveImageInfo) {
        nvkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo.address());
    }

}