I wish I hadn’t waited so long to read this paper. It’s got three of my favorite things in a graphics paper: it’s image-space, it’s got a proof rather than hand waving, and it’s clever! It contains some damned pretty images too.

The setup is pretty much the same as every image-space rendering algorithm. You render a few buffers (3D position and normal) of the refractive object from the view of the light. Like most image-space algorithms, you want to consider each texel in these buffers to be a small surface. To calculate the caustics on the scene, you want to know where the light refracted through each of these surfaces ends up in the 3D scene. This is the hard part about rendering caustics, because you need to know where the refracted ray intersects the scene. Ray-scene intersection on the GPU = impractical (though obviously not impossible). This is the problem that this paper takes a hack at.

By additionally rendering the 3D positions of the scene (sans-refractive object) from the view of the light, this algorithm totally bypasses explicit ray-scene intersection. The paper outlines an iterative method which moves toward the correct distance along the refracted ray at which it intersects a scene surface, in image-space. The algorithm is as follows:

Assume an initial distance d along the refracted ray

do for some number of iterations:

Backproject the 3D position P1 at length d along the ray into view space of the camera

at length along the ray into view space of the camera Use the calculated view space position to get the 3D position P2 of the scene from the scene position buffer

of the scene from the scene position buffer Use the distance between the P1 and P2 as the new estimate for d

The paper offers a proof of convergence based on Newton’s method. By repeating this process for each texel in the refractive object buffer and splatting the refracted flux onto the scene at the 3D position calculated by the iterative process above, voila caustics.

One problem with a naive implementation is that the amount of flux splatted onto the scene is dependent on the number of texels covered by the refractive object in the refractive object buffers. The paper states that the flux contribution of each texel is the flux at the surface (N dot L) multiplied by the reciprocal of the projected area of the object in the refracted object buffer. The paper doesn’t state this, but I believe that this should additionally be multiplied by a fresnel term. The projected area is calculated by performing an occlusion query from the view of the light.

I think the method in this paper is very practical. The frame rates are fantastic. They suggest two buffers for the refractive objective information but it could be stored in one RGBA texture by storing depth in one channel and backprojecting/unprojecting the depth to 3D position. This will save a bit on bandwidth and utilize the ALU a bit more.

Musawir A. Shah, Jaakko Konttinen, Sumanta Pattanaik. “Caustics Mapping: An Image-space Technique for Real-time Caustics” To appear in IEEE Transactions on Visualization and Computer Graphics (TVCG).

paper – project page