《OGRE 3D 渲染引擎原理与架构》4.3 光照视觉参数

光源的漫反射/镜面颜色决定它朝场景辐射什么光,powerScale 统一缩放 RGB 贡献;光源颜色与材质颜色按通道相乘并饱和,类型标志位与排序距离用于光源归组。lab 复现颜色存储、缩放与合成。

4.3 光照视觉参数

4.1 定了类型、4.2 定了衰减,但光源「看起来什么颜色、多亮」由另一组视觉参数决定:漫反射色、镜面色与 powerScale。最终像素颜色不是光源颜色本身,而是光源颜色 × 材质反射颜色按通道相乘并饱和的结果;powerScale 在不改光源颜色存储的前提下统一缩放 RGB 贡献。此外光源还带着类型标志位与排序距离,参与场景查询归组与渲染排序。

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

cg 三卷讲过 Phong 模型里漫反射与镜面项各自乘什么;卷一 ogre-core 3.x 讲过 ColourValue 与材质。本节把「光源侧提供什么」与「材质侧反射什么」的接口切开,讲清 Light::setDiffuseColour 的语义注释、powerScale 的只缩 RGB 约定,以及光源怎么在渲染队列里排序(方向光恒排最前)。

漫反射与镜面颜色

setDiffuseColour 的文档注释是整套合成模型的纲领:材质提供「反射多少」的系数,光源提供「辐射多少」的颜色,实际外观是两者合成的结果;镜面还依赖材质的 shininess:

// OgreMain/include/OgreLight.h:setDiffuseColour 文档(v14.6.3 源码摘录,已删减)
        /** Sets the colour of the diffuse light given off by this source.

            Material objects have ambient, diffuse and specular values which indicate how much of each type of
            light an object reflects. This value denotes the amount and colour of this type of light the light
            exudes into the scene. The actual appearance of objects is a combination of the two.
        @par
            Diffuse light simulates the typical light emanating from light sources and affects the base colour
            of objects together with ambient light.
        */
        void setDiffuseColour(float red, float green, float blue);

实现只是把 RGB 分量存进 ColourValue,读时原样返回——颜色本身不做任何预处理,合成留给着色器:

// OgreMain/src/OgreLight.cpp:setDiffuseColour/setSpecularColour(v14.6.3 源码摘录,已删减)
    void Light::setDiffuseColour(float red, float green, float blue)
    {
        mDiffuse.r = red;
        mDiffuse.b = blue;
        mDiffuse.g = green;
    }
    ...
    void Light::setSpecularColour(float red, float green, float blue)
    {
        mSpecular.r = red;
        mSpecular.b = blue;
        mSpecular.g = green;
    }

着色器端的合成是逐通道的:final = saturate(lightColor × materialColor × intensity)。溢出的通道被 saturate 夹回 1,所以超亮光源对白色材质也不会把某通道推过 1,只会均匀提亮其它通道。这正是「光源颜色负责给什么颜色、材质颜色负责反射多少」的分工。

powerScale:只缩 RGB 的全局亮度

mPowerScale 是光源亮度的统一缩放旋钮,默认 1.0。它不改变 mDiffuse 存储,只在取用时把 RGB 分量整体乘一遍。AutoParamDataSource 把这个语义写成 getLightDiffuseColourWithPower:scale, but not alpha——只动 RGB、不碰 alpha:

// OgreMain/src/OgreAutoParamDataSource.cpp:getLightDiffuseColourWithPower(v14.6.3 源码摘录,已删减)
    const ColourValue AutoParamDataSource::getLightDiffuseColourWithPower(size_t index) const
    {
        const Light& l = getLight(index);
        ColourValue scaled(l.getDiffuseColour());
        Real power = l.getPowerScale();
        // scale, but not alpha
        scaled.r *= power;
        scaled.g *= power;
        scaled.b *= power;
        return scaled;
    }

配套的 setPowerScale/getPowerScale 只读写成员,没有任何级联更新。用 powerScale 而不是直接改 mDiffuse 的好处是:HDR 或后期调亮度时,可以临时把整场光源统一乘一个数,不用逐光源改颜色,也方便做「随帧闪灯」这类动画。

类型标志位与排序距离

光源作为 MovableObject 要能被场景查询归组。getTypeFlags 返回 SceneManager::LIGHT_TYPE_MASK,把光源放进查询掩码体系的高位区(0x08000000),与实体、特效、静态几何区分开:

// OgreMain/include/OgreSceneManager.h:enum QueryTypeMask(v14.6.3 源码摘录,已删减)
        enum QueryTypeMask : uint32
        {
            /// Query type mask which will be used for world geometry @see SceneQuery
            WORLD_GEOMETRY_TYPE_MASK = 0x80000000,
            /// Query type mask which will be used for entities @see SceneQuery
            ENTITY_TYPE_MASK = 0x40000000,
            /// Query type mask which will be used for effects like billboardsets / particle systems @see SceneQuery
            FX_TYPE_MASK = 0x20000000,
            /// Query type mask which will be used for StaticGeometry  @see SceneQuery
            STATICGEOMETRY_TYPE_MASK = 0x10000000,
            /// Query type mask which will be used for lights  @see SceneQuery
            LIGHT_TYPE_MASK = 0x08000000,
            /// Query type mask which will be used for frusta and cameras @see SceneQuery
            FRUSTUM_TYPE_MASK = 0x04000000,
            ...
        };
// OgreMain/src/OgreLight.cpp:Light::getTypeFlags(v14.6.3 源码摘录,已删减)
    uint32 Light::getTypeFlags(void) const
    {
        return SceneManager::LIGHT_TYPE_MASK;
    }

每帧收集受影响光源时,_calcTempSquareDist 算出一个排序标签:方向光恒为 -1(永远排在点光之前),点光取到指定世界位置的距离平方:

// OgreMain/src/OgreLight.cpp:Light::_calcTempSquareDist(v14.6.3 源码摘录,已删减)
    void Light::_calcTempSquareDist(const Vector3& worldPos)
    {
        if (mLightType == LT_DIRECTIONAL)
        {
            // make sure directional lights are always in front
            // even of point lights at worldPos
            // tempSquareDist is just a tag for sorting, and nobody will take the sqrt
            tempSquareDist = -1;
        }
        else
        {
            tempSquareDist = 
                (worldPos - getDerivedPosition()).squaredLength();
        }
    }

注释点明这是个「排序标签」,没人会对它开平方——距离平方本身就够比较远近。

源码定位

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

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

下面复现光照视觉参数链路:颜色存储与读取、powerScale 只缩 RGB、getTypeFlags 类型掩码、光源×材质按通道合成并饱和、_calcTempSquareDist 的方向光恒 -1 与点光距离平方。它与 src/04-3-light-visual.cpp 逐字节一致:

// file: src/04-3-light-visual.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/04-3-light-visual.cpp -o bin/04-3-light-visual && ./bin/04-3-light-visual
//
// 复现 OgreLight.h / OgreLight.cpp / OgreAutoParamDataSource.cpp 的
// 光照视觉参数与合成:
//   mDiffuse/mSpecular 存储与 set/get;
//   mPowerScale 缩放(getLightDiffuseColourWithPower:只缩放 RGB);
//   getTypeFlags 返回 SceneManager::LIGHT_TYPE_MASK = 0x08000000;
//   _calcTempSquareDist:方向光恒 -1 排前,点光取到光源距离平方;
//   着色器每通道合成 saturate(light * material)。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>

namespace ogre_repro {

struct Vec3 {
  float x, y, z;
};
inline Vec3 operator-(const Vec3& a, const Vec3& b) {
  return Vec3{a.x - b.x, a.y - b.y, a.z - b.z};
}

struct Colour {
  float r, g, b;
};
inline bool colEq(const Colour& a, const Colour& b) {
  return a.r == b.r && a.g == b.g && a.b == b.b;
}

// 对应着色器常用的 saturate:夹到 [0,1]
inline float saturate(float v) { return v < 0.0f ? 0.0f : (v > 1.0f ? 1.0f : v); }

// 对应着色器每通道合成:saturate(light * material)
Colour shade(const Colour& light, const Colour& mat) {
  return Colour{saturate(light.r * mat.r), saturate(light.g * mat.g),
                saturate(light.b * mat.b)};
}

// 对应 OgreLight.h:视觉参数相关的最小 Light
class Light {
 public:
  enum LightTypes : uint8_t { LT_POINT = 0, LT_DIRECTIONAL = 1 };

  Light() {
    mDiffuse = Colour{1.0f, 1.0f, 1.0f};   // White
    mSpecular = Colour{0.0f, 0.0f, 0.0f};  // Black
    mPowerScale = 1.0f;
    mLightType = LT_POINT;
    mPosition = Vec3{0, 0, 0};
  }

  void setType(LightTypes t) { mLightType = t; }

  void setDiffuseColour(float r, float g, float b) { mDiffuse = Colour{r, g, b}; }
  const Colour& getDiffuseColour() const { return mDiffuse; }
  void setSpecularColour(float r, float g, float b) { mSpecular = Colour{r, g, b}; }
  const Colour& getSpecularColour() const { return mSpecular; }

  void setPowerScale(float power) { mPowerScale = power; }
  float getPowerScale() const { return mPowerScale; }

  // 对应 Light::getTypeFlags:SceneManager::LIGHT_TYPE_MASK
  uint32_t getTypeFlags() const { return 0x08000000u; }

  // 对应 getLightDiffuseColourWithPower:只缩放 RGB,不动 alpha
  Colour getDiffuseWithPower() const {
    return Colour{mDiffuse.r * mPowerScale, mDiffuse.g * mPowerScale,
                  mDiffuse.b * mPowerScale};
  }

  // 对应 Light::_calcTempSquareDist:方向光恒 -1 排最前,点光取距离平方
  float calcTempSquareDist(const Vec3& worldPos) const {
    if (mLightType == LT_DIRECTIONAL) return -1.0f;
    Vec3 d = worldPos - mPosition;
    return d.x * d.x + d.y * d.y + d.z * d.z;
  }

  Vec3 mPosition;

 private:
  Colour mDiffuse;
  Colour mSpecular;
  float mPowerScale;
  LightTypes mLightType;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // 默认漫反射白、镜面黑、powerScale 1
  Light light;
  CHECK(colEq(light.getDiffuseColour(), Colour{1.0f, 1.0f, 1.0f}));
  CHECK(colEq(light.getSpecularColour(), Colour{0.0f, 0.0f, 0.0f}));
  CHECK_EQ(light.getPowerScale(), 1.0f);

  // 颜色存储
  light.setDiffuseColour(1.0f, 0.5f, 0.0f);
  CHECK(colEq(light.getDiffuseColour(), Colour{1.0f, 0.5f, 0.0f}));
  light.setSpecularColour(0.2f, 0.4f, 0.6f);
  CHECK(colEq(light.getSpecularColour(), Colour{0.2f, 0.4f, 0.6f}));

  // powerScale:缩放光源 RGB 贡献
  light.setPowerScale(2.0f);
  CHECK_EQ(light.getPowerScale(), 2.0f);
  Colour dp = light.getDiffuseWithPower();
  CHECK(colEq(dp, Colour{2.0f, 1.0f, 0.0f}));

  // 类型标志位:LIGHT_TYPE_MASK = 0x08000000
  CHECK_EQ(light.getTypeFlags(), 0x08000000u);

  // 合成:saturate(light * material)
  Colour lit1 = shade(Colour{1.0f, 0.5f, 0.0f}, Colour{0.8f, 0.8f, 0.8f});
  CHECK(colEq(lit1, Colour{0.8f, 0.4f, 0.0f}));

  // 高光溢出被 saturate 夹回 1
  Colour lit2 = shade(Colour{2.0f, 0.5f, 0.0f}, Colour{1.0f, 1.0f, 1.0f});
  CHECK(colEq(lit2, Colour{1.0f, 0.5f, 0.0f}));

  // 低值按乘法自然变暗
  Colour lit3 = shade(Colour{0.5f, 0.0f, 0.0f}, Colour{0.5f, 1.0f, 1.0f});
  CHECK(colEq(lit3, Colour{0.25f, 0.0f, 0.0f}));

  // _calcTempSquareDist:方向光恒 -1 排最前
  light.setType(Light::LT_DIRECTIONAL);
  CHECK_EQ(light.calcTempSquareDist(Vec3{100, 100, 100}), -1.0f);

  // 点光:取到光源距离平方
  light.setType(Light::LT_POINT);
  light.mPosition = Vec3{0, 0, 0};
  CHECK_EQ(light.calcTempSquareDist(Vec3{10, 20, 30}), 1400.0f);
  CHECK_EQ(light.calcTempSquareDist(Vec3{0, 0, 0}), 0.0f);

  return lab::report("04-3 光照视觉参数:颜色/powerScale/合成/排序");
}

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

小结

  • 漫反射/镜面颜色只负责「光源辐射什么色」,材质决定「反射多少」,着色器逐通道 saturate(light × material) 合成。
  • powerScale 只缩放 RGB 不动 alpha,是全局提亮/闪灯的统一旋钮。
  • getTypeFlags 返回 LIGHT_TYPE_MASK = 0x08000000,把光源归进查询掩码体系。
  • _calcTempSquareDist 用距离平方做排序标签,方向光恒 -1 保证排在点光前。

阅读导航:上一节:4.2 衰减与范围 · 下一节:5.1 阴影技术总览 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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