Blender Git Loki

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.

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