Associating extra information to a ray in Cycles

Question

Maxwell Render has a feature called Multilight, where the integrator keeps track of which emitter contributed how much to the scene, so that lights can be dimmed or brightened without re-rendering. As far as I'm aware, this feature does not exist in Blender.

If you wanted to implement Multilight in Blender, you would need to keep track of the different emitters' contributions in the integrator. So to any ray is associated a series of numbers indicating the contributions per light, and afterwards these extra numbers are available to the compositor (so that the different contributions can be mixed and matched however needed).

My question is not about Multilight, but rather about a more general problem:

Is it possible (and if so, how) to associate in Cycles' integrator to every ray some extra piece of information, process it on every bounce, and have the result available in the compositor?

The Multilight case is an example of this, but here are two others:

• calculate for every ray the total distance it has traveled from camera to emitter
• keep track of how many times a ray has hit a certain object

For the first of these, I'm aware of the Ray length socket in the Light path input node, but I don't see how to keep track of all these things along an entire ray.

Answer 1

Simple Answere

This is not possible without changing the code of Cycles. ;)

More Detailed

While rendering, there is no data stored about the individual rays, only until the current sampling function returns. There are multiple images – passes – stored and are kept and accessible, but storing data for every ray would need hundreds of gigabytes for large renders. Reading such amount of data would most probably be slower than rendering.

By touching the source of Cycles you could average out additional information about rays into new passes, like the number of bounces or total ray length. This is what other renderers do probably.

Emulating Multilighting

LuxRender allows to create light-groups. The lighting of those groups can be changed later, their color or intensity to be precise.

This behaviour can be achieved in Blender by separating your light-groups onto layers and creating a separate render layer for each group.

In the compositor you could mix these without rendering. Rendering each layer again in the compositor would be easy with the designated button.

Example Scene

Compositor Setup

The pass of the lamps are multiplied with (2, 2, 2) and (0.5, 0.5, 0.5) colors. The same result is achieved when the strength of lamps are changed to 200 and 50 from 100:

Emulating Bounce Count Pass

You would have to create multiple renders with the limit of total bounces increased on each render. Subtracting those from each other one would get the amount of contribution a given bounce provides.

You could multiply 0, 1, 2, etc with the related contributions and sum those. Dividing the result with the sum of the contributions – the last render – would result in the contribution weighted bounce count average.

You could use the bigger than node to get where each bounce contributed at least a little and multiply them with the related 0, 1, 2, etc and get the maximum of those. This would result the maximum bounce count for each pixel.

Bouce Count Setup

Answer 2

If you could isolate your emission sources and render them independently, then you could manage this in the Compositor via a Brightness & Mix/Multiply node set. The isolation per render image would basically allow you to render with the max amount of Rays that you would desire to sample.

At this point you could then take those images as image inputs, and mix them together based on Brightness levels which essentially is determined by number of bounces, and length of rays (The sum of all of these parts / The fruit of the render labor). You could also use Math nodes to determine a "Less Than" or "Greater Than" factor of brightness, and logically have the same basic controls over your renders that you just described in your example.