How does one create a glossy material like Phong shading with importance sampling?

[miguelggcc]

EDIT; I MEAN PHONG REFLECTION MODEL, NOT SHADING
For what I understand, there's three main functions on the program when it comes to importance sampling:

1. value returns PDF for known incoming and outgoing directions based on the PDF class
2. generate: samples BRDF to return a new (outgoing) ray direction.
3. scattering_pdf: returns PDF of sampling given incoming and outgoing direction

With no multiple importance sampling 1. and 3. should return the same value.

Doing some look around, I found that the PDF for the specular part of a Phong material would be PDF = (n+1)/(2*PI) * (cos α)^m, and based on that I can calculate the direction sampling for a reflected ray proportional to (cos α) ^m, like on this Lafortune paper(https://www.cs.princeton.edu/courses/archive/fall03/cs526/papers/lafortune94.pdf).

The way I thought of doing it is choosing randomly between specular and diffuse scattering based on the Phong diffuse/specular parameters. If it is diffuse, I just do pdf = cos (theta)/pi and I sample with the random_cosine_direction() function. If it is specular, I still set srec.is_specular to false because I want to use the PDF functions. The problem arises once I've set if it's specular or diffuse and I call scattering_pdf with rec.mat_ptr->scattering_pdf(r, rec, scattered), how can it know if its diffuse or specular to calculate the specific PDF with the current structure just based on the incoming/outcoming ray? Am I missing something that makes everything much easier? Am I in the right path?

[ghadeeras]

Hello!

I hope I properly understood your question. My experience with ray tracing is relatively recent. So I hope someone could validate my answer:

When generating a scatter ray, if you're randomly choosing between diffuse and specular, you must be using some weights for each, say Wd and Ws, such that Wd + Ws = 1.

For instance:

// Scattered ray generation
if (random() < Wd) {
  return random_diffuse_ray(...);
} else {
  return random_specular_ray(...);
}

If so, the scattering PDF should be a weighted sum of the two PDFs, no matter which function generated the ray:

  scatter_pdf = Wd * diffuse_pdf(ray, ...) + Ws * specular_pdf(ray, ...);

I hope this helps.

Cheers!

[miguelggcc]

You were right, I was choosing between diffuse and specular pdfs instead of doing a weighted sum, which was causing weird artifacts.
The problem i had next was that the result was too "white", like the material color came back with a brighter tone than it should. I think I figured it out after some research, the current way it is done in the thrid book doesn't work for a phong like material, because the pdf values get multiplied by the attenuation, and in this case the pdf includes the diffuse pdf and specular pdf, but the specular pdf's attenuation is normally (1.0,1.0,1.0) because you usually want to reflect the light without attenuation. Consequently, you will need to separate the pdfs so that you get attenuation*diffuse_pdf + (1.0,1.0,1.0)*specular_pdf in the Monte Carlo integrator.

My crappy solution was turning the pdfs value from a float to a vector3, and for the specular pdf I pre-multiply it by the inverse of the attenuation, so that it cancels out. It seems to work but it's not too elegant, I hope someone can tell me a better way, or if this is even correct.

I ended up creating a new part of the integrator, leaving me with three possible paths, specular scattering, diffuse scattering and SpecularDiffuse (Blinn Phong) scattering. The latter looks like this:

 ScatterRecord::SpecularDiffuse {
                    pdf_specular,
                    pdf_diffuse,
                    k_specular,
                    attenuation,
                } => {
                    let pdf_lights = PDFType::PDFObj {
                        pdf: PDF::new(hit.p, light),
                    };
                    let mixture_diffuse = PDFMixture::new(&pdf_lights, &pdf_diffuse);
                    let mixture_specular = PDFMixture::new(&pdf_lights, &pdf_specular);

                    let is_specular = rng.gen::<f32>() < k_specular;

                    let scattered = if is_specular {
                        Ray::new(hit.p, mixture_specular.generate(chance, rng))
                    } else {
                        Ray::new(hit.p, mixture_diffuse.generate(chance, rng))
                    };
                    
                    let pdf_val = mixture_diffuse.value(chance, scattered.direction)
                        * (1.0 - k_specular)
                        + mixture_specular.value(chance, scattered.direction) * k_specular;

                    let pdf_multiplicator_diffuse =
                        pdf_diffuse.value(scattered.direction) / pdf_val;
                    let pdf_multiplicator_specular =
                        pdf_specular.value(scattered.direction) / pdf_val;

                    color = color
                        * (attenuation * pdf_multiplicator_diffuse * (1.0 - k_specular)
                            + Vector3::new(1.0, 1.0, 1.0)
                                * pdf_multiplicator_specular
                                * k_specular);

                    scatter_ray = scattered;

                    continue;
                }

It's in Rust but you hopefully get the idea. pdf_diffuse is just a cosine pdf just like the lambertian, pdf_specular is the Blinn Phong normalized pdf:

let normal_pdf =
                (pdf.exponent + 1.0) / (2.0 * PI) * cosine_specular.powf(pdf.exponent);

The result is the following: