CptS 548 (Advanced Computer Graphics) Unit 2: Basic Ray Tracing

Transcription

1 CptS 548 (Advanced Computer Graphics) Unit 2: Basic Ray Tracing Bob Lewis School of Engineering and Applied Science Washington State University Spring, 2018

2 Why Build a Ray Tracer? Ray tracing is more elegant than polygon scan conversion. Testbed for lots of effects in modelling rendering texturing animation Ray tracers are the easiest renderers to implement. Ray tracers are used in practically all other photorealistic renderers. "Ray tracing is the future of computer graphics, and always will be."

3 Rays r(t) = õ + dt parameter origin d o This is a parametric equation. The parameter t is >= 0. The ray direction d is always unit length in the coordinate system, so t is a distance. When transforming the ray, we must not only transform õ and d, but renormalize d.

4 Unit 2: Basic Ray Tracing Part Part Part Part Part 1: 2: 3: 4: 5: Intersections and Targets Top-Down Ray Tracing Viewing Rays Representing Luminaires and Materials Alternatives to Ray Tracing Why We Call it Ray Tracing (or Casting) scene Mathematically trace rays from the eye through a viewing plane (pixel) into a scene. Compute intersection(s) with objects in the scene. Compute lighting at the closest intersection. If this is a simple lighting calculation, we call it ray casting. If it s more complicated (e.g. tracing additional rays), we call it ray tracing. Set pixel to computed color (or background if no object is hit). Bob Lewis WSU CptS 548 (Spring, 2018)

5 Ray/Implicit Surface Intersections Implicit surfaces are given by f (x, y, z) = f ( p) = 0. Substitute p r(t) = õ + dt into it, you get f ( r(t)) = 0. How many equations are there? How many unknowns? What kind of mathematical problem is this? Are these easy to solve, in general? After we compute the intersection, we need the surface normal N Why? (Hint: Why did we need them in coaster?)

6 Aside: Partial Derivatives Partial derivatives are symbolic operations on functions. We compute the partial derivative f x of a function f (x, y, z) with respect to one of its variables (x, here) by taking that variable s derivative while treating all other variables as constant. Example: ( 3x 2 + 2xz + 4y 5 ) = (6x + 2z) x You can approximate them with very small increments h: f (x + h, y, z) f (x h, y, z) f (x, y, z) x 2h This is, of course, properly frowned on by mathematicians.

7 Aside: The Gradient Operator A very important operator on implicit functions is the gradient: f (x, y, z) = f f x + x y ŷ + f z ẑ Note that this is a vector. Example: ( 3x 2 + 2xz + 4y 5 ) = (6x + 2z) x + (4) ŷ + (2x) ẑ Q: What is the gradient of a sphere centered on the origin?

8 Ray/Implicit Surface Intersections: Planes For a plane f ( p) = ( N p) + D, If you know one point p 0 on the plane, D = ( N p 0 ). Substitute p = r(t) = õ + dt into it, you get Solve to get What can go wrong? ( N õ) + ( N d)t + D = 0. t = D + ( N õ) ( N d) Why are we taking a dot product of a vector with a point?

9 Ray/Parametric Surface Intersections: General Recall a parametric surface definition: f (u, v) p(u, v) = g(u, v) h(u, v) So we need to solve this for t, u, and v: r(t) = p(u, v) õ + dt = f (u, v) g(u, v) h(u, v) A solution is possible, given three equations in three unknowns, but it is not easy. Nevertheless, if we do find a solution, computing the normal is easy...

10 Parametric Surface Normals We can compute a parametric surface normal easily: N(u, v) = p u p v p u p v As with implicit surfaces, the partial derivatives can be computed numerically, to similar consternation of mathematicians. We re assuming that p u and p v are never parallel.

11 Ray/Sphere Intersections (Problem) Like planes, spheres are implicit surfaces: f ( p) = p c 2 R 2 = 0 Substitute p r(t) = õ + dt and you get õ + dt c 2 R 2 = 0 Rearranging and recalling that d 1, you get t 2 + 2( d (õ c))t + õ c 2 R 2 = 0 What kind of equation is this? Is it easy to solve? Sure!...

12 Ray/Sphere Intersections (Solution) solution: where t = B ± B 2 4AC 2A A = 1 B = 2( d (õ c)) C = õ c 2 R 2 How many solutions are possible and what do the possible values of the discriminant (B 2 4AC) say about them?

13 Aside: Spheres Can Be Bounding Boxes The sphere intersection test is pretty cheap: We can often use them for bounding box testing. Given a (very) complicated object with an expensive intersection test, Make a sphere big enough to contain the whole object. Test the ray intersection with the sphere. If the ray misses the sphere, it will miss everything contained in the sphere, so you can skip the expensive test. If the ray hits the sphere, do the expensive test. (The sphere test becomes overhead.) Other bounding box tests (e.g. actual boxes ) are also possible.

14 Ray/Triangle Intersections (Problem) Imagine a triangle defined by points ã, b, and c. c b a In 3D, this defines a plane, right? Any point p in this plane can be expressed by... p = ã + β( b ã) + γ( c ã) This is a variation on barycentric coordinates.

15 Aside: Barycentric Coordinates Definition: It s easy to show that: For any point in the plane: p(α, β, γ) = αã + β b + γ c α + β + γ = 1 If and only if α, β, and γ all lie between 0 and 1, p is within the triangle. We use the above equation to get rid of α in the equation on the previous slide.

16 Ray/Triangle Intersections (Problem, continued) We have p = ã + β( b ã) + γ( c ã) From barycentric considerations, we can show 0 γ 1 and 0 β 1 γ iff p is in the triangle, so substitute p r(t) = õ + dt and then solve: õ + dt = ã + β( b ã) + γ( c ã) How many equations? How many unknowns? What are they? Is this a linear equation? If so, how can we express it as such?

17 Ray/Triangle Intersections (Solution) Rewriting õ + dt = ã + β( b ã) + γ( c ã) in matrix form, we get: [ ] β β ( b ã) ( c ã) d γ M γ = [ (õ ã) ] t t so β γ t = M 1 [ (õ ã) ] How do we interpret results? What if M cannot be inverted? What ranges of β, γ, and t are important? How do we solve for β, γ, and t? Do we always need to solve for all three unknowns?

18 Generalizing Ray/Object Intersections This is an embarassingly simple example of object orientation. Create an abstract superclass Target. Add virtual methods firstintersectionbetween() and getnormal(). Add modelling transforms to it. Create subclasses for each kind of object (Plane, Sphere, Triangle, etc.). Add leaf methods to each subclass as needed. Your raytracer works on a collection of Targets. All geometry-specific knowledge is in subclasses.

19 The Initial Target Hierarchy Here s the idea in UML: UML methods usually have inout and out arguments to indicate multiple returns. In our pseudocode below, we ll always follow the output(s) = method(input(s)) convention.

20 Target Example: The Halfspace Class class Halfspace :... Tuple firstintersectionbetween ( halfspace, ray, tmin, tmax ): targetray = ray. transform ( halfspace. scenetotargettransform ) eqnat0 = targetray. origin [2] # z - component ddotn = -targetray. normalizeddirection [2] if abs ( ddotn ) < EPSILON : # ray is nearly perpendicular to the plane if abs ( eqnat0 ) >= EPSILON : return (tmin, tmax, None ) # ray origin doesn t lie in the plane targett = 0 # arbitrary, could be any non - negative value else : targett = eqnat0 / ddotn targetp = targetray. position ( targett ) p = targetp. transform ( halfspace. targettoscenetransform ) t = (p - ray. origin ). mag () # ray direction is normalized if t < tmin or t > tmax : return (tmin, tmax, None ) # intersection is too far away tmax = t # closer than previous tmax return (tmin, tmax, Intersection ( halfspace, p)) Vector3D getnormal ( halfspace, p): # returns the 3rd column target -to - scene transform ( normalized ) return Vector3D ( halfspace. targettoscenetransform [0:2,2]). normalized ()

21 Notes on the Halfspace Class This pseudocode only looks like Python: It isn t. We use the target prefix to identify entities that are defined in the target frame. Halfspaces are always x-y planes with z normals. (They can be transformed to any other position and orientation.) Only t values between tmin and tmax (inclusive) count. Think of getnormal() as transforming (0, 0, 1) in the target frame into scene coordinates.

22 Camera.renderImage(): A High-Level Ray Tracer This is really all there is to a raytracer: class Camera :... Image renderimage ( camera, scene, width, height ): image = Image ( width, height ) for iu from 0 to width -1: for iv from 0 to height -1: column = iu row = height iv image [ row, column ] = camera. renderpixel ( scene, width, height, iu, iv) return image Radiance renderpixel ( camera, scene, width, height, iu, iv ): ray = camera.viewingray(width, height, iu + 0.5, iv + 0.5) return scene.traceray(ray, 0)

23 Notes on Camera.renderImage() Think of it this way: renderimage() turns a Scene and a Camera into an Image. Convention: Red indicates methods we have yet to cover. The ray goes through the middle (0.5, 0.5) of the pixel. We could combine the two statements in renderpixel() into a single one, but we don t, for reasons that will be clear later. Multiple cameras looking at the same scene could be used for stereo and/or multiple users. A set of images from multiple cameras and scenes changing over time could be frames for an animation.

24 Scene.traceRay() class Scene :... Radiance traceray ( scene, ray, tmin ): intersection = scene. firstintersection (ray, tmin ) if intersection!= None : return intersection.target.material.illuminate(intersection, ray, scene) else : return scene. backgroundradiance Intersection firstintersection ( scene, ray, tmin ): # Why pass tmin? Isn t it always 0? (No, see later.) tmax = intersection = None for target in scene. targets : (tmin, tmax, newintersection ) = target. firstintersectionbetween ( ray, tmin, tmax ) if newintersection is not None : intersection = newintersection return intersection

25 Lighting: Direct vs. Indirect C B A Direct light bounces off a (non-mirror) surface once before it reaches the eye (e.g. bulb-a-eye). Indirect light bounces off more than one surface before it reaches the eye. (e.g. bulb-b-c-eye) The room you re in is probably lit mostly by indirect light. Direct light is easy to do with ray tracing. Indirect light is hard except for a few special cases so we use some hacks and wait to improve things later.

26 Lighting: Lambert s Law Lambert s Law defines a diffuse surface as one for which reflected light obeys the formula L r = ER cos θ i, where Lr is the reflected radiance (power per unit area per unit solid angle) E is the incident normal irradiance (power per unit area) intrinsic to the light source (hereafter, luminaire ) R is the (diffuse) reflectance intrinsic to the surface θ i is the incident angle (between the normal and the luminaire direction) Note that there is no dependency on the reflected angle θ r. This is true at every wavelength or channel. Many surfaces in nature (and man-made) are diffuse, or almost so.

27 Implementing Diffuse Surfaces ^n ^v θ r θ i ^s ~ p For an intersection point p, we have the eye vector v (= d) the surface normal n (from the target) a vector ŝ in the direction towards the luminaire (computed from the luminaire properties) So how do we replace the cosine in Lambert s Law?

28 Shader.directRadiance() The Material abstract class represents Target illumination properties. The Shader (also abstract) subclass is for Materials with a bidirectional reflectance distribution function (BRDF). class Shader :... Radiance directradiance ( shader, intersection, incidentray, luminaire ): towardscamera = - incidentray. normalizeddirection # v normal = intersection. getnormal () # n towardsluminaire = luminaire.towards(intersection.p) # ŝ return (shader.brdf(towardsluminaire, normal, towardscamera) * luminaire.irradiance(intersection.p, normal)) Shader.brdf() is a (virtual) method which computes the bi-directional reflectance distribution function (hereafter BRDF ).

29 DiffuseShader.brdf() The simplest Shader subclass is DiffuseShader. This represents classic Lambertian surfaces. class DiffuseShader :... Rgb brdf ( diffuseshader, towardsluminaire, normal, towardscamera ): return diffuseshader. reflectivity

30 Shadows ^n ^v θ r θ i ^s ~ p What if there s an object between the luminaire and p? Is there some tool we could use to find out if the path from p to the luminaire is blocked?

31 Material.illuminate() class Material :... Radiance illuminate ( material, intersection, incidentray, scene ): radiance = material.indirectradiance(intersection, incidentray,scene) towardscamera = -incidentray. normalizeddirection # = v p = intersection.p # = p normal = intersection. target. getnormal (p) # = n for luminaire in scene. luminaires : towardsluminaire = luminaire.towards(p) # = ŝ if dot ( normal, towardsluminaire ) > 0: # above horizon shadowray = Ray (p, towardsluminaire ) shadowintersection = scene. firstintersection ( shadowray, EPSILON ) if shadowintersection == None or luminaire.isbetween(shadowintersection.p, p): radiance += material. directradiance ( towardscamera, normal, luminaire ) return radiance What purpose does EPSILON serve in the scene.firstintersection() call?

32 Part Part Part Part Part Unit 2: Basic Ray Tracing 1: 2: 3: 4: 5: Intersections and Targets Top-Down Ray Tracing Viewing Rays Representing Luminaires and Materials Alternatives to Ray Tracing Constructing Viewing Rays: Viewing Geometry y^ ~ e g^ image plane x^ j=0 j=1 z^ d d^ ~ o... -> uvw? u... i=1 j=h 1 i=w 1 i=0 Note the reversal of the image plane and eye point compared to OpenGL. There s a reason for this we ll see in the distribution raytracing unit. Bob Lewis WSU CptS 548 (Spring, 2018)

33 Viewing Geometry II given (in scene coordinates): to find (in scene coordinates): ẽ: the eye prime position == uvw (xyz) coords õ: the ray origin g: the gaze direction u: the up direction w and h: image dimensions i and j: pixel indices Θ y : the y field of view (angle) d: the ray direction

34 Transforming World to Viewing Coordinate Bases Similarly to what we did in CptS 442/542, compute these in order: ẑ = g g x = u ẑ u ẑ ŷ = ẑ x Combined with ẽ, we have the transforms between scene and viewing coordinates. Q: Is this a right-handed or left-handed coordinate system?

35 Constructing the View Ray I We ll compute the ray origin õ, starting with õ y, its y coordinate in view coordinates. Looking sideways in the z y plane: ^y j=0 o ~ y (i, j)= ~ ( h 1 2 ) j e ^z Θ y h d j=h 1 We want to convert pixel coordinate j to õ y lying between h/2 and h/2. We need d, the distance in pixels from ẽ to the image plane. Trigonometry says: ( ) Θy tan 2 = d = h 2 d h ( ) Θy 2 tan 2

36 Constructing the View Ray II The same holds true in the z x plane for (Θ x, w) (Θ y, h) (although we don t actually need Θ x ). So the formula for õ(i, j) in camera coordinates is: õ (i, j) = and since all rays pass through ẽ w 1 2 i h 1 2 j d d (i, j) = ẽ õ (i, j) (note: not normalized yet) but since ẽ is the origin of viewing coordinates and we re working in those coordinates, this is just d (i, j) = õ (i, j)

37 Constructing the View Ray III Having d (i, j) in view coordinates, we need to turn it back into scene coordinates, so we multiply each component of d (i, j) by its corresponding vector. This is actually a matrix transform: [ ] d(i, j) = x ŷ ẑ d (i, j) ( ) ( w 1 h 1 = i x 2 2 ( = i w 1 ) ( x + j h ) j ŷ dẑ ) ŷ dẑ

38 Constructing the View Ray IV So now we normalize d(i, j) to construct the ray: d(i, j) = d(i, j) d(i, j) Rather than transform the õ (i, j) we used above as the ray origin, we could just as easily use the origin of the coordinate system all the rays pass through there as the ray origin (and remember that d is a vector). In scene coordinates, that means õ = ẽ.

39 Perspective You ve now got everything you need to build a raytracer with diffuse objects. I suggest you do this before proceeding, creating a small 2D array of t values (i.e. depths ) instead of an image.

40 Directional Luminaires These are parameterized by direction towards luminaire: l normal irradiance: E. This is the amount of power per unit area perpendicular to the direction of travel. both of which are constant, although you might want to make them methods to be compatible with other luminaires (see below).

41 Point Luminaires These are parameterized by (constant) position: P (constant) power (e.g. in Watts): Φ direction towards luminaire from a point p: ŝ( p) = P p P p normal irradiance at point p: E( p) = Φ 4π p P 2

42 Ambient Luminaires? These are parameterized by ambient radiance: L a which is constant. Each Shader may then have an ambient reflectivity (an Rgb) that multiplies L a. This is an egregious hack!

43 Part Part Part Part Part Unit 2: Basic Ray Tracing 1: 2: 3: 4: 5: Intersections and Targets Top-Down Ray Tracing Viewing Rays Representing Luminaires and Materials Alternatives to Ray Tracing Smooth Metal I n^ θr θi ( =θr ) v^ r^v ~ p Bob Lewis WSU CptS 548 (Spring, 2018)

44 Smooth Metal II If the intersection material is a smooth metal, we want a mirror effect, so we cast a mirror ray starting at p in the reflected direction r v into the scene and incorporate the color we get for that ray into the color we return at p. We allow for less than 100% reflectivity no mirror is perfect and the reflectivity may also be channel-dependent, which allows us to do, say, gold- or copper-colored mirrors, which would have more red, less green, and even less blue reflectances. Here are the details...

45 The Reflection Vector ^n ^v θ r ( =θ i ) θ i r^ v ^v ^n ~ p ^v ^v ^n The reflection vector is given by: r v = v + 2( v n) n But we can also use the ray direction d( v) instead of v: r v = d 2( d n) n

46 Reflector.indirectRadiance() Mirror reflectors are a new subclass of Material: class Reflector :... Radiance indirectradiance ( material, intersection, incidentray, scene ): towardscamera = -incidentray. direction. normalized () normal = intersection. getnormal () reflectedray = Ray ( intersection.p, towardscamera. reflect ( normal ), incidentray. refractiveindex, incidentray. depth +1) return material. reflectivity * scene. traceray ( reflectedray, EPSILON ) Note the EPSILON again. Same reason.

47 Aside: What Ray.depth is For Suppose we have two perfect mirrors placed like this:... The depth parameter is one way to limit the number of reflections. There are more accurate possibilities, but this is the easiest. Note, however, that this is one of the shortcomings of raytracing: It can t do complicated mirror geometries.

48 Part Part Part Part Part Unit 2: Basic Ray Tracing 1: 2: 3: 4: 5: Intersections and Targets Top-Down Ray Tracing Viewing Rays Representing Luminaires and Materials Alternatives to Ray Tracing Dielectrics I n^ θt v^ ~ p θi Bob Lewis ^t WSU CptS 548 (Spring, 2018)

49 Dielectrics II If the surface at intersection p is dielectric ((semi-)transparent and light-refracting, like glass or water), we want to show refraction, so we cast a ray starting at p in the transmitted refracted direction t and incorporate the color we get for that ray into the color at p. This may be combined with reflection.

50 Refraction Geometry ^v^v θ i ~ p ^n θ t ^t index n i ^b index n t We always want θ i 90. To enforce this, keep in mind that normals are double-valued: n and n are both perpendicular to the surface. So negate n if ( v n) is initially negative. (This is for refraction: It doesn t matter for reflection.)

51 Snell s Law I Ibn Sahl (Baghdad, c AD) described it first, but Snell (Willebrord Snellius, Dutch, ) gets the credit: n t sin θ t = n i sin θ i Where n i and n t are the indices of refraction of the two media. (These are usually greater than 1. See below.) We rewrite this as: sin θ t = n i sin θ t η 1 ( v n) n 2 t

52 Snell s Law II We know n, but if we also had the tangent (unit) vector b, we could write: t = sin θ t b cos θt n t = ( ) η 1 ( v n) 2 b 1 ( η ) 2 1 ( v n) 2 n (Ugh!)

53 Computing the Tangent Vector b I So let s find b: ^v θ i ^n ( ^v ^n) v t ~ p ^b v has both normal (parallel to n) and tangential (perpendicular to n) components. The normal component is its projection in the n direction, so v = v t + ( v n) n

54 Computing the Tangent Vector b II ^v θ i ^n ( ^v ^n) v t ~ p ^b We extract the tangential component: v t = v ( v n) n b is this vector, negated and normalized: b = v t v t = ( v n) n v 1 ( v n) 2 ( = cos θ i n v sin θ i )

55 The Transmitted Ray Direction Substituting b = ( v n) n v 1 ( v n) 2 into t = ( ) η 1 ( v n) 2 b 1 ( ) 2 η 1 ( v n) 2 n We get (whew!) t = η (( v n) n v) 1 ( ) 2 η 1 ( v n) 2 n What could go wrong? (Watch those square roots!)

56 Indices of Refraction Medium Index of Refraction Methylene Iodide 1.74 Glass, dense flint 1.66 Carbon bisulfide 1.63 Sodium chloride 1.53 Glass, crown 1.52 Fused Quartz 1.46 Ethyl alcohol 1.36 Water 1.33 Air (1 atm, 20 C) Vacuum 1 (by definition)

57 The Fresnel Term When light reflects off a dielectric, its reflectivity has an angular dependence: ( ) R( v, ŝ, η) = 1 (g c) 2 (c(g + c) 1)2 2 (g + c) (c(g c) 1) 2 where c ( v ĥ) ĥ v+ŝ v+ŝ g η 2 + c 2 1 but this is time-consuming. (Aside: we ve seen before.) ĥ is the halfway vector

58 Schlick s Approximation to the Fresnel Term A reasonable approximation to the Fresnel term (due to Christophe Schlick) is where R( v, n, η) = R 0 + (1 R 0 ) (1 ( v n)) 5 R 0 ( η 1 ) 2 1 η Note that this uses the normal n, not ŝ as in the exact Fresnel term.

59 Dielectric.indirectRadiance() class Dielectric :... method indirectradiance ( dielectric, intersection, incidentray, scene ): towardscamera = -incidentray. normalizeddirection # = v normal = intersection. getnormal () # = n if towardscamera.dot ( normal ) < 0.0: normal = - normal # for refraction to work ( no effect on reflection ) reflectedray = Ray ( intersection.p, towardscamera. reflect ( normal ), incidentray. refractiveindex, incidentray. depth +1) transmitteddirection = towardscamera. refract (normal, dielectric. refractiveindex ) # = t refractedray = Ray ( intersection.p, transmitteddirection, dielectric. refractiveindex, incidentray. depth +1) f = dielectric. fresnel ( towardscamera, normal, incidentray. refractiveindex ) radiance = scene. traceray ( reflectedray, EPSILON ) if f < 1.0: # Compute refraction iff reflection isn t total internal. radiance = f * radiance + (1 -f) * scene. traceray ( refractedray, EPSILON ) return dielectric. kabs * radiance

60 Notes on Dielectric.indirectRadiance() To distinguish entries from exits, assume that normals point outwards. To avoid confusion in entry/exit, assume all objects are distinct.

61 Attenuating Media L+dL L x L L 0 Beer s Law: Light passing through an absorbing medium (e.g. smoke) is diminished by fractional amount proportional to the thickness of the medium. dl = CLdx dl dx = CL L = L 0 e Cx e Cx is the attenuation factor. This is the same idea as fog in OpenGL. How would you incorporate this into the schema?

62 Materials: Polished Surfaces This is an alternative shader developed by Shirley: ( L = R 1 (1 ( v n)) 2) ( 1 (1 (ŝ n)) 2) E

63 Materials: A Conventional Ray Tracing Shader Here s our old friend, the EADS shader from 442/542 (and a little OpenGL): L = L e + k a L a + ) (k a + k d (ŝ i n) + k s (ŝ i ĥ)ns E i where all luminaires i L e : emissivity k a : ambient reflectivity L a : ambient irradiance (of scene) ŝ i : direction towards luminaire i k d : diffuse reflectivity. k s : specular reflectivity. n s : specular exponent ( shininess ). E i : luminaire i s normal irradiance Negative dot products are ignored.