光线追踪代码优化：如何避免类成员函数中基于构造输入的if判断

你遇到的核心问题是：intersect函数被调用数十亿次，其中的smoothShading分支判断完全冗余（构造时就已确定），但拆分类会带来容器类型兼容问题，智能指针又会引入额外的间接访问开销。下面提供几种零运行时分支开销的解决方案，适配不同代码场景：

方案1：编译期多态（CRTP）—— 完全消除虚函数开销 #

把Triangle的公共数据抽离到基类，再通过CRTP（奇异递归模板模式）派生出不同着色类型的子类，让intersect逻辑在编译期绑定：

// 公共数据基类，存储顶点和平面法向量
template<typename Tp>
struct TriangleBase {
    Vertex<Tp> v0, v1, v2;
    vec3<Tp> n;

    TriangleBase(Vertex<Tp> v0_, Vertex<Tp> v1_, Vertex<Tp> v2_)
        : v0(std::move(v0_)), v1(std::move(v1_)), v2(std::move(v2_)) {
        // 提前预计算平面法向量（Flat着色时直接使用）
        n = normalize(cross(v1.position - v0.position, v2.position - v0.position));
    }
};

// Flat着色的Triangle实现
template<typename Tp>
struct FlatTriangle : public TriangleBase<Tp> {
    using Base = TriangleBase<Tp>;
    FlatTriangle(Vertex<Tp> v0, Vertex<Tp> v1, Vertex<Tp> v2)
        : Base(std::move(v0), std::move(v1), std::move(v2)) {}

    void intersect(Ray<Tp>& ray) const {
        ray.hit.n = -this->n;
    }
};

// Smooth着色的Triangle实现
template<typename Tp>
struct SmoothTriangle : public TriangleBase<Tp> {
    using Base = TriangleBase<Tp>;
    SmoothTriangle(Vertex<Tp> v0, Vertex<Tp> v1, Vertex<Tp> v2)
        : Base(std::move(v0), std::move(v1), std::move(v2)) {}

    void intersect(Ray<Tp>& ray) const {
        const auto w = 1.0f - ray.hit.uv[0] - ray.hit.uv[1];
        ray.hit.n = normalize(ray.hit.uv[0] * this->v1.normal + ray.hit.uv[1] * this->v2.normal + w * this->v0.normal);
    }
};

适配容器场景： #

• 如果场景中只有单一着色类型的三角形，直接用std::vector<FlatTriangle<float>>或std::vector<SmoothTriangle<float>>，完全没有运行时开销；
• 如果需要混合存储两种类型，用std::vector<std::variant<FlatTriangle<float>, SmoothTriangle<float>>>, 调用时通过std::visit分发：

std::vector<std::variant<FlatTriangle<float>, SmoothTriangle<float>>> triangles;
// ... 填充三角形数据
Ray<float> ray;
for (const auto& tri : triangles) {
    std::visit([&ray](const auto& t) { t.intersect(ray); }, tri);
}

std::visit的分发开销可以忽略不计，且不会有分支预测失败的问题。

方案2：函数指针绑定—— 最小改动现有代码 #

如果不想大幅修改类结构，可以在Triangle构造时，将对应着色逻辑的函数指针存储下来，调用时直接通过指针跳转，彻底消除条件分支：

template<typename Tp>
class Triangle {
public:
    using IntersectFunc = void(Triangle<Tp>::*)(Ray<Tp>&) const;

    Triangle(Vertex<Tp> v0_, Vertex<Tp> v1_, Vertex<Tp> v2_, bool smoothShading)
        : v0(std::move(v0_)), v1(std::move(v1_)), v2(std::move(v2_)) {
        n = normalize(cross(v1.position - v0.position, v2.position - v0.position));
        // 构造时绑定对应的intersect函数
        intersectFunc = smoothShading ? &Triangle::smoothIntersect : &Triangle::flatIntersect;
    }

    void intersect(Ray<Tp>& ray) const {
        (this->*intersectFunc)(ray); // 直接调用，无分支判断
    }

private:
    void smoothIntersect(Ray<Tp>& ray) const {
        const auto w = 1.0f - ray.hit.uv[0] - ray.hit.uv[1];
        ray.hit.n = normalize(ray.hit.uv[0] * v1.normal + ray.hit.uv[1] * v2.normal + w * v0.normal);
    }

    void flatIntersect(Ray<Tp>& ray) const {
        ray.hit.n = -n;
    }

    IntersectFunc intersectFunc;
    Vertex<Tp> v0, v1, v2;
    vec3<Tp> n;
    // 原有的smoothShading成员可以删除，已被函数指针替代
};

这个方案完全兼容你原来的std::vector<Triangle<float>>容器，每次intersect调用都是直接的函数指针跳转，没有条件分支的开销，也不会有智能指针的间接访问成本。

方案3：模板参数控制着色类型—— 编译期彻底消除分支 #

把smoothShading作为模板参数，让编译器在编译期就生成对应着色逻辑的代码，完全没有运行时的分支判断：

template<typename Tp, bool SmoothShading>
class Triangle {
public:
    Triangle(Vertex<Tp> v0_, Vertex<Tp> v1_, Vertex<Tp> v2_)
        : v0(std::move(v0_)), v1(std::move(v1_)), v2(std::move(v2_)) {
        n = normalize(cross(v1.position - v0.position, v2.position - v0.position));
    }

    void intersect(Ray<Tp>& ray) const {
        if constexpr (SmoothShading) {
            const auto w = 1.0f - ray.hit.uv[0] - ray.hit.uv[1];
            ray.hit.n = normalize(ray.hit.uv[0] * v1.normal + ray.hit.uv[1] * v2.normal + w * v0.normal);
        } else {
            ray.hit.n = -n;
        }
    }

private:
    Vertex<Tp> v0, v1, v2;
    vec3<Tp> n;
};

使用方式： #

• Flat着色三角形：Triangle<float, false>
• Smooth着色三角形：Triangle<float, true>

这种方案性能最优，因为if constexpr是编译期分支，编译后会直接生成对应逻辑的代码，没有任何运行时开销。如果需要混合存储，同样可以搭配std::variant使用。

内容的提问来源于stack exchange，提问作者Chris Gnam