4
社区成员
发帖
与我相关
我的任务
分享VulKan统一缓冲区
#version 450
layout(binding = 0) uniform UniformBufferObject {
mat4 model;
mat4 view;
mat4 proj;
} ubo;
layout(location = 0) in vec2 inPosition;
layout(location = 1) in vec3 inColor;
layout(location = 0) out vec3 fragColor;
void main() {
gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition, 0.0, 1.0);
fragColor = inColor;
}
-----------------------------------------------------------------------------------------------------------------------------
#version 450
layout(location = 0) in vec3 fragColor;
layout(location = 0) out vec4 outColor;
void main() {
outColor = vec4(fragColor, 1.0);
}
-----------------------------------------------------------------------------------------------------------------------------
#define GLFW_INCLUDE_VULKAN // 让GLFW自动包含Vulkan头文件
#include <GLFW/glfw3.h> // GLFW窗口库
#include <glm/glm.hpp> // GLM数学库核心
#include <glm/gtc/matrix_transform.hpp> // GLM矩阵变换函数（旋转、平移、透视等）
#include <iostream> // 标准输入输出流
#include <fstream> // 文件读写（着色器二进制文件）
#include <stdexcept> // 标准异常处理
#include <algorithm> // 算法库（clamp等）
#include <chrono> // 高精度时钟（用于时间计算）
#include <vector> // 动态数组
#include <cstring> // 内存操作函数
#include <cstdlib> // 通用工具函数
#include <cstdint> // 固定宽度整数类型
#include <limits> // 数值极限
#include <array> // 固定大小数组
#include <optional> // 可选值（C++17）
#include <set> // 集合（用于去重）
const uint32_t WIDTH = 800; // 窗口宽度（像素）
const uint32_t HEIGHT = 600; // 窗口高度（像素）
const int MAX_FRAMES_IN_FLIGHT = 2; // 最大飞行帧数（双缓冲，CPU和GPU并行）
const std::vector<const char*> validationLayers = { "VK_LAYER_KHRONOS_validation" }; // 启用标准Vulkan验证层
const std::vector<const char*> deviceExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME }; // 需要交换链扩展
#ifdef NDEBUG // 如果是Release模式（定义了NDEBUG）
const bool enableValidationLayers = false; // 关闭验证层（提升性能）
#else // 否则是Debug模式
const bool enableValidationLayers = true; // 开启验证层（便于调试）
#endif
// 创建调试信使的辅助函数（因为它是扩展函数，需要动态加载）
VkResult CreateDebugUtilsMessengerEXT(VkInstance instance, 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; // 返回扩展不存在错误码
}
}
// 销毁调试信使的辅助函数
void DestroyDebugUtilsMessengerEXT(VkInstance instance, 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();
}
};
// 交换链支持详情结构体
struct SwapChainSupportDetails {
VkSurfaceCapabilitiesKHR capabilities; // 表面能力（最小/最大图像数、尺寸等）
std::vector<VkSurfaceFormatKHR> formats; // 支持的表面格式列表
std::vector<VkPresentModeKHR> presentModes; // 支持的呈现模式列表
};
// 顶点结构体（包含位置和颜色）
struct Vertex {
glm::vec2 pos; // 位置坐标（x, y）
glm::vec3 color; // 颜色（r, g, b）
static VkVertexInputBindingDescription getBindingDescription() { // 获取顶点缓冲绑定描述
VkVertexInputBindingDescription bindingDescription{}; // 创建绑定描述
bindingDescription.binding = 0; // 绑定索引为0
bindingDescription.stride = sizeof(Vertex); // 每个顶点占用的字节数
bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; // 逐顶点获取数据
return bindingDescription; // 返回绑定描述
}
static std::array<VkVertexInputAttributeDescription, 2> getAttributeDescriptions() { // 获取顶点属性描述（位置和颜色）
std::array<VkVertexInputAttributeDescription, 2> attributeDescriptions{}; // 创建属性描述数组，大小为2
attributeDescriptions[0].binding = 0; // 绑定索引为0
attributeDescriptions[0].location = 0; // 着色器中的location = 0
attributeDescriptions[0].format = VK_FORMAT_R32G32_SFLOAT; // 格式为2个32位浮点数（vec2）
attributeDescriptions[0].offset = offsetof(Vertex, pos); // 在Vertex结构体中的偏移量
attributeDescriptions[1].binding = 0; // 绑定索引为0
attributeDescriptions[1].location = 1; // 着色器中的location = 1
attributeDescriptions[1].format = VK_FORMAT_R32G32B32_SFLOAT; // 格式为3个32位浮点数（vec3）
attributeDescriptions[1].offset = offsetof(Vertex, color); // 在Vertex结构体中的偏移量
return attributeDescriptions; // 返回属性描述数组
}
};
// Uniform缓冲对象结构体（对着色器中的uniform块）
struct UniformBufferObject {
alignas(16) glm::mat4 model; // 模型矩阵（16字节对齐，满足std140布局）
alignas(16) glm::mat4 view; // 视图矩阵（16字节对齐）
alignas(16) glm::mat4 proj; // 投影矩阵（16字节对齐）
};
// 预定义的顶点数据（正方形四个顶点，每个顶点有颜色）
const std::vector<Vertex> vertices = {
{{-0.5f, -0.5f}, {1.0f, 0.0f, 0.0f}}, // 左下角：红色
{{0.5f, -0.5f}, {0.0f, 1.0f, 0.0f}}, // 右下角：绿色
{{0.5f, 0.5f}, {0.0f, 0.0f, 1.0f}}, // 右上角：蓝色
{{-0.5f, 0.5f}, {1.0f, 1.0f, 1.0f}} // 左上角：白色
};
// 预定义的索引数据（两个三角形组成矩形）
const std::vector<uint16_t> indices = {
0, 1, 2, // 第一个三角形（顶点0-1-2）
2, 3, 0 // 第二个三角形（顶点2-3-0）
};
// 主应用类
class HelloTriangleApplication {
public:
void run() { // 应用程序运行入口
initWindow(); // 初始化GLFW窗口
initVulkan(); // 初始化Vulkan
mainLoop(); // 进入主循环
cleanup(); // 清理所有资源
}
private:
GLFWwindow* window; // GLFW窗口指针
VkInstance instance; // Vulkan实例句柄
VkDebugUtilsMessengerEXT debugMessenger; // 调试信使句柄
VkSurfaceKHR surface; // 窗口表面句柄
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE; // 物理设备句柄（初始为空）
VkDevice device; // 逻辑设备句柄
VkQueue graphicsQueue; // 图形队列句柄
VkQueue presentQueue; // 呈现队列句柄
VkSwapchainKHR swapChain; // 交换链句柄
std::vector<VkImage> swapChainImages; // 交换链图像列表
VkFormat swapChainImageFormat; // 交换链图像格式
VkExtent2D swapChainExtent; // 交换链图像尺寸
std::vector<VkImageView> swapChainImageViews; // 交换链图像视图列表
std::vector<VkFramebuffer> swapChainFramebuffers; // 帧缓冲列表
VkRenderPass renderPass; // 渲染过程句柄
VkDescriptorSetLayout descriptorSetLayout; // 描述符集布局句柄
VkPipelineLayout pipelineLayout; // 管线布局句柄
VkPipeline graphicsPipeline; // 图形管线句柄
VkCommandPool commandPool; // 命令池句柄
VkBuffer vertexBuffer; // 顶点缓冲句柄
VkDeviceMemory vertexBufferMemory; // 顶点缓冲设备内存句柄
VkBuffer indexBuffer; // 索引缓冲句柄
VkDeviceMemory indexBufferMemory; // 索引缓冲设备内存句柄
std::vector<VkBuffer> uniformBuffers; // Uniform缓冲列表（每帧一个）
std::vector<VkDeviceMemory> uniformBuffersMemory; // Uniform缓冲内存列表
std::vector<void*> uniformBuffersMapped; // Uniform缓冲映射指针列表（CPU可访问）
VkDescriptorPool descriptorPool; // 描述符池句柄
std::vector<VkDescriptorSet> descriptorSets; // 描述符集列表（每帧一个）
std::vector<VkCommandBuffer> commandBuffers; // 命令缓冲列表（每帧一个）
std::vector<VkSemaphore> imageAvailableSemaphores; // 图像可用信号量列表
std::vector<VkSemaphore> renderFinishedSemaphores; // 渲染完成信号量列表
std::vector<VkFence> inFlightFences; // 飞行中围栏列表
uint32_t currentFrame = 0; // 当前帧索引（0或1，双缓冲轮换）
bool framebufferResized = false; // 窗口尺寸变化标志
void initWindow() { // 初始化GLFW窗口
glfwInit(); // 初始化GLFW库
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); // 设置窗口提示：不创建OpenGL上下文
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)); // 从窗口获取应用实例指针
app->framebufferResized = true; // 标记帧缓冲尺寸已变化
}
void initVulkan() { // 初始化Vulkan所有组件
createInstance(); // 创建Vulkan实例
setupDebugMessenger(); // 设置调试信使
createSurface(); // 创建窗口表面
pickPhysicalDevice(); // 选择物理设备
createLogicalDevice(); // 创建逻辑设备
createSwapChain(); // 创建交换链
createImageViews(); // 创建图像视图
createRenderPass(); // 创建渲染过程
createDescriptorSetLayout(); // 创建描述符集布局
createGraphicsPipeline(); // 创建图形管线
createFramebuffers(); // 创建帧缓冲
createCommandPool(); // 创建命令池
createVertexBuffer(); // 创建顶点缓冲
createIndexBuffer(); // 创建索引缓冲
createUniformBuffers(); // 创建Uniform缓冲
createDescriptorPool(); // 创建描述符池
createDescriptorSets(); // 创建描述符集
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() { // 清理所有资源（程序退出时调用）
cleanupSwapChain(); // 先清理交换链相关
vkDestroyPipeline(device, graphicsPipeline, nullptr); // 销毁图形管线
vkDestroyPipelineLayout(device, pipelineLayout, nullptr); // 销毁管线布局
vkDestroyRenderPass(device, renderPass, nullptr); // 销毁渲染过程
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) { // 遍历所有帧
vkDestroyBuffer(device, uniformBuffers[i], nullptr); // 销毁Uniform缓冲
vkFreeMemory(device, uniformBuffersMemory[i], nullptr); // 释放Uniform缓冲内存
}
vkDestroyDescriptorPool(device, descriptorPool, nullptr); // 销毁描述符池
vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); // 销毁描述符集布局
vkDestroyBuffer(device, indexBuffer, nullptr); // 销毁索引缓冲
vkFreeMemory(device, indexBufferMemory, nullptr); // 释放索引缓冲内存
vkDestroyBuffer(device, vertexBuffer, nullptr); // 销毁顶点缓冲
vkFreeMemory(device, vertexBufferMemory, 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); // 销毁实例
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; // 链式传递调试信息
}
else { // 如果未启用验证层
createInfo.enabledLayerCount = 0; // 层数量为0
createInfo.pNext = nullptr; // pNext为空
}
if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) { // 创建实例
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; // 回调函数指针
createInfo.pUserData = nullptr; // 用户数据指针（可选）
}
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() { // 创建窗口表面
if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS) { // 使用GLFW创建表面
throw std::runtime_error("failed to create window surface!"); // 失败抛出异常
}
}
void pickPhysicalDevice() { // 选择物理设备
uint32_t deviceCount = 0; // 设备数量
vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr); // 获取设备数量
if (deviceCount == 0) { // 如果没有支持Vulkan的设备
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() }; // 去重后的队列族集合
float queuePriority = 1.0f; // 队列优先级
for (uint32_t queueFamily : uniqueQueueFamilies) { // 遍历每个队列族
VkDeviceQueueCreateInfo queueCreateInfo{}; // 队列创建信息
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; // 结构体类型
queueCreateInfo.queueFamilyIndex = queueFamily; // 队列族索引
queueCreateInfo.queueCount = 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); // 获取图形队列
vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue); // 获取呈现队列
}
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; // 队列族数量为2
createInfo.pQueueFamilyIndices = queueFamilyIndices; // 队列族索引数组指针
}
else { // 如果队列族相同
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; // 使用独占共享模式
}
createInfo.preTransform = swapChainSupport.capabilities.currentTransform; // 预变换（与表面能力一致）
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; // 复合Alpha（不透明）
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; // R分量映射（不变）
createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY; // G分量映射
createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY; // B分量映射
createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY; // A分量映射
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // 子资源方面（颜色）
createInfo.subresourceRange.baseMipLevel = 0; // 基础Mip层级
createInfo.subresourceRange.levelCount = 1; // Mip层级数量
createInfo.subresourceRange.baseArrayLayer = 0; // 基础数组层
createInfo.subresourceRange.layerCount = 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; // 颜色附件数量
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; // 附件数量
renderPassInfo.pAttachments = &colorAttachment; // 附件描述指针
renderPassInfo.subpassCount = 1; // 子通道数量
renderPassInfo.pSubpasses = &subpass; // 子通道指针
renderPassInfo.dependencyCount = 1; // 依赖数量
renderPassInfo.pDependencies = &dependency; // 依赖指针
if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS) { // 创建渲染过程
throw std::runtime_error("failed to create render pass!"); // 失败抛出异常
}
}
void createDescriptorSetLayout() { // 创建描述符集布局
VkDescriptorSetLayoutBinding uboLayoutBinding{}; // 描述符集布局绑定
uboLayoutBinding.binding = 0; // 绑定索引为0
uboLayoutBinding.descriptorCount = 1; // 描述符数量为1
uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; // 类型：Uniform缓冲
uboLayoutBinding.pImmutableSamplers = nullptr; // 不可变采样器（无）
uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; // 着色器阶段：顶点着色器
VkDescriptorSetLayoutCreateInfo layoutInfo{}; // 描述符集布局创建信息
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; // 结构体类型
layoutInfo.bindingCount = 1; // 绑定数量
layoutInfo.pBindings = &uboLayoutBinding; // 绑定指针
if (vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &descriptorSetLayout) != VK_SUCCESS) { // 创建布局
throw std::runtime_error("failed to create descriptor set layout!"); // 失败抛出异常
}
}
void createGraphicsPipeline() { // 创建图形管线
auto vertShaderCode = readFile("shaders/22_shader_ubo.vert.spv"); // 读取顶点着色器SPIR-V文件
auto fragShaderCode = readFile("shaders/22_shader_ubo.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; // 结构体类型
auto bindingDescription = Vertex::getBindingDescription(); // 获取顶点绑定描述
auto attributeDescriptions = Vertex::getAttributeDescriptions(); // 获取顶点属性描述
vertexInputInfo.vertexBindingDescriptionCount = 1; // 绑定描述数量
vertexInputInfo.vertexAttributeDescriptionCount = static_cast<uint32_t>(attributeDescriptions.size()); // 属性描述数量
vertexInputInfo.pVertexBindingDescriptions = &bindingDescription; // 绑定描述指针
vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data(); // 属性描述指针
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; // 线宽
rasterizer.cullMode = VK_CULL_MODE_BACK_BIT; // 剔除模式：剔除背面
rasterizer.frontFace = VK_FRONT_FACE_COUNTER_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 | 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
colorBlending.blendConstants[1] = 0.0f; // 混合常量G
colorBlending.blendConstants[2] = 0.0f; // 混合常量B
colorBlending.blendConstants[3] = 0.0f; // 混合常量A
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 = 1; // 描述符集布局数量
pipelineLayoutInfo.pSetLayouts = &descriptorSetLayout; // 描述符集布局指针
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; // 子通道索引
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; // 附件数量
framebufferInfo.pAttachments = attachments; // 附件指针
framebufferInfo.width = swapChainExtent.width; // 宽度
framebufferInfo.height = swapChainExtent.height; // 高度
framebufferInfo.layers = 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 graphics command pool!"); // 失败抛出异常
}
}
void createVertexBuffer() { // 创建顶点缓冲
VkDeviceSize bufferSize = sizeof(vertices[0]) * vertices.size(); // 计算缓冲大小
VkBuffer stagingBuffer; // 暂存缓冲句柄
VkDeviceMemory stagingBufferMemory; // 暂存缓冲内存句柄
createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory); // 创建暂存缓冲（CPU可访问）
void* data; // 数据指针
vkMapMemory(device, stagingBufferMemory, 0, bufferSize, 0, &data); // 映射暂存缓冲内存到CPU
memcpy(data, vertices.data(), (size_t)bufferSize); // 将顶点数据拷贝到暂存缓冲
vkUnmapMemory(device, stagingBufferMemory); // 取消映射
createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, vertexBuffer, vertexBufferMemory); // 创建最终顶点缓冲（设备本地）
copyBuffer(stagingBuffer, vertexBuffer, bufferSize); // 从暂存缓冲复制到最终缓冲
vkDestroyBuffer(device, stagingBuffer, nullptr); // 销毁暂存缓冲
vkFreeMemory(device, stagingBufferMemory, nullptr); // 释放暂存缓冲内存
}
void createIndexBuffer() { // 创建索引缓冲
VkDeviceSize bufferSize = sizeof(indices[0]) * indices.size(); // 计算缓冲大小
VkBuffer stagingBuffer; // 暂存缓冲句柄
VkDeviceMemory stagingBufferMemory; // 暂存缓冲内存句柄
createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory); // 创建暂存缓冲
void* data; // 数据指针
vkMapMemory(device, stagingBufferMemory, 0, bufferSize, 0, &data); // 映射内存
memcpy(data, indices.data(), (size_t)bufferSize); // 拷贝索引数据
vkUnmapMemory(device, stagingBufferMemory); // 取消映射
createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, indexBuffer, indexBufferMemory); // 创建最终索引缓冲
copyBuffer(stagingBuffer, indexBuffer, bufferSize); // 复制数据
vkDestroyBuffer(device, stagingBuffer, nullptr); // 销毁暂存缓冲
vkFreeMemory(device, stagingBufferMemory, nullptr); // 释放暂存缓冲内存
}
void createUniformBuffers() { // 创建Uniform缓冲
VkDeviceSize bufferSize = sizeof(UniformBufferObject); // 计算Uniform缓冲大小
uniformBuffers.resize(MAX_FRAMES_IN_FLIGHT); // 调整Uniform缓冲列表大小
uniformBuffersMemory.resize(MAX_FRAMES_IN_FLIGHT); // 调整内存列表大小
uniformBuffersMapped.resize(MAX_FRAMES_IN_FLIGHT); // 调整映射指针列表大小
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) { // 遍历每帧
createBuffer(bufferSize, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, uniformBuffers[i], uniformBuffersMemory[i]); // 创建Uniform缓冲
vkMapMemory(device, uniformBuffersMemory[i], 0, bufferSize, 0, &uniformBuffersMapped[i]); // 映射内存到CPU（永久映射）
}
}
void createDescriptorPool() { // 创建描述符池
VkDescriptorPoolSize poolSize{}; // 描述符池大小
poolSize.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; // 描述符类型：Uniform缓冲
poolSize.descriptorCount = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT); // 描述符数量（与帧数相同）
VkDescriptorPoolCreateInfo poolInfo{}; // 描述符池创建信息
poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; // 结构体类型
poolInfo.poolSizeCount = 1; // 池大小数量
poolInfo.pPoolSizes = &poolSize; // 池大小指针
poolInfo.maxSets = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT); // 最大描述符集数量
if (vkCreateDescriptorPool(device, &poolInfo, nullptr, &descriptorPool) != VK_SUCCESS) { // 创建描述符池
throw std::runtime_error("failed to create descriptor pool!"); // 失败抛出异常
}
}
void createDescriptorSets() { // 创建描述符集
std::vector<VkDescriptorSetLayout> layouts(MAX_FRAMES_IN_FLIGHT, descriptorSetLayout); // 每个帧使用相同的布局
VkDescriptorSetAllocateInfo allocInfo{}; // 描述符集分配信息
allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; // 结构体类型
allocInfo.descriptorPool = descriptorPool; // 描述符池
allocInfo.descriptorSetCount = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT); // 描述符集数量
allocInfo.pSetLayouts = layouts.data(); // 布局指针
descriptorSets.resize(MAX_FRAMES_IN_FLIGHT); // 调整描述符集列表大小
if (vkAllocateDescriptorSets(device, &allocInfo, descriptorSets.data()) != VK_SUCCESS) { // 分配描述符集
throw std::runtime_error("failed to allocate descriptor sets!"); // 失败抛出异常
}
for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) { // 遍历每帧
VkDescriptorBufferInfo bufferInfo{}; // 描述符缓冲信息
bufferInfo.buffer = uniformBuffers[i]; // 关联的Uniform缓冲
bufferInfo.offset = 0; // 偏移量0
bufferInfo.range = sizeof(UniformBufferObject); // 范围
VkWriteDescriptorSet descriptorWrite{}; // 描述符写入
descriptorWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; // 结构体类型
descriptorWrite.dstSet = descriptorSets[i]; // 目标描述符集
descriptorWrite.dstBinding = 0; // 目标绑定索引0
descriptorWrite.dstArrayElement = 0; // 数组元素索引0
descriptorWrite.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; // 描述符类型
descriptorWrite.descriptorCount = 1; // 描述符数量
descriptorWrite.pBufferInfo = &bufferInfo; // 缓冲信息指针
vkUpdateDescriptorSets(device, 1, &descriptorWrite, 0, nullptr); // 更新描述符集
}
}
void createBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer, VkDeviceMemory& bufferMemory) { // 创建缓冲的通用函数
VkBufferCreateInfo bufferInfo{}; // 缓冲创建信息
bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; // 结构体类型
bufferInfo.size = size; // 缓冲大小
bufferInfo.usage = usage; // 缓冲用途
bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; // 独占共享模式
if (vkCreateBuffer(device, &bufferInfo, nullptr, &buffer) != VK_SUCCESS) { // 创建缓冲
throw std::runtime_error("failed to create buffer!"); // 失败抛出异常
}
VkMemoryRequirements memRequirements; // 内存需求
vkGetBufferMemoryRequirements(device, buffer, &memRequirements); // 获取内存需求
VkMemoryAllocateInfo allocInfo{}; // 内存分配信息
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; // 结构体类型
allocInfo.allocationSize = memRequirements.size; // 分配大小
allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties); // 内存类型索引
if (vkAllocateMemory(device, &allocInfo, nullptr, &bufferMemory) != VK_SUCCESS) { // 分配内存
throw std::runtime_error("failed to allocate buffer memory!"); // 失败抛出异常
}
vkBindBufferMemory(device, buffer, bufferMemory, 0); // 绑定内存到缓冲
}
void copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size) { // 复制缓冲的通用函数
VkCommandBufferAllocateInfo allocInfo{}; // 命令缓冲分配信息
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; // 结构体类型
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; // 主命令缓冲
allocInfo.commandPool = commandPool; // 命令池
allocInfo.commandBufferCount = 1; // 分配数量1
VkCommandBuffer commandBuffer; // 命令缓冲句柄
vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer); // 分配命令缓冲
VkCommandBufferBeginInfo beginInfo{}; // 命令缓冲开始信息
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; // 结构体类型
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; // 一次性提交
vkBeginCommandBuffer(commandBuffer, &beginInfo); // 开始记录命令缓冲
VkBufferCopy copyRegion{}; // 复制区域
copyRegion.size = size; // 复制大小
vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, ©Region); // 添加复制命令
vkEndCommandBuffer(commandBuffer); // 结束记录
VkSubmitInfo submitInfo{}; // 提交信息
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; // 结构体类型
submitInfo.commandBufferCount = 1; // 命令缓冲数量
submitInfo.pCommandBuffers = &commandBuffer; // 命令缓冲指针
vkQueueSubmit(graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE); // 提交到图形队列
vkQueueWaitIdle(graphicsQueue); // 等待队列空闲
vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); // 释放命令缓冲
}
uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties) { // 查找合适的内存类型
VkPhysicalDeviceMemoryProperties memProperties; // 物理设备内存属性
vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProperties); // 获取内存属性
for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) { // 遍历内存类型
if ((typeFilter & (1 << i)) && (memProperties.memoryTypes[i].propertyFlags & properties) == properties) { // 如果类型匹配且属性满足
return i; // 返回该类型索引
}
}
throw std::runtime_error("failed to find suitable memory type!"); // 未找到抛出异常
}
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}} }; // 清除颜色（黑色，不透明）
renderPassInfo.clearValueCount = 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 }; // 偏移(0,0)
scissor.extent = swapChainExtent; // 尺寸
vkCmdSetScissor(commandBuffer, 0, 1, &scissor); // 设置裁剪矩形（动态）
VkBuffer vertexBuffers[] = { vertexBuffer }; // 顶点缓冲数组
VkDeviceSize offsets[] = { 0 }; // 偏移数组
vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets); // 绑定顶点缓冲
vkCmdBindIndexBuffer(commandBuffer, indexBuffer, 0, VK_INDEX_TYPE_UINT16); // 绑定索引缓冲
vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSets[currentFrame], 0, nullptr); // 绑定描述符集
vkCmdDrawIndexed(commandBuffer, static_cast<uint32_t>(indices.size()), 1, 0, 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 updateUniformBuffer(uint32_t currentImage) { // 更新Uniform缓冲
static auto startTime = std::chrono::high_resolution_clock::now(); // 记录程序启动时间（静态，只初始化一次）
auto currentTime = std::chrono::high_resolution_clock::now(); // 获取当前时间
float time = std::chrono::duration<float, std::chrono::seconds::period>(currentTime - startTime).count(); // 计算运行秒数
UniformBufferObject ubo{}; // 创建Uniform缓冲对象
ubo.model = glm::rotate(glm::mat4(1.0f), time * glm::radians(90.0f), glm::vec3(0.0f, 0.0f, 1.0f)); // 模型矩阵：绕Z轴旋转，速度90°/秒
ubo.view = glm::lookAt(glm::vec3(2.0f, 2.0f, 2.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f)); // 视图矩阵：从(2,2,2)看向原点，上方向为Z轴
ubo.proj = glm::perspective(glm::radians(45.0f), swapChainExtent.width / (float)swapChainExtent.height, 0.1f, 10.0f); // 投影矩阵：45度FOV，宽高比，近/远平面
ubo.proj[1][1] *= -1; // 翻转Y轴（Vulkan的NDC坐标系Y向下，OpenGL向上）
memcpy(uniformBuffersMapped[currentImage], &ubo, sizeof(ubo)); // 将数据拷贝到映射的Uniform缓冲中
}
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!"); // 抛出异常
}
updateUniformBuffer(currentFrame); // 更新Uniform数据
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] }; // 等待信号量（图像可用）
VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT }; // 等待阶段（颜色附件输出）
submitInfo.waitSemaphoreCount = 1; // 等待信号量数量
submitInfo.pWaitSemaphores = waitSemaphores; // 等待信号量指针
submitInfo.pWaitDstStageMask = waitStages; // 等待阶段指针
submitInfo.commandBufferCount = 1; // 命令缓冲数量
submitInfo.pCommandBuffers = &commandBuffers[currentFrame]; // 命令缓冲指针
VkSemaphore signalSemaphores[] = { renderFinishedSemaphores[currentFrame] }; // 信号信号量（渲染完成）
submitInfo.signalSemaphoreCount = 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; // 等待信号量数量
presentInfo.pWaitSemaphores = signalSemaphores; // 等待信号量指针（渲染完成）
VkSwapchainKHR swapChains[] = { swapChain }; // 交换链数组
presentInfo.swapchainCount = 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) { // 创建着色器模块
VkShaderModuleCreateInfo createInfo{}; // 创建信息
createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; // 结构体类型
createInfo.codeSize = code.size(); // 代码大小
createInfo.pCode = reinterpret_cast<const uint32_t*>(code.data()); // 代码指针（转换为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 && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) { // 首选：BGRA8_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) { // 首选：MAILBOX（三重缓冲，无撕裂）
return availablePresentMode; // 返回MAILBOX模式
}
}
return VK_PRESENT_MODE_FIFO_KHR; // 否则使用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); // 获取帧缓冲尺寸
VkExtent2D actualExtent = { // 实际尺寸
static_cast<uint32_t>(width),
static_cast<uint32_t>(height)
};
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(); // 如果所有所需扩展都被支持，返回true
}
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() { // 获取所需实例扩展
uint32_t glfwExtensionCount = 0; // GLFW扩展数量
const char** glfwExtensions; // GLFW扩展名称列表
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount); // 获取GLFW所需扩展
std::vector<const char*> extensions(glfwExtensions, glfwExtensions + glfwExtensionCount); // 复制到vector
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; // 返回false
}
}
return true; // 所有层都找到，返回true
}
static std::vector<char> readFile(const std::string& filename) { // 读取文件到vector
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(); // 获取文件大小
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（表示不中止Vulkan调用）
}
};
int main() { // 程序入口
HelloTriangleApplication app; // 创建应用实例
try { // 尝试执行
app.run(); // 运行应用
} // try结束
catch (const std::exception& e) { // 捕获异常
std::cerr << e.what() << std::endl; // 输出异常信息
return EXIT_FAILURE; // 返回失败码
} // catch结束
return EXIT_SUCCESS; // 返回成功码
} // main函数结束
...全文
请发表友善的回复…
发表回复
