private static string[] EnumerateInstanceExtensions()
{
if (!IsVulkanLoaded())
{
return(Array.Empty <string>());
}
uint propCount = 0;
VkResult result = vkEnumerateInstanceExtensionProperties((byte *)null, ref propCount, null);
if (result != VkResult.Success)
{
return(Array.Empty <string>());
}
if (propCount == 0)
{
return(Array.Empty <string>());
}
VkExtensionProperties[] props = new VkExtensionProperties[propCount];
vkEnumerateInstanceExtensionProperties((byte *)null, ref propCount, ref props[0]);
string[] ret = new string[propCount];
for (int i = 0; i < propCount; i++)
{
fixed(byte *extensionNamePtr = props[i].extensionName)
{
ret[i] = Util.GetString(extensionNamePtr);
}
}
return(ret);
}
internal Extension(VkExtensionProperties prop) {
unsafe
{
Name = Interop.GetString(&prop.extensionName);
}
Version = prop.specVersion;
}
/// <summary>
/// Gets the instance extensions supported by the current system.
/// </summary>
/// <param name="layerName">The optional layer name in which to look for extensions.</param>
public static VkExtensionProperties[] GetExtensions(string?layerName)
{
uint count = 0;
VkExtensionProperties[] props;
if (layerName is not null)
{
using var nativeName = new NativeString(layerName);
InstanceFunctionTable.EnumerateInstanceExtensionProperties(nativeName.Data, &count, null)
.Throw("EnumerateInstanceExtensionProperties");
props = new VkExtensionProperties[count];
fixed(VkExtensionProperties *ptr = props)
{
InstanceFunctionTable.EnumerateInstanceExtensionProperties(nativeName.Data, &count, ptr)
.Throw("EnumerateInstanceExtensionProperties");
}
}
else
{
InstanceFunctionTable.EnumerateInstanceExtensionProperties(null, &count, null)
.Throw("EnumerateInstanceExtensionProperties");
props = new VkExtensionProperties[count];
fixed(VkExtensionProperties *ptr = props)
{
InstanceFunctionTable.EnumerateInstanceExtensionProperties(null, &count, ptr)
.Throw("EnumerateInstanceExtensionProperties");
}
}
return(props);
}
public SoftwarePhysicalDevice(SoftwareInstance instance)
{
m_Instance = instance;
m_QueueFamilyProperties.Add(VkQueueFamilyProperties.Create(1, VkQueueFlagBits.VK_QUEUE_GRAPHICS_BIT));
m_QueueFamilyProperties.Add(VkQueueFamilyProperties.Create(1, VkQueueFlagBits.VK_QUEUE_COMPUTE_BIT));
m_ExtensionProperties.Add(VkExtensionProperties.Create(VkExtensionNames.VK_KHR_SWAPCHAIN_EXTENSION_NAME, 1));
m_PhysicalDeviceMemoryProperties = new VkPhysicalDeviceMemoryProperties();
m_PhysicalDeviceMemoryProperties.memoryTypeCount = 1;
m_PhysicalDeviceMemoryProperties.memoryTypes = new VkMemoryType[]
{
new VkMemoryType()
{
heapIndex = 0,
propertyFlags = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
}
};
m_PhysicalDeviceMemoryProperties.memoryHeapCount = 1;
m_PhysicalDeviceMemoryProperties.memoryHeaps = new VkMemoryHeap[]
{
new VkMemoryHeap()
{
flags = VkMemoryHeapFlagBits.VK_MEMORY_HEAP_DEVICE_LOCAL_BIT, size = 64 * 1024 * 1024
}
};
}
/// <summary>
/// To query the extensions available to a given physical device, call:
/// </summary>
/// <param name="layerName">is either `NULL` or a pointer to a null-terminated UTF-8 string naming the layer to retrieve extensions from.</param>
/// <returns>array of <see cref="VkExtensionProperties"/> structures</returns>
/// <exception cref="VulkanLibrary.Unmanaged.VkErrorOutOfHostMemory"></exception>
/// <exception cref="VulkanLibrary.Unmanaged.VkErrorOutOfDeviceMemory"></exception>
/// <exception cref="VulkanLibrary.Unmanaged.VkErrorLayerNotPresent"></exception>
public VkExtensionProperties[] EnumerateExtensionProperties(string layerName)
{
unsafe
{
var layerNamePtr = (byte *)0;
try
{
if (layerName != null)
{
layerNamePtr = (byte *)Marshal.StringToHGlobalAnsi(layerName).ToPointer();
}
VkExtensionProperties[] props;
uint count = 0;
do
{
props = new VkExtensionProperties[count];
fixed(VkExtensionProperties *pptr = props)
VkException.Check(vkEnumerateDeviceExtensionProperties(this, layerNamePtr, &count, pptr));
} while (props.Length != count);
return(props);
}
finally
{
if (layerNamePtr != (byte *)0)
{
Marshal.FreeHGlobal(new IntPtr(layerNamePtr));
}
}
}
}
public static string[] EnumerateInstanceExtensions()
{
uint propCount = 0;
VkResult result = vkEnumerateInstanceExtensionProperties((byte *)null, ref propCount, null);
CheckResult(result);
if (propCount == 0)
{
return(Array.Empty <string>());
}
VkExtensionProperties[] props = new VkExtensionProperties[propCount];
vkEnumerateInstanceExtensionProperties((byte *)null, ref propCount, ref props[0]);
string[] ret = new string[propCount];
for (int i = 0; i < propCount; i++)
{
fixed(byte *extensionNamePtr = props[i].extensionName)
{
ret[i] = Utilities.GetString(extensionNamePtr);
}
}
return(ret);
}
public unsafe bool GetDeviceExtensionSupported(string extName)
{
uint propCount = 0;
vkEnumerateDeviceExtensionProperties(phy, IntPtr.Zero, out propCount, IntPtr.Zero);
VkExtensionProperties[] extProps = new VkExtensionProperties[propCount];
vkEnumerateDeviceExtensionProperties(phy, IntPtr.Zero, out propCount, extProps.Pin());
extProps.Unpin();
for (int i = 0; i < extProps.Length; i++)
{
fixed(VkExtensionProperties *ep = extProps)
{
IntPtr n = (IntPtr)ep[i].extensionName;
if (Marshal.PtrToStringAnsi(n) == extName)
{
return(true);
}
}
}
Console.WriteLine($"INFO: unsuported device extension: {extName}");
return(false);
}
public DummyPhysicalDevice(SoftwareInstance instance)
{
m_Instance = instance;
m_QueueFamilyProperties.Add(VkQueueFamilyProperties.Create(1, VkQueueFlagBits.VK_QUEUE_GRAPHICS_BIT));
m_QueueFamilyProperties.Add(VkQueueFamilyProperties.Create(1, VkQueueFlagBits.VK_QUEUE_COMPUTE_BIT));
m_ExtensionProperties.Add(VkExtensionProperties.Create(VkExtensionNames.VK_KHR_SWAPCHAIN_EXTENSION_NAME, 1));
}
private unsafe ReadOnlyCollection <ExtensionProperties> EnumerateDeviceExtensions()
{
VkExtensionProperties[] vkProps = _gd.GetDeviceExtensionProperties();
ExtensionProperties[] veldridProps = new ExtensionProperties[vkProps.Length];
for (int i = 0; i < vkProps.Length; i++)
{
VkExtensionProperties prop = vkProps[i];
veldridProps[i] = new ExtensionProperties(Util.GetString(prop.extensionName), prop.specVersion);
}
return(new ReadOnlyCollection <ExtensionProperties>(veldridProps));
}
private bool checkDeviceExtensionsSupport(VkPhysicalDevice physicalDevice)
{
int extensionCount = 0;
Vulkan.vkEnumerateDeviceExtensionProperties(physicalDevice, null, ref extensionCount, null);
VkExtensionProperties[] availableExtensions = new VkExtensionProperties[extensionCount];
Vulkan.vkEnumerateDeviceExtensionProperties(physicalDevice, null, ref extensionCount, availableExtensions);
HashSet <string> requiredExtensions = new HashSet <string>(deviceExtensions);
foreach (var extension in availableExtensions)
{
requiredExtensions.Remove(extension.extensionName);
}
return(!requiredExtensions.Any());
}
unsafe void init()
{
// Gather physical Device memory properties
IntPtr tmp = Marshal.AllocHGlobal(Marshal.SizeOf <VkPhysicalDeviceMemoryProperties>());
vkGetPhysicalDeviceMemoryProperties(phy, tmp);
memoryProperties = Marshal.PtrToStructure <VkPhysicalDeviceMemoryProperties> (tmp);
uint queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(phy, out queueFamilyCount, IntPtr.Zero);
QueueFamilies = new VkQueueFamilyProperties[queueFamilyCount];
if (queueFamilyCount <= 0)
{
throw new Exception("No queues found for physical device");
}
vkGetPhysicalDeviceQueueFamilyProperties(phy, out queueFamilyCount, QueueFamilies.Pin());
QueueFamilies.Unpin();
uint propCount = 0;
vkEnumerateDeviceExtensionProperties(phy, IntPtr.Zero, out propCount, IntPtr.Zero);
VkExtensionProperties[] extProps = new VkExtensionProperties[propCount];
vkEnumerateDeviceExtensionProperties(phy, IntPtr.Zero, out propCount, extProps.Pin());
extProps.Unpin();
for (int i = 0; i < extProps.Length; i++)
{
fixed(VkExtensionProperties *ep = extProps)
{
IntPtr n = (IntPtr)ep[i].extensionName;
switch (Marshal.PtrToStringAnsi(n))
{
case "VK_KHR_swapchain":
HasSwapChainSupport = true;
break;
}
}
}
}
/// <summary>
/// Gets the extension properties available on the passed device.
/// </summary>
/// <param name="device">The device to get the extensions on.</param>
public static VkExtensionProperties[] GetExtensions(VkPhysicalDevice device)
{
if (!device)
{
throw new ArgumentNullException(nameof(device), "Cannot pass null device or device handle");
}
uint extCount;
device.EnumerateDeviceExtensionProperties(null, &extCount, null).Throw("EnumerateDeviceExtensionProperties");
var props = new VkExtensionProperties[extCount];
fixed(VkExtensionProperties *extPtr = props)
{
device.EnumerateDeviceExtensionProperties(null, &extCount, extPtr).Throw("EnumerateDeviceExtensionProperties");
}
return(props);
}
/// <summary>
/// Returns properties of available physical device extensions
/// </summary>
/// <param name="physicalDevice">The <see cref="VkPhysicalDevice"/> that will be queried.</param>
/// <param name="layerName">Is either null/empty or a string naming the layer to retrieve extensions from.</param>
/// <returns>A <see cref="ReadOnlySpan{VkExtensionProperties}"/>.</returns>
/// <exception cref="VkException">Vulkan returns an error code.</exception>
public static ReadOnlySpan <VkExtensionProperties> vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, string layerName = "")
{
int dstLayerNameByteCount = Interop.GetMaxByteCount(layerName);
var dstLayerNamePtr = stackalloc byte[dstLayerNameByteCount];
Interop.StringToPointer(layerName, dstLayerNamePtr, dstLayerNameByteCount);
uint propertyCount = 0;
vkEnumerateDeviceExtensionProperties(physicalDevice, dstLayerNamePtr, &propertyCount, null).CheckResult();
ReadOnlySpan <VkExtensionProperties> properties = new VkExtensionProperties[propertyCount];
fixed(VkExtensionProperties *propertiesPtr = properties)
{
vkEnumerateDeviceExtensionProperties(physicalDevice, dstLayerNamePtr, &propertyCount, propertiesPtr).CheckResult();
}
return(properties);
}
/// <summary>
/// Returns up to requested number of global extension properties
/// </summary>
/// <param name="layerName">Is either null/empty or a string naming the layer to retrieve extensions from.</param>
/// <returns>A <see cref="ReadOnlySpan{VkExtensionProperties}"/> </returns>
/// <exception cref="VkException">Vulkan returns an error code.</exception>
public static unsafe ReadOnlySpan <VkExtensionProperties> vkEnumerateInstanceExtensionProperties(string?layerName = null)
{
int dstLayerNameByteCount = Interop.GetMaxByteCount(layerName);
byte *dstLayerNamePtr = stackalloc byte[dstLayerNameByteCount];
Interop.StringToPointer(layerName, dstLayerNamePtr, dstLayerNameByteCount);
uint count = 0;
vkEnumerateInstanceExtensionProperties(dstLayerNamePtr, &count, null).CheckResult();
ReadOnlySpan <VkExtensionProperties> properties = new VkExtensionProperties[count];
fixed(VkExtensionProperties *ptr = properties)
{
vkEnumerateInstanceExtensionProperties(dstLayerNamePtr, &count, ptr).CheckResult();
}
return(properties);
}
public static string GetExtensionName(this VkExtensionProperties properties)
{
return(Interop.GetString(properties.extensionName));
}
private IntPtr CreateInstance()
{
var enabledExtensionCount = 0u;
var isSurfaceExtensionSupported = false;
var isWin32SurfaceExtensionSupported = false;
var isXlibSurfaceExtensionSupported = false;
var isDebugReportExtensionSupported = false;
var extensionPropertyCount = 0u;
ThrowExternalExceptionIfFailed(nameof(vkEnumerateInstanceExtensionProperties), vkEnumerateInstanceExtensionProperties(pLayerName: null, &extensionPropertyCount, pProperties: null));
var extensionProperties = new VkExtensionProperties[extensionPropertyCount];
fixed(VkExtensionProperties *pExtensionProperties = extensionProperties)
{
ThrowExternalExceptionIfFailed(nameof(vkEnumerateInstanceExtensionProperties), vkEnumerateInstanceExtensionProperties(pLayerName: null, &extensionPropertyCount, pExtensionProperties));
}
for (var i = 0; i < extensionProperties.Length; i++)
{
var extensionName = new ReadOnlySpan <sbyte>(Unsafe.AsPointer(ref extensionProperties[i].extensionName[0]), int.MaxValue);
extensionName = extensionName.Slice(0, extensionName.IndexOf((sbyte)'\0') + 1);
if (!isSurfaceExtensionSupported && VK_KHR_SURFACE_EXTENSION_NAME.SequenceEqual(extensionName))
{
isSurfaceExtensionSupported = true;
enabledExtensionCount++;
}
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
if (!isWin32SurfaceExtensionSupported && VK_KHR_WIN32_SURFACE_EXTENSION_NAME.SequenceEqual(extensionName))
{
isWin32SurfaceExtensionSupported = true;
enabledExtensionCount++;
}
}
else
{
if (!isXlibSurfaceExtensionSupported && VK_KHR_XLIB_SURFACE_EXTENSION_NAME.SequenceEqual(extensionName))
{
isXlibSurfaceExtensionSupported = true;
enabledExtensionCount++;
}
}
#if DEBUG
if (!isDebugReportExtensionSupported && VK_EXT_DEBUG_REPORT_EXTENSION_NAME.SequenceEqual(extensionName))
{
isDebugReportExtensionSupported = true;
enabledExtensionCount++;
}
#endif
}
var enabledExtensionNames = stackalloc sbyte *[(int)enabledExtensionCount];
if (!isSurfaceExtensionSupported)
{
ThrowInvalidOperationException(nameof(isSurfaceExtensionSupported), isSurfaceExtensionSupported);
}
enabledExtensionNames[0] = (sbyte *)Unsafe.AsPointer(ref MemoryMarshal.GetReference(VK_KHR_SURFACE_EXTENSION_NAME));
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
if (!isWin32SurfaceExtensionSupported)
{
ThrowInvalidOperationException(nameof(isWin32SurfaceExtensionSupported), isWin32SurfaceExtensionSupported);
}
enabledExtensionNames[1] = (sbyte *)Unsafe.AsPointer(ref MemoryMarshal.GetReference(VK_KHR_WIN32_SURFACE_EXTENSION_NAME));
}
else
{
if (!isXlibSurfaceExtensionSupported)
{
ThrowInvalidOperationException(nameof(isXlibSurfaceExtensionSupported), isXlibSurfaceExtensionSupported);
}
enabledExtensionNames[1] = (sbyte *)Unsafe.AsPointer(ref MemoryMarshal.GetReference(VK_KHR_XLIB_SURFACE_EXTENSION_NAME));
}
if (isDebugReportExtensionSupported)
{
// We don't want to throw if the debug extension isn't available
enabledExtensionNames[2] = (sbyte *)Unsafe.AsPointer(ref MemoryMarshal.GetReference(VK_EXT_DEBUG_REPORT_EXTENSION_NAME));
}
var enabledLayerCount = 0u;
var isLunarGStandardValidationLayerSupported = false;
#if DEBUG
var layerPropertyCount = 0u;
ThrowExternalExceptionIfFailed(nameof(vkEnumerateInstanceLayerProperties), vkEnumerateInstanceLayerProperties(&layerPropertyCount, pProperties: null));
var layerProperties = new VkLayerProperties[layerPropertyCount];
fixed(VkLayerProperties *pLayerProperties = layerProperties)
{
ThrowExternalExceptionIfFailed(nameof(vkEnumerateInstanceLayerProperties), vkEnumerateInstanceLayerProperties(&layerPropertyCount, pLayerProperties));
}
for (var i = 0; i < layerProperties.Length; i++)
{
var layerName = new ReadOnlySpan <sbyte>(Unsafe.AsPointer(ref layerProperties[i].layerName[0]), int.MaxValue);
layerName = layerName.Slice(0, layerName.IndexOf((sbyte)'\0') + 1);
if (!isLunarGStandardValidationLayerSupported && VK_LAYER_LUNARG_STANDARD_VALIDATION_LAYER_NAME.SequenceEqual(layerName))
{
isLunarGStandardValidationLayerSupported = true;
enabledLayerCount++;
}
}
#endif
var enabledLayerNames = stackalloc sbyte *[(int)enabledLayerCount];
if (isLunarGStandardValidationLayerSupported)
{
enabledLayerNames[0] = (sbyte *)Unsafe.AsPointer(ref MemoryMarshal.GetReference(VK_LAYER_LUNARG_STANDARD_VALIDATION_LAYER_NAME));
}
var applicationInfo = new VkApplicationInfo {
sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
pNext = null,
pApplicationName = null,
applicationVersion = 1,
pEngineName = (sbyte *)Unsafe.AsPointer(ref MemoryMarshal.GetReference(s_engineName)),
engineVersion = VK_MAKE_VERSION(0, 1, 0),
apiVersion = VK_API_VERSION_1_0,
};
var createInfo = new VkInstanceCreateInfo {
sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
pNext = null,
flags = 0,
pApplicationInfo = &applicationInfo,
enabledLayerCount = enabledLayerCount,
ppEnabledLayerNames = enabledLayerNames,
enabledExtensionCount = enabledExtensionCount,
ppEnabledExtensionNames = enabledExtensionNames,
};
IntPtr instance;
var result = vkCreateInstance(&createInfo, null, &instance);
if (result != VK_SUCCESS)
{
ThrowExternalException(nameof(vkCreateInstance), (int)result);
}
if (isDebugReportExtensionSupported && isLunarGStandardValidationLayerSupported)
{
#if DEBUG
ulong debugReportCallbackExt;
_debugReportCallback = new NativeDelegate <PFN_vkDebugReportCallbackEXT>(DebugReportCallback);
var debugReportCallbackCreateInfo = new VkDebugReportCallbackCreateInfoEXT {
sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
pNext = null,
flags = (uint)(VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT),
pfnCallback = _debugReportCallback,
pUserData = null,
};
// We don't want to fail if creating the debug report callback failed
var vkCreateDebugReportCallbackEXT = vkGetInstanceProcAddr(instance, (sbyte *)Unsafe.AsPointer(ref MemoryMarshal.GetReference(VKCREATEDEBUGREPORTCALLBACKEXT_FUNCTION_NAME)));
_ = Marshal.GetDelegateForFunctionPointer <PFN_vkCreateDebugReportCallbackEXT>(vkCreateDebugReportCallbackEXT)(instance, &debugReportCallbackCreateInfo, pAllocator : null, &debugReportCallbackExt);
_debugReportCallbackExt = debugReportCallbackExt;
#endif
}
return(instance);
}
