org.lwjgl.vulkan.NVXImageViewHandle 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 query an opaque handle from an image view for use as a sampled image or storage image. This provides no direct functionality itself.
 * 
 * VK_NVX_image_view_handle
 * 
 * 
 * Name String
 * {@code VK_NVX_image_view_handle}
 * Extension Type
 * Device extension
 * Registered Extension Number
 * 31
 * Revision
 * 2
 * Extension and Version Dependencies
 * 
 * Requires Vulkan 1.0
 * 
 * Contact
 * 
 * Eric Werness ewerness-nv
 * 
 * 
 * 
 * Other Extension Metadata
 * 
 * 
 * Last Modified Date
 * 2020-04-03
 * Contributors
 * 
 * Eric Werness, NVIDIA
 * Jeff Bolz, NVIDIA
 * Daniel Koch, NVIDIA
 * 
 * 
 */
public class NVXImageViewHandle {

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

    /** The extension name. */
    public static final String VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME = "VK_NVX_image_view_handle";

    /**
     * Extends {@code VkStructureType}.
     * 
     * Enum values:
     * 
     * 
     * {@link #VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX}
     * {@link #VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX        = 1000030000,
        VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001;

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

    // --- [ vkGetImageViewHandleNVX ] ---

    /** Unsafe version of: {@link #vkGetImageViewHandleNVX GetImageViewHandleNVX} */
    public static int nvkGetImageViewHandleNVX(VkDevice device, long pInfo) {
        long __functionAddress = device.getCapabilities().vkGetImageViewHandleNVX;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPI(device.address(), pInfo, __functionAddress);
    }

    /**
     * Get the handle for an image view for a specific descriptor type.
     * 
     * C Specification
     * 
     * To get the handle for an image view, call:
     * 
     * 
     * uint32_t vkGetImageViewHandleNVX(
     *     VkDevice                                    device,
     *     const VkImageViewHandleInfoNVX*             pInfo);
     * 
     * Valid Usage (Implicit)
     * 
     * 
     * {@code device} must be a valid {@code VkDevice} handle
     * {@code pInfo} must be a valid pointer to a valid {@link VkImageViewHandleInfoNVX} structure
     * 
     * 
     * See Also
     * 
     * {@link VkImageViewHandleInfoNVX}
     *
     * @param device the logical device that owns the image view.
     * @param pInfo  describes the image view to query and type of handle.
     */
    @NativeType("uint32_t")
    public static int vkGetImageViewHandleNVX(VkDevice device, @NativeType("VkImageViewHandleInfoNVX const *") VkImageViewHandleInfoNVX pInfo) {
        return nvkGetImageViewHandleNVX(device, pInfo.address());
    }

    // --- [ vkGetImageViewAddressNVX ] ---

    /** Unsafe version of: {@link #vkGetImageViewAddressNVX GetImageViewAddressNVX} */
    public static int nvkGetImageViewAddressNVX(VkDevice device, long imageView, long pProperties) {
        long __functionAddress = device.getCapabilities().vkGetImageViewAddressNVX;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPJPI(device.address(), imageView, pProperties, __functionAddress);
    }

    /**
     * Get the device address of an image view.
     * 
     * C Specification
     * 
     * To get the device address for an image view, call:
     * 
     * 
     * VkResult vkGetImageViewAddressNVX(
     *     VkDevice                                    device,
     *     VkImageView                                 imageView,
     *     VkImageViewAddressPropertiesNVX*            pProperties);
     * 
     * Valid Usage (Implicit)
     * 
     * 
     * {@code device} must be a valid {@code VkDevice} handle
     * {@code imageView} must be a valid {@code VkImageView} handle
     * {@code pProperties} must be a valid pointer to a {@link VkImageViewAddressPropertiesNVX} structure
     * {@code imageView} must have been created, allocated, or retrieved from {@code device}
     * 
     * 
     * Return Codes
     * 
     * 
     * On success, this command returns
     * 
     * {@link VK10#VK_SUCCESS SUCCESS}
     * 
     * On failure, this command returns
     * 
     * {@link VK10#VK_ERROR_OUT_OF_HOST_MEMORY ERROR_OUT_OF_HOST_MEMORY}
     * {@link VK10#VK_ERROR_UNKNOWN ERROR_UNKNOWN}
     * 
     * 
     * 
     * See Also
     * 
     * {@link VkImageViewAddressPropertiesNVX}
     *
     * @param device      the logical device that owns the image view.
     * @param imageView   a handle to the image view.
     * @param pProperties contains the device address and size when the call returns.
     */
    @NativeType("VkResult")
    public static int vkGetImageViewAddressNVX(VkDevice device, @NativeType("VkImageView") long imageView, @NativeType("VkImageViewAddressPropertiesNVX *") VkImageViewAddressPropertiesNVX pProperties) {
        return nvkGetImageViewAddressNVX(device, imageView, pProperties.address());
    }

}