4
社区成员
发帖
与我相关
我的任务
分享vulkan 官方源码 1.3绘制三角形_彩色三角形(c++17)
#version 450
layout(location = 0) out vec3 fragColor;
vec2 positions[3] = vec2[](
vec2(0.0, -0.5),
vec2(0.5, 0.5),
vec2(-0.5, 0.5)
);
vec3 colors[3] = vec3[](
vec3(1.0, 0.0, 0.0),
vec3(0.0, 1.0, 0.0),
vec3(0.0, 0.0, 1.0)
);
void main() {
gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
fragColor = colors[gl_VertexIndex];
}
#version 450
layout(location = 0) in vec3 fragColor;
layout(location = 0) out vec4 outColor;
void main() {
outColor = vec4(fragColor, 1.0);
}
在命令行中，逐条输入并执行以下命令：
bash
glslc shaders/09_shader_base.vert -o shaders/09_shader_base.vert.spv
这条命令会编译顶点着色器，并输出一个名为 09_shader_base.vert.spv 的文件到 shaders 文件夹中。
bash
glslc shaders/09_shader_base.frag -o shaders/09_shader_base.frag.spv
#define GLFW_INCLUDE_VULKAN // 让GLFW自动包含Vulkan头文件，确保GLFW使用Vulkan类型
#include <GLFW/glfw3.h> // GLFW窗口库头文件
#include <iostream> // 标准输入输出流，用于打印错误信息
#include <fstream> // 文件流，用于读取着色器SPIR-V字节码文件
#include <stdexcept> // 标准异常类，用于抛出运行时错误
#include <algorithm> // 算法库，提供std::clamp等工具函数
#include <vector> // 动态数组容器，存储交换链图像、扩展等列表
#include <cstring> // C字符串函数，用于strcmp比较层名称
#include <cstdlib> // C标准库，提供EXIT_SUCCESS和EXIT_FAILURE宏
#include <cstdint> // 固定宽度整数类型，如uint32_t
#include <limits> // 数值极限，用于判断currentExtent是否为特殊值
#include <optional> // 可选值容器，用于可能不存在的队列族索引
#include <set> // 集合容器，用于去重唯一的队列族索引
const uint32_t WIDTH = 800; // 窗口宽度，800像素
const uint32_t HEIGHT = 600; // 窗口高度，600像素
const int MAX_FRAMES_IN_FLIGHT = 2; // 最大并行处理帧数，实现双重缓冲
const std::vector<const char*> validationLayers = { // 验证层列表
"VK_LAYER_KHRONOS_validation" // Khronos官方验证层，用于调试API调用
};
const std::vector<const char*> deviceExtensions = { // 设备扩展列表
VK_KHR_SWAPCHAIN_EXTENSION_NAME // 交换链扩展，用于将渲染结果呈现到窗口
};
#ifdef NDEBUG // 如果是发布版本（定义了NDEBUG宏）
const bool enableValidationLayers = false; // 禁用验证层以提升性能
#else // 如果是调试版本
const bool enableValidationLayers = true; // 启用验证层以帮助调试
#endif
// 代理函数：动态加载vkCreateDebugUtilsMessengerEXT扩展函数
VkResult CreateDebugUtilsMessengerEXT(VkInstance instance, // Vulkan实例句柄
const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, // 调试信使创建配置
const VkAllocationCallbacks* pAllocator, // 自定义内存分配器回调
VkDebugUtilsMessengerEXT* pDebugMessenger) { // 输出的调试信使句柄
auto func = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT"); // 动态获取函数指针
if (func != nullptr) { // 如果成功获取函数指针
return func(instance, pCreateInfo, pAllocator, pDebugMessenger); // 调用扩展函数创建调试信使
}
else { // 获取函数指针失败
return VK_ERROR_EXTENSION_NOT_PRESENT; // 返回扩展不存在错误码
}
}
// 代理函数：动态加载vkDestroyDebugUtilsMessengerEXT扩展函数
void DestroyDebugUtilsMessengerEXT(VkInstance instance, // Vulkan实例句柄
VkDebugUtilsMessengerEXT debugMessenger, // 要销毁的调试信使句柄
const VkAllocationCallbacks* pAllocator) { // 自定义内存分配器回调
auto func = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT"); // 动态获取函数指针
if (func != nullptr) { // 如果成功获取函数指针
func(instance, debugMessenger, pAllocator); // 调用扩展函数销毁调试信使
}
}
// 队列族索引结构体，存储图形和呈现队列族的索引
struct QueueFamilyIndices {
std::optional<uint32_t> graphicsFamily; // 支持图形操作的队列族索引（可能为空）
std::optional<uint32_t> presentFamily; // 支持呈现到表面的队列族索引（可能为空）
bool isComplete() { // 检查是否找到了所有必需的队列族
return graphicsFamily.has_value() && presentFamily.has_value(); // 两者都有值才返回true
}
};
// 交换链支持详情结构体，存储物理设备对交换链的支持信息
struct SwapChainSupportDetails {
VkSurfaceCapabilitiesKHR capabilities; // 表面能力（最小/最大图像数量、当前分辨率等）
std::vector<VkSurfaceFormatKHR> formats; // 支持的表面格式列表（像素格式+颜色空间）
std::vector<VkPresentModeKHR> presentModes; // 支持的呈现模式列表（立即、FIFO、邮箱等）
};
class HelloTriangleApplication { // Vulkan三角形渲染应用程序主类
public:
void run() { // 应用程序主入口函数
initWindow(); // 第一步：初始化GLFW窗口
initVulkan(); // 第二步：初始化所有Vulkan资源
mainLoop(); // 第三步：进入主渲染循环
cleanup(); // 第四步：清理所有资源
}
private:
GLFWwindow* window; // GLFW窗口指针
VkInstance instance; // Vulkan实例句柄，连接应用程序与Vulkan库
VkDebugUtilsMessengerEXT debugMessenger; // 调试信使句柄，接收验证层消息
VkSurfaceKHR surface; // 窗口表面句柄，用于呈现渲染结果
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE; // 物理设备句柄（GPU），初始化为空
VkDevice device; // 逻辑设备句柄，与物理设备交互的抽象接口
VkQueue graphicsQueue; // 图形队列句柄，提交绘制命令
VkQueue presentQueue; // 呈现队列句柄，将图像呈现到窗口
VkSwapchainKHR swapChain; // 交换链句柄，管理用于显示的图像缓冲区
std::vector<VkImage> swapChainImages; // 交换链中的图像句柄列表
VkFormat swapChainImageFormat; // 交换链图像格式（如VK_FORMAT_B8G8R8A8_SRGB）
VkExtent2D swapChainExtent; // 交换链图像分辨率（宽度和高度）
std::vector<VkImageView> swapChainImageViews; // 交换链图像的视图列表，用于渲染目标
std::vector<VkFramebuffer> swapChainFramebuffers; // 帧缓冲列表，每个对应一个交换链图像
VkRenderPass renderPass; // 渲染通道句柄，定义渲染操作的结构
VkPipelineLayout pipelineLayout; // 管线布局句柄，定义着色器资源布局
VkPipeline graphicsPipeline; // 图形管线句柄，封装完整的渲染状态
VkCommandPool commandPool; // 命令池句柄，管理命令缓冲区的分配
std::vector<VkCommandBuffer> commandBuffers; // 命令缓冲区列表，每帧一个用于并行录制
std::vector<VkSemaphore> imageAvailableSemaphores; // 信号量列表：交换链图像获取完成
std::vector<VkSemaphore> renderFinishedSemaphores; // 信号量列表：渲染完成
std::vector<VkFence> inFlightFences; // 栅栏列表：标记CPU-GPU同步点
uint32_t currentFrame = 0; // 当前帧索引，在0和MAX_FRAMES_IN_FLIGHT-1间轮转
bool framebufferResized = false; // 窗口大小是否改变，用于触发交换链重建
void initWindow() { // 初始化GLFW窗口
glfwInit(); // 初始化GLFW库
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); // 告诉GLFW不创建OpenGL上下文，因为使用Vulkan
window = glfwCreateWindow(WIDTH, HEIGHT, "Vulkan", nullptr, nullptr); // 创建窗口（宽度、高度、标题）
glfwSetWindowUserPointer(window, this); // 将this指针存入窗口，供回调函数使用
glfwSetFramebufferSizeCallback(window, framebufferResizeCallback); // 设置窗口大小改变回调
}
static void framebufferResizeCallback(GLFWwindow* window, int width, int height) { // 窗口大小改变时的回调
auto app = reinterpret_cast<HelloTriangleApplication*>(glfwGetWindowUserPointer(window)); // 从窗口取回this指针
app->framebufferResized = true; // 标记需要重建交换链
}
void initVulkan() { // 初始化所有Vulkan资源
createInstance(); // 创建Vulkan实例
setupDebugMessenger(); // 设置调试信使（仅调试版本）
createSurface(); // 创建窗口表面
pickPhysicalDevice(); // 选择合适的物理设备（GPU）
createLogicalDevice(); // 创建逻辑设备并获取队列
createSwapChain(); // 创建交换链
createImageViews(); // 为交换链图像创建视图
createRenderPass(); // 创建渲染通道
createGraphicsPipeline(); // 创建图形管线
createFramebuffers(); // 创建帧缓冲
createCommandPool(); // 创建命令池
createCommandBuffers(); // 分配命令缓冲区
createSyncObjects(); // 创建同步对象（信号量和栅栏）
}
void mainLoop() { // 主渲染循环
while (!glfwWindowShouldClose(window)) { // 当窗口未请求关闭时持续循环
glfwPollEvents(); // 处理窗口事件（键盘、鼠标、窗口大小改变等）
drawFrame(); // 绘制一帧
}
vkDeviceWaitIdle(device); // 等待设备完成所有未完成操作再清理
}
void cleanupSwapChain() { // 清理交换链相关资源（重建交换链时调用）
for (auto framebuffer : swapChainFramebuffers) { // 遍历所有帧缓冲
vkDestroyFramebuffer(device, framebuffer, nullptr); // 销毁帧缓冲
}
for (auto imageView : swapChainImageViews) { // 遍历所有图像视图
vkDestroyImageView(device, imageView, nullptr); // 销毁图像视图
}
vkDestroySwapchainKHR(device, swapChain, nullptr); // 销毁交换链
}
void cleanup() { // 清理所有Vulkan和GLFW资源
cleanupSwapChain(); // 先清理交换链相关资源
vkDestroyPipeline(device, graphicsPipeline, nullptr); // 销毁图形管线
vkDestroyPipelineLayout(device, pipelineLayout, nullptr); // 销毁管线布局
vkDestroyRenderPass(device, renderPass, nullptr); // 销毁渲染通道
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) { // 遍历所有飞行帧
vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr); // 销毁渲染完成信号量
vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr); // 销毁图像可用信号量
vkDestroyFence(device, inFlightFences[i], nullptr); // 销毁飞行栅栏
}
vkDestroyCommandPool(device, commandPool, nullptr); // 销毁命令池（自动释放所有命令缓冲区）
vkDestroyDevice(device, nullptr); // 销毁逻辑设备
if (enableValidationLayers) { // 如果启用了验证层
DestroyDebugUtilsMessengerEXT(instance, debugMessenger, nullptr); // 销毁调试信使
}
vkDestroySurfaceKHR(instance, surface, nullptr); // 销毁窗口表面
vkDestroyInstance(instance, nullptr); // 销毁Vulkan实例
glfwDestroyWindow(window); // 销毁GLFW窗口
glfwTerminate(); // 终止GLFW库
}
void recreateSwapChain() { // 重建交换链（处理窗口大小改变和次优交换链）
int width = 0, height = 0; // 新的窗口尺寸
glfwGetFramebufferSize(window, &width, &height); // 获取当前帧缓冲大小
while (width == 0 || height == 0) { // 如果窗口最小化（尺寸为0）
glfwGetFramebufferSize(window, &width, &height); // 持续等待直到窗口恢复
glfwWaitEvents(); // 阻塞等待事件，避免忙等
}
vkDeviceWaitIdle(device); // 等待设备完全空闲
cleanupSwapChain(); // 清理旧的交换链资源
createSwapChain(); // 创建新交换链
createImageViews(); // 创建新图像视图
createFramebuffers(); // 创建新帧缓冲
}
void createInstance() { // 创建Vulkan实例
if (enableValidationLayers && !checkValidationLayerSupport()) { // 启用了验证层但系统不支持
throw std::runtime_error("validation layers requested, but not available!"); // 抛出异常终止程序
}
VkApplicationInfo appInfo{}; // 应用程序信息结构体
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; // 结构体类型标识
appInfo.pApplicationName = "Hello Triangle"; // 应用程序名称
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0); // 应用程序版本号
appInfo.pEngineName = "No Engine"; // 引擎名称（无引擎）
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0); // 引擎版本号
appInfo.apiVersion = VK_API_VERSION_1_0; // 使用的Vulkan API版本
VkInstanceCreateInfo createInfo{}; // 实例创建信息结构体
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; // 结构体类型标识
createInfo.pApplicationInfo = &appInfo; // 指向应用程序信息的指针
auto extensions = getRequiredExtensions(); // 获取平台和调试所需的扩展列表
createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size()); // 启用的扩展数量
createInfo.ppEnabledExtensionNames = extensions.data(); // 扩展名称字符串数组
VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo{}; // 调试信使创建信息（用于实例创建时的调试）
if (enableValidationLayers) { // 如果启用了验证层
createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size()); // 启用的验证层数量
createInfo.ppEnabledLayerNames = validationLayers.data(); // 验证层名称字符串数组
populateDebugMessengerCreateInfo(debugCreateInfo); // 填充调试回调信息
createInfo.pNext = (VkDebugUtilsMessengerCreateInfoEXT*)&debugCreateInfo; // 通过pNext链扩展，使实例创建时也启用调试
}
else { // 未启用验证层
createInfo.enabledLayerCount = 0; // 不启用任何层
createInfo.pNext = nullptr; // 无扩展链
}
if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) { // 创建Vulkan实例
throw std::runtime_error("failed to create instance!"); // 创建失败则抛出异常
}
}
void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo) { // 填充调试信使配置
createInfo = {}; // 清零所有字段
createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; // 结构体类型标识
createInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | // 接收详细消息
VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | // 接收警告消息
VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; // 接收错误消息
createInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | // 通用消息
VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | // 验证相关消息
VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT; // 性能相关消息
createInfo.pfnUserCallback = debugCallback; // 设置消息回调函数指针
}
void setupDebugMessenger() { // 创建调试信使
if (!enableValidationLayers) return; // 未启用验证层则直接返回
VkDebugUtilsMessengerCreateInfoEXT createInfo; // 调试信使创建信息
populateDebugMessengerCreateInfo(createInfo); // 填充创建信息
if (CreateDebugUtilsMessengerEXT(instance, &createInfo, nullptr, &debugMessenger) != VK_SUCCESS) { // 调用代理函数创建调试信使
throw std::runtime_error("failed to set up debug messenger!"); // 失败则抛出异常
}
}
void createSurface() { // 创建窗口表面（连接Vulkan和窗口系统）
if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS) { // GLFW辅助创建表面
throw std::runtime_error("failed to create window surface!"); // 失败则抛出异常
}
}
void pickPhysicalDevice() { // 选择物理设备（GPU）
uint32_t deviceCount = 0; // 支持Vulkan的设备数量
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr); // 获取设备数量
if (deviceCount == 0) { // 如果没有支持Vulkan的GPU
throw std::runtime_error("failed to find GPUs with Vulkan support!"); // 抛出异常
}
std::vector<VkPhysicalDevice> devices(deviceCount); // 创建物理设备列表
vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data()); // 枚举所有物理设备
for (const auto& device : devices) { // 遍历所有物理设备
if (isDeviceSuitable(device)) { // 检查设备是否满足需求
physicalDevice = device; // 选择第一个合适的设备
break; // 停止搜索
}
}
if (physicalDevice == VK_NULL_HANDLE) { // 如果没有找到合适的设备
throw std::runtime_error("failed to find a suitable GPU!"); // 抛出异常
}
}
void createLogicalDevice() { // 创建逻辑设备和队列
QueueFamilyIndices indices = findQueueFamilies(physicalDevice); // 获取所选物理设备的队列族索引
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos; // 队列创建信息列表
std::set<uint32_t> uniqueQueueFamilies = { indices.graphicsFamily.value(), // 图形队列族索引
indices.presentFamily.value() }; // 呈现队列族索引（set自动去重）
float queuePriority = 1.0f; // 队列优先级（0.0-1.0，1.0为最高）
for (uint32_t queueFamily : uniqueQueueFamilies) { // 为每个唯一的队列族创建队列
VkDeviceQueueCreateInfo queueCreateInfo{}; // 队列创建信息结构体
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; // 结构体类型标识
queueCreateInfo.queueFamilyIndex = queueFamily; // 队列族索引
queueCreateInfo.queueCount = 1; // 创建1个队列
queueCreateInfo.pQueuePriorities = &queuePriority; // 队列优先级数组
queueCreateInfos.push_back(queueCreateInfo); // 添加到列表
}
VkPhysicalDeviceFeatures deviceFeatures{}; // 请求的物理设备特性（全部为默认/关闭）
VkDeviceCreateInfo createInfo{}; // 逻辑设备创建信息结构体
createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; // 结构体类型标识
createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size()); // 队列创建信息数量
createInfo.pQueueCreateInfos = queueCreateInfos.data(); // 队列创建信息数组
createInfo.pEnabledFeatures = &deviceFeatures; // 启用的设备特性
createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size()); // 启用的扩展数量
createInfo.ppEnabledExtensionNames = deviceExtensions.data(); // 扩展名称数组
if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS) { // 创建逻辑设备
throw std::runtime_error("failed to create logical device!"); // 失败则抛出异常
}
vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue); // 获取图形队列句柄（队列索引0）
vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue); // 获取呈现队列句柄（队列索引0）
}
void createSwapChain() { // 创建交换链
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice); // 查询物理设备的交换链支持
VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats); // 选择合适的表面格式
VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes); // 选择合适的呈现模式
VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities); // 选择交换链分辨率
uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1; // 图像数量=最小数量+1（实现三缓冲）
if (swapChainSupport.capabilities.maxImageCount > 0 && // 如果存在最大图像数量限制
imageCount > swapChainSupport.capabilities.maxImageCount) { // 且请求数量超过限制
imageCount = swapChainSupport.capabilities.maxImageCount; // 限制为最大值
}
VkSwapchainCreateInfoKHR createInfo{}; // 交换链创建信息结构体
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; // 结构体类型标识
createInfo.surface = surface; // 关联的窗口表面
createInfo.minImageCount = imageCount; // 交换链最小图像数量
createInfo.imageFormat = surfaceFormat.format; // 图像像素格式
createInfo.imageColorSpace = surfaceFormat.colorSpace; // 颜色空间
createInfo.imageExtent = extent; // 图像分辨率
createInfo.imageArrayLayers = 1; // 图像数组层数（1为非立体渲染）
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; // 图像用途：作为颜色附件
QueueFamilyIndices indices = findQueueFamilies(physicalDevice); // 获取队列族索引
uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), // 图形队列族索引
indices.presentFamily.value() }; // 呈现队列族索引
if (indices.graphicsFamily != indices.presentFamily) { // 如果图形和呈现队列在不同族
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT; // 并发共享模式，图像可被多族访问
createInfo.queueFamilyIndexCount = 2; // 两个队列族共享
createInfo.pQueueFamilyIndices = queueFamilyIndices; // 共享的队列族数组
}
else { // 如果在同一队列族
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; // 独占模式，性能更好
}
createInfo.preTransform = swapChainSupport.capabilities.currentTransform; // 表面变换（旋转等）
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; // 不透明混合模式
createInfo.presentMode = presentMode; // 呈现模式
createInfo.clipped = VK_TRUE; // 裁剪被遮挡像素以提升性能
if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapChain) != VK_SUCCESS) { // 创建交换链
throw std::runtime_error("failed to create swap chain!"); // 失败则抛出异常
}
vkGetSwapchainImagesKHR(device, swapChain, &imageCount, nullptr); // 获取实际图像数量
swapChainImages.resize(imageCount); // 调整图像列表大小
vkGetSwapchainImagesKHR(device, swapChain, &imageCount, swapChainImages.data()); // 获取交换链中的所有图像句柄
swapChainImageFormat = surfaceFormat.format; // 保存图像格式
swapChainExtent = extent; // 保存图像分辨率
}
void createImageViews() { // 为每个交换链图像创建图像视图
swapChainImageViews.resize(swapChainImages.size()); // 调整图像视图列表大小
for (size_t i = 0; i < swapChainImages.size(); i++) { // 遍历所有交换链图像
VkImageViewCreateInfo createInfo{}; // 图像视图创建信息结构体
createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; // 结构体类型标识
createInfo.image = swapChainImages[i]; // 要创建视图的图像
createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; // 2D图像视图类型
createInfo.format = swapChainImageFormat; // 图像格式（必须与图像一致）
createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY; // 红色通道不做映射
createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY; // 绿色通道不做映射
createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY; // 蓝色通道不做映射
createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY; // Alpha通道不做映射
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // 视图包含颜色方面
createInfo.subresourceRange.baseMipLevel = 0; // 基础MIP级别为0
createInfo.subresourceRange.levelCount = 1; // MIP级别数量为1
createInfo.subresourceRange.baseArrayLayer = 0; // 基础数组层为0
createInfo.subresourceRange.layerCount = 1; // 数组层数量为1
if (vkCreateImageView(device, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS) { // 创建图像视图
throw std::runtime_error("failed to create image views!"); // 失败则抛出异常
}
}
}
void createRenderPass() { // 创建渲染通道（定义帧缓冲结构和渲染操作）
VkAttachmentDescription colorAttachment{}; // 颜色附件描述
colorAttachment.format = swapChainImageFormat; // 附件格式与交换链一致
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT; // 1倍采样（无多重采样抗锯齿）
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; // 渲染前清除附件内容
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE; // 渲染后保存附件内容
colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; // 模板加载：不关心（未使用模板）
colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; // 模板存储：不关心（未使用模板）
colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; // 渲染前图像布局（未定义，内容可丢弃）
colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; // 渲染后图像布局（适用于呈现）
VkAttachmentReference colorAttachmentRef{}; // 子通道中的附件引用
colorAttachmentRef.attachment = 0; // 引用附件数组中的第0个附件
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; // 在子通道中使用的布局
VkSubpassDescription subpass{}; // 子通道描述
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; // 这是图形管线绑定点
subpass.colorAttachmentCount = 1; // 颜色附件数量为1
subpass.pColorAttachments = &colorAttachmentRef; // 颜色附件引用数组
VkSubpassDependency dependency{}; // 子通道依赖（用于同步和布局转换）
dependency.srcSubpass = VK_SUBPASS_EXTERNAL; // 源子通道：外部（渲染通道之前）
dependency.dstSubpass = 0; // 目标子通道：子通道0
dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; // 源等待阶段：颜色输出完成
dependency.srcAccessMask = 0; // 源访问掩码：无
dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; // 目标等待阶段：颜色输出
dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; // 目标访问类型：颜色写入
VkRenderPassCreateInfo renderPassInfo{}; // 渲染通道创建信息结构体
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; // 结构体类型标识
renderPassInfo.attachmentCount = 1; // 附件数量为1
renderPassInfo.pAttachments = &colorAttachment; // 附件描述数组
renderPassInfo.subpassCount = 1; // 子通道数量为1
renderPassInfo.pSubpasses = &subpass; // 子通道描述数组
renderPassInfo.dependencyCount = 1; // 依赖数量为1
renderPassInfo.pDependencies = &dependency; // 依赖描述数组
if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS) { // 创建渲染通道
throw std::runtime_error("failed to create render pass!"); // 失败则抛出异常
}
}
void createGraphicsPipeline() { // 创建图形管线（配置固定功能状态和着色器）
auto vertShaderCode = readFile("shaders/09_shader_base.vert.spv"); // 读取顶点着色器SPIR-V字节码
auto fragShaderCode = readFile("shaders/09_shader_base.frag.spv"); // 读取片段着色器SPIR-V字节码
VkShaderModule vertShaderModule = createShaderModule(vertShaderCode); // 从字节码创建顶点着色器模块
VkShaderModule fragShaderModule = createShaderModule(fragShaderCode); // 从字节码创建片段着色器模块
VkPipelineShaderStageCreateInfo vertShaderStageInfo{}; // 顶点着色器阶段创建信息
vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; // 结构体类型标识
vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT; // 着色器阶段：顶点着色器
vertShaderStageInfo.module = vertShaderModule; // 着色器模块
vertShaderStageInfo.pName = "main"; // 入口点函数名
VkPipelineShaderStageCreateInfo fragShaderStageInfo{}; // 片段着色器阶段创建信息
fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; // 结构体类型标识
fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT; // 着色器阶段：片段着色器
fragShaderStageInfo.module = fragShaderModule; // 着色器模块
fragShaderStageInfo.pName = "main"; // 入口点函数名
VkPipelineShaderStageCreateInfo shaderStages[] = { vertShaderStageInfo, fragShaderStageInfo }; // 着色器阶段数组
VkPipelineVertexInputStateCreateInfo vertexInputInfo{}; // 顶点输入状态（描述顶点数据格式）
vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; // 结构体类型标识
vertexInputInfo.vertexBindingDescriptionCount = 0; // 顶点绑定描述数量为0（着色器中硬编码顶点）
vertexInputInfo.vertexAttributeDescriptionCount = 0; // 顶点属性描述数量为0
VkPipelineInputAssemblyStateCreateInfo inputAssembly{}; // 输入装配状态（图元拓扑）
inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; // 结构体类型标识
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; // 图元拓扑：三角形列表
inputAssembly.primitiveRestartEnable = VK_FALSE; // 不启用图元重启
VkPipelineViewportStateCreateInfo viewportState{}; // 视口和裁剪状态
viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; // 结构体类型标识
viewportState.viewportCount = 1; // 视口数量（实际值在命令缓冲区中动态设置）
viewportState.scissorCount = 1; // 裁剪矩形数量（实际值在命令缓冲区中动态设置）
VkPipelineRasterizationStateCreateInfo rasterizer{}; // 光栅化状态
rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; // 结构体类型标识
rasterizer.depthClampEnable = VK_FALSE; // 不启用深度钳制（超出近远平面的片元不丢弃而是钳制）
rasterizer.rasterizerDiscardEnable = VK_FALSE; // 不丢弃所有光栅化结果
rasterizer.polygonMode = VK_POLYGON_MODE_FILL; // 多边形填充模式（实心）
rasterizer.lineWidth = 1.0f; // 线宽为1像素
rasterizer.cullMode = VK_CULL_MODE_BACK_BIT; // 剔除背面三角形
rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE; // 顺时针顶点顺序为正面
rasterizer.depthBiasEnable = VK_FALSE; // 不启用深度偏移
VkPipelineMultisampleStateCreateInfo multisampling{}; // 多重采样状态
multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; // 结构体类型标识
multisampling.sampleShadingEnable = VK_FALSE; // 不启用采样着色（超采样）
multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; // 每像素1个采样点
VkPipelineColorBlendAttachmentState colorBlendAttachment{}; // 单个附件的颜色混合状态
colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | // 写入所有RGBA通道
VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
colorBlendAttachment.blendEnable = VK_FALSE; // 不启用混合（直接覆盖）
VkPipelineColorBlendStateCreateInfo colorBlending{}; // 颜色混合全局状态
colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; // 结构体类型标识
colorBlending.logicOpEnable = VK_FALSE; // 不启用逻辑操作
colorBlending.logicOp = VK_LOGIC_OP_COPY; // 逻辑操作类型（未使用）
colorBlending.attachmentCount = 1; // 混合附件数量
colorBlending.pAttachments = &colorBlendAttachment; // 附件混合状态数组
colorBlending.blendConstants[0] = 0.0f; // 混合常量R=0
colorBlending.blendConstants[1] = 0.0f; // 混合常量G=0
colorBlending.blendConstants[2] = 0.0f; // 混合常量B=0
colorBlending.blendConstants[3] = 0.0f; // 混合常量A=0
std::vector<VkDynamicState> dynamicStates = { // 可在命令缓冲区中动态设置的状态
VK_DYNAMIC_STATE_VIEWPORT, // 视口可动态改变
VK_DYNAMIC_STATE_SCISSOR // 裁剪矩形可动态改变
};
VkPipelineDynamicStateCreateInfo dynamicState{}; // 动态状态创建信息
dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; // 结构体类型标识
dynamicState.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size()); // 动态状态数量
dynamicState.pDynamicStates = dynamicStates.data(); // 动态状态数组
VkPipelineLayoutCreateInfo pipelineLayoutInfo{}; // 管线布局创建信息（描述着色器资源）
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; // 结构体类型标识
pipelineLayoutInfo.setLayoutCount = 0; // 描述符集布局数量为0（着色器不使用uniform）
pipelineLayoutInfo.pushConstantRangeCount = 0; // 推送常量范围数量为0
if (vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, &pipelineLayout) != VK_SUCCESS) { // 创建管线布局
throw std::runtime_error("failed to create pipeline layout!"); // 失败则抛出异常
}
VkGraphicsPipelineCreateInfo pipelineInfo{}; // 图形管线创建信息结构体
pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; // 结构体类型标识
pipelineInfo.stageCount = 2; // 着色器阶段数量（顶点+片段）
pipelineInfo.pStages = shaderStages; // 着色器阶段信息数组
pipelineInfo.pVertexInputState = &vertexInputInfo; // 顶点输入状态
pipelineInfo.pInputAssemblyState = &inputAssembly; // 输入装配状态
pipelineInfo.pViewportState = &viewportState; // 视口状态
pipelineInfo.pRasterizationState = &rasterizer; // 光栅化状态
pipelineInfo.pMultisampleState = &multisampling; // 多重采样状态
pipelineInfo.pColorBlendState = &colorBlending; // 颜色混合状态
pipelineInfo.pDynamicState = &dynamicState; // 动态状态
pipelineInfo.layout = pipelineLayout; // 管线布局
pipelineInfo.renderPass = renderPass; // 兼容的渲染通道
pipelineInfo.subpass = 0; // 在子通道0中使用
pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; // 不基于现有管线派生
if (vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &graphicsPipeline) != VK_SUCCESS) { // 创建图形管线
throw std::runtime_error("failed to create graphics pipeline!"); // 失败则抛出异常
}
vkDestroyShaderModule(device, fragShaderModule, nullptr); // 销毁片段着色器模块（已链接到管线）
vkDestroyShaderModule(device, vertShaderModule, nullptr); // 销毁顶点着色器模块（已链接到管线）
}
void createFramebuffers() { // 为每个交换链图像视图创建帧缓冲
swapChainFramebuffers.resize(swapChainImageViews.size()); // 调整帧缓冲列表大小
for (size_t i = 0; i < swapChainImageViews.size(); i++) { // 遍历所有图像视图
VkImageView attachments[] = { // 附件数组（每个帧缓冲包含一个颜色附件）
swapChainImageViews[i] // 对应的图像视图
};
VkFramebufferCreateInfo framebufferInfo{}; // 帧缓冲创建信息结构体
framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; // 结构体类型标识
framebufferInfo.renderPass = renderPass; // 兼容的渲染通道
framebufferInfo.attachmentCount = 1; // 附件数量为1
framebufferInfo.pAttachments = attachments; // 附件数组
framebufferInfo.width = swapChainExtent.width; // 帧缓冲宽度
framebufferInfo.height = swapChainExtent.height; // 帧缓冲高度
framebufferInfo.layers = 1; // 层数为1
if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, &swapChainFramebuffers[i]) != VK_SUCCESS) { // 创建帧缓冲
throw std::runtime_error("failed to create framebuffer!"); // 失败则抛出异常
}
}
}
void createCommandPool() { // 创建命令池
QueueFamilyIndices queueFamilyIndices = findQueueFamilies(physicalDevice); // 获取队列族索引
VkCommandPoolCreateInfo poolInfo{}; // 命令池创建信息结构体
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; // 结构体类型标识
poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; // 允许单独重置命令缓冲区（而非整个池）
poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value(); // 图形队列族索引
if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPool) != VK_SUCCESS) { // 创建命令池
throw std::runtime_error("failed to create command pool!"); // 失败则抛出异常
}
}
void createCommandBuffers() { // 分配命令缓冲区（每帧一个）
commandBuffers.resize(MAX_FRAMES_IN_FLIGHT); // 调整命令缓冲区列表大小
VkCommandBufferAllocateInfo allocInfo{}; // 命令缓冲区分配信息结构体
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; // 结构体类型标识
allocInfo.commandPool = commandPool; // 分配来源命令池
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; // 主命令缓冲区（可直接提交）
allocInfo.commandBufferCount = (uint32_t)commandBuffers.size(); // 分配数量等于飞行帧数
if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data()) != VK_SUCCESS) { // 分配命令缓冲区
throw std::runtime_error("failed to allocate command buffers!"); // 失败则抛出异常
}
}
void recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) { // 录制渲染命令
VkCommandBufferBeginInfo beginInfo{}; // 命令缓冲区开始录制信息
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; // 结构体类型标识
if (vkBeginCommandBuffer(commandBuffer, &beginInfo) != VK_SUCCESS) { // 开始录制命令缓冲区
throw std::runtime_error("failed to begin recording command buffer!"); // 失败则抛出异常
}
VkRenderPassBeginInfo renderPassInfo{}; // 渲染通道开始信息
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; // 结构体类型标识
renderPassInfo.renderPass = renderPass; // 渲染通道
renderPassInfo.framebuffer = swapChainFramebuffers[imageIndex]; // 当前图像对应的帧缓冲
renderPassInfo.renderArea.offset = { 0, 0 }; // 渲染区域起点为(0,0)
renderPassInfo.renderArea.extent = swapChainExtent; // 渲染区域大小等于交换链分辨率
VkClearValue clearColor = { {{0.0f, 0.0f, 0.0f, 1.0f}} }; // 清除值：黑色（RGBA）
renderPassInfo.clearValueCount = 1; // 清除值数量为1
renderPassInfo.pClearValues = &clearColor; // 清除值数组
vkCmdBeginRenderPass(commandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE); // 开始渲染通道（命令内联录制）
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline); // 绑定图形管线
VkViewport viewport{}; // 视口定义
viewport.x = 0.0f; // 视口左上角X坐标
viewport.y = 0.0f; // 视口左上角Y坐标
viewport.width = (float)swapChainExtent.width; // 视口宽度等于交换链宽度
viewport.height = (float)swapChainExtent.height; // 视口高度等于交换链高度
viewport.minDepth = 0.0f; // 最小深度值
viewport.maxDepth = 1.0f; // 最大深度值
vkCmdSetViewport(commandBuffer, 0, 1, &viewport); // 动态设置视口
VkRect2D scissor{}; // 裁剪矩形定义
scissor.offset = { 0, 0 }; // 裁剪矩形左上角
scissor.extent = swapChainExtent; // 裁剪矩形大小等于交换链分辨率
vkCmdSetScissor(commandBuffer, 0, 1, &scissor); // 动态设置裁剪矩形
vkCmdDraw(commandBuffer, 3, 1, 0, 0); // 绘制命令：3个顶点，1个实例，首顶点偏移0，首实例偏移0
vkCmdEndRenderPass(commandBuffer); // 结束渲染通道
if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) { // 结束录制命令缓冲区
throw std::runtime_error("failed to record command buffer!"); // 失败则抛出异常
}
}
void createSyncObjects() { // 创建同步对象（信号量和栅栏）
imageAvailableSemaphores.resize(MAX_FRAMES_IN_FLIGHT); // 调整信号量列表大小
renderFinishedSemaphores.resize(MAX_FRAMES_IN_FLIGHT); // 调整信号量列表大小
inFlightFences.resize(MAX_FRAMES_IN_FLIGHT); // 调整栅栏列表大小
VkSemaphoreCreateInfo semaphoreInfo{}; // 信号量创建信息结构体
semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; // 结构体类型标识
VkFenceCreateInfo fenceInfo{}; // 栅栏创建信息结构体
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; // 结构体类型标识
fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT; // 创建时即设为已触发状态（避免第一帧死锁）
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) { // 为每个飞行帧创建同步对象
if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) != VK_SUCCESS || // 创建图像可用信号量
vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) != VK_SUCCESS || // 创建渲染完成信号量
vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS) { // 创建飞行栅栏
throw std::runtime_error("failed to create synchronization objects for a frame!"); // 任一失败则抛出异常
}
}
}
void drawFrame() { // 绘制一帧
vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX); // 等待当前帧的栅栏被触发（上一帧完成）
uint32_t imageIndex; // 交换链图像索引
VkResult result = vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, // 获取下一个可用的交换链图像
imageAvailableSemaphores[currentFrame], // 图像获取完成后触发此信号量
VK_NULL_HANDLE, &imageIndex); // 不使用栅栏，输出图像索引
if (result == VK_ERROR_OUT_OF_DATE_KHR) { // 交换链已过时（如窗口调整大小）
recreateSwapChain(); // 重建交换链
return; // 跳过本帧
}
else if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) { // 未预期错误
throw std::runtime_error("failed to acquire swap chain image!"); // 抛出异常
}
vkResetFences(device, 1, &inFlightFences[currentFrame]); // 手动重置栅栏为未触发状态
vkResetCommandBuffer(commandBuffers[currentFrame], /*VkCommandBufferResetFlagBits*/ 0); // 重置当前帧的命令缓冲区
recordCommandBuffer(commandBuffers[currentFrame], imageIndex); // 录制渲染命令
VkSubmitInfo submitInfo{}; // 队列提交信息结构体
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; // 结构体类型标识
VkSemaphore waitSemaphores[] = { imageAvailableSemaphores[currentFrame] }; // GPU等待：图像获取完成信号量
VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT }; // 等待的阶段：颜色输出
submitInfo.waitSemaphoreCount = 1; // 等待1个信号量
submitInfo.pWaitSemaphores = waitSemaphores; // 等待信号量数组
submitInfo.pWaitDstStageMask = waitStages; // 每个信号量对应的等待阶段
submitInfo.commandBufferCount = 1; // 提交1个命令缓冲区
submitInfo.pCommandBuffers = &commandBuffers[currentFrame]; // 命令缓冲区数组
VkSemaphore signalSemaphores[] = { renderFinishedSemaphores[currentFrame] }; // 渲染完成后触发此信号量
submitInfo.signalSemaphoreCount = 1; // 触发1个信号量
submitInfo.pSignalSemaphores = signalSemaphores; // 触发信号量数组
if (vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]) != VK_SUCCESS) { // 提交到图形队列，完成后触发栅栏
throw std::runtime_error("failed to submit draw command buffer!"); // 失败则抛出异常
}
VkPresentInfoKHR presentInfo{}; // 呈现信息结构体
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; // 结构体类型标识
presentInfo.waitSemaphoreCount = 1; // 等待1个信号量
presentInfo.pWaitSemaphores = signalSemaphores; // 等待渲染完成信号量
VkSwapchainKHR swapChains[] = { swapChain }; // 交换链数组
presentInfo.swapchainCount = 1; // 1个交换链
presentInfo.pSwapchains = swapChains; // 交换链数组指针
presentInfo.pImageIndices = &imageIndex; // 要呈现的图像索引
result = vkQueuePresentKHR(presentQueue, &presentInfo); // 将图像提交到呈现队列
if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR || // 交换链过时或次优
framebufferResized) { // 或窗口大小已改变
framebufferResized = false; // 重置窗口改变标志
recreateSwapChain(); // 重建交换链
}
else if (result != VK_SUCCESS) { // 未预期错误
throw std::runtime_error("failed to present swap chain image!"); // 抛出异常
}
currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT; // 循环递增当前帧索引
}
VkShaderModule createShaderModule(const std::vector<char>& code) { // 从SPIR-V字节码创建着色器模块
VkShaderModuleCreateInfo createInfo{}; // 着色器模块创建信息
createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; // 结构体类型标识
createInfo.codeSize = code.size(); // 字节码大小（字节数）
createInfo.pCode = reinterpret_cast<const uint32_t*>(code.data()); // 字节码数据指针（SPIR-V要求uint32_t对齐）
VkShaderModule shaderModule; // 着色器模块句柄
if (vkCreateShaderModule(device, &createInfo, nullptr, &shaderModule) != VK_SUCCESS) { // 创建着色器模块
throw std::runtime_error("failed to create shader module!"); // 失败则抛出异常
}
return shaderModule; // 返回着色器模块
}
VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats) { // 选择最佳表面格式
for (const auto& availableFormat : availableFormats) { // 遍历可用格式
if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB && // BGRA 8位SRGB格式
availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) { // SRGB非线性颜色空间
return availableFormat; // 找到首选格式，直接返回
}
}
return availableFormats[0]; // 找不到首选格式，返回第一个可用格式
}
VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes) { // 选择最佳呈现模式
for (const auto& availablePresentMode : availablePresentModes) { // 遍历可用呈现模式
if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR) { // 邮箱模式（三重缓冲，低延迟）
return availablePresentMode; // 返回邮箱模式
}
}
return VK_PRESENT_MODE_FIFO_KHR; // 所有Vulkan实现必须支持FIFO（类似垂直同步）
}
VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities) { // 选择交换链分辨率
if (capabilities.currentExtent.width != std::numeric_limits<uint32_t>::max()) { // 如果当前分辨率不是特殊值（表示可任意选择）
return capabilities.currentExtent; // 直接使用当前分辨率
}
else { // 需要手动匹配窗口大小
int width, height; // 窗口尺寸变量
glfwGetFramebufferSize(window, &width, &height); // 获取GLFW窗口的帧缓冲大小
VkExtent2D actualExtent = { // 实际分辨率
static_cast<uint32_t>(width), // 宽度转为uint32_t
static_cast<uint32_t>(height) // 高度转为uint32_t
};
actualExtent.width = std::clamp(actualExtent.width, // 将宽度限制在最小和最大值之间
capabilities.minImageExtent.width,
capabilities.maxImageExtent.width);
actualExtent.height = std::clamp(actualExtent.height, // 将高度限制在最小和最大值之间
capabilities.minImageExtent.height,
capabilities.maxImageExtent.height);
return actualExtent; // 返回限制后的分辨率
}
}
SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device) { // 查询物理设备的交换链支持详情
SwapChainSupportDetails details; // 创建详情结构体
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities); // 获取表面能力
uint32_t formatCount; // 支持的格式数量
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr); // 先查询数量
if (formatCount != 0) { // 如果有支持的格式
details.formats.resize(formatCount); // 调整列表大小
vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data()); // 获取所有格式
}
uint32_t presentModeCount; // 支持的呈现模式数量
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr); // 先查询数量
if (presentModeCount != 0) { // 如果有支持的呈现模式
details.presentModes.resize(presentModeCount); // 调整列表大小
vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data()); // 获取所有呈现模式
}
return details; // 返回完整详情
}
bool isDeviceSuitable(VkPhysicalDevice device) { // 判断物理设备是否满足需求
QueueFamilyIndices indices = findQueueFamilies(device); // 查找队列族
bool extensionsSupported = checkDeviceExtensionSupport(device); // 检查设备扩展支持
bool swapChainAdequate = false; // 交换链是否满足条件
if (extensionsSupported) { // 只有扩展支持时才检查交换链
SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device); // 查询交换链支持
swapChainAdequate = !swapChainSupport.formats.empty() && // 至少有一种格式
!swapChainSupport.presentModes.empty(); // 至少有一种呈现模式
}
return indices.isComplete() && extensionsSupported && swapChainAdequate; // 所有条件都满足才合适
}
bool checkDeviceExtensionSupport(VkPhysicalDevice device) { // 检查物理设备是否支持所需扩展
uint32_t extensionCount; // 扩展数量
vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr); // 获取扩展数量
std::vector<VkExtensionProperties> availableExtensions(extensionCount); // 可用扩展列表
vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, availableExtensions.data()); // 获取所有扩展属性
std::set<std::string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end()); // 将所需扩展放入集合
for (const auto& extension : availableExtensions) { // 遍历所有可用扩展
requiredExtensions.erase(extension.extensionName); // 从所需集合中移除已存在的扩展
}
return requiredExtensions.empty(); // 集合为空说明所有所需扩展都支持
}
QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device) { // 查找物理设备的队列族索引
QueueFamilyIndices indices; // 创建队列族索引结构体
uint32_t queueFamilyCount = 0; // 队列族数量
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr); // 获取队列族数量
std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount); // 队列族属性列表
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data()); // 获取所有队列族属性
int i = 0; // 当前队列族索引
for (const auto& queueFamily : queueFamilies) { // 遍历所有队列族
if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) { // 检查是否支持图形操作
indices.graphicsFamily = i; // 记录图形队列族索引
}
VkBool32 presentSupport = false; // 呈现支持标志
vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport); // 检查是否支持呈现到表面
if (presentSupport) { // 如果支持呈现
indices.presentFamily = i; // 记录呈现队列族索引
}
if (indices.isComplete()) { // 如果已找到所有需要的队列族
break; // 提前结束搜索
}
i++; // 递增索引
}
return indices; // 返回队列族索引
}
std::vector<const char*> getRequiredExtensions() { // 获取应用程序所需的Vulkan实例扩展
uint32_t glfwExtensionCount = 0; // GLFW所需扩展数量
const char** glfwExtensions; // GLFW所需扩展名称数组
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount); // 获取GLFW所需的Vulkan扩展
std::vector<const char*> extensions(glfwExtensions, glfwExtensions + glfwExtensionCount); // 创建扩展列表并复制GLFW扩展
if (enableValidationLayers) { // 如果启用了验证层
extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME); // 添加调试工具扩展
}
return extensions; // 返回扩展列表
}
bool checkValidationLayerSupport() { // 检查请求的验证层是否可用
uint32_t layerCount; // 可用的实例层数量
vkEnumerateInstanceLayerProperties(&layerCount, nullptr); // 获取层数量
std::vector<VkLayerProperties> availableLayers(layerCount); // 可用层属性列表
vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data()); // 获取所有可用层属性
for (const char* layerName : validationLayers) { // 遍历所有请求的验证层
bool layerFound = false; // 标记是否找到
for (const auto& layerProperties : availableLayers) { // 遍历所有可用层
if (strcmp(layerName, layerProperties.layerName) == 0) { // 比较层名称
layerFound = true; // 找到了该层
break; // 跳出内层循环
}
}
if (!layerFound) { // 如果某层未找到
return false; // 返回不支持
}
}
return true; // 所有请求的层都可用
}
static std::vector<char> readFile(const std::string& filename) { // 读取文件为字节数组（用于读取着色器）
std::ifstream file(filename, std::ios::ate | std::ios::binary); // 以二进制模式打开，并定位到文件末尾
if (!file.is_open()) { // 如果文件打开失败
throw std::runtime_error("failed to open file!"); // 抛出异常
}
size_t fileSize = (size_t)file.tellg(); // 获取文件大小（tellg返回当前位置，即文件末尾）
std::vector<char> buffer(fileSize); // 创建合适大小的缓冲区
file.seekg(0); // 回到文件开头
file.read(buffer.data(), fileSize); // 读取全部文件内容
file.close(); // 关闭文件
return buffer; // 返回字节数组
}
static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback( // 调试回调函数（验证层消息处理）
VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, // 消息严重性级别
VkDebugUtilsMessageTypeFlagsEXT messageType, // 消息类型
const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, // 回调数据（包含消息字符串）
void* pUserData) { // 用户自定义数据（未使用）
std::cerr << "validation layer: " << pCallbackData->pMessage << std::endl; // 输出验证层消息到标准错误流
return VK_FALSE; // VK_FALSE表示不中断API调用（VK_TRUE会中断）
}
};
int main() { // 程序入口点
HelloTriangleApplication app; // 创建应用程序实例
try { // 异常处理块
app.run(); // 运行应用程序
}
catch (const std::exception& e) { // 捕获标准异常
std::cerr << e.what() << std::endl; // 输出错误信息
return EXIT_FAILURE; // 返回失败退出码
}
return EXIT_SUCCESS; // 正常退出，返回成功退出码
}
...全文
请发表友善的回复…
发表回复
