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

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

WError WMaterial::Bind(WRenderTarget* rt, unsigned int num_vertex_buffers) {	if (!Valid())		return WError(W_NOTVALID);	VkDevice device = m_app->GetVulkanDevice();	VkCommandBuffer renderCmdBuffer = rt->GetCommnadBuffer();	if (!renderCmdBuffer)		return WError(W_NORENDERTARGET);	int curDSIndex = 0;	for (int i = 0; i < m_sampler_info.size(); i++) {		W_BOUND_RESOURCE* info = m_sampler_info[i].sampler_info;		if (m_sampler_info[i].img && m_sampler_info[i].img->Valid()) {			m_sampler_info[i].descriptor.imageView = m_sampler_info[i].img->GetView();			VkWriteDescriptorSet writeDescriptorSet = {};			writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;			writeDescriptorSet.dstSet = m_descriptorSet;			writeDescriptorSet.descriptorCount = 1;			writeDescriptorSet.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;			writeDescriptorSet.pImageInfo = &m_sampler_info[i].descriptor;			writeDescriptorSet.dstBinding = info->binding_index;			m_writeDescriptorSets[curDSIndex++] = writeDescriptorSet;		}	}	if (curDSIndex)		vkUpdateDescriptorSets(device, curDSIndex, m_writeDescriptorSets.data(), 0, NULL);	vkCmdBindDescriptorSets(renderCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_effect->GetPipelineLayout(), 0, 1, &m_descriptorSet, 0, NULL);	return m_effect->Bind(rt, num_vertex_buffers);}

	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 vkeGameRendererDynamic::initTerrainCommand(){	VulkanDC *dc = VulkanDC::Get();	VulkanDC::Device  *device = dc->getDefaultDevice();	VulkanDC::Device::Queue *queue = dc->getDefaultQueue();	uint32_t cmdID = 1021;	VkResult rslt;	for (uint32_t i = 0; i < 2; ++i){		if (m_terrain_command[i] != VK_NULL_HANDLE){			vkFreeCommandBuffers(device->getVKDevice(), queue->getCommandPool(), 1, &m_terrain_command[i]);			m_terrain_command[i] = VK_NULL_HANDLE;		}		{			VkCommandBufferAllocateInfo cmdBufInfo = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };			cmdBufInfo.commandBufferCount = 1;			cmdBufInfo.commandPool = queue->getCommandPool();			cmdBufInfo.level = VK_COMMAND_BUFFER_LEVEL_SECONDARY;			rslt = vkAllocateCommandBuffers(device->getVKDevice(), &cmdBufInfo, &m_terrain_command[i]);			VkCommandBufferBeginInfo cmdBeginInfo = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };			cmdBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;			rslt = vkBeginCommandBuffer(m_terrain_command[i], &cmdBeginInfo);			vkCmdBindPipeline(m_terrain_command[i], VK_PIPELINE_BIND_POINT_GRAPHICS, m_quad_pipeline);			vkCmdBindDescriptorSets(m_terrain_command[i], VK_PIPELINE_BIND_POINT_GRAPHICS, m_quad_pipeline_layout, 0, 1, &m_quad_descriptor_set, 0, NULL);			m_screen_quad.bind(&m_terrain_command[i]);			m_screen_quad.draw(&m_terrain_command[i]);			vkCmdBindPipeline(m_terrain_command[i], VK_PIPELINE_BIND_POINT_GRAPHICS, m_terrain_pipeline);			vkCmdBindDescriptorSets(m_terrain_command[i], VK_PIPELINE_BIND_POINT_GRAPHICS, m_terrain_pipeline_layout, 0, 1, &m_terrain_descriptor_set, 0, NULL);			m_terrain_quad.bind(&m_terrain_command[i]);			m_terrain_quad.draw(&m_terrain_command[i]);/**/			vkEndCommandBuffer(m_terrain_command[i]);		}	}}

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 QeParticle::updateComputeCommandBuffer(VkCommandBuffer &commandBuffer) {    if (!currentParticlesSize) return;    vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, VK->pipelineLayout, eDescriptorSetLayout_Compute, 1,                            &descriptorSetCompute.set, 0, nullptr);    vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, VK->createComputePipeline(&computePipeline));    vkCmdDispatch(commandBuffer, currentParticlesSize, 1, 1);}

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

//======================================================================//======================================================================void 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 = 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 VkeDrawCall::initDrawCommands(const uint32_t inCount, const uint32_t inCommandIndex){	VkPipelineLayout layout = m_renderer->getPipelineLayout();	VkPipeline pipeline = m_renderer->getPipeline();	VkDescriptorSet sceneDescriptor = m_renderer->getSceneDescriptorSet();	VkDescriptorSet *textureDescriptors = m_renderer->getTextureDescriptorSets();	VkBuffer sceneIndirectBuffer = m_renderer->getSceneIndirectBuffer();	VulkanDC *dc = VulkanDC::Get();	VulkanDC::Device  *device = dc->getDefaultDevice();	VulkanDC::Device::Queue *queue = dc->getDefaultQueue();	VulkanAppContext *ctxt = VulkanAppContext::GetInstance();	vkResetCommandBuffer(m_draw_command[inCommandIndex], 0);	VkCommandBufferBeginInfo cmdBeginInfo = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };	cmdBeginInfo.flags =  VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;	VKA_CHECK_ERROR(vkBeginCommandBuffer(m_draw_command[inCommandIndex], &cmdBeginInfo), "Could not begin command buffer./n");	vkCmdBindPipeline(m_draw_command[inCommandIndex], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);	VkeVBO *theVBO = ctxt->getVBO();	VkeIBO *theIBO = ctxt->getIBO();	theVBO->bind(&m_draw_command[inCommandIndex]);	theIBO->bind(&m_draw_command[inCommandIndex]);	VkDescriptorSet sets[3] = { sceneDescriptor, textureDescriptors[0], m_transform_descriptor_set };	vkCmdBindDescriptorSets(m_draw_command[inCommandIndex], VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, 3, sets, 0, NULL);	vkCmdDrawIndexedIndirect(m_draw_command[inCommandIndex], sceneIndirectBuffer, 0, inCount, sizeof(VkDrawIndexedIndirectCommand));	vkCmdDraw(m_draw_command[inCommandIndex], 1, 1, 0, 0);	vkEndCommandBuffer(m_draw_command[inCommandIndex]);	/*	Lock mutex to update generated call count.	*/	//std::lock_guard<std::mutex> lk(m_renderer->getSecondaryCmdBufferMutex());	/*	Increment the generated call count	*/	m_renderer->incrementDrawCallsGenerated();}

	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 buildComputeCommandBuffer()	{		VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();;		vkBeginCommandBuffer(computeCmdBuffer, &cmdBufInfo);		vkCmdBindPipeline(computeCmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelines.compute);		vkCmdBindDescriptorSets(computeCmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, computePipelineLayout, 0, 1, &computeDescriptorSet, 0, 0);		vkCmdDispatch(computeCmdBuffer, PARTICLE_COUNT / 16, 1, 1);		vkEndCommandBuffer(computeCmdBuffer);	}

void BRDFMaterial::bindDescriptorSets(const ICommandBuffersSP& cmdBuffer, const VkPipelineLayout layout, const uint32_t bufferIndex) const{    if (!cmdBuffer.get())    {        return;    }    if (!descriptorSets.get())    {        return;    }    vkCmdBindDescriptorSets(cmdBuffer->getCommandBuffer(bufferIndex), VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, 1, &descriptorSets->getDescriptorSets()[0], 0, nullptr);}

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

VkBool32 Example::buildCmdBuffer(){	VkResult result;	//	cmdBuffer = vkts::commandBuffersCreate(device->getDevice(), commandPool->getCmdPool(), VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1);	if (!cmdBuffer.get())	{		vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not create command buffer.");		return VK_FALSE;	}	result = cmdBuffer->beginCommandBuffer(0, VK_NULL_HANDLE, 0, VK_NULL_HANDLE, VK_FALSE, 0, 0);	if (result != VK_SUCCESS)	{		vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not begin command buffer.");		return VK_FALSE;	}	//	vkCmdBindPipeline(cmdBuffer->getCommandBuffer(), VK_PIPELINE_BIND_POINT_COMPUTE, pipeline->getPipeline());	vkCmdBindDescriptorSets(cmdBuffer->getCommandBuffer(), VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout->getPipelineLayout(), 0, 1, descriptorSet->getDescriptorSets(), 0, nullptr);	VkImageSubresourceRange imageSubresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };	image->cmdPipelineBarrier(cmdBuffer->getCommandBuffer(), VK_ACCESS_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL, imageSubresourceRange);	vkCmdDispatch(cmdBuffer->getCommandBuffer(), VKTS_IMAGE_LENGTH / VKTS_LOCAL_SIZE, VKTS_IMAGE_LENGTH / VKTS_LOCAL_SIZE, 1);	//	result = cmdBuffer->endCommandBuffer();	if (result != VK_SUCCESS)	{		vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not end command buffer.");		return VK_FALSE;	}	return VK_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 PhongMaterial::bindDescriptorSets(const std::string& nodeName, const ICommandBuffersSP& cmdBuffer, const VkPipelineLayout layout, const uint32_t bufferIndex) const{    if (!cmdBuffer.get())    {        return;    }    auto currentDescriptorSets = getDescriptorSetsByName(nodeName);    if (!currentDescriptorSets.get())    {        return;    }    vkCmdBindDescriptorSets(cmdBuffer->getCommandBuffer(bufferIndex), VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, 1, &currentDescriptorSets->getDescriptorSets()[0], 0, nullptr);}

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

	void renderNode(vkglTF::Node *node, VkCommandBuffer commandBuffer) {		if (node->mesh) {			for (vkglTF::Primitive * primitive : node->mesh->primitives) {				const std::vector<VkDescriptorSet> descriptorsets = {					descriptorSet,					node->mesh->uniformBuffer.descriptorSet				};				vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, static_cast<uint32_t>(descriptorsets.size()), descriptorsets.data(), 0, NULL);								struct PushBlock {					glm::vec4 baseColorFactor;				} pushBlock;				pushBlock.baseColorFactor = primitive->material.baseColorFactor;				vkCmdPushConstants(commandBuffer, pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(PushBlock), &pushBlock);				/*					[POI] Setup the conditional rendering				*/				VkConditionalRenderingBeginInfoEXT conditionalRenderingBeginInfo{};				conditionalRenderingBeginInfo.sType = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT;				conditionalRenderingBeginInfo.buffer = conditionalBuffer.buffer;				conditionalRenderingBeginInfo.offset = sizeof(int32_t) * node->index;				/*					[POI] Begin conditionally rendered section					If the value from the conditional rendering buffer at the given offset is != 0, the draw commands will be executed				*/				vkCmdBeginConditionalRenderingEXT(commandBuffer, &conditionalRenderingBeginInfo);				vkCmdDrawIndexed(commandBuffer, primitive->indexCount, 1, primitive->firstIndex, 0, 0);				vkCmdEndConditionalRenderingEXT(commandBuffer);			}		};		for (auto child : node->children) {			renderNode(child, commandBuffer);		}	}

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

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