org.lwjgl.vulkan.KHRMaintenance4 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.6
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 javax.annotation.*;

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

/**
 * {@code VK_KHR_maintenance4} adds a collection of minor features, none of which would warrant an entire extension of their own.
 * 
 * The new features are as follows:
 * 
 * 
 * Allow the application to destroy their {@code VkPipelineLayout} object immediately after it was used to create another object. It is no longer necessary to keep its handle valid while the created object is in use.
 * Add a new {@code maxBufferSize} implementation-defined limit for the maximum size {@code VkBuffer} that can be created.
 * Add support for the SPIR-V 1.2 {@code LocalSizeId} execution mode, which can be used as an alternative to {@code LocalSize} to specify the local workgroup size with specialization constants.
 * Add a guarantee that images created with identical creation parameters will always have the same alignment requirements.
 * Add new {@link #vkGetDeviceBufferMemoryRequirementsKHR GetDeviceBufferMemoryRequirementsKHR}, {@link #vkGetDeviceImageMemoryRequirementsKHR GetDeviceImageMemoryRequirementsKHR}, and {@link #vkGetDeviceImageSparseMemoryRequirementsKHR GetDeviceImageSparseMemoryRequirementsKHR} to allow the application to query the image memory requirements without having to create an image object and query it.
 * Relax the requirement that push constants must be initialized before they are dynamically accessed.
 * Relax the interface matching rules to allow a larger output vector to match with a smaller input vector, with additional values being discarded.
 * 
 * 
 * VK_KHR_maintenance4
 * 
 * 
 * Name String
 * {@code VK_KHR_maintenance4}
 * Extension Type
 * Device extension
 * Registered Extension Number
 * 414
 * Revision
 * 1
 * Extension and Version Dependencies
 * 
 * Requires Vulkan 1.1
 * 
 * Contact
 * 
 * Piers Daniell pdaniell-nv
 * 
 * 
 * 
 * Other Extension Metadata
 * 
 * 
 * Last Modified Date
 * 2021-08-18
 * Interactions and External Dependencies
 * 
 * Requires SPIR-V 1.2 for {@code LocalSizeId}
 * 
 * Contributors
 * 
 * Lionel Duc, NVIDIA
 * Jason Ekstrand, Intel
 * Spencer Fricke, Samsung
 * Tobias Hector, AMD
 * Lionel Landwerlin, Intel
 * Graeme Leese, Broadcom
 * Tom Olson, Arm
 * Stu Smith, AMD
 * 
 * 
 */
public class KHRMaintenance4 {

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

    /** The extension name. */
    public static final String VK_KHR_MAINTENANCE_4_EXTENSION_NAME = "VK_KHR_maintenance4";

    /**
     * Extends {@code VkStructureType}.
     * 
     * Enum values:
     * 
     * 
     * {@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR}
     * {@link #VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR}
     * {@link #VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR}
     * {@link #VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR}
     * 
     */
    public static final int
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR   = 1000413000,
        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR = 1000413001,
        VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR        = 1000413002,
        VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR         = 1000413003;

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

    // --- [ vkGetDeviceBufferMemoryRequirementsKHR ] ---

    /** Unsafe version of: {@link #vkGetDeviceBufferMemoryRequirementsKHR GetDeviceBufferMemoryRequirementsKHR} */
    public static void nvkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, long pInfo, long pMemoryRequirements) {
        long __functionAddress = device.getCapabilities().vkGetDeviceBufferMemoryRequirementsKHR;
        if (CHECKS) {
            check(__functionAddress);
            VkDeviceBufferMemoryRequirementsKHR.validate(pInfo);
        }
        callPPPV(device.address(), pInfo, pMemoryRequirements, __functionAddress);
    }

    /**
     * Returns the memory requirements for specified Vulkan object.
     * 
     * C Specification
     * 
     * To determine the memory requirements for a buffer resource without creating an object, call:
     * 
     * 
     * void vkGetDeviceBufferMemoryRequirementsKHR(
     *     VkDevice                                    device,
     *     const VkDeviceBufferMemoryRequirementsKHR*  pInfo,
     *     VkMemoryRequirements2*                      pMemoryRequirements);
     * 
     * Valid Usage (Implicit)
     * 
     * 
     * {@code device} must be a valid {@code VkDevice} handle
     * {@code pInfo} must be a valid pointer to a valid {@link VkDeviceBufferMemoryRequirementsKHR} structure
     * {@code pMemoryRequirements} must be a valid pointer to a {@link VkMemoryRequirements2} structure
     * 
     * 
     * See Also
     * 
     * {@link VkDeviceBufferMemoryRequirementsKHR}, {@link VkMemoryRequirements2}
     *
     * @param device              the logical device intended to own the buffer.
     * @param pInfo               a pointer to a {@link VkDeviceBufferMemoryRequirementsKHR} structure containing parameters required for the memory requirements query.
     * @param pMemoryRequirements a pointer to a {@link VkMemoryRequirements2} structure in which the memory requirements of the buffer object are returned.
     */
    public static void vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, @NativeType("VkDeviceBufferMemoryRequirementsKHR const *") VkDeviceBufferMemoryRequirementsKHR pInfo, @NativeType("VkMemoryRequirements2 *") VkMemoryRequirements2 pMemoryRequirements) {
        nvkGetDeviceBufferMemoryRequirementsKHR(device, pInfo.address(), pMemoryRequirements.address());
    }

    // --- [ vkGetDeviceImageMemoryRequirementsKHR ] ---

    /** Unsafe version of: {@link #vkGetDeviceImageMemoryRequirementsKHR GetDeviceImageMemoryRequirementsKHR} */
    public static void nvkGetDeviceImageMemoryRequirementsKHR(VkDevice device, long pInfo, long pMemoryRequirements) {
        long __functionAddress = device.getCapabilities().vkGetDeviceImageMemoryRequirementsKHR;
        if (CHECKS) {
            check(__functionAddress);
            VkDeviceImageMemoryRequirementsKHR.validate(pInfo);
        }
        callPPPV(device.address(), pInfo, pMemoryRequirements, __functionAddress);
    }

    /**
     * Returns the memory requirements for specified Vulkan object.
     * 
     * C Specification
     * 
     * To determine the memory requirements for an image resource without creating an object, call:
     * 
     * 
     * void vkGetDeviceImageMemoryRequirementsKHR(
     *     VkDevice                                    device,
     *     const VkDeviceImageMemoryRequirementsKHR*   pInfo,
     *     VkMemoryRequirements2*                      pMemoryRequirements);
     * 
     * Valid Usage (Implicit)
     * 
     * 
     * {@code device} must be a valid {@code VkDevice} handle
     * {@code pInfo} must be a valid pointer to a valid {@link VkDeviceImageMemoryRequirementsKHR} structure
     * {@code pMemoryRequirements} must be a valid pointer to a {@link VkMemoryRequirements2} structure
     * 
     * 
     * See Also
     * 
     * {@link VkDeviceImageMemoryRequirementsKHR}, {@link VkMemoryRequirements2}
     *
     * @param device              the logical device intended to own the image.
     * @param pInfo               a pointer to a {@link VkDeviceImageMemoryRequirementsKHR} structure containing parameters required for the memory requirements query.
     * @param pMemoryRequirements a pointer to a {@link VkMemoryRequirements2} structure in which the memory requirements of the image object are returned.
     */
    public static void vkGetDeviceImageMemoryRequirementsKHR(VkDevice device, @NativeType("VkDeviceImageMemoryRequirementsKHR const *") VkDeviceImageMemoryRequirementsKHR pInfo, @NativeType("VkMemoryRequirements2 *") VkMemoryRequirements2 pMemoryRequirements) {
        nvkGetDeviceImageMemoryRequirementsKHR(device, pInfo.address(), pMemoryRequirements.address());
    }

    // --- [ vkGetDeviceImageSparseMemoryRequirementsKHR ] ---

    /**
     * Unsafe version of: {@link #vkGetDeviceImageSparseMemoryRequirementsKHR GetDeviceImageSparseMemoryRequirementsKHR}
     *
     * @param pSparseMemoryRequirementCount a pointer to an integer related to the number of sparse memory requirements available or queried, as described below.
     */
    public static void nvkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, long pInfo, long pSparseMemoryRequirementCount, long pSparseMemoryRequirements) {
        long __functionAddress = device.getCapabilities().vkGetDeviceImageSparseMemoryRequirementsKHR;
        if (CHECKS) {
            check(__functionAddress);
            VkDeviceImageMemoryRequirementsKHR.validate(pInfo);
        }
        callPPPPV(device.address(), pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, __functionAddress);
    }

    /**
     * Query the memory requirements for a sparse image.
     * 
     * C Specification
     * 
     * To determine the sparse memory requirements for an image resource without creating an object, call:
     * 
     * 
     * void vkGetDeviceImageSparseMemoryRequirementsKHR(
     *     VkDevice                                    device,
     *     const VkDeviceImageMemoryRequirementsKHR*   pInfo,
     *     uint32_t*                                   pSparseMemoryRequirementCount,
     *     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
     * 
     * Valid Usage (Implicit)
     * 
     * 
     * {@code device} must be a valid {@code VkDevice} handle
     * {@code pInfo} must be a valid pointer to a valid {@link VkDeviceImageMemoryRequirementsKHR} structure
     * {@code pSparseMemoryRequirementCount} must be a valid pointer to a {@code uint32_t} value
     * If the value referenced by {@code pSparseMemoryRequirementCount} is not 0, and {@code pSparseMemoryRequirements} is not {@code NULL}, {@code pSparseMemoryRequirements} must be a valid pointer to an array of {@code pSparseMemoryRequirementCount} {@link VkSparseImageMemoryRequirements2} structures
     * 
     * 
     * See Also
     * 
     * {@link VkDeviceImageMemoryRequirementsKHR}, {@link VkSparseImageMemoryRequirements2}
     *
     * @param device                        the logical device intended to own the image.
     * @param pInfo                         a pointer to a {@link VkDeviceImageMemoryRequirementsKHR} structure containing parameters required for the memory requirements query.
     * @param pSparseMemoryRequirementCount a pointer to an integer related to the number of sparse memory requirements available or queried, as described below.
     * @param pSparseMemoryRequirements     either {@code NULL} or a pointer to an array of {@link VkSparseImageMemoryRequirements2} structures.
     */
    public static void vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, @NativeType("VkDeviceImageMemoryRequirementsKHR const *") VkDeviceImageMemoryRequirementsKHR pInfo, @NativeType("uint32_t *") IntBuffer pSparseMemoryRequirementCount, @Nullable @NativeType("VkSparseImageMemoryRequirements2 *") VkSparseImageMemoryRequirements2.Buffer pSparseMemoryRequirements) {
        if (CHECKS) {
            check(pSparseMemoryRequirementCount, 1);
            checkSafe(pSparseMemoryRequirements, pSparseMemoryRequirementCount.get(pSparseMemoryRequirementCount.position()));
        }
        nvkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo.address(), memAddress(pSparseMemoryRequirementCount), memAddressSafe(pSparseMemoryRequirements));
    }

    /** Array version of: {@link #vkGetDeviceImageSparseMemoryRequirementsKHR GetDeviceImageSparseMemoryRequirementsKHR} */
    public static void vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, @NativeType("VkDeviceImageMemoryRequirementsKHR const *") VkDeviceImageMemoryRequirementsKHR pInfo, @NativeType("uint32_t *") int[] pSparseMemoryRequirementCount, @Nullable @NativeType("VkSparseImageMemoryRequirements2 *") VkSparseImageMemoryRequirements2.Buffer pSparseMemoryRequirements) {
        long __functionAddress = device.getCapabilities().vkGetDeviceImageSparseMemoryRequirementsKHR;
        if (CHECKS) {
            check(__functionAddress);
            check(pSparseMemoryRequirementCount, 1);
            checkSafe(pSparseMemoryRequirements, pSparseMemoryRequirementCount[0]);
            VkDeviceImageMemoryRequirementsKHR.validate(pInfo.address());
        }
        callPPPPV(device.address(), pInfo.address(), pSparseMemoryRequirementCount, memAddressSafe(pSparseMemoryRequirements), __functionAddress);
    }

}