private unsafe VkResult CreateDebugReportCallback( VkDebugReportFlagsEXT flags ) { _debugCallbackFunction = DebugCallback; var debugFunctionPtr = Marshal.GetFunctionPointerForDelegate(_debugCallbackFunction); var debugCallbackInfo = new VkDebugReportCallbackCreateInfoEXT { sType = VkStructureType.DebugReportCallbackCreateInfoEXT, flags = flags, pfnCallback = debugFunctionPtr }; var createFunctionPtr = VulkanNative.vkGetInstanceProcAddr( _handle, new FixedUtf8String("vkCreateDebugReportCallbackEXT") ); if (createFunctionPtr == IntPtr.Zero) { return(VkResult.ErrorValidationFailedEXT); } var createDelegate = Marshal.GetDelegateForFunctionPointer <vkCreateDebugReportCallbackEXT_d>( createFunctionPtr ); return(createDelegate( _handle, &debugCallbackInfo, IntPtr.Zero, out _debugCallbackHandle )); }
private void EnableDebugCallback(VkDebugReportFlagBitsEXT flags = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_ERROR_BIT_EXT | VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_WARNING_BIT_EXT | VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_DEBUG_BIT_EXT) { Debug.WriteLine("Enabling Vulkan Debug callbacks."); this.debugCallbackFunc = this.DebugCallback; IntPtr debugFunctionPtr = Marshal.GetFunctionPointerForDelegate(this.debugCallbackFunc); VkDebugReportCallbackCreateInfoEXT debugCallbackCI = new VkDebugReportCallbackCreateInfoEXT(); debugCallbackCI.sType = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; debugCallbackCI.flags = flags; debugCallbackCI.pfnCallback = debugFunctionPtr; var createFnPtr = VulkanNative.vkGetInstanceProcAddr(this.vkInstance, "vkCreateDebugReportCallbackEXT".ToPointer()); if (createFnPtr == IntPtr.Zero) { return; } vkCreateDebugReportCallbackEXT_d createDelegate = Marshal.GetDelegateForFunctionPointer <vkCreateDebugReportCallbackEXT_d>(createFnPtr); VkResult result = createDelegate(this.vkInstance, &debugCallbackCI, IntPtr.Zero, out this.debugCallbackHandle); Helpers.CheckErrors(result); }
public DebugReport(Instance instance, VkDebugReportFlagsEXT flags = VkDebugReportFlagsEXT.ErrorEXT | VkDebugReportFlagsEXT.WarningEXT) { inst = instance; VkDebugReportCallbackCreateInfoEXT dbgInfo = new VkDebugReportCallbackCreateInfoEXT { sType = VkStructureType.DebugReportCallbackCreateInfoEXT, flags = flags, pfnCallback = Marshal.GetFunctionPointerForDelegate(debugCallbackDelegate) }; Utils.CheckResult(vkCreateDebugReportCallbackEXT(inst.Handle, ref dbgInfo, IntPtr.Zero, out handle)); }
private void SetupDebugCallback() { if (!EnableValidationLayers) { return; } var createInfo = new VkDebugReportCallbackCreateInfoEXT { Flags = VkDebugReportFlagsEXT.Error | VkDebugReportFlagsEXT.Warning, Callback = DebugCallback }; callback = instance.CreateDebugReportCallbackEXT(createInfo, null).Object; }
public void EnableDebugCallback(VkDebugReportFlagsEXT flags = VkDebugReportFlagsEXT.WarningEXT | VkDebugReportFlagsEXT.ErrorEXT) { _debugCallbackFunc = DebugCallback; IntPtr debugFunctionPtr = Marshal.GetFunctionPointerForDelegate(_debugCallbackFunc); VkDebugReportCallbackCreateInfoEXT debugCallbackCI = VkDebugReportCallbackCreateInfoEXT.New(); debugCallbackCI.flags = flags; debugCallbackCI.pfnCallback = debugFunctionPtr; FixedUtf8String debugExtFnName = "vkCreateDebugReportCallbackEXT"; IntPtr createFnPtr = vkGetInstanceProcAddr(_instance, debugExtFnName); vkCreateDebugReportCallbackEXT_d createDelegate = Marshal.GetDelegateForFunctionPointer <vkCreateDebugReportCallbackEXT_d>(createFnPtr); createDelegate(_instance, &debugCallbackCI, IntPtr.Zero, out _debugCallbackHandle); }
private void setupDebugCallback() { if (!enableValidationLayers) { return; } VkDebugReportCallbackCreateInfoEXT createInfo = new VkDebugReportCallbackCreateInfoEXT(); createInfo.sType = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; createInfo.flags = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_ERROR_BIT_EXT | VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_WARNING_BIT_EXT; createInfo.pfnCallback = debugCallback; if (Vulkan.vkCreateDebugReportCallbackEXT(instance, createInfo, null, out callback) != VkResult.VK_SUCCESS) { throw Program.Throw("failed to set up debug callback!"); } }
public void EnableDebugCallback(VkDebugReportFlagsEXT flags = VkDebugReportFlagsEXT.WarningEXT | VkDebugReportFlagsEXT.ErrorEXT) { Debug.WriteLine("Enabling Vulkan Debug callbacks."); _debugCallbackFunc = DebugCallback; IntPtr debugFunctionPtr = Marshal.GetFunctionPointerForDelegate(_debugCallbackFunc); VkDebugReportCallbackCreateInfoEXT debugCallbackCI = VkDebugReportCallbackCreateInfoEXT.New(); debugCallbackCI.flags = flags; debugCallbackCI.pfnCallback = debugFunctionPtr; IntPtr createFnPtr; using (FixedUtf8String debugExtFnName = "vkCreateDebugReportCallbackEXT") { createFnPtr = vkGetInstanceProcAddr(_instance, debugExtFnName); } vkCreateDebugReportCallbackEXT_d createDelegate = Marshal.GetDelegateForFunctionPointer <vkCreateDebugReportCallbackEXT_d>(createFnPtr); VkResult result = createDelegate(_instance, &debugCallbackCI, IntPtr.Zero, out _debugCallbackHandle); CheckResult(result); }
internal DebugReportCallbackExt(VkInstance parent, VkDebugReportFlagsEXT flags, Func <DebugReportCallbackInfo, bool> callback, IntPtr userData = default(IntPtr)) { Parent = parent; Func <DebugReportCallbackInfo, bool> createInfoCallback = callback; IntPtr callbackHandle = IntPtr.Zero; if (createInfoCallback != null) { _callback = (flags, objectType, @object, location, messageCode, layerPrefix, message, userData) => createInfoCallback(new DebugReportCallbackInfo { Flags = flags, ObjectType = objectType, Object = @object, Location = location, MessageCode = messageCode, LayerPrefix = Utilities.FromPointer(layerPrefix), Message = Utilities.FromPointer(message), UserData = userData }); callbackHandle = Marshal.GetFunctionPointerForDelegate(_callback); } var nativeCreateInfo = new VkDebugReportCallbackCreateInfoEXT { sType = VkStructureType.DebugReportCallbackCreateInfoEXT, flags = flags, pfnCallback = callbackHandle, pUserData = (void *)userData }; long handle; VkResult result = vkCreateDebugReportCallbackEXT(Parent)(Parent.Handle, &nativeCreateInfo, null, &handle); this.handle = (ulong)handle; }
public static extern VkResult CreateDebugReportCallbackEXT( VkInstance instance, ref VkDebugReportCallbackCreateInfoEXT pCreateInfo, IntPtr pAllocator, out VkDebugReportCallbackEXT pCallback );
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); } }
public VkResult CreateDebugReportCallback(VkDebugReportCallbackCreateInfoEXT pCreateInfo, out VkDebugReportCallbackEXT pCallback) { pCallback = new VkDebugReportCallbackEXT(this, pCreateInfo); m_ReportCallbacks.Add(pCallback); return(VkResult.VK_SUCCESS); }
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); }
private VkInstance CreateInstance() { List <GCHandle> handles = new List <GCHandle>(); bool debug = false; string[] debugOnlyLayers = new string[] { //"VK_LAYER_GOOGLE_threading", //"VK_LAYER_LUNARG_parameter_validation", //"VK_LAYER_LUNARG_device_limits", Not Present? //"VK_LAYER_LUNARG_object_tracker", //"VK_LAYER_LUNARG_image", Not Present? "VK_LAYER_LUNARG_core_validation", //"VK_LAYER_LUNARG_swapchain", //"VK_LAYER_GOOGLE_unique_objects", }; List <string> layerList = new List <string>(); if (debug) { layerList.AddRange(debugOnlyLayers); } string[] layers = layerList.ToArray(); byte[][] pDebugLayers = new byte[layers.Length][]; byte *[] ppDebugLayerArray = new byte *[pDebugLayers.Length]; if (!debug) { ppDebugLayerArray = new byte *[1];//this is to give a null ptr to use later } for (int i = 0; i < pDebugLayers.Length; i++) { pDebugLayers[i] = Encoding.UTF8.GetBytes(layers[i] + char.MinValue); GCHandle handle = GCHandle.Alloc(pDebugLayers[i]); handles.Add(handle); fixed(byte *p = &(((byte[])handle.Target)[0])) { ppDebugLayerArray[i] = p; } } List <string> requiredExtensions = new List <string>(); requiredExtensions.Add("VK_EXT_debug_report"); requiredExtensions.AddRange(GLFW.Vulkan.GetRequiredInstanceExtensions()); string[] extensionNames = requiredExtensions.ToArray(); byte[][] pExtensionNames = new byte[extensionNames.Length][]; byte *[] ppExtensionNamesArray = new byte *[extensionNames.Length]; for (int i = 0; i < pExtensionNames.Length; i++) { pExtensionNames[i] = Encoding.UTF8.GetBytes(extensionNames[i] + char.MinValue); GCHandle handle = GCHandle.Alloc(pExtensionNames[i]); handles.Add(handle); fixed(byte *p = &(((byte[])handle.Target)[0])) { ppExtensionNamesArray[i] = p; } } VkInstance instance = new VkInstance(); fixed(byte **layersptr = &ppDebugLayerArray[0]) { fixed(byte **extensions = &ppExtensionNamesArray[0]) { VkInstanceCreateInfo pCreateInfo = VkInstanceCreateInfo.New(); pCreateInfo.ppEnabledLayerNames = layersptr; pCreateInfo.ppEnabledExtensionNames = extensions; pCreateInfo.enabledLayerCount = (uint)pDebugLayers.Length; pCreateInfo.enabledExtensionCount = (uint)extensionNames.Length; Assert(vkCreateInstance(&pCreateInfo, null, &instance)); } } foreach (var handle in handles) { handle.Free(); } DebugDelegate debugDelegate = new DebugDelegate(DebugCallback); //PFN_vkDebugReportCallbackEXT _debugCallbackFunc =(PFN_vkDebugReportCallbackEXT) debugDelegate; IntPtr debugFunctionPtr = Marshal.GetFunctionPointerForDelegate(debugDelegate); debugDelegateHandle = GCHandle.Alloc(debugDelegate); VkDebugReportCallbackCreateInfoEXT createInfoEXT = VkDebugReportCallbackCreateInfoEXT.New(); createInfoEXT.pfnCallback = debugFunctionPtr; createInfoEXT.flags = //VkDebugReportFlagsEXT.DebugEXT | VkDebugReportFlagsEXT.ErrorEXT | VkDebugReportFlagsEXT.WarningEXT | (VkDebugReportFlagsEXT)int.MaxValue; byte[] debugExtFnName = Encoding.UTF8.GetBytes("vkCreateDebugReportCallbackEXT" + char.MinValue); IntPtr createFnPtr; fixed(byte *namePtr = &(debugExtFnName[0])) { createFnPtr = vkGetInstanceProcAddr(instance, namePtr); } vkCreateDebugReportCallbackEXT_d createDelegate = Marshal.GetDelegateForFunctionPointer <vkCreateDebugReportCallbackEXT_d>(createFnPtr); VkDebugReportCallbackCreateInfoEXT *createInfoPtr = (&createInfoEXT); fixed(ulong *ptr = &(debugReport.Handle)) { Assert(createDelegate(instance, createInfoPtr, IntPtr.Zero, out debugReport)); } return(instance); }