This time we will have a look at two types that will help us on your way. First I will show you how I implemented a ray-type for representing the most important aspect of ray-tracing itself and then I will show you the viewport-type I use to generate all starting-rays for the image we want to generate.

The ray-type

My thinking behind a “ray” is very simple. It’s just a line starting at some point together with a direction. The start-point will be just that – a point in 3D space and the direction should be a direction-vector in 3D space having unit-length (length 1). So the type will imply this constraint (direction have length 1). For this I choose to give two static members for construction of the ray. One for point+direction and a one for constructing a ray from a start-point and another point lying on the ray – the second will make certain that the unit-length constraint is met, the first one will NOT check (for performance-reasons):

type Ray = struct

    val Start : Point
    val Direction : Direction

    new (s, d) = { Start = s; Direction = d }

    static member Create (start, direction) =
        new Ray (start, direction)

    static member FromPoints (start, pointOnRay) =
        let direction = Vector.Normalize (pointOnRay - start)
        Ray.Create (start, direction)

end

The view-port type

This one will be responsible for creating the a raster of points on the viewport and ultimately a ray for each of these raster points pointing from the eye-point in the world-space to the raster-point on the viewport – have a look at this diagram for details:

type RayRaster = Ray[,]

type ViewPort(eye : Point, center : Point, dirUp : Direction, dirRight : Direction, height : float, width : float) =

    let createRaster (resX : int, resY : int) : Point[,] =
        let dX = width / (float resX)
        let dY = height / (float resY)
        let start = center - ((width-dX)/2.0)*dirRight - ((height-dY)/2.0)*dirUp
        Array2D.init resX resY (fun x y -> start + (float x*dX)*dirRight + (float y*dY)*dirUp)

    let createRay (viewPortPoint : Point) =
        Ray.FromPoints (eye, viewPortPoint)

    member vp.CreateRaster (resX, resY) : RayRaster =
        createRaster(resX, resY) |> Array2D.map createRay

I think the code is straight forward – resX/resY stands for Resolution in X and Y direction (on the viewport – so in the right/up-direction the type get’s in it’s constructor). In the diagram up points just up (vertical) and right just right (horizontal).

That’s it for now – next time we will talk about hitting spheres …