Blender Git Commits

Cycles: Fix border rendering with denoising enabled

The code assumed that the rendered image starts at (0, 0), which is of course wrong for border rendering.

Fix compilation on MSVC with 64-bit bitmasks in the Pass flag

Apparently MSVC doesn't like the (1UL << x) syntax, so now 1 is explicitly cast to a 64-bit integer before shifting.

Merge remote-tracking branch 'origin/master' into soc-2016-cycles_denoising

Conflicts:
intern/cycles/kernel/kernel_path.h
intern/cycles/kernel/kernel_path_branched.h
intern/cycles/kernel/kernel_types.h
intern/cycles/render/buffers.cpp
intern/cycles/render/buffers.h
intern/cycles/render/film.cpp
intern/cycles/render/film.h
intern/cycles/render/integrator.cpp
source/blender/render/intern/source/render_result.c

Cycles: Add the two new headers to CMake

Cycles: Implement Postprocessing API

This commit implements the Postprocessing API in the Cycles Python bindings
and the poll function in the actual Cycles code.
The actual postprocessing doesn't do any processing yet.

Render API/Image Editor: Add postprocessing operator that calls the render engine when executed

This commit adds a general operator for postprocessing render results in the Image editor.
To do so, the render API is extended by two functions:
- can_postprocess checks whether the current render result can be postprocessed by the engine.
For the denoiser, this will check whether the required passes have been rendered.
- postprocess is executed when the user runs the operator. For the denoiser, this will do the actual denoising.

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.