public static void main(String[] args) { // Create the Vulkan instance VkInstance instance = createInstance(); VKData data = new VKData(); data.instance = instance; // <- set Vulkan instance JFrame frame = new JFrame("AWT test"); frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); frame.setLayout(new BorderLayout()); frame.setPreferredSize(new Dimension(600, 600)); frame.add(new AWTVKCanvas(data) { private static final long serialVersionUID = 1L; public void initVK() { @SuppressWarnings("unused") long surface = this.surface; // Do something with surface... } public void paintVK() { } }, BorderLayout.CENTER); frame.pack(); frame.setVisible(true); }
/** * This function sets up the debug callback which the validation layers will use to yell at us when we make mistakes. */ private static long setupDebugging(VkInstance instance, int flags, VkDebugReportCallbackEXT callback) { // Again, a struct to create something, in this case the debug report callback VkDebugReportCallbackCreateInfoEXT dbgCreateInfo = VkDebugReportCallbackCreateInfoEXT.callocStack() .sType(VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT) // <- the struct type .pNext(NULL) // <- must be NULL .pfnCallback(callback) // <- the actual function pointer (in LWJGL a Closure) .pUserData(NULL) // <- any user data provided to the debug report callback function .flags(flags); // <- indicates which kind of messages we want to receive LongBuffer pCallback = stackMallocLong(1); // <- allocate a LongBuffer (for a non-dispatchable handle) // Actually create the debug report callback int err = vkCreateDebugReportCallbackEXT(instance, dbgCreateInfo, null, pCallback); long callbackHandle = pCallback.get(0); if (err != VK_SUCCESS) { throw new AssertionError("Failed to create VkInstance: " + translateVulkanResult(err)); } return callbackHandle; }
/** * Returns the handle to the first physical device connected to the system. * * @param instance The instance of the vulkan * * @return The handle to the first physical device. */ public static VkPhysicalDevice getFirstPhysicalDevice(VkInstance instance) { IntBuffer gpuCount = memAllocInt(1); vkEnumeratePhysicalDevices(instance, gpuCount, null); PointerBuffer devices = memAllocPointer(gpuCount.get(0)); vkEnumeratePhysicalDevices(instance, gpuCount, devices); VkPhysicalDevice firstPhysicalDevice = new VkPhysicalDevice(devices.get(0), instance); memFree(gpuCount); memFree(devices); return firstPhysicalDevice; }
private long setupDebugging(VkInstance instance, int flags, VkDebugReportCallbackEXT callback) { VkDebugReportCallbackCreateInfoEXT dbgCreateInfo = VkDebugReportCallbackCreateInfoEXT.calloc() .sType(VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT) .pNext(0) .pfnCallback(callback) .pUserData(0) .flags(flags); LongBuffer pCallback = memAllocLong(1); int err = vkCreateDebugReportCallbackEXT(instance, dbgCreateInfo, null, pCallback); long callbackHandle = pCallback.get(0); memFree(pCallback); dbgCreateInfo.free(); if (err != VK_SUCCESS) { throw new AssertionError("Failed to create VkInstance: " + VKUtil.translateVulkanResult(err)); } return callbackHandle; }
private VkPhysicalDevice getFirstPhysicalDevice(VkInstance instance) { IntBuffer pPhysicalDeviceCount = memAllocInt(1); int err = vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, null); if (err != VK_SUCCESS) { throw new AssertionError("Failed to get number of physical devices: " + VKUtil.translateVulkanResult(err)); } PointerBuffer pPhysicalDevices = memAllocPointer(pPhysicalDeviceCount.get(0)); err = vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); long physicalDevice = pPhysicalDevices.get(0); memFree(pPhysicalDeviceCount); memFree(pPhysicalDevices); if (err != VK_SUCCESS) { throw new AssertionError("Failed to get physical devices: " + VKUtil.translateVulkanResult(err)); } return new VkPhysicalDevice(physicalDevice, instance); }
/** * This function sets up the debug callback which the validation layers will use to yell at us when we make mistakes. */ private static long setupDebugging(VkInstance instance, int flags, VkDebugReportCallbackEXT callback) { // Again, a struct to create something, in this case the debug report callback VkDebugReportCallbackCreateInfoEXT dbgCreateInfo = VkDebugReportCallbackCreateInfoEXT.calloc() .sType(VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT) // <- the struct type .pNext(NULL) // <- must be NULL .pfnCallback(callback) // <- the actual function pointer (in LWJGL a Closure) .pUserData(NULL) // <- any user data provided to the debug report callback function .flags(flags); // <- indicates which kind of messages we want to receive LongBuffer pCallback = memAllocLong(1); // <- allocate a LongBuffer (for a non-dispatchable handle) // Actually create the debug report callback int err = vkCreateDebugReportCallbackEXT(instance, dbgCreateInfo, null, pCallback); long callbackHandle = pCallback.get(0); memFree(pCallback); // <- and free the LongBuffer dbgCreateInfo.free(); // <- and also the create-info struct if (err != VK_SUCCESS) { throw new AssertionError("Failed to create VkInstance: " + translateVulkanResult(err)); } return callbackHandle; }
/** * This method will enumerate the physical devices (i.e. GPUs) the system has available for us, and will just return * the first one. */ private static VkPhysicalDevice getFirstPhysicalDevice(VkInstance instance) { IntBuffer pPhysicalDeviceCount = memAllocInt(1); int err = vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, null); if (err != VK_SUCCESS) { throw new AssertionError("Failed to get number of physical devices: " + translateVulkanResult(err)); } PointerBuffer pPhysicalDevices = memAllocPointer(pPhysicalDeviceCount.get(0)); err = vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); long physicalDevice = pPhysicalDevices.get(0); memFree(pPhysicalDeviceCount); memFree(pPhysicalDevices); if (err != VK_SUCCESS) { throw new AssertionError("Failed to get physical devices: " + translateVulkanResult(err)); } return new VkPhysicalDevice(physicalDevice, instance); }
/** * 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; }
/** * This method will enumerate the physical devices (i.e. GPUs) the system has available for us, and will just return * the first one. */ private static VkPhysicalDevice getFirstPhysicalDevice(VkInstance instance) { IntBuffer pPhysicalDeviceCount = stackMallocInt(1); int err = vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, null); if (err != VK_SUCCESS) { throw new AssertionError("Failed to get number of physical devices: " + translateVulkanResult(err)); } PointerBuffer pPhysicalDevices = stackMallocPointer(pPhysicalDeviceCount.get(0)); err = vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); long physicalDevice = pPhysicalDevices.get(0); if (err != VK_SUCCESS) { throw new AssertionError("Failed to get physical devices: " + translateVulkanResult(err)); } return new VkPhysicalDevice(physicalDevice, instance); }
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; }
public static void main(String[] args) { // Create the Vulkan instance VkInstance instance = createInstance(); // Create SWT Display, Shell and VKCanvas final Display display = new Display(); final Shell shell = new Shell(display, SWT.SHELL_TRIM | SWT.NO_BACKGROUND | SWT.NO_REDRAW_RESIZE); shell.setLayout(new FillLayout()); shell.addListener(SWT.Traverse, new Listener() { public void handleEvent(Event event) { switch (event.detail) { case SWT.TRAVERSE_ESCAPE: shell.close(); event.detail = SWT.TRAVERSE_NONE; event.doit = false; break; } } }); VKData data = new VKData(); data.instance = instance; // <- set Vulkan instance final VKCanvas canvas = new VKCanvas(shell, SWT.NO_BACKGROUND | SWT.NO_REDRAW_RESIZE, data); shell.setSize(800, 600); shell.open(); while (!shell.isDisposed()) { if (!display.readAndDispatch()) display.sleep(); } canvas.dispose(); display.dispose(); }
/** * 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; }
/** * The main heart of an example, it runs the event loop and manages the creation and destruction of the window and * also creates the surface for Vulkan. */ public void start() { glfwInit(); // Check if Vulkan is available, if not, exit early. if (!glfwVulkanSupported()) throw new UnsupportedOperationException("Vulkan driver is not found on this machine. Please update your drivers."); // Create a GLFW window with no API glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); if (title == null) title = "Vulkan Tests"; windowID = glfwCreateWindow(800, 600, title, NULL, NULL); // Initialize Vulkan and get the instance. VkInstance vulkanInstance = initVulkan(); // Create the surface and attach to the window. LongBuffer pSurface = memAllocLong(1); int err = glfwCreateWindowSurface(vulkanInstance, windowID, null, pSurface); if (err != 0) throw new IllegalStateException("Could not create surface for Vulkan"); long surfaceID = pSurface.get(); memFree(pSurface); while (!glfwWindowShouldClose(windowID)) { glfwPollEvents(); render(); } vkDestroySurfaceKHR(vulkanInstance, surfaceID, null); cleanUp(); glfwTerminate(); }
@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; }
/** * The job of this method is to initialize Vulkan and return the VkInstance struct handle so that it is used to * create a surface and attaches with the window. The initialization code should request the KHR_SURFACE extension * to be able to create the surface. * * @return The VkInstance handle to the successfully initialized Vulkan instance. */ public abstract VkInstance initVulkan();
