static void Main(string[] args) { VkInstance inst; using (VkApplicationInfo ai = new VkApplicationInfo()) { using (VkInstanceCreateInfo ci = new VkInstanceCreateInfo { pApplicationInfo = ai }){ CheckResult(vkCreateInstance(ci, IntPtr.Zero, out inst)); } } Vk.LoadInstanceFunctionPointers(inst); CheckResult(vkEnumeratePhysicalDevices(inst, out uint phyCount, IntPtr.Zero)); VkPhysicalDevice[] phys = new VkPhysicalDevice[phyCount]; CheckResult(vkEnumeratePhysicalDevices(inst, out phyCount, phys.Pin())); for (int i = 0; i < phys.Length; i++) { vkGetPhysicalDeviceProperties(phys[i], out VkPhysicalDeviceProperties props); Console.WriteLine($"{props.deviceName}"); Console.WriteLine($"\tdeviceType: {props.deviceType,20}"); Console.WriteLine($"\tapiVersion: {(Version)props.apiVersion,20}"); Console.WriteLine($"\tdriverVersion:{props.driverVersion,20}"); Console.WriteLine($"\tvendorID: {props.vendorID,20}"); } vkDestroyInstance(inst, IntPtr.Zero); }
private VkInstance InitInstance() { var extensions = new string[] { vkAPI.VK_KHR_surface, vkAPI.VK_KHR_win32_surface, vkAPI.VK_EXT_debug_report }; VkLayerProperties[] layerProperties = vkAPI.InstanceLayerProperties(); string layers = layerProperties.Any( l => Marshal.PtrToStringAnsi((IntPtr)l.layerName) == VK_LAYER_LUNARG_standard_validation) ? VK_LAYER_LUNARG_standard_validation : null; var appInfo = new VkApplicationInfo { sType = VkStructureType.ApplicationInfo }; appInfo.apiVersion = Vulkan.VkVersion.Make(1, 0, 0); appInfo.pApplicationName = "Hello Vulkan"; appInfo.pEngineName = "Hello Engine"; var info = new VkInstanceCreateInfo { sType = VkStructureType.InstanceCreateInfo }; info.EnabledExtensions = extensions; info.EnabledLayers = layers; info.pApplicationInfo = &appInfo; VkInstance vkInstance; vkAPI.vkCreateInstance(&info, null, &vkInstance).Check(); info.Free(); appInfo.Free(); return(vkInstance); }
private VkResult CreateInstance(bool enableValidation) { Settings.Validation = enableValidation; VkApplicationInfo appInfo = new VkApplicationInfo() { sType = VkStructureType.ApplicationInfo, apiVersion = new Version(1, 0, 0), pApplicationName = Name, pEngineName = Name, }; NativeList <IntPtr> instanceExtensions = new NativeList <IntPtr>(2); instanceExtensions.Add(Strings.VK_KHR_SURFACE_EXTENSION_NAME); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { instanceExtensions.Add(Strings.VK_KHR_WIN32_SURFACE_EXTENSION_NAME); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { instanceExtensions.Add(Strings.VK_KHR_XLIB_SURFACE_EXTENSION_NAME); } else { throw new PlatformNotSupportedException(); } VkInstanceCreateInfo instanceCreateInfo = VkInstanceCreateInfo.New(); instanceCreateInfo.pApplicationInfo = &appInfo; if (instanceExtensions.Count > 0) { if (enableValidation) { instanceExtensions.Add(Strings.VK_EXT_DEBUG_REPORT_EXTENSION_NAME); } instanceCreateInfo.enabledExtensionCount = instanceExtensions.Count; instanceCreateInfo.ppEnabledExtensionNames = (byte **)instanceExtensions.Data; } if (enableValidation) { NativeList <IntPtr> enabledLayerNames = new NativeList <IntPtr>(1); enabledLayerNames.Add(Strings.StandardValidationLayeName); instanceCreateInfo.enabledLayerCount = enabledLayerNames.Count; instanceCreateInfo.ppEnabledLayerNames = (byte **)enabledLayerNames.Data; } VkInstance instance; VkResult result = vkCreateInstance(&instanceCreateInfo, null, &instance); Instance = instance; return(result); }
private void CreateInstance() { #if DEBUG if (!this.CheckValidationLayerSupport()) { throw new Exception("Validation layers requested, but not available!"); } #endif VkApplicationInfo appInfo = new VkApplicationInfo() { sType = VkStructureType.VK_STRUCTURE_TYPE_APPLICATION_INFO, pApplicationName = "Hello Triangle".ToPointer(), applicationVersion = Helpers.Version(1, 0, 0), pEngineName = "No Engine".ToPointer(), engineVersion = Helpers.Version(1, 0, 0), apiVersion = Helpers.Version(1, 2, 0), }; VkInstanceCreateInfo createInfo = default; createInfo.sType = VkStructureType.VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; createInfo.pApplicationInfo = &appInfo; // Extensions this.GetAllInstanceExtensionsAvailables(); IntPtr *extensionsToBytesArray = stackalloc IntPtr[extensions.Length]; for (int i = 0; i < extensions.Length; i++) { extensionsToBytesArray[i] = Marshal.StringToHGlobalAnsi(extensions[i]); } createInfo.enabledExtensionCount = (uint)extensions.Length; createInfo.ppEnabledExtensionNames = (byte **)extensionsToBytesArray; // Validation layers #if DEBUG IntPtr *layersToBytesArray = stackalloc IntPtr[validationLayers.Length]; for (int i = 0; i < validationLayers.Length; i++) { layersToBytesArray[i] = Marshal.StringToHGlobalAnsi(validationLayers[i]); } createInfo.enabledLayerCount = (uint)validationLayers.Length; createInfo.ppEnabledLayerNames = (byte **)layersToBytesArray; #else createInfo.enabledLayerCount = 0; createInfo.pNext = null; #endif fixed(VkInstance *instancePtr = &instance) { Helpers.CheckErrors(VulkanNative.vkCreateInstance(&createInfo, null, instancePtr)); VulkanNative.LoadFuncionPointers(instance); } }
private VkInstance CreateVulkanInstance() { NativeString name = App.Name; NativeString engine = "Foster.Framework"; // create the App Info var appInfo = new VkApplicationInfo { sType = VkStructureType.ApplicationInfo, pApplicationName = name, applicationVersion = VK.MAKE_VERSION(1, 0, 0), pEngineName = engine, engineVersion = VK.MAKE_VERSION(App.Version), apiVersion = VK.MAKE_VERSION(1, 0, 0), }; var createInfo = new VkInstanceCreateInfo { sType = VkStructureType.InstanceCreateInfo, pApplicationInfo = &appInfo, }; // required validation layers using var validationLayerNames = new NativeStringArray(validationLayers); if (HasValidationLayers) { createInfo.enabledLayerCount = validationLayerNames.Length; createInfo.ppEnabledLayerNames = validationLayerNames; } // get the required Vulkan Extensions var exts = System.GetVKExtensions(); if (HasValidationLayers) { exts.Add(VkConst.EXT_DEBUG_UTILS_EXTENSION_NAME); } using var extensions = new NativeStringArray(exts); createInfo.enabledExtensionCount = extensions.Length; createInfo.ppEnabledExtensionNames = extensions; // create instance var result = VK.CreateInstance(&createInfo, null, out var instance); if (result != VkResult.Success) { throw new Exception($"Failed to create Vulkan Instance, {result}"); } return(instance); }
private VkResult CreateInstance(bool enableValidation) { Settings.Validation = enableValidation; VkApplicationInfo appInfo = new VkApplicationInfo(); { appInfo.sType = ApplicationInfo; appInfo.apiVersion = VkVersion.Make(1, 0, 0); //Name.Set(ref appInfo.pApplicationName); appInfo.pApplicationName = Name; //Name.Set(ref appInfo.pEngineName); appInfo.pEngineName = Name; }; var instanceExtensions = new List <string>(); instanceExtensions.Add(Strings.VK_KHR_SURFACE_EXTENSION_NAME); instanceExtensions.Add(Strings.VK_KHR_WIN32_SURFACE_EXTENSION_NAME); VkInstanceCreateInfo instanceCreateInfo = new VkInstanceCreateInfo(); instanceCreateInfo.sType = InstanceCreateInfo; instanceCreateInfo.pApplicationInfo = &appInfo; if (instanceExtensions.Count > 0) { if (enableValidation) { instanceExtensions.Add(Strings.VK_EXT_DEBUG_REPORT_EXTENSION_NAME); } //instanceExtensions.ToArray().Set(ref instanceCreateInfo.ppEnabledExtensionNames, ref instanceCreateInfo.enabledExtensionCount); instanceCreateInfo.EnabledExtensions = instanceExtensions.ToArray(); } if (enableValidation) { var enabledLayerNames = new List <string>(); enabledLayerNames.Add(Strings.StandardValidationLayeName); //enabledLayerNames.ToArray().Set(ref instanceCreateInfo.ppEnabledLayerNames, ref instanceCreateInfo.enabledLayerCount); instanceCreateInfo.EnabledLayers = enabledLayerNames.ToArray(); } VkInstance instance; VkResult result = vkCreateInstance(&instanceCreateInfo, null, &instance); Instance = instance; return(result); }
void CreateInstance(InstanceCreateInfo mInfo) { InteropString appName = null; InteropString engineName = null; Marshalled <VkApplicationInfo> appInfoMarshalled = null; var extensionsMarshalled = new NativeStringArray(mInfo.extensions); var layersMarshalled = new NativeStringArray(mInfo.layers); var info = new VkInstanceCreateInfo(); info.sType = VkStructureType.InstanceCreateInfo; info.enabledExtensionCount = (uint)extensionsMarshalled.Count; info.ppEnabledExtensionNames = extensionsMarshalled.Address; info.enabledLayerCount = (uint)layersMarshalled.Count; info.ppEnabledLayerNames = layersMarshalled.Address; if (mInfo.applicationInfo != null) { var appInfo = new VkApplicationInfo(); appInfo.sType = VkStructureType.ApplicationInfo; appInfo.apiVersion = mInfo.applicationInfo.apiVersion; appInfo.engineVersion = mInfo.applicationInfo.engineVersion; appInfo.applicationVersion = mInfo.applicationInfo.applicationVersion; appName = new InteropString(mInfo.applicationInfo.applicationName); appInfo.pApplicationName = appName.Address; engineName = new InteropString(mInfo.applicationInfo.engineName); appInfo.pEngineName = engineName.Address; appInfoMarshalled = new Marshalled <VkApplicationInfo>(appInfo); info.pApplicationInfo = appInfoMarshalled.Address; } using (appName) //appName, engineName, and appInfoMarshalled may be null using (engineName) using (appInfoMarshalled) using (extensionsMarshalled) using (layersMarshalled) { var result = createInstance(ref info, alloc, out instance); if (result != VkResult.Success) { throw new InstanceException(string.Format("Error creating instance: {0}", result)); } } }
void CreateInstance() { var extensions = new List <string>(GLFW.GetRequiredInstanceExceptions()); var appInfo = new VkApplicationInfo { apiVersion = new VkVersion(1, 0, 0), applicationVersion = new VkVersion(1, 0, 0), engineVersion = new VkVersion(1, 0, 0), applicationName = "All Colors", }; var info = new VkInstanceCreateInfo { applicationInfo = appInfo, extensions = extensions, layers = layers }; instance = new VkInstance(info); }
private void createInstance() { if (enableValidationLayers && !checkValidationLayerSupport()) { throw Program.Throw("validation layers requested, but not available"); } VkApplicationInfo appInfo = new VkApplicationInfo(); appInfo.sType = VkStructureType.VK_STRUCTURE_TYPE_APPLICATION_INFO; appInfo.pApplicationName = "Hello Triangle"; appInfo.applicationVersion = Vulkan.VK_MAKE_VERSION(1, 0, 0); appInfo.pEngineName = "No Engine"; appInfo.engineVersion = Vulkan.VK_MAKE_VERSION(1, 0, 0); appInfo.apiVersion = VkApiVersion.VK_API_VERSION_1_0; VkInstanceCreateInfo createInfo = new VkInstanceCreateInfo(); createInfo.sType = VkStructureType.VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; createInfo.pApplicationInfo = appInfo; List <string> extensions = getRequiredExtensions(); createInfo.enabledExtensionCount = extensions.Count; createInfo.ppEnabledExtensionNames = extensions.ToArray(); if (enableValidationLayers) { createInfo.enabledLayerCount = validationLayers.Length; createInfo.ppEnabledLayerNames = validationLayers; } else { createInfo.enabledLayerCount = 0; } VkResult result = Vulkan.vkCreateInstance(createInfo, null, out instance); if (result != VkResult.VK_SUCCESS) { throw Program.Throw("failed to create instance!", result); } }
void CreateInstance() { var appName = new InteropString("Hello Triangle"); var appInfo = new VkApplicationInfo(); appInfo.sType = CSGL.Vulkan.VkStructureType.ApplicationInfo; appInfo.pApplicationName = appName.Address; appInfo.applicationVersion = new CSGL.Vulkan.VkVersion(1, 0, 0); appInfo.engineVersion = new CSGL.Vulkan.VkVersion(0, 0, 1); appInfo.apiVersion = new CSGL.Vulkan.VkVersion(1, 0, 0); var appInfoNative = new Native <VkApplicationInfo>(appInfo); var info = new VkInstanceCreateInfo(); info.sType = CSGL.Vulkan.VkStructureType.InstanceCreateInfo; info.pApplicationInfo = appInfoNative.Address; var extensions = GLFW.GetRequiredInstanceExceptions(); var extensionsNative = new NativeStringArray(extensions); info.ppEnabledExtensionNames = extensionsNative.Address; info.enabledExtensionCount = (uint)extensions.Count; var layersNative = new NativeStringArray(layers); info.ppEnabledLayerNames = layersNative.Address; info.enabledLayerCount = (uint)layers.Length; var result = VK.CreateInstance(ref info, alloc, out instance); appName.Dispose(); appInfoNative.Dispose(); extensionsNative.Dispose(); layersNative.Dispose(); }
void CreateInstance() { var extensions = new List <string>(GLFW.GetRequiredInstanceExceptions()); foreach (var extension in instanceExtensions) { extensions.Add(extension); } var appInfo = new VkApplicationInfo { apiVersion = new VkVersion(1, 0, 0), applicationVersion = new VkVersion(1, 0, 0), engineVersion = new VkVersion(1, 0, 0), applicationName = "Hello Triangle" }; var info = new VkInstanceCreateInfo { applicationInfo = appInfo, extensions = extensions, layers = layers }; instance = new VkInstance(info); }
private void CreateInstance() { var appInfo = new VkApplicationInfo { ApplicationName = "Hello Triangle", ApplicationVersion = (uint)new VkApiVersion(1, 0, 0).Raw, EngineName = "No Engine", EngineVersion = (uint)new VkApiVersion(1, 0, 0).Raw, ApiVersion = new VkApiVersion(1, 0, 0) }; var instanceCreateInfo = new VkInstanceCreateInfo { ApplicationInfo = appInfo, EnabledExtensionNames = new[] { "VK_KHR_surface", "VK_KHR_win32_surface", VkDefines.VK_EXT_DEBUG_REPORT_EXTENSION_NAME }, EnabledLayerNames = LayerNames }; instance = vkGlobal.CreateInstance(instanceCreateInfo, null).Object; }
static void Main(string[] args) { VkInstance instance; #if AUTO_SET_STYPE Console.WriteLine("AUTO_SET_STYPE: ON"); using (VkApplicationInfo ai = new VkApplicationInfo()) { using (VkInstanceCreateInfo ci = new VkInstanceCreateInfo { pApplicationInfo = ai }){ Console.WriteLine(vkCreateInstance(ci, IntPtr.Zero, out instance)); } } #else Console.WriteLine("AUTO_SET_STYPE: OFF"); using (VkApplicationInfo ai = VkApplicationInfo.New) { VkInstanceCreateInfo ci = VkInstanceCreateInfo.New; ci.pApplicationInfo = ai; Console.WriteLine(vkCreateInstance(ci, IntPtr.Zero, out instance)); ci.Dispose(); } #endif vkDestroyInstance(instance, IntPtr.Zero); }
public static void Init() { optionalExtn_avail = new bool[optionalDeviceExtns.Length]; Console.BackgroundColor = ConsoleColor.Black; Console.ForegroundColor = ConsoleColor.White; Window = new GameWindow(AppName); fixed(IntPtr *instancePtr = &instanceHndl) fixed(IntPtr * surfacePtr = &surfaceHndl) { VkResult res; var instLayers = new List <string>(); var instExtns = new List <string>(); var devExtns = new List <string>(); uint glfwExtnCnt = 0; var glfwExtns = glfwGetRequiredInstanceExtensions(&glfwExtnCnt); for (int i = 0; i < glfwExtnCnt; i++) { instExtns.Add(Marshal.PtrToStringAnsi(glfwExtns[i])); } instExtns.Add(VkKhrGetPhysicalDeviceProperties2ExtensionName); if (EnableValidation) { instLayers.Add("VK_LAYER_KHRONOS_validation"); instExtns.Add(VkExtDebugUtilsExtensionName); } var layers = stackalloc IntPtr[instLayers.Count]; for (int i = 0; i < instLayers.Count; i++) { layers[i] = Marshal.StringToHGlobalAnsi(instLayers[i]); } var extns = stackalloc IntPtr[instExtns.Count]; for (int i = 0; i < instExtns.Count; i++) { extns[i] = Marshal.StringToHGlobalAnsi(instExtns[i]); } { var appInfo = new VkApplicationInfo() { sType = VkStructureType.StructureTypeApplicationInfo, pApplicationName = AppName, pEngineName = EngineName, apiVersion = VkApiVersion12, applicationVersion = 1, engineVersion = 1, pNext = IntPtr.Zero }; var appInfo_ptr = appInfo.Pointer(); var instCreatInfo = new VkInstanceCreateInfo() { sType = VkStructureType.StructureTypeInstanceCreateInfo, pApplicationInfo = appInfo_ptr, }; instCreatInfo.ppEnabledLayerNames = layers; instCreatInfo.enabledLayerCount = (uint)instLayers.Count; instCreatInfo.ppEnabledExtensionNames = extns; instCreatInfo.enabledExtensionCount = (uint)instExtns.Count; var instCreatInfo_ptr = instCreatInfo.Pointer(); //register instance create debug message handler debugCreatInfo = new VkDebugUtilsMessengerCreateInfoEXT() { sType = VkStructureType.StructureTypeDebugUtilsMessengerCreateInfoExt, messageSeverity = VkDebugUtilsMessageSeverityFlagsEXT.DebugUtilsMessageSeverityErrorBitExt | VkDebugUtilsMessageSeverityFlagsEXT.DebugUtilsMessageSeverityWarningBitExt | VkDebugUtilsMessageSeverityFlagsEXT.DebugUtilsMessageSeverityVerboseBitExt | VkDebugUtilsMessageSeverityFlagsEXT.DebugUtilsMessageSeverityInfoBitExt, messageType = VkDebugUtilsMessageTypeFlagsEXT.DebugUtilsMessageTypeGeneralBitExt | VkDebugUtilsMessageTypeFlagsEXT.DebugUtilsMessageTypePerformanceBitExt | VkDebugUtilsMessageTypeFlagsEXT.DebugUtilsMessageTypeValidationBitExt, pfnUserCallback = DebugCallback }; var debugCreatInfo_ptr = debugCreatInfo.Pointer(); if (EnableValidation) { instCreatInfo.pNext = debugCreatInfo_ptr; } res = vkCreateInstance(instCreatInfo_ptr, null, instancePtr); if (res != VkResult.Success) { throw new Exception("Failed to create instance."); } } if (EnableValidation) { SetupDebugMessengers(instanceHndl); var debugCreatInfo_ptr = debugCreatInfo.Pointer(); fixed(IntPtr *dbg_ptr = &debugMessenger) res = CreateDebugUtilsMessengerEXT(instanceHndl, debugCreatInfo_ptr, IntPtr.Zero, dbg_ptr); if (res != VkResult.Success) { throw new Exception("Failed to register debug callback."); } } res = Window.CreateSurface(instanceHndl, surfacePtr); if (res != VkResult.Success) { throw new Exception("Failed to create surface."); } uint devCount = 0; vkEnumeratePhysicalDevices(instanceHndl, &devCount, null); if (devCount == 0) { throw new Exception("Failed to find Vulkan compatible devices."); } var devices = new IntPtr[devCount]; fixed(IntPtr *devicesPtr = devices) vkEnumeratePhysicalDevices(instanceHndl, &devCount, devicesPtr); var ratedDevices = new List <(uint, IntPtr)>(); for (int i = 0; i < devices.Length; i++) { //rate each device ratedDevices.Add((RateDevice(devices[i]), devices[i])); } var orderedDevices = ratedDevices.OrderByDescending(a => a.Item1) .Select(a => a.Item2) .ToArray(); DeviceInformation = new DeviceInfo[orderedDevices.Length]; DeviceInformation[0] = new DeviceInfo() { PhysicalDevice = orderedDevices[0] }; //TODO for now just choose the first device { //allocate queues for primary device uint graphicsFamily = ~0u; uint computeFamily = ~0u; uint transferFamily = ~0u; uint presentFamily = ~0u; uint qfam_cnt = 0; vkGetPhysicalDeviceQueueFamilyProperties(orderedDevices[0], &qfam_cnt, null); var qFams_ptr = new ManagedPtrArray <VkQueueFamilyProperties>(qfam_cnt); vkGetPhysicalDeviceQueueFamilyProperties(orderedDevices[0], &qfam_cnt, qFams_ptr); var qFams = qFams_ptr.Value; uint qFamIdx = 0; foreach (var qFam in qFams) { bool presentSupport = false; vkGetPhysicalDeviceSurfaceSupportKHR(orderedDevices[0], qFamIdx, surfaceHndl, &presentSupport); if ((qFam.queueFlags & VkQueueFlags.QueueGraphicsBit) != 0 && graphicsFamily == ~0u) { graphicsFamily = qFamIdx; if (presentSupport) { presentFamily = qFamIdx; } qFamIdx++; continue; } if ((qFam.queueFlags & VkQueueFlags.QueueComputeBit) != 0 && computeFamily == ~0u) { computeFamily = qFamIdx; if ((qFam.queueFlags & VkQueueFlags.QueueTransferBit) != 0) { transferFamily = qFamIdx; } qFamIdx++; continue; } if ((qFam.queueFlags & VkQueueFlags.QueueTransferBit) != 0) { transferFamily = qFamIdx; } if (graphicsFamily != ~0u && computeFamily != ~0u && transferFamily != ~0u && presentFamily != ~0u) { break; } qFamIdx++; } if (presentFamily == ~0u) { throw new Exception("Separate present queue support hasn't been implemented."); } var max_q_priority = stackalloc float[] { 1.0f }; var dual_graph_q_priority = stackalloc float[] { 1.0f }; var triple_graph_q_priority = stackalloc float[] { 1.0f, 1.0f, 1.0f }; VkDeviceQueueCreateInfo graphics_qCreatInfo = new VkDeviceQueueCreateInfo() { sType = VkStructureType.StructureTypeDeviceQueueCreateInfo, queueFamilyIndex = graphicsFamily, queueCount = 1, pQueuePriorities = max_q_priority }; VkDeviceQueueCreateInfo compute_qCreatInfo = new VkDeviceQueueCreateInfo { sType = VkStructureType.StructureTypeDeviceQueueCreateInfo, queueFamilyIndex = computeFamily, queueCount = 1, pQueuePriorities = max_q_priority }; VkDeviceQueueCreateInfo transfer_qCreatInfo = new VkDeviceQueueCreateInfo(); if (transferFamily != graphicsFamily) { transfer_qCreatInfo.sType = VkStructureType.StructureTypeDeviceQueueCreateInfo; transfer_qCreatInfo.queueFamilyIndex = transferFamily; transfer_qCreatInfo.queueCount = 1; transfer_qCreatInfo.pQueuePriorities = max_q_priority; } else { graphics_qCreatInfo.queueCount = 2; graphics_qCreatInfo.pQueuePriorities = dual_graph_q_priority; } var qCreatInfos = new VkDeviceQueueCreateInfo[3]; qCreatInfos[0] = graphics_qCreatInfo; qCreatInfos[1] = compute_qCreatInfo; if (transferFamily != graphicsFamily) { qCreatInfos[2] = transfer_qCreatInfo; } DeviceInformation[0].GraphicsFamily = graphicsFamily; DeviceInformation[0].ComputeFamily = computeFamily; DeviceInformation[0].TransferFamily = transferFamily; DeviceInformation[0].PresentFamily = presentFamily; VkPhysicalDeviceFeatures devFeats = new VkPhysicalDeviceFeatures() { multiDrawIndirect = true, drawIndirectFirstInstance = true, fullDrawIndexUint32 = true, tessellationShader = true, fragmentStoresAndAtomics = true, vertexPipelineStoresAndAtomics = true, robustBufferAccess = EnableValidation, shaderInt16 = true, samplerAnisotropy = true, fillModeNonSolid = true, largePoints = true, }; var devFeats11 = new VkPhysicalDeviceVulkan11Features() { sType = VkStructureType.StructureTypePhysicalDeviceVulkan11Features, shaderDrawParameters = true, //storageBuffer16BitAccess = true, //uniformAndStorageBuffer16BitAccess = true, //storagePushConstant16 = true, }; var devFeats11_ptr = devFeats11.Pointer(); /* * var depthStenc = new VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures() * { * sType = VkStructureType.StructureTypePhysicalDeviceSeparateDepthStencilLayoutsFeatures, * separateDepthStencilLayouts = true, * pNext = devFeats11_ptr * }; * var depthStenc_ptr = depthStenc.Pointer(); * * var timelineSems = new VkPhysicalDeviceTimelineSemaphoreFeatures() * { * sType = VkStructureType.StructureTypePhysicalDeviceTimelineSemaphoreFeatures, * timelineSemaphore = true, * pNext = depthStenc_ptr, * }; * var timelineSems_ptr = timelineSems.Pointer(); * * var indirectCnt = new VkPhysicalDeviceShaderFloat16Int8Features() * { * sType = VkStructureType.StructureTypePhysicalDeviceShaderFloat16Int8Features, * shaderFloat16 = true, * shaderInt8 = true, * pNext = timelineSems_ptr, * }; * var indirectCnt_ptr = indirectCnt.Pointer(); * * var uboLayout = new VkPhysicalDeviceUniformBufferStandardLayoutFeatures() * { * sType = VkStructureType.StructureTypePhysicalDeviceUniformBufferStandardLayoutFeatures, * uniformBufferStandardLayout = true, * pNext = indirectCnt_ptr * }; * var uboLayout_ptr = uboLayout.Pointer(); * * var storageByte = new VkPhysicalDevice8BitStorageFeatures() * { * sType = VkStructureType.StructureTypePhysicalDevice8bitStorageFeatures, * storageBuffer8BitAccess = true, * uniformAndStorageBuffer8BitAccess = true, * pNext = uboLayout_ptr * }; * var storageByte_ptr = storageByte.Pointer(); * var descIndexing = new VkPhysicalDeviceDescriptorIndexingFeatures() * { * sType = VkStructureType.StructureTypePhysicalDeviceDescriptorIndexingFeatures, * descriptorBindingSampledImageUpdateAfterBind = true, * descriptorBindingStorageBufferUpdateAfterBind = true, * descriptorBindingStorageImageUpdateAfterBind = true, * descriptorBindingStorageTexelBufferUpdateAfterBind = true, * descriptorBindingUniformBufferUpdateAfterBind = true, * descriptorBindingUniformTexelBufferUpdateAfterBind = true, * descriptorBindingUpdateUnusedWhilePending = true, * descriptorBindingPartiallyBound = true, * shaderStorageTexelBufferArrayDynamicIndexing = true, * pNext = storageByte_ptr, * }; * var descIndexing_ptr = descIndexing.Pointer();*/ //var drawIndirectCount = new VkDrawIndirecCount var devFeats12 = new VkPhysicalDeviceVulkan12Features() { sType = VkStructureType.StructureTypePhysicalDeviceVulkan12Features, separateDepthStencilLayouts = true, timelineSemaphore = true, drawIndirectCount = true, shaderFloat16 = true, shaderInt8 = true, uniformBufferStandardLayout = true, storageBuffer8BitAccess = true, uniformAndStorageBuffer8BitAccess = true, descriptorIndexing = true, descriptorBindingSampledImageUpdateAfterBind = true, descriptorBindingStorageBufferUpdateAfterBind = true, descriptorBindingStorageImageUpdateAfterBind = true, descriptorBindingStorageTexelBufferUpdateAfterBind = true, descriptorBindingUniformBufferUpdateAfterBind = true, descriptorBindingUniformTexelBufferUpdateAfterBind = true, descriptorBindingUpdateUnusedWhilePending = true, descriptorBindingPartiallyBound = true, shaderStorageTexelBufferArrayDynamicIndexing = true, shaderStorageBufferArrayNonUniformIndexing = true, runtimeDescriptorArray = true, descriptorBindingVariableDescriptorCount = true, pNext = devFeats11_ptr }; var devFeats12_ptr = devFeats12.Pointer(); devExtns.AddRange(requiredDeviceExtns); for (int i = 0; i < optionalExtn_avail.Length; i++) { if (optionalExtn_avail[i]) { devExtns.Add(optionalDeviceExtns[i]); } } var devExtns_ptr = stackalloc IntPtr[devExtns.Count]; for (int i = 0; i < devExtns.Count; i++) { devExtns_ptr[i] = Marshal.StringToHGlobalAnsi(devExtns[i]); } var qCreatInfos_ptr = qCreatInfos.Pointer(); var devFeats_ptr = devFeats.Pointer(); var devCreatInfo = new VkDeviceCreateInfo() { sType = VkStructureType.StructureTypeDeviceCreateInfo, queueCreateInfoCount = (uint)(transferFamily != graphicsFamily ? 3 : 2), enabledExtensionCount = (uint)devExtns.Count, ppEnabledExtensionNames = devExtns_ptr, enabledLayerCount = (uint)instLayers.Count, ppEnabledLayerNames = layers, pEnabledFeatures = devFeats_ptr, pQueueCreateInfos = qCreatInfos_ptr, pNext = devFeats12_ptr }; var devCreatInfo_ptr = devCreatInfo.Pointer(); IntPtr deviceHndl = IntPtr.Zero; res = vkCreateDevice(orderedDevices[0], devCreatInfo_ptr, null, &deviceHndl); if (res != VkResult.Success) { throw new Exception("Failed to create logical device."); } DeviceInformation[0].Device = deviceHndl; //Setup memory allocator var allocCreatInfo = new VmaAllocatorCreateInfo() { physicalDevice = DeviceInformation[0].PhysicalDevice, device = DeviceInformation[0].Device }; var allocCreatInfo_ptr = allocCreatInfo.Pointer(); fixed(IntPtr *vma_alloc_ptr = &DeviceInformation[0].vmaAllocator) res = vmaCreateAllocator(allocCreatInfo_ptr, vma_alloc_ptr); if (res != VkResult.Success) { throw new Exception("Failed to initialize allocator."); } IntPtr graph_q_hndl = IntPtr.Zero; IntPtr trans_q_hndl = IntPtr.Zero; IntPtr comp_q_hndl = IntPtr.Zero; vkGetDeviceQueue(DeviceInformation[0].Device, graphicsFamily, 0, &graph_q_hndl); vkGetDeviceQueue(DeviceInformation[0].Device, computeFamily, 0, &comp_q_hndl); if (transferFamily != graphicsFamily) { vkGetDeviceQueue(DeviceInformation[0].Device, transferFamily, 0, &trans_q_hndl); } else { vkGetDeviceQueue(DeviceInformation[0].Device, graphicsFamily, 1, &trans_q_hndl); } DeviceInformation[0].GraphicsQueue = new GpuQueue(CommandQueueKind.Graphics, graph_q_hndl, graphicsFamily, 0); DeviceInformation[0].TransferQueue = new GpuQueue(CommandQueueKind.Transfer, trans_q_hndl, transferFamily, 0); DeviceInformation[0].ComputeQueue = new GpuQueue(CommandQueueKind.Compute, comp_q_hndl, computeFamily, 0); var queue_indices = new List <uint>(); if (!queue_indices.Contains(DeviceInformation[0].GraphicsFamily)) { queue_indices.Add(DeviceInformation[0].GraphicsFamily); } if (!queue_indices.Contains(DeviceInformation[0].ComputeFamily)) { queue_indices.Add(DeviceInformation[0].ComputeFamily); } if (!queue_indices.Contains(DeviceInformation[0].PresentFamily)) { queue_indices.Add(DeviceInformation[0].PresentFamily); } if (!queue_indices.Contains(DeviceInformation[0].TransferFamily)) { queue_indices.Add(DeviceInformation[0].TransferFamily); } DeviceInformation[0].QueueFamilyIndices = queue_indices.ToArray(); var physDeviceProps = new ManagedPtr <VkPhysicalDeviceProperties>(); vkGetPhysicalDeviceProperties(DeviceInformation[0].PhysicalDevice, physDeviceProps); DeviceInformation[0].Properties = physDeviceProps.Value; var caps_ptr = new ManagedPtr <VkSurfaceCapabilitiesKHR>(); vkGetPhysicalDeviceSurfaceCapabilitiesKHR(DeviceInformation[0].PhysicalDevice, surfaceHndl, caps_ptr); var caps = caps_ptr.Value; VkExtent2D cur_extent = new VkExtent2D(); if (caps.currentExtent.width != uint.MaxValue) { cur_extent = caps.currentExtent; } else { cur_extent.width = System.Math.Clamp((uint)Window.Width, caps.minImageExtent.width, caps.maxImageExtent.width); cur_extent.height = System.Math.Clamp((uint)Window.Height, caps.minImageExtent.height, caps.maxImageExtent.height); } uint img_cnt = caps.minImageCount + 1; VkSwapchainCreateInfoKHR swapCreatInfo = new VkSwapchainCreateInfoKHR() { sType = VkStructureType.StructureTypeSwapchainCreateInfoKhr, surface = surfaceHndl, minImageCount = img_cnt, imageFormat = surface_fmt.format, imageColorSpace = surface_fmt.colorSpace, imageExtent = cur_extent, imageArrayLayers = 1, imageUsage = VkImageUsageFlags.ImageUsageColorAttachmentBit | VkImageUsageFlags.ImageUsageTransferDstBit | VkImageUsageFlags.ImageUsageTransferSrcBit, imageSharingMode = VkSharingMode.SharingModeExclusive, queueFamilyIndexCount = 0, pQueueFamilyIndices = null, preTransform = caps.currentTransform, compositeAlpha = VkCompositeAlphaFlagsKHR.CompositeAlphaOpaqueBitKhr, presentMode = present_mode, clipped = true, oldSwapchain = IntPtr.Zero }; var swapCreatInfo_ptr = swapCreatInfo.Pointer(); fixed(IntPtr *swapchain_ptr = &swapChainHndl) res = vkCreateSwapchainKHR(DeviceInformation[0].Device, swapCreatInfo_ptr, null, swapchain_ptr); if (res != VkResult.Success) throw new Exception("Failed to create swapchain."); fixed(uint *swapchain_img_cnt_ptr = &swapchain_img_cnt) { vkGetSwapchainImagesKHR(DeviceInformation[0].Device, swapChainHndl, swapchain_img_cnt_ptr, null); var swapchainImages_l = new IntPtr[swapchain_img_cnt]; fixed(IntPtr *swapchain_imgs = swapchainImages_l) vkGetSwapchainImagesKHR(DeviceInformation[0].Device, swapChainHndl, swapchain_img_cnt_ptr, swapchain_imgs); MaxFramesInFlight = swapchain_img_cnt; MaxFrameCount = swapchain_img_cnt; swapchainImages = new Image[swapchain_img_cnt]; for (int i = 0; i < swapchainImages.Length; i++) { swapchainImages[i] = new Image($"Swapchain_{i}") { Dimensions = 2, Width = cur_extent.width, Height = cur_extent.height, Depth = 1, Format = (ImageFormat)surface_fmt.format, Layers = 1, Levels = 1, MemoryUsage = MemoryUsage.GpuOnly, Usage = ImageUsage.Sampled, InitialLayout = ImageLayout.Undefined, Cubemappable = false, }; swapchainImages[i].Build(0, swapchainImages_l[i]); } surface_extent = cur_extent; swapchainViews = new ImageView[swapchain_img_cnt]; DefaultFramebuffer = new Framebuffer[swapchain_img_cnt]; for (int i = 0; i < swapchainImages.Length; i++) { swapchainViews[i] = new ImageView($"Swapchain_{i}") { BaseLayer = 0, BaseLevel = 0, Format = (ImageFormat)surface_fmt.format, LayerCount = 1, LevelCount = 1, ViewType = ImageViewType.View2D, }; swapchainViews[i].Build(swapchainImages[i]); DefaultFramebuffer[i] = new Framebuffer(); DefaultFramebuffer[i].Width = surface_extent.width; DefaultFramebuffer[i].Height = surface_extent.height; DefaultFramebuffer[i].Name = $"Swapchain_{i}"; DefaultFramebuffer[i].ColorAttachments = new ImageView[] { swapchainViews[i] }; } } for (int i = 0; i < instLayers.Count; i++) { Marshal.FreeHGlobal(layers[i]); } for (int i = 0; i < instExtns.Count; i++) { Marshal.FreeHGlobal(extns[i]); } for (int i = 0; i < devExtns.Count; i++) { Marshal.FreeHGlobal(devExtns_ptr[i]); } //TODO allocate compute and trasnfer queues for all secondary devices } for (int i = 0; i < 1 /*DeviceInformation.Length*/; i++) { var devInfo = DeviceInformation[i]; IntPtr rrCtxtHndl = IntPtr.Zero; if (rrCreateContextVk(RrApiVersion, devInfo.Device, devInfo.PhysicalDevice, devInfo.ComputeQueue.Handle, devInfo.ComputeFamily, &rrCtxtHndl) != RRError.RrSuccess) { Console.WriteLine($"Failed to initialize RadeonRays for device #{i}."); } DeviceInformation[i].RaysContext = rrCtxtHndl; } FrameFinishedSemaphore = new GpuSemaphore[MaxFramesInFlight]; ImageAvailableSemaphore = new GpuSemaphore[MaxFramesInFlight]; InflightFences = new Fence[MaxFramesInFlight]; for (int i = 0; i < MaxFramesInFlight; i++) { FrameFinishedSemaphore[i] = new GpuSemaphore(); FrameFinishedSemaphore[i].Build(0, false, 0); ImageAvailableSemaphore[i] = new GpuSemaphore(); ImageAvailableSemaphore[i].Build(0, false, 0); InflightFences[i] = new Fence { CreateSignaled = true }; InflightFences[i].Build(0); } Width = (uint)Window.Width; Height = (uint)Window.Height; } }
public unsafe GraphicsAdapterFactoryInstance(bool enableValidation) { var applicationInfo = new VkApplicationInfo { sType = VkStructureType.ApplicationInfo, apiVersion = new VkVersion(1, 0, 0), pEngineName = (byte *)Marshal.StringToHGlobalAnsi("Stride"), //engineVersion = new VkVersion() }; var validationLayerNames = new[] { "VK_LAYER_KHRONOS_validation", }; IntPtr[] enabledLayerNames = new IntPtr[0]; if (enableValidation) { var layers = vkEnumerateInstanceLayerProperties(); var availableLayerNames = new HashSet <string>(); for (int index = 0; index < layers.Length; index++) { var properties = layers[index]; var namePointer = properties.layerName; var name = Marshal.PtrToStringAnsi((IntPtr)namePointer); availableLayerNames.Add(name); } enabledLayerNames = validationLayerNames .Where(x => availableLayerNames.Contains(x)) .Select(Marshal.StringToHGlobalAnsi).ToArray(); // Check if validation was really available enableValidation = enabledLayerNames.Length > 0; } var extensionProperties = vkEnumerateInstanceExtensionProperties(); var availableExtensionNames = new List <string>(); var desiredExtensionNames = new List <string>(); for (int index = 0; index < extensionProperties.Length; index++) { var extensionProperty = extensionProperties[index]; var name = Marshal.PtrToStringAnsi((IntPtr)extensionProperty.extensionName); availableExtensionNames.Add(name); } desiredExtensionNames.Add(KHRSurfaceExtensionName); if (!availableExtensionNames.Contains(KHRSurfaceExtensionName)) { throw new InvalidOperationException($"Required extension {KHRSurfaceExtensionName} is not available"); } if (Platform.Type == PlatformType.Windows) { desiredExtensionNames.Add(KHRWin32SurfaceExtensionName); if (!availableExtensionNames.Contains(KHRWin32SurfaceExtensionName)) { throw new InvalidOperationException($"Required extension {KHRWin32SurfaceExtensionName} is not available"); } } else if (Platform.Type == PlatformType.Android) { desiredExtensionNames.Add(KHRAndroidSurfaceExtensionName); if (!availableExtensionNames.Contains(KHRAndroidSurfaceExtensionName)) { throw new InvalidOperationException($"Required extension {KHRAndroidSurfaceExtensionName} is not available"); } } else if (Platform.Type == PlatformType.Linux) { if (availableExtensionNames.Contains("VK_KHR_xlib_surface")) { desiredExtensionNames.Add("VK_KHR_xlib_surface"); HasXlibSurfaceSupport = true; } else if (availableExtensionNames.Contains("VK_KHR_xcb_surface")) { desiredExtensionNames.Add("VK_KHR_xcb_surface"); } else { throw new InvalidOperationException("None of the supported surface extensions VK_KHR_xcb_surface or VK_KHR_xlib_surface is available"); } } bool enableDebugReport = enableValidation && availableExtensionNames.Contains(EXTDebugUtilsExtensionName); if (enableDebugReport) { desiredExtensionNames.Add(EXTDebugUtilsExtensionName); } var enabledExtensionNames = desiredExtensionNames.Select(Marshal.StringToHGlobalAnsi).ToArray(); try { fixed(void *enabledExtensionNamesPointer = &enabledExtensionNames[0]) { var instanceCreateInfo = new VkInstanceCreateInfo { sType = VkStructureType.InstanceCreateInfo, pApplicationInfo = &applicationInfo, enabledLayerCount = enabledLayerNames != null ? (uint)enabledLayerNames.Length : 0, ppEnabledLayerNames = enabledLayerNames?.Length > 0 ? (byte **)Core.Interop.Fixed(enabledLayerNames) : null, enabledExtensionCount = (uint)enabledExtensionNames.Length, ppEnabledExtensionNames = (byte **)enabledExtensionNamesPointer, }; vkCreateInstance(&instanceCreateInfo, null, out NativeInstance); vkLoadInstance(NativeInstance); } // Check if validation layer was available (otherwise detected count is 0) if (enableValidation) { debugReport = DebugReport; var createInfo = new VkDebugUtilsMessengerCreateInfoEXT { sType = VkStructureType.DebugUtilsMessengerCreateInfoEXT, messageSeverity = VkDebugUtilsMessageSeverityFlagsEXT.Verbose | VkDebugUtilsMessageSeverityFlagsEXT.Error | VkDebugUtilsMessageSeverityFlagsEXT.Warning, messageType = VkDebugUtilsMessageTypeFlagsEXT.General | VkDebugUtilsMessageTypeFlagsEXT.Validation | VkDebugUtilsMessageTypeFlagsEXT.Performance, pfnUserCallback = Marshal.GetFunctionPointerForDelegate(debugReport) }; vkCreateDebugUtilsMessengerEXT(NativeInstance, &createInfo, null, out debugReportCallback).CheckResult(); } } finally { foreach (var enabledExtensionName in enabledExtensionNames) { Marshal.FreeHGlobal(enabledExtensionName); } foreach (var enabledLayerName in enabledLayerNames) { Marshal.FreeHGlobal(enabledLayerName); } Marshal.FreeHGlobal((IntPtr)applicationInfo.pEngineName); } }
protected override void Initialize() { var result = vkInitialize(); result.CheckResult(); var version = vkEnumerateInstanceVersion(); var queryExtensions = vkEnumerateInstanceExtensionProperties(); var queryLayers = vkEnumerateInstanceLayerProperties(); VkString name = "01-ClearScreen"; var appInfo = new VkApplicationInfo { sType = VkStructureType.ApplicationInfo, pApplicationName = name, applicationVersion = new VkVersion(1, 0, 0), pEngineName = s_EngineName, engineVersion = new VkVersion(1, 0, 0), apiVersion = VkVersion.Version_1_0, }; var instanceExtensions = new List <string> { KHRSurfaceExtensionName, KHRWin32SurfaceExtensionName }; var instanceLayers = new List <string>(); if (EnableValidationLayers) { FindValidationLayers(instanceLayers); } if (instanceLayers.Count > 0) { instanceExtensions.Add(EXTDebugUtilsExtensionName); } using var vkInstanceExtensions = new VkStringArray(instanceExtensions); var instanceCreateInfo = new VkInstanceCreateInfo { sType = VkStructureType.InstanceCreateInfo, pApplicationInfo = &appInfo, enabledExtensionCount = vkInstanceExtensions.Length, ppEnabledExtensionNames = vkInstanceExtensions }; using var vkLayerNames = new VkStringArray(instanceLayers); if (instanceLayers.Count > 0) { instanceCreateInfo.enabledLayerCount = vkLayerNames.Length; instanceCreateInfo.ppEnabledLayerNames = vkLayerNames; } result = vkCreateInstance(&instanceCreateInfo, null, out instance); vkLoadInstance(instance); if (instanceLayers.Count > 0) { _debugMessengerCallbackFunc = DebugMessengerCallback; var debugCreateInfo = new VkDebugUtilsMessengerCreateInfoEXT { sType = VkStructureType.DebugUtilsMessengerCreateInfoEXT, messageSeverity = /*VkDebugUtilsMessageSeverityFlagsEXT.VerboseEXT | */ VkDebugUtilsMessageSeverityFlagsEXT.ErrorEXT | VkDebugUtilsMessageSeverityFlagsEXT.WarningEXT, messageType = VkDebugUtilsMessageTypeFlagsEXT.GeneralEXT | VkDebugUtilsMessageTypeFlagsEXT.ValidationEXT | VkDebugUtilsMessageTypeFlagsEXT.PerformanceEXT, pfnUserCallback = Marshal.GetFunctionPointerForDelegate(_debugMessengerCallbackFunc) }; vkCreateDebugUtilsMessengerEXT(instance, &debugCreateInfo, null, out debugMessenger).CheckResult(); } var surfaceCreateInfo = new VkWin32SurfaceCreateInfoKHR { sType = VkStructureType.Win32SurfaceCreateInfoKHR, hinstance = HInstance, hwnd = MainWindow.Handle }; result = vkCreateWin32SurfaceKHR(instance, &surfaceCreateInfo, null, out surface); var physicalDevices = vkEnumeratePhysicalDevices(instance); foreach (var physicalDevice in physicalDevices) { vkGetPhysicalDeviceProperties(physicalDevice, out var properties); var deviceName = properties.GetDeviceName(); } physicalDevice = physicalDevices[0]; var queueFamilies = FindQueueFamilies(physicalDevice, surface); var priority = 1.0f; var queueCreateInfo = new VkDeviceQueueCreateInfo { sType = VkStructureType.DeviceQueueCreateInfo, queueFamilyIndex = queueFamilies.graphicsFamily, queueCount = 1, pQueuePriorities = &priority }; List <string> deviceExtensions = new List <string> { KHRSwapchainExtensionName }; var deviceCreateInfo = new VkDeviceCreateInfo { sType = VkStructureType.DeviceCreateInfo, pQueueCreateInfos = &queueCreateInfo, queueCreateInfoCount = 1, pEnabledFeatures = null, }; using var deviceExtensionNames = new VkStringArray(deviceExtensions); deviceCreateInfo.enabledExtensionCount = deviceExtensionNames.Length; deviceCreateInfo.ppEnabledExtensionNames = deviceExtensionNames; result = vkCreateDevice(physicalDevice, &deviceCreateInfo, null, out device); if (result != VkResult.Success) { throw new Exception($"Failed to create Vulkan Logical Device, {result}"); } vkGetDeviceQueue(device, queueFamilies.graphicsFamily, 0, out graphicsQueue); vkGetDeviceQueue(device, queueFamilies.presentFamily, 0, out presentQueue); CreateSwapchain(); CreateSyncPrimitives(); }
public unsafe GraphicsAdapterFactoryInstance(bool enableValidation) { var applicationInfo = new VkApplicationInfo { sType = VkStructureType.ApplicationInfo, apiVersion = new VkVersion(1, 0, 0), pEngineName = (byte *)Marshal.StringToHGlobalAnsi("Focus"), //EngineVersion = new SharpVulkan.Version() }; var desiredLayerNames = new[] { //"VK_LAYER_LUNARG_standard_validation", "VK_LAYER_GOOGLE_threading", "VK_LAYER_LUNARG_parameter_validation", "VK_LAYER_LUNARG_device_limits", "VK_LAYER_LUNARG_object_tracker", "VK_LAYER_LUNARG_image", "VK_LAYER_LUNARG_core_validation", "VK_LAYER_LUNARG_swapchain", "VK_LAYER_GOOGLE_unique_objects", //"VK_LAYER_LUNARG_api_dump", //"VK_LAYER_LUNARG_vktrace" }; IntPtr[] enabledLayerNames = new IntPtr[0]; if (enableValidation) { var layers = vkEnumerateInstanceLayerProperties(); var availableLayerNames = new HashSet <string>(); for (int index = 0; index < layers.Length; index++) { var properties = layers[index]; var namePointer = properties.layerName; var name = Marshal.PtrToStringAnsi((IntPtr)namePointer); availableLayerNames.Add(name); } enabledLayerNames = desiredLayerNames .Where(x => availableLayerNames.Contains(x)) .Select(Marshal.StringToHGlobalAnsi).ToArray(); } var extensionProperties = vkEnumerateInstanceExtensionProperties(); var availableExtensionNames = new List <string>(); var desiredExtensionNames = new List <string>(); for (int index = 0; index < extensionProperties.Length; index++) { var extensionProperty = extensionProperties[index]; var name = Marshal.PtrToStringAnsi((IntPtr)extensionProperty.extensionName); availableExtensionNames.Add(name); } desiredExtensionNames.Add("VK_KHR_surface"); desiredExtensionNames.Add("VK_KHR_win32_surface"); // windows desiredExtensionNames.Add("VK_KHR_android_surface"); // android desiredExtensionNames.Add("VK_KHR_xlib_surface"); // linux desiredExtensionNames.Add("VK_KHR_xcb_surface"); // linux desiredExtensionNames.Add("VK_MVK_macos_surface"); // macos desiredExtensionNames.Add("VK_EXT_metal_surface"); // macos desiredExtensionNames.Add("VK_MVK_moltenvk"); // macos desiredExtensionNames.Add("VK_NV_external_memory_capabilities"); // NVIDIA needs this one for OpenVR desiredExtensionNames.Add("VK_KHR_external_memory_capabilities"); // this one might be used in the future for OpenVR bool enableDebugReport = enableValidation && availableExtensionNames.Contains("VK_EXT_debug_report"); if (enableDebugReport) { desiredExtensionNames.Add("VK_EXT_debug_report"); } // take out any extensions not supported for (int i = 0; i < desiredExtensionNames.Count; i++) { if (availableExtensionNames.Contains(desiredExtensionNames[i]) == false) { desiredExtensionNames.RemoveAt(i); i--; } } var enabledExtensionNames = desiredExtensionNames.Select(Marshal.StringToHGlobalAnsi).ToArray(); var createDebugReportCallbackName = Marshal.StringToHGlobalAnsi("vkCreateDebugReportCallbackEXT"); try { fixed(void *enabledExtensionNamesPointer = &enabledExtensionNames[0]) { var instanceCreateInfo = new VkInstanceCreateInfo { sType = VkStructureType.InstanceCreateInfo, pApplicationInfo = &applicationInfo, enabledLayerCount = enabledLayerNames != null ? (uint)enabledLayerNames.Length : 0, ppEnabledLayerNames = enabledLayerNames?.Length > 0 ? (byte **)Core.Interop.Fixed(enabledLayerNames) : null, enabledExtensionCount = (uint)enabledExtensionNames.Length, ppEnabledExtensionNames = (byte **)enabledExtensionNamesPointer, }; vkCreateInstance(&instanceCreateInfo, null, out NativeInstance); vkLoadInstance(NativeInstance); } if (enableDebugReport) { var createDebugReportCallback = (CreateDebugReportCallbackDelegate)Marshal.GetDelegateForFunctionPointer(vkGetInstanceProcAddr(NativeInstance, (byte *)createDebugReportCallbackName), typeof(CreateDebugReportCallbackDelegate)); debugReport = DebugReport; var createInfo = new VkDebugReportCallbackCreateInfoEXT { sType = VkStructureType.DebugReportCallbackCreateInfoEXT, flags = VkDebugReportFlagsEXT.ErrorEXT | VkDebugReportFlagsEXT.WarningEXT /* | VkDebugReportFlagsEXT.PerformanceWarningEXT | VkDebugReportFlagsEXT.InformationEXT | VkDebugReportFlagsEXT.DebugEXT*/, pfnCallback = Marshal.GetFunctionPointerForDelegate(debugReport) }; createDebugReportCallback(NativeInstance, ref createInfo, null, out debugReportCallback); } if (availableExtensionNames.Contains("VK_EXT_debug_marker")) { var beginDebugMarkerName = System.Text.Encoding.ASCII.GetBytes("vkCmdDebugMarkerBeginEXT"); var ptr = vkGetInstanceProcAddr(NativeInstance, (byte *)Core.Interop.Fixed(beginDebugMarkerName)); if (ptr != IntPtr.Zero) { BeginDebugMarker = (BeginDebugMarkerDelegate)Marshal.GetDelegateForFunctionPointer(ptr, typeof(BeginDebugMarkerDelegate)); } var endDebugMarkerName = System.Text.Encoding.ASCII.GetBytes("vkCmdDebugMarkerEndEXT"); ptr = vkGetInstanceProcAddr(NativeInstance, (byte *)Core.Interop.Fixed(endDebugMarkerName)); if (ptr != IntPtr.Zero) { EndDebugMarker = (EndDebugMarkerDelegate)Marshal.GetDelegateForFunctionPointer(ptr, typeof(EndDebugMarkerDelegate)); } } } finally { foreach (var enabledExtensionName in enabledExtensionNames) { Marshal.FreeHGlobal(enabledExtensionName); } foreach (var enabledLayerName in enabledLayerNames) { Marshal.FreeHGlobal(enabledLayerName); } Marshal.FreeHGlobal((IntPtr)applicationInfo.pEngineName); Marshal.FreeHGlobal(createDebugReportCallbackName); } }
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); }
public VkInstance CreateInstance() { VkApplicationInfo AppInfo = new VkApplicationInfo() { sType = VkStructureType.ApplicationInfo, apiVersion = new Version(1, 0, 0), applicationVersion = new Version(0, 0, 1), engineVersion = new Version(0, 0, 2), pApplicationName = Interop.String.ToPointer("Zeckoxe Engine"), pEngineName = Interop.String.ToPointer("Zeckoxe"), }; if (Parameters.Settings.Validation) { // TODO: } EnumerateInstanceExtensions = Tools.EnumerateInstanceExtensions(); if (EnumerateInstanceExtensions.Contains("VK_KHR_surface")) { InstanceExtensions.Add("VK_KHR_surface"); } if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { if (EnumerateInstanceExtensions.Contains("VK_KHR_win32_surface")) { InstanceExtensions.Add("VK_KHR_win32_surface"); } } if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { if (EnumerateInstanceExtensions.Contains("VK_MVK_macos_surface")) { InstanceExtensions.Add("VK_MVK_macos_surface"); } if (EnumerateInstanceExtensions.Contains("VK_MVK_ios_surface")) { InstanceExtensions.Add("VK_MVK_ios_surface"); } } if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { if (EnumerateInstanceExtensions.Contains("VK_KHR_android_surface")) { InstanceExtensions.Add("VK_KHR_android_surface"); } if (EnumerateInstanceExtensions.Contains("VK_KHR_xlib_surface")) { InstanceExtensions.Add("VK_KHR_xlib_surface"); } if (EnumerateInstanceExtensions.Contains("VK_KHR_wayland_surface")) { InstanceExtensions.Add("VK_KHR_wayland_surface"); } } VkInstanceCreateInfo instanceCreateInfo = new VkInstanceCreateInfo() { sType = VkStructureType.InstanceCreateInfo, pNext = null, pApplicationInfo = &AppInfo, enabledExtensionCount = (uint)InstanceExtensions.Count(), ppEnabledExtensionNames = Interop.String.AllocToPointers(InstanceExtensions.ToArray()), }; VkInstance instance; VulkanNative.vkCreateInstance(&instanceCreateInfo, (VkAllocationCallbacks *)null, &instance); return(instance); }
void init() { List <IntPtr> instanceExtensions = new List <IntPtr> (); List <IntPtr> enabledLayerNames = new List <IntPtr> (); instanceExtensions.Add(Strings.VK_KHR_SURFACE_EXTENSION_NAME); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { instanceExtensions.Add(Strings.VK_KHR_WIN32_SURFACE_EXTENSION_NAME); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { instanceExtensions.Add(Strings.VK_KHR_XCB_SURFACE_EXTENSION_NAME); } else { throw new PlatformNotSupportedException(); } if (VALIDATION) { enabledLayerNames.Add(Strings.LayerValidation); } if (RENDER_DOC_CAPTURE) { enabledLayerNames.Add(Strings.RenderdocCaptureLayerName); } if (DEBUG_UTILS) { instanceExtensions.Add(Strings.VK_EXT_DEBUG_UTILS_EXTENSION_NAME); instanceExtensions.Add(Strings.VK_EXT_DEBUG_REPORT_EXTENSION_NAME); } VkApplicationInfo appInfo = new VkApplicationInfo() { sType = VkStructureType.ApplicationInfo, apiVersion = new Vulkan.Version(1, 0, 0), pApplicationName = Strings.Name, pEngineName = Strings.Name, }; VkInstanceCreateInfo instanceCreateInfo = VkInstanceCreateInfo.New(); instanceCreateInfo.pApplicationInfo = appInfo.Pin(); if (instanceExtensions.Count > 0) { instanceCreateInfo.enabledExtensionCount = (uint)instanceExtensions.Count; instanceCreateInfo.ppEnabledExtensionNames = instanceExtensions.Pin(); } if (enabledLayerNames.Count > 0) { instanceCreateInfo.enabledLayerCount = (uint)enabledLayerNames.Count; instanceCreateInfo.ppEnabledLayerNames = enabledLayerNames.Pin(); } VkResult result = vkCreateInstance(ref instanceCreateInfo, IntPtr.Zero, out inst); if (result != VkResult.Success) { throw new InvalidOperationException("Could not create Vulkan instance. Error: " + result); } Vk.LoadInstanceFunctionPointers(inst); appInfo.Unpin(); if (instanceExtensions.Count > 0) { instanceExtensions.Unpin(); } if (enabledLayerNames.Count > 0) { enabledLayerNames.Unpin(); } }
static void Main(string[] args) { VkInstance inst; using (VkApplicationInfo ai = new VkApplicationInfo()) { using (VkInstanceCreateInfo ci = new VkInstanceCreateInfo { pApplicationInfo = ai }){ CheckResult(vkCreateInstance(ci, IntPtr.Zero, out inst)); } } Vk.LoadInstanceFunctionPointers(inst); if (!TryGetPhysicalDevice(inst, VkPhysicalDeviceType.DiscreteGpu, out VkPhysicalDevice phy)) { if (!TryGetPhysicalDevice(inst, VkPhysicalDeviceType.IntegratedGpu, out phy)) { if (!TryGetPhysicalDevice(inst, VkPhysicalDeviceType.Cpu, out phy)) { throw new Exception("no suitable physical device found"); } } } foreach (VkPhysicalDeviceToolPropertiesEXT toolProp in GetToolProperties(phy)) { Console.ForegroundColor = ConsoleColor.DarkYellow; Console.WriteLine($"Enabled Tool: {toolProp.name}({toolProp.version})"); Console.ResetColor(); } vkGetPhysicalDeviceQueueFamilyProperties(phy, out uint queueFamilyCount, IntPtr.Zero); VkQueueFamilyProperties[] qFamProps = new VkQueueFamilyProperties[queueFamilyCount]; vkGetPhysicalDeviceQueueFamilyProperties(phy, out queueFamilyCount, qFamProps.Pin()); qFamProps.Unpin(); Console.WriteLine($"Queues:"); for (int i = 0; i < queueFamilyCount; i++) { Console.WriteLine($"\t{i}: {qFamProps[i].queueFlags,-60} ({qFamProps[i].queueCount})"); } uint qFamIndex = (uint)qFamProps.Select((qFam, index) => (qFam, index)) .First(qfp => qfp.qFam.queueFlags.HasFlag(VkQueueFlags.Graphics)).index; VkDevice dev = default; float[] priorities = { 0 }; using (VkDeviceQueueCreateInfo qInfo = new VkDeviceQueueCreateInfo(qFamIndex, 1, priorities)) { using (VkDeviceCreateInfo deviceCreateInfo = new VkDeviceCreateInfo() { pQueueCreateInfos = qInfo }) { CheckResult(vkCreateDevice(phy, deviceCreateInfo, IntPtr.Zero, out dev)); } } vkGetDeviceQueue(dev, qFamIndex, 0, out VkQueue gQ); vkDestroyDevice(dev, IntPtr.Zero); vkDestroyInstance(inst, IntPtr.Zero); }
private void CreateInstance(bool debug) { HashSet <string> availableInstanceLayers = new HashSet <string>(EnumerateInstanceLayers()); HashSet <string> availableInstanceExtensions = new HashSet <string>(EnumerateInstanceExtensions()); VkInstanceCreateInfo instanceCI = VkInstanceCreateInfo.New(); VkApplicationInfo applicationInfo = new VkApplicationInfo(); applicationInfo.apiVersion = new VkVersion(1, 0, 0); applicationInfo.applicationVersion = new VkVersion(1, 0, 0); applicationInfo.engineVersion = new VkVersion(1, 0, 0); applicationInfo.pApplicationName = s_name; applicationInfo.pEngineName = s_name; instanceCI.pApplicationInfo = &applicationInfo; StackList <IntPtr, Size64Bytes> instanceExtensions = new StackList <IntPtr, Size64Bytes>(); StackList <IntPtr, Size64Bytes> instanceLayers = new StackList <IntPtr, Size64Bytes>(); if (!availableInstanceExtensions.Contains(CommonStrings.VK_KHR_SURFACE_EXTENSION_NAME)) { throw new VeldridException($"The required instance extension was not available: {CommonStrings.VK_KHR_SURFACE_EXTENSION_NAME}"); } instanceExtensions.Add(CommonStrings.VK_KHR_SURFACE_EXTENSION_NAME); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { if (!availableInstanceExtensions.Contains(CommonStrings.VK_KHR_WIN32_SURFACE_EXTENSION_NAME)) { throw new VeldridException($"The required instance extension was not available: {CommonStrings.VK_KHR_WIN32_SURFACE_EXTENSION_NAME}"); } instanceExtensions.Add(CommonStrings.VK_KHR_WIN32_SURFACE_EXTENSION_NAME); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { if (!availableInstanceExtensions.Contains(CommonStrings.VK_KHR_XLIB_SURFACE_EXTENSION_NAME)) { throw new VeldridException($"The required instance extension was not available: {CommonStrings.VK_KHR_XLIB_SURFACE_EXTENSION_NAME}"); } instanceExtensions.Add(CommonStrings.VK_KHR_XLIB_SURFACE_EXTENSION_NAME); } else { throw new NotSupportedException("This platform does not support Vulkan."); } bool debugReportExtensionAvailable = false; if (debug) { if (availableInstanceExtensions.Contains(CommonStrings.VK_EXT_DEBUG_REPORT_EXTENSION_NAME)) { debugReportExtensionAvailable = true; instanceExtensions.Add(CommonStrings.VK_EXT_DEBUG_REPORT_EXTENSION_NAME); } if (availableInstanceLayers.Contains(CommonStrings.StandardValidationLayerName)) { instanceLayers.Add(CommonStrings.StandardValidationLayerName); } } instanceCI.enabledExtensionCount = instanceExtensions.Count; instanceCI.ppEnabledExtensionNames = (byte **)instanceExtensions.Data; instanceCI.enabledLayerCount = instanceLayers.Count; instanceCI.ppEnabledLayerNames = (byte **)instanceLayers.Data; VkResult result = vkCreateInstance(ref instanceCI, null, out _instance); CheckResult(result); if (debug && debugReportExtensionAvailable) { EnableDebugCallback(); } }
/// <summary> /// Create a new vulkan instance with enabled extensions given as argument. /// </summary> /// <param name="extensions">List of extension to enable if supported</param> public Instance(params string[] extensions) { List <IntPtr> instanceExtensions = new List <IntPtr> (); List <IntPtr> enabledLayerNames = new List <IntPtr> (); string[] supportedExts = SupportedExtensions(IntPtr.Zero); using (PinnedObjects pctx = new PinnedObjects()) { for (int i = 0; i < extensions.Length; i++) { if (supportedExts.Contains(extensions [i])) { instanceExtensions.Add(extensions [i].Pin(pctx)); if (extensions [i] == Ext.I.VK_EXT_debug_utils) { debugUtilsEnabled = true; } } else { Console.WriteLine($"Vulkan initialisation: Unsupported extension: {extensions [i]}"); } } if (VALIDATION) { enabledLayerNames.Add(strValidationLayer.Pin(pctx)); } if (RENDER_DOC_CAPTURE) { enabledLayerNames.Add(strRenderDocLayer.Pin(pctx)); } VkApplicationInfo appInfo = new VkApplicationInfo() { sType = VkStructureType.ApplicationInfo, apiVersion = new Vulkan.Version(VK_MAJOR, VK_MINOR, 0), pApplicationName = ENGINE_NAME.Pin(pctx), pEngineName = APPLICATION_NAME.Pin(pctx), }; VkInstanceCreateInfo instanceCreateInfo = VkInstanceCreateInfo.New(); instanceCreateInfo.pApplicationInfo = appInfo.Pin(pctx); if (instanceExtensions.Count > 0) { instanceCreateInfo.enabledExtensionCount = (uint)instanceExtensions.Count; instanceCreateInfo.ppEnabledExtensionNames = instanceExtensions.Pin(pctx); } if (enabledLayerNames.Count > 0) { instanceCreateInfo.enabledLayerCount = (uint)enabledLayerNames.Count; instanceCreateInfo.ppEnabledLayerNames = enabledLayerNames.Pin(pctx); } VkResult result = vkCreateInstance(ref instanceCreateInfo, IntPtr.Zero, out inst); if (result != VkResult.Success) { throw new InvalidOperationException("Could not create Vulkan instance. Error: " + result); } Vk.LoadInstanceFunctionPointers(inst); } }
private void CreateInstance() { ////var availableExtensions = EnumerateInstanceExtensions(); ////var availableLayers = EnumerateInstanceLayers(); VkApplicationInfo appInfo = new VkApplicationInfo() { sType = VkStructureType.VK_STRUCTURE_TYPE_APPLICATION_INFO, pApplicationName = "Hello Triangle".ToPointer(), pEngineName = "WaveEngine".ToPointer(), engineVersion = Helpers.Version(3, 0, 0), }; string[] extensions = new string[] { "VK_KHR_surface", "VK_KHR_win32_surface", "VK_EXT_debug_report", }; IntPtr *extensionsToEnableArray = stackalloc IntPtr[extensions.Length]; for (int i = 0; i < extensions.Length; i++) { string extension = extensions[i]; extensionsToEnableArray[i] = Marshal.StringToHGlobalAnsi(extension); } string[] layers = new string[] { "VK_LAYER_LUNARG_standard_validation" }; IntPtr *layersToEnableArray = stackalloc IntPtr[layers.Length]; for (int i = 0; i < layers.Length; i++) { string layer = layers[i]; layersToEnableArray[i] = Marshal.StringToHGlobalAnsi(layer); } VkInstanceCreateInfo createInfo = new VkInstanceCreateInfo() { sType = VkStructureType.VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, ppEnabledExtensionNames = (byte **)extensionsToEnableArray, enabledExtensionCount = (uint)extensions.Length, enabledLayerCount = (uint)layers.Length, ppEnabledLayerNames = (byte **)layersToEnableArray, pApplicationInfo = &appInfo, }; VkInstance newInstance; var result = VulkanNative.vkCreateInstance(&createInfo, null, &newInstance); this.vkInstance = newInstance; Helpers.CheckErrors(result); for (int i = 0; i < extensions.Length; i++) { Marshal.FreeHGlobal(extensionsToEnableArray[i]); } for (int i = 0; i < layers.Length; i++) { Marshal.FreeHGlobal(layersToEnableArray[i]); } EnableDebugCallback(); }
static VkInstance CreateInstance(Settings settings) { bool enableValidation = settings.Validation; vkInitialize().CheckResult(); var appInfo = new VkApplicationInfo { sType = VkStructureType.ApplicationInfo, pApplicationName = settings.ApplicationName, applicationVersion = new VkVersion(1, 0, 0), pEngineName = engineName, engineVersion = new VkVersion(1, 0, 0), apiVersion = vkEnumerateInstanceVersion() }; if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { instanceExtensions.Add("VK_KHR_win32_surface"); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { instanceExtensions.Add("VK_KHR_xlib_surface"); } else { throw new PlatformNotSupportedException(); } VkInstanceCreateInfo instanceCreateInfo = new VkInstanceCreateInfo { sType = VkStructureType.InstanceCreateInfo }; instanceCreateInfo.pApplicationInfo = &appInfo; if (instanceExtensions.Count > 0) { if (enableValidation) { instanceExtensions.Add(Vulkan.EXTDebugReportExtensionName); } instanceCreateInfo.enabledExtensionCount = instanceExtensions.Count; instanceCreateInfo.ppEnabledExtensionNames = (byte **)instanceExtensions.Data; } using CStringList enabledLayerNames = new CStringList { "VK_LAYER_KHRONOS_validation" }; if (enableValidation) { instanceCreateInfo.enabledLayerCount = enabledLayerNames.Count; instanceCreateInfo.ppEnabledLayerNames = (byte **)enabledLayerNames.Data; } VulkanUtil.CheckResult(vkCreateInstance(&instanceCreateInfo, null, out VkInstance instance)); VkInstance = instance; vkLoadInstance(VkInstance); if (settings.Validation) { debugReportCallbackExt = CreateDebugReportCallback(); } return(instance); }
public unsafe GraphicsService() { //create vulkan info var applicationInfo = new VkApplicationInfo { sType = VkStructureType.ApplicationInfo, apiVersion = new VkVersion(1, 0, 0), applicationVersion = new VkVersion(1, 0, 0), engineVersion = new VkVersion(1, 0, 0), pApplicationName = new FixedUtf8String("Tortuga"), pEngineName = new FixedUtf8String("Tortuga") }; //vulkan extensions var instanceExtensions = new NativeList <IntPtr>(); instanceExtensions.Add(GraphicsApiConstants.VK_KHR_SURFACE_EXTENSION_NAME); if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { instanceExtensions.Add(GraphicsApiConstants.VK_KHR_XLIB_SURFACE_EXTENSION_NAME); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { instanceExtensions.Add(GraphicsApiConstants.VK_KHR_WIN32_SURFACE_EXTENSION_NAME); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { instanceExtensions.Add(GraphicsApiConstants.VK_MVK_SURFACE_EXTENSION_NAME); } else { throw new NotSupportedException("This platform is not supported"); } if (Settings.IsGraphicsApiDebugingEnabled) { instanceExtensions.Add(GraphicsApiConstants.VK_EXT_DEBUG_REPORT_EXTENSION_NAME); } //vulkan validation layers var validationLayer = new NativeList <IntPtr>(); if (Settings.IsGraphicsApiDebugingEnabled) { uint supportedLayersCount; VulkanNative.vkEnumerateInstanceLayerProperties(&supportedLayersCount, null); var supportedLayers = new NativeList <VkLayerProperties>(supportedLayersCount); supportedLayers.Count = supportedLayersCount; VulkanNative.vkEnumerateInstanceLayerProperties( &supportedLayersCount, (VkLayerProperties *)supportedLayers.Data.ToPointer() ); foreach (var vl in supportedLayers) { var validationName = Encoding.ASCII.GetString(vl.layerName, 256).Replace("\0", ""); Console.WriteLine($"Supported Validation Layer: {validationName}"); validationLayer.Add(new IntPtr(vl.layerName)); } } var instanceInfo = new VkInstanceCreateInfo { sType = VkStructureType.InstanceCreateInfo, pApplicationInfo = &applicationInfo, enabledExtensionCount = instanceExtensions.Count, ppEnabledExtensionNames = (byte **)instanceExtensions.Data, enabledLayerCount = validationLayer.Count, ppEnabledLayerNames = (byte **)validationLayer.Data }; VkInstance instance; if (VulkanNative.vkCreateInstance( &instanceInfo, null, &instance ) != VkResult.Success) { throw new Exception("failed to initialize graphics api"); } _handle = instance; if (Settings.IsGraphicsApiDebugingEnabled) { if (CreateDebugReportCallback( GetVulkanDebugFlags ) != VkResult.Success) { throw new Exception("failed to start graphics api debugger"); } } //get vulkan physical device list uint deviceCount = 0; if (VulkanNative.vkEnumeratePhysicalDevices( _handle, ref deviceCount, null ) != VkResult.Success) { throw new Exception("could not get physical devices"); } var physicalDevices = new NativeList <VkPhysicalDevice>(deviceCount); physicalDevices.Count = deviceCount; if (VulkanNative.vkEnumeratePhysicalDevices( _handle, ref deviceCount, (VkPhysicalDevice *)physicalDevices.Data.ToPointer() ) != VkResult.Success) { throw new Exception("could not get physical devices"); } //setup devices _devices = new List <Device>(); for (int i = 0; i < deviceCount; i++) { _devices.Add(new Device(physicalDevices[i])); } //sort devices with best to worst _devices.Sort((a, b) => b.Score.CompareTo(a.Score)); }
public GraphicsDevice(string applicationName, bool enableValidation, Window?window) { VkString name = applicationName; var appInfo = new VkApplicationInfo { sType = VkStructureType.ApplicationInfo, pApplicationName = name, applicationVersion = new VkVersion(1, 0, 0), pEngineName = s_EngineName, engineVersion = new VkVersion(1, 0, 0), apiVersion = vkEnumerateInstanceVersion() }; List <string> instanceExtensions = new List <string> { KHRSurfaceExtensionName }; if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { instanceExtensions.Add(KHRWin32SurfaceExtensionName); } List <string> instanceLayers = new List <string>(); if (enableValidation) { FindValidationLayers(instanceLayers); } if (instanceLayers.Count > 0) { instanceExtensions.Add(EXTDebugUtilsExtensionName); } using var vkInstanceExtensions = new VkStringArray(instanceExtensions); var instanceCreateInfo = new VkInstanceCreateInfo { sType = VkStructureType.InstanceCreateInfo, pApplicationInfo = &appInfo, enabledExtensionCount = vkInstanceExtensions.Length, ppEnabledExtensionNames = vkInstanceExtensions }; using var vkLayerNames = new VkStringArray(instanceLayers); if (instanceLayers.Count > 0) { instanceCreateInfo.enabledLayerCount = vkLayerNames.Length; instanceCreateInfo.ppEnabledLayerNames = vkLayerNames; } var debugUtilsCreateInfo = new VkDebugUtilsMessengerCreateInfoEXT { sType = VkStructureType.DebugUtilsMessengerCreateInfoEXT }; if (instanceLayers.Count > 0) { _debugMessengerCallbackFunc = DebugMessengerCallback; debugUtilsCreateInfo.messageSeverity = VkDebugUtilsMessageSeverityFlagsEXT.Error | VkDebugUtilsMessageSeverityFlagsEXT.Warning; debugUtilsCreateInfo.messageType = VkDebugUtilsMessageTypeFlagsEXT.Validation | VkDebugUtilsMessageTypeFlagsEXT.Performance; debugUtilsCreateInfo.pfnUserCallback = Marshal.GetFunctionPointerForDelegate(_debugMessengerCallbackFunc); instanceCreateInfo.pNext = &debugUtilsCreateInfo; } VkResult result = vkCreateInstance(&instanceCreateInfo, null, out VkInstance); if (result != VkResult.Success) { throw new InvalidOperationException($"Failed to create vulkan instance: {result}"); } vkLoadInstance(VkInstance); if (instanceLayers.Count > 0) { vkCreateDebugUtilsMessengerEXT(VkInstance, &debugUtilsCreateInfo, null, out _debugMessenger).CheckResult(); } Log.Info($"Created VkInstance with version: {appInfo.apiVersion.Major}.{appInfo.apiVersion.Minor}.{appInfo.apiVersion.Patch}"); if (instanceLayers.Count > 0) { foreach (var layer in instanceLayers) { Log.Info($"Instance layer '{layer}'"); } } foreach (string extension in instanceExtensions) { Log.Info($"Instance extension '{extension}'"); } _surface = CreateSurface(window); // Find physical device, setup queue's and create device. var physicalDevices = vkEnumeratePhysicalDevices(VkInstance); foreach (var physicalDevice in physicalDevices) { vkGetPhysicalDeviceProperties(physicalDevice, out var properties); var deviceName = properties.GetDeviceName(); } PhysicalDevice = physicalDevices[0]; var queueFamilies = FindQueueFamilies(PhysicalDevice, _surface); var priority = 1.0f; var queueCreateInfo = new VkDeviceQueueCreateInfo { sType = VkStructureType.DeviceQueueCreateInfo, queueFamilyIndex = queueFamilies.graphicsFamily, queueCount = 1, pQueuePriorities = &priority }; List <string> deviceExtensions = new List <string> { KHRSwapchainExtensionName }; var deviceCreateInfo = new VkDeviceCreateInfo { sType = VkStructureType.DeviceCreateInfo, pQueueCreateInfos = &queueCreateInfo, queueCreateInfoCount = 1, pEnabledFeatures = null, }; using var deviceExtensionNames = new VkStringArray(deviceExtensions); deviceCreateInfo.enabledExtensionCount = deviceExtensionNames.Length; deviceCreateInfo.ppEnabledExtensionNames = deviceExtensionNames; result = vkCreateDevice(PhysicalDevice, &deviceCreateInfo, null, out VkDevice); if (result != VkResult.Success) { throw new Exception($"Failed to create Vulkan Logical Device, {result}"); } vkGetDeviceQueue(VkDevice, queueFamilies.graphicsFamily, 0, out GraphicsQueue); vkGetDeviceQueue(VkDevice, queueFamilies.presentFamily, 0, out PresentQueue); // Create swap chain Swapchain = new Swapchain(this, window); _perFrame = new PerFrame[Swapchain.ImageCount]; for (var i = 0; i < _perFrame.Length; i++) { VkFenceCreateInfo fenceCreateInfo = new VkFenceCreateInfo(VkFenceCreateFlags.Signaled); vkCreateFence(VkDevice, &fenceCreateInfo, null, out _perFrame[i].QueueSubmitFence).CheckResult(); VkCommandPoolCreateInfo poolCreateInfo = new VkCommandPoolCreateInfo { sType = VkStructureType.CommandPoolCreateInfo, flags = VkCommandPoolCreateFlags.Transient, queueFamilyIndex = queueFamilies.graphicsFamily, }; vkCreateCommandPool(VkDevice, &poolCreateInfo, null, out _perFrame[i].PrimaryCommandPool).CheckResult(); VkCommandBufferAllocateInfo commandBufferInfo = new VkCommandBufferAllocateInfo { sType = VkStructureType.CommandBufferAllocateInfo, commandPool = _perFrame[i].PrimaryCommandPool, level = VkCommandBufferLevel.Primary, commandBufferCount = 1 }; vkAllocateCommandBuffers(VkDevice, &commandBufferInfo, out _perFrame[i].PrimaryCommandBuffer).CheckResult(); } }
private VkInstance CreateInstance(bool debug) { VkInstance instance; // Specify standard validation layers. string surfaceExtension; switch (Host.Platform) { case Platform.Android: surfaceExtension = KHRAndroidSurfaceExtensionName; break; case Platform.Win32: surfaceExtension = KHRWin32SurfaceExtensionName; break; default: throw new NotImplementedException(); } VkString name = "TODO Application Name"; var appInfo = new VkApplicationInfo { sType = VkStructureType.ApplicationInfo, pApplicationName = name, applicationVersion = new VkVersion(1, 0, 0), pEngineName = s_EngineName, engineVersion = new VkVersion(1, 0, 0), apiVersion = VkVersion.Version_1_0, }; var instanceExtensions = new List <string> { KHRSurfaceExtensionName, surfaceExtension }; var instanceLayers = new List <string>(); if (EnableValidationLayers) { FindValidationLayers(instanceLayers); } if (instanceLayers.Count > 0) { instanceExtensions.Add(EXTDebugUtilsExtensionName); } using var vkInstanceExtensions = new VkStringArray(instanceExtensions); var instanceCreateInfo = new VkInstanceCreateInfo { sType = VkStructureType.InstanceCreateInfo, pApplicationInfo = &appInfo, enabledExtensionCount = vkInstanceExtensions.Length, ppEnabledExtensionNames = vkInstanceExtensions }; using var vkLayerNames = new VkStringArray(instanceLayers); if (instanceLayers.Count > 0) { instanceCreateInfo.enabledLayerCount = vkLayerNames.Length; instanceCreateInfo.ppEnabledLayerNames = vkLayerNames; } VkResult result = vkCreateInstance(&instanceCreateInfo, null, out instance); vkLoadInstance(instance); if (instanceLayers.Count > 0) { _debugMessengerCallbackFunc = DebugMessengerCallback; var debugCreateInfo = new VkDebugUtilsMessengerCreateInfoEXT { sType = VkStructureType.DebugUtilsMessengerCreateInfoEXT, messageSeverity = VkDebugUtilsMessageSeverityFlagsEXT.Verbose | VkDebugUtilsMessageSeverityFlagsEXT.Error | VkDebugUtilsMessageSeverityFlagsEXT.Warning, messageType = VkDebugUtilsMessageTypeFlagsEXT.General | VkDebugUtilsMessageTypeFlagsEXT.Validation | VkDebugUtilsMessageTypeFlagsEXT.Performance, pfnUserCallback = Marshal.GetFunctionPointerForDelegate(_debugMessengerCallbackFunc) }; vkCreateDebugUtilsMessengerEXT(instance, &debugCreateInfo, null, out debugMessenger).CheckResult(); } return(instance); }
public Instance(ICollection <VkExtension> preferredExtensions, ICollection <VkExtension> requiredExtensions, ICollection <string> preferredLayers, ICollection <string> requiredLayers) { var supportedLayers = Vulkan.EnumerateLayerProperties().Select(x => x.LayerNameString).ToHashSet(); Log.Info($"Supported instance layers: {string.Join(", ", supportedLayers)}"); foreach (var requiredLayer in requiredLayers) { if (!supportedLayers.Contains(requiredLayer)) { throw new NotSupportedException($"Layer {requiredLayer} isn't supported"); } } var layersToUse = requiredLayers.Union(preferredLayers.Where(supportedLayers.Contains)).ToList(); var supportedExtensions = Vulkan.EnumerateExtensionProperties(null).Union( layersToUse.SelectMany(Vulkan.EnumerateExtensionProperties)).Select(x => x.ExtensionNameString) .ToHashSet(); Log.Info($"Supported instance extensions: {string.Join(", ", supportedExtensions)}"); foreach (var requiredExtension in requiredExtensions) { if (!supportedExtensions.Contains(VkExtensionDatabase.Extension(requiredExtension).Extension)) { throw new NotSupportedException($"Extension {requiredExtension} isn't supported"); } } var extensionsToUse = requiredExtensions.Select(VkExtensionDatabase.Extension).Select(x => x.Extension) .Union( preferredExtensions.Select(VkExtensionDatabase.Extension).Select(x => x.Extension) .Where(supportedExtensions.Contains)).ToList(); _enabledExtensions = extensionsToUse.Select(VkExtensionDatabase.Extension).Where(y => y != null).Select(x => x.ExtensionId).ToHashSet(); _enableExtensionsByName = extensionsToUse.ToHashSet(); Log.Info($"Using instance layers: {string.Join(", ", layersToUse)}"); Log.Info($"Using instance extensions: {string.Join(", ", extensionsToUse)}"); unsafe { var layersToUseAnsi = new IntPtr[layersToUse.Count]; for (var i = 0; i < layersToUse.Count; i++) { layersToUseAnsi[i] = Marshal.StringToHGlobalAnsi(layersToUse[i]); } var extensionsToUseAnsi = new IntPtr[extensionsToUse.Count]; for (var i = 0; i < extensionsToUse.Count; i++) { extensionsToUseAnsi[i] = Marshal.StringToHGlobalAnsi(extensionsToUse[i]); } var pinnedLayersToUse = GCHandle.Alloc(layersToUseAnsi, GCHandleType.Pinned); var pinnedExtensionsToUse = GCHandle.Alloc(extensionsToUseAnsi, GCHandleType.Pinned); try { AllocationCallbacks = (VkAllocationCallbacks *)0; var appInfo = new VkApplicationInfo() { SType = VkStructureType.ApplicationInfo, ApiVersion = new VkVersion(1, 0, 0), PApplicationName = (byte *)0, PEngineName = (byte *)0, PNext = IntPtr.Zero }; var instanceInfo = new VkInstanceCreateInfo() { SType = VkStructureType.InstanceCreateInfo, EnabledExtensionCount = (uint)extensionsToUse.Count, PpEnabledExtensionNames = extensionsToUse.Count > 0 ? (byte **)Marshal.UnsafeAddrOfPinnedArrayElement(extensionsToUseAnsi, 0).ToPointer() : (byte **)0, EnabledLayerCount = (uint)layersToUse.Count, PpEnabledLayerNames = layersToUse.Count > 0 ? (byte **)Marshal.UnsafeAddrOfPinnedArrayElement(layersToUseAnsi, 0).ToPointer() : (byte **)0, Flags = 0, PApplicationInfo = &appInfo, PNext = IntPtr.Zero }; Handle = Vulkan.CreateInstance(&instanceInfo, AllocationCallbacks); } finally { pinnedLayersToUse.Free(); pinnedExtensionsToUse.Free(); foreach (var ptr in layersToUseAnsi) { Marshal.FreeHGlobal(ptr); } foreach (var ptr in extensionsToUseAnsi) { Marshal.FreeHGlobal(ptr); } } } var devs = new List <PhysicalDevice>(); foreach (var dev in Handle.EnumeratePhysicalDevices()) { devs.Add(new PhysicalDevice(this, dev)); } PhysicalDevices = devs; }