Ray Tracing

I know basically two methods:
-you generate the ray in the object space of the camera, then transorm it with its world space.
-The other way is to transform the four corners of the view plane in world space, and then interpolate across the surface.

I use the second method, wich in pseudocode would be:

This is more or less what I use to generate rays (I could send you real code if you need it). I can't say that this method is better than transforming camera space rays with the World matrix of the camera, but this is the one I use.

I think its all these coordinate systems which are throwing me off. Also what is the CamToWorld transformation? Also what is Camera space? If thats OpenGL code I would be most grateful.


I have the code below exactly the same i.e

for each pixel in surface {
Ray r = someOrigin;
r.direction = someOrigin - pixelPoint;
r.SelfNormalize();
}

Its just the transformation side, I tried something along the lines of
a couple of matrices and a scaling factor but to be honest my maths isn't the best.

neutrinohunter

Well, I'm not a math guru myself, so I will try to explain in poor words (hopening that they are also correct):
Every object in the virtual scene is defined in a local space. For example, in its local space the camera is centered in (0,0,0), but when moved in the scene it can be placed everywhere, i.e. (10, -2, 22). This transformation usually changes both position and direction (viewing vector, in the camera example, orientation, with other items), but can also include other transformation: scale, or projections, for example.
This transformation is performed through matrices and it is what I call CamToWorld. This is done in software as well as in hardware renderer.

What I do to generate rays is building up this matrix (you can find the matrices for most common transformations everywhere, wikipedia included IIRC). Then you multiply the matrix for the four corners of the 'screen'. Their coordinate depend from how you decide to build your camera, an example is:

A = (-1, 0.5, 1.5)
B = (1, 0.5, 1.5)
A = (-1, -0.5, 1.5)
A = (1, -0.5, 1.5)

This defines a rectangle aligned with the xy plane and perpendicular to the z axis. It is 2 units width and 1 unit heigth, and 1 unit far from the origin. These are local coordinates, and suppose that the camera point of view is at (0,0,0).

What you do is to take your matrix and multiply it for the three vertices. Then interpolate through the plane to get xres * yres points over the surface and for each point (pixel) you build a ray in the following way:

r.origin = camera_pos_in_the_scene;
r.direction = (current_point_on_the_surface - r.origin).Normalize();

I could send you both my geometric library and the code I used to build camera ray, but be warned that:
-everything is work in progress
-The two parts don't work togheter since I recently rewrote the vector libarary but not yet the camera class.

Honestly, I suggest to try to implement this yourself. It can be hard at first as it was for me, but then at least you will know better what you're doing.

Ok, ive had a stab but I don't think I've gone wrong. I think ive tested my intersection code enough to know that the image I'm getting is wrong.

I was using the idea that i could transform from pixel to world using the inverse transformation of the modelview matrix inside opengl.

Something like:

Point = [Transformation along -n for eye post][Inv of View][Pixel]

Unfortunately I'm getting nothing except a black screen (background colour), so I'm thinking that my ray function isn't correlating to the actual rays going out (i.e a sphere should be drawn if it is in view of the camera)

neutrinohunter

I believe this does what you're asking

Thanks, Im currently just trying to compile it.

One question though, what do the last couple of lines do in the screenClickToGlobal() function ? I understand the bit using matrices to get the idea of a viewplane, but I'm baffled to now what the last bits do exactly.

It looks like stuff for intersections: Position + (time * directionRay)
but wondering why the divide for z and the distance bit?

neutrinohunter