Problem with PDF Light sampling

[aaalloc]

Hey,

I'm currently implementing ray tracing book in wgpu/wgsl/rust

I'm trying to implement https://raytracing.github.io/books/RayTracingTheRestOfYourLife.html#samplinglightsdirectly
I've tried the hard coded part and it gives me the right result (I guess)

But later when refactoring it and for having the pdf of a quad

    double pdf_value(const point3& origin, const vec3& direction) const override {
        hit_record rec;
        if (!this->hit(ray(origin, direction), interval(0.001, infinity), rec))
            return 0;

        auto distance_squared = rec.t * rec.t * direction.length_squared();
        auto cosine = std::fabs(dot(direction, rec.normal) / direction.length());

        return distance_squared / (cosine * area);
    }

to

fn pdf_light_value(origin: vec3<f32>, direction: vec3<f32>) -> f32 {
    let light = lights[0];
    let vertices_1 = surfaces[objects[light.id].offset].vertices;

    let area = area_surface(vertices_1) * 2.0;
    var hit = HitRecord();
    if !check_intersection(Ray(origin, direction), &hit) {
        return 0.0;
    }


    let distance = hit.t * hit.t * length(direction * direction);
    let cosine = abs(dot(direction, hit.normal) / length(direction));
    return distance / (cosine * area);
}

I'm having something like this

Those white lines around the rectangle is provoked by the hit.t²

    let distance = hit.t * hit.t * length(direction * direction);

I've tried to look at my code at every angle and I can't find any solution ....

this is the ray_color function

fn ray_color(first_ray: Ray, rngState: ptr<function, u32>) -> vec3<f32> {
    var ray = first_ray;
    var sky_color = vec3(0.0);
    var color_from_scatter = vec3(1.0);
    var color_from_emission = vec3(0.0);

    for (var i = 0u; i < render_param.max_depth; i += 1u) {
        var intersection = HitRecord();
        if !check_intersection(ray, &intersection) {
            let direction = normalize(ray.direction);
            let a = 0.5 * (direction.y + 1.0);
            // sky_color = (1.0 - a) * vec3<f32>(1.0, 1.0, 1.0) + a * vec3<f32>(0.5, 0.7, 1);
            break;
        }
        // for triangles only
        if !intersection.front_face {
            continue;
        }

        let material = materials[intersection.material_index];
        color_from_emission += color_from_scatter * emitted(material, 0.5, 0.5, intersection);

        var scattered = Scatter();
        if !scatter(&scattered, ray, intersection, material, rngState) {
            break;
        }
        if scattered.type_pdf == PDF_NONE {
            color_from_scatter *= scattered.attenuation;
            ray = scattered.ray;
            continue;
        }
        scattered.ray.origin = intersection.p;
        scattered.ray.direction = pdf_light_generate(rngState, intersection.p);
        let pdf = pdf_light_value(intersection.p, scattered.ray.direction);

        let scattering_pdf = scattering_pdf_lambertian(intersection.normal, scattered.ray.direction);

        color_from_scatter *= (scattered.attenuation * scattering_pdf) / pdf;
        ray = scattered.ray;
    }
    return color_from_emission + color_from_scatter * sky_color;
}

Any idea on how to fix that ?

[hollasch]

From a quick review of the code, I believe this is just a simplification of

$$ \text{distance} = (\text{direction.length} * t)^2 $$

since the vector from the ray origin to the intersection point is $\text{ray.origin} + t * \text{ray.direction}$, and its length is just $t * \text{ray.direction}$. So length squared is

$$ (\text{ray.direction.length} * t)^2 = t * t * \text{ray.direction.length}^2 = t * t * \text{ray.direction.lengthSquared} $$

Unless I'm misunderstanding your question of this line. Still, I don't think this helps explain the effect you're noting above.

All of this depends on the assumption that the ray is actually originating from the view position, and that the direction vector hasn't been normalized after computing $t$ or something like that. That is, it should be true that $rec.p = direction.origin() + t * direction.direction()$.

[aaalloc]

All of this depends on the assumption that the ray is actually originating from the view position, and that the direction vector hasn't been normalized after computing t or something like that. That is, it should be true that ...

Yeah this is the case

fn hit_triangle(
    triangle_index: u32,
    material_index: u32,
    ray: Ray,
    ray_min: f32,
    ray_max: f32,
    hit: ptr<function, HitRecord>,
) -> bool {
// https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm

    let surface = surfaces[triangle_index];

    let e1 = surface.vertices[1].xyz - surface.vertices[0].xyz;
    let e2 = surface.vertices[2].xyz - surface.vertices[0].xyz;
    let h = cross(ray.direction, e2);
    let a = dot(e1, h);

    if a > -EPSILON && a < EPSILON {
        return false;
    }

    let f = 1.0 / a;
    let s = ray.origin - surface.vertices[0].xyz;
    let u = f * dot(s, h);

    if u < 0.0 || u > 1.0 {
        return false;
    }

    let q = cross(s, e1);
    let v = f * dot(ray.direction, q);

    if v < 0.0 || u + v > 1.0 {
        return false;
    }

    let t = f * dot(e2, q);
    if t > ray_min && t < ray_max {
        let p = ray.origin + t * ray.direction;
        let b = vec3(1.0 - u - v, u, v);
        let n = b.x * surface.normals[0].xyz + b.y * surface.normals[1].xyz + b.z * surface.normals[2].xyz;
        let front_face = dot(ray.direction, n) < 0.0;
        *hit = HitRecord(p, normalize(n), t, material_index, front_face, triangle_index);
        return true;
    }

    return false;
}