org.lwjgl.vulkan.EXTConditionalRendering 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 the execution of one or more rendering commands to be conditional on a value in buffer memory. This may help an application reduce the latency by conditionally discarding rendering commands without application intervention. The conditional rendering commands are limited to draws, compute dispatches and clearing attachments within a conditional rendering block.
 * 
 * Examples
 * 
 * None.
 * 
 * VK_EXT_conditional_rendering
 * 
 * 
 * Name String
 * {@code VK_EXT_conditional_rendering}
 * Extension Type
 * Device extension
 * Registered Extension Number
 * 82
 * Revision
 * 2
 * Extension and Version Dependencies
 * 
 * Requires Vulkan 1.0
 * 
 * Contact
 * 
 * Vikram Kushwaha vkushwaha
 * 
 * 
 * 
 * Other Extension Metadata
 * 
 * 
 * Last Modified Date
 * 2018-05-21
 * IP Status
 * No known IP claims.
 * Contributors
 * 
 * Vikram Kushwaha, NVIDIA
 * Daniel Rakos, AMD
 * Jesse Hall, Google
 * Jeff Bolz, NVIDIA
 * Piers Daniell, NVIDIA
 * Stuart Smith, Imagination Technologies
 * 
 * 
 */
public class EXTConditionalRendering {

    /** The extension specification version. */
    public static final int VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION = 2;

    /** The extension name. */
    public static final String VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME = "VK_EXT_conditional_rendering";

    /**
     * Extends {@code VkStructureType}.
     * 
     * Enum values:
     * 
     * 
     * {@link #VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT}
     * {@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT}
     * {@link #VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT        = 1000081001,
        VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT                      = 1000081002;

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

    /** Extends {@code VkBufferUsageFlagBits}. */
    public static final int VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x200;

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

    /**
     * VkConditionalRenderingFlagBitsEXT - Specify the behavior of conditional rendering
     * 
     * Description
     * 
     * 
     * {@link #VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT CONDITIONAL_RENDERING_INVERTED_BIT_EXT} specifies the condition used to determine whether to discard rendering commands or not. That is, if the 32-bit predicate read from {@code buffer} memory at {@code offset} is zero, the rendering commands are not discarded, and if non zero, then they are discarded.
     * 
     */
    public static final int VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x1;

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

    // --- [ vkCmdBeginConditionalRenderingEXT ] ---

    /** Unsafe version of: {@link #vkCmdBeginConditionalRenderingEXT CmdBeginConditionalRenderingEXT} */
    public static void nvkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, long pConditionalRenderingBegin) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdBeginConditionalRenderingEXT;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPV(commandBuffer.address(), pConditionalRenderingBegin, __functionAddress);
    }

    /**
     * Define the beginning of a conditional rendering block.
     * 
     * C Specification
     * 
     * To begin conditional rendering, call:
     * 
     * 
     * void vkCmdBeginConditionalRenderingEXT(
     *     VkCommandBuffer                             commandBuffer,
     *     const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin);
     * 
     * Valid Usage
     * 
     * 
     * Conditional rendering must not already be active
     * 
     * 
     * Valid Usage (Implicit)
     * 
     * 
     * {@code commandBuffer} must be a valid {@code VkCommandBuffer} handle
     * {@code pConditionalRenderingBegin} must be a valid pointer to a valid {@link VkConditionalRenderingBeginInfoEXT} structure
     * {@code commandBuffer} must be in the recording state
     * The {@code VkCommandPool} that {@code commandBuffer} was allocated from must support graphics, or compute 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 Compute
     * 
     * See Also
     * 
     * {@link VkConditionalRenderingBeginInfoEXT}
     *
     * @param commandBuffer              the command buffer into which this command will be recorded.
     * @param pConditionalRenderingBegin a pointer to a {@link VkConditionalRenderingBeginInfoEXT} structure specifying parameters of conditional rendering.
     */
    public static void vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, @NativeType("VkConditionalRenderingBeginInfoEXT const *") VkConditionalRenderingBeginInfoEXT pConditionalRenderingBegin) {
        nvkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin.address());
    }

    // --- [ vkCmdEndConditionalRenderingEXT ] ---

    /**
     * Define the end of a conditional rendering block.
     * 
     * C Specification
     * 
     * To end conditional rendering, call:
     * 
     * 
     * void vkCmdEndConditionalRenderingEXT(
     *     VkCommandBuffer                             commandBuffer);
     * 
     * Description
     * 
     * Once ended, conditional rendering becomes inactive.
     * 
     * Valid Usage
     * 
     * 
     * Conditional rendering must be active
     * If conditional rendering was made active outside of a render pass instance, it must not be ended inside a render pass instance
     * If conditional rendering was made active within a subpass it must be ended in the same subpass
     * 
     * 
     * 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, or compute 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 Compute
     *
     * @param commandBuffer the command buffer into which this command will be recorded.
     */
    public static void vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) {
        long __functionAddress = commandBuffer.getCapabilities().vkCmdEndConditionalRenderingEXT;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPV(commandBuffer.address(), __functionAddress);
    }

}