TRTC – Chapter 8 – Shadow

This chapter is not as big as the previous but the concept at hand is still important. There is quite a bit code in the raytracer so far an there is more to come.

Like the book says most of the code to generate shadows is there already. What is needed is to do little tweaks in the code. Nothin too big so lets dive in.

Lighting in Shadow and Testing for Shadows

If there is a point that is in shadow then there must be a object between that point and the light source. Because the diffuse and specular components are calculated using the light source vector we can’t use them when the point is in shadow. What we do is that we ignore them and use only the ambient component. This makes sense so the test is like this.

func testLightingWithSurfaceInShadow() {
    // Given
    let eyev = newRGVector(x: 0, y: 0, z: -1)
    let normalv = newRGVector(x: 0, y: 0, z: -1)
    let light = newRGPointLight(newRGColorWhite(), newRGPoint(x: 0, y: 0, z: -10))
    let inShadow = true
    let m = newRGMaterial()
    let position = newRGPoint(x: 0, y: 0, z: 0)
    
    // When
    let result = newRGLighting(m: m, p: position, l: light, e: eyev, n: normalv, inShadow: inShadow)
    
    // Then
    XCTAssertEqual(result == newRGColor(red: 0.1, green: 0.1, blue: 0.1), true)
}

To do the implementation we must add one thing that is missing. Our newRGLighting function don’t know if the point is in shadow or not so that must be fixed first. After that it’s easy to drop the diffuse and the specular components when the point is in shadow. The newRGLighting function needs an extra argument isShadow. So here is the new newRGLighting function:

public func newRGLighting(m: RGMaterial, p: RGTuple, l: RGPointLight, e: RGTuple, n: RGTuple, inShadow: Bool) -> 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
    
    
    // Since diffuce and specular are dependent on the ligh source
    // points in shadow should ignore these and return only ambient.
    if inShadow == true {
        return 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
}

The inShadow parameter is calculated using a new isShadowed function. It looks like:

/**
 Calculates if given point in a world is in shadow or not.
 This information is used in newRGLighting function.
 */
public func isShadowed(world: RGWorld, point: RGTuple) -> Bool {
    
    let v = world.lightSource!.location - point
    let distance = v.magnitude()
    let direction = v.normalize()
    
    let ray = newRGRay(origin: point, direction: direction)
    let intersections = intersectRGWorld(world: world, ray: ray)
    
    guard let h = hitRG(intersections: intersections) else {
        return false
    }

    if h.t.isLess(than: distance) {
        return true
    } else {
        return false
    }
}

There is quite a few test cases to check if point is in shadow or not. I will not list all of them here. Like always you could found them in the source code.

At this point the book promises that only one more thing is neede before we can render shadows. There is some kind of tweak needed in the newRGShadeHit function. This tweak is needed because there is inaccuracy in floating point values. So what it means in practice is that we can’t precisely say where the ray intersect the surface. These inaccuracies aka. rounding errors means that the sphere could cast a ray on its own point of intersection.

So the solution is to adjust the point slightly in the direction of the normal, before testing for shadows. I imagine this in a way that the point jumps up from the surface into the direction of the points normal.

In code this all means that we must add an overPoint attribute in RGComputation struct and a way to calculate that attribute in newRGShadeHit function. The new RGComputation struct, prepareRGComputation function and newRGShadeHit functions are here respectively:

/**
 Datastucture to hold attributes in one place to make it easier to do the calculations.
 */
public struct RGComputation {
    public var t: Double
    public var object: RGSphere
    public var point: RGTuple
    public var eyev: RGTuple
    public var normal: RGTuple
    public var inside: Bool
    public var overPoint: RGTuple
}


public func prepareRGComputation(intersection i: RGIntersection, ray: RGRay) -> RGComputation {
    let point = newRGPosition(ray: ray, t: i.t)
    
    let eye = -ray.direction
    var normal = normalAt(i.object, point)
    var inside = false
    
    if dot(lT: normal, rT: eye) < 0 {
        inside = true
        normal = -normal
        
    }
    
    let overPoint = point + normal * Double.eps()
    let comps = RGComputation(t: i.t , object: i.object, point: point, eyev: -ray.direction, normal: normal, inside: inside, overPoint: overPoint)
    
    return comps
}


/**
 - Returns: RGColor at the intersection encapsulated by computations in given world.
 */
public func newRGShadeHit(world: RGWorld, computations comps: RGComputation) -> RGColor {
    let shadowed = isShadowed(world: world, point: comps.overPoint)
    
    return newRGLighting(m: comps.object.material , p: comps.point, l: world.lightSource!, e: comps.eyev, n: comps.normal, inShadow: shadowed)
}

About the epsilon. Well the epsilon has been a round from the early beginning of this book and now I decided to change it’s implementation in my code a little. So I added an extension static function in Double which returns epsilon. It’s now hardcoded into 0.00001. This is now just for convenience. Double extensions are like this now:

public extension Double {
    static func eps() -> Double {
        return 0.00001
    }
    /**
     Compares float to another.
     If the difference between them is less than given epsilon
     they are considered equal.
     - Returns: Bool
     */
    func isEqualTo(_ f: Double, eps: Double = Double.eps()) -> Bool {
        if abs(self - f) < eps {
            return true
            }
        else {
            return false
            }
    }
}

And for this chapter…that was all. Wow. Those little changes in code made it capable to produce shadows. The Putting It Together part is basically the same as in chapter 7. Just the new function cals are used. You could find it in the Chapter 8 playground. The result is this image below.