Vulkan(0)搭建环境-清空窗口
认识Vulkan
Vulkan是新一代3D图形API，它继承了OpenGL的优点，弥补了OpenGL的缺憾。有点像科创板之于主板，歼20之于歼10，微信之于QQ，网店之于实体店，今日之于昨日。
使用OpenGL时，每次drawcall都需要向OpenGL提交很多数据。而Vulkan可以提前将这些drawcall指令保存到一个buffer（像保存顶点数据到buffer一样），这样就减少了很多开销。
使用OpenGL时，OpenGL的Context会包含很多你并不打算使用的东西，例如线的宽度、混合等。而Vulkan不会提供这些你用不到的东西，你需要什么，你来指定。（当然，你不指定，Vulkan不会自动地提供）
Vulkan还支持多线程，OpenGL这方面就不行了。
Vulkan对GPU的抽象比OpenGL更加细腻。
搭建环境
本文和本系列都将使用C#和Visual Studio 2017来学习使用Vulkan。
首先，在官网（https://vulkan.lunarg.com）下载vulkan-sdk.exe和vulkan-runtime.exe。完后安装。vulkan-runtime.exe也可以在（https://files.cnblogs.com/files/bitzhuwei/vulkan-runtime.rar）下载。vulkan-sdk.exe太大，我就不提供下载了。
然后，下载Vulkan.net库（https://github.com/bitzhuwei/Vulkan.net）。这是本人搜罗整理来的一个Vulkan库，外加一些示例代码。用VS2017打开Vulkan.sln，在这个解决方案下就可以学习使用Vulkan了。
如果读者在Github上的下载速度太慢，可以试试将各个文件单独点开下载。这很笨，但也是个办法。
简单介绍下此解决方案。
Vulkan文件夹下的Vulkan.csproj是对Vulkan API的封装。Vulkan使用了大量的struct、enum，这与OpenGL类似。
Vulkan.Platforms文件夹下的Vulkan.Platforms.csproj是平台相关的一些API。
Lesson01Clear文件夹下的是第一个示例，展示了Vulkan清空窗口的代码。以后会逐步添加更多的示例。
有了这个库，读者就可以运行示例程序，一点点地读代码，慢慢理解Vulkan了。这也是本人用的最多的学习方法。遇到不懂的就上网搜索，毕竟我没有别人可以问。
这个库还很不成熟，以后会有大的改动。但这不妨碍学习，反而是学习的好资料，在变动的过程中方能体会软件工程的精髓。
清空窗口
用Vulkan写个清空窗口的程序，就像是用C写个hello world。
外壳
新建Windows窗体应用程序。
添加对类库Vulkan和Vulkan.Platforms的引用：
添加此项目的核心类型LessonClear。Vulkan需要初始化(Init)一些东西，在每次渲染时，渲染(Render)一些东西。
namespace Lesson01Clear {
unsafe class LessonClear {
bool isInitialized = false;
public void Init() {
if (this.isInitialized) { return; }
this.isInitialized = true;
}
public void Render() {
if (!isInitialized) return;
}
}
}
添加一个User Control，用以调用LessonClear。
namespace Lesson01Clear {
public partial class UCClear : UserControl {
LessonClear lesson;
public UCClear() {
InitializeComponent();
}
protected override void OnLoad(EventArgs e) {
base.OnLoad(e);
this.lesson = new LessonClear();
this.lesson.Init();
}
protected override void OnPaintBackground(PaintEventArgs e) {
var lesson = this.lesson;
if (lesson != null) {
lesson.Render();
}
}
}
}
在主窗口中添加一个自定义控件UCClear。这样，在窗口启动时，就会自动执行LessonClear的初始化和渲染功能了。
此时的解决方案如下：
初始化
要初始化的东西比较多，我们一项一项来看。
VkInstance
在LessonClear中添加成员变量VkInstance vkIntance，在InitInstance()函数中初始化它。
unsafe class LessonClear {
VkInstance vkIntance;
bool isInitialized = false;
public void Init() {
if (this.isInitialized) { return; }
this.vkIntance = InitInstance();
this.isInitialized = true;
}
private VkInstance InitInstance() {
VkLayerProperties[] layerProperties;
Layer.EnumerateInstanceLayerProperties(out layerProperties);
string[] layersToEnable = layerProperties.Any(l => StringHelper.ToStringAnsi(l.LayerName) == "VK_LAYER_LUNARG_standard_validation")
? new[] { "VK_LAYER_LUNARG_standard_validation" }
: new string[];
var appInfo = new VkApplicationInfo();
{
appInfo.SType = VkStructureType.ApplicationInfo;
uint version = Vulkan.Version.Make(, , );
appInfo.ApiVersion = version;
}
var extensions = new string[] { "VK_KHR_surface", "VK_KHR_win32_surface", "VK_EXT_debug_report" };
var info = new VkInstanceCreateInfo();
{
info.SType = VkStructureType.InstanceCreateInfo;
extensions.Set(ref info.EnabledExtensionNames, ref info.EnabledExtensionCount);
layersToEnable.Set(ref info.EnabledLayerNames, ref info.EnabledLayerCount);
info.ApplicationInfo = (IntPtr)(&appInfo);
}
VkInstance result;
VkInstance.Create(ref info, null, out result).Check();
return result;
}
}
VkInstance的extension和layer是什么，一时难以说清，先不管。VkInstance像是一个缓存，它根据用户提供的参数，准备好了用户可能要用的东西。在创建VkInstance时，我明显感到程序卡顿了1秒。如果用户稍后请求的东西在缓存中，VkInstance就立即提供给他；如果不在，VkInstance就不给，并抛出VkResult。
以“Vk”开头的一般是Vulkan的结构体，或者对某种Vulkan对象的封装。
VkInstance就是一个对Vulkan对象的封装。创建一个VkInstance对象时，Vulkan的API只会返回一个 IntPtr 指针。在本库中，用一个class VkInstance将其封装起来，以便使用。
创建一个VkInstance对象时，需要我们提供给Vulkan API一个对应的 VkInstanceCreateInfo 结构体。这个结构体包含了创建VkInstance所需的各种信息，例如我们想让这个VkInstance支持哪些extension、哪些layer等。对于extension，显然，这必须用一个数组指针IntPtr和extension的总数来描述。
public struct VkInstanceCreateInfo {
public VkStructureType SType;
public IntPtr Next;
public UInt32 Flags;
public IntPtr ApplicationInfo;
public UInt32 EnabledLayerCount;
public IntPtr EnabledLayerNames;
public UInt32 EnabledExtensionCount; // 数组元素的数量
public IntPtr EnabledExtensionNames; // 数组指针
}
这样的情况在Vulkan十分普遍，所以本库提供一个扩展方法来执行这一操作：
/// <summary>
/// Set an array of structs to specified <paramref name="target"/> and <paramref name="count"/>.
/// <para>Enumeration types are not allowed to use this method.
/// If you have to, convert them to byte/short/ushort/int/uint according to their underlying types first.</para>
/// </summary>
/// <param name="value"></param>
/// <param name="target">address of first element/array.</param>
/// <param name="count">How many elements?</param>
public static void Set<T>(this T[] value, ref IntPtr target, ref UInt32 count) where T : struct {
{ // free unmanaged memory.
if (target != IntPtr.Zero) {
Marshal.FreeHGlobal(target);
target = IntPtr.Zero;
count = ;
}
}
{
count = (UInt32)value.Length; int elementSize = Marshal.SizeOf<T>();
int byteLength = (int)(count * elementSize);
IntPtr array = Marshal.AllocHGlobal(byteLength);
var dst = (byte*)array;
GCHandle pin = GCHandle.Alloc(value, GCHandleType.Pinned);
IntPtr address = Marshal.UnsafeAddrOfPinnedArrayElement(value, );
var src = (byte*)address;
for (int i = ; i < byteLength; i++) {
dst[i] = src[i];
}
pin.Free(); target = array;
}
}
这个Set<T>()函数的核心作用是：在非托管内存上创建一个数组，将托管内存中的数组T[] value中的数据复制过去，然后，记录非托管内存中的数组的首地址(target)和元素数量(count)。当然，如果这不是第一次让target记录非托管内存中的某个数组，那就意味着首先应当将target指向的数组释放掉。
如果这里的T是枚举类型， Marshal.SizeOf() 会抛出异常，所以，必须先将枚举数组转换为 byte/short/ushort/int/uint 类型的数组。至于Marshal.SizeOf为什么会抛异常，我也不知道。
如果这里的T是string，那么必须用另一个变种函数代替：
/// <summary>
/// Set an array of strings to specified <paramref name="target"/> and <paramref name="count"/>.
/// </summary>
/// <param name="value"></param>
/// <param name="target">address of first element/array.</param>
/// <param name="count">How many elements?</param>
public static void Set(this string[] value, ref IntPtr target, ref UInt32 count) {
{ // free unmanaged memory.
var pointer = (IntPtr*)(target.ToPointer());
if (pointer != null) {
for (int i = ; i < count; i++) {
Marshal.FreeHGlobal(pointer[i]);
}
}
}
{
int length = value.Length;
if (length > ) {
int elementSize = Marshal.SizeOf(typeof(IntPtr));
int byteLength = (int)(length * elementSize);
IntPtr array = Marshal.AllocHGlobal(byteLength);
IntPtr* pointer = (IntPtr*)array.ToPointer();
for (int i = ; i < length; i++) {
IntPtr str = Marshal.StringToHGlobalAnsi(value[i]);
pointer[i] = str;
}
target = array;
}
count = (UInt32)length;
}
}
public static void Set(this string[] value, ref IntPtr target, ref UInt32 count)
实现和解释起来略显复杂，但使用起来十分简单：
var extensions = new string[] { "VK_KHR_surface", "VK_KHR_win32_surface", "VK_EXT_debug_report" };
extensions.Set(ref info.EnabledExtensionNames, ref info.EnabledExtensionCount);
var layersToEnable = new[] { "VK_LAYER_LUNARG_standard_validation" };
layersToEnable.Set(ref info.EnabledLayerNames, ref info.EnabledLayerCount);
在后续创建其他Vulkan对象时，我们将多次使用这一方法。
创建VkInstance的内部过程，就是调用Vulkan API的问题：
namespace Vulkan {
public unsafe partial class VkInstance : IDisposable {
public readonly IntPtr handle;
private readonly UnmanagedArray<VkAllocationCallbacks> callbacks;
public static VkResult Create(ref VkInstanceCreateInfo createInfo, UnmanagedArray<VkAllocationCallbacks> callbacks, out VkInstance instance) {
VkResult result = VkResult.Success;
var handle = new IntPtr();
VkAllocationCallbacks* pAllocator = callbacks != null ? (VkAllocationCallbacks*)callbacks.header : null;
fixed (VkInstanceCreateInfo* pCreateInfo = &createInfo) {
vkAPI.vkCreateInstance(pCreateInfo, pAllocator, &handle).Check();
}
instance = new VkInstance(callbacks, handle);
return result;
}
private VkInstance(UnmanagedArray<VkAllocationCallbacks> callbacks, IntPtr handle) {
this.callbacks = callbacks;
this.handle = handle;
}
public void Dispose() {
VkAllocationCallbacks* pAllocator = callbacks != null ? (VkAllocationCallbacks*)callbacks.header : null;
vkAPI.vkDestroyInstance(this.handle, pAllocator);
}
}
class vkAPI {
const string VulkanLibrary = "vulkan-1";
[DllImport(VulkanLibrary, CallingConvention = CallingConvention.Winapi)]
internal static unsafe extern VkResult vkCreateInstance(VkInstanceCreateInfo* pCreateInfo, VkAllocationCallbacks* pAllocator, IntPtr* pInstance);
[DllImport(VulkanLibrary, CallingConvention = CallingConvention.Winapi)]
internal static unsafe extern void vkDestroyInstance(IntPtr instance, VkAllocationCallbacks* pAllocator);
}
}
在 public static VkResult Create(ref VkInstanceCreateInfo createInfo, UnmanagedArray<VkAllocationCallbacks> callbacks, out VkInstance instance); 函数中：
第一个参数用ref标记，是因为这样就会强制程序员提供一个 VkInstanceCreateInfo 结构体。如果改用 VkInstanceCreateInfo* ，那么程序员就有可能提供一个null指针，这对于Vulkan API的 vkCreateInstance() 是没有应用意义的。
对第二个参数提供null指针是有应用意义的，但是，如果用 VkAllocationCallbacks* ，那么此参数指向的对象仍旧可能位于托管内存中（从而，在后续阶段，其位置有可能被GC改变）。用 UnmanagedArray<VkAllocationCallbacks> 就可以保证它位于非托管内存。
对于第三个参数，之所以让它用out标记（而不是放到返回值上），是因为 vkCreateInstance() 的返回值是 VkResult 。这样写，可以保持代码的风格与Vulkan一致。如果以后需要用切面编程之类的的方式添加log等功能，这样的一致性就会带来便利。
在函数中声明的结构体变量（例如这里的 var handle = new IntPtr(); ），可以直接取其地址（ &handle ）。
创建VkInstance的方式方法流程，与创建其他Vulkan对象的方式方法流程是极其相似的。读者可以触类旁通。
VkSurfaceKhr
在LessonClear中添加成员变量VkSurfaceKhr vkSurface，在InitSurface()函数中初始化它。
namespace Lesson01Clear {
unsafe class LessonClear {
VkInstance vkIntance;
VkSurfaceKhr vkSurface;
bool isInitialized = false;
public void Init(IntPtr hwnd, IntPtr processHandle) {
if (this.isInitialized) { return; }
this.vkIntance = InitInstance();
this.vkSurface = InitSurface(this.vkIntance, hwnd, processHandle);
this.isInitialized = true;
}
private VkSurfaceKhr InitSurface(VkInstance instance, IntPtr hwnd, IntPtr processHandle) {
var info = new VkWin32SurfaceCreateInfoKhr {
SType = VkStructureType.Win32SurfaceCreateInfoKhr,
Hwnd = hwnd, // handle of User Control.
Hinstance = processHandle, //Process.GetCurrentProcess().Handle
};
return instance.CreateWin32SurfaceKHR(ref info, null);
}
}
}
可见，VkSurfaceKhr的创建与VkInstance遵循同样的模式，只是CreateInfo内容比较少。VkSurfaceKhr需要知道窗口句柄和进程句柄，这样它才能渲染到相应的窗口/控件上。
VkPhysicalDevice
这里的物理设备指的就是我们的计算机上的GPU了。
namespace Lesson01Clear {
unsafe class LessonClear {
VkInstance vkIntance;
VkSurfaceKhr vkSurface;
VkPhysicalDevice vkPhysicalDevice;
bool isInitialized = false;
public void Init(IntPtr hwnd, IntPtr processHandle) {
if (this.isInitialized) { return; }
this.vkIntance = InitInstance();
this.vkSurface = InitSurface(this.vkIntance, hwnd, processHandle);
this.vkPhysicalDevice = InitPhysicalDevice();
this.isInitialized = true;
}
private VkPhysicalDevice InitPhysicalDevice() {
VkPhysicalDevice[] physicalDevices;
this.vkIntance.EnumeratePhysicalDevices(out physicalDevices);
return physicalDevices[];
}
}
}
创建VkPhysicalDivice对象不需要Callback：
namespace Vulkan {
public unsafe partial class VkPhysicalDevice {
public readonly IntPtr handle;
public static VkResult Enumerate(VkInstance instance, out VkPhysicalDevice[] physicalDevices) {
if (instance == null) { physicalDevices = null; return VkResult.Incomplete; }
UInt32 count;
VkResult result = vkAPI.vkEnumeratePhysicalDevices(instance.handle, &count, null).Check();
var handles = stackalloc IntPtr[(int)count];
if (count > ) {
result = vkAPI.vkEnumeratePhysicalDevices(instance.handle, &count, handles).Check();
}
physicalDevices = new VkPhysicalDevice[count];
for (int i = ; i < count; i++) {
physicalDevices[i] = new VkPhysicalDevice(handles[i]);
}
return result;
}
private VkPhysicalDevice(IntPtr handle) {
this.handle = handle;
}
}
}
在函数中声明的变量（例如这里的 var handle = new IntPtr(); ），可以直接取其地址（ &handle ）。
但是在函数中声明的数组，数组本身是在堆中的，不能直接取其地址。为了能够取其地址，可以用（ var handles = stackalloc IntPtr[(int)count]; ）这样的方式，这会将数组本身创建到函数自己的栈空间，从而可以直接取其地址了。
VkDevice
这个设备是对物理设备的缓存\抽象\接口，我们想使用物理设备的哪些功能，就在CreateInfo中指定，然后创建VkDevice。（不指定的功能，以后就无法使用。）后续各种对象，都是用VkDevice创建的。
namespace Lesson01Clear {
unsafe class LessonClear {
VkInstance vkIntance;
VkSurfaceKhr vkSurface;
VkPhysicalDevice vkPhysicalDevice;
VkDevice vkDevice;
bool isInitialized = false;
public void Init(IntPtr hwnd, IntPtr processHandle) {
if (this.isInitialized) { return; }
this.vkIntance = InitInstance();
this.vkSurface = InitSurface(this.vkIntance, hwnd, processHandle);
this.vkPhysicalDevice = InitPhysicalDevice();
VkSurfaceFormatKhr surfaceFormat = SelectFormat(this.vkPhysicalDevice, this.vkSurface);
VkSurfaceCapabilitiesKhr surfaceCapabilities;
this.vkPhysicalDevice.GetSurfaceCapabilitiesKhr(this.vkSurface, out surfaceCapabilities);
this.vkDevice = InitDevice(this.vkPhysicalDevice, this.vkSurface);
this.isInitialized = true;
}
private VkDevice InitDevice(VkPhysicalDevice physicalDevice, VkSurfaceKhr surface) {
VkQueueFamilyProperties[] properties = physicalDevice.GetQueueFamilyProperties();
uint index;
for (index = ; index < properties.Length; ++index) {
VkBool32 supported;
physicalDevice.GetSurfaceSupportKhr(index, surface, out supported);
if (!supported) { continue; }
if (properties[index].QueueFlags.HasFlag(VkQueueFlags.QueueGraphics)) break;
}
var queueInfo = new VkDeviceQueueCreateInfo();
{
queueInfo.SType = VkStructureType.DeviceQueueCreateInfo;
new float[] { 1.0f }.Set(ref queueInfo.QueuePriorities, ref queueInfo.QueueCount);
queueInfo.QueueFamilyIndex = index;
}
var deviceInfo = new VkDeviceCreateInfo();
{
deviceInfo.SType = VkStructureType.DeviceCreateInfo;
new string[] { "VK_KHR_swapchain" }.Set(ref deviceInfo.EnabledExtensionNames, ref deviceInfo.EnabledExtensionCount);
new VkDeviceQueueCreateInfo[] { queueInfo }.Set(ref deviceInfo.QueueCreateInfos, ref deviceInfo.QueueCreateInfoCount);
}
VkDevice device;
physicalDevice.CreateDevice(ref deviceInfo, null, out device);
return device;
}
}
}
后续的Queue、Swapchain、Image、RenderPass、Framebuffer、Fence和Semaphore等都不再一一介绍，毕竟都是十分类似的创建过程。
最后只介绍一下VkCommandBuffer。
VkCommandBuffer
Vulkan可以将很多渲染指令保存到buffer，将buffer一次性上传到GPU内存，这样以后每次调用它即可，不必重复提交这些数据了。
namespace Lesson01Clear {
unsafe class LessonClear {
VkInstance vkIntance;
VkSurfaceKhr vkSurface;
VkPhysicalDevice vkPhysicalDevice;
VkDevice vkDevice;
VkQueue vkQueue;
VkSwapchainKhr vkSwapchain;
VkImage[] vkImages;
VkRenderPass vkRenderPass;
VkFramebuffer[] vkFramebuffers;
VkFence vkFence;
VkSemaphore vkSemaphore;
VkCommandBuffer[] vkCommandBuffers;
bool isInitialized = false;
public void Init(IntPtr hwnd, IntPtr processHandle) {
if (this.isInitialized) { return; }
this.vkIntance = InitInstance();
this.vkSurface = InitSurface(this.vkIntance, hwnd, processHandle);
this.vkPhysicalDevice = InitPhysicalDevice();
VkSurfaceFormatKhr surfaceFormat = SelectFormat(this.vkPhysicalDevice, this.vkSurface);
VkSurfaceCapabilitiesKhr surfaceCapabilities;
this.vkPhysicalDevice.GetSurfaceCapabilitiesKhr(this.vkSurface, out surfaceCapabilities);
this.vkDevice = InitDevice(this.vkPhysicalDevice, this.vkSurface);
this.vkQueue = this.vkDevice.GetDeviceQueue(, );
this.vkSwapchain = CreateSwapchain(this.vkDevice, this.vkSurface, surfaceFormat, surfaceCapabilities);
this.vkImages = this.vkDevice.GetSwapchainImagesKHR(this.vkSwapchain);
this.vkRenderPass = CreateRenderPass(this.vkDevice, surfaceFormat);
this.vkFramebuffers = CreateFramebuffers(this.vkDevice, this.vkImages, surfaceFormat, this.vkRenderPass, surfaceCapabilities);
var fenceInfo = new VkFenceCreateInfo() { SType = VkStructureType.FenceCreateInfo };
this.vkFence = this.vkDevice.CreateFence(ref fenceInfo);
var semaphoreInfo = new VkSemaphoreCreateInfo() { SType = VkStructureType.SemaphoreCreateInfo };
this.vkSemaphore = this.vkDevice.CreateSemaphore(ref semaphoreInfo);
this.vkCommandBuffers = CreateCommandBuffers(this.vkDevice, this.vkImages, this.vkFramebuffers, this.vkRenderPass, surfaceCapabilities);
this.isInitialized = true;
}
VkCommandBuffer[] CreateCommandBuffers(VkDevice device, VkImage[] images, VkFramebuffer[] framebuffers, VkRenderPass renderPass, VkSurfaceCapabilitiesKhr surfaceCapabilities) {
var createPoolInfo = new VkCommandPoolCreateInfo {
SType = VkStructureType.CommandPoolCreateInfo,
Flags = VkCommandPoolCreateFlags.ResetCommandBuffer
};
var commandPool = device.CreateCommandPool(ref createPoolInfo);
var commandBufferAllocateInfo = new VkCommandBufferAllocateInfo {
SType = VkStructureType.CommandBufferAllocateInfo,
Level = VkCommandBufferLevel.Primary,
CommandPool = commandPool.handle,
CommandBufferCount = (uint)images.Length
};
VkCommandBuffer[] buffers = device.AllocateCommandBuffers(ref commandBufferAllocateInfo);
for (int i = ; i < images.Length; i++) {
var commandBufferBeginInfo = new VkCommandBufferBeginInfo() {
SType = VkStructureType.CommandBufferBeginInfo
};
buffers[i].Begin(ref commandBufferBeginInfo);
{
var renderPassBeginInfo = new VkRenderPassBeginInfo();
{
renderPassBeginInfo.SType = VkStructureType.RenderPassBeginInfo;
renderPassBeginInfo.Framebuffer = framebuffers[i].handle;
renderPassBeginInfo.RenderPass = renderPass.handle;
new VkClearValue[] { new VkClearValue { Color = new VkClearColorValue(0.9f, 0.7f, 0.0f, 1.0f) } }.Set(ref renderPassBeginInfo.ClearValues, ref renderPassBeginInfo.ClearValueCount);
renderPassBeginInfo.RenderArea = new VkRect2D {
Extent = surfaceCapabilities.CurrentExtent
};
};
buffers[i].CmdBeginRenderPass(ref renderPassBeginInfo, VkSubpassContents.Inline);
{
// nothing to do in this lesson.
}
buffers[i].CmdEndRenderPass();
}
buffers[i].End();
}
return buffers;
}
}
}
本例中的VkClearValue用于指定背景色，这里指定了黄色，运行效果如下：
总结
如果看不懂本文，就去看代码，运行代码，再来看本文。反反复复看，总会懂。