Blender Git Loki

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

EEVEE: Check updates using recalc flag only an object maps.

This avoids having to reset accumulation if nothing affecting
eevee changes.

EEVEE: Light: Add back LTC area lights and lighting function

I did a small optimization pass to avoid some division and
redundant computation.

Also cleans-up the Light vector usage.

EEVEE: Light: 2.5D Culling: Initial implementation

This follows closely the implementation of 2.5D tiled light
culling described in the presentation:
"Improved Culling for Tiled and Clustered Rendering"
from Michal Drobot
http://advances.realtimerendering.com/s2017/2017_Sig_Improved_Culling_final.pdf

I chose the tile + Z binning approach for its high depth range support
and low CPU overhead & low memory consumption compared to the cluster
based culling. The cons is that the culling is a bit less precise in
some aspect but it is quite balanced.

The culling is done by the `Culling` object which is templated to easily
be reused for light probes cullg.

The Z-binning process is described starting from slide 20 in the
reference pdf.

I also implemented a debug pass to visualize false negative (light
culled when they shouldn't) and light evaluation density.
This is useful to detect failure case and hotspot. This could be exposed
as a developper only render pass in the future.

Some optimization of the reference implementation requires extensions
not yet added to GPU module and will be added later.

GPUTexture: Fix missing cases for integer textures