TRC- Light and Shading – Chapter 6

Things are getting more and more interesting here. The red circle that appeared on the file as the result of the last chapters putting it together part was cool. The result that is promised at the end of this chapter is cooler still 🙂 Now we are about to add the light and shading to make the drawing to represent a real three dimensional object.

The truth is that most ray tracers favor approximations over physically accurate simulations, so that to shade any point, you only need to know four vectors.

Jamis Buck

The quote from the book doesn’t sound that bad. Only four vectors to master shade! On the page 76 (pdf version) there is this nice figure that demonstrates the thing. If I put my self into the place of observer on that image the vectors are like this:

E = eye vector, it is from the point P that I am looking at pointing straight into my eye (autch).

L = light vector, from the point P I am looking at to the point of the light source.

N = surface normal, this vector is perpendicular to the surface at that point P that I am looking at.

R = reflection vector, the direction where the light would bounce when it comes from the light source.

To calculate E we just negate the ray’s direction vector. Negating vector kind of flips the vector. To calculate the L we need to know lights position. Since we can decide in our ray tracer where the light will be we would probably know it 🙂 . All we need to do is to subtract the point P from the position of our light source and that would be the L. So far everything seems to be understandable.

Surface Normals

A surface normal (or just normal) is a vector that points perpendicular to a surface at a given point.

Jamis Buck

I’m not going to explain the normal any other way than what is explained in the book. There is nice figures in the book that demonstrates the concept of normal. In this case one picture tells “easily” more that thousand words.

Computing the Normal on a Sphere

On thing about normals is that normals are always represented as unit vectors, since the purpose of a normal is only to represent a direction. To keep normals as unit vectors makes things cleaner.

The first tests consists of four cases where the normal on a sphere is tested and the fifth test basically checks that the normal is a unit vector.

func testComputingTheNormalOnASphere() {
    // The normal on a sphere at a point on the x axis
    // Given
    let s1 = RGSphere()
    // When
    let n1 = normalAt(s1, newRGPoint(x: 1, y: 0, z: 0))
    // Then
    XCTAssertEqual(equalTuples(n1, newRGVector(x: 1, y: 0, z: 0)), true)

    
    // The normal on a sphere at a point on the y axis
    // Given
    let s2 = RGSphere()
    // When
    let n2 = normalAt(s2, newRGPoint(x: 0, y: 1, z: 0))
    // Then
    XCTAssertEqual(equalTuples(n2, newRGVector(x: 0, y: 1, z: 0)), true)
    
    // The normal on a sphere at a point on the z axis
    // Given
    let s3 = RGSphere()
    // When
    let n3 = normalAt(s3, newRGPoint(x: 0, y: 0, z: 1))
    // Then
    XCTAssertEqual(equalTuples(n3, newRGVector(x: 0, y: 0, z: 1)), true)
    
    // The normal on a sphere at a nonaxial point
    // Given
    let s4 = RGSphere()
    // When
    let n4 = normalAt(s4, newRGPoint(x: sqrt(3)/3.0, y: sqrt(3)/3.0, z: sqrt(3)/3.0))
    // Then
    XCTAssertEqual(equalTuples(n4, newRGVector(x: sqrt(3)/3.0, y: sqrt(3)/3.0, z: sqrt(3)/3.0)), true)
}

func testNormalIsNormalized() {
    // The normal is a normalized vector
    // Given
    let s = RGSphere()
    // When
    let n = normalAt(s, newRGPoint(x: sqrt(3)/3.0, y: sqrt(3)/3.0, z: sqrt(3)/3.0))
    // Then
    XCTAssertEqual(equalTuples(n, n.normalize()), true)
}

To implement the normatAt function all that is needed to done at this point is to subtract the origin of the sphere (which is (0,0,0)) from the point that we are interested and normalise that vector. Still everything seems quite understandable. Here is the implementation:

/**
 Calculates the normal on the surface of a sphere.
 */
public func normalAt(_ s: RGSphere, _ point: RGTuple) -> RGTuple {
	return  (point - newRGPoint(x: 0, y: 0, z: 0)).normalize()
}

Transforming Normals

Previous cases where the easy ones because all the spheres were located at the origin. That will not be the case when constructing an actual scene. To calculate the normals for a point on a sphere that is located in actual world space we need to do some extra work.

If the sphere is in the world space it needs to be converted back to object space. In object space it’s easy to calculate the normal because in object space the spheres centre is in origin (0,0,0). The last step is to transform that calculated normal back to world space.

To do the normal transformation back to world space so that the normals will hold the perpendicularity the normals in object space must be multiplied with the transpose of the inverse of the transform matrix. (Whoah)

For me things are getting little tricky here. I mean it’s easy to follow the book and get the code work but to actually understand this last step is a bit hard. So I’m not going to stuck in to it. I count on that I will catch up that later. Anyway the normalAt function implementation looks like this:

/**
 Calculates the normal on the surface of a sphere.
 */
public func normalAt(_ s: RGSphere, _ point: RGTuple) -> RGTuple {
    let objectPoint = s.transform.inverse * point
    let objectNormal = objectPoint - newRGPoint(x: 0, y: 0, z: 0)
    var worldNormal = s.transform.inverse.transpose * objectNormal
    worldNormal.w = 0.0
    return worldNormal.normalize()
}

Reflecting Vectors

The normal that we calculated in the last step plays a central role now when we need to reflect a vector. Again there is these nice figures in the book that shows what reflection means. If I try to express reflection in an alternative way I might say that: “When vector hits a surface at a certain point it’s the points normal that defines what the reflection vector will be.”

So now we will create a function newRGReflect. It will return a new vector representing the reflection based on the input vector and normal vector. Here are the two test cases.

func testReflecting() {
    // Reflecting a vector approaching at 45°
    // Given
    let v1 = newRGVector(x: 1, y: -1, z: 0)
    let n1 = newRGVector(x: 0, y: 1, z: 0)
    // When
    let r1 = newRGReflect(v1, n1)
    // Then
    XCTAssertEqual(equalTuples(r1, newRGVector(x: 1, y: 1, z: 0)), true)
    
    // Reflecting a vector off a slanted surface
    // Given
    let v2 = newRGVector(x: 0, y: -1, z: 0)
    let n2 = newRGVector(x: sqrt(2)/2, y: sqrt(2)/2, z: 0)
    // When
    let r2 = newRGReflect(v2, n2)
    // Then
    XCTAssertEqual(equalTuples(r2, newRGVector(x: 1, y: 0, z: 0)), true)
}

After converting the pseudocode from book to Swift code the reflection function will look like this:

/**
 - RETURNS: New RGTuple that represents the reflection vector.
 */
public func newRGReflect(_ inp: RGTuple, _ normal: RGTuple) -> RGTuple {
    return inp - normal * 2.0 * simd_dot(inp, normal)
}

The Phong Reflection Model

In the book Jamis uses the Phong reflection model. I am not very aware of the different shading techniques but even I have heard this Phong reflection model before 🙂

In this model there is three different types of lighting. First there is this ambient reflection which means how the other objects in an environment reflects light and it is considered as a constant in Phong model. I guess this makes things much easier since in real world there is all kinds of different types of materials and surfaces that reflects light differently and to recon all these individually makes everything much harder to put together.

Second there is diffuse reflection which depends only on the angle between the light source and surface normal. Its purpose is to reflect the light from matte surfaces.

The third is specular reflection and it’s the reflection of the light source it self. This is something that is controlled by the parameter called shininess.

The higher the shininess, the smaller and tighter the specular highlight.

Jamis Buck

All different attributes could be calculated separately but to make some use of them all of them must be put together. There is nice illustration in the book that demonstrates just that.

To reflect a light we need a source for the light. To have a light we create a point light. Point light is a simple struct defined like this (test case included):

/**
 Point light that have its position and intensity.
 */
public struct RGPointLight {
    public var intensity: RGColor
    public var location: RGTuple
}

func testPointLight() {
    // A point light has a position and intensity
    // Given
    let intensity = newRGColor(red: 1, green: 1, blue: 1)
    let location = newRGPoint(x: 0, y: 0, z: 0)
    // When
    let light = newRGPointLight(intensity, location)
    // Then
    XCTAssertEqual(equalColors(light.intensity, intensity), true)
    XCTAssertEqual(equalTuples(light.location, location), true)
}

To create something concrete we will still need a data structure called material that will hold the color of the material and all the Phong reflection model attributes. Here is the implementation, the test case could be found in the source code.

public struct RGMaterial {
    public var color: RGColor
    public var ambient: Double
    public var diffuse: Double
    public var specular: Double
    public var shininess: Double
}


public func newRGMaterial() -> RGMaterial {
    return RGMaterial(color: newRGColor(red: 1, green: 1, blue: 1), ambient: 0.1, diffuse: 0.9, specular: 0.9, shininess: 200.0)
}

A material on its own is not useful so we need to attach it into our sphere. So we could think this like if the sphere knows what material it is made of it knows how to reflect the light that cast on it.

The very last thing is to create a lighting function. In my code it’s called newRGLighting and it returns a new RGColor object. It will take as input the point on the sphere we are interested, the location where our eye is (where the observation point is), the material object that defines the material in that point we are observing and the point light object aka the light source. Based on the given data the function calculates how the point at hand should be shaded or rendered in given context.

There are quite many test cases that test different setups so I’m not going to copy paste all of them here. The function that is based on the books pseudocode is shown bellow.

public func newRGLighting(m: RGMaterial, p: RGTuple, l: RGPointLight, e: RGTuple, n: RGTuple) -> RGColor {
    // combine the surface color with the light's color/intensity
    let effectiveColor = m.color * l.intensity
    
    // find the direction to the light source
    let lightv = (l.location - p).normalize()
    
    // compute the ambient contribution
    let ambient = effectiveColor * m.ambient
    
    // lightDotNormal represents the cosine of the angel between the
    // light vector and the normal vector. A negative number means the
    // light is on the other side of teh surface.
    var diffuse: RGColor
    var specular: RGColor
    
    let lightDotNormal = dot(lightv, n)
    if lightDotNormal < 0.0 {
        diffuse = newRGColorBlack()
        specular = newRGColorBlack()
    } else {
        // compute the diffuse contribution
        diffuse = effectiveColor * m.diffuse * lightDotNormal
        
        // reflect_dot_eye represents the cosine of the angle between the
        // reflection vector and the eye vector. A negative number means the
        // light reflects away from the eye.
        let reflectv = newRGReflect(-lightv, n)
        let reflectDotEye = dot(reflectv, e)
        
        if reflectDotEye <= 0.0 {
            specular = newRGColorBlack()
        } else {
            let factor = pow(reflectDotEye, m.shininess)
            specular = l.intensity * m.specular * factor
        }
    }
    
    return ambient + diffuse + specular
}

I think this is very fascinating. You put some data together, make some math with it and you get a color that reflects the color in a realistic environment. Now we have everything we need to render a shaded object.

Putting It Together

The putting it together could be found in this chapters playground. I have commented the parts that are specific for this chapter so it should be easy to follow. Compared to the red circle we get in the end of the previous chapter (and that was nice too) this one looks way more better. The end result is below and I must say it was really rewarding to get the result right 🙂