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

static void frame_begin(){    VkResult err;    while (true)    {        err = vkWaitForFences(g_Device, 1, &g_Fence[g_FrameIndex], VK_TRUE, 100);        if (err == VK_SUCCESS) break;        if (err == VK_TIMEOUT) continue;        check_vk_result(err);    }    {        err = vkAcquireNextImageKHR(g_Device, g_Swapchain, UINT64_MAX, g_PresentCompleteSemaphore[g_FrameIndex], VK_NULL_HANDLE, &g_BackbufferIndices[g_FrameIndex]);        check_vk_result(err);    }    {        err = vkResetCommandPool(g_Device, g_CommandPool[g_FrameIndex], 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(g_CommandBuffer[g_FrameIndex], &info);        check_vk_result(err);    }    {        VkRenderPassBeginInfo info = {};        info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;        info.renderPass = g_RenderPass;        info.framebuffer = g_Framebuffer[g_BackbufferIndices[g_FrameIndex]];        info.renderArea.extent.width = fb_width;        info.renderArea.extent.height = fb_height;        info.clearValueCount = 1;        info.pClearValues = &g_ClearValue;        vkCmdBeginRenderPass(g_CommandBuffer[g_FrameIndex], &info, VK_SUBPASS_CONTENTS_INLINE);    }}

	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 CommandBufferImpl::beginRenderPassInternal(){	VkRenderPassBeginInfo bi = {};	bi.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;	FramebufferImpl& impl = m_activeFb->getImplementation();	bi.renderPass = impl.getRenderPassHandle();	bi.clearValueCount = impl.getAttachmentCount();	bi.pClearValues = impl.getClearValues();	if(!impl.isDefaultFramebuffer())	{		// Bind a non-default FB		bi.framebuffer = impl.getFramebufferHandle(0);		impl.getAttachmentsSize(			bi.renderArea.extent.width, bi.renderArea.extent.height);	}	else	{		// Bind the default FB		m_renderedToDefaultFb = true;		bi.framebuffer = impl.getFramebufferHandle(			getGrManagerImpl().getFrame() % MAX_FRAMES_IN_FLIGHT);		bi.renderArea.extent.width =			getGrManagerImpl().getDefaultSurfaceWidth();		bi.renderArea.extent.height =			getGrManagerImpl().getDefaultSurfaceHeight();	}	vkCmdBeginRenderPass(m_handle, &bi, VK_SUBPASS_CONTENTS_INLINE);}

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 HookGui::HGWidgetShader::BeginRender(VulkanWrapper::Context* _graphicContext, int _swapchainImageIndex){	// Get a new command buffer for this rendering	// m_CommandBuffer = _graphicContext->GetValidFrameCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY);	// Set the command buffer begin indo	VkCommandBufferBeginInfo beginInfo = {};	beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;	beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT; // VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT 	// Begin the command buffer	vkBeginCommandBuffer(m_CommandBuffer, &beginInfo);	// Set the clear color	std::array<VkClearValue, 2> clearValues = {};	clearValues[0].color = { 0.0f, 0.0f, 0.0f, 1.0f };	clearValues[1].depthStencil = { 1.0f, 0 };	// Set the render pass info	VkRenderPassBeginInfo renderPassInfo = {};	renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;	renderPassInfo.renderPass = m_RenderPass;	renderPassInfo.framebuffer = m_Framebuffers[_swapchainImageIndex];	renderPassInfo.renderArea.offset = { 0, 0 };	renderPassInfo.renderArea.extent = _graphicContext->GetSwapChain()->GetExtent();	renderPassInfo.clearValueCount = 0; // clearValues.size()	renderPassInfo.pClearValues = clearValues.data();	// Begin the render pass	vkCmdBeginRenderPass(m_CommandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);	// Set our pipeline	vkCmdBindPipeline(m_CommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, m_GraphicsPipeline);}

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 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);		}	}

/*===============R_SetupScene===============*/void R_SetupScene (void){	render_pass_index = 0;	vkCmdBeginRenderPass(vulkan_globals.command_buffer, &vulkan_globals.main_render_pass_begin_infos[render_warp ? 0 : 1], VK_SUBPASS_CONTENTS_INLINE);	R_PushDlights();	R_AnimateLight ();	r_framecount++;	R_SetupMatrix ();}

	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 UtilityShaderDraw::BeginRenderPass(VkFramebuffer framebuffer, const VkRect2D& region,                                        const VkClearValue* clear_value){  VkRenderPassBeginInfo begin_info = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,                                      nullptr,                                      m_pipeline_info.render_pass,                                      framebuffer,                                      region,                                      clear_value ? 1u : 0u,                                      clear_value};  vkCmdBeginRenderPass(m_command_buffer, &begin_info, VK_SUBPASS_CONTENTS_INLINE);}

	void RHI_CommandList::Begin(const string& pass_name, void* render_pass, RHI_SwapChain* swap_chain)	{		if (!render_pass || !swap_chain)		{			LOG_ERROR_INVALID_PARAMETER();			return;		}		m_swap_chain = swap_chain;		// Ensure the command list is not recording		if (m_is_recording)			return;		// Sync CPU to GPU		if (m_is_rendering)		{			Vulkan_Common::fence::wait_reset(m_rhi_device, IN_FLIGHT_FENCE);			m_is_rendering = false;		}		// Acquire next swap chain image			SPARTAN_ASSERT(m_swap_chain->AcquireNextImage());		// Begin command buffer		VkCommandBufferBeginInfo beginInfo	= {};		beginInfo.sType						= VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;		beginInfo.flags						= VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;		auto result = vkBeginCommandBuffer(CMD_BUFFER_VK, &beginInfo);		if (result != VK_SUCCESS) 		{			LOGF_ERROR("Failed to begin recording command buffer, %s.", Vulkan_Common::result_to_string(result));			return;		}		// Begin render pass		VkClearValue clear_color					= { 1.0f, 0.0f, 0.0f, 1.0f };		VkRenderPassBeginInfo render_pass_info		= {};		render_pass_info.sType						= VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;		render_pass_info.renderPass					= static_cast<VkRenderPass>(render_pass);		render_pass_info.framebuffer				= static_cast<VkFramebuffer>(swap_chain->GetFrameBuffer());		render_pass_info.renderArea.offset			= { 0, 0 };		render_pass_info.renderArea.extent.width	= static_cast<uint32_t>(swap_chain->GetWidth());		render_pass_info.renderArea.extent.height	= static_cast<uint32_t>(swap_chain->GetHeight());		render_pass_info.clearValueCount			= 1;		render_pass_info.pClearValues				= &clear_color;		vkCmdBeginRenderPass(CMD_BUFFER_VK, &render_pass_info, VK_SUBPASS_CONTENTS_INLINE);		m_is_recording = true;	}

	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]));		}	}

void StateTracker::BeginDiscardRenderPass(){  if (InRenderPass())    return;  m_current_render_pass = m_framebuffer->GetDiscardRenderPass();  m_framebuffer_render_area = m_framebuffer->GetRect();  VkRenderPassBeginInfo begin_info = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,                                      nullptr,                                      m_current_render_pass,                                      m_framebuffer->GetFB(),                                      m_framebuffer_render_area,                                      0,                                      nullptr};  vkCmdBeginRenderPass(g_command_buffer_mgr->GetCurrentCommandBuffer(), &begin_info,                       VK_SUBPASS_CONTENTS_INLINE);}

void StateTracker::BeginClearRenderPass(const VkRect2D& area, const VkClearValue* clear_values,                                        u32 num_clear_values){  ASSERT(!InRenderPass());  m_current_render_pass = m_framebuffer->GetClearRenderPass();  m_framebuffer_render_area = area;  VkRenderPassBeginInfo begin_info = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,                                      nullptr,                                      m_current_render_pass,                                      m_framebuffer->GetFB(),                                      m_framebuffer_render_area,                                      num_clear_values,                                      clear_values};  vkCmdBeginRenderPass(g_command_buffer_mgr->GetCurrentCommandBuffer(), &begin_info,                       VK_SUBPASS_CONTENTS_INLINE);}

void CommandPool::beginRenderPass(std::size_t index,                                  FrameBuffer &frameBuffer, RenderPass &renderPass,                                  const std::vector<VkClearValue> &clearValues) {    assert(index < mCommandBuffers.size());    VkRenderPassBeginInfo info = {};    VkRect2D area;    area.offset = VkOffset2D{0, 0};    area.extent = VkExtent2D{frameBuffer.width(), frameBuffer.height()};    info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;    info.pNext = nullptr;    info.renderPass = renderPass;    info.framebuffer = frameBuffer;    info.renderArea = area;    info.clearValueCount = clearValues.size();    info.pClearValues = &clearValues[0];    vkCmdBeginRenderPass(mCommandBuffers[index], &info, VK_SUBPASS_CONTENTS_INLINE);}

//.........这里部分代码省略.........        vkCmdBindPipeline(secondary_cmds[i], VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);        vkCmdBindDescriptorSets(secondary_cmds[i], VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline_layout, 0, 1,                                &info.desc_set[i == 0 || i == 3], 0, NULL);        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;

//.........这里部分代码省略.........    clear_values[0].color.float32[2] = 0.2f;    clear_values[0].color.float32[3] = 0.2f;    clear_values[1].depthStencil.depth = 1.0f;    clear_values[1].depthStencil.stencil = 0;    VkSemaphore imageAcquiredSemaphore;    VkSemaphoreCreateInfo imageAcquiredSemaphoreCreateInfo;    imageAcquiredSemaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;    imageAcquiredSemaphoreCreateInfo.pNext = NULL;    imageAcquiredSemaphoreCreateInfo.flags = 0;    res = vkCreateSemaphore(info.device, &imageAcquiredSemaphoreCreateInfo, NULL, &imageAcquiredSemaphore);    assert(res == VK_SUCCESS);    // 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;

//.........这里部分代码省略.........        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;}

//.........这里部分代码省略.........    clear_values[1].depthStencil.stencil = 0;    VkSemaphore presentCompleteSemaphore;    VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo;    presentCompleteSemaphoreCreateInfo.sType =        VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;    presentCompleteSemaphoreCreateInfo.pNext = NULL;    presentCompleteSemaphoreCreateInfo.flags = 0;    res = vkCreateSemaphore(info.device, &presentCompleteSemaphoreCreateInfo,                            NULL, &presentCompleteSemaphore);    assert(res == VK_SUCCESS);    // Get the index of the next available swapchain image:    res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX,                                presentCompleteSemaphore, 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);    /* 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;

//.........这里部分代码省略.........    descriptor_writes[1].descriptorCount = 1;    descriptor_writes[1].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;    descriptor_writes[1].pImageInfo = &info.texture_data.image_info;  // populated by init_texture()    descriptor_writes[1].dstArrayElement = 0;    descriptor_writes[1].dstBinding = 1;    // Populate with info about our sampler    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 {

            bool VKRenderPass::VBuildCommandList()             {                if (!allocateCommandBuffer())                    return false;                if (m_instanceBlock.buffer != VK_NULL_HANDLE)                    DeleteUniformBuffer(m_device, m_instanceBlock);                //Create block of data for instance variables                if (m_instanceDataSize > 0)                {                    if (!CreateUniformBuffer(m_device, m_instanceDataSize, m_instanceData, &m_instanceBlock))                        return false;                }                //Setup the order of the commands we will issue in the command list                BuildRenderRequestHeirarchy();                VkResult err;                VKRenderer* renderer = VKRenderer::RendererInstance;                VkCommandBufferInheritanceInfo inheritanceInfo = {};                inheritanceInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;                inheritanceInfo.pNext = nullptr;                inheritanceInfo.renderPass = VK_NULL_HANDLE;                inheritanceInfo.subpass = 0;                inheritanceInfo.framebuffer = VK_NULL_HANDLE;                inheritanceInfo.occlusionQueryEnable = VK_FALSE;                inheritanceInfo.queryFlags = 0;                inheritanceInfo.pipelineStatistics = 0;                VkCommandBufferBeginInfo beginInfo = {};                beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;                beginInfo.pNext = nullptr;                beginInfo.flags = 0;                beginInfo.pInheritanceInfo = &inheritanceInfo;                //Get the current clear color from the renderer                VkClearValue clearColor = renderer->GetClearColor();                std::vector<VkClearValue> clearValues;                for (size_t i = 0; i < m_outputRenderTargets.size(); i++)                {                    VKRenderTargetHandle vkTarget= m_outputRenderTargets[i].DynamicCastHandle<VKRenderTarget>();                    const VkClearValue* targetClearColor = vkTarget->GetClearColor();                    //If a clear color is provided by the render target, lets use that                    if (targetClearColor == nullptr)                        clearValues.push_back(clearColor);                    else                        clearValues.push_back(*targetClearColor);                }                clearValues.push_back({1.0f, 0.0f});                VkRenderPassBeginInfo renderPassBeginInfo = {};                renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;                renderPassBeginInfo.pNext = nullptr;                renderPassBeginInfo.renderPass = m_renderPass;                renderPassBeginInfo.framebuffer = m_framebuffer;                renderPassBeginInfo.renderArea.offset.x = 0;                renderPassBeginInfo.renderArea.offset.y = 0;                renderPassBeginInfo.renderArea.extent.width = m_width;                renderPassBeginInfo.renderArea.extent.height = m_height;                renderPassBeginInfo.clearValueCount = static_cast<uint32_t>(clearValues.size());                renderPassBeginInfo.pClearValues = clearValues.data();                VkViewport viewport = {};                viewport.width = static_cast<float>(m_width);                viewport.height = static_cast<float>(m_height);                viewport.minDepth = 0.0f;                viewport.maxDepth = 1.0f;                VkRect2D scissor = {};                scissor.extent.width = m_width;                scissor.extent.height = m_height;                scissor.offset.x = 0;                scissor.offset.y = 0;                                err = vkBeginCommandBuffer(m_commandBuffer, &beginInfo);                assert(!err);                if (err != VK_SUCCESS)                {                    HT_DEBUG_PRINTF("VKRenderPass::VBuildCommandList(): Failed to build command buffer./n");                    return false;                }                /*                    BEGIN BUFFER COMMANDS                */                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++)                {//.........这里部分代码省略.........

  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]));//.........这里部分代码省略.........