Blender Git Loki

Cycles: Preliminary support of multi-threaded rendering

Implemented by creating multiple path tracing contexts per device.

Some of the PathTrace logic will be changed as discussed with Brecht
over #34, but this part seems to be needed anyway.

Cycles: Initial pass of adding work scheduling for path tracer

Touches a lot of little things which will be needed for a final version
of work scheduler, putting API in place.

The scheduling logic is still CPU-centric, but is now hidden behind a
more manageable API.

The biggest thing to figure out is the big tile render buffer memory
and per-device "work" memory.

Cycles: Mark BufferParams as const

No functional changes, but allows to use offset calculation from code
which wants to operate on const buffer params.

Cycles: initial implementation of direct light in new integrator

Only opaque shadows for now.

Cycles: minor optimization for render pass accumulation

Cycles: do more complete shaderdata setup using new integrator state

Cycles: Load texture info before creating integrator queue

This allows kernel to access texture information.

The place of where loading is done is a bit weird on a first glance,
but it seems to match what was happening in the task-based code.

Cycles: initial implementation of surface shader evaluation

There are many loose ends marked with TODO, but it's a starting point.

Cycles: convert more path state functions to use new integrator state

Cycles: add DeviceQueue method to test if any work remains

Cycles: remove CMJ pattern, prepare random number code for new integrator state

We should always use PMJ instead of CMJ, and not have to know the number of
samples in advance. This simplifies the code a bit.

Cycles: work towards writing directly to render buffer instead of PathRadiance

This only has basic writing to the combined pass for the new kernels. A
significant change is that we now accumulate transparency instead of alpha.
This means we only have to write transparency for background and holdouts,
rather than writing alpha on path termination, which happens in many places.

Cycles: Remove network device

The implementation was never finished, and the way how new split kernel
is organized it is not possible to implement network rendering on a
device level in an efficient way.

Cleanup: Simplify Cycles app folder inclusion

The check about which applications are to be compiled is done in the
`app/CMakeLists.txt`, so there is no need to duplicate condition in
the parent folder.

Refactor: Move support classes from device_cpu.cpp to own files

Reduces boiler plate code of a single file, making it more clear what
is going on in each of the objects.

Refactor: Move Cycles device declarations closer to implementation

Avoid one header where functions for all devices are declared. Also,
made it so caller will not care about compiled-in features: it should
be possible to request device initialization and enumeration, and if
the compiled-in support is missing it will act similar to case when
the system does not have the requested device.

Makes it so things are more properly black-boxed and separated.
There is still some possible combing to be done, but think this change
is a good first iteration.

Cycles: Move denoiser's TileInfo into ccl namespace

Is unclear why it needs to be defined in the global scope.

Refactor: Move Cycles devices to sub-folders

The idea is to have per-device type folder, where more than one file is
allowed to be existing. This is something what was already happening
for CUDA and OpenCL devices. Do the same for CPU and OptiX. Also move
the device implementation files to the folder.

The way how OpenCL and OptiX class hierarchy is implemented needs a bit
of refactor to streamline it. It will happen when we will be adding
support of CUDA and OptiX back.

Refactor: Change the way how Cycles reports uarch name

Avoid a global variable which gets strcmp-ed from a KernelFunctions.
Instead, do an explicit log from CPUDevice's constructor. This way the
microarchitecture is always logged, regardless of whether it is a first
render or a subsequent one.

Cycles: prepare part of shader setup and evaluation code for new integrator state