Blender Git Loki

Cleanup: add various #includes to make it possible to include individual headers

For the new integrator kernels we only want to include what is needed for every
kernel, not everything. Still a long way to get there, but I'm adding #includes as
I find them missing.

Cycles: disable shader ray-tracing and specific bounces types

For easier refactoring.

Cycles: initial implementation of background shader evaluation

Cycles: modify integrator kernels to check if they need to execute

And do some renaming for clarity.

Cycles: Properly initialize camera rays

The idea is to pass KernelWorkTile to the generate_camera_rays
kernel so that it can have access to screen-space coordinates.
Some fields of the KernelWorkTile are unused and are either to
be removed in the future, or a simplified version of a struct
is to be used.

The device side of changes is related on making it to queue is
aware of where in the bug tile if is operating on. Currently
done as an API of DeviceQueue, and with time might become more
clear whether such work tile concept should only be done for
path tracing related queue.

The path tracer change is rather annoying and a bit messy: it
evaluates the render graph for every pixel in a progressive
refine manner. It is slow and single threaded, and code is not
folded very flexible yet. The good thing is that it allows to
make it so kernels to output proper data.

The output kernels needs an adjustment, so that they write to
an offset within the render buffer. Only modified the surface
kernel, because otherwise other kernels will override the value
and make it so nothing is visible.

Cycles: Cleanup, rename WorkTile to KernelWorkTile

Makes it a clear separation between device and kernel types.

Cycles: initial implemention of intersect_closest kernel

Cycles: initial implementation of generate_camera_rays kernel

Cycles: dummy implementation of background and surface to write something

Cleanup: mark KernelGlobals const in kernel, and use ccl_restrict in new code

Not sure if restrict will help performance in practice, but might as well
start marking this kind of stuff as we bring back kernel functionality.

Cycles: disable old CPU path tracing and bake kernels implementation

Build only the new integrator kernels, for easier refactoring of the code.

Cleanup: use pragma once for all kernel headers

Previously some were using #ifdef and some not, now make it all consistent so
we can more easily include headers without worrying about duplication, especially
while we reorganize the kernel code.

Cycles: Communicate path tracer result to the UI

The Session side is implemented similarly to the progressive refine.
There is some code duplication there, but this is a temporary code,
since the tile and render tile concepts will likely be eliminated.

Cycles: Refactor kernel invocation

Use variadic template and make KernelFunction look like an actual
function call. This was an initial plan when the abstraction was
added, just was never implemented because C++11 was not a thing
back in those days.

Cycles: Move kernel functions to own container struct

Allows to localize initialization logic, have all kernels grouped
together. But what is more important, allows to share function
pointers with queue.

Cycles: Boiler plate for actual kernels invocation

Now the integrator kernels will be invoked by the path traces.

For now the path state is hard-coded to 1. Will be done properly
as one of the nearest future changes.

Another thing which needs to be changed in the nearest future is
the render buffer management. We really need to communicate it
to the BlenderSession to start seeing actual pixels!

Cycles: Refactor KernelFunctions class

- Rename it toKernelFunction with a comment which makes it explicit
that it is a single kernel, which picks up best microarchitecture
for the current configuration.

- Re-write initialization part, avoiding chain of code-wise if-else
mixed together with preprocessor.

Some further possibilities:

- Avoid preprocessor check, and rely on settings and function pointers
to pick up best kernel, avoiding preprocessor.

- Use string_view or something similar instead of `char*` to make
comparison more modern.

Cycles: Refactor kernel globals localization

A follow-up of the previous change. Based on the idea that
KernelGlobals pointer is not needed for OSL. Allows to use
more const qualifiers.

Fix Cycles compilation error without OSL

Annoyingly, had to roll back to an untyped memory buffer for OSL globals.

Cycles: Refactor kernel globals localization used for CPU

Move all resource management to a dedicated class. Reduces code
duplication between rendering and shading, as well as makes resource
management more localized and robust.

Additionally, removed the kgbuffer, which seemed to be some sort of
part of a finished project.

Should become handy when adding actual execution logic to the device
queue (which would need to have KernelGlobals in order to invoke
kernels).

Currently no functional changes. Tested by switching Session::render()
back to its operable state.