Ray Tracing¶

bool rayTriangleIntersect(const Vector3f& v0, const Vector3f& v1, const Vector3f& v2, const Vector3f& orig,
                          const Vector3f& dir, float& tnear, float& u, float& v)
{
    // 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*)
    Vector3f E_1 = v1 - v0;
    Vector3f E_2 = v2 - v0;
    Vector3f S = orig - v0;
    Vector3f S_1 = crossProduct(dir, E_2);
    Vector3f S_2 = crossProduct(S, E_1);
    float inv = 1 / dotProduct(S_1, E_1);
    tnear = dotProduct(S_2, E_2) * inv;
    u = dotProduct(S_1, S) * inv;
    v = dotProduct(S_2, dir) * inv;
    if (u >= 0 && v >= 0 && u + v <= 1 && tnear >= 0)
        return true;
    return false;
}

/*
采用两个点表示 BoundingBox，分别为 pmin 和 pmax
*/
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
    // 这里假设 v=\sqrt{x^2+y^2+z^2}，则 v_x = x，那么就能明白 invDir 的用处了
    // 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
    double t1 = 0, t2 = 0, tmin = 0, tmax = 0;
    t1 = (pMin.x - ray.origin.x) * invDir.x;
    t2 = (pMax.x - ray.origin.x) * invDir.x;
    tmin = (dirIsNeg[0]>0)?t1:t2;
    tmax = (dirIsNeg[0]>0)?t2:t1;
    t1 = (pMin.y - ray.origin.y) * invDir.y;
    t2 = (pMax.y - ray.origin.y) * invDir.y;
    tmin = std::max(tmin, (dirIsNeg[1]>0)?t1:t2);
    tmax = std::min(tmax, (dirIsNeg[1]>0)?t2:t1);
    t1 = (pMin.z - ray.origin.z) * invDir.z;
    t2 = (pMax.z - ray.origin.z) * invDir.z;
    tmin = std::max(tmin, (dirIsNeg[2]>0)?t1:t2);
    tmax = std::min(tmax, (dirIsNeg[2]>0)?t2:t1);

    if(tmin < tmax && tmax >= 0) return true;
    else return false;
}

shade(p, wo):
    Randomly choose N directions wi~pdf
    Lo = 0.0
    for each wi:
        Trace a ray r(p, wi)
        if ray r hit the light:
            Lo += (1/N) * L_i * f_r * cosine / pdf(wi)
        else if ray r hit an object at position q:
            Lo += (1/N) * shade(q, -wi) * f_r * cosine / pdf(wi)
    return Lo

shade(p, wo):
    Randomly choose 1 directions wi~pdf(w)
    Trace a ray r(p, wi)
    if ray r hit the light:
        Lo = L_i * f_r * cosine / pdf(wi)
    else if ray r hit an object at position q:
        Lo = shade(q, -wi) * f_r * cosine / pdf(wi)
    return Lo

ray_generation(camPos, pixel):
    Uniformly choose N sample positions within pixel
    pixel_radience = 0.0
    for each sample in the pixel
        shoot a ray r(camPos, cam_to_sample)
        if ray r hit the scene at p
            pixel_radience += 1/N * shade(p, sample_to_cam)
    return pixel_radience

shade(p, wo)
    Manually specify a probability P_RR
    Randomly select a ksi in a uniform dist, in [0,1]
    if(ksi > P_RR) return 0.0

    Randomly choose 1 directions wi~pdf(w)
    Trace a ray r(p, wi)
    if ray r hit the light:
        Lo = L_i * f_r * cosine / pdf(wi) / P_RR
    else if ray r hit an object at position q:
        Lo = shade(q, -wi) * f_r * cosine / pdf(wi) / P_RR
    return Lo

shade(p, wo)
    # contribution from the light source
    Uniform sample the light at x', pdf_light = 1/A
    L_dir = L_i * f_r * cos θ * cos θ' / |x'-p|^2 / pdf_light

    # contribution from other reflector
    L_indir = 0.0
    Manually specify a probability P_RR
    Randomly select a ksi in a uniform dist, in [0,1]
    if(ksi > P_RR) return 0.0

    Uniform sample the hemisphere toward wi, pdf_hemi = 1/2pi
    Trace a ray r(p, wi)
    if ray r hit a non-emitting object at position q:
        L_indir = shade(q, -wi) * f_r * cos θ / pdf_hemi / P_RR

    # return the sum of them
    return L_dir + L_indir

Vector3f Scene::shade(Intersection &pos, const Vector3f &wo) const
{
    Vector3f L_dir(0), L_indir(0);

    // 直接光照
    Intersection light;
    float light_pdf;
    sampleLight(light, light_pdf);
    Vector3f obj2light = light.coords - pos.coords;

    Vector3f obj2light_normalized = obj2light.normalized();
    auto t = intersect(Ray(pos.coords, obj2light_normalized));
    if(t.distance + EPSILON > obj2light.norm())
    { // 光线未被遮挡，EPSILON放宽精度防止自相交
        Vector3f f_r = pos.m->eval(obj2light, wo, pos.normal);
        float cos_theta = std::max(0.0f, dotProduct(pos.normal, obj2light_normalized));
        float cos_theta_prime = std::max(0.0f, dotProduct(light.normal, -obj2light_normalized));
        L_dir = light.emit * f_r * cos_theta * cos_theta_prime / (obj2light.norm() * obj2light.norm()) / light_pdf;
    }

    // 间接光照
    if(get_random_float() < RussianRoulette)
    {
        Vector3f wi = pos.m->sample(wo, pos.normal);
        Ray ray(pos.coords, wi);
        Intersection next_pos = intersect(ray);
        if(next_pos.happened)
        {
            L_indir = shade(next_pos, -wi);
            Vector3f f_r = pos.m->eval(wi, wo, pos.normal);
            float cos_theta = std::max(0.0f, dotProduct(pos.normal, wi));
            L_indir = L_indir * f_r * cos_theta * 2 * PI / RussianRoulette;
        }
    }

    return L_dir + L_indir;
}