Ray Tracing 006Surface Normals

Summary

Added a surface normal to shade the sphere.
Updated to visualize the normals with a color (normal) map.
Updated to return the ray-sphere intersection point and map the normal unit vector to the RGB color components.

The sphere I added last time was rendered as a flat red circle. Here I'm going to add a surface normal to shade the sphere.

Surface normals are used for several purposes in graphics, primarily for lighting. A surface normal is a vector that is perpendicular to the surface at a given point. This vector can either point outward or inward. They usually point outward by convention, but inward pointing normals can be useful, for example, to distinguish between solid spheres and spherical bubbles.

The surface normal for a sphere is in the direction from the center through the hitpoint, minus the center.

The scene has no lights yet, but we can visualize the normals with a color map (see also Normal mapping. Assume N is a unit length vector so that each component is between -1 and 1. Map each component to the range from 0 to 1, and then map x,y,z to r,g,b.

Click to view C++ source code

// surfacenormal-example.cpp
[HL]
float hit_sphere(const vec3& center, float radius, const ray& r) {
[/HL]
  // See notes, solving the quadratic formula where 
  // p(t)=A+tB meets the sphere x^2+y^2+z^2=R^2
  vec3 oc = r.origin() - center;
  float a = dot(r.direction(), r.direction());
  float b = 2.0 * dot(oc, r.direction());
  float c = dot(oc, oc) - radius * radius;
  float discriminant = b*b - 4*a*c;
  [HL]
  // square root of negative numbers not defined here, 
  // no roots = ray doesn't hit sphere
  if (discriminant < 0) return -1.0; 
  else return (-b - sqrt(discriminant)) / (2.0*a);
  // return smallest t (closest hitpoint)
  [/HL]
}

The hit_sphere() function is no longer just returning whether or not the sphere was hit by the ray. Now it's returning the hitpoint needed to compute the normal. That is, the parameter t where $p(t)=A+tB$ intersects with the sphere. The return value changes from bool to a float.

If the ray misses the sphere (discriminant < 0) we return -1. This value for t won't affect the visible area because it lies behind the camera.

If the ray hits the sphere, we'll return the smallest t, the closest hitpoint.

The color() function needs to be updated to calculate and visualize the normal:

Click to view C++ source code

vec3 color(const ray& r) {
  [HL]
  // get closest t intersecting with the sphere with 
  // center at (0,0,-1) and radius 0.5
  float t = hit_sphere(vec3(0.0,0.0,-1.0), 0.5, r);
      
  // if t > 0 we have hit the sphere
  // if t < 0 no roots, no intersection with sphere
  if (t > 0.0) {
    // N = (P - C) converted into a unit-vector 
    // with components between -1 and 1
    vec3 N = unit_vector(r.point_at_parameter(t) - vec3(0.0,0.0,-1.0));
  
    // map components to 0-1 and use these as r, g, b values
    return 0.5 * vec3(N.x() + 1.0, N.y() + 1.0, N.z() + 1.0);
  }
  [/HL]
      
  // ray didn't hit the sphere, get the pixel position the 
  // ray is passing through (u,v) as unit-vector -1 to 1 
  vec3 unit_direction = unit_vector(r.direction());
  // map this to 0-1
  t = 0.5 * (unit_direction.y() + 1.0);
  // linear interpolation from blue to white
  return (1.0 - t) * vec3(1.0, 1.0, 1.0) + t * vec3(0.5, 0.7, 1.0);
}

Javascript and Canvas

Here's the example in Javascript.

Figure RT006: Simple canvas image with surface normals

Click to view Javascript source code

Gerrit Wessendorf 👋

Ray Tracing 006Surface Normals

Next Steps

Summary

Javascript and Canvas

Links

Next Steps