Vulkan: динамический рендеринг изображения перехода

Что касается образа цепочки обмена, вы, вероятно, не ждете, пока он станет готовым (его получение завершится). Используйте ограждение для ожидания на стороне процессора или используйте семафор с VkSubmitInfo::pWaitSemaphores.

Для изображения глубины: VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT не указывает этап выполнения, если он указан в первой области синхронизации (src_stage). т. е. вы не сообщаете графическому процессору, что его предыдущее использование завершено, а кеши очищены/недействительны.

Вы, вероятно, тоже хотите VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT для src_stage, с соответствующим VkAccessFlagBits.

Настоящий «ответ» на этот вопрос заключается в том, что мне все еще нужно больше изучать синхронизацию. Ничего удивительного.

Однако мне удалось устранить ошибки проверки синхронизации, которые я видел, переместив существующий код на использование расширения sync2. Я использовал новую настройку vkguide.dev в качестве основы и пошел дальше. Сейчас цепочка событий выглядит следующим образом.

Я начинаю запись буфера команд однократной отправки. Затем я перемещаю буфер цвета и буфер глубины и начинаю рендеринг.

void vkColorDepth::begin() {
    auto &color_buffer = *Renderer::swapchain().images()[Renderer::image_index()];
    color_buffer.transition_layout(Renderer::cmd_buffer(),
                                   vk::ImageLayout::eUndefined,
                                   vk::ImageLayout::eColorAttachmentOptimal);

    _depth_buffer.transition_layout(Renderer::cmd_buffer(),
                                    vk::ImageLayout::eUndefined,
                                    vk::ImageLayout::eDepthAttachmentOptimal);

    vk::Rect2D const render_area = {
        .offset { .x = 0u, .y = 0u },
        .extent {
            .width  = Renderer::swapchain().size().width,
            .height = Renderer::swapchain().size().height,
        },
    };

    Renderer::cmd_buffer().begin_rendering(
        vk::RenderingInfoKHR {
            .pNext                = nullptr,
            .flags                = { },
            .renderArea           = render_area,
            .layerCount           = 1u,
            .viewMask             = 0u,
            .colorAttachmentCount = 1u,
            .pColorAttachments    = &_color_attachments[Renderer::image_index()],
            .pDepthAttachment     = &_depth_attachment,
            .pStencilAttachment   = nullptr,
        }
    );
}

Команды записываются, затем я снова перемещаю буфер цвета:

void vkColorDepth::end() {
    Renderer::cmd_buffer().end_rendering();

    auto &color_buffer = *Renderer::swapchain().images()[Renderer::image_index()];
    color_buffer.transition_layout(Renderer::cmd_buffer(),
                                   vk::ImageLayout::eColorAttachmentOptimal,
                                   vk::ImageLayout::ePresentSrcKHR);
}

И, наконец, команды отправляются:

void Renderer::_submit_commands() {
    auto const &frame_sync = _frame_sync[_image_index];

    auto const cmd_submit_info = vk::CommandBufferSubmitInfo {
        .pNext = nullptr,
        .commandBuffer = frame_sync.cmd_buffer().native(),
        .deviceMask = { },
    };

    auto const wait_info = vk::SemaphoreSubmitInfoKHR {
        .pNext = nullptr,
        .semaphore = frame_sync.present_semaphore(),
        .value = { },
        .stageMask = vk::PipelineStageFlagBits2KHR::eColorAttachmentOutput,
        .deviceIndex = { },
    };

    auto const signal_info = vk::SemaphoreSubmitInfoKHR {
        .pNext = nullptr,
        .semaphore = frame_sync.queue_semaphore(),
        .value = { },
        .stageMask = vk::PipelineStageFlagBits2KHR::eAllGraphics,
        .deviceIndex = { },
    };

    auto const queue_submit_info = vk::SubmitInfo2KHR {
      .pNext = nullptr,
      .flags = { },
      .waitSemaphoreInfoCount = 1u,
      .pWaitSemaphoreInfos = &wait_info,
      .commandBufferInfoCount = 1u,
      .pCommandBufferInfos = &cmd_submit_info,
      .signalSemaphoreInfoCount = 1u,
      .pSignalSemaphoreInfos = &signal_info,
    };

    auto const result = _device.graphics_queue().native().submit2KHR(
        1u,
        &queue_submit_info,
        frame_sync.queue_fence()
    );

    if (result != vk::Result::eSuccess) {
        BTX_CRITICAL("Failed to submit commands to device queue: '{}'",
                     vk::to_string(result));
    }
}

Теперь вот как выглядит код перехода изображения цепочки обмена:

void vkSwapchainImage::transition_layout(vkCmdBuffer const &cmd_buffer,
                                         vk::ImageLayout const old_layout,
                                         vk::ImageLayout const new_layout)
{
    // BTX_TRACE("Swapchain image {}: '{:s}'->'{:s}'",
    //           _handle,
    //           vk::to_string(old_layout),
    //           vk::to_string(new_layout));

    vk::ImageMemoryBarrier2KHR barrier {
        .pNext = nullptr,
        .srcStageMask  = vk::PipelineStageFlagBits2KHR::eAllCommands,
        .srcAccessMask = vk::AccessFlagBits2KHR::eMemoryWrite,
        .dstStageMask  = vk::PipelineStageFlagBits2KHR::eAllCommands,
        .dstAccessMask = vk::AccessFlagBits2KHR::eMemoryRead
                         | vk::AccessFlagBits2KHR::eMemoryWrite,
        .oldLayout = old_layout,
        .newLayout = new_layout,
        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .image = _handle,
        .subresourceRange {
            .aspectMask     = vk::ImageAspectFlagBits::eColor,
            .baseMipLevel   = 0u,
            .levelCount     = VK_REMAINING_MIP_LEVELS,
            .baseArrayLayer = 0u,
            .layerCount     = VK_REMAINING_ARRAY_LAYERS,
        }
    };

    if (old_layout == vk::ImageLayout::eUndefined) {
        if (new_layout == vk::ImageLayout::eColorAttachmentOptimal) {
            barrier.srcAccessMask = vk::AccessFlagBits2KHR::eColorAttachmentRead
                                    | vk::AccessFlagBits2KHR::eColorAttachmentWrite;
            barrier.dstAccessMask = vk::AccessFlagBits2KHR::eColorAttachmentRead
                                    | vk::AccessFlagBits2KHR::eColorAttachmentWrite;
        }
        else {
            BTX_CRITICAL("Image {}: unsupported swapchain image layout "
                         "transition: '{:s}'->'{:s}'",
                         _handle,
                         vk::to_string(old_layout),
                         vk::to_string(new_layout));
            return;
        }
    }
    else if (old_layout == vk::ImageLayout::eColorAttachmentOptimal) {
        if (new_layout == vk::ImageLayout::ePresentSrcKHR) {
            barrier.srcAccessMask = vk::AccessFlagBits2KHR::eColorAttachmentRead
                                    | vk::AccessFlagBits2KHR::eColorAttachmentWrite;
            barrier.dstAccessMask = { };
        }
        else {
            BTX_CRITICAL("Image {}: unsupported swapchain image layout "
                         "transition: '{:s}'->'{:s}'",
                         _handle,
                         vk::to_string(old_layout),
                         vk::to_string(new_layout));
            return;
        }
    }
    else {
        BTX_CRITICAL("Image {}: unsupported swapchain image layout transition: "
                     "'{:s}'->'{:s}'",
                     _handle,
                     vk::to_string(old_layout),
                     vk::to_string(new_layout));
        return;
    }

    auto dep_info = vk::DependencyInfoKHR {
        .pNext = nullptr,
        .dependencyFlags = { },
        .memoryBarrierCount = { },
        .pMemoryBarriers = { },
        .bufferMemoryBarrierCount = { },
        .pBufferMemoryBarriers = { },
        .imageMemoryBarrierCount = 1u,
        .pImageMemoryBarriers = &barrier,
    };

    cmd_buffer.native().pipelineBarrier2KHR(dep_info);
}

Я пропущу публикацию кода перехода к буферу глубины, потому что структурно он практически такой же.

Удивительно полезным в этом упражнении было то, что предупреждения проверки sync2 намного более информативны, чем предупреждения sync1. Помимо полного игнорирования предупреждения об использовании маски этапа ALL_COMMANDS, я фактически смог перейти от одного предупреждения к другому после первоначальной настройки использования подхода vkguide.dev «кувалда» для синхронизации перехода макета.

Мне все еще приходится работать над этим, чтобы получить некоторое понимание, а не копировать/вставлять/следовать подсказкам, которые я делал до сих пор, но приятно иметь для этого проверенный трамплин.