自学教程：C++ vkCmdEndRenderPass函数代码示例

void op3d::Engine::createCommandBuffers(){    if (commandBuffers.size() > 0)    {        vkFreeCommandBuffers(device, commandBufferManager.getCommandPool(), commandBuffers.size(), commandBuffers.data());    }    commandBuffers.resize(swapChainFramebuffers.size());    VkCommandBufferAllocateInfo allocInfo = {};    allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;    allocInfo.commandPool = commandBufferManager.getCommandPool();    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!");    }    for (std::size_t i = 0; i < commandBuffers.size(); i++)    {        VkCommandBufferBeginInfo beginInfo = {};        beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;        beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;        vkBeginCommandBuffer(commandBuffers[i], &beginInfo);        VkRenderPassBeginInfo renderPassInfo = {};        renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;        renderPassInfo.renderPass = renderPass;        renderPassInfo.framebuffer = swapChainFramebuffers[i];        renderPassInfo.renderArea.offset = {0, 0};        renderPassInfo.renderArea.extent = swapChain.getExtent();        std::array <VkClearValue, 2> clearValues = {};        clearValues[0].color = { 0.0f, 0.0f, 0.0f, 1.0f };        clearValues[1].depthStencil = { 1.0f, 0 };        renderPassInfo.clearValueCount = clearValues.size();        renderPassInfo.pClearValues = clearValues.data();        vkCmdBeginRenderPass(commandBuffers[i], &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);        vkCmdBindPipeline(commandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);        VkBuffer vertexBuffers[] = {vertexBuffer};        VkDeviceSize offsets[] = {0};        vkCmdBindVertexBuffers(commandBuffers[i], 0, 1, vertexBuffers, offsets);        vkCmdBindIndexBuffer(commandBuffers[i], indexBuffer, 0, VK_INDEX_TYPE_UINT16);        vkCmdBindDescriptorSets(commandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, nullptr);        vkCmdDrawIndexed(commandBuffers[i], indices.size(), 1, 0, 0, 0);        vkCmdEndRenderPass(commandBuffers[i]);        if (vkEndCommandBuffer(commandBuffers[i]) != VK_SUCCESS)        {            throw std::runtime_error("failed to record command buffer!");        }    }}

static void FrameRender(ImGui_ImplVulkanH_WindowData* wd){	VkResult err;	VkSemaphore& image_acquired_semaphore  = wd->Frames[wd->FrameIndex].ImageAcquiredSemaphore;	err = vkAcquireNextImageKHR(g_Device, wd->Swapchain, UINT64_MAX, image_acquired_semaphore, VK_NULL_HANDLE, &wd->FrameIndex);	check_vk_result(err);    ImGui_ImplVulkanH_FrameData* fd = &wd->Frames[wd->FrameIndex];    {		err = vkWaitForFences(g_Device, 1, &fd->Fence, VK_TRUE, UINT64_MAX);	// wait indefinitely instead of periodically checking        check_vk_result(err);		err = vkResetFences(g_Device, 1, &fd->Fence);        check_vk_result(err);    }    {        err = vkResetCommandPool(g_Device, fd->CommandPool, 0);        check_vk_result(err);        VkCommandBufferBeginInfo info = {};        info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;        info.flags |= VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;        err = vkBeginCommandBuffer(fd->CommandBuffer, &info);        check_vk_result(err);    }    {        VkRenderPassBeginInfo info = {};        info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;        info.renderPass = wd->RenderPass;		info.framebuffer = wd->Framebuffer[wd->FrameIndex];        info.renderArea.extent.width = wd->Width;        info.renderArea.extent.height = wd->Height;        info.clearValueCount = 1;        info.pClearValues = &wd->ClearValue;        vkCmdBeginRenderPass(fd->CommandBuffer, &info, VK_SUBPASS_CONTENTS_INLINE);    }	// Record Imgui Draw Data and draw funcs into command buffer	ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(), fd->CommandBuffer);	// Submit command buffer    vkCmdEndRenderPass(fd->CommandBuffer);    {        VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;        VkSubmitInfo info = {};        info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;        info.waitSemaphoreCount = 1;		info.pWaitSemaphores = &image_acquired_semaphore;        info.pWaitDstStageMask = &wait_stage;        info.commandBufferCount = 1;        info.pCommandBuffers = &fd->CommandBuffer;        info.signalSemaphoreCount = 1;        info.pSignalSemaphores = &fd->RenderCompleteSemaphore;        err = vkEndCommandBuffer(fd->CommandBuffer);        check_vk_result(err);        err = vkQueueSubmit(g_Queue, 1, &info, fd->Fence);        check_vk_result(err);    }}

 void VulkanWindow::EndRender() const {     vkCmdEndRenderPass ( mVulkanRenderer.GetCommandBuffer() );     if ( VkResult result = vkEndCommandBuffer ( mVulkanRenderer.GetCommandBuffer() ) )     {         std::cout << GetVulkanResultString ( result ) << "  " << __func__ << " " << __LINE__ << " " << std::endl;     }     VkSubmitInfo submit_info{};     submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;     submit_info.waitSemaphoreCount = 0;     submit_info.pWaitSemaphores = nullptr;     submit_info.pWaitDstStageMask = nullptr;     submit_info.commandBufferCount = 1;     submit_info.pCommandBuffers = &mVulkanRenderer.GetCommandBuffer();     submit_info.signalSemaphoreCount = 1;     submit_info.pSignalSemaphores = &mVulkanRenderer.GetSignalSemaphore();     if ( VkResult result = vkQueueSubmit ( mVulkanRenderer.GetQueue(), 1, &submit_info, VK_NULL_HANDLE ) )     {         std::cout << GetVulkanResultString ( result ) << "  " << __func__ << " " << __LINE__ << " " << std::endl;     }     std::array<VkResult, 1> result_array{ { VkResult::VK_SUCCESS } };     VkPresentInfoKHR present_info{};     present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;     present_info.waitSemaphoreCount = 1;     present_info.pWaitSemaphores = &mVulkanRenderer.GetSignalSemaphore();     present_info.swapchainCount = 1;     present_info.pSwapchains = &mVkSwapchainKHR;     present_info.pImageIndices = &mActiveImageIndex;     present_info.pResults = result_array.data();     if ( VkResult result = vkQueuePresentKHR ( mVulkanRenderer.GetQueue(), &present_info ) )     {         std::cout << GetVulkanResultString ( result ) << "  " << __func__ << " " << __LINE__ << " " << std::endl;     } }

	void buildCommandBuffers()	{		VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();		VkClearValue clearValues[2];		clearValues[0].color = defaultClearColor;		clearValues[1].depthStencil = { 1.0f, 0 };		VkRenderPassBeginInfo renderPassBeginInfo = vkTools::initializers::renderPassBeginInfo();		renderPassBeginInfo.renderPass = renderPass;		renderPassBeginInfo.renderArea.offset.x = 0;		renderPassBeginInfo.renderArea.offset.y = 0;		renderPassBeginInfo.renderArea.extent.width = width;		renderPassBeginInfo.renderArea.extent.height = height;		renderPassBeginInfo.clearValueCount = 2;		renderPassBeginInfo.pClearValues = clearValues;		VkResult err;		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)		{			// Set target frame buffer			renderPassBeginInfo.framebuffer = frameBuffers[i];			err = vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo);			assert(!err);			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);			VkViewport viewport = vkTools::initializers::viewport(				(float)width,				(float)height,				0.0f,				1.0f);			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);			VkRect2D scissor = vkTools::initializers::rect2D(				width,				height,				0,				0);			vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);			vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, NULL);			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.solid);			VkDeviceSize offsets[1] = { 0 };			// Bind mesh vertex buffer			vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &mesh.vertices.buf, offsets);			// Bind mesh index buffer			vkCmdBindIndexBuffer(drawCmdBuffers[i], mesh.indices.buf, 0, VK_INDEX_TYPE_UINT32);			// Render mesh vertex buffer using it's indices			vkCmdDrawIndexed(drawCmdBuffers[i], mesh.indices.count, 1, 0, 0, 0);			vkCmdEndRenderPass(drawCmdBuffers[i]);			err = vkEndCommandBuffer(drawCmdBuffers[i]);			assert(!err);		}	}

void StateTracker::EndRenderPass(){  if (!InRenderPass())    return;  vkCmdEndRenderPass(g_command_buffer_mgr->GetCurrentCommandBuffer());  m_current_render_pass = VK_NULL_HANDLE;}

void Shadow::CookCmdBuffer(const Scene& scene){	// COMMAND BUFFER	auto drawTriangleCmdBufferAllocInfo = vkstruct<VkCommandBufferAllocateInfo>();	drawTriangleCmdBufferAllocInfo.commandPool = mCmdPool;	drawTriangleCmdBufferAllocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;	drawTriangleCmdBufferAllocInfo.commandBufferCount = 1u;	gVkLastRes = vkAllocateCommandBuffers(gDevice.VkHandle(), &drawTriangleCmdBufferAllocInfo, &mCmdBuffer);	VKFN_LAST_RES_SUCCESS_OR_QUIT(vkAllocateCommandBuffers);	auto framebufferCreateInfo = vkstruct<VkFramebufferCreateInfo>();	framebufferCreateInfo.flags = 0;	framebufferCreateInfo.renderPass = mRenderPass;	framebufferCreateInfo.attachmentCount = 1u;	framebufferCreateInfo.pAttachments = &mDepthImage.view;	framebufferCreateInfo.width = static_cast<u32>(SHADOWMAP_RES);	framebufferCreateInfo.height = static_cast<u32>(SHADOWMAP_RES);	framebufferCreateInfo.layers = 1u;	gVkLastRes = vkCreateFramebuffer(gDevice.VkHandle(), &framebufferCreateInfo, nullptr, &mFramebuffer);	VKFN_LAST_RES_SUCCESS_OR_QUIT(vkCreateFramebuffer);	VkClearValue clearDepthStencilValue;	clearDepthStencilValue.depthStencil = { 1.f, 0 };	auto renderPassBeginInfo = vkstruct<VkRenderPassBeginInfo>();	renderPassBeginInfo.renderPass = mRenderPass;	renderPassBeginInfo.framebuffer = mFramebuffer;	renderPassBeginInfo.renderArea = { { 0, 0 },{ SHADOWMAP_RES, SHADOWMAP_RES } };	renderPassBeginInfo.clearValueCount = 1u;	renderPassBeginInfo.pClearValues = &clearDepthStencilValue;	auto cmdBufferBeginInfo = vkstruct<VkCommandBufferBeginInfo>();	cmdBufferBeginInfo.flags = 0;	// REGISTER COMMAND BUFFER	gVkLastRes = vkBeginCommandBuffer(mCmdBuffer, &cmdBufferBeginInfo);	VKFN_LAST_RES_SUCCESS_OR_QUIT(vkBeginCommandBuffer);	// TRANSITION RENDERTARGET FROM PRESENTABLE TO RENDERABLE LAYOUT + Initial transition from UNDEFINED layout	vkCmdBeginRenderPass(mCmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);	vkCmdBindPipeline(mCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, mPipeline);	vkCmdBindDescriptorSets(mCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, mPipelineLayout,		0u, GlobalDescriptorSets::CB_COUNT, GlobalDescriptorSets::descriptorSets, 0u, nullptr);	scene.BindDrawingToCmdBuffer(mCmdBuffer);	vkCmdEndRenderPass(mCmdBuffer);	gVkLastRes = vkEndCommandBuffer(mCmdBuffer);	VKFN_LAST_RES_SUCCESS_OR_QUIT(vkEndCommandBuffer);}

	void buildCommandBuffers()	{		VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();		VkClearValue clearValues[2];		clearValues[0].color = defaultClearColor;		clearValues[1].depthStencil = { 1.0f, 0 };		VkRenderPassBeginInfo renderPassBeginInfo = vks::initializers::renderPassBeginInfo();		renderPassBeginInfo.renderPass = renderPass;		renderPassBeginInfo.renderArea.offset.x = 0;		renderPassBeginInfo.renderArea.offset.y = 0;		renderPassBeginInfo.renderArea.extent.width = width;		renderPassBeginInfo.renderArea.extent.height = height;		renderPassBeginInfo.clearValueCount = 2;		renderPassBeginInfo.pClearValues = clearValues;		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)		{			// Set target frame buffer			renderPassBeginInfo.framebuffer = frameBuffers[i];			VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);			VkViewport viewport = vks::initializers::viewport((float)width,	(float)height, 0.0f, 1.0f);			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);			VkRect2D scissor = vks::initializers::rect2D(width,	height,	0, 0);			vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);			VkDeviceSize offsets[1] = { 0 };			// Skybox			if (displaySkybox)			{				vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSets.skybox, 0, NULL);				vkCmdBindVertexBuffers(drawCmdBuffers[i], 0, 1, &models.skybox.vertices.buffer, offsets);				vkCmdBindIndexBuffer(drawCmdBuffers[i], models.skybox.indices.buffer, 0, VK_INDEX_TYPE_UINT32);				vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.skybox);				vkCmdDrawIndexed(drawCmdBuffers[i], models.skybox.indexCount, 1, 0, 0, 0);			}			// 3D object			vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSets.object, 0, NULL);			vkCmdBindVertexBuffers(drawCmdBuffers[i], 0, 1, &models.objects[models.objectIndex].vertices.buffer, offsets);			vkCmdBindIndexBuffer(drawCmdBuffers[i], models.objects[models.objectIndex].indices.buffer, 0, VK_INDEX_TYPE_UINT32);			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.reflect);			vkCmdDrawIndexed(drawCmdBuffers[i], models.objects[models.objectIndex].indexCount, 1, 0, 0, 0);			drawUI(drawCmdBuffers[i]);			vkCmdEndRenderPass(drawCmdBuffers[i]);			VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));		}	}

	void buildCommandBuffers()	{		VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();		VkClearValue clearValues[2];		clearValues[0].color = { {0.5f, 0.5f, 0.5f, 0.0f} };		clearValues[1].depthStencil = { 1.0f, 0 };		VkRenderPassBeginInfo renderPassBeginInfo = vkTools::initializers::renderPassBeginInfo();		renderPassBeginInfo.renderPass = renderPass;		renderPassBeginInfo.renderArea.offset.x = 0;		renderPassBeginInfo.renderArea.offset.y = 0;		renderPassBeginInfo.renderArea.extent.width = width;		renderPassBeginInfo.renderArea.extent.height = height;		renderPassBeginInfo.clearValueCount = 2;		renderPassBeginInfo.pClearValues = clearValues;		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)		{			// Set target frame buffer			renderPassBeginInfo.framebuffer = frameBuffers[i];			VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);			VkViewport viewport = vkTools::initializers::viewport(splitScreen ? (float)width / 2.0f : (float)width, (float)height, 0.0f, 1.0f);			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);			VkRect2D scissor = vkTools::initializers::rect2D(width, height, 0, 0);			vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);			vkCmdSetLineWidth(drawCmdBuffers[i], 1.0f);			vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, NULL);			VkDeviceSize offsets[1] = { 0 };			vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &meshes.object.vertices.buf, offsets);			vkCmdBindIndexBuffer(drawCmdBuffers[i], meshes.object.indices.buf, 0, VK_INDEX_TYPE_UINT32);			if (splitScreen)			{				vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);				vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLeft);				vkCmdDrawIndexed(drawCmdBuffers[i], meshes.object.indexCount, 1, 0, 0, 0);				viewport.x = float(width) / 2;			}			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineRight);			vkCmdDrawIndexed(drawCmdBuffers[i], meshes.object.indexCount, 1, 0, 0, 0);			vkCmdEndRenderPass(drawCmdBuffers[i]);			VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));		}	}

//==============================================================================void CommandBufferImpl::endRenderPass(){	commandCommon();	ANKI_ASSERT(insideRenderPass());	ANKI_ASSERT(m_rpDrawcallCount > 0);	vkCmdEndRenderPass(m_handle);	m_activeFb.reset(nullptr);}

	void buildCommandBuffers()	{		VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();		VkClearValue clearValues[2];		clearValues[0].color = defaultClearColor;		clearValues[1].depthStencil = { 1.0f, 0 };		VkRenderPassBeginInfo renderPassBeginInfo = vkTools::initializers::renderPassBeginInfo();		renderPassBeginInfo.renderPass = renderPass;		renderPassBeginInfo.renderArea.offset.x = 0;		renderPassBeginInfo.renderArea.offset.y = 0;		renderPassBeginInfo.renderArea.extent.width = width;		renderPassBeginInfo.renderArea.extent.height = height;		renderPassBeginInfo.clearValueCount = 2;		renderPassBeginInfo.pClearValues = clearValues;		VkResult err;		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)		{			// Set target frame buffer			renderPassBeginInfo.framebuffer = frameBuffers[i];			err = vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo);			assert(!err);			// The primary command buffer does not contain any rendering commands			// These are stored (and retrieved) from the secondary command buffers			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);			// Execute secondary command buffers			for (auto& renderThread : renderThreads)			{				// todo : Make sure threads are finished before accessing their command buffers				vkCmdExecuteCommands(drawCmdBuffers[i], 1, &renderThread.cmdBuffers[i]);			}			vkCmdEndRenderPass(drawCmdBuffers[i]);			VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);			vkCmdPipelineBarrier(				drawCmdBuffers[i],				VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,				VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,				VK_FLAGS_NONE,				0, nullptr,				0, nullptr,				1, &prePresentBarrier);			err = vkEndCommandBuffer(drawCmdBuffers[i]);			assert(!err);		}	}

void HookGui::HGWidgetShader::EndRender(){	// End the render pass	vkCmdEndRenderPass(m_CommandBuffer);	// End the command buffer record	if (vkEndCommandBuffer(m_CommandBuffer) != VK_SUCCESS)	{		throw std::runtime_error("failed to record command buffer!");	}}

	void buildCommandBuffers()	{		VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();		VkClearValue clearValues[2];		clearValues[0].color = defaultClearColor;		clearValues[1].depthStencil = { 1.0f, 0 };		VkRenderPassBeginInfo renderPassBeginInfo = vks::initializers::renderPassBeginInfo();		renderPassBeginInfo.renderPass = renderPass;		renderPassBeginInfo.renderArea.offset.x = 0;		renderPassBeginInfo.renderArea.offset.y = 0;		renderPassBeginInfo.renderArea.extent.width = width;		renderPassBeginInfo.renderArea.extent.height = height;		renderPassBeginInfo.clearValueCount = 2;		renderPassBeginInfo.pClearValues = clearValues;		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)		{			renderPassBeginInfo.framebuffer = frameBuffers[i];			VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);			VkViewport viewport = vks::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);			VkRect2D scissor = vks::initializers::rect2D(width, height, 0, 0);			vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);			VkDeviceSize offsets[1] = { 0 };			vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &vertexBuffer.buffer, offsets);			vkCmdBindIndexBuffer(drawCmdBuffers[i], indexBuffer.buffer, 0, VK_INDEX_TYPE_UINT32);			// Render multiple objects using different model matrices by dynamically offsetting into one uniform buffer			for (uint32_t j = 0; j < OBJECT_INSTANCES; j++)			{				// One dynamic offset per dynamic descriptor to offset into the ubo containing all model matrices				uint32_t dynamicOffset = j * static_cast<uint32_t>(dynamicAlignment);				// Bind the descriptor set for rendering a mesh using the dynamic offset				vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 1, &dynamicOffset);				vkCmdDrawIndexed(drawCmdBuffers[i], indexCount, 1, 0, 0, 0);			}			vkCmdEndRenderPass(drawCmdBuffers[i]);			VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));		}	}

	/**	* Update the command buffers to reflect text changes	*/	void updateCommandBuffers()	{		VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();		VkRenderPassBeginInfo renderPassBeginInfo = vks::initializers::renderPassBeginInfo();		renderPassBeginInfo.renderPass = renderPass;		renderPassBeginInfo.renderArea.extent.width = *frameBufferWidth;		renderPassBeginInfo.renderArea.extent.height = *frameBufferHeight;		// None of the attachments will be cleared		renderPassBeginInfo.clearValueCount = 0;		renderPassBeginInfo.pClearValues = nullptr;		for (size_t i = 0; i < cmdBuffers.size(); ++i)		{			renderPassBeginInfo.framebuffer = *frameBuffers[i];			VK_CHECK_RESULT(vkBeginCommandBuffer(cmdBuffers[i], &cmdBufInfo));			if (vks::debugmarker::active)			{				vks::debugmarker::beginRegion(cmdBuffers[i], "Text overlay", glm::vec4(1.0f, 0.94f, 0.3f, 1.0f));			}			vkCmdBeginRenderPass(cmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);			VkViewport viewport = vks::initializers::viewport((float)*frameBufferWidth, (float)*frameBufferHeight, 0.0f, 1.0f);			vkCmdSetViewport(cmdBuffers[i], 0, 1, &viewport);			VkRect2D scissor = vks::initializers::rect2D(*frameBufferWidth, *frameBufferHeight, 0, 0);			vkCmdSetScissor(cmdBuffers[i], 0, 1, &scissor);						vkCmdBindPipeline(cmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);			vkCmdBindDescriptorSets(cmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, NULL);			VkDeviceSize offsets = 0;			vkCmdBindVertexBuffers(cmdBuffers[i], 0, 1, &vertexBuffer.buffer, &offsets);			vkCmdBindVertexBuffers(cmdBuffers[i], 1, 1, &vertexBuffer.buffer, &offsets);			for (uint32_t j = 0; j < numLetters; j++)			{				vkCmdDraw(cmdBuffers[i], 4, 1, j * 4, 0);			}			vkCmdEndRenderPass(cmdBuffers[i]);			if (vks::debugmarker::active)			{				vks::debugmarker::endRegion(cmdBuffers[i]);			}			VK_CHECK_RESULT(vkEndCommandBuffer(cmdBuffers[i]));		}	}

	void RHI_CommandList::End()	{		if (!m_is_recording)			return;		vkCmdEndRenderPass(CMD_BUFFER_VK);		auto result = vkEndCommandBuffer(CMD_BUFFER_VK);		if (result != VK_SUCCESS)		{			LOGF_ERROR("Failed to end command buffer, %s.", Vulkan_Common::result_to_string(result));			return;		}		m_is_recording = false;	}

	void buildCommandBuffers()	{		VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();		VkClearValue clearValues[2];		clearValues[0].color = { { 1.0f, 1.0f, 1.0f, 1.0f } };		clearValues[1].depthStencil = { 1.0f, 0 };		VkRenderPassBeginInfo renderPassBeginInfo = vks::initializers::renderPassBeginInfo();		renderPassBeginInfo.renderPass = renderPass;		renderPassBeginInfo.renderArea.offset.x = 0;		renderPassBeginInfo.renderArea.offset.y = 0;		renderPassBeginInfo.renderArea.extent.width = width;		renderPassBeginInfo.renderArea.extent.height = height;		renderPassBeginInfo.clearValueCount = 2;		renderPassBeginInfo.pClearValues = clearValues;		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i) {			renderPassBeginInfo.framebuffer = frameBuffers[i];			VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);			VkViewport viewport = vks::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);			VkRect2D scissor = vks::initializers::rect2D(width, height, 0, 0);			vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);			vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, NULL);			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);							const VkDeviceSize offsets[1] = { 0 };			vkCmdBindVertexBuffers(drawCmdBuffers[i], 0, 1, &scene.vertices.buffer, offsets);			vkCmdBindIndexBuffer(drawCmdBuffers[i], scene.indices.buffer, 0, VK_INDEX_TYPE_UINT32);			for (auto node : scene.nodes) {				renderNode(node, drawCmdBuffers[i]);			}			drawUI(drawCmdBuffers[i]);			vkCmdEndRenderPass(drawCmdBuffers[i]);			VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));		}	}

	void buildCommandBuffers()	{		VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();		VkClearValue clearValues[3];		// Clear to a white background for higher contrast		clearValues[0].color = { { 1.0f, 1.0f, 1.0f, 1.0f } };		clearValues[1].color = { { 1.0f, 1.0f, 1.0f, 1.0f } };		clearValues[2].depthStencil = { 1.0f, 0 };		VkRenderPassBeginInfo renderPassBeginInfo = vks::initializers::renderPassBeginInfo();		renderPassBeginInfo.renderPass = renderPass;		renderPassBeginInfo.renderArea.extent.width = width;		renderPassBeginInfo.renderArea.extent.height = height;		renderPassBeginInfo.clearValueCount = 3;		renderPassBeginInfo.pClearValues = clearValues;		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)		{			// Set target frame buffer			renderPassBeginInfo.framebuffer = frameBuffers[i];			VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);			VkViewport viewport = vks::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);			VkRect2D scissor = vks::initializers::rect2D(width, height, 0, 0);			vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);			vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, NULL);			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, useSampleShading ? pipelines.MSAASampleShading : pipelines.MSAA);			VkDeviceSize offsets[1] = { 0 };			vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &models.example.vertices.buffer, offsets);			vkCmdBindIndexBuffer(drawCmdBuffers[i], models.example.indices.buffer, 0, VK_INDEX_TYPE_UINT32);			vkCmdDrawIndexed(drawCmdBuffers[i], models.example.indexCount, 1, 0, 0, 0);			vkCmdEndRenderPass(drawCmdBuffers[i]);			VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));		}	}

void NormalMapVK::PopulateCommandBuffer(const size_t i){	const auto CB = CommandPools[0].second[i];//CommandBuffers[i];	//const auto SCB = SecondaryCommandBuffers[i];	const auto FB = Framebuffers[i];	const auto Image = SwapchainImages[i];	const VkCommandBufferBeginInfo BeginInfo = {		VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,		nullptr,		0,		nullptr	};	VERIFY_SUCCEEDED(vkBeginCommandBuffer(CB, &BeginInfo)); {		vkCmdSetViewport(CB, 0, static_cast<uint32_t>(Viewports.size()), Viewports.data());		vkCmdSetScissor(CB, 0, static_cast<uint32_t>(ScissorRects.size()), ScissorRects.data());		ClearColor(CB, Image, Colors::SkyBlue);		const VkRenderPassBeginInfo RenderPassBeginInfo = {			VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,			nullptr,			RenderPass,			FB,			ScissorRects[0],			0, nullptr		};		vkCmdBeginRenderPass(CB, &RenderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); {						if (!DescriptorSets.empty()) {				vkCmdBindDescriptorSets(CB,					VK_PIPELINE_BIND_POINT_GRAPHICS,					PipelineLayout,					0, static_cast<uint32_t>(DescriptorSets.size()), DescriptorSets.data(),					0, nullptr);			}			vkCmdBindPipeline(CB, VK_PIPELINE_BIND_POINT_GRAPHICS, Pipeline);			vkCmdDrawIndirect(CB, IndirectBuffer, 0, 1, 0);		} vkCmdEndRenderPass(CB);	} VERIFY_SUCCEEDED(vkEndCommandBuffer(CB));}

	void buildCommandBuffers()	{		VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();		VkClearValue clearValues[2];		clearValues[0].color = defaultClearColor;		clearValues[1].depthStencil = { 1.0f, 0 };		VkRenderPassBeginInfo renderPassBeginInfo = vkTools::initializers::renderPassBeginInfo();		renderPassBeginInfo.renderPass = renderPass;		renderPassBeginInfo.renderArea.offset.x = 0;		renderPassBeginInfo.renderArea.offset.y = 0;		renderPassBeginInfo.renderArea.extent.width = width;		renderPassBeginInfo.renderArea.extent.height = height;		renderPassBeginInfo.clearValueCount = 2;		renderPassBeginInfo.pClearValues = clearValues;		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)		{			renderPassBeginInfo.framebuffer = frameBuffers[i];			VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);			VkViewport viewport = vkTools::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);			VkRect2D scissor = vkTools::initializers::rect2D(width, height, 0, 0);			vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.solid);			for (auto& gear : gears)			{				gear->draw(drawCmdBuffers[i], pipelineLayout);			}			vkCmdEndRenderPass(drawCmdBuffers[i]);			VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));		}	}

static void frame_end(){    VkResult err;    vkCmdEndRenderPass(g_CommandBuffer[g_FrameIndex]);    {        VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;        VkSubmitInfo info = {};        info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;        info.waitSemaphoreCount = 1;        info.pWaitSemaphores = &g_PresentCompleteSemaphore[g_FrameIndex];        info.pWaitDstStageMask = &wait_stage;        info.commandBufferCount = 1;        info.pCommandBuffers = &g_CommandBuffer[g_FrameIndex];        info.signalSemaphoreCount = 1;        info.pSignalSemaphores = &g_RenderCompleteSemaphore[g_FrameIndex];        err = vkEndCommandBuffer(g_CommandBuffer[g_FrameIndex]);        check_vk_result(err);        err = vkResetFences(g_Device, 1, &g_Fence[g_FrameIndex]);        check_vk_result(err);        err = vkQueueSubmit(g_Queue, 1, &info, g_Fence[g_FrameIndex]);        check_vk_result(err);    }}

//.........这里部分代码省略.........        vkCmdBindVertexBuffers(secondary_cmds[i], 0, 1, &info.vertex_buffer.buf, offsets);        viewport.x = 25.0f + 250.0f * (i % 2);        viewport.y = 25.0f + 250.0f * (i / 2);        vkCmdSetViewport(secondary_cmds[i], 0, NUM_VIEWPORTS, &viewport);        vkCmdSetScissor(secondary_cmds[i], 0, NUM_SCISSORS, &scissor);        vkCmdDraw(secondary_cmds[i], 12 * 3, 1, 0, 0);        vkEndCommandBuffer(secondary_cmds[i]);    }    VkRenderPassBeginInfo rp_begin;    rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;    rp_begin.pNext = NULL;    rp_begin.renderPass = info.render_pass;    rp_begin.framebuffer = info.framebuffers[info.current_buffer];    rp_begin.renderArea.offset.x = 0;    rp_begin.renderArea.offset.y = 0;    rp_begin.renderArea.extent.width = info.width;    rp_begin.renderArea.extent.height = info.height;    rp_begin.clearValueCount = 2;    rp_begin.pClearValues = clear_values;    // specifying VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS means this    // render pass may    // ONLY call vkCmdExecuteCommands    vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);    vkCmdExecuteCommands(info.cmd, 4, secondary_cmds);    vkCmdEndRenderPass(info.cmd);    VkImageMemoryBarrier prePresentBarrier = {};    prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;    prePresentBarrier.pNext = NULL;    prePresentBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;    prePresentBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;    prePresentBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;    prePresentBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;    prePresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;    prePresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;    prePresentBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;    prePresentBarrier.subresourceRange.baseMipLevel = 0;    prePresentBarrier.subresourceRange.levelCount = 1;    prePresentBarrier.subresourceRange.baseArrayLayer = 0;    prePresentBarrier.subresourceRange.layerCount = 1;    prePresentBarrier.image = info.buffers[info.current_buffer].image;    vkCmdPipelineBarrier(info.cmd, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL,                         0, NULL, 1, &prePresentBarrier);    res = vkEndCommandBuffer(info.cmd);    assert(res == VK_SUCCESS);    const VkCommandBuffer cmd_bufs[] = {info.cmd};    VkFenceCreateInfo fenceInfo;    VkFence drawFence;    fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;    fenceInfo.pNext = NULL;    fenceInfo.flags = 0;    vkCreateFence(info.device, &fenceInfo, NULL, &drawFence);    VkPipelineStageFlags pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;    VkSubmitInfo submit_info[1] = {};

//.........这里部分代码省略.........    // Get the index of the next available swapchain image:    res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX, imageAcquiredSemaphore, VK_NULL_HANDLE,                                &info.current_buffer);    // TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR    // return codes    assert(res == VK_SUCCESS);    VkRenderPassBeginInfo rp_begin;    rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;    rp_begin.pNext = NULL;    rp_begin.renderPass = info.render_pass;    rp_begin.framebuffer = info.framebuffers[info.current_buffer];    rp_begin.renderArea.offset.x = 0;    rp_begin.renderArea.offset.y = 0;    rp_begin.renderArea.extent.width = info.width;    rp_begin.renderArea.extent.height = info.height;    rp_begin.clearValueCount = 2;    rp_begin.pClearValues = clear_values;    vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);    vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);    vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline_layout, 0, descriptor_set_count,                            descriptor_sets, 0, NULL);    const VkDeviceSize offsets[1] = {0};    vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf, offsets);    init_viewports(info);    init_scissors(info);    vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);    vkCmdEndRenderPass(info.cmd);    res = vkEndCommandBuffer(info.cmd);    assert(res == VK_SUCCESS);    const VkCommandBuffer cmd_bufs[] = {info.cmd};    VkFenceCreateInfo fenceInfo;    VkFence drawFence;    fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;    fenceInfo.pNext = NULL;    fenceInfo.flags = 0;    vkCreateFence(info.device, &fenceInfo, NULL, &drawFence);    VkPipelineStageFlags pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;    VkSubmitInfo submit_info[1] = {};    submit_info[0].pNext = NULL;    submit_info[0].sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;    submit_info[0].waitSemaphoreCount = 1;    submit_info[0].pWaitSemaphores = &imageAcquiredSemaphore;    submit_info[0].pWaitDstStageMask = &pipe_stage_flags;    submit_info[0].commandBufferCount = 1;    submit_info[0].pCommandBuffers = cmd_bufs;    submit_info[0].signalSemaphoreCount = 0;    submit_info[0].pSignalSemaphores = NULL;    /* Queue the command buffer for execution */    res = vkQueueSubmit(info.graphics_queue, 1, submit_info, drawFence);    assert(res == VK_SUCCESS);    /* Now present the image in the window */    VkPresentInfoKHR present;    present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;    present.pNext = NULL;

//.........这里部分代码省略.........        moduleCreateInfo.pCode = fragmentBinary->code;        spvDiagnosticDestroy(fragmentDiag);        spvContextDestroy(spvContext);    } else {        // Convert GLSL to SPIR-V        init_glslang();        std::vector<unsigned int> fragSpv;        bool U_ASSERT_ONLY retVal = GLSLtoSPV(VK_SHADER_STAGE_FRAGMENT_BIT, fragShaderText, fragSpv);        assert(retVal);        finalize_glslang();        moduleCreateInfo.codeSize = fragSpv.size() * sizeof(unsigned int);        moduleCreateInfo.pCode = fragSpv.data();    }    res = vkCreateShaderModule(info.device, &moduleCreateInfo, NULL, &info.shaderStages[1].module);    assert(res == VK_SUCCESS);    /* VULKAN_KEY_END */    init_framebuffers(info, depthPresent);    init_vertex_buffer(info, g_vb_texture_Data, sizeof(g_vb_texture_Data), sizeof(g_vb_texture_Data[0]), true);    init_descriptor_pool(info, true);    init_descriptor_set(info, true);    init_pipeline_cache(info);    init_pipeline(info, depthPresent);    init_presentable_image(info);    VkClearValue clear_values[2];    init_clear_color_and_depth(info, clear_values);    VkRenderPassBeginInfo rp_begin;    init_render_pass_begin_info(info, rp_begin);    rp_begin.clearValueCount = 2;    rp_begin.pClearValues = clear_values;    vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);    vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);    vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,                            info.desc_set.data(), 0, NULL);    const VkDeviceSize offsets[1] = {0};    vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf, offsets);    init_viewports(info);    init_scissors(info);    vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);    vkCmdEndRenderPass(info.cmd);    res = vkEndCommandBuffer(info.cmd);    assert(res == VK_SUCCESS);    VkFence drawFence = {};    init_fence(info, drawFence);    VkPipelineStageFlags pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;    VkSubmitInfo submit_info = {};    init_submit_info(info, submit_info, pipe_stage_flags);    /* Queue the command buffer for execution */    res = vkQueueSubmit(info.graphics_queue, 1, &submit_info, drawFence);    assert(res == VK_SUCCESS);    /* Now present the image in the window */    VkPresentInfoKHR present = {};    init_present_info(info, present);    /* Make sure command buffer is finished before presenting */    do {        res = vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);    } while (res == VK_TIMEOUT);    assert(res == VK_SUCCESS);    res = vkQueuePresentKHR(info.present_queue, &present);    assert(res == VK_SUCCESS);    wait_seconds(1);    if (info.save_images) write_ppm(info, "spirv_specialization");    vkDestroyFence(info.device, drawFence, NULL);    vkDestroySemaphore(info.device, info.imageAcquiredSemaphore, NULL);    destroy_pipeline(info);    destroy_pipeline_cache(info);    destroy_textures(info);    destroy_descriptor_pool(info);    destroy_vertex_buffer(info);    destroy_framebuffers(info);    destroy_shaders(info);    destroy_renderpass(info);    destroy_descriptor_and_pipeline_layouts(info);    destroy_uniform_buffer(info);    destroy_depth_buffer(info);    destroy_swap_chain(info);    destroy_command_buffer(info);    destroy_command_pool(info);    destroy_device(info);    destroy_window(info);    destroy_instance(info);    return 0;}

//.........这里部分代码省略.........    rp_begin.renderArea.offset.x = 0;    rp_begin.renderArea.offset.y = 0;    rp_begin.renderArea.extent.width = info.width;    rp_begin.renderArea.extent.height = info.height;    rp_begin.clearValueCount = 2;    rp_begin.pClearValues = clear_values;    vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);    vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);    /* The first draw should use the first matrix in the buffer */    uint32_t uni_offsets[1] = {0};    vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,                            info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,                            info.desc_set.data(), 1, uni_offsets);    const VkDeviceSize vtx_offsets[1] = {0};    vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf,                           vtx_offsets);    init_viewports(info);    init_scissors(info);    vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);    uni_offsets[0] = (uint32_t)buf_size; /* The second draw should use the                                            second matrix in the buffer */    vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,                            info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,                            info.desc_set.data(), 1, uni_offsets);    vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);    vkCmdEndRenderPass(info.cmd);    VkImageMemoryBarrier prePresentBarrier = {};    prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;    prePresentBarrier.pNext = NULL;    prePresentBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;    prePresentBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;    prePresentBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;    prePresentBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;    prePresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;    prePresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;    prePresentBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;    prePresentBarrier.subresourceRange.baseMipLevel = 0;    prePresentBarrier.subresourceRange.levelCount = 1;    prePresentBarrier.subresourceRange.baseArrayLayer = 0;    prePresentBarrier.subresourceRange.layerCount = 1;    prePresentBarrier.image = info.buffers[info.current_buffer].image;    vkCmdPipelineBarrier(info.cmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,                         VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0,                         NULL, 1, &prePresentBarrier);    res = vkEndCommandBuffer(info.cmd);    const VkCommandBuffer cmd_bufs[] = {info.cmd};    VkFenceCreateInfo fenceInfo;    VkFence drawFence;    fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;    fenceInfo.pNext = NULL;    fenceInfo.flags = 0;    vkCreateFence(info.device, &fenceInfo, NULL, &drawFence);    VkPipelineStageFlags pipe_stage_flags =        VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;    VkSubmitInfo submit_info[1] = {};

//.........这里部分代码省略.........    descriptor_writes[2] = {};    descriptor_writes[2].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;    descriptor_writes[2].pNext = NULL;    descriptor_writes[2].dstSet = descriptor_sets[0];    descriptor_writes[2].descriptorCount = 1;    descriptor_writes[2].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;    descriptor_writes[2].pImageInfo = &samplerInfo;    descriptor_writes[2].dstArrayElement = 0;    descriptor_writes[2].dstBinding = 2;    vkUpdateDescriptorSets(info.device, resource_count, descriptor_writes, 0, NULL);    /* VULKAN_KEY_END */    init_pipeline_cache(info);    init_pipeline(info, depthPresent);    init_presentable_image(info);    VkClearValue clear_values[2];    init_clear_color_and_depth(info, clear_values);    VkRenderPassBeginInfo rp_begin;    init_render_pass_begin_info(info, rp_begin);    rp_begin.clearValueCount = 2;    rp_begin.pClearValues = clear_values;    vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);    vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);    vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,                            descriptor_sets, 0, NULL);    const VkDeviceSize offsets[1] = {0};    vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf, offsets);    init_viewports(info);    init_scissors(info);    vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);    vkCmdEndRenderPass(info.cmd);    res = vkEndCommandBuffer(info.cmd);    assert(res == VK_SUCCESS);    VkFence drawFence = {};    init_fence(info, drawFence);    VkPipelineStageFlags pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;    VkSubmitInfo submit_info = {};    init_submit_info(info, submit_info, pipe_stage_flags);    /* Queue the command buffer for execution */    res = vkQueueSubmit(info.graphics_queue, 1, &submit_info, drawFence);    assert(res == VK_SUCCESS);    /* Now present the image in the window */    VkPresentInfoKHR present = {};    init_present_info(info, present);    /* Make sure command buffer is finished before presenting */    do {        res = vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);    } while (res == VK_TIMEOUT);    assert(res == VK_SUCCESS);    res = vkQueuePresentKHR(info.present_queue, &present);    assert(res == VK_SUCCESS);    wait_seconds(1);    if (info.save_images) write_ppm(info, "separate_image_sampler");    vkDestroyFence(info.device, drawFence, NULL);    vkDestroySemaphore(info.device, info.imageAcquiredSemaphore, NULL);    destroy_pipeline(info);    destroy_pipeline_cache(info);    vkDestroySampler(info.device, separateSampler, NULL);    vkDestroyImageView(info.device, info.textures[0].view, NULL);    vkDestroyImage(info.device, info.textures[0].image, NULL);    vkFreeMemory(info.device, info.textures[0].mem, NULL);    // instead of destroy_descriptor_pool(info);    vkDestroyDescriptorPool(info.device, descriptor_pool[0], NULL);    destroy_vertex_buffer(info);    destroy_framebuffers(info);    destroy_shaders(info);    destroy_renderpass(info);    // instead of destroy_descriptor_and_pipeline_layouts(info);    for (int i = 0; i < descriptor_set_count; i++) vkDestroyDescriptorSetLayout(info.device, descriptor_layouts[i], NULL);    vkDestroyPipelineLayout(info.device, info.pipeline_layout, NULL);    destroy_uniform_buffer(info);    destroy_depth_buffer(info);    destroy_swap_chain(info);    destroy_command_buffer(info);    destroy_command_pool(info);    destroy_device(info);    destroy_window(info);    destroy_instance(info);    return 0;}

//.........这里部分代码省略.........                */                vkCmdBeginRenderPass(m_commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);                vkCmdSetViewport(m_commandBuffer, 0, 1, &viewport);                vkCmdSetScissor(m_commandBuffer, 0, 1, &scissor);                std::map<IPipelineHandle, std::vector<RenderableInstances>>::iterator iterator;                for (iterator = m_pipelineList.begin(); iterator != m_pipelineList.end(); iterator++)                {                    VKPipelineHandle pipeline = iterator->first.DynamicCastHandle<VKPipeline>();                    //Calculate inverse view proj                    Math::Matrix4 invViewProj = Math::MMMatrixTranspose(Math::MMMatrixInverse(m_view));                    m_view = Math::MMMatrixTranspose(m_view);                    m_proj = Math::MMMatrixTranspose(m_proj);                    pipeline->VSetMatrix4("pass.0proj", m_proj);                    pipeline->VSetMatrix4("pass.1view", m_view);                    pipeline->VSetMatrix4("pass.2invViewProj", invViewProj);                    pipeline->VSetInt("pass.3width", m_width);                    pipeline->VSetInt("pass.4height", m_height);                    pipeline->VUpdate();                    VkPipeline vkPipeline = pipeline->GetVKPipeline();                    VkPipelineLayout vkPipelineLayout = renderer->GetVKRootLayoutHandle()->VKGetPipelineLayout();                    vkCmdBindPipeline(m_commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vkPipeline);                    pipeline->SendPushConstants(m_commandBuffer, vkPipelineLayout);                    //Bind input textures                    if(m_inputTargetDescriptorSets.size() > 0)                        vkCmdBindDescriptorSets(m_commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vkPipelineLayout, m_firstInputTargetSetIndex,                            static_cast<uint32_t>(m_inputTargetDescriptorSets.size()), m_inputTargetDescriptorSets.data(), 0, nullptr);                    std::vector<RenderableInstances> renderables = iterator->second;                    VkDeviceSize offsets[] = { 0 };                    for (uint32_t i = 0; i < renderables.size(); i++)                    {                        Renderable renderable = renderables[i].renderable;                        uint32_t count = renderables[i].count;                        VKMaterialHandle material = renderable.material.DynamicCastHandle<VKMaterial>();                        VKMeshHandle     mesh = renderable.mesh.DynamicCastHandle<VKMesh>();                                            std::vector<VkDescriptorSet> descriptorSets = material->GetVKDescriptorSets();                                                //Bind material descriptor sets                        vkCmdBindDescriptorSets(m_commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,                            vkPipelineLayout, 0, static_cast<uint32_t>(descriptorSets.size()), descriptorSets.data(), 0, nullptr);                                            //Bind instance buffer                        if(m_instanceDataSize > 0)                            vkCmdBindVertexBuffers(m_commandBuffer, 1, 1, &m_instanceBlock.buffer, offsets);                        UniformBlock_vk vertBlock = mesh->GetVertexBlock();                        UniformBlock_vk indexBlock = mesh->GetIndexBlock();                        uint32_t indexCount = mesh->GetIndexCount();                        vkCmdBindVertexBuffers(m_commandBuffer, 0, 1, &vertBlock.buffer, offsets);                        vkCmdBindIndexBuffer(m_commandBuffer, indexBlock.buffer, 0, VK_INDEX_TYPE_UINT32);                                                vkCmdDrawIndexed(m_commandBuffer, indexCount, count, 0, 0, 0);                    }                }                vkCmdEndRenderPass(m_commandBuffer);                /*                    END BUFFER COMMANDS                */                //Blit to render targets                for (size_t i = 0; i < m_outputRenderTargets.size(); i++)                {                    VKRenderTargetHandle renderTarget = m_outputRenderTargets[i].DynamicCastHandle<VKRenderTarget>();                    if (!renderTarget->Blit(m_commandBuffer, m_colorImages[i]))                        return false;                }                                err = vkEndCommandBuffer(m_commandBuffer);                assert(!err);                if (err != VK_SUCCESS)                {                    HT_DEBUG_PRINTF("VKRenderPass::VBuildCommandList(): Failed to end command buffer./n");                    return false;                }                //Delete instance data                delete[] m_instanceData;                m_instanceData = nullptr;                m_instanceDataSize = 0;                return true;            }

  bool Tutorial03::RecordCommandBuffers() {    VkCommandBufferBeginInfo graphics_commandd_buffer_begin_info = {      VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,    // VkStructureType                        sType      nullptr,                                        // const void                            *pNext      VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,   // VkCommandBufferUsageFlags              flags      nullptr                                         // const VkCommandBufferInheritanceInfo  *pInheritanceInfo    };    VkImageSubresourceRange image_subresource_range = {      VK_IMAGE_ASPECT_COLOR_BIT,                      // VkImageAspectFlags             aspectMask      0,                                              // uint32_t                       baseMipLevel      1,                                              // uint32_t                       levelCount      0,                                              // uint32_t                       baseArrayLayer      1                                               // uint32_t                       layerCount    };    VkClearValue clear_value = {      { 1.0f, 0.8f, 0.4f, 0.0f },                     // VkClearColorValue              color    };    const std::vector<ImageParameters>& swap_chain_images = GetSwapChain().Images;    for( size_t i = 0; i < Vulkan.GraphicsCommandBuffers.size(); ++i ) {      vkBeginCommandBuffer( Vulkan.GraphicsCommandBuffers[i], &graphics_commandd_buffer_begin_info );      if( GetPresentQueue().Handle != GetGraphicsQueue().Handle ) {        VkImageMemoryBarrier barrier_from_present_to_draw = {          VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,     // VkStructureType                sType          nullptr,                                    // const void                    *pNext          VK_ACCESS_MEMORY_READ_BIT,                  // VkAccessFlags                  srcAccessMask          VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,       // VkAccessFlags                  dstAccessMask          VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,            // VkImageLayout                  oldLayout          VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,            // VkImageLayout                  newLayout          GetPresentQueue().FamilyIndex,              // uint32_t                       srcQueueFamilyIndex          GetGraphicsQueue().FamilyIndex,             // uint32_t                       dstQueueFamilyIndex          swap_chain_images[i].Handle,                // VkImage                        image          image_subresource_range                     // VkImageSubresourceRange        subresourceRange        };        vkCmdPipelineBarrier( Vulkan.GraphicsCommandBuffers[i], VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier_from_present_to_draw );      }      VkRenderPassBeginInfo render_pass_begin_info = {        VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,     // VkStructureType                sType        nullptr,                                      // const void                    *pNext        Vulkan.RenderPass,                            // VkRenderPass                   renderPass        Vulkan.Framebuffers[i],                       // VkFramebuffer                  framebuffer        {                                             // VkRect2D                       renderArea          {                                           // VkOffset2D                     offset            0,                                          // int32_t                        x            0                                           // int32_t                        y          },          {                                           // VkExtent2D                     extent            300,                                        // int32_t                        width            300,                                        // int32_t                        height          }        },        1,                                            // uint32_t                       clearValueCount        &clear_value                                  // const VkClearValue            *pClearValues      };      vkCmdBeginRenderPass( Vulkan.GraphicsCommandBuffers[i], &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE );      vkCmdBindPipeline( Vulkan.GraphicsCommandBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, Vulkan.GraphicsPipeline );      vkCmdDraw( Vulkan.GraphicsCommandBuffers[i], 3, 1, 0, 0 );      vkCmdEndRenderPass( Vulkan.GraphicsCommandBuffers[i] );      if( GetGraphicsQueue().Handle != GetPresentQueue().Handle ) {        VkImageMemoryBarrier barrier_from_draw_to_present = {          VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,       // VkStructureType              sType          nullptr,                                      // const void                  *pNext          VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,         // VkAccessFlags                srcAccessMask          VK_ACCESS_MEMORY_READ_BIT,                    // VkAccessFlags                dstAccessMask          VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,              // VkImageLayout                oldLayout          VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,              // VkImageLayout                newLayout          GetGraphicsQueue().FamilyIndex,               // uint32_t                     srcQueueFamilyIndex          GetPresentQueue().FamilyIndex,                // uint32_t                     dstQueueFamilyIndex          swap_chain_images[i].Handle,                  // VkImage                      image          image_subresource_range                       // VkImageSubresourceRange      subresourceRange        };        vkCmdPipelineBarrier( Vulkan.GraphicsCommandBuffers[i], VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier_from_draw_to_present );      }      if( vkEndCommandBuffer( Vulkan.GraphicsCommandBuffers[i] ) != VK_SUCCESS ) {        std::cout << "Could not record command buffer!" << std::endl;        return false;      }    }    return true;  }

	void buildCommandBuffers()	{		// Destroy command buffers if already present		if (!checkCommandBuffers())		{			destroyCommandBuffers();			createCommandBuffers();		}		VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();		VkClearValue clearValues[2];		clearValues[0].color = defaultClearColor;		clearValues[1].depthStencil = { 1.0f, 0 };		VkRenderPassBeginInfo renderPassBeginInfo = vkTools::initializers::renderPassBeginInfo();		renderPassBeginInfo.renderPass = renderPass;		renderPassBeginInfo.renderArea.offset.x = 0;		renderPassBeginInfo.renderArea.offset.y = 0;		renderPassBeginInfo.renderArea.extent.width = width;		renderPassBeginInfo.renderArea.extent.height = height;		renderPassBeginInfo.clearValueCount = 2;		renderPassBeginInfo.pClearValues = clearValues;		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)		{			// Set target frame buffer			renderPassBeginInfo.framebuffer = frameBuffers[i];			VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));			// Compute particle movement			// Add memory barrier to ensure that the (rendering) vertex shader operations have finished			// Required as the compute shader will overwrite the vertex buffer data			VkBufferMemoryBarrier bufferBarrier = vkTools::initializers::bufferMemoryBarrier();			// Vertex shader invocations have finished reading from the buffer			bufferBarrier.srcAccessMask = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;			// Compute shader buffer read and write			bufferBarrier.dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT;			bufferBarrier.buffer = computeStorageBuffer.buffer;			bufferBarrier.size = computeStorageBuffer.descriptor.range;			bufferBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;			bufferBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;			vkCmdPipelineBarrier(				drawCmdBuffers[i],				VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,				VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,				VK_FLAGS_NONE,				0, nullptr,				1, &bufferBarrier,				0, nullptr);			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_COMPUTE, pipelines.compute);			vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_COMPUTE, computePipelineLayout, 0, 1, &computeDescriptorSet, 0, 0);			// Dispatch the compute job			vkCmdDispatch(drawCmdBuffers[i], PARTICLE_COUNT / 16, 1, 1);			// Add memory barrier to ensure that compute shader has finished writing to the buffer			// Without this the (rendering) vertex shader may display incomplete results (partial data from last frame)			// Compute shader has finished writes to the buffer			bufferBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;			// Vertex shader access (attribute binding)			bufferBarrier.dstAccessMask = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;			bufferBarrier.buffer = computeStorageBuffer.buffer;			bufferBarrier.size = computeStorageBuffer.descriptor.range;			bufferBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;			bufferBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;			vkCmdPipelineBarrier(				drawCmdBuffers[i],				VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,				VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,				VK_FLAGS_NONE, 				0, nullptr,				1, &bufferBarrier,				0, nullptr);			// Draw the particle system using the update vertex buffer			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);			VkViewport viewport = vkTools::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);			VkRect2D scissor = vkTools::initializers::rect2D(width, height, 0, 0);			vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.postCompute);			vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSetPostCompute, 0, NULL);			VkDeviceSize offsets[1] = { 0 };			vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &computeStorageBuffer.buffer, offsets);			vkCmdDraw(drawCmdBuffers[i], PARTICLE_COUNT, 1, 0, 0);			vkCmdEndRenderPass(drawCmdBuffers[i]);			VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));//.........这里部分代码省略.........

	void buildCommandBuffers()	{		VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();		VkClearValue clearValues[2];		VkViewport viewport;		VkRect2D scissor;		VkDeviceSize offsets[1] = { 0 };		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)		{			VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));			/*				First render pass: Offscreen rendering			*/			{				clearValues[0].color = { { 0.0f, 0.0f, 0.0f, 0.0f } };				clearValues[1].depthStencil = { 1.0f, 0 };				VkRenderPassBeginInfo renderPassBeginInfo = vks::initializers::renderPassBeginInfo();				renderPassBeginInfo.renderPass = offscreenPass.renderPass;				renderPassBeginInfo.framebuffer = offscreenPass.frameBuffer;				renderPassBeginInfo.renderArea.extent.width = offscreenPass.width;				renderPassBeginInfo.renderArea.extent.height = offscreenPass.height;				renderPassBeginInfo.clearValueCount = 2;				renderPassBeginInfo.pClearValues = clearValues;				viewport = vks::initializers::viewport((float)offscreenPass.width, (float)offscreenPass.height, 0.0f, 1.0f);				vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);				scissor = vks::initializers::rect2D(offscreenPass.width, offscreenPass.height, 0, 0);				vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);				vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);				vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.scene, 0, 1, &descriptorSets.scene, 0, NULL);				vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.colorPass);				vkCmdBindVertexBuffers(drawCmdBuffers[i], 0, 1, &models.example.vertices.buffer, offsets);				vkCmdBindIndexBuffer(drawCmdBuffers[i], models.example.indices.buffer, 0, VK_INDEX_TYPE_UINT32);				vkCmdDrawIndexed(drawCmdBuffers[i], models.example.indexCount, 1, 0, 0, 0);				vkCmdEndRenderPass(drawCmdBuffers[i]);			}			/*				Note: Explicit synchronization is not required between the render pass, as this is done implicit via sub pass dependencies			*/			/*				Second render pass: Scene rendering with applied radial blur			*/			{				clearValues[0].color = defaultClearColor;				clearValues[1].depthStencil = { 1.0f, 0 };				VkRenderPassBeginInfo renderPassBeginInfo = vks::initializers::renderPassBeginInfo();				renderPassBeginInfo.renderPass = renderPass;				renderPassBeginInfo.framebuffer = frameBuffers[i];				renderPassBeginInfo.renderArea.extent.width = width;				renderPassBeginInfo.renderArea.extent.height = height;				renderPassBeginInfo.clearValueCount = 2;				renderPassBeginInfo.pClearValues = clearValues;				vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);				viewport = vks::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);				vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);				scissor = vks::initializers::rect2D(width, height, 0, 0);				vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);								// 3D scene				vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.scene, 0, 1, &descriptorSets.scene, 0, NULL);				vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.phongPass);				vkCmdBindVertexBuffers(drawCmdBuffers[i], 0, 1, &models.example.vertices.buffer, offsets);				vkCmdBindIndexBuffer(drawCmdBuffers[i], models.example.indices.buffer, 0, VK_INDEX_TYPE_UINT32);				vkCmdDrawIndexed(drawCmdBuffers[i], models.example.indexCount, 1, 0, 0, 0);				// Fullscreen triangle (clipped to a quad) with radial blur				if (blur)				{					vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.radialBlur, 0, 1, &descriptorSets.radialBlur, 0, NULL);					vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, (displayTexture) ? pipelines.offscreenDisplay : pipelines.radialBlur);					vkCmdDraw(drawCmdBuffers[i], 3, 1, 0, 0);				}				drawUI(drawCmdBuffers[i]);				vkCmdEndRenderPass(drawCmdBuffers[i]);			}			VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));		}	}

//.........这里部分代码省略.........    descriptor_writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;    descriptor_writes[0].pNext = NULL;    descriptor_writes[0].dstSet = descriptor_sets[0];    descriptor_writes[0].descriptorCount = 1;    descriptor_writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;    descriptor_writes[0].pBufferInfo = &info.uniform_data.buffer_info;  // populated by init_uniform_buffer()    descriptor_writes[0].dstArrayElement = 0;    descriptor_writes[0].dstBinding = 0;    vkUpdateDescriptorSets(info.device, resource_count, descriptor_writes, 0, NULL);    // Create our push constant data, which matches shader expectations    unsigned pushConstants[2] = {};    pushConstants[0] = (unsigned)2;    pushConstants[1] = (unsigned)0x3F800000;    // Ensure we have enough room for push constant data    if (sizeof(pushConstants) > info.gpu_props.limits.maxPushConstantsSize) assert(0 && "Too many push constants");    vkCmdPushConstants(info.cmd, info.pipeline_layout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(pushConstants), pushConstants);    /* VULKAN_KEY_END */    init_pipeline_cache(info);    init_pipeline(info, depthPresent);    init_presentable_image(info);    VkClearValue clear_values[2];    init_clear_color_and_depth(info, clear_values);    VkRenderPassBeginInfo rp_begin;    init_render_pass_begin_info(info, rp_begin);    rp_begin.clearValueCount = 2;    rp_begin.pClearValues = clear_values;    vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);    vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);    vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,                            descriptor_sets, 0, NULL);    const VkDeviceSize offsets[1] = {0};    vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf, offsets);    init_viewports(info);    init_scissors(info);    vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);    vkCmdEndRenderPass(info.cmd);    res = vkEndCommandBuffer(info.cmd);    assert(res == VK_SUCCESS);    VkFence drawFence = {};    init_fence(info, drawFence);    VkPipelineStageFlags pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;    VkSubmitInfo submit_info = {};    init_submit_info(info, submit_info, pipe_stage_flags);    /* Queue the command buffer for execution */    res = vkQueueSubmit(info.graphics_queue, 1, &submit_info, drawFence);    assert(res == VK_SUCCESS);    /* Now present the image in the window */    VkPresentInfoKHR present = {};    init_present_info(info, present);    /* Make sure command buffer is finished before presenting */    do {        res = vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);    } while (res == VK_TIMEOUT);    assert(res == VK_SUCCESS);    res = vkQueuePresentKHR(info.present_queue, &present);    assert(res == VK_SUCCESS);    wait_seconds(1);    if (info.save_images) write_ppm(info, "push_constants");    vkDestroyFence(info.device, drawFence, NULL);    vkDestroySemaphore(info.device, info.imageAcquiredSemaphore, NULL);    destroy_pipeline(info);    destroy_pipeline_cache(info);    // instead of destroy_descriptor_pool(info);    vkDestroyDescriptorPool(info.device, descriptor_pool[0], NULL);    destroy_vertex_buffer(info);    destroy_framebuffers(info);    destroy_shaders(info);    destroy_renderpass(info);    // instead of destroy_descriptor_and_pipeline_layouts(info);    for (int i = 0; i < descriptor_set_count; i++) vkDestroyDescriptorSetLayout(info.device, descriptor_layouts[i], NULL);    vkDestroyPipelineLayout(info.device, info.pipeline_layout, NULL);    destroy_uniform_buffer(info);    destroy_depth_buffer(info);    destroy_swap_chain(info);    destroy_command_buffer(info);    destroy_command_pool(info);    destroy_device(info);    destroy_window(info);    destroy_instance(info);    return 0;}

	void buildCommandBuffers()	{		// Destroy command buffers if already present		if (!checkCommandBuffers())		{			destroyCommandBuffers();			createCommandBuffers();		}		VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();		VkClearValue clearValues[2];		clearValues[0].color = defaultClearColor;		clearValues[1].depthStencil = { 1.0f, 0 };		VkRenderPassBeginInfo renderPassBeginInfo = vkTools::initializers::renderPassBeginInfo();		renderPassBeginInfo.renderPass = renderPass;		renderPassBeginInfo.renderArea.offset.x = 0;		renderPassBeginInfo.renderArea.offset.y = 0;		renderPassBeginInfo.renderArea.extent.width = width;		renderPassBeginInfo.renderArea.extent.height = height;		renderPassBeginInfo.clearValueCount = 2;		renderPassBeginInfo.pClearValues = clearValues;		VkResult err;		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)		{			// Set target frame buffer			renderPassBeginInfo.framebuffer = frameBuffers[i];			err = vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo);			assert(!err);			// Buffer memory barrier to make sure that compute shader			// writes are finished before using the storage buffer 			// in the vertex shader			VkBufferMemoryBarrier bufferBarrier = vkTools::initializers::bufferMemoryBarrier();			// Source access : Compute shader buffer write			bufferBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;			// Dest access : Vertex shader access (attribute binding)			bufferBarrier.dstAccessMask = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;			bufferBarrier.buffer = computeStorageBuffer.buffer;			bufferBarrier.offset = 0;			bufferBarrier.size = computeStorageBuffer.descriptor.range;			bufferBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;			bufferBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;			vkCmdPipelineBarrier(				drawCmdBuffers[i],				VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,				VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,				VK_FLAGS_NONE, 				0, nullptr,				1, &bufferBarrier,				0, nullptr);			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);			VkViewport viewport = vkTools::initializers::viewport(				(float)width,				(float)height,				0.0f,				1.0f				);			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);			VkRect2D scissor = vkTools::initializers::rect2D(				width,				height,				0,				0				);			vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);			vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSetPostCompute, 0, NULL);			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.postCompute);			VkDeviceSize offsets[1] = { 0 };			vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &computeStorageBuffer.buffer, offsets);			vkCmdDraw(drawCmdBuffers[i], PARTICLE_COUNT, 1, 0, 0);			vkCmdEndRenderPass(drawCmdBuffers[i]);			err = vkEndCommandBuffer(drawCmdBuffers[i]);			assert(!err);		}	}