Blender Git Loki

Cycles: kernel tweaks to make GPU compilation work

Cycles: add DeviceKernel::NUM_KERNELS

Cycles: Make CPU queue be able to access CPUDevice

Cycles: Make CPU textures initialization more explicit

Allows to decouple queues allocation from their initialization for
actual path tracing.

Interesting fact: using auto&& in range based loop over unique_ptr<Foo>
will make variable type Foo&.

Cycles: Make PathTrace have same lifetime as Session

Avoids re-initialization based on per-render call.

Might not be so visible for offline rendering, but is kind of crucial
for viewport rendering.

Cycles: Fix missing updates on camera rotation

Is currently invisible, but for the on-gong development is nice to
have proper viewport updates,

Effectively, revers behavior of previous commit: it is a bit more
tricky to detect when kernel globals are to be copied. Roll back
to older behavior for now.

Cycles: Initial support of viewport rendering

Rather straightforward idea: request path trace to copy its render
buffers to the given display buffer. There is some more glue logic
to pass samples, resolution divider, and proper offset/stride to
the kernel.

For some reason viewport is not that interactive: seems that there
is no redraw on lower resolution results. Could be because of the
locking nature of the `render_samples()` call, or could be something
else. Forcing resolution divider in the tile manager, or setting
pixel size to 8x clearly shows proper behavior, so it's something
with the updates rather than an issue in implementation of this
part of the code.

The TileManager is still the source of truth for current sample
and resolution. This will be moved out in the further development.

Cycles: Avoid unnecessary copy of KernelGlobals

Re-use "thread-local" copy as much as possible.

Cleanup: De-duplicate array size calculation

The function should become more re-usable, but is not immediately clear
what is the best place for it.

Cycles: Add default constructor to CPUKernelThreadGlobals

Allows to create thread-local KernelGlobals without giving an explicit
value. Currently unused, but is needed for an upcoming development.

Cycles: Split CPUDevice to own file

Makes it possible to CPU device specific logic from other CPU-related
entities, such as render queue.

Cycles: avoid updating global memory bounce state for shader evaluation

Cycles: basic support for transparent shadows

Missing still is volume shadows and support for continuing to trace if the
max number of hits is exceeded.

Fix error in light_sample_terminate

Cycles: Make path tracer aware of start sample of tile manager

This is a part of "bring viewport rendering back" project.
This is something what is required to have with the current way of
how viewport drawing is done. In the future it might make sense to
have PathTrace persistent in the Session, so that it can keep track
of sample and resolution divider.

However, this new API will likely be used to achieve the "add more
samples to existing render" feature.

Cycles: break up direct_emission function

To help experiment with reordering this code and potentially moving light
shader evaluation into its own kernel or have a single shader evaluation
function in the surface kernel.

Fix incorrect assert in shadow kernel

Cycles: Fix work scheduler causing oversampling of one pixel

Typical off-by-one in range calculation.

Cycles: Fix border rendering

Cycles: Simplify render buffers management

Avoid per-integrator-queue render buffers, which also avoids copy
of render results from one buffer to another.

Now on CPU all integrator queues are sharing same render buffer
created for the big tile and are writing to different parts of
this buffer.

For a single-GPU device there will be one integrator queue and one
render buffer on the device side.

Multi-device would need to have some more tricky buffer management
that it originally looked like to me; data transfers are to be
avoided as much as possible. So ideally it would be some per-device
statically allocated buffers, with possibly some re-arrangement
during rendering to balance things better. From the memory ownership
point of view it will mean per-device render buffers and multiple
integrator queues for CPU. So from this point of view the idea of
path tracing context becomes obsolete.

Remove the PathTraceContext. Maybe later it can become PathTraceWork
with an implementation of "wavefront management". But for now lets
keep things more localized to PathTrace for easier refactoring.