void VulkanExampleBase::createCommandBuffers()
{
// Create one command buffer per frame buffer
// in the swap chain
// Command buffers store a reference to the
// frame buffer inside their render pass info
// so for static usage withouth having to rebuild
// them each frame, we use one per frame buffer
drawCmdBuffers.resize(swapChain.imageCount);
VkCommandBufferAllocateInfo cmdBufAllocateInfo =
vkTools::initializers::commandBufferAllocateInfo(
cmdPool,
VK_COMMAND_BUFFER_LEVEL_PRIMARY,
(uint32_t)drawCmdBuffers.size());
VkResult vkRes = vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, drawCmdBuffers.data());
assert(!vkRes);
// Command buffers for submitting present barriers
cmdBufAllocateInfo.commandBufferCount = 1;
// Pre present
vkRes = vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, &prePresentCmdBuffer);
assert(!vkRes);
// Post present
vkRes = vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, &postPresentCmdBuffer);
assert(!vkRes);
}
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!");
}
}
}
VkCommandBuffer CommandBufferFactory::newCommandBuffer(CommandBufferFlag cmdbFlags)
{
ANKI_ASSERT(isCreated());
Bool secondLevel = !!(cmdbFlags & CommandBufferFlag::SECOND_LEVEL);
Bool smallBatch = !!(cmdbFlags & CommandBufferFlag::SMALL_BATCH);
CmdbType& type = m_types[secondLevel][smallBatch];
LockGuard<Mutex> lock(type.m_mtx);
VkCommandBuffer out = VK_NULL_HANDLE;
if(type.m_count > 0)
{
// Recycle
--type.m_count;
out = type.m_cmdbs[type.m_count];
}
else
{
// Create a new one
VkCommandBufferAllocateInfo ci = {};
ci.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
ci.commandPool = m_pool;
ci.level = (secondLevel) ? VK_COMMAND_BUFFER_LEVEL_SECONDARY : VK_COMMAND_BUFFER_LEVEL_PRIMARY;
ci.commandBufferCount = 1;
ANKI_TRACE_INC_COUNTER(VK_CMD_BUFFER_CREATE, 1);
ANKI_VK_CHECKF(vkAllocateCommandBuffers(m_dev, &ci, &out));
}
ANKI_ASSERT(out);
return out;
}
VkCommandBuffer VulkanWrapper::VWFrameCommandBufferAllocator::CreateFrameCommandBuffer(VWGraphicInstance* _graphicInstance, VkCommandBufferLevel _level, uint32_t _threadIndex)
{
// Get the thread command data
CommandDataPerThread& threadCommandData = m_ThreadCommandData[_threadIndex];
// Check if we dont need to create a new command buffer
if (threadCommandData.sCommandPoolAux[m_CurrentFrameMagnitude].sTargetCommandBuffer < threadCommandData.sCommandPoolAux[m_CurrentFrameMagnitude].sValidCommandBuffers.size())
{
uint32_t commandBufferIndex = threadCommandData.sCommandPoolAux[m_CurrentFrameMagnitude].sTargetCommandBuffer;
threadCommandData.sCommandPoolAux[m_CurrentFrameMagnitude].sTargetCommandBuffer++;
return threadCommandData.sCommandPoolAux[m_CurrentFrameMagnitude].sValidCommandBuffers[commandBufferIndex];
}
VkCommandBuffer commandBuffer = {};
VkCommandBufferAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.commandPool = threadCommandData.sCommandPoolAux[m_CurrentFrameMagnitude].sCommandPool;
allocInfo.level = _level;
allocInfo.commandBufferCount = 1;
if (vkAllocateCommandBuffers(_graphicInstance->GetDevice(), &allocInfo, &commandBuffer) != VK_SUCCESS)
{
throw std::runtime_error("failed to allocate command buffers!");
}
// Insert the command buffer into the command buffer array
threadCommandData.sCommandPoolAux[m_CurrentFrameMagnitude].sValidCommandBuffers.push_back(commandBuffer);
threadCommandData.sCommandPoolAux[m_CurrentFrameMagnitude].sTargetCommandBuffer++;
return commandBuffer;
}
bool VkContext::CreateCommandBuffers() {
VkCommandBufferAllocateInfo allocateInfo = {};
allocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocateInfo.pNext = nullptr;
allocateInfo.commandPool = cmdPool;
allocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
// Allocate swapchain draw buffers
allocateInfo.commandBufferCount = (u32)swapchainImages.size();
drawCmdBuffers.resize(swapchainImages.size());
CheckVkResult(vkAllocateCommandBuffers(dev, &allocateInfo, drawCmdBuffers.data()));
// Subresource range for clearing image
VkImageSubresourceRange subresourceRange = {};
subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
subresourceRange.baseMipLevel = 0;
subresourceRange.levelCount = 1;
subresourceRange.baseArrayLayer = 0;
subresourceRange.layerCount = 1;
VkClearColorValue clearColor = { {0.0f, 0.0f, 0.0f, 1.0f} };
// Record the command buffer for every swap chain image
for (u32 i = 0; i < swapchainImages.size(); i++) {
BeginDrawBuffer(drawCmdBuffers[i], swapchainImages[i]);
vkCmdClearColorImage(drawCmdBuffers[i], swapchainImages[i], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearColor, 1, &subresourceRange);
EndDrawBuffer(drawCmdBuffers[i], swapchainImages[i]);
}
return true;
}
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);
}
bool CommandBufferManager::CreateCommandBuffers()
{
VkDevice device = g_vulkan_context->GetDevice();
for (FrameResources& resources : m_frame_resources)
{
resources.init_command_buffer_used = false;
resources.needs_fence_wait = false;
VkCommandBufferAllocateInfo allocate_info = {
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, nullptr, m_command_pool,
VK_COMMAND_BUFFER_LEVEL_PRIMARY, static_cast<uint32_t>(resources.command_buffers.size())};
VkResult res =
vkAllocateCommandBuffers(device, &allocate_info, resources.command_buffers.data());
if (res != VK_SUCCESS)
{
LOG_VULKAN_ERROR(res, "vkAllocateCommandBuffers failed: ");
return false;
}
VkFenceCreateInfo fence_info = {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, nullptr,
VK_FENCE_CREATE_SIGNALED_BIT};
res = vkCreateFence(device, &fence_info, nullptr, &resources.fence);
if (res != VK_SUCCESS)
{
LOG_VULKAN_ERROR(res, "vkCreateFence failed: ");
return false;
}
// TODO: A better way to choose the number of descriptors.
VkDescriptorPoolSize pool_sizes[] = {{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 500000},
{VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 500000},
{VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 16},
{VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1024}};
VkDescriptorPoolCreateInfo pool_create_info = {VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
nullptr,
0,
100000, // tweak this
static_cast<u32>(ArraySize(pool_sizes)),
pool_sizes};
res = vkCreateDescriptorPool(device, &pool_create_info, nullptr, &resources.descriptor_pool);
if (res != VK_SUCCESS)
{
LOG_VULKAN_ERROR(res, "vkCreateDescriptorPool failed: ");
return false;
}
}
// Activate the first command buffer. ActivateCommandBuffer moves forward, so start with the last
m_current_frame = m_frame_resources.size() - 1;
ActivateCommandBuffer();
return true;
}
void VulkanBase::createCommandBuffers() {
drawCmdBuffers.resize(swapChain.imageCount);
VkCommandBufferAllocateInfo cmdBufAllocateInfo =
vkTools::initializers::commandBufferAllocateInfo(
cmdPool,
VK_COMMAND_BUFFER_LEVEL_PRIMARY,
(uint32_t)drawCmdBuffers.size());
vkTools::checkResult(vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, drawCmdBuffers.data()));
// Command buffers for submitting present barriers
cmdBufAllocateInfo.commandBufferCount = 1;
// Pre present
vkTools::checkResult(vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, &prePresentCmdBuffer));
// Post present
vkTools::checkResult(vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, &postPresentCmdBuffer));
}
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);
}
// Create a separate command buffer for compute commands
void createComputeCommandBuffer()
{
VkCommandBufferAllocateInfo cmdBufAllocateInfo =
vkTools::initializers::commandBufferAllocateInfo(
cmdPool,
VK_COMMAND_BUFFER_LEVEL_PRIMARY,
1);
VkResult vkRes = vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, &computeCmdBuffer);
assert(!vkRes);
}
/**
* Reallocate command buffers for the text overlay
* @note Frees the existing command buffers
*/
void reallocateCommandBuffers()
{
vkFreeCommandBuffers(vulkanDevice->logicalDevice, commandPool, static_cast<uint32_t>(cmdBuffers.size()), cmdBuffers.data());
VkCommandBufferAllocateInfo cmdBufAllocateInfo =
vks::initializers::commandBufferAllocateInfo(
commandPool,
VK_COMMAND_BUFFER_LEVEL_PRIMARY,
static_cast<uint32_t>(cmdBuffers.size()));
VK_CHECK_RESULT(vkAllocateCommandBuffers(vulkanDevice->logicalDevice, &cmdBufAllocateInfo, cmdBuffers.data()));
}
bool Tutorial03::AllocateCommandBuffers( VkCommandPool pool, uint32_t count, VkCommandBuffer *command_buffers ) {
VkCommandBufferAllocateInfo command_buffer_allocate_info = {
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType
nullptr, // const void *pNext
pool, // VkCommandPool commandPool
VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level
count // uint32_t bufferCount
};
if( vkAllocateCommandBuffers( GetDevice(), &command_buffer_allocate_info, command_buffers ) != VK_SUCCESS ) {
return false;
}
return true;
}
int sample_main() {
VkResult U_ASSERT_ONLY res;
struct sample_info info = {};
char sample_title[] = "Command Buffer Sample";
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
init_window_size(info, 500, 500);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
init_device(info);
/* VULKAN_KEY_START */
/* Create a command pool to allocate our command buffer from */
VkCommandPoolCreateInfo cmd_pool_info = {};
cmd_pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
cmd_pool_info.pNext = NULL;
cmd_pool_info.queueFamilyIndex = info.graphics_queue_family_index;
cmd_pool_info.flags = 0;
res =
vkCreateCommandPool(info.device, &cmd_pool_info, NULL, &info.cmd_pool);
assert(res == VK_SUCCESS);
/* Create the command buffer from the command pool */
VkCommandBufferAllocateInfo cmd = {};
cmd.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
cmd.pNext = NULL;
cmd.commandPool = info.cmd_pool;
cmd.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
cmd.commandBufferCount = 1;
res = vkAllocateCommandBuffers(info.device, &cmd, &info.cmd);
assert(res == VK_SUCCESS);
/* VULKAN_KEY_END */
VkCommandBuffer cmd_bufs[1] = {info.cmd};
vkFreeCommandBuffers(info.device, info.cmd_pool, 1, cmd_bufs);
vkDestroyCommandPool(info.device, info.cmd_pool, NULL);
destroy_window(info);
destroy_device(info);
destroy_instance(info);
return 0;
}
void CommandBuffer::init(const Device &dev,
const VkCommandBufferAllocateInfo &info) {
VkCommandBuffer cmd;
// Make sure commandPool is set
assert(info.commandPool);
if (EXPECT(vkAllocateCommandBuffers(dev.handle(), &info, &cmd) ==
VK_SUCCESS)) {
Handle::init(cmd);
dev_handle_ = dev.handle();
cmd_pool_ = info.commandPool;
}
}
ICommandBuffersSP VKTS_APIENTRY commandBuffersCreate(const VkDevice device, const VkCommandPool commandPool, const VkCommandBufferLevel level, const uint32_t commandBufferCount)
{
if (!device)
{
return ICommandBuffersSP();
}
VkResult result;
VkCommandBufferAllocateInfo commandBufferAllocateInfo;
memset(&commandBufferAllocateInfo, 0, sizeof(VkCommandBufferAllocateInfo));
commandBufferAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
commandBufferAllocateInfo.commandPool = commandPool;
commandBufferAllocateInfo.level = level;
commandBufferAllocateInfo.commandBufferCount = commandBufferCount;
std::vector<VkCommandBuffer> allCommandBuffers;
VkCommandBuffer dummy;
for (uint32_t i = 0; i < commandBufferCount; i++)
{
allCommandBuffers.push_back(dummy);
}
result = vkAllocateCommandBuffers(device, &commandBufferAllocateInfo, &allCommandBuffers[0]);
if (result != VK_SUCCESS)
{
logPrint(VKTS_LOG_ERROR, "CommandBuffer: Could not create command buffer.");
return ICommandBuffersSP();
}
//
auto newInstance = new CommandBuffers(device, commandPool, level, commandBufferCount, &allCommandBuffers[0]);
if (!newInstance)
{
vkFreeCommandBuffers(device, commandPool, (uint32_t)allCommandBuffers.size(), &allCommandBuffers[0]);
return ICommandBuffersSP();
}
return ICommandBuffersSP(newInstance);
}
VulkanRenderManager::VulkanRenderManager(VulkanContext *vulkan) : vulkan_(vulkan), queueRunner_(vulkan) {
VkSemaphoreCreateInfo semaphoreCreateInfo = { VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO };
semaphoreCreateInfo.flags = 0;
VkResult res = vkCreateSemaphore(vulkan_->GetDevice(), &semaphoreCreateInfo, nullptr, &acquireSemaphore_);
assert(res == VK_SUCCESS);
res = vkCreateSemaphore(vulkan_->GetDevice(), &semaphoreCreateInfo, nullptr, &renderingCompleteSemaphore_);
assert(res == VK_SUCCESS);
for (int i = 0; i < vulkan_->GetInflightFrames(); i++) {
VkCommandPoolCreateInfo cmd_pool_info = { VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
cmd_pool_info.queueFamilyIndex = vulkan_->GetGraphicsQueueFamilyIndex();
cmd_pool_info.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
VkResult res = vkCreateCommandPool(vulkan_->GetDevice(), &cmd_pool_info, nullptr, &frameData_[i].cmdPoolInit);
assert(res == VK_SUCCESS);
res = vkCreateCommandPool(vulkan_->GetDevice(), &cmd_pool_info, nullptr, &frameData_[i].cmdPoolMain);
assert(res == VK_SUCCESS);
VkCommandBufferAllocateInfo cmd_alloc = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
cmd_alloc.commandPool = frameData_[i].cmdPoolInit;
cmd_alloc.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
cmd_alloc.commandBufferCount = 1;
res = vkAllocateCommandBuffers(vulkan_->GetDevice(), &cmd_alloc, &frameData_[i].initCmd);
assert(res == VK_SUCCESS);
cmd_alloc.commandPool = frameData_[i].cmdPoolMain;
res = vkAllocateCommandBuffers(vulkan_->GetDevice(), &cmd_alloc, &frameData_[i].mainCmd);
assert(res == VK_SUCCESS);
frameData_[i].fence = vulkan_->CreateFence(true); // So it can be instantly waited on
}
queueRunner_.CreateDeviceObjects();
// Temporary AMD hack for issue #10097
if (vulkan_->GetPhysicalDeviceProperties().vendorID == VULKAN_VENDOR_AMD) {
useThread_ = false;
}
}
std::size_t CommandPool::allocateCommandBuffer() {
VkCommandBuffer cmd;
VkCommandBufferAllocateInfo info;
info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
info.pNext = nullptr;
info.commandPool = mCommandPool;
info.commandBufferCount = 1;
info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
vulkanCheckError(vkAllocateCommandBuffers(mDevice, &info, &cmd));
mCommandBuffers.emplace_back(cmd);
return mCommandBuffers.size() - 1;
}
/**
* 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;
}
CommandBuffer::CommandBuffer(std::shared_ptr<Device> p_Device, std::shared_ptr<CommandPool> p_CommandPool, bool p_bOneTimeSubmit)
: m_Device(p_Device)
, m_CommandPool(p_CommandPool)
, m_Handle(VK_NULL_HANDLE)
{
VkCommandBufferAllocateInfo l_Info = {};
l_Info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
l_Info.commandPool = m_CommandPool->GetHandle();
l_Info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
l_Info.commandBufferCount = 1;
InitBeginInfo(p_bOneTimeSubmit);
VK_THROW_IF_NOT_SUCCESS(vkAllocateCommandBuffers(m_Device->GetHandle(), &l_Info, &m_Handle), "Failed to allocate primary command buffer");
LOG("Primary command buffer created", "vulkan", Debug);
}
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 CommandBuffer::sharedConstructor()
{
VkCommandPoolCreateInfo commandPoolCreateInfo = {VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO};
commandPoolCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
commandPoolCreateInfo.queueFamilyIndex = this->computeQueueFamily;
if (VK_SUCCESS != vkCreateCommandPool(this->device, &commandPoolCreateInfo, nullptr, &commandPool)) {
throw ERROR_COMMAND;
}
VkCommandBufferAllocateInfo commandBufferAllocateInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO};
commandBufferAllocateInfo.commandBufferCount = 1;
commandBufferAllocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
commandBufferAllocateInfo.commandPool = commandPool;
if (VK_SUCCESS != vkAllocateCommandBuffers(this->device, &commandBufferAllocateInfo, &commandBuffer)) {
throw ERROR_COMMAND;
}
}
void create_swapchain_command_buffers() {
VkResult err;
const VkCommandBufferAllocateInfo command_allocate_info = {
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
NULL,
_vulkan_command_pool,
VK_COMMAND_BUFFER_LEVEL_PRIMARY,
1,
};
for (uint32_t i = 0; i < _swapchain_image_count; i++) {
VkCommandBuffer command_buffer;
err = vkAllocateCommandBuffers(_vulkan_device, &command_allocate_info, &command_buffer);
assert(!err);
_swapchain_command_buffers.push_back(command_buffer);
}
}
VkCommandBuffer VkApp::beginSingleTimeCommands(){
VkCommandBufferAllocateInfo allocInfo = {};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandPool = commandPool;
allocInfo.commandBufferCount = 1;
VkCommandBuffer commandBuffer;
vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer);
VkCommandBufferBeginInfo beginInfo = {};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
vkBeginCommandBuffer(commandBuffer, &beginInfo);
return commandBuffer;
}
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;
}
VkCommandBuffer
VKDevice::allocate_cmd_buffer (VkCommandPool pool)
{
XCAM_ASSERT (XCAM_IS_VALID_VK_ID (_dev_id));
XCAM_ASSERT (XCAM_IS_VALID_VK_ID (pool));
VkCommandBufferAllocateInfo allocate_info = {};
allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocate_info.commandPool = pool;
allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocate_info.commandBufferCount = 1;
VkCommandBuffer buf_id = VK_NULL_HANDLE;
XCAM_VK_CHECK_RETURN (
ERROR, vkAllocateCommandBuffers (_dev_id, &allocate_info, &buf_id),
VK_NULL_HANDLE, "VKDevice create command buffers failed.");
return buf_id;
}
void VulkanBase::createSetupCommandBuffer() {
if (setupCmdBuffer != VK_NULL_HANDLE){
vkFreeCommandBuffers(device, cmdPool, 1, &setupCmdBuffer);
setupCmdBuffer = VK_NULL_HANDLE; // todo : check if still necessary
}
VkCommandBufferAllocateInfo cmdBufAllocateInfo =
vkTools::initializers::commandBufferAllocateInfo(
cmdPool,
VK_COMMAND_BUFFER_LEVEL_PRIMARY,
1);
vkTools::checkResult(vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, &setupCmdBuffer));
VkCommandBufferBeginInfo cmdBufInfo = {};
cmdBufInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
vkTools::checkResult(vkBeginCommandBuffer(setupCmdBuffer, &cmdBufInfo));
}
VkCommandBuffer getCommandBuffer(bool begin)
{
VkCommandBuffer cmdBuffer;
VkCommandBufferAllocateInfo cmdBufAllocateInfo = {};
cmdBufAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
cmdBufAllocateInfo.commandPool = cmdPool;
cmdBufAllocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
cmdBufAllocateInfo.commandBufferCount = 1;
VK_CHECK_RESULT(vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, &cmdBuffer));
if (begin)
{
VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();
VK_CHECK_RESULT(vkBeginCommandBuffer(cmdBuffer, &cmdBufInfo));
}
return cmdBuffer;
}
void VkeDrawCall::initCommandPool(){
VulkanDC *dc = VulkanDC::Get();
VulkanDC::Device *device = dc->getDefaultDevice();
VkCommandPoolCreateInfo cmdPoolInfo = { VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
cmdPoolInfo.queueFamilyIndex = 0;
cmdPoolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
VKA_CHECK_ERROR(vkCreateCommandPool(device->getVKDevice(), &cmdPoolInfo, NULL, &m_command_pool), "Could not create command pool.\n");
VkCommandBufferAllocateInfo cmdBufInfo = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
cmdBufInfo.commandBufferCount = 2;
cmdBufInfo.level = VK_COMMAND_BUFFER_LEVEL_SECONDARY;
cmdBufInfo.commandPool = m_command_pool;
VKA_CHECK_ERROR(vkAllocateCommandBuffers(device->getVKDevice(), &cmdBufInfo, m_draw_command), "Could not allocate secondary command buffers.\n");
}
VkCommandBuffer VulkanExampleBase::createCommandBuffer(VkCommandBufferLevel level, bool begin)
{
VkCommandBuffer cmdBuffer;
VkCommandBufferAllocateInfo cmdBufAllocateInfo =
vkTools::initializers::commandBufferAllocateInfo(
cmdPool,
level,
1);
vkTools::checkResult(vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, &cmdBuffer));
// If requested, also start the new command buffer
if (begin)
{
VkCommandBufferBeginInfo cmdBufInfo = vkTools::initializers::commandBufferBeginInfo();
vkTools::checkResult(vkBeginCommandBuffer(cmdBuffer, &cmdBufInfo));
}
return cmdBuffer;
}
gboolean
gst_vulkan_device_create_cmd_buffer (GstVulkanDevice * device,
VkCommandBuffer * cmd, GError ** error)
{
VkResult err;
VkCommandBufferAllocateInfo cmd_info = { 0, };
cmd_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
cmd_info.pNext = NULL;
cmd_info.commandPool = device->cmd_pool;
cmd_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
cmd_info.commandBufferCount = 1;
err = vkAllocateCommandBuffers (device->device, &cmd_info, cmd);
if (gst_vulkan_error_to_g_error (err, error, "vkCreateCommandBuffer") < 0)
return FALSE;
GST_LOG_OBJECT (device, "created cmd buffer %p", cmd);
return TRUE;
}
