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

/*=============R_DrawViewModel -- johnfitz -- gutted=============*/void R_DrawViewModel (void){	if (!r_drawviewmodel.value || !r_drawentities.value || chase_active.value)		return;	if (cl.items & IT_INVISIBILITY || cl.stats[STAT_HEALTH] <= 0)		return;	currententity = &cl.viewent;	if (!currententity->model)		return;	//johnfitz -- this fixes a crash	if (currententity->model->type != mod_alias)		return;	//johnfitz	// hack the depth range to prevent view model from poking into walls	VkViewport viewport;	viewport.x = 0;	viewport.y = 0;	viewport.width = vid.width;	viewport.height = vid.height;	viewport.minDepth = 0.0f;	viewport.maxDepth = 0.3f;	vkCmdSetViewport(vulkan_globals.command_buffer, 0, 1, &viewport);		R_DrawAliasModel (currententity);	viewport.minDepth = 0.0f;	viewport.maxDepth = 1.0f;	vkCmdSetViewport(vulkan_globals.command_buffer, 0, 1, &viewport);}

	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);			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 VulkanTexturedQuad::RenderImpl(VkCommandBuffer commandBuffer){    VulkanSample::RenderImpl(commandBuffer);    VkViewport viewports [1] = {};    viewports [0].width = static_cast<float> (window_->GetWidth ());    viewports [0].height = static_cast<float> (window_->GetHeight ());    viewports [0].minDepth = 0;    viewports [0].maxDepth = 1;    vkCmdSetViewport (commandBuffer, 0, 1, viewports);    VkRect2D scissors [1] = {};    scissors [0].extent.width = window_->GetWidth ();    scissors [0].extent.height = window_->GetHeight ();    vkCmdSetScissor (commandBuffer, 0, 1, scissors);    vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,        pipeline_);    VkDeviceSize offsets[] = { 0 };    vkCmdBindIndexBuffer(commandBuffer, indexBuffer_, 0, VK_INDEX_TYPE_UINT32);    vkCmdBindVertexBuffers(commandBuffer, 0, 1, &vertexBuffer_, offsets);    vkCmdBindDescriptorSets (commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,        pipelineLayout_, 0, 1, &descriptorSet_, 0, nullptr);    vkCmdDrawIndexed(commandBuffer, 6, 1, 0, 0, 0);}

bool game_buffer_editor_record_vulkan_commands(game_buffer *game_buffer, vulkan *vulkan) {  game_buffer_editor *editor = game_buffer->editor;  ImDrawData *draw_data = ImGui::GetDrawData();  VkResult vk_result = {};  {    uint64 vertices_size = draw_data->TotalVtxCount * sizeof(ImDrawVert);    uint64 indices_size = draw_data->TotalIdxCount * sizeof(ImDrawIdx);    uint64 map_size = round_to_multi(vertices_size + indices_size, vulkan->physical_device_non_coherent_atom_size);    assert(map_size <= editor->imgui_vertex_index_vulkan_buffer.size);    uint8 *buf_ptr = nullptr;    if ((vk_result = vkMapMemory(vulkan->device, editor->imgui_vertex_index_vulkan_buffer.device_memory, 0, map_size, 0, (void **)&buf_ptr)) != VK_SUCCESS) {      return false;    }    assert((uintptr_t)buf_ptr % 16 == 0);    for (int i = 0; i < draw_data->CmdListsCount; i += 1) {      ImDrawList *dlist = draw_data->CmdLists[i];      memcpy(buf_ptr, dlist->VtxBuffer.Data, dlist->VtxBuffer.Size * sizeof(ImDrawVert));      buf_ptr += dlist->VtxBuffer.Size * sizeof(ImDrawVert);    }    for (int i = 0; i < draw_data->CmdListsCount; i += 1) {      ImDrawList *dlist = draw_data->CmdLists[i];      memcpy(buf_ptr, dlist->IdxBuffer.Data, dlist->IdxBuffer.Size * sizeof(ImDrawIdx));      buf_ptr += dlist->IdxBuffer.Size * sizeof(ImDrawIdx);    }    VkMappedMemoryRange memory_range = { VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE };    memory_range.memory = editor->imgui_vertex_index_vulkan_buffer.device_memory;    memory_range.offset = map_size;    if ((vk_result = vkFlushMappedMemoryRanges(vulkan->device, 1, &memory_range)) != VK_SUCCESS) {      return false;    }    vkUnmapMemory(vulkan->device, editor->imgui_vertex_index_vulkan_buffer.device_memory);  }  vkCmdBindPipeline(vulkan->swap_chain_cmd_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, editor->imgui_vulkan_pipeline);  VkViewport viewport = { 0, 0, (float)game_buffer->vulkan_framebuffer_image_width, (float)game_buffer->vulkan_framebuffer_image_height, 0, 1 };  vkCmdSetViewport(vulkan->swap_chain_cmd_buffer, 0, 1, &viewport);  vec2 push_consts = { (float)game_buffer->vulkan_framebuffer_image_width, (float)game_buffer->vulkan_framebuffer_image_height };  vkCmdPushConstants(vulkan->swap_chain_cmd_buffer, editor->imgui_vulkan_pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(push_consts), &push_consts);  VkDeviceSize vertex_offset = 0;  VkDeviceSize index_offset = draw_data->TotalVtxCount * sizeof(ImDrawVert);  for (int i = 0; i < draw_data->CmdListsCount; i += 1) {    ImDrawList *dlist = draw_data->CmdLists[i];    vkCmdBindVertexBuffers(vulkan->swap_chain_cmd_buffer, 0, 1, &editor->imgui_vertex_index_vulkan_buffer.buffer, &vertex_offset);    vertex_offset += dlist->VtxBuffer.Size * sizeof(ImDrawVert);    for (int i = 0; i < dlist->CmdBuffer.Size; i += 1) {      ImDrawCmd *dcmd = &dlist->CmdBuffer.Data[i];      VkRect2D scissor = { { (int)dcmd->ClipRect.x, (int)dcmd->ClipRect.y }, { (uint)dcmd->ClipRect.z, (uint)dcmd->ClipRect.w } };      vkCmdSetScissor(vulkan->swap_chain_cmd_buffer, 0, 1, &scissor);      if (dcmd->TextureId == editor->imgui_font_atlas_vulkan_image.image) {        vkCmdBindDescriptorSets(vulkan->swap_chain_cmd_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, editor->imgui_vulkan_pipeline_layout, 0, 1, &editor->imgui_vulkan_descriptor_sets[0], 0, nullptr);      }      else {        vkCmdBindDescriptorSets(vulkan->swap_chain_cmd_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, editor->imgui_vulkan_pipeline_layout, 0, 1, &editor->imgui_vulkan_descriptor_sets[1], 0, nullptr);      }      vkCmdBindIndexBuffer(vulkan->swap_chain_cmd_buffer, editor->imgui_vertex_index_vulkan_buffer.buffer, index_offset, VK_INDEX_TYPE_UINT16);      vkCmdDrawIndexed(vulkan->swap_chain_cmd_buffer, dcmd->ElemCount, 1, 0, 0, 0);      index_offset += dcmd->ElemCount * sizeof(ImDrawIdx);    }  }  return true;}

	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 NvUIGraphicFrameRenderVK::Draw(float alpha, const NvPackedColor& color, const float pixelToClipMatrix[4][4],                            const nv::vec2<float>& thickness, const nv::vec2<float>& texBorder, bool drawCenter){	NvVkContext& vk = *NvUIVKctx().mVk;	VkCommandBuffer& cmd = NvUIVKctx().mCmd;	// Set transform	// pixelToClipMatrix	memcpy(&(ms_ubo->pixelToClipMat), pixelToClipMatrix, 16 * sizeof(float));	ms_ubo->pixelToClipMat(1, 1) *= -1.0f;	ms_ubo->pixelToClipMat(1, 3) *= -1.0f;	ms_ubo->alpha = alpha;	ms_ubo->color = nv::vec4f(NV_PC_RED_FLOAT(color),		NV_PC_GREEN_FLOAT(color), NV_PC_BLUE_FLOAT(color), 1.0f);	NvUITexture* tex = m_graphic->GetTex();	ms_ubo->thickness = thickness;	ms_ubo->texBorder.x = texBorder.x / tex->GetWidth();	ms_ubo->texBorder.y = texBorder.y / tex->GetHeight();	ms_ubo.Update();	m_uboOffset = ms_ubo.getDynamicOffset();	VkViewport vp;	VkRect2D sc;	vp.x = 0;	vp.y = 0;	vp.height = (float)(vk.mainRenderTarget()->height());	vp.width = (float)(vk.mainRenderTarget()->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);	if (m_graphic->GetTex()->GetHasAlpha() || (alpha < 1.0f)) {		vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, ms_pipelineAlpha);	}	else {		vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, ms_pipelineOpaque);	}	vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, ms_pipelineLayout, 0, 1, &m_descriptorSet, 1, &m_uboOffset);	// Bind the vertex and index buffers	VkDeviceSize offsets[] = { 0 };	vkCmdBindVertexBuffers(cmd, 0, 1, &ms_vbo(), offsets);	vkCmdBindIndexBuffer(cmd, ms_ibo(), 0, VK_INDEX_TYPE_UINT16);	// Draw the triangle	vkCmdDrawIndexed(cmd, 30 + 6, 1, 0, 0, 0);}

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

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

	void RHI_CommandList::SetViewport(const RHI_Viewport& viewport)	{		if (!m_is_recording)			return;		VkViewport vk_viewport	= {};		vk_viewport.x			= viewport.GetX();		vk_viewport.y			= viewport.GetY();		vk_viewport.width		= viewport.GetWidth();		vk_viewport.height		= viewport.GetHeight();		vk_viewport.minDepth	= viewport.GetMinDepth();		vk_viewport.maxDepth	= viewport.GetMaxDepth();		vkCmdSetViewport(CMD_BUFFER_VK, 0, 1, &vk_viewport);	}

bool StateTracker::Bind(){  // Must have a pipeline.  if (!m_pipeline)    return false;  // Check the render area if we were in a clear pass.  if (m_current_render_pass == m_framebuffer->GetClearRenderPass() && !IsViewportWithinRenderArea())    EndRenderPass();  // Get a new descriptor set if any parts have changed  if (!UpdateDescriptorSet())  {    // We can fail to allocate descriptors if we exhaust the pool for this command buffer.    WARN_LOG(VIDEO, "Failed to get a descriptor set, executing buffer");    Renderer::GetInstance()->ExecuteCommandBuffer(false, false);    if (!UpdateDescriptorSet())    {      // Something strange going on.      ERROR_LOG(VIDEO, "Failed to get descriptor set, skipping draw");      return false;    }  }  // Start render pass if not already started  if (!InRenderPass())    BeginRenderPass();  // Re-bind parts of the pipeline  const VkCommandBuffer command_buffer = g_command_buffer_mgr->GetCurrentCommandBuffer();  if (m_dirty_flags & DIRTY_FLAG_VERTEX_BUFFER)    vkCmdBindVertexBuffers(command_buffer, 0, 1, &m_vertex_buffer, &m_vertex_buffer_offset);  if (m_dirty_flags & DIRTY_FLAG_INDEX_BUFFER)    vkCmdBindIndexBuffer(command_buffer, m_index_buffer, m_index_buffer_offset, m_index_type);  if (m_dirty_flags & DIRTY_FLAG_PIPELINE)    vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipeline->GetVkPipeline());  if (m_dirty_flags & DIRTY_FLAG_VIEWPORT)    vkCmdSetViewport(command_buffer, 0, 1, &m_viewport);  if (m_dirty_flags & DIRTY_FLAG_SCISSOR)    vkCmdSetScissor(command_buffer, 0, 1, &m_scissor);  m_dirty_flags &= ~(DIRTY_FLAG_VERTEX_BUFFER | DIRTY_FLAG_INDEX_BUFFER | DIRTY_FLAG_PIPELINE |                     DIRTY_FLAG_VIEWPORT | DIRTY_FLAG_SCISSOR);  return true;}

void SetViewportAndScissor(VkCommandBuffer command_buffer, int x, int y, int width, int height,                           float min_depth /*= 0.0f*/, float max_depth /*= 1.0f*/){  VkViewport viewport = {static_cast<float>(x),                         static_cast<float>(y),                         static_cast<float>(width),                         static_cast<float>(height),                         min_depth,                         max_depth};  VkRect2D scissor = {{x, y}, {static_cast<uint32_t>(width), static_cast<uint32_t>(height)}};  vkCmdSetViewport(command_buffer, 0, 1, &viewport);  vkCmdSetScissor(command_buffer, 0, 1, &scissor);}

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

//.........这里部分代码省略.........    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);    vkCmdExecuteCommands(info.cmd, 4, secondary_cmds);    vkCmdEndRenderPass(info.cmd);    VkImageMemoryBarrier prePresentBarrier = {};    prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;    prePresentBarrier.pNext = NULL;

VkBool32 Example::buildCmdBuffer(const int32_t usedBuffer){	VkResult result;	cmdBuffer[usedBuffer] = vkts::commandBuffersCreate(initialResources->getDevice()->getDevice(), commandPool->getCmdPool(), VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1);	if (!cmdBuffer[usedBuffer].get())	{		vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not create command buffer.");		return VK_FALSE;	}	result = cmdBuffer[usedBuffer]->beginCommandBuffer(0, VK_NULL_HANDLE, 0, VK_NULL_HANDLE, VK_FALSE, 0, 0);	if (result != VK_SUCCESS)	{		vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not begin command buffer.");		return VK_FALSE;	}    //    swapchain->cmdPipelineBarrier(cmdBuffer[usedBuffer]->getCommandBuffer(), VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, usedBuffer);    //	VkClearColorValue clearColorValue;	memset(&clearColorValue, 0, sizeof(VkClearColorValue));	clearColorValue.float32[0] = 0.2f;	clearColorValue.float32[1] = 0.2f;	clearColorValue.float32[2] = 0.2f;	clearColorValue.float32[3] = 1.0f;	VkClearDepthStencilValue clearDepthStencilValue;	memset(&clearDepthStencilValue, 0, sizeof(VkClearDepthStencilValue));	clearDepthStencilValue.depth = 1.0f;	clearDepthStencilValue.stencil = 0;	VkClearValue clearValues[2];	memset(clearValues, 0, sizeof(clearValues));	clearValues[0].color = clearColorValue;	clearValues[1].depthStencil = clearDepthStencilValue;	VkRenderPassBeginInfo renderPassBeginInfo;	memset(&renderPassBeginInfo, 0, sizeof(VkRenderPassBeginInfo));	renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;	renderPassBeginInfo.renderPass = renderPass->getRenderPass();	renderPassBeginInfo.framebuffer = framebuffer[usedBuffer]->getFramebuffer();	renderPassBeginInfo.renderArea.offset.x = 0;	renderPassBeginInfo.renderArea.offset.y = 0;	renderPassBeginInfo.renderArea.extent = swapchain->getImageExtent();	renderPassBeginInfo.clearValueCount = 2;	renderPassBeginInfo.pClearValues = clearValues;	cmdBuffer[usedBuffer]->cmdBeginRenderPass(&renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);	VkViewport viewport;	memset(&viewport, 0, sizeof(VkViewport));	viewport.x = 0.0f;	viewport.y = 0.0f;	viewport.width = (float) swapchain->getImageExtent().width;	viewport.height = (float) swapchain->getImageExtent().height;	viewport.minDepth = 0.0f;	viewport.maxDepth = 1.0f;	vkCmdSetViewport(cmdBuffer[usedBuffer]->getCommandBuffer(), 0, 1, &viewport);	VkRect2D scissor;	memset(&scissor, 0, sizeof(VkRect2D));	scissor.offset.x = 0;	scissor.offset.y = 0;	scissor.extent = swapchain->getImageExtent();	vkCmdSetScissor(cmdBuffer[usedBuffer]->getCommandBuffer(), 0, 1, &scissor);	if (scene.get())	{		scene->bindDrawIndexedRecursive(cmdBuffer[usedBuffer], allGraphicsPipelines);	}	cmdBuffer[usedBuffer]->cmdEndRenderPass();    //    swapchain->cmdPipelineBarrier(cmdBuffer[usedBuffer]->getCommandBuffer(), VK_ACCESS_MEMORY_READ_BIT, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, usedBuffer);    ////.........这里部分代码省略.........

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

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

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

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

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

//.........这里部分代码省略.........    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*/);    vkCmdCopyQueryPoolResults(        info.cmd, query_pool, 0 /*firstQuery*/, 2 /*queryCount*/,        query_result_buf, 0 /*dstOffset*/, sizeof(uint64_t) /*stride*/,        VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);    VkImageMemoryBarrier prePresentBarrier = {};    prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;    prePresentBarrier.pNext = NULL;    prePresentBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;    prePresentBarrier.dstAccessMask = 0;    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;

void vkeGameRendererDynamic::generateDrawCommands(){	//Start generating draw commands.	VulkanDC *dc = VulkanDC::Get();	VulkanDC::Device *device = dc->getDefaultDevice();	VkClearValue clearValues[3];	/*	Dispatch threads to create the secondary	command buffers.	*/	m_calls_generated = 0;	for (uint32_t i = 0; i < m_max_draw_calls; ++i){		m_draw_calls[i]->initDrawCommands(m_node_data->count(), m_current_buffer_index);	}	/*	Begin setting up the primary command buffer.	*/	VkCommandBufferBeginInfo cmdBeginInfo = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };	cmdBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;	vkResetCommandBuffer(m_primary_commands[m_current_buffer_index], 0);	vkResetCommandBuffer(m_update_commands[m_current_buffer_index], 0);	VKA_CHECK_ERROR(vkBeginCommandBuffer(m_update_commands[m_current_buffer_index], &cmdBeginInfo), "Could not begin primary command buffer./n");	VkBufferMemoryBarrier bufBarrier = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER };	bufBarrier.dstAccessMask = VK_ACCESS_UNIFORM_READ_BIT;	bufBarrier.srcAccessMask = VK_ACCESS_HOST_WRITE_BIT;	bufBarrier.dstQueueFamilyIndex = 0;	bufBarrier.offset = 0;	bufBarrier.buffer = m_uniforms_buffer;	bufBarrier.srcQueueFamilyIndex = 0;	colorClearValues(&clearValues[0], 1.0, 1.0, 1.0);	depthStencilClearValues(&clearValues[1]);//default#	colorClearValues(&clearValues[2], 0.0, 0.0, 0.0);	uint32_t sz = (sizeof(VkeNodeUniform) * 100) + (64 * 64);	VkBufferCopy bufCopy;	bufCopy.dstOffset = 0;	bufCopy.srcOffset = 0;	bufCopy.size = sz;	vkCmdCopyBuffer(m_update_commands[m_current_buffer_index], m_uniforms_buffer_staging, m_uniforms_buffer, 1, &bufCopy);	vkCmdPipelineBarrier(		m_update_commands[m_current_buffer_index],		VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,		VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,		0,		0,		NULL,		1,		&bufBarrier,		0,		NULL);	VKA_CHECK_ERROR(vkEndCommandBuffer(m_update_commands[m_current_buffer_index]), "Could not end command buffer for draw command./n");	VKA_CHECK_ERROR(vkBeginCommandBuffer(m_primary_commands[m_current_buffer_index], &cmdBeginInfo), "Could not begin primary command buffer./n");	renderPassBegin(&m_primary_commands[m_current_buffer_index], m_render_pass, m_framebuffers[m_current_buffer_index], 0, 0, m_width, m_height, clearValues, 3, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);	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(m_primary_commands[m_current_buffer_index], 0, 1, &vp);	vkCmdSetScissor(m_primary_commands[m_current_buffer_index], 0, 1, &sc);	/*	Wait here until the secondary commands are ready.	*/	VkCommandBuffer secondaryCommands[11];	secondaryCommands[0] = m_terrain_command[m_current_buffer_index];	for (uint32_t i = 0; i < m_max_draw_calls; ++i){		secondaryCommands[i + 1] = m_draw_calls[i]->getDrawCommand(m_current_buffer_index);	}	vkCmdExecuteCommands(m_primary_commands[m_current_buffer_index], 1 + m_max_draw_calls, secondaryCommands);//.........这里部分代码省略.........

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

	void buildCommandBuffers()	{		VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();		VkClearValue clearValues[3];		clearValues[0].color = { { 0.0f, 0.0f, 0.2f, 0.0f } };		clearValues[1].color = { { 0.0f, 0.0f, 0.2f, 0.0f } };		clearValues[2].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 = 3;		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);			VkDeviceSize offsets[1] = { 0 };			/*				First sub pass				Fills the attachments			*/			{				vks::debugmarker::beginRegion(drawCmdBuffers[i], "Subpass 0: Writing attachments", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));				vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.attachmentWrite);				vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.attachmentWrite, 0, 1, &descriptorSets.attachmentWrite, 0, NULL);				vkCmdBindVertexBuffers(drawCmdBuffers[i], 0, 1, &scene.vertices.buffer, offsets);				vkCmdBindIndexBuffer(drawCmdBuffers[i], scene.indices.buffer, 0, VK_INDEX_TYPE_UINT32);				vkCmdDrawIndexed(drawCmdBuffers[i], scene.indexCount, 1, 0, 0, 0);				vks::debugmarker::endRegion(drawCmdBuffers[i]);			}			/*				Second sub pass				Reads from the attachments via input attachments			*/			{				vks::debugmarker::beginRegion(drawCmdBuffers[i], "Subpass 1: Reading attachments", glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));				vkCmdNextSubpass(drawCmdBuffers[i], VK_SUBPASS_CONTENTS_INLINE);				vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.attachmentRead);				vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.attachmentRead, 0, 1, &descriptorSets.attachmentRead, 0, NULL);				vkCmdDraw(drawCmdBuffers[i], 3, 1, 0, 0);				vks::debugmarker::endRegion(drawCmdBuffers[i]);			}			vkCmdEndRenderPass(drawCmdBuffers[i]);			VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));		}	}

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

void vkeGameRendererDynamic::generateDrawCommands(){	//Start generating draw commands.	VulkanDC *dc = VulkanDC::Get();	VulkanDC::Device *device = dc->getDefaultDevice();	VkClearValue clearValues[3];	colorClearValues(&clearValues[0], 1.0, 1.0, 1.0);	depthStencilClearValues(&clearValues[1]);//default#	colorClearValues(&clearValues[2], 0.0, 0.0, 0.0);	/*	Dispatch threads to create the secondary	command buffers.	*/	m_calls_generated = 0;	for (uint32_t i = 0; i < m_max_draw_calls; ++i){		m_draw_calls[i]->initDrawCommands(m_node_data->count(), m_current_buffer_index);	}	/*	Begin setting up the primary command buffer.	*/	VkCommandBufferBeginInfo cmdBeginInfo = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };	cmdBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;	VKA_CHECK_ERROR(vkResetCommandBuffer(m_primary_commands[m_current_buffer_index], 0),"Could not reset primary command buffer");	VKA_CHECK_ERROR(vkBeginCommandBuffer(m_primary_commands[m_current_buffer_index], &cmdBeginInfo), "Could not begin primary command buffer./n");	uint32_t cnt = m_node_data->count();	VkDeviceSize sz = (sizeof(VkeNodeUniform) * cnt) + (m_instance_count * 64);	vkCmdUpdateBuffer(m_primary_commands[m_current_buffer_index], m_uniforms_buffer, 0, sz, (const uint32_t *)m_uniforms_local);	m_camera->updateCameraCmd(m_primary_commands[m_current_buffer_index]);	renderPassBegin(&m_primary_commands[m_current_buffer_index], m_render_pass, m_framebuffers[m_current_buffer_index], 0, 0, m_width, m_height, clearValues, 3, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);	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(m_primary_commands[m_current_buffer_index], 0, 1, &vp);	vkCmdSetScissor(m_primary_commands[m_current_buffer_index], 0, 1, &sc);	/*	Wait here until the secondary commands are ready.	*/	VkCommandBuffer secondaryCommands[11];	secondaryCommands[0] = m_terrain_command[m_current_buffer_index];	for (uint32_t i = 0; i < m_max_draw_calls; ++i){		secondaryCommands[i+1] = m_draw_calls[i]->getDrawCommand(m_current_buffer_index);	}	vkCmdExecuteCommands(m_primary_commands[m_current_buffer_index],  1+m_max_draw_calls, secondaryCommands);	vkCmdEndRenderPass(m_primary_commands[m_current_buffer_index]);	VkImageResolve blitInfo;    blitInfo.srcOffset.x = 0;	blitInfo.srcOffset.y = 0;	blitInfo.srcOffset.z = 0;	blitInfo.dstOffset.x = 0;	blitInfo.dstOffset.y = 0;	blitInfo.dstOffset.z = 0;    blitInfo.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;    blitInfo.srcSubresource.mipLevel = 0;    blitInfo.srcSubresource.baseArrayLayer = 0;    blitInfo.srcSubresource.layerCount = 1;    blitInfo.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;    blitInfo.dstSubresource.mipLevel = 0;    blitInfo.dstSubresource.baseArrayLayer = 0;    blitInfo.dstSubresource.layerCount = 1;    blitInfo.extent.width = m_width;    blitInfo.extent.height = m_height;    blitInfo.extent.depth = 1;	vkCmdResolveImage(		m_primary_commands[m_current_buffer_index],		m_color_attachment.image,		VK_IMAGE_LAYOUT_GENERAL,		m_resolve_attachment[m_current_buffer_index].image,		VK_IMAGE_LAYOUT_GENERAL,		1,		&blitInfo);//.........这里部分代码省略.........