重构完成未debug

src/render/render.cpp

@@ -39,11 +39,7 @@ void PlumageRender::renderMain::framebufferResizeCallback(GLFWwindow* window, in
 // todo：重写成glfw的
 void PlumageRender::renderMain::windowResized()
 	{
-		buildCommandBuffers();
+		
-		vkDeviceWaitIdle(device);
-		updateUniformBuffers();
-		//update UI
-		updateUIOverlay();
 	}
 
 void PlumageRender::renderMain::prepare()
@@ -52,18 +48,18 @@ void PlumageRender::renderMain::prepare()
 
 	setupCamera();
 
-	loadAssets();
+	renderInput.loadAssets();
-	generateBRDFLUT();
+	pbrMaterial.generateBRDFLUT();
-	generateCubemaps();
+	pbrMaterial.generateCubemap();
 	//prepareUniformBuffers();
 	//setupDescriptors();
-	preparePipelines();
+	//preparePipelines();
 	if (!PlumageRender::Setter::settings.headless)
 	{
-		gui = new UI(vulkanDevice, renderPass, queue, pipelineCache,PlumageRender::Setter::settings.sampleCount);
+		auto gui = renderGUI.gui;
-		updateUIOverlay();
+		renderGUI.updateUIOverlay();
 	}
-	buildCommandBuffers();
+	;
 
 	prepared = true;
 }
@@ -86,10 +82,16 @@ void PlumageRender::renderMain::submitWork(VkCommandBuffer cmdBuffer, VkQueue qu
 		submitInfo.pCommandBuffers = &cmdBuffer;
 		VkFenceCreateInfo fenceInfo = vks::initializers::fenceCreateInfo();
 		VkFence fence;
-		VK_CHECK_RESULT(vkCreateFence(device, &fenceInfo, nullptr, &fence));
+		VK_CHECK_RESULT(vkCreateFence(VulkanBackend::VulkanFoundation::device, &fenceInfo, nullptr, &fence));
 		VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, fence));
-		VK_CHECK_RESULT(vkWaitForFences(device, 1, &fence, VK_TRUE, UINT64_MAX));
+		VK_CHECK_RESULT(vkWaitForFences(VulkanBackend::VulkanFoundation::device, 1, &fence, VK_TRUE, UINT64_MAX));
-		vkDestroyFence(device, fence, nullptr);
+		vkDestroyFence(VulkanBackend::VulkanFoundation::device, fence, nullptr);
+	}
+
+void PlumageRender::renderMain::submitToPresentQueue()
+{
+
+	
 }
 
 void PlumageRender::renderMain::render()
@@ -100,7 +102,7 @@ void PlumageRender::renderMain::render()
 
 		if (!PlumageRender::Setter::settings.headless)
 		{
-			updateUIOverlay();
+			renderGUI.updateUIOverlay();
 		}
 		
 		//加入写到文件的函数
@@ -108,92 +110,113 @@ void PlumageRender::renderMain::render()
 		//outputImageSequeue(swapChainImage,filePath.imageSequenceFilePath);
 
 		
-		outputImageSequence();
+		uint32_t imageIndex;
-		VK_CHECK_RESULT(vkWaitForFences(device, 1, &waitFences[frameIndex], VK_TRUE, UINT64_MAX));
 		
-		imageSequenceToVideo();
+		VK_CHECK_RESULT(vkWaitForFences(VulkanBackend::VulkanFoundation::device, 1, &vkFoundation.waitFences[frameIndex], VK_TRUE, UINT64_MAX));
-		VK_CHECK_RESULT(vkResetFences(device, 1, &waitFences[frameIndex]));
+		VkResult result = vkAcquireNextImageKHR(VulkanBackend::VulkanFoundation::device, VulkanBackend::VulkanFoundation::swapChain, UINT64_MAX, vkFoundation.renderCompleteSemaphores[frameIndex], VK_NULL_HANDLE, &imageIndex);
 
-		VkResult acquire = swapChain.acquireNextImage(presentCompleteSemaphores[frameIndex], &currentBuffer);
+		if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR || framebufferResized)
-		if ((acquire == VK_ERROR_OUT_OF_DATE_KHR) || (acquire == VK_SUBOPTIMAL_KHR)) {
+		{
-			windowResize();
+			framebufferResized = false;
+			vkFoundation.recreateSwapChain();
+			return;
 		}
-		else {
+		else if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR)
-			VK_CHECK_RESULT(acquire);
+		{
-			
+			throw std::runtime_error("failed to acquire swap chain image in drawFrame");
-			
 		}
 		
+		VK_CHECK_RESULT(vkResetFences(VulkanBackend::VulkanFoundation::device, 1, &vkFoundation.waitFences[frameIndex]));
+		renderOutput.outputImageSequence();
+		renderOutput.imageSequenceToVideo();
 		
 		// Update UBOs
-		updateUniformBuffers();
+		vkFoundation.updateUniformBuffers();
-		UniformBufferSet[currentUB] = uniformBuffers[currentBuffer];
+		VulkanBackend::VulkanFoundation::UniformBufferSet currentUB = vkFoundation.uniformBuffers[currentBuffer];
-		memcpy(currentUB.scene.mapped, &shaderDataScene, sizeof(shaderDataScene));
+		memcpy(currentUB.scene.mapped, &vkFoundation.shaderDataScene, sizeof(vkFoundation.shaderDataScene));
-		memcpy(currentUB.params.mapped, &shaderData, sizeof(shaderData));
+		memcpy(currentUB.params.mapped, &PBR::Material::shaderData, sizeof(PBR::Material::shaderData));
-		memcpy(currentUB.skybox.mapped, &shaderDataSkybox, sizeof(shaderDataSkybox));
+		memcpy(currentUB.skybox.mapped, &vkFoundation.shaderDataSkybox, sizeof(vkFoundation.shaderDataSkybox));
 
 		const VkPipelineStageFlags waitDstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
 		VkSubmitInfo submitInfo{};
 		submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
 		submitInfo.pWaitDstStageMask = &waitDstStageMask;
-		submitInfo.pWaitSemaphores = &presentCompleteSemaphores[frameIndex];
+		submitInfo.pWaitSemaphores = &vkFoundation.presentCompleteSemaphores[frameIndex];
 		submitInfo.waitSemaphoreCount = 1;
-		submitInfo.pSignalSemaphores = &renderCompleteSemaphores[frameIndex];
+		submitInfo.pSignalSemaphores = &vkFoundation.renderCompleteSemaphores[frameIndex];
 		submitInfo.signalSemaphoreCount = 1;
-		submitInfo.pCommandBuffers = &commandBuffers[currentBuffer];
+		submitInfo.pCommandBuffers = &vkFoundation.commandbuffers[currentBuffer];
 		submitInfo.commandBufferCount = 1;
-		VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, waitFences[frameIndex]));
+		VK_CHECK_RESULT(vkQueueSubmit(vkFoundation.graphicQueue, 1, &submitInfo, vkFoundation.waitFences[frameIndex]));
 
 		//显示队列
 
-		VkResult present = swapChain.queuePresent(queue, currentBuffer, renderCompleteSemaphores[frameIndex]);
+		VkSemaphore signalSemaphores[] = { vkFoundation.renderCompleteSemaphores[frameIndex] };
-		if (!((present == VK_SUCCESS) || (present == VK_SUBOPTIMAL_KHR))) {
+
-			if (present == VK_ERROR_OUT_OF_DATE_KHR) {
+		VkPresentInfoKHR presentInfo{};
-				windowResize();
+		presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
-				return;
+
-			}
+		presentInfo.waitSemaphoreCount = 1;
-			else {
+		presentInfo.pWaitSemaphores = signalSemaphores;
-				VK_CHECK_RESULT(present);
+
+		VkSwapchainKHR swapChains[] = { vkFoundation.swapChain };
+		presentInfo.swapchainCount = 1;
+		presentInfo.pSwapchains = swapChains;
+		presentInfo.pImageIndices = &imageIndex;
+		presentInfo.pResults = nullptr;
+
+		result = vkQueuePresentKHR(vkFoundation.presentQueue, &presentInfo);
+		if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR)
+		{
+			framebufferResized = false;
+			vkFoundation.recreateSwapChain();
 		}
+		else if (result != VK_SUCCESS)
+		{
+			throw std::runtime_error("failed to present swap chain image in drawFrame");
 		}
 
 		frameIndex += 1;
-		frameIndex %= renderAhead;
+		frameIndex %= PlumageRender::Setter::settings.MaxFrameInFlight;
 
-		if (!paused) {
+		if (!PlumageRender::Setter::settings.pause) {
 			if (PlumageRender::Setter::settings.rotateModel) {
 				modelrot.y += frameTimer * 35.0f;
 				if (modelrot.y > 360.0f) {
 					modelrot.y -= 360.0f;
 				}
 			}
-			if ((animate) && (models.scene.animations.size() > 0)) {
+			if ((PlumageRender::Setter::settings.animate) && (models.scene.animations.size() > 0)) {
 				animationTimer += frameTimer;
 				if (animationTimer > models.scene.animations[animationIndex].end) {
 					animationTimer -= models.scene.animations[animationIndex].end;
 				}
 				models.scene.updateAnimation(animationIndex, animationTimer);
 			}
-			updateShaderData();
+			vkFoundation.updateShaderData();
 			if (PlumageRender::Setter::settings.rotateModel) {
-				updateUniformBuffers();
+				vkFoundation.updateUniformBuffers();
 			}
 		}
 		if (camera.updated) {
-			updateUniformBuffers();
+			vkFoundation.updateUniformBuffers();
 		}
 
 	}
 
-void PlumageRender::renderMain::fileDropped(std::string filename)
+	void PlumageRender::renderMain::renderLoop(GLFWwindow* window)
 	{
-			vkDeviceWaitIdle(device);
+		while (!glfwWindowShouldClose(window))
-			loadScene(filename);
+		{
-			setupDescriptors();
+			glfwPollEvents();
-			buildCommandBuffers();
+			render();
-
 		}
 
+		vkDeviceWaitIdle(VulkanBackend::VulkanFoundation::device);
+	}
+
+
+
 
 
 
@@ -234,14 +257,12 @@ int main()
 {
 	PlumageRender::renderMain plumageRender;
 	VulkanBackend::VulkanFoundation vkFoundation;	
-	
 	vkFoundation.initVulkan();
 	if (!PlumageRender::Setter::settings.headless)
 	{
 		plumageRender.initWindow(PlumageRender::Setter::settings.width,PlumageRender::Setter::settings.height);
 		
 	}
-	
 	return 0;
 }
 	

src/render/render.h

@@ -72,7 +72,13 @@ namespace PlumageRender
 
 		uint64_t savedFrameCounter = PlumageRender::Setter::settings.startFrameCount;
 
-		bool framebufferResized = false;
+		
+
+		uint32_t lastFPS = 0;
+		static const float frameTimer = 1.0f;
+
+		static int32_t animationIndex;
+		float animationTimer = 0.0f;
 
 		renderMain();
 		~renderMain()
@@ -90,9 +96,26 @@ namespace PlumageRender
 		void prepare();
 		void setupCamera();
 		void submitWork(VkCommandBuffer cmdBuffer, VkQueue queue);
+		void submitToPresentQueue();
+
 		virtual void render();
-		virtual void fileDropped(std::string filename);
+		void renderLoop(GLFWwindow* window);
 	private:
+
+		PlumageRender::RenderInput renderInput;
+
+		PlumageRender::RenderOutput renderOutput;
+
+		PBR::Material pbrMaterial;
+
+		PlumageRender::PlumageGUI renderGUI;
+
+		VulkanBackend::VulkanFoundation vkFoundation;
+
+		bool framebufferResized = false;
+
+		bool prepared = false;
+
 	};
 	
 

src/render/renderIO.h

@@ -24,14 +24,13 @@ namespace PlumageRender
 
 		void loadEnvironment(std::string fileName);
 
-		static void loadAssets();
+		void loadAssets();
 
-		static int32_t animationIndex;
 		
 	private:
 
 		
-		float animationTimer = 0.0f;
+		
 		
 		
 	};

src/render/renderSetter.h

@@ -33,12 +33,13 @@ namespace PlumageRender
 			bool outputPNGimage = false; // 输出图片序列格式为PNG（四通道）
 			bool enableSaveToImageSequeue = false; // 图片序列开关（暂时弃用）
 			bool animate = true; // 动画开关
+			bool pause = false; // 暂停模型旋转（暂时弃用）
 			uint32_t MaxFrameInFlight = 2; // 最大并行渲染帧数（通常为2，此时CPU和GPU并行处理）
 			uint32_t endFrameIndex = 75; // 图片序列结束帧
 			bool enableIMGUI = false; // gui使用imgui
 			uint32_t startFrameCount = 1; // 图片序列开始帧
 			uint32_t videoFrameRate = 25; // 视频帧率
-			uint32_t selectedPhysicalDeviceIndex = 0;
+			uint32_t selectedPhysicalDeviceIndex = 0; // 选中的显卡，数组形式从0开始编号
 
 			VkSampleCountFlagBits sampleCount = VK_SAMPLE_COUNT_4_BIT; // 多重采样倍率
 		};

src/render/renderUI.cpp

@@ -8,7 +8,7 @@ void PlumageRender::PlumageGUI::updateUIOverlay()
 
 	ImVec2 lastDisplaySize = io.DisplaySize;
 	io.DisplaySize = ImVec2((float)PlumageRender::Setter::settings.width, (float)PlumageRender::Setter::settings.height);
-	io.DeltaTime = frameTimer;
+	io.DeltaTime = PlumageRender::renderMain::frameTimer;
 
 	io.MousePos = ImVec2(mousePos.x, mousePos.y);
 	io.MouseDown[0] = mouseButtons.left;
@@ -57,12 +57,15 @@ void PlumageRender::PlumageGUI::updateUIOverlay()
 					vkDeviceWaitIdle(VulkanBackend::VulkanFoundation::device);
 					std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
 					std::string stringFilename = converter.to_bytes(filename);
-					PlumageRender::RenderInput::loadScene(stringFilename);
+					
-					PlumageRender::renderMain::vkFoundation.createDescriptorSets();
+					renderInput.loadScene(stringFilename);
+					
+					vkFoundation.createDescriptorSets();
 					updateCBs = true;
-					PlumageRender::renderMain::renderOutput.signal.imageSequenceOutputComplete = false;
+					
-					PlumageRender::renderMain::renderOutput.signal.imageSequenceToVideoComplete = false;
+					renderOutput.signal.imageSequenceOutputComplete = false;
-					PlumageRender::renderMain::renderOutput.savedFrameCounter = 1;
+					renderOutput.signal.imageSequenceToVideoComplete = false;
+					renderOutput.savedFrameCounter = 1;
 				}
 			}
 			gui->endMenu();
@@ -71,24 +74,24 @@ void PlumageRender::PlumageGUI::updateUIOverlay()
 		{
 			if (gui->beginMenu(chineseUI.menuEnvironmentConfig))
 			{
-				auto& selectedEnvironment = PlumageRender::renderMain::renderInput.selectedEnvironment;
+				auto& selectedEnvironment = renderInput.selectedEnvironment;
-				auto& environments = PlumageRender::renderMain::renderInput.environments;
+				auto& environments = renderInput.environments;
 				if (gui->combo(chineseUI.environmentMap, selectedEnvironment, environments)) {
-					vkDeviceWaitIdle(PlumageRender::renderMain::vkFoundation.device);
+					vkDeviceWaitIdle(vkFoundation.device);
-					PlumageRender::renderMain::renderInput.loadEnvironment(environments[selectedEnvironment]);
+					renderInput.loadEnvironment(environments[selectedEnvironment]);
-					PlumageRender::renderMain::vkFoundation.createDescriptorSets();
+					vkFoundation.createDescriptorSets();
 					updateCBs = true;
 				}
 				if (gui->checkbox(chineseUI.environmentBackGround, &PlumageRender::Setter::settings.displayBackground)) {
 					updateShaderParams = true;
 				}
-				if (gui->slider("Exposure", &PlumageRender::renderMain::vkFoundation.shaderData.exposure, 0.1f, 10.0f)) {
+				if (gui->slider("Exposure", &PBR::Material::shaderData.exposure, 0.1f, 10.0f)) {
 					updateShaderParams = true;
 				}
-				if (gui->slider("Gamma", &PlumageRender::renderMain::vkFoundation.shaderData.gamma, 0.1f, 4.0f)) {
+				if (gui->slider("Gamma", &PBR::Material::shaderData.gamma, 0.1f, 4.0f)) {
 					updateShaderParams = true;
 				}
-				if (gui->slider("IBL", &PlumageRender::renderMain::vkFoundation.shaderData.scaleIBLAmbient, 0.0f, 1.0f)) {
+				if (gui->slider("IBL", &PBR::Material::shaderData.scaleIBLAmbient, 0.0f, 1.0f)) {
 					updateShaderParams = true;
 				}
 				gui->endMenu();
@@ -103,7 +106,7 @@ void PlumageRender::PlumageGUI::updateUIOverlay()
 			"none", "Base color", "Normal", "Occlusion", "Emissive", "Metallic", "Roughness"
 				};
 				if (gui->combo(chineseUI.debugInput, &debugView.debugViewInputs, debugNamesInputs)) {
-					PlumageRender::renderMain::vkFoundation.shaderData.debugViewInputs = static_cast<float>(debugView.debugViewInputs);
+					PBR::Material::shaderData.debugViewInputs = static_cast<float>(debugView.debugViewInputs);
 					updateShaderParams = true;
 				}
 				gui->endMenu();
@@ -114,7 +117,7 @@ void PlumageRender::PlumageGUI::updateUIOverlay()
 			"none", "Diff (l,n)", "F (l,h)", "G (l,v,h)", "D (h)", "Specular"
 				};
 				if (gui->combo(chineseUI.debugPBREquation, &debugView.debugViewEquation, debugNamesEquation)) {
-					PlumageRender::renderMain::vkFoundation.shaderData.debugViewEquation = static_cast<float>(debugView.debugViewEquation);
+					PBR::Material::shaderData.debugViewEquation = static_cast<float>(debugView.debugViewEquation);
 					updateShaderParams = true;
 				}
 				gui->endMenu();
@@ -122,7 +125,7 @@ void PlumageRender::PlumageGUI::updateUIOverlay()
 
 			if (gui->beginMenu(chineseUI.menuDebugFrameRate))
 			{
-				gui->text("%.1d fps (%.2f ms)", lastFPS, (1000.0f / lastFPS));
+				gui->text("%.1d fps (%.2f ms)", renderMain.lastFPS, (1000.0f / renderMain.lastFPS));
 				gui->endMenu();
 			}
 			gui->endMenu();
@@ -142,7 +145,7 @@ void PlumageRender::PlumageGUI::updateUIOverlay()
 					for (auto animation : PlumageRender::renderMain::models.scene.animations) {
 						animationNames.push_back(animation.name);
 					}
-					gui->combo(chineseUI.animationSeq, &PlumageRender::RenderInput::animationIndex, animationNames);
+					gui->combo(chineseUI.animationSeq, &renderMain.animationIndex, animationNames);
 					gui->endMenu();
 				}
 			}

src/render/renderUI.h

@@ -15,7 +15,7 @@ namespace PlumageRender
 		PlumageGUI();
 		~PlumageGUI();
 
-		UI* gui;
+		UI* gui = new UI(VulkanBackend::VulkanFoundation::vulkanDevice, VulkanBackend::VulkanFoundation::renderPass, VulkanBackend::VulkanFoundation::graphicQueue, VulkanBackend::VulkanFoundation::pipelineCache, PlumageRender::Setter::settings.sampleCount);
 
 		void  updateUIOverlay();
 
@@ -29,10 +29,12 @@ namespace PlumageRender
 
 	private:
 
-		PlumageRender::Setter setter;
 		
-		uint32_t lastFPS = 0;
+		
-		float frameTimer = 1.0f;
+		PlumageRender::RenderInput renderInput;
+		VulkanBackend::VulkanFoundation vkFoundation;
+		PlumageRender::RenderOutput renderOutput;
+		PlumageRender::renderMain renderMain;
 
 		struct GamePadState {
 			glm::vec2 axisLeft = glm::vec2(0.0f);

src/render/vulkanFoundation.cpp

@@ -1679,6 +1679,21 @@ void VulkanBackend::VulkanFoundation::allocateCommandBuffers()
 	VK_CHECK_RESULT(vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, commandbuffers.data()));
 }
 
+void VulkanBackend::VulkanFoundation::cleanupSwapChain()
+{
+	for (auto framebuffer : framebuffers)
+	{
+		vkDestroyFramebuffer(device, framebuffer, nullptr);
+	}
+
+	for (auto imageView : swapChainImageViews)
+	{
+		vkDestroyImageView(device, imageView, nullptr);
+	}
+
+	vkDestroySwapchainKHR(device, swapChain, nullptr);
+}
+
 void VulkanBackend::VulkanFoundation::createCommandBuffer()
 {
 	
@@ -1883,6 +1898,29 @@ void VulkanBackend::VulkanFoundation::updateShaderData()
 		0.0f);
 }
 
+void VulkanBackend::VulkanFoundation::recreateSwapChain()
+{
+	int width = 0, height = 0;
+	glfwGetFramebufferSize(window, &width, &height);
+	while (width == 0 || height == 0)
+	{
+		if (glfwWindowShouldClose(window))
+		{
+			return;
+		}
+		glfwGetFramebufferSize(window, &width, &height);
+		glfwWaitEvents();
+	}
+
+	vkDeviceWaitIdle(device);
+
+	cleanupSwapChain();
+
+	createSwapChain();
+	createImageView();
+	createFramebuffer();
+}
+
 
 
 

src/render/vulkanFoundation.h

@@ -35,8 +35,7 @@ namespace VulkanBackend
 			vkDestroyDescriptorSetLayout(device, descriptorSetLayouts.material, nullptr);
 			vkDestroyDescriptorSetLayout(device, descriptorSetLayouts.node, nullptr);
 
-			models.scene.destroy(device);
+			
-			models.skybox.destroy(device);
 
 			for (auto buffer : uniformBuffers) {
 				buffer.params.destroy();
@@ -81,6 +80,32 @@ namespace VulkanBackend
 
 		static std::vector<VkImage> swapChainImages;
 		static VkFormat swapChainImageFormat;
+		static VkSwapchainKHR swapChain;
+
+		static VkRenderPass renderPass;
+
+		std::vector<VkFence> waitFences;
+		std::vector<VkSemaphore> renderCompleteSemaphores;
+		std::vector<VkSemaphore> presentCompleteSemaphores;
+
+		struct UniformBufferSet {
+			Buffer scene;
+			Buffer skybox;
+			Buffer params;
+		};
+
+		struct UBOMatrices {
+			glm::mat4 projection;
+			glm::mat4 model;
+			glm::mat4 view;
+			glm::vec3 camPos;
+		} shaderDataScene, shaderDataSkybox;
+
+		std::vector<UniformBufferSet> uniformBuffers;
+
+		std::vector<VkCommandBuffer> commandbuffers;
+
+		VkQueue presentQueue;
 
 		void initVulkan();
 
@@ -89,8 +114,16 @@ namespace VulkanBackend
 
 		void createCommandBuffer();
 
+		void updateUniformBuffers();
+
+		void updateShaderData();
+
+		void recreateSwapChain();
+		
 	private:
 
+		
+
 		VkInstance instance;
 
 		VkDebugUtilsMessengerEXT debugMessenger;
@@ -125,19 +158,14 @@ namespace VulkanBackend
 		
 		VkPhysicalDeviceFeatures deviceFeatures;
 		
-		VkQueue presentQueue;
-
-		
-		VkSwapchainKHR swapChain;
 		
 		VkExtent2D swapChainExtent;
 		std::vector<VkImageView> swapChainImageViews;
 
 		
-		
 		PFN_vkGetPhysicalDeviceSurfacePresentModesKHR fpGetPhysicalDeviceSurfacePresentModesKHR;
 
-		VkRenderPass renderPass;
+		
 
 		VkCommandPool commandPool;
 
@@ -148,7 +176,7 @@ namespace VulkanBackend
 		
 		std::vector<VkFramebuffer> framebuffers;
 		
-		std::vector<VkCommandBuffer> commandbuffers;
+		
 
 		struct FrameBufferAttachment
 		{
@@ -201,30 +229,14 @@ namespace VulkanBackend
 		VkPipelineLayout pipelineLayout;
 
 
-
-		struct UniformBufferSet {
-			Buffer scene;
-			Buffer skybox;
-			Buffer params;
-		};
-
-		struct UBOMatrices {
-			glm::mat4 projection;
-			glm::mat4 model;
-			glm::mat4 view;
-			glm::vec3 camPos;
-		} shaderDataScene, shaderDataSkybox;
-
 		struct LightSource {
 			glm::vec3 color = glm::vec3(1.0f);
 			glm::vec3 rotation = glm::vec3(75.0f, 40.0f, 0.0f);
 		} lightSource;
 
-		std::vector<UniformBufferSet> uniformBuffers;
 		
-		std::vector<VkFence> waitFences;
+
-		std::vector<VkSemaphore> renderCompleteSemaphores;
+		
-		std::vector<VkSemaphore> presentCompleteSemaphores;
 
 		// 句柄创建，检查校验层支持和获取需要的扩展
 		void createInstance();
@@ -259,6 +271,7 @@ namespace VulkanBackend
 		VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats);
 		VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes);
 		VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities);
+		void cleanupSwapChain();
 
 		// 创建交换链中的imageView，用于访问交换链中图像
 		void createImageView();
@@ -289,7 +302,7 @@ namespace VulkanBackend
 		// 创建统一缓冲区
 		void createUniformBuffer();
 
-		void updateUniformBuffers();
+		
 
 		// 创建描述符池
 		void createDescriptorPool();
@@ -310,7 +323,7 @@ namespace VulkanBackend
 		// 创建栅栏和信号量，用于多帧并行的同步
 		void createFenceAndSemaphore();
 
-		void updateShaderData();
+		
 
 	};