《OGRE 3D 渲染引擎原理与架构》2.3 索引缓冲

索引缓冲让多个三角形共享顶点:HardwareIndexBuffer 以 uint8 枚举区分 16/32 位索引(mIndexSize 记录每索引字节数),IndexData 用 indexBuffer+indexStart+indexCount 描述要画的区段,三角形数=indexCount/3。lab 复现 16/32 位索引、三角形展开与切片。

2.3 索引缓冲

相邻三角形几乎总是共享顶点——没有索引,四边形要存 6 个独立顶点(两份位置/法线/UV 重复);有了索引,存 4 个顶点 + 6 个索引(0,1,2,2,1,3)。索引缓冲就是那份「顶点排列清单」。这一节看 HardwareIndexBuffer 与 IndexData。

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

卷一 7.3 讲过 IndexData 的语义;这里从渲染系统看:索引的存储形态(16/32 位)与切片(indexStart/indexCount)如何支撑一块缓冲供多个 renderable 共享。

16 位还是 32 位:一次选择

HardwareIndexBuffer 的索引类型其实是一个很轻的枚举:

// OgreMain/include/OgreHardwareIndexBuffer.h:HardwareIndexBuffer(v14.6.3 源码摘录,已删减)
    class _OgreExport HardwareIndexBuffer final : public HardwareBuffer
    {
        public:
            enum IndexType : uint8 {
                IT_16BIT,
                IT_32BIT
            };

        private:
            IndexType mIndexType;
            uint8 mIndexSize;
            HardwareBufferManagerBase* mMgr;
            uint32 mNumIndexes;

注意:枚举只是标签(IT_16BIT=0、IT_32BIT=1),真正的位宽存在成员 mIndexSize(2 或 4 字节)。为什么是标签 + 成员而不是直接用数值?因为 OGRE 只关心「每索引几个字节」,而显存分配、读取宽度都由 mIndexSize 决定,枚举只负责人类可读地表达意图。16 位索引(≤65535 个顶点)省一半内存,顶点数超限才用 32 位。

IndexData:画哪一段

// OgreMain/include/OgreVertexIndexData.h:IndexData(v14.6.3 源码摘录,已删减)
    class _OgreExport IndexData : public IndexDataAlloc
    {
    public:
        IndexData();
        ~IndexData();
        /// Pointer to the HardwareIndexBuffer to use, must be specified if useIndexes = true
        HardwareIndexBufferSharedPtr indexBuffer;

        /// Index in the buffer to start from for this operation
        uint32 indexStart;

        /// The number of indexes to use from the buffer
        uint32 indexCount;

三个字段决定画什么:

字段含义
indexBuffer索引住哪块缓冲(哪段显存)
indexStart从第几个索引开始
indexCount一共用几个索引

三角形列表下 三角形数 = indexCount / 3。indexStart/indexCount 让一块索引缓冲切给多个网格(子网格共用一张索引池),这与 2.2 的 vertexStart/vertexCount 完全对称——顶点按段、索引按段,两两组合出一个可渲染区间。这也是卷一 7.1 SubMesh 的 indexData 落点。

IndexData 还带一个有意思的方法 optimiseVertexCacheTriList()——重新排序索引让三角形尽量复用最近用过的顶点(顶点缓存友好),在卷四第 9 章性能剖析里会展开。

源码定位

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

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

下面复现索引类型、三角形展开与切片。它与 src/02-3-index-buffer.cpp 逐字节一致:

// file: src/02-3-index-buffer.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/02-3-index-buffer.cpp -o bin/02-3-index-buffer && ./bin/02-3-index-buffer
//
// 复现 IndexData 与索引缓冲(对应 OgreVertexIndexData.h 248-282、OgreHardwareIndexBuffer.h 46-):
//   HardwareIndexBuffer 有 16/32 位索引类型(IT_16BIT=0x10000/IT_32BIT=0x20000 的简化);
//   IndexData 持有 indexBuffer + indexStart + indexCount:表示「从哪一段开始画」;
//   三角形数 = indexCount / 3(三角形列表);
//   通过索引展开三角形 → 顶点序列;展示索引复用(两个三角形共享一条边)。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>
#include <memory>
#include <vector>

namespace ogre_repro {

class HardwareIndexBuffer {
 public:
  // 对应 HardwareIndexBuffer::IndexType(uint8 底层)
  enum IndexType : uint8_t { IT_16BIT, IT_32BIT };

  HardwareIndexBuffer(IndexType type, size_t indexCount)
      : mType(type), mIndexSize(type == IT_16BIT ? 2 : 4) {
    if (type == IT_16BIT) {
      mData16.assign(indexCount, 0);
    } else {
      mData32.assign(indexCount, 0);
    }
  }
  size_t getIndexSize() const { return mIndexSize; }  // 对应成员 mIndexSize
  void write16(size_t i, uint16_t v) { mData16[i] = v; }
  void write32(size_t i, uint32_t v) { mData32[i] = v; }
  uint32_t read(size_t i) const { return mType == IT_16BIT ? mData16[i] : mData32[i]; }

 private:
  IndexType mType;
  uint8_t mIndexSize;  // 每索引字节数(2 或 4)
  std::vector<uint16_t> mData16;
  std::vector<uint32_t> mData32;
};

struct IndexData {
  std::shared_ptr<HardwareIndexBuffer> indexBuffer;
  uint32_t indexStart = 0;  // 对应 IndexData::indexStart
  uint32_t indexCount = 0;  // 对应 IndexData::indexCount
  uint32_t triangleCount() const { return indexCount / 3; }
  // 展开当前区段为三角形(每行 3 个顶点索引)
  std::vector<uint32_t> triangles() const {
    std::vector<uint32_t> tris;
    for (uint32_t i = indexStart; i < indexStart + indexCount; ++i)
      tris.push_back(indexBuffer->read(i));
    return tris;
  }
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // 四边形 = 两个三角形,共享顶点 1-2(索引复用,缓存友好)
  auto ib = std::make_shared<HardwareIndexBuffer>(HardwareIndexBuffer::IT_16BIT, 6);
  const uint16_t quad[] = {0, 1, 2, 2, 1, 3};
  for (size_t i = 0; i < 6; ++i) ib->write16(i, quad[i]);

  CHECK(ib->getIndexSize() == 2);  // 16 位每索引 2 字节

  IndexData data;
  data.indexBuffer = ib;
  data.indexStart = 0;
  data.indexCount = 6;
  CHECK(data.triangleCount() == 2);

  auto tris = data.triangles();
  CHECK(tris.size() == 6);
  CHECK(tris[0] == 0 && tris[1] == 1 && tris[2] == 2);
  CHECK(tris[3] == 2 && tris[4] == 1 && tris[5] == 3);  // 第二个三角形复用 1、2

  // 32 位索引:每索引 4 字节
  auto ib32 = std::make_shared<HardwareIndexBuffer>(HardwareIndexBuffer::IT_32BIT, 3);
  ib32->write32(0, 1000);
  ib32->write32(1, 2000);
  ib32->write32(2, 3000);
  CHECK(ib32->getIndexSize() == 4);

  // indexStart 切片:只画第二个三角形
  IndexData slice;
  slice.indexBuffer = ib;
  slice.indexStart = 3;
  slice.indexCount = 3;
  auto sliced = slice.triangles();
  CHECK(sliced.size() == 3);
  CHECK(sliced[0] == 2 && sliced[1] == 1 && sliced[2] == 3);

  return lab::report("02-3 索引缓冲");
}

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

小结

  • 索引类型用 uint8 枚举做标签(IT_16BIT/IT_32BIT),位宽存 mIndexSize(2/4 字节)。
  • IndexData 的 indexBuffer + indexStart + indexCount 描述「画哪个区段」,三角形数 = indexCount / 3。
  • 顶点按段、索引按段,两块拼出一个可渲染区间——一块缓冲服务多个子网格。
  • 索引复用(0,1,2,2,1,3)让顶点数据量大幅下降,是「顶点缓存友好」的前提。

阅读导航:上一节:2.2 顶点声明 · 下一节:3.1 GPU 程序抽象 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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