org.lwjgl.vulkan.VkPhysicalDevice Java Examples

/**
 * 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);
}
 

public static List<String> getPhysicalDeviceExtensionNamesSupport(VkPhysicalDevice physicalDevice){

	IntBuffer extensionCount = memAllocInt(1);
	
	int err = vkEnumerateDeviceExtensionProperties(physicalDevice, "", extensionCount, null);
	if (err != VK_SUCCESS) {
           throw new AssertionError(VkUtil.translateVulkanResult(err));
       }
	
	VkExtensionProperties.Buffer extensions = VkExtensionProperties.calloc(extensionCount.get(0));
	
	err = vkEnumerateDeviceExtensionProperties(physicalDevice, "", extensionCount, extensions);
	if (err != VK_SUCCESS) {
           throw new AssertionError(VkUtil.translateVulkanResult(err));
       }
	
	List<String> extensionNames = new ArrayList<>();
	for (VkExtensionProperties extension : extensions){
		extensionNames.add(extension.extensionNameString());
	}
	
	return extensionNames;
}
 

public PhysicalDevice(VkInstance vkInstance, long surface) {

		IntBuffer pPhysicalDeviceCount = memAllocInt(1);
        int err = vkEnumeratePhysicalDevices(vkInstance, pPhysicalDeviceCount, null);
        if (err != VK_SUCCESS) {
            throw new AssertionError("Failed to get number of physical devices: " + VkUtil.translateVulkanResult(err));
        }
        
        log.info("Available Physical Devices: " + pPhysicalDeviceCount.get(0));
        
        PointerBuffer pPhysicalDevices = memAllocPointer(pPhysicalDeviceCount.get(0));
        err = vkEnumeratePhysicalDevices(vkInstance, pPhysicalDeviceCount, pPhysicalDevices);
        long physicalDevice = pPhysicalDevices.get(0);
       
        if (err != VK_SUCCESS) {
            throw new AssertionError("Failed to get physical devices: " + VkUtil.translateVulkanResult(err));
        }
        
        memFree(pPhysicalDeviceCount);
        memFree(pPhysicalDevices);
        
        handle =  new VkPhysicalDevice(physicalDevice, vkInstance);
        queueFamilies = new QueueFamilies(handle, surface);
        swapChainCapabilities = new SurfaceProperties(handle, surface);
        supportedExtensionNames = DeviceCapabilities.getPhysicalDeviceExtensionNamesSupport(handle);
        memoryProperties = VkPhysicalDeviceMemoryProperties.calloc();
        vkGetPhysicalDeviceMemoryProperties(handle, memoryProperties);
        
        properties = DeviceCapabilities.checkPhysicalDeviceProperties(handle);
        features = DeviceCapabilities.checkPhysicalDeviceFeatures(handle);
        
//        log.info(properties.apiVersion());
//        log.info(properties.driverVersion());
//        log.info(properties.vendorID());
//        log.info(properties.deviceID());
//        log.info(properties.deviceType());
//        log.info(properties.deviceNameString());
	}
 

public static VkFormatProperties getVkPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
		int format){
	
	VkFormatProperties formatProperties = VkFormatProperties.create();
	vkGetPhysicalDeviceFormatProperties(physicalDevice, format, formatProperties);
	
	return formatProperties;
}
 

public SurfaceProperties(VkPhysicalDevice physicalDevice, long surface) {

		surfaceCapabilities = VkSurfaceCapabilitiesKHR.calloc();
        int err = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, surfaceCapabilities);
        if (err != VK_SUCCESS) {
            throw new AssertionError("Failed to get physical device surface capabilities: " + VkUtil.translateVulkanResult(err));
        }
        
        IntBuffer pFormatCount = memAllocInt(1);
        err = vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pFormatCount, null);
        int formatCount = pFormatCount.get(0);
        if (err != VK_SUCCESS) {
            throw new AssertionError("Failed to query number of physical device surface formats: " + VkUtil.translateVulkanResult(err));
        }

        surfaceFormats = VkSurfaceFormatKHR.calloc(formatCount);
        err = vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pFormatCount, surfaceFormats);
        if (err != VK_SUCCESS) {
            throw new AssertionError("Failed to query physical device surface formats: " + VkUtil.translateVulkanResult(err));
        }
        
        IntBuffer pPresentModeCount = memAllocInt(1);
        err = vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, null);
        int presentModeCount = pPresentModeCount.get(0);
        if (err != VK_SUCCESS) {
            throw new AssertionError("Failed to get number of physical device surface presentation modes: " + VkUtil.translateVulkanResult(err));
        }

        presentModes = memAllocInt(presentModeCount);
        err = vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, presentModes);
        if (err != VK_SUCCESS) {
            throw new AssertionError("Failed to get physical device surface presentation modes: " + VkUtil.translateVulkanResult(err));
        }
        
        memFree(pPresentModeCount);
        memFree(pFormatCount);
	}
 

@Override
public boolean getPhysicalDevicePresentationSupport(VkPhysicalDevice physicalDevice, int queueFamily) {
    return KHRXlibSurface.vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamily, 0, 0);
}
 

public boolean getPhysicalDevicePresentationSupport(VkPhysicalDevice physicalDevice, int queueFamily) {
    return vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamily);
}
 

private static DeviceAndGraphicsQueueFamily createDeviceAndGetGraphicsQueueFamily(VkPhysicalDevice physicalDevice) {
    IntBuffer pQueueFamilyPropertyCount = memAllocInt(1);
    vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, null);
    int queueCount = pQueueFamilyPropertyCount.get(0);
    VkQueueFamilyProperties.Buffer queueProps = VkQueueFamilyProperties.calloc(queueCount);
    vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, queueProps);
    memFree(pQueueFamilyPropertyCount);
    int graphicsQueueFamilyIndex;
    for (graphicsQueueFamilyIndex = 0; graphicsQueueFamilyIndex < queueCount; graphicsQueueFamilyIndex++) {
        if ((queueProps.get(graphicsQueueFamilyIndex).queueFlags() & VK_QUEUE_GRAPHICS_BIT) != 0)
            break;
    }
    queueProps.free();
    FloatBuffer pQueuePriorities = memAllocFloat(1).put(0.0f);
    pQueuePriorities.flip();
    VkDeviceQueueCreateInfo.Buffer queueCreateInfo = VkDeviceQueueCreateInfo.calloc(1)
            .sType(VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO)
            .queueFamilyIndex(graphicsQueueFamilyIndex)
            .pQueuePriorities(pQueuePriorities);

    PointerBuffer extensions = memAllocPointer(1);
    ByteBuffer VK_KHR_SWAPCHAIN_EXTENSION = memUTF8(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
    extensions.put(VK_KHR_SWAPCHAIN_EXTENSION);
    extensions.flip();
    PointerBuffer ppEnabledLayerNames = memAllocPointer(layers.length);
    for (int i = 0; validation && i < layers.length; i++)
        ppEnabledLayerNames.put(layers[i]);
    ppEnabledLayerNames.flip();

    VkDeviceCreateInfo deviceCreateInfo = VkDeviceCreateInfo.calloc()
            .sType(VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO)
            .pNext(NULL)
            .pQueueCreateInfos(queueCreateInfo)
            .ppEnabledExtensionNames(extensions)
            .ppEnabledLayerNames(ppEnabledLayerNames);

    PointerBuffer pDevice = memAllocPointer(1);
    int err = vkCreateDevice(physicalDevice, deviceCreateInfo, null, pDevice);
    long device = pDevice.get(0);
    memFree(pDevice);
    if (err != VK_SUCCESS) {
        throw new AssertionError("Failed to create device: " + translateVulkanResult(err));
    }

    DeviceAndGraphicsQueueFamily ret = new DeviceAndGraphicsQueueFamily();
    ret.device = new VkDevice(device, physicalDevice, deviceCreateInfo);
    ret.queueFamilyIndex = graphicsQueueFamilyIndex;

    deviceCreateInfo.free();
    memFree(ppEnabledLayerNames);
    memFree(VK_KHR_SWAPCHAIN_EXTENSION);
    memFree(extensions);
    memFree(pQueuePriorities);
    return ret;
}
 

public boolean getPhysicalDevicePresentationSupport(VkPhysicalDevice physicalDevice, int queueFamily) {
    return vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamily);
}
 

public QueueFamilies(VkPhysicalDevice physicalDevice, long surface) {

	queueFamilies = new ArrayList<>();
	
	IntBuffer pQueueFamilyPropertyCount = memAllocInt(1);
       vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, null);
       int queueCount = pQueueFamilyPropertyCount.get(0);
       
       VkQueueFamilyProperties.Buffer queueProps = VkQueueFamilyProperties.calloc(queueCount);
       vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, queueProps);
       
       log.info("Available Queues: " + queueCount);
       
       IntBuffer supportsPresent = memAllocInt(queueCount);

       for (int i = 0; i < queueCount; i++) {

       	supportsPresent.position(i);
       	supportsPresent.put(i, 0);
       	
       	int flags = queueProps.get(i).queueFlags();
       	int count = queueProps.get(i).queueCount();
       	
       	// check if surface exists
       	if (surface != -1){
        	int err = vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, 
					   i, 
					   surface, 
					   supportsPresent);
			if (err != VK_SUCCESS) {
			throw new AssertionError("Failed to physical device surface support: " + VkUtil.translateVulkanResult(err));
			}
       	}
       	
       	log.info("Index:" + i + " flags:" + flags + " count:" + count + " presentation:" + supportsPresent.get(i));
       	
       	QueueFamily queueFamily = new QueueFamily();
       	queueFamily.setIndex(i);
       	queueFamily.setFlags(flags);
       	queueFamily.setCount(count);
       	queueFamily.setPresentFlag(supportsPresent.get(i));
       	
       	queueFamilies.add(queueFamily);
       }
       
       memFree(pQueueFamilyPropertyCount);
       queueProps.free();
}
 

public static VkPhysicalDeviceProperties checkPhysicalDeviceProperties(VkPhysicalDevice physicalDevice){
	
	VkPhysicalDeviceProperties properties = VkPhysicalDeviceProperties.create();
	vkGetPhysicalDeviceProperties(physicalDevice, properties);
	
	log.info("Device: " + properties.deviceNameString());
	
	return properties;
}
 

public static VkPhysicalDeviceFeatures checkPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice){
	
	VkPhysicalDeviceFeatures features = VkPhysicalDeviceFeatures.create();
	vkGetPhysicalDeviceFeatures(physicalDevice, features);
	
	return features;
}
 

/**
 * Determine whether there is presentation support for the given {@link VkPhysicalDevice} in a command queue of the specified <code>queueFamiliy</code>.
 * 
 * @param physicalDevice
 *            the Vulkan {@link VkPhysicalDevice}
 * @param queueFamily
 *            the command queue family
 * @return <code>true</code> of <code>false</code>
 */
public boolean getPhysicalDevicePresentationSupport(VkPhysicalDevice physicalDevice, int queueFamily) {
    return platformCanvas.getPhysicalDevicePresentationSupport(physicalDevice, queueFamily);
}
 

/**
 * Determine whether there is presentation support for the given {@link VkPhysicalDevice} in a command queue of the specified
 * <code>queueFamiliy</code>.
 * 
 * @param physicalDevice
 *            the Vulkan {@link VkPhysicalDevice}
 * @param queueFamily
 *            the command queue family
 * @return <code>true</code> of <code>false</code>
 */
public boolean getPhysicalDevicePresentationSupport(VkPhysicalDevice physicalDevice, int queueFamily) {
    return platformCanvas.getPhysicalDevicePresentationSupport(physicalDevice, queueFamily);
}
 

boolean getPhysicalDevicePresentationSupport(VkPhysicalDevice physicalDevice, int queueFamily); 

boolean getPhysicalDevicePresentationSupport(VkPhysicalDevice physicalDevice, int queueFamily);