Vulkan验证错误：前两帧交换链图像布局不符合要求

问题概况 #

• 基于Vulkan-Hpp RAII实现渲染逻辑，仅保留渲染通道部分，跳过图形管线基础章节，目标是实现交换链图像清色呈现
• 功能正常，但前两帧触发验证错误，提示呈现的图像布局为VK_IMAGE_LAYOUT_UNDEFINED，不符合VK_IMAGE_LAYOUT_PRESENT_SRC_KHR或VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR要求
• 使用device.waitIdle()替代信号量/栅栏做同步，交换链含3张图像，但仅前两帧报错
• presentKHR返回Success，关闭验证层后前两帧显示正常

错误信息 #

Validation Error: [ VUID-VkPresentInfoKHR-pImageIndices-01296 ] Object 0: handle = 0x1f5d50ee1e0, type = VK_OBJECT_TYPE_QUEUE; | MessageID = 0xc7aabc16 | vkQueuePresentKHR(): pSwapchains[0] images passed to present must be in layout VK_IMAGE_LAYOUT_PRESENT_SRC_KHR or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR but is in VK_IMAGE_LAYOUT_UNDEFINED. 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 layout at the time the operation is executed on a VkDevice

初始化代码 #

// 交换链创建后
auto images = m_swapchain.getImages();

for (auto& image : images) {
    m_images.emplace(image, createImageView(image));
}

m_renderPass = createRenderPass();

m_frameBuffers.reserve(m_images.size());

for (auto& [image, imageView] : m_images) {
    m_frameBuffers.push_back(createFrameBuffer(imageView));
}

auto [result, imageIndex] = m_swapchain.acquireNextImage(
            std::numeric_limits<uint64_t>().max(),
            *m_imageAvailableSemaphore
        );
// 按规范要求必须使用信号量或栅栏
m_imageIndex = imageIndex;


// 辅助函数
vk::raii::ImageView Swapchain::createImageView(const vk::Image& image) const {
    try {
        return m_context.getDevice().createImageView(
            vk::ImageViewCreateInfo{
                .flags            = {},
                .image            = image,
                .viewType         = vk::ImageViewType::e2D,
                .format           = m_surfaceFormat.format,
                .components       = vk::ComponentMapping{
                    .r = vk::ComponentSwizzle::eIdentity,
                    .g = vk::ComponentSwizzle::eIdentity,
                    .b = vk::ComponentSwizzle::eIdentity,
                    .a = vk::ComponentSwizzle::eIdentity
                },
                .subresourceRange = vk::ImageSubresourceRange{
                    .aspectMask     = vk::ImageAspectFlagBits::eColor,
                    .baseMipLevel   = 0,
                    .levelCount     = 1,
                    .baseArrayLayer = 0,
                    .layerCount     = 1
                }
            }
        );
    }
    catch (const std::exception& e) {
        // 错误处理
    }
}

vk::raii::RenderPass Swapchain::createRenderPass() const {
    auto attachments = std::array{
        vk::AttachmentDescription{
            .flags          = {},
            .format         = m_surfaceFormat.format,
            .samples        = vk::SampleCountFlagBits::e1,
            .loadOp         = vk::AttachmentLoadOp::eClear,
            .storeOp        = vk::AttachmentStoreOp::eStore,
            .stencilLoadOp  = vk::AttachmentLoadOp::eDontCare,
            .stencilStoreOp = vk::AttachmentStoreOp::eDontCare,
            .initialLayout  = vk::ImageLayout::eUndefined,
            .finalLayout    = vk::ImageLayout::ePresentSrcKHR
        }
    };

    auto attachmentReferences = std::array{
        vk::AttachmentReference{
            .attachment = 0,
            .layout     = vk::ImageLayout::eColorAttachmentOptimal
        }
    };

    auto subpasses = std::array{
        vk::SubpassDescription{
            .flags                   = {},
            .pipelineBindPoint       = vk::PipelineBindPoint::eGraphics,
            .inputAttachmentCount    = 0,
            .pInputAttachments       = nullptr,
            .colorAttachmentCount    = static_cast<uint32_t>(attachmentReferences.size()),
            .pColorAttachments       = attachmentReferences.data(),
            .pResolveAttachments     = nullptr,
            .pDepthStencilAttachment = nullptr,
            .preserveAttachmentCount = 0,
            .pPreserveAttachments    = nullptr
        }
    };

    try {
        return m_context.getDevice().createRenderPass(
            vk::RenderPassCreateInfo{
                .flags           = {},
                .attachmentCount = static_cast<uint32_t>(attachments.size()),
                .pAttachments    = attachments.data(),
                .subpassCount    = static_cast<uint32_t>(subpasses.size()),
                .pSubpasses      = subpasses.data(),
                .dependencyCount = 0,
                .pDependencies   = nullptr
            }
        );
    }
    catch (const std::exception& e) {
        // 错误处理
    }
}

vk::raii::Framebuffer Swapchain::createFrameBuffer(const vk::raii::ImageView& imageView) const {
    try {
        return m_context.getDevice().createFramebuffer(
            vk::FramebufferCreateInfo{
                .flags           = {},
                .renderPass      = *m_renderPass,
                .attachmentCount = 1,
                .pAttachments    = &*imageView,
                .width           = m_imageExtent.width,
                .height          = m_imageExtent.height,
                .layers          = 1
            }
        );
    }
    catch (const std::exception& e) {
        // 错误处理
    }
}

每帧渲染代码 #

// 每帧调用的渲染函数
void Renderer::render() {
    m_context->recordCommands(
        [&]() {
            m_swapchain->beginRenderPassCommand(0.125f, 0.125f, 0.125f);
            m_swapchain->endRenderPassCommand();
        }
    );

    m_context->submitRecording();

    m_swapchain->swap();
}

void GraphicsContext::recordCommands(const Application::Recording& recording) {
    m_device.waitIdle();

    m_commandBuffer.reset();
    m_commandBuffer.begin(
        vk::CommandBufferBeginInfo{
            .flags            = {},
            .pInheritanceInfo = {}
        }
    );

    recording();

    m_commandBuffer.end();
}

void Swapchain::beginRenderPassCommand(
        float clearColorRed,
        float clearColorGreen,
        float clearColorBlue
) {
    auto clearValues = std::array{
        vk::ClearValue(
            vk::ClearColorValue(
                std::array{
                    clearColorRed,
                    clearColorGreen,
                    clearColorBlue,
                    1.0f
                }
            )
        )
    };

    m_context.getCommandBuffer().beginRenderPass(
        vk::RenderPassBeginInfo{
            .renderPass      = *m_renderPass,
            .framebuffer     = *m_frameBuffers[m_imageIndex],
            .renderArea      = vk::Rect2D{
                .offset = vk::Offset2D{
                    .x = 0,
                    .y = 0
                },
                .extent = m_imageExtent
            },
            .clearValueCount = static_cast<uint32_t>(clearValues.size()),
            .pClearValues    = clearValues.data()
        },
        vk::SubpassContents::eInline
    );
}

void Swapchain::endRenderPassCommand() {
    m_context.getCommandBuffer().endRenderPass();
}

void GraphicsContext::submitRecording() {
    m_device.waitIdle();

    m_graphicsQueue.submit(
        vk::SubmitInfo{
            .waitSemaphoreCount   = 0,
            .pWaitSemaphores      = nullptr,
            .pWaitDstStageMask    = nullptr,
            .commandBufferCount   = 1,
            .pCommandBuffers      = &*m_commandBuffer,
            .signalSemaphoreCount = 0,
            .pSignalSemaphores    = nullptr
        }
    );
}

void Swapchain::swap() {
    m_context.getDevice().waitIdle();

    auto presentResult = m_context.getPresentQueue().presentKHR(
        vk::PresentInfoKHR{
            .waitSemaphoreCount = 0,
            .pWaitSemaphores    = nullptr,
            .swapchainCount     = 1,
            .pSwapchains        = &*m_swapchain,
            .pImageIndices      = &m_imageIndex,
            .pResults           = nullptr
        }
    );

    m_context.getDevice().waitIdle();

    auto [result, imageIndex] = m_swapchain.acquireNextImage(
        std::numeric_limits<uint64_t>().max(),
        *m_imageAvailableSemaphore
    );

    m_imageIndex = imageIndex;
}

问题分析 #

1. 验证层状态追踪逻辑：验证层依赖同步对象（信号量/栅栏）追踪资源状态，而非硬件实际执行状态。即使device.waitIdle()确保命令已执行，但验证层未看到正确的同步依赖，仍会判定图像布局不符合要求。
2. 信号量未正确关联：初始化和每帧acquireNextImage都使用了m_imageAvailableSemaphore，但提交命令时未等待该信号量，验证层无法确认图像已完成从UNDEFINED到PRESENT_SRC_KHR的布局转换。
3. 前两帧报错原因：前两帧的图像是首次被渲染，初始布局为UNDEFINED；第三帧开始，图像已被RenderPass处理为PRESENT_SRC_KHR，验证层不再报错。

解决方案 #

修改命令提交逻辑，关联acquire信号量 #

1. 更新GraphicsContext::submitRecording，添加等待信号量的参数：

void GraphicsContext::submitRecording(vk::Semaphore waitSemaphore) {
    m_device.waitIdle();

    vk::PipelineStageFlags waitStage = vk::PipelineStageFlagBits::eColorAttachmentOutput;
    m_graphicsQueue.submit(
        vk::SubmitInfo{
            .waitSemaphoreCount   = waitSemaphore ? 1 : 0,
            .pWaitSemaphores      = waitSemaphore ? &waitSemaphore : nullptr,
            .pWaitDstStageMask    = waitSemaphore ? &waitStage : nullptr,
            .commandBufferCount   = 1,
            .pCommandBuffers      = &*m_commandBuffer,
            .signalSemaphoreCount = 0,
            .pSignalSemaphores    = nullptr
        }
    );
}

2. 在Renderer::render中调用时传入信号量：

void Renderer::render() {
    m_context->recordCommands(
        [&]() {
            m_swapchain->beginRenderPassCommand(0.125f, 0.125f, 0.125f);
            m_swapchain->endRenderPassCommand();
        }
    );

    // 传入acquire时使用的信号量
    m_context->submitRecording(*m_swapchain->getImageAvailableSemaphore());

    m_swapchain->swap();
}

3. 确保Swapchain类提供获取m_imageAvailableSemaphore的接口：

vk::raii::Semaphore& Swapchain::getImageAvailableSemaphore() {
    return m_imageAvailableSemaphore;
}

补充说明 #

• 即使使用device.waitIdle()，正确关联同步对象仍能让验证层正确追踪资源状态，消除错误提示。
• 该问题并非验证层bug，而是同步依赖未正确声明导致的状态追踪误判。

内容的提问来源于stack exchange，提问作者McFlyboy