As we will use float-values to do our computations we might run into situations where we get into precision-troubles. It’s because of this problems that we have to consider values the same if they differ by a small amount instead of exactly zero.

To get this out of our way let’s just write a couple of functions and active-patterns to help us in the future. I think it’s almost trivial so I don’t think I have to go over each line and explain – so without further due here is the helper code:

[< AutoOpen >]
module FloatHelpers =

    let ZeroThreshold = 0.0000000001

    let IsNearZero (f : float) =
        abs f <= ZeroThreshold

    let IsPositive (f : float) =
        f > ZeroThreshold

    let IsNegative (f : float) =
        f < -ZeroThreshold

    let (|NotNearZero|_|) (f : float) =
        if IsNearZero f
        then None
        else Some f

    let (|Negative|NearZero|Positive|) (f : float) =
        if f |> IsNegative then Negative
        elif f |> IsPositive then Positive
        else NearZero

You can find a good article on active patterns by Jessica Kerr right here: Pattern Matching in F# Part2.

To give a first simple use of this (and give some hint of why I included the somewhat strange NotNearZero (never make a negative predicate right … well no not “never”):

    let Normalize (v : Vector3) =
        match Length v with
        | NotNearZero l -> (1.0/l)*v
        | _             -> Zero

This is a function to normalize a vector – that is finding a vector with the same direction but length 1 so that if the vector is not zero.

We will need this often because many calculations are easier (and need fewer operations) if one (or any) of the participating vectors is a normal-vector.

This is why I will model a ray’s direction to always be a normal vector.