CS 87/187, Spring 2016 RENDERING ALGORITHMS I:

http://www.graphics.cornell.edu/online/box/compare.html

Prof. Wojciech Jarosz [email protected] (with some slides by Jan Novák and Wenzel Jakob) Control variates off Last time

• Variance reduction using – Control variates – Careful sample placement Random Stratified N-Rooks

Control variates on

Multi-Jittered Quasi-Random Poisson-Disc Rendering Algorithms Spring 2016 2 Today’s Menu

• Light paths • Heckbert notation • Rendering Equation • Solving the Rendering Equation – Recursive Monte Carlo – Path tracing

Rendering Algorithms Spring 2016 3 Color Bleeding

James Gurney

Rendering Algorithms Spring 2016 4 Color Bleeding

Sculpture by John Ferren

All visible surfaces are painted white, the color is only due to inter-reflections

Rendering Algorithms Spring 2016 5 Caustics

Rendering Algorithms Spring 2016 source: Flickr 6 Subsurface Scattering

flickr.com

http://www.math.psu.edu/jech

Rendering Algorithms Spring 2016 7 All-in-One!

Ritschel et al. [2012]

Rendering Algorithms Spring 2016 8 Simulating Global Illumination

http://www.graphics.cornell.edu/online/box/compare.html One image here was captured from a physical model under controlled lighting conditions using a Photometrics CCD camera. The other image was rendered using a geometric model with material properties and lighting set to values identical to the physical conditions. Which one is which?

Rendering Algorithms Spring 2016 9 Light Paths

Rendering Algorithms Spring 2016 10 Light Paths

• Express light paths in terms of the surface interactions that have occurred • A light path is a chain of linear segments joined at event “vertices”

Rendering Algorithms Spring 2016 11 Heckbert’s Classification

• Classification of “vertices”: – : a light source – : the eye – : a specular reflection – : a diffuse reflection

classification by Paul Heckbert

Rendering Algorithms Spring 2016 12 Heckbert’s Classification

Light source

Eye

Specular Image plane

Diffuse

Rendering Algorithms Spring 2016 13 Heckbert’s Classification

Light source

Eye

Specular Image plane

Diffuse

Rendering Algorithms Spring 2016 14 Heckbert’s Classification

Light source

Eye

Specular Image plane

Diffuse

Rendering Algorithms Spring 2016 15 Heckbert’s Classification

Light source

Eye

Specular Image plane

Diffuse

Rendering Algorithms Spring 2016 16 Heckbert’s Classification

Light source

Eye

Specular Image plane

Diffuse

Rendering Algorithms Spring 2016 17 Heckbert’s Classification

Light source

Eye

Specular Image plane

Diffuse

Rendering Algorithms Spring 2016 18 Heckbert’s Classification

• Can express arbitrary classes of paths using a regular expression type syntax: – : one or more of event – : zero or more of event – : zero or one events – : a or event

Rendering Algorithms Spring 2016 19 Heckbert’s Classification

• Direct illumination: • Indirect illumination: • Classical (Whitted-style) ray tracing:

Rendering Algorithms Spring 2016 20 Heckbert’s Classification

• Direct illumination: • Indirect illumination: • Classical (Whitted-style) ray tracing: • Full global illumination: – diffuse inter-reflections: – caustics:

Rendering Algorithms Spring 2016 21 Ray Tracing

Rendering Algorithms Spring 2016 22 Beyond Ray Tracing

Wojciech Jarosz Ray-traced Real

Rendering Algorithms Spring 2016 23 What is Indirect Illumination?

Rendering Algorithms Spring 2016 24 What is Indirect Illumination?

Rendering Algorithms Spring 2016 25 What is Indirect Illumination?

Rendering Algorithms Spring 2016 26 What is Indirect Illumination?

Rendering Algorithms Spring 2016 27 What is Indirect Illumination?

Rendering Algorithms Spring 2016 28 What is Indirect Illumination?

Rendering Algorithms Spring 2016 29 Direct Illumination

Rendering Algorithms Spring 2016 30 Direct + Indirect Illumination

Rendering Algorithms Spring 2016 31 Indirect Illumination

Rendering Algorithms Spring 2016 32 Reflection Equation

• reflected radiance depends on incident radiance

Rendering Algorithms Spring 2016 33 Rendering Equation

• James Kajiya, “The Rendering Equation.” SIGGRAPH 1986. • Energy equilibrium:

outgoing emitted reflected

Rendering Algorithms Spring 2016 34 Light Transport

• No participating media → radiance is constant along ray • We can relate incoming radiance to outgoing radiance

x ray tracing function

Rendering Algorithms Spring 2016 35 Rendering Equation

• Hemispherical form

ray tracing function

• Only outgoing radiance (except for ) on both sides – we drop the “o” subscript – Fredholm equation of the second kind (recursive)

Rendering Algorithms Spring 2016 36 Rendering Equation

• Surface area form

Rendering Algorithms Spring 2016 37 Rendering Equation

• How to evaluate these integrals? • Closed-form solution almost never exists – multidimensional, complex BRDF – discontinuous integrand (visibility) • Numerical Methods – Gaussian quadrature – curse of dimensionality → inefficient

Rendering Algorithms Spring 2016 38 Solving the Rendering Equation

• Monte Carlo methods – Today: unbiased methods • Recursive Monte Carlo ray tracing • Path tracing and light tracing • Bidirectional path tracing – Later: biased methods • Many-light algorithms • Density estimation • (Probabilistic) progressive mapping • caching

Rendering Algorithms Spring 2016 39 Solving the Rendering Equation

Rendering Algorithms Spring 2016 40 Solving the Rendering Equation

Rendering Algorithms Spring 2016 41 Solving the Rendering Equation

Rendering Algorithms Spring 2016 42 Solving the Rendering Equation

How do we get these?

Rendering Algorithms Spring 2016 43 Recursive Monte Carlo Ray Tracing

Rendering Algorithms Spring 2016 44 Solving the Rendering Equation

Rendering Algorithms Spring 2016 45 Solving the Rendering Equation

Rendering Algorithms Spring 2016 46 Recursive Monte Carlo Ray Tracing

Rendering Algorithms Spring 2016 47 Partitioning the Integrand

• Direct illumination: sometimes better estimated by sampling emissive surfaces • Let’s estimate direct illumination separately from indirect illumination, then add the two – i.e. shoot shadow rays (direct lighting) and gather rays (indirect lighting) – be careful not to double-count! • Explicit estimation of direct illumination is also known as next-event estimation

Rendering Algorithms Spring 2016 48 Recursive Monte Carlo Ray Tracing with explicit shadow rays

✘

Avoid ✘ double counting!

L(x, ~! )=Le(x, ~! )+Ld(x, ~! )+Li(x, ~! )

L(x, ~! )=Le + ...Le ...dA(x0)+ ...L...d~! 0 2 ZA ZH Rendering Algorithms Spring 2016 49 Monte Carlo Ray Tracing Algorithm

L(x, ~! )=Le(x, ~! )+Ld(x, ~! )+Li(x, ~! ) color shade (point x, normal n) { for all lights // direct illumination

Ld += contribution from light;

for all N indirect sample rays // indirect illumination ω’ = random direction in hemisphere above n;

Li += brdf * shade(trace(x, ω’)) * dot(n, ω’) / (p(ω’) * N);

if not last bounce specular // prevent double-counting

return Ld + Li;

return Le + Ld + Li; }

Rendering Algorithms Spring 2016 50 Monte Carlo Ray Tracing Algorithm

L(x, ~! )=Le(x, ~! )+Ld(x, ~! )+Li(x, ~! ) color shade (point x, normal n) { for all lights // direct illumination

Ld += contribution from light;

for all N indirect sample rays // indirect illumination ω’ = random direction in hemisphere above n;

Li += brdf * shade(trace(x, ω’)) * dot(n, ω’) / (p(ω’) * N);

if not last bounce specular // prevent double-counting

return Ld + Li;

return Le + Ld + Li; }

Rendering Algorithms Spring 2016 51 Monte Carlo Ray Tracing Algorithm

L(x, ~! )=Le(x, ~! )+Ld(x, ~! )+Li(x, ~! ) color shade (point x, normal n) { for all lights // direct illumination

Ld += contribution from light;

for all N indirect sample rays // indirect illumination ω’ = random direction in hemisphere above n;

Li += brdf * shade(trace(x, ω’)) * dot(n, ω’) / (p(ω’) * N);

if not last bounce specular // prevent double-counting

return Ld + Li;

return Le + Ld + Li; }

Rendering Algorithms Spring 2016 52 Monte Carlo Ray Tracing Algorithm

L(x, ~! )=Le(x, ~! )+Ld(x, ~! )+Li(x, ~! ) color shade (point x, normal n) { for all lights // direct illumination

Ld += contribution from light;

for all N indirect sample rays // indirect illumination ω’ = random direction in hemisphere above n;

Li += brdf * shade(trace(x, ω’)) * dot(n, ω’) / (p(ω’) * N);

if last bounce not specular // prevent double-counting

return Ld + Li;

return Le + Ld + Li; }

Rendering Algorithms Spring 2016 53 Monte Carlo Ray Tracing Algorithm

• Formulation of is recursive! • Can you see any problem? ...

• Exponential growth! • 3-bounce contributes less than 1-bounce transport, but we estimate it with 25× as many samples!

Rendering Algorithms Spring 2016 54 Path Tracing

Rendering Algorithms Spring 2016 55 Path Tracing

Rendering Algorithms Spring 2016 56 Path Tracing with Shadow Rays

Avoid ✘ double counting!

L(x,~!)=Le(x,~!)+ ...Le ...dA(x0)+ ...L...d~!0 2 ZA ZH

Rendering Algorithms Spring 2016 57 Path Tracing with Shadow Rays

1 path/pixel

Rendering Algorithms Spring 2016 58 Path Tracing with Shadow Rays

4 paths/pixel

Rendering Algorithms Spring 2016 59 Path Tracing with Shadow Rays

16 paths/pixel

Rendering Algorithms Spring 2016 60 Path Tracing with Shadow Rays

64 paths/pixel

Rendering Algorithms Spring 2016 61 Path Tracing with Shadow Rays

256 paths/pixel

Rendering Algorithms Spring 2016 62 Path Tracing with Shadow Rays

1024 paths/pixel

Rendering Algorithms Spring 2016 63 Monte Carlo Ray Tracing Algorithm

L(x, ~! )=Le(x, ~! )+Ld(x, ~! )+Li(x, ~! ) color shade (point x, normal n) { for all lights // direct illumination

Ld += contribution from light;

for all N indirect sample rays // indirect illumination ω’ = random direction in hemisphere above n;

Li += brdf * shade(trace(x, ω’)) * dot(n, ω’) / (p(ω’) * N);

if last bounce not specular // prevent double-counting

return Ld + Li;

return Le + Ld + Li; }

Rendering Algorithms Spring 2016 64 Monte Carlo Ray Tracing Algorithm

L(x, ~! )=Le(x, ~! )+Ld(x, ~! )+Li(x, ~! ) color shade (point x, normal n) { for all lights // direct illumination

Ld += contribution from light;

for all N indirect sample rays // indirect illumination ω’ = random direction in hemisphere above n;

Li += brdf * shade(trace(x, ω’)) * dot(n, ω’) / (p(ω’) * N);

if last bounce not specular // prevent double-counting

return Ld + Li;

return Le + Ld + Li; }

Rendering Algorithms Spring 2016 65 Path Tracing Algorithm

L(x, ~! )=Le(x, ~! )+Ld(x, ~! )+Li(x, ~! ) color shade (point x, normal n) { for all lights // direct illumination

Ld += contribution from light;

// indirect illumination ω’ = random direction in hemisphere above n;

Li += brdf * shade(trace(x, ω’)) * dot(n, ω’) / (p(ω’));

if last bounce not specular // prevent double-counting

return Ld + Li;

return Le + Ld + Li; }

Rendering Algorithms Spring 2016 66 Path Tracing

• Shoot multiple rays/pixel to improve quality of indirect illumination estimation • Since we are already shooting multiple rays/pixel, we can achieve antialiasing/depth of field/motion blur at the same time “for free”!

Rendering Algorithms Spring 2016 67 Russian Roulette

• When do we stop recursion? • Truncating at some fixed depth introduces bias • Russian roulette: – probabilistically terminate the recursion – choose some termination probability – generate a random number ⇠ F 1 q ⇠>q F 0 = (0 otherwise

Rendering Algorithms Spring 2016 68 Path Tracing Algorithm

L(x, ~! )=Le(x, ~! )+Ld(x, ~! )+Li(x, ~! ) color shade (point x, normal n) { for all lights // direct illumination

Ld += contribution from light;

// indirect illumination ω’ = random direction in hemisphere above n;

Li += brdf * shade(trace(x, ω’)) * dot(n, ω’) / (p(ω’));

if last bounce not specular // prevent double-counting

return Ld + Li;

return Le + Ld + Li; }

Rendering Algorithms Spring 2016 69 Path Tracing Algorithm

L(x, ~! )=Le(x, ~! )+Ld(x, ~! )+Li(x, ~! ) color shade (point x, normal n) { for all lights // direct illumination

Ld += contribution from light;

if rand() > q // indirect illumination ω’ = random direction in hemisphere above n;

Li += brdf * shade(trace(x, ω’)) * dot(n, ω’) / (p(ω’));

if last bounce not specular // prevent double-counting

return Ld + Li / (1-q);

return Le + Ld + Li / (1-q); }

Rendering Algorithms Spring 2016 70 Path Tracing on 99 Lines of C++

48. Vec radiance(const Ray &r, int depth, unsigned short *Xi){ 49. double t; // distance to intersection Minimalistic PT by Kevin Beason 50. int id=0; // id of intersected object 51. if (!intersect(r, t, id)) return Vec(); // if miss, return black 52. const Sphere &obj = spheres[id]; // the hit object 1. #include // smallpt, a Path Tracer by Kevin Beason, 2008 53. Vec x=r.o+r.d*t, n=(x-obj.p).norm(), nl=n.dot(r.d)<0?n:n*-1, f=obj.c; 2. #include // Make : g++ -O3 -fopenmp smallpt.cpp -o smallpt 54. double p = f.x>f.y && f.x>f.z ? f.x : f.y>f.z ? f.y : f.z; // max refl 3. #include // Remove "-fopenmp" for g++ version < 4.2 55. if (++depth>5) if (erand48(Xi).1?Vec(0,1):Vec(1))%w).norm(), v=w%u; 7. Vec operator+(const Vec &b) const { return Vec(x+b.x,y+b.y,z+b.z); } 59. Vec d = (u*cos(r1)*r2s + v*sin(r1)*r2s + w*sqrt(1-r2)).norm(); 8. Vec operator-(const Vec &b) const { return Vec(x-b.x,y-b.y,z-b.z); } 60. return obj.e + f.mult(radiance(Ray(x,d),depth,Xi)); 9. Vec operator*(double b) const { return Vec(x*b,y*b,z*b); } 61. } else if (obj.refl == SPEC) // Ideal SPECULAR reflection 10. Vec mult(const Vec &b) const { return Vec(x*b.x,y*b.y,z*b.z); } 62. return obj.e + f.mult(radiance(Ray(x,r.d-n*2*n.dot(r.d)),depth,Xi)); 11. Vec& norm(){ return *this = *this * (1/sqrt(x*x+y*y+z*z)); } 63. Ray reflRay(x, r.d-n*2*n.dot(r.d)); // Ideal dielectric REFRACTION 12. double dot(const Vec &b) const { return x*b.x+y*b.y+z*b.z; } // cross: 64. bool into = n.dot(nl)>0; // Ray from outside going in? 13. Vec operator%(Vec&b){return Vec(y*b.z-z*b.y,z*b.x-x*b.z,x*b.y-y*b.x);} 65. double nc=1, nt=1.5, nnt=into?nc/nt:nt/nc, ddn=r.d.dot(nl), cos2t; 14. }; 66. if ((cos2t=1-nnt*nnt*(1-ddn*ddn))<0) // Total internal reflection 15. struct Ray { Vec o, d; Ray(Vec o_, Vec d_) : o(o_), d(d_) {} }; 67. return obj.e + f.mult(radiance(reflRay,depth,Xi)); 16. enum Refl_t { DIFF, SPEC, REFR }; // material types, used in radiance() 68. Vec tdir = (r.d*nnt - n*((into?1:-1)*(ddn*nnt+sqrt(cos2t)))).norm(); 17. struct Sphere { 69. double a=nt-nc, b=nt+nc, R0=a*a/(b*b), c = 1-(into?-ddn:tdir.dot(n)); 18. double rad; // radius 70. double Re=R0+(1-R0)*c*c*c*c*c,Tr=1-Re,P=.25+.5*Re,RP=Re/P,TP=Tr/(1-P); 19. Vec p, e, c; // position, emission, color 71. return obj.e + f.mult(depth>2 ? (erand48(Xi)

eps ? t : ((t=b+det)>eps ? t : 0); 79. #pragma omp parallel for schedule(dynamic, 1) private(r) // OpenMP 28. } 80. for (int y=0; y1 ? 1 : x; } 93. } 42. inline int toInt(double x){ return int(pow(clamp(x),1/2.2)*255+.5); } 94. } 43. inline bool intersect(const Ray &r, double &t, int &id){ 95. FILE *f = fopen("image.ppm", "w"); // Write image to PPM file. 44. double n=sizeof(spheres)/sizeof(Sphere), d, inf=t=1e20; 96. fprintf(f, "P3\n%d %d\n%d\n", w, h, 255); 45. for(int i=int(n);i--;) if((d=spheres[i].intersect(r))&&d

Rendering Algorithms Spring 2016 71 Questions?

• Use MIS at least for direct illumination!

Rendering Algorithms Spring 2016 72 A Simple Example Scene

Scattering media with index matched boundary, i.e.

Rendering Algorithms Spring 2016 73 + Dielectric Boundary

Rendering Algorithms Spring 2016 74 + Glossy Materials

Rendering Algorithms Spring 2016 75 + Inconveniently placed light source

Rendering Algorithms Spring 2016 76 Another Simple Scene

Henrik Wann Jensen 10 paths/pixel

Rendering Algorithms Spring 2016 77 + Glass/Mirror Material

Henrik Wann Jensen 10 paths/pixel

Rendering Algorithms Spring 2016 78 Path Tracing Caustics

Glass sphere

Rendering Algorithms Spring 2016 79 Path Tracing Caustics

Glass sphere (delta BRDF)

Rendering Algorithms Spring 2016 80 Path Tracing Caustics

Random sampling of hemisphere will rarely hit the light source

Rendering Algorithms Spring 2016 81 Path Tracing Caustics

Random sampling of hemisphere will never hit the light source

Rendering Algorithms Spring 2016 82 Let’s just give it more time...

• Nature ~ 2 × 1033 / second • Fastest GPU ray tracer ~ 2 × 108 / second “ .. if we'd rendered [Gravity] on a single processor instead of having a room full of computers, we would have had to start rendering in 5000 BC to fnish in time to deliver the flm. At the dawn of Egyptian civilisation.

[Gravity, Framestore]

Tim Webber, Gravity VFX supervisor ”

Rendering Algorithms Spring 2016 83 Let’s just give it more time...

1 image ~ 8 core years (parallelized on a cluster)

Rendering Algorithms Spring 2016 84 Path Tracing - Summary

✓ Full solution to the rendering equation ✓ Simple to implement ✘ Slow convergence – requires 4x more samples to half the error ✘ Robustness issues – does not handle some light paths well (or not at all), e.g. caustics ( ) ✘ No reuse or caching of computation ✘ General sampling issue – makes only locally good decisions

Rendering Algorithms Spring 2016 85