Blender Git Loki

Cycles: Boiler plate code for kernel queues

The goal of this change is lay down an initial version of API which
will allow path tracer to queue kernels for execution.

This is done by introducing new `DeviceQueue` class which is a higher
level abstraction over concepts like OpenCL queue or CUDA stream. Its
purpose is to take overhead of kernels invocation. The queue is created
by a device, and after that it becomes self-sufficient.

The queue is implemented as a "stub" for CPU device.

This change also contains changes which is basically an initial pass
over render graph implementation.

In order to have all bits tested had to rake over `Session::render()`
function so now render result is always empty. The old code is ifdefed
so that it is more visible which parts of code are to be brought back
in a proper design.

Next steps will include implementation of some resource management so
that integrator kernels can be actually invoked.

Cleanup: Cycles, remove unneeded forward declaration

Cleanup: Cycles, use const reference in RenderBuffers::reset()

No functional changes. Allows to pass parameters as a const-reference
in the upcoming code.

Cycles: Pull make_unique into the ccl namespace

Allows to allocate object instances which are guarded by unique_ptr
in a more modern fashion.

This is a C++14 feature, which is higher than typically used C++11
in the Cycles code. Since Blender is C++17 it makes sense to move
to a newer standard in Cycles as well. All this is applicable if
there are no other places in Cycles which are relying on a more
modern C++ already.

Cycles: Fix compilation error with strict compiler flags

Added a note to re-evaluate in the future whether implementing proper
assign semantic worth a trouble. For now, just be careful and not use
the macro for something which is not a struct with only (possibly
vectorized) scalars.

Cycles: add integrator control flow utility macros and correct subsurface kernel

* The control flow macros do nothing yet, but help communicate what is happening
and may become useful. Perhaps for actual scheduling, or for debugging only.
* Subsurface should be scheduled after surface and do direct and indirect lighting
as per the design.
* Add INTEGRATOR_STATE_COPY to copy shadow path and volume stack state.

Cycles: flesh out integrator kernels a bit more

* Add background kernel
* Add render buffer argument to kernels that need it
* Placeholder code to explain control flow and state access

Cycles: initial struct and macro definitions for integrator state

Cycles: Add boiler plate for PathTrace class

As per design, the idea of this class it to implement the kernel graph
and all the logic needed for adaptive path tracing of a big tile on the
given (multi)device.

This commit is very minimalistic, could be seen as one big TODO, but it
feels better to put all files in place early on.

The change introduces the new folder called integrator in the root of
Cycles sources. The reasoning includes the following thoughts:

- There will be more auxiliary classes such as CPU side of a queue,
perhaps variance calculation, adaptive stopping criteria and many
things like that.

- For the long time it felt that we need more separation in Cycles code
structure to separate scene state and rendering algorithms.

Cycles: Register split kernel functions in CPUDevice

Self-explanatory.

Still need to be exposed via the Device API, but first would be nice to
quickly double-check on it.

Cycles: Boiler plate code for the new split kernel functions

The implementation of kernels places in the kernel/integrator folder to
make some distinction between new code being written and the existing.

Currently, all the kernels have a single KernelGlobals argument and an
empty implementation. It would be nice if there is a way to have a
minimal and standard arguments, as it simplifies things in the future.

The new "section" of code is marked as such. Not sure if it's helping
or not, but kind of feels it makes it easier to see functions which
are to be removed or, at least, re-evaluated.

The way how kernels are defined and declared follows the legacy macro,
which I'm not huge fan of, but don't feel like looking into more clear
ways of replacing them is a good time investment at this time. It is
all localized, and doesn't matter too much for the actual code of the
kernels implementation.

Cycles: Remove CPU split kernel declaration

Was missing in the bigger split kernel removal commit.

There are still places in the code which are `ifdef __SPLIT_KERNEL__`
and those are to be removed as well. Although they aren't really in
a way yet.

Cycles: Remove split kernel

This changes removes split kernel implementation and majority
of related boiler plate code on device level.

The goal is to free up some room for the new split kernel
implementation.

The OpenCL becomes unusable with this change. CPU, CUDA, and
OptiX are still working. CPU still passes regression tests.

There are some more possibilities to simplify code, like remove
the requested features and CPUKernelFunctions abstraction, but
it can happen as a followup development.

Cycles: Disable CUDA and OpenCL by default

Allows to focus on CPU side of changes, without having to worry
about disabling the options manually.

Once an initial new kernel and AO rendering is done we can enable
those back.

Point submodules to main Blender repositories

Solves issue with `make update` which expects submodules to be relative
to the blender.git.

Seems that it is important to do `make update` first time after this change,
otherwise local .git/config will use "wrong" URLs. This means the easiest way
to get proper thing to work is:

- Clone repository
- Switch to the branch
- Only then run `make update`