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

Go to download
Show more of this group Show more artifacts with this name
Show all versions of lwjgl-vulkan Show documentation
A new generation graphics and compute API that provides high-efficiency, cross-platform access to modern GPUs used in a wide variety of devices from PCs and consoles to mobile phones and embedded platforms.
There is a newer version: 3.3.4
Show newest version
/*
 * 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 allows applications to create single-pass render pass instances without needing to create render pass objects or framebuffers. Dynamic render passes can also span across multiple primary command buffers, rather than relying on secondary command buffers.
 * 
 * This extension also incorporates {@link #VK_ATTACHMENT_STORE_OP_NONE_KHR ATTACHMENT_STORE_OP_NONE_KHR} from {@link QCOMRenderPassStoreOps VK_QCOM_render_pass_store_ops}, enabling applications to avoid unnecessary synchronization when an attachment is not written during a render pass.
 * 
 * VK_KHR_dynamic_rendering
 * 
 * 
 * Name String
 * {@code VK_KHR_dynamic_rendering}
 * Extension Type
 * Device extension
 * Registered Extension Number
 * 45
 * Revision
 * 1
 * Extension and Version Dependencies
 * 
 * Requires Vulkan 1.0
 * Requires {@link KHRGetPhysicalDeviceProperties2 VK_KHR_get_physical_device_properties2}
 * 
 * Contact
 * 
 * Tobias Hector tobski
 * 
 * Extension Proposal
 * VK_KHR_dynamic_rendering
 * 
 * 
 * Other Extension Metadata
 * 
 * 
 * Last Modified Date
 * 2021-10-06
 * Contributors
 * 
 * Tobias Hector, AMD
 * Arseny Kapoulkine, Roblox
 * François Duranleau, Gameloft
 * Stuart Smith, AMD
 * Hai Nguyen, Google
 * Jean-François Roy, Google
 * Jeff Leger, Qualcomm
 * Jan-Harald Fredriksen, Arm
 * Piers Daniell, Nvidia
 * James Fitzpatrick, Imagination
 * Piotr Byszewski, Mobica
 * Jesse Hall, Google
 * Mike Blumenkrantz, Valve
 * 
 * 
 */
public class KHRDynamicRendering {

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

    /** The extension name. */
    public static final String VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME = "VK_KHR_dynamic_rendering";

    /**
     * Extends {@code VkStructureType}.
     * 
     * Enum values:
     * 
     * 
     * {@link #VK_STRUCTURE_TYPE_RENDERING_INFO_KHR STRUCTURE_TYPE_RENDERING_INFO_KHR}
     * {@link #VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR}
     * {@link #VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR}
     * {@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR}
     * {@link #VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_RENDERING_INFO_KHR                             = 1000044000,
        VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR                  = 1000044001,
        VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR             = 1000044002,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR = 1000044003,
        VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR  = 1000044004;

    /** Extends {@code VkAttachmentStoreOp}. */
    public static final int VK_ATTACHMENT_STORE_OP_NONE_KHR = 1000301000;

    /** Extends {@code VkPipelineCreateFlagBits}. */
    public static final int VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x200000;

    /** Extends {@code VkStructureType}. */
    public static final int VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006;

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

    /** Extends {@code VkStructureType}. */
    public static final int VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT = 1000044007;

    /** Extends {@code VkStructureType}. */
    public static final int VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008;

    /** Extends {@code VkStructureType}. */
    public static final int VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV = 1000044008;

    /** Extends {@code VkStructureType}. */
    public static final int VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX = 1000044009;

    /**
     * VkRenderingFlagBitsKHR - Bitmask specifying additional properties of a dynamic render pass instance
     * 
     * Description
     * 
     * 
     * {@link #VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR} specifies that draw calls for the render pass instance will be recorded in secondary command buffers.
     * {@link #VK_RENDERING_RESUMING_BIT_KHR RENDERING_RESUMING_BIT_KHR} specifies that the render pass instance is resuming an earlier suspended render pass instance.
     * {@link #VK_RENDERING_SUSPENDING_BIT_KHR RENDERING_SUSPENDING_BIT_KHR} specifies that the render pass instance will be suspended.
     * 
     * 
     * The contents of {@code pRenderingInfo} must match between suspended render pass instances and the render pass instances that resume them, other than the presence or absence of the {@link #VK_RENDERING_RESUMING_BIT_KHR RENDERING_RESUMING_BIT_KHR}, {@link #VK_RENDERING_SUSPENDING_BIT_KHR RENDERING_SUSPENDING_BIT_KHR}, and {@link #VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR} flags. No action or synchronization commands, or other render pass instances, are allowed between suspending and resuming render pass instances.
     */
    public static final int
        VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = 0x1,
        VK_RENDERING_SUSPENDING_BIT_KHR                         = 0x2,
        VK_RENDERING_RESUMING_BIT_KHR                           = 0x4;

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

    // --- [ vkCmdBeginRenderingKHR ] ---

    /** Unsafe version of: {@link #vkCmdBeginRenderingKHR CmdBeginRenderingKHR} */
    public static void nvkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, long pRenderingInfo) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdBeginRenderingKHR;
        if (CHECKS) {
            check(__functionAddress);
            VkRenderingInfoKHR.validate(pRenderingInfo);
        }
        callPPV(commandBuffer.address(), pRenderingInfo, __functionAddress);
    }

    /**
     * Begin a dynamic render pass instance.
     * 
     * C Specification
     * 
     * To begin a render pass instance, call:
     * 
     * 
     * void vkCmdBeginRenderingKHR(
     *     VkCommandBuffer                             commandBuffer,
     *     const VkRenderingInfoKHR*                   pRenderingInfo);
     * 
     * Description
     * 
     * After beginning a render pass instance, the command buffer is ready to record draw commands.
     * 
     * If {@code pRenderingInfo→flags} includes {@link #VK_RENDERING_RESUMING_BIT_KHR RENDERING_RESUMING_BIT_KHR} then this render pass is resumed from a render pass instance that has been suspended earlier in submission order.
     * 
     * Valid Usage
     * 
     * 
     * The {@code dynamicRendering} feature must be enabled
     * If {@code commandBuffer} is a secondary command buffer, {@code pRenderingInfo→flags} must not include {@link #VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR}
     * 
     * 
     * Valid Usage (Implicit)
     * 
     * 
     * {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * {@code pRenderingInfo} must be a valid pointer to a valid {@link VkRenderingInfoKHR} 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 VkRenderingInfoKHR}
     *
     * @param commandBuffer  the command buffer in which to record the command.
     * @param pRenderingInfo a pointer to a {@link VkRenderingInfoKHR} structure specifying details of the render pass instance to begin.
     */
    public static void vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, @NativeType("VkRenderingInfoKHR const *") VkRenderingInfoKHR pRenderingInfo) {
        nvkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo.address());
    }

    // --- [ vkCmdEndRenderingKHR ] ---

    /**
     * End a dynamic render pass instance.
     * 
     * C Specification
     * 
     * To end a render pass instance, call:
     * 
     * 
     * void vkCmdEndRenderingKHR(
     *     VkCommandBuffer                             commandBuffer);
     * 
     * Description
     * 
     * If the value of {@code pRenderingInfo→flags} used to begin this render pass instance included {@link #VK_RENDERING_SUSPENDING_BIT_KHR RENDERING_SUSPENDING_BIT_KHR}, then this render pass is suspended and will be resumed later in submission order.
     * 
     * Valid Usage
     * 
     * 
     * The current render pass instance must have been begun with {@link #vkCmdBeginRenderingKHR CmdBeginRenderingKHR}
     * The current render pass instance must have been begun in {@code commandBuffer}
     * 
     * 
     * Valid Usage (Implicit)
     * 
     * 
     * {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * {@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 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
Primary Secondary Inside Graphics
     *
     * @param commandBuffer the command buffer in which to record the command.
     */
    public static void vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdEndRenderingKHR;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPV(commandBuffer.address(), __functionAddress);
    }

}