All Downloads are FREE. Search and download functionalities are using the official Maven repository.

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

Go to download

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.*;

/**
 * An application may wish to reference device fences in multiple Vulkan logical devices or instances, in multiple processes, and/or in multiple APIs. This extension provides a set of capability queries and handle definitions that allow an application to determine what types of "{@code external}" fence handles an implementation supports for a given set of use cases.
 * 
 * 

 * 
Name String

 * 
{@code VK_KHR_external_fence_capabilities}

 * 
Extension Type

 * 
Instance extension

 * 
Registered Extension Number

 * 
113

 * 
Revision

 * 
1

 * 
Extension and Version Dependencies

 * 

 * 
Contact

 * 
    
 * 
  • Jesse Hall @jessehall
    • 
 * 

 * 
Last Modified Date

 * 
2017-05-08

 * 
IP Status

 * 
No known IP claims.

 * 
Contributors

 * 

 * 

 */
public class KHRExternalFenceCapabilities {

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

    /** The extension name. */
    public static final String VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME = "VK_KHR_external_fence_capabilities";

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

     * 
     * 
    
     * 
  • {@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR}
    • 
     * 
  • {@link #VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR}
    • 
     * 

     */
    public static final int
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = 1000112000,
        VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR           = 1000112001;

    /** VK_LUID_SIZE_KHR */
    public static final int VK_LUID_SIZE_KHR = 8;

    /**
     * VkExternalFenceHandleTypeFlagBitsKHR - Bitmask of valid external fence handle types
     * 
     * 
Description

     * 
     * 
    
     * 
  • {@link #VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR} indicates a POSIX file descriptor handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the POSIX system calls {@code dup}, {@code dup2}, {@code close}, and the non-standard system call {@code dup3}. Additionally, it must be transportable over a socket using an {@code SCM_RIGHTS} control message. It owns a reference to the underlying synchronization primitive represented by its Vulkan fence object.
    • 
     * 
  • {@link #VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR} indicates an NT handle that has only limited valid usage outside of Vulkan and other compatible APIs. It must be compatible with the functions {@code DuplicateHandle}, {@code CloseHandle}, {@code CompareObjectHandles}, {@code GetHandleInformation}, and {@code SetHandleInformation}. It owns a reference to the underlying synchronization primitive represented by its Vulkan fence object.
    • 
     * 
  • {@link #VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR} indicates a global share handle that has only limited valid usage outside of Vulkan and other compatible APIs. It is not compatible with any native APIs. It does not own a reference to the underlying synchronization primitive represented by its Vulkan fence object, and will therefore become invalid when all Vulkan fence objects associated with it are destroyed.
    • 
     * 
  • {@link #VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR} indicates a POSIX file descriptor handle to a Linux Sync File or Android Fence. It can be used with any native API accepting a valid sync file or fence as input. It owns a reference to the underlying synchronization primitive associated with the file descriptor. Implementations which support importing this handle type must accept any type of sync or fence FD supported by the native system they are running on.
    • 
     * 

     * 
     * 
Some external fence handle types can only be shared within the same underlying physical device and/or the same driver version, as defined in the following table:

     * 
     * 
External fence handle types compatibility

     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
     * 
Handle type{@link VkPhysicalDeviceIDPropertiesKHR}{@code ::driverUUID}{@link VkPhysicalDeviceIDPropertiesKHR}{@code ::deviceUUID}
{@link #VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR}Must matchMust match
{@link #VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR}Must matchMust match
{@link #VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR}Must matchMust match
{@link #VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR}No restrictionNo restriction

     * 
     * 
See Also

     * 
     * 
{@code VkExternalFenceHandleTypeFlagsKHR}, {@link VkFenceGetFdInfoKHR}, {@link VkFenceGetWin32HandleInfoKHR}, {@link VkImportFenceFdInfoKHR}, {@link VkImportFenceWin32HandleInfoKHR}, {@link VkPhysicalDeviceExternalFenceInfoKHR}

     */
    public static final int
        VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR        = 0x1,
        VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR     = 0x2,
        VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x4,
        VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR          = 0x8;

    /**
     * VkExternalFenceFeatureFlagBitsKHR - Bitfield describing features of an external fence handle type
     * 
     * 
Description

     * 
     * 
    
     * 
  • {@link #VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR} indicates handles of this type can be exported from Vulkan fence objects.
    • 
     * 
  • {@link #VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR} indicates handles of this type can be imported to Vulkan fence objects.
    • 
     * 

     * 
     * 
See Also

     * 
     * 
{@code VkExternalFenceFeatureFlagsKHR}

     */
    public static final int
        VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = 0x1,
        VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = 0x2;

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

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

    // --- [ vkGetPhysicalDeviceExternalFencePropertiesKHR ] ---

    /** Unsafe version of: {@link #vkGetPhysicalDeviceExternalFencePropertiesKHR GetPhysicalDeviceExternalFencePropertiesKHR} */
    public static void nvkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, long pExternalFenceInfo, long pExternalFenceProperties) {
        long __functionAddress = physicalDevice.getCapabilities().vkGetPhysicalDeviceExternalFencePropertiesKHR;
        if (CHECKS) {
            check(__functionAddress);
        }
        callPPPV(__functionAddress, physicalDevice.address(), pExternalFenceInfo, pExternalFenceProperties);
    }

    /**
     * Function for querying external fence handle capabilities.
     * 
     * 
C Specification

     * 
     * 
Fences may support import and export of their payload to external handles. To query the external handle types supported by fences, call:

     * 
     * 
     * void vkGetPhysicalDeviceExternalFencePropertiesKHR(
     *     VkPhysicalDevice                            physicalDevice,
     *     const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo,
     *     VkExternalFencePropertiesKHR*               pExternalFenceProperties);

     * 
     * 
Valid Usage (Implicit)

     * 
     * 
    
     * 
  • {@code physicalDevice} must be a valid {@code VkPhysicalDevice} handle
    • 
     * 
  • {@code pExternalFenceInfo} must be a pointer to a valid {@link VkPhysicalDeviceExternalFenceInfoKHR} structure
    • 
     * 
  • {@code pExternalFenceProperties} must be a pointer to a {@link VkExternalFencePropertiesKHR} structure
    • 
     * 

     * 
     * 
See Also

     * 
     * 
{@link VkExternalFencePropertiesKHR}, {@link VkPhysicalDeviceExternalFenceInfoKHR}

     *
     * @param physicalDevice           the physical device from which to query the fence capabilities.
     * @param pExternalFenceInfo       points to an instance of the {@link VkPhysicalDeviceExternalFenceInfoKHR} structure, describing the parameters that would be consumed by {@link VK10#vkCreateFence CreateFence}.
     * @param pExternalFenceProperties points to an instance of the {@link VkExternalFencePropertiesKHR} structure in which capabilities are returned.
     */
    public static void vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, @NativeType("const VkPhysicalDeviceExternalFenceInfoKHR *") VkPhysicalDeviceExternalFenceInfoKHR pExternalFenceInfo, @NativeType("VkExternalFencePropertiesKHR *") VkExternalFencePropertiesKHR pExternalFenceProperties) {
        nvkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo.address(), pExternalFenceProperties.address());
    }

}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy