Blender Git Commits

Fix Denoising Albedo pass behind glass in Cycles X

Makes the albedo pass match to what it used to be before the split
kernel redesign.

The normal is all zeroes, which is a bit counter-intuitive, but is
how it used to be as well.

Test file: {F10211946}

Differential Revision: https://developer.blender.org/D11807

Fix over-exposed float3 passes in Cycles X

Was affecting configurations when adaptive sampling is used
and passes like Denoising Albedo.

Fix Cycles X OIDN with adaptive sampling

The decision on whether to scale input buffer was wrong.
It was wrong from the beginning in the Cycles X branch,
but the bug got avoided by some other state set differently.

Cycles X: Multi-device re-balancing

This is an initial implementation which seems to give better
device utilization here when using two non-matched GPUs, as
well as multi-GPU and CPU.

General idea is to balance amount of work based on an
observed performance of devices, and "re-slice" the big tile.

Things which are known to be not final but considered a further
development:

- The balancing algorithm might need some tweaks for the
objective function and weight modification to converge to
the ideal balance quicker.

- The "re-slicing" might also be optimized memory-wise.

- Headless rendering needs to give few iterations of smaller
works to allow multi-device to settle down in the balance.

The balancing logic is in own little file, which simplifies
process of experiments.

Differential Revision: https://developer.blender.org/D11774

Cycles X: Make temp CPU-side render buffers creation reusable

Cycles X: Ground work for work balancing

No actual logic implementation yet, just taking gradual steps towards
the desired goal.

Cycles X: Avoid device copy for every pass

Differential Revision: https://developer.blender.org/D11743

Fix CPU rendering and OptiX denoiser in Cycles X

Make sure copying of temporary render buffers to the device
happens as part of the denoiser queue.

Initially thought this will be fixed by some more global changes
related to multi-GPU support, but:

- It is a simple and clear change.
- It brings multi-device support to a working state, which makes
it easier to verify changes.
- Multi-device is supported at a higher level, and it could still
be useful to support current usecases of DeviceDenoiser (where
input render buffers are allocated on a different device).

Differential Revision: https://developer.blender.org/D11742

Cycles X: Ensure OptiX denoiser setup and usage uses the same stream

Avoids possible access of denoiser non-initialized state without
explicit sync.

Differential Revision: https://developer.blender.org/D11741

Cycles X: Remove zero_to_device from RenderBuffers::reset()

In all the current usages of RenderBuffers::reset the zero was
actually redundant.

This change makes it easier to allocate temporary render buffer
and copy data to it as a part of a specific stream without zero
(which happens in the default stream) conflicting.

Differential Revision: https://developer.blender.org/D11740

Cycles X: Fix crash using CPU and OptiX denoiser in viewport

Not sure why it is only visible now, there was a buffer overrun since
the initial CPU Render + OptiX denoise support commit by the looks of
it.

There now seems to be a synchronization issue between queues, leading
to only partial buffer update in the viewport. Investigating this now.

Cycles X: Initialize all fields of buffer params

Allows to rely on default constructor and follow-up call of
modified() without accessing non-initialized fields.

Cycles X: Remove redundant field in path trace works

Render buffers are available via the base class, no need to duplicate
it in the derived classes.

Cycles X: Initial support of multi-GPU and GPU+CPU rendering

This change makes it possible to render single frame on multiple GPUs
and/or GPU(s)+CPU. (as configured in the User Preferences).

Work is split equally along the height of the big tile.
In the future this will be looked into to perform better initial guess
based on devices performance, dynamic re-scheduling, and interleaving
scanlines across devices.

The main idea is to move render buffers to per-work basis, so that the
ender buffers are always associated with the device work is being done
by. And then upon access delegate the read/write to the work, so that
it operates with a specific slice in the source/destination,

There are some multiple memory and performance improvements possible,
like:

- Copy render result to GPUDisplay from multiple threads (now when it
is clear graphics inetrop can not be mixed in with naive update).
- Avoid denoiser buffer re-allocation.
- Avoid creation of temporary buffers in the denoisers when we know
that we have a copy of real buffers.
- Only copy passes needed for denoiser, and results of denoiser.

The current state of the `PathTrace::denoise()` is not entirely ideal:
it could be split up, and memory usage could be improved. But think it
is good enough for the initial implementation. The further improvements
would require changes in the Denoiser API.

Differential Revision: https://developer.blender.org/D11727

Cycles X: Move need-to-zero-render-buffers check to render scheduler

No functional changes, but localizes handling of the render buffers,
helping with the coming further development.

Fix Cycles X multi-device type generation

The info type can not be set to first device type because the device
might be ignored. So delay type assignment until we have a device which
is known to be used.

Fixes issue in viewport when OptiX+OptiX will be considered an OptiX
device with 2 sub-devices, and OptiX+OptiX+CPU will be considered a
Multi device. The issue with the latter one is that the info IDs in
both cases are the same, but not the type, making it a wrong comparison
in `DeviceInfo::operator==`.

Differential Revision: https://developer.blender.org/D11729

Cycles X: remove old volume code

Cycles X: tweak a few functions for easier reuse in volume code

Cycles X: restore two more volume stack functions

Cycles X: refactor path termination in preparation for volume bounces

To support similar logic as transparent and emissive surfaces.