Blender Git Loki

GPUNodeTree: Add weight tree inversion

This constructs a "mirror" nodetree that feeds the closure "shader"
nodes with their respective final weight.

The tree is mirrored using simple math nodes. This is quite messy but
this is the only way to proceed without introducing special nodes.
The other issue with this method is that inputs are all uniforms even
for unplugged socket on temporary math nodes with add bloat to the
shader uniform buffer structure.

Only the part relevant to the weighting is duplicated. Other connexions
with the shading tree are reuse.

All shader nodes are updated to receive a `Weight` hidden parameter.

The original shader mixing tree is preserve to let the choice of using
either way to weight the output.

For now this is only done for the output nodes. This will need to be
extended to Closure to RGBA sub-tree.

GPUNodeTree: Move closure socket implicit cast to ntreeGPUMaterialNodes

This reduces complexity of weighting closure in further dev.

GPUNode: Remove ssr_id and sss_id

These are not useful anymore.

GPU/EEVEE: Refactor codegen and nodetree support

This is the first step towards the new evaluation scheme of EEVEE
closures.

This commit contains:
- Removal of GPU_SOURCE_BUILTIN type, prefering global instead. This
avoid many boilerplate code since most of the old builtins are now
datas that are always present (i.e: view matrices, normals).
- Rewritting of codegen in C++ to use `std::stringstream`.
- Added a callback to let engine decide what to do with codegen code.
This remove a lot of needs for defines because of code order
dependency. The engine can insert the nodetree code in custom ways
to create advance effects (i.e: add displacement or vertex lighting).
Engine now returns final shader strings.
- Closure nodes evaluation replacment is a placeholder for now.

EEVEE: Material: Add basic material logic

This is a port of the old material grouping. This is a bit more
clean as we use containers for each passes and other structures.

Nodetree is generated without major error for simple materials but
it is not yet used as closures are not outputed.

DRWShaderLib: Add better debug output from missing lib

EEVEE: Implementation of volume rendering

This adds the transparency and volume handling in the deferred
render pipeline.

Implementation is still unfinished.

To have better naming convention, I renamed object shader to surface.

EEVEE: Initial implementation of deferred shading

This introduce a fat Gbuffer layout that groups closure data in groups
of similar BSDF. The goal is to have at least one sample for each
group to avoid too much code complexity and expected worse performance.

There is a lot of room for buffer reuse to reduce memory usage but it is
not considered a priority for now.

DRWTexture: Add missing integer render-targets format support.

EEVEE: Add specular layer to temporary default material

EEVEE: Film/Sampling: Add smooth transition

Add a smooth transition to avoid flickering of stochastic effects such
as soft shadows.

This use a simple blend method to progressively reveal the render
after some low sample count to avoid most of the flickering.

Parameters are hardcoded for now.

EEVEE: Shadow: Add back soft shadows support

We use a new RNG to avoid correlation artifacts between Anti-Aliasing
and Shadow samples (see T68594).

The new sequence is a leap halton sequence. This makes it good with
low number of samples and yield less correlation issues.

Another change is that we directly jitter the projection matrix instead
of rotating the view matrix. This is improving convergence time and
avoid passing a second matrix to the shader.

However this case lead to discontinuity artifacts at face boders.
We might want to revert to the old rotation method for this
reason even if convergence is slower.

EEVEE: Shadow: Add back shadow caster tracking

Compared to previous implementation this does track dupli objects.

There is a few optimizations left like using bitfield instead of bool
arrays.

EEVEE: Shadow: Simplify the shadow module

Now the shadows are linked to a `Light` object. The `Light` object is
linked to an `ObjectKey` to ensure persistence and deletion tracking.

The Uniform data are packed so that there is 1 `ShadowPunctualData`
per light in a `LightBatch`. This means there is only a shadowmap
limit to the number of `Shadow` in a scene.

EEVEE: Use C++ vector types

BLI: Add more operator to float2/3 and int2/3

BLI: add int2 and int3 C++ support

Simple addition based on float2/3.

DRW: Debug: Add DRW_debug_view

EEVEE: Shadow: Add Point light shadows support back

Difference with previous implementation:
- Better texture space usage of cone and area light shadow.
- Shadows are packed in an atlas. Reducing requirements for future
features.
- Sampling is simpler because shadow matrix does everything.

EEVEE: Fix use after free crash