Blender Git Loki

Cycles: Cleanup - use an enum instead of hardcoded types, scale data passes by scale

This commit turns the extended pass types into an enum for nicer code.
Also, the feature passes are now scaled like the regular ones, which means that the passes
are shown correctly in the Image editor.

Cycles: Add CPU overhead dneoising as a debug option

In order to allow easier debugging of memory-related bugs in the GPU code,
this commit adds the option to also use overscan denoising on CPUs.

Cycles: Implement GPU denoising

This commit adds the CUDA denoising kernels and host code.

Cycles: Implement tile overscan for GPU denoising

This commit adds support for tile overscan - rendering a larger tile internally
and only showing its center area. That is needed for GPU denoising since the regular
approach of keeping the neighbor tiles in memory would require far too much memory.
Since tiles are generally quite large on GPUs, the added overhead isn't too large.

Cycles: Add experimental second-order fitting for denoising, disabled for now

This change can help a lot with shadow edges, but adds artifacts to smoother areas.
In the future, I'll look into adaptively selecting the polynomial order.

Cycles: Implement denoising kernels

This commit finally adds the denoising kernels, which means that basic denoising is operational now.

Cycles: Add device code and kernel stubs for denoising

This commit implements stub kernels and the required host-side code to call them (CPU-only for now).

Cycles: Add util header with various matrix/vector math operations for the denoiser

Cycles: Add function to get neighbor tiles for denoising

This is needed by the denoising task to get the buffers of the nearby tiles.
Also, this commit syncs the half window option into the kernel data.

Cycles: Separate the render result for selective denoising

This commit finally implements the selective denoising pass writing.
With this commit, the denoising feature passes and therefore the changes to the
regular Cycles kernels should be finished.

Cycles: Refactor storing of the integration result

This commit refactors how the integration result is stored: Instead of summing up
the PathRadiance in the integration function and returning the final color, the integration
function now fills a PathRadiance passed to it and just returns the alpha value.
The main kernel function then passes that PathRadiance to kernel_write_result, a new function
which then handles summing, clamping and storing of light and combined passes.

This commit by itself shouldn't change existing behaviour, but is needed for the upcoming
selective denoising.

Cycles: Write denoising feature passes

With this commit, the newly added passes finally get some content.
The three explicitly stored features are the surface normal, the albedo of the surface
and the path length from the camera. These features will be used by the denoiser to "understand"
where differences in lighting come from - for example, the normal pass allows the denoiser to
smooth the noise on a wall, but keep the edge in the corner of the room perfectly sharp.
To preserve small detail like bumpmapped reflections, the actual normal used for shading
is stored instead of the surface normal which is used for the regular Normal pass.
The main purpose of the albedo pass is to preserve fine texture detail, but can also help to detect
object borders.
The depth pass helps for some edges where both surfaces have the same orientation
(so that normal don't help), but its variance also helps to detect depth-of-field blurring.

The real image passes aren't stored yet because they still require a bit of refactoring.

Cycles: Add a roughness variable to ShaderClosures to be used for the denoise feature heuristic

To produce better results for sharp reflections/refractions, the denoise features are only written at the first
rough/diffuse bounce. To determine whether the current bounce is rough/diffuse or not, the roughness of the individual
closures will be used.
Also, the PathState tracks the total length of the path, for the same reason (it might not be written at the first bounce).

Cycles: Allocate and sync the denoise passes

With this commit, Cycles will add the passes to the result if keeping them is activated.
The actual data isn't written yet, so it just returns zeros.

Render: Add denoising passes to the Render code

These passes will eventually be hidden from the user, but for now they're really
useful for debugging.

Render API: Allow renderers to allocate additional passes

This commit adds the add_pass function to the renderer API, which allows a renderer
to add a pass to a certain or all render layers. Since the RNA only has 32bit integers as
argument types, the position of the passtype bit is passed instead of the actual passtype.
When additional RenderResults are allocated, all additional passes added to the main result
are added to it as well.

Render: Extend the passtype field of RenderPasses to 64 bit

This commit extends the number of possible pass types to 64 bit. However, it only
affects the structures used for storage during and after rendering, not the SceneRenderLayer
that's visible to the user (due to various limitations to 32 bit integers in RNA).
Therefore, their main purpose is to be allocated by the renderer based on some other setting.

Cycles Denoising: Defaults for the RenderLayer options

Cycles Denoising: Add RenderLayer options

This commit adds the necessary parameters to the RenderLayer panel and syncs them to Cycles.
It would be nicer to define the RNA properties from Cycles Python code like most other ones, but
since that's not possible for RenderLayers, it has to be added in the DNA :/

Cycles Denoising: Implement the denoising data render passes in Cycles

The parameters aren't set anywhere yet since that requires them to be added to the RenderLayer first.