Blender Git Commits

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

DRW: Fix const correctness

EEVE: Lights: Implement simple culling scheme.

This has the basis of clustered light culling but does not yet do
it. The lights are only culled by frustum.

Its the same as if there was only one Cell for the entire Viewport.

EEVEE: Split shading passes to eevee_shading.cc

EEVEE: Refactor: Split implementation to .cc file

This also wrap GPUFrameBuffer & GPUTexture inside eevee:Framebuffer
and eevee:Texture to improve managment.

Another cleanup was to put all members of `Instance` public to
avoid much complexity in accessing the data with modules
dependencies.

Also split velocity View related data to `class Velocity` and
rename previous `Velocity` to `VelocityModule`

EEVEE: Lights: Support infinite light count

Support infinite light count by dividing rendering into chucks of
LIGHT_MAX. Forward passes are just rendered again and deferred passes
(not implemented yet) will just have to have multiple light evaluation
passes.

EEVEE: Lights: Initial Work in progress implementation

Only supports simple point lights for now