public void CreateDebugReportCallbackExt() { var createInfo = new InstanceCreateInfo( enabledLayerNames: new[] { InstanceLayer.LunarGStandardValidation }, enabledExtensionNames: new[] { InstanceExtension.ExtDebugReport }); using (var instance = new Instance(createInfo)) { var callbackArgs = new List <DebugReportCallbackInfo>(); int userData = 1; IntPtr userDataHandle = new IntPtr(&userData); var debugReportCallbackCreateInfo = new DebugReportCallbackCreateInfoExt( DebugReportFlagsExt.All, args => { callbackArgs.Add(args); return(false); }, userDataHandle); using (instance.CreateDebugReportCallbackExt(debugReportCallbackCreateInfo)) { instance.DebugReportMessageExt(DebugReportFlagsExt.Debug, "test"); Assert.NotEmpty(callbackArgs); Assert.Equal(1, *(int *)callbackArgs[0].UserData); } callbackArgs.Clear(); using (instance.CreateDebugReportCallbackExt(debugReportCallbackCreateInfo, CustomAllocator)) { instance.DebugReportMessageExt(DebugReportFlagsExt.Debug, "test"); Assert.NotEmpty(callbackArgs); Assert.Equal(1, *(int *)callbackArgs[0].UserData); } } }
private void CreateInstance() { AvailableInstanceExtensions = Instance.EnumerateExtensionProperties(); string[] selectExtensions = new[] { Constant.InstanceExtension.ExtDebugReport } .Where(AvailableInstanceExtensions.Contains) .ToArray(); // Specify standard validation layers. var createInfo = new InstanceCreateInfo { EnabledLayerNames = new[] { Constant.InstanceLayer.LunarGStandardValidation }, EnabledExtensionNames = selectExtensions }; Instance = new Instance(createInfo); // Attach debug callback and fail any test on any error or warning from validation layers. var debugReportCreateInfo = new DebugReportCallbackCreateInfoExt( DebugReportFlagsExt.Error | DebugReportFlagsExt.Warning | DebugReportFlagsExt.PerformanceWarning, args => { if ((args.Flags & (DebugReportFlagsExt.Error | DebugReportFlagsExt.PerformanceWarning | DebugReportFlagsExt.Warning)) > 0) { Assert.True(false, $"Validation layer error/warning:\n\n[{args.Flags}] {args.Message}"); } return(false); } ); _debugReportCallback = Instance.CreateDebugReportCallbackExt(debugReportCreateInfo); }
public void CreateDebugReportCallbackExt() { var createInfo = new InstanceCreateInfo( enabledLayerNames: new[] { InstanceLayer.LunarGStandardValidation }, enabledExtensionNames: new[] { InstanceExtension.ExtDebugReport }); using (var instance = new Instance(createInfo)) { var callbackArgs = new List <DebugReportCallbackInfo>(); int userData = 1; IntPtr userDataHandle = new IntPtr(&userData); var debugReportCallbackCreateInfo = new DebugReportCallbackCreateInfoExt( DebugReportFlagsExt.All, args => { callbackArgs.Add(args); return(false); }, userDataHandle); // Registering the callback should generate DEBUG messages. using (instance.CreateDebugReportCallbackExt(debugReportCallbackCreateInfo)) { } using (instance.CreateDebugReportCallbackExt(debugReportCallbackCreateInfo, CustomAllocator)) { } Assert.True(callbackArgs.Count > 0); Assert.Equal(1, *(int *)callbackArgs[0].UserData); } }
Instance CreateInstance() { // There is no global state in Vulkan and all per-application state is stored in a // `Instance` object. Creating a `Instance` object initializes the Vulkan library // and allows the application to pass information about itself to the implementation. // For this example, we want Vulkan to act in a 'default' fashion, so we don't // pass and ApplicationInfo object and we don't request any layers or extensions String[] enabledLayers = new string[] { "VK_LAYER_LUNARG_standard_validation" }; var enabledExtensions = new[] { VulkanConstant.ExtDebugReportExtensionName, }; var instanceCreateInfo = new InstanceCreateInfo(enabledLayers, enabledExtensions); var instance = Vk.CreateInstance(instanceCreateInfo); debugCallback = DebugUtils.CreateDebugReportCallback(instance, DebugReport); return(instance); }
private unsafe void instanceCreate() { var appInfo = new ApplicationInfo { SType = StructureType.ApplicationInfo, PApplicationName = (byte *)Marshal.StringToHGlobalAnsi(Assembly.GetExecutingAssembly().GetName().Name), ApplicationVersion = new Version32(1, 0, 0), PEngineName = (byte *)Marshal.StringToHGlobalAnsi(Assembly.GetExecutingAssembly().GetName().Name), EngineVersion = new Version32(1, 0, 0), ApiVersion = Vk.Version11 }; var createInfo = new InstanceCreateInfo { SType = StructureType.InstanceCreateInfo, PApplicationInfo = &appInfo, EnabledExtensionCount = 0, PpEnabledExtensionNames = null, EnabledLayerCount = 0, PNext = null }; fixed(Instance *instance = &_vk_instance) { if (_vk.CreateInstance(&createInfo, null, instance) != Result.Success) { throw new Exception("Failed to create instance!"); } } _vk.CurrentInstance = _vk_instance; Marshal.FreeHGlobal((IntPtr)appInfo.PApplicationName); Marshal.FreeHGlobal((IntPtr)appInfo.PEngineName); }
public static unsafe ReturnSet <Instance> Create() { try { var applicationInfo = new ApplicationInfo { StructureType = StructureType.ApplicationInfo, EngineVersion = 0, ApiVersion = Vulkan.ApiVersion }; var enabledExtensionNames = BuildExtensionArray(ExtensionNames.VK_KHR_surface, ExtensionNames.VK_KHR_win32_surface, ExtensionNames.VK_EXT_debug_report); fixed(void *enabledExtensionNamesPointer = &enabledExtensionNames[0]) { var instanceCreateInfo = new InstanceCreateInfo { StructureType = StructureType.InstanceCreateInfo, ApplicationInfo = new IntPtr(&applicationInfo), EnabledExtensionCount = (uint)enabledExtensionNames.Length, EnabledExtensionNames = new IntPtr(enabledExtensionNamesPointer), }; return(new ReturnSet <Instance>(Vulkan.CreateInstance(ref instanceCreateInfo))); } } catch (Exception ex) { return(new ReturnSet <Instance>(ex)); } }
static void CreateInstance() { var appInfo = new ApplicationInfo(); appInfo.ApplicationName = "vulkanExample"; appInfo.EngineName = "vulkanExample"; appInfo.ApiVersion = MakeVersion(1, 0, 0); var instanceEnabledExtensions = new[] { "VK_KHR_surface", // VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface", // VK_KHR_WIN32_SURFACE_EXTENSION_NAME }; var instanceCreateInfo = new InstanceCreateInfo(); instanceCreateInfo.ApplicationInfo = appInfo; instanceCreateInfo.EnabledExtensionNames = instanceEnabledExtensions; instance = new Instance(instanceCreateInfo); Console.WriteLine("[ OK ] Instance"); var physicalDevices = instance.EnumeratePhysicalDevices(); Console.WriteLine($"Physical Devices: {physicalDevices.Count}"); physicalDevice = physicalDevices[0]; Console.WriteLine("[ OK ] Physical Device"); }
public void ConstructorWithEnabledLayerAndExtension() { var createInfo = new InstanceCreateInfo( enabledLayerNames: new[] { InstanceLayer.LunarGStandardValidation }, enabledExtensionNames: new[] { InstanceExtension.ExtDebugReport }); using (new Instance(createInfo)) { } }
public void ConstructorWithApplicationInfo() { var createInfo1 = new InstanceCreateInfo(new ApplicationInfo()); var createInfo2 = new InstanceCreateInfo(new ApplicationInfo("app name", new Version(1, 0, 0), "engine name", new Version(2, 0, 0))); using (new Instance(createInfo1)) { } using (new Instance(createInfo2)) { } }
void CreateInstance() { //LayerProperties[] available_layers = DelegateUtility.EnumerateToArray<LayerProperties> ( vk.EnumerateInstanceLayerProperties ); ExtensionProperties[] available_extensions = DelegateUtility.EnumerateToArray <ExtensionProperties> (vk.EnumerateInstanceExtensionProperties, IntPtr.Zero); List <string> extensions = new List <string> { KhrWin32Surface.EXTENSION_NAME, KhrSurface.EXTENSION_NAME }; for (int i = 0; i < extensions.Count; ++i) { if (!CheckExtensionAvailability(extensions[i], available_extensions)) { //std::cout << "Could not find instance extension named \"" << extensions[i] << "\"!" << std::endl; return; } } if (CheckExtensionAvailability(ExtDebugReport.EXTENSION_NAME, available_extensions)) { extensions.Add(ExtDebugReport.EXTENSION_NAME); supportDebugReport = true; } var exPtr = MarshalUtility.AllocateString(extensions); ApplicationInfo application_info = new ApplicationInfo { sType = StructureType.ApplicationInfo, pNext = IntPtr.Zero, pApplicationName = (byte *)Marshal.StringToHGlobalAnsi("Vulkan Window"), applicationVersion = new Version(1, 0, 0), pEngineName = (byte *)Marshal.StringToHGlobalAnsi("Vulkan Tutorial"), engineVersion = new Version(1, 0, 0), apiVersion = new Version(1, 0, 0), }; InstanceCreateInfo instance_create_info = new InstanceCreateInfo { sType = StructureType.InstanceCreateInfo, pNext = IntPtr.Zero, flags = 0, pApplicationInfo = &application_info, enabledLayerCount = 0, ppEnabledLayerNames = (byte *)0, enabledExtensionCount = (uint)extensions.Count, ppEnabledExtensionNames = (byte *)exPtr, }; vk.CreateInstance(ref instance_create_info, (AllocationCallbacks *)0, out vulkan.Instance).CheckError(); MarshalUtility.FreeString(exPtr, extensions.Count); Marshal.FreeHGlobal((IntPtr)application_info.pApplicationName); Marshal.FreeHGlobal((IntPtr)application_info.pEngineName); }
internal static DeviceInfo[] GetSuitablePhysicalDevices(Vk api) { var appName = Marshal.StringToHGlobalAnsi(AppName); var applicationInfo = new ApplicationInfo { PApplicationName = (byte *)appName, ApplicationVersion = 1, PEngineName = (byte *)appName, EngineVersion = 1, ApiVersion = Vk.Version12.Value }; var instanceCreateInfo = new InstanceCreateInfo { SType = StructureType.InstanceCreateInfo, PApplicationInfo = &applicationInfo, PpEnabledExtensionNames = null, PpEnabledLayerNames = null, EnabledExtensionCount = 0, EnabledLayerCount = 0 }; api.CreateInstance(in instanceCreateInfo, null, out var instance).ThrowOnError(); Marshal.FreeHGlobal(appName); uint physicalDeviceCount; api.EnumeratePhysicalDevices(instance, &physicalDeviceCount, null).ThrowOnError(); PhysicalDevice[] physicalDevices = new PhysicalDevice[physicalDeviceCount]; fixed(PhysicalDevice *pPhysicalDevices = physicalDevices) { api.EnumeratePhysicalDevices(instance, &physicalDeviceCount, pPhysicalDevices).ThrowOnError(); } DeviceInfo[] devices = new DeviceInfo[physicalDevices.Length]; for (int i = 0; i < physicalDevices.Length; i++) { var physicalDevice = physicalDevices[i]; api.GetPhysicalDeviceProperties(physicalDevice, out var properties); devices[i] = new DeviceInfo( StringFromIdPair(properties.VendorID, properties.DeviceID), VendorUtils.GetNameFromId(properties.VendorID), Marshal.PtrToStringAnsi((IntPtr)properties.DeviceName), properties.DeviceType == PhysicalDeviceType.DiscreteGpu); } api.DestroyInstance(instance, null); return(devices); }
public static Instance CreateInstance(bool includeCommonDebug = false) { IEnumerable <InitRequest> initRequest = null; if (includeCommonDebug) { initRequest = InitRequestCommonDebug; } InstanceCreateInfo instanceCreateInfo = CreateInstanceCreateInfo(initRequest); return(new Instance(instanceCreateInfo)); }
public static void CreateVkInstance(Vk vk, InstanceCreateInfo instanceCreateInfo, out Instance instance) { fixed(Instance *_instance = &instance) { var result = vk.CreateInstance(&instanceCreateInfo, null, _instance); if (result != Result.Success) { Console.WriteLine("Failed to create vulkan instance"); return; } } }
private Instance CreateInstance(bool debug) { // Specify standard validation layers. string surfaceExtension; switch (Host.Platform) { case Platform.Android: surfaceExtension = Constant.InstanceExtension.KhrAndroidSurface; break; case Platform.Win32: surfaceExtension = Constant.InstanceExtension.KhrWin32Surface; break; case Platform.MacOS: surfaceExtension = Constant.InstanceExtension.MvkMacOSSurface; break; default: throw new NotImplementedException(); } var createInfo = new InstanceCreateInfo(); //Currently MoltenVK (used for MacOS) doesn't support the debug layer. if (debug && Host.Platform != Platform.MacOS) { var availableLayers = Instance.EnumerateLayerProperties(); createInfo.EnabledLayerNames = new[] { Constant.InstanceLayer.LunarGStandardValidation } .Where(availableLayers.Contains) .ToArray(); createInfo.EnabledExtensionNames = new[] { Constant.InstanceExtension.KhrSurface, surfaceExtension, Constant.InstanceExtension.ExtDebugReport }; } else { createInfo.EnabledExtensionNames = new[] { Constant.InstanceExtension.KhrSurface, surfaceExtension, }; } return(new Instance(createInfo)); }
public void EnumeratePhysicalDeviceGroupsKhx() { if (!AvailableDeviceExtensions.Contains(InstanceExtension.KhxDeviceGroupCreation)) { return; } var createInfo = new InstanceCreateInfo( enabledExtensionNames: new[] { InstanceExtension.KhxDeviceGroupCreation }); using (var instance = new Instance(createInfo)) { instance.EnumeratePhysicalDeviceGroupsKhx(); } }
private void CreateInstance() { ApplicationInfo applicationInfo = VkCreator.CreateApplicationInfo("Lux Graphics", default(SharpVk.Version), m_applicationName); List <string> extensions = new List <string>() { KhrSurface.ExtensionName, KhrWin32Surface.ExtensionName, }; CheckInstanceExtensions(extensions); List <string> validationLayers = new List <string>(); m_logger.WriteLine("{0} validation layers", m_usingValidationLayer ? "Using" : "Not using"); if (m_usingValidationLayer) { validationLayers.Add("VK_LAYER_LUNARG_standard_validation"); m_logger.WriteLine("Requested Instance validation layers are:"); validationLayers.ForEach(m_logger.WriteLine); List <LayerProperties> layerProperties = Instance.EnumerateLayerProperties().ToList(); m_logger.WriteLine("Available Instance validation layers are:"); layerProperties.Select(layer => layer.LayerName).ToList().ForEach(m_logger.WriteLine); if (validationLayers.Except(layerProperties.Select(layer => layer.LayerName)).Any()) { m_logger.WriteLine("The following requested validation layers are not available:"); validationLayers.Except(layerProperties.Select(layer => layer.LayerName)).ToList().ForEach(m_logger.WriteLine); throw new Exception("Instance validation layers not supported!"); } m_logger.WriteLine("All requested Instance validation layers have been found and are supported."); } InstanceCreateInfo instanceCreateInfo = VkCreator.CreateInstanceCreateInfo(applicationInfo, extensions.ToArray(), validationLayers.ToArray()); m_vkInstance = Instance.Create(instanceCreateInfo); m_logger.WriteLine("Instance created for application \"{0}\"", m_applicationName); }
public static void Main() { // https://gist.github.com/graphitemaster/e162a24e57379af840d4 var applicationInfo = new ApplicationInfo { ApplicationName = "Tutorial 1", EngineName = "", EngineVersion = 1, ApiVersion = Version.Make(1, 0, 0) }; var instanceInfo = new InstanceCreateInfo { ApplicationInfo = applicationInfo, Flags = 0, EnabledLayerCount = 0, EnabledLayerNames = null, EnabledExtensionCount = 2, EnabledExtensionNames = new [] { Extension.KhrSurface, Extension.KhrWin32Surface } }; var instance = new Instance(instanceInfo); var devices = instance.EnumeratePhysicalDevices(); foreach (var dev in devices) { PrintDeviceInformation(dev); } var physicalDevice = devices.First(); var device = CreateAbstractDevice(physicalDevice); var window = new Window(); window.Show(); var swapChain = new SwapChain(instance, physicalDevice, device); swapChain.Initialize(window); swapChain.Create(null); instance.Destroy(); Console.ReadLine(); }
internal static Instance CreateInstance() { // Pick surface extension for platform to create a window surface string surfaceExtension; switch (Environment.OSVersion.Platform) { case PlatformID.Win32NT: surfaceExtension = Constant.InstanceExtension.KhrWin32Surface; break; //case PlatformID.Unix: //surfaceExtension = Constant.InstanceExtension.KhrXlibSurface; //break; default: throw new PlatformNotSupportedException("No surface extension for this platform"); } // Start defining create info for this instance var createInfo = new InstanceCreateInfo(); #if DEBUG // Get properties of all available validation layers var availableLayers = Instance.EnumerateLayerProperties(); // Pick all of the layers in the below array that are available createInfo.EnabledLayerNames = new[] { Constant.InstanceLayer.LunarGStandardValidation } .Where(availableLayers.Contains) .ToArray(); // Set enabled extension names createInfo.EnabledExtensionNames = new[] { Constant.InstanceExtension.KhrSurface, surfaceExtension, Constant.InstanceExtension.ExtDebugReport // Debug report extension }; #else // Set enabled extension names createInfo.EnabledExtensionNames = new[] { Constant.InstanceExtension.KhrSurface, surfaceExtension, }; #endif return(new Instance(createInfo)); }
internal Instance(string appName, string engName, VER appVer, VER engVer, VER apiVer, bool bDebug) { string vlName = ""; if (bDebug) { if (!bCheckValidation(out vlName)) { return; } } ApplicationInfo ai = new ApplicationInfo(); ai.ApplicationName = appName; ai.ApplicationVersion = appVer; ai.EngineName = engName; ai.EngineVersion = engVer; ai.ApiVersion = apiVer; InstanceCreateInfo ici = new InstanceCreateInfo(); ici.Next = IntPtr.Zero; ici.ApplicationInfo = ai; List <string> extensions = new List <string>(); extensions.AddRange(Vulkan.GetRequiredInstanceExtensions()); if (bDebug) { extensions.Add(Constant.InstanceExtension.ExtDebugReport); } //get extension stuff from glfw ici.EnabledExtensionNames = extensions.ToArray(); if (bDebug) { ici.EnabledLayerNames = new string[1] { vlName }; } mInstance = new INST(ici, null); }
private Instance CreateInstance() { var app = new ApplicationInfo(); app.ApiVersion = Vulkan.Version.Make(1, 0, 0); app.ApplicationName = "VulkanSample"; app.ApplicationVersion = Vulkan.Version.Make(1, 0, 0); app.EngineName = "Engine0"; app.EngineVersion = Vulkan.Version.Make(1, 0, 0); var info = new InstanceCreateInfo(); info.ApplicationInfo = app; info.EnabledExtensionNames = new [] { "VK_KHR_surface", "VK_KHR_win32_surface" }; return(new Instance(info)); }
public Instance(InstanceCreateInfo CreateInfo, AllocationCallbacks Allocator = null) { Result result; unsafe { fixed(IntPtr *ptrInstance = &m) { result = Interop.NativeMethods.vkCreateInstance(CreateInfo.m, Allocator != null ? Allocator.m : null, ptrInstance); } } if (result != Result.Success) { throw new ResultException(result); } }
public Instance(InstanceCreateInfo createInfo, AllocationCallbacks allocator = null) { Result result; unsafe { fixed(IntPtr *ptrInstance = &_handle) { result = Interop.NativeMethods.vkCreateInstance(createInfo._handle, allocator != null ? allocator.Handle : null, ptrInstance); } } if (result != Result.Success) { throw new ResultException(result); } }
public static void CreateVkInfo(string appName, out ApplicationInfo applicationInfo, out InstanceCreateInfo instanceCreateInfo) { applicationInfo = new ApplicationInfo { SType = StructureType.ApplicationInfo, PApplicationName = (byte *)Marshal.StringToHGlobalAnsi(appName), ApiVersion = Vk.Version12 }; fixed(ApplicationInfo *appInfo = &applicationInfo) { instanceCreateInfo = new InstanceCreateInfo { SType = StructureType.InstanceCreateInfo, PApplicationInfo = appInfo }; } }
protected Instance CreateInstance() { String[] enabledLayers = new string[] { "VK_LAYER_LUNARG_standard_validation" }; var enabledExtensions = new[] { VulkanConstant.KhrSurfaceExtensionName, VulkanConstant.KhrWin32SurfaceExtensionName, VulkanConstant.ExtDebugReportExtensionName, }; var instanceCreateInfo = new InstanceCreateInfo(enabledLayers, enabledExtensions); var instance = Vk.CreateInstance(instanceCreateInfo); debugCallback = DebugUtils.CreateDebugReportCallback(instance, DebugReport); return(instance); }
private Instance CreateInstance() { using var appName = SilkMarshal.StringToMemory("Hello Cube"); using var engineName = SilkMarshal.StringToMemory("Custom Engine"); var appInfo = new ApplicationInfo ( pApplicationName: (byte *)appName, applicationVersion: new Version32(0, 0, 1), pEngineName: (byte *)engineName, engineVersion: new Version32(0, 0, 1), apiVersion: Vk.Version11 ); List <string> extensions = new List <string>(GetWindowExtensions()) { Debugging.DebugExtensionString }; string[] layers = new string[] { "VK_LAYER_KHRONOS_validation" }; using var extList = SilkMarshal.StringArrayToMemory(extensions); using var layerList = SilkMarshal.StringArrayToMemory(layers); var instInfo = new InstanceCreateInfo(pApplicationInfo: &appInfo, enabledLayerCount: (uint)layers.Length, ppEnabledLayerNames: (byte **)layerList, enabledExtensionCount: (uint)extensions.Count, ppEnabledExtensionNames: (byte **)extList); Instance inst; var res = VkApi.CreateInstance(&instInfo, null, &inst); if (res != Result.Success) { throw new VMASharp.VulkanResultException("Instance Creation Failed", res); } return(inst); }
public bool TryInit(string appName, uint version, string[] validationLayers, string[] extensionNames) { LayerProperties[] layers = Commands.EnumerateInstanceLayerProperties(); if (!ValidateLayers(validationLayers, layers)) { return(false); } ExtensionProperties[] extensions = Commands.EnumerateInstanceExtensionProperties(""); if (!ValidateExtentsions(extensionNames, extensions)) { return(false); } InstanceCreateInfo info = new InstanceCreateInfo { ApplicationInfo = new ApplicationInfo { ApplicationName = appName, ApplicationVersion = 0, EngineName = appName, EngineVersion = 0, ApiVersion = ApiVersion, }, EnabledLayerNames = validationLayers, EnabledExtensionNames = extensionNames, }; Instance = new Instance(info); gpuList = Instance.EnumeratePhysicalDevices(); if (gpuList.Length < 0) { return(false); } return(true); }
public void DebugReportMessageExt() { const string message = "message õäöü"; const DebugReportObjectTypeExt objectType = DebugReportObjectTypeExt.DebugReportCallback; const long @object = long.MaxValue; var location = new IntPtr(int.MaxValue); const int messageCode = 1; const string layerPrefix = "prefix õäöü"; bool visitedCallback = false; var instanceCreateInfo = new InstanceCreateInfo( enabledExtensionNames: new[] { InstanceExtension.ExtDebugReport }); using (var instance = new Instance(instanceCreateInfo)) { var debugReportCallbackCreateInfo = new DebugReportCallbackCreateInfoExt( DebugReportFlagsExt.Error, args => { Assert.Equal(objectType, args.ObjectType); Assert.Equal(@object, args.Object); Assert.Equal(location, args.Location); Assert.Equal(messageCode, args.MessageCode); Assert.Equal(layerPrefix, args.LayerPrefix); Assert.Equal(message, args.Message); visitedCallback = true; return(false); }); using (instance.CreateDebugReportCallbackExt(debugReportCallbackCreateInfo)) { instance.DebugReportMessageExt(DebugReportFlagsExt.Error, message, objectType, @object, location, messageCode, layerPrefix); } } Assert.True(visitedCallback); }
private void CreateInstance() { ApplicationInfo appInfo = new ApplicationInfo() { ApplicationName = "Hello Triangle", EngineName = "WaveEngine", EngineVersion = Vulkan.Version.Make(3, 0, 0), }; string[] extensions = new string[] { "VK_KHR_surface", "VK_KHR_win32_surface", }; InstanceCreateInfo createInfo = new InstanceCreateInfo() { EnabledExtensionNames = extensions, ApplicationInfo = appInfo, }; vkInstance = new Instance(createInfo); }
public static unsafe Instance CreateInstance(string[] instanceLayers, string[] instanceExtensions, IVkSurface windowSurface) { ApplicationInfo appInfo = new() { SType = StructureType.ApplicationInfo, PApplicationName = (byte *)SilkMarshal.StringToPtr("SilkyNvg-Vulkan-Example"), ApplicationVersion = Vk.MakeVersion(1, 0, 0), PEngineName = (byte *)SilkMarshal.StringToPtr("SilkyNvg (Renderer: Vulkan)"), EngineVersion = Vk.MakeVersion(1, 0, 0), ApiVersion = Vk.Version12 }; byte **windowExtensionsPtr = windowSurface.GetRequiredExtensions(out uint windowExtensionCount); byte **instanceExtensionsPtr = (byte **)SilkMarshal.StringArrayToPtr(instanceExtensions); byte **extensions = stackalloc byte *[(int)windowExtensionCount + instanceExtensions.Length]; int i = 0; for (; i < windowExtensionCount; i++) { extensions[i] = windowExtensionsPtr[i]; } for (; i < windowExtensionCount + instanceExtensions.Length; i++) { extensions[i] = instanceExtensionsPtr[i]; } CheckInstanceExtensionsPresent(extensions, (int)windowExtensionCount + instanceExtensions.Length); CheckInstanceLayersPresent(instanceLayers); byte **layers = (byte **)SilkMarshal.StringArrayToPtr(instanceLayers); InstanceCreateInfo instanceCreateInfo = VkInit.InstanceCreateInfo(appInfo, layers, (uint)instanceLayers.Length, extensions, windowExtensionCount); AssertVulkan(Vk.CreateInstance(instanceCreateInfo, null, out Instance instance)); return(instance); }
public static InstanceCreateInfo CreateInstanceCreateInfo(ApplicationInfo appInfo, IEnumerable <InitRequest> initRequest = null) { string[] layers; string[] extentions; if (initRequest != null) { layers = GetInstanceLayers(initRequest); extentions = GetInstanceExtention(initRequest); } else { layers = new string[0]; extentions = new string[0]; } InstanceCreateInfo instanceCreateInfo = new InstanceCreateInfo { ApplicationInfo = appInfo, EnabledLayerNames = layers, EnabledExtensionNames = extentions, }; return(instanceCreateInfo); }
public static unsafe Instance CreateInstance(ref InstanceCreateInfo createInfo, AllocationCallbacks* allocator = null) { Instance instance; fixed (InstanceCreateInfo* __createInfo__ = &createInfo) { vkCreateInstance(__createInfo__, allocator, &instance).CheckError(); } return instance; }
public unsafe GraphicsAdapterFactoryInstance(bool enableValidation) { var applicationInfo = new ApplicationInfo { StructureType = StructureType.ApplicationInfo, ApiVersion = new SharpVulkan.Version(1, 0, 0), EngineName = Marshal.StringToHGlobalAnsi("Xenko"), //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 = Vulkan.InstanceLayerProperties; var availableLayerNames = new HashSet<string>(); for (int index = 0; index < layers.Length; index++) { var properties = layers[index]; var namePointer = new IntPtr(Interop.Fixed(ref properties.LayerName)); var name = Marshal.PtrToStringAnsi(namePointer); availableLayerNames.Add(name); } enabledLayerNames = desiredLayerNames .Where(x => availableLayerNames.Contains(x)) .Select(Marshal.StringToHGlobalAnsi).ToArray(); } var extensionProperties = Vulkan.GetInstanceExtensionProperties(); var availableExtensionNames = new List<string>(); var desiredExtensionNames = new List<string>(); for (int index = 0; index < extensionProperties.Length; index++) { var namePointer = new IntPtr(Interop.Fixed(ref extensionProperties[index].ExtensionName)); var name = Marshal.PtrToStringAnsi(namePointer); availableExtensionNames.Add(name); } desiredExtensionNames.Add("VK_KHR_surface"); if (!availableExtensionNames.Contains("VK_KHR_surface")) throw new InvalidOperationException("Required extension VK_KHR_surface is not available"); #if SILICONSTUDIO_PLATFORM_WINDOWS_DESKTOP desiredExtensionNames.Add("VK_KHR_win32_surface"); if (!availableExtensionNames.Contains("VK_KHR_win32_surface")) throw new InvalidOperationException("Required extension VK_KHR_win32_surface is not available"); #elif SILICONSTUDIO_PLATFORM_ANDROID desiredExtensionNames.Add("VK_KHR_android_surface"); if (!availableExtensionNames.Contains("VK_KHR_android_surface")) throw new InvalidOperationException("Required extension VK_KHR_android_surface is not available"); #elif SILICONSTUDIO_PLATFORM_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"); } #endif bool enableDebugReport = enableValidation && availableExtensionNames.Contains("VK_EXT_debug_report"); if (enableDebugReport) desiredExtensionNames.Add("VK_EXT_debug_report"); var enabledExtensionNames = desiredExtensionNames.Select(Marshal.StringToHGlobalAnsi).ToArray(); var createDebugReportCallbackName = Marshal.StringToHGlobalAnsi("vkCreateDebugReportCallbackEXT"); try { fixed (void* enabledExtensionNamesPointer = &enabledExtensionNames[0]) { var instanceCreateInfo = new InstanceCreateInfo { StructureType = StructureType.InstanceCreateInfo, ApplicationInfo = new IntPtr(&applicationInfo), EnabledLayerCount = enabledLayerNames != null ? (uint)enabledLayerNames.Length : 0, EnabledLayerNames = enabledLayerNames?.Length > 0 ? new IntPtr(Interop.Fixed(enabledLayerNames)) : IntPtr.Zero, EnabledExtensionCount = (uint)enabledExtensionNames.Length, EnabledExtensionNames = new IntPtr(enabledExtensionNamesPointer) }; NativeInstance = Vulkan.CreateInstance(ref instanceCreateInfo); } if (enableDebugReport) { var createDebugReportCallback = (CreateDebugReportCallbackDelegate)Marshal.GetDelegateForFunctionPointer(NativeInstance.GetProcAddress((byte*)createDebugReportCallbackName), typeof(CreateDebugReportCallbackDelegate)); debugReport = DebugReport; var createInfo = new DebugReportCallbackCreateInfo { StructureType = StructureType.DebugReportCallbackCreateInfo, Flags = (uint)(DebugReportFlags.Error | DebugReportFlags.Warning /* | DebugReportFlags.PerformanceWarning | DebugReportFlags.Information | DebugReportFlags.Debug*/), Callback = 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 = NativeInstance.GetProcAddress((byte*)Interop.Fixed(beginDebugMarkerName)); if (ptr != IntPtr.Zero) BeginDebugMarker = (BeginDebugMarkerDelegate)Marshal.GetDelegateForFunctionPointer(ptr, typeof(BeginDebugMarkerDelegate)); var endDebugMarkerName = System.Text.Encoding.ASCII.GetBytes("vkCmdDebugMarkerEndEXT"); ptr = NativeInstance.GetProcAddress((byte*)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(applicationInfo.EngineName); Marshal.FreeHGlobal(createDebugReportCallbackName); } }
protected virtual void CreateInstance() { var applicationInfo = new ApplicationInfo { StructureType = StructureType.ApplicationInfo, EngineVersion = 0, ApiVersion = Vulkan.ApiVersion }; var enabledLayerNames = new [] { Marshal.StringToHGlobalAnsi("VK_LAYER_LUNARG_standard_validation"), }; var enabledExtensionNames = new [] { Marshal.StringToHGlobalAnsi("VK_KHR_surface"), Marshal.StringToHGlobalAnsi("VK_KHR_win32_surface"), Marshal.StringToHGlobalAnsi("VK_EXT_debug_report"), }; try { fixed (void* enabledLayerNamesPointer = &enabledLayerNames[0]) fixed (void* enabledExtensionNamesPointer = &enabledExtensionNames[0]) { var instanceCreateInfo = new InstanceCreateInfo { StructureType = StructureType.InstanceCreateInfo, ApplicationInfo = new IntPtr(&applicationInfo), EnabledExtensionCount = (uint)enabledExtensionNames.Length, EnabledExtensionNames = new IntPtr(enabledExtensionNamesPointer), }; if (validate) { instanceCreateInfo.EnabledLayerCount = (uint)enabledLayerNames.Length; instanceCreateInfo.EnabledLayerNames = new IntPtr(enabledLayerNamesPointer); } instance = Vulkan.CreateInstance(ref instanceCreateInfo); } if (validate) { var createDebugReportCallbackName = Encoding.ASCII.GetBytes("vkCreateDebugReportCallbackEXT"); fixed (byte* createDebugReportCallbackNamePointer = &createDebugReportCallbackName[0]) { var createDebugReportCallback = Marshal.GetDelegateForFunctionPointer<CreateDebugReportCallbackDelegate>(instance.GetProcAddress(createDebugReportCallbackNamePointer)); debugReport = DebugReport; var createInfo = new DebugReportCallbackCreateInfo { StructureType = StructureType.DebugReportCallbackCreateInfo, Flags = (uint)(DebugReportFlags.Error | DebugReportFlags.Warning | DebugReportFlags.PerformanceWarning), Callback = Marshal.GetFunctionPointerForDelegate(debugReport) }; createDebugReportCallback(instance, ref createInfo, null, out debugReportCallback); } } } finally { foreach (var enabledExtensionName in enabledExtensionNames) Marshal.FreeHGlobal(enabledExtensionName); foreach (var enabledLayerName in enabledLayerNames) Marshal.FreeHGlobal(enabledLayerName); } physicalDevice = instance.PhysicalDevices[0]; var props = physicalDevice.QueueFamilyProperties; }
internal static unsafe extern Result vkCreateInstance(InstanceCreateInfo* createInfo, AllocationCallbacks* allocator, Instance* instance);