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