Chapter 14 - Groups

My first guess is the normal vector is not being correctly calculated. Can you share your normal_at, world_to_object, and object_to_world functions?

Maybe it's related, but there's another problem with my code too, I can't seem to be able to recreate the image here forum.raytracerchallenge.com/thread/15/first-light-refraction-code


Mine just turns out like this:



Even if I take both sphere's out of the scene just to see if I can render a view looking down at the checkered "floor" but it comes out the same.

I've been implementing the unit tests and they're passing, but I guess I've missed something somewhere or made a mistake. 

Any idea's on which part I might have messed up? At least I can go back through my git history to see if I had it working at some point...

As far as I can tell (never written F# before) the normal functions look good. Did the view vector fix for the glass-inside-a-sphere also fix the group text render?

As with gbordelon, I don't have much experience with F#, but I'm not seeing anything obviously wrong. Given the images that are being rendered, though, it feels like transformations aren't being applied correctly to child shapes within a group. As was also suggested, it could also be something with the normal computation, but it looks to me like more than the normals are wrong--the geometry itself seems off.

My next step here would be to pick a pixel in your output image, preferably one where the shading/geometry is obviously wrong, and then run your renderer on just that pixel. Dump out a whole bunch of numbers for the computations being done on that pixel, and then try to see what might be going wrong. You might need to do some of the computations by hand to compare.

Another option would be to start with the unrotated image (which you said renders correctly), and apply a minuscule rotation to it (like, 0.01 radians or something). Does it immediately go wrong? Or does rotation work up to some threshold value?

Sorry I don't have a quick fix for you. I could probably render that image with some rotation, and give you some numbers from my own renderer for you to compare with, if that would help?

serial -- that video is really insightful! It makes me wonder if gbordelon is right, about the normal vector not being computer correctly (specifically in the case where the normal is being computed on a child of a group). I've not used F# before, but I did write this ray tracer once in OCaml, and IIRC the stuff involving groups was a lot trickier than I expected in that language. (You can see my OCaml implementation here, if you're interested: github.com/jamis/rtc-ocaml).

To simplify the problem being investigated, what happens if you have a scene containing a single group, which contains a single sphere? Then, apply a transformation (like a translation or a scaling) to the sphere, and a rotation to the group. Does the sphere still render correctly?

These all look okay to me; then I repeated the exact same thing but with a cylinder, using the same matrices as I applied to the sphere/groups before.

Scaled cylinder by itself



Cylinder in a group



Cylinder in a group in a group



This last one looks wrong, and since the sphere worked, it looks like the issue is with my cylinder code.

serial, I think the last picture of the sphere looks odd, too, actually. The normals seem off--compare the location of the specular highlight to the location of the shadow. It reminds me of the illustration in the "Surface Normals" section of the book (page 83 or so), with the purple sphere that's been squashed.



Huge kudos for going this route! I learned a ton writing the ray tracer in OCaml, too--I'd never written anything in it before, and I learned a lot. Definitely a baptism by fire, though.