完成三角形渲染的 msaa8x 抗锯齿

vulkan/Application.cpp

@@ -1,4 +1,8 @@
 #include "Application.h"
+#include <iostream>
+#include <string>
+
+using namespace std;
 
 #ifdef _WIN32
 
@@ -28,6 +32,7 @@ void Application::initWindow()
 void Application::run()
 {
 	initVulkan();
+	cout << "initVulkan finished" << endl;
 	mainLoop();
 	cleanup();
 }
@@ -65,7 +70,9 @@ void Application::initVulkan()
 	pickPhysicalDevice(physicalDevice, surface);      // 选择物理设备
 	createLogicalDevice();     // 创建逻辑设备
 	createSwapChain();         // 创建交换链
+	createImages();
 	createImageViews();        // 创建交换链图像视图
+	createColorResources();
 	createRenderPass();        // 创建渲染流程
 	createPipelineLayout(); // 在这里调用
 	createGraphicsPipeline();  // 创建图形管线
@@ -76,6 +83,14 @@ void Application::initVulkan()
 	inited = true;
 }
 
+void Application::createImages()
+{
+	uint32_t imageCount = 0;
+	vkGetSwapchainImagesKHR(device, swapChain, &imageCount, nullptr);
+	swapChainImages.resize(imageCount);
+	vkGetSwapchainImagesKHR(device, swapChain, &imageCount, swapChainImages.data());
+}
+
 void Application::createImageViews() {
 	swapChainImageViews.resize(swapChainImages.size());
 
@@ -100,20 +115,23 @@ void Application::createImageViews() {
 		}
 	}
 }
-
+void Application::createFramebuffers() 
-void Application::createFramebuffers() {
+{
 	swapChainFramebuffers.resize(swapChainImageViews.size());
 
-	for (size_t i = 0; i < swapChainImageViews.size(); i++) {
+	for (size_t i = 0; i < swapChainImageViews.size(); i++) 
-		VkImageView attachments[] = {
+	{
-			swapChainImageViews[i]
+		std::vector<VkImageView> attachments = 
+		{
+			colorImageView,           // 0: MSAA color attachment
+			swapChainImageViews[i]    // 1: resolve target (swapchain)
 		};
 
 		VkFramebufferCreateInfo framebufferInfo{};
 		framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
 		framebufferInfo.renderPass = renderPass;
-		framebufferInfo.attachmentCount = 1;
+		framebufferInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
-		framebufferInfo.pAttachments = attachments;
+		framebufferInfo.pAttachments = attachments.data();
 		framebufferInfo.width = swapChainExtent.width;
 		framebufferInfo.height = swapChainExtent.height;
 		framebufferInfo.layers = 1;
@@ -227,16 +245,12 @@ void Application::createSwapChain() {
 		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;
-	MAX_FRAMES_IN_FLIGHT = imageCount;
 }
 
+
+
 void Application::createPipelineLayout() {
 	VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
 	pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
@@ -323,7 +337,7 @@ void Application::createGraphicsPipeline() {
 	VkPipelineMultisampleStateCreateInfo multisampling{};
 	multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
 	multisampling.sampleShadingEnable = VK_FALSE;
-	multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+	multisampling.rasterizationSamples = VK_SAMPLE_COUNT_8_BIT;
 
 	// 颜色混合状态
 	VkPipelineColorBlendAttachmentState colorBlendAttachment{};
@@ -361,31 +375,62 @@ void Application::createGraphicsPipeline() {
 }
 
 void Application::createRenderPass() {
+	// 1. 多重采样颜色附件（8x）
 	VkAttachmentDescription colorAttachment{};
 	colorAttachment.format = swapChainImageFormat;
-	colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
+	colorAttachment.samples = VK_SAMPLE_COUNT_8_BIT; // ←←← 8x
 	colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
-	colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+	colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; // 不需要存储，因为会 resolve
 	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;
+	colorAttachment.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 
+	// 2. Resolve 附件（普通 swapchain image）
+	VkAttachmentDescription resolveAttachment{};
+	resolveAttachment.format = swapChainImageFormat;
+	resolveAttachment.samples = VK_SAMPLE_COUNT_1_BIT; // ←←← resolve 到单采样
+	resolveAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+	resolveAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+	resolveAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+	resolveAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+	resolveAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+	resolveAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+
+	// 引用
 	VkAttachmentReference colorAttachmentRef{};
 	colorAttachmentRef.attachment = 0;
 	colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 
+	VkAttachmentReference resolveAttachmentRef{};
+	resolveAttachmentRef.attachment = 1;
+	resolveAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+
+	// Subpass：指定 color 和 resolve
 	VkSubpassDescription subpass{};
 	subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
 	subpass.colorAttachmentCount = 1;
 	subpass.pColorAttachments = &colorAttachmentRef;
+	subpass.pResolveAttachments = &resolveAttachmentRef; // ←←← 关键！
 
+	// Subpass 依赖（可选但推荐）
+	VkSubpassDependency dependency{};
+	dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
+	dependency.dstSubpass = 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;
+
+	std::vector<VkAttachmentDescription> attachments = { colorAttachment, resolveAttachment };
 	VkRenderPassCreateInfo renderPassInfo{};
 	renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
-	renderPassInfo.attachmentCount = 1;
+	renderPassInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
-	renderPassInfo.pAttachments = &colorAttachment;
+	renderPassInfo.pAttachments = attachments.data();
 	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!");
@@ -393,7 +438,6 @@ void Application::createRenderPass() {
 }
 
 
-
 void Application::createCommandPool() {
 	QueueFamilyIndices queueFamilyIndices = findQueueFamilies(physicalDevice, surface);
 
@@ -409,26 +453,24 @@ void Application::createCommandPool() {
 
 void Application::createCommandBuffer()
 {
-	commandBuffers.resize(MAX_FRAMES_IN_FLIGHT);
+	//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 = (uint32_t)MAX_FRAMES_IN_FLIGHT;
+	allocInfo.commandBufferCount = 1;
 
-	if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data()) != VK_SUCCESS) {
+	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() 
 {
-
-	imageAvailableSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
-	renderFinishedSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
-	inFlightFences.resize(MAX_FRAMES_IN_FLIGHT);
-	imagesInFlight.resize(MAX_FRAMES_IN_FLIGHT, VK_NULL_HANDLE);
-
 	VkSemaphoreCreateInfo semaphoreInfo{};
 	semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
 
@@ -436,20 +478,13 @@ void Application::createSyncObjects()
 	fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
 	fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
 
-	// 为每个交换链图像创建信号量
+	vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores_Left);
-	for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
+	vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores_Right);
-		if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) != VK_SUCCESS ||
+	vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores_Left);
-			vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) != VK_SUCCESS) {
+	vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores_Right);
-			throw std::runtime_error("failed to create synchronization objects!");
+	vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences_Left);
-		}
+	vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences_Right);
-	}
 	
-	// 为每个帧在飞行创建栅栏
-	for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
-		if (vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS) {
-			throw std::runtime_error("failed to create synchronization objects!");
-		}
-	}
 }
 
 void Application::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) 
@@ -491,53 +526,93 @@ void Application::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t im
 	}
 }
 
-void Application::drawFrame() 
+void Application::drawLeft()
 {
+	if(showDrawDebug)
+		cout << "call drawLeft     curFrame:" << to_string(currentFrame) << endl;
 	// 1. 等待前一帧完成
-	vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);
+	vkWaitForFences(device, 1, &inFlightFences_Left, VK_TRUE, UINT64_MAX);
+
+	if (showDrawDebug) cout << "vkWaitForFences inFlightFences_Left" << endl;
 
 	// 2. 获取交换链图像 - 使用当前帧的信号量
 	uint32_t imageIndex;
-	VkResult result = vkAcquireNextImageKHR(device, swapChain, UINT64_MAX,imageAvailableSemaphores[currentFrame],VK_NULL_HANDLE, &imageIndex);
+	VkResult result = vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, imageAvailableSemaphores_Left, VK_NULL_HANDLE, &imageIndex);
+
+	if (showDrawDebug) 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[imageIndex] != VK_NULL_HANDLE) {
+		if (imagesInFlight_Left != VK_NULL_HANDLE) {
-		vkWaitForFences(device, 1, &imagesInFlight[imageIndex], VK_TRUE, UINT64_MAX);
+			if (showDrawDebug) cout << "vkWaitForFences imagesInFlight_Left ImageIndex:" << to_string(imageIndex) << endl;
+			vkWaitForFences(device, 1, &imagesInFlight_Left, VK_TRUE, UINT64_MAX);
 		}
+		else
+		{
+			if (showDrawDebug) cout << "imagesInFlight_Left is NULL" << endl;
+		}
+
+		if (showDrawDebug) cout << "imagesInFlight_Left = inFlightFences_Left ImageIndex:" << to_string(imageIndex) << endl;
 		// 标记该图像正在被当前帧使用
-	imagesInFlight[imageIndex] = inFlightFences[currentFrame];
+		imagesInFlight_Left = inFlightFences_Left;
+	}
+	else
+	{
+		// 3. 检查该图像是否正在被之前的帧使用
+		if (imagesInFlight_Right != VK_NULL_HANDLE) {
+			if (showDrawDebug) cout << "vkWaitForFences imagesInFlight_Right ImageIndex:" << to_string(imageIndex) << endl;
+			vkWaitForFences(device, 1, &imagesInFlight_Right, VK_TRUE, UINT64_MAX);
+		}
+		if (showDrawDebug) cout << "imagesInFlight_Right = inFlightFences_Left ImageIndex:" << to_string(imageIndex) << endl;
+		imagesInFlight_Right = inFlightFences_Left;
+	}
 
+	if (showDrawDebug) cout << "vkResetFences inFlightFences_Left" << endl;
 	// 4. 重置栅栏
-	vkResetFences(device, 1, &inFlightFences[currentFrame]);
+	vkResetFences(device, 1, &inFlightFences_Left);
 
+	if (showDrawDebug) cout << "Process commandBuffers_Left" << endl;
 	// 5. 记录命令缓冲区
-	vkResetCommandBuffer(commandBuffers[currentFrame], 0);
+	vkResetCommandBuffer(commandBuffers_Left, 0);
-	recordCommandBuffer(commandBuffers[currentFrame], imageIndex);
+	recordCommandBuffer(commandBuffers_Left, imageIndex);
 
 	// 6. 提交命令缓冲区
 	VkSubmitInfo submitInfo{};
 	submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
 
 	// 等待图像获取完成
-	VkSemaphore waitSemaphores[] = { imageAvailableSemaphores[currentFrame] };
+	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[currentFrame];
+	submitInfo.pCommandBuffers = &commandBuffers_Left;
-
+	VkSemaphore signalSemaphores[1];
+	if (imageIndex == 0)
+	{
+		if (showDrawDebug) cout << "renderFinishedSemaphores_Left ImageIndex:" << to_string(imageIndex) << endl;
 		// 使用对应图像的渲染完成信号量
-	VkSemaphore signalSemaphores[] = { renderFinishedSemaphores[imageIndex] };
+		signalSemaphores[0] = { renderFinishedSemaphores_Left };
+		
+	}
+	else
+	{
+		if (showDrawDebug) cout << "renderFinishedSemaphores_Right ImageIndex:" << to_string(imageIndex) << endl;
+		// 使用对应图像的渲染完成信号量
+		signalSemaphores[0] = { renderFinishedSemaphores_Right };
+	}
 	submitInfo.signalSemaphoreCount = 1;
 	submitInfo.pSignalSemaphores = signalSemaphores;
 
-	if (vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]) != VK_SUCCESS) {
+	if (showDrawDebug) cout << "vkQueueSubmit inFlightFences_Left" << endl;
+	if (vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences_Left) != VK_SUCCESS) {
 		throw std::runtime_error("failed to submit draw command buffer!");
 	}
 
@@ -552,14 +627,132 @@ void Application::drawFrame()
 	presentInfo.pSwapchains = swapChains;
 	presentInfo.pImageIndices = &imageIndex;
 
+	if (showDrawDebug) cout << "Present Left \n" << endl;
 	result = vkQueuePresentKHR(presentQueue, &presentInfo);
 
 	if (result != VK_SUCCESS) {
 		throw std::runtime_error("failed to present swap chain image!");
 	}
 
-	// 8. 前进到下一帧
+}
-	currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
+
+void Application::drawRight()
+{
+	if (showDrawDebug) cout << "call drawRight     curFrame:" << to_string(currentFrame) << endl;
+	// 1. 等待前一帧完成
+	vkWaitForFences(device, 1, &inFlightFences_Right, VK_TRUE, UINT64_MAX);
+
+	if (showDrawDebug) cout << "vkWaitForFences inFlightFences_Right" << endl;
+
+	// 2. 获取交换链图像 - 使用当前帧的信号量
+	uint32_t imageIndex;
+	VkResult result = vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, imageAvailableSemaphores_Right, VK_NULL_HANDLE, &imageIndex);
+
+	if (showDrawDebug) 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) {
+			if (showDrawDebug) cout << "vkWaitForFences imagesInFlight_Left ImageIndex:0" << endl;
+			vkWaitForFences(device, 1, &imagesInFlight_Left, VK_TRUE, UINT64_MAX);
+		}
+		if (showDrawDebug) cout << "imagesInFlight_Left = inFlightFences_Right ImageIndex:0" << endl;
+		// 标记该图像正在被当前帧使用
+		imagesInFlight_Left = inFlightFences_Right;
+	}
+	else
+	{
+		// 3. 检查该图像是否正在被之前的帧使用
+		if (imagesInFlight_Right != VK_NULL_HANDLE) {
+			if (showDrawDebug) cout << "vkWaitForFences imagesInFlight_Right ImageIndex:1" << endl;
+			vkWaitForFences(device, 1, &imagesInFlight_Right, VK_TRUE, UINT64_MAX);
+		}
+		else {
+			if (showDrawDebug) cout << "imagesInFlight_Right is NULL" << endl;
+		}
+		if (showDrawDebug) cout << "imagesInFlight_Right = inFlightFences_Right ImageIndex:1" << endl;
+		imagesInFlight_Right = inFlightFences_Right;
+	}
+
+	if (showDrawDebug) cout << "vkResetFences inFlightFences_Right" << endl;
+	// 4. 重置栅栏
+	vkResetFences(device, 1, &inFlightFences_Right);
+
+	if (showDrawDebug) 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)
+	{
+		if (showDrawDebug) cout << "renderFinishedSemaphores_Left ImageIndex:0" << endl;
+		// 使用对应图像的渲染完成信号量
+		signalSemaphores[0] = { renderFinishedSemaphores_Left };
+
+	}
+	else
+	{
+		if (showDrawDebug) cout << "renderFinishedSemaphores_Right ImageIndex:1" << endl;
+		// 使用对应图像的渲染完成信号量
+		signalSemaphores[0] = { renderFinishedSemaphores_Right };
+	}
+	submitInfo.signalSemaphoreCount = 1;
+	submitInfo.pSignalSemaphores = signalSemaphores;
+
+	if (showDrawDebug) 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;
+
+	if (showDrawDebug) 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) {
@@ -569,6 +762,77 @@ void DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT
 	}
 }
 
+void Application::createColorResources() {
+	VkFormat colorFormat = swapChainImageFormat;
+
+	VkImageCreateInfo imageInfo{};
+	imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+	imageInfo.imageType = VK_IMAGE_TYPE_2D;
+	imageInfo.format = colorFormat;
+	imageInfo.extent.width = swapChainExtent.width;
+	imageInfo.extent.height = swapChainExtent.height;
+	imageInfo.extent.depth = 1;
+	imageInfo.mipLevels = 1;
+	imageInfo.arrayLayers = 1;
+	imageInfo.samples = VK_SAMPLE_COUNT_8_BIT; // ←←← 8x MSAA
+	imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
+	imageInfo.usage = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+	imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+
+	if (vkCreateImage(device, &imageInfo, nullptr, &colorImage) != VK_SUCCESS) {
+		throw std::runtime_error("failed to create MSAA color image!");
+	}
+
+	VkMemoryRequirements memRequirements;
+	vkGetImageMemoryRequirements(device, colorImage, &memRequirements);
+
+	VkMemoryAllocateInfo allocInfo{};
+	allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+	allocInfo.allocationSize = memRequirements.size;
+	allocInfo.memoryTypeIndex = findMemoryType(physicalDevice, memRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+
+	if (vkAllocateMemory(device, &allocInfo, nullptr, &colorImageMemory) != VK_SUCCESS) {
+		throw std::runtime_error("failed to allocate MSAA color image memory!");
+	}
+
+	vkBindImageMemory(device, colorImage, colorImageMemory, 0);
+
+	// 创建 ImageView
+	VkImageViewCreateInfo viewInfo{};
+	viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+	viewInfo.image = colorImage;
+	viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
+	viewInfo.format = colorFormat;
+	viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+	viewInfo.subresourceRange.baseMipLevel = 0;
+	viewInfo.subresourceRange.levelCount = 1;
+	viewInfo.subresourceRange.baseArrayLayer = 0;
+	viewInfo.subresourceRange.layerCount = 1;
+
+	if (vkCreateImageView(device, &viewInfo, nullptr, &colorImageView) != VK_SUCCESS) {
+		throw std::runtime_error("failed to create MSAA color image view!");
+	}
+}
+
+
+uint32_t Application::findMemoryType(VkPhysicalDevice physicalDevice, 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 Application::cleanup() {
 	if (enableValidationLayers) {
 		DestroyDebugUtilsMessengerEXT(instance, debugMessenger, nullptr);
@@ -579,11 +843,14 @@ void Application::cleanup() {
 	vkDeviceWaitIdle(device);
 
 	// 正确销毁所有同步对象
-	for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
+	vkDestroySemaphore(device, imageAvailableSemaphores_Left, nullptr);
-		vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr);
+	vkDestroySemaphore(device, renderFinishedSemaphores_Left, nullptr);
-		vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr);
+	vkDestroyFence(device, inFlightFences_Left, nullptr);
-		vkDestroyFence(device, inFlightFences[i], nullptr);
+
-	}
+	// 正确销毁所有同步对象
+	vkDestroySemaphore(device, imageAvailableSemaphores_Right, nullptr);
+	vkDestroySemaphore(device, renderFinishedSemaphores_Right, nullptr);
+	vkDestroyFence(device, inFlightFences_Right, nullptr);
 
 	// 不需要手动释放commandBuffers，销毁命令池时会自动释放
 	// 销毁命令池
@@ -603,6 +870,10 @@ void Application::cleanup() {
 		vkDestroyImageView(device, imageView, nullptr);
 	}
 
+	vkDestroyImageView(device, colorImageView, nullptr);
+	vkDestroyImage(device, colorImage, nullptr);
+	vkFreeMemory(device, colorImageMemory, nullptr);
+
 	// 销毁交换链
 	vkDestroySwapchainKHR(device, swapChain, nullptr);
 
@@ -618,6 +889,7 @@ void Application::cleanup() {
 	// 销毁 Vulkan 实例
 	vkDestroyInstance(instance, nullptr);
 
+
 #ifdef _WIN32
 	// 销毁 GLFW 窗口
 	glfwDestroyWindow(window);

vulkan/Application.h

@@ -17,6 +17,7 @@ public:
     void mainLoop();
     void cleanup();
     
+    void createImages();
     void createImageViews();
     void createFramebuffers();
     void createCommandPool();
@@ -30,6 +31,8 @@ public:
     void recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex);
     void createSyncObjects();
     void drawFrame();
+    void drawLeft();
+    void drawRight();
     bool isInited() { return inited; }
 private:
     VkPhysicalDevice physicalDevice = VK_NULL_HANDLE; // 物理设备
@@ -48,12 +51,32 @@ private:
     VkQueue presentQueue; // 呈现队列
 
     VkCommandPool commandPool;
-    std::vector<VkCommandBuffer> commandBuffers;
+    VkCommandBuffer commandBuffers_Left;
-    std::vector<VkSemaphore> imageAvailableSemaphores; // 每个交换链图像一个
+    VkCommandBuffer commandBuffers_Right;
-    std::vector<VkSemaphore> renderFinishedSemaphores; // 每个交换链图像一个        
+
-    std::vector<VkFence> inFlightFences;               // 每个帧在飞行一个
+    VkSemaphore imageAvailableSemaphores_Left;
-    std::vector<VkFence> imagesInFlight;               // 跟踪每个图像的使用状态
+    VkSemaphore imageAvailableSemaphores_Right;
+
+    VkSemaphore renderFinishedSemaphores_Left;
+    VkSemaphore renderFinishedSemaphores_Right;
+
+    VkFence inFlightFences_Left;
+    VkFence inFlightFences_Right;
+
+    VkFence imagesInFlight_Left = VK_NULL_HANDLE;
+    VkFence imagesInFlight_Right = VK_NULL_HANDLE;
+
+    const bool showDrawDebug = false;
+
     int currentFrame = 0;
-    int MAX_FRAMES_IN_FLIGHT = 2;
     bool inited = false;
+
+    //MSAA
+    VkImage colorImage;
+    VkDeviceMemory colorImageMemory;
+    VkImageView colorImageView;
+    void createColorResources();
+    uint32_t findMemoryType(VkPhysicalDevice physicalDevice, uint32_t typeFilter,
+        VkMemoryPropertyFlags properties);
+
 };