xsl/face_sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c6db16a52b187af9e47b2497e1be568703f3108d
face_sdk/vulkan/Application.cpp
T

783 lines
28 KiB
C++
Raw Blame History

#include "Application.h"
#include <iostream>
#include <string>
using namespace std;
#ifdef _WIN32
#else
#include <game-activity/native_app_glue/android_native_app_glue.h>
#include <game-activity/GameActivity.h>
#include <vulkan/vulkan_android.h>
#include "../app/src/main/cpp/AndroidOut.h"
#endif
void Application::initWindow()
{
#ifdef _WIN32
glfwInit();
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
window = glfwCreateWindow(480, 480, "Vulkan", nullptr, nullptr);
#else
#endif
}
void Application::run()
{
initVulkan();
cout << "initVulkan finished" << endl;
mainLoop();
cleanup();
}
#ifdef _WIN32
#else
extern android_app* g_android_app;
#endif
void Application::createSurface() {
#ifdef _WIN32
if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS) {
throw std::runtime_error("failed to create window surface!");
}
#else
//VkSurfaceKHR surface{};
VkAndroidSurfaceCreateInfoKHR info{VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR};
info.window = g_android_app->window;
VK_CHECK(vkCreateAndroidSurfaceKHR(instance, &info, nullptr, &surface));
#endif
}
void Application::initVulkan()
{
initWindow();
createInstance(); // 创建 Vulkan 实例
setupDebugMessenger(); // 在这里调用
createSurface(); // 创建窗口表面
pickPhysicalDevice(physicalDevice, surface); // 选择物理设备
createLogicalDevice(); // 创建逻辑设备
createSwapChain(); // 创建交换链
createImageViews(); // 创建交换链图像视图
createRenderPass(); // 创建渲染流程
createPipelineLayout(); // 在这里调用
createGraphicsPipeline(); // 创建图形管线
createFramebuffers(); // 创建帧缓冲区
createCommandPool(); // 创建命令池
createCommandBuffer(); // 创建命令缓冲区
createSyncObjects(); // 创建同步对象
inited = true;
}
void Application::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;
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;
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
createInfo.subresourceRange.baseMipLevel = 0;
createInfo.subresourceRange.levelCount = 1;
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 Application::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 Application::mainLoop()
{
#ifdef _WIN32
while (!glfwWindowShouldClose(window))
{
glfwPollEvents();
drawFrame(); // 在这里调用
}
#else
#endif
vkDeviceWaitIdle(device); // 等待设备空闲
}
void Application::createLogicalDevice() {
QueueFamilyIndices indices = findQueueFamilies(physicalDevice, surface);
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;
// 启用交换链扩展
const std::vector<const char*> deviceExtensions = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME
};
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 Application::createSwapChain() {
// 选择交换链格式、颜色空间和分辨率
VkSurfaceFormatKHR surfaceFormat = { VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };
VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
VkSurfaceCapabilitiesKHR surface_capabilities{};
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(this->physicalDevice, this->surface, &surface_capabilities);
VkExtent2D extent = surface_capabilities.currentExtent;
uint32_t imageCount = 2;
// 创建交换链
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;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
QueueFamilyIndices indices = findQueueFamilies(physicalDevice, surface);
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.queueFamilyIndexCount = 0; // Optional
createInfo.pQueueFamilyIndices = nullptr; // Optional
}
createInfo.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
createInfo.oldSwapchain = VK_NULL_HANDLE;
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 Application::createPipelineLayout() {
VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pipelineLayoutInfo.setLayoutCount = 0; // 可选：描述符集布局
pipelineLayoutInfo.pSetLayouts = nullptr; // 可选：描述符集布局
pipelineLayoutInfo.pushConstantRangeCount = 0; // 可选：推送常量范围
pipelineLayoutInfo.pPushConstantRanges = nullptr; // 可选：推送常量范围
if (vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, &pipelineLayout) != VK_SUCCESS) {
throw std::runtime_error("failed to create pipeline layout!");
}
}
void Application::createGraphicsPipeline() {
// 顶点着色器和片段着色器
auto vertShaderCode = readFile("shaders/simple_shader.vert.spv");
auto fragShaderCode = readFile("shaders/simple_shader.frag.spv");
// 创建着色器模块
VkShaderModule vertShaderModule = createShaderModule(this->device, vertShaderCode);
VkShaderModule fragShaderModule = createShaderModule(this->device, 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;
vertexInputInfo.pVertexBindingDescriptions = nullptr;
vertexInputInfo.vertexAttributeDescriptionCount = 0;
vertexInputInfo.pVertexAttributeDescriptions = nullptr;
// 输入组装状态
VkPipelineInputAssemblyStateCreateInfo inputAssembly{};
inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
inputAssembly.primitiveRestartEnable = VK_FALSE;
// 视口状态
VkViewport viewport{};
viewport.x = 0.0f;
viewport.y = 0.0f;
viewport.width = (float)swapChainExtent.width;
viewport.height = (float)swapChainExtent.height;
viewport.minDepth = 0.0f;
viewport.maxDepth = 1.0f;
VkRect2D scissor{};
scissor.offset = { 0, 0 };
scissor.extent = swapChainExtent;
VkPipelineViewportStateCreateInfo viewportState{};
viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
viewportState.viewportCount = 1;
viewportState.pViewports = &viewport;
viewportState.scissorCount = 1;
viewportState.pScissors = &scissor;
// 光栅化状态
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_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;
// 颜色混合状态
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.attachmentCount = 1;
colorBlending.pAttachments = &colorBlendAttachment;
// 创建图形管线
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.layout = pipelineLayout;
pipelineInfo.renderPass = renderPass;
pipelineInfo.subpass = 0;
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 Application::createRenderPass() {
VkAttachmentDescription colorAttachment{};
colorAttachment.format = swapChainImageFormat;
colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
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;
colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass{};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &colorAttachmentRef;
VkRenderPassCreateInfo renderPassInfo{};
renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassInfo.attachmentCount = 1;
renderPassInfo.pAttachments = &colorAttachment;
renderPassInfo.subpassCount = 1;
renderPassInfo.pSubpasses = &subpass;
if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS) {
throw std::runtime_error("failed to create render pass!");
}
}
void Application::createCommandPool() {
QueueFamilyIndices queueFamilyIndices = findQueueFamilies(physicalDevice, surface);
VkCommandPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; // 添加标志
if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPool) != VK_SUCCESS) {
throw std::runtime_error("failed to create command pool!");
}
}
void Application::createCommandBuffer()
{
//std::vector<VkCommandBuffer> commandBuffers = { commandBuffers_Left, commandBuffers_Right };
VkCommandBufferAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.commandPool = commandPool;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandBufferCount = 1;
if (vkAllocateCommandBuffers(device, &allocInfo, &commandBuffers_Left) != VK_SUCCESS) {
throw std::runtime_error("failed to allocate command buffers!");
}
if (vkAllocateCommandBuffers(device, &allocInfo, &commandBuffers_Right) != VK_SUCCESS) {
throw std::runtime_error("failed to allocate command buffers!");
}
}
void Application::createSyncObjects()
{
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;
vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores_Left);
vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores_Right);
vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores_Left);
vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores_Right);
vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences_Left);
vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences_Right);
}
void Application::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex)
{
VkCommandBufferBeginInfo beginInfo{};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
beginInfo.flags = 0; // 可选标志
beginInfo.pInheritanceInfo = nullptr; // 仅用于次级命令缓冲区
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]; // 使用正确的imageIndex
renderPassInfo.renderArea.offset = { 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);
// 绘制三角形
vkCmdDraw(commandBuffer, 3, 1, 0, 0);
// 结束渲染流程
vkCmdEndRenderPass(commandBuffer);
if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) {
throw std::runtime_error("failed to record command buffer!");
}
}
void Application::drawLeft()
{
cout << "call drawLeft curFrame:" << to_string(currentFrame) << endl;
// 1. 等待前一帧完成
vkWaitForFences(device, 1, &inFlightFences_Left, VK_TRUE, UINT64_MAX);
cout << "vkWaitForFences inFlightFences_Left" << endl;
// 2. 获取交换链图像 - 使用当前帧的信号量
uint32_t imageIndex;
VkResult result = vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, imageAvailableSemaphores_Left, VK_NULL_HANDLE, &imageIndex);
cout << "vkAcquireNextImageKHR set imageAvailableSemaphores_Left ImageIndex:" << to_string(imageIndex) << endl;
if (result != VK_SUCCESS) {
throw std::runtime_error("failed to acquire swap chain image!");
}
if (imageIndex == 0)
{
// 3. 检查该图像是否正在被之前的帧使用
if (imagesInFlight_Left != VK_NULL_HANDLE) {
cout << "vkWaitForFences imagesInFlight_Left ImageIndex:" << to_string(imageIndex) << endl;
vkWaitForFences(device, 1, &imagesInFlight_Left, VK_TRUE, UINT64_MAX);
}
else
{
cout << "imagesInFlight_Left is NULL" << endl;
}
cout << "imagesInFlight_Left = inFlightFences_Left ImageIndex:" << to_string(imageIndex) << endl;
// 标记该图像正在被当前帧使用
imagesInFlight_Left = inFlightFences_Left;
}
else
{
// 3. 检查该图像是否正在被之前的帧使用
if (imagesInFlight_Right != VK_NULL_HANDLE) {
cout << "vkWaitForFences imagesInFlight_Right ImageIndex:" << to_string(imageIndex) << endl;
vkWaitForFences(device, 1, &imagesInFlight_Right, VK_TRUE, UINT64_MAX);
}
cout << "imagesInFlight_Right = inFlightFences_Left ImageIndex:" << to_string(imageIndex) << endl;
imagesInFlight_Right = inFlightFences_Left;
}
cout << "vkResetFences inFlightFences_Left" << endl;
// 4. 重置栅栏
vkResetFences(device, 1, &inFlightFences_Left);
cout << "Process commandBuffers_Left" << endl;
// 5. 记录命令缓冲区
vkResetCommandBuffer(commandBuffers_Left, 0);
recordCommandBuffer(commandBuffers_Left, imageIndex);
// 6. 提交命令缓冲区
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
// 等待图像获取完成
VkSemaphore waitSemaphores[] = { imageAvailableSemaphores_Left };
VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = waitSemaphores;
submitInfo.pWaitDstStageMask = waitStages;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &commandBuffers_Left;
VkSemaphore signalSemaphores[1];
if (imageIndex == 0)
{
cout << "renderFinishedSemaphores_Left ImageIndex:" << to_string(imageIndex) << endl;
// 使用对应图像的渲染完成信号量
signalSemaphores[0] = { renderFinishedSemaphores_Left };
}
else
{
cout << "renderFinishedSemaphores_Right ImageIndex:" << to_string(imageIndex) << endl;
// 使用对应图像的渲染完成信号量
signalSemaphores[0] = { renderFinishedSemaphores_Right };
}
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = signalSemaphores;
cout << "vkQueueSubmit inFlightFences_Left" << endl;
if (vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences_Left) != VK_SUCCESS) {
throw std::runtime_error("failed to submit draw command buffer!");
}
// 7. 呈现图像
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;
cout << "Present Left \n" << endl;
result = vkQueuePresentKHR(presentQueue, &presentInfo);
if (result != VK_SUCCESS) {
throw std::runtime_error("failed to present swap chain image!");
}
}
void Application::drawRight()
{
cout << "call drawRight curFrame:" << to_string(currentFrame) << endl;
// 1. 等待前一帧完成
vkWaitForFences(device, 1, &inFlightFences_Right, VK_TRUE, UINT64_MAX);
cout << "vkWaitForFences inFlightFences_Right" << endl;
// 2. 获取交换链图像 - 使用当前帧的信号量
uint32_t imageIndex;
VkResult result = vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, imageAvailableSemaphores_Right, VK_NULL_HANDLE, &imageIndex);
cout << "vkAcquireNextImageKHR set imageAvailableSemaphores_Right ImageIndex:" << to_string(imageIndex) << endl;
if (result != VK_SUCCESS) {
throw std::runtime_error("failed to acquire swap chain image!");
}
if (imageIndex == 0)
{
// 3. 检查该图像是否正在被之前的帧使用
if (imagesInFlight_Left != VK_NULL_HANDLE) {
cout << "vkWaitForFences imagesInFlight_Left ImageIndex:0" << endl;
vkWaitForFences(device, 1, &imagesInFlight_Left, VK_TRUE, UINT64_MAX);
}
cout << "imagesInFlight_Left = inFlightFences_Right ImageIndex:0" << endl;
// 标记该图像正在被当前帧使用
imagesInFlight_Left = inFlightFences_Right;
}
else
{
// 3. 检查该图像是否正在被之前的帧使用
if (imagesInFlight_Right != VK_NULL_HANDLE) {
cout << "vkWaitForFences imagesInFlight_Right ImageIndex:1" << endl;
vkWaitForFences(device, 1, &imagesInFlight_Right, VK_TRUE, UINT64_MAX);
}
else {
cout << "imagesInFlight_Right is NULL" << endl;
}
cout << "imagesInFlight_Right = inFlightFences_Right ImageIndex:1" << endl;
imagesInFlight_Right = inFlightFences_Right;
}
cout << "vkResetFences inFlightFences_Right" << endl;
// 4. 重置栅栏
vkResetFences(device, 1, &inFlightFences_Right);
cout << "Process commandBuffers_Right" << endl;
// 5. 记录命令缓冲区
vkResetCommandBuffer(commandBuffers_Right, 0);
recordCommandBuffer(commandBuffers_Right, imageIndex);
// 6. 提交命令缓冲区
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
// 等待图像获取完成
VkSemaphore waitSemaphores[] = { imageAvailableSemaphores_Right };
VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = waitSemaphores;
submitInfo.pWaitDstStageMask = waitStages;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &commandBuffers_Right;
VkSemaphore signalSemaphores[1];
if (imageIndex == 0)
{
cout << "renderFinishedSemaphores_Left ImageIndex:0" << endl;
// 使用对应图像的渲染完成信号量
signalSemaphores[0] = { renderFinishedSemaphores_Left };
}
else
{
cout << "renderFinishedSemaphores_Right ImageIndex:1" << endl;
// 使用对应图像的渲染完成信号量
signalSemaphores[0] = { renderFinishedSemaphores_Right };
}
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = signalSemaphores;
cout << "vkQueueSubmit inFlightFences_Right" << endl;
if (vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences_Right) != VK_SUCCESS) {
throw std::runtime_error("failed to submit draw command buffer!");
}
// 7. 呈现图像
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;
cout << "Present Right \n" << endl;
result = vkQueuePresentKHR(presentQueue, &presentInfo);
if (result != VK_SUCCESS) {
throw std::runtime_error("failed to present swap chain image!");
}
}
void Application::drawFrame()
{
if (currentFrame % 2 == 0)
{
drawLeft();
}
else
{
drawRight();
}
currentFrame++;
}
void DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator) {
auto func = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");
if (func != nullptr) {
func(instance, debugMessenger, pAllocator);
}
}
void Application::cleanup() {
if (enableValidationLayers) {
DestroyDebugUtilsMessengerEXT(instance, debugMessenger, nullptr);
}
// 等待设备空闲，确保所有命令都完成
vkDeviceWaitIdle(device);
// 正确销毁所有同步对象
vkDestroySemaphore(device, imageAvailableSemaphores_Left, nullptr);
vkDestroySemaphore(device, renderFinishedSemaphores_Left, nullptr);
vkDestroyFence(device, inFlightFences_Left, nullptr);
// 正确销毁所有同步对象
vkDestroySemaphore(device, imageAvailableSemaphores_Right, nullptr);
vkDestroySemaphore(device, renderFinishedSemaphores_Right, nullptr);
vkDestroyFence(device, inFlightFences_Right, nullptr);
// 不需要手动释放commandBuffers，销毁命令池时会自动释放
// 销毁命令池
vkDestroyCommandPool(device, commandPool, nullptr);
// 销毁图形管线
vkDestroyPipeline(device, graphicsPipeline, nullptr);
// 销毁管线布局
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
// 销毁渲染流程
vkDestroyRenderPass(device, renderPass, nullptr);
// 销毁图像视图
for (auto imageView : swapChainImageViews) {
vkDestroyImageView(device, imageView, nullptr);
}
// 销毁交换链
vkDestroySwapchainKHR(device, swapChain, nullptr);
// 销毁命令池
vkDestroyCommandPool(device, commandPool, nullptr);
// 销毁逻辑设备
vkDestroyDevice(device, nullptr);
// 销毁窗口表面
vkDestroySurfaceKHR(instance, surface, nullptr);
// 销毁 Vulkan 实例
vkDestroyInstance(instance, nullptr);
#ifdef _WIN32
// 销毁 GLFW 窗口
glfwDestroyWindow(window);
// 终止 GLFW
glfwTerminate();
#endif
}
Reference in New Issue View Git Blame Copy Permalink