Blender Git Loki

Cleanup: add utility functions write writing ray and isect to integrator state

Fix CUDA runtime compilation after last commit

Cleanup: rename and move various files for consistency

* Shorten filenames when they are in a device specific folder
* Rename kernel/kernels to kernel/device
* Move kernel_*_compat.h to kernel/device/*/compat.h
* Move kernel_globals.h to kernel/device/*/globals.h
* Move kernel.h and filter.h into kernel/device/cpu
* Rename path trace work classes from Pixel/Tiled to CPU/GPU
* Remove old OpenCL split kernel files

Cycles: Move GPU display texture state tracking to base class

While is still not ideal and feels rather fragile, at least now the
actual implementation of a sub-class is straightforward and does not
require state tracking.

Cycles: refactor CPU/megakernel for more flexible execution order

Previously it would call kernels in a fixed order, which becomes harder with
a more complex state machine for SSS and volumes. Further, there was code
duplication in that kernels would be indicate the next kernel to execute, and
check if the current kernel needs to be executed.

Instead use queued_kernel on both CPU and GPU, and implement the megakernel as
a switch statement using this value.

Fix crash rendering scene without light

Fix OpenImageDenoise link error

Fix Cycles viewport flicker after recent refactor

Was a mistake in the modification check of the GPU display parameters.

Cycles: Fix possible missing updates in PathTrace

The path tracer schedules multiple samples to render to keep device
busy between updates. This was causing an issue with a time check in
the update function: it is possible that N samples finished rendering
slightly faster than aimed 1 second, so the update callback will not
be called. So perceptually rendering was looking sluggish in some
scenes, especially at the lower number of samples rendered.

Now the frequency of updates is fully under PathTrace::render_samples
control.

Technically, simple scenes might be rendering slower now, since there
will be more updates now. This could be addressed by aiming for a
longer render times between updates (schedule more samples to the
device) after reaching certain noise level.

Cycles: Fix possible stalling in viewport updates

If rendering a sample takes longer than update timeout it was
possible to have viewport navigation which will never update a
viewport during navigation.

For example, rendering on CPU with high start resolution and
denoising enabled could have taken a bit more than configured
0.1sec. Before this change the viewport would have only updated
after navigation was finished. After this change the viewport
will be refreshed at about 10fps, which is better for artists.

Cycles: Remove kernel status from Progress

Was a remaining part from feature kernels.

The kernel status was never called now, meaning, all the places which
were using that status were using an empty string, effectively ignoring
it.

Cycles: Fix crash when rendering with OSL enabled

Implement move semantic for the CPUKernelThreadGlobals.

Without this the way how kernels globals were initialized was using move
semantic, but was leaving runtime pointers in original and a moved copy.

Cycles: Remove unused update time tracking

Cycles: Remove unused reset time tracking

Cycles: Log render time from main rendering loop

This way it is possible to log render time of viewport.

Ideally would need to also be possible to expose it into the interface
so that artists can use it for benchmarking as well, but that would be
a more intrusive change.

Cycles: Remove duplicated code

This was a leftover from run_cpu() times which was doing an explicit
reset before main loop iteration. Now this is all handled at the top
of the main render loop in run_update_for_next_iteration().

Should be no functional changes.

Cycles: Hide more logic from main render loop

No functional changes, just moving decision making logic to a more
consolidated place.

Cycles: Fix usage of emplace_back()

Cycles: Initial implementation of GPUDisplay

The idea of GPUDisplay is to take care of viewport texture update
and drawing in a way that is the same exact from API point of view
for both CPU and GPU rendering.

This change moves a lot of code and refactors it in a more reusable
and isolated building blocks to implement the GPUDIsplay for Blender
viewport.

The CPU rendering is same exact from users perspective.

The GPU rendering currently does not use CUDA OpenGL buffers, which
can potentially cause degradation in the performance.

There is also a temporary half buffer in BlenderGPUDisplay, because
it is not clear yet how to create OpenGL context, so that we can
update texture from different thread than the drawing.

The update of the GPUDisplay is performed by the Session. Ideally,
this will be done in PathTracer so that it can avoid unnecessary
updates if sample rendered quick enough. This behavior will need a
bit deeper change in a way how TIleManager, Session::render() and
PathTracer are communicating to each other.

Cycles: Remove unused draw() return value

Should be no functional changes since the return value was never used.