《OGRE 3D 渲染引擎原理与架构》11.2 交换链

交换链是窗口双缓冲呈现的抽象:Vulkan 后端用真正的 VkSwapchainKHR 对象与 SwapchainStatus 状态机管理多张图像,D3D11 用 DXGI 交换链并区分 flip/discard 模式,GL 则在窗口层直接 glXSwapBuffers。lab 复现交换链创建、取图轮转、OUT_OF_DATE 重建与 MSAA resolve 后 Present。

11.2 交换链

上一节讲了 RenderTarget 这个统一抽象:update(bool swap) 末尾可选地调用 swapBuffers(),基类里它是空实现。这一节看三个后端各自怎么实现真正的「交换」——Vulkan 用实打实的 VkSwapchainKHR 对象,D3D11 用 DXGI 交换链,GL 则把交换下放到窗口系统的 glXSwapBuffers。这就是交换链:一组轮转的后台缓冲,一帧画完把「正在显示」的前台与「刚画完」的后台交换,避免撕裂。

本章与站内既有内容的分工

helio 四卷在 Vulkan/Metal 章节分别实现过平台 swapchain,但 OGRE 的价值在于它把「交换链状态机」「缓冲轮转」「VSync 呈现模式」作为可独立分析的机制。这节用三个后端对照,聚焦交换链本身的结构与生命周期,不重复 11.1 的目标抽象。

Vulkan:真正的 Swapchain 对象

VulkanWindow(RenderSystems/Vulkan/include/OgreVulkanWindow.h)把交换链做成一个显式的状态机。SwapchainStatus 枚举描述了交换链的完整生命周期:

// RenderSystems/Vulkan/include/OgreVulkanWindow.h:SwapchainStatus(v14.6.3 源码摘录)
        enum SwapchainStatus
        {
            /// We already called VulkanWindow::acquireNextImage.
            ///
            /// Can only go into this state if we're coming from SwapchainReleased
            SwapchainAcquired,
            /// We already called VulkanWindow::getImageAcquiredSemaphore.
            /// Further calls to getImageAcquiredSemaphore will return null.
            /// Ogre is rendering or intends to into this swapchain.
            ///
            /// Can only go into this state if we're coming from SwapchainAcquired
            SwapchainUsedInRendering,
            /// We've come from SwapchainUsedInRendering and are waiting for
            /// VulkanDevice::commitAndNextCommandBuffer to present us
            SwapchainPendingSwap,
            /// We don't own a swapchain. Ogre cannot render to this window.
            ///
            /// This status should not last long unless we're not initialized yet.
            SwapchainReleased
        };

状态迁移是一条直线:Released → Acquired → UsedInRendering → PendingSwap → Released。Acquired 是「已拿到一张图像但还没开始画」,UsedInRendering 是「正在往里画」,PendingSwap 是「画完排队等待呈现」。窗口持有与之配套的资源集合:

// RenderSystems/Vulkan/include/OgreVulkanWindow.h:交换链资源(v14.6.3 源码摘录,已删减)
        VkSurfaceKHR mSurfaceKHR;
        VkSwapchainKHR mSwapchain;
        std::vector<VkImage> mSwapchainImages;
        std::vector<VkImageView> mSwapchainImageViews;
        ...
        std::vector<VkSemaphore> mImageReadySemaphores;
        std::vector<VkSemaphore> mRenderFinishedSemaphores;
        std::vector<VkFence> mImageFences;
        int mCurrentSemaphoreIndex;
        SwapchainStatus mSwapchainStatus;

mSwapchainImages 就是物理缓冲,mSwapchainImageViews 让它们可作渲染目标,每个图像配一对信号量(mImageReadySemaphores/mRenderFinishedSemaphores)与一个围栏。创建时按「请求至少 minImageCount + 1 张」尝试三重缓冲,并受 maxImageCount 约束:

// RenderSystems/Vulkan/src/OgreVulkanWindow.cpp:createSwapchain(v14.6.3 源码摘录,已删减)
        // FIFO is guaranteed to be present
        VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;

        if (!mVSync &&
            std::find(presentModes.begin(), presentModes.end(), VK_PRESENT_MODE_IMMEDIATE_KHR) != presentModes.end())
        {
            presentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
        }
        ...
        // try to get triple buffering by default
        // https://github.com/KhronosGroup/Vulkan-Samples/blob/master/samples/performance/swapchain_images/swapchain_images_tutorial.md
        auto minImageCount = surfaceCaps.minImageCount + 1;
        if (surfaceCaps.maxImageCount != 0u)
            minImageCount = std::min(minImageCount, surfaceCaps.maxImageCount);

        VkSwapchainCreateInfoKHR swapchainCreateInfo = {VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR};
        swapchainCreateInfo.surface = mSurfaceKHR;
        swapchainCreateInfo.minImageCount = minImageCount;
        swapchainCreateInfo.imageFormat = VulkanMappings::get(mTexture->getFormat());
        swapchainCreateInfo.imageColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
        ...
        swapchainCreateInfo.imageExtent.width = getWidth();
        swapchainCreateInfo.imageExtent.height = getHeight();
        swapchainCreateInfo.imageArrayLayers = 1u;
        swapchainCreateInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
        ...
        swapchainCreateInfo.presentMode = presentMode;

两个值得记的细节:

机制代码目的
presentMode默认 FIFO_KHR,!mVSync 且支持时换 IMMEDIATE_KHRFIFO 是 Vk 保证存在、等同垂直同步的模式;关 VSync 才用立即呈现
图像数量minImageCount + 1,再对 maxImageCount 取 min驱动保证的 min 只够双缓冲,+1 是向三重缓冲努力
surface 尺寸currentExtent != 0xFFFFFFFF 时强制跟随窗口系统MoltenVK 上不匹配会让 vkAcquireNextImageKHR 永远返回 OUT_OF_DATE

每帧开头 acquireNextImage 轮转信号量下标并取下一张图像;如果交换链已过时(窗口尺寸变了等),它就地销毁并重建:

// RenderSystems/Vulkan/src/OgreVulkanWindow.cpp:acquireNextImage(v14.6.3 源码摘录,已删减)
    void VulkanWindow::acquireNextImage( void )
    {
        OGRE_ASSERT_LOW( mSwapchainStatus == SwapchainReleased );

        mCurrentSemaphoreIndex = (mCurrentSemaphoreIndex + 1) % mImageReadySemaphores.size();
        auto semaphore = mImageReadySemaphores[mCurrentSemaphoreIndex];

        uint32 imageIdx = 0u;
        auto res =
            vkAcquireNextImageKHR(mDevice->mDevice, mSwapchain, UINT64_MAX, semaphore, VK_NULL_HANDLE, &imageIdx);

        if (res == VK_ERROR_OUT_OF_DATE_KHR || res == VK_SUBOPTIMAL_KHR)
        {
            mDevice->stall();
            destroySwapchain();
            createSwapchain();
            return;
        }
        ...
        mSwapchainStatus = SwapchainAcquired;
        mTexture->_setCurrentImage( mSwapchainImages[imageIdx], imageIdx );
    }

呈现被拆成两步。swapBuffers() 只把窗口挂进 mWindowsPendingSwap 队列并把状态推到 PendingSwap,真正的 vkQueuePresentKHR 留到 _swapBuffers()(由 VulkanDevice::commitAndNextCommandBuffer 统一提交):

// RenderSystems/Vulkan/src/OgreVulkanWindow.cpp:swapBuffers 与 _swapBuffers(v14.6.3 源码摘录,已删减)
    void VulkanWindow::swapBuffers( void )
    {
        mSwapchainStatus = SwapchainUsedInRendering;
        ...
        mDevice->mGraphicsQueue.mWindowsPendingSwap.push_back( this );
        mSwapchainStatus = SwapchainPendingSwap;

        //endRenderPassDescriptor();
        mDevice->commitAndNextCommandBuffer( SubmissionType::EndFrameAndSwap );
    }
    //-------------------------------------------------------------------------
    void VulkanWindow::_swapBuffers()
    {
        OGRE_ASSERT_LOW( mSwapchainStatus == SwapchainPendingSwap );
        ...
        VkPresentInfoKHR present = {VK_STRUCTURE_TYPE_PRESENT_INFO_KHR};
        present.swapchainCount = 1u;
        present.pSwapchains = &mSwapchain;
        present.pImageIndices = &currentImageIdx;
        present.waitSemaphoreCount = 1u;
        present.pWaitSemaphores = &queueFinishSemaphore;

        VkResult result = vkQueuePresentKHR( mDevice->mPresentQueue, &present );
        ...
        mSwapchainStatus = SwapchainReleased;
    }

present.pWaitSemaphores 让呈现等待渲染队列执行完再上屏,避免把「画一半的帧」呈现出去。

D3D11:DXGI 交换链与 flip 模式

Windows 上的 D3D11 后端把交换链封装成 D3D11RenderWindowSwapChainBased 基类,HWND 窗口(D3D11RenderWindowHwnd)与 WinRT 核心窗口(D3D11RenderWindowCoreWindow)各自实现纯虚的 _createSwapChainImpl:

// RenderSystems/Direct3D11/include/OgreD3D11RenderWindow.h:交换链基类(v14.6.3 教学示意,参照上游同名实现,已删减)
    class _OgreD3D11Export D3D11RenderWindowSwapChainBased
        : public D3D11RenderWindowBase
    {
    public:
        ...
        IDXGISwapChainN* _getSwapChain()                        { return mpSwapChain.Get(); }
        DXGI_SWAP_CHAIN_DESC_N* _getSwapChainDescription(void)  { return &mSwapChainDesc; }
        ...
        void swapBuffers();
        ...
    protected:
        DXGI_FORMAT _getSwapChainFormat()                       { return D3D11Mappings::_getGammaFormat(_getBasicFormat(), isHardwareGammaEnabled() && !mUseFlipMode); }
        void _createSwapChain();
        virtual HRESULT _createSwapChainImpl(IDXGIDeviceN* pDXGIDevice) = 0;
        void _destroySwapChain();
        void _resizeSwapChainBuffers(unsigned width, unsigned height);
        ...
    protected:
        // Pointer to swap chain
        ComPtr<IDXGISwapChainN> mpSwapChain;
        DXGI_SWAP_CHAIN_DESC_N  mSwapChainDesc;
        ...
        bool                    mUseFlipMode;                   // 是否启用 flip 呈现模型(Win8+)
        bool                    mVSync;                         // flip 模式下假定为 true

mUseFlipMode 是 DXGI 的关键分支:flip 呈现模型(DXGI_SWAP_EFFECT_FLIP_DISCARD/FLIP_SEQUENTIAL)只在 Win8+ 可用、WinRT 必须用,且交换链本身不做 MSAA。_createSwapChainImpl 里两套配置差异明显:

// RenderSystems/Direct3D11/src/OgreD3D11RenderWindow.cpp:_createSwapChainImpl(v14.6.3 源码摘录,已删减)
        ZeroMemory(&mSwapChainDesc, sizeof(DXGI_SWAP_CHAIN_DESC_N));
        mSwapChainDesc.BufferDesc.Width = mWidth;
        mSwapChainDesc.BufferDesc.Height = mHeight;
        mSwapChainDesc.BufferDesc.Format = _getSwapChainFormat();
        ...
        if(mUseFlipMode)
        {
            mSwapChainDesc.SampleDesc.Count = 1;
            mSwapChainDesc.SampleDesc.Quality = 0;
            mSwapChainDesc.BufferCount = 2;
            ...
        }
        else
        {
            assert(!mUseFlipMode);
            mSwapChainDesc.SampleDesc.Count = mFSAAType.Count;
            mSwapChainDesc.SampleDesc.Quality = mFSAAType.Quality;
            mSwapChainDesc.BufferCount = 1;
            mSwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
        }

        mSwapChainDesc.BufferUsage          = DXGI_USAGE_RENDER_TARGET_OUTPUT;
        mSwapChainDesc.OutputWindow         = mHWnd;
        mSwapChainDesc.Windowed             = !mIsFullScreen;
        mSwapChainDesc.Flags                = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
字段flip 模式discard 模式
BufferCount21
SampleDesc1×1(交换链不支持 MSAA)来自 mFSAAType
SwapEffectFLIP_DISCARD/FLIP_SEQUENTIALDISCARD

swapBuffers() 里因此多了一步:flip + MSAA 时由应用先把多重采样后台缓冲 resolve 到交换链的 1×1 后台缓冲,再 Present:

// RenderSystems/Direct3D11/src/OgreD3D11RenderWindow.cpp:swapBuffers(v14.6.3 源码摘录,已删减)
    void D3D11RenderWindowSwapChainBased::swapBuffers( )
    {
        ...
        if( !mDevice.isNull() )
        {
            // Step of resolving MSAA resource for swap chains in FlipSequentialMode should be done by application rather than by OS.
            if(mUseFlipMode && mFSAAType.Count > 1)
            {
                ComPtr<ID3D11Texture2D> swapChainBackBuffer;
                HRESULT hr = mpSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)swapChainBackBuffer.ReleaseAndGetAddressOf());
                ...
                mDevice.GetImmediateContext()->ResolveSubresource(swapChainBackBuffer.Get(), 0, mpBackBuffer.Get(), 0, _getRenderFormat());
                ...
            }

            // flip presentation model swap chains have another semantic for first parameter
            UINT syncInterval = mUseFlipMode ? std::max(1U, mVSyncInterval) : (mVSync ? mVSyncInterval : 0);
            HRESULT hr = mpSwapChain->Present(syncInterval, 0);
            ...
        }
    }

syncInterval 是 VSync 间隔:flip 模式下强制至少 1(flip 模型没有「关 VSync」语义),discard 模式按 mVSync 决定。窗口尺寸变化时 _resizeSwapChainBuffers 调用 mpSwapChain->ResizeBuffers(...) 重配后台缓冲——真正的交换链是随窗口变形的:

// RenderSystems/Direct3D11/src/OgreD3D11RenderWindow.cpp:_resizeSwapChainBuffers(v14.6.3 源码摘录,已删减)
        // width and height can be zero to autodetect size, therefore do not rely on them
        HRESULT hr = mpSwapChain->ResizeBuffers(mSwapChainDesc.BufferCount, width, height, _getSwapChainFormat(), 0);
        if(hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET)
        {
            rsys->handleDeviceLost();
            // Everything is set up now. Do not continue execution of this method. HandleDeviceLost will reenter this method 
            // and correctly set up the new device.
            return;
        }

GL:把交换留给窗口系统

GL 后端没有独立的交换链对象:窗口的交换直接走平台上下文。X11 下 GLXWindow::swapBuffers 一行就完成:

// RenderSystems/GLSupport/src/GLX/OgreGLXWindow.cpp:swapBuffers(v14.6.3 源码摘录)
    void GLXWindow::swapBuffers()
    {
        if (mClosed || mIsExternalGLControl)
            return;

        glXSwapBuffers(mGLSupport->getGLDisplay(), static_cast<GLXContext*>(mContext)->mDrawable);
    }

mIsExternalGLControl 表示窗口被外部接管(比如嵌入别的 GL 应用),这时 OGRE 不做交换。GL 渲染目标纹理的「交换」则是另一回事——GL3PlusFrameBufferObject::swapBuffers() 把多重采样缓冲 blit 到最终缓冲,触发一次 MSAA resolve,逻辑与 D3D11 flip 模式的做法等价:

// RenderSystems/GL3Plus/src/OgreGL3PlusFrameBufferObject.cpp:swapBuffers(v14.6.3 源码摘录,已删减)
    void GL3PlusFrameBufferObject::swapBuffers()
    {
        if (mMultisampleFB)
        {
            auto rs = static_cast<GL3PlusRenderSystem*>(Root::getSingleton().getRenderSystem());
            GLint oldfb = 0;
            OGRE_CHECK_GL_ERROR(glGetIntegerv(GL_FRAMEBUFFER_BINDING, &oldfb));

            // Blit from multisample buffer to final buffer, triggers resolve
            uint32 width = mColour[0].buffer->getWidth();
            uint32 height = mColour[0].buffer->getHeight();
            rs->_getStateCacheManager()->bindGLFrameBuffer( GL_READ_FRAMEBUFFER, mMultisampleFB );
            rs->_getStateCacheManager()->bindGLFrameBuffer( GL_DRAW_FRAMEBUFFER, mFB );

所以「交换链」在三后端各有形态:Vulkan 有显式对象与状态机,D3D11 是 DXGI 交换链 + flip/discard 分支,GL 则把窗口交换下放给 glXSwapBuffers、把纹理交换做成 MSAA resolve。

交换链的重建与帧槽的复用

交换链对象关联一组由显示系统管理的图像。重建涉及窗口尺寸、图像和对应视图或附件。命令缓冲的帧槽是另一组生命周期,它通过 fence 管理可重用的录制资源。

先标出本帧 acquire 的图像,再标出 CPU 使用的帧槽。resize 之后验证旧视图解绑、重建成功以及下一次 acquire 的结果,细节见卷二 8.2。

源码定位

上游引用固定到 OGRE v14.6.3 源码 。

可运行产物:C++ 最小验证

下面用纯 C++ 复现交换链的状态机与缓冲轮转:创建时按 min+1 尝试三重缓冲、按 VSync 选呈现模式、acquire → render → swapBuffers → _swapBuffers 完整帧循环、OUT_OF_DATE 重建、D3D11 flip 的 MSAA resolve 与 GLX 的外部控制跳过。它与 src/11-2-swap-chain.cpp 逐字节一致:

// file: src/11-2-swap-chain.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/11-2-swap-chain.cpp -o bin/11-2-swap-chain && ./bin/11-2-swap-chain
//
// 复现交换链状态机与缓冲轮转(对应 RenderSystems/Vulkan/src/OgreVulkanWindow.cpp
// 132-282、319-349、595-661 与 RenderSystems/Direct3D11/src/OgreD3D11RenderWindow.cpp
// 534-567):SwapchainStatus 四态 Released->Acquired->UsedInRendering->PendingSwap->Released;
// 创建时按 minImageCount+1 尝试三重缓冲、把 presentMode 按 VSync 选 FIFO/IMMEDIATE,
// 并被 maxImageCount 约束;acquireNextImage 轮转取图像、命中 OUT_OF_DATE 时重建交换链;
// swapBuffers 只登记 pending,真实呈现推迟到 _swapBuffers;D3D11 flip 模式下
// 先做 MSAA resolve 再 Present;GLX 窗口在 closed/外部控制时跳过 glXSwapBuffers。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <algorithm>
#include <cstdint>

namespace ogre_repro {

enum SwapchainStatus {
  SwapchainAcquired,
  SwapchainUsedInRendering,
  SwapchainPendingSwap,
  SwapchainReleased
};

enum VkResult { VK_SUCCESS, VK_SUBOPTIMAL_KHR, VK_ERROR_OUT_OF_DATE_KHR };

enum PresentMode { PM_IMMEDIATE_KHR, PM_MAILBOX_KHR, PM_FIFO_KHR, PM_FIFO_RELAXED_KHR };

// 对应 VulkanWindow(OgreVulkanWindow.h 39-168)的关键子集
class SwapChain {
 public:
  struct SurfaceCaps {
    uint32_t minImageCount = 2;
    uint32_t maxImageCount = 0;  // 0 = 数量不限
    uint32_t currentExtentWidth = 1920;
    uint32_t currentExtentHeight = 1080;
  };

  explicit SwapChain(bool vSync) : mVSync(vSync) {}

  // 对应 createSwapchain(OgreVulkanWindow.cpp 132-282)的关键逻辑
  void createSwapchain(const SurfaceCaps& caps) {
    mWidth = caps.currentExtentWidth;
    mHeight = caps.currentExtentHeight;

    // 尝试三重缓冲:minImageCount + 1,受 maxImageCount 约束
    uint32_t imageCount = caps.minImageCount + 1;
    if (caps.maxImageCount != 0) imageCount = std::min(imageCount, caps.maxImageCount);
    mSwapchainImages = imageCount;

    // presentMode:VSync 用 FIFO(保证存在),否则优先 IMMEDIATE
    mPresentMode = PM_FIFO_KHR;
    if (!mVSync) mPresentMode = PM_IMMEDIATE_KHR;

    mStatus = SwapchainReleased;
  }

  // 对应 acquireNextImage(319-349):轮转图像索引,OUT_OF_DATE 触发重建
  VkResult acquireNextImage() {
    if (mStatus != SwapchainReleased) return VK_SUCCESS;  // 真实代码此处是断言
    mCurrentImageIdx = (mCurrentImageIdx + 1) % mSwapchainImages;
    if (mOutOfDate) {
      mOutOfDate = false;
      ++mRecreateCount;
      return VK_ERROR_OUT_OF_DATE_KHR;
    }
    mStatus = SwapchainAcquired;
    return VK_SUCCESS;
  }

  // 渲染阶段标记:对应 getImageAcquiredSemaphore 之后的 UsedInRendering
  void beginRendering() { mStatus = SwapchainUsedInRendering; }

  // 对应 swapBuffers(595-613):只登记 pending,真实 Present 推迟到 _swapBuffers
  void swapBuffers() {
    mStatus = SwapchainPendingSwap;
    ++mPendingPresentCount;
  }

  // 对应 _swapBuffers(615-661):vkQueuePresentKHR 真正呈现
  void _swapBuffers() {
    ++mPresented;
    mStatus = SwapchainReleased;
  }

  uint32_t getWidth() const { return mWidth; }
  uint32_t getHeight() const { return mHeight; }
  uint32_t getImageCount() const { return mSwapchainImages; }
  PresentMode getPresentMode() const { return mPresentMode; }
  SwapchainStatus getStatus() const { return mStatus; }
  uint32_t getCurrentImageIdx() const { return mCurrentImageIdx; }
  uint32_t getRecreateCount() const { return mRecreateCount; }
  uint32_t getPresented() const { return mPresented; }
  uint32_t getPendingPresentCount() const { return mPendingPresentCount; }
  void setOutOfDate() { mOutOfDate = true; }

 private:
  bool mVSync;
  uint32_t mWidth = 0, mHeight = 0;
  uint32_t mSwapchainImages = 0;
  PresentMode mPresentMode = PM_FIFO_KHR;
  SwapchainStatus mStatus = SwapchainReleased;
  uint32_t mCurrentImageIdx = 0;
  uint32_t mRecreateCount = 0;
  uint32_t mPresented = 0;
  uint32_t mPendingPresentCount = 0;
  bool mOutOfDate = false;
};

// 对应 D3D11 flip 模式的 MSAA resolve + Present(OgreD3D11RenderWindow.cpp 534-567)
struct D3D11SwapChain {
  uint32_t mFSAASamples = 0;
  uint32_t mSyncInterval = 0;
  uint32_t mResolves = 0;
  uint32_t mPresents = 0;
  bool mUseFlipMode = false;

  // 每帧交换:flip + MSAA 时先 ResolveSubresource 再 Present
  void present(bool vsync, uint32_t vsyncInterval) {
    if (mUseFlipMode && mFSAASamples > 1) ++mResolves;
    mSyncInterval = mUseFlipMode ? std::max(1u, vsyncInterval) : (vsync ? vsyncInterval : 0);
    ++mPresents;
  }
};

// 对应 GLXWindow::swapBuffers(OgreGLXWindow.cpp 484-490):OS 层 glXSwapBuffers
struct GLXWindow {
  uint32_t mSwapCount = 0;
  void swapBuffers(bool closed, bool externalGLControl) {
    if (closed || externalGLControl) return;
    ++mSwapCount;
  }
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // 创建交换链:VSync 打开 → FIFO,三重缓冲尝试(min+1)
  SwapChain sc(true);
  SwapChain::SurfaceCaps caps;
  caps.minImageCount = 2;
  caps.maxImageCount = 4;
  caps.currentExtentWidth = 1920;
  caps.currentExtentHeight = 1080;
  sc.createSwapchain(caps);
  CHECK(sc.getImageCount() == 3);  // min 2 + 1 = 3,未超 max 4
  CHECK(sc.getPresentMode() == PM_FIFO_KHR);
  CHECK(sc.getWidth() == 1920);
  CHECK(sc.getHeight() == 1080);

  // VSync 关闭 → IMMEDIATE
  SwapChain scNoVsync(false);
  scNoVsync.createSwapchain(caps);
  CHECK(scNoVsync.getPresentMode() == PM_IMMEDIATE_KHR);

  // maxImageCount 约束:min 2 + 1 = 3 但 max 只有 2
  SwapChain::SurfaceCaps tightCaps = caps;
  tightCaps.maxImageCount = 2;
  scNoVsync.createSwapchain(tightCaps);
  CHECK(scNoVsync.getImageCount() == 2);

  // 完整帧循环:acquire → render → swapBuffers → _swapBuffers
  CHECK(sc.acquireNextImage() == VK_SUCCESS);
  CHECK(sc.getStatus() == SwapchainAcquired);
  sc.beginRendering();
  CHECK(sc.getStatus() == SwapchainUsedInRendering);
  sc.swapBuffers();
  CHECK(sc.getStatus() == SwapchainPendingSwap);
  sc._swapBuffers();
  CHECK(sc.getStatus() == SwapchainReleased);
  CHECK(sc.getPresented() == 1);

  // 图像索引轮转:3 张图像周而复始
  uint32_t first = sc.getCurrentImageIdx();
  sc.acquireNextImage(); sc.beginRendering(); sc.swapBuffers(); sc._swapBuffers();
  CHECK(sc.getCurrentImageIdx() == (first + 1) % 3);
  sc.acquireNextImage(); sc.beginRendering(); sc.swapBuffers(); sc._swapBuffers();
  CHECK(sc.getCurrentImageIdx() == (first + 2) % 3);
  sc.acquireNextImage(); sc.beginRendering(); sc.swapBuffers(); sc._swapBuffers();
  CHECK(sc.getCurrentImageIdx() == first);  // 绕回

  // OUT_OF_DATE:获取失败,重建交换链后再继续
  sc.setOutOfDate();
  CHECK(sc.acquireNextImage() == VK_ERROR_OUT_OF_DATE_KHR);
  sc.createSwapchain(caps);  // 重建
  CHECK(sc.getRecreateCount() == 1);
  CHECK(sc.acquireNextImage() == VK_SUCCESS);  // 重建后可继续取图

  // D3D11 flip 模式:MSAA resolve + Present,syncInterval 强制 >= 1
  D3D11SwapChain dx;
  dx.mUseFlipMode = true;
  dx.mFSAASamples = 4;
  dx.present(false, 0);
  CHECK(dx.mResolves == 1);
  CHECK(dx.mSyncInterval == 1);

  // 非 flip:VSync 决定 syncInterval
  D3D11SwapChain dx2;
  dx2.present(true, 1);
  CHECK(dx2.mResolves == 0);
  CHECK(dx2.mSyncInterval == 1);
  dx2.present(false, 0);
  CHECK(dx2.mSyncInterval == 0);

  // GLX 窗口:closed / 外部控制时不交换
  GLXWindow glx;
  glx.swapBuffers(false, false);
  CHECK(glx.mSwapCount == 1);
  glx.swapBuffers(true, false);   // 已关闭
  glx.swapBuffers(false, true);   // 外部控制
  CHECK(glx.mSwapCount == 1);

  return lab::report("11-2 交换链");
}

本机实测(Apple clang 16,clang++ -std=c++20 -Wall -I.):编译零警告,断言 25/25 通过。

小结

  • 交换链是窗口双缓冲呈现的抽象:一组轮转后台缓冲,一帧画完交换前台/后台避免撕裂。
  • Vulkan 用显式 SwapchainStatus 状态机管理生命周期:Released→Acquired→UsedInRendering→PendingSwap→Released。
  • createSwapchain 用 minImageCount + 1 尝试三重缓冲,按 VSync 选 FIFO/IMMEDIATE 呈现模式;OUT_OF_DATE 时销毁重建。
  • D3D11 的 DXGI 交换链区分 flip/discard 模式:flip 模式下交换链不做 MSAA,应用先 ResolveSubresource 再 Present。
  • GL 把窗口交换下放给 glXSwapBuffers(外部控制/关闭时跳过);渲染纹理的「交换」则是 FBO 的 MSAA resolve blit。

阅读导航:上一节:11.1 帧缓冲抽象 · 下一节:11.3 像素格式 。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图