Неожиданное поведение после изменения окна в Вулкане ⇐ Linux

[Anonymous]

У меня вулканский рендерер. Все нравится, чтобы быть, я приобретаю следующее изображение, я записываю и отправляю команды с забором, жду этого забора и делаю присутствие, чем снова. Все работает нормально, прежде чем я начну манипулировать размером окна, чем я получил ошибку с текстом < /p>
Validation Error: [ VUID-vkQueuePresentKHR-pWaitSemaphores-03268 ] | MessageID = 0x251f8f7a
vkQueuePresentKHR(): pPresentInfo->pWaitSemaphores[0] queue (VkQueue 0x55555597adc0) is waiting on semaphore (VkSemaphore 0x30000000003) that has no way to be signaled.
The Vulkan spec states: All elements of the pWaitSemaphores member of pPresentInfo must reference a semaphore signal operation that has been submitted for execution and any semaphore signal operations on which it depends must have also been submitted for execution (https://vulkan.lunarg.com/doc/view/1.4. ... ores-03268)
Objects: 2
[0] VkSemaphore 0x30000000003
[1] VkQueue 0x55555597adc0

Validation Error: [ VUID-VkPresentInfoKHR-pImageIndices-01430 ] | MessageID = 0x48ad24c6
vkQueuePresentKHR(): pPresentInfo->pSwapchains[0] image at index 0 was not acquired from the swapchain.
The Vulkan spec states: Each element of pImageIndices must be the index of a presentable image acquired from the swapchain specified by the corresponding element of the pSwapchains array, and the presented image subresource must be in the VK_IMAGE_LAYOUT_PRESENT_SRC_KHR or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR layout at the time the operation is executed on a VkDevice (https://vulkan.lunarg.com/doc/view/1.4. ... ices-01430)
Objects: 1
[0] VkSwapchainKHR 0x50000000005
< /code>
и программа замораживает из -за тупика. Я использую только один забор и семафор на приложение и один командный буфер. Вот мой код: < /p>

cl->Begin();
cl->SetFramebuffer(m_GraphicsDevice->GetSwapchain()->GetFramebuffer());
cl->End();
m_GraphicsDevice->SubmitCommands(cl);
m_GraphicsDevice->Present();

< /code>
(это из основного цикла) < /p>
void VulkanCommandList::Begin()
{
m_CurrentImage = m_GraphicsDevice->swapchain->AcquireNextImage();

VkCommandBufferBeginInfo beginInfo{};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
beginInfo.flags = 0;

A3D_CHECK_VKRESULT(vkResetCommandBuffer(commandBuffer, 0));
A3D_CHECK_VKRESULT(vkBeginCommandBuffer(commandBuffer, &beginInfo));
}

void VulkanCommandList::End()
{
if (m_CurrentFramebuffer)
{
EndRendering();

m_CurrentFramebuffer = nullptr;
}

A3D_CHECK_VKRESULT(vkEndCommandBuffer(commandBuffer));
}

void VulkanCommandList::BeginRendering()
{
std::vector colorAttachments;
colorAttachments.resize(m_CurrentFramebuffer->frames.size());

for (int i = 0; i < m_CurrentFramebuffer->frames.size(); i++)
{
VkImageMemoryBarrier barrier{};
barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
barrier.image = m_CurrentFramebuffer->frames->image;
barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
barrier.subresourceRange.baseMipLevel = 0;
barrier.subresourceRange.levelCount = 1;
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = 1;
barrier.srcAccessMask = VK_ACCESS_MEMORY_READ_BIT;
barrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;

vkCmdPipelineBarrier(
commandBuffer,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
0,
0, nullptr,
0, nullptr,
1, &barrier);

VkRenderingAttachmentInfo colorAttachment = {};
colorAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
colorAttachment.imageView = m_CurrentFramebuffer->imageViews;
colorAttachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
colorAttachment.clearValue.color = {0.2f, 0.8f, 0.1f, 1.0f};

colorAttachments = colorAttachment;
}

VkRenderingInfo renderingInfo = {};
renderingInfo.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
renderingInfo.renderArea = {{0, 0}, m_CurrentFramebuffer->renderArea };
renderingInfo.layerCount = 1;
renderingInfo.colorAttachmentCount = colorAttachments.size();
renderingInfo.pColorAttachments = colorAttachments.data();

if (m_CurrentFramebuffer->depthStencil)
{
VkImageMemoryBarrier depthBarrier{};
depthBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
depthBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
depthBarrier.newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
depthBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
depthBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
depthBarrier.image = m_CurrentFramebuffer->depthStencil->image;
depthBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
depthBarrier.subresourceRange.baseMipLevel = 0;
depthBarrier.subresourceRange.levelCount = 1;
depthBarrier.subresourceRange.baseArrayLayer = 0;
depthBarrier.subresourceRange.layerCount = 1;
depthBarrier.srcAccessMask = VK_ACCESS_MEMORY_READ_BIT;
depthBarrier.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;

vkCmdPipelineBarrier(
commandBuffer,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
0,
0, nullptr,
0, nullptr,
1, &depthBarrier);

VkRenderingAttachmentInfo depthAttachment = {};
depthAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
depthAttachment.imageView = m_CurrentFramebuffer->depthStencilImageView;
depthAttachment.imageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
depthAttachment.clearValue.depthStencil = {1.0f, 0};

renderingInfo.pDepthAttachment = &depthAttachment;
}

vkCmdBeginRenderingKHR(commandBuffer, &renderingInfo);
}

void VulkanCommandList::EndRendering()
{
vkCmdEndRenderingKHR(commandBuffer);

for (int i = 0; i < m_CurrentFramebuffer->frames.size(); i++)
{
VkImageMemoryBarrier barrier{};
barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
barrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
barrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
barrier.image = m_CurrentFramebuffer->frames->image;
barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
barrier.subresourceRange.baseMipLevel = 0;
barrier.subresourceRange.levelCount = 1;
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = 1;
barrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
barrier.dstAccessMask = 0;

vkCmdPipelineBarrier(
commandBuffer,
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
0,
0, nullptr,
0, nullptr,
1, &barrier
);
}

if (m_CurrentFramebuffer->depthStencil)
{
VkImageMemoryBarrier depthBarrierEnd{};
depthBarrierEnd.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
depthBarrierEnd.oldLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
depthBarrierEnd.newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
depthBarrierEnd.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
depthBarrierEnd.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
depthBarrierEnd.image = m_CurrentFramebuffer->depthStencil->image;
depthBarrierEnd.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
depthBarrierEnd.subresourceRange.baseMipLevel = 0;
depthBarrierEnd.subresourceRange.levelCount = 1;
depthBarrierEnd.subresourceRange.baseArrayLayer = 0;
depthBarrierEnd.subresourceRange.layerCount = 1;
depthBarrierEnd.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
depthBarrierEnd.dstAccessMask = 0;

vkCmdPipelineBarrier(
commandBuffer,
VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
0,
0, nullptr,
0, nullptr,
1, &depthBarrierEnd);
}

m_CurrentFramebuffer = nullptr;
}

< /code>
(это из списка команд) < /p>

void VulkanGraphicsDevice::SubmitCommands(Ref commandList)
{
Ref vcl = std::static_pointer_cast(commandList);

VkPipelineStageFlags waitFlags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;

VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.pNext = nullptr;
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &imageAvailableSemaphore;
submitInfo.pWaitDstStageMask = &waitFlags;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &vcl->commandBuffer;
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &renderFinishedSemaphore;

A3D_CHECK_VKRESULT(vkQueueSubmit(graphicsQueue, 1, &submitInfo, fence));

A3D_CHECK_VKRESULT(vkWaitForFences(device, 1, &fence, VK_TRUE, UINT64_MAX));
A3D_CHECK_VKRESULT(vkResetFences(device, 1, &fence));
}

void VulkanGraphicsDevice::Present()
{
VkPresentInfoKHR presentInfo{};
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;

presentInfo.waitSemaphoreCount = 1;
presentInfo.pWaitSemaphores = &renderFinishedSemaphore;
presentInfo.swapchainCount = 1;
presentInfo.pSwapchains = &swapchain->swapchain;
presentInfo.pImageIndices = &swapchain->currentImageIndex;

A3D_CHECK_VKRESULT(vkQueuePresentKHR(presentQueue, &presentInfo));
}

< /code>
(это от графического устройства) < /p>
Открыть для ваших вопросов. (Я мог бы изменить размер Swapchain на обратном вызове с изменением размера окна, потому что тупик произошел перед этим обратным вызовом) < /p>
Я попытался переустановить Vulkan и поставить Waitdeviceidle до и после каждой функции семафора. Если кто -то нуждается в источнике - https://github.com/tdp-technologies/aero3d/tree/develop


Подробнее здесь: https://stackoverflow.com/questions/796 ... -in-vulkan