Java 类org.lwjgl.vulkan.VkApplicationInfo 实例源码

/**
 * Create a Vulkan instance using LWJGL 3.
 * 
 * @return the VkInstance handle
 */
private static VkInstance createInstance() {
    VkApplicationInfo appInfo = VkApplicationInfo.calloc()
            .sType(VK_STRUCTURE_TYPE_APPLICATION_INFO)
            .pApplicationName(memUTF8("AWT Vulkan Demo"))
            .pEngineName(memUTF8(""))
            .apiVersion(VK_MAKE_VERSION(1, 0, 2));
    ByteBuffer VK_KHR_SURFACE_EXTENSION = memUTF8(VK_KHR_SURFACE_EXTENSION_NAME);
    ByteBuffer VK_KHR_OS_SURFACE_EXTENSION;
    if (Platform.get() == Platform.WINDOWS)
        VK_KHR_OS_SURFACE_EXTENSION = memUTF8(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
    else
        VK_KHR_OS_SURFACE_EXTENSION = memUTF8(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
    PointerBuffer ppEnabledExtensionNames = memAllocPointer(2);
    ppEnabledExtensionNames.put(VK_KHR_SURFACE_EXTENSION);
    ppEnabledExtensionNames.put(VK_KHR_OS_SURFACE_EXTENSION);
    ppEnabledExtensionNames.flip();
    VkInstanceCreateInfo pCreateInfo = VkInstanceCreateInfo.calloc()
            .sType(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO)
            .pNext(0L)
            .pApplicationInfo(appInfo);
    if (ppEnabledExtensionNames.remaining() > 0) {
        pCreateInfo.ppEnabledExtensionNames(ppEnabledExtensionNames);
    }
    PointerBuffer pInstance = MemoryUtil.memAllocPointer(1);
    int err = vkCreateInstance(pCreateInfo, null, pInstance);
    if (err != VK_SUCCESS) {
        throw new RuntimeException("Failed to create VkInstance: " + translateVulkanResult(err));
    }
    long instance = pInstance.get(0);
    memFree(pInstance);
    VkInstance ret = new VkInstance(instance, pCreateInfo);
    memFree(ppEnabledExtensionNames);
    memFree(VK_KHR_OS_SURFACE_EXTENSION);
    memFree(VK_KHR_SURFACE_EXTENSION);
    appInfo.free();
    return ret;
}

private VkInstance createInstance(PointerBuffer requiredExtensions) {
    VkApplicationInfo appInfo = VkApplicationInfo.calloc()
            .sType(VK_STRUCTURE_TYPE_APPLICATION_INFO)
            .pApplicationName(memUTF8("GLFW Vulkan Demo"))
            .pEngineName(memUTF8(""))
            .apiVersion(VK_MAKE_VERSION(1, 0, 2));
    PointerBuffer ppEnabledExtensionNames = memAllocPointer(requiredExtensions.remaining() + 1);
    ppEnabledExtensionNames.put(requiredExtensions);
    ByteBuffer VK_EXT_DEBUG_REPORT_EXTENSION = memUTF8(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
    ppEnabledExtensionNames.put(VK_EXT_DEBUG_REPORT_EXTENSION);
    ppEnabledExtensionNames.flip();
    PointerBuffer ppEnabledLayerNames = memAllocPointer(layers.length);
    for (int i = 0; validation && i < layers.length; i++)
        ppEnabledLayerNames.put(layers[i]);
    ppEnabledLayerNames.flip();
    VkInstanceCreateInfo pCreateInfo = VkInstanceCreateInfo.calloc()
            .sType(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO)
            .pNext(0)
            .pApplicationInfo(appInfo)
            .ppEnabledExtensionNames(ppEnabledExtensionNames)
            .ppEnabledLayerNames(ppEnabledLayerNames);
    PointerBuffer pInstance = memAllocPointer(1);
    int err = vkCreateInstance(pCreateInfo, null, pInstance);
    long instance = pInstance.get(0);
    memFree(pInstance);
    if (err != VK_SUCCESS) {
        throw new AssertionError("Failed to create VkInstance: " + VKUtil.translateVulkanResult(err));
    }
    VkInstance ret = new VkInstance(instance, pCreateInfo);
    pCreateInfo.free();
    memFree(ppEnabledLayerNames);
    memFree(VK_EXT_DEBUG_REPORT_EXTENSION);
    memFree(ppEnabledExtensionNames);
    memFree(appInfo.pApplicationName());
    memFree(appInfo.pEngineName());
    appInfo.free();
    return ret;
}

/**
 * Create a Vulkan instance using LWJGL 3.
 * 
 * @return the VkInstance handle
 */
private static VkInstance createInstance() {
    VkApplicationInfo appInfo = VkApplicationInfo.calloc()
            .sType(VK_STRUCTURE_TYPE_APPLICATION_INFO)
            .pApplicationName(memUTF8("SWT Vulkan Demo"))
            .pEngineName(memUTF8(""))
            .apiVersion(VK_MAKE_VERSION(1, 0, 2));
    ByteBuffer VK_KHR_SURFACE_EXTENSION = memUTF8(VK_KHR_SURFACE_EXTENSION_NAME);
    ByteBuffer VK_KHR_OS_SURFACE_EXTENSION;
    if (Platform.get() == Platform.WINDOWS)
        VK_KHR_OS_SURFACE_EXTENSION = memUTF8(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
    else
        VK_KHR_OS_SURFACE_EXTENSION = memUTF8(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
    PointerBuffer ppEnabledExtensionNames = memAllocPointer(2);
    ppEnabledExtensionNames.put(VK_KHR_SURFACE_EXTENSION);
    ppEnabledExtensionNames.put(VK_KHR_OS_SURFACE_EXTENSION);
    ppEnabledExtensionNames.flip();
    VkInstanceCreateInfo pCreateInfo = VkInstanceCreateInfo.calloc()
            .sType(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO)
            .pNext(0L)
            .pApplicationInfo(appInfo);
    if (ppEnabledExtensionNames.remaining() > 0) {
        pCreateInfo.ppEnabledExtensionNames(ppEnabledExtensionNames);
    }
    PointerBuffer pInstance = MemoryUtil.memAllocPointer(1);
    int err = vkCreateInstance(pCreateInfo, null, pInstance);
    if (err != VK_SUCCESS) {
        throw new RuntimeException("Failed to create VkInstance: " + translateVulkanResult(err));
    }
    long instance = pInstance.get(0);
    memFree(pInstance);
    VkInstance ret = new VkInstance(instance, pCreateInfo);
    memFree(ppEnabledExtensionNames);
    memFree(VK_KHR_OS_SURFACE_EXTENSION);
    memFree(VK_KHR_SURFACE_EXTENSION);
    appInfo.free();
    return ret;
}

/**
 * Create a Vulkan {@link VkInstance} using LWJGL 3.
 * <p>
 * The {@link VkInstance} represents a handle to the Vulkan API and we need that instance for about everything we do.
 * 
 * @return the VkInstance handle
 */
private static VkInstance createInstance(PointerBuffer requiredExtensions) {
    // Here we say what the name of our application is and which Vulkan version we are targetting (having this is optional)
    VkApplicationInfo appInfo = VkApplicationInfo.callocStack()
            .sType(VK_STRUCTURE_TYPE_APPLICATION_INFO)
            .pApplicationName(stackUTF8("GLFW Vulkan Demo"))
            .pEngineName(stackUTF8(""))
            .apiVersion(VK_MAKE_VERSION(1, 0, 2));

    // We also need to tell Vulkan which extensions we would like to use.
    // Those include the platform-dependent required extensions we are being told by GLFW to use.
    // This includes stuff like the Window System Interface extensions to actually render something on a window.
    //
    // We also add the debug extension so that validation layers and other things can send log messages to us.
    ByteBuffer VK_EXT_DEBUG_REPORT_EXTENSION = stackUTF8(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
    PointerBuffer ppEnabledExtensionNames = stackMallocPointer(requiredExtensions.remaining() + 1);
    ppEnabledExtensionNames.put(requiredExtensions) // <- platform-dependent required extensions
                           .put(VK_EXT_DEBUG_REPORT_EXTENSION) // <- the debug extensions
                           .flip();

    // Now comes the validation layers. These layers sit between our application (the Vulkan client) and the
    // Vulkan driver. Those layers will check whether we make any mistakes in using the Vulkan API and yell
    // at us via the debug extension.
    PointerBuffer ppEnabledLayerNames = stackMallocPointer(layers.length);
    for (int i = 0; validation && i < layers.length; i++)
        ppEnabledLayerNames.put(layers[i]);
    ppEnabledLayerNames.flip();

    // Vulkan uses many struct/record types when creating something. This ensures that every information is available
    // at the callsite of the creation and allows for easier validation and also for immutability of the created object.
    // 
    // The following struct defines everything that is needed to create a VkInstance
    VkInstanceCreateInfo pCreateInfo = VkInstanceCreateInfo.callocStack()
            .sType(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO) // <- identifies what kind of struct this is (this is useful for extending the struct type later)
            .pNext(NULL) // <- must always be NULL until any next Vulkan version tells otherwise
            .pApplicationInfo(appInfo) // <- the application info we created above
            .ppEnabledExtensionNames(ppEnabledExtensionNames) // <- and the extension names themselves
            .ppEnabledLayerNames(ppEnabledLayerNames); // <- and the layer names themselves
    PointerBuffer pInstance = stackMallocPointer(1); // <- create a PointerBuffer which will hold the handle to the created VkInstance
    int err = vkCreateInstance(pCreateInfo, null, pInstance); // <- actually create the VkInstance now!
    long instance = pInstance.get(0); // <- get the VkInstance handle
    // One word about freeing memory:
    // Every host-allocated memory directly or indirectly referenced via a parameter to any Vulkan function can always
    // be freed right after the invocation of the Vulkan function returned.

    // Check whether we succeeded in creating the VkInstance
    if (err != VK_SUCCESS) {
        throw new AssertionError("Failed to create VkInstance: " + translateVulkanResult(err));
    }
    // Create an object-oriented wrapper around the simple VkInstance long handle
    // This is needed by LWJGL to later "dispatch" (i.e. direct calls to) the right Vukan functions.
    VkInstance ret = new VkInstance(instance, pCreateInfo);
    return ret;
}

/**
 * Create a Vulkan {@link VkInstance} using LWJGL 3.
 * <p>
 * The {@link VkInstance} represents a handle to the Vulkan API and we need that instance for about everything we do.
 * 
 * @return the VkInstance handle
 */
private static VkInstance createInstance(PointerBuffer requiredExtensions) {
    // Here we say what the name of our application is and which Vulkan version we are targetting (having this is optional)
    VkApplicationInfo appInfo = VkApplicationInfo.callocStack()
            .sType(VK_STRUCTURE_TYPE_APPLICATION_INFO)
            .pApplicationName(stackUTF8("GLFW Vulkan Demo"))
            .pEngineName(stackUTF8(""))
            .apiVersion(VK_MAKE_VERSION(1, 0, 2));

    // We also need to tell Vulkan which extensions we would like to use.
    // Those include the platform-dependent required extensions we are being told by GLFW to use.
    // This includes stuff like the Window System Interface extensions to actually render something on a window.
    //
    // We also add the debug extension so that validation layers and other things can send log messages to us.
    ByteBuffer VK_EXT_DEBUG_REPORT_EXTENSION = stackUTF8(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
    PointerBuffer ppEnabledExtensionNames = stackMallocPointer(requiredExtensions.remaining() + 1);
    ppEnabledExtensionNames.put(requiredExtensions) // <- platform-dependent required extensions
                           .put(VK_EXT_DEBUG_REPORT_EXTENSION) // <- the debug extensions
                           .flip();

    // Now comes the validation layers. These layers sit between our application (the Vulkan client) and the
    // Vulkan driver. Those layers will check whether we make any mistakes in using the Vulkan API and yell
    // at us via the debug extension.
    PointerBuffer ppEnabledLayerNames = stackMallocPointer(layers.length);
    for (int i = 0; validation && i < layers.length; i++)
        ppEnabledLayerNames.put(layers[i]);
    ppEnabledLayerNames.flip();

    // Vulkan uses many struct/record types when creating something. This ensures that every information is available
    // at the callsite of the creation and allows for easier validation and also for immutability of the created object.
    // 
    // The following struct defines everything that is needed to create a VkInstance
    VkInstanceCreateInfo pCreateInfo = VkInstanceCreateInfo.callocStack()
            .sType(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO) // <- identifies what kind of struct this is (this is useful for extending the struct type later)
            .pNext(NULL) // <- must always be NULL until any next Vulkan version tells otherwise
            .pApplicationInfo(appInfo) // <- the application info we created above
            .ppEnabledExtensionNames(ppEnabledExtensionNames) // <- and the extension names themselves
            .ppEnabledLayerNames(ppEnabledLayerNames); // <- and the layer names themselves
    PointerBuffer pInstance = stackMallocPointer(1); // <- create a PointerBuffer which will hold the handle to the created VkInstance
    int err = vkCreateInstance(pCreateInfo, null, pInstance); // <- actually create the VkInstance now!
    long instance = pInstance.get(0); // <- get the VkInstance handle
    // One word about freeing memory:
    // Every host-allocated memory directly or indirectly referenced via a parameter to any Vulkan function can always
    // be freed right after the invocation of the Vulkan function returned.

    // Check whether we succeeded in creating the VkInstance
    if (err != VK_SUCCESS) {
        throw new AssertionError("Failed to create VkInstance: " + translateVulkanResult(err));
    }
    // Create an object-oriented wrapper around the simple VkInstance long handle
    // This is needed by LWJGL to later "dispatch" (i.e. direct calls to) the right Vukan functions.
    VkInstance ret = new VkInstance(instance, pCreateInfo);
    return ret;
}

@Override
public VkInstance initVulkan()
{
    // We need to say which extensions to enable at the time of creating the instance. We should also add in the
    // extensions required by GLFW to create the surface. Note that this should not be freed manually.
    PointerBuffer glfwExtensions = glfwGetRequiredInstanceExtensions();

    // Create a PointerBuffer with memory enough to hold pointers for all the extension names.
    PointerBuffer enabledExtensionNames = memAllocPointer(glfwExtensions.remaining() + 1);

    // Encode the surface extension names into a ByteBuffer so we can put it in the PointerBuffer.
    ByteBuffer KHR_SURFACE_EXTENSION = memASCII(VK_KHR_SURFACE_EXTENSION_NAME);

    // Add the extensions to the PointerBuffer and flip the buffer. In order to present something
    // we must request the KHR_SURFACE_EXTENSION, without which, the instance will act like an offscreen context.
    enabledExtensionNames.put(KHR_SURFACE_EXTENSION);

    // Also put in the GLFW extensions into the enabledExtensionNames list so they get enabled too.
    while (glfwExtensions.remaining() > 0)
        enabledExtensionNames.put(glfwExtensions.get());

    // Flip the buffer so that the system can read from the buffer.
    enabledExtensionNames.flip();

    // The VkApplicationInfo struct contains information about the application that we are going to create.
    VkApplicationInfo appInfo = VkApplicationInfo.calloc()
            .sType(VK_STRUCTURE_TYPE_APPLICATION_INFO)
            .pApplicationName(memASCII("Vulkan Instance Example"))
            .pEngineName(memASCII(""))
            .apiVersion(VK_MAKE_VERSION(1, 0, 4));

    // The VkInstanceCreateInfo struct contains information about the Vulkan instance, and refers to the appInfo.
    VkInstanceCreateInfo instInfo = VkInstanceCreateInfo.calloc()
            .sType(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO)
            .pNext(NULL)
            .pApplicationInfo(appInfo)
            .ppEnabledExtensionNames(enabledExtensionNames);

    // The PointerBuffer enough to hold one pointer, the PointerBuffer is not a pointer, but it's contents are.
    PointerBuffer pInstance = memAllocPointer(1);

    // Create the instance. The instance handle is stored in the PointerBuffer which we can use now.
    vkCreateInstance(instInfo, null, pInstance);

    // Get the VkInstance handle from the pointer
    instance = new VkInstance(pInstance.get(), instInfo);

    // Free the pointer buffer, not the VkInstance struct
    memFree(pInstance);

    // Free the VkApplicationInfo and VkInstanceCreateInfo structs, we no longer need them in our application.
    appInfo.free();
    instInfo.free();

    // Free the extension names, we don't need them now.
    memFree(enabledExtensionNames);
    memFree(KHR_SURFACE_EXTENSION);

    // Print out the instance capabilities
    VKCapabilities capabilities = instance.getCapabilities();

    System.out.println("Vulkan10: " + capabilities.Vulkan10);
    System.out.println("VK_KHR_display: " + capabilities.VK_KHR_display);
    System.out.println("VK_KHR_surface: " + capabilities.VK_KHR_surface);
    System.out.println("VK_KHR_swapchain: " + capabilities.VK_KHR_swapchain);
    System.out.println("VK_EXT_debug_report: " + capabilities.VK_EXT_debug_report);
    System.out.println("VK_KHR_xlib_surface: " + capabilities.VK_KHR_xlib_surface);
    System.out.println("VK_KHR_win32_surface: " + capabilities.VK_KHR_win32_surface);
    System.out.println("VK_KHR_display_swapchain: " + capabilities.VK_KHR_display_swapchain);
    System.out.println("VK_KHR_sampler_mirror_clamp_to_edge: " + capabilities.VK_KHR_sampler_mirror_clamp_to_edge);

    // Return instance to attach to the display so rendering can be done.
    return instance;
}

/**
 * Create a Vulkan {@link VkInstance} using LWJGL 3.
 * <p>
 * The {@link VkInstance} represents a handle to the Vulkan API and we need that instance for about everything we do.
 * 
 * @return the VkInstance handle
 */
private static VkInstance createInstance() {
    VkApplicationInfo appInfo = VkApplicationInfo.calloc()
            .sType(VK_STRUCTURE_TYPE_APPLICATION_INFO)
            .pApplicationName(memUTF8("SWT Vulkan Demo"))
            .pEngineName(memUTF8(""))
            .apiVersion(VK_MAKE_VERSION(1, 0, 2));
    ByteBuffer VK_KHR_SURFACE_EXTENSION = memUTF8(VK_KHR_SURFACE_EXTENSION_NAME);
    ByteBuffer VK_EXT_DEBUG_REPORT_EXTENSION = memUTF8(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
    ByteBuffer VK_KHR_OS_SURFACE_EXTENSION;
    if (Platform.get() == Platform.WINDOWS)
        VK_KHR_OS_SURFACE_EXTENSION = memUTF8(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
    else
        VK_KHR_OS_SURFACE_EXTENSION = memUTF8(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
    PointerBuffer ppEnabledExtensionNames = memAllocPointer(3)
      .put(VK_KHR_SURFACE_EXTENSION)
      .put(VK_KHR_OS_SURFACE_EXTENSION)
      .put(VK_EXT_DEBUG_REPORT_EXTENSION)
      .flip();
    PointerBuffer ppEnabledLayerNames = memAllocPointer(layers.length);
    for (int i = 0; validation && i < layers.length; i++)
        ppEnabledLayerNames.put(layers[i]);
    ppEnabledLayerNames.flip();
    VkInstanceCreateInfo pCreateInfo = VkInstanceCreateInfo.calloc()
            .sType(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO)
            .pNext(NULL)
            .pApplicationInfo(appInfo)
            .ppEnabledExtensionNames(ppEnabledExtensionNames)
            .ppEnabledLayerNames(ppEnabledLayerNames);
    PointerBuffer pInstance = memAllocPointer(1);
    int err = vkCreateInstance(pCreateInfo, null, pInstance);
    long instance = pInstance.get(0);
    memFree(pInstance);
    if (err != VK_SUCCESS) {
        throw new AssertionError("Failed to create VkInstance: " + translateVulkanResult(err));
    }
    VkInstance ret = new VkInstance(instance, pCreateInfo);
    pCreateInfo.free();
    memFree(ppEnabledLayerNames);
    memFree(ppEnabledExtensionNames);
    memFree(VK_KHR_OS_SURFACE_EXTENSION);
    memFree(VK_EXT_DEBUG_REPORT_EXTENSION);
    memFree(VK_KHR_SURFACE_EXTENSION);
    appInfo.free();
    return ret;
}