org.lwjgl.vulkan.KHRTimelineSemaphore 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 java.nio.*;

import org.lwjgl.system.*;

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

/**
 * This extension introduces a new type of semaphore that has an integer payload identifying a point in a timeline. Such timeline semaphores support the following operations:
 * 
 * 
 * Host query - A host operation that allows querying the payload of the timeline semaphore.
 * Host wait - A host operation that allows a blocking wait for a timeline semaphore to reach a specified value.
 * Host signal - A host operation that allows advancing the timeline semaphore to a specified value.
 * Device wait - A device operation that allows waiting for a timeline semaphore to reach a specified value.
 * Device signal - A device operation that allows advancing the timeline semaphore to a specified value.
 * 
 * 
 * Promotion to Vulkan 1.2
 * 
 * All functionality in this extension is included in core Vulkan 1.2, with the KHR suffix omitted. The original type, enum and command names are still available as aliases of the core functionality.
 * 
 * VK_KHR_timeline_semaphore
 * 
 * 
 * Name String
 * {@code VK_KHR_timeline_semaphore}
 * Extension Type
 * Device extension
 * Registered Extension Number
 * 208
 * Revision
 * 2
 * Extension and Version Dependencies
 * 
 * Requires Vulkan 1.0
 * Requires {@link KHRGetPhysicalDeviceProperties2 VK_KHR_get_physical_device_properties2}
 * 
 * Deprecation state
 * 
 * Promoted to Vulkan 1.2
 * 
 * Contact
 * 
 * Jason Ekstrand jekstrand
 * 
 * 
 * 
 * Other Extension Metadata
 * 
 * 
 * Last Modified Date
 * 2019-06-12
 * IP Status
 * No known IP claims.
 * Interactions and External Dependencies
 * 
 * This extension interacts with {@link KHRExternalSemaphoreCapabilities VK_KHR_external_semaphore_capabilities}
 * This extension interacts with {@link KHRExternalSemaphore VK_KHR_external_semaphore}
 * This extension interacts with {@link KHRExternalSemaphoreWin32 VK_KHR_external_semaphore_win32}
 * Promoted to Vulkan 1.2 Core
 * 
 * Contributors
 * 
 * Jeff Bolz, NVIDIA
 * Yuriy O’Donnell, Epic Games
 * Jason Ekstrand, Intel
 * Jesse Hall, Google
 * James Jones, NVIDIA
 * Jeff Juliano, NVIDIA
 * Daniel Rakos, AMD
 * Ray Smith, Arm
 * 
 * 
 */
public class KHRTimelineSemaphore {

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

    /** The extension name. */
    public static final String VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME = "VK_KHR_timeline_semaphore";

    /**
     * Extends {@code VkStructureType}.
     * 
     * Enum values:
     * 
     * 
     * {@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR}
     * {@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR}
     * {@link #VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR}
     * {@link #VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR}
     * {@link #VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR}
     * {@link #VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR   = 1000207000,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = 1000207001,
        VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR                    = 1000207002,
        VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR                = 1000207003,
        VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR                           = 1000207004,
        VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR                         = 1000207005;

    /**
     * Extends {@code VkSemaphoreType}.
     * 
     * Enum values:
     * 
     * 
     * {@link #VK_SEMAPHORE_TYPE_BINARY_KHR SEMAPHORE_TYPE_BINARY_KHR}
     * {@link #VK_SEMAPHORE_TYPE_TIMELINE_KHR SEMAPHORE_TYPE_TIMELINE_KHR}
     * 
     */
    public static final int
        VK_SEMAPHORE_TYPE_BINARY_KHR   = 0,
        VK_SEMAPHORE_TYPE_TIMELINE_KHR = 1;

    /** Extends {@code VkSemaphoreWaitFlagBits}. */
    public static final int VK_SEMAPHORE_WAIT_ANY_BIT_KHR = 0x1;

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

    // --- [ vkGetSemaphoreCounterValueKHR ] ---

    /** Unsafe version of: {@link #vkGetSemaphoreCounterValueKHR GetSemaphoreCounterValueKHR} */
    public static int nvkGetSemaphoreCounterValueKHR(VkDevice device, long semaphore, long pValue) {
        long __functionAddress = device.getCapabilities().vkGetSemaphoreCounterValueKHR;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPJPI(device.address(), semaphore, pValue, __functionAddress);
    }

    /**
     * See {@link VK12#vkGetSemaphoreCounterValue GetSemaphoreCounterValue}.
     *
     * @param device    the logical device that owns the semaphore.
     * @param semaphore the handle of the semaphore to query.
     * @param pValue    a pointer to a 64-bit integer value in which the current counter value of the semaphore is returned.
     */
    @NativeType("VkResult")
    public static int vkGetSemaphoreCounterValueKHR(VkDevice device, @NativeType("VkSemaphore") long semaphore, @NativeType("uint64_t *") LongBuffer pValue) {
        if (CHECKS) {
            check(pValue, 1);
        }
        return nvkGetSemaphoreCounterValueKHR(device, semaphore, memAddress(pValue));
    }

    // --- [ vkWaitSemaphoresKHR ] ---

    /** Unsafe version of: {@link #vkWaitSemaphoresKHR WaitSemaphoresKHR} */
    public static int nvkWaitSemaphoresKHR(VkDevice device, long pWaitInfo, long timeout) {
        long __functionAddress = device.getCapabilities().vkWaitSemaphoresKHR;
        if (CHECKS) {
            check(__functionAddress);
            VkSemaphoreWaitInfo.validate(pWaitInfo);
        }
        return callPPJI(device.address(), pWaitInfo, timeout, __functionAddress);
    }

    /**
     * See {@link VK12#vkWaitSemaphores WaitSemaphores}.
     *
     * @param device    the logical device that owns the semaphores.
     * @param pWaitInfo a pointer to a {@link VkSemaphoreWaitInfo} structure containing information about the wait condition.
     * @param timeout   the timeout period in units of nanoseconds. {@code timeout} is adjusted to the closest value allowed by the implementation-dependent timeout accuracy, which may be substantially longer than one nanosecond, and may be longer than the requested period.
     */
    @NativeType("VkResult")
    public static int vkWaitSemaphoresKHR(VkDevice device, @NativeType("VkSemaphoreWaitInfo const *") VkSemaphoreWaitInfo pWaitInfo, @NativeType("uint64_t") long timeout) {
        return nvkWaitSemaphoresKHR(device, pWaitInfo.address(), timeout);
    }

    // --- [ vkSignalSemaphoreKHR ] ---

    /** Unsafe version of: {@link #vkSignalSemaphoreKHR SignalSemaphoreKHR} */
    public static int nvkSignalSemaphoreKHR(VkDevice device, long pSignalInfo) {
        long __functionAddress = device.getCapabilities().vkSignalSemaphoreKHR;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPI(device.address(), pSignalInfo, __functionAddress);
    }

    /**
     * See {@link VK12#vkSignalSemaphore SignalSemaphore}.
     *
     * @param device      the logical device that owns the semaphore.
     * @param pSignalInfo a pointer to a {@link VkSemaphoreSignalInfo} structure containing information about the signal operation.
     */
    @NativeType("VkResult")
    public static int vkSignalSemaphoreKHR(VkDevice device, @NativeType("VkSemaphoreSignalInfo const *") VkSemaphoreSignalInfo pSignalInfo) {
        return nvkSignalSemaphoreKHR(device, pSignalInfo.address());
    }

    /** Array version of: {@link #vkGetSemaphoreCounterValueKHR GetSemaphoreCounterValueKHR} */
    @NativeType("VkResult")
    public static int vkGetSemaphoreCounterValueKHR(VkDevice device, @NativeType("VkSemaphore") long semaphore, @NativeType("uint64_t *") long[] pValue) {
        long __functionAddress = device.getCapabilities().vkGetSemaphoreCounterValueKHR;
        if (CHECKS) {
            check(__functionAddress);
            check(pValue, 1);
        }
        return callPJPI(device.address(), semaphore, pValue, __functionAddress);
    }

}