《OGRE 3D 渲染引擎原理与架构》11.3 Camera 与投影

Camera 继承 Frustum:Frustum 管投影(ProjectionType 枚举、near/far 裁剪面、fovy、aspect),Camera 加位置/朝向与视图矩阵。getViewMatrix 会先检查 mCullFrustum(反射/斜面裁剪时用代理视锥)。lab 用 C++ 复现构造默认值、裁剪面 setter 与透视视锥换算。

11.3 Camera 与投影

Camera 是场景的「眼睛」。在 OGRE 里它继承 Frustum(视锥):投影相关的数学全在 Frustum 里,Camera 只加位置、朝向和视图矩阵。这一节拆这层继承关系。

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

cg 三卷讲投影矩阵的数学推导;本节讲 OGRE 里「谁持有投影参数、谁持有视图参数」的类划分,以及 mCullFrustum 代理机制。

Camera 继承 Frustum

OgreCamera.h 开头即声明继承关系,并带一个 Listener 接口:

// OgreMain/include/OgreCamera.h:class Camera(v14.6.3 源码摘录,已删减)
    class _OgreExport Camera : public Frustum
    {
    public:
        /** Listener interface so you can be notified of Camera events. 
        */
        class _OgreExport Listener 
        {
        public:
            Listener() {}
            virtual ~Listener() {}

            /// Called prior to the scene being rendered with this camera
            virtual void cameraPreRenderScene(Camera* cam)
                        { (void)cam; }

            /// Called after the scene has been rendered with this camera
            virtual void cameraPostRenderScene(Camera* cam)
                        { (void)cam; }
        };

Frustum 是投影的持有者。OgreFrustum.h 定义投影类型:

// OgreMain/include/OgreFrustum.h:ProjectionType(v14.6.3 源码摘录,已删减)
    enum ProjectionType : uint8
    {
        PT_ORTHOGRAPHIC,
        PT_PERSPECTIVE
    };

Frustum 的构造默认值

OgreFrustum.cpp 构造初始化列表给出默认参数:

// OgreMain/src/OgreFrustum.cpp:Frustum 构造函数初始化列表(v14.6.3 源码摘录,已删减)
        mFOVy(Radian(Math::PI/4.0f)),
        mFarDist(100000.0f),
        mNearDist(100.0f),
        mAspect(1.33333333333333f),
        ...
        mProjType(PT_PERSPECTIVE),

默认值:

  • mFOVy = PI/4 = 45°(垂直视场角);
  • mNearDist = 100、mFarDist = 100000(近远裁剪面);
  • mAspect = 4/3;
  • mProjType = PT_PERSPECTIVE(透视)。

裁剪面 setter:赋值 + 失效

setNearClipDistance/setFarClipDistance 不只是赋值,还要把缓存的视锥置为失效(下次用到时重算):

// OgreMain/src/OgreFrustum.cpp:Frustum::setFarClipDistance(v14.6.3 源码摘录,已删减)
    void Frustum::setFarClipDistance(float farPlane)
    {
        mFarDist = farPlane;
        invalidateFrustum();
    }

    //-----------------------------------------------------------------------
    void Frustum::setNearClipDistance(float nearPlane)
    {
        OgreAssert(nearPlane > 0, "Invalid clip distance");
        ...
        mNearDist = nearPlane;
        invalidateFrustum();
    }

注意 OgreAssert(nearPlane > 0, ...):近裁剪面必须为正,非法值直接断言失败。invalidateFrustum() 把 mRecalcFrustum 等标志置真,让投影矩阵/裁剪平面/世界空间角点全部推迟到下一帧才重算——这是 OGRE 常见的「脏标记」模式。

getViewMatrix:代理视锥优先

Camera::getViewMatrix 先检查 mCullFrustum——反射(镜子/水面)或斜面投影时,相机用一个代理视锥做剔除:

// OgreMain/src/OgreCamera.cpp:Camera::getViewMatrix(v14.6.3 源码摘录,已删减)
    const Affine3& Camera::getViewMatrix(void) const
    {
        if (mCullFrustum)
        {
            return mCullFrustum->getViewMatrix();
        }
        else
        {
            return Frustum::getViewMatrix();
        }
    }

如果没有代理视锥,就回退到 Frustum::getViewMatrix()(由相机的位置/朝向推导)。getViewMatrix(bool ownFrustumOnly) 变体允许调用方显式要求只看自己的视锥。

源码定位

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

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

下面复现 Camera/Frustum 的默认值、裁剪面 setter 与透视视锥换算。它与 src/11-3-camera-projection.cpp 逐字节一致:

// file: src/11-3-camera-projection.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/11-3-camera-projection.cpp -o bin/11-3-camera-projection && ./bin/11-3-camera-projection
//
// 复现 Camera / Frustum 的裁剪面与投影:
//   Camera 继承 Frustum(对应 OgreCamera.h class Camera : public Frustum);
//   构造默认 mFOVy=45°、mNearDist=100、mFarDist=100000、mAspect=4/3
//   (对应 OgreFrustum.cpp 构造初始化列表);
//   setNearClipDistance/setFarClipDistance 修改裁剪面并使其失效;
//   透视投影的视锥半高/半宽换算 + 简化视图矩阵。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cmath>
#include <vector>

namespace ogre_repro {

// 对应 Ogre::Frustum::ProjectionType
enum ProjectionType : uint8_t {
  PT_ORTHOGRAPHIC,
  PT_PERSPECTIVE,
};

struct Vec3 {
  float x = 0, y = 0, z = 0;
  Vec3 operator-(const Vec3& o) const { return {x - o.x, y - o.y, z - o.z}; }
  float dot(const Vec3& o) const { return x * o.x + y * o.y + z * o.z; }
};

// 对应 Ogre::Frustum:投影类型 + near/far + fovy + aspect
class Frustum {
 public:
  // 对应 OgreFrustum.cpp 构造初始化列表的默认值
  Frustum()
      : mProjType(PT_PERSPECTIVE), mFOVy(45.0f), mFarDist(100000.0f),
        mNearDist(100.0f), mAspect(1.33333333333333f) {}

  void setProjectionType(ProjectionType pt) { mProjType = pt; }
  ProjectionType getProjectionType() const { return mProjType; }

  // 对应 Frustum::setFarClipDistance:赋值并使视锥失效
  void setFarClipDistance(float farPlane) {
    mFarDist = farPlane;
    mRecalcFrustum = true;
  }
  float getFarClipDistance() const { return mFarDist; }

  // 对应 Frustum::setNearClipDistance:断言 near>0 后赋值并使视锥失效
  void setNearClipDistance(float nearPlane) {
    if (nearPlane <= 0.0f) return;  // 对应 OgreAssert(nearPlane > 0, ...)
    mNearDist = nearPlane;
    mRecalcFrustum = true;
  }
  float getNearClipDistance() const { return mNearDist; }

  void setFOVy(float fovyDeg) { mFOVy = fovyDeg; }
  void setAspectRatio(float aspect) { mAspect = aspect; }

  // 透视视锥:距离 d 处的投影半高 = d * tan(fovy/2),半宽 = 半高 * aspect
  float projHalfHeightAt(float distance) const {
    return distance * std::tan(mFOVy * 3.14159265358979323846f / 360.0f);
  }
  float projHalfWidthAt(float distance) const {
    return projHalfHeightAt(distance) * mAspect;
  }

  ProjectionType mProjType;
  float mFOVy, mFarDist, mNearDist, mAspect;
  bool mRecalcFrustum = true;
};

// 对应 Ogre::Camera:继承 Frustum,另持有位置/朝向,提供视图矩阵
class Camera : public Frustum {
 public:
  void setPosition(const Vec3& p) { mPosition = p; }
  void lookAt(const Vec3& target) {
    mForward = target - mPosition;  // 简化:只存前向向量
    mDerivedDirty = true;
  }
  // 简化 getViewMatrix:返回 {right, up, forward} 三个基向量
  std::vector<Vec3> getViewMatrix() const {
    Vec3 f = mForward;
    float len = std::sqrt(f.dot(f));
    if (len > 0.0f) {
      f.x /= len; f.y /= len; f.z /= len;
    }
    Vec3 up{0, 1, 0};
    Vec3 right = {up.z * f.y - up.y * f.z,
                  up.x * f.z - up.z * f.x,
                  up.y * f.x - up.x * f.y};
    return {right, up, f};
  }

 private:
  Vec3 mPosition{0, 0, 0};
  Vec3 mForward{0, 0, -1};
  bool mDerivedDirty = true;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  Camera cam;
  // 默认透视 + near=100 far=100000 fovy=45° aspect=4/3(对应 OgreFrustum.cpp)
  CHECK(cam.getProjectionType() == PT_PERSPECTIVE);
  CHECK(cam.getNearClipDistance() == 100.0f);
  CHECK(cam.getFarClipDistance() == 100000.0f);

  // 设置裁剪面并生效
  cam.setNearClipDistance(0.5f);
  CHECK(cam.getNearClipDistance() == 0.5f);
  cam.setFarClipDistance(2000.0f);
  CHECK(cam.getFarClipDistance() == 2000.0f);
  // 非法近平面被拒绝
  cam.setNearClipDistance(0.0f);
  CHECK(cam.getNearClipDistance() == 0.5f);

  // 切换投影类型(对应 setProjectionType(PT_ORTHOGRAPHIC))
  cam.setProjectionType(PT_ORTHOGRAPHIC);
  CHECK(cam.getProjectionType() == PT_ORTHOGRAPHIC);
  cam.setProjectionType(PT_PERSPECTIVE);

  // 透视视锥:fovy=45° aspect=4/3,near 处半高 = tan(22.5°),半宽/半高 = 4/3
  cam.setFOVy(45.0f);
  cam.setAspectRatio(4.0f / 3.0f);
  CHECK(std::abs(cam.projHalfHeightAt(1.0f) -
                 std::tan(22.5f * 3.14159265358979323846f / 180.0f)) < 1e-6);
  float halfW = cam.projHalfWidthAt(1.0f);
  CHECK(std::abs(halfW / cam.projHalfHeightAt(1.0f) - 4.0f / 3.0f) < 1e-6);

  // 视图矩阵:lookAt 后前向指向目标方向(-Z)
  cam.setPosition(Vec3{10, 5, 20});
  cam.lookAt(Vec3{10, 5, 0});
  auto vm = cam.getViewMatrix();
  CHECK(std::abs(vm[2].z + 1.0f) < 1e-6);

  return lab::report("11-3 渲染对象体系:Camera 与投影");
}

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

小结

  • Camera : public Frustum:投影数学归 Frustum,Camera 管位置/朝向/视图。
  • 构造默认 fovy=45°、near=100、far=100000、aspect=4/3、透视投影。
  • setNearClipDistance 用 OgreAssert 强制 near > 0;两个 setter 都置脏标记。
  • getViewMatrix 优先用 mCullFrustum 代理,否则回退到自身 Frustum::getViewMatrix。

阅读导航:上一节:11.2 Light 类型与光照参数 · 下一节:12.1 FrameListener 与渲染循环 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析·向量数据库与 AI 检索内核》 · 目录与学习路径(45 篇)
  2. 《大规模分布式计算深入解析》15.3 自研向量引擎:可执行骨架与工程缺口
  3. 《大规模分布式计算深入解析》14.1 Milvus:组件架构、段管理与检索链路