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

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

void CommandBuffer::begin(){    VkCommandBufferBeginInfo commandBufferBeginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO};    if (VK_SUCCESS != vkBeginCommandBuffer(commandBuffer, &commandBufferBeginInfo)) {        throw ERROR_COMMAND;    }}

VkResult CommandBuffers::beginCommandBuffer(const VkCommandBufferUsageFlags flags, const VkRenderPass renderPass, const uint32_t subpass, const VkFramebuffer framebuffer, const VkBool32 occlusionQueryEnable, const VkQueryControlFlags queryFlags, const VkQueryPipelineStatisticFlags pipelineStatistics, const uint32_t bufferIndex) const{	VkCommandBufferInheritanceInfo commandBufferInheritanceInfo;	memset(&commandBufferInheritanceInfo, 0, sizeof(VkCommandBufferInheritanceInfo));	commandBufferInheritanceInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;	commandBufferInheritanceInfo.renderPass = renderPass;	commandBufferInheritanceInfo.subpass = subpass;	commandBufferInheritanceInfo.framebuffer = framebuffer;	commandBufferInheritanceInfo.occlusionQueryEnable = occlusionQueryEnable;	commandBufferInheritanceInfo.queryFlags = queryFlags;	commandBufferInheritanceInfo.pipelineStatistics = pipelineStatistics;    VkCommandBufferBeginInfo commandBufferBeginInfo;    memset(&commandBufferBeginInfo, 0, sizeof(VkCommandBufferBeginInfo));    commandBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;    commandBufferBeginInfo.flags = flags;    commandBufferBeginInfo.pInheritanceInfo = &commandBufferInheritanceInfo;    return vkBeginCommandBuffer(allCommandBuffers[bufferIndex], &commandBufferBeginInfo);}

void VulkanRenderManager::EndSyncFrame(int frame) {	FrameData &frameData = frameData_[frame];	Submit(frame, false);	// This is brutal! Should probably wait for a fence instead, not that it'll matter much since we'll	// still stall everything.	vkDeviceWaitIdle(vulkan_->GetDevice());	// At this point we can resume filling the command buffers for the current frame since	// we know the device is idle - and thus all previously enqueued command buffers have been processed.	// No need to switch to the next frame number.	VkCommandBufferBeginInfo begin{		VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,		nullptr,		VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT	};	VkResult res = vkBeginCommandBuffer(frameData.mainCmd, &begin);	assert(res == VK_SUCCESS);	if (useThread_) {		std::unique_lock<std::mutex> lock(frameData.push_mutex);		frameData.readyForFence = true;		frameData.push_condVar.notify_all();	}}

			void VkContext::BeginDrawBuffer(VkCommandBuffer cmdBuffer, VkImage image) {				VkCommandBufferBeginInfo beginInfo = {};				beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;				beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;				VkImageSubresourceRange subresourceRange = {};				subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;				subresourceRange.baseMipLevel = 0;				subresourceRange.levelCount = 1;				subresourceRange.baseArrayLayer = 0;				subresourceRange.layerCount = 1;				VkImageMemoryBarrier memoryBarrier = {};				memoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;				memoryBarrier.srcAccessMask = 0;				memoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;				memoryBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;				memoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;				memoryBarrier.srcQueueFamilyIndex = queueIndex;				memoryBarrier.dstQueueFamilyIndex = queueIndex;				memoryBarrier.image = image;				memoryBarrier.subresourceRange = subresourceRange;				// Begin command buffer				vkBeginCommandBuffer(cmdBuffer, &beginInfo);				// Change image layout to transfer dst optimal				vkCmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &memoryBarrier);			}

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

static void FrameRender(ImGui_ImplVulkanH_WindowData* wd){	VkResult err;	VkSemaphore& image_acquired_semaphore  = wd->Frames[wd->FrameIndex].ImageAcquiredSemaphore;	err = vkAcquireNextImageKHR(g_Device, wd->Swapchain, UINT64_MAX, image_acquired_semaphore, VK_NULL_HANDLE, &wd->FrameIndex);	check_vk_result(err);    ImGui_ImplVulkanH_FrameData* fd = &wd->Frames[wd->FrameIndex];    {		err = vkWaitForFences(g_Device, 1, &fd->Fence, VK_TRUE, UINT64_MAX);	// wait indefinitely instead of periodically checking        check_vk_result(err);		err = vkResetFences(g_Device, 1, &fd->Fence);        check_vk_result(err);    }    {        err = vkResetCommandPool(g_Device, fd->CommandPool, 0);        check_vk_result(err);        VkCommandBufferBeginInfo info = {};        info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;        info.flags |= VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;        err = vkBeginCommandBuffer(fd->CommandBuffer, &info);        check_vk_result(err);    }    {        VkRenderPassBeginInfo info = {};        info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;        info.renderPass = wd->RenderPass;		info.framebuffer = wd->Framebuffer[wd->FrameIndex];        info.renderArea.extent.width = wd->Width;        info.renderArea.extent.height = wd->Height;        info.clearValueCount = 1;        info.pClearValues = &wd->ClearValue;        vkCmdBeginRenderPass(fd->CommandBuffer, &info, VK_SUBPASS_CONTENTS_INLINE);    }	// Record Imgui Draw Data and draw funcs into command buffer	ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(), fd->CommandBuffer);	// Submit command buffer    vkCmdEndRenderPass(fd->CommandBuffer);    {        VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;        VkSubmitInfo info = {};        info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;        info.waitSemaphoreCount = 1;		info.pWaitSemaphores = &image_acquired_semaphore;        info.pWaitDstStageMask = &wait_stage;        info.commandBufferCount = 1;        info.pCommandBuffers = &fd->CommandBuffer;        info.signalSemaphoreCount = 1;        info.pSignalSemaphores = &fd->RenderCompleteSemaphore;        err = vkEndCommandBuffer(fd->CommandBuffer);        check_vk_result(err);        err = vkQueueSubmit(g_Queue, 1, &info, fd->Fence);        check_vk_result(err);    }}

void 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 VulkanBase::submitPostPresentBarrier(VkImage image) {	VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();	vkTools::checkResult(vkBeginCommandBuffer(postPresentCmdBuffer, &cmdBufInfo));	VkImageMemoryBarrier postPresentBarrier = vkTools::initializers::imageMemoryBarrier();	postPresentBarrier.srcAccessMask = 0;	postPresentBarrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;	postPresentBarrier.oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;	postPresentBarrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;	postPresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;	postPresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;	postPresentBarrier.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };	postPresentBarrier.image = image;	vkCmdPipelineBarrier(		postPresentCmdBuffer,		VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,		VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,		0,		0, nullptr, // No memory barriers,		0, nullptr, // No buffer barriers,		1, &postPresentBarrier);	vkTools::checkResult(vkEndCommandBuffer(postPresentCmdBuffer));	VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();	submitInfo.commandBufferCount = 1;	submitInfo.pCommandBuffers = &postPresentCmdBuffer;	vkTools::checkResult(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));}

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

	void buildCommandBuffers()	{		VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();		VkClearValue clearValues[2];		clearValues[0].color = defaultClearColor;		clearValues[1].depthStencil = { 1.0f, 0 };		VkRenderPassBeginInfo renderPassBeginInfo = vks::initializers::renderPassBeginInfo();		renderPassBeginInfo.renderPass = renderPass;		renderPassBeginInfo.renderArea.offset.x = 0;		renderPassBeginInfo.renderArea.offset.y = 0;		renderPassBeginInfo.renderArea.extent.width = width;		renderPassBeginInfo.renderArea.extent.height = height;		renderPassBeginInfo.clearValueCount = 2;		renderPassBeginInfo.pClearValues = clearValues;		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)		{			// Set target frame buffer			renderPassBeginInfo.framebuffer = frameBuffers[i];			VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);			VkViewport viewport = vks::initializers::viewport((float)width,	(float)height, 0.0f, 1.0f);			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);			VkRect2D scissor = vks::initializers::rect2D(width,	height,	0, 0);			vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);			VkDeviceSize offsets[1] = { 0 };			// Skybox			if (displaySkybox)			{				vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSets.skybox, 0, NULL);				vkCmdBindVertexBuffers(drawCmdBuffers[i], 0, 1, &models.skybox.vertices.buffer, offsets);				vkCmdBindIndexBuffer(drawCmdBuffers[i], models.skybox.indices.buffer, 0, VK_INDEX_TYPE_UINT32);				vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.skybox);				vkCmdDrawIndexed(drawCmdBuffers[i], models.skybox.indexCount, 1, 0, 0, 0);			}			// 3D object			vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSets.object, 0, NULL);			vkCmdBindVertexBuffers(drawCmdBuffers[i], 0, 1, &models.objects[models.objectIndex].vertices.buffer, offsets);			vkCmdBindIndexBuffer(drawCmdBuffers[i], models.objects[models.objectIndex].indices.buffer, 0, VK_INDEX_TYPE_UINT32);			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.reflect);			vkCmdDrawIndexed(drawCmdBuffers[i], models.objects[models.objectIndex].indexCount, 1, 0, 0, 0);			drawUI(drawCmdBuffers[i]);			vkCmdEndRenderPass(drawCmdBuffers[i]);			VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));		}	}

	void buildCommandBuffers()	{		VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();		VkClearValue clearValues[2];		clearValues[0].color = { {0.5f, 0.5f, 0.5f, 0.0f} };		clearValues[1].depthStencil = { 1.0f, 0 };		VkRenderPassBeginInfo renderPassBeginInfo = vkTools::initializers::renderPassBeginInfo();		renderPassBeginInfo.renderPass = renderPass;		renderPassBeginInfo.renderArea.offset.x = 0;		renderPassBeginInfo.renderArea.offset.y = 0;		renderPassBeginInfo.renderArea.extent.width = width;		renderPassBeginInfo.renderArea.extent.height = height;		renderPassBeginInfo.clearValueCount = 2;		renderPassBeginInfo.pClearValues = clearValues;		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)		{			// Set target frame buffer			renderPassBeginInfo.framebuffer = frameBuffers[i];			VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);			VkViewport viewport = vkTools::initializers::viewport(splitScreen ? (float)width / 2.0f : (float)width, (float)height, 0.0f, 1.0f);			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);			VkRect2D scissor = vkTools::initializers::rect2D(width, height, 0, 0);			vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);			vkCmdSetLineWidth(drawCmdBuffers[i], 1.0f);			vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, NULL);			VkDeviceSize offsets[1] = { 0 };			vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &meshes.object.vertices.buf, offsets);			vkCmdBindIndexBuffer(drawCmdBuffers[i], meshes.object.indices.buf, 0, VK_INDEX_TYPE_UINT32);			if (splitScreen)			{				vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);				vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLeft);				vkCmdDrawIndexed(drawCmdBuffers[i], meshes.object.indexCount, 1, 0, 0, 0);				viewport.x = float(width) / 2;			}			vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);			vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineRight);			vkCmdDrawIndexed(drawCmdBuffers[i], meshes.object.indexCount, 1, 0, 0, 0);			vkCmdEndRenderPass(drawCmdBuffers[i]);			VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));		}	}

void 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 beginCommandBuffer( VkCommandBuffer cmdBuf ){	VkCommandBufferBeginInfo cmd = {};	cmd.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;	cmd.pNext = nullptr;	cmd.flags = 0;	cmd.pInheritanceInfo = 0;	HR( vkBeginCommandBuffer( cmdBuf, &cmd ) );}

	void buildCommandBuffers()	{		VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();		VkClearValue clearValues[2];		clearValues[0].color = defaultClearColor;		clearValues[1].depthStencil = { 1.0f, 0 };		VkRenderPassBeginInfo renderPassBeginInfo = vkTools::initializers::renderPassBeginInfo();		renderPassBeginInfo.renderPass = renderPass;		renderPassBeginInfo.renderArea.offset.x = 0;		renderPassBeginInfo.renderArea.offset.y = 0;		renderPassBeginInfo.renderArea.extent.width = width;		renderPassBeginInfo.renderArea.extent.height = height;		renderPassBeginInfo.clearValueCount = 2;		renderPassBeginInfo.pClearValues = clearValues;		VkResult err;		for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)		{			// Set target frame buffer			renderPassBeginInfo.framebuffer = frameBuffers[i];			err = vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo);			assert(!err);			// The primary command buffer does not contain any rendering commands			// These are stored (and retrieved) from the secondary command buffers			vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);			// Execute secondary command buffers			for (auto& renderThread : renderThreads)			{				// todo : Make sure threads are finished before accessing their command buffers				vkCmdExecuteCommands(drawCmdBuffers[i], 1, &renderThread.cmdBuffers[i]);			}			vkCmdEndRenderPass(drawCmdBuffers[i]);			VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);			vkCmdPipelineBarrier(				drawCmdBuffers[i],				VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,				VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,				VK_FLAGS_NONE,				0, nullptr,				0, nullptr,				1, &prePresentBarrier);			err = vkEndCommandBuffer(drawCmdBuffers[i]);			assert(!err);		}	}

static void vulkan_raster_font_flush(vulkan_raster_t *font){   const struct vk_draw_triangles call = {      font->vk->pipelines.font,      &font->texture_optimal,      font->vk->samplers.mipmap_linear,      &font->vk->mvp,      sizeof(font->vk->mvp),      &font->range,      font->vertices,   };   if(font->needs_update)   {      VkCommandBuffer staging;      VkSubmitInfo submit_info             = { VK_STRUCTURE_TYPE_SUBMIT_INFO };      VkCommandBufferAllocateInfo cmd_info = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };      VkCommandBufferBeginInfo begin_info  = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };      cmd_info.commandPool        = font->vk->staging_pool;      cmd_info.level              = VK_COMMAND_BUFFER_LEVEL_PRIMARY;      cmd_info.commandBufferCount = 1;      vkAllocateCommandBuffers(font->vk->context->device, &cmd_info, &staging);      begin_info.flags            = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;      vkBeginCommandBuffer(staging, &begin_info);      vulkan_copy_staging_to_dynamic(font->vk, staging,            &font->texture_optimal, &font->texture);      vkEndCommandBuffer(staging);#ifdef HAVE_THREADS      slock_lock(font->vk->context->queue_lock);#endif      submit_info.commandBufferCount = 1;      submit_info.pCommandBuffers    = &staging;      vkQueueSubmit(font->vk->context->queue,            1, &submit_info, VK_NULL_HANDLE);      vkQueueWaitIdle(font->vk->context->queue);#ifdef HAVE_THREADS      slock_unlock(font->vk->context->queue_lock);#endif      vkFreeCommandBuffers(font->vk->context->device,            font->vk->staging_pool, 1, &staging);      font->needs_update = false;   }   vulkan_draw_triangles(font->vk, &call);}

void CommandPool::beginCommandBuffer(std::size_t index) {    assert(index < mCommandBuffers.size());    VkCommandBufferBeginInfo info = {};    info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;    info.pNext = nullptr;    info.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;    info.pInheritanceInfo = nullptr;    vulkanCheckError(vkBeginCommandBuffer(mCommandBuffers[index], &info));}

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

//==============================================================================Error CommandBufferImpl::init(const CommandBufferInitInfo& init){	auto& pool = getGrManagerImpl().getAllocator().getMemoryPool();	m_alloc = StackAllocator<U8>(pool.getAllocationCallback(),		pool.getAllocationCallbackUserData(),		init.m_hints.m_chunkSize,		1.0,		0,		false);	m_flags = init.m_flags;	m_tid = Thread::getCurrentThreadId();	Bool secondLevel = (m_flags & CommandBufferFlag::SECOND_LEVEL)		== CommandBufferFlag::SECOND_LEVEL;	m_handle = getGrManagerImpl().newCommandBuffer(m_tid, secondLevel);	ANKI_ASSERT(m_handle);	// Begin recording	VkCommandBufferInheritanceInfo inheritance = {};	inheritance.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;	if(secondLevel)	{		ANKI_ASSERT(0 && "TODO");	}	VkCommandBufferBeginInfo begin = {};	begin.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;	begin.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;	begin.pInheritanceInfo = &inheritance;	vkBeginCommandBuffer(m_handle, &begin);	// If it's the frame's first command buffer then do the default fb image	// transition	if((m_flags & CommandBufferFlag::FRAME_FIRST)		== CommandBufferFlag::FRAME_FIRST)	{		// Default FB barrier/transition		setImageBarrier(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,			VK_ACCESS_MEMORY_READ_BIT,			VK_IMAGE_LAYOUT_UNDEFINED,			VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,			VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,			VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,			getGrManagerImpl().getDefaultSurfaceImage(				getGrManagerImpl().getFrame() % MAX_FRAMES_IN_FLIGHT),			VkImageSubresourceRange{VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1});	}	return ErrorCode::NONE;}

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

VkCommandBuffer VulkanRenderManager::GetInitCmd() {	int curFrame = vulkan_->GetCurFrame();	FrameData &frameData = frameData_[curFrame];	if (!frameData.hasInitCommands) {		VkCommandBufferBeginInfo begin = {			VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,			nullptr,			VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT		};		VkResult res = vkBeginCommandBuffer(frameData.initCmd, &begin);		assert(res == VK_SUCCESS);		frameData.hasInitCommands = true;	}	return frameData_[curFrame].initCmd;}

		/**		* Allocate a command buffer from the command pool		*		* @param level Level of the new command buffer (primary or secondary)		* @param (Optional) begin If true, recording on the new command buffer will be started (vkBeginCommandBuffer) (Defaults to false)		*		* @return A handle to the allocated command buffer		*/		VkCommandBuffer createCommandBuffer(VkCommandBufferLevel level, bool begin = false)		{			VkCommandBufferAllocateInfo cmdBufAllocateInfo = vkTools::initializers::commandBufferAllocateInfo(commandPool, level, 1);			VkCommandBuffer cmdBuffer;			VK_CHECK_RESULT(vkAllocateCommandBuffers(logicalDevice, &cmdBufAllocateInfo, &cmdBuffer));			// If requested, also start recording for the new command buffer			if (begin)			{				VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();				VK_CHECK_RESULT(vkBeginCommandBuffer(cmdBuffer, &cmdBufInfo));			}			return cmdBuffer;		}

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

VkCommandBuffer Renderer::_BeginSingleTimeCommands(VkCommandPool pool) {	VkCommandBufferAllocateInfo allocate_info {};	allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;	allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;	allocate_info.commandPool = pool;	allocate_info.commandBufferCount = 1;	VkCommandBuffer command_buffer;	ErrorCheck(vkAllocateCommandBuffers(_device, &allocate_info, &command_buffer));	VkCommandBufferBeginInfo begin_info {};	begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;	begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;	ErrorCheck(vkBeginCommandBuffer(command_buffer, &begin_info));	return command_buffer;}