《OGRE 3D 渲染引擎原理与架构》7.2 GL 硬件缓冲与顶点数组

GL3PlusHardwareBuffer 把 OGRE 的缓冲抽象映射到 glMapBufferRange:lockImpl 按 LockOptions 组合访问位(DISCARD 触发重分配、NO_OVERWRITE 加 UNSYNCHRONIZED),GLVertexArrayObject 用 needsUpdate/bindToGpu 缓存已绑定属性。源码在 RenderSystems/GL3Plus 与 GLSupport。lab 复现访问位推导与 VAO 更新判定。

7.2 GL 硬件缓冲与顶点数组

7.1 看到 GL3PlusRenderSystem 怎么把绘制命令发给 GL。这一节往下两层:GL3PlusHardwareBuffer 包装 GPU 缓冲(顶点/索引),把 OGRE 的 LockOptions 翻译成 glMapBufferRange 的访问位;GLVertexArrayObject(VAO)缓存「已绑定属性集合」,避免每帧重复配置顶点属性指针。

lockImpl:LockOptions → GL 访问位

GL3PlusHardwareBuffer::lockImpl 是 CPU 侧读写 GPU 缓冲的入口。它按「写专用」判定分组:要么只写(WRITE_ONLY,或用法声明了 WRITE_ONLY 且本次不是读/普通),要么只读,要么读写:

// RenderSystems/GL3Plus/src/OgreGL3PlusHardwareBuffer.cpp:GL3PlusHardwareBuffer::lockImpl(v14.6.3 源码摘录,已删减)
void* GL3PlusHardwareBuffer::lockImpl(size_t offset, size_t length, LockOptions options)
{
    GLenum access = 0;

    // Use glMapBuffer
    mRenderSystem->_getStateCacheManager()->bindGLBuffer(mTarget,mBufferId);

    bool writeOnly =
        options == HardwareBuffer::HBL_WRITE_ONLY ||
        ((mUsage & HBU_DETAIL_WRITE_ONLY) &&
         options != HardwareBuffer::HBL_READ_ONLY && options != HardwareBuffer::HBL_NORMAL);

    if (writeOnly)
    {
        if(options == HBL_DISCARD)
            OGRE_CHECK_GL_ERROR(glBufferData(mTarget, mSizeInBytes, NULL, getGLUsage(mUsage)));
 
        access |= GL_MAP_WRITE_BIT;
        if(options == HBL_NO_OVERWRITE)
            access |= GL_MAP_UNSYNCHRONIZED_BIT;
    }
    else if (options == HardwareBuffer::HBL_READ_ONLY)
        access |= GL_MAP_READ_BIT;
    else
        access |= GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;

    void* pBuffer;
    OGRE_CHECK_GL_ERROR(pBuffer = glMapBufferRange(mTarget, offset, length, access));
    ...
}

三个值得注意的点:

  • HBL_DISCARD 语义:先用 glBufferData 用空数据重新定义缓冲(orphaning),再映射——等于告诉驱动「旧内容我不要了」,避免与正在渲染的 GPU 同步。
  • HBL_NO_OVERWRITE 语义:加 GL_MAP_UNSYNCHRONIZED_BIT,承诺只写未消费区域,跳过同步。
  • glMapBufferRange 的返回指针已经偏移过 offset(末尾注释特意说明)。

unlockImpl:unmap 与数据损坏检测

// RenderSystems/GL3Plus/src/OgreGL3PlusHardwareBuffer.cpp:GL3PlusHardwareBuffer::unlockImpl(v14.6.3 源码摘录,已删减)
void GL3PlusHardwareBuffer::unlockImpl()
{
    mRenderSystem->_getStateCacheManager()->bindGLBuffer(mTarget, mBufferId);

    GLboolean mapped;
    OGRE_CHECK_GL_ERROR(mapped = glUnmapBuffer(mTarget));
    if(!mapped)
    {
        OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
                    "Buffer data corrupted, please reload",
                    "GL3PlusHardwareBuffer::unlock");
    }
}

glUnmapBuffer 返回 GL_FALSE 表示缓冲数据损坏(典型是驱动崩溃恢复),OGRE 直接抛 ERR_INTERNAL_ERROR。

GLVertexArrayObject:needsUpdate 判定

VAO 的核心价值是缓存:只要绑定过的属性集合没变,就不必重新走一遍 glEnableVertexAttribArray + glVertexAttribPointer。needsUpdate 检查三件事——脏标记、已绑定属性集合、vertexStart:

// RenderSystems/GLSupport/src/OgreGLVertexArrayObject.cpp:GLVertexArrayObject::needsUpdate(v14.6.3 源码摘录,已删减)
bool GLVertexArrayObject::needsUpdate(VertexBufferBinding* vertexBufferBinding,
                                      size_t vertexStart)
{
    if(mNeedsUpdate)
        return true;

    for (const auto& elem : mElementList)
    {
        uint16 source = elem.getSource();

        if (!vertexBufferBinding->isBufferBound(source))
            continue; // Skip unbound elements

        VertexElementSemantic sem = elem.getSemantic();
        unsigned short elemIndex = elem.getIndex();

        uint32 attrib = (uint32)GLSLProgramCommon::getFixedAttributeIndex(sem, elemIndex);

        const HardwareVertexBufferSharedPtr& vertexBuffer = vertexBufferBinding->getBuffer(source);
        if (std::find(mAttribsBound.begin(), mAttribsBound.end(),
                      std::make_pair(attrib, vertexBuffer.get())) == mAttribsBound.end())
            return true;

        if (vertexBuffer->isInstanceData() &&
            std::find(mInstanceAttribsBound.begin(), mInstanceAttribsBound.end(), attrib) ==
                mInstanceAttribsBound.end())
            return true;
    }

    if(vertexStart != mVertexStart) {
        return true;
    }

    return false;
}

属性集合用 (attrib, vertexBuffer 指针) 二元组比对——同位置换了个缓冲也是「变了」。实例化数据(isInstanceData())还额外维护一份 mInstanceAttribsBound。bindToGpu 在真正配置后把当前集合记录进 mAttribsBound:

// RenderSystems/GLSupport/src/OgreGLVertexArrayObject.cpp:GLVertexArrayObject::bindToGpu(v14.6.3 源码摘录,已删减)
void GLVertexArrayObject::bindToGpu(GLRenderSystemCommon* rs,
                                    VertexBufferBinding* vertexBufferBinding,
                                    size_t vertexStart)
{
    mAttribsBound.clear();
    mInstanceAttribsBound.clear();

    for (const auto& elem : mElementList)
    {
        uint16 source = elem.getSource();

        if (!vertexBufferBinding->isBufferBound(source))
            continue; // Skip unbound elements

        VertexElementSemantic sem = elem.getSemantic();
        unsigned short elemIndex = elem.getIndex();

        uint32 attrib = (uint32)GLSLProgramCommon::getFixedAttributeIndex(sem, elemIndex);

        const HardwareVertexBufferSharedPtr& vertexBuffer = vertexBufferBinding->getBuffer(source);

        mAttribsBound.push_back(std::make_pair(attrib, vertexBuffer.get()));

        rs->bindVertexElementToGpu(elem, vertexBuffer, vertexStart);

        if (vertexBuffer->isInstanceData())
            mInstanceAttribsBound.push_back(attrib);
    }
    ...
}

lab 里我们复现「脏标记 / 属性集合变化 / vertexStart 变化」三路 needsUpdate 判定,以及 bindToGpu 后判定翻转。

源码定位

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

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

下面用纯 C++ 复现 GL 硬件缓冲的访问位推导与 VAO 的更新判定。它与 src/07-2-gl-hardware-buffer.cpp 逐字节一致:

// file: src/07-2-gl-hardware-buffer.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/07-2-gl-hardware-buffer.cpp -o bin/07-2-gl-hardware-buffer && ./bin/07-2-gl-hardware-buffer
//
// 复现 GL3Plus 硬件缓冲与顶点数组对象(对应 OgreGL3PlusHardwareBuffer.cpp 39-120 与
// OgreGLVertexArrayObject.h/.cpp 39-129):
//   lockImpl 按 LockOptions 组合 glMapBufferRange 的访问位(DISCARD 触发重分配、
//   NO_OVERWRITE 加 UNSYNCHRONIZED、READ_ONLY 只读、NORMAL 读写);
//   unlockImpl 仅 bind + unmap;
//   GLVertexArrayObject::needsUpdate 检查 mNeedsUpdate、已绑定属性集合与 vertexStart;
//   bindToGpu 记录已绑定属性集合。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>
#include <utility>
#include <vector>

namespace ogre_repro {

// GL 常量
constexpr int32_t GL_MAP_READ_BIT = 0x0001;
constexpr int32_t GL_MAP_WRITE_BIT = 0x0002;
constexpr int32_t GL_MAP_UNSYNCHRONIZED_BIT = 0x0020;

enum LockOptions : uint8_t {
  HBL_NORMAL = 0,
  HBL_DISCARD = 1,
  HBL_READ_ONLY = 2,
  HBL_NO_OVERWRITE = 3,
  HBL_WRITE_ONLY = 4
};

class GLBuffer {
 public:
  explicit GLBuffer(size_t sizeBytes) : mSizeInBytes(sizeBytes), mAllocCount(0) { realloc(); }
  void realloc() {
    mData.assign(mSizeInBytes, 0);
    ++mAllocCount;
  }

  // 对应 lockImpl:由 LockOptions 推导访问位(DISCARD 会重分配缓冲)
  int32_t computeAccess(LockOptions options) {
    int32_t access = 0;
    bool writeOnly =
        options == HBL_WRITE_ONLY || (options != HBL_READ_ONLY && options != HBL_NORMAL);
    if (writeOnly) {
      if (options == HBL_DISCARD) realloc();
      access |= GL_MAP_WRITE_BIT;
      if (options == HBL_NO_OVERWRITE) access |= GL_MAP_UNSYNCHRONIZED_BIT;
    } else if (options == HBL_READ_ONLY) {
      access |= GL_MAP_READ_BIT;
    } else {
      access |= GL_MAP_READ_BIT | GL_MAP_WRITE_BIT;
    }
    return access;
  }

  size_t getAllocCount() const { return mAllocCount; }

 private:
  size_t mSizeInBytes;
  size_t mAllocCount;
  std::vector<uint8_t> mData;
};

class VertexArrayObject {
 public:
  VertexArrayObject() : mNeedsUpdate(true), mVertexStart(0) {}

  // 对应 needsUpdate:脏标记、属性集合变化、vertexStart 变化任一触发更新
  bool needsUpdate(const std::vector<std::pair<uint32_t, const void*>>& currentAttribs,
                   size_t vertexStart) const {
    if (mNeedsUpdate) return true;
    for (const auto& a : currentAttribs) {
      bool found = false;
      for (const auto& b : mAttribsBound)
        if (b.first == a.first && b.second == a.second) {
          found = true;
          break;
        }
      if (!found) return true;
    }
    return vertexStart != mVertexStart;
  }

  void bindToGpu(const std::vector<std::pair<uint32_t, const void*>>& currentAttribs) {
    mAttribsBound = currentAttribs;
    mNeedsUpdate = false;
  }

  void setVertexStart(size_t s) { mVertexStart = s; }
  void notifyChanged() { mNeedsUpdate = true; }
  std::vector<std::pair<uint32_t, const void*>> mAttribsBound;
  bool mNeedsUpdate;
  size_t mVertexStart;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  GLBuffer buf(16);
  CHECK_EQ(buf.getAllocCount(), size_t(1));

  // 写专用访问位
  int32_t writeOnly = buf.computeAccess(HBL_WRITE_ONLY);
  CHECK(writeOnly == GL_MAP_WRITE_BIT);

  // NO_OVERWRITE:加 UNSYNCHRONIZED
  int32_t noOverwrite = buf.computeAccess(HBL_NO_OVERWRITE);
  CHECK((noOverwrite & GL_MAP_WRITE_BIT) != 0);
  CHECK((noOverwrite & GL_MAP_UNSYNCHRONIZED_BIT) != 0);

  // DISCARD:重分配 + 仅写
  int32_t discard = buf.computeAccess(HBL_DISCARD);
  CHECK((discard & GL_MAP_WRITE_BIT) != 0);
  CHECK((discard & GL_MAP_READ_BIT) == 0);
  CHECK_EQ(buf.getAllocCount(), size_t(2));  // DISCARD 触发重新分配

  // READ_ONLY:只读
  int32_t ro = buf.computeAccess(HBL_READ_ONLY);
  CHECK(ro == GL_MAP_READ_BIT);

  // NORMAL:读写
  int32_t normal = buf.computeAccess(HBL_NORMAL);
  CHECK((normal & GL_MAP_READ_BIT) != 0 && (normal & GL_MAP_WRITE_BIT) != 0);

  // VAO needsUpdate 判定
  VertexArrayObject vao;
  uint8_t vboA, vboB;
  std::vector<std::pair<uint32_t, const void*>> attribs = {{0, &vboA}, {2, &vboB}};
  CHECK(vao.needsUpdate(attribs, 0));  // mNeedsUpdate 初始为 true

  vao.bindToGpu(attribs);
  vao.setVertexStart(0);
  CHECK(!vao.needsUpdate(attribs, 0));  // 属性集合与 vertexStart 都一致

  std::vector<std::pair<uint32_t, const void*>> changed = {{0, &vboA}, {3, &vboB}};
  CHECK(vao.needsUpdate(changed, 0));  // 属性位置变化

  CHECK(vao.needsUpdate(attribs, 3));  // vertexStart 变化
  vao.notifyChanged();
  CHECK(vao.needsUpdate(attribs, 0));  // notifyChanged 强制更新

  return lab::report("07-2 GL 硬件缓冲与顶点数组");
}

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

小结

  • lockImpl 把 LockOptions 分组映射成 glMapBufferRange 访问位:DISCARD 重分配、NO_OVERWRITE 加 UNSYNCHRONIZED、READ_ONLY 只读、NORMAL 读写。
  • unlockImpl 用 glUnmapBuffer 的返回值检测缓冲损坏并抛异常。
  • GLVertexArrayObject::needsUpdate 检查脏标记、已绑定属性集合(attrib, buffer 二元组)与 vertexStart 三路信号。
  • bindToGpu 记录已绑定集合,是「每帧零配置」优化的落点。

阅读导航:上一节:7.1 GL3Plus 渲染系统 · 下一节:7.3 GLSL 着色器 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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