private void GetAllInstanceExtensionsAvailables()
{
uint extensionCount;
Helpers.CheckErrors(VulkanNative.vkEnumerateInstanceExtensionProperties(null, &extensionCount, null));
VkExtensionProperties *extensions = stackalloc VkExtensionProperties[(int)extensionCount];
Helpers.CheckErrors(VulkanNative.vkEnumerateInstanceExtensionProperties(null, &extensionCount, extensions));
for (int i = 0; i < extensionCount; i++)
{
Debug.WriteLine($"Extension: {Helpers.GetString(extensions[i].extensionName)} version: {extensions[i].specVersion}");
}
// Return
//Extension: VK_KHR_device_group_creation version: 1
//Extension: VK_KHR_external_fence_capabilities version: 1
//Extension: VK_KHR_external_memory_capabilities version: 1
//Extension: VK_KHR_external_semaphore_capabilities version: 1
//Extension: VK_KHR_get_physical_device_properties2 version: 2
//Extension: VK_KHR_get_surface_capabilities2 version: 1
//Extension: VK_KHR_surface version: 25
//Extension: VK_KHR_surface_protected_capabilities version: 1
//Extension: VK_KHR_win32_surface version: 6
//Extension: VK_EXT_debug_report version: 9
//Extension: VK_EXT_debug_utils version: 2
//Extension: VK_EXT_swapchain_colorspace version: 4
//Extension: VK_NV_external_memory_capabilities version: 1
}
public vksVulkanDevice(VkPhysicalDevice physicalDevice)
{
Debug.Assert(physicalDevice.Handle != IntPtr.Zero);
PhysicalDevice = physicalDevice;
// Store Properties features, limits and properties of the physical device for later use
// Device properties also contain limits and sparse properties
VkPhysicalDeviceProperties properties;
vkGetPhysicalDeviceProperties(physicalDevice, out properties);
Properties = properties;
// Features should be checked by the examples before using them
VkPhysicalDeviceFeatures features;
vkGetPhysicalDeviceFeatures(physicalDevice, out features);
Features = features;
// Memory properties are used regularly for creating all kinds of buffers
VkPhysicalDeviceMemoryProperties memoryProperties;
vkGetPhysicalDeviceMemoryProperties(physicalDevice, out memoryProperties);
MemoryProperties = memoryProperties;
// Queue family properties, used for setting up requested queues upon device creation
uint queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, ref queueFamilyCount, null);
Debug.Assert(queueFamilyCount > 0);
QueueFamilyProperties.Resize(queueFamilyCount);
vkGetPhysicalDeviceQueueFamilyProperties(
physicalDevice,
&queueFamilyCount,
(VkQueueFamilyProperties *)QueueFamilyProperties.Data.ToPointer());
QueueFamilyProperties.Count = queueFamilyCount;
// Get list of supported extensions
uint extCount = 0;
vkEnumerateDeviceExtensionProperties(physicalDevice, (byte *)null, ref extCount, null);
if (extCount > 0)
{
VkExtensionProperties *extensions = stackalloc VkExtensionProperties[(int)extCount];
if (vkEnumerateDeviceExtensionProperties(physicalDevice, (byte *)null, ref extCount, extensions) == VkResult.Success)
{
for (uint i = 0; i < extCount; i++)
{
var ext = extensions[i];
// supportedExtensions.push_back(ext.extensionName);
// TODO: fixed-length char arrays are not being parsed correctly.
}
}
}
}
public static List <string> EnumerateInstanceExtensions()
{
uint Count = 0;
vkEnumerateInstanceExtensionProperties((byte *)null, ref Count, null);
VkExtensionProperties *ext = stackalloc VkExtensionProperties[(int)Count];
vkEnumerateInstanceExtensionProperties((byte *)null, ref Count, ext);
List <string> extensionName = new List <string>();
for (int i = 0; i < Count; i++)
{
extensionName.Add(Interop.String.FromPointer(ext[i].extensionName));
}
return(extensionName);
}
private bool CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice)
{
uint extensionCount;
Helpers.CheckErrors(VulkanNative.vkEnumerateDeviceExtensionProperties(physicalDevice, null, &extensionCount, null));
VkExtensionProperties *availableExtensions = stackalloc VkExtensionProperties[(int)extensionCount];
Helpers.CheckErrors(VulkanNative.vkEnumerateDeviceExtensionProperties(physicalDevice, null, &extensionCount, availableExtensions));
HashSet <string> requiredExtensions = new HashSet <string>(deviceExtensions);
for (int i = 0; i < extensionCount; i++)
{
var extension = availableExtensions[i];
requiredExtensions.Remove(Helpers.GetString(extension.extensionName));
}
return(requiredExtensions.Count == 0);
}
public string[] EnumerateInstanceExtensions()
{
uint propCount = 0;
VkResult result = VulkanNative.vkEnumerateInstanceExtensionProperties((byte *)null, &propCount, null);
Helpers.CheckErrors(result);
if (propCount == 0)
{
return(Array.Empty <string>());
}
VkExtensionProperties *props = stackalloc VkExtensionProperties[(int)propCount];
VulkanNative.vkEnumerateInstanceExtensionProperties((byte *)null, &propCount, props);
string[] ret = new string[propCount];
for (int i = 0; i < propCount; i++)
{
ret[i] = Marshal.PtrToStringAnsi((IntPtr)props[i].extensionName);
}
return(ret);
}
private void CreateLogicalDevice()
{
GetQueueFamilyIndices();
HashSet <uint> familyIndices = new HashSet <uint> {
_graphicsQueueIndex, _presentQueueIndex
};
RawList <VkDeviceQueueCreateInfo> queueCreateInfos = new RawList <VkDeviceQueueCreateInfo>();
foreach (uint index in familyIndices)
{
VkDeviceQueueCreateInfo queueCreateInfo = VkDeviceQueueCreateInfo.New();
queueCreateInfo.queueFamilyIndex = _graphicsQueueIndex;
queueCreateInfo.queueCount = 1;
float priority = 1f;
queueCreateInfo.pQueuePriorities = &priority;
queueCreateInfos.Add(queueCreateInfo);
}
VkPhysicalDeviceFeatures deviceFeatures = new VkPhysicalDeviceFeatures();
deviceFeatures.samplerAnisotropy = true;
deviceFeatures.fillModeNonSolid = true;
deviceFeatures.geometryShader = true;
deviceFeatures.depthClamp = true;
bool debugMarkerSupported = false;
uint propertyCount = 0;
VkResult result = vkEnumerateDeviceExtensionProperties(_physicalDevice, (byte *)null, &propertyCount, null);
CheckResult(result);
VkExtensionProperties *properties = stackalloc VkExtensionProperties[(int)propertyCount];
result = vkEnumerateDeviceExtensionProperties(_physicalDevice, (byte *)null, &propertyCount, properties);
CheckResult(result);
for (int i = 0; i < propertyCount; i++)
{
if (Util.GetString(properties[i].extensionName) == "VK_EXT_debug_marker")
{
Console.WriteLine("VK_EXT_debug_marker is available.");
debugMarkerSupported = true;
break;
}
}
VkDeviceCreateInfo deviceCreateInfo = VkDeviceCreateInfo.New();
fixed(VkDeviceQueueCreateInfo *qciPtr = &queueCreateInfos.Items[0])
{
deviceCreateInfo.pQueueCreateInfos = qciPtr;
deviceCreateInfo.queueCreateInfoCount = queueCreateInfos.Count;
deviceCreateInfo.pEnabledFeatures = &deviceFeatures;
StackList <IntPtr> layerNames = new StackList <IntPtr>();
layerNames.Add(CommonStrings.StandardValidationLayerName);
deviceCreateInfo.enabledLayerCount = layerNames.Count;
deviceCreateInfo.ppEnabledLayerNames = (byte **)layerNames.Data;
StackList <IntPtr> extensionNames = new StackList <IntPtr>();
extensionNames.Add(CommonStrings.VK_KHR_SWAPCHAIN_EXTENSION_NAME);
if (debugMarkerSupported)
{
extensionNames.Add(CommonStrings.VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
_debugMarkerEnabled = true;
}
deviceCreateInfo.enabledExtensionCount = extensionNames.Count;
deviceCreateInfo.ppEnabledExtensionNames = (byte **)extensionNames.Data;
result = vkCreateDevice(_physicalDevice, ref deviceCreateInfo, null, out _device);
CheckResult(result);
}
vkGetDeviceQueue(_device, _graphicsQueueIndex, 0, out _graphicsQueue);
vkGetDeviceQueue(_device, _presentQueueIndex, 0, out _presentQueue);
if (debugMarkerSupported)
{
IntPtr setObjectNamePtr;
using (FixedUtf8String debugExtFnName = "vkDebugMarkerSetObjectNameEXT")
{
setObjectNamePtr = vkGetInstanceProcAddr(_instance, debugExtFnName);
}
_setObjectNameDelegate = Marshal.GetDelegateForFunctionPointer <vkDebugMarkerSetObjectNameEXT_d>(setObjectNamePtr);
}
}
public static extern VkResult vpGetProfileDeviceExtensionProperties([NativeTypeName("const VpProfileProperties *")] VpProfileProperties *pProfile, [NativeTypeName("uint32_t *")] uint *pPropertyCount, VkExtensionProperties *pProperties);
private VkPhysicalDevice PickPhysicalDevice()
{
uint deviceCount;
VK.EnumeratePhysicalDevices(Instance, &deviceCount, null);
if (deviceCount > 0)
{
VkPhysicalDevice *devices = stackalloc VkPhysicalDevice[(int)deviceCount];
VkPhysicalDevice *valid = stackalloc VkPhysicalDevice[(int)deviceCount];
VK.EnumeratePhysicalDevices(Instance, &deviceCount, devices);
// find valid devices
int validCount = 0;
for (int i = 0; i < deviceCount; i++)
{
if (IsValidPhysicalDevice(devices[i]))
{
valid[validCount++] = devices[i];
}
}
// find the best device
if (validCount > 0)
{
for (int i = 0; i < validCount; i++)
{
VkPhysicalDeviceProperties properties;
VK.GetPhysicalDeviceProperties(devices[i], &properties);
if (properties.deviceType == VkPhysicalDeviceType.DiscreteGpu)
{
return(valid[i]);
}
}
return(valid[0]);
}
}
throw new Exception("Failed to find any GPUs that support Vulkan");
bool IsValidPhysicalDevice(VkPhysicalDevice device)
{
if (!TryGetQueueFamilyIndex(device, VkQueueFlags.GraphicsBit, out _))
{
return(false);
}
uint extensionCount;
VK.EnumerateDeviceExtensionProperties(device, null, &extensionCount, null);
VkExtensionProperties *availableExtensions = stackalloc VkExtensionProperties[(int)extensionCount];
VK.EnumerateDeviceExtensionProperties(device, null, &extensionCount, availableExtensions);
foreach (var str in deviceExtensions)
{
var hasExtension = false;
for (int j = 0; j < extensionCount && !hasExtension; j++)
{
if (str == VK.STRING(availableExtensions[j].extensionName))
{
hasExtension = true;
}
}
if (!hasExtension)
{
return(false);
}
}
return(true);
}
}
