《OGRE 3D 渲染引擎原理与架构》5.3 静态几何

静态几何把世界切成 512 区:getRegionIndexes 用 floor 除法把点映射到 [-512,511] 单元格并平移 REGION_HALF_RANGE,packIndex 每轴 10 位打包成 30 位索引;addEntity 先入队 QueuedSubMesh,build 才按包围盒分配到区域并建块。lab 复现 floor 除法、越界检查与 10 位打包。

5.3 静态几何

实例化解决「大量重复网格」的渲染开销,但它仍假设物体每帧可能移动——每帧都要更新实例变换。如果场景里有一批永远不动的物体(一片建筑群、地形上的石头、关卡里的静态道具),连这个更新都可以省掉。OGRE 的 StaticGeometry 就为此设计:把所有静态实体合并成大块网格,按空间区域组织,渲染时像渲染几个大网格一样高效。这一节看它的核心机制——区域划分。

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

第 5.1/5.2 节讲实例化的批次管理,InstanceBatchHW::setStaticAndUpdate 提过「让批表现像静态几何」;本节把它做成完整的类。卷二讲 Mesh 的组织方式,本节看 StaticGeometry 怎么把多个 Mesh 合并进区域网格。第 9 章还会从合批角度再提它——StaticGeometry 本质上是一种「把渲染状态切换降到最低」的合批手段。

区域划分:REGION 与 floor 除法

StaticGeometry 的世界被切成固定大小的空间块,每个块叫 Region。划分算法的核心在 getRegionIndexes:

// OgreMain/src/OgreStaticGeometry.cpp:REGION 常量(v14.6.3 源码摘录,已删减)
    #define REGION_HALF_RANGE 512
    #define REGION_MAX_INDEX 511
    #define REGION_MIN_INDEX -512

每个轴允许的单元格索引范围是 [-512, 511],加上 HALF_RANGE=512 平移后正好落进无符号 10 位范围 [0, 1023]——这就是 10 位打包的前提。世界原点落在 512 号单元格。

// OgreMain/src/OgreStaticGeometry.cpp:getRegionIndexes(v14.6.3 源码摘录,已删减)
    void StaticGeometry::getRegionIndexes(const Vector3& point,
        ushort& x, ushort& y, ushort& z)
    {
        // Scale the point into multiples of region and adjust for origin
        Vector3 scaledPoint = (point - mOrigin) / mRegionDimensions;

        // Round down to 'bottom left' point which represents the cell index
        int ix = Math::IFloor(scaledPoint.x);
        int iy = Math::IFloor(scaledPoint.y);
        int iz = Math::IFloor(scaledPoint.z);

        // Check bounds
        if (ix < REGION_MIN_INDEX || ix > REGION_MAX_INDEX
            || iy < REGION_MIN_INDEX || iy > REGION_MAX_INDEX
            || iz < REGION_MIN_INDEX || iz > REGION_MAX_INDEX)
        {
            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
                "Point out of bounds",
                "StaticGeometry::getRegionIndexes");
        }
        // Adjust for the fact that we use unsigned values for simplicity
        // (requires less faffing about for negatives give 10-bit packing
        x = static_cast<ushort>(ix + REGION_HALF_RANGE);
        y = static_cast<ushort>(iy + REGION_HALF_RANGE);
        z = static_cast<ushort>(iz + REGION_HALF_RANGE);


    }

算法三步:

  1. 缩放:点减去世界原点,除以 mRegionDimensions(每个 Region 的尺寸),得到「以 Region 为单位的坐标」。
  2. floor 除法:Math::IFloor 取整——注意是向负无穷的 floor,不是 C++ 整数除法的向零截断。-1/10 在 floor 下得 -1(向零截断则得 0)。这保证负坐标点正确落到「左下」单元格。
  3. 越界检查 + 平移:单元格索引必须在 [-512, 511];越界抛 ERR_INVALIDPARAMS。合法则加 REGION_HALF_RANGE 转成无符号——注释里的 less faffing about for negatives 点明意图:平移后全是正数,可以直接用无符号 10 位打包。

packIndex:10 位/轴 打包

getRegionIndexes 产出三个 ushort 索引,packIndex 把它们压缩进一个 32 位整数:

// OgreMain/src/OgreStaticGeometry.cpp:packIndex(v14.6.3 源码摘录,已删减)
    uint32 StaticGeometry::packIndex(ushort x, ushort y, ushort z)
    {
        return x + (y << 10) + (z << 20);
    }

每轴 10 位:x 占第 0-9 位,y 左移 10 占第 10-19 位,z 左移 20 占第 20-29 位,最高两位空闲。这样一个 uint32 就能唯一标识一个 Region,作为 mRegionMap(map<uint32, Region*>)的键。这正是 getRegionIndexes 注释里「10-bit packing」的落点。

getRegion(point, autoCreate) 把两步串起来:先 getRegionIndexes 求单元格,再查/建 Region。这个「查建一体」的语义贯穿 build 阶段。

addEntity:先入队,build 才动手

StaticGeometry 的使用姿势是「先 add 一批实体,最后调一次 build」。addEntity 只做登记:

// OgreMain/src/OgreStaticGeometry.cpp:addEntity(v14.6.3 源码摘录,已删减)
    void StaticGeometry::addEntity(Entity* ent, const Vector3& position,
        const Quaternion& orientation, const Vector3& scale)
    {
        const MeshPtr& msh = ent->getMesh();
        // Validate
        if (msh->hasManualLodLevel())
        {
            LogManager::getSingleton().logWarning("(StaticGeometry): Manual LOD is not supported. "
                                                  "Using only highest LOD level for mesh " +
                                                  msh->getName());
        }

        AxisAlignedBox sharedWorldBounds;
        // queue this entities submeshes and choice of material
        // also build the lists of geometry to be used for the source of lods
        for (uint i = 0; i < ent->getNumSubEntities(); ++i)
        {
            SubEntity* se = ent->getSubEntity(i);
            QueuedSubMesh* q = OGRE_NEW QueuedSubMesh();

            // Get the geometry for this SubMesh
            q->submesh = se->getSubMesh();
            q->material = se->getMaterial();
            q->geometryLodList = determineGeometry(q->submesh);
            q->orientation = orientation;
            q->position = position;
            q->scale = scale;
            // Determine the bounds based on the highest LOD
            q->worldBounds = calculateBounds(
                (*q->geometryLodList)[0].vertexData,
                    position, orientation, scale);

            mQueuedSubMeshes.push_back(q);
        }
    }

addEntity 做四件事:校验手动 LOD(不支持则告警,只用最高 LOD)、遍历实体的每个 SubEntity、为每个 SubEntity 建一个 QueuedSubMesh 队列项(记录 submesh/材质/几何 LOD 列表/变换),并 calculateBounds 算出世界包围盒。队列项被塞进 mQueuedSubMeshes——注意注释的措辞「queue this entities submeshes」:入队,还没分到任何 Region。头文件的声明注释强调同一点:

// OgreMain/include/OgreStaticGeometry.h:addEntity 声明(v14.6.3 源码摘录,已删减)
        virtual void addEntity(Entity* ent, const Vector3& position,
            const Quaternion& orientation = Quaternion::IDENTITY, 
            const Vector3& scale = Vector3::UNIT_SCALE);

参数带默认值(orientation = IDENTITY,scale = UNIT_SCALE),所以最简单用法 addEntity(ent, pos) 就能登记一个标准朝向、标准缩放的实体。注释提醒:必须 build 之前调用,且 build 之前不要卸载实体引用的 Mesh——几何数据是在 build 时才真正读取的。

build:按包围盒分配到 Region

所有实体入队后,build 一次性把队列分配到各 Region 并生成块:

// OgreMain/src/OgreStaticGeometry.cpp:build(v14.6.3 源码摘录,已删减)
    void StaticGeometry::build(void)
    {
        // Make sure there's nothing from previous builds
        destroy();

        // Firstly allocate meshes to regions
        for (auto qsm : mQueuedSubMeshes)
        {
            Region* region = getRegion(qsm->worldBounds, true);
            region->assign(qsm);
        }
        bool stencilShadows = false;
        if (mCastShadows && mOwner->isShadowTechniqueStencilBased())
        {
            stencilShadows = true;
        }

        // Now tell each region to build itself
        for (auto & ri : mRegionMap)
        {
            ri.second->build(stencilShadows);

            // Set the visibility flags on these regions
            ri.second->setVisibilityFlags(mVisibilityFlags);
        }

    }

build 三个阶段:

  1. 清理:destroy() 确保上次构建的 Region 全部释放,避免重复 build 叠加。
  2. 分配:遍历 mQueuedSubMeshes,对每个队列项用 getRegion(worldBounds, true) 找到它所属的 Region——第二个参数 autoCreate=true,不存在的 Region 就地创建——然后 region->assign(qsm) 把它塞进去。
  3. 构建:遍历 mRegionMap,让每个 Region 自己 build(stencilShadows) 生成合并几何,再设置可见性标志。

注意分配是按世界包围盒而不是按位置点——qsm->worldBounds 是 addEntity 时算好的,getRegion 内部用包围盒的中心(或所在位置)求单元格。build 之后 mQueuedSubMeshes 里的队列项被 Region 接管,destroy()/reset() 负责回收。

源码定位

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

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

下面用纯 C++ 复现静态几何的区域划分:getRegionIndexes 的 floor 除法与越界检查、packIndex 的 10 位打包、addEntity 入队与 build 分配。它与 src/ogre-ext-05-3-static-geometry.cpp 逐字节一致:

// file: src/ogre-ext-05-3-static-geometry.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/ogre-ext-05-3-static-geometry.cpp -o bin/ogre-ext-05-3-static-geometry && ./bin/ogre-ext-05-3-static-geometry
//
// 复现 StaticGeometry 的区域划分(对应 OgreStaticGeometry.cpp 36-38 的
//   REGION_HALF_RANGE/REGION_MAX_INDEX/REGION_MIN_INDEX、185-217 的
//   getRegionIndexes/packIndex、269-303 的 addEntity、515-541 的 build):
//   点按区域尺寸 floor 除法求单元格,再平移 HALF_RANGE 转无符号;10 位/轴
//   打包成 30 位索引;addEntity 先入队,build 才把实体分配到各区域。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

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

namespace ogre_repro {

constexpr int REGION_HALF_RANGE = 512;
constexpr int REGION_MAX_INDEX = 511;
constexpr int REGION_MIN_INDEX = -512;

struct Vector3 {
  float x, y, z;
};

// 队列项:对应 QueuedSubMesh(实体 + 变换)
struct QueuedSubMesh {
  std::string meshName;
  Vector3 position;
};

// 区域:一个 (x,y,z) 桶,收集 build 时落进来的几何
struct Region {
  uint16_t x, y, z;
  std::vector<QueuedSubMesh> meshes;
  bool empty() const { return meshes.empty(); }
  size_t meshCount() const { return meshes.size(); }
};

// 对应 getRegionIndexes 185-212:floor 除法 + 平移
// 返回 false 表示越界(OGRE 此时抛 OGRE_EXCEPT)
bool getRegionIndexes(const Vector3& point, const Vector3& regionDimensions,
                      const Vector3& origin, uint16_t& x, uint16_t& y, uint16_t& z) {
  const float sx = (point.x - origin.x) / regionDimensions.x;
  const float sy = (point.y - origin.y) / regionDimensions.y;
  const float sz = (point.z - origin.z) / regionDimensions.z;
  const int ix = static_cast<int>(std::floor(sx));
  const int iy = static_cast<int>(std::floor(sy));
  const int iz = static_cast<int>(std::floor(sz));
  if (ix < REGION_MIN_INDEX || ix > REGION_MAX_INDEX ||
      iy < REGION_MIN_INDEX || iy > REGION_MAX_INDEX ||
      iz < REGION_MIN_INDEX || iz > REGION_MAX_INDEX)
    return false;
  x = static_cast<uint16_t>(ix + REGION_HALF_RANGE);
  y = static_cast<uint16_t>(iy + REGION_HALF_RANGE);
  z = static_cast<uint16_t>(iz + REGION_HALF_RANGE);
  return true;
}

// 对应 packIndex 214-217:每轴 10 位
uint32_t packIndex(uint16_t x, uint16_t y, uint16_t z) {
  return static_cast<uint32_t>(x) + (static_cast<uint32_t>(y) << 10) +
         (static_cast<uint32_t>(z) << 20);
}

// 极简 StaticGeometry:addEntity 入队,build 按位置分配区域
class StaticGeometry {
 public:
  StaticGeometry(const Vector3& dims, const Vector3& origin)
      : mRegionDimensions(dims), mOrigin(origin) {}

  void addEntity(const std::string& meshName, const Vector3& position) {
    QueuedSubMesh q{meshName, position};
    mQueuedSubMeshes.push_back(q);
  }

  // 对应 build:遍历队列,求区域,把网格塞进对应桶(自动建桶)
  void build() {
    for (const auto& q : mQueuedSubMeshes) {
      uint16_t x, y, z;
      if (getRegionIndexes(q.position, mRegionDimensions, mOrigin, x, y, z)) {
        const uint32_t key = packIndex(x, y, z);
        Region* r = nullptr;
        for (auto& reg : mRegions)
          if (packIndex(reg.x, reg.y, reg.z) == key) {
            r = &reg;
            break;
          }
        if (!r) {
          Region n{x, y, z, {}};
          mRegions.push_back(n);
          r = &mRegions.back();
        }
        r->meshes.push_back(q);
      }
    }
    mQueuedSubMeshes.clear();
  }

  std::vector<QueuedSubMesh> mQueuedSubMeshes;
  std::vector<Region> mRegions;
  Vector3 mRegionDimensions;
  Vector3 mOrigin;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  const Vector3 dims{10.f, 10.f, 10.f};
  const Vector3 origin{0.f, 0.f, 0.f};

  // floor 除法:正点 (10,10,10) → 单元格 (1,1,1) → 平移 512
  uint16_t x, y, z;
  CHECK(getRegionIndexes({10.f, 10.f, 10.f}, dims, origin, x, y, z));
  CHECK_EQ(x, uint16_t(513));
  CHECK_EQ(y, uint16_t(513));
  CHECK_EQ(z, uint16_t(513));

  // 负数:-1/10 floor 得 -1(向负无穷),非 C++ 整除的 0
  CHECK(getRegionIndexes({-1.f, -1.f, -1.f}, dims, origin, x, y, z));
  CHECK_EQ(x, uint16_t(511));
  CHECK_EQ(y, uint16_t(511));

  // 原点 → (0,0,0) → 平移 512
  CHECK(getRegionIndexes({0.f, 0.f, 0.f}, dims, origin, x, y, z));
  CHECK_EQ(x, uint16_t(512));

  // 边界:511 上限与 -512 下限之内合法
  CHECK(getRegionIndexes({5110.f, 0.f, 0.f}, dims, origin, x, y, z));
  CHECK_EQ(x, uint16_t(1023));  // 511 + 512
  CHECK(!getRegionIndexes({5120.f, 0.f, 0.f}, dims, origin, x, y, z));  // 越界
  CHECK(!getRegionIndexes({-5130.f, 0.f, 0.f}, dims, origin, x, y, z));

  // packIndex:10 位/轴 打包
  CHECK_EQ(packIndex(1, 2, 3), uint32_t(1 + (2 << 10) + (3 << 20)));
  CHECK_EQ(packIndex(0, 0, 1), uint32_t(1 << 20));

  // addEntity 入队,build 分配区域
  StaticGeometry sg(dims, origin);
  sg.addEntity("rock.mesh", {0.f, 0.f, 0.f});
  sg.addEntity("rock.mesh", {10.f, 10.f, 10.f});
  sg.addEntity("rock.mesh", {15.f, 10.f, 10.f});  // 与第二块同区
  CHECK_EQ(sg.mQueuedSubMeshes.size(), size_t(3));
  sg.build();
  CHECK_EQ(sg.mQueuedSubMeshes.size(), size_t(0));
  CHECK_EQ(sg.mRegions.size(), size_t(2));
  CHECK_EQ(sg.mRegions[0].meshCount(), size_t(1));
  CHECK_EQ(sg.mRegions[1].meshCount(), size_t(2));

  return lab::report("5.3 静态几何");
}

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

小结

  • 世界被切成 [-512, 511] 的 Region 单元格,REGION_HALF_RANGE=512 平移后转无符号。
  • getRegionIndexes 用 Math::IFloor 向负无穷取整,负坐标正确落到「左下」单元格。
  • packIndex 每轴 10 位移位打包,uint32 唯一标识一个 Region。
  • addEntity 只入队 QueuedSubMesh(含世界包围盒),真正的分配在 build 时发生。
  • build 三步:destroy 清理 → 按包围盒 getRegion(…, true) 分配 → 各 Region 构建合并几何。

阅读导航:上一节:5.2 实例批 · 下一节:6.1 高级着色器程序 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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