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

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

	/**	* 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 TriangleVK::Render(VkCommandBuffer cmd_buf, Camera *pCam){    struct DATA    {        XMMATRIX mat;    } *pData;    VkDescriptorBufferInfo constantBuffer;    m_pConstantBufferRing->AllocConstantBuffer(4*4 * sizeof(float), (void**)&pData, &constantBuffer);    pData->mat = pCam->GetView() * pCam->GetProjection();    VkWriteDescriptorSet writes[1];    writes[0] = {};    writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;    writes[0].pNext = NULL;    writes[0].dstSet = m_descriptorSets[0];    writes[0].descriptorCount = 1;    writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;    writes[0].pBufferInfo = &constantBuffer;    writes[0].dstArrayElement = 0;    writes[0].dstBinding = 0;    vkUpdateDescriptorSets(m_pDevice->GetDevice(), 1, writes, 0, NULL);    const VkDeviceSize offsets[1] = { m_geometry.offset };    vkCmdBindVertexBuffers(cmd_buf, 0, 1, &m_geometry.buffer, offsets);    vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipeline);    vkCmdBindDescriptorSets(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, m_pipelineLayout, 0, (uint32_t)m_descriptorSets.size(), m_descriptorSets.data(), 0, NULL);    vkCmdDraw(cmd_buf, 12 * 3, 1, 0, 0);}

	void Model::draw(VkCommandBuffer commandBuffer)	{		VkDeviceSize offsets[1] = { 0 };		vkCmdBindVertexBuffers(commandBuffer, 0, 1, &m_vertices.buffer, offsets);		vkCmdBindIndexBuffer(commandBuffer, m_indices.buffer, 0, VK_INDEX_TYPE_UINT32);		vkCmdDrawIndexed(commandBuffer, m_indexCount, 1, 0, 0, 1);	}

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

	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 VulkanGear::draw(VkCommandBuffer cmdbuffer, VkPipelineLayout pipelineLayout){	VkDeviceSize offsets[1] = { 0 };	vkCmdBindDescriptorSets(cmdbuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, NULL);	vkCmdBindVertexBuffers(cmdbuffer, 0, 1, &vertexBuffer.buf, offsets);	vkCmdBindIndexBuffer(cmdbuffer, indexBuffer.buf, 0, VK_INDEX_TYPE_UINT32);	vkCmdDrawIndexed(cmdbuffer, indexBuffer.count, 1, 0, 0, 1);}

void rSimpleMesh::record( VkCommandBuffer _buf ) {   VkDeviceSize lOffsets[] = {0};   VkBuffer lVertex        = vVertex.getBuffer();   vPipeline->cmdBindPipeline( _buf, VK_PIPELINE_BIND_POINT_GRAPHICS );   vkCmdBindVertexBuffers( _buf, vPipeline->getVertexBindPoint(), 1, &lVertex, &lOffsets[0] );   vkCmdBindIndexBuffer( _buf, vIndex.getBuffer(), 0, VK_INDEX_TYPE_UINT32 );   vkCmdDrawIndexed( _buf, vIndex.getSize(), 1, 0, 0, 1 );}

//======================================================================//======================================================================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 RHI_CommandList::SetBufferVertex(const RHI_VertexBuffer* buffer)	{		if (!m_is_recording)			return;		VkBuffer vertex_buffers[]	= { static_cast<VkBuffer>(buffer->GetBuffer()) };		VkDeviceSize offsets[]		= { 0 };		vkCmdBindVertexBuffers(CMD_BUFFER_VK, 0, 1, vertex_buffers, offsets);	}

	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 VulkanQuad::RenderImpl (VkCommandBuffer commandBuffer){    VulkanSample::RenderImpl (commandBuffer);    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);    vkCmdDrawIndexed (commandBuffer, 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]));		}	}

//==============================================================================void CommandBufferImpl::bindResourceGroup(	ResourceGroupPtr rc, U slot, const TransientMemoryInfo* dynInfo){	// TODO set the correct binding point	commandCommon();	const ResourceGroupImpl& impl = rc->getImplementation();	if(impl.hasDescriptorSet())	{		Array<U32, MAX_UNIFORM_BUFFER_BINDINGS + MAX_STORAGE_BUFFER_BINDINGS>			dynOffsets = {{}};		impl.setupDynamicOffsets(dynInfo, &dynOffsets[0]);		VkDescriptorSet dset = impl.getHandle();		vkCmdBindDescriptorSets(m_handle,			VK_PIPELINE_BIND_POINT_GRAPHICS,			getGrManagerImpl().getGlobalPipelineLayout(),			slot,			1,			&dset,			dynOffsets.getSize(),			&dynOffsets[0]);	}	// Bind vertex and index buffer only in the first set	if(slot == 0)	{		const VkBuffer* buffers = nullptr;		const VkDeviceSize* offsets = nullptr;		U bindingCount = 0;		impl.getVertexBindingInfo(buffers, offsets, bindingCount);		if(bindingCount)		{			vkCmdBindVertexBuffers(m_handle, 0, bindingCount, buffers, offsets);		}		VkBuffer idxBuff;		VkDeviceSize idxBuffOffset;		VkIndexType idxType;		if(impl.getIndexBufferInfo(idxBuff, idxBuffOffset, idxType))		{			vkCmdBindIndexBuffer(m_handle, idxBuff, idxBuffOffset, idxType);		}	}	// Hold the reference	m_rcList.pushBack(m_alloc, rc);}

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 drawIndexed(VkCommandBuffer cmdBuffer)		{			VkDeviceSize offsets[1] = { 0 };			if (pipeline != VK_NULL_HANDLE)			{				vkCmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);			}			if ((pipelineLayout != VK_NULL_HANDLE) && (descriptorSet != VK_NULL_HANDLE))			{				vkCmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, NULL);			}			vkCmdBindVertexBuffers(cmdBuffer, vertexBufferBinding, 1, &buffers.vertices.buf, offsets);			vkCmdBindIndexBuffer(cmdBuffer, buffers.indices.buf, 0, VK_INDEX_TYPE_UINT32);			vkCmdDrawIndexed(cmdBuffer, buffers.indexCount, 1, 0, 0, 0);		}

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

/** * Register the commands that render the entity. */void VkcEntity::render(VkCommandBuffer commandBuffer, MgBuffer uniformBuffer, QMatrix4x4 vpMatrix, const VkcDevice *device){    // Wiggle, wiggle, wiggle.    position += QVector3D(dir, 0.0f, 0.0f);    float pos = position.x();    if(pos > 0.1f || pos < -0.1f)        dir *= -1.0f;    // Calculate model matrix.    QMatrix4x4 modelMatrix;    modelMatrix.translate(position);    modelMatrix.rotate(rotation);    modelMatrix.scale(scale);    // Calculate MVP matrix.    QMatrix4x4 mvpMatrix = vpMatrix * modelMatrix;    // Map uniform buffer memory to host.    void *data = nullptr;    vkMapMemory(device->logical, uniformBuffer.memory, 0, VK_WHOLE_SIZE, 0, &data);    // Copy data to the buffer.    memcpy(data, mvpMatrix.data(), 16 * sizeof(float));    // Unmap memory.    vkUnmapMemory(device->logical, uniformBuffer.memory);    // Bind vertex and index bufffer.    VkDeviceSize vboOffsets[] = {0};    uint32_t iboOffset = vertices.size() * sizeof(VkVertex);    vkCmdBindVertexBuffers(commandBuffer, 0, 1, &buffer.handle, vboOffsets);    vkCmdBindIndexBuffer(commandBuffer, buffer.handle, iboOffset, VK_INDEX_TYPE_UINT32);    // Draw entity.    vkCmdDrawIndexed(commandBuffer, indices.size(), 1, 0, 0, 0);}

void SubMesh::bindVertexBuffers(const ICommandBuffersSP& cmdBuffer, const uint32_t bufferIndex) const{    if (!vertexBuffer.get())    {        return;    }    if (!vertexBuffer->getBuffer().get())    {        return;    }    if (!cmdBuffer.get())    {        return;    }    VkDeviceSize offsets[1] = {0};    VkBuffer buffers[1] = {vertexBuffer->getBuffer()->getBuffer()};    vkCmdBindVertexBuffers(cmdBuffer->getCommandBuffer(bufferIndex), 0, 1, buffers, offsets);}

void WireframeModel::Render(VulkanInterface * vulkan, VulkanCommandBuffer * commandBuffer, VulkanPipeline * pipeline, Camera * camera, int framebufferId){	// Update vertex uniform buffer	vertexUniformBuffer.MVP = camera->GetProjectionMatrix() * camera->GetViewMatrix() * worldMatrix;	vsUBO->Update(vulkan->GetVulkanDevice(), &vertexUniformBuffer, sizeof(VertexUniformBuffer));	UpdateDescriptorSet(vulkan, pipeline);	// Render	drawCmdBuffers[framebufferId]->BeginRecordingSecondary(vulkan->GetForwardRenderpass()->GetRenderpass(), vulkan->GetVulkanSwapchain()->GetFramebuffer(framebufferId));	vulkan->InitViewportAndScissors(drawCmdBuffers[framebufferId], (float)gSettings->GetWindowWidth(), (float)gSettings->GetWindowHeight(),		(uint32_t)gSettings->GetWindowWidth(), (uint32_t)gSettings->GetWindowHeight());	pipeline->SetActive(drawCmdBuffers[framebufferId]);	VkDeviceSize offsets[1] = { 0 };	vkCmdBindVertexBuffers(drawCmdBuffers[framebufferId]->GetCommandBuffer(), 0, 1, vertexBuffer->GetBuffer(), offsets);	vkCmdBindIndexBuffer(drawCmdBuffers[framebufferId]->GetCommandBuffer(), *indexBuffer->GetBuffer(), 0, VK_INDEX_TYPE_UINT32);	vkCmdDrawIndexed(drawCmdBuffers[framebufferId]->GetCommandBuffer(), indexCount, 1, 0, 0, 0);	drawCmdBuffers[framebufferId]->EndRecording();	drawCmdBuffers[framebufferId]->ExecuteSecondary(commandBuffer);}

//.........这里部分代码省略.........    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);    vkCmdExecuteCommands(info.cmd, 4, secondary_cmds);    vkCmdEndRenderPass(info.cmd);

//.........这里部分代码省略.........    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;    submit_info[0].pSignalSemaphores = NULL;    /* Queue the command buffer for execution */    res = vkQueueSubmit(info.graphics_queue, 1, submit_info, drawFence);    assert(res == VK_SUCCESS);

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

//.........这里部分代码省略.........    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;    prePresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;    prePresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;    prePresentBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;    prePresentBarrier.subresourceRange.baseMipLevel = 0;    prePresentBarrier.subresourceRange.levelCount = 1;    prePresentBarrier.subresourceRange.baseArrayLayer = 0;    prePresentBarrier.subresourceRange.layerCount = 1;    prePresentBarrier.image = info.buffers[info.current_buffer].image;    vkCmdPipelineBarrier(info.cmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,

//.........这里部分代码省略.........    descriptor_writes[2] = {};    descriptor_writes[2].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;    descriptor_writes[2].pNext = NULL;    descriptor_writes[2].dstSet = descriptor_sets[0];    descriptor_writes[2].descriptorCount = 1;    descriptor_writes[2].descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER;    descriptor_writes[2].pImageInfo = &samplerInfo;    descriptor_writes[2].dstArrayElement = 0;    descriptor_writes[2].dstBinding = 2;    vkUpdateDescriptorSets(info.device, resource_count, descriptor_writes, 0, NULL);    /* VULKAN_KEY_END */    init_pipeline_cache(info);    init_pipeline(info, depthPresent);    init_presentable_image(info);    VkClearValue clear_values[2];    init_clear_color_and_depth(info, clear_values);    VkRenderPassBeginInfo rp_begin;    init_render_pass_begin_info(info, rp_begin);    rp_begin.clearValueCount = 2;    rp_begin.pClearValues = clear_values;    vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);    vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);    vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,                            descriptor_sets, 0, NULL);    const VkDeviceSize offsets[1] = {0};    vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf, offsets);    init_viewports(info);    init_scissors(info);    vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);    vkCmdEndRenderPass(info.cmd);    res = vkEndCommandBuffer(info.cmd);    assert(res == VK_SUCCESS);    VkFence drawFence = {};    init_fence(info, drawFence);    VkPipelineStageFlags pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;    VkSubmitInfo submit_info = {};    init_submit_info(info, submit_info, pipe_stage_flags);    /* Queue the command buffer for execution */    res = vkQueueSubmit(info.graphics_queue, 1, &submit_info, drawFence);    assert(res == VK_SUCCESS);    /* Now present the image in the window */    VkPresentInfoKHR present = {};    init_present_info(info, present);    /* Make sure command buffer is finished before presenting */    do {        res = vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);    } while (res == VK_TIMEOUT);    assert(res == VK_SUCCESS);    res = vkQueuePresentKHR(info.present_queue, &present);    assert(res == VK_SUCCESS);    wait_seconds(1);