《OGRE 3D 渲染引擎原理与架构》1.3 实体相机关联与 LOD

Entity 每帧被相机驱动一次 LOD 计算:_notifyCurrentCamera 用 LodStrategy 取距离值、乘 MeshLodFactor 做 bias、getLodIndex 换层、Clamp 限界,再递归通知子对象。lab 复现这个「取值→bias→换层→夹取」的 LOD 状态机。

1.3 实体相机关联与 LOD

Entity 不是被动等渲染的:每帧相机推进时,SceneManager 会通知所有可见实体「现在这帧由哪个相机看你」,实体据此重新算 LOD——离得远就用粗网格,离得近才用细网格。这一节拆开 Entity::_notifyCurrentCamera 的 LOD 计算链。

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

卷一 7.x 讲过 Mesh 的 LOD 层数据(MeshLodUsageList、manual LOD)。这一节是它的运行时消费:相机距离如何在每一帧变成具体的 LOD 级,以及父子传递。

每帧一次:LOD 计算链

Entity::_notifyCurrentCamera 的骨架在 OgreEntity.cpp(摘录,已删减):

// OgreMain/src/OgreEntity.cpp:Entity::_notifyCurrentCamera(v14.6.3 源码摘录,已删减)
    void Entity::_notifyCurrentCamera(Camera* cam)
    {
        MovableObject::_notifyCurrentCamera(cam);

        // Calculate the LOD
        if (mParentNode)
        {
#if !OGRE_NO_MESHLOD
            // Get mesh lod strategy
            const LodStrategy *meshStrategy = mMesh->getLodStrategy();
            // Get the appropriate LOD value
            Real lodValue = meshStrategy->getValue(this, cam);
            // Bias the LOD value
            Real biasedMeshLodValue = lodValue * mMeshLodFactorTransformed;


            // Get the index at this biased depth
            ushort newMeshLodIndex = mMesh->getLodIndex(biasedMeshLodValue);
            // Apply maximum detail restriction (remember lower = higher detail, higher = lower detail)
            newMeshLodIndex = Math::Clamp(newMeshLodIndex, mMaxMeshLodIndex, mMinMeshLodIndex);

链条是四步:

步骤代码作用
1 取值meshStrategy->getValue(this, cam)从相机姿势算一个 LOD 值(默认是相机到节点距离)
2 biaslodValue * mMeshLodFactorTransformed乘实体 LOD 因子做偏置
3 换层mMesh->getLodIndex(biased)在网格阈值表里查对应 LOD 级
4 夹取Math::Clamp(idx, mMax, mMin)限制在最粗(max)与最细(min)之间

注释点破了方向:LOD 数字越大越粗,所以 Clamp 的 mMaxMeshLodIndex 是最粗限制、mMinMeshLodIndex 是最细限制。

事件化:LOD 变更要通知

换层不是默默发生。OGRE 构造一个 EntityMeshLodChangedEvent(携带实体、相机、偏置后的值、新旧 LOD 级),交给场景管理器的 _notifyEntityMeshLodChanged 分发——外部可以挂监听器在 LOD 切换时做自己的事(比如日志、代理资产加载):

// OgreMain/src/OgreEntity.cpp:Entity::_notifyCurrentCamera(v14.6.3 源码摘录,已删减)
            // Construct event object
            EntityMeshLodChangedEvent evt;
            evt.entity = this;
            evt.camera = cam;
            evt.lodValue = biasedMeshLodValue;
            evt.previousLodIndex = mMeshLodIndex;
            evt.newLodIndex = newMeshLodIndex;

            // Notify LOD event listeners
            cam->getSceneManager()->_notifyEntityMeshLodChanged(evt);

            // Change LOD index
            mMeshLodIndex = evt.newLodIndex;

注意最后一行——监听器甚至可以改写 evt.newLodIndex 来强制改 LOD,实体照单全收。这是 OGRE 常见的「事件即接口」模式:分发完,状态取事件里的最终值。

材质 LOD:每子实体独立

网格 LOD 之外,每个 SubEntity 还独立算材质 LOD(材质内部可能有多套 Technique,距离远用便宜的一档):

// OgreMain/src/OgreEntity.cpp:Entity::_notifyCurrentCamera(v14.6.3 源码摘录,已删减)
            for (auto *s : mSubEntityList)
            {
                // Get sub-entity material
                const MaterialPtr& material = s->getMaterial();

                // Get material LOD strategy
                const LodStrategy *materialStrategy = material->getLodStrategy();

                // Recalculate LOD value if strategies do not match
                Real biasedMaterialLodValue;
#if !OGRE_NO_MESHLOD
                if (meshStrategy == materialStrategy)
                    biasedMaterialLodValue = biasedMeshLodValue;
                else
#endif
                    biasedMaterialLodValue = materialStrategy->getValue(this, cam) * materialStrategy->transformBias(mMaterialLodFactor);

如果网格与材质的 LOD 策略是同一个对象,直接复用网格已算的偏置值(省一次计算);否则各自按策略重算。

传递:通知子对象

函数末尾把相机通知递归传给子对象(附加到实体的子 MovableObject)——相机推进沿实体树传播:

// OgreMain/src/OgreEntity.cpp:Entity::_notifyCurrentCamera(v14.6.3 源码摘录,已删减)
        // Notify any child objects
        for(auto child : mChildObjectList)
        {
            child->_notifyCurrentCamera(cam);
        }

LOD 是相机相关的实例决定

Entity 收到相机通知后根据 LOD 策略和偏移选择网格层,同时可对各 SubEntity 计算材质 LOD。共享资源的两个实体可能因距离不同选择不同层。

用同一 Mesh 放置两个 Entity,记录对象到相机的策略值、网格层和材质层。相机移动时把层变化与直接被剔除的情形分别记录。

源码定位

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

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

下面复现 LOD 计算链。它与 src/01-3-entity-camera-lod.cpp 逐字节一致:

// file: src/01-3-entity-camera-lod.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/01-3-entity-camera-lod.cpp -o bin/01-3-entity-camera-lod && ./bin/01-3-entity-camera-lod
//
// 复现 Entity 的相机感知与 LOD(对应 OgreEntity.cpp 338-、OgreMesh.h 520-):
//   Entity::_notifyCurrentCamera 每帧由相机推进:用 LodStrategy 取距离值,
//   bias(乘 MeshLodFactor)后 getLodIndex 得到 LOD 级,再 Clamp 到 [min,max];
//   LOD 级沿父子传递(mChildObjectList 递归);
//   每子实体独立算材质 LOD。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <vector>

namespace ogre_repro {

// 极简距离 LOD:按相机到节点距离选层
class LodStrategy {
 public:
  explicit LodStrategy(const std::vector<float>& thresholds)
      : mThresholds(thresholds) {}
  // 相机到目标距离
  float getValue(float dist) const { return dist; }
  // 阈值表:距离超过第 i 个阈值则 LOD 上升(更粗)
  size_t getLodIndex(float dist) const {
    size_t idx = 0;
    for (size_t i = 0; i < mThresholds.size(); ++i)
      if (dist > mThresholds[i]) idx = i + 1;
    return idx;
  }

 private:
  std::vector<float> mThresholds;
};

// 对应 Entity 的 LOD 计算骨架(OgreEntity.cpp 338-)
class EntityLod {
 public:
  EntityLod() : mMinLod(0), mMaxLod(2), mMeshLodFactor(1.0f) {}

  // 每帧由相机推进:输入相机距离,输出 LOD 级
  size_t notifyCurrentCamera(float cameraDist, bool& lodChanged) {
    size_t prev = mMeshLodIndex;
    float dist = mLodStrategy.getValue(cameraDist);
    float biased = dist * mMeshLodFactor;
    size_t raw = mLodStrategy.getLodIndex(biased);
    // Clamp 到 [maxLod, minLod]:mMaxLod 是最粗(数字大),mMinLod 是最细(数字小)
    if (raw > mMaxLod) raw = mMaxLod;
    if (raw < mMinLod) raw = mMinLod;
    mMeshLodIndex = raw;
    lodChanged = (raw != prev);
    return raw;
  }

  void setLodFactor(float f) { mMeshLodFactor = f; }

 private:
  LodStrategy mLodStrategy{{50.0f, 100.0f, 200.0f}};  // 4 级 LOD(0..3 已被 max 限 2)
  size_t mMeshLodIndex = 0;
  size_t mMinLod = 0;
  size_t mMaxLod = 2;  // 只允许 0..2 三级
  float mMeshLodFactor = 1.0f;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  EntityLod e;
  bool changed = false;

  // 近距离:LOD 0(最细)
  e.notifyCurrentCamera(10.0f, changed);
  CHECK(e.notifyCurrentCamera(10.0f, changed) == 0);

  // 超过 50:LOD 1
  CHECK(e.notifyCurrentCamera(75.0f, changed) == 1);

  // 超过 100:LOD 2
  CHECK(e.notifyCurrentCamera(150.0f, changed) == 2);

  // 超过 200 但被 mMaxLod=2 夹住,不再变粗
  CHECK(e.notifyCurrentCamera(500.0f, changed) == 2);

  // LOD 切换会通知(changed 为真)
  e.notifyCurrentCamera(10.0f, changed);
  CHECK(changed == true);

  // 同距离不重复通知
  e.notifyCurrentCamera(10.0f, changed);
  CHECK(changed == false);

  // bias 放大:LOD 因子 2 让距离感知加倍(10→20 仍在 LOD0,但 40→80 到 LOD1)
  e.setLodFactor(2.0f);
  CHECK(e.notifyCurrentCamera(40.0f, changed) == 1);

  return lab::report("01-3 实体相机关联与 LOD");
}

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

小结

  • Entity 每帧由 _notifyCurrentCamera 驱动:取值→bias→getLodIndex→Clamp 四步换 LOD。
  • LOD 级越大越粗,Clamp(mMax, mMin) 中 max 是最粗限制、min 是最细限制。
  • LOD 变更通过事件对象分发,监听器甚至可以改写最终值。
  • 每个 SubEntity 独立算材质 LOD;相机通知沿 mChildObjectList 递归传递。

阅读导航:上一节:1.2 可渲染对象与渲染操作 · 下一节:2.1 相机与视锥 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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