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

	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);			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, &models.quad.vertices.buffer, offsets);			vkCmdBindIndexBuffer(drawCmdBuffers[i], models.quad.indices.buffer, 0, VK_INDEX_TYPE_UINT32);			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);			vkCmdDrawIndexed(drawCmdBuffers[i], models.quad.indexCount, 1, 0, 0, 1);			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 QeParticle::updateDrawCommandBuffer(QeDataDrawCommand *command) {    if (!isShowByCulling(command->camera)) return;    if (!currentParticlesSize) return;    vkCmdBindDescriptorSets(command->commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, VK->pipelineLayout, eDescriptorSetLayout_Model,                            1, &descriptorSet.set, 0, nullptr);    graphicsPipeline.subpass = 0;    graphicsPipeline.componentType = componentType;    graphicsPipeline.sampleCount = GRAP->sampleCount;    graphicsPipeline.renderPass = command->renderPass;    graphicsPipeline.minorType = eGraphicsPipeLine_none;    graphicsPipeline.shader = &graphicsShader;    VkDeviceSize offsets[] = {0};    vkCmdBindVertexBuffers(command->commandBuffer, 0, 1, &vertexBuffer.buffer, offsets);    vkCmdBindPipeline(command->commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, VK->createGraphicsPipeline(&graphicsPipeline));    vkCmdDraw(command->commandBuffer, currentParticlesSize, 1, 0, 0);}

	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 RHI_CommandList::SetPipeline(const RHI_Pipeline* pipeline)	{		if (!m_is_recording)			return;		vkCmdBindPipeline(CMD_BUFFER_VK, VK_PIPELINE_BIND_POINT_GRAPHICS, static_cast<VkPipeline>(pipeline->GetPipeline()));		auto descriptor_set = static_cast<VkDescriptorSet>(pipeline->GetDescriptorSet());		vkCmdBindDescriptorSets		(			CMD_BUFFER_VK,			VK_PIPELINE_BIND_POINT_GRAPHICS,			static_cast<VkPipelineLayout>(pipeline->GetPipelineLayout()), 			0, 			1, 			&descriptor_set, 			0,			nullptr		);	}

	void draw()	{		VK_CHECK_RESULT(Swapchain.acquire(presentCompleteSemaphore, &currentBuffer));		VK_CHECK_RESULT(vkWaitForFences(device, 1, &waitFences[currentBuffer], VK_TRUE, UINT64_MAX));		VK_CHECK_RESULT(vkResetFences(device, 1, &waitFences[currentBuffer]));		glo::context* Context = (glo::context*)this->Context;		Context->temp_set_framebuffer(frameBuffers[currentBuffer]);		Context->temp_set_renderpass(renderPass, 0, 0, width, height);		wglMakeCurrentGTC(this->DeviceContext, this->Context);		VkCommandBuffer CommandBuffer = Context->temp_get_command_buffer();		glViewportIndexedf(0, 0, 0, width, height);		glScissor(0, 0, width, height);		vkCmdBindPipeline(CommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);		glBindBufferRange(GL_UNIFORM_BUFFER, 0, uniformDataVS.buffer, 0, sizeof(uboVS));		glBindVertexBuffer(VERTEX_BUFFER_BIND_ID, vertices.buffer, 0, 0);		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices.buffer);		glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, indices.count, GL_UNSIGNED_INT, NULL, 1, 0, 0);		glFlush();		VkPipelineStageFlags waitStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;		VkSubmitInfo submitInfo = {};		submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;		submitInfo.pWaitDstStageMask = &waitStageMask;		submitInfo.pWaitSemaphores = &presentCompleteSemaphore;		submitInfo.waitSemaphoreCount = 1;		submitInfo.pSignalSemaphores = &renderCompleteSemaphore;		submitInfo.signalSemaphoreCount = 1;		submitInfo.pCommandBuffers = &CommandBuffer;		submitInfo.commandBufferCount = 1;		VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, waitFences[currentBuffer]));		VK_CHECK_RESULT(Swapchain.present(queue, currentBuffer, renderCompleteSemaphore));	}

	void updateSecondaryCommandBuffer(VkCommandBufferInheritanceInfo inheritanceInfo)	{		// Secondary command buffer for the sky sphere		VkCommandBufferBeginInfo commandBufferBeginInfo = vkTools::initializers::commandBufferBeginInfo();		commandBufferBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;		commandBufferBeginInfo.pInheritanceInfo = &inheritanceInfo;		VK_CHECK_RESULT(vkBeginCommandBuffer(secondaryCommandBuffer, &commandBufferBeginInfo));		VkViewport viewport = vkTools::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);		vkCmdSetViewport(secondaryCommandBuffer, 0, 1, &viewport);		VkRect2D scissor = vkTools::initializers::rect2D(width, height, 0, 0);		vkCmdSetScissor(secondaryCommandBuffer, 0, 1, &scissor);		vkCmdBindPipeline(secondaryCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.starsphere);		glm::mat4 view = glm::mat4();		view = glm::rotate(view, glm::radians(rotation.x), glm::vec3(1.0f, 0.0f, 0.0f));		view = glm::rotate(view, glm::radians(rotation.y), glm::vec3(0.0f, 1.0f, 0.0f));		view = glm::rotate(view, glm::radians(rotation.z), glm::vec3(0.0f, 0.0f, 1.0f));		glm::mat4 mvp = matrices.projection * view;		vkCmdPushConstants(			secondaryCommandBuffer,			pipelineLayout,			VK_SHADER_STAGE_VERTEX_BIT,			0,			sizeof(mvp),			&mvp);		VkDeviceSize offsets[1] = { 0 };		vkCmdBindVertexBuffers(secondaryCommandBuffer, 0, 1, &meshes.skysphere.vertices.buf, offsets);		vkCmdBindIndexBuffer(secondaryCommandBuffer, meshes.skysphere.indices.buf, 0, VK_INDEX_TYPE_UINT32);		vkCmdDrawIndexed(secondaryCommandBuffer, meshes.skysphere.indexCount, 1, 0, 0, 0);		VK_CHECK_RESULT(vkEndCommandBuffer(secondaryCommandBuffer));	}

XCamReturnVKComputePipeline::bind_by (VKCmdBuf &cmd_buf){    VkCommandBuffer buf_id = cmd_buf.get_cmd_buf_id ();    VkPipeline pipe_id = get_pipeline_id ();    XCAM_ASSERT (XCAM_IS_VALID_VK_ID (buf_id));    XCAM_FAIL_RETURN (        ERROR,        XCAM_IS_VALID_VK_ID (pipe_id) && XCAM_IS_VALID_VK_ID (_pipe_layout) && _desc_set.ptr (),        XCAM_RETURN_ERROR_PARAM,        "vk compute pipeline bind command buffer failed, please check pipe_id, pipe_layout and desc_layout.");    // // bind pipeline sets    vkCmdBindPipeline (buf_id, VK_PIPELINE_BIND_POINT_COMPUTE, pipe_id);    // bind descriptor sets    VkDescriptorSet desc_set_id = _desc_set->get_set_id ();    vkCmdBindDescriptorSets (        buf_id, VK_PIPELINE_BIND_POINT_COMPUTE, _pipe_layout,        0, 1, &desc_set_id, 0, NULL);    return XCAM_RETURN_NO_ERROR;}

void ComputeVK::PopulateCommandBuffer(const size_t i){	const auto CB = CommandPools[0].second[i];//CommandBuffers[i];	const VkCommandBufferBeginInfo BeginInfo = {		VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,		nullptr,		0,		nullptr	};	VERIFY_SUCCEEDED(vkBeginCommandBuffer(CB, &BeginInfo)); {		if (!DescriptorSets.empty()) {			vkCmdBindDescriptorSets(CB,				VK_PIPELINE_BIND_POINT_COMPUTE,				PipelineLayout,				0, static_cast<uint32_t>(DescriptorSets.size()), DescriptorSets.data(),				0, nullptr);		}				vkCmdBindPipeline(CB, VK_PIPELINE_BIND_POINT_COMPUTE, Pipeline);		vkCmdDispatchIndirect(CB, IndirectBuffer, 0);	} VERIFY_SUCCEEDED(vkEndCommandBuffer(CB));}

void SkinningAppVk::draw(void){	VkResult result = VK_ERROR_INITIALIZATION_FAILED;	NvSimpleUBO<SkinnedMesh::UBOBlock>& uboObj = mMesh.mUBO;	SkinnedMesh::UBOBlock& ubo = *uboObj;	// Compute and update the ModelViewProjection matrix	nv::perspectiveLH(ubo.mMVP, 45.0f, (float)m_width / (float)m_height, 0.1f, 100.0f);		ubo.mMVP *= m_transformer->getModelViewMat();	// Compute and update the bone matrices	computeBones(mTime, ubo);	mTime += mTimeScalar * getFrameDeltaTime();	// Update other uniforms	ubo.mRenderMode[0] = (int32_t)mSingleBoneSkinning;	ubo.mRenderMode[1] = (int32_t)mRenderMode;	uboObj.Update();	VkCommandBuffer cmd = vk().getMainCommandBuffer();	VkRenderPassBeginInfo renderPassBeginInfo = { VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO };	renderPassBeginInfo.renderPass = vk().mainRenderTarget()->clearRenderPass();	renderPassBeginInfo.framebuffer = vk().mainRenderTarget()->frameBuffer();	renderPassBeginInfo.renderArea.offset.x = 0;	renderPassBeginInfo.renderArea.offset.y = 0;	renderPassBeginInfo.renderArea.extent.width = m_width;	renderPassBeginInfo.renderArea.extent.height = m_height;	VkClearValue clearValues[2];	clearValues[0].color.float32[0] = 0.33f;	clearValues[0].color.float32[1] = 0.44f;	clearValues[0].color.float32[2] = 0.66f;	clearValues[0].color.float32[3] = 1.0f;	clearValues[1].depthStencil.depth = 1.0f;	clearValues[1].depthStencil.stencil = 0;	renderPassBeginInfo.pClearValues = clearValues;	renderPassBeginInfo.clearValueCount = 2;	vkCmdBeginRenderPass(cmd, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);	{		// Bind the mPipeline state		vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, mPipeline);		VkViewport vp;		VkRect2D sc;		vp.x = 0;		vp.y = 0;		vp.height = (float)(m_height);		vp.width = (float)(m_width);		vp.minDepth = 0.0f;		vp.maxDepth = 1.0f;		sc.offset.x = 0;		sc.offset.y = 0;		sc.extent.width = vp.width;		sc.extent.height = vp.height;		vkCmdSetViewport(cmd, 0, 1, &vp);		vkCmdSetScissor(cmd, 0, 1, &sc);		mMesh.draw(mPipelineLayout, cmd);	}	vkCmdEndRenderPass(cmd);	vk().submitMainCommandBuffer();}

//.........这里部分代码省略.........		cr_fbuf.layers = 1;		VkFramebuffer fbuf;		VK_CALL_CHECKED(vkCreateFramebuffer, dev.get_device(), &cr_fbuf, nullptr, &fbuf);		fbufs.push_back(fbuf);	}	VkCommandPoolCreateInfo cr_pool = {};	cr_pool.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;	cr_pool.queueFamilyIndex = info.second.graphics_fam;	cr_pool.flags = 0;	VkCommandPool pool;	VK_CALL_CHECKED(vkCreateCommandPool, dev.get_device(), &cr_pool, nullptr, &pool);	std::vector<VkCommandBuffer> cmd_bufs(fbufs.size());	VkCommandBufferAllocateInfo cr_cmd_bufs = {};	cr_cmd_bufs.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;	cr_cmd_bufs.commandPool = pool;	cr_cmd_bufs.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;	cr_cmd_bufs.commandBufferCount = static_cast<uint32_t>(cmd_bufs.size());	VK_CALL_CHECKED(vkAllocateCommandBuffers, dev.get_device(), &cr_cmd_bufs, cmd_bufs.data());	for (size_t i = 0; i < cmd_bufs.size(); i++) {		auto cmd_buf = cmd_bufs[i];		auto fbuf = fbufs[i];		VkCommandBufferBeginInfo begin_info = {};		begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;		begin_info.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;		begin_info.pInheritanceInfo = nullptr;		vkBeginCommandBuffer(cmd_buf, &begin_info);		VkRenderPassBeginInfo cmd_render = {};		cmd_render.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;		cmd_render.renderPass = render_pass;		cmd_render.framebuffer = fbuf;		cmd_render.renderArea.offset = { 0, 0 };		cmd_render.renderArea.extent = display.extent;		VkClearValue clear_color = {{{ 0.0f, 0.0f, 0.0f, 1.0f }}};		cmd_render.clearValueCount = 1;		cmd_render.pClearValues = &clear_color;		vkCmdBeginRenderPass(cmd_buf, &cmd_render, VK_SUBPASS_CONTENTS_INLINE);		vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);		vkCmdDraw(cmd_buf, 3, 1, 0, 0);		vkCmdEndRenderPass(cmd_buf);		VK_CALL_CHECKED(vkEndCommandBuffer, cmd_buf);		VkSemaphoreCreateInfo cr_sem = {};		cr_sem.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;		VkSemaphore sem_image_ready;		VkSemaphore sem_render_done;		VK_CALL_CHECKED(vkCreateSemaphore, dev.get_device(), &cr_sem, nullptr, &sem_image_ready);		VK_CALL_CHECKED(vkCreateSemaphore, dev.get_device(), &cr_sem, nullptr, &sem_render_done);		uint32_t img_idx = 0;		VK_CALL_CHECKED(vkAcquireNextImageKHR, dev.get_device(), display.swapchain, std::numeric_limits<uint64_t>::max(), sem_image_ready, VK_NULL_HANDLE, &img_idx);		VkSubmitInfo submit = {};		submit.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;		submit.waitSemaphoreCount = 1;		submit.pWaitSemaphores = &sem_image_ready;		VkPipelineStageFlags mask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;		submit.pWaitDstStageMask = &mask;		submit.commandBufferCount = 1;		submit.pCommandBuffers = &cmd_bufs[img_idx];		submit.signalSemaphoreCount = 1;		submit.pSignalSemaphores = &sem_render_done;		VK_CALL_CHECKED(vkQueueSubmit, dev.get_queue(0), 1, &submit, VK_NULL_HANDLE);		VkPresentInfoKHR present_info = {};		present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;		present_info.waitSemaphoreCount = 1;		present_info.pWaitSemaphores = &sem_render_done;		present_info.swapchainCount = 1;		present_info.pSwapchains = &display.swapchain;		present_info.pImageIndices = &img_idx;		present_info.pResults = nullptr;		vkQueuePresentKHR(dev.get_queue(0), &present_info);		vkQueueWaitIdle(dev.get_queue(0));		vkDeviceWaitIdle(dev.get_device());	}}

//.........这里部分代码省略.........    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;    submit_info[0].pCommandBuffers = cmd_bufs;    submit_info[0].signalSemaphoreCount = 0;

	void buildCommandBuffers()	{		VkCommandBufferBeginInfo cmdBufInfo = {};		cmdBufInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;		cmdBufInfo.pNext = NULL;		VkClearValue clearValues[2];		clearValues[0].color = { { 0.0f, 0.0f, 0.0f, 1.0f } };		clearValues[1].depthStencil = { 1.0f, 0 };		VkRenderPassBeginInfo renderPassBeginInfo = {};		renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;		renderPassBeginInfo.pNext = NULL;		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);			// Update dynamic viewport state			VkViewport viewport = {};			viewport.height = (float)height;			viewport.width = (float)width;			viewport.minDepth = (float) 0.0f;			viewport.maxDepth = (float) 1.0f;			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);			// Update dynamic scissor state			VkRect2D scissor = {};			scissor.extent.width = width;			scissor.extent.height = height;			scissor.offset.x = 0;			scissor.offset.y = 0;			vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);			// Bind descriptor sets describing shader binding points			vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, NULL);			// Bind the rendering pipeline (including the shaders)			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.solid);			// Bind triangle vertices			VkDeviceSize offsets[1] = { 0 };			vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &vertices.buf, offsets);			// Bind triangle indices			vkCmdBindIndexBuffer(drawCmdBuffers[i], indices.buf, 0, VK_INDEX_TYPE_UINT32);			// Draw indexed triangle			vkCmdDrawIndexed(drawCmdBuffers[i], indices.count, 1, 0, 0, 1);			vkCmdEndRenderPass(drawCmdBuffers[i]);			err = vkEndCommandBuffer(drawCmdBuffers[i]);			assert(!err);		}	}

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

//.........这里部分代码省略.........    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 {        res = vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);    } while (res == VK_TIMEOUT);

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

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

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

int sample_main(int argc, char *argv[]) {    VkResult U_ASSERT_ONLY res;    struct sample_info info = {};    char sample_title[] = "Draw Textured Cube";    const bool depthPresent = true;    process_command_line_args(info, argc, argv);    init_global_layer_properties(info);    init_instance_extension_names(info);    init_device_extension_names(info);    init_instance(info, sample_title);    init_enumerate_device(info);    init_window_size(info, 500, 500);    init_connection(info);    init_window(info);    init_swapchain_extension(info);    init_device(info);    init_command_pool(info);    init_command_buffer(info);    execute_begin_command_buffer(info);    init_device_queue(info);    init_swap_chain(info);    init_depth_buffer(info);    init_texture(info);    init_uniform_buffer(info);    init_descriptor_and_pipeline_layouts(info, true);    init_renderpass(info, depthPresent);    init_shaders(info, vertShaderText, fragShaderText);    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);    /* VULKAN_KEY_START */    VkClearValue clear_values[2];    clear_values[0].color.float32[0] = 0.2f;    clear_values[0].color.float32[1] = 0.2f;    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 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);    set_image_layout(info, info.buffers[info.current_buffer].image,                     VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_UNDEFINED,                     VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);    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, 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);    VkImageMemoryBarrier prePresentBarrier = {};    prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;    prePresentBarrier.pNext = NULL;//.........这里部分代码省略.........

	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 operator()(const command_buffer &command_buffer, command_recorder &) && override final {		vkCmdBindPipeline(command_buffer, bind_point, pipeline);	}

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

	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));			// Reset timestamp query pool			vkCmdResetQueryPool(drawCmdBuffers[i], queryPool, 0, static_cast<uint32_t>(pipelineStats.size()));			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 };			// Start capture of pipeline statistics			vkCmdBeginQuery(drawCmdBuffers[i], queryPool, 0, VK_QUERY_CONTROL_PRECISE_BIT);			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);			vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 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);			for (int32_t y = 0; y < gridSize; y++) {				for (int32_t x = 0; x < gridSize; x++) {					glm::vec3 pos = glm::vec3(float(x - (gridSize / 2.0f)) * 2.5f, 0.0f, float(y - (gridSize / 2.0f)) * 2.5f);					vkCmdPushConstants(drawCmdBuffers[i], pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(glm::vec3), &pos);					vkCmdDrawIndexed(drawCmdBuffers[i], models.objects[models.objectIndex].indexCount, 1, 0, 0, 0);				}			}			// End capture of pipeline statistics			vkCmdEndQuery(drawCmdBuffers[i], queryPool, 0);			drawUI(drawCmdBuffers[i]);			vkCmdEndRenderPass(drawCmdBuffers[i]);			VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));		}	}

//.........这里部分代码省略.........    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;    prePresentBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;    prePresentBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;

//.........这里部分代码省略.........    res =        vkBindBufferMemory(info.device, query_result_buf, query_result_mem, 0);    assert(res == VK_SUCCESS);    VkQueryPool query_pool;    VkQueryPoolCreateInfo query_pool_info;    query_pool_info.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;    query_pool_info.pNext = NULL;    query_pool_info.queryType = VK_QUERY_TYPE_OCCLUSION;    query_pool_info.flags = 0;    query_pool_info.queryCount = 2;    query_pool_info.pipelineStatistics = 0;    res = vkCreateQueryPool(info.device, &query_pool_info, NULL, &query_pool);    assert(res == VK_SUCCESS);    vkCmdResetQueryPool(info.cmd, query_pool, 0 /*startQuery*/,                        2 /*queryCount*/);    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, NUM_DESCRIPTOR_SETS,                            info.desc_set.data(), 0, NULL);    const VkDeviceSize offsets[1] = {0};    vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf, offsets);    VkViewport viewport;    viewport.height = (float)info.height;    viewport.width = (float)info.width;    viewport.minDepth = (float)0.0f;    viewport.maxDepth = (float)1.0f;    viewport.x = 0;    viewport.y = 0;    vkCmdSetViewport(info.cmd, 0, NUM_VIEWPORTS, &viewport);    VkRect2D scissor;    scissor.extent.width = info.width;    scissor.extent.height = info.height;    scissor.offset.x = 0;    scissor.offset.y = 0;    vkCmdSetScissor(info.cmd, 0, NUM_SCISSORS, &scissor);    vkCmdBeginQuery(info.cmd, query_pool, 0 /*slot*/, 0 /*flags*/);    vkCmdEndQuery(info.cmd, query_pool, 0 /*slot*/);    vkCmdBeginQuery(info.cmd, query_pool, 1 /*slot*/, 0 /*flags*/);    vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);    vkCmdEndRenderPass(info.cmd);    vkCmdEndQuery(info.cmd, query_pool, 1 /*slot*/);

	void buildCommandBuffers()	{		VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();		VkClearValue clearValues[2];		clearValues[0].color = { { 0.0f, 0.0f, 0.0f, 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;		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);			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);			// Solid shading			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.solid);			vkCmdDrawIndexed(drawCmdBuffers[i], meshes.object.indexCount, 1, 0, 0, 0);			// Normal debugging			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.normals);			vkCmdDrawIndexed(drawCmdBuffers[i], meshes.object.indexCount, 1, 0, 0, 0);			vkCmdEndRenderPass(drawCmdBuffers[i]);			err = vkEndCommandBuffer(drawCmdBuffers[i]);			assert(!err);		}	}

void R_UpdateWarpTextures (void){	texture_t *tx;	int i;	float x, y, x2, warptess;	if (cl.paused || r_drawflat_cheatsafe || r_lightmap_cheatsafe)		return;	warptess = 128.0/CLAMP (3.0, floor(r_waterquality.value), 64.0);	int num_textures = cl.worldmodel->numtextures;	int num_warp_textures = 0;	// Render warp to top mips	for (i = 0; i < num_textures; ++i)	{		if (!(tx = cl.worldmodel->textures[i]))			continue;		if (!tx->update_warp)			continue;		VkRect2D render_area;		render_area.offset.x = 0;		render_area.offset.y = 0;		render_area.extent.width = WARPIMAGESIZE;		render_area.extent.height = WARPIMAGESIZE;		VkRenderPassBeginInfo render_pass_begin_info;		memset(&render_pass_begin_info, 0, sizeof(render_pass_begin_info));		render_pass_begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;		render_pass_begin_info.renderArea = render_area;		render_pass_begin_info.renderPass = vulkan_globals.warp_render_pass;		render_pass_begin_info.framebuffer = tx->warpimage->frame_buffer;		vkCmdBeginRenderPass(vulkan_globals.command_buffer, &render_pass_begin_info, VK_SUBPASS_CONTENTS_INLINE);		//render warp		GL_SetCanvas (CANVAS_WARPIMAGE);		vkCmdBindPipeline(vulkan_globals.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vulkan_globals.warp_pipeline);		vkCmdBindDescriptorSets(vulkan_globals.command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, vulkan_globals.basic_pipeline_layout, 0, 1, &tx->gltexture->descriptor_set, 0, NULL);		int num_verts = 0;		for (y=0.0; y<128.01; y+=warptess) // .01 for rounding errors			num_verts += 2;		for (x=0.0; x<128.0; x=x2)		{				VkBuffer buffer;			VkDeviceSize buffer_offset;			basicvertex_t * vertices = (basicvertex_t*)R_VertexAllocate(num_verts * sizeof(basicvertex_t), &buffer, &buffer_offset);			int i = 0;			x2 = x + warptess;			for (y=0.0; y<128.01; y+=warptess) // .01 for rounding errors			{				vertices[i].position[0] = x;				vertices[i].position[1] = y;				vertices[i].position[2] = 0.0f;				vertices[i].texcoord[0] = WARPCALC(x,y);				vertices[i].texcoord[1] = WARPCALC(y,x);				vertices[i].color[0] = 255;				vertices[i].color[1] = 255;				vertices[i].color[2] = 255;				vertices[i].color[3] = 255;				i += 1;				vertices[i].position[0] = x2;				vertices[i].position[1] = y;				vertices[i].position[2] = 0.0f;				vertices[i].texcoord[0] = WARPCALC(x2,y);				vertices[i].texcoord[1] = WARPCALC(y,x2);				vertices[i].color[0] = 255;				vertices[i].color[1] = 255;				vertices[i].color[2] = 255;				vertices[i].color[3] = 255;				i += 1;			}			vkCmdBindVertexBuffers(vulkan_globals.command_buffer, 0, 1, &buffer, &buffer_offset);			vkCmdDraw(vulkan_globals.command_buffer, num_verts, 1, 0, 0);		}		vkCmdEndRenderPass(vulkan_globals.command_buffer);		VkImageMemoryBarrier * image_barrier = &warp_image_barriers[num_warp_textures];		image_barrier->sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;		image_barrier->pNext = NULL;		image_barrier->srcAccessMask = VK_ACCESS_SHADER_READ_BIT;		image_barrier->dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;		image_barrier->oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;		image_barrier->newLayout = VK_IMAGE_LAYOUT_GENERAL;		image_barrier->srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;		image_barrier->dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;		image_barrier->image = tx->warpimage->image;		image_barrier->subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;		image_barrier->subresourceRange.baseMipLevel = 1;		image_barrier->subresourceRange.levelCount = WARPIMAGEMIPS - 1;		image_barrier->subresourceRange.baseArrayLayer = 0;		image_barrier->subresourceRange.layerCount = 1;//.........这里部分代码省略.........

//.........这里部分代码省略.........    viewport.height = 200.0f;    viewport.width = 200.0f;    viewport.minDepth = (float)0.0f;    viewport.maxDepth = (float)1.0f;    viewport.x = 0;    viewport.y = 0;    VkRect2D scissor;    scissor.extent.width = info.width;    scissor.extent.height = info.height;    scissor.offset.x = 0;    scissor.offset.y = 0;    // now we record four separate command buffers, one for each quadrant of the    // screen    VkCommandBufferInheritanceInfo cmd_buf_inheritance_info = {};    cmd_buf_inheritance_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, cmd_buf_inheritance_info.pNext = NULL;    cmd_buf_inheritance_info.renderPass = info.render_pass;    cmd_buf_inheritance_info.subpass = 0;    cmd_buf_inheritance_info.framebuffer = info.framebuffers[info.current_buffer];    cmd_buf_inheritance_info.occlusionQueryEnable = VK_FALSE;    cmd_buf_inheritance_info.queryFlags = 0;    cmd_buf_inheritance_info.pipelineStatistics = 0;    VkCommandBufferBeginInfo secondary_begin = {};    secondary_begin.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;    secondary_begin.pNext = NULL;    secondary_begin.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT | VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;    secondary_begin.pInheritanceInfo = &cmd_buf_inheritance_info;    for (int i = 0; i < 4; i++) {        vkBeginCommandBuffer(secondary_cmds[i], &secondary_begin);        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);

//.........这里部分代码省略.........    vkUpdateDescriptorSets(info.device, 1, writes, 0, NULL);    init_pipeline_cache(info);    init_pipeline(info, depthPresent, vertexPresent);    // Color attachment clear to gray    VkClearValue clear_values;    clear_values.color.float32[0] = 0.2f;    clear_values.color.float32[1] = 0.2f;    clear_values.color.float32[2] = 0.2f;    clear_values.color.float32[3] = 0.2f;    VkSemaphoreCreateInfo imageAcquiredSemaphoreCreateInfo;    imageAcquiredSemaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;    imageAcquiredSemaphoreCreateInfo.pNext = NULL;    imageAcquiredSemaphoreCreateInfo.flags = 0;    res = vkCreateSemaphore(info.device, &imageAcquiredSemaphoreCreateInfo, NULL, &info.imageAcquiredSemaphore);    assert(res == VK_SUCCESS);    // Get the index of the next available swapchain image:    res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX, info.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 = 1;    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);    init_viewports(info);    init_scissors(info);    vkCmdDraw(info.cmd, 3, 1, 0, 0);    vkCmdEndRenderPass(info.cmd);    res = vkEndCommandBuffer(info.cmd);    assert(res == VK_SUCCESS);    /* VULKAN_KEY_END */    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);    execute_queue_cmdbuf(info, cmd_bufs, drawFence);    do {        res = vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);    } while (res == VK_TIMEOUT);    assert(res == VK_SUCCESS);    vkDestroyFence(info.device, drawFence, NULL);    execute_present_image(info);    wait_seconds(1);    if (info.save_images) write_ppm(info, "input_attachment");    vkDestroySemaphore(info.device, info.imageAcquiredSemaphore, NULL);    vkDestroyImageView(info.device, input_attachment_view, NULL);    vkDestroyImage(info.device, input_image, NULL);    vkFreeMemory(info.device, input_memory, NULL);    destroy_pipeline(info);    destroy_pipeline_cache(info);    destroy_descriptor_pool(info);    destroy_framebuffers(info);    destroy_shaders(info);    destroy_renderpass(info);    destroy_descriptor_and_pipeline_layouts(info);    destroy_swap_chain(info);    destroy_command_buffer(info);    destroy_command_pool(info);    destroy_device(info);    destroy_window(info);    destroy_instance(info);    return 0;}