Learn_Vulkan00_第一个三角形

//创建
VkXxxCreateInfo createInfo{};
if(VK_SUCCESS != vkCreateXxx(&createInfo, nullptr, &xxx)){
    Error("Failed to create xxx.");
}
//销毁
vkDestroyXxx(xxx, nullptr);

uint32_t xxxCount;
vkEnumerateXxx(&xxxCount, nullptr);
VkXxx xxxArr[xxxCount];
vkEnumerateXxx(&xxxCount, xxxArr);

//申请内存
VkMemoryAllocateInfo memAllocateInfo = {
        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
        .allocationSize = n,
        .memoryTypeIndex = index
};
vkAllocateMemory(device, &memAllocateInfo, nullptr, &xxxMemo));

//释放内存
vkFreeMemory(vk.device, &xxxMemo, nullptr);

vkBeginXxx();
...
...
vkEndXxx();

00_hello_triangle/
|-- CMakeLists.txt
`-- src
    |-- Main.cpp				// 程序入口
    |-- VkBundle.h				// Vulkan对象维护
    |-- VkHelper.cpp			// Vulkan API调用工具类实现
    |-- VkHelper.h				// Vulkan API调用工具类定义
    `-- VulkanCommon.h			// 公用的宏和工具函数

1 directory, 6 files

#include "VulkanCommon.h"

struct VkBundle {
	VkInstance instance;
    ...
    ...
};

#include "VulkanCommon.h"

class VkHelper {
public:
    /** create Vulkan Instance */
    static void createInstance(bool bValidate, VkInstance *out_instance, VkDebugReportCallbackEXT *out_debugReport);
};

cmake_minimum_required(VERSION 3.24)
project(00_hello_triangle)

set(CMAKE_CXX_STANDARD 17)

# 定义平台为Windows
# VK_USE_PLATFORM_WIN32_KHR -> Windows
# VK_USE_PLATFORM_ANDROID_KHR -> 安卓
# ...
add_definitions(-DVK_USE_PLATFORM_WIN32_KHR)

# Vulkan
find_package(Vulkan REQUIRED)
if(Vulkan_FOUND)
    message("Find vulkan success!")
    include_directories(${Vulkan_INCLUDE_DIRS})
endif()

# 如果没有配置寻找cmake path环境变量，可以使用这种临时方案找到对应包
#set(glfw3_DIR "C:/Program Files (x86)/GLFW/lib/cmake/glfw3")
#set(glfw3_INCLUDE_DIRS "C:/Program Files (x86)/GLFW/include")
#set(glfw3_LIBRARY "C:/Program Files (x86)/GLFW/lib/libglfw3.a")

# GLFW3
find_package(glfw3 REQUIRED)
if(glfw3_FOUND)
    message("Find glfw3 success!")
    include_directories(${glfw3_INCLUDE_DIRS})
endif()

add_executable(
        ${PROJECT_NAME}
        src/VulkanCommon.h
        src/Main.cpp
        src/VkBundle.h
        src/VkHelper.cpp
        src/VkHelper.h
)

target_link_libraries(${PROJECT_NAME} PUBLIC ${Vulkan_LIBRARY} ${glfw3_LIBRARY})

...
...
#define VK_ALLOC nullptr
#define APP_NAME "Learn Vulkan"
...
...
#ifndef Print
#define Print(...) ((void)my_debug(DBG, __VA_ARGS__))
#endif

#ifndef Warn
#define Warn(...) ((void)my_debug(WRN, __VA_ARGS__))
#endif

#ifndef Error
#define Error(...) ((void)my_debug(ERR, __VA_ARGS__))
#endif

static void
vk_check_errors(VkResult result, const char *file_name, const int line_number, const char *function){
    if(VK_SUCCESS != result){
        Error( "[%s, %d]: %s: %s\n", file_name, line_number, function, vk_error_string( result ) );
    }
}
#define CALL_VK(func) vk_check_errors(func, __FILE__, __LINE__, #func);
#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))

#include <iostream>
#include "VkBundle.h"
#include "VkHelper.h"
#include <GLFW/glfw3.h>
#include <limits>

/***** 全局变量 *****/
GLFWwindow *window;
VkBundle vk;
bool canRender;
/***** 全局变量 *****/

void init(){
    //TODO
    //...
    //...
    canRender = true;
}

void render(uint32_t currentFrame){
    if(!canRender) return;
    //TODO
	//...
    //...
}

void renderLoop(){
    uint32_t currentFrame = 0;
    while(true){
		render(currentFrame);
		currentFrame ++;
    }
}

void destroy(){
    Print("%s", __FUNCTION__);
    //vkDestroyXxx(...);
    //TODO
}

int main() {
    std::cout << "Hello, Learn Vulkan!" << std::endl;

    init();
    renderLoop();
    destroy();

    return 0;
}

struct VkBundle{
    VkAbc abc;
}

class VkHelper {
public:
    /** create abc */
    static void createAbc(VkAbc *abc){
        ...
        ...
       	//具体的创建逻辑
    }
};

//全局变量
VkBundle vk;

void init(){
    VkHelper::createAbc(&vk.abc);
}

void destroy(){
    vkDestroyAbc(vk.abc, nullptr);
}

struct VkBundle {
    VkInstance instance;
    VkDebugReportCallbackEXT debugReport;
}

typedef struct
{
    const char      *name;
    bool			validationOnly;
    bool			required;
} DriverFeature;

/**
 * 层/扩展验证
 * @param label 提示名，用作日志输出使用
 * @param validationEnabled 是否启用验证，如果为否，直接跳过
 * @param extensions 是否属于扩展验证，层验证时为false，扩展验证时为true
 * @param requested 待验证列表
 * @param requestedCount 待验证数量
 * @param available 全部的功能列表，从vkEnumerateXxxLayerProperties或vkEnumerateXxxExtensionProperties获取
 * @param availableCount 全部功能数量
 * @param enabledNames 输出的可用功能名称数组
 * @param enabledCount 输出的可用功能数量
 * @return 操作是否成功
 */
static bool
checkFeatures(const char *label, const bool validationEnabled, const bool extensions,
                   const DriverFeature *requested, const uint32_t requestedCount,
                   const void *available, const uint32_t availableCount,
                   const char *enabledNames[], uint32_t *enabledCount){
#if 1		//TODO 这里只是为了调试而打开，可以置为0关闭
    Print("%s available: ", label);
    for(int i = 0; i < availableCount; i++){
        const char * name = extensions ? ((const VkExtensionProperties *)available)[i].extensionName : ((const VkLayerProperties *)available)[i].layerName;
        Print("%s", name);
    }
#endif
    bool foundAllRequired = true;
    *enabledCount = 0;
    for ( uint32_t i = 0; i < requestedCount; i++ )
    {
        bool found = false;
        const char *result = requested[i].required ? "(required, not found)" : "(not found)";
        for ( uint32_t j = 0; j < availableCount; j++ )
        {
            const char * name = extensions ? ((const VkExtensionProperties *)available)[j].extensionName :
                                ((const VkLayerProperties *)available)[j].layerName;
            if ( strcmp( requested[i].name, name ) == 0 )
            {
                found = true;
                if ( requested[i].validationOnly && !validationEnabled )
                {
                    result = "(not enabled)";
                    break;
                }
                enabledNames[(*enabledCount)++] = requested[i].name;
                result = requested[i].required ? "(required, enabled)" : "(enabled)";
                break;
            }
        }
        foundAllRequired &= ( found || !requested[i].required );
        Print( "%-21s%c %s %s", ( i == 0 ? label : "" ), ( i == 0 ? ':' : ' ' ), requested[i].name, result );
    }
    return foundAllRequired;
}

const DriverFeature validation_layers[] = {
        {"VK_LAYER_KHRONOS_validation",    false,     true}
};

void VkHelper::createInstance(bool bValidate, VkInstance *out_instance, VkDebugReportCallbackEXT *out_debugReport) {
    //instance layers
    uint32_t availableLayerCount;
    CALL_VK(vkEnumerateInstanceLayerProperties(&availableLayerCount, nullptr));
    VkLayerProperties availableLayerProps[availableLayerCount];
    CALL_VK(vkEnumerateInstanceLayerProperties(&availableLayerCount, availableLayerProps));
    Print("---------------------------------");
    const char *enabledLayerNames[32] = {};
    uint32_t enabledLayerCount = 0;
    checkFeatures("Instance Layers", bValidate, false, validation_layers, ARRAY_SIZE(validation_layers),
                  availableLayerProps, availableLayerCount, enabledLayerNames, &enabledLayerCount);

    //TODO
}

const DriverFeature validation_extensions[] = {
        {"VK_KHR_surface",    false,     true},
        {"VK_KHR_win32_surface",    false,     true}
};

//instance extensions
uint32_t availableExtensionCount;
CALL_VK(vkEnumerateInstanceExtensionProperties(nullptr, &availableExtensionCount, nullptr));
VkExtensionProperties availableExtensionProps[availableExtensionCount];
CALL_VK(vkEnumerateInstanceExtensionProperties(nullptr, &availableExtensionCount, availableExtensionProps));
Print("---------------------------------");
const char *enableExtensionNames[32] = {};
uint32_t enableExtensionCount = 0;
checkFeatures("Instance Extensions", bValidate, true, validation_extensions, ARRAY_SIZE(validation_extensions),
              availableExtensionProps, availableExtensionCount, enableExtensionNames, &enableExtensionCount);

VkInstanceCreateInfo createInfo = {
        .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .pApplicationInfo = nullptr,
        .enabledLayerCount = enabledLayerCount,
        .ppEnabledLayerNames = enabledLayerCount == 0 ? nullptr : enabledLayerNames,
        .enabledExtensionCount = enableExtensionCount,
        .ppEnabledExtensionNames = enableExtensionCount == 0 ? nullptr : enableExtensionNames
};
CALL_VK(vkCreateInstance(&createInfo, VK_ALLOC, out_instance));

VkApplicationInfo application = {
        .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
        .pNext = nullptr,
        .pApplicationName = APP_NAME,
        .applicationVersion = VK_MAKE_VERSION(1, 0, 0),
        .pEngineName = APP_NAME,
        .engineVersion = VK_MAKE_VERSION(1, 0, 0),
        .apiVersion = VK_VERSION_1_0
};

VkInstanceCreateInfo createInfo = {
        .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .pApplicationInfo = &application,
        .enabledLayerCount = enabledLayerCount,
        .ppEnabledLayerNames = enabledLayerCount == 0 ? nullptr : enabledLayerNames,
        .enabledExtensionCount = enableExtensionCount,
        .ppEnabledExtensionNames = enableExtensionCount == 0 ? nullptr : enableExtensionNames
};

VkBool32 debugReportCallback(VkDebugReportFlagsEXT msgFlags, VkDebugReportObjectTypeEXT objType, uint64_t srcObject, size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg, void *pUserData){
    if(msgFlags == VK_DEBUG_REPORT_ERROR_BIT_EXT){
        Error("%s: [%s] Code %d : %s", "Error", pLayerPrefix, msgCode, pMsg);
    } else if(msgFlags == VK_DEBUG_REPORT_WARNING_BIT_EXT) {
        Warn("%s: [%s] Code %d : %s", "Warning", pLayerPrefix, msgCode, pMsg);
    } else {
        Print("%s: [%s] Code %d : %s", "Info", pLayerPrefix, msgCode, pMsg);
    }
    return VK_FALSE;
}

VkInstanceCreateInfo createInfo = {
	...
    ...
};

//在创建VkInstance之前
if(bValidate){
    VkDebugReportCallbackCreateInfoEXT debugReport = {
        .sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
        .pNext = nullptr,
        .flags = VK_DEBUG_REPORT_ERROR_BIT_EXT |				//错误信息
                 VK_DEBUG_REPORT_WARNING_BIT_EXT |				//警告信息
                 VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,	//性能警告信息
        .pfnCallback = (PFN_vkDebugReportCallbackEXT) debugReportCallback,
        .pUserData = nullptr,
    };
    
    createInfo.pNext = &debugReport;
}

CALL_VK(vkCreateInstance(&createInfo, VK_ALLOC, out_instance));

void init(){
    VkHelper::createInstance(true, &vk.instance, &vk.debugReport);
}

...
...
void destroy(){
    Print("%s", __FUNCTION__);
    vkDestroyInstance(vk.instance, VK_ALLOC);
}

VkInstanceCreateInfo createInfo = {
            .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
            .pNext = nullptr,
            .flags = 0,
            .pApplicationInfo = &application,
            .enabledLayerCount = enabledLayerCount,
            .ppEnabledLayerNames = enabledLayerCount == 0 ? nullptr : enabledLayerNames,
            .enabledExtensionCount = enableExtensionCount,
    		// 更改这里，可以测试验证层是否成功。
            .ppEnabledExtensionNames = nullptr, //enableExtensionCount == 0 ? nullptr : enableExtensionNames
    };
...
...

struct VkBundle {
    VkInstance instance;
    VkDebugReportCallbackEXT debugReport;

    VkSurfaceKHR surface;
}

#define WINDOW_WIDTH 800
#define WINDOW_HEIGHT 600
GLFWwindow *window;

void createWindow(){
    if(!glfwInit()){
        throw std::runtime_error("Can not init glfw window.");
    }
    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE); // 暂时不允许改变大小，改变大小后需要重置交换链，后续demo实现
    window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, APP_NAME, nullptr, nullptr);
    if(!window){
        throw std::runtime_error("Can not create glfw window");
    }

    Print("GLFW Vulkan Support: %d", glfwVulkanSupported());
    glfwMakeContextCurrent(window);

    if(glfwCreateWindowSurface(vk.instance, window, VK_ALLOC, &vk.surface) != VK_SUCCESS){
        throw std::runtime_error("Can not creat surface.");
    }

    Print("surface: %p", vk.surface);
}

void init(){
    VkHelper::createInstance(true, &vk.instance, &vk.debugReport);
    createWindow();
}

void renderLoop(){
    uint32_t currentFrame = 0;
    while(!glfwWindowShouldClose(window)){
        
        glfwPollEvents();

        render(currentFrame);

        glfwSwapBuffers(window);
        currentFrame ++;
    }
}

void destroy(){
    Print("%s", __FUNCTION__);
    vkDestroySurfaceKHR(vk.instance, vk.surface, VK_ALLOC);
    vkDestroyInstance(vk.instance, VK_ALLOC);
    glfwDestroyWindow(window);
    glfwTerminate();
}

struct DeviceInfo {
    VkPhysicalDevice physicalDev;
    VkPhysicalDeviceLimits physicalDevLimits;
    VkPhysicalDeviceMemoryProperties physicalDevMemoProps;
    VkDevice device;
};

struct QueueInfo {
    uint16_t workQueueIndex;
    uint16_t presentQueueIndex;
    VkQueue queue;
};

struct VkBundle {
    ...
    ...
    struct DeviceInfo deviceInfo;
    struct QueueInfo queueInfo;
}

void VkHelper::pickPhyDevAndCreateDev(VkInstance instance, VkSurfaceKHR surface, DeviceInfo *out_deviceInfo, QueueInfo *out_queueInfo) {}

void VkHelper::pickPhyDevAndCreateDev(VkInstance instance, VkSurfaceKHR surface, DeviceInfo *out_deviceInfo, QueueInfo *out_queueInfo) {
    uint32_t physicalDevCount;
    CALL_VK(vkEnumeratePhysicalDevices(instance, &physicalDevCount, nullptr));
    VkPhysicalDevice physicalDevs[physicalDevCount];
    CALL_VK(vkEnumeratePhysicalDevices(instance, &physicalDevCount, physicalDevs));
}

typedef enum VkQueueFlagBits {
    VK_QUEUE_GRAPHICS_BIT = 0x00000001,			// 图形
    VK_QUEUE_COMPUTE_BIT = 0x00000002,			// 计算
    VK_QUEUE_TRANSFER_BIT = 0x00000004,			// 传输
	...
	...
} VkQueueFlagBits;

void VkHelper::printPhysicalDevLog(const VkPhysicalDeviceProperties &devProps) {
    /****************** For log *********************/
    const uint32_t driverMajor = VK_VERSION_MAJOR(devProps.driverVersion);
    const uint32_t driverMinor = VK_VERSION_MINOR(devProps.driverVersion);
    const uint32_t driverPatch = VK_VERSION_PATCH(devProps.driverVersion);

    const uint32_t apiMajor = VK_VERSION_MAJOR(devProps.apiVersion);
    const uint32_t apiMinor = VK_VERSION_MINOR(devProps.apiVersion);
    const uint32_t apiPatch = VK_VERSION_PATCH(devProps.apiVersion);

    Print("---------------------------------");
    Print("Device Name          : %s", devProps.deviceName);
    Print("Device Type          : %s",
          ((devProps.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU) ? "integrated GPU" :
           ((devProps.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) ? "discrete GPU" :
            ((devProps.deviceType == VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU) ? "virtual GPU" :
             ((devProps.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU) ? "CPU" : "unknown")))));
    Print("Vendor ID            : 0x%04X", devProps.vendorID);
    Print("Device ID            : 0x%04X", devProps.deviceID);
    Print("Driver Version       : %d.%d.%d", driverMajor, driverMinor, driverPatch);
    Print("API Version          : %d.%d.%d", apiMajor, apiMinor, apiPatch);
    /****************** For log *********************/
}

void VkHelper::pickPhyDevAndCreateDev(VkInstance instance, VkSurfaceKHR surface, DeviceInfo *out_deviceInfo, QueueInfo *out_queueInfo) {
    ...
    ...
    Print("---------------------------------");
    Print("Physical Devices:");

    //选取的物理设备和队列索引
    VkPhysicalDevice selectedPhysicalDev = nullptr;
    uint16_t workQueueIndex;
    uint16_t presentQueueIndex;

    for(int i = 0; i < physicalDevCount; i++){
        VkPhysicalDeviceProperties devProps;
        vkGetPhysicalDeviceProperties(physicalDevs[i], &devProps);

        //打印Log，不影响流程
        printPhysicalDevLog(devProps);

        uint32_t queueFamilyPropCount;
        vkGetPhysicalDeviceQueueFamilyProperties(physicalDevs[i], &queueFamilyPropCount, nullptr);
        VkQueueFamilyProperties queueFamilyProps[queueFamilyPropCount];
        vkGetPhysicalDeviceQueueFamilyProperties(physicalDevs[i], &queueFamilyPropCount, queueFamilyProps);
        //表面查询支持
        for(int j = 0; j < queueFamilyPropCount; j++){
            VkBool32 surfaceSupport;
            vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevs[i], i, surface, &surfaceSupport);
            Print("Surface Support: %d", surfaceSupport);

            //支持图形渲染管线
            if(surfaceSupport && queueFamilyProps[j].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
                selectedPhysicalDev = physicalDevs[i];
                workQueueIndex = j;
                presentQueueIndex = j;
                break;
            }
        }
    }
    if(nullptr == selectedPhysicalDev){
        throw std::runtime_error("Can not find any suitable Physical device.");
    }
}

void VkHelper::pickPhyDevAndCreateDev(VkInstance instance, VkSurfaceKHR surface, DeviceInfo *out_deviceInfo, QueueInfo *out_queueInfo) {
    ...
    ...
    VkPhysicalDeviceProperties devProps;
    vkGetPhysicalDeviceProperties(selectedPhysicalDev, &devProps);
    out_deviceInfo->physicalDev = selectedPhysicalDev;
    out_deviceInfo->physicalDevLimits = devProps.limits;
    out_queueInfo->workQueueIndex = workQueueIndex;
    out_queueInfo->presentQueueIndex = presentQueueIndex;
    vkGetPhysicalDeviceMemoryProperties(selectedPhysicalDev, &out_deviceInfo->physicalDevMemoProps);
}

const DriverFeature validation_device_extensions[] = {
        {VK_KHR_SWAPCHAIN_EXTENSION_NAME, false, true}
};

void VkHelper::pickPhyDevAndCreateDev(VkInstance instance, VkSurfaceKHR surface, DeviceInfo *out_deviceInfo, QueueInfo *out_queueInfo) {
    ...
	...
    uint32_t availableDeviceExtensionCount;
    CALL_VK(vkEnumerateDeviceExtensionProperties(out_deviceInfo->physicalDev, nullptr, &availableDeviceExtensionCount, nullptr));
    VkExtensionProperties availableDeviceExtensions[availableDeviceExtensionCount];
    CALL_VK(vkEnumerateDeviceExtensionProperties(out_deviceInfo->physicalDev, nullptr, &availableDeviceExtensionCount, availableDeviceExtensions));
    const char *enableDeviceExtensions[32];
    uint32_t enableDeviceExtensionCount;
    checkFeatures("Device Extensions", true, true, validation_device_extensions, ARRAY_SIZE(validation_device_extensions),
                  availableDeviceExtensions, availableDeviceExtensionCount, enableDeviceExtensions, &enableDeviceExtensionCount);
}

void VkHelper::pickPhyDevAndCreateDev(VkInstance instance, VkSurfaceKHR surface, DeviceInfo *out_deviceInfo, QueueInfo *out_queueInfo) {
    ...
    ...
    float queuePriority = 1.0f;
    VkDeviceQueueCreateInfo queueCreateInfo = {
            .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
            .pNext = nullptr,
            .flags = 0,
            .queueFamilyIndex = out_queueInfo->workQueueIndex,
            .queueCount = 1,
            .pQueuePriorities = &queuePriority, //队列优先级
    };
}

void VkHelper::pickPhyDevAndCreateDev(VkInstance instance, VkSurfaceKHR surface, DeviceInfo *out_deviceInfo, QueueInfo *out_queueInfo) {
    ...
    ...
    VkDeviceCreateInfo deviceCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .queueCreateInfoCount = 1,
        .pQueueCreateInfos = &queueCreateInfo,
        .enabledLayerCount = 0,
        .ppEnabledLayerNames = nullptr,
        .enabledExtensionCount = enableDeviceExtensionCount,
        .ppEnabledExtensionNames = enableDeviceExtensionCount == 0 ? nullptr : enableDeviceExtensions
    };
    CALL_VK(vkCreateDevice(out_deviceInfo->physicalDev, &deviceCreateInfo, VK_ALLOC, &out_deviceInfo->device));
}

vkGetDeviceQueue(out_deviceInfo->device, out_queueInfo->workQueueIndex, 0, &out_queueInfo->queue);

void init(){
    ...
    ...
    createWindow();
    VkHelper::pickPhyDevAndCreateDev(vk.instance, vk.surface, &vk.deviceInfo, &vk.queueInfo);
}

void destroy(){
	Print("%s", __FUNCTION__);
    vkDeviceWaitIdle(vk.deviceInfo.device);
    
    vkDestroyDevice(vk.deviceInfo.device, VK_ALLOC);
    vkDestroySurfaceKHR(vk.instance, vk.surface, VK_ALLOC);
    ...
    ...
}

struct VkBundle {
    ...
    ...
	VkCommandPool cmdPool;
}

void VkHelper::createCommandPool(VkDevice device, uint32_t workQueueIndex, VkCommandPool *out_cmdPool) {
 	VkCommandPoolCreateInfo createInfo = {
        .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
        .pNext = nullptr,
        .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
        .queueFamilyIndex = workQueueIndex
    };
    CALL_VK(vkCreateCommandPool(device, &createInfo, VK_ALLOC, out_cmdPool));
}

VkHelper::createCommandPool(vk.deviceInfo.device, vk.queueInfo.workQueueIndex, &vk.cmdPool);

void destroy(){
    ...
    ...
	vkDestroyCommandPool(vk.deviceInfo.device, vk.cmdPool, VK_ALLOC);
    vkDestroyDevice(vk.deviceInfo.device, VK_ALLOC);
    ...
    ...
}

struct SwapchainParam{
    VkSurfaceCapabilitiesKHR capabilities;	//功能
    VkSurfaceFormatKHR format;				//格式
    VkPresentModeKHR presentMode;			//呈现模式
    VkExtent2D extent;						//范围
};

void VkHelper::createSwapchain(VkPhysicalDevice physicalDev, VkDevice device, VkSurfaceKHR surface,
                               uint16_t workQueueIndex, uint16_t presentQueueIndex,
                               SwapchainParam *out_swapchainParam, VkSwapchainKHR *out_swapchain){}

void querySwapchainParam(VkPhysicalDevice physicalDev, VkSurfaceKHR surface, SwapchainParam *out_swapchainParam){
	//capabilities
    CALL_VK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDev, surface, &out_swapchainParam->capabilities));
    out_swapchainParam->extent = out_swapchainParam->capabilities.currentExtent;
    Print("Extent: %d, %d", out_swapchainParam->extent.width, out_swapchainParam->extent.height);
    
    //format
    uint32_t formatCount;
    vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDev, surface, &formatCount, nullptr);
    VkSurfaceFormatKHR formats[formatCount];
    vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDev, surface, &formatCount, formats);
    bool bFindFormat = false;
    if(formatCount == 1 && formats[0].format == VK_FORMAT_UNDEFINED){
        out_swapchainParam->format = {VK_FORMAT_B8G8R8A8_UNORM,   VK_COLORSPACE_SRGB_NONLINEAR_KHR};
        bFindFormat = true;
    }  else {
        for (const auto &item: formats) {
            if(item.format == VK_FORMAT_B8G8R8A8_UNORM && item.colorSpace == VK_COLORSPACE_SRGB_NONLINEAR_KHR){
                out_swapchainParam->format = item;
                bFindFormat = true;
                break;
            }
        }
    }
    if(!bFindFormat){
        out_swapchainParam->format = formats[0];
    }
    
    //present mode
    uint32_t presentModeCount;
    vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDev, surface, &presentModeCount, nullptr);
    VkPresentModeKHR presentModes[presentModeCount];
    vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDev, surface, &presentModeCount, presentModes);

    //VK_PRESENT_MODE_IMMEDIATE_KHR 立即提交，可能导致画面撕裂
    //VK_PRESENT_MODE_FIFO_KHR 先进先出的队列，队列满时需要等待，类似垂直同步
    //VK_PRESENT_MODE_FIFO_RELAXED_KHR 和上一模式的区别是：如果应用程序延迟，导致交换链的队列在上一次垂直回扫时为空， 那么，如果应用程序在下一次垂直回扫前提交图像，图像会立即被显示。这一模式可能会导致撕裂现象。
    //VK_PRESENT_MODE_MAILBOX_KHR 这一模式是第二种模式的另一个变种。它不会在交换链的队列满时阻塞应用程序，队列中的图像会被直接替换为应用程序新提交的图像。这一模式可以用来实现三倍缓冲，避免撕裂现象的同时减小了延迟问题
    bool bFoundPrentMode = false;
    for (const auto &item: presentModes) {
        if(VK_PRESENT_MODE_MAILBOX_KHR == item){
            out_swapchainParam->presentMode = item;
            bFoundPrentMode = true;
        } else if(VK_PRESENT_MODE_IMMEDIATE_KHR == item){ //目前大部分硬件不不支持VK_PRESENT_MODE_MAILBOX_KHR
            out_swapchainParam->presentMode = item;
            bFoundPrentMode = true;
        }
    }
    if(!bFoundPrentMode){
        out_swapchainParam->presentMode = VK_PRESENT_MODE_MAILBOX_KHR;
    }
}

void VkHelper::createSwapchain(VkPhysicalDevice physicalDev, VkDevice device, VkSurfaceKHR surface,
                               uint16_t workQueueIndex, uint16_t presentQueueIndex,
                               SwapchainParam *out_swapchainParam, VkSwapchainKHR *out_swapchain){
    querySwapchainParam(physicalDev, surface, out_swapchainParam);
    ...
    ...
}

void VkHelper::createSwapchain(VkPhysicalDevice physicalDev, VkDevice device, VkSurfaceKHR surface,
                               uint16_t workQueueIndex, uint16_t presentQueueIndex,
                               SwapchainParam *out_swapchainParam, VkSwapchainKHR *out_swapchain){

    querySwapchainParam(physicalDev, surface, out_swapchainParam);
    
    ...
    ...
    VkSwapchainCreateInfoKHR swapchainCreateInfo = {
        //TODO
    }; 
    CALL_VK(vkCreateSwapchainKHR(device, &swapchainCreateInfo, VK_ALLOC, out_swapchain));

uint32_t queueFamilysArr[2] = {static_cast<uint32_t>(workQueueIndex), static_cast<uint32_t>(presentQueueIndex)};

VkSwapchainKHR oldSwapchain;
if(nullptr != out_swapchain && VK_NULL_HANDLE != *out_swapchain){
    oldSwapchain = *out_swapchain;
}

VkSwapchainCreateInfoKHR swapchainCreateInfo = {
            .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
            .pNext = nullptr,
            .flags = 0,
    		//上文创建的窗口表面
            .surface = surface,
            .minImageCount = out_swapchainParam->capabilities.minImageCount,
            .imageFormat = out_swapchainParam->format.format,
            .imageColorSpace = out_swapchainParam->format.colorSpace,
            .imageExtent = out_swapchainParam->extent,
            .imageArrayLayers = 1,
    		//用为颜色附件
            .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
            .imageSharingMode = workQueueIndex == presentQueueIndex ? VK_SHARING_MODE_EXCLUSIVE : VK_SHARING_MODE_CONCURRENT,
            .queueFamilyIndexCount = static_cast<uint32_t>(workQueueIndex == presentQueueIndex ? 1 : 2),
            .pQueueFamilyIndices = workQueueIndex == presentQueueIndex ? nullptr : queueFamilysArr,
            .preTransform = out_swapchainParam->capabilities.currentTransform,
            .compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, //忽略掉alpha通道
            .presentMode = out_swapchainParam->presentMode,
            .clipped = VK_TRUE,
            .oldSwapchain = oldSwapchain
    };

struct VkBundle {
	...
    ...
    VkCommandPool cmdPool;

    SwapchainParam swapchainParam;
    VkSwapchainKHR swapchain;
}

void init(){
    ...
    ...
    VkHelper::createSwapchain(vk.deviceInfo.physicalDev, vk.deviceInfo.device, vk.surface, 				vk.queueInfo.workQueueIndex, vk.queueInfo.presentQueueIndex,
                                  &vk.swapchainParam,&vk.swapchain);
}

void destroy(){
    Print("%s", __FUNCTION__);
    vkDeviceWaitIdle(vk.deviceInfo.device);

    vkDestroySwapchainKHR(vk.deviceInfo.device, vk.swapchain, VK_ALLOC);
    ...
    ...
}

struct SwapchainImage{
    uint32_t imageCount;
    VkImage *images;
    VkImageView *views;
};

struct VkBundle {
    ...
    ...
    SwapchainImage swapchainImage;
}

CALL_VK(vkGetSwapchainImagesKHR(vk.deviceInfo.device, vk.swapchain, &vk.swapchainImage.imageCount, nullptr));
vk.swapchainImage.images = static_cast<VkImage *>(malloc(sizeof(VkImage) * vk.swapchainImage.imageCount));
CALL_VK(vkGetSwapchainImagesKHR(vk.deviceInfo.device, vk.swapchain, &vk.swapchainImage.imageCount, vk.swapchainImage.images));

vk.swapchainImage.views = static_cast<VkImageView *>(malloc(sizeof(VkImageView) * vk.swapchainImage.imageCount));
for(uint32_t i = 0; i < vk.swapchainImage.imageCount; i++){
    VkImageViewCreateInfo createInfo = {
        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .image = vk.swapchainImage.images[i],
        .viewType = VK_IMAGE_VIEW_TYPE_2D,
        .format = vk.swapchainParam.format.format,
        .components = {VK_COMPONENT_SWIZZLE_IDENTITY},
        .subresourceRange = {
                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
                .baseMipLevel = 0,
                .levelCount = 1,
                .baseArrayLayer = 0,
                .layerCount = 1
        }
    };
    CALL_VK(vkCreateImageView(vk.deviceInfo.device, &createInfo, VK_ALLOC, &vk.swapchainImage.views[i]));
}

void destroy(){
    Print("%s", __FUNCTION__);
    vkDeviceWaitIdle(vk.deviceInfo.device);   
	for(uint32_t i = 0; i < vk.swapchainImage.imageCount; i++){
        vkDestroyImageView(vk.deviceInfo.device, vk.swapchainImage.views[i], VK_ALLOC);
    }
    free(vk.swapchainImage.views);
    free(vk.swapchainImage.images);
    ...
    ...
}

struct VkBundle {
	...
    ...
    SwapchainImage swapchainImage;
	VkRenderPass renderPass;
}

void VkHelper::createRenderPass(VkDevice device, SwapchainParam swapchainParam, VkRenderPass *out_renderPass) {
	
    //TODO 我们不管createInfo有多复杂，先把框架写出来，接下来再完善。
    VkRenderPassCreateInfo createInfo = {};
    CALL_VK(vkCreateRenderPass(device, &createInfo, VK_ALLOC, out_renderPass));
}

VkAttachmentDescription attachDesc[] = {
    {
        .flags = 0,
        .format = swapchainParam.format.format,
        .samples = VK_SAMPLE_COUNT_1_BIT,
        //VK_ATTACHMENT_LOAD_OP_LOAD：保持附着的现有内容
        //VK_ATTACHMENT_LOAD_OP_CLEAR：使用一个常量值来清除附着的内容
        //VK_ATTACHMENT_LOAD_OP_DONT_CARE：不关心附着现存的内容
        .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
        .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
        //K_ATTACHMENT_STORE_OP_STORE：渲染的内容会被存储起来，以便之后读取
        //VK_ATTACHMENT_STORE_OP_DONT_CARE：渲染后，不会读取帧缓冲的内容
        .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
        .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
        .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
        .finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
    }
};

VkAttachmentReference colorAttachRef = {
        .attachment = 0,										// 0表示上文attachDesc[]数组的第1位
        .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,		// 作为颜色附件使用
};

VkSubpassDescription subpass = {
        .flags = 0,
        .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
        .inputAttachmentCount = 0,
        .pInputAttachments = nullptr,
        .colorAttachmentCount = 1,
        .pColorAttachments = &colorAttachRef,
        .preserveAttachmentCount = 0,
        .pPreserveAttachments = nullptr,
};

VkSubpassDependency dependency = {
        .srcSubpass = VK_SUBPASS_EXTERNAL,								// 外部流程作为输入
        .dstSubpass = 0,
        .srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
        .dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
        .srcAccessMask = 0,
        .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,// 颜色附件作为输出
        .dependencyFlags = 0,
};

void VkHelper::createRenderPass(VkDevice device, SwapchainParam swapchainParam, VkRenderPass *out_renderPass) {
    
    ...
    ...
    VkRenderPassCreateInfo createInfo = {
        .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .attachmentCount = ARRAY_SIZE(attachDesc),
        .pAttachments = attachDesc,
        .subpassCount = 1,
        .pSubpasses = &subpass,
        .dependencyCount = 1,
        .pDependencies = &dependency
    };
    CALL_VK(vkCreateRenderPass(device, &createInfo, VK_ALLOC, out_renderPass));
}

void init(){
    ...
	...
    VkHelper::createRenderPass(vk.deviceInfo.device, vk.swapchainParam, &vk.renderPass);
}

void destroy(){
    Print("%s", __FUNCTION__);
    vkDeviceWaitIdle(vk.deviceInfo.device);

    vkDestroyRenderPass(vk.deviceInfo.device, vk.renderPass, VK_ALLOC);
    ...
    ...
}

struct VkBundle {
    ...
	...
	uint32_t framebufferCount;
    VkFramebuffer *framebuffers;
}

void init(){
    ...
    ...
    vk.framebufferCount = vk.swapchainImage.imageCount;
    vk.framebuffers = static_cast<VkFramebuffer *>(malloc(sizeof(VkFramebuffer) * vk.framebufferCount));
    //TODO 创建帧缓冲
    VkHelper::createFramebuffer(vk.deviceInfo.device, vk.renderPass, vk.swapchainParam.extent.width, 										vk.swapchainParam.extent.height,
                                vk.framebufferCount, vk.swapchainImage.views, vk.framebuffers);
}

void destroy(){
	Print("%s", __FUNCTION__);
    vkDeviceWaitIdle(vk.deviceInfo.device);
    for (size_t i = 0; i < vk.framebufferCount; i++) {
    	vkDestroyFramebuffer(vk.deviceInfo.device, vk.framebuffers[i], VK_ALLOC);
    }
    free(vk.framebuffers);
    ...
	...
}

void VkHelper::createFramebuffer(VkDevice device, VkRenderPass renderPass,
                                 uint32_t width, uint32_t height,
                                 uint32_t framebufferCount, VkImageView *imageViews, VkFramebuffer *out_framebuffers) {
    for(uint32_t i = 0; i < framebufferCount; i++){
        VkImageView attachment[] = {
                imageViews[i],
        };
        VkFramebufferCreateInfo createInfo = {
                .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
                .pNext = nullptr,
                .flags = 0,
                .renderPass = renderPass,
                .attachmentCount = ARRAY_SIZE(attachment),
                .pAttachments = attachment,
                .width = width,
                .height = height,
                .layers = 1
        };
        CALL_VK(vkCreateFramebuffer(device, &createInfo, VK_ALLOC, &out_framebuffers[i]));
    }
}

struct VkBundle {
	...
    ...
    uint32_t framebufferCount;
    VkFramebuffer *framebuffers;
    VkPipelineLayout pipelineLayout;
}

void VkHelper::createPipelineLayout(VkDevice device, VkPipelineLayout *out_pipelineLayout) {}

void VkHelper::createPipelineLayout(VkDevice device, VkPipelineLayout *out_pipelineLayout) {
    VkPipelineLayoutCreateInfo createInfo = {
            .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
            .pNext = nullptr,
            .flags = 0,
            .setLayoutCount = 0,
            .pSetLayouts = nullptr,
            .pushConstantRangeCount = 0,
            .pPushConstantRanges = nullptr
    };
    CALL_VK(vkCreatePipelineLayout(device, &createInfo, VK_ALLOC, out_pipelineLayout));
}

void init(){
    ...
	...
    VkHelper::createPipelineLayout(vk.deviceInfo.device, &vk.pipelineLayout);
}

void destroy(){
    Print("%s", __FUNCTION__);
    vkDeviceWaitIdle(vk.deviceInfo.device);

    vkDestroyPipelineLayout(vk.deviceInfo.device, vk.pipelineLayout, VK_ALLOC);
    ...
    ...
}

#version 450
#extension GL_ARB_separate_shader_objects : enable

out gl_PerVertex {
    vec4 gl_Position;
};

out layout(location=0) vec4 vertexColor;

vec3 verties[] = {
    vec3(0, 0, 0),
    vec3(0, 0.5f, 0),
    vec3(-0.5f, 0, 0)
};

vec4 colors[] = {
    vec4(1, 0, 0, 1),
    vec4(0, 1, 0, 1),
    vec4(0, 0, 1, 1)
};

void main(){
    vec3 in_pos = verties[gl_VertexIndex];
    gl_Position = vec4(in_pos.x, -in_pos.y, in_pos.z, 1.0f);    //reverse Y, same as OpenGL
    vertexColor = colors[gl_VertexIndex];
}

#version 450
#extension GL_ARB_separate_shader_objects : enable

layout(location=0) in vec4 vertexColor;
layout(location=0) out vec4 outColor;

void main(){
    outColor = vertexColor;
}

find_program(GLSLANGVALIDATOR_COMMAND glslangValidator)
if(NOT GLSLANGVALIDATOR_COMMAND)
	message(FATAL_ERROR "glslangValidator required - source maintained at https://github.com/KhronosGroup/glslang")
endif()

#
# Generate SPIR-V header files from the arguments. Returns a list of headers.
#
function(spirv_shaders ret)
	set(options)
	set(oneValueArgs SPIRV_VERSION)
	set(multiValueArgs SOURCES)
	cmake_parse_arguments(_spirvshaders "${options}" "${oneValueArgs}"
	                      "${multiValueArgs}" ${ARGN})

	if(NOT _spirvshaders_SPIRV_VERSION)
		set(_spirvshaders_SPIRV_VERSION 1.0)
	endif()

	foreach(GLSL ${_spirvshaders_SOURCES})
		string(MAKE_C_IDENTIFIER ${GLSL} IDENTIFIER)
		set(HEADER "${CMAKE_CURRENT_BINARY_DIR}/${GLSL}.spv")
		set(GLSL "${CMAKE_CURRENT_SOURCE_DIR}/${GLSL}")
        
		message("GLSL Command: ${GLSLANGVALIDATOR_COMMAND} -V --target-env spirv${_spirvshaders_SPIRV_VERSION} ${GLSL} -o ${HEADER}")

		add_custom_command(
			OUTPUT ${HEADER}
			COMMAND ${GLSLANGVALIDATOR_COMMAND} -V --target-env spirv${_spirvshaders_SPIRV_VERSION} ${GLSL} -o ${HEADER}
			DEPENDS ${GLSL})
		list(APPEND HEADERS ${HEADER})
	endforeach()

	set(${ret} "${HEADERS}" PARENT_SCOPE)
endfunction(spirv_shaders)

GLSL Command: C:/Users/ts/VK/Bin/glslangValidator.exe -V --target-env spirv1.0 D:/st/learn_vulkan_blog/00_hello_triangle/shaders/demo001.frag -o D:/st/learn_vulkan_blog/00_hello_triangle/cmake-build-debug/shaders/demo001.frag.spv
GLSL Command: C:/Users/ts/VK/Bin/glslangValidator.exe -V --target-env spirv1.0 D:/st/learn_vulkan_blog/00_hello_triangle/shaders/demo001.vert -o D:/st/learn_vulkan_blog/00_hello_triangle/cmake-build-debug/shaders/demo001.vert.spv

...
...

list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}")
include(SPIR-V)

# 使用SHADERS暂存shader文件列表
set(SHADERS
        shaders/demo001.frag
        shaders/demo001.vert
        # shaders/demo002.frag
        # shaders/demo002.vert
        # ...
        # ...
        )
# 编译为中间文件
spirv_shaders(
        SHADER_HEADERS
        SPIRV_VERSION
        1.0 # Currently targeting Vulkan 1.0
        SOURCES
        ${SHADERS}
)

add_executable(
        ${PROJECT_NAME}
        ${SHADER_HEADERS}
        src/VulkanCommon.h
        src/Main.cpp
        src/VkBundle.h
        src/VkHelper.cpp
        src/VkHelper.h
)

...
...

static std::vector<char> readFile(const std::string& filePath){
    //从文件尾部开始读取
    std::ifstream file(filePath, std::ios::ate | std::ios::binary);
    if(!file.is_open()){
        throw std::runtime_error("can not open the file: " + filePath);
    }

    size_t fileSize = (size_t) file.tellg();
    std::vector<char> buffer(fileSize);
    file.seekg(0);//从头开始读
    file.read(buffer.data(), fileSize);
    file.close();
    return buffer;
}

void init(){
    ...
    ...
    std::string shaders("shaders/");
    const char *defaultShader = "demo001";

    auto vertexShaderCode = readFile(shaders + defaultShader + ".vert.spv");// ---> shaders/demo001.vert.spv
    auto fragShaderCode = readFile(shaders + defaultShader + ".frag.spv");// ---> shaders/demo001.frag.spv
}

VkShaderModule VkHelper::createShaderModule(VkDevice device, std::vector<char> &code) {
    VkShaderModuleCreateInfo createInfo;
    createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
    createInfo.pNext = nullptr;
    createInfo.flags = 0;
    createInfo.codeSize = code.size();
    createInfo.pCode = reinterpret_cast<const uint32_t *>(code.data());

    VkShaderModule shaderModule;
    if(vkCreateShaderModule(device, &createInfo, nullptr, &shaderModule) != VK_SUCCESS) {
        throw std::runtime_error("failed to create shader module!");
    }
    return shaderModule;
}

struct VkBundle {
	...
    ...
    VkShaderModule vertexShaderModule;
    VkShaderModule fragShaderModule;
}

void init(){
    ...
    ...
    std::string shaders("shaders/");
    const char *defaultShader = "demo01";

    auto vertexShaderCode = readFile(shaders + defaultShader + ".vert.spv");// ---> shaders/demo01.vert.spv
    auto fragShaderCode = readFile(shaders + defaultShader + ".frag.spv");// ---> shaders/demo01.frag.spv
    
    vk.vertexShaderModule = VkHelper::createShaderModule(vk.deviceInfo.device, vertexShaderCode);
    vk.fragShaderModule = VkHelper::createShaderModule(vk.deviceInfo.device, fragShaderCode);
}

void destroy(){
    Print("%s", __FUNCTION__);
    vkDeviceWaitIdle(vk.deviceInfo.device);

    vkDestroyShaderModule(vk.deviceInfo.device, vk.vertexShaderModule, VK_ALLOC);
    vkDestroyShaderModule(vk.deviceInfo.device, vk.fragShaderModule, VK_ALLOC);
    
    ...
    ...
}

struct VkBundle {
	...
    ...
    VkPipeline graphicPipeline;
}

void VkHelper::createPipeline(VkDevice device, VkPipelineLayout pipelineLayout, VkRenderPass renderPass, VkShaderModule vertShaderModule, VkShaderModule fragShaderModule, SwapchainParam swapchainParam, VkPipeline *out_pipeline) {
    //TODO 
}

VkPipelineShaderStageCreateInfo stages[] = {
        {
            .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
            .pNext = nullptr,
            .flags = 0,
            .stage = VK_SHADER_STAGE_VERTEX_BIT,
            .module = vertShaderModule,
            .pName = "main",
            .pSpecializationInfo = nullptr
        },
        {
            .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
            .pNext = nullptr,
            .flags = 0,
            .stage = VK_SHADER_STAGE_FRAGMENT_BIT,
            .module = fragShaderModule,
            .pName = "main",
            .pSpecializationInfo = nullptr
        }
};

VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .vertexBindingDescriptionCount = 0,
        .pVertexBindingDescriptions = nullptr,
        .vertexAttributeDescriptionCount = 0,
        .pVertexAttributeDescriptions = nullptr
};

VkPipelineInputAssemblyStateCreateInfo assemblyStateCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
        .primitiveRestartEnable = VK_FALSE,
};

VkViewport viewport = {
        .x = 0,
        .y = 0,
        .width = static_cast<float>(swapchainParam.extent.width),
        .height = static_cast<float>(swapchainParam.extent.height),
        .minDepth = 0,
        .maxDepth = 1
};

VkRect2D scissor = {
        .offset = {0, 0},
        .extent = swapchainParam.extent,
};

VkPipelineViewportStateCreateInfo viewportStateCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .viewportCount = 1,
        .pViewports = &viewport,
        .scissorCount = 1,
        .pScissors = &scissor
};

VkPipelineRasterizationStateCreateInfo rasterizationStateCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .depthClampEnable = VK_FALSE,        //计算阴影
        .rasterizerDiscardEnable = VK_FALSE, //VK_TRUE表示所有几何图元都不能通过光栅化阶段。这一设置会禁止一切片段输出到帧缓冲
        // VK_POLYGON_MODE_FILL：整个多边形，包括多边形内部都产生片段
        // VK_POLYGON_MODE_LINE：只有多边形的边会产生片段
        // VK_POLYGON_MODE_POINT：只有多边形的顶点会产生片段
        .polygonMode = VK_POLYGON_MODE_FILL,
        .cullMode = VK_CULL_MODE_BACK_BIT,   //表面剔除
        .frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE, //逆时针标识为前面
        .depthBiasEnable = VK_FALSE,
        .depthBiasConstantFactor = 0,
        .depthBiasClamp = 0,
        .depthBiasSlopeFactor = 0,
        .lineWidth = 1.0f,
};

VkPipelineMultisampleStateCreateInfo multisampleStateCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT,
        .sampleShadingEnable = VK_FALSE,    //抗锯齿
        .minSampleShading = 1.0f,
        .pSampleMask = nullptr,
        .alphaToCoverageEnable = VK_FALSE,
        .alphaToOneEnable = VK_FALSE
};

VkPipelineColorBlendAttachmentState attachmentState = {
        //    VkColorComponentFlags    colorWriteMask;
        .blendEnable = VK_FALSE,
        .srcColorBlendFactor = VK_BLEND_FACTOR_ONE,
        .dstColorBlendFactor = VK_BLEND_FACTOR_ZERO,
        .colorBlendOp = VK_BLEND_OP_ADD,
        .srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE,
        .dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO,
        .alphaBlendOp = VK_BLEND_OP_ADD,
        .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT
};

VkPipelineColorBlendStateCreateInfo colorBlendStateCreateInfo = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .logicOpEnable = VK_FALSE,
        .logicOp = VK_LOGIC_OP_CLEAR,
        .attachmentCount = 1,
        .pAttachments = &attachmentState,
        .blendConstants = {0, 0, 0, 0},
};

VkGraphicsPipelineCreateInfo createInfo = {
        .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .stageCount = ARRAY_SIZE(stages),
        .pStages = stages,
        .pVertexInputState = &vertexInputStateCreateInfo,
        .pInputAssemblyState = &assemblyStateCreateInfo,
        .pTessellationState = nullptr,
        .pViewportState = &viewportStateCreateInfo,
        .pRasterizationState = &rasterizationStateCreateInfo,
        .pMultisampleState = &multisampleStateCreateInfo,
        .pDepthStencilState = nullptr,
        .pColorBlendState = &colorBlendStateCreateInfo,
        .pDynamicState = nullptr,
        .layout = pipelineLayout,
        .renderPass = renderPass,
        .subpass = 0,
        .basePipelineHandle = nullptr,
        .basePipelineIndex = 0
};

CALL_VK(vkCreateGraphicsPipelines(device, nullptr, 1, &createInfo, VK_ALLOC, out_pipeline));

void init(){
    ...
    ...
    vk.vertexShaderModule = VkHelper::createShaderModule(vk.deviceInfo.device, vertexShaderCode);
    vk.fragShaderModule = VkHelper::createShaderModule(vk.deviceInfo.device, fragShaderCode);
    VkHelper::createPipeline(vk.deviceInfo.device, vk.pipelineLayout, vk.renderPass, vk.vertexShaderModule, vk.fragShaderModule, vk.swapchainParam, &vk.graphicPipeline);
}

void destroy(){
    Print("%s", __FUNCTION__);
    vkDeviceWaitIdle(vk.deviceInfo.device);

    vkDestroyPipeline(vk.deviceInfo.device, vk.graphicPipeline, VK_ALLOC);
    ...
    ...
}

struct VkBundle {
	...
    ...
    uint32_t cmdBufferCount;
    VkCommandBuffer *cmdBuffers;
}

void VkHelper::allocateCommandBuffers(VkDevice device, VkCommandPool cmdPool, uint32_t cmdBufferCount, VkCommandBuffer *cmdBuffers) {
	VkCommandBufferAllocateInfo allocateInfo = {
            .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
            .pNext = nullptr,
            .commandPool = cmdPool,
            .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
            .commandBufferCount = cmdBufferCount
    };

    CALL_VK(vkAllocateCommandBuffers(device, &allocateInfo, cmdBuffers));
}

void init(){
    ...
    ...
    vk.cmdBufferCount = vk.swapchainImage.imageCount;
    vk.cmdBuffers = static_cast<VkCommandBuffer *>(malloc(sizeof(VkCommandBuffer) * vk.cmdBufferCount));
    VkHelper::allocateCommandBuffers(vk.deviceInfo.device, vk.cmdPool, vk.cmdBufferCount, vk.cmdBuffers);
}

void destroy(){
    Print("%s", __FUNCTION__);
    vkDeviceWaitIdle(vk.deviceInfo.device);

    vkFreeCommandBuffers(vk.deviceInfo.device, vk.cmdPool, vk.cmdBufferCount, vk.cmdBuffers);
    free(vk.cmdBuffers);
    ...
    ...
}

struct VkBundle {
    ...
    ...
    VkSemaphore imageSemaphore;
    VkSemaphore presentSemaphore;
}

void init(){
    ...
	...
    VkSemaphoreCreateInfo semaphoreCreateInfo = {
            .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
            .pNext = nullptr,
            .flags = 0
    };
    CALL_VK(vkCreateSemaphore(vk.deviceInfo.device, &semaphoreCreateInfo, VK_ALLOC, &vk.imageSemaphore));
    CALL_VK(vkCreateSemaphore(vk.deviceInfo.device, &semaphoreCreateInfo, VK_ALLOC, &vk.presentSemaphore));
}

void destroy(){
    Print("%s", __FUNCTION__);
    vkDeviceWaitIdle(vk.deviceInfo.device);
    
    vkDestroySemaphore(vk.deviceInfo.device, vk.presentSemaphore, VK_ALLOC);
    vkDestroySemaphore(vk.deviceInfo.device, vk.imageSemaphore, VK_ALLOC);
    ...
    ...
}

void render(uint32_t currentFrame){
    if(!canRender) return;
    uint32_t imageIndex = 0;
    VkResult rt = vkAcquireNextImageKHR(vk.deviceInfo.device, vk.swapchain, std::numeric_limits<uint64_t>::max(), vk.imageSemaphore, VK_NULL_HANDLE, &imageIndex);

    // out of date: 窗口变化等情况会出现这个返回。本案例先不处理。
    if(rt == VK_ERROR_OUT_OF_DATE_KHR){
        Error("swapchain was out of date.");
        return;
    }
    
    //TODO
}

VkCommandBufferBeginInfo cmdBufferBeginInfo = {
        .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
        .pNext = nullptr,
        //VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT：指令缓冲在执行一次后，就被用来记录新的指令。
        //VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT：这是一个只在一个渲染流程内使用的辅助指令缓冲。
        //VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT：在指令缓冲等待执行时，仍然可以提交这一指令缓冲。
        .flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
        .pInheritanceInfo = nullptr
};
CALL_VK(vkBeginCommandBuffer(vk.cmdBuffers[imageIndex], &cmdBufferBeginInfo));

VkClearValue defaultClearValues = { 0.1f,  0.1f,  0.2f,  1.0f};//清屏颜色
VkRenderPassBeginInfo renderPassBeginInfo = {
        .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
        .pNext = nullptr,
        .renderPass = vk.renderPass,
        .framebuffer = vk.framebuffers[imageIndex],
        .renderArea = {
                .offset = {0, 0},
                .extent = vk.swapchainParam.extent
        },
        .clearValueCount = 1,
        .pClearValues = &defaultClearValues,
};

//VK_SUBPASS_CONTENTS_INLINE：所有要执行的指令都在主要指令缓冲中，没有辅助指令缓冲需要执行。
//VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS：有来自辅助指令缓冲的指令需要执行。
vkCmdBeginRenderPass(vk.cmdBuffers[imageIndex], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);

//绑定渲染管线
vkCmdBindPipeline(vk.cmdBuffers[imageIndex], VK_PIPELINE_BIND_POINT_GRAPHICS, vk.graphicPipeline);

/*
 * commandBuffer 命令缓冲
 * vertexCount 顶点数量
 * instanceCount 实例数量，我们目前只绘制一个实例。当绘制大批量对象时会用到。
 * firstVertex 起始顶点，用于偏移
 * firstInstance 起始实例，用于偏移
 */
vkCmdDraw(vk.cmdBuffers[imageIndex], 3, 1, 0, 0);

vkCmdEndRenderPass(vk.cmdBuffers[imageIndex]);

CALL_VK(vkEndCommandBuffer(vk.cmdBuffers[imageIndex]));

VkPipelineStageFlags stages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
VkSubmitInfo submitInfo = {
        .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
        .pNext = nullptr,
        .waitSemaphoreCount = 1,
        .pWaitSemaphores = &vk.imageSemaphore,
        .pWaitDstStageMask = stages,
        .commandBufferCount = 1,
        .pCommandBuffers = &vk.cmdBuffers[imageIndex],
        .signalSemaphoreCount = 1,
        .pSignalSemaphores = &vk.presentSemaphore,
};
CALL_VK(vkQueueSubmit(vk.queueInfo.queue, 1, &submitInfo, VK_NULL_HANDLE));

VkPresentInfoKHR presentInfo = {
        .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
        .pNext = nullptr,
        .waitSemaphoreCount = 1,
        .pWaitSemaphores = &vk.presentSemaphore,
        .swapchainCount = 1,
        .pSwapchains = &vk.swapchain,
        .pImageIndices = &imageIndex,
        .pResults = nullptr
};
CALL_VK(vkQueuePresentKHR(vk.queueInfo.queue, &presentInfo));

CALL_VK(vkQueueWaitIdle(vk.queueInfo.queue));