《OGRE 3D 渲染引擎原理与架构》8.1 Vulkan 渲染系统

Vulkan 渲染系统初始化走 VulkanDevice:createInstance 声明引擎名 Ogre3D Vulkan Engine 与 apiVersion 1.2,findGraphicsQueue 遍历队列族挑带 VK_QUEUE_GRAPHICS_BIT 且未用满的族;VulkanWindow 用 SwapchainStatus 状态机管理交换链(Released→Acquired→UsedInRendering→PendingSwap→Released)。lab 复现实例参数、队列选择与交换链状态流转。

8.1 Vulkan 渲染系统

8.x 三节从初始化到管线把 VulkanRenderSystem 拆完。这一节先看地基:VulkanDevice::createInstance 怎么声明引擎身份、findGraphicsQueue 怎么挑选队列族,以及 VulkanWindow::SwapchainStatus 这套交换链状态机——它是 VK 后端「谁拥有 swapchain image」的权威判据。

OGRE 的 Vulkan 后端位于 RenderSystems/Vulkan,用 volk 加载函数指针,分层与 GL3Plus 一一对应。

createInstance:引擎名与 API 版本

Vulkan 实例是进程级句柄,VkApplicationInfo 里的引擎名/版本会出现在驱动与调试器里:

// RenderSystems/Vulkan/src/OgreVulkanDevice.cpp:VulkanDevice::createInstance(v14.6.3 源码摘录,已删减)
VkInstance VulkanDevice::createInstance( FastArray<const char *> &extensions,
                                         FastArray<const char *> &layers,
                                         PFN_vkDebugReportCallbackEXT debugCallback)
{
    VkInstanceCreateInfo createInfo = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO};
    VkApplicationInfo appInfo = {VK_STRUCTURE_TYPE_APPLICATION_INFO};

    appInfo.pEngineName = "Ogre3D Vulkan Engine";
    appInfo.engineVersion = OGRE_VERSION;
    appInfo.apiVersion = VK_API_VERSION_1_2;

    createInfo.pApplicationInfo = &appInfo;
    createInfo.enabledLayerCount = layers.size();
    createInfo.ppEnabledLayerNames = layers.data();

    createInfo.enabledExtensionCount = extensions.size();
    createInfo.ppEnabledExtensionNames = extensions.data();
    ...
    VkInstance instance;
    OGRE_VK_CHECK(vkCreateInstance(&createInfo, 0, &instance));
    return instance;
}

引擎版本直接取 OGRE_VERSION 宏;API 版本硬编码 1.2。lab 里我们复现引擎名、API 版本与 layer/extension 计数的默认值。

findGraphicsQueue:挑第一个可用 graphics 族

Vulkan 的队列族(queue family)各自声明能力位。OGRE 按序扫描,找「带 VK_QUEUE_GRAPHICS_BIT 且尚未用满」的第一个族,并占用一个队列槽:

// RenderSystems/Vulkan/src/OgreVulkanDevice.cpp:VulkanDevice::findGraphicsQueue(v14.6.3 源码摘录,已删减)
void VulkanDevice::findGraphicsQueue( FastArray<uint32> &inOutUsedQueueCount )
{
    const size_t numQueues = mQueueProps.size();
    for( size_t i = 0u; i < numQueues; ++i )
    {
        if( mQueueProps[i].queueFlags & VK_QUEUE_GRAPHICS_BIT &&
            inOutUsedQueueCount[i] < mQueueProps[i].queueCount )
        {
            mGraphicsQueue.setQueueData( this, VulkanQueue::Graphics, static_cast<uint32>( i ),
                                         inOutUsedQueueCount[i] );
            ++inOutUsedQueueCount[i];
            return;
        }
    }

    OGRE_EXCEPT( Exception::ERR_RENDERINGAPI_ERROR,
                 "GPU does not expose Graphics queue. Cannot be used for rendering",
                 "VulkanQueue::findGraphicsQueue" );
}

inOutUsedQueueCount 是跨设备共享的「已占用队列数」账本——同一族可能既提供 graphics 又提供 compute,多次分配不能超卖。找不到 graphics 族直接抛 ERR_RENDERINGAPI_ERROR。lab 里我们验证「族 1 有 graphics 位就选族 1」,以及「已用满的族不再入选」。

VulkanWindow::SwapchainStatus:交换链状态机

交换链 image 一次只能被一个阶段持有。OGRE 用枚举状态机表达归属,每个状态的注释都写明合法的来源状态:

// RenderSystems/Vulkan/include/OgreVulkanWindow.h:VulkanWindow::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
};
状态含义唯一合法来源
SwapchainAcquiredacquireNextImage 已调用,拿到 image 归属SwapchainReleased
SwapchainUsedInRendering已取信号量、正在渲染到该 imageSwapchainAcquired
SwapchainPendingSwap渲染完毕,等 commitAndNextCommandBuffer 提交呈现SwapchainUsedInRendering
SwapchainReleased不持有交换链,不能渲染SwapchainPendingSwap(present 后)

环形流转 Released → Acquired → UsedInRendering → PendingSwap → Released 保证任何时刻只有一个阶段在消费当前 image。lab 里我们完整走一遍这条环并断言每步状态。

源码定位

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

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

下面用纯 C++ 复现 Vulkan 实例参数、队列选择与交换链状态机。它与 src/08-1-vulkan-render-system.cpp 逐字节一致:

// file: src/08-1-vulkan-render-system.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/08-1-vulkan-render-system.cpp -o bin/08-1-vulkan-render-system && ./bin/08-1-vulkan-render-system
//
// 复现 Vulkan 渲染系统初始化与交换链状态机(对应 OgreVulkanDevice.cpp 81-179、
// OgreVulkanWindow.h 42-61、OgreVulkanWindow.cpp 319-349):
//   createInstance:VkApplicationInfo 引擎名 "Ogre3D Vulkan Engine"、apiVersion 1.2;
//   createPhysicalDevice:枚举物理设备、按 deviceIdx 选择;
//   findGraphicsQueue:遍历队列族,挑带 VK_QUEUE_GRAPHICS_BIT 且未用满的族;
//   VulkanWindow::SwapchainStatus:Released -> Acquired -> UsedInRendering ->
//   PendingSwap -> Released 的环形流转。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>
#include <string>
#include <vector>

namespace ogre_repro {

constexpr uint32_t VK_API_VERSION_1_2 = (1u << 22) | (2u << 12);  // 0x420000
constexpr uint32_t VK_QUEUE_GRAPHICS_BIT = 0x00000001;
constexpr uint32_t VK_QUEUE_COMPUTE_BIT = 0x00000002;
constexpr uint32_t VK_QUEUE_TRANSFER_BIT = 0x00000004;

struct InstanceCreateInfo {
  std::string engineName;
  uint32_t engineVersion;
  uint32_t apiVersion;
  uint32_t enabledLayerCount;
  uint32_t enabledExtensionCount;
};

struct QueueFamilyProps {
  uint32_t queueFlags;
  uint32_t queueCount;
};

struct VulkanQueue {
  uint32_t familyIdx;
  uint32_t queueIdx;
};

struct VulkanDevice {
  std::vector<QueueFamilyProps> mQueueProps;
  VulkanQueue mGraphicsQueue;
  uint32_t mDeviceIdx;

  static InstanceCreateInfo createInstance() {
    InstanceCreateInfo ci;
    ci.engineName = "Ogre3D Vulkan Engine";
    ci.engineVersion = 1;
    ci.apiVersion = VK_API_VERSION_1_2;
    ci.enabledLayerCount = 0;
    ci.enabledExtensionCount = 0;
    return ci;
  }

  // 对应 findGraphicsQueue:挑第一个带 graphics 位且未用满的队列族
  void findGraphicsQueue(std::vector<uint32_t>& inOutUsedQueueCount) {
    for (size_t i = 0; i < mQueueProps.size(); ++i) {
      if ((mQueueProps[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) &&
          inOutUsedQueueCount[i] < mQueueProps[i].queueCount) {
        mGraphicsQueue.familyIdx = static_cast<uint32_t>(i);
        mGraphicsQueue.queueIdx = inOutUsedQueueCount[i];
        ++inOutUsedQueueCount[i];
        return;
      }
    }
    mGraphicsQueue.familyIdx = 0xFFFFFFFFu;  // 未找到
  }
};

enum class SwapchainStatus : uint8_t {
  SwapchainAcquired,
  SwapchainUsedInRendering,
  SwapchainPendingSwap,
  SwapchainReleased
};

class VulkanWindow {
 public:
  void acquireNextImage() { mSwapchainStatus = SwapchainStatus::SwapchainAcquired; }
  void beginRender() { mSwapchainStatus = SwapchainStatus::SwapchainUsedInRendering; }
  void swapBuffers() { mSwapchainStatus = SwapchainStatus::SwapchainPendingSwap; }
  void present() { mSwapchainStatus = SwapchainStatus::SwapchainReleased; }
  SwapchainStatus getStatus() const { return mSwapchainStatus; }

 private:
  SwapchainStatus mSwapchainStatus = SwapchainStatus::SwapchainReleased;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // createInstance 参数
  InstanceCreateInfo ci = VulkanDevice::createInstance();
  CHECK(ci.engineName == "Ogre3D Vulkan Engine");
  CHECK_EQ(ci.apiVersion, VK_API_VERSION_1_2);
  CHECK_EQ(ci.enabledLayerCount, uint32_t(0));

  // findGraphicsQueue:两个队列族,graphics 在族 1
  VulkanDevice dev;
  dev.mQueueProps = {{VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT, 1},
                     {VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, 2}};
  std::vector<uint32_t> used = {0, 0};
  dev.findGraphicsQueue(used);
  CHECK_EQ(dev.mGraphicsQueue.familyIdx, uint32_t(1));
  CHECK_EQ(dev.mGraphicsQueue.queueIdx, uint32_t(0));
  CHECK_EQ(used[1], uint32_t(1));

  // 队列数用满后不再选择该族
  VulkanDevice dev2;
  dev2.mQueueProps = {{VK_QUEUE_GRAPHICS_BIT, 1}};
  std::vector<uint32_t> used2 = {1};  // 已用满
  dev2.findGraphicsQueue(used2);
  CHECK_EQ(dev2.mGraphicsQueue.familyIdx, uint32_t(0xFFFFFFFFu));

  // 交换链状态机流转
  VulkanWindow w;
  CHECK(w.getStatus() == SwapchainStatus::SwapchainReleased);
  w.acquireNextImage();
  CHECK(w.getStatus() == SwapchainStatus::SwapchainAcquired);
  w.beginRender();
  CHECK(w.getStatus() == SwapchainStatus::SwapchainUsedInRendering);
  w.swapBuffers();
  CHECK(w.getStatus() == SwapchainStatus::SwapchainPendingSwap);
  w.present();
  CHECK(w.getStatus() == SwapchainStatus::SwapchainReleased);

  return lab::report("08-1 Vulkan 渲染系统");
}

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

小结

  • VulkanDevice::createInstance 声明引擎名 Ogre3D Vulkan Engine、apiVersion 1.2,layer/extension 从外部传入。
  • findGraphicsQueue 按序挑第一个带 VK_QUEUE_GRAPHICS_BIT 且未用满的队列族,占用一个槽并更新账本。
  • VulkanWindow::SwapchainStatus 用四状态环形流转管理交换链 image 归属,每个状态有唯一合法来源。

阅读导航:上一节:7.3 GLSL 着色器 · 下一节:8.2 Vulkan 命令缓冲 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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