public void Recreate()
{
NativePhysicalDevices = new List <VkPhysicalDevice>();
NativePhysicalDevices = GetPhysicalDevice();
foreach (var item in NativePhysicalDevices)
{
NativePhysicalDevice = item;
}
Properties = GetProperties();
}
/// <summary>
/// Gets the version-aware properties associated with the physical device.
/// </summary>
/// <param name="device">The device to get the properties for.</param>
/// <param name="props">The Vulkan 1.0 properties.</param>
/// <param name="props11">The Vulkan 1.1 properties.</param>
/// <param name="props12">The Vulkan 1.2 properties.</param>
public static void GetProperties(VkPhysicalDevice device,
out VkPhysicalDeviceProperties props,
out VkPhysicalDeviceVulkan11Properties props11,
out VkPhysicalDeviceVulkan12Properties props12)
{
if (!device)
{
throw new ArgumentNullException(nameof(device), "Cannot pass null device or device handle");
}
VkPhysicalDeviceProperties.New(out props);
VkPhysicalDeviceVulkan11Properties.New(out props11);
VkPhysicalDeviceVulkan12Properties.New(out props12);
var version = device.Parent.Functions.CoreVersion;
// 1.0
if (version < VkVersion.VK_VERSION_1_1)
{
device.GetPhysicalDeviceProperties(out props);
}
// 1.1
else if (version < VkVersion.VK_VERSION_1_2)
{
VkPhysicalDeviceProperties2.New(out var props2);
fixed(VkPhysicalDeviceVulkan11Properties *ptr11 = &props11)
{
props2.pNext = ptr11;
device.GetPhysicalDeviceProperties2(&props2);
props = props2.Properties;
}
}
// 1.2
else
{
VkPhysicalDeviceProperties2.New(out var props2);
fixed(VkPhysicalDeviceVulkan11Properties *ptr11 = &props11)
fixed(VkPhysicalDeviceVulkan12Properties * ptr12 = &props12)
{
props2.pNext = ptr11;
ptr11->pNext = ptr12;
device.GetPhysicalDeviceProperties2(&props2);
props = props2.Properties;
ptr11->pNext = null;
}
}
}
internal PhysicalDevice(Instance instance, VkPhysicalDevice handle)
{
Instance = instance;
Handle = handle;
unsafe
{
var props = Handle.GetPhysicalDeviceProperties();
_properties = props;
DeviceName = Marshal.PtrToStringAnsi(new IntPtr(props.DeviceName));
{
var memProps = Handle.GetPhysicalDeviceMemoryProperties();
var heapList = new List <MemoryHeap>((int)memProps.MemoryHeapCount);
for (uint i = 0; i < memProps.MemoryHeapCount; i++)
{
heapList.Add(new MemoryHeap(i, memProps.MemoryHeaps[(int)i]));
}
MemoryHeaps = heapList;
var typeList = new List <MemoryType>((int)memProps.MemoryTypeCount);
for (uint i = 0; i < memProps.MemoryTypeCount; i++)
{
typeList.Add(new MemoryType(i, heapList[(int)memProps.MemoryTypes[(int)i].HeapIndex],
(VkMemoryPropertyFlag)memProps.MemoryTypes[(int)i].PropertyFlags));
}
MemoryTypes = typeList;
}
}
{
ExtensionProperties = new List <VkExtensionProperties>(Handle.EnumerateExtensionProperties(null));
LayerProperties = new List <VkLayerProperties>(Handle.EnumerateLayerProperties());
var availableExt = new HashSet <ExtensionDescriptionAttribute>();
foreach (var ext in ExtensionProperties)
{
var desc = VkExtensionDatabase.Extension(ext.ExtensionNameString);
if (desc != null)
{
availableExt.Add(desc);
}
}
AvailableExtensions = availableExt;
}
}
internal PhysicalDeviceProperties(VkPhysicalDeviceProperties prop)
{
unsafe
{
Name = Interop.GetString(&prop.deviceName);
byte[] uuid = new byte[16];
for (int i = 0; i < 16; i++)
{
uuid[i] = (&prop.pipelineCacheUUID)[i];
}
PipelineCache = new Guid(uuid);
}
APIVersion = prop.apiVersion;
Type = prop.deviceType;
DriverVersion = prop.driverVersion;
VendorID = prop.vendorID;
DeviceID = prop.deviceID;
Limits = prop.limits;
SparseProperties = prop.sparseProperties;
}
public static VkSampleCountFlags ExtractMaxSampleCount(VkPhysicalDeviceProperties physical)
{
VkSampleCountFlags counts = physical.limits.framebufferColorSampleCounts & physical.limits.framebufferDepthSampleCounts;
if ((counts & VkSampleCountFlags.Count64) != 0)
{
return(VkSampleCountFlags.Count64);
}
if ((counts & VkSampleCountFlags.Count32) != 0)
{
return(VkSampleCountFlags.Count32);
}
if ((counts & VkSampleCountFlags.Count16) != 0)
{
return(VkSampleCountFlags.Count16);
}
if ((counts & VkSampleCountFlags.Count8) != 0)
{
return(VkSampleCountFlags.Count8);
}
if ((counts & VkSampleCountFlags.Count4) != 0)
{
return(VkSampleCountFlags.Count4);
}
if ((counts & VkSampleCountFlags.Count2) != 0)
{
return(VkSampleCountFlags.Count2);
}
return(VkSampleCountFlags.Count1);
}
public static string GetDeviceName(this VkPhysicalDeviceProperties properties)
{
return(Interop.GetString(properties.deviceName));
}
public abstract void GetPhysicalDeviceProperties(out VkPhysicalDeviceProperties pProperties);
public override void GetPhysicalDeviceProperties(out VkPhysicalDeviceProperties pProperties)
{
throw new NotImplementedException();
}
static VkPhysicalDevice PickPhysicalDevice(VkInstance instance, VkSurfaceKHR surface, out uint queueFamilyIndex)
{
queueFamilyIndex = 0;
uint deviceCount = 0;
vkEnumeratePhysicalDevices(instance, &deviceCount, null);
Console.WriteLine($"There are {deviceCount} devices available.");
VkPhysicalDevice[] devices = new VkPhysicalDevice[deviceCount];
if (deviceCount <= 0)
return(VkPhysicalDevice.Null);
fixed(VkPhysicalDevice *ptr = &devices[0])
vkEnumeratePhysicalDevices(instance, &deviceCount, ptr);
VkPhysicalDeviceProperties props = new VkPhysicalDeviceProperties();
for (int i = 0; i < deviceCount; i++)
{
bool badGpu = true;
bool onlyPickDiscrete = true;
vkGetPhysicalDeviceProperties(devices[i], &props);
uint familyQueueCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(devices[i], &familyQueueCount, null);
VkQueueFamilyProperties[] famProps = new VkQueueFamilyProperties[familyQueueCount];
fixed(VkQueueFamilyProperties *ptr = famProps)
vkGetPhysicalDeviceQueueFamilyProperties(devices[i], &familyQueueCount, ptr);
VkPhysicalDeviceFeatures deviceFeatures;
vkGetPhysicalDeviceFeatures(devices[i], &deviceFeatures);
if (deviceFeatures.samplerAnisotropy == VkBool32.False)
{
continue;
}
for (uint k = 0; k < familyQueueCount; k++)
{
if ((int)(famProps[k].queueFlags & VkQueueFlags.Graphics) <= 0)
{
continue;
}
VkBool32 supported = VkBool32.False;
Assert(vkGetPhysicalDeviceSurfaceSupportKHR(devices[i], k, surface, &supported));
if (supported == VkBool32.False)
{
continue;
}
/*fixed (VkPhysicalDevice* ptr = &(devices[i]))
* if (!GLFW.Vulkan.GetPhysicalDevicePresentationSupport((IntPtr)(&instance), (IntPtr)ptr, k))//Throws exception
* {
* continue;
* }*/
if (onlyPickDiscrete && !(props.deviceType == VkPhysicalDeviceType.DiscreteGpu))
{
continue;
}
queueFamilyIndex = k;
badGpu = false;
}
//Here we pick if its acceptable
if (badGpu)
{
continue;
}
Console.WriteLine($"Picking GPU: {Marshal.PtrToStringUTF8((IntPtr)props.deviceName)}");
return(devices[i]);
}
throw new System.Exception("There was no GPU that filled our needs.");
}
