Reproducing the "before Fresnel" and "after Fresnel" picture

Thanks for sharing your repo! Your code looks really great overall. The only difference I can see is in the very last line of the schlick function, here: github.com/Disembleergon/3d-raytracer/blob/master/3d-raytracing-renderer/World.cpp#L133

return std::pow(r0 + (1 - r0) * (1 - cos), 5);

Here, you're raising r0 + (1 - r0) * (1 - cos) to the fifth power. What should actually be happening is taking (1 - cos) to the fifth power, and multiplying that by (1 - r0), e.g.:

return r0 + (1 - r0) * std::pow((1 - cos), 5);

If you look closely at the lower edges of your black spheres, you can see that there is a little bit of refraction going on. At the very edges of your sphere, I believe the value of the schlick function approaches 1, which means even raising it to the fifth power will make little difference, resulting in the bits of refraction you see in your image. I'm optimistic that if you fix that last line to raise only (1 - cos) to the fifth power, the rest of the sphere should render correctly, too!

Let me know if that helps,

Jamis

Okay, let's try this, then. When I render (at 300x300) the pixel at 141,141 and display the state of the renderer at that point, here's what I get:

color: v(0.4126,0.4126,0.4126)
t: 4.00337188413327
point: p(-0.0519,0.0519,-0.9973)
inside: false
eyev: v(0.0130,-0.0130,-0.9998)
normalv: v(-0.0519,0.0519,-0.9973)
reflectv: v(-0.1164,0.1164,-0.9864)
over point: p(-0.0519,0.0519,-0.9974)
under point: p(-0.0519,0.0519,-0.9972)
n1: 1
n2: 1.5
schlick: 0.04000000000127377


Because of variation in your scene and your renderer, you may not get exactly these numbers, but they should be in about the same ballpark. Maybe any differences will suggest where things are not right in your implementation?

edit: I should clarify -- these numbers are for the very first intersection, the one nearest the camera, with the outermost sphere.

Okay, here are a few more numbers to try, same pixel, same resolution as before.

At the first intersection with the inner sphere:

color: v(0.4775,0.4775,0.4775)
t: 0.5017801325608208
point: p(-0.0475,0.0475,-0.4955)
inside: false
eyev: v(-0.0087,0.0087,-0.9999)
normalv: v(-0.0951,0.0951,-0.9909)
reflectv: v(-0.1800,0.1800,-0.9670)
over point: p(-0.0475,0.0475,-0.4956)
under point: p(-0.0475,0.0475,-0.4954)
n1: 1.5
n2: 1.0000034
schlick: 0.03999934854893808


At the second intersection with the inner sphere:

color: v(0.5527,0.5527,0.5527)
t: 0.9829494388012451
point: p(-0.0820,0.0820,0.4864)
inside: true
eyev: v(0.0350,-0.0350,-0.9988)
normalv: v(0.1639,-0.1639,-0.9728)
reflectv: v(0.2872,-0.2872,-0.9138)
over point: p(-0.0819,0.0819,0.4863)
under point: p(-0.0820,0.0820,0.4865)
n1: 1.0000034
n2: 1.5
schlick: 0.03999934854622657


And at the second intersection with the outer sphere:

color: v(0.6397,0.6397,0.6397)
t: 0.5017795642243366
point: p(-0.1214,0.1214,0.9851)
inside: true
eyev: v(0.0786,-0.0786,-0.9938)
normalv: v(0.1214,-0.1214,-0.9851)
reflectv: v(0.1638,-0.1638,-0.9728)
over point: p(-0.1214,0.1214,0.9851)
under point: p(-0.1214,0.1214,0.9852)
n1: 1.5
n2: 1
schlick: 0.04000000000127249


Do any of those give any more clues?

I'm pretty old school when it comes to debugging, I just put in a bunch of print statements and see what comes out. For the output I posted, I've got something like the following in my color_at method (which is in Ruby, but you should be able to get the gist of what I mean):

def color_at(ray, max_depth: 5)
 # ...
 info = hit.prepare(ray, xs)
 result = shading(info, max_depth: max_depth)

 if max_depth > 0
   puts "----"
   puts "color: #{result}"
   puts "t: #{info.t}"
   puts "point: #{info.point}"
   puts "inside: #{info.inside}"
   puts "eyev: #{info.eyev}"
   puts "normalv: #{info.normalv}"
   puts "reflectv: #{info.reflectv}"
   puts "over point: #{info.over_point}"
   puts "under point: #{info.under_point}"
   puts "n1: #{info.n1}"
   puts "n2: #{info.n2}"
   puts "schlick: #{info.schlick}" if info.n1
 end

 # ...
end

This will (of course) dump quite a bit of info, and most of the output is not useful (coming from very deep in the recursion). Judging from the `point` value I take the output that corresponds to the intersections I expect, and those are the ones I shared.

It's very much a "shotgun" style of debugging, but it has served me well in the past.

Tricky! I'm really not sure. The one thing that stands out to me is in your third intersection (where, as you noted, there were differences), with the computed point of intersection (and subsequently, all the related vectors and points). In my third intersection, the z value for that point is positive, whereas yours is negative.

This may be a red herring -- it might be as simple as you showing the reflection ray from the surface of the inner sphere, while I showed the refraction ray. But if it turns out that your third intersection is supposed to be the refraction ray, then there might be something further to investigate there, because the point of intersection is *behind* the ray's point of origin. (I hope that makes sense!)

I wish I could suggest something more helpful! These bugs can be frustratingly difficult to track down, but it's not impossible. It takes a lot of patience, coupled with carefully stepping through your code and manually checking each calculation. Drawing the result on paper as you go helps, too---checking to see if the numbers that are computed actually make sense intuitively.

Please let me know if there is anything else you'd like me to try on my end. I'm happy to provide more numbers from my own ray tracer if that would help.

Hi,

I've been looking at your code and pinpointed the issue to your prepare_computations() method. You need to negate the normal before calculating the over_point and under_point. Here is a snippet my C# code:


Normalv = Object.NormalAt(Point);

if (Normalv.Dot(Eyev) < 0)
{
   Inside = true;
   Normalv = -Normalv;
}
else
{
   Inside = false;
}

// after computing and (if appropriate) negating
// the normal vector...
OverPoint = Point + (Normalv * Constants.EPSILON);
UnderPoint = Point - (Normalv * Constants.EPSILON);


I ran your code after making that change and your failing passed with the correct color, and the scene produced the correct image.




Ian.