// 模型变换矩阵，绕 Z 轴旋转
Eigen::Matrix4f get_model_matrix(float rotation_angle)
{
    Eigen::Matrix4f model = Eigen::Matrix4f::Identity();

    float theta = rotation_angle / 180 * MY_PI;
    model << cos(theta), -sin(theta), 0, 0,
        sin(theta), cos(theta), 0, 0,
        0, 0, 1, 0,
        0, 0, 0, 1;

    return model;
}
// 投影矩阵
Eigen::Matrix4f get_projection_matrix(float eye_fov, float aspect_ratio, float zNear, float zFar)
{
    float n = -zNear, f = -zFar;
    float fov = eye_fov / 180 * MY_PI;
    float t = tan(fov / 2) * fabs(n);
    float r = t * aspect_ratio;

    // 透视投影矩阵
    Eigen::Matrix4f Pe = Eigen::Matrix4f::Identity();
    Pe << n, 0, 0, 0,
        0, n, 0, 0,
        0, 0, n + f, -n * f,
        0, 0, 1, 0;

    // 正交投影矩阵 [-r,r]*[-t,t]*[n,f]
    Eigen::Matrix4f Or = Eigen::Matrix4f::Identity();
    Or << 1 / r, 0, 0, 0,
        0, 1 / t, 0, 0,
        0, 0, 2 / (f - n), -(n + f) / 2,
        0, 0, 0, 1;

    return Or * Pe;
}

超采样需要对每个像素中细分出来的点储存深度值和颜色值，否则会出现黑边。

如果颜色只存在像素上，三角形相交区域的边界上只会储存最上面三角形的颜色，无法与其他三角形混合，因此颜色会没有过渡出现黑边。

rasterizer.cpp的部分代码如下：

static bool insideTriangle(float x, float y, const Vector3f* _v)
{
    Vector2f P(x, y);
    Vector2f v[3] = {
        Vector2f(_v[0].x(), _v[0].y()),
        Vector2f(_v[1].x(), _v[1].y()),
        Vector2f(_v[2].x(), _v[2].y())};
    int sign = 0;
    auto Cross = [](const Vector2f &a, const Vector2f &b) { return a.x() * b.y() - a.y() * b.x(); };
    for (int i = 0; i < 3; i++)
    {
        // 求二维叉乘值
        float val = Cross(v[(i + 1) % 3] - v[i], P - v[i]);
        // 在三角形边上
        if (fabs(val) < 1e-8)
            return true;
        if (!sign)
            sign = (val < 0 ? -1 : 1);
        // 叉乘正负性不相同，不在三角形内部
        if ((val < 0 ? -1 : 1) != sign)
            return false;
    }
    return true;
}

// Screen space rasterization
void rst::rasterizer::rasterize_triangle(const Triangle &t)
{
    auto v = t.toVector4();

    // 求出 bounding box
    float L = std::min({v[0].x(), v[1].x(), v[2].x()});
    float R = std::max({v[0].x(), v[1].x(), v[2].x()});
    float B = std::min({v[0].y(), v[1].y(), v[2].y()});
    float T = std::max({v[0].y(), v[1].y(), v[2].y()});

    for (int px = L; px <= R; px++)
        for (int py = B; py <= T; py++)
        {
            // 2x2 的超采样
            int count = 0;
            for (int i = 0; i < 2; i++)
                for (int j = 0; j < 2; j++)
                {
                    float x = px + (i + 0.5) / 2, y = py + (j + 0.5) / 2;
                    if (insideTriangle(x, y, t.v))
                    {
                        count++;
                        // 用重心坐标进行深度插值
                        auto [alpha, beta, gamma] = computeBarycentric2D(x, y, t.v);
                        float w_reciprocal = 1.0 / (alpha / v[0].w() + beta / v[1].w() + gamma / v[2].w());
                        float z_interpolated = alpha * v[0].z() / v[0].w() + beta * v[1].z() / v[1].w() + gamma * v[2].z() / v[2].w();
                        z_interpolated *= w_reciprocal;
                        // z-buffer
                        int index = get_index(px, py) + (i << 1) + j;
                        if (z_interpolated < depth_buf[index])
                        {
                            depth_buf[index] = z_interpolated;
                            color_buf[index] = t.getColor();
                        }
                    }
                }
            if (count > 0)
            {
                int index = get_index(px, py);
                Vector3f color = (color_buf[index] + color_buf[index + 1] + color_buf[index + 2] + color_buf[index + 3]) / 4;
                set_pixel(Vector3f(px, py, 0), color);
            }
        }
}

void rst::rasterizer::clear(rst::Buffers buff)
{
    if ((buff & rst::Buffers::Color) == rst::Buffers::Color)
    {
        std::fill(frame_buf.begin(), frame_buf.end(), Eigen::Vector3f{0, 0, 0});
        std::fill(color_buf.begin(), color_buf.end(), Eigen::Vector3f{0, 0, 0});
    }
    if ((buff & rst::Buffers::Depth) == rst::Buffers::Depth)
    {
        std::fill(depth_buf.begin(), depth_buf.end(), std::numeric_limits<float>::infinity());
    }
}

rst::rasterizer::rasterizer(int w, int h) : width(w), height(h)
{
    frame_buf.resize(w * h);
    depth_buf.resize(w * h * 4);
    color_buf.resize(w * h * 4);
}

int rst::rasterizer::get_index(int x, int y)
{
    return ((height - 1 - y) * width + x) * 4;
}

rasterizer.cpp的部分代码：

// Screen space rasterization
void rst::rasterizer::rasterize_triangle(const Triangle &t, const std::array<Eigen::Vector3f, 3> &view_pos)
{
    auto v = t.toVector4();

    // 求出 bounding box
    float L = std::min({v[0].x(), v[1].x(), v[2].x()});
    float R = std::max({v[0].x(), v[1].x(), v[2].x()});
    float B = std::min({v[0].y(), v[1].y(), v[2].y()});
    float T = std::max({v[0].y(), v[1].y(), v[2].y()});

    for (int px = L; px <= R; px++)
        for (int py = B; py <= T; py++)
        {
            float x = px + 0.5, y = py + 0.5;
            if (insideTriangle(x, y, t.v))
            {
                // 用重心坐标进行深度插值，需要进行透视投影矫正
                auto [alpha, beta, gamma] = computeBarycentric2D(x, y, t.v);
                float Z = 1.0 / (alpha / v[0].w() + beta / v[1].w() + gamma / v[2].w());
                alpha *= Z / v[0].w();
                beta *= Z / v[1].w();
                gamma *= Z / v[2].w();
                float zp = alpha * v[0].z() + beta * v[1].z() + gamma * v[2].z();

                // z-buffer
                int index = get_index(px, py);
                if (zp < depth_buf[index])
                {
                    depth_buf[index] = zp;
                    // 插值信息
                    Vector3f color = alpha * t.color[0] + beta * t.color[1] + gamma * t.color[2];
                    Vector3f normal = alpha * t.normal[0] + beta * t.normal[1] + gamma * t.normal[2];
                    Vector2f texcoords = alpha * t.tex_coords[0] + beta * t.tex_coords[1] + gamma * t.tex_coords[2];
                    Vector3f shadingcoords = alpha * view_pos[0] + beta * view_pos[1] + gamma * view_pos[2];
                    // 着色
                    fragment_shader_payload payload(color, normal.normalized(), texcoords, texture ? &*texture : nullptr);
                    payload.view_pos = shadingcoords;
                    auto pixel_color = fragment_shader(payload);
                    set_pixel(Vector2i(px, py), pixel_color);
                }
            }
        }
}

main.cpp的部分代码：

Eigen::Vector3f texture_fragment_shader(const fragment_shader_payload &payload)
{
    Eigen::Vector3f return_color = {0, 0, 0};
    if (payload.texture)
    {
        return_color = payload.texture->getColor(payload.tex_coords[0], payload.tex_coords[1]);
    }
    Eigen::Vector3f texture_color;
    texture_color << return_color.x(), return_color.y(), return_color.z();

    Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
    Eigen::Vector3f kd = texture_color / 255.f;
    Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);

    auto l1 = light{{20, 20, 20}, {500, 500, 500}};
    auto l2 = light{{-20, 20, 0}, {500, 500, 500}};

    std::vector<light> lights = {l1, l2};
    Eigen::Vector3f amb_light_intensity{10, 10, 10};
    Eigen::Vector3f eye_pos{0, 0, 10};

    float p = 150;

    Eigen::Vector3f color = texture_color;
    Eigen::Vector3f point = payload.view_pos;
    Eigen::Vector3f normal = payload.normal;

    Eigen::Vector3f result_color = {0, 0, 0};
    Vector3f v = (eye_pos - point).normalized(); // 观察方向
    auto Scale = [](const Vector3f &s, const Vector3f &a) { return Vector3f(s.x() * a.x(), s.y() * a.y(), s.z() * a.z()); };
    for (auto &light : lights)
    {
        Vector3f l = light.position - point; // 光照方向
        float r2 = l.squaredNorm();          // 距离平方
        l.normalize();
        Vector3f diffuse = Scale(kd, light.intensity / r2) * std::max(0.0f, l.dot(normal));               // 漫反射项
        Vector3f h = (v + l).normalized();                                                                // 半程向量
        Vector3f specular = Scale(ks, light.intensity / r2) * std::pow(std::max(0.0f, h.dot(normal)), p); // 镜面反射项
        Vector3f ambient = Scale(ka, amb_light_intensity);                                                // 间接光照项
        result_color += diffuse + specular + ambient;
    }

    return result_color * 255.f;
}

Eigen::Vector3f phong_fragment_shader(const fragment_shader_payload &payload)
{
    Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
    Eigen::Vector3f kd = payload.color;
    Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);

    auto l1 = light{{20, 20, 20}, {500, 500, 500}};
    auto l2 = light{{-20, 20, 0}, {500, 500, 500}};

    std::vector<light> lights = {l1, l2};
    Eigen::Vector3f amb_light_intensity{10, 10, 10};
    Eigen::Vector3f eye_pos{0, 0, 10};

    float p = 150;

    Eigen::Vector3f color = payload.color;
    Eigen::Vector3f point = payload.view_pos;
    Eigen::Vector3f normal = payload.normal;

    Eigen::Vector3f result_color = {0, 0, 0};
    Vector3f v = (eye_pos - point).normalized(); // 观察方向
    auto Scale = [](const Vector3f &s, const Vector3f &a) { return Vector3f(s.x() * a.x(), s.y() * a.y(), s.z() * a.z()); };
    for (auto &light : lights)
    {
        Vector3f l = light.position - point; // 光照方向
        float r2 = l.squaredNorm();          // 距离平方
        l.normalize();
        Vector3f diffuse = Scale(kd, light.intensity / r2) * std::max(0.0f, l.dot(normal));               // 漫反射项
        Vector3f h = (v + l).normalized();                                                                // 半程向量
        Vector3f specular = Scale(ks, light.intensity / r2) * std::pow(std::max(0.0f, h.dot(normal)), p); // 镜面反射项
        Vector3f ambient = Scale(ka, amb_light_intensity);                                                // 间接光照项
        result_color += diffuse + specular + ambient;
    }

    return result_color * 255.f;
}

Eigen::Vector3f displacement_fragment_shader(const fragment_shader_payload &payload)
{
    Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
    Eigen::Vector3f kd = payload.color;
    Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);

    auto l1 = light{{20, 20, 20}, {500, 500, 500}};
    auto l2 = light{{-20, 20, 0}, {500, 500, 500}};

    std::vector<light> lights = {l1, l2};
    Eigen::Vector3f amb_light_intensity{10, 10, 10};
    Eigen::Vector3f eye_pos{0, 0, 10};

    float p = 150;

    Eigen::Vector3f color = payload.color;
    Eigen::Vector3f point = payload.view_pos;
    Eigen::Vector3f normal = payload.normal;

    float kh = 0.2, kn = 0.1;

    // TODO: Implement displacement mapping here
    // Let n = normal = (x, y, z)
    // Vector t = (x*y/sqrt(x*x+z*z),sqrt(x*x+z*z),z*y/sqrt(x*x+z*z))
    // Vector b = n cross product t
    // Matrix TBN = [t b n]
    // dU = kh * kn * (h(u+1/w,v)-h(u,v))
    // dV = kh * kn * (h(u,v+1/h)-h(u,v))
    // Vector ln = (-dU, -dV, 1)
    // Position p = p + kn * n * h(u,v)
    // Normal n = normalize(TBN * ln)

    Vector3f n = normal;
    float nx = n.x(), ny = n.y(), nz = n.z();
    Vector3f t(nx * ny / sqrt(nx * nx + nz * nz), sqrt(nx * nx + nz * nz), nz * ny / sqrt(nx * nx + nz * nz));
    Vector3f b = n.cross(t);
    Matrix3f TBN;
    TBN << t.x(), b.x(), n.x(),
        t.y(), b.y(), n.y(),
        t.z(), b.z(), n.z();
    float w = payload.texture->width, h = payload.texture->height;                                                  // 纹理长宽
    float u = payload.tex_coords[0], v = payload.tex_coords[1];                                                     // 纹理坐标
    float dU = kh * kn * (payload.texture->getColor(u + 1 / w, v).norm() - payload.texture->getColor(u, v).norm()); // 梯度
    float dV = kh * kn * (payload.texture->getColor(u, v + 1 / h).norm() - payload.texture->getColor(u, v).norm());
    Vector3f ln(-dU, -dV, 1);
    point += kn * n * payload.texture->getColor(u, v).norm(); // 位移后的位置
    normal = (TBN * ln).normalized();                         // 新的法线

    Eigen::Vector3f result_color = {0, 0, 0};
    Vector3f V = (eye_pos - point).normalized(); // 观察方向
    auto Scale = [](const Vector3f &s, const Vector3f &a) { return Vector3f(s.x() * a.x(), s.y() * a.y(), s.z() * a.z()); };
    for (auto &light : lights)
    {
        Vector3f l = light.position - point; // 光照方向
        float r2 = l.squaredNorm();          // 距离平方
        l.normalize();
        Vector3f diffuse = Scale(kd, light.intensity / r2) * std::max(0.0f, l.dot(normal));               // 漫反射项
        Vector3f h = (V + l).normalized();                                                                // 半程向量
        Vector3f specular = Scale(ks, light.intensity / r2) * std::pow(std::max(0.0f, h.dot(normal)), p); // 镜面反射项
        Vector3f ambient = Scale(ka, amb_light_intensity);                                                // 间接光照项
        result_color += diffuse + specular + ambient;
    }

    return result_color * 255.f;
}

Eigen::Vector3f bump_fragment_shader(const fragment_shader_payload &payload)
{
    Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
    Eigen::Vector3f kd = payload.color;
    Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);

    auto l1 = light{{20, 20, 20}, {500, 500, 500}};
    auto l2 = light{{-20, 20, 0}, {500, 500, 500}};

    std::vector<light> lights = {l1, l2};
    Eigen::Vector3f amb_light_intensity{10, 10, 10};
    Eigen::Vector3f eye_pos{0, 0, 10};

    float p = 150;

    Eigen::Vector3f color = payload.color;
    Eigen::Vector3f point = payload.view_pos;
    Eigen::Vector3f normal = payload.normal;

    float kh = 0.2, kn = 0.1;

    // TODO: Implement bump mapping here
    // Let n = normal = (x, y, z)
    // Vector t = (x*y/sqrt(x*x+z*z),sqrt(x*x+z*z),z*y/sqrt(x*x+z*z))
    // Vector b = n cross product t
    // Matrix TBN = [t b n]
    // dU = kh * kn * (h(u+1/w,v)-h(u,v))
    // dV = kh * kn * (h(u,v+1/h)-h(u,v))
    // Vector ln = (-dU, -dV, 1)
    // Normal n = normalize(TBN * ln)

    Vector3f n = normal;
    float nx = n.x(), ny = n.y(), nz = n.z();
    Vector3f t(nx * ny / sqrt(nx * nx + nz * nz), sqrt(nx * nx + nz * nz), nz * ny / sqrt(nx * nx + nz * nz));
    Vector3f b = n.cross(t);
    Matrix3f TBN;
    TBN << t.x(), b.x(), n.x(),
        t.y(), b.y(), n.y(),
        t.z(), b.z(), n.z();
    float w = payload.texture->width, h = payload.texture->height;                                                  // 纹理长宽
    float u = payload.tex_coords[0], v = payload.tex_coords[1];                                                     // 纹理坐标
    float dU = kh * kn * (payload.texture->getColor(u + 1 / w, v).norm() - payload.texture->getColor(u, v).norm()); // 梯度
    float dV = kh * kn * (payload.texture->getColor(u, v + 1 / h).norm() - payload.texture->getColor(u, v).norm());
    Vector3f ln(-dU, -dV, 1);
    normal = (TBN * ln).normalized(); // 新的法线

    Eigen::Vector3f result_color = {0, 0, 0};
    result_color = normal;

    return result_color * 255.f;
}

template <typename T>
T lerp(const T &a, const T &b, float t)
{
    return a + (b - a) * t;
}
cv::Point2f recursive_bezier(std::vector<cv::Point2f> &control_points, float t)
{
    if (control_points.empty())
        return cv::Point2f(0, 0);
    if (control_points.size() == 1)
        return control_points[0];
    for (int i = 0, si = control_points.size(); i < si - 1; i++)
        control_points[i] = lerp(control_points[i], control_points[i + 1], t);
    control_points.pop_back();
    return recursive_bezier(control_points, t);
}
void bezier(const std::vector<cv::Point2f> &control_points, cv::Mat &window)
{
    std::vector<cv::Point2f> tem_points;
    for (double t = 0.0; t <= 1.0; t += 0.001)
    {
        tem_points = control_points;
        auto point = recursive_bezier(tem_points, t);
        window.at<cv::Vec3b>(point.y, point.x)[2] = 255;
    }
}

如果Render函数中使用i+0.5和j+0.5，会在阴影处出现背景色蓝点，原因不明。

Renderer.cpp的部分代码：

void Renderer::Render(const Scene &scene)
{
    std::vector<Vector3f> framebuffer(scene.width * scene.height);

    // scale = t / |zNear|
    // imageAspectRatio = r / t
    // 只需要给出 fov ，不需要给出 zNear ，原因在下面解释
    float scale = std::tan(deg2rad(scene.fov * 0.5f));
    float imageAspectRatio = scene.width / (float)scene.height;

    // Use this variable as the eye position to start your rays.
    Vector3f eye_pos(0);
    int m = 0;
    for (int j = 0; j < scene.height; ++j)
    {
        for (int i = 0; i < scene.width; ++i)
        {
            // generate primary ray direction
            // TODO: Find the x and y positions of the current pixel to get the direction
            // vector that passes through it.
            // Also, don't forget to multiply both of them with the variable *scale*, and
            // x (horizontal) variable with the *imageAspectRatio*

            // x = pixelX * imageAspectRatio * scale * |zNear|
            // y = pixelY * scale * |zNear|
            float x = (2.0 * i / scene.width - 1) * imageAspectRatio * scale * 1;
            float y = (1 - 2.0 * j / scene.height) * scale * 1;

            // 方向向量要单位化，zNear 会被单位化掉，因此有 fov 即可，不需要 zNear 具体数值
            Vector3f dir = normalize(Vector3f(x, y, -1)); // Don't forget to normalize this direction!
            framebuffer[m++] = castRay(eye_pos, dir, scene, 0);
        }
        UpdateProgress(j / (float)scene.height);
    }

    // save framebuffer to file
    FILE *fp = fopen("binary.ppm", "wb");
    (void)fprintf(fp, "P6\n%d %d\n255\n", scene.width, scene.height);
    for (auto i = 0; i < scene.height * scene.width; ++i)
    {
        static unsigned char color[3];
        color[0] = (char)(255 * clamp(0, 1, framebuffer[i].x));
        color[1] = (char)(255 * clamp(0, 1, framebuffer[i].y));
        color[2] = (char)(255 * clamp(0, 1, framebuffer[i].z));
        fwrite(color, 1, 3, fp);
    }
    fclose(fp);
}

Triangle.hpp的部分代码：

bool rayTriangleIntersect(const Vector3f &v0, const Vector3f &v1, const Vector3f &v2, const Vector3f &orig,
                          const Vector3f &dir, float &tnear, float &u, float &v)
{
    // TODO: Implement this function that tests whether the triangle
    // that's specified bt v0, v1 and v2 intersects with the ray (whose
    // origin is *orig* and direction is *dir*)
    // Also don't forget to update tnear, u and v.

    Vector3f e1 = v1 - v0, e2 = v2 - v0, s = orig - v0;
    Vector3f s1 = crossProduct(dir, e2), s2 = crossProduct(s, e1);
    float val = dotProduct(s1, e1);
    if (fabs(val) < 1e-8) // dir 与三角形面平行
        return false;

    tnear = dotProduct(s2, e2) / val;
    u = dotProduct(s1, s) / val;
    v = dotProduct(s2, dir) / val;
    return tnear >= 0 && u >= 0 && v >= 0 && 1 - u - v >= 0; // 射线正方向，三角形内部
}

Renderer.cpp的部分代码：

void Renderer::Render(const Scene &scene)
{
    std::vector<Vector3f> framebuffer(scene.width * scene.height);

    float scale = tan(deg2rad(scene.fov * 0.5));
    float imageAspectRatio = scene.width / (float)scene.height;
    Vector3f eye_pos(-1, 5, 10);
    int m = 0;
    for (uint32_t j = 0; j < scene.height; ++j)
    {
        for (uint32_t i = 0; i < scene.width; ++i)
        {
            // generate primary ray direction
            float x = (2 * (i + 0.5) / (float)scene.width - 1) * imageAspectRatio * scale;
            float y = (1 - 2 * (j + 0.5) / (float)scene.height) * scale;
            Vector3f dir = normalize(Vector3f(x, y, -1));
            framebuffer[m++] = scene.castRay(Ray(eye_pos, dir), 0);
        }
        UpdateProgress(j / (float)scene.height);
    }
    UpdateProgress(1.f);

    // save framebuffer to file
    FILE *fp = fopen("binary.ppm", "wb");
    (void)fprintf(fp, "P6\n%d %d\n255\n", scene.width, scene.height);
    for (auto i = 0; i < scene.height * scene.width; ++i)
    {
        static unsigned char color[3];
        color[0] = (unsigned char)(255 * clamp(0, 1, framebuffer[i].x));
        color[1] = (unsigned char)(255 * clamp(0, 1, framebuffer[i].y));
        color[2] = (unsigned char)(255 * clamp(0, 1, framebuffer[i].z));
        fwrite(color, 1, 3, fp);
    }
    fclose(fp);
}

Triangle.hpp的部分代码：

inline Intersection Triangle::getIntersection(Ray ray)
{
    Intersection inter;

    if (dotProduct(ray.direction, normal) > 0) // 忽略反方向的光
        return inter;
    double u, v, t_tmp = 0;
    Vector3f pvec = crossProduct(ray.direction, e2); // s1
    double det = dotProduct(e1, pvec);
    if (fabs(det) < EPSILON)
        return inter;

    double det_inv = 1. / det;
    Vector3f tvec = ray.origin - v0; // s
    u = dotProduct(tvec, pvec) * det_inv;
    if (u < 0 || u > 1)
        return inter;
    Vector3f qvec = crossProduct(tvec, e1); // s2
    v = dotProduct(ray.direction, qvec) * det_inv;
    if (v < 0 || u + v > 1)
        return inter;
    t_tmp = dotProduct(e2, qvec) * det_inv; // tnear
    if (t_tmp < ray.t_min || t_tmp > ray.t_max)
        return inter;

    // TODO find ray triangle intersection
    inter.happened = true;       // 相交
    inter.coords = ray(t_tmp);   // 交点
    inter.normal = this->normal; // 法线
    inter.m = this->m;           // 材质
    inter.obj = this;            // 对象
    inter.distance = t_tmp;      // 距离
    return inter;
}

Bounds3.hpp的部分代码：

inline bool Bounds3::IntersectP(const Ray &ray, const Vector3f &invDir, const std::array<int, 3> &dirIsNeg) const
{
    // invDir: ray direction(x,y,z), invDir=(1.0/x,1.0/y,1.0/z), use this because Multiply is faster that Division
    // dirIsNeg: ray direction(x,y,z), dirIsNeg=[int(x>0),int(y>0),int(z>0)], use this to simplify your logic
    // TODO test if ray bound intersects
    Vector3f tmin = (pMin - ray.origin) * invDir;
    Vector3f tmax = (pMax - ray.origin) * invDir;
    if (!dirIsNeg[0])
        std::swap(tmin.x, tmax.x);
    if (!dirIsNeg[1])
        std::swap(tmin.y, tmax.y);
    if (!dirIsNeg[2])
        std::swap(tmin.z, tmax.z);
    float tenter = std::max({tmin.x, tmin.y, tmin.z});
    float texit = std::min({tmax.x, tmax.y, tmax.z});
    return tenter < texit && texit >= 0;
}

BVH.cpp的部分代码：

Intersection BVHAccel::getIntersection(BVHBuildNode *node, const Ray &ray) const
{
    // TODO Traverse the BVH to find intersection
    Intersection inter;
    if (node == nullptr)
        return inter;
    std::array<int, 3> dirIsNeg{ray.direction.x > 0, ray.direction.y > 0, ray.direction.z > 0};
    if (!node->bounds.IntersectP(ray, ray.direction_inv, dirIsNeg)) // 和包围盒不相交，直接退出
        return inter;
    if (node->object != nullptr) // 该节点有物体，求交点
        return node->object->getIntersection(ray);

    Intersection interl = getIntersection(node->left, ray);
    Intersection interr = getIntersection(node->right, ray);
    inter = interl.distance < interr.distance ? interl : interr; // 取近的交点
    return inter;
}

Bounds3.hpp的部分代码：

inline bool Bounds3::IntersectP(const Ray &ray, const Vector3f &invDir, const std::array<int, 3> &dirIsNeg) const
{
    // invDir: ray direction(x,y,z), invDir=(1.0/x,1.0/y,1.0/z), use this because Multiply is faster that Division
    // dirIsNeg: ray direction(x,y,z), dirIsNeg=[int(x>0),int(y>0),int(z>0)], use this to simplify your logic
    // TODO test if ray bound intersects
    Vector3f tmin = (pMin - ray.origin) * invDir;
    Vector3f tmax = (pMax - ray.origin) * invDir;
    if (!dirIsNeg[0])
        std::swap(tmin.x, tmax.x);
    if (!dirIsNeg[1])
        std::swap(tmin.y, tmax.y);
    if (!dirIsNeg[2])
        std::swap(tmin.z, tmax.z);
    float tenter = std::max({tmin.x, tmin.y, tmin.z});
    float texit = std::min({tmax.x, tmax.y, tmax.z});
    return tenter <= texit && texit >= 0; // tenter <= texit 需要等号，有交点是一个点的情况
}

Scene.cpp的部分代码：

Vector3f Scene::castRay(const Ray &ray, int depth) const
{
    // TO DO Implement Path Tracing Algorithm here
    Intersection obj = intersect(ray); // 求出着色点
    if (!obj.happened)                 // 找不到着色点
        return Vector3f(0, 0, 0);
    Vector3f p = obj.coords, wo = ray.direction, n = obj.normal; // 着色点参数

    Intersection interLight;
    float pdf_light = 0;
    sampleLight(interLight, pdf_light); // 从光源采样一个点
    Vector3f x = interLight.coords;     // 光源采样点
    Vector3f ws = normalize(x - p);     // p->x

    Intersection block = intersect(Ray(p, ws));             // 射线p->x求交
    Vector3f L_dir(0, 0, 0);                                // 直接光照
    if (block.happened && (block.coords - x).norm() < 1e-4) // p->x没有被阻挡
    {
        Vector3f nn = interLight.normal; // 光源采样点法线
        Vector3f Li = interLight.emit;
        Vector3f f_r = obj.m->eval(wo, ws, n);
        float cosp = dotProduct(n, ws);
        float cosx = dotProduct(nn, -ws);
        float dis = (x - p).norm();
        L_dir = Li * f_r * cosp * cosx / dis / dis / pdf_light;
    }

    Vector3f L_indir(0, 0, 0);                 // 间接光照
    if (get_random_float() <= RussianRoulette) // 轮盘赌
    {
        Vector3f wi = normalize(obj.m->sample(wo, n)); // 采样一个出射光线
        Intersection interObj = intersect(Ray(p, wi));
        if (interObj.happened && !interObj.m->hasEmission()) // 打到的不是光源
        {
            Vector3f q = interObj.coords;
            Vector3f Li = castRay(Ray(p, wi), depth + 1);
            Vector3f f_r = obj.m->eval(wo, wi, n);
            float cos = dotProduct(n, wi);
            float pdf = obj.m->pdf(wo, wi, n);
            L_indir = Li * f_r * cos / pdf / RussianRoulette;
        }
    }

    return obj.m->getEmission() + L_dir + L_indir; // 自发光+直接光照+间接光照
}