diff --git a/Avalonia.sln b/Avalonia.sln index e6898131b0..04feef5683 100644 --- a/Avalonia.sln +++ b/Avalonia.sln @@ -232,6 +232,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ControlCatalog.Browser.Blaz EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ReactiveUIDemo", "samples\ReactiveUIDemo\ReactiveUIDemo.csproj", "{75C47156-C5D8-44BC-A5A7-E8657C2248D6}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Avalonia.Vulkan", "src\Avalonia.Vulkan\Avalonia.Vulkan.csproj", "{3E2DE2B6-13BC-4C27-BCB9-A423B86CAF77}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -543,6 +545,10 @@ Global {75C47156-C5D8-44BC-A5A7-E8657C2248D6}.Debug|Any CPU.Build.0 = Debug|Any CPU {75C47156-C5D8-44BC-A5A7-E8657C2248D6}.Release|Any CPU.ActiveCfg = Release|Any CPU {75C47156-C5D8-44BC-A5A7-E8657C2248D6}.Release|Any CPU.Build.0 = Release|Any CPU + {3E2DE2B6-13BC-4C27-BCB9-A423B86CAF77}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {3E2DE2B6-13BC-4C27-BCB9-A423B86CAF77}.Debug|Any CPU.Build.0 = Debug|Any CPU + {3E2DE2B6-13BC-4C27-BCB9-A423B86CAF77}.Release|Any CPU.ActiveCfg = Release|Any CPU + {3E2DE2B6-13BC-4C27-BCB9-A423B86CAF77}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/build/CoreLibraries.props b/build/CoreLibraries.props index 00a1e3094b..0432141f0b 100644 --- a/build/CoreLibraries.props +++ b/build/CoreLibraries.props @@ -4,6 +4,7 @@ + diff --git a/samples/ControlCatalog.NetCore/Program.cs b/samples/ControlCatalog.NetCore/Program.cs index d5e5cb14dc..1496cb82dd 100644 --- a/samples/ControlCatalog.NetCore/Program.cs +++ b/samples/ControlCatalog.NetCore/Program.cs @@ -10,7 +10,7 @@ using Avalonia.Controls.ApplicationLifetimes; using Avalonia.Headless; using Avalonia.LogicalTree; using Avalonia.Threading; - +using Avalonia.Vulkan; using ControlCatalog.Pages; namespace ControlCatalog.NetCore @@ -122,7 +122,15 @@ namespace ControlCatalog.NetCore { EnableMultiTouch = true, UseDBusMenu = true, - EnableIme = true + EnableIme = true, + UseVulkan = true + }) + .With(new VulkanOptions + { + VulkanInstanceCreationOptions = new () + { + UseDebug = true + } }) .UseSkia() .AfterSetup(builder => diff --git a/src/Android/Avalonia.Android/Platform/SkiaPlatform/InvalidationAwareSurfaceView.cs b/src/Android/Avalonia.Android/Platform/SkiaPlatform/InvalidationAwareSurfaceView.cs index 33501ece06..eca20b84e3 100644 --- a/src/Android/Avalonia.Android/Platform/SkiaPlatform/InvalidationAwareSurfaceView.cs +++ b/src/Android/Avalonia.Android/Platform/SkiaPlatform/InvalidationAwareSurfaceView.cs @@ -7,10 +7,11 @@ using Android.Util; using Android.Views; using Avalonia.Android.Platform.SkiaPlatform; using Avalonia.Platform; +using Avalonia.Platform.Surfaces; namespace Avalonia.Android { - public abstract class InvalidationAwareSurfaceView : SurfaceView, ISurfaceHolderCallback, IPlatformNativeSurfaceHandle + public abstract class InvalidationAwareSurfaceView : SurfaceView, ISurfaceHolderCallback, INativeHandlePlatformSurface { bool _invalidateQueued; readonly object _lock = new object(); diff --git a/src/Avalonia.Base/Platform/Interop/Utf8Buffer.cs b/src/Avalonia.Base/Platform/Interop/Utf8Buffer.cs index 7a0b5b34cd..22b0dff967 100644 --- a/src/Avalonia.Base/Platform/Interop/Utf8Buffer.cs +++ b/src/Avalonia.Base/Platform/Interop/Utf8Buffer.cs @@ -54,5 +54,8 @@ namespace Avalonia.Platform.Interop ArrayPool.Shared.Return(bytes); } } + + public static implicit operator IntPtr(Utf8Buffer b) => b.handle; + public static unsafe implicit operator byte*(Utf8Buffer b) => (byte*)b.handle; } } diff --git a/src/Avalonia.Controls/Platform/IPlatformNativeSurfaceHandle.cs b/src/Avalonia.Controls/Platform/Surfaces/IPlatformNativeSurfaceHandle.cs similarity index 58% rename from src/Avalonia.Controls/Platform/IPlatformNativeSurfaceHandle.cs rename to src/Avalonia.Controls/Platform/Surfaces/IPlatformNativeSurfaceHandle.cs index 6ad07b1b13..5220792adc 100644 --- a/src/Avalonia.Controls/Platform/IPlatformNativeSurfaceHandle.cs +++ b/src/Avalonia.Controls/Platform/Surfaces/IPlatformNativeSurfaceHandle.cs @@ -1,10 +1,10 @@ using System; using Avalonia.Metadata; -namespace Avalonia.Platform +namespace Avalonia.Platform.Surfaces { [Unstable] - public interface IPlatformNativeSurfaceHandle : IPlatformHandle + public interface INativeHandlePlatformSurface : IPlatformHandle { PixelSize Size { get; } double Scaling { get; } diff --git a/src/Avalonia.Vulkan/Avalonia.Vulkan.csproj b/src/Avalonia.Vulkan/Avalonia.Vulkan.csproj new file mode 100644 index 0000000000..7ade700b64 --- /dev/null +++ b/src/Avalonia.Vulkan/Avalonia.Vulkan.csproj @@ -0,0 +1,17 @@ + + + + net6.0;netstandard2.0 + true + + + + + + + + + + + + diff --git a/src/Avalonia.Vulkan/IVulkanDevice.cs b/src/Avalonia.Vulkan/IVulkanDevice.cs new file mode 100644 index 0000000000..45815adffc --- /dev/null +++ b/src/Avalonia.Vulkan/IVulkanDevice.cs @@ -0,0 +1,34 @@ +using System; +using System.Collections.Generic; +using Avalonia.Metadata; +using Avalonia.Platform; +using Avalonia.Vulkan.UnmanagedInterop; + +namespace Avalonia.Vulkan; +public interface IVulkanDevice : IDisposable, IOptionalFeatureProvider +{ + public IntPtr Handle { get; } + public IntPtr PhysicalDeviceHandle { get; } + public IntPtr MainQueueHandle { get; } + public uint GraphicsQueueFamilyIndex { get; } + public IVulkanInstance Instance { get; } + bool IsLost { get; } + public IDisposable Lock(); +} + +[NotClientImplementable] +public interface IVulkanPlatformGraphicsContext : IPlatformGraphicsContext +{ + IVulkanDevice Device { get; } + IVulkanInstance Instance { get; } + internal VulkanInstanceApi InstanceApi { get; } + internal VulkanDeviceApi DeviceApi { get; } + IVulkanRenderTarget CreateRenderTarget(IEnumerable surfaces); +} + +public interface IVulkanInstance +{ + public IntPtr Handle { get; } + public IntPtr GetInstanceProcAddress(IntPtr instance, string name); + public IntPtr GetDeviceProcAddress(IntPtr device, string name); +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/IVulkanPlatformSurface.cs b/src/Avalonia.Vulkan/IVulkanPlatformSurface.cs new file mode 100644 index 0000000000..30da4981d8 --- /dev/null +++ b/src/Avalonia.Vulkan/IVulkanPlatformSurface.cs @@ -0,0 +1,15 @@ +using System; + +namespace Avalonia.Vulkan; +public interface IVulkanKhrSurfacePlatformSurface : IDisposable +{ + double Scaling { get; } + PixelSize Size { get; } + IntPtr CreateSurface(IVulkanPlatformGraphicsContext context); +} + +public interface IVulkanKhrSurfacePlatformSurfaceFactory +{ + bool CanRenderToSurface(IVulkanPlatformGraphicsContext context, object surface); + IVulkanKhrSurfacePlatformSurface CreateSurface(IVulkanPlatformGraphicsContext context, object surface); +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/IVulkanRenderTarget.cs b/src/Avalonia.Vulkan/IVulkanRenderTarget.cs new file mode 100644 index 0000000000..76a1182bce --- /dev/null +++ b/src/Avalonia.Vulkan/IVulkanRenderTarget.cs @@ -0,0 +1,29 @@ +using System; + +namespace Avalonia.Vulkan; + +public interface IVulkanPlatformSurface +{ + public IVulkanRenderTarget CreateRenderTarget(IVulkanPlatformGraphicsContext context); +} + +public interface IVulkanRenderTarget : IDisposable +{ + IVulkanRenderSession BeginDraw(); +} + +public interface IVulkanRenderSession : IDisposable +{ + double Scaling { get; } + PixelSize Size { get; } + public bool IsYFlipped { get; } + uint ImageFormat { get; } + IntPtr ImageHandle { get; } + uint ImageLayout { get; } + uint ImageTiling { get; } + uint ImageUsageFlags { get; } + uint LevelCount { get; } + IntPtr ImageMemoryHandle { get; } + ulong ImageMemorySize { get; } + bool IsRgba { get; } +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/Interop/VulkanCommandBuffer.cs b/src/Avalonia.Vulkan/Interop/VulkanCommandBuffer.cs new file mode 100644 index 0000000000..d2dfbdeafd --- /dev/null +++ b/src/Avalonia.Vulkan/Interop/VulkanCommandBuffer.cs @@ -0,0 +1,108 @@ +using System; +using Avalonia.Vulkan.UnmanagedInterop; + +namespace Avalonia.Vulkan.Interop; + +internal class VulkanCommandBuffer : IDisposable +{ + private readonly VulkanCommandBufferPool _pool; + private IntPtr _handle; + private readonly IVulkanDevice _device; + private readonly VulkanDeviceApi _api; + private VulkanFence _fence; + private bool _hasEnded; + private bool _hasStarted; + public IntPtr Handle => _handle; + + public VulkanCommandBuffer(VulkanCommandBufferPool pool, IntPtr handle, IVulkanDevice device, VulkanDeviceApi api) + { + _pool = pool; + _handle = handle; + _device = device; + _api = api; + _fence = new VulkanFence(_device, _api, VkFenceCreateFlags.VK_FENCE_CREATE_SIGNALED_BIT); + } + + public unsafe void Dispose() + { + if (_fence.Handle != IntPtr.Zero) + _fence.Wait(); + _fence.Dispose(); + if (_handle != IntPtr.Zero) + { + IntPtr buf = _handle; + _api.FreeCommandBuffers(_device.Handle, _handle, 1, &buf); + _handle = IntPtr.Zero; + } + + _pool.OnCommandBufferDisposed(this); + } + + public void BeginRecording() + { + if (_hasStarted) + return; + + var beginInfo = new VkCommandBufferBeginInfo + { + sType = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, + flags = VkCommandBufferUsageFlags.VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT + }; + + _api.BeginCommandBuffer(_handle, ref beginInfo).ThrowOnError("vkBeginCommandBuffer"); + _hasStarted = true; + } + + public void EndRecording() + { + if (_hasStarted && !_hasEnded) + { + _api.EndCommandBuffer(_handle).ThrowOnError("vkEndCommandBuffer"); + _hasEnded = true; + } + } + + public void Submit() + { + Submit(null, null, null); + } + + public unsafe void Submit( + ReadOnlySpan waitSemaphores, + ReadOnlySpan waitDstStageMask, + ReadOnlySpan signalSemaphores, + VulkanFence? fence = null) + { + + EndRecording(); + var fenceHandle = (fence ?? _fence).Handle; + _api.ResetFences(_device.Handle, 1, &fenceHandle) + .ThrowOnError("vkResetFences"); + + var pWaitSempaphores = stackalloc IntPtr[waitSemaphores.Length]; + for (var c = 0; c < waitSemaphores.Length; c++) + pWaitSempaphores[c] = waitSemaphores[c].Handle; + + var pSignalSemaphores = stackalloc IntPtr[signalSemaphores.Length]; + for (var c = 0; c < signalSemaphores.Length; c++) + pSignalSemaphores[c] = signalSemaphores[c].Handle; + + IntPtr commandBuffer = _handle; + fixed (VkPipelineStageFlags* flags = waitDstStageMask) + { + var submitInfo = new VkSubmitInfo + { + sType = VkStructureType.VK_STRUCTURE_TYPE_SUBMIT_INFO, + waitSemaphoreCount = (uint)waitSemaphores.Length, + pWaitSemaphores = pWaitSempaphores, + signalSemaphoreCount = (uint)signalSemaphores.Length, + pSignalSemaphores = pSignalSemaphores, + commandBufferCount = 1, + pCommandBuffers = &commandBuffer, + pWaitDstStageMask = flags + }; + _api.QueueSubmit(_device.MainQueueHandle, 1, &submitInfo, fenceHandle) + .ThrowOnError("vkQueueSubmit"); + } + } +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/Interop/VulkanCommandBufferPool.cs b/src/Avalonia.Vulkan/Interop/VulkanCommandBufferPool.cs new file mode 100644 index 0000000000..febc1ede13 --- /dev/null +++ b/src/Avalonia.Vulkan/Interop/VulkanCommandBufferPool.cs @@ -0,0 +1,62 @@ +using System; +using System.Collections.Generic; +using Avalonia.Vulkan.Interop; +using Avalonia.Vulkan.UnmanagedInterop; + +namespace Avalonia.Vulkan; + +internal class VulkanCommandBufferPool : IDisposable +{ + private readonly IVulkanDevice _device; + private readonly VulkanDeviceApi _api; + private readonly List _commandBuffers = new(); + private IntPtr _handle; + + public VulkanCommandBufferPool(IVulkanDevice device, VulkanDeviceApi api) + { + _device = device; + _api = api; + var createInfo = new VkCommandPoolCreateInfo + { + sType = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, + flags = VkCommandPoolCreateFlags.VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, + queueFamilyIndex = device.GraphicsQueueFamilyIndex + }; + api.CreateCommandPool(device.Handle, ref createInfo, IntPtr.Zero, out _handle) + .ThrowOnError("vkCreateCommandPool"); + } + + public void FreeUsedCommandBuffers() + { + foreach (var usedCommandBuffer in _commandBuffers) + usedCommandBuffer.Dispose(); + _commandBuffers.Clear(); + } + + public void Dispose() + { + FreeUsedCommandBuffers(); + + if (_handle != IntPtr.Zero) + _api.DestroyCommandPool(_device.Handle, _handle, IntPtr.Zero); + _handle = IntPtr.Zero; + } + + public unsafe VulkanCommandBuffer CreateCommandBuffer() + { + var commandBufferAllocateInfo = new VkCommandBufferAllocateInfo + { + sType = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, + commandPool = _handle, + commandBufferCount = 1, + level = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_PRIMARY + }; + var bufferHandle = IntPtr.Zero; + _api.AllocateCommandBuffers(_device.Handle, ref commandBufferAllocateInfo, + &bufferHandle).ThrowOnError("vkAllocateCommandBuffers"); + + return new VulkanCommandBuffer(this, bufferHandle, _device, _api); + } + + internal void OnCommandBufferDisposed(VulkanCommandBuffer buffer) => _commandBuffers.Remove(buffer); +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/Interop/VulkanDebugLogger.cs b/src/Avalonia.Vulkan/Interop/VulkanDebugLogger.cs new file mode 100644 index 0000000000..0d77ce3c88 --- /dev/null +++ b/src/Avalonia.Vulkan/Interop/VulkanDebugLogger.cs @@ -0,0 +1,37 @@ +using System; +using System.Runtime.InteropServices; +using Avalonia.Logging; +using Avalonia.Vulkan.UnmanagedInterop; + +namespace Avalonia.Vulkan.Interop; + +unsafe static class VulkanDebugLogger +{ + private static VkDebugUtilsMessengerCallbackEXTDelegate s_Delegate = WriteLogEvent; + public static IntPtr CallbackPtr { get; } = Marshal.GetFunctionPointerForDelegate(s_Delegate); + + private static uint WriteLogEvent(VkDebugUtilsMessageSeverityFlagsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messagetypes, + VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void* puserdata) + { + var level = messageSeverity switch + { + VkDebugUtilsMessageSeverityFlagsEXT.VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT => LogEventLevel.Error, + VkDebugUtilsMessageSeverityFlagsEXT.VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT => + LogEventLevel.Warning, + VkDebugUtilsMessageSeverityFlagsEXT.VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT => + LogEventLevel.Verbose, + VkDebugUtilsMessageSeverityFlagsEXT.VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT => LogEventLevel + .Information, + _ => LogEventLevel.Information + }; + if (Logger.TryGet(level, "Vulkan", out var logger)) + { + var msg =Marshal.PtrToStringAnsi((nint)pCallbackData->pMessage); + logger.Log("Vulkan", "Vulkan: {0}", msg); + } + + return 0; + } +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/Interop/VulkanDevice.Create.cs b/src/Avalonia.Vulkan/Interop/VulkanDevice.Create.cs new file mode 100644 index 0000000000..b5de8645c7 --- /dev/null +++ b/src/Avalonia.Vulkan/Interop/VulkanDevice.Create.cs @@ -0,0 +1,163 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.InteropServices; +using Avalonia.Vulkan.Interop; +using Avalonia.Vulkan.UnmanagedInterop; + +namespace Avalonia.Vulkan; + +internal unsafe partial class VulkanDevice +{ + public static unsafe IVulkanDevice Create(IVulkanInstance instance, + VulkanDeviceCreationOptions options, VulkanPlatformSpecificOptions platformOptions) + { + uint deviceCount = 0; + var api = new VulkanInstanceApi(instance); + api.EnumeratePhysicalDevices(api.Instance.Handle, ref deviceCount, null) + .ThrowOnError("vkEnumeratePhysicalDevices"); + + if (deviceCount == 0) + throw new VulkanException("No devices found"); + + var devices = stackalloc IntPtr[(int)deviceCount]; + api.EnumeratePhysicalDevices(api.Instance.Handle, ref deviceCount, devices) + .ThrowOnError("vkEnumeratePhysicalDevices"); + + var surfaceForProbe = platformOptions.DeviceCheckSurfaceFactory?.Invoke(api.Instance); + + DeviceInfo? compatibleDevice = null, discreteDevice = null; + + for (var c = 0; c < deviceCount; c++) + { + var info = CheckDevice(api, devices[c], options, surfaceForProbe); + if (info != null) + { + compatibleDevice ??= info; + if (info.Value.Type == VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) + discreteDevice ??= info; + } + + if (compatibleDevice != null && (discreteDevice != null || !options.PreferDiscreteGpu)) + break; + } + + if (options.PreferDiscreteGpu && discreteDevice != null) + compatibleDevice = discreteDevice; + + if (compatibleDevice == null) + throw new VulkanException("No compatible devices found"); + + var dev = compatibleDevice.Value; + + var queuePriorities = stackalloc float[(int)dev.QueueCount]; + for (var c = 0; c < dev.QueueCount; c++) + queuePriorities[c] = 1f; + + var queueCreateInfo = new VkDeviceQueueCreateInfo + { + sType = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, + queueFamilyIndex = dev.QueueFamilyIndex, + queueCount = dev.QueueCount, + pQueuePriorities = queuePriorities, + }; + + using var enabledExtensions = new Utf8BufferArray(options.DeviceExtensions + .Intersect(dev.Extensions).Append(VK_KHR_swapchain).Distinct()); + + var createInfo = new VkDeviceCreateInfo + { + sType = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, + queueCreateInfoCount = 1, + pQueueCreateInfos = &queueCreateInfo, + ppEnabledExtensionNames = enabledExtensions, + enabledExtensionCount = enabledExtensions.UCount, + }; + + api.CreateDevice(dev.PhysicalDevice, ref createInfo, IntPtr.Zero, out var createdDevice) + .ThrowOnError("vkCreateDevice"); + + api.GetDeviceQueue(createdDevice, dev.QueueFamilyIndex, 0, out var createdQueue); + + return new VulkanDevice(api.Instance, createdDevice, dev.PhysicalDevice, createdQueue, + dev.QueueFamilyIndex, platformOptions.PlatformFeatures); + + } + + struct DeviceInfo + { + public IntPtr PhysicalDevice; + public uint QueueFamilyIndex; + public VkPhysicalDeviceType Type; + public List Extensions; + public uint QueueCount; + } + + static unsafe List GetDeviceExtensions(VulkanInstanceApi instance, IntPtr physicalDevice) + { + uint propertyCount = 0; + instance.EnumerateDeviceExtensionProperties(physicalDevice, null, ref propertyCount, null); + var extensionProps = new VkExtensionProperties[propertyCount]; + var extensions = new List((int)propertyCount); + if (propertyCount != 0) + fixed (VkExtensionProperties* ptr = extensionProps) + { + instance.EnumerateDeviceExtensionProperties(physicalDevice, null, ref propertyCount, ptr); + + for (var c = 0; c < propertyCount; c++) + extensions.Add(Marshal.PtrToStringAnsi(new IntPtr(ptr[c].extensionName))!); + } + + return extensions; + } + + private const string VK_KHR_swapchain = "VK_KHR_swapchain"; + + static unsafe DeviceInfo? CheckDevice(VulkanInstanceApi instance, IntPtr physicalDevice, + VulkanDeviceCreationOptions options, IntPtr? surface) + { + instance.GetPhysicalDeviceProperties(physicalDevice, out var properties); + + var supportedExtensions = GetDeviceExtensions(instance, physicalDevice); + var foundSwapchain = false; + foreach (var ext in supportedExtensions) + if (ext == VK_KHR_swapchain) + foundSwapchain = true; + + if (!foundSwapchain) + return null; + + uint familyCount = 0; + instance.GetPhysicalDeviceQueueFamilyProperties(physicalDevice, ref familyCount, null); + var familyProperties = stackalloc VkQueueFamilyProperties[(int)familyCount]; + instance.GetPhysicalDeviceQueueFamilyProperties(physicalDevice, ref familyCount, familyProperties); + var requredFlags = VkQueueFlags.VK_QUEUE_GRAPHICS_BIT; + if (options.RequireComputeBit) + requredFlags |= VkQueueFlags.VK_QUEUE_COMPUTE_BIT; + + for (var c = 0; c < familyCount; c++) + { + if ((familyProperties[c].queueFlags & requredFlags) != requredFlags) + continue; + if (surface.HasValue) + { + instance.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, (uint)c, surface.Value, out var supported) + .ThrowOnError("vkGetPhysicalDeviceSurfaceSupportKHR"); + if (supported == 0) + continue; + } + + return new DeviceInfo + { + PhysicalDevice = physicalDevice, + Extensions = supportedExtensions, + Type = properties.deviceType, + QueueFamilyIndex = (uint)c, + QueueCount = familyProperties[c].queueCount + }; + + } + + return null; + } +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/Interop/VulkanDevice.cs b/src/Avalonia.Vulkan/Interop/VulkanDevice.cs new file mode 100644 index 0000000000..98064b48af --- /dev/null +++ b/src/Avalonia.Vulkan/Interop/VulkanDevice.cs @@ -0,0 +1,66 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reactive.Disposables; +using System.Runtime.InteropServices; +using System.Threading; +using Avalonia.Platform; +using Avalonia.Vulkan.Interop; + +namespace Avalonia.Vulkan; + + + +internal partial class VulkanDevice : IVulkanDevice +{ + private readonly IntPtr _handle; + private readonly IntPtr _physicalDeviceHandle; + private readonly IntPtr _mainQueue; + private readonly uint _graphicsQueueIndex; + private readonly Dictionary _features; + private readonly object _lock = new(); + private Thread? _lockedByThread; + + private VulkanDevice(IVulkanInstance instance, IntPtr handle, IntPtr physicalDeviceHandle, + IntPtr mainQueue, uint graphicsQueueIndex, Dictionary features) + { + _handle = handle; + _physicalDeviceHandle = physicalDeviceHandle; + _mainQueue = mainQueue; + _graphicsQueueIndex = graphicsQueueIndex; + _features = features; + Instance = instance; + } + + T CheckAccess(T f) + { + if (_lockedByThread != Thread.CurrentThread) + throw new InvalidOperationException("This class is only usable when locked"); + return f; + } + + public IDisposable Lock() + { + Monitor.Enter(_lock); + var oldLockedBy = _lockedByThread; + _lockedByThread = Thread.CurrentThread; + return Disposable.Create(() => + { + _lockedByThread = null; + Monitor.Exit(_lock); + }); + } + + public bool IsLost => false; + public IntPtr Handle => CheckAccess(_handle); + public IntPtr PhysicalDeviceHandle => CheckAccess(_physicalDeviceHandle); + public IntPtr MainQueueHandle => CheckAccess(_mainQueue); + public uint GraphicsQueueFamilyIndex => CheckAccess(_graphicsQueueIndex); + public IVulkanInstance Instance { get; } + public void Dispose() + { + // TODO + } + + public object? TryGetFeature(Type featureType) => null; +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/Interop/VulkanDisplay.cs b/src/Avalonia.Vulkan/Interop/VulkanDisplay.cs new file mode 100644 index 0000000000..dfec0eb6f8 --- /dev/null +++ b/src/Avalonia.Vulkan/Interop/VulkanDisplay.cs @@ -0,0 +1,328 @@ +using System; +using System.Linq; +using System.Threading; +using Avalonia.Vulkan.UnmanagedInterop; +// ReSharper disable FieldCanBeMadeReadOnly.Local +// ReSharper disable IdentifierTypo +// ReSharper disable StringLiteralTypo + +namespace Avalonia.Vulkan.Interop; + +internal class VulkanDisplay : IDisposable +{ + private IVulkanPlatformGraphicsContext _context; + private VulkanSemaphorePair _semaphorePair; + private uint _nextImage; + private readonly VulkanKhrSurface _surface; + private VkSurfaceFormatKHR _surfaceFormat; + private VkSwapchainKHR _swapchain; + private VkExtent2D _swapchainExtent; + private IntPtr[] _swapchainImages = Array.Empty(); + private IntPtr[] _swapchainImageViews = Array.Empty(); + public VulkanCommandBufferPool CommandBufferPool { get; private set; } + public PixelSize Size { get; private set; } + public uint QueueFamilyIndex => _context.Device.GraphicsQueueFamilyIndex; + + private VulkanDisplay(IVulkanPlatformGraphicsContext context, VulkanKhrSurface surface, VkSwapchainKHR swapchain, + VkExtent2D swapchainExtent) + { + _context = context; + _surface = surface; + _swapchain = swapchain; + _swapchainExtent = swapchainExtent; + _semaphorePair = new VulkanSemaphorePair(_context.Device, _context.DeviceApi); + CommandBufferPool = new VulkanCommandBufferPool(_context.Device, _context.DeviceApi); + CreateSwapchainImages(); + } + + internal VkSurfaceFormatKHR SurfaceFormat + { + get + { + if (_surfaceFormat.format == VkFormat.VK_FORMAT_UNDEFINED) + _surfaceFormat = _surface.GetSurfaceFormat(); + return _surfaceFormat; + } + } + + private static unsafe IntPtr CreateSwapchain(IVulkanPlatformGraphicsContext context, + VulkanKhrSurface surface, out VkExtent2D swapchainExtent, VulkanDisplay? oldDisplay = null) + { + while (!surface.CanSurfacePresent()) + Thread.Sleep(16); + context.InstanceApi.GetPhysicalDeviceSurfaceCapabilitiesKHR(context.Device.PhysicalDeviceHandle, + surface.Handle, out var capabilities) + .ThrowOnError("vkGetPhysicalDeviceSurfaceCapabilitiesKHR"); + uint presentModesCount = 0; + context.InstanceApi.GetPhysicalDeviceSurfacePresentModesKHR(context.Device.PhysicalDeviceHandle, + surface.Handle, ref presentModesCount, null) + .ThrowOnError("vkGetPhysicalDeviceSurfacePresentModesKHR"); + + var modes = new VkPresentModeKHR[(int)presentModesCount]; + fixed (VkPresentModeKHR* pModes = modes) + context.InstanceApi.GetPhysicalDeviceSurfacePresentModesKHR(context.Device.PhysicalDeviceHandle, + surface.Handle, ref presentModesCount, pModes) + .ThrowOnError("vkGetPhysicalDeviceSurfacePresentModesKHR"); + + var imageCount = capabilities.minImageCount + 1; + if (capabilities.maxImageCount > 0 && imageCount > capabilities.maxImageCount) + imageCount = capabilities.maxImageCount; + + var surfaceFormat = surface.GetSurfaceFormat(); + + bool supportsIdentityTransform = capabilities.supportedTransforms.HasAllFlags( + VkSurfaceTransformFlagsKHR.VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR); + + bool isRotated = + capabilities.currentTransform.HasAllFlags(VkSurfaceTransformFlagsKHR.VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR) + || capabilities.currentTransform.HasAllFlags(VkSurfaceTransformFlagsKHR + .VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR); + + if (capabilities.currentExtent.width != uint.MaxValue) + swapchainExtent = capabilities.currentExtent; + else + { + var surfaceSize = surface.Size; + + var width = Math.Max(capabilities.minImageExtent.width, + Math.Min(capabilities.maxImageExtent.width, (uint)surfaceSize.Width)); + var height = Math.Max(capabilities.minImageExtent.height, + Math.Min(capabilities.maxImageExtent.height, (uint)surfaceSize.Height)); + + swapchainExtent = new VkExtent2D + { + width = width, + height = height + }; + } + VkPresentModeKHR presentMode; + if (modes.Contains(VkPresentModeKHR.VK_PRESENT_MODE_MAILBOX_KHR)) + presentMode = VkPresentModeKHR.VK_PRESENT_MODE_MAILBOX_KHR; + else if (modes.Contains(VkPresentModeKHR.VK_PRESENT_MODE_FIFO_KHR)) + presentMode = VkPresentModeKHR.VK_PRESENT_MODE_FIFO_KHR; + else + presentMode = VkPresentModeKHR.VK_PRESENT_MODE_IMMEDIATE_KHR; + + var swapchainCreateInfo = new VkSwapchainCreateInfoKHR + { + sType = VkStructureType.VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, + surface = surface.Handle, + minImageCount = imageCount, + imageFormat = surfaceFormat.format, + imageColorSpace = surfaceFormat.colorSpace, + imageExtent = swapchainExtent, + imageUsage = VkImageUsageFlags.VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | + VkImageUsageFlags.VK_IMAGE_USAGE_TRANSFER_DST_BIT, + imageSharingMode = VkSharingMode.VK_SHARING_MODE_EXCLUSIVE, + imageArrayLayers = 1, + preTransform = supportsIdentityTransform && isRotated + ? VkSurfaceTransformFlagsKHR.VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR + : capabilities.currentTransform, + compositeAlpha = VkCompositeAlphaFlagsKHR.VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, + presentMode = presentMode, + clipped = 1, + oldSwapchain = oldDisplay?._swapchain ?? default + }; + context.DeviceApi.CreateSwapchainKHR(context.Device.Handle, ref swapchainCreateInfo, IntPtr.Zero, + out var swapchain).ThrowOnError("vkCreateSwapchainKHR"); + oldDisplay?.DestroySwapchain(); + return swapchain; + } + + private void DestroySwapchain() + { + if(_swapchain != IntPtr.Zero) + _context.DeviceApi.DestroySwapchainKHR(_context.Device.Handle, _swapchain, IntPtr.Zero); + _swapchain = IntPtr.Zero; + } + + internal static VulkanDisplay CreateDisplay(IVulkanPlatformGraphicsContext context, VulkanKhrSurface surface) + { + var swapchain = CreateSwapchain(context, surface, out var extent); + return new VulkanDisplay(context, surface, swapchain, extent); + } + + private unsafe void DestroyCurrentImageViews() + { + if (_swapchainImageViews.Length <= 0) + return; + for (var i = 0; i < _swapchainImageViews.Length; i++) + _context.DeviceApi.DestroyImageView(_context.Device.Handle, _swapchainImageViews[i], IntPtr.Zero); + _swapchainImageViews = Array.Empty(); + + } + + private unsafe void CreateSwapchainImages() + { + DestroyCurrentImageViews(); + Size = new PixelSize((int)_swapchainExtent.width, (int)_swapchainExtent.height); + uint imageCount = 0; + _context.DeviceApi.GetSwapchainImagesKHR(_context.Device.Handle, _swapchain, ref imageCount, null) + .ThrowOnError("vkGetSwapchainImagesKHR"); + _swapchainImages = new IntPtr[imageCount]; + fixed (IntPtr* pImages = _swapchainImages) + _context.DeviceApi.GetSwapchainImagesKHR(_context.Device.Handle, _swapchain, ref imageCount, + pImages).ThrowOnError("vkGetSwapchainImagesKHR"); + _swapchainImageViews = new IntPtr[imageCount]; + for (var c = 0; c < imageCount; c++) + _swapchainImageViews[c] = CreateSwapchainImageView(_swapchainImages[c], SurfaceFormat.format); + } + + private unsafe IntPtr CreateSwapchainImageView(IntPtr swapchainImage, VkFormat format) + { + var imageViewCreateInfo = new VkImageViewCreateInfo + { + sType = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, + subresourceRange = + { + aspectMask = VkImageAspectFlags.VK_IMAGE_ASPECT_COLOR_BIT, + levelCount = 1, + layerCount = 1 + }, + format = format, + image = swapchainImage, + viewType = VkImageViewType.VK_IMAGE_VIEW_TYPE_2D, + }; + _context.DeviceApi.CreateImageView(_context.Device.Handle, ref imageViewCreateInfo, + IntPtr.Zero, out var imageView).ThrowOnError("vkCreateImageView"); + return imageView; + } + + private void Recreate() + { + _context.DeviceApi.DeviceWaitIdle(_context.Device.Handle); + _swapchain = CreateSwapchain(_context, _surface, out var extent, this); + _swapchainExtent = extent; + CreateSwapchainImages(); + } + + public bool EnsureSwapchainAvailable() + { + if (Size != _surface.Size) + { + Recreate(); + return false; + } + return true; + } + + public unsafe VulkanCommandBuffer StartPresentation() + { + _nextImage = 0; + while (true) + { + var acquireResult = _context.DeviceApi.AcquireNextImageKHR( + _context.Device.Handle, + _swapchain, + ulong.MaxValue, + _semaphorePair.ImageAvailableSemaphore.Handle, + default, out _nextImage); + if (acquireResult is VkResult.VK_ERROR_OUT_OF_DATE_KHR or VkResult.VK_SUBOPTIMAL_KHR) + Recreate(); + else + { + acquireResult.ThrowOnError("vkAcquireNextImageKHR"); + break; + } + } + + var commandBuffer = CommandBufferPool.CreateCommandBuffer(); + commandBuffer.BeginRecording(); + VulkanMemoryHelper.TransitionLayout(_context, commandBuffer, + _swapchainImages[_nextImage], VkImageLayout.VK_IMAGE_LAYOUT_UNDEFINED, + VkAccessFlags.VK_ACCESS_NONE, VkImageLayout.VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + VkAccessFlags.VK_ACCESS_TRANSFER_WRITE_BIT, 1); + return commandBuffer; + } + + internal unsafe void BlitImageToCurrentImage(VulkanCommandBuffer commandBuffer, VulkanImage image) + { + VulkanMemoryHelper.TransitionLayout(_context, commandBuffer, + image.Handle, image.CurrentLayout, VkAccessFlags.VK_ACCESS_NONE, + VkImageLayout.VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + VkAccessFlags.VK_ACCESS_TRANSFER_READ_BIT, + image.MipLevels); + + var srcBlitRegion = new VkImageBlit + { + srcOffsets2 = + { + x = image.Size.Width, + y = image.Size.Height, + z = 1 + }, + dstOffsets2 = + { + x = Size.Width, + y = Size.Height + }, + srcSubresource = + { + aspectMask = VkImageAspectFlags.VK_IMAGE_ASPECT_COLOR_BIT, + layerCount = 1 + }, + dstSubresource = + { + aspectMask = VkImageAspectFlags.VK_IMAGE_ASPECT_COLOR_BIT, + layerCount = 1 + } + }; + + _context.DeviceApi.CmdBlitImage(commandBuffer.Handle, image.Handle, + VkImageLayout.VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + _swapchainImages[_nextImage], + VkImageLayout.VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + 1, &srcBlitRegion, VkFilter.VK_FILTER_LINEAR); + + VulkanMemoryHelper.TransitionLayout(_context, commandBuffer, + image.Handle, VkImageLayout.VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + VkAccessFlags.VK_ACCESS_TRANSFER_READ_BIT, + image.CurrentLayout, VkAccessFlags.VK_ACCESS_NONE, image.MipLevels); + } + + internal unsafe void EndPresentation(VulkanCommandBuffer commandBuffer) + { + VulkanMemoryHelper.TransitionLayout(_context, commandBuffer, + _swapchainImages[_nextImage], + VkImageLayout.VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + VkAccessFlags.VK_ACCESS_NONE, + VkImageLayout.VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, + VkAccessFlags.VK_ACCESS_NONE, + 1); + commandBuffer.Submit(new[] { _semaphorePair.ImageAvailableSemaphore }, + new[] { VkPipelineStageFlags.VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT }, + new[] { _semaphorePair.RenderFinishedSemaphore }); + + var semaphore = (VkSemaphore)_semaphorePair.RenderFinishedSemaphore.Handle; + var swapchain = _swapchain; + var nextImage = _nextImage; + + VkResult result; + var presentInfo = new VkPresentInfoKHR + { + sType = VkStructureType.VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, + waitSemaphoreCount = 1, + pWaitSemaphores = &semaphore, + swapchainCount = 1, + pSwapchains = &swapchain, + pImageIndices = &nextImage, + pResults = &result + }; + + _context.DeviceApi.vkQueuePresentKHR(_context.Device.MainQueueHandle, ref presentInfo) + .ThrowOnError("vkQueuePresentKHR"); + result.ThrowOnError("vkQueuePresentKHR"); + CommandBufferPool.FreeUsedCommandBuffers(); + } + + public unsafe void Dispose() + { + _context.DeviceApi.DeviceWaitIdle(_context.Device.Handle); + _semaphorePair?.Dispose(); + DestroyCurrentImageViews(); + DestroySwapchain(); + CommandBufferPool?.Dispose(); + CommandBufferPool = null!; + } + +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/Interop/VulkanFence.cs b/src/Avalonia.Vulkan/Interop/VulkanFence.cs new file mode 100644 index 0000000000..b822757eed --- /dev/null +++ b/src/Avalonia.Vulkan/Interop/VulkanFence.cs @@ -0,0 +1,47 @@ +using System; +using Avalonia.Vulkan.Interop; +using Avalonia.Vulkan.UnmanagedInterop; + +namespace Avalonia.Vulkan; + +internal struct VulkanFence : IDisposable +{ + private readonly VulkanDeviceApi _api; + private readonly IVulkanDevice _device; + private IntPtr _handle; + + public VulkanFence(VulkanDeviceApi api, IVulkanDevice device, IntPtr handle) + { + _api = api; + _device = device; + _handle = handle; + } + + public VulkanFence(IVulkanDevice device, VulkanDeviceApi api, VkFenceCreateFlags vkFenceCreateSignaledBit) + { + _device = device; + _api = api; + var fenceCreateInfo = new VkFenceCreateInfo + { + sType = VkStructureType.VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, + flags = VkFenceCreateFlags.VK_FENCE_CREATE_SIGNALED_BIT + }; + + _api.CreateFence(_device.Handle, ref fenceCreateInfo, IntPtr.Zero, out _handle) + .ThrowOnError("vkCreateFence"); + } + + public IntPtr Handle => _handle; + + public void Dispose() + { + _api.DestroyFence(_device.Handle, _handle, IntPtr.Zero); + _handle = IntPtr.Zero; + } + + public unsafe void Wait(ulong timeout = ulong.MaxValue) + { + IntPtr fence = _handle; + _api.WaitForFences(_device.Handle, 1, &fence, 1, timeout).ThrowOnError("vkWaitForFences"); + } +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/Interop/VulkanImage.cs b/src/Avalonia.Vulkan/Interop/VulkanImage.cs new file mode 100644 index 0000000000..fd26a09559 --- /dev/null +++ b/src/Avalonia.Vulkan/Interop/VulkanImage.cs @@ -0,0 +1,152 @@ +using System; +using Avalonia.Vulkan.Interop; +using Avalonia.Vulkan.UnmanagedInterop; + +namespace Avalonia.Vulkan; + +internal class VulkanImage : IDisposable +{ + private IVulkanPlatformGraphicsContext _context; + + private VkAccessFlags _currentAccessFlags; + public VkImageUsageFlags UsageFlags { get; } + private IntPtr _imageView; + private IntPtr _imageMemory; + private IntPtr _handle; + private VulkanCommandBufferPool _commandBufferPool; + internal IntPtr Handle => _handle; + internal VkFormat Format { get; } + internal VkImageAspectFlags AspectFlags { get; private set; } + public uint MipLevels { get; private set; } + public PixelSize Size { get; } + public ulong MemorySize { get; private set; } + public VkImageLayout CurrentLayout { get; private set; } + public IntPtr MemoryHandle => _imageMemory; + + public VkImageTiling Tiling => VkImageTiling.VK_IMAGE_TILING_OPTIMAL; + + + public VulkanImage(IVulkanPlatformGraphicsContext context, + VulkanCommandBufferPool commandBufferPool, + VkFormat format, PixelSize size, uint mipLevels = 0) + { + Format = format; + Size = size; + MipLevels = mipLevels; + _context = context; + _commandBufferPool = commandBufferPool; + UsageFlags = VkImageUsageFlags.VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT + | VkImageUsageFlags.VK_IMAGE_USAGE_TRANSFER_DST_BIT + | VkImageUsageFlags.VK_IMAGE_USAGE_TRANSFER_SRC_BIT + | VkImageUsageFlags.VK_IMAGE_USAGE_SAMPLED_BIT; + Initialize(); + } + + public unsafe void Initialize() + { + if (Handle != IntPtr.Zero) + return; + MipLevels = MipLevels != 0 ? MipLevels : (uint)Math.Floor(Math.Log(Math.Max(Size.Width, Size.Height), 2)); + var createInfo = new VkImageCreateInfo + { + sType = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, + imageType = VkImageType.VK_IMAGE_TYPE_2D, + format = Format, + extent = new VkExtent3D + { + depth = 1, + width = (uint)Size.Width, + height = (uint)Size.Height + }, + mipLevels = MipLevels, + arrayLayers = 1, + samples = VkSampleCountFlags.VK_SAMPLE_COUNT_1_BIT, + tiling = Tiling, + usage = UsageFlags, + sharingMode = VkSharingMode.VK_SHARING_MODE_EXCLUSIVE, + initialLayout = VkImageLayout.VK_IMAGE_LAYOUT_UNDEFINED, + flags = VkImageCreateFlags.VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT + }; + + _context.DeviceApi.CreateImage(_context.Device.Handle, ref createInfo, IntPtr.Zero, out _handle) + .ThrowOnError("vkCreateImage"); + + _context.DeviceApi.GetImageMemoryRequirements(_context.Device.Handle, _handle, out var memoryRequirements); + var memoryAllocateInfo = new VkMemoryAllocateInfo + { + sType = VkStructureType.VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, + allocationSize = memoryRequirements.size, + memoryTypeIndex = (uint)VulkanMemoryHelper.FindSuitableMemoryTypeIndex(_context, + memoryRequirements.memoryTypeBits, + VkMemoryPropertyFlags.VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT), + }; + + _context.DeviceApi.AllocateMemory(_context.Device.Handle, ref memoryAllocateInfo, IntPtr.Zero, + out _imageMemory).ThrowOnError("vkAllocateMemory"); + + _context.DeviceApi.BindImageMemory(_context.Device.Handle, _handle, _imageMemory, 0) + .ThrowOnError("vkBindImageMemory"); + + MemorySize = memoryRequirements.size; + AspectFlags = VkImageAspectFlags.VK_IMAGE_ASPECT_COLOR_BIT; + + var imageViewCreateInfo = new VkImageViewCreateInfo + { + sType = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, + components = new(), + subresourceRange = new() + { + aspectMask = AspectFlags, + levelCount = MipLevels, + layerCount = 1 + }, + format = Format, + image = _handle, + viewType = VkImageViewType.VK_IMAGE_VIEW_TYPE_2D + }; + _context.DeviceApi.CreateImageView(_context.Device.Handle, ref imageViewCreateInfo, + IntPtr.Zero, out _imageView).ThrowOnError("vkCreateImageView"); + CurrentLayout = VkImageLayout.VK_IMAGE_LAYOUT_UNDEFINED; + + TransitionLayout(VkImageLayout.VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VkAccessFlags.VK_ACCESS_NONE_KHR); + } + + internal void TransitionLayout(VkImageLayout destinationLayout, VkAccessFlags destinationAccessFlags) + { + var commandBuffer = _commandBufferPool!.CreateCommandBuffer(); + commandBuffer.BeginRecording(); + VulkanMemoryHelper.TransitionLayout(_context, commandBuffer, Handle, + CurrentLayout, _currentAccessFlags, destinationLayout, destinationAccessFlags, + MipLevels); + commandBuffer.EndRecording(); + commandBuffer.Submit(); + CurrentLayout = destinationLayout; + _currentAccessFlags = destinationAccessFlags; + } + + public void TransitionLayout(uint destinationLayout, uint destinationAccessFlags) + { + TransitionLayout((VkImageLayout)destinationLayout, (VkAccessFlags)destinationAccessFlags); + } + + public void Dispose() + { + var api = _context.DeviceApi; + var d = _context.Device.Handle; + if (_imageView != IntPtr.Zero) + { + api.DestroyImageView(d, _imageView, IntPtr.Zero); + _imageView = IntPtr.Zero; + } + if (_handle != IntPtr.Zero) + { + api.DestroyImage(d, _handle, IntPtr.Zero); + _handle = IntPtr.Zero; + } + if (_imageMemory != IntPtr.Zero) + { + api.FreeMemory(d, _imageMemory, IntPtr.Zero); + _imageMemory = IntPtr.Zero; + } + } +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/Interop/VulkanInstance.cs b/src/Avalonia.Vulkan/Interop/VulkanInstance.cs new file mode 100644 index 0000000000..3b15694064 --- /dev/null +++ b/src/Avalonia.Vulkan/Interop/VulkanInstance.cs @@ -0,0 +1,134 @@ +using System; +using System.Linq; +using System.Reactive.Disposables; +using System.Runtime.InteropServices; +using Avalonia.Platform.Interop; +using Avalonia.Vulkan.Interop; +using Avalonia.Vulkan.UnmanagedInterop; + +namespace Avalonia.Vulkan; +internal class VulkanInstance : IVulkanInstance +{ + private readonly VkGetInstanceProcAddressDelegate _getProcAddress; + private readonly VulkanInstanceApi _api; + + public VulkanInstance(IntPtr handle, VkGetInstanceProcAddressDelegate getProcAddress) + { + Handle = handle; + _getProcAddress = getProcAddress; + _api = new VulkanInstanceApi(this); + } + + internal static unsafe IVulkanInstance Create( + VulkanInstanceCreationOptions options, + VulkanPlatformSpecificOptions platformOptions) + { + var getProcAddress = options.CustomGetProcAddressDelegate ?? + platformOptions.GetProcAddressDelegate ?? + throw new ArgumentException("No VkGetInstanceProcAddr provided"); + + + using var name = new Utf8Buffer(options.ApplicationName ?? "AvaloniaUI"); + using var engineName = new Utf8Buffer("AvaloniaUI"); + + var gapi = new UnmanagedInterop.VulkanGlobalApi(getProcAddress); + + var appInfo = new VkApplicationInfo() + { + sType = VkStructureType.VK_STRUCTURE_TYPE_APPLICATION_INFO, + apiVersion = VulkanHelpers.MakeVersion(options.VulkanVersion), + applicationVersion = VulkanHelpers.MakeVersion(1, 0, 0), + engineVersion = VulkanHelpers.MakeVersion(1, 0, 0), + pApplicationName = name, + pEngineName = engineName, + }; + + var enabledExtensions = options.InstanceExtensions.Concat(platformOptions.RequiredInstanceExtensions) + .Append("VK_KHR_surface").ToList(); + var enabledLayers = options.EnabledLayers.ToList(); + if (options.UseDebug) + { + enabledExtensions.Add("VK_EXT_debug_utils"); + if (IsLayerAvailable(gapi, "VK_LAYER_KHRONOS_validation")) + enabledLayers.Add("VK_LAYER_KHRONOS_validation"); + } + + using var enabledExtensionBuffers = new Utf8BufferArray( + enabledExtensions + .Where(x => !string.IsNullOrWhiteSpace(x)) + .Distinct()); + + using var enabledLayersBuffers = new Utf8BufferArray(enabledLayers + .Where(x => !string.IsNullOrWhiteSpace(x)) + .Distinct()); + + + var createInfo = new VkInstanceCreateInfo() + { + sType = VkStructureType.VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, + pApplicationInfo = &appInfo, + ppEnabledLayerNames = enabledLayersBuffers, + enabledLayerCount = enabledLayersBuffers.UCount, + ppEnabledExtensionNames = enabledExtensionBuffers, + enabledExtensionCount = enabledExtensionBuffers.UCount + }; + + gapi.vkCreateInstance(ref createInfo, IntPtr.Zero, out var pInstance) + .ThrowOnError(nameof(gapi.vkCreateInstance)); + + var instance = new VulkanInstance(pInstance, getProcAddress); + var instanceApi = new VulkanInstanceApi(instance); + + if (options.UseDebug) + { + var debugCreateInfo = new VkDebugUtilsMessengerCreateInfoEXT + { + sType = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, + messageSeverity = VkDebugUtilsMessageSeverityFlagsEXT.VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT + |VkDebugUtilsMessageSeverityFlagsEXT.VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT + |VkDebugUtilsMessageSeverityFlagsEXT.VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT + |VkDebugUtilsMessageSeverityFlagsEXT.VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT, + messageType = VkDebugUtilsMessageTypeFlagsEXT.VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT + |VkDebugUtilsMessageTypeFlagsEXT.VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT + |VkDebugUtilsMessageTypeFlagsEXT.VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT, + pfnUserCallback = VulkanDebugLogger.CallbackPtr + }; + + instanceApi.CreateDebugUtilsMessengerEXT(pInstance, ref debugCreateInfo, IntPtr.Zero, out var messenger); + } + + return instance; + } + + private static unsafe bool IsLayerAvailable(VulkanGlobalApi api, string layerName) + { + uint layerPropertiesCount = 0; + + api.EnumerateInstanceLayerProperties(ref layerPropertiesCount, null) + .ThrowOnError("vkEnumerateInstanceLayerProperties"); + + var layerProperties = new VkLayerProperties[layerPropertiesCount]; + + fixed (VkLayerProperties* pLayerProperties = layerProperties) + { + api.EnumerateInstanceLayerProperties(ref layerPropertiesCount, pLayerProperties) + .ThrowOnError("vkEnumerateInstanceLayerProperties"); + + for (var i = 0; i < layerPropertiesCount; i++) + { + var currentLayerName = Marshal.PtrToStringAnsi((IntPtr)pLayerProperties[i].layerName); + if (currentLayerName == layerName) return true; + } + } + + return false; + } + + public IntPtr Handle { get; } + public IntPtr GetInstanceProcAddress(IntPtr instance, string name) => _getProcAddress(instance, name); + public IntPtr GetDeviceProcAddress(IntPtr device, string name) + { + using var buf = new Utf8Buffer(name); + return _api.GetDeviceProcAddr(device, buf); + } +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/Interop/VulkanKhrSurface.cs b/src/Avalonia.Vulkan/Interop/VulkanKhrSurface.cs new file mode 100644 index 0000000000..2988c364fa --- /dev/null +++ b/src/Avalonia.Vulkan/Interop/VulkanKhrSurface.cs @@ -0,0 +1,69 @@ +using System; +using Avalonia.Vulkan.UnmanagedInterop; + +namespace Avalonia.Vulkan.Interop; + + +internal class VulkanKhrSurface : IDisposable +{ + private readonly IVulkanPlatformGraphicsContext _context; + private readonly IVulkanKhrSurfacePlatformSurface _surfaceInfo; + private IntPtr _handle; + public IntPtr Handle => _handle; + + public VulkanKhrSurface(IVulkanPlatformGraphicsContext context, IVulkanKhrSurfacePlatformSurface surfaceInfo) + { + _context = context; + _surfaceInfo = surfaceInfo; + _handle = surfaceInfo.CreateSurface(context); + } + + internal bool CanSurfacePresent() + { + _context.InstanceApi.GetPhysicalDeviceSurfaceSupportKHR(_context.Device.PhysicalDeviceHandle, + _context.Device.GraphicsQueueFamilyIndex, _handle, out var isSupported) + .ThrowOnError("vkGetPhysicalDeviceSurfaceSupportKHR"); + return isSupported != 0; + } + + internal unsafe VkSurfaceFormatKHR GetSurfaceFormat() + { + uint surfaceFormatsCount = 0; + _context.InstanceApi.GetPhysicalDeviceSurfaceFormatsKHR(_context.Device.PhysicalDeviceHandle, + _handle, ref surfaceFormatsCount, null) + .ThrowOnError("vkGetPhysicalDeviceSurfaceFormatsKHR"); + + if (surfaceFormatsCount == 0) + throw new VulkanException("vkGetPhysicalDeviceSurfaceFormatsKHR returned 0 formats"); + + var surfaceFormats = stackalloc VkSurfaceFormatKHR[(int)surfaceFormatsCount]; + _context.InstanceApi.GetPhysicalDeviceSurfaceFormatsKHR(_context.Device.PhysicalDeviceHandle, + _handle, ref surfaceFormatsCount, surfaceFormats) + .ThrowOnError("vkGetPhysicalDeviceSurfaceFormatsKHR"); + + + if (surfaceFormatsCount == 1 && surfaceFormats[0].format == VkFormat.VK_FORMAT_UNDEFINED) + return new VkSurfaceFormatKHR + { + format = VkFormat.VK_FORMAT_B8G8R8A8_UNORM, + colorSpace = VkColorSpaceKHR.VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + }; + for (var c = 0; c < surfaceFormatsCount; c++) + { + if (surfaceFormats[c].format == VkFormat.VK_FORMAT_B8G8R8A8_UNORM + && surfaceFormats[c].colorSpace == VkColorSpaceKHR.VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) + return surfaceFormats[c]; + } + + return surfaceFormats[0]; + } + + public PixelSize Size => _surfaceInfo.Size; + + public void Dispose() + { + if (_handle != IntPtr.Zero) + _context.InstanceApi.DestroySurfaceKHR(_context.Instance.Handle, _handle, IntPtr.Zero); + _handle = IntPtr.Zero; + } +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/Interop/VulkanMemoryHelper.cs b/src/Avalonia.Vulkan/Interop/VulkanMemoryHelper.cs new file mode 100644 index 0000000000..b6ed14047a --- /dev/null +++ b/src/Avalonia.Vulkan/Interop/VulkanMemoryHelper.cs @@ -0,0 +1,67 @@ +using System; +using Avalonia.Vulkan.UnmanagedInterop; + +namespace Avalonia.Vulkan.Interop; + +internal static class VulkanMemoryHelper +{ + internal static int FindSuitableMemoryTypeIndex(IVulkanPlatformGraphicsContext context, uint memoryTypeBits, + VkMemoryPropertyFlags flags) + { + context.InstanceApi.GetPhysicalDeviceMemoryProperties(context.Device.PhysicalDeviceHandle, + out var properties); + for (var i = 0; i < properties.memoryTypeCount; i++) + { + var type = properties.memoryTypes[i]; + + if ((memoryTypeBits & (1 << i)) != 0 && type.propertyFlags.HasAllFlags(flags)) + return i; + } + + return -1; + } + + + + internal static unsafe void TransitionLayout(IVulkanPlatformGraphicsContext context, + VulkanCommandBuffer commandBuffer, + VkImage image, + VkImageLayout sourceLayout, + VkAccessFlags sourceAccessMask, + VkImageLayout destinationLayout, + VkAccessFlags destinationAccessMask, + uint mipLevels) + { + var subresourceRange = new VkImageSubresourceRange + { + aspectMask = VkImageAspectFlags.VK_IMAGE_ASPECT_COLOR_BIT, + levelCount = mipLevels, + layerCount = 1 + }; + + var barrier = new VkImageMemoryBarrier + { + sType = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, + srcAccessMask = sourceAccessMask, + dstAccessMask = destinationAccessMask, + oldLayout = sourceLayout, + newLayout = destinationLayout, + srcQueueFamilyIndex = VulkanHelpers.QueueFamilyIgnored, + dstQueueFamilyIndex = VulkanHelpers.QueueFamilyIgnored, + image = image, + subresourceRange = subresourceRange + }; + + context.DeviceApi.CmdPipelineBarrier( + commandBuffer.Handle, + VkPipelineStageFlags.VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + VkPipelineStageFlags.VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + 0, + 0, + IntPtr.Zero, + 0, + IntPtr.Zero, + 1, + &barrier); + } +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/Interop/VulkanSemaphore.cs b/src/Avalonia.Vulkan/Interop/VulkanSemaphore.cs new file mode 100644 index 0000000000..0f1d9c8a77 --- /dev/null +++ b/src/Avalonia.Vulkan/Interop/VulkanSemaphore.cs @@ -0,0 +1,53 @@ +using System; +using Avalonia.Vulkan.Interop; +using Avalonia.Vulkan.UnmanagedInterop; + +namespace Avalonia.Vulkan; + +class VulkanSemaphore : IDisposable +{ + private readonly IVulkanDevice _device; + private readonly VulkanDeviceApi _api; + private IntPtr _handle; + public IntPtr Handle => _handle; + + public VulkanSemaphore(IVulkanDevice device, VulkanDeviceApi api) + { + _device = device; + _api = api; + var info = new VkSemaphoreCreateInfo + { + sType = VkStructureType.VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO + }; + _api.CreateSemaphore(device.Handle, ref info, IntPtr.Zero, out _handle) + .ThrowOnError("vkCreateSemaphore"); + } + + public void Dispose() + { + if (_handle != IntPtr.Zero) + { + _api.DestroySemaphore(_device.Handle, _handle, IntPtr.Zero); + _handle = IntPtr.Zero; + } + } +} + +internal class VulkanSemaphorePair : IDisposable +{ + + public unsafe VulkanSemaphorePair(IVulkanDevice device, VulkanDeviceApi api) + { + ImageAvailableSemaphore = new VulkanSemaphore(device, api); + RenderFinishedSemaphore = new VulkanSemaphore(device, api); + } + + internal VulkanSemaphore ImageAvailableSemaphore { get; } + internal VulkanSemaphore RenderFinishedSemaphore { get; } + + public void Dispose() + { + ImageAvailableSemaphore.Dispose(); + RenderFinishedSemaphore.Dispose(); + } +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/UnmanagedInterop/Utf8BufferArray.cs b/src/Avalonia.Vulkan/UnmanagedInterop/Utf8BufferArray.cs new file mode 100644 index 0000000000..0df20275b6 --- /dev/null +++ b/src/Avalonia.Vulkan/UnmanagedInterop/Utf8BufferArray.cs @@ -0,0 +1,46 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.InteropServices; +using Avalonia.Platform.Interop; + +namespace Avalonia.Vulkan.Interop; + +internal unsafe class Utf8BufferArray : IDisposable +{ + private readonly List _buffers; + private byte** _bufferArray; + + public Utf8BufferArray(IEnumerable strings) + { + _buffers = strings.Select(x => new Utf8Buffer(x)).ToList(); + _bufferArray = (byte**)Marshal.AllocHGlobal(_buffers.Count * IntPtr.Size); + for (var c = 0; c < _buffers.Count; c++) + _bufferArray[c] = _buffers[c]; + } + + public static unsafe implicit operator byte**(Utf8BufferArray a) => a._bufferArray; + + public int Count => _buffers.Count; + public uint UCount => (uint)Count; + + public void Dispose() => Dispose(true); + void Dispose(bool disposing) + { + if (_bufferArray != null) + Marshal.FreeHGlobal(new IntPtr(_bufferArray)); + _bufferArray = null; + if (disposing) + { + foreach (var b in _buffers) + b.Dispose(); + _buffers.Clear(); + GC.SuppressFinalize(this); + } + } + + ~Utf8BufferArray() + { + Dispose(false); + } +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/UnmanagedInterop/VulkanDeviceApi.cs b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanDeviceApi.cs new file mode 100644 index 0000000000..8071783765 --- /dev/null +++ b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanDeviceApi.cs @@ -0,0 +1,139 @@ +using System; +using Avalonia.SourceGenerator; +using Avalonia.Vulkan.Interop; +using uint32_t = System.UInt32; +using uint64_t = System.UInt64; +using VkBool32 = System.UInt32; +using VkDeviceSize = System.UInt64; + +namespace Avalonia.Vulkan.UnmanagedInterop; + + +internal unsafe partial class VulkanDeviceApi +{ + public VulkanDeviceApi(IVulkanDevice device) + { + Initialize(name => + { + var addr = device.Instance.GetDeviceProcAddress(device.Handle, name); + if (addr != IntPtr.Zero) + return addr; + return device.Instance.GetInstanceProcAddress(device.Instance.Handle, name); + }); + + } + + [GetProcAddress("vkCreateFence")] + public partial VkResult CreateFence(IntPtr device, + ref VkFenceCreateInfo pCreateInfo, + IntPtr pAllocator, + out IntPtr pFence); + + [GetProcAddress("vkDestroyFence")] + public partial void DestroyFence(IntPtr device, IntPtr fence, IntPtr pAllocator); + + [GetProcAddress("vkCreateCommandPool")] + public partial VkResult CreateCommandPool(IntPtr device, ref VkCommandPoolCreateInfo pCreateInfo, + IntPtr pAllocator, out IntPtr pCommandPool); + + [GetProcAddress("vkDestroyCommandPool")] + public partial void DestroyCommandPool(IntPtr device, IntPtr pool, IntPtr pAllocator); + + [GetProcAddress("vkAllocateCommandBuffers")] + public partial VkResult AllocateCommandBuffers(IntPtr device, + ref VkCommandBufferAllocateInfo pAllocateInfo, IntPtr* pCommandBuffers); + + [GetProcAddress("vkFreeCommandBuffers")] + public partial void FreeCommandBuffers(IntPtr device, IntPtr commandPool, uint32_t commandBufferCount, + IntPtr* pCommandBuffers); + + [GetProcAddress("vkWaitForFences")] + public partial VkResult WaitForFences(IntPtr device, uint32_t fenceCount, IntPtr* pFences, VkBool32 waitAll, + uint64_t timeout); + + [GetProcAddress("vkBeginCommandBuffer")] + public partial VkResult BeginCommandBuffer(IntPtr commandBuffer, ref VkCommandBufferBeginInfo pBeginInfo); + + [GetProcAddress("vkEndCommandBuffer")] + public partial VkResult EndCommandBuffer(IntPtr commandBuffer); + + [GetProcAddress("vkCreateSemaphore")] + public partial VkResult CreateSemaphore(IntPtr device, ref VkSemaphoreCreateInfo pCreateInfo, + IntPtr pAllocator, out IntPtr pSemaphore); + + [GetProcAddress("vkDestroySemaphore")] + public partial void DestroySemaphore(IntPtr device, IntPtr semaphore, IntPtr pAllocator); + + [GetProcAddress("vkResetFences")] + public partial VkResult ResetFences(IntPtr device, uint32_t fenceCount, IntPtr* pFences); + + [GetProcAddress("vkQueueSubmit")] + public partial VkResult QueueSubmit(IntPtr queue, uint32_t submitCount, VkSubmitInfo* pSubmits, + IntPtr fence); + + [GetProcAddress("vkCreateImage")] + public partial VkResult CreateImage(IntPtr device, ref VkImageCreateInfo pCreateInfo, IntPtr pAllocator, + out IntPtr pImage); + + [GetProcAddress("vkDestroyImage")] + public partial void DestroyImage(IntPtr device, IntPtr image, IntPtr pAllocator); + + [GetProcAddress("vkGetImageMemoryRequirements")] + public partial void GetImageMemoryRequirements(IntPtr device, IntPtr image, + out VkMemoryRequirements pMemoryRequirements); + + [GetProcAddress("vkAllocateMemory")] + public partial VkResult AllocateMemory(IntPtr device, ref VkMemoryAllocateInfo pAllocateInfo, IntPtr pAllocator, + out IntPtr pMemory); + + [GetProcAddress("vkFreeMemory")] + public partial void FreeMemory(IntPtr device, IntPtr memory, IntPtr pAllocator); + + [GetProcAddress("vkBindImageMemory")] + public partial VkResult BindImageMemory(IntPtr device, IntPtr image, IntPtr memory, VkDeviceSize memoryOffset); + + [GetProcAddress("vkCreateImageView")] + public partial VkResult CreateImageView(IntPtr device, ref VkImageViewCreateInfo pCreateInfo, IntPtr pAllocator, + out IntPtr pView); + + [GetProcAddress("vkDestroyImageView")] + public partial void DestroyImageView(IntPtr device, IntPtr imageView, IntPtr pAllocator); + + + [GetProcAddress("vkCmdPipelineBarrier")] + public partial void CmdPipelineBarrier(IntPtr commandBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + IntPtr pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + IntPtr pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + VkImageMemoryBarrier* pImageMemoryBarriers); + + [GetProcAddress("vkCreateSwapchainKHR")] + public partial VkResult CreateSwapchainKHR(IntPtr device, ref VkSwapchainCreateInfoKHR pCreateInfo, + IntPtr pAllocator, out IntPtr pSwapchain); + + [GetProcAddress("vkDestroySwapchainKHR")] + public partial void DestroySwapchainKHR(IntPtr device, IntPtr swapchain, IntPtr pAllocator); + + [GetProcAddress("vkGetSwapchainImagesKHR")] + public partial VkResult GetSwapchainImagesKHR(IntPtr device, IntPtr swapchain, ref uint32_t pSwapchainImageCount, + IntPtr* pSwapchainImages); + + [GetProcAddress("vkDeviceWaitIdle")] + public partial VkResult DeviceWaitIdle(IntPtr device); + + [GetProcAddress("vkAcquireNextImageKHR")] + public partial VkResult AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, + VkSemaphore semaphore, VkFence fence, out uint32_t pImageIndex); + + [GetProcAddress("vkCmdBlitImage")] + public partial void CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, + VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, VkImageBlit* pRegions, VkFilter filter); + + [GetProcAddress("vkQueuePresentKHR")] + public partial VkResult vkQueuePresentKHR(VkQueue queue, ref VkPresentInfoKHR pPresentInfo); +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/UnmanagedInterop/VulkanEnums.cs b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanEnums.cs new file mode 100644 index 0000000000..9c18392e17 --- /dev/null +++ b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanEnums.cs @@ -0,0 +1,2102 @@ +using System; + +namespace Avalonia.Vulkan.UnmanagedInterop +{ + + public enum VkResult + { + VK_SUCCESS = 0, + VK_NOT_READY = 1, + VK_TIMEOUT = 2, + VK_EVENT_SET = 3, + VK_EVENT_RESET = 4, + VK_INCOMPLETE = 5, + VK_ERROR_OUT_OF_HOST_MEMORY = -1, + VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, + VK_ERROR_INITIALIZATION_FAILED = -3, + VK_ERROR_DEVICE_LOST = -4, + VK_ERROR_MEMORY_MAP_FAILED = -5, + VK_ERROR_LAYER_NOT_PRESENT = -6, + VK_ERROR_EXTENSION_NOT_PRESENT = -7, + VK_ERROR_FEATURE_NOT_PRESENT = -8, + VK_ERROR_INCOMPATIBLE_DRIVER = -9, + VK_ERROR_TOO_MANY_OBJECTS = -10, + VK_ERROR_FORMAT_NOT_SUPPORTED = -11, + VK_ERROR_FRAGMENTED_POOL = -12, + VK_ERROR_UNKNOWN = -13, + VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, + VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, + VK_ERROR_FRAGMENTATION = -1000161000, + VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000, + VK_ERROR_SURFACE_LOST_KHR = -1000000000, + VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, + VK_SUBOPTIMAL_KHR = 1000001003, + VK_ERROR_OUT_OF_DATE_KHR = -1000001004, + VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, + VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, + VK_ERROR_INVALID_SHADER_NV = -1000012000, + VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, + VK_ERROR_NOT_PERMITTED_EXT = -1000174001, + VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000, + VK_THREAD_IDLE_KHR = 1000268000, + VK_THREAD_DONE_KHR = 1000268001, + VK_OPERATION_DEFERRED_KHR = 1000268002, + VK_OPERATION_NOT_DEFERRED_KHR = 1000268003, + VK_PIPELINE_COMPILE_REQUIRED_EXT = 1000297000, + VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, + VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, + VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION, + VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, + VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, + VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED_EXT, + VK_RESULT_MAX_ENUM = 0x7FFFFFFF + } + + internal enum VkStructureType + { + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, + VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, + VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, + VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, + VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, + VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, + VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000, + VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004, + VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005, + VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000, + VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000, + VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002, + VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001, + VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002, + VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, + VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004, + VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001, + VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, + VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, + VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, + VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, + VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, + VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, + VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, + VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, + VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, + VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, + VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, + VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, + VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, + VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, + VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, + VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002, + VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001, + VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, + VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, + VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, + VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = 1000066000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, + VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, + VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, + VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, + VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, + VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001, + VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002, + VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, + VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, + VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, + VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, + VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, + VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, + VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001, + VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, + VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, + VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, + VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, + VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, + VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, + VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001, + VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002, + VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003, + VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, + VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, + VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, + VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, + VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, + VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, + VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, + VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, + VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002, + VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, + VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002, + VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003, + VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, + VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = 1000138000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = 1000138001, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = 1000138002, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = 1000138003, + VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, + VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, + VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, + VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000150007, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR = 1000150009, + VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010, + VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011, + VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR = 1000150013, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR = 1000150014, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR = 1000150020, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR = 1000347001, + VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015, + VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016, + VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR = 1000348013, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001, + VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005, + VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, + VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR = 1000163000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR = 1000163001, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005, + VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001, + VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003, + VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004, + VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005, + VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009, + VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000, + VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, + VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, + VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000, + VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000, + VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002, + VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000, + VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000192000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002, + VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000, + VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000, + VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001, + VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002, + VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003, + VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004, + VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000, + VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000, + VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001, + VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = 1000215000, + VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001, + VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = 1000225000, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = 1000225001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = 1000225002, + VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000, + VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000, + VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001, + VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT = 1000245000, + VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000, + VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001, + VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000, + VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002, + VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001, + VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000, + VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001, + VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002, + VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003, + VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004, + VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = 1000276000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000, + VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV = 1000277005, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = 1000281001, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000, + VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000, + VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001, + VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002, + VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = 1000295000, + VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = 1000295001, + VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT = 1000295002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT = 1000297000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000, + VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001, + VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001, + VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = 1000335000, + VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR = 1000337000, + VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR = 1000337001, + VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR = 1000337002, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR = 1000337003, + VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR = 1000337004, + VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR = 1000337005, + VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR = 1000337006, + VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR = 1000337007, + VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = 1000337008, + VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = 1000337009, + VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = 1000337010, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000, + VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, + VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, + + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, + + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, + + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, + + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, + + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, + + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, + VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, + VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO, + VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_END_INFO, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, + + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, + + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, + VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, + + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, + + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, + + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, + + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, + + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, + + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, + + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, + + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, + VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, + VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, + VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO, + VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, + + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = + VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, + + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT, + + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, + VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, + + VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = + VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, + + VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = + VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, + + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, + + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, + VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF + } + + enum VkPhysicalDeviceType + { + VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, + VK_PHYSICAL_DEVICE_TYPE_CPU = 4, + } + + [Flags] + internal enum VkQueueFlags + { + VK_QUEUE_GRAPHICS_BIT = 0x00000001, + VK_QUEUE_COMPUTE_BIT = 0x00000002, + VK_QUEUE_TRANSFER_BIT = 0x00000004, + VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, + + // Provided by VK_VERSION_1_1 + VK_QUEUE_PROTECTED_BIT = 0x00000010, + + // Provided by VK_KHR_video_decode_queue + VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0x00000020, + + // Provided by VK_KHR_video_encode_queue + VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 0x00000040, + + // Provided by VK_NV_optical_flow + VK_QUEUE_OPTICAL_FLOW_BIT_NV = 0x00000100, + } + + + [Flags] + enum VkDeviceQueueCreateFlags + { + // Provided by VK_VERSION_1_1 + VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001, + } + + enum VkFenceCreateFlags + { + VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, + } + + enum VkCommandPoolCreateFlags + { + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, + + // Provided by VK_VERSION_1_1 + VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004, + } + + enum VkCommandBufferLevel + { + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + } + + enum VkCommandBufferUsageFlags + { + VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, + VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, + VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, + } + + enum VkPipelineStageFlags + { + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, + VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, + VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, + VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, + VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, + VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, + VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, + VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, + VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, + VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, + VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, + VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, + VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, + VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, + + // Provided by VK_VERSION_1_3 + VK_PIPELINE_STAGE_NONE = 0, + + // Provided by VK_EXT_transform_feedback + VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000, + + // Provided by VK_EXT_conditional_rendering + VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000, + + // Provided by VK_KHR_acceleration_structure + VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000, + + // Provided by VK_KHR_ray_tracing_pipeline + VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 0x00200000, + + // Provided by VK_EXT_fragment_density_map + VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000, + + // Provided by VK_KHR_fragment_shading_rate + VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000, + + // Provided by VK_NV_device_generated_commands + VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = 0x00020000, + + // Provided by VK_EXT_mesh_shader + VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT = 0x00080000, + + // Provided by VK_EXT_mesh_shader + VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT = 0x00100000, + + // Provided by VK_NV_shading_rate_image + VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + + // Provided by VK_NV_ray_tracing + VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, + + // Provided by VK_NV_ray_tracing + VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, + + // Provided by VK_NV_mesh_shader + VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT, + + // Provided by VK_NV_mesh_shader + VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT, + + // Provided by VK_KHR_synchronization2 + VK_PIPELINE_STAGE_NONE_KHR = VK_PIPELINE_STAGE_NONE, + } + + enum VkFormat + { + VK_FORMAT_UNDEFINED = 0, + VK_FORMAT_R4G4_UNORM_PACK8 = 1, + VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, + VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, + VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, + VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, + VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, + VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, + VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, + VK_FORMAT_R8_UNORM = 9, + VK_FORMAT_R8_SNORM = 10, + VK_FORMAT_R8_USCALED = 11, + VK_FORMAT_R8_SSCALED = 12, + VK_FORMAT_R8_UINT = 13, + VK_FORMAT_R8_SINT = 14, + VK_FORMAT_R8_SRGB = 15, + VK_FORMAT_R8G8_UNORM = 16, + VK_FORMAT_R8G8_SNORM = 17, + VK_FORMAT_R8G8_USCALED = 18, + VK_FORMAT_R8G8_SSCALED = 19, + VK_FORMAT_R8G8_UINT = 20, + VK_FORMAT_R8G8_SINT = 21, + VK_FORMAT_R8G8_SRGB = 22, + VK_FORMAT_R8G8B8_UNORM = 23, + VK_FORMAT_R8G8B8_SNORM = 24, + VK_FORMAT_R8G8B8_USCALED = 25, + VK_FORMAT_R8G8B8_SSCALED = 26, + VK_FORMAT_R8G8B8_UINT = 27, + VK_FORMAT_R8G8B8_SINT = 28, + VK_FORMAT_R8G8B8_SRGB = 29, + VK_FORMAT_B8G8R8_UNORM = 30, + VK_FORMAT_B8G8R8_SNORM = 31, + VK_FORMAT_B8G8R8_USCALED = 32, + VK_FORMAT_B8G8R8_SSCALED = 33, + VK_FORMAT_B8G8R8_UINT = 34, + VK_FORMAT_B8G8R8_SINT = 35, + VK_FORMAT_B8G8R8_SRGB = 36, + VK_FORMAT_R8G8B8A8_UNORM = 37, + VK_FORMAT_R8G8B8A8_SNORM = 38, + VK_FORMAT_R8G8B8A8_USCALED = 39, + VK_FORMAT_R8G8B8A8_SSCALED = 40, + VK_FORMAT_R8G8B8A8_UINT = 41, + VK_FORMAT_R8G8B8A8_SINT = 42, + VK_FORMAT_R8G8B8A8_SRGB = 43, + VK_FORMAT_B8G8R8A8_UNORM = 44, + VK_FORMAT_B8G8R8A8_SNORM = 45, + VK_FORMAT_B8G8R8A8_USCALED = 46, + VK_FORMAT_B8G8R8A8_SSCALED = 47, + VK_FORMAT_B8G8R8A8_UINT = 48, + VK_FORMAT_B8G8R8A8_SINT = 49, + VK_FORMAT_B8G8R8A8_SRGB = 50, + VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, + VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, + VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, + VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, + VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, + VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, + VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, + VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, + VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, + VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, + VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, + VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, + VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, + VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, + VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, + VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, + VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, + VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, + VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, + VK_FORMAT_R16_UNORM = 70, + VK_FORMAT_R16_SNORM = 71, + VK_FORMAT_R16_USCALED = 72, + VK_FORMAT_R16_SSCALED = 73, + VK_FORMAT_R16_UINT = 74, + VK_FORMAT_R16_SINT = 75, + VK_FORMAT_R16_SFLOAT = 76, + VK_FORMAT_R16G16_UNORM = 77, + VK_FORMAT_R16G16_SNORM = 78, + VK_FORMAT_R16G16_USCALED = 79, + VK_FORMAT_R16G16_SSCALED = 80, + VK_FORMAT_R16G16_UINT = 81, + VK_FORMAT_R16G16_SINT = 82, + VK_FORMAT_R16G16_SFLOAT = 83, + VK_FORMAT_R16G16B16_UNORM = 84, + VK_FORMAT_R16G16B16_SNORM = 85, + VK_FORMAT_R16G16B16_USCALED = 86, + VK_FORMAT_R16G16B16_SSCALED = 87, + VK_FORMAT_R16G16B16_UINT = 88, + VK_FORMAT_R16G16B16_SINT = 89, + VK_FORMAT_R16G16B16_SFLOAT = 90, + VK_FORMAT_R16G16B16A16_UNORM = 91, + VK_FORMAT_R16G16B16A16_SNORM = 92, + VK_FORMAT_R16G16B16A16_USCALED = 93, + VK_FORMAT_R16G16B16A16_SSCALED = 94, + VK_FORMAT_R16G16B16A16_UINT = 95, + VK_FORMAT_R16G16B16A16_SINT = 96, + VK_FORMAT_R16G16B16A16_SFLOAT = 97, + VK_FORMAT_R32_UINT = 98, + VK_FORMAT_R32_SINT = 99, + VK_FORMAT_R32_SFLOAT = 100, + VK_FORMAT_R32G32_UINT = 101, + VK_FORMAT_R32G32_SINT = 102, + VK_FORMAT_R32G32_SFLOAT = 103, + VK_FORMAT_R32G32B32_UINT = 104, + VK_FORMAT_R32G32B32_SINT = 105, + VK_FORMAT_R32G32B32_SFLOAT = 106, + VK_FORMAT_R32G32B32A32_UINT = 107, + VK_FORMAT_R32G32B32A32_SINT = 108, + VK_FORMAT_R32G32B32A32_SFLOAT = 109, + VK_FORMAT_R64_UINT = 110, + VK_FORMAT_R64_SINT = 111, + VK_FORMAT_R64_SFLOAT = 112, + VK_FORMAT_R64G64_UINT = 113, + VK_FORMAT_R64G64_SINT = 114, + VK_FORMAT_R64G64_SFLOAT = 115, + VK_FORMAT_R64G64B64_UINT = 116, + VK_FORMAT_R64G64B64_SINT = 117, + VK_FORMAT_R64G64B64_SFLOAT = 118, + VK_FORMAT_R64G64B64A64_UINT = 119, + VK_FORMAT_R64G64B64A64_SINT = 120, + VK_FORMAT_R64G64B64A64_SFLOAT = 121, + VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, + VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, + VK_FORMAT_D16_UNORM = 124, + VK_FORMAT_X8_D24_UNORM_PACK32 = 125, + VK_FORMAT_D32_SFLOAT = 126, + VK_FORMAT_S8_UINT = 127, + VK_FORMAT_D16_UNORM_S8_UINT = 128, + VK_FORMAT_D24_UNORM_S8_UINT = 129, + VK_FORMAT_D32_SFLOAT_S8_UINT = 130, + VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, + VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, + VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, + VK_FORMAT_BC2_UNORM_BLOCK = 135, + VK_FORMAT_BC2_SRGB_BLOCK = 136, + VK_FORMAT_BC3_UNORM_BLOCK = 137, + VK_FORMAT_BC3_SRGB_BLOCK = 138, + VK_FORMAT_BC4_UNORM_BLOCK = 139, + VK_FORMAT_BC4_SNORM_BLOCK = 140, + VK_FORMAT_BC5_UNORM_BLOCK = 141, + VK_FORMAT_BC5_SNORM_BLOCK = 142, + VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, + VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, + VK_FORMAT_BC7_UNORM_BLOCK = 145, + VK_FORMAT_BC7_SRGB_BLOCK = 146, + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, + VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, + VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, + VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, + VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, + VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, + VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, + VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, + VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, + VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, + VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, + VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, + VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, + VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, + VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, + VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, + VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, + VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, + VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, + VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, + VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, + VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, + VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, + VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, + VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, + VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, + VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, + VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, + VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, + VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, + VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, + VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, + VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, + + // Provided by VK_VERSION_1_1 + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_G8_B8R8_2PLANE_444_UNORM = 1000330000, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 = 1000330001, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 = 1000330002, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_G16_B16R16_2PLANE_444_UNORM = 1000330003, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_A4R4G4B4_UNORM_PACK16 = 1000340000, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_A4B4G4R4_UNORM_PACK16 = 1000340001, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK = 1000066000, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK = 1000066001, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK = 1000066002, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK = 1000066003, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK = 1000066004, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK = 1000066005, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK = 1000066006, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK = 1000066007, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK = 1000066008, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK = 1000066009, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK = 1000066010, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK = 1000066011, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK = 1000066012, + + // Provided by VK_VERSION_1_3 + VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK = 1000066013, + + // Provided by VK_IMG_format_pvrtc + VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, + + // Provided by VK_IMG_format_pvrtc + VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, + + // Provided by VK_IMG_format_pvrtc + VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, + + // Provided by VK_IMG_format_pvrtc + VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, + + // Provided by VK_IMG_format_pvrtc + VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, + + // Provided by VK_IMG_format_pvrtc + VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, + + // Provided by VK_IMG_format_pvrtc + VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, + + // Provided by VK_IMG_format_pvrtc + VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, + + // Provided by VK_NV_optical_flow + VK_FORMAT_R16G16_S10_5_NV = 1000464000, + + // Provided by VK_EXT_texture_compression_astc_hdr + VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK, + + // Provided by VK_EXT_texture_compression_astc_hdr + VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK, + + // Provided by VK_EXT_texture_compression_astc_hdr + VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK, + + // Provided by VK_EXT_texture_compression_astc_hdr + VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK, + + // Provided by VK_EXT_texture_compression_astc_hdr + VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK, + + // Provided by VK_EXT_texture_compression_astc_hdr + VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK, + + // Provided by VK_EXT_texture_compression_astc_hdr + VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK, + + // Provided by VK_EXT_texture_compression_astc_hdr + VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK, + + // Provided by VK_EXT_texture_compression_astc_hdr + VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK, + + // Provided by VK_EXT_texture_compression_astc_hdr + VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK, + + // Provided by VK_EXT_texture_compression_astc_hdr + VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK, + + // Provided by VK_EXT_texture_compression_astc_hdr + VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK, + + // Provided by VK_EXT_texture_compression_astc_hdr + VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK, + + // Provided by VK_EXT_texture_compression_astc_hdr + VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, + + // Provided by VK_EXT_ycbcr_2plane_444_formats + VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, + + // Provided by VK_EXT_ycbcr_2plane_444_formats + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, + + // Provided by VK_EXT_ycbcr_2plane_444_formats + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, + + // Provided by VK_EXT_ycbcr_2plane_444_formats + VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM, + + // Provided by VK_EXT_4444_formats + VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = VK_FORMAT_A4R4G4B4_UNORM_PACK16, + + // Provided by VK_EXT_4444_formats + VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = VK_FORMAT_A4B4G4R4_UNORM_PACK16, + } + + enum VkColorSpaceKHR + { + VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, + + // Provided by VK_EXT_swapchain_colorspace + VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, + + // Provided by VK_EXT_swapchain_colorspace + VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, + + // Provided by VK_EXT_swapchain_colorspace + VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003, + + // Provided by VK_EXT_swapchain_colorspace + VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, + + // Provided by VK_EXT_swapchain_colorspace + VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, + + // Provided by VK_EXT_swapchain_colorspace + VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, + + // Provided by VK_EXT_swapchain_colorspace + VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, + + // Provided by VK_EXT_swapchain_colorspace + VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, + + // Provided by VK_EXT_swapchain_colorspace + VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, + + // Provided by VK_EXT_swapchain_colorspace + VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, + + // Provided by VK_EXT_swapchain_colorspace + VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, + + // Provided by VK_EXT_swapchain_colorspace + VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, + + // Provided by VK_EXT_swapchain_colorspace + VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, + + // Provided by VK_EXT_swapchain_colorspace + VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, + + // Provided by VK_AMD_display_native_hdr + VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000, + VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + + // Provided by VK_EXT_swapchain_colorspace + VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT, + } + + [Flags] + enum VkMemoryPropertyFlags + { + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, + VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, + VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, + + // Provided by VK_VERSION_1_1 + VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020, + + // Provided by VK_AMD_device_coherent_memory + VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0x00000040, + + // Provided by VK_AMD_device_coherent_memory + VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0x00000080, + + // Provided by VK_NV_external_memory_rdma + VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV = 0x00000100, + } + + [Flags] + enum VkMemoryHeapFlags + { + VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, + + // Provided by VK_VERSION_1_1 + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002, + + // Provided by VK_KHR_device_group_creation + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, + } + + enum VkImageLayout + { + VK_IMAGE_LAYOUT_UNDEFINED = 0, + VK_IMAGE_LAYOUT_GENERAL = 1, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, + VK_IMAGE_LAYOUT_PREINITIALIZED = 8, + + // Provided by VK_VERSION_1_1 + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, + + // Provided by VK_VERSION_1_1 + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, + + // Provided by VK_VERSION_1_2 + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000, + + // Provided by VK_VERSION_1_2 + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001, + + // Provided by VK_VERSION_1_2 + VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002, + + // Provided by VK_VERSION_1_2 + VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003, + + // Provided by VK_VERSION_1_3 + VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL = 1000314000, + + // Provided by VK_VERSION_1_3 + VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL = 1000314001, + + // Provided by VK_KHR_swapchain + VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, + + // Provided by VK_KHR_video_decode_queue + VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR = 1000024000, + + // Provided by VK_KHR_video_decode_queue + VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR = 1000024001, + + // Provided by VK_KHR_video_decode_queue + VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR = 1000024002, + + // Provided by VK_KHR_shared_presentable_image + VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, + + // Provided by VK_EXT_fragment_density_map + VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000, + + // Provided by VK_KHR_fragment_shading_rate + VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003, + + // Provided by VK_KHR_video_encode_queue + VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR = 1000299000, + + // Provided by VK_KHR_video_encode_queue + VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR = 1000299001, + + // Provided by VK_KHR_video_encode_queue + VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002, + + // Provided by VK_EXT_attachment_feedback_loop_layout + VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT = 1000339000, + + // Provided by VK_KHR_maintenance2 + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, + + // Provided by VK_KHR_maintenance2 + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, + + // Provided by VK_NV_shading_rate_image + VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR, + + // Provided by VK_KHR_separate_depth_stencil_layouts + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, + + // Provided by VK_KHR_separate_depth_stencil_layouts + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, + + // Provided by VK_KHR_separate_depth_stencil_layouts + VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, + + // Provided by VK_KHR_separate_depth_stencil_layouts + VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, + + // Provided by VK_KHR_synchronization2 + VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL, + + // Provided by VK_KHR_synchronization2 + VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, + } + + [Flags] + enum VkAccessFlags + { + VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, + VK_ACCESS_INDEX_READ_BIT = 0x00000002, + VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, + VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, + VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, + VK_ACCESS_SHADER_READ_BIT = 0x00000020, + VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, + VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, + VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, + VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, + VK_ACCESS_HOST_READ_BIT = 0x00002000, + VK_ACCESS_HOST_WRITE_BIT = 0x00004000, + VK_ACCESS_MEMORY_READ_BIT = 0x00008000, + VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, + + // Provided by VK_VERSION_1_3 + VK_ACCESS_NONE = 0, + + // Provided by VK_EXT_transform_feedback + VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000, + + // Provided by VK_EXT_transform_feedback + VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000, + + // Provided by VK_EXT_transform_feedback + VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000, + + // Provided by VK_EXT_conditional_rendering + VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000, + + // Provided by VK_EXT_blend_operation_advanced + VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, + + // Provided by VK_KHR_acceleration_structure + VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000, + + // Provided by VK_KHR_acceleration_structure + VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000, + + // Provided by VK_EXT_fragment_density_map + VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000, + + // Provided by VK_KHR_fragment_shading_rate + VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000, + + // Provided by VK_NV_device_generated_commands + VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000, + + // Provided by VK_NV_device_generated_commands + VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000, + + // Provided by VK_NV_shading_rate_image + VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, + + // Provided by VK_NV_ray_tracing + VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR, + + // Provided by VK_NV_ray_tracing + VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, + + // Provided by VK_KHR_synchronization2 + VK_ACCESS_NONE_KHR = VK_ACCESS_NONE, + } + + [Flags] + enum VkImageUsageFlags + { + VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, + VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, + VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, + VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, + VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, + + // Provided by VK_EXT_fragment_density_map + VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200, + + // Provided by VK_KHR_fragment_shading_rate + VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100, + + // Provided by VK_EXT_attachment_feedback_loop_layout + VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x00080000, + + // Provided by VK_HUAWEI_invocation_mask + VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0x00040000, + + // Provided by VK_QCOM_image_processing + VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000, + + // Provided by VK_QCOM_image_processing + VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0x00200000, + + // Provided by VK_NV_shading_rate_image + VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + } + + enum VkImageAspectFlags + { + VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, + VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, + VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, + VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, + + // Provided by VK_VERSION_1_1 + VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010, + + // Provided by VK_VERSION_1_1 + VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020, + + // Provided by VK_VERSION_1_1 + VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040, + + // Provided by VK_VERSION_1_3 + VK_IMAGE_ASPECT_NONE = 0, + + // Provided by VK_EXT_image_drm_format_modifier + VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080, + + // Provided by VK_EXT_image_drm_format_modifier + VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100, + + // Provided by VK_EXT_image_drm_format_modifier + VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200, + + // Provided by VK_EXT_image_drm_format_modifier + VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT, + + // Provided by VK_KHR_maintenance4 + VK_IMAGE_ASPECT_NONE_KHR = VK_IMAGE_ASPECT_NONE, + } + + [Flags] + enum VkImageCreateFlags + { + VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, + VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, + + // Provided by VK_VERSION_1_1 + VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400, + + // Provided by VK_VERSION_1_1 + VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040, + + // Provided by VK_VERSION_1_1 + VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020, + + // Provided by VK_VERSION_1_1 + VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080, + + // Provided by VK_VERSION_1_1 + VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100, + + // Provided by VK_VERSION_1_1 + VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800, + + // Provided by VK_VERSION_1_1 + VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200, + + // Provided by VK_NV_corner_sampled_image + VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000, + + // Provided by VK_EXT_sample_locations + VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, + + // Provided by VK_EXT_fragment_density_map + VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000, + + // Provided by VK_EXT_descriptor_buffer + VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00010000, + + // Provided by VK_EXT_multisampled_render_to_single_sampled + VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00040000, + + // Provided by VK_EXT_image_2d_view_of_3d + VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000, + + // Provided by VK_QCOM_fragment_density_map_offset + VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = 0x00008000, + + // Provided by VK_KHR_bind_memory2 with VK_KHR_device_group + VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, + + // Provided by VK_KHR_maintenance1 + VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, + + // Provided by VK_KHR_maintenance2 + VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, + + // Provided by VK_KHR_maintenance2 + VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT, + + // Provided by VK_KHR_bind_memory2 + VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT, + } + + enum VkImageType + { + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, + } + + [Flags] + enum VkSampleCountFlags { + VK_SAMPLE_COUNT_1_BIT = 0x00000001, + VK_SAMPLE_COUNT_2_BIT = 0x00000002, + VK_SAMPLE_COUNT_4_BIT = 0x00000004, + VK_SAMPLE_COUNT_8_BIT = 0x00000008, + VK_SAMPLE_COUNT_16_BIT = 0x00000010, + VK_SAMPLE_COUNT_32_BIT = 0x00000020, + VK_SAMPLE_COUNT_64_BIT = 0x00000040, + } + + enum VkImageTiling + { + VK_IMAGE_TILING_OPTIMAL = 0, + VK_IMAGE_TILING_LINEAR = 1, + + // Provided by VK_EXT_image_drm_format_modifier + VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000, + } + + enum VkSharingMode + { + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, + } + + enum VkImageViewCreateFlags + { + // Provided by VK_EXT_fragment_density_map + VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001, + + // Provided by VK_EXT_descriptor_buffer + VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000004, + + // Provided by VK_EXT_fragment_density_map2 + VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = 0x00000002, + } + + enum VkImageViewType + { + VK_IMAGE_VIEW_TYPE_1D = 0, + VK_IMAGE_VIEW_TYPE_2D = 1, + VK_IMAGE_VIEW_TYPE_3D = 2, + VK_IMAGE_VIEW_TYPE_CUBE = 3, + VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, + VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, + VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, + } + + enum VkComponentSwizzle + { + VK_COMPONENT_SWIZZLE_IDENTITY = 0, + VK_COMPONENT_SWIZZLE_ZERO = 1, + VK_COMPONENT_SWIZZLE_ONE = 2, + VK_COMPONENT_SWIZZLE_R = 3, + VK_COMPONENT_SWIZZLE_G = 4, + VK_COMPONENT_SWIZZLE_B = 5, + VK_COMPONENT_SWIZZLE_A = 6, + } + + enum VkDependencyFlags + { + VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, + + // Provided by VK_VERSION_1_1 + VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004, + + // Provided by VK_VERSION_1_1 + VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002, + + // Provided by VK_EXT_attachment_feedback_loop_layout + VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT = 0x00000008, + + // Provided by VK_KHR_multiview + VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT, + + // Provided by VK_KHR_device_group + VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT, + } + + enum VkSurfaceTransformFlagsKHR + { + VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, + VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, + VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, + VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, + VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, + } + + enum VkCompositeAlphaFlagsKHR + { + VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, + VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, + VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, + VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, + } + + enum VkPresentModeKHR + { + VK_PRESENT_MODE_IMMEDIATE_KHR = 0, + VK_PRESENT_MODE_MAILBOX_KHR = 1, + VK_PRESENT_MODE_FIFO_KHR = 2, + VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, + + // Provided by VK_KHR_shared_presentable_image + VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, + + // Provided by VK_KHR_shared_presentable_image + VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, + } + + enum VkSwapchainCreateFlagsKHR + { + // Provided by VK_VERSION_1_1 with VK_KHR_swapchain, VK_KHR_device_group with VK_KHR_swapchain + VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, + + // Provided by VK_VERSION_1_1 with VK_KHR_swapchain + VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, + + // Provided by VK_KHR_swapchain_mutable_format + VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004, + + // Provided by VK_EXT_swapchain_maintenance1 + VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = 0x00000008, + } + + enum VkFilter { + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, + // Provided by VK_EXT_filter_cubic + VK_FILTER_CUBIC_EXT = 1000015000, + // Provided by VK_IMG_filter_cubic + VK_FILTER_CUBIC_IMG = VK_FILTER_CUBIC_EXT, + } + + [Flags] + enum VkDebugUtilsMessageSeverityFlagsEXT + { + VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000, + } + + [Flags] + enum VkDebugUtilsMessageTypeFlagsEXT { + VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001, + VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002, + VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004, + // Provided by VK_EXT_device_address_binding_report + VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT = 0x00000008, + } + + enum VkObjectType + { + VK_OBJECT_TYPE_UNKNOWN = 0, + VK_OBJECT_TYPE_INSTANCE = 1, + VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, + VK_OBJECT_TYPE_DEVICE = 3, + VK_OBJECT_TYPE_QUEUE = 4, + VK_OBJECT_TYPE_SEMAPHORE = 5, + VK_OBJECT_TYPE_COMMAND_BUFFER = 6, + VK_OBJECT_TYPE_FENCE = 7, + VK_OBJECT_TYPE_DEVICE_MEMORY = 8, + VK_OBJECT_TYPE_BUFFER = 9, + VK_OBJECT_TYPE_IMAGE = 10, + VK_OBJECT_TYPE_EVENT = 11, + VK_OBJECT_TYPE_QUERY_POOL = 12, + VK_OBJECT_TYPE_BUFFER_VIEW = 13, + VK_OBJECT_TYPE_IMAGE_VIEW = 14, + VK_OBJECT_TYPE_SHADER_MODULE = 15, + VK_OBJECT_TYPE_PIPELINE_CACHE = 16, + VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, + VK_OBJECT_TYPE_RENDER_PASS = 18, + VK_OBJECT_TYPE_PIPELINE = 19, + VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, + VK_OBJECT_TYPE_SAMPLER = 21, + VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, + VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, + VK_OBJECT_TYPE_FRAMEBUFFER = 24, + VK_OBJECT_TYPE_COMMAND_POOL = 25, + + // Provided by VK_VERSION_1_1 + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, + + // Provided by VK_VERSION_1_1 + VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000, + + // Provided by VK_VERSION_1_3 + VK_OBJECT_TYPE_PRIVATE_DATA_SLOT = 1000295000, + + // Provided by VK_KHR_surface + VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, + + // Provided by VK_KHR_swapchain + VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, + + // Provided by VK_KHR_display + VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, + + // Provided by VK_KHR_display + VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, + + // Provided by VK_EXT_debug_report + VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000, + + // Provided by VK_NVX_binary_import + VK_OBJECT_TYPE_CU_MODULE_NVX = 1000029000, + + // Provided by VK_NVX_binary_import + VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001, + + // Provided by VK_EXT_debug_utils + VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, + + // Provided by VK_KHR_acceleration_structure + VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, + + // Provided by VK_EXT_validation_cache + VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, + + // Provided by VK_NV_ray_tracing + VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, + + // Provided by VK_INTEL_performance_query + VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000, + + // Provided by VK_KHR_deferred_host_operations + VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000, + + // Provided by VK_NV_device_generated_commands + VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000, + + // Provided by VK_FUCHSIA_buffer_collection + VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA = 1000366000, + + // Provided by VK_EXT_opacity_micromap + VK_OBJECT_TYPE_MICROMAP_EXT = 1000396000, + + // Provided by VK_NV_optical_flow + VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000, + + // Provided by VK_KHR_descriptor_update_template + VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, + + // Provided by VK_KHR_sampler_ycbcr_conversion + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, + + // Provided by VK_EXT_private_data + VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, + } +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/UnmanagedInterop/VulkanGlobalApi.cs b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanGlobalApi.cs new file mode 100644 index 0000000000..03a55422c5 --- /dev/null +++ b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanGlobalApi.cs @@ -0,0 +1,25 @@ +using System; +using Avalonia.SourceGenerator; +using Avalonia.Vulkan.Interop; + +namespace Avalonia.Vulkan.UnmanagedInterop; + +internal unsafe partial class VulkanGlobalApi +{ + private readonly VkGetInstanceProcAddressDelegate _vkGetProcAddress; + + public VulkanGlobalApi(VkGetInstanceProcAddressDelegate vkGetProcAddress) + { + _vkGetProcAddress = vkGetProcAddress; + Initialize(name => vkGetProcAddress(IntPtr.Zero, name)); + } + + public IntPtr GetProcAddress(IntPtr instance, string name) => _vkGetProcAddress(instance, name); + + + [GetProcAddress("vkEnumerateInstanceLayerProperties")] + public partial VkResult EnumerateInstanceLayerProperties(ref uint pPropertyCount, VkLayerProperties* pProperties); + + [GetProcAddress("vkCreateInstance")] + public partial VkResult vkCreateInstance(ref VkInstanceCreateInfo pCreateInfo, IntPtr pAllocator, out IntPtr pInstance); +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/UnmanagedInterop/VulkanInstanceApi.cs b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanInstanceApi.cs new file mode 100644 index 0000000000..d5daac3bac --- /dev/null +++ b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanInstanceApi.cs @@ -0,0 +1,75 @@ +using System; +using Avalonia.SourceGenerator; +using Avalonia.Vulkan.Interop; +using Avalonia.Vulkan.UnmanagedInterop; +using uint32_t = System.UInt32; +using VkBool32 = System.UInt32; +namespace Avalonia.Vulkan; + +internal unsafe partial class VulkanInstanceApi +{ + public IVulkanInstance Instance { get; } + + public VulkanInstanceApi(IVulkanInstance instance) + { + Instance = instance; + Initialize(name => instance.GetInstanceProcAddress(instance.Handle, name)); + } + + [GetProcAddress("vkCreateDebugUtilsMessengerEXT", true)] + public partial VkResult CreateDebugUtilsMessengerEXT(IntPtr instance, + ref VkDebugUtilsMessengerCreateInfoEXT pCreateInfo, IntPtr pAllocator, out IntPtr pMessenger); + + [GetProcAddress("vkEnumeratePhysicalDevices")] + public partial VkResult EnumeratePhysicalDevices(IntPtr instance, ref uint32_t pPhysicalDeviceCount, + IntPtr* pPhysicalDevices); + + [GetProcAddress("vkGetPhysicalDeviceProperties")] + public partial void GetPhysicalDeviceProperties(IntPtr physicalDevice, out VkPhysicalDeviceProperties pProperties); + + [GetProcAddress("vkEnumerateDeviceExtensionProperties")] + public partial VkResult EnumerateDeviceExtensionProperties(IntPtr physicalDevice, byte* pLayerName, + ref uint32_t pPropertyCount, VkExtensionProperties* pProperties); + + [GetProcAddress("vkGetPhysicalDeviceSurfaceSupportKHR")] + public partial VkResult GetPhysicalDeviceSurfaceSupportKHR(IntPtr physicalDevice, uint32_t queueFamilyIndex, + IntPtr surface, out VkBool32 pSupported); + + + [GetProcAddress("vkGetPhysicalDeviceQueueFamilyProperties")] + public partial void GetPhysicalDeviceQueueFamilyProperties(IntPtr physicalDevice, + ref uint32_t pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); + + [GetProcAddress("vkCreateDevice")] + public partial VkResult CreateDevice(IntPtr physicalDevice, ref VkDeviceCreateInfo pCreateInfo, + IntPtr pAllocator, out IntPtr pDevice); + + [GetProcAddress("vkGetDeviceQueue")] + public partial void GetDeviceQueue(IntPtr device, uint32_t queueFamilyIndex, uint32_t queueIndex, + out IntPtr pQueue); + + [GetProcAddress("vkGetDeviceProcAddr")] + public partial IntPtr GetDeviceProcAddr(IntPtr device, IntPtr pName); + + [GetProcAddress("vkDestroySurfaceKHR")] + public partial void DestroySurfaceKHR(IntPtr instance, IntPtr surface, IntPtr pAllocator); + + [GetProcAddress("vkGetPhysicalDeviceSurfaceFormatsKHR")] + public partial VkResult GetPhysicalDeviceSurfaceFormatsKHR( + IntPtr physicalDevice, + IntPtr surface, + ref uint32_t pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats); + + [GetProcAddress("vkGetPhysicalDeviceMemoryProperties")] + public partial void GetPhysicalDeviceMemoryProperties(IntPtr physicalDevice, + out VkPhysicalDeviceMemoryProperties pMemoryProperties); + + [GetProcAddress("vkGetPhysicalDeviceSurfaceCapabilitiesKHR")] + public partial VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(IntPtr physicalDevice, IntPtr surface, + out VkSurfaceCapabilitiesKHR pSurfaceCapabilities); + + [GetProcAddress("vkGetPhysicalDeviceSurfacePresentModesKHR")] + public partial VkResult GetPhysicalDeviceSurfacePresentModesKHR(IntPtr physicalDevice, IntPtr surface, + ref uint32_t pPresentModeCount, VkPresentModeKHR* pPresentModes); +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/UnmanagedInterop/VulkanStructs.cs b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanStructs.cs new file mode 100644 index 0000000000..91660195b3 --- /dev/null +++ b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanStructs.cs @@ -0,0 +1,657 @@ +// ReSharper disable IdentifierTypo + +// ReSharper disable InconsistentNaming +// ReSharper disable NotAccessedField.Global +#pragma warning disable CS0649 +#pragma warning disable CS0169 +#pragma warning disable CA1823 +using System; +using uint32_t = System.UInt32; +using VkSampleCountFlags = System.UInt32; +using int32_t = System.Int32; +using VkBool32 = System.UInt32; +using uint8_t = System.Byte; +using size_t = System.IntPtr; +using VkDeviceSize = System.UInt64; +// ReSharper disable RedundantUnsafeContext + +namespace Avalonia.Vulkan.UnmanagedInterop +{ + struct VkDevice + { + public IntPtr Handle; + public static implicit operator IntPtr(VkDevice d) => d.Handle; + public static implicit operator VkDevice(IntPtr d) => new() { Handle = d }; + } + + struct VkSwapchainKHR + { + public IntPtr Handle; + public static implicit operator IntPtr(VkSwapchainKHR d) => d.Handle; + public static implicit operator VkSwapchainKHR(IntPtr d) => new() { Handle = d }; + } + + struct VkSemaphore + { + public IntPtr Handle; + public static implicit operator IntPtr(VkSemaphore d) => d.Handle; + public static implicit operator VkSemaphore(IntPtr d) => new() { Handle = d }; + } + + struct VkFence + { + public IntPtr Handle; + public static implicit operator IntPtr(VkFence d) => d.Handle; + public static implicit operator VkFence(IntPtr d) => new() { Handle = d }; + } + + struct VkImage + { + public IntPtr Handle; + public static implicit operator IntPtr(VkImage d) => d.Handle; + public static implicit operator VkImage(IntPtr d) => new() { Handle = d }; + } + + struct VkQueue + { + public IntPtr Handle; + public static implicit operator IntPtr(VkQueue d) => d.Handle; + public static implicit operator VkQueue(IntPtr d) => new() { Handle = d }; + } + + struct VkCommandBuffer + { + public IntPtr Handle; + public static implicit operator IntPtr(VkCommandBuffer d) => d.Handle; + public static implicit operator VkCommandBuffer(IntPtr d) => new() { Handle = d }; + } + + + unsafe struct VkLayerProperties + { + public fixed byte layerName[256]; + public uint32_t specVersion; + public uint32_t implementationVersion; + public fixed byte description[256]; + } + + unsafe struct VkDebugUtilsLabelEXT + { + public VkStructureType sType; + public IntPtr pNext; + public IntPtr pLabelName; + public fixed float color[4]; + } + + struct VkDebugUtilsObjectNameInfoEXT + { + public VkStructureType sType; + public IntPtr pNext; + public VkObjectType objectType; + public ulong objectHandle; + public IntPtr pObjectName; + } + + unsafe struct VkDebugUtilsMessengerCallbackDataEXT + { + public VkStructureType sType; + public IntPtr pNext; + public uint flags; + public IntPtr pMessageIdName; + public int32_t messageIdNumber; + public IntPtr pMessage; + public uint32_t queueLabelCount; + public VkDebugUtilsLabelEXT* pQueueLabels; + public uint32_t cmdBufLabelCount; + public VkDebugUtilsLabelEXT* pCmdBufLabels; + public uint32_t objectCount; + public VkDebugUtilsObjectNameInfoEXT* pObjects; + } + + unsafe delegate VkBool32 VkDebugUtilsMessengerCallbackEXTDelegate( + VkDebugUtilsMessageSeverityFlagsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void* pUserData); + + struct VkDebugUtilsMessengerCreateInfoEXT + { + public VkStructureType sType; + public IntPtr pNext; + public uint flags; + public VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; + public VkDebugUtilsMessageTypeFlagsEXT messageType; + public IntPtr pfnUserCallback; + public IntPtr pUserData; + } + + unsafe struct VkInstanceCreateInfo + { + public VkStructureType sType; + public IntPtr pNext; + public int flags; + public VkApplicationInfo* pApplicationInfo; + public uint32_t enabledLayerCount; + public byte** ppEnabledLayerNames; + public uint32_t enabledExtensionCount; + public byte** ppEnabledExtensionNames; + } + + unsafe struct VkApplicationInfo + { + public VkStructureType sType; + public void* pNext; + public byte* pApplicationName; + public uint32_t applicationVersion; + public byte* pEngineName; + public uint32_t engineVersion; + public uint32_t apiVersion; + } + + unsafe struct VkPhysicalDeviceSparseProperties + { + public VkBool32 residencyStandard2DBlockShape; + public VkBool32 residencyStandard2DMultisampleBlockShape; + public VkBool32 residencyStandard3DBlockShape; + public VkBool32 residencyAlignedMipSize; + public VkBool32 residencyNonResidentStrict; + } + + unsafe struct VkPhysicalDeviceProperties + { + public uint32_t apiVersion; + public uint32_t driverVersion; + public uint32_t vendorID; + public uint32_t deviceID; + public VkPhysicalDeviceType deviceType; + public fixed byte deviceName[256]; + public fixed uint8_t pipelineCacheUUID[16]; + public VkPhysicalDeviceLimits limits; + public VkPhysicalDeviceSparseProperties sparseProperties; + } + + unsafe struct VkPhysicalDeviceLimits + { + public uint32_t maxImageDimension1D; + public uint32_t maxImageDimension2D; + public uint32_t maxImageDimension3D; + public uint32_t maxImageDimensionCube; + public uint32_t maxImageArrayLayers; + public uint32_t maxTexelBufferElements; + public uint32_t maxUniformBufferRange; + public uint32_t maxStorageBufferRange; + public uint32_t maxPushConstantsSize; + public uint32_t maxMemoryAllocationCount; + public uint32_t maxSamplerAllocationCount; + public VkDeviceSize bufferImageGranularity; + public VkDeviceSize sparseAddressSpaceSize; + public uint32_t maxBoundDescriptorSets; + public uint32_t maxPerStageDescriptorSamplers; + public uint32_t maxPerStageDescriptorUniformBuffers; + public uint32_t maxPerStageDescriptorStorageBuffers; + public uint32_t maxPerStageDescriptorSampledImages; + public uint32_t maxPerStageDescriptorStorageImages; + public uint32_t maxPerStageDescriptorInputAttachments; + public uint32_t maxPerStageResources; + public uint32_t maxDescriptorSetSamplers; + public uint32_t maxDescriptorSetUniformBuffers; + public uint32_t maxDescriptorSetUniformBuffersDynamic; + public uint32_t maxDescriptorSetStorageBuffers; + public uint32_t maxDescriptorSetStorageBuffersDynamic; + public uint32_t maxDescriptorSetSampledImages; + public uint32_t maxDescriptorSetStorageImages; + public uint32_t maxDescriptorSetInputAttachments; + public uint32_t maxVertexInputAttributes; + public uint32_t maxVertexInputBindings; + public uint32_t maxVertexInputAttributeOffset; + public uint32_t maxVertexInputBindingStride; + public uint32_t maxVertexOutputComponents; + public uint32_t maxTessellationGenerationLevel; + public uint32_t maxTessellationPatchSize; + public uint32_t maxTessellationControlPerVertexInputComponents; + public uint32_t maxTessellationControlPerVertexOutputComponents; + public uint32_t maxTessellationControlPerPatchOutputComponents; + public uint32_t maxTessellationControlTotalOutputComponents; + public uint32_t maxTessellationEvaluationInputComponents; + public uint32_t maxTessellationEvaluationOutputComponents; + public uint32_t maxGeometryShaderInvocations; + public uint32_t maxGeometryInputComponents; + public uint32_t maxGeometryOutputComponents; + public uint32_t maxGeometryOutputVertices; + public uint32_t maxGeometryTotalOutputComponents; + public uint32_t maxFragmentInputComponents; + public uint32_t maxFragmentOutputAttachments; + public uint32_t maxFragmentDualSrcAttachments; + public uint32_t maxFragmentCombinedOutputResources; + public uint32_t maxComputeSharedMemorySize; + public fixed uint32_t maxComputeWorkGroupCount[3]; + public uint32_t maxComputeWorkGroupInvocations; + public fixed uint32_t maxComputeWorkGroupSize[3]; + public uint32_t subPixelPrecisionBits; + public uint32_t subTexelPrecisionBits; + public uint32_t mipmapPrecisionBits; + public uint32_t maxDrawIndexedIndexValue; + public uint32_t maxDrawIndirectCount; + public float maxSamplerLodBias; + public float maxSamplerAnisotropy; + public uint32_t maxViewports; + public fixed uint32_t maxViewportDimensions[2]; + public fixed float viewportBoundsRange[2]; + public uint32_t viewportSubPixelBits; + public size_t minMemoryMapAlignment; + public VkDeviceSize minTexelBufferOffsetAlignment; + public VkDeviceSize minUniformBufferOffsetAlignment; + public VkDeviceSize minStorageBufferOffsetAlignment; + public int32_t minTexelOffset; + public uint32_t maxTexelOffset; + public int32_t minTexelGatherOffset; + public uint32_t maxTexelGatherOffset; + public float minInterpolationOffset; + public float maxInterpolationOffset; + public uint32_t subPixelInterpolationOffsetBits; + public uint32_t maxFramebufferWidth; + public uint32_t maxFramebufferHeight; + public uint32_t maxFramebufferLayers; + public VkSampleCountFlags framebufferColorSampleCounts; + public VkSampleCountFlags framebufferDepthSampleCounts; + public VkSampleCountFlags framebufferStencilSampleCounts; + public VkSampleCountFlags framebufferNoAttachmentsSampleCounts; + public uint32_t maxColorAttachments; + public VkSampleCountFlags sampledImageColorSampleCounts; + public VkSampleCountFlags sampledImageIntegerSampleCounts; + public VkSampleCountFlags sampledImageDepthSampleCounts; + public VkSampleCountFlags sampledImageStencilSampleCounts; + public VkSampleCountFlags storageImageSampleCounts; + public uint32_t maxSampleMaskWords; + public VkBool32 timestampComputeAndGraphics; + public float timestampPeriod; + public uint32_t maxClipDistances; + public uint32_t maxCullDistances; + public uint32_t maxCombinedClipAndCullDistances; + public uint32_t discreteQueuePriorities; + public fixed float pointSizeRange[2]; + public fixed float lineWidthRange[2]; + public float pointSizeGranularity; + public float lineWidthGranularity; + public VkBool32 strictLines; + public VkBool32 standardSampleLocations; + public VkDeviceSize optimalBufferCopyOffsetAlignment; + public VkDeviceSize optimalBufferCopyRowPitchAlignment; + public VkDeviceSize nonCoherentAtomSize; + } + + internal unsafe struct VkExtensionProperties + { + public fixed byte extensionName[256]; + public uint32_t specVersion; + } + + struct VkQueueFamilyProperties + { + public VkQueueFlags queueFlags; + public uint32_t queueCount; + public uint32_t timestampValidBits; + public VkExtent3D minImageTransferGranularity; + } + + struct VkExtent2D + { + public uint32_t width; + public uint32_t height; + } + + struct VkExtent3D + { + public uint32_t width; + public uint32_t height; + public uint32_t depth; + } + + unsafe struct VkDeviceQueueCreateInfo + { + public VkStructureType sType; + public IntPtr pNext; + public VkDeviceQueueCreateFlags flags; + public uint32_t queueFamilyIndex; + public uint32_t queueCount; + public float* pQueuePriorities; + } + + unsafe struct VkDeviceCreateInfo + { + public VkStructureType sType; + public IntPtr pNext; + public uint flags; + public uint32_t queueCreateInfoCount; + public VkDeviceQueueCreateInfo* pQueueCreateInfos; + public uint32_t enabledLayerCount; + public byte** ppEnabledLayerNames; + public uint32_t enabledExtensionCount; + public byte** ppEnabledExtensionNames; + public IntPtr pEnabledFeatures; + } + + struct VkFenceCreateInfo + { + public VkStructureType sType; + IntPtr pNext; + public VkFenceCreateFlags flags; + } + + struct VkCommandPoolCreateInfo + { + public VkStructureType sType; + IntPtr pNext; + public VkCommandPoolCreateFlags flags; + public uint32_t queueFamilyIndex; + } + + + + struct VkCommandBufferAllocateInfo + { + public VkStructureType sType; + IntPtr pNext; + public IntPtr commandPool; + public VkCommandBufferLevel level; + public uint32_t commandBufferCount; + } + + + + struct VkCommandBufferBeginInfo + { + public VkStructureType sType; + IntPtr pNext; + public VkCommandBufferUsageFlags flags; + IntPtr pInheritanceInfo; + } + + struct VkSemaphoreCreateInfo + { + public VkStructureType sType; + IntPtr pNext; + uint flags; + } + + unsafe struct VkSubmitInfo + { + public VkStructureType sType; + public IntPtr pNext; + public uint32_t waitSemaphoreCount; + public IntPtr* pWaitSemaphores; + public VkPipelineStageFlags* pWaitDstStageMask; + public uint32_t commandBufferCount; + public IntPtr* pCommandBuffers; + public uint32_t signalSemaphoreCount; + public IntPtr* pSignalSemaphores; + } + + + struct VkSurfaceFormatKHR + { + public VkFormat format; + public VkColorSpaceKHR colorSpace; + } + + + + struct VkMemoryType + { + public VkMemoryPropertyFlags propertyFlags; + public uint32_t heapIndex; + } + + struct VkMemoryHeap + { + public VkDeviceSize size; + public VkMemoryHeapFlags flags; + } + + unsafe struct VkPhysicalDeviceMemoryProperties + { + public uint32_t memoryTypeCount; + public VkMemoryTypesBuffer memoryTypes; + public uint32_t memoryHeapCount; + public VkMemoryHeapsBuffer memoryHeaps; + + public struct VkMemoryTypesBuffer + { + public VkMemoryType Element0; + public VkMemoryType Element1; + public VkMemoryType Element2; + public VkMemoryType Element3; + public VkMemoryType Element4; + public VkMemoryType Element5; + public VkMemoryType Element6; + public VkMemoryType Element7; + public VkMemoryType Element8; + public VkMemoryType Element9; + public VkMemoryType Element10; + public VkMemoryType Element11; + public VkMemoryType Element12; + public VkMemoryType Element13; + public VkMemoryType Element14; + public VkMemoryType Element15; + public VkMemoryType Element16; + public VkMemoryType Element17; + public VkMemoryType Element18; + public VkMemoryType Element19; + public VkMemoryType Element20; + public VkMemoryType Element21; + public VkMemoryType Element22; + public VkMemoryType Element23; + public VkMemoryType Element24; + public VkMemoryType Element25; + public VkMemoryType Element26; + public VkMemoryType Element27; + public VkMemoryType Element28; + public VkMemoryType Element29; + public VkMemoryType Element30; + public VkMemoryType Element31; + + public ref VkMemoryType this[int index] + { + get + { + if (index > 31 || index < 0) + { + throw new ArgumentOutOfRangeException(nameof(index)); + } + + fixed (VkMemoryType* ptr = &Element0) + { + return ref ptr[index]; + } + } + } + } + public struct VkMemoryHeapsBuffer + { + public VkMemoryHeap Element0; + public VkMemoryHeap Element1; + public VkMemoryHeap Element2; + public VkMemoryHeap Element3; + public VkMemoryHeap Element4; + public VkMemoryHeap Element5; + public VkMemoryHeap Element6; + public VkMemoryHeap Element7; + public VkMemoryHeap Element8; + public VkMemoryHeap Element9; + public VkMemoryHeap Element10; + public VkMemoryHeap Element11; + public VkMemoryHeap Element12; + public VkMemoryHeap Element13; + public VkMemoryHeap Element14; + public VkMemoryHeap Element15; + + public ref VkMemoryHeap this[int index] + { + get + { + if (index > 15 || index < 0) + { + throw new ArgumentOutOfRangeException(nameof(index)); + } + + fixed (VkMemoryHeap* ptr = &Element0) + { + return ref ptr[index]; + } + } + } + + + } + } + + unsafe struct VkImageCreateInfo + { + public VkStructureType sType; + public IntPtr pNext; + public VkImageCreateFlags flags; + public VkImageType imageType; + public VkFormat format; + public VkExtent3D extent; + public uint32_t mipLevels; + public uint32_t arrayLayers; + public VkSampleCountFlags samples; + public VkImageTiling tiling; + public VkImageUsageFlags usage; + public VkSharingMode sharingMode; + public uint32_t queueFamilyIndexCount; + public uint32_t* pQueueFamilyIndices; + public VkImageLayout initialLayout; + } + + struct VkMemoryRequirements + { + public VkDeviceSize size; + public VkDeviceSize alignment; + public uint32_t memoryTypeBits; + } + + struct VkMemoryAllocateInfo + { + public VkStructureType sType; + IntPtr pNext; + public VkDeviceSize allocationSize; + public uint32_t memoryTypeIndex; + } + + struct VkComponentMapping + { + public VkComponentSwizzle r; + public VkComponentSwizzle g; + public VkComponentSwizzle b; + public VkComponentSwizzle a; + } + + struct VkImageSubresourceRange + { + public VkImageAspectFlags aspectMask; + public uint32_t baseMipLevel; + public uint32_t levelCount; + public uint32_t baseArrayLayer; + public uint32_t layerCount; + } + + struct VkImageViewCreateInfo + { + public VkStructureType sType; + public IntPtr pNext; + public VkImageViewCreateFlags flags; + public IntPtr image; + public VkImageViewType viewType; + public VkFormat format; + public VkComponentMapping components; + public VkImageSubresourceRange subresourceRange; + } + + struct VkImageMemoryBarrier + { + public VkStructureType sType; + IntPtr pNext; + public VkAccessFlags srcAccessMask; + public VkAccessFlags dstAccessMask; + public VkImageLayout oldLayout; + public VkImageLayout newLayout; + public uint32_t srcQueueFamilyIndex; + public uint32_t dstQueueFamilyIndex; + public IntPtr image; + public VkImageSubresourceRange subresourceRange; + } + + struct VkSurfaceCapabilitiesKHR + { + public uint32_t minImageCount; + public uint32_t maxImageCount; + public VkExtent2D currentExtent; + public VkExtent2D minImageExtent; + public VkExtent2D maxImageExtent; + public uint32_t maxImageArrayLayers; + public VkSurfaceTransformFlagsKHR supportedTransforms; + public VkSurfaceTransformFlagsKHR currentTransform; + public VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + public VkImageUsageFlags supportedUsageFlags; + } + + unsafe struct VkSwapchainCreateInfoKHR + { + public VkStructureType sType; + public IntPtr pNext; + public VkSwapchainCreateFlagsKHR flags; + public IntPtr surface; + public uint32_t minImageCount; + public VkFormat imageFormat; + public VkColorSpaceKHR imageColorSpace; + public VkExtent2D imageExtent; + public uint32_t imageArrayLayers; + public VkImageUsageFlags imageUsage; + public VkSharingMode imageSharingMode; + public uint32_t queueFamilyIndexCount; + public uint32_t* pQueueFamilyIndices; + public VkSurfaceTransformFlagsKHR preTransform; + public VkCompositeAlphaFlagsKHR compositeAlpha; + public VkPresentModeKHR presentMode; + public VkBool32 clipped; + public IntPtr oldSwapchain; + } + + struct VkOffset3D + { + public int32_t x; + public int32_t y; + public int32_t z; + } + + struct VkImageSubresourceLayers + { + public VkImageAspectFlags aspectMask; + public uint32_t mipLevel; + public uint32_t baseArrayLayer; + public uint32_t layerCount; + } + + struct VkImageBlit + { + public VkImageSubresourceLayers srcSubresource; + public VkOffset3D srcOffsets1; + public VkOffset3D srcOffsets2; + public VkImageSubresourceLayers dstSubresource; + public VkOffset3D dstOffsets1; + public VkOffset3D dstOffsets2; + } + + unsafe struct VkPresentInfoKHR + { + public VkStructureType sType; + public IntPtr pNext; + public uint32_t waitSemaphoreCount; + public VkSemaphore* pWaitSemaphores; + public uint32_t swapchainCount; + public VkSwapchainKHR* pSwapchains; + public uint32_t* pImageIndices; + public VkResult* pResults; + } +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/VulkanBindings.cs b/src/Avalonia.Vulkan/VulkanBindings.cs new file mode 100644 index 0000000000..d3a05fa980 --- /dev/null +++ b/src/Avalonia.Vulkan/VulkanBindings.cs @@ -0,0 +1,19 @@ +using System; +using System.Collections.Generic; +using System.Runtime.InteropServices; +using Avalonia.Vulkan.Interop; + +namespace Avalonia.Vulkan; + + +static class VulkanHelpers +{ + public static uint MakeVersion(Version v) => MakeVersion(v.Major, v.Minor, v.Build); + + public static uint MakeVersion(int major, int minor, int patch) + { + return (uint)((major << 22) | (minor << 12) | patch); + } + + public const uint QueueFamilyIgnored = 4294967295; +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/VulkanContext.cs b/src/Avalonia.Vulkan/VulkanContext.cs new file mode 100644 index 0000000000..a1c0b5d413 --- /dev/null +++ b/src/Avalonia.Vulkan/VulkanContext.cs @@ -0,0 +1,53 @@ +using System; +using System.Collections.Generic; +using Avalonia.Vulkan.UnmanagedInterop; + +namespace Avalonia.Vulkan; + +internal class VulkanContext : IVulkanPlatformGraphicsContext +{ + private readonly IVulkanKhrSurfacePlatformSurfaceFactory? _surfaceFactory; + + public VulkanContext(IVulkanDevice device, Dictionary platformFeatures) + { + Device = device; + using (device.Lock()) + { + InstanceApi = new VulkanInstanceApi(device.Instance); + DeviceApi = new VulkanDeviceApi(device); + if (platformFeatures.TryGetValue(typeof(IVulkanKhrSurfacePlatformSurfaceFactory), out var factory)) + _surfaceFactory = (IVulkanKhrSurfacePlatformSurfaceFactory)factory; + } + } + + public void Dispose() + { + throw new NotImplementedException(); + } + + public object? TryGetFeature(Type featureType) => null; + + public bool IsLost => Device.IsLost; + public IDisposable EnsureCurrent() => Device.Lock(); + + public IVulkanDevice Device { get; } + public IVulkanInstance Instance => Device.Instance; + public VulkanInstanceApi InstanceApi { get; } + public VulkanDeviceApi DeviceApi { get; } + public IVulkanRenderTarget CreateRenderTarget(IEnumerable surfaces) + { + foreach (var surf in surfaces) + { + IVulkanKhrSurfacePlatformSurface khrSurface; + if (surf is IVulkanKhrSurfacePlatformSurface khr) + khrSurface = khr; + else if (_surfaceFactory?.CanRenderToSurface(this, surf) == true) + khrSurface = _surfaceFactory.CreateSurface(this, surf); + else + continue; + return new VulkanKhrRenderTarget(khrSurface, this); + } + + throw new VulkanException("Unable to find a suitable platform surface"); + } +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/VulkanException.cs b/src/Avalonia.Vulkan/VulkanException.cs new file mode 100644 index 0000000000..d1cfb69b36 --- /dev/null +++ b/src/Avalonia.Vulkan/VulkanException.cs @@ -0,0 +1,27 @@ +using System; +using Avalonia.Vulkan.Interop; +using Avalonia.Vulkan.UnmanagedInterop; + +namespace Avalonia.Vulkan; + +public class VulkanException : Exception +{ + public VulkanException(string message) : base(message) + { + + } + + public VulkanException(string funcName, VkResult res) : base($"{funcName} returned {res}") + { + + } +} + +public static class VulkanExceptionExtensions +{ + public static void ThrowOnError(this VkResult res, string funcName) + { + if (res != VkResult.VK_SUCCESS) + throw new VulkanException(funcName, res); + } +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/VulkanKhrSurfaceRenderTarget.cs b/src/Avalonia.Vulkan/VulkanKhrSurfaceRenderTarget.cs new file mode 100644 index 0000000000..822b454010 --- /dev/null +++ b/src/Avalonia.Vulkan/VulkanKhrSurfaceRenderTarget.cs @@ -0,0 +1,109 @@ +using System; +using Avalonia.Vulkan.Interop; +using Avalonia.Vulkan.UnmanagedInterop; + +namespace Avalonia.Vulkan; + + +internal class VulkanKhrRenderTarget : IVulkanRenderTarget +{ + private IVulkanKhrSurfacePlatformSurface _surface; + private readonly VulkanKhrSurface _khrSurface; + private readonly IVulkanPlatformGraphicsContext _context; + private VulkanDisplay _display; + private PixelSize _size; + private VulkanImage? _image; + public VkFormat Format { get; } + public bool IsRgba { get; } + + public VulkanKhrRenderTarget(IVulkanKhrSurfacePlatformSurface surface, IVulkanPlatformGraphicsContext context) + { + _surface = surface; + _khrSurface = new(context, surface); + _display = VulkanDisplay.CreateDisplay(context, _khrSurface); + _context = context; + IsRgba = _display.SurfaceFormat.format >= VkFormat.VK_FORMAT_R8G8B8A8_UNORM && + _display.SurfaceFormat.format <= VkFormat.VK_FORMAT_R8G8B8A8_SRGB; + + // Skia seems to only create surfaces from images with unorm format + Format = IsRgba ? VkFormat.VK_FORMAT_R8G8B8A8_UNORM : VkFormat.VK_FORMAT_B8G8R8A8_UNORM; + } + + private void CreateImage() + { + _size = _display.Size; + _image = new VulkanImage(_context, _display.CommandBufferPool, Format, _display.Size); + } + + private void DestroyImage() + { + _context.DeviceApi.DeviceWaitIdle(_context.Device.Handle); + _image?.Dispose(); + _image = null; + } + + public void Dispose() + { + _context.DeviceApi.DeviceWaitIdle(_context.Device.Handle); + DestroyImage(); + _display?.Dispose(); + _display = null!; + _surface?.Dispose(); + _surface = null!; + } + + + public IVulkanRenderSession BeginDraw() + { + var l = _context.EnsureCurrent(); + if (_display.EnsureSwapchainAvailable() || _image == null) + { + DestroyImage(); + CreateImage(); + } + else + _image.TransitionLayout(VkImageLayout.VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + VkAccessFlags.VK_ACCESS_NONE); + + return new RenderingSession(_display, _image!, IsRgba, _surface.Scaling, l); + } + + public class RenderingSession : IVulkanRenderSession + { + private readonly VulkanImage _image; + private readonly IDisposable _dispose; + + public RenderingSession(VulkanDisplay display, VulkanImage image, bool isRgba, double scaling, + IDisposable dispose) + { + _image = image; + _dispose = dispose; + Display = display; + IsRgba = isRgba; + Scaling = scaling; + } + + public VulkanDisplay Display { get; } + public PixelSize Size => _image.Size; + public double Scaling { get; } + public bool IsYFlipped => true; + + public uint ImageFormat => (uint)_image.Format; + public IntPtr ImageHandle => _image.Handle; + public uint ImageLayout => (uint)_image.CurrentLayout; + public uint ImageTiling => (uint)_image.Tiling; + public uint ImageUsageFlags => (uint)_image.UsageFlags; + public uint LevelCount => (uint)_image.MipLevels; + public IntPtr ImageMemoryHandle => _image.MemoryHandle; + public ulong ImageMemorySize => _image.MemorySize; + public bool IsRgba { get; } + + public void Dispose() + { + var commandBuffer = Display.StartPresentation(); + Display.BlitImageToCurrentImage(commandBuffer, _image); + Display.EndPresentation(commandBuffer); + _dispose.Dispose(); + } + } +} \ No newline at end of file diff --git a/src/Avalonia.Vulkan/VulkanOptions.cs b/src/Avalonia.Vulkan/VulkanOptions.cs new file mode 100644 index 0000000000..a1f4d09ec5 --- /dev/null +++ b/src/Avalonia.Vulkan/VulkanOptions.cs @@ -0,0 +1,73 @@ +using System; +using System.Collections.Generic; + +namespace Avalonia.Vulkan; + +public class VulkanOptions +{ + public VulkanInstanceCreationOptions VulkanInstanceCreationOptions { get; set; } = new(); + public VulkanDeviceCreationOptions VulkanDeviceCreationOptions { get; set; } = new(); + public IVulkanDevice? CustomSharedDevice { get; set; } +} +public class VulkanInstanceCreationOptions +{ + public VkGetInstanceProcAddressDelegate? CustomGetProcAddressDelegate { get; set; } + + /// + /// Sets the application name of the vulkan instance + /// + public string? ApplicationName { get; set; } + + /// + /// Specifies the vulkan api version to use + /// + public Version VulkanVersion{ get; set; } = new Version(1, 1, 0); + + /// + /// Specifies additional extensions to enable if available on the instance + /// + public IList InstanceExtensions { get; set; } = new List(); + + /// + /// Specifies layers to enable if available on the instance + /// + public IList EnabledLayers { get; set; } = new List(); + + /// + /// Enables the debug layer + /// + public bool UseDebug { get; set; } + + /* + + + /// + /// Sets the presentation mode the swapchain uses if available. + /// + //public PresentMode PresentMode { get; set; } = PresentMode.Mailbox;*/ +} + +public class VulkanDeviceCreationOptions +{ + /// + /// Specifies extensions to enable if available on the logical device + /// + public IList DeviceExtensions { get; set; } = new List(); + + /// + /// Selects the first suitable discrete gpu available + /// + public bool PreferDiscreteGpu { get; set; } + + public bool RequireComputeBit { get; set; } +} + +public class VulkanPlatformSpecificOptions +{ + public IList RequiredInstanceExtensions { get; set; } = new List(); + public VkGetInstanceProcAddressDelegate? GetProcAddressDelegate { get; set; } + public Func? DeviceCheckSurfaceFactory { get; set; } + public Dictionary PlatformFeatures { get; set; } = new(); +} + +public delegate IntPtr VkGetInstanceProcAddressDelegate(IntPtr instance, string name); \ No newline at end of file diff --git a/src/Avalonia.Vulkan/VulkanPlatformGraphics.cs b/src/Avalonia.Vulkan/VulkanPlatformGraphics.cs new file mode 100644 index 0000000000..0ae0523138 --- /dev/null +++ b/src/Avalonia.Vulkan/VulkanPlatformGraphics.cs @@ -0,0 +1,103 @@ +using System; +using Avalonia.Logging; +using Avalonia.Platform; + +namespace Avalonia.Vulkan; + +public class VulkanPlatformGraphics : IPlatformGraphics +{ + private readonly IVulkanDeviceFactory _factory; + private IVulkanPlatformGraphicsContext? _currentSharedContext; + private readonly VulkanPlatformSpecificOptions _platformOptions; + public VulkanPlatformGraphics(IVulkanDeviceFactory factory, VulkanPlatformSpecificOptions platformOptions) + { + _factory = factory; + _platformOptions = platformOptions; + } + + public IPlatformGraphicsContext CreateContext() => + new VulkanContext(_factory.CreateDevice(_platformOptions), _platformOptions.PlatformFeatures); + + public IPlatformGraphicsContext GetSharedContext() + { + if (_currentSharedContext?.IsLost == true) + _currentSharedContext = null; + return _currentSharedContext = + new VulkanContext(_factory.GetSharedDevice(_platformOptions), _platformOptions.PlatformFeatures); + } + + public bool UsesSharedContext => _factory.UsesShadedDevice; + + + public interface IVulkanDeviceFactory + { + bool UsesShadedDevice { get; } + IVulkanDevice GetSharedDevice(VulkanPlatformSpecificOptions platformOptions); + IVulkanDevice CreateDevice(VulkanPlatformSpecificOptions platformOptions); + } + + + class DefaultDeviceFactory : IVulkanDeviceFactory + { + private readonly IVulkanInstance _instance; + private readonly VulkanDeviceCreationOptions _deviceOptions; + + public DefaultDeviceFactory(IVulkanInstance instance, VulkanDeviceCreationOptions deviceOptions) + { + _instance = instance; + _deviceOptions = deviceOptions; + } + + public bool UsesShadedDevice => false; + + public IVulkanDevice GetSharedDevice(VulkanPlatformSpecificOptions platformOptions) => throw new NotSupportedException(); + + public IVulkanDevice CreateDevice(VulkanPlatformSpecificOptions platformOptions) + { + return VulkanDevice.Create(_instance, _deviceOptions, platformOptions); + } + } + + class CustomSharedDeviceFactory : IVulkanDeviceFactory + { + private readonly IVulkanDevice _device; + + public CustomSharedDeviceFactory(IVulkanDevice device) + { + _device = device; + } + + public bool UsesShadedDevice => true; + public IVulkanDevice GetSharedDevice(VulkanPlatformSpecificOptions platformOptions) => _device; + + public IVulkanDevice CreateDevice(VulkanPlatformSpecificOptions platformOptions) => + throw new NotSupportedException(); + } + + public static VulkanPlatformGraphics? TryCreate(VulkanOptions options, VulkanPlatformSpecificOptions platformOptions) + { + if (options.CustomSharedDevice != null) + return new(new CustomSharedDeviceFactory(options.CustomSharedDevice), platformOptions); + + IVulkanInstance? instance = null; + try + { + instance = VulkanInstance.Create(options.VulkanInstanceCreationOptions ?? new(), + platformOptions); + + var devOpts = options.VulkanDeviceCreationOptions ?? new(); + VulkanDevice.Create(instance, devOpts, platformOptions) + .Dispose(); + + return new VulkanPlatformGraphics(new DefaultDeviceFactory(instance, devOpts), platformOptions); + } + catch (Exception e) + { + //instance?.Dispose(); + Logger.TryGet(LogEventLevel.Error, "Vulkan")?.Log(null, "Unable to initialize Vulkan rendering: {0}", e); + return null; + } + } +} + + diff --git a/src/Avalonia.X11/Avalonia.X11.csproj b/src/Avalonia.X11/Avalonia.X11.csproj index c762349c1c..812010a3c3 100644 --- a/src/Avalonia.X11/Avalonia.X11.csproj +++ b/src/Avalonia.X11/Avalonia.X11.csproj @@ -13,4 +13,7 @@ + + + diff --git a/src/Avalonia.X11/Vulkan/VulkanNativeInterop.cs b/src/Avalonia.X11/Vulkan/VulkanNativeInterop.cs new file mode 100644 index 0000000000..034db4161c --- /dev/null +++ b/src/Avalonia.X11/Vulkan/VulkanNativeInterop.cs @@ -0,0 +1,29 @@ +using System; +using Avalonia.SourceGenerator; +using Avalonia.Vulkan; +using Avalonia.Vulkan.Interop; +using Avalonia.Vulkan.UnmanagedInterop; + +namespace Avalonia.X11.Vulkan; +partial class X11VulkanInterface +{ + + public X11VulkanInterface(IVulkanInstance instance) + { + Initialize(name => instance.GetInstanceProcAddress(instance.Handle, name)); + } + + [GetProcAddress("vkCreateXlibSurfaceKHR")] + public partial VkResult vkCreateXlibSurfaceKHR(IntPtr instance, ref VkXlibSurfaceCreateInfoKHR pCreateInfo, + IntPtr pAllocator, out IntPtr pSurface); +} + +struct VkXlibSurfaceCreateInfoKHR +{ + public const uint VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000; + public uint sType; + public IntPtr pNext; + public uint flags; + public IntPtr dpy; + public IntPtr window; +} \ No newline at end of file diff --git a/src/Avalonia.X11/Vulkan/VulkanSupport.cs b/src/Avalonia.X11/Vulkan/VulkanSupport.cs new file mode 100644 index 0000000000..fa0dc639b4 --- /dev/null +++ b/src/Avalonia.X11/Vulkan/VulkanSupport.cs @@ -0,0 +1,97 @@ +using System; +using System.Collections.Generic; +using System.Runtime.InteropServices; +using Avalonia.Platform; +using Avalonia.Platform.Surfaces; +using Avalonia.Vulkan; +using JetBrains.Annotations; + +namespace Avalonia.X11.Vulkan; + +internal class VulkanSupport +{ + private static IntPtr s_offscreenWindow; + + [DllImport("libvulkan.so.1")] + private static extern IntPtr vkGetInstanceProcAddr(IntPtr instance, string name); + + [CanBeNull] + public static VulkanPlatformGraphics TryInitialize(X11Info info, VulkanOptions options) + { + s_offscreenWindow = XLib.XCreateSimpleWindow(info.DeferredDisplay, + XLib.XDefaultRootWindow(info.DeferredDisplay), 0, 0, 1, + 1, 1, IntPtr.Zero, IntPtr.Zero); + XLib.XSync(info.DeferredDisplay, true); + + return VulkanPlatformGraphics.TryCreate(options ?? new(), new VulkanPlatformSpecificOptions + { + RequiredInstanceExtensions = { "VK_KHR_xlib_surface" }, + GetProcAddressDelegate = vkGetInstanceProcAddr, + DeviceCheckSurfaceFactory = instance => CreateDummySurface(info.DeferredDisplay, instance), + PlatformFeatures = new Dictionary + { + [typeof(IVulkanKhrSurfacePlatformSurfaceFactory)] = new VulkanSurfaceFactory(info.DeferredDisplay) + } + }); + } + + internal class VulkanSurfaceFactory : IVulkanKhrSurfacePlatformSurfaceFactory + { + private readonly IntPtr _display; + + public VulkanSurfaceFactory(IntPtr display) + { + _display = display; + } + + public bool CanRenderToSurface(IVulkanPlatformGraphicsContext context, object surface) => + surface is INativeHandlePlatformSurface handle && handle.HandleDescriptor == "XID"; + + public IVulkanKhrSurfacePlatformSurface CreateSurface(IVulkanPlatformGraphicsContext context, object handle) => + new XidSurface(_display, (INativeHandlePlatformSurface)handle); + } + + class XidSurface : IVulkanKhrSurfacePlatformSurface + { + private readonly IntPtr _display; + private readonly INativeHandlePlatformSurface _handle; + + public XidSurface(IntPtr display, INativeHandlePlatformSurface handle) + { + _display = display; + _handle = handle; + } + + public void Dispose() + { + // No-op + } + + public double Scaling => _handle.Scaling; + public PixelSize Size => _handle.Size; + public IntPtr CreateSurface(IVulkanPlatformGraphicsContext context) => + CreateXlibSurface(_display, _handle.Handle, context.Instance); + } + + private static IntPtr CreateDummySurface(IntPtr display, IVulkanInstance instance) + { + var surf = CreateXlibSurface(display, s_offscreenWindow, instance); + XLib.XSync(display, true); + return surf; + } + + private static IntPtr CreateXlibSurface(IntPtr display, IntPtr window, IVulkanInstance instance) + { + var vulkanXlib = new X11VulkanInterface(instance); + var createInfo = new VkXlibSurfaceCreateInfoKHR + { + sType = VkXlibSurfaceCreateInfoKHR.VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, + dpy = display, + window = window + }; + vulkanXlib.vkCreateXlibSurfaceKHR(instance.Handle, ref createInfo, IntPtr.Zero, out var surface) + .ThrowOnError("vkCreateXlibSurfaceKHR"); + return surface; + } +} + diff --git a/src/Avalonia.X11/X11Platform.cs b/src/Avalonia.X11/X11Platform.cs index e44b5ded14..36b5740a17 100644 --- a/src/Avalonia.X11/X11Platform.cs +++ b/src/Avalonia.X11/X11Platform.cs @@ -14,8 +14,10 @@ using Avalonia.OpenGL.Egl; using Avalonia.Platform; using Avalonia.Rendering; using Avalonia.Rendering.Composition; +using Avalonia.Vulkan; using Avalonia.X11; using Avalonia.X11.Glx; +using Avalonia.X11.Vulkan; using static Avalonia.X11.XLib; namespace Avalonia.X11 @@ -94,7 +96,14 @@ namespace Avalonia.X11 XI2 = xi2; } - if (options.UseGpu) + if (options.UseVulkan) + { + var vulkan = VulkanSupport.TryInitialize(Info, AvaloniaLocator.Current.GetService()); + if (vulkan != null) + AvaloniaLocator.CurrentMutable.Bind().ToConstant(vulkan); + } + + if (options.UseGpu && AvaloniaLocator.Current.GetService() == null) { if (options.UseEGL) EglPlatformGraphics.TryInitialize(); @@ -102,12 +111,12 @@ namespace Avalonia.X11 GlxPlatformGraphics.TryInitialize(Info, Options.GlProfiles); } - var gl = AvaloniaLocator.Current.GetService(); + var graphics = AvaloniaLocator.Current.GetService(); if (options.UseCompositor) - Compositor = new Compositor(AvaloniaLocator.Current.GetService()!, gl); + Compositor = new Compositor(AvaloniaLocator.Current.GetService()!, graphics); else - RenderInterface = new(gl); + RenderInterface = new(graphics); } @@ -289,6 +298,11 @@ namespace Avalonia /// public bool? EnableMultiTouch { get; set; } = true; + /// + /// Enables Vulkan rendering backend + /// + public bool UseVulkan { get; set; } + public X11PlatformOptions() { try diff --git a/src/Avalonia.X11/X11Window.cs b/src/Avalonia.X11/X11Window.cs index 810a806c8a..a1788c96f2 100644 --- a/src/Avalonia.X11/X11Window.cs +++ b/src/Avalonia.X11/X11Window.cs @@ -16,6 +16,7 @@ using Avalonia.OpenGL; using Avalonia.OpenGL.Egl; using Avalonia.Platform; using Avalonia.Platform.Storage; +using Avalonia.Platform.Surfaces; using Avalonia.Rendering; using Avalonia.Rendering.Composition; using Avalonia.Threading; @@ -1231,7 +1232,7 @@ namespace Avalonia.X11 public IStorageProvider StorageProvider { get; } - public class SurfacePlatformHandle : IPlatformNativeSurfaceHandle + public class SurfacePlatformHandle : INativeHandlePlatformSurface { private readonly X11Window _owner; diff --git a/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs b/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs new file mode 100644 index 0000000000..96b8e9759a --- /dev/null +++ b/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs @@ -0,0 +1,76 @@ +using System; +using System.Collections.Generic; +using Avalonia.Vulkan; +using Avalonia.Platform; +using Avalonia.Rendering; +using SkiaSharp; + +namespace Avalonia.Skia.Vulkan; + +internal class VulkanSkiaGpu : ISkiaGpu +{ + public IVulkanPlatformGraphicsContext Vulkan { get; private set; } + public GRContext GrContext { get; private set; } + + public VulkanSkiaGpu(IVulkanPlatformGraphicsContext vulkan, long? maxResourceBytes) + { + Vulkan = vulkan; + var device = vulkan.Device; + using (Vulkan.EnsureCurrent()) + { + IntPtr GetProcAddressWrapper(string name, IntPtr instance, IntPtr device) + { + if (device != IntPtr.Zero) + { + var addr = Vulkan.Instance.GetDeviceProcAddress(device, name); + if (addr != IntPtr.Zero) + return addr; + } + + if (instance != IntPtr.Zero) + { + var addr = Vulkan.Instance.GetInstanceProcAddress(instance, name); + if (addr != IntPtr.Zero) + return addr; + } + + return Vulkan.Instance.GetInstanceProcAddress(IntPtr.Zero, name); + } + + var ctx = new GRVkBackendContext + { + VkInstance = device.Instance.Handle, + VkPhysicalDevice = device.PhysicalDeviceHandle, + VkDevice = device.Handle, + VkQueue = device.MainQueueHandle, + GraphicsQueueIndex = device.GraphicsQueueFamilyIndex, + GetProcedureAddress = GetProcAddressWrapper + }; + + GrContext = GRContext.CreateVulkan(ctx) ?? + throw new VulkanException("Unable to create GrContext from IVulkanDevice"); + + if (maxResourceBytes.HasValue) + GrContext.SetResourceCacheLimit(maxResourceBytes.Value); + } + } + + public void Dispose() + { + Vulkan.Dispose(); + } + + public object TryGetFeature(Type featureType) => null; + public bool IsLost => Vulkan.IsLost; + public IDisposable EnsureCurrent() => Vulkan.EnsureCurrent(); + + + public ISkiaGpuRenderTarget TryCreateRenderTarget(IEnumerable surfaces) + { + var target = Vulkan.CreateRenderTarget(surfaces); + return new VulkanSkiaRenderTarget(this, target); + } + + + public ISkiaSurface TryCreateSurface(PixelSize size, ISkiaGpuRenderSession session) => null; +} \ No newline at end of file diff --git a/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaRenderTarget.cs b/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaRenderTarget.cs new file mode 100644 index 0000000000..dbff86e762 --- /dev/null +++ b/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaRenderTarget.cs @@ -0,0 +1,104 @@ +using System; +using Avalonia.Skia.Helpers; +using Avalonia.Vulkan; +using SkiaSharp; + +namespace Avalonia.Skia.Vulkan; + +class VulkanSkiaRenderTarget : ISkiaGpuRenderTarget +{ + private readonly VulkanSkiaGpu _gpu; + private readonly IVulkanRenderTarget _target; + + public VulkanSkiaRenderTarget(VulkanSkiaGpu gpu, IVulkanRenderTarget target) + { + _gpu = gpu; + _target = target; + } + + public void Dispose() + { + _target.Dispose(); + } + + public ISkiaGpuRenderSession BeginRenderingSession() + { + var session = _target.BeginDraw(); + bool success = false; + try + { + var size = session.Size; + var scaling = session.Scaling; + if (size.Width <= 0 || size.Height <= 0 || scaling < 0) + { + session.Dispose(); + throw new InvalidOperationException( + $"Can't create drawing context for surface with {size} size and {scaling} scaling"); + } + _gpu.GrContext.ResetContext(); + var imageInfo = new GRVkImageInfo + { + CurrentQueueFamily = _gpu.Vulkan.Device.GraphicsQueueFamilyIndex, + Format = session.ImageFormat, + Image = (ulong)session.ImageHandle, + ImageLayout = session.ImageLayout, + ImageTiling = session.ImageTiling, + ImageUsageFlags = session.ImageUsageFlags, + LevelCount = session.LevelCount, + SampleCount = 1, + Protected = false, + Alloc = new GRVkAlloc + { + Memory = (ulong)session.ImageMemoryHandle, + Size = session.ImageMemorySize + } + }; + using var renderTarget = new GRBackendRenderTarget(size.Width, size.Height, 1, imageInfo); + var surface = SKSurface.Create(_gpu.GrContext, renderTarget, + session.IsYFlipped ? GRSurfaceOrigin.TopLeft : GRSurfaceOrigin.BottomLeft, + session.IsRgba ? SKColorType.Rgba8888 : SKColorType.Bgra8888, SKColorSpace.CreateSrgb()); + + if (surface == null) + throw new InvalidOperationException( + $"Surface can't be created with the provided render target"); + success = true; + return new VulkanSkiaRenderSession(_gpu.GrContext, surface, session); + } + finally + { + if(!success) + session.Dispose(); + } + } + + public bool IsCorrupted => false; + + + internal class VulkanSkiaRenderSession : ISkiaGpuRenderSession + { + private readonly IVulkanRenderSession _vulkanSession; + + public VulkanSkiaRenderSession(GRContext grContext, + SKSurface surface, + IVulkanRenderSession vulkanSession) + { + GrContext = grContext; + SkSurface = surface; + _vulkanSession = vulkanSession; + SurfaceOrigin = vulkanSession.IsYFlipped ? GRSurfaceOrigin.TopLeft : GRSurfaceOrigin.BottomLeft; + } + + public void Dispose() + { + SkSurface.Canvas.Flush(); + SkSurface.Dispose(); + GrContext.Flush(); + _vulkanSession.Dispose(); + } + + public GRContext GrContext { get; } + public SKSurface SkSurface { get; } + public double ScaleFactor => _vulkanSession.Scaling; + public GRSurfaceOrigin SurfaceOrigin { get; } + } +} \ No newline at end of file diff --git a/src/Skia/Avalonia.Skia/PlatformRenderInterface.cs b/src/Skia/Avalonia.Skia/PlatformRenderInterface.cs index b202b60cdf..3dd86b0267 100644 --- a/src/Skia/Avalonia.Skia/PlatformRenderInterface.cs +++ b/src/Skia/Avalonia.Skia/PlatformRenderInterface.cs @@ -11,6 +11,8 @@ using Avalonia.OpenGL; using Avalonia.OpenGL.Imaging; using Avalonia.Platform; using Avalonia.Media.Imaging; +using Avalonia.Skia.Vulkan; +using Avalonia.Vulkan; using SkiaSharp; namespace Avalonia.Skia @@ -37,6 +39,8 @@ namespace Avalonia.Skia return new SkiaContext(skiaGpu); if (graphicsContext is IGlContext gl) return new SkiaContext(new GlSkiaGpu(gl, _maxResourceBytes)); + if (graphicsContext is IVulkanPlatformGraphicsContext vulkanContext) + return new SkiaContext(new VulkanSkiaGpu(vulkanContext, _maxResourceBytes)); throw new ArgumentException("Graphics context of type is not supported"); } diff --git a/src/Windows/Avalonia.Win32/WindowImpl.cs b/src/Windows/Avalonia.Win32/WindowImpl.cs index b2ce68ee83..0858455d2f 100644 --- a/src/Windows/Avalonia.Win32/WindowImpl.cs +++ b/src/Windows/Avalonia.Win32/WindowImpl.cs @@ -26,6 +26,7 @@ using static Avalonia.Win32.Interop.UnmanagedMethods; using Avalonia.Collections.Pooled; using Avalonia.Metadata; using Avalonia.Platform.Storage; +using Avalonia.Platform.Surfaces; using Avalonia.Win32.DirectX; using Avalonia.Win32.OpenGl.Angle; @@ -503,7 +504,7 @@ namespace Avalonia.Win32 } } - public IEnumerable Surfaces => new object[] { (IPlatformNativeSurfaceHandle)Handle, _gl, _framebuffer }; + public IEnumerable Surfaces => new object[] { Handle, _gl, _framebuffer }; public PixelPoint Position { @@ -1468,7 +1469,7 @@ namespace Avalonia.Win32 public IStorageProvider StorageProvider { get; } - private class WindowImplPlatformHandle : IPlatformNativeSurfaceHandle + private class WindowImplPlatformHandle : INativeHandlePlatformSurface { private readonly WindowImpl _owner; public WindowImplPlatformHandle(WindowImpl owner) => _owner = owner;