Jump to content

  • Log In with Google      Sign In   
  • Create Account


Why are my ray traced reflections wrong?


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
2 replies to this topic

#1 BloodOrange1981   Members   -  Reputation: 214

Like
0Likes
Like

Posted 02 April 2014 - 08:41 PM

Hi! After some fooling around with basic ray tracing with spheres and planes I added reflections, but using the formula seen on many websites

 

ray direction - 2 * DotProduct(rayDirection , surfaceNormal) * surfaceNormal 

 

the reflections seem to be orientated the wrong way.

 

test.png

 

but if I use

 

ray direction - 2 * DotProduct( -rayDirection , surfaceNormal) * surfaceNormal 

 

The reflections on the spheres seem ok but isn`t the reflection on the plane a little strange?

 

test.png

 

The code that determines the color for a pixel goes as follows


//intersection point at time t
point = ray.GetOrigin() + t * ray.GetDirection();

surfaceNormal = sceneObj->GetSurfaceNormal(point);

//determine the reflection direction vector
reflectDirection = ray.GetDirection() - (2.0f * DotProduct(-ray.GetDirection(),surfaceNormal))*surfaceNormal;

//generate the color for this ray and generate a secondary ray, add the generated color
return GenerateColor(point,sceneObj,surfaceNormal) + TraceRay(Ray(reflectDirection,point+reflectDirection * 0.001f),depth-1);

Thanks in advance



Sponsor:

#2 Bacterius   Crossbones+   -  Reputation: 8532

Like
2Likes
Like

Posted 02 April 2014 - 10:24 PM

Since your plane doesn't appear to be reflecting light in the same way as your spheres regardless of the reflection formula you use, I would check that your surface normal is pointing the right way for both objects. It's almost certain your sphere surface normals are pointing inwards of the sphere whereas your plane surface normal is pointing upwards (or vice versa).

 

Remember: the surface normal is typically defined as always pointing "outwards", that is, if V is the direction of the ray as it hits the geometry, then dot(V, N) < 0 (so that dot(R, N) > 0 where R is the reflected ray). You can define it the other way, with it pointing inwards if you want, but you have to be consistent and make sure this is true for all your geometry, since the reflection formula kind of "needs to know" which way to reflect your incident vector, and that depends on the orientation of the normal vector.

 

It's fairly easy to enforce if you're only doing reflection, since you can do the dot product check and flip your normal as needed, but it gets messy when you start doing refraction/transparency where non-watertight meshes are physically meaningless (they have no boundary) and you can't flip normals since you need to keep track of which object(s) your ray is currently inside of, therefore you have to be a lot more careful in these situations to make sure your geometry is self-consistent. For opaque reflection you can just hack the surface normal to make it point in whichever direction you need and you're good to go (again, because with reflection only your ray is always "outside" and you know it).

 

EDIT: if you could show your code for the GetSurfaceNormal() method, that should help track down the bug.


The slowsort algorithm is a perfect illustration of the multiply and surrender paradigm, which is perhaps the single most important paradigm in the development of reluctant algorithms. The basic multiply and surrender strategy consists in replacing the problem at hand by two or more subproblems, each slightly simpler than the original, and continue multiplying subproblems and subsubproblems recursively in this fashion as long as possible. At some point the subproblems will all become so simple that their solution can no longer be postponed, and we will have to surrender. Experience shows that, in most cases, by the time this point is reached the total work will be substantially higher than what could have been wasted by a more direct approach.

 

- Pessimal Algorithms and Simplexity Analysis


#3 BloodOrange1981   Members   -  Reputation: 214

Like
2Likes
Like

Posted 02 April 2014 - 11:20 PM

Ahh, the Normals were in fact fine, but thanks for the suggestion.

 

The problem I has having and why the formula didn`t work was 1) not normalizing the generated ray Direction and 2) in my sphere intersection code I was simply checking for the lowest value of t, and not checking if they were positive values as well, hence shapes behind the ray`s origin influencing the reflected colour. Now it looks an awful lot better!

 

Thank you.

 

test.png


Edited by BloodOrange1981, 02 April 2014 - 11:24 PM.





Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS