## Thursday, July 2, 2020

### Warping samples paper at rendering symposium

Here is a paper at EGSR being presented tomorrow at the time of this writing.

It deals with sampling lights.  The paper is pretty daunting because it has some curve fitting which always looks complicated and it works on manifolds so there are Jacobians running around.   But the basic ideas are less scary than the algebra implies and is clean in code.  I will cover a key part of it in a simple case.

If you are doing direct lighting from a rectangular light source, this is the typical Monte Carlo code for shading a point p:

pick point q on light with PDF p(q) = pdf_q
d = unit_vector(q-p)
light += BRDF * dot(d, n_p) * dot(-d, n_q) * emitted(q) / (distance_squared(p,q) * pdf_q)

Most renderings, or most of mine anyway, pick the point uniformly on the rectangle so pdf_q = 1/area.   There are more sophisticated methods that try to pick the PDF intelligently.  This is hard in practice.  See the paper for some references to cool work.

But we can also just try to make it one or two steps better than constant PDF.  The first obvious candidate is PDF that is bilinear which just computes this at each corner:

weight = BRDF * dot(d_corner, n_p) * dot(-d, n_corner) * emitted(corner) / distance_squared(p,corner)

The PDF gets 4 weights and needs to be normalized so it a PDF, and you need to pick points from it.  This is an algebraic book-keeping job.  But not bad (see the paper!).  The disruption to the code is no big deal.   For my particular C++ implementation here is my sampling code (which is a port of David Hart's shadertoy-- see that for the code in action-- this is just to show you it's no big deal)

// generate a sample from a bilinear set of weights
vec2 sample_quad(const vec2& uv, const vec4& w) {
vec2 newuv;
real u = pdf_u(uv.x(), w);
real v = pdf_v(uv.y(), u, w);
return vec2(u,v);

// helper functions
inline real pdf_u(real r, const vec4& w) {
real A = w.z() + w.w() - w.y() - w.x();
real B = 2.*(w.y()+w.x());
real C = -(w.x() + w.y() + w.z() + w.w())*r;
}

inline real pdf_v(real r, real u, const vec4& w) {
real A = (1.-u)*w.y() + u*w.w() - (1.-u)*w.x() - u*w.z();
real B = 2.*(1.-u)*w.x() + 2.*u*w.z();
real C = -((1.-u)*w.y() + u*w.w() + (1.-u)*w.x() + u*w.z())*r;
}

// evaluate the PDF
inline real eval_quad_pdf(const  vec2& uv, const vec4& w ) {
return 4.0 *
( w.x() * (1.0 - uv.x()) * (1. - uv.y())
+ w.y() * (1.0 - uv.x()) * uv.y()
+ w.z() * uv.x()        * (1. - uv.y())
+ w.w() * uv.x()        * uv.y()
) / (w.x() + w.y() + w.z() + w.w());
}

The same basic approach works on triangles and works if you sample in a solid angle space.  I hope you try it!