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_KHR | FIFO 是 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 = ¤tImageIdx;
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 模式 |
|---|---|---|
BufferCount | 2 | 1 |
SampleDesc | 1×1(交换链不支持 MSAA) | 来自 mFSAAType |
SwapEffect | FLIP_DISCARD/FLIP_SEQUENTIAL | DISCARD |
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。
源码定位
RenderSystems/Vulkan/include/OgreVulkanWindow.h:enum SwapchainStatus(42-61)、交换链资源成员(77-87)、createSwapchain/destroySwapchain(92-93)、acquireNextImage(102)、swapBuffers(156)、_swapBuffers(162)RenderSystems/Vulkan/src/OgreVulkanWindow.cpp:createSwapchain(132-282)、destroySwapchain(284-318)、acquireNextImage(319-349)、swapBuffers(595-613)、_swapBuffers(615-661)RenderSystems/Direct3D11/include/OgreD3D11RenderWindow.h:D3D11RenderWindowSwapChainBased(110-158)、mpSwapChain/mSwapChainDesc(149-150)RenderSystems/Direct3D11/src/OgreD3D11RenderWindow.cpp:_destroySwapChain(399-405)、_createSwapChain(407-413)、_createSizeDependedD3DResources(415-465)、_resizeSwapChainBuffers(491-531)、swapBuffers(534-567)、D3D11RenderWindowHwnd::_createSwapChainImpl(858-933)RenderSystems/GLSupport/src/GLX/OgreGLXWindow.cpp:swapBuffers(484-490)RenderSystems/GL3Plus/src/OgreGL3PlusFrameBufferObject.cpp:swapBuffers(230-245+)
上游引用固定到 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 像素格式 。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。