Blender Git Loki

EEVEE: Lightprobe: Port back lightprobe filtering

No much change appart from code organization and structure.

DRW: Add DRW_view_frustum_bsphere_get

DRW: Increase shader library max supported lib count

DRW: Add DRW_view_get_active

EEVEE: Lightprobe: Add simple world probe rendering and downsampling

EEVEE: Add back world nodetree support

Only for background for now.

Support is now not using defines and just use the correct globals and
uniforms to keep the same values as before.

World: Add static default world

This is a small convenience. This let the render engine use this
default world if scene has no world.

World is black to keep the same behavior as before.

EEVEE: Fix ModelMatrix in nodetree and wrong bump map output

EEVEE: Rework multi material handling

Shading groups are now created by the material_array_get functions
instead of passing a reference to be filled later. This avoids having
to wait later to maybe create a sub shading group.
This also simplifies different geomety type handling.

EEVEE/GPU: Nodes: Fix some BSDF nodes

Fix glass, principled and eevee specular shaders.

EEVEE: GPencil: Add basic support for gpencil geometry

This adds support for rendering gpencil objects.

There is a lot of features to implement specially the ones requiring
per object uniforms.

EEVEE: Material: Fix shader uuid to material type conversion

DRW: Shader: Fix deferred compilation abortion

The case where a shader was queued but then requested as non deferred
was not handled correctly.

EEVEE: Add back split sum BSDF approximation

This improves the surface appearance of most bsdf.

EEVEE: Material: Use weight to random sample closure per types

This adds a new closure selection method.

- In a first pass, weights are accumulated per output type (diffuse,
reflection, refraction).
- A random threshold is then generated before evaluating the BSDF nodes
again.
- During the evaluation pass the random threshold is decremented until
it reaches 0. At this moment the current BSDF is sampled.

For this to work, I splited the evaluation and the weighting in two
functions for all BSDF. The `*_eval` nodes are generated as dangling
nodes from the graph and only serialized after the rest of the graph.

GPUMaterial: Add recalc flag workaround

Recalc flag on Material ID being unavailable to render engine, this
adds a simple way to detect material update by detecting shader creation
or update.

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.