archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
e305560f13c3c67b048dc3889c7797eae2e345c4
blender-archive/source/blender/draw/engines/eevee/eevee_lights.c

1487 lines
52 KiB
C
Raw Normal View History

Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
/*
* Copyright 2016, Blender Foundation.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* Contributor(s): Blender Institute
*
*/
/** \file eevee_lights.c
* \ingroup DNA
*/
#include "DRW_render.h"
Eevee: Shadows: Filtering improvement. - Replace poisson by concentric samples: Less variance. They are sorted by radius then by angle. - Separate filtering into 2 blur. First blur is 3x3 box blur. Second is user dependant. - Group fetches by group of 4.
2017-09-08 20:21:57 +02:00
#include "BLI_dynstr.h"
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
#include "BLI_rand.h"
Eevee: Make use of culling when rendering the shadowmaps.
2018-03-02 18:35:25 +01:00
#include "BLI_rect.h"
Eevee: Shadows: Filtering improvement. - Replace poisson by concentric samples: Less variance. They are sorted by radius then by angle. - Separate filtering into 2 blur. First blur is 3x3 box blur. Second is user dependant. - Group fetches by group of 4.
2017-09-08 20:21:57 +02:00
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
#include "BKE_object.h"
Move EEVEE properties into scene We handle doversion for the scene properties, but not for the view layer overrides. Overrides will be implemented in a different way via dynamic overrides. For now this data is completely lost.
2018-05-16 19:34:24 +02:00
#include "DEG_depsgraph_query.h"
Cleanup: draw engine - use DRW_engine prefix for engine types. - use engine suffix for files that define a draw engine. - remove engines from include path (they're only referenced once)
2017-04-26 17:42:39 +10:00
#include "eevee_engine.h"
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
#include "eevee_private.h"
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
#define SHADOW_CASTER_ALLOC_CHUNK 16
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
Eevee: Add debug visual for Cascaded Shadow Maps
2018-07-16 20:08:02 +02:00
// #define DEBUG_CSM
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
// #define DEBUG_SHADOW_DISTRIBUTION
Eevee: Add debug visual for Cascaded Shadow Maps
2018-07-16 20:08:02 +02:00
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
static struct {
struct GPUShader *shadow_sh;
Eevee: Add Variance Shadow Mapping This is an alternative to ESM. It does not suffer the same bleeding artifacts.
2017-09-01 18:39:39 +02:00
struct GPUShader *shadow_store_cube_sh[SHADOW_METHOD_MAX];
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
struct GPUShader *shadow_store_cube_high_sh[SHADOW_METHOD_MAX];
Eevee: Add Variance Shadow Mapping This is an alternative to ESM. It does not suffer the same bleeding artifacts.
2017-09-01 18:39:39 +02:00
struct GPUShader *shadow_store_cascade_sh[SHADOW_METHOD_MAX];
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
struct GPUShader *shadow_store_cascade_high_sh[SHADOW_METHOD_MAX];
Eevee: Shadows: Filtering improvement. - Replace poisson by concentric samples: Less variance. They are sorted by radius then by angle. - Separate filtering into 2 blur. First blur is 3x3 box blur. Second is user dependant. - Group fetches by group of 4.
2017-09-08 20:21:57 +02:00
struct GPUShader *shadow_copy_cube_sh[SHADOW_METHOD_MAX];
struct GPUShader *shadow_copy_cascade_sh[SHADOW_METHOD_MAX];
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
} e_data = {NULL}; /* Engine data */
extern char datatoc_shadow_vert_glsl[];
extern char datatoc_shadow_frag_glsl[];
extern char datatoc_shadow_store_frag_glsl[];
Eevee: Shadows: Filtering improvement. - Replace poisson by concentric samples: Less variance. They are sorted by radius then by angle. - Separate filtering into 2 blur. First blur is 3x3 box blur. Second is user dependant. - Group fetches by group of 4.
2017-09-08 20:21:57 +02:00
extern char datatoc_shadow_copy_frag_glsl[];
extern char datatoc_concentric_samples_lib_glsl[];
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
Eevee: Add Light Threshold value This is an important change. Starting from now, all lights have a finite influence radius (similar to the old sphere option for BI). In order to avoid costly setup time, this distance is first computed automatically based on a light threshold. The distance is computed at the light origin and using the inverse square falloff. The setting can be found inside the render settings panel > shadow tab. This light threshold does not take the light shape into account an may not suit every case. That's why we provide a per lamp override where you can just set the cutt off distance (Light Properties Panel > Light > Custom Distance). The influence distance is also used as shadow far clip distance. This influence distance does not concerns sun lights that still have a far clip distance. --- This change is important because it makes it possible to cull lights an improve performance drastically in the future.
2018-11-15 14:44:45 +01:00
/* Prototypes */
Eevee: Support for dupli lamps without shadows.
2018-01-09 18:01:56 +01:00
static void eevee_light_setup(Object *ob, EEVEE_Light *evli);
Eevee: Add Light Threshold value This is an important change. Starting from now, all lights have a finite influence radius (similar to the old sphere option for BI). In order to avoid costly setup time, this distance is first computed automatically based on a light threshold. The distance is computed at the light origin and using the inverse square falloff. The setting can be found inside the render settings panel > shadow tab. This light threshold does not take the light shape into account an may not suit every case. That's why we provide a per lamp override where you can just set the cutt off distance (Light Properties Panel > Light > Custom Distance). The influence distance is also used as shadow far clip distance. This influence distance does not concerns sun lights that still have a far clip distance. --- This change is important because it makes it possible to cull lights an improve performance drastically in the future.
2018-11-15 14:44:45 +01:00
static float light_attenuation_radius_get(Lamp *la, float light_threshold);
Eevee: Support for dupli lamps without shadows.
2018-01-09 18:01:56 +01:00
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* *********** LIGHT BITS *********** */
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
static void lightbits_set_single(EEVEE_LightBits *bitf, uint idx, bool val)
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
{
if (val) {
bitf->fields[idx / 8] |= (1 << (idx % 8));
}
else {
bitf->fields[idx / 8] &= ~(1 << (idx % 8));
}
}
static void lightbits_set_all(EEVEE_LightBits *bitf, bool val)
{
memset(bitf, (val) ? 0xFF : 0x00, sizeof(EEVEE_LightBits));
}
static void lightbits_or(EEVEE_LightBits *r, const EEVEE_LightBits *v)
{
for (int i = 0; i < MAX_LIGHTBITS_FIELDS; ++i) {
r->fields[i] |= v->fields[i];
}
}
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
static bool lightbits_get(const EEVEE_LightBits *r, uint idx)
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
{
return r->fields[idx / 8] & (1 << (idx % 8));
}
Cleanup: whitespace, long lines, duplicate include
2018-05-26 10:41:25 +02:00
static void lightbits_convert(
EEVEE_LightBits *r, const EEVEE_LightBits *bitf, const int *light_bit_conv_table, uint table_length)
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
{
for (int i = 0; i < table_length; ++i) {
if (lightbits_get(bitf, i) != 0) {
if (light_bit_conv_table[i] >= 0) {
r->fields[i / 8] |= (1 << (i % 8));
}
}
}
}
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
/* *********** FUNCTIONS *********** */
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
void EEVEE_lights_init(EEVEE_ViewLayerData *sldata)
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
{
Cleanup: use 'uint' in draw manager
2018-05-11 07:48:52 +02:00
const uint shadow_ubo_size = sizeof(EEVEE_Shadow) * MAX_SHADOW +
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
sizeof(EEVEE_ShadowCube) * MAX_SHADOW_CUBE +
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
sizeof(EEVEE_ShadowCascade) * MAX_SHADOW_CASCADE;
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
const DRWContextState *draw_ctx = DRW_context_state_get();
Move EEVEE properties into scene We handle doversion for the scene properties, but not for the view layer overrides. Overrides will be implemented in a different way via dynamic overrides. For now this data is completely lost.
2018-05-16 19:34:24 +02:00
const Scene *scene_eval = DEG_get_evaluated_scene(draw_ctx->depsgraph);
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
if (!e_data.shadow_sh) {
e_data.shadow_sh = DRW_shader_create(
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
datatoc_shadow_vert_glsl, NULL, datatoc_shadow_frag_glsl, NULL);
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
}
Eevee: Put shadows and probes inside SceneLayerEngineData This remove the duplication of data for each viewport improving memory usage.
2017-05-30 22:29:20 +02:00
if (!sldata->lamps) {
sldata->lamps = MEM_callocN(sizeof(EEVEE_LampsInfo), "EEVEE_LampsInfo");
sldata->light_ubo = DRW_uniformbuffer_create(sizeof(EEVEE_Light) * MAX_LIGHT, NULL);
sldata->shadow_ubo = DRW_uniformbuffer_create(shadow_ubo_size, NULL);
sldata->shadow_render_ubo = DRW_uniformbuffer_create(sizeof(EEVEE_ShadowRender), NULL);
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
for (int i = 0; i < 2; ++i) {
sldata->shcasters_buffers[i].shadow_casters = MEM_callocN(sizeof(EEVEE_ShadowCaster) * SHADOW_CASTER_ALLOC_CHUNK, "EEVEE_ShadowCaster buf");
sldata->shcasters_buffers[i].flags = MEM_callocN(sizeof(sldata->shcasters_buffers[0].flags) * SHADOW_CASTER_ALLOC_CHUNK, "EEVEE_shcast_buffer flags buf");
sldata->shcasters_buffers[i].alloc_count = SHADOW_CASTER_ALLOC_CHUNK;
sldata->shcasters_buffers[i].count = 0;
}
sldata->lamps->shcaster_frontbuffer = &sldata->shcasters_buffers[0];
sldata->lamps->shcaster_backbuffer = &sldata->shcasters_buffers[1];
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* Flip buffers */
SWAP(EEVEE_ShadowCasterBuffer *, sldata->lamps->shcaster_frontbuffer, sldata->lamps->shcaster_backbuffer);
Move EEVEE properties into scene We handle doversion for the scene properties, but not for the view layer overrides. Overrides will be implemented in a different way via dynamic overrides. For now this data is completely lost.
2018-05-16 19:34:24 +02:00
const int sh_method = scene_eval->eevee.shadow_method;
int sh_cube_size = scene_eval->eevee.shadow_cube_size;
int sh_cascade_size = scene_eval->eevee.shadow_cascade_size;
const bool sh_high_bitdepth = (scene_eval->eevee.flag & SCE_EEVEE_SHADOW_HIGH_BITDEPTH) != 0;
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
sldata->lamps->soft_shadows = (scene_eval->eevee.flag & SCE_EEVEE_SHADOW_SOFT) != 0;
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
EEVEE_LampsInfo *linfo = sldata->lamps;
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
if ((linfo->shadow_cube_size != sh_cube_size) ||
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
(linfo->shadow_method != sh_method) ||
(linfo->shadow_high_bitdepth != sh_high_bitdepth))
Eevee: Shadow: Add high bitdepth option. This option is here for reducing the memory usage of shadow maps. Also lower bitdepth are quicker to process.
2017-09-02 02:27:28 +02:00
{
Eevee: Cap Shadow resolution to 4096px^2. As much as I want to give freedom to the user, 1.5G of vram for a single shadow is a big of a stability issue. So limiting to 4096 for now, we may remove this limit in the future.
2018-05-04 15:42:06 +02:00
BLI_assert((sh_cube_size > 0) && (sh_cube_size <= 4096));
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
DRW_TEXTURE_FREE_SAFE(sldata->shadow_cube_pool);
Eevee: Shadow: Add high bitdepth option. This option is here for reducing the memory usage of shadow maps. Also lower bitdepth are quicker to process.
2017-09-02 02:27:28 +02:00
DRW_TEXTURE_FREE_SAFE(sldata->shadow_cube_target);
Eevee: Shadows: Add cubemap filtering and adaptive sample count. Filter size is constant in world space and not dependant of shadow resolution. The filter size is limited to the number of precomputed samples.
2017-09-09 21:11:22 +02:00
DRW_TEXTURE_FREE_SAFE(sldata->shadow_cube_blur);
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
Eevee: Shadows: Compute Octahedron size from CubeMap size. This was the otherway around before. But since we can have a different size* for cube texture now, we can compute the correct-ish texture size. This will give us on average the same texture appearance when we will add support for real cubemap shadows.
2018-05-04 15:59:01 +02:00
/* Compute adequate size for the octahedral map. */
Eevee: LightCache: Initial Implementation This separate probe rendering from viewport rendering, making possible to run the baking in another thread (non blocking and faster). The baked lighting is saved in the blend file. Nothing needs to be recomputed on load. There is a few missing bits / bugs: - Cache cannot be saved to disk as a separate file, it is saved in the DNA for now making file larger and memory usage higher. - Auto update only cubemaps does update the grids (bug). - Probes cannot be updated individually (considered as dynamic). - Light Cache cannot be (re)generated during render.
2018-07-10 15:02:25 +02:00
linfo->shadow_cube_store_size = OCTAHEDRAL_SIZE_FROM_CUBESIZE(sh_cube_size);
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
Eevee: Shadows: Compute Octahedron size from CubeMap size. This was the otherway around before. But since we can have a different size* for cube texture now, we can compute the correct-ish texture size. This will give us on average the same texture appearance when we will add support for real cubemap shadows.
2018-05-04 15:59:01 +02:00
CLAMP(linfo->shadow_cube_store_size, 1, 4096);
Eevee: Cap Shadow resolution to 4096px^2. As much as I want to give freedom to the user, 1.5G of vram for a single shadow is a big of a stability issue. So limiting to 4096 for now, we may remove this limit in the future.
2018-05-04 15:42:06 +02:00
CLAMP(sh_cube_size, 1, 4096);
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
Eevee: Shadows: Compute Octahedron size from CubeMap size. This was the otherway around before. But since we can have a different size* for cube texture now, we can compute the correct-ish texture size. This will give us on average the same texture appearance when we will add support for real cubemap shadows.
2018-05-04 15:59:01 +02:00
linfo->shadow_render_data.cube_texel_size = 1.0f / sh_cube_size;
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
}
Eevee: Reduce loading time. Only compile the needed shadow shaders to reduce the startup time. Theses shaders is taking forever to compile on intel (~5s each).
2018-04-08 14:31:41 +02:00
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
if ((linfo->shadow_cascade_size != sh_cascade_size) ||
(linfo->shadow_method != sh_method) ||
(linfo->shadow_high_bitdepth != sh_high_bitdepth))
{
Eevee: Cap Shadow resolution to 4096px^2. As much as I want to give freedom to the user, 1.5G of vram for a single shadow is a big of a stability issue. So limiting to 4096 for now, we may remove this limit in the future.
2018-05-04 15:42:06 +02:00
BLI_assert((sh_cascade_size > 0) && (sh_cascade_size <= 4096));
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
DRW_TEXTURE_FREE_SAFE(sldata->shadow_cascade_pool);
DRW_TEXTURE_FREE_SAFE(sldata->shadow_cascade_target);
DRW_TEXTURE_FREE_SAFE(sldata->shadow_cascade_blur);
Eevee: Cap Shadow resolution to 4096px^2. As much as I want to give freedom to the user, 1.5G of vram for a single shadow is a big of a stability issue. So limiting to 4096 for now, we may remove this limit in the future.
2018-05-04 15:42:06 +02:00
CLAMP(sh_cascade_size, 1, 4096);
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
}
linfo->shadow_high_bitdepth = sh_high_bitdepth;
linfo->shadow_method = sh_method;
linfo->shadow_cube_size = sh_cube_size;
linfo->shadow_cascade_size = sh_cascade_size;
Eevee: Reduce loading time. Only compile the needed shadow shaders to reduce the startup time. Theses shaders is taking forever to compile on intel (~5s each).
2018-04-08 14:31:41 +02:00
/* only compile the ones needed. reduce startup time. */
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
if ((sh_method == SHADOW_ESM) && !e_data.shadow_copy_cube_sh[SHADOW_ESM]) {
Eevee: Reduce loading time. Only compile the needed shadow shaders to reduce the startup time. Theses shaders is taking forever to compile on intel (~5s each).
2018-04-08 14:31:41 +02:00
e_data.shadow_copy_cube_sh[SHADOW_ESM] = DRW_shader_create_fullscreen(
datatoc_shadow_copy_frag_glsl,
"#define ESM\n"
"#define COPY\n");
e_data.shadow_copy_cascade_sh[SHADOW_ESM] = DRW_shader_create_fullscreen(
datatoc_shadow_copy_frag_glsl,
"#define ESM\n"
"#define COPY\n"
"#define CSM\n");
}
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
else if ((sh_method == SHADOW_VSM) && !e_data.shadow_copy_cube_sh[SHADOW_VSM]) {
Eevee: Reduce loading time. Only compile the needed shadow shaders to reduce the startup time. Theses shaders is taking forever to compile on intel (~5s each).
2018-04-08 14:31:41 +02:00
e_data.shadow_copy_cube_sh[SHADOW_VSM] = DRW_shader_create_fullscreen(
datatoc_shadow_copy_frag_glsl,
"#define VSM\n"
"#define COPY\n");
e_data.shadow_copy_cascade_sh[SHADOW_VSM] = DRW_shader_create_fullscreen(
datatoc_shadow_copy_frag_glsl,
"#define VSM\n"
"#define COPY\n"
"#define CSM\n");
}
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
}
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
static GPUShader *eevee_lights_get_store_sh(int shadow_method, bool high_blur, bool cascade)
{
GPUShader **shader;
if (cascade) {
shader = (high_blur) ? &e_data.shadow_store_cascade_high_sh[shadow_method]
: &e_data.shadow_store_cascade_sh[shadow_method];
}
else {
shader = (high_blur) ? &e_data.shadow_store_cube_high_sh[shadow_method]
: &e_data.shadow_store_cube_sh[shadow_method];
}
if (*shader == NULL) {
DynStr *ds_frag = BLI_dynstr_new();
BLI_dynstr_append(ds_frag, datatoc_concentric_samples_lib_glsl);
BLI_dynstr_append(ds_frag, datatoc_shadow_store_frag_glsl);
char *store_shadow_shader_str = BLI_dynstr_get_cstring(ds_frag);
BLI_dynstr_free(ds_frag);
ds_frag = BLI_dynstr_new();
BLI_dynstr_append(ds_frag, (shadow_method == SHADOW_VSM) ? "#define VSM\n" : "#define ESM\n");
if (high_blur) BLI_dynstr_append(ds_frag, "#define HIGH_BLUR\n");
if (cascade) BLI_dynstr_append(ds_frag, "#define CSM\n");
char *define_str = BLI_dynstr_get_cstring(ds_frag);
BLI_dynstr_free(ds_frag);
*shader = DRW_shader_create_fullscreen(
store_shadow_shader_str, define_str);
MEM_freeN(store_shadow_shader_str);
MEM_freeN(define_str);
}
return *shader;
}
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
static DRWPass *eevee_lights_cube_store_pass_get(EEVEE_PassList *psl, EEVEE_ViewLayerData *sldata, int shadow_method, int shadow_samples_len)
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
{
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
bool high_blur = shadow_samples_len > 16;
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
DRWPass **pass = (high_blur) ? &psl->shadow_cube_store_pass : &psl->shadow_cube_store_high_pass;
if (*pass == NULL) {
EEVEE_LampsInfo *linfo = sldata->lamps;
*pass = DRW_pass_create("Shadow Cube Storage Pass", DRW_STATE_WRITE_COLOR);
GPUShader *shader = eevee_lights_get_store_sh(shadow_method, high_blur, false);
DRWShadingGroup *grp = DRW_shgroup_create(shader, *pass);
DRW_shgroup_uniform_texture_ref(grp, "shadowTexture", &sldata->shadow_cube_blur);
DRW_shgroup_uniform_block(grp, "shadow_render_block", sldata->shadow_render_ubo);
DRW_shgroup_uniform_float(grp, "shadowFilterSize", &linfo->filter_size, 1);
DRW_shgroup_call_add(grp, DRW_cache_fullscreen_quad_get(), NULL);
}
return *pass;
}
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
static DRWPass *eevee_lights_cascade_store_pass_get(EEVEE_PassList *psl, EEVEE_ViewLayerData *sldata, int shadow_method, int shadow_samples_len)
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
{
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
bool high_blur = shadow_samples_len > 16;
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
DRWPass **pass = (high_blur) ? &psl->shadow_cascade_store_pass : &psl->shadow_cascade_store_high_pass;
if (*pass == NULL) {
EEVEE_LampsInfo *linfo = sldata->lamps;
*pass = DRW_pass_create("Shadow Cascade Storage Pass", DRW_STATE_WRITE_COLOR);
GPUShader *shader = eevee_lights_get_store_sh(shadow_method, high_blur, true);
DRWShadingGroup *grp = DRW_shgroup_create(shader, *pass);
DRW_shgroup_uniform_texture_ref(grp, "shadowTexture", &sldata->shadow_cascade_blur);
DRW_shgroup_uniform_block(grp, "shadow_render_block", sldata->shadow_render_ubo);
DRW_shgroup_uniform_int(grp, "cascadeId", &linfo->current_shadow_cascade, 1);
DRW_shgroup_uniform_float(grp, "shadowFilterSize", &linfo->filter_size, 1);
DRW_shgroup_call_add(grp, DRW_cache_fullscreen_quad_get(), NULL);
}
return *pass;
}
DRW: Refactor simple instancing. Instead of creating a new instancing shading group without attrib, we now have instancing calls. The benefits is that they can be culled. They can be used in conjuction with the standard and generate calls but shader must support it (which is generally not the case). We store a pointer to the actual count so that the number can be tweaked between redraw. This will makes multi layer rendering more efficient.
2018-03-01 19:27:38 +01:00
void EEVEE_lights_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
{
Eevee: Put shadows and probes inside SceneLayerEngineData This remove the duplication of data for each viewport improving memory usage.
2017-05-30 22:29:20 +02:00
EEVEE_LampsInfo *linfo = sldata->lamps;
DRW: Refactor simple instancing. Instead of creating a new instancing shading group without attrib, we now have instancing calls. The benefits is that they can be culled. They can be used in conjuction with the standard and generate calls but shader must support it (which is generally not the case). We store a pointer to the actual count so that the number can be tweaked between redraw. This will makes multi layer rendering more efficient.
2018-03-01 19:27:38 +01:00
EEVEE_StorageList *stl = vedata->stl;
EEVEE_PassList *psl = vedata->psl;
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
linfo->shcaster_frontbuffer->count = 0;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
linfo->num_light = 0;
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
linfo->num_cube_layer = 0;
linfo->num_cascade_layer = 0;
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
linfo->gpu_cube_len = linfo->gpu_cascade_len = linfo->gpu_shadow_len = 0;
linfo->cpu_cube_len = linfo->cpu_cascade_len = 0;
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
memset(linfo->light_ref, 0, sizeof(linfo->light_ref));
memset(linfo->shadow_cube_ref, 0, sizeof(linfo->shadow_cube_ref));
memset(linfo->shadow_cascade_ref, 0, sizeof(linfo->shadow_cascade_ref));
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
memset(linfo->new_shadow_id, -1, sizeof(linfo->new_shadow_id));
/* Shadow Casters: Reset flags. */
memset(linfo->shcaster_backbuffer->flags, (char)SHADOW_CASTER_PRUNED, linfo->shcaster_backbuffer->alloc_count);
memset(linfo->shcaster_frontbuffer->flags, 0x00, linfo->shcaster_frontbuffer->alloc_count);
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
psl->shadow_cube_store_pass = NULL;
psl->shadow_cube_store_high_pass = NULL;
psl->shadow_cascade_store_pass = NULL;
psl->shadow_cascade_store_high_pass = NULL;
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
Eevee: Shadows: Filtering improvement. - Replace poisson by concentric samples: Less variance. They are sorted by radius then by angle. - Separate filtering into 2 blur. First blur is 3x3 box blur. Second is user dependant. - Group fetches by group of 4.
2017-09-08 20:21:57 +02:00
{
psl->shadow_cube_copy_pass = DRW_pass_create("Shadow Copy Pass", DRW_STATE_WRITE_COLOR);
Cleanup: line length, right shift
2017-11-20 14:28:24 +11:00
DRWShadingGroup *grp = DRW_shgroup_create(
e_data.shadow_copy_cube_sh[linfo->shadow_method], psl->shadow_cube_copy_pass);
DRW: Rename DRW_shgroup_uniform_buffer into DRW_shgroup_uniform_texture_ref This is in order to not mix it with the incomming buffer textures.
2018-03-25 19:24:19 +02:00
DRW_shgroup_uniform_texture_ref(grp, "shadowTexture", &sldata->shadow_cube_target);
Eevee: Shadows: Filtering improvement. - Replace poisson by concentric samples: Less variance. They are sorted by radius then by angle. - Separate filtering into 2 blur. First blur is 3x3 box blur. Second is user dependant. - Group fetches by group of 4.
2017-09-08 20:21:57 +02:00
DRW_shgroup_uniform_block(grp, "shadow_render_block", sldata->shadow_render_ubo);
DRW_shgroup_uniform_float(grp, "shadowFilterSize", &linfo->filter_size, 1);
DRW_shgroup_uniform_int(grp, "faceId", &linfo->current_shadow_face, 1);
DRW_shgroup_call_add(grp, DRW_cache_fullscreen_quad_get(), NULL);
}
{
psl->shadow_cascade_copy_pass = DRW_pass_create("Shadow Cascade Copy Pass", DRW_STATE_WRITE_COLOR);
Cleanup: line length, right shift
2017-11-20 14:28:24 +11:00
DRWShadingGroup *grp = DRW_shgroup_create(
e_data.shadow_copy_cascade_sh[linfo->shadow_method], psl->shadow_cascade_copy_pass);
DRW: Rename DRW_shgroup_uniform_buffer into DRW_shgroup_uniform_texture_ref This is in order to not mix it with the incomming buffer textures.
2018-03-25 19:24:19 +02:00
DRW_shgroup_uniform_texture_ref(grp, "shadowTexture", &sldata->shadow_cascade_target);
Eevee: Shadows: Filtering improvement. - Replace poisson by concentric samples: Less variance. They are sorted by radius then by angle. - Separate filtering into 2 blur. First blur is 3x3 box blur. Second is user dependant. - Group fetches by group of 4.
2017-09-08 20:21:57 +02:00
DRW_shgroup_uniform_block(grp, "shadow_render_block", sldata->shadow_render_ubo);
DRW_shgroup_uniform_float(grp, "shadowFilterSize", &linfo->filter_size, 1);
DRW_shgroup_uniform_int(grp, "cascadeId", &linfo->current_shadow_cascade, 1);
DRW_shgroup_call_add(grp, DRW_cache_fullscreen_quad_get(), NULL);
}
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
{
DRW: Rename some DRW_STATE_* for more consistency.
2018-05-20 19:05:13 +02:00
DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL;
DRW: Refactor simple instancing. Instead of creating a new instancing shading group without attrib, we now have instancing calls. The benefits is that they can be culled. They can be used in conjuction with the standard and generate calls but shader must support it (which is generally not the case). We store a pointer to the actual count so that the number can be tweaked between redraw. This will makes multi layer rendering more efficient.
2018-03-01 19:27:38 +01:00
psl->shadow_pass = DRW_pass_create("Shadow Pass", state);
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
stl->g_data->shadow_shgrp = DRW_shgroup_create(e_data.shadow_sh, psl->shadow_pass);
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
}
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
}
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
void EEVEE_lights_cache_add(EEVEE_ViewLayerData *sldata, Object *ob)
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
{
Eevee: Put shadows and probes inside SceneLayerEngineData This remove the duplication of data for each viewport improving memory usage.
2017-05-30 22:29:20 +02:00
EEVEE_LampsInfo *linfo = sldata->lamps;
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
Eevee: Add Light Threshold value This is an important change. Starting from now, all lights have a finite influence radius (similar to the old sphere option for BI). In order to avoid costly setup time, this distance is first computed automatically based on a light threshold. The distance is computed at the light origin and using the inverse square falloff. The setting can be found inside the render settings panel > shadow tab. This light threshold does not take the light shape into account an may not suit every case. That's why we provide a per lamp override where you can just set the cutt off distance (Light Properties Panel > Light > Custom Distance). The influence distance is also used as shadow far clip distance. This influence distance does not concerns sun lights that still have a far clip distance. --- This change is important because it makes it possible to cull lights an improve performance drastically in the future.
2018-11-15 14:44:45 +01:00
const DRWContextState *draw_ctx = DRW_context_state_get();
const float threshold = draw_ctx->scene->eevee.light_threshold;
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
/* Step 1 find all lamps in the scene and setup them */
Eevee: Fix T52546 : 129th light crashes Blender
2017-09-12 13:13:20 +02:00
if (linfo->num_light >= MAX_LIGHT) {
UI/Python: rename Lamps to Lights, to follow more standard terminology. Internally it's still mostly named lamps, though some modules like Cycles were already calling them lights.
2018-06-27 14:41:53 +02:00
printf("Too many lights in the scene !!!\n");
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
}
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
else {
Lamp *la = (Lamp *)ob->data;
Eevee: Support for dupli lamps without shadows.
2018-01-09 18:01:56 +01:00
EEVEE_Light *evli = linfo->light_data + linfo->num_light;
eevee_light_setup(ob, evli);
/* We do not support shadowmaps for dupli lamps. */
if ((ob->base_flag & BASE_FROMDUPLI) != 0) {
linfo->num_light++;
return;
}
Eevee: Cleanup, naming For functions which will allocate requested data if it does not exist yet "_ensure" is to be used instead of "_get". "_get" functions should return NULL in cases when requested data does not exist yet.
2017-11-29 10:36:58 +01:00
EEVEE_LampEngineData *led = EEVEE_lamp_data_ensure(ob);
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* Save previous shadow id. */
int prev_cube_sh_id = led->prev_cube_shadow_id;
/* Default light without shadows */
led->data.ld.shadow_id = -1;
led->prev_cube_shadow_id = -1;
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
Fix EEVEE lamps with shadows by default but wrong UI Reported on T54788: Actually this was what BI was doing as well. But anyways fixed for good now. That includes a subversion bump.
2018-04-24 12:11:31 +02:00
if (la->mode & LA_SHADOW) {
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
if (la->type == LA_SUN) {
Eevee: Shadows: Don't allocate more CSM layer than we need.
2018-05-04 19:24:02 +02:00
int cascade_nbr = la->cascade_count;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
Eevee: Fix compilation issue cause by cleanup
2018-10-31 21:14:32 +01:00
if ((linfo->gpu_cascade_len + 1) <= MAX_SHADOW_CASCADE) {
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
/* Save Light object. */
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
linfo->shadow_cascade_ref[linfo->cpu_cascade_len] = ob;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* Store indices. */
EEVEE_ShadowCascadeData *data = &led->data.scad;
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
data->shadow_id = linfo->gpu_shadow_len;
data->cascade_id = linfo->gpu_cascade_len;
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
data->layer_id = linfo->num_cascade_layer;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
/* Increment indices. */
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
linfo->gpu_shadow_len += 1;
Eevee: Cleanup: Remove TODOs about MSM Soft shadows are supported in another manner, Multiple Shadow Maps are not needed anymore.
2018-10-31 19:44:01 +01:00
linfo->gpu_cascade_len += 1;
linfo->num_cascade_layer += cascade_nbr;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
linfo->cpu_cascade_len += 1;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
}
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
else if (la->type == LA_SPOT || la->type == LA_LOCAL || la->type == LA_AREA) {
Eevee: Cleanup: Remove TODOs about MSM Soft shadows are supported in another manner, Multiple Shadow Maps are not needed anymore.
2018-10-31 19:44:01 +01:00
if ((linfo->gpu_cube_len + 1) <= MAX_SHADOW_CUBE) {
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
/* Save Light object. */
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
linfo->shadow_cube_ref[linfo->cpu_cube_len] = ob;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* For light update tracking. */
if ((prev_cube_sh_id >= 0) &&
Cleanup: style, warning
2018-02-15 18:03:55 +11:00
(prev_cube_sh_id < linfo->shcaster_backbuffer->count))
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
{
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
linfo->new_shadow_id[prev_cube_sh_id] = linfo->cpu_cube_len;
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
}
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
led->prev_cube_shadow_id = linfo->cpu_cube_len;
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* Saving lamp bounds for later. */
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
BLI_assert(linfo->cpu_cube_len >= 0 && linfo->cpu_cube_len < MAX_LIGHT);
copy_v3_v3(linfo->shadow_bounds[linfo->cpu_cube_len].center, ob->obmat[3]);
Eevee: Add Light Threshold value This is an important change. Starting from now, all lights have a finite influence radius (similar to the old sphere option for BI). In order to avoid costly setup time, this distance is first computed automatically based on a light threshold. The distance is computed at the light origin and using the inverse square falloff. The setting can be found inside the render settings panel > shadow tab. This light threshold does not take the light shape into account an may not suit every case. That's why we provide a per lamp override where you can just set the cutt off distance (Light Properties Panel > Light > Custom Distance). The influence distance is also used as shadow far clip distance. This influence distance does not concerns sun lights that still have a far clip distance. --- This change is important because it makes it possible to cull lights an improve performance drastically in the future.
2018-11-15 14:44:45 +01:00
linfo->shadow_bounds[linfo->cpu_cube_len].radius = light_attenuation_radius_get(la, threshold);
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
EEVEE_ShadowCubeData *data = &led->data.scd;
/* Store indices. */
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
data->shadow_id = linfo->gpu_shadow_len;
data->cube_id = linfo->gpu_cube_len;
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
data->layer_id = linfo->num_cube_layer;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
/* Increment indices. */
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
linfo->gpu_shadow_len += 1;
Eevee: Cleanup: Remove TODOs about MSM Soft shadows are supported in another manner, Multiple Shadow Maps are not needed anymore.
2018-10-31 19:44:01 +01:00
linfo->gpu_cube_len += 1;
linfo->num_cube_layer += 1;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
linfo->cpu_cube_len += 1;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
}
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
}
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
led->data.ld.light_id = linfo->num_light;
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
linfo->light_ref[linfo->num_light] = ob;
linfo->num_light++;
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
}
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
/* Add a shadow caster to the shadowpasses */
Cleanup: line length, right shift
2017-11-20 14:28:24 +11:00
void EEVEE_lights_cache_shcaster_add(
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
EEVEE_ViewLayerData *UNUSED(sldata), EEVEE_StorageList *stl, struct GPUBatch *geom, Object *ob)
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
{
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
DRW_shgroup_call_object_add(
DRW: Refactor simple instancing. Instead of creating a new instancing shading group without attrib, we now have instancing calls. The benefits is that they can be culled. They can be used in conjuction with the standard and generate calls but shader must support it (which is generally not the case). We store a pointer to the actual count so that the number can be tweaked between redraw. This will makes multi layer rendering more efficient.
2018-03-01 19:27:38 +01:00
stl->g_data->shadow_shgrp,
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
geom, ob);
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
}
Eevee: Transparency: Add support for Clip and Stochastic shadows.
2017-07-11 01:10:57 +02:00
void EEVEE_lights_cache_shcaster_material_add(
Eevee: Fix assert when using transparent shadows Was missing some UBO bindings.
2018-09-10 18:05:00 +02:00
EEVEE_ViewLayerData *sldata, EEVEE_PassList *psl, struct GPUMaterial *gpumat,
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
struct GPUBatch *geom, struct Object *ob, float *alpha_threshold)
Eevee: Transparency: Add support for Clip and Stochastic shadows.
2017-07-11 01:10:57 +02:00
{
DRW: Refactor simple instancing. Instead of creating a new instancing shading group without attrib, we now have instancing calls. The benefits is that they can be culled. They can be used in conjuction with the standard and generate calls but shader must support it (which is generally not the case). We store a pointer to the actual count so that the number can be tweaked between redraw. This will makes multi layer rendering more efficient.
2018-03-01 19:27:38 +01:00
/* TODO / PERF : reuse the same shading group for objects with the same material */
DRWShadingGroup *grp = DRW_shgroup_material_create(gpumat, psl->shadow_pass);
Eevee: Add failsafe check in shadow material.
2017-07-11 12:42:59 +02:00
if (grp == NULL) return;
Eevee: Fix assert when using transparent shadows Was missing some UBO bindings.
2018-09-10 18:05:00 +02:00
/* Grrr needed for correctness but not 99% of the time not needed.
* TODO detect when needed? */
DRW_shgroup_uniform_block(grp, "probe_block", sldata->probe_ubo);
DRW_shgroup_uniform_block(grp, "grid_block", sldata->grid_ubo);
DRW_shgroup_uniform_block(grp, "planar_block", sldata->planar_ubo);
DRW_shgroup_uniform_block(grp, "light_block", sldata->light_ubo);
DRW_shgroup_uniform_block(grp, "shadow_block", sldata->shadow_ubo);
DRW_shgroup_uniform_block(grp, "common_block", sldata->common_ubo);
Eevee: Transparency: Add support for Clip and Stochastic shadows.
2017-07-11 01:10:57 +02:00
if (alpha_threshold != NULL)
DRW_shgroup_uniform_float(grp, "alphaThreshold", alpha_threshold, 1);
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
DRW_shgroup_call_object_add(grp, geom, ob);
Eevee: Transparency: Add support for Clip and Stochastic shadows.
2017-07-11 01:10:57 +02:00
}
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* Make that object update shadow casting lamps inside its influence bounding box. */
void EEVEE_lights_cache_shcaster_object_add(EEVEE_ViewLayerData *sldata, Object *ob)
{
if ((ob->base_flag & BASE_FROMDUPLI) != 0) {
/* TODO: Special case for dupli objects because we cannot save the object pointer. */
return;
}
EEVEE_ObjectEngineData *oedata = EEVEE_object_data_ensure(ob);
EEVEE_LampsInfo *linfo = sldata->lamps;
EEVEE_ShadowCasterBuffer *backbuffer = linfo->shcaster_backbuffer;
EEVEE_ShadowCasterBuffer *frontbuffer = linfo->shcaster_frontbuffer;
int past_id = oedata->shadow_caster_id;
/* Update flags in backbuffer. */
if (past_id > -1 && past_id < backbuffer->count) {
backbuffer->flags[past_id] &= ~SHADOW_CASTER_PRUNED;
if (oedata->need_update) {
backbuffer->flags[past_id] |= SHADOW_CASTER_UPDATED;
}
}
/* Update id. */
oedata->shadow_caster_id = frontbuffer->count++;
/* Make sure shadow_casters is big enough. */
if (oedata->shadow_caster_id >= frontbuffer->alloc_count) {
frontbuffer->alloc_count += SHADOW_CASTER_ALLOC_CHUNK;
frontbuffer->shadow_casters = MEM_reallocN(frontbuffer->shadow_casters, sizeof(EEVEE_ShadowCaster) * frontbuffer->alloc_count);
frontbuffer->flags = MEM_reallocN(frontbuffer->flags, sizeof(EEVEE_ShadowCaster) * frontbuffer->alloc_count);
}
EEVEE_ShadowCaster *shcaster = frontbuffer->shadow_casters + oedata->shadow_caster_id;
if (oedata->need_update) {
frontbuffer->flags[oedata->shadow_caster_id] = SHADOW_CASTER_UPDATED;
}
/* Update World AABB in frontbuffer. */
BoundBox *bb = BKE_object_boundbox_get(ob);
float min[3], max[3];
INIT_MINMAX(min, max);
for (int i = 0; i < 8; ++i) {
float vec[3];
copy_v3_v3(vec, bb->vec[i]);
mul_m4_v3(ob->obmat, vec);
minmax_v3v3_v3(min, max, vec);
}
EEVEE_BoundBox *aabb = &shcaster->bbox;
add_v3_v3v3(aabb->center, min, max);
mul_v3_fl(aabb->center, 0.5f);
sub_v3_v3v3(aabb->halfdim, aabb->center, max);
aabb->halfdim[0] = fabsf(aabb->halfdim[0]);
aabb->halfdim[1] = fabsf(aabb->halfdim[1]);
aabb->halfdim[2] = fabsf(aabb->halfdim[2]);
oedata->need_update = false;
}
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
void EEVEE_lights_cache_finish(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
{
Eevee: Put shadows and probes inside SceneLayerEngineData This remove the duplication of data for each viewport improving memory usage.
2017-05-30 22:29:20 +02:00
EEVEE_LampsInfo *linfo = sldata->lamps;
DRW: Remove DRWTextureFormat in favor or GPUTextureFormat. Because: - Less redundancy. - Better suffixes. Also a few modification to GPU_texture_create_* to simplify the API: - make the format explicit to the texture creation process. - remove the component count as it's specified in the GPUTextureFormat.
2018-04-30 16:02:24 +02:00
GPUTextureFormat shadow_pool_format = GPU_R32F;
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
Eevee: Put all constant uniforms in a global UBO. This is an optimization / cleanup commit. The use of a global ubo remove lots of uniform lookups and only transfert data when needed. Lots of renaming for more consistent codestyle.
2018-01-21 17:25:10 +01:00
sldata->common_data.la_num_light = linfo->num_light;
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
/* Setup enough layers. */
/* Free textures if number mismatch. */
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
if (linfo->num_cube_layer != linfo->cache_num_cube_layer) {
DRW_TEXTURE_FREE_SAFE(sldata->shadow_cube_pool);
linfo->cache_num_cube_layer = linfo->num_cube_layer;
linfo->update_flag |= LIGHT_UPDATE_SHADOW_CUBE;
}
Eevee: Fix Cascaded shadow map calculation. The first one was done correctly but the second was wrong due to the matrix being overwritten.
2018-05-04 17:33:16 +02:00
if (linfo->num_cascade_layer != linfo->cache_num_cascade_layer) {
DRW_TEXTURE_FREE_SAFE(sldata->shadow_cascade_pool);
linfo->cache_num_cascade_layer = linfo->num_cascade_layer;
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
Eevee: Add Variance Shadow Mapping This is an alternative to ESM. It does not suffer the same bleeding artifacts.
2017-09-01 18:39:39 +02:00
switch (linfo->shadow_method) {
DRW: Remove DRWTextureFormat in favor or GPUTextureFormat. Because: - Less redundancy. - Better suffixes. Also a few modification to GPU_texture_create_* to simplify the API: - make the format explicit to the texture creation process. - remove the component count as it's specified in the GPUTextureFormat.
2018-04-30 16:02:24 +02:00
case SHADOW_ESM: shadow_pool_format = ((linfo->shadow_high_bitdepth) ? GPU_R32F : GPU_R16F); break;
case SHADOW_VSM: shadow_pool_format = ((linfo->shadow_high_bitdepth) ? GPU_RG32F : GPU_RG16F); break;
Eevee: Add Variance Shadow Mapping This is an alternative to ESM. It does not suffer the same bleeding artifacts.
2017-09-01 18:39:39 +02:00
default:
BLI_assert(!"Incorrect Shadow Method");
break;
}
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
/* Cubemaps */
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
if (!sldata->shadow_cube_target) {
Cleanup: line length, right shift
2017-11-20 14:28:24 +11:00
sldata->shadow_cube_target = DRW_texture_create_cube(
Eevee: Shadows: Compute Octahedron size from CubeMap size. This was the otherway around before. But since we can have a different size* for cube texture now, we can compute the correct-ish texture size. This will give us on average the same texture appearance when we will add support for real cubemap shadows.
2018-05-04 15:59:01 +02:00
linfo->shadow_cube_size, GPU_DEPTH_COMPONENT24, 0, NULL);
Cleanup: line length, right shift
2017-11-20 14:28:24 +11:00
sldata->shadow_cube_blur = DRW_texture_create_cube(
Eevee: Shadows: Compute Octahedron size from CubeMap size. This was the otherway around before. But since we can have a different size* for cube texture now, we can compute the correct-ish texture size. This will give us on average the same texture appearance when we will add support for real cubemap shadows.
2018-05-04 15:59:01 +02:00
linfo->shadow_cube_size, shadow_pool_format, DRW_TEX_FILTER, NULL);
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
if (!sldata->shadow_cube_pool) {
sldata->shadow_cube_pool = DRW_texture_create_2D_array(
Eevee: Fix Cascaded shadow map calculation. The first one was done correctly but the second was wrong due to the matrix being overwritten.
2018-05-04 17:33:16 +02:00
linfo->shadow_cube_store_size, linfo->shadow_cube_store_size, max_ii(1, linfo->num_cube_layer),
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
shadow_pool_format, DRW_TEX_FILTER, NULL);
}
Eevee: Fix Cascaded shadow map calculation. The first one was done correctly but the second was wrong due to the matrix being overwritten.
2018-05-04 17:33:16 +02:00
GPU_framebuffer_ensure_config(&sldata->shadow_cube_target_fb, {
GPU_ATTACHMENT_TEXTURE(sldata->shadow_cube_target)
});
GPU_framebuffer_ensure_config(&sldata->shadow_cube_store_fb, {
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(sldata->shadow_cube_pool)
});
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
/* CSM */
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
if (!sldata->shadow_cascade_target) {
sldata->shadow_cascade_target = DRW_texture_create_2D_array(
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
linfo->shadow_cascade_size, linfo->shadow_cascade_size, MAX_CASCADE_NUM, GPU_DEPTH_COMPONENT24, 0, NULL);
Eevee: Shadows: Filtering improvement. - Replace poisson by concentric samples: Less variance. They are sorted by radius then by angle. - Separate filtering into 2 blur. First blur is 3x3 box blur. Second is user dependant. - Group fetches by group of 4.
2017-09-08 20:21:57 +02:00
sldata->shadow_cascade_blur = DRW_texture_create_2D_array(
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
linfo->shadow_cascade_size, linfo->shadow_cascade_size, MAX_CASCADE_NUM, shadow_pool_format, DRW_TEX_FILTER, NULL);
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
if (!sldata->shadow_cascade_pool) {
sldata->shadow_cascade_pool = DRW_texture_create_2D_array(
Eevee: Fix Cascaded shadow map calculation. The first one was done correctly but the second was wrong due to the matrix being overwritten.
2018-05-04 17:33:16 +02:00
linfo->shadow_cascade_size, linfo->shadow_cascade_size, max_ii(1, linfo->num_cascade_layer),
Eevee: Refactor Shadow System - Use only one 2d texture array to store all shadowmaps. - Allow to change shadow maps resolution. - Do not output radial distance when rendering shadowmaps. This will allow fast rendering of shadowmaps when we will drop the use of geometry shaders.
2017-09-01 15:59:01 +02:00
shadow_pool_format, DRW_TEX_FILTER, NULL);
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
GPU_framebuffer_ensure_config(&sldata->shadow_cascade_target_fb, {
GPU_ATTACHMENT_TEXTURE(sldata->shadow_cascade_target)
});
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
GPU_framebuffer_ensure_config(&sldata->shadow_cascade_store_fb, {
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(sldata->shadow_cascade_pool)
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
});
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
/* Update Lamps UBOs. */
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
EEVEE_lights_update(sldata, vedata);
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
}
Eevee: Add Light Threshold value This is an important change. Starting from now, all lights have a finite influence radius (similar to the old sphere option for BI). In order to avoid costly setup time, this distance is first computed automatically based on a light threshold. The distance is computed at the light origin and using the inverse square falloff. The setting can be found inside the render settings panel > shadow tab. This light threshold does not take the light shape into account an may not suit every case. That's why we provide a per lamp override where you can just set the cutt off distance (Light Properties Panel > Light > Custom Distance). The influence distance is also used as shadow far clip distance. This influence distance does not concerns sun lights that still have a far clip distance. --- This change is important because it makes it possible to cull lights an improve performance drastically in the future.
2018-11-15 14:44:45 +01:00
float light_attenuation_radius_get(Lamp *la, float light_threshold)
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
{
Eevee: Add Light Threshold value This is an important change. Starting from now, all lights have a finite influence radius (similar to the old sphere option for BI). In order to avoid costly setup time, this distance is first computed automatically based on a light threshold. The distance is computed at the light origin and using the inverse square falloff. The setting can be found inside the render settings panel > shadow tab. This light threshold does not take the light shape into account an may not suit every case. That's why we provide a per lamp override where you can just set the cutt off distance (Light Properties Panel > Light > Custom Distance). The influence distance is also used as shadow far clip distance. This influence distance does not concerns sun lights that still have a far clip distance. --- This change is important because it makes it possible to cull lights an improve performance drastically in the future.
2018-11-15 14:44:45 +01:00
if (la->mode & LA_CUSTOM_ATTENUATION)
return la->att_dist;
/* Compute max light power. */
float power = max_fff(la->r, la->g, la->b);
power *= fabsf(la->energy);
power *= max_ff(1.0f, la->spec_fac);
/* Compute the distance (using the inverse square law)
* at which the light power reaches the light_threshold. */
float distance = sqrtf(max_ff(1e-16, power / max_ff(1e-16, light_threshold)));
return distance;
}
Eevee: Diffuse Lights (1 / 2) I added srgb tonemapping for previewing purpose. Also since the color buffer is still not HDR, there is ugly artifacts (fixed in part2)
2017-03-28 00:09:45 +02:00
Eevee: Add Light Threshold value This is an important change. Starting from now, all lights have a finite influence radius (similar to the old sphere option for BI). In order to avoid costly setup time, this distance is first computed automatically based on a light threshold. The distance is computed at the light origin and using the inverse square falloff. The setting can be found inside the render settings panel > shadow tab. This light threshold does not take the light shape into account an may not suit every case. That's why we provide a per lamp override where you can just set the cutt off distance (Light Properties Panel > Light > Custom Distance). The influence distance is also used as shadow far clip distance. This influence distance does not concerns sun lights that still have a far clip distance. --- This change is important because it makes it possible to cull lights an improve performance drastically in the future.
2018-11-15 14:44:45 +01:00
static void light_shape_parameters_set(EEVEE_Light *evli, const Lamp *la, float scale[3])
{
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
if (la->type == LA_SPOT) {
Eevee: Add Light Threshold value This is an important change. Starting from now, all lights have a finite influence radius (similar to the old sphere option for BI). In order to avoid costly setup time, this distance is first computed automatically based on a light threshold. The distance is computed at the light origin and using the inverse square falloff. The setting can be found inside the render settings panel > shadow tab. This light threshold does not take the light shape into account an may not suit every case. That's why we provide a per lamp override where you can just set the cutt off distance (Light Properties Panel > Light > Custom Distance). The influence distance is also used as shadow far clip distance. This influence distance does not concerns sun lights that still have a far clip distance. --- This change is important because it makes it possible to cull lights an improve performance drastically in the future.
2018-11-15 14:44:45 +01:00
/* Spot size & blend */
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
evli->sizex = scale[0] / scale[2];
evli->sizey = scale[1] / scale[2];
evli->spotsize = cosf(la->spotsize * 0.5f);
evli->spotblend = (1.0f - evli->spotsize) * la->spotblend;
Eevee: Change MAX2 to max_ff
2017-04-27 22:27:41 +02:00
evli->radius = max_ff(0.001f, la->area_size);
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
else if (la->type == LA_AREA) {
Eevee: Lights: Bump the minimum area light size This is to avoid visible artifacts with default lamps intensity.
2018-10-09 19:07:52 +02:00
evli->sizex = max_ff(0.003f, la->area_size * scale[0] * 0.5f);
Cycles/Eevee: Implement disk and ellipse shapes for area lamps The implementation is pretty straightforward. In Cycles, sampling the shapes is currently done w.r.t. area instead of solid angle. There is a paper on solid angle sampling for disks [1], but the described algorithm is based on simply sampling the enclosing square and rejecting samples outside of the disk, which is not exactly great for Cycles' RNG (we'd need to setup a LCG for the repeated sampling) and for GPU divergence. Even worse, the algorithm is only defined for disks. For ellipses, the basic idea still works, but a way to analytically calculate the solid angle is required. This is technically possible [2], but the calculation is extremely complex and still requires a lookup table for the Heuman Lambda function. Therefore, I've decided to not implement that for now, we could still look into it later on. In Eevee, the code uses the existing ltc_evaluate_disk to implement the lighting calculations. [1]: "Solid Angle Sampling of Disk and Cylinder Lights" [2]: "Analytical solution for the solid angle subtended at any point by an ellipse via a point source radiation vector potential" Reviewers: sergey, brecht, fclem Differential Revision: https://developer.blender.org/D3171
2018-05-24 03:50:16 +02:00
if (ELEM(la->area_shape, LA_AREA_RECT, LA_AREA_ELLIPSE)) {
Eevee: Lights: Bump the minimum area light size This is to avoid visible artifacts with default lamps intensity.
2018-10-09 19:07:52 +02:00
evli->sizey = max_ff(0.003f, la->area_sizey * scale[1] * 0.5f);
Eevee: Diffuse Light (2/2) and GGX low quality lights GGX is missing sun lamps area.
2017-03-29 23:45:07 +02:00
}
else {
Eevee: Lights: Bump the minimum area light size This is to avoid visible artifacts with default lamps intensity.
2018-10-09 19:07:52 +02:00
evli->sizey = max_ff(0.003f, la->area_size * scale[1] * 0.5f);
Eevee: Diffuse Light (2/2) and GGX low quality lights GGX is missing sun lamps area.
2017-03-29 23:45:07 +02:00
}
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
else {
Eevee: Change MAX2 to max_ff
2017-04-27 22:27:41 +02:00
evli->radius = max_ff(0.001f, la->area_size);
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
Eevee: Add Light Threshold value This is an important change. Starting from now, all lights have a finite influence radius (similar to the old sphere option for BI). In order to avoid costly setup time, this distance is first computed automatically based on a light threshold. The distance is computed at the light origin and using the inverse square falloff. The setting can be found inside the render settings panel > shadow tab. This light threshold does not take the light shape into account an may not suit every case. That's why we provide a per lamp override where you can just set the cutt off distance (Light Properties Panel > Light > Custom Distance). The influence distance is also used as shadow far clip distance. This influence distance does not concerns sun lights that still have a far clip distance. --- This change is important because it makes it possible to cull lights an improve performance drastically in the future.
2018-11-15 14:44:45 +01:00
}
Eevee: Diffuse Lights (1 / 2) I added srgb tonemapping for previewing purpose. Also since the color buffer is still not HDR, there is ugly artifacts (fixed in part2)
2017-03-28 00:09:45 +02:00
Eevee: Add Light Threshold value This is an important change. Starting from now, all lights have a finite influence radius (similar to the old sphere option for BI). In order to avoid costly setup time, this distance is first computed automatically based on a light threshold. The distance is computed at the light origin and using the inverse square falloff. The setting can be found inside the render settings panel > shadow tab. This light threshold does not take the light shape into account an may not suit every case. That's why we provide a per lamp override where you can just set the cutt off distance (Light Properties Panel > Light > Custom Distance). The influence distance is also used as shadow far clip distance. This influence distance does not concerns sun lights that still have a far clip distance. --- This change is important because it makes it possible to cull lights an improve performance drastically in the future.
2018-11-15 14:44:45 +01:00
static float light_shape_power_get(const Lamp *la, const EEVEE_Light *evli)
{
float power;
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
/* Make illumination power constant */
if (la->type == LA_AREA) {
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
power = 1.0f / (evli->sizex * evli->sizey * 4.0f * M_PI) * /* 1/(w*h*Pi) */
80.0f; /* XXX : Empirical, Fit cycles power */
Cycles/Eevee: Implement disk and ellipse shapes for area lamps The implementation is pretty straightforward. In Cycles, sampling the shapes is currently done w.r.t. area instead of solid angle. There is a paper on solid angle sampling for disks [1], but the described algorithm is based on simply sampling the enclosing square and rejecting samples outside of the disk, which is not exactly great for Cycles' RNG (we'd need to setup a LCG for the repeated sampling) and for GPU divergence. Even worse, the algorithm is only defined for disks. For ellipses, the basic idea still works, but a way to analytically calculate the solid angle is required. This is technically possible [2], but the calculation is extremely complex and still requires a lookup table for the Heuman Lambda function. Therefore, I've decided to not implement that for now, we could still look into it later on. In Eevee, the code uses the existing ltc_evaluate_disk to implement the lighting calculations. [1]: "Solid Angle Sampling of Disk and Cylinder Lights" [2]: "Analytical solution for the solid angle subtended at any point by an ellipse via a point source radiation vector potential" Reviewers: sergey, brecht, fclem Differential Revision: https://developer.blender.org/D3171
2018-05-24 03:50:16 +02:00
if (ELEM(la->area_shape, LA_AREA_DISK, LA_AREA_ELLIPSE)) {
Merge branch 'master' into blender2.8
2018-09-19 18:19:49 +02:00
/* Scale power to account for the lower area of the ellipse compared to the surrounding rectangle. */
Cycles/Eevee: Implement disk and ellipse shapes for area lamps The implementation is pretty straightforward. In Cycles, sampling the shapes is currently done w.r.t. area instead of solid angle. There is a paper on solid angle sampling for disks [1], but the described algorithm is based on simply sampling the enclosing square and rejecting samples outside of the disk, which is not exactly great for Cycles' RNG (we'd need to setup a LCG for the repeated sampling) and for GPU divergence. Even worse, the algorithm is only defined for disks. For ellipses, the basic idea still works, but a way to analytically calculate the solid angle is required. This is technically possible [2], but the calculation is extremely complex and still requires a lookup table for the Heuman Lambda function. Therefore, I've decided to not implement that for now, we could still look into it later on. In Eevee, the code uses the existing ltc_evaluate_disk to implement the lighting calculations. [1]: "Solid Angle Sampling of Disk and Cylinder Lights" [2]: "Analytical solution for the solid angle subtended at any point by an ellipse via a point source radiation vector potential" Reviewers: sergey, brecht, fclem Differential Revision: https://developer.blender.org/D3171
2018-05-24 03:50:16 +02:00
power *= 4.0f / M_PI;
}
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
else if (la->type == LA_SPOT || la->type == LA_LOCAL) {
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
power = 1.0f / (4.0f * evli->radius * evli->radius * M_PI * M_PI) * /* 1/(4*r²*Pi²) */
Eevee: Implement Sun area lighting and few fixes/opti. Sun is treated as a unit distant disk like in cycles. Opti: Since computing the diffuse contribution via LTC is the same as not using the Linear Transformation, we can bypass most of the LTC code. This replaces the sphere analytical diffuse computation as it gives a more pleasing result very close to cycles' AND cheaper. Lights power have been retweaked to be coherent with cycles (except sun lamp with large radius where cycles has a non-uniform light distribution).
2018-01-18 21:51:23 +01:00
M_PI * M_PI * 10.0; /* XXX : Empirical, Fit cycles power */
Eevee: Codestyle, optimisation and a few fixes Something is very wrong with the energy factor. For now I tweaked them by hand to fit cycles.
2017-03-31 01:07:30 +02:00
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
/* for point lights (a.k.a radius == 0.0) */
// power = M_PI * M_PI * 0.78; /* XXX : Empirical, Fit cycles power */
}
else {
Eevee: Cleanup: Fix wrong sun area light power calculation
2018-11-14 15:54:10 +01:00
power = 1.0f / (evli->radius * evli->radius * M_PI); /* 1/(r²*Pi) */
Eevee: Make sun power match cycles better. I made an empirical test with a 100% diffuse sphere and manually tweak the lighting power of a sun lamp trying to fit cycles and eevee the best I can. Then I plotted the result and found a rough fit to the equation and that seems to work pretty well.
2018-11-14 15:46:40 +01:00
/* Make illumation power closer to cycles for bigger radii. Cycles uses a cos^3 term that we cannot reproduce
* so we account for that by scaling the light power. This function is the result of a rough manual fitting. */
Eevee: Add Light Threshold value This is an important change. Starting from now, all lights have a finite influence radius (similar to the old sphere option for BI). In order to avoid costly setup time, this distance is first computed automatically based on a light threshold. The distance is computed at the light origin and using the inverse square falloff. The setting can be found inside the render settings panel > shadow tab. This light threshold does not take the light shape into account an may not suit every case. That's why we provide a per lamp override where you can just set the cutt off distance (Light Properties Panel > Light > Custom Distance). The influence distance is also used as shadow far clip distance. This influence distance does not concerns sun lights that still have a far clip distance. --- This change is important because it makes it possible to cull lights an improve performance drastically in the future.
2018-11-15 14:44:45 +01:00
power += 1.0f / (2.0f * M_PI); /* power *= 1 + r²/2 */
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
Eevee: Add Light Threshold value This is an important change. Starting from now, all lights have a finite influence radius (similar to the old sphere option for BI). In order to avoid costly setup time, this distance is first computed automatically based on a light threshold. The distance is computed at the light origin and using the inverse square falloff. The setting can be found inside the render settings panel > shadow tab. This light threshold does not take the light shape into account an may not suit every case. That's why we provide a per lamp override where you can just set the cutt off distance (Light Properties Panel > Light > Custom Distance). The influence distance is also used as shadow far clip distance. This influence distance does not concerns sun lights that still have a far clip distance. --- This change is important because it makes it possible to cull lights an improve performance drastically in the future.
2018-11-15 14:44:45 +01:00
return power;
}
/* Update buffer with lamp data */
static void eevee_light_setup(Object *ob, EEVEE_Light *evli)
{
Lamp *la = (Lamp *)ob->data;
float mat[4][4], scale[3], power, att_radius;
const DRWContextState *draw_ctx = DRW_context_state_get();
const float light_threshold = draw_ctx->scene->eevee.light_threshold;
/* Position */
copy_v3_v3(evli->position, ob->obmat[3]);
/* Color */
copy_v3_v3(evli->color, &la->r);
evli->spec = la->spec_fac;
/* Influence Radius */
att_radius = light_attenuation_radius_get(la, light_threshold);
/* Take the inverse square of this distance. */
evli->invsqrdist = 1.0 / max_ff(1e-4f, att_radius * att_radius);
/* Vectors */
normalize_m4_m4_ex(mat, ob->obmat, scale);
copy_v3_v3(evli->forwardvec, mat[2]);
normalize_v3(evli->forwardvec);
negate_v3(evli->forwardvec);
copy_v3_v3(evli->rightvec, mat[0]);
normalize_v3(evli->rightvec);
copy_v3_v3(evli->upvec, mat[1]);
normalize_v3(evli->upvec);
light_shape_parameters_set(evli, la, scale);
/* Lamp Type */
evli->lamptype = (float)la->type;
if ((la->type == LA_AREA) && ELEM(la->area_shape, LA_AREA_DISK, LA_AREA_ELLIPSE)) {
evli->lamptype = LAMPTYPE_AREA_ELLIPSE;
}
power = light_shape_power_get(la, evli);
Eevee: Fix light color being non-linear.
2017-05-11 14:32:03 +02:00
mul_v3_fl(evli->color, power * la->energy);
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
/* No shadow by default */
evli->shadowid = -1.0f;
}
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
/**
* Special ball distribution:
* Point are distributed in a way that when they are orthogonaly
* projected into any plane, the resulting distribution is (close to)
* a uniform disc distribution.
**/
static void sample_ball(int sample_ofs, float radius, float rsample[3])
{
double ht_point[3];
double ht_offset[3] = {0.0, 0.0, 0.0};
uint ht_primes[3] = {2, 3, 7};
BLI_halton_3D(ht_primes, ht_offset, sample_ofs, ht_point);
float omega = ht_point[1] * 2.0f * M_PI;
rsample[2] = ht_point[0] * 2.0f - 1.0f; /* cos theta */
Cleanup: style
2018-10-29 10:24:42 +11:00
float r = sqrtf(fmaxf(0.0f, 1.0f - rsample[2] * rsample[2])); /* sin theta */
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
rsample[0] = r * cosf(omega);
rsample[1] = r * sinf(omega);
radius *= sqrt(sqrt(ht_point[2]));
mul_v3_fl(rsample, radius);
}
static void sample_rectangle(
int sample_ofs, float x_axis[3], float y_axis[3], float size_x, float size_y,
float rsample[3])
{
double ht_point[2];
double ht_offset[2] = {0.0, 0.0};
uint ht_primes[2] = {2, 3};
BLI_halton_2D(ht_primes, ht_offset, sample_ofs, ht_point);
/* Change ditribution center to be 0,0 */
ht_point[0] = (ht_point[0] > 0.5f) ? ht_point[0] - 1.0f : ht_point[0];
ht_point[1] = (ht_point[1] > 0.5f) ? ht_point[1] - 1.0f : ht_point[1];
zero_v3(rsample);
madd_v3_v3fl(rsample, x_axis, (ht_point[0] * 2.0f) * size_x);
madd_v3_v3fl(rsample, y_axis, (ht_point[1] * 2.0f) * size_y);
}
static void sample_ellipse(
int sample_ofs, float x_axis[3], float y_axis[3], float size_x, float size_y,
float rsample[3])
{
double ht_point[2];
double ht_offset[2] = {0.0, 0.0};
uint ht_primes[2] = {2, 3};
BLI_halton_2D(ht_primes, ht_offset, sample_ofs, ht_point);
/* Uniform disc sampling. */
float omega = ht_point[1] * 2.0f * M_PI;
float r = sqrtf(ht_point[0]);
ht_point[0] = r * cosf(omega) * size_x;
ht_point[1] = r * sinf(omega) * size_y;
zero_v3(rsample);
madd_v3_v3fl(rsample, x_axis, ht_point[0]);
madd_v3_v3fl(rsample, y_axis, ht_point[1]);
}
static void shadow_cube_random_position_set(
Cleanup: style
2018-10-29 10:24:42 +11:00
EEVEE_Light *evli, Lamp *la,
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
int sample_ofs,
float ws_sample_pos[3])
{
float jitter[3];
#ifndef DEBUG_SHADOW_DISTRIBUTION
int i = sample_ofs;
#else
Eevee: Fix Sun soft shadows not starting at first sample
2018-10-29 16:02:13 +01:00
for (int i = 0; i <= sample_ofs; ++i) {
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
#endif
switch (la->type) {
case LA_AREA:
if (ELEM(la->area_shape, LA_AREA_RECT, LA_AREA_SQUARE)) {
sample_rectangle(i, evli->rightvec, evli->upvec, evli->sizex, evli->sizey, jitter);
}
else {
sample_ellipse(i, evli->rightvec, evli->upvec, evli->sizex, evli->sizey, jitter);
}
break;
default:
sample_ball(i, evli->radius, jitter);
}
#ifdef DEBUG_SHADOW_DISTRIBUTION
float p[3];
add_v3_v3v3(p, jitter, ws_sample_pos);
DRW_debug_sphere(p, 0.01f, (float[4]){1.0f, (sample_ofs == i) ? 1.0f : 0.0f, 0.0f, 1.0f});
}
#endif
add_v3_v3(ws_sample_pos, jitter);
}
static void eevee_shadow_cube_setup(Object *ob, EEVEE_LampsInfo *linfo, EEVEE_LampEngineData *led, int sample_ofs)
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
{
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
EEVEE_ShadowCubeData *sh_data = &led->data.scd;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
EEVEE_Light *evli = linfo->light_data + sh_data->light_id;
EEVEE_Shadow *ubo_data = linfo->shadow_data + sh_data->shadow_id;
EEVEE_ShadowCube *cube_data = linfo->shadow_cube_data + sh_data->cube_id;
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
Lamp *la = (Lamp *)ob->data;
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
copy_v3_v3(cube_data->position, ob->obmat[3]);
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
if (linfo->soft_shadows) {
shadow_cube_random_position_set(evli, la, sample_ofs, cube_data->position);
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
ubo_data->bias = 0.05f * la->bias;
ubo_data->near = la->clipsta;
Eevee: Add Light Threshold value This is an important change. Starting from now, all lights have a finite influence radius (similar to the old sphere option for BI). In order to avoid costly setup time, this distance is first computed automatically based on a light threshold. The distance is computed at the light origin and using the inverse square falloff. The setting can be found inside the render settings panel > shadow tab. This light threshold does not take the light shape into account an may not suit every case. That's why we provide a per lamp override where you can just set the cutt off distance (Light Properties Panel > Light > Custom Distance). The influence distance is also used as shadow far clip distance. This influence distance does not concerns sun lights that still have a far clip distance. --- This change is important because it makes it possible to cull lights an improve performance drastically in the future.
2018-11-15 14:44:45 +01:00
ubo_data->far = 1.0f / (evli->invsqrdist * evli->invsqrdist);
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
ubo_data->exp = (linfo->shadow_method == SHADOW_VSM) ? la->bleedbias : la->bleedexp;
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
evli->shadowid = (float)(sh_data->shadow_id);
ubo_data->shadow_start = (float)(sh_data->layer_id);
ubo_data->data_start = (float)(sh_data->cube_id);
Eevee : SSS : Add Translucency support. This adds the possibility to simulate things like red ears with strong backlight or material with high scattering distances. To enable it you need to turn on the "Subsurface Translucency" option in the "Options" tab of the Material Panel (and of course to have "regular" SSS enabled in both render settings and material options). Since the effect is adding another overhead I prefer to make it optional. But this is open to discussion. Be aware that the effect only works for direct lights (so no indirect/world lighting) that have shadowmaps, and is affected by the "softness" of the shadowmap and resolution. Technical notes: This is inspired by http://www.iryoku.com/translucency/ but goes a bit beyond that. We do not use a sum of gaussian to apply in regards to the object thickness but we precompute a 1D kernel texture. This texture stores the light transmited to a point at the back of an infinite slab of material of variying thickness. We make the assumption that the slab is perpendicular to the light so that no fresnel or diffusion term is taken into account. The light is considered constant. If the setup is similar to the one assume during the profile baking, the realtime render matches cycles reference. Due to these assumptions the computed transmitted light is in most cases too bright for curvy objects. Finally we jitter the shadow map sample per pixel so we can simulate dispersion inside the medium. Radius of the dispersion is in world space and derived by from the "soft" shadowmap parameter. Idea for this come from this presentation http://www.iryoku.com/stare-into-the-future (slide 164).
2017-11-22 04:51:21 +01:00
ubo_data->shadow_blur = la->soft * 0.02f; /* Used by translucence shadowmap blur */
Eevee: Shadows: Add Contact Shadows This add the possibility to add screen space raytraced shadows to fix light leaking cause by shadows maps. Theses inherit of the same artifacts as other screenspace methods.
2017-10-06 23:43:36 +02:00
ubo_data->contact_dist = (la->mode & LA_SHAD_CONTACT) ? la->contact_dist : 0.0f;
ubo_data->contact_bias = 0.05f * la->contact_bias;
ubo_data->contact_spread = la->contact_spread;
ubo_data->contact_thickness = la->contact_thickness;
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
static void shadow_cascade_random_matrix_set(float mat[4][4], float radius, int sample_ofs)
{
float jitter[3];
#ifndef DEBUG_SHADOW_DISTRIBUTION
int i = sample_ofs;
#else
Eevee: Fix Sun soft shadows not starting at first sample
2018-10-29 16:02:13 +01:00
for (int i = 0; i <= sample_ofs; ++i) {
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
#endif
sample_ellipse(i, mat[0], mat[1], radius, radius, jitter);
#ifdef DEBUG_SHADOW_DISTRIBUTION
float p[3];
add_v3_v3v3(p, jitter, mat[2]);
DRW_debug_sphere(p, 0.01f, (float[4]){1.0f, (sample_ofs == i) ? 1.0f : 0.0f, 0.0f, 1.0f});
}
#endif
add_v3_v3(mat[2], jitter);
orthogonalize_m4(mat, 2);
}
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
#define LERP(t, a, b) ((a) + (t) * ((b) - (a)))
Eevee: Cleanup cascaded shadowmap code.
2018-02-24 04:25:25 +01:00
static double round_to_digits(double value, int digits)
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
{
Eevee: Cleanup cascaded shadowmap code.
2018-02-24 04:25:25 +01:00
double factor = pow(10.0, digits - ceil(log10(fabs(value))));
return round(value * factor) / factor;
}
static void frustum_min_bounding_sphere(const float corners[8][3], float r_center[3], float *r_radius)
{
#if 0 /* Simple solution but waste too much space. */
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
float minvec[3], maxvec[3];
/* compute the bounding box */
INIT_MINMAX(minvec, maxvec);
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
for (int i = 0; i < 8; ++i) {
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
minmax_v3v3_v3(minvec, maxvec, corners[i]);
}
/* compute the bounding sphere of this box */
r_radius = len_v3v3(minvec, maxvec) * 0.5f;
add_v3_v3v3(r_center, minvec, maxvec);
mul_v3_fl(r_center, 0.5f);
#else
Eevee: Cleanup cascaded shadowmap code.
2018-02-24 04:25:25 +01:00
/* Find averaged center. */
zero_v3(r_center);
for (int i = 0; i < 8; ++i) {
add_v3_v3(r_center, corners[i]);
}
mul_v3_fl(r_center, 1.0f / 8.0f);
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
Eevee: Cleanup cascaded shadowmap code.
2018-02-24 04:25:25 +01:00
/* Search the largest distance from the sphere center. */
*r_radius = 0.0f;
for (int i = 0; i < 8; ++i) {
float rad = len_squared_v3v3(corners[i], r_center);
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
if (rad > *r_radius) {
*r_radius = rad;
}
}
Eevee: Cleanup cascaded shadowmap code.
2018-02-24 04:25:25 +01:00
/* TODO try to reduce the radius further by moving the center.
* Remember we need a __stable__ solution! */
/* Try to reduce float imprecision leading to shimmering. */
*r_radius = (float)round_to_digits(sqrtf(*r_radius), 3);
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
#endif
}
Eevee: Fix Cascaded shadow map calculation. The first one was done correctly but the second was wrong due to the matrix being overwritten.
2018-05-04 17:33:16 +02:00
static void eevee_shadow_cascade_setup(
Object *ob, EEVEE_LampsInfo *linfo, EEVEE_LampEngineData *led,
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
DRWMatrixState *saved_mats, float view_near, float view_far, int sample_ofs)
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
{
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
Lamp *la = (Lamp *)ob->data;
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
/* Camera Matrices */
Eevee: Fix Cascaded shadow map calculation. The first one was done correctly but the second was wrong due to the matrix being overwritten.
2018-05-04 17:33:16 +02:00
float (*persinv)[4] = saved_mats->mat[DRW_MAT_PERSINV];
float (*vp_projmat)[4] = saved_mats->mat[DRW_MAT_WIN];
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
bool is_persp = DRW_viewport_is_persp_get();
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
/* Lamps Matrices */
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
int cascade_nbr = la->cascade_count;
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
EEVEE_ShadowCascadeData *sh_data = &led->data.scad;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
EEVEE_Light *evli = linfo->light_data + sh_data->light_id;
EEVEE_Shadow *ubo_data = linfo->shadow_data + sh_data->shadow_id;
EEVEE_ShadowCascade *cascade_data = linfo->shadow_cascade_data + sh_data->cascade_id;
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
Eevee: Make use of culling when rendering the shadowmaps.
2018-03-02 18:35:25 +01:00
/* obmat = Object Space > World Space */
/* viewmat = World Space > View Space */
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
float (*viewmat)[4] = sh_data->viewmat;
Eevee: Shadows: Perf: Do not update shadows that are not inside the view.
2018-05-03 15:44:19 +02:00
#if 0 /* done at culling time */
normalize_m4_m4(viewmat, ob->obmat);
#endif
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
if (linfo->soft_shadows) {
shadow_cascade_random_matrix_set(viewmat, evli->radius, sample_ofs);
}
copy_m4_m4(sh_data->viewinv, viewmat);
Eevee: Shadows: Perf: Do not update shadows that are not inside the view.
2018-05-03 15:44:19 +02:00
invert_m4(viewmat);
Eevee: Make use of culling when rendering the shadowmaps.
2018-03-02 18:35:25 +01:00
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
/* The technique consists into splitting
* the view frustum into several sub-frustum
* that are individually receiving one shadow map */
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
float csm_start, csm_end;
if (is_persp) {
csm_start = view_near;
csm_end = max_ff(view_far, -la->cascade_max_dist);
/* Avoid artifacts */
csm_end = min_ff(view_near, csm_end);
}
else {
csm_start = -view_far;
csm_end = view_far;
}
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
/* init near/far */
for (int c = 0; c < MAX_CASCADE_NUM; ++c) {
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
cascade_data->split_start[c] = csm_end;
cascade_data->split_end[c] = csm_end;
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
}
/* Compute split planes */
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
float splits_start_ndc[MAX_CASCADE_NUM];
float splits_end_ndc[MAX_CASCADE_NUM];
{
/* Nearest plane */
float p[4] = {1.0f, 1.0f, csm_start, 1.0f};
/* TODO: we don't need full m4 multiply here */
Eevee: Fix Cascaded shadow map calculation. The first one was done correctly but the second was wrong due to the matrix being overwritten.
2018-05-04 17:33:16 +02:00
mul_m4_v4(vp_projmat, p);
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
splits_start_ndc[0] = p[2];
if (is_persp) {
splits_start_ndc[0] /= p[3];
}
}
{
/* Farthest plane */
float p[4] = {1.0f, 1.0f, csm_end, 1.0f};
/* TODO: we don't need full m4 multiply here */
Eevee: Fix Cascaded shadow map calculation. The first one was done correctly but the second was wrong due to the matrix being overwritten.
2018-05-04 17:33:16 +02:00
mul_m4_v4(vp_projmat, p);
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
splits_end_ndc[cascade_nbr - 1] = p[2];
if (is_persp) {
splits_end_ndc[cascade_nbr - 1] /= p[3];
}
}
cascade_data->split_start[0] = csm_start;
cascade_data->split_end[cascade_nbr - 1] = csm_end;
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
for (int c = 1; c < cascade_nbr; ++c) {
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
/* View Space */
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
float linear_split = LERP(((float)(c) / (float)cascade_nbr), csm_start, csm_end);
float exp_split = csm_start * powf(csm_end / csm_start, (float)(c) / (float)cascade_nbr);
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
if (is_persp) {
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
cascade_data->split_start[c] = LERP(la->cascade_exponent, linear_split, exp_split);
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
}
else {
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
cascade_data->split_start[c] = linear_split;
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
}
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
cascade_data->split_end[c - 1] = cascade_data->split_start[c];
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
/* Add some overlap for smooth transition */
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
cascade_data->split_start[c] = LERP(la->cascade_fade, cascade_data->split_end[c - 1],
(c > 1) ? cascade_data->split_end[c - 2] : cascade_data->split_start[0]);
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
/* NDC Space */
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
{
float p[4] = {1.0f, 1.0f, cascade_data->split_start[c], 1.0f};
/* TODO: we don't need full m4 multiply here */
Eevee: Fix Cascaded shadow map calculation. The first one was done correctly but the second was wrong due to the matrix being overwritten.
2018-05-04 17:33:16 +02:00
mul_m4_v4(vp_projmat, p);
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
splits_start_ndc[c] = p[2];
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
if (is_persp) {
splits_start_ndc[c] /= p[3];
}
}
{
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
float p[4] = {1.0f, 1.0f, cascade_data->split_end[c - 1], 1.0f};
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
/* TODO: we don't need full m4 multiply here */
Eevee: Fix Cascaded shadow map calculation. The first one was done correctly but the second was wrong due to the matrix being overwritten.
2018-05-04 17:33:16 +02:00
mul_m4_v4(vp_projmat, p);
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
splits_end_ndc[c - 1] = p[2];
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
if (is_persp) {
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
splits_end_ndc[c - 1] /= p[3];
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
}
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
}
}
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
/* Set last cascade split fade distance into the first split_start. */
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
float prev_split = (cascade_nbr > 1) ? cascade_data->split_end[cascade_nbr - 2] : cascade_data->split_start[0];
cascade_data->split_start[0] = LERP(la->cascade_fade, cascade_data->split_end[cascade_nbr - 1], prev_split);
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
/* For each cascade */
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
for (int c = 0; c < cascade_nbr; ++c) {
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
float (*projmat)[4] = sh_data->projmat[c];
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
/* Given 8 frustum corners */
Eevee: Cleanup cascaded shadowmap code.
2018-02-24 04:25:25 +01:00
float corners[8][3] = {
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
/* Near Cap */
Eevee: Cleanup cascaded shadowmap code.
2018-02-24 04:25:25 +01:00
{ 1.0f, -1.0f, splits_start_ndc[c]},
Eevee: Add debug visual for Cascaded Shadow Maps
2018-07-16 20:08:02 +02:00
{-1.0f, -1.0f, splits_start_ndc[c]},
Eevee: Cleanup cascaded shadowmap code.
2018-02-24 04:25:25 +01:00
{-1.0f, 1.0f, splits_start_ndc[c]},
{ 1.0f, 1.0f, splits_start_ndc[c]},
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
/* Far Cap */
Eevee: Cleanup cascaded shadowmap code.
2018-02-24 04:25:25 +01:00
{ 1.0f, -1.0f, splits_end_ndc[c]},
Eevee: Add debug visual for Cascaded Shadow Maps
2018-07-16 20:08:02 +02:00
{-1.0f, -1.0f, splits_end_ndc[c]},
Eevee: Cleanup cascaded shadowmap code.
2018-02-24 04:25:25 +01:00
{-1.0f, 1.0f, splits_end_ndc[c]},
{ 1.0f, 1.0f, splits_end_ndc[c]}
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
};
/* Transform them into world space */
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
for (int i = 0; i < 8; ++i) {
Eevee: Cleanup cascaded shadowmap code.
2018-02-24 04:25:25 +01:00
mul_project_m4_v3(persinv, corners[i]);
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
}
Eevee: Cleanup cascaded shadowmap code.
2018-02-24 04:25:25 +01:00
float center[3];
frustum_min_bounding_sphere(corners, center, &(sh_data->radius[c]));
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
Eevee: Add debug visual for Cascaded Shadow Maps
2018-07-16 20:08:02 +02:00
#ifdef DEBUG_CSM
float dbg_col[4] = {0.0f, 0.0f, 0.0f, 1.0f};
if (c < 3) {
dbg_col[c] = 1.0f;
}
DRW_debug_bbox((BoundBox *)&corners, dbg_col);
DRW_debug_sphere(center, sh_data->radius[c], dbg_col);
#endif
Eevee: Cleanup cascaded shadowmap code.
2018-02-24 04:25:25 +01:00
/* Project into lightspace */
Eevee: Fix Cascaded Shadow Maps glitches There was an issue that caused the cascaded shadow map to appear glitchy when the lamp was not at the origin.
2018-07-16 19:54:37 +02:00
mul_m4_v3(viewmat, center);
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
/* Snap projection center to nearest texel to cancel shimmering. */
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
float shadow_origin[2], shadow_texco[2];
Cleanup: line length, right shift
2017-11-20 14:28:24 +11:00
/* Light to texture space. */
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
mul_v2_v2fl(shadow_origin, center, linfo->shadow_cascade_size / (2.0f * sh_data->radius[c]));
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
/* Find the nearest texel. */
Eevee: Cleanup cascaded shadowmap code.
2018-02-24 04:25:25 +01:00
shadow_texco[0] = roundf(shadow_origin[0]);
shadow_texco[1] = roundf(shadow_origin[1]);
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
/* Compute offset. */
sub_v2_v2(shadow_texco, shadow_origin);
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
mul_v2_fl(shadow_texco, (2.0f * sh_data->radius[c]) / linfo->shadow_cascade_size); /* Texture to light space. */
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
/* Apply offset. */
add_v2_v2(center, shadow_texco);
/* Expand the projection to cover frustum range */
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
rctf rect_cascade;
Eevee: Make use of culling when rendering the shadowmaps.
2018-03-02 18:35:25 +01:00
BLI_rctf_init_pt_radius(&rect_cascade, center, sh_data->radius[c]);
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
orthographic_m4(projmat,
Eevee: Make use of culling when rendering the shadowmaps.
2018-03-02 18:35:25 +01:00
rect_cascade.xmin, rect_cascade.xmax,
rect_cascade.ymin, rect_cascade.ymax,
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
la->clipsta, la->clipend);
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
mul_m4_m4m4(sh_data->viewprojmat[c], projmat, viewmat);
mul_m4_m4m4(cascade_data->shadowmat[c], texcomat, sh_data->viewprojmat[c]);
Eevee: Add debug visual for Cascaded Shadow Maps
2018-07-16 20:08:02 +02:00
#ifdef DEBUG_CSM
DRW_debug_m4_as_bbox(sh_data->viewprojmat[c], dbg_col, true);
#endif
Eevee: Cascaded Shadow Maps, follow up. - Compute coarse bounding box of split frustum. Can be improved - Make use of 4 cascade. - View dependant glitches are fixed. - Optimized shader code.
2017-04-21 16:43:14 +02:00
}
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
ubo_data->bias = 0.05f * la->bias;
ubo_data->near = la->clipsta;
ubo_data->far = la->clipend;
ubo_data->exp = (linfo->shadow_method == SHADOW_VSM) ? la->bleedbias : la->bleedexp;
evli->shadowid = (float)(sh_data->shadow_id);
ubo_data->shadow_start = (float)(sh_data->layer_id);
ubo_data->data_start = (float)(sh_data->cascade_id);
Eevee : SSS : Add Translucency support. This adds the possibility to simulate things like red ears with strong backlight or material with high scattering distances. To enable it you need to turn on the "Subsurface Translucency" option in the "Options" tab of the Material Panel (and of course to have "regular" SSS enabled in both render settings and material options). Since the effect is adding another overhead I prefer to make it optional. But this is open to discussion. Be aware that the effect only works for direct lights (so no indirect/world lighting) that have shadowmaps, and is affected by the "softness" of the shadowmap and resolution. Technical notes: This is inspired by http://www.iryoku.com/translucency/ but goes a bit beyond that. We do not use a sum of gaussian to apply in regards to the object thickness but we precompute a 1D kernel texture. This texture stores the light transmited to a point at the back of an infinite slab of material of variying thickness. We make the assumption that the slab is perpendicular to the light so that no fresnel or diffusion term is taken into account. The light is considered constant. If the setup is similar to the one assume during the profile baking, the realtime render matches cycles reference. Due to these assumptions the computed transmitted light is in most cases too bright for curvy objects. Finally we jitter the shadow map sample per pixel so we can simulate dispersion inside the medium. Radius of the dispersion is in world space and derived by from the "soft" shadowmap parameter. Idea for this come from this presentation http://www.iryoku.com/stare-into-the-future (slide 164).
2017-11-22 04:51:21 +01:00
ubo_data->shadow_blur = la->soft * 0.02f; /* Used by translucence shadowmap blur */
Eevee: Shadows: Add Contact Shadows This add the possibility to add screen space raytraced shadows to fix light leaking cause by shadows maps. Theses inherit of the same artifacts as other screenspace methods.
2017-10-06 23:43:36 +02:00
ubo_data->contact_dist = (la->mode & LA_SHAD_CONTACT) ? la->contact_dist : 0.0f;
ubo_data->contact_bias = 0.05f * la->contact_bias;
ubo_data->contact_spread = la->contact_spread;
ubo_data->contact_thickness = la->contact_thickness;
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
}
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
/* Used for checking if object is inside the shadow volume. */
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
static bool sphere_bbox_intersect(const EEVEE_BoundSphere *bs, const EEVEE_BoundBox *bb)
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
{
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* We are testing using a rougher AABB vs AABB test instead of full AABB vs Sphere. */
/* TODO test speed with AABB vs Sphere. */
bool x = fabsf(bb->center[0] - bs->center[0]) <= (bb->halfdim[0] + bs->radius);
bool y = fabsf(bb->center[1] - bs->center[1]) <= (bb->halfdim[1] + bs->radius);
bool z = fabsf(bb->center[2] - bs->center[2]) <= (bb->halfdim[2] + bs->radius);
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
return x && y && z;
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
}
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
void EEVEE_lights_update(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
{
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
EEVEE_LampsInfo *linfo = sldata->lamps;
Object *ob;
int i;
char *flag;
EEVEE_ShadowCaster *shcaster;
EEVEE_BoundSphere *bsphere;
EEVEE_ShadowCasterBuffer *frontbuffer = linfo->shcaster_frontbuffer;
EEVEE_ShadowCasterBuffer *backbuffer = linfo->shcaster_backbuffer;
EEVEE_LightBits update_bits = {{0}};
if ((linfo->update_flag & LIGHT_UPDATE_SHADOW_CUBE) != 0) {
/* Update all lights. */
lightbits_set_all(&update_bits, true);
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
}
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
else {
/* Search for deleted shadow casters and if shcaster WAS in shadow radius. */
/* No need to run this if we already update all lamps. */
EEVEE_LightBits past_bits = {{0}};
EEVEE_LightBits curr_bits = {{0}};
shcaster = backbuffer->shadow_casters;
flag = backbuffer->flags;
for (i = 0; i < backbuffer->count; ++i, ++flag, ++shcaster) {
/* If the shadowcaster has been deleted or updated. */
if (*flag != 0) {
/* Add the lamps that were intersecting with its BBox. */
lightbits_or(&past_bits, &shcaster->bits);
}
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
}
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* Convert old bits to new bits and add result to final update bits. */
/* NOTE: This might be overkill since all lights are tagged to refresh if
* the light count changes. */
lightbits_convert(&curr_bits, &past_bits, linfo->new_shadow_id, MAX_LIGHT);
lightbits_or(&update_bits, &curr_bits);
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
}
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* Search for updates in current shadow casters. */
shcaster = frontbuffer->shadow_casters;
flag = frontbuffer->flags;
for (i = 0; i < frontbuffer->count; i++, flag++, shcaster++) {
/* Run intersection checks to fill the bitfields. */
bsphere = linfo->shadow_bounds;
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
for (int j = 0; j < linfo->cpu_cube_len; j++, bsphere++) {
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
bool iter = sphere_bbox_intersect(bsphere, &shcaster->bbox);
lightbits_set_single(&shcaster->bits, j, iter);
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
}
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* Only add to final bits if objects has been updated. */
if (*flag != 0) {
lightbits_or(&update_bits, &shcaster->bits);
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
}
}
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* Setup shadow cube in UBO and tag for update if necessary. */
for (i = 0; (i < MAX_SHADOW_CUBE) && (ob = linfo->shadow_cube_ref[i]); i++) {
EEVEE_LampEngineData *led = EEVEE_lamp_data_ensure(ob);
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
eevee_shadow_cube_setup(ob, linfo, led, effects->taa_current_sample - 1);
if (lightbits_get(&update_bits, i) != 0 || linfo->soft_shadows) {
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
led->need_update = true;
}
}
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
/* Resize shcasters buffers if too big. */
if (frontbuffer->alloc_count - frontbuffer->count > SHADOW_CASTER_ALLOC_CHUNK) {
frontbuffer->alloc_count = (frontbuffer->count / SHADOW_CASTER_ALLOC_CHUNK) * SHADOW_CASTER_ALLOC_CHUNK;
frontbuffer->alloc_count += (frontbuffer->count % SHADOW_CASTER_ALLOC_CHUNK != 0) ? SHADOW_CASTER_ALLOC_CHUNK : 0;
frontbuffer->shadow_casters = MEM_reallocN(frontbuffer->shadow_casters, sizeof(EEVEE_ShadowCaster) * frontbuffer->alloc_count);
frontbuffer->flags = MEM_reallocN(frontbuffer->flags, sizeof(EEVEE_ShadowCaster) * frontbuffer->alloc_count);
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
}
/* this refresh lamps shadow buffers */
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
void EEVEE_draw_shadows(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
{
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
EEVEE_PassList *psl = vedata->psl;
EEVEE_StorageList *stl = vedata->stl;
EEVEE_EffectsInfo *effects = stl->effects;
Eevee: Put shadows and probes inside SceneLayerEngineData This remove the duplication of data for each viewport improving memory usage.
2017-05-30 22:29:20 +02:00
EEVEE_LampsInfo *linfo = sldata->lamps;
Eevee: Add Light Threshold value This is an important change. Starting from now, all lights have a finite influence radius (similar to the old sphere option for BI). In order to avoid costly setup time, this distance is first computed automatically based on a light threshold. The distance is computed at the light origin and using the inverse square falloff. The setting can be found inside the render settings panel > shadow tab. This light threshold does not take the light shape into account an may not suit every case. That's why we provide a per lamp override where you can just set the cutt off distance (Light Properties Panel > Light > Custom Distance). The influence distance is also used as shadow far clip distance. This influence distance does not concerns sun lights that still have a far clip distance. --- This change is important because it makes it possible to cull lights an improve performance drastically in the future.
2018-11-15 14:44:45 +01:00
const DRWContextState *draw_ctx = DRW_context_state_get();
const float light_threshold = draw_ctx->scene->eevee.light_threshold;
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
Object *ob;
int i;
Eevee: Make use of culling when rendering the shadowmaps.
2018-03-02 18:35:25 +01:00
DRWMatrixState saved_mats;
Eevee: Add partial support for the Light Path Node This makes it possible to tweak indirect lighting in the shader. Only a subset of the outputs is supported and the ray depth has not exactly the same meaning: Is Camera : Supported. Is Shadow : Supported. Is Diffuse : Supported. Is Glossy : Supported. Is Singular : Not supported. Same as Is Glossy. Is Reflection : Not supported. Same as Is Glossy. Is Transmission : Not supported. Same as Is Glossy. Ray Length : Not supported. Defaults to 1.0. Ray Depth : Indicate the current bounce when baking the light cache. Diffuse Depth : Same as Ray Depth but only when baking diffuse light. Glossy Depth : Same as Ray Depth but only when baking specular light. Transparent Depth : Not supported. Defaults to 0. Transmission Depth : Not supported. Same as Glossy Depth. Caveat: Is Glossy does not work with Screen Space Reflections but does work with reflection planes (when used with SSR or not). We have to render the world twice for that to work.
2018-11-08 19:17:41 +01:00
int saved_ray_type = sldata->common_data.ray_type;
/* TODO: make it optionnal if we don't draw shadows. */
sldata->common_data.ray_type = EEVEE_RAY_SHADOW;
DRW_uniformbuffer_update(sldata->common_ubo, &sldata->common_data);
Eevee: Make use of culling when rendering the shadowmaps.
2018-03-02 18:35:25 +01:00
Eevee: Shadows: Perf: Do not update shadows that are not inside the view.
2018-05-03 15:44:19 +02:00
/* Precompute all shadow/view test before rendering and trashing the culling cache. */
bool cube_visible[MAX_SHADOW_CUBE];
for (i = 0; (ob = linfo->shadow_cube_ref[i]) && (i < MAX_SHADOW_CUBE); i++) {
Lamp *la = (Lamp *)ob->data;
BoundSphere bsphere = {
.center = {ob->obmat[3][0], ob->obmat[3][1], ob->obmat[3][2]},
Cleanup: add trailing commas to structs Needed for clang formatting to workaround bug/limit, see: T53211
2019-01-07 00:06:58 +11:00
.radius = light_attenuation_radius_get(la, light_threshold),
Eevee: Shadows: Perf: Do not update shadows that are not inside the view.
2018-05-03 15:44:19 +02:00
};
cube_visible[i] = DRW_culling_sphere_test(&bsphere);
}
bool cascade_visible[MAX_SHADOW_CASCADE];
for (i = 0; (ob = linfo->shadow_cascade_ref[i]) && (i < MAX_SHADOW_CASCADE); i++) {
EEVEE_LampEngineData *led = EEVEE_lamp_data_get(ob);
EEVEE_ShadowCascadeData *sh_data = &led->data.scad;
float plane[4];
normalize_m4_m4(sh_data->viewmat, ob->obmat);
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
Eevee: Shadows: Perf: Do not update shadows that are not inside the view.
2018-05-03 15:44:19 +02:00
plane_from_point_normal_v3(plane, sh_data->viewmat[3], sh_data->viewmat[2]);
/* TODO: check against near/far instead of "local Z = 0" plane.
* Or even the cascades AABB. */
cascade_visible[i] = DRW_culling_plane_test(plane);
}
Eevee: Make use of culling when rendering the shadowmaps.
2018-03-02 18:35:25 +01:00
/* We need to save the Matrices before overidding them */
DRW_viewport_matrix_get_all(&saved_mats);
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
/* Cube Shadow Maps */
Eevee: Shadows: Update cascaded shadowmaps when rendering probes. This is really resource intensive but there is no other way to correctly handle it.
2017-09-10 03:07:55 +02:00
DRW_stats_group_start("Cube Shadow Maps");
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
/* Render each shadow to one layer of the array */
for (i = 0; (ob = linfo->shadow_cube_ref[i]) && (i < MAX_SHADOW_CUBE); i++) {
Eevee: Cleanup, naming For functions which will allocate requested data if it does not exist yet "_ensure" is to be used instead of "_get". "_get" functions should return NULL in cases when requested data does not exist yet.
2017-11-29 10:36:58 +01:00
EEVEE_LampEngineData *led = EEVEE_lamp_data_ensure(ob);
Eevee: Polishing of Exponential Shadow mapping Added exponent parameter to tweak light bleeding. Added depth bias to the shadow test. Added better blurring using 32 samples.
2017-06-02 20:50:04 +02:00
Lamp *la = (Lamp *)ob->data;
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
Eevee: Shadows: Perf: Do not update shadows that are not inside the view.
2018-05-03 15:44:19 +02:00
if (!led->need_update || !cube_visible[i]) {
Eevee: Cleanup, avoid too much nested indentation Just do early `continue`, makes code easier to follow than fewzillion of nested checks and loops and everything.
2017-11-29 11:59:15 +01:00
continue;
}
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
DRWMatrixState render_mats;
float (*winmat)[4] = render_mats.mat[DRW_MAT_WIN];
float (*viewmat)[4] = render_mats.mat[DRW_MAT_VIEW];
float (*persmat)[4] = render_mats.mat[DRW_MAT_PERS];
Eevee: Cleanup, avoid too much nested indentation Just do early `continue`, makes code easier to follow than fewzillion of nested checks and loops and everything.
2017-11-29 11:59:15 +01:00
EEVEE_ShadowRender *srd = &linfo->shadow_render_data;
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
EEVEE_ShadowCubeData *evscd = &led->data.scd;
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
EEVEE_ShadowCube *cube_data = linfo->shadow_cube_data + evscd->cube_id;
Eevee: Transparency: Add support for Clip and Stochastic shadows.
2017-07-11 01:10:57 +02:00
Eevee: Cleanup, avoid too much nested indentation Just do early `continue`, makes code easier to follow than fewzillion of nested checks and loops and everything.
2017-11-29 11:59:15 +01:00
srd->clip_near = la->clipsta;
Eevee: Add Light Threshold value This is an important change. Starting from now, all lights have a finite influence radius (similar to the old sphere option for BI). In order to avoid costly setup time, this distance is first computed automatically based on a light threshold. The distance is computed at the light origin and using the inverse square falloff. The setting can be found inside the render settings panel > shadow tab. This light threshold does not take the light shape into account an may not suit every case. That's why we provide a per lamp override where you can just set the cutt off distance (Light Properties Panel > Light > Custom Distance). The influence distance is also used as shadow far clip distance. This influence distance does not concerns sun lights that still have a far clip distance. --- This change is important because it makes it possible to cull lights an improve performance drastically in the future.
2018-11-15 14:44:45 +01:00
srd->clip_far = light_attenuation_radius_get(la, light_threshold);
Eevee: Shadows: Compute Octahedron size from CubeMap size. This was the otherway around before. But since we can have a different size* for cube texture now, we can compute the correct-ish texture size. This will give us on average the same texture appearance when we will add support for real cubemap shadows.
2018-05-04 15:59:01 +02:00
srd->stored_texel_size = 1.0 / (float)linfo->shadow_cube_store_size;
Eevee: Fix ESM not working after a certain distance This was caused by overflow caused by the background and precision during filtering.
2018-11-11 17:45:29 +01:00
srd->exponent = la->bleedexp;
Eevee: Add Light Threshold value This is an important change. Starting from now, all lights have a finite influence radius (similar to the old sphere option for BI). In order to avoid costly setup time, this distance is first computed automatically based on a light threshold. The distance is computed at the light origin and using the inverse square falloff. The setting can be found inside the render settings panel > shadow tab. This light threshold does not take the light shape into account an may not suit every case. That's why we provide a per lamp override where you can just set the cutt off distance (Light Properties Panel > Light > Custom Distance). The influence distance is also used as shadow far clip distance. This influence distance does not concerns sun lights that still have a far clip distance. --- This change is important because it makes it possible to cull lights an improve performance drastically in the future.
2018-11-15 14:44:45 +01:00
copy_v3_v3(srd->position, cube_data->position);
perspective_m4(winmat, -srd->clip_near, srd->clip_near, -srd->clip_near, srd->clip_near, srd->clip_near, srd->clip_far);
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
Eevee: Cleanup, avoid too much nested indentation Just do early `continue`, makes code easier to follow than fewzillion of nested checks and loops and everything.
2017-11-29 11:59:15 +01:00
DRW_uniformbuffer_update(sldata->shadow_render_ubo, srd);
Eevee: Shadows: Add cubemap filtering and adaptive sample count. Filter size is constant in world space and not dependant of shadow resolution. The filter size is limited to the number of precomputed samples.
2017-09-09 21:11:22 +02:00
Eevee: Cleanup, avoid too much nested indentation Just do early `continue`, makes code easier to follow than fewzillion of nested checks and loops and everything.
2017-11-29 11:59:15 +01:00
/* Render shadow cube */
Cleanup: typos
2018-07-03 09:08:00 +02:00
/* Render 6 faces separately: seems to be faster for the general case.
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
* The only time it's more beneficial is when the CPU culling overhead
Merge branch 'master' into blender2.8
2018-09-19 18:19:49 +02:00
* outweigh the instancing overhead. which is rarely the case. */
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
for (int j = 0; j < 6; j++) {
/* TODO optimize */
float tmp[4][4];
unit_m4(tmp);
negate_v3_v3(tmp[3], srd->position);
mul_m4_m4m4(viewmat, cubefacemat[j], tmp);
mul_m4_m4m4(persmat, winmat, viewmat);
invert_m4_m4(render_mats.mat[DRW_MAT_WININV], winmat);
invert_m4_m4(render_mats.mat[DRW_MAT_VIEWINV], viewmat);
invert_m4_m4(render_mats.mat[DRW_MAT_PERSINV], persmat);
DRW_viewport_matrix_override_set_all(&render_mats);
GPU_framebuffer_texture_cubeface_attach(sldata->shadow_cube_target_fb,
sldata->shadow_cube_target, 0, j, 0);
GPU_framebuffer_bind(sldata->shadow_cube_target_fb);
GPU_framebuffer_clear_depth(sldata->shadow_cube_target_fb, 1.0f);
DRW_draw_pass(psl->shadow_pass);
}
Eevee: Shadows: Add cubemap filtering and adaptive sample count. Filter size is constant in world space and not dependant of shadow resolution. The filter size is limited to the number of precomputed samples.
2017-09-09 21:11:22 +02:00
Eevee: Cleanup, avoid too much nested indentation Just do early `continue`, makes code easier to follow than fewzillion of nested checks and loops and everything.
2017-11-29 11:59:15 +01:00
/* 0.001f is arbitrary, but it should be relatively small so that filter size is not too big. */
float filter_texture_size = la->soft * 0.001f;
Eevee: Shadows: Compute Octahedron size from CubeMap size. This was the otherway around before. But since we can have a different size* for cube texture now, we can compute the correct-ish texture size. This will give us on average the same texture appearance when we will add support for real cubemap shadows.
2018-05-04 15:59:01 +02:00
float filter_pixel_size = ceil(filter_texture_size / srd->cube_texel_size);
linfo->filter_size = srd->cube_texel_size * ((filter_pixel_size > 1.0f) ? 1.5f : 0.0f);
Eevee: Cleanup, avoid too much nested indentation Just do early `continue`, makes code easier to follow than fewzillion of nested checks and loops and everything.
2017-11-29 11:59:15 +01:00
/* TODO: OPTI: Filter all faces in one/two draw call */
Eevee: Shadows: Compute Octahedron size from CubeMap size. This was the otherway around before. But since we can have a different size* for cube texture now, we can compute the correct-ish texture size. This will give us on average the same texture appearance when we will add support for real cubemap shadows.
2018-05-04 15:59:01 +02:00
/* TODO: OPTI: Don't do this intermediate step if no filter is needed. */
Eevee: Cleanup, avoid too much nested indentation Just do early `continue`, makes code easier to follow than fewzillion of nested checks and loops and everything.
2017-11-29 11:59:15 +01:00
for (linfo->current_shadow_face = 0;
linfo->current_shadow_face < 6;
linfo->current_shadow_face++)
{
/* Copy using a small 3x3 box filter */
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
GPU_framebuffer_texture_cubeface_attach(sldata->shadow_cube_store_fb, sldata->shadow_cube_blur, 0,
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
linfo->current_shadow_face, 0);
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
GPU_framebuffer_bind(sldata->shadow_cube_store_fb);
Eevee: Cleanup, avoid too much nested indentation Just do early `continue`, makes code easier to follow than fewzillion of nested checks and loops and everything.
2017-11-29 11:59:15 +01:00
DRW_draw_pass(psl->shadow_cube_copy_pass);
}
/* Push it to shadowmap array */
/* Adjust constants if concentric samples change. */
const float max_filter_size = 7.5f;
Eevee: Shadows: Compute Octahedron size from CubeMap size. This was the otherway around before. But since we can have a different size* for cube texture now, we can compute the correct-ish texture size. This will give us on average the same texture appearance when we will add support for real cubemap shadows.
2018-05-04 15:59:01 +02:00
const float magic = 4.5f; /* Dunno why but that works. */
Eevee: Cleanup, avoid too much nested indentation Just do early `continue`, makes code easier to follow than fewzillion of nested checks and loops and everything.
2017-11-29 11:59:15 +01:00
const int max_sample = 256;
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
Eevee: Cleanup, avoid too much nested indentation Just do early `continue`, makes code easier to follow than fewzillion of nested checks and loops and everything.
2017-11-29 11:59:15 +01:00
if (filter_pixel_size > 2.0f) {
Eevee: Shadows: Compute Octahedron size from CubeMap size. This was the otherway around before. But since we can have a different size* for cube texture now, we can compute the correct-ish texture size. This will give us on average the same texture appearance when we will add support for real cubemap shadows.
2018-05-04 15:59:01 +02:00
linfo->filter_size = srd->cube_texel_size * max_filter_size * magic;
Eevee: Cleanup, avoid too much nested indentation Just do early `continue`, makes code easier to follow than fewzillion of nested checks and loops and everything.
2017-11-29 11:59:15 +01:00
filter_pixel_size = max_ff(0.0f, filter_pixel_size - 3.0f);
/* Compute number of concentric samples. Depends directly on filter size. */
float pix_size_sqr = filter_pixel_size * filter_pixel_size;
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
srd->shadow_samples_len = min_ii(max_sample, 4 + 8 * (int)filter_pixel_size + 4 * (int)(pix_size_sqr));
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
}
Eevee: Cleanup, avoid too much nested indentation Just do early `continue`, makes code easier to follow than fewzillion of nested checks and loops and everything.
2017-11-29 11:59:15 +01:00
else {
linfo->filter_size = 0.0f;
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
srd->shadow_samples_len = 4;
Eevee: Cleanup, avoid too much nested indentation Just do early `continue`, makes code easier to follow than fewzillion of nested checks and loops and everything.
2017-11-29 11:59:15 +01:00
}
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
srd->shadow_samples_len_inv = 1.0f / (float)srd->shadow_samples_len;
Eevee: Cleanup, avoid too much nested indentation Just do early `continue`, makes code easier to follow than fewzillion of nested checks and loops and everything.
2017-11-29 11:59:15 +01:00
DRW_uniformbuffer_update(sldata->shadow_render_ubo, srd);
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
GPU_framebuffer_texture_layer_attach(sldata->shadow_cube_store_fb, sldata->shadow_cube_pool, 0, evscd->layer_id, 0);
GPU_framebuffer_bind(sldata->shadow_cube_store_fb);
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
DRWPass *store_pass = eevee_lights_cube_store_pass_get(psl, sldata, linfo->shadow_method, srd->shadow_samples_len);
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
DRW_draw_pass(store_pass);
Eevee: Cleanup, avoid too much nested indentation Just do early `continue`, makes code easier to follow than fewzillion of nested checks and loops and everything.
2017-11-29 11:59:15 +01:00
Eevee: Implement jittered soft shadowmap This new option is located in the shadows options in the render settings. This approach is simple and just randomize the shadow map position (not the lamp itself) and just let the temporal supersampling do the average of all the shadowing. The downside is that is needs quite a large number of samples to give smooth results and individual sample position can remain visible. Enabling this option will make the viewport refresh all shadow maps every redraw so it has a serious performance impact. This approach is not physicaly based at all and will not match cycles. ---- The sampling for point lamps (spheres) is not
2018-10-28 21:41:40 +01:00
if (linfo->soft_shadows == false) {
led->need_update = false;
}
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
Eevee: Tag shadow maps to update only when necessary. Shadow maps are now only updated if one shadow casting object inside it's shadow bounds has been updated.
2017-06-01 18:20:44 +02:00
linfo->update_flag &= ~LIGHT_UPDATE_SHADOW_CUBE;
Eevee: Shadows: Update cascaded shadowmaps when rendering probes. This is really resource intensive but there is no other way to correctly handle it.
2017-09-10 03:07:55 +02:00
DRW_stats_group_end();
Eevee: Codestyle, optimisation and a few fixes Something is very wrong with the energy factor. For now I tweaked them by hand to fit cycles.
2017-03-31 01:07:30 +02:00
Eevee: Fix Cascaded shadowmap setup. It was getting the wrong matrice because of the point light override.
2018-03-06 02:51:51 +01:00
DRW_viewport_matrix_override_set_all(&saved_mats);
Eevee: Fix Cascaded shadow map calculation. The first one was done correctly but the second was wrong due to the matrix being overwritten.
2018-05-04 17:33:16 +02:00
float near = DRW_viewport_near_distance_get();
float far = DRW_viewport_far_distance_get();
Eevee: Fix Cascaded shadowmap setup. It was getting the wrong matrice because of the point light override.
2018-03-06 02:51:51 +01:00
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
/* Cascaded Shadow Maps */
Eevee: Shadows: Update cascaded shadowmaps when rendering probes. This is really resource intensive but there is no other way to correctly handle it.
2017-09-10 03:07:55 +02:00
DRW_stats_group_start("Cascaded Shadow Maps");
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
for (i = 0; (ob = linfo->shadow_cascade_ref[i]) && (i < MAX_SHADOW_CASCADE); i++) {
Eevee: Shadows: Perf: Do not update shadows that are not inside the view.
2018-05-03 15:44:19 +02:00
if (!cascade_visible[i]) {
continue;
}
Eevee: Cleanup, naming For functions which will allocate requested data if it does not exist yet "_ensure" is to be used instead of "_get". "_get" functions should return NULL in cases when requested data does not exist yet.
2017-11-29 10:36:58 +01:00
EEVEE_LampEngineData *led = EEVEE_lamp_data_ensure(ob);
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
Lamp *la = (Lamp *)ob->data;
Eevee: Lamps: Optimize lamps CPU/Memory usage. Tests on my system with ~1200 objects with 128 shadow casting lamps (current max) show a significant perf improvment (cache timing : 22ms -> 9ms) With a baseline with no shadow casting light at 6ms this give a reduction of the overhead from 16ms to 3ms. This remove pretty much all allocations during the cache phase. Leading to a big improvement for scene with a large number of lights & shadowcasters. The lamps storage has been replace by a union to remove the need to free/allocate everyframe (also reducing memory fragmentation). We replaced the linked list system used to track shadow casters by a huge bitflag. We gather the lights shadows bounds as well as the shadow casters AABB during the cache populate phase and put them in big arrays cache friendly. Then in the cache finish phase, it's easier to iterate over the lamps shadow SphereBounds and test for intersection. We use a double buffer system for the shadow casters arrays to detect deleted shadow casters. Unfortunatly, it seems that deleting an object trigger an update for all other objects (thus tagging most shadow casting lamps to update), defeating the purpose of this tracking. This needs further investigation.
2018-01-11 14:08:21 +01:00
EEVEE_ShadowCascadeData *evscd = &led->data.scad;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
EEVEE_ShadowRender *srd = &linfo->shadow_render_data;
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
DRWMatrixState render_mats;
float (*winmat)[4] = render_mats.mat[DRW_MAT_WIN];
float (*viewmat)[4] = render_mats.mat[DRW_MAT_VIEW];
float (*persmat)[4] = render_mats.mat[DRW_MAT_PERS];
Eevee: Fix Sun soft shadows not starting at first sample
2018-10-29 16:02:13 +01:00
eevee_shadow_cascade_setup(ob, linfo, led, &saved_mats, near, far, effects->taa_current_sample - 1);
Eevee: Shadows: Update cascaded shadowmaps when rendering probes. This is really resource intensive but there is no other way to correctly handle it.
2017-09-10 03:07:55 +02:00
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
srd->clip_near = la->clipsta;
srd->clip_far = la->clipend;
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
srd->stored_texel_size = 1.0 / (float)linfo->shadow_cascade_size;
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
DRW_uniformbuffer_update(sldata->shadow_render_ubo, &linfo->shadow_render_data);
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
copy_m4_m4(viewmat, evscd->viewmat);
invert_m4_m4(render_mats.mat[DRW_MAT_VIEWINV], viewmat);
Eevee: Make use of culling when rendering the shadowmaps.
2018-03-02 18:35:25 +01:00
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
/* Render shadow cascades */
Cleanup: typos
2018-07-03 09:08:00 +02:00
/* Render cascade separately: seems to be faster for the general case.
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
* The only time it's more beneficial is when the CPU culling overhead
Merge branch 'master' into blender2.8
2018-09-19 18:19:49 +02:00
* outweigh the instancing overhead. which is rarely the case. */
Eevee: Shadows: Transition to individual face rendering. This gets rid of the need of a geom shader and instancing. Both are pretty slow compared to the new method. The only moment the old method could be better is when scene is filled with lots of objects and most of the objects in the shadow map appear on every layer. But even then, we could optimize the culling and minimize the overhead.
2018-04-15 22:22:50 +02:00
for (int j = 0; j < la->cascade_count; j++) {
copy_m4_m4(winmat, evscd->projmat[j]);
copy_m4_m4(persmat, evscd->viewprojmat[j]);
invert_m4_m4(render_mats.mat[DRW_MAT_WININV], winmat);
invert_m4_m4(render_mats.mat[DRW_MAT_PERSINV], persmat);
DRW_viewport_matrix_override_set_all(&render_mats);
GPU_framebuffer_texture_layer_attach(sldata->shadow_cascade_target_fb,
sldata->shadow_cascade_target, 0, j, 0);
GPU_framebuffer_bind(sldata->shadow_cascade_target_fb);
GPU_framebuffer_clear_depth(sldata->shadow_cascade_target_fb, 1.0f);
DRW_draw_pass(psl->shadow_pass);
}
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
Eevee: Shadows: Add cubemap filtering and adaptive sample count. Filter size is constant in world space and not dependant of shadow resolution. The filter size is limited to the number of precomputed samples.
2017-09-09 21:11:22 +02:00
/* TODO: OPTI: Filter all cascade in one/two draw call */
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
for (linfo->current_shadow_cascade = 0;
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
linfo->current_shadow_cascade < la->cascade_count;
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
++linfo->current_shadow_cascade)
{
Eevee: Shadows: Add cubemap filtering and adaptive sample count. Filter size is constant in world space and not dependant of shadow resolution. The filter size is limited to the number of precomputed samples.
2017-09-09 21:11:22 +02:00
/* 0.01f factor to convert to percentage */
float filter_texture_size = la->soft * 0.01f / evscd->radius[linfo->current_shadow_cascade];
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
float filter_pixel_size = ceil(linfo->shadow_cascade_size * filter_texture_size);
Eevee: Shadows: Add cubemap filtering and adaptive sample count. Filter size is constant in world space and not dependant of shadow resolution. The filter size is limited to the number of precomputed samples.
2017-09-09 21:11:22 +02:00
Eevee: Shadows: Filtering improvement. - Replace poisson by concentric samples: Less variance. They are sorted by radius then by angle. - Separate filtering into 2 blur. First blur is 3x3 box blur. Second is user dependant. - Group fetches by group of 4.
2017-09-08 20:21:57 +02:00
/* Copy using a small 3x3 box filter */
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
/* NOTE: We always do it in the case of CSM because of artifacts in the farthest cascade. */
linfo->filter_size = srd->stored_texel_size;
GPUFramebuffer: Refactor (Part 2) This refactor modernise the use of framebuffers. It also touches a lot of files so breaking down changes we have: - GPUTexture: Allow textures to be attached to more than one GPUFrameBuffer. This allows to create and configure more FBO without the need to attach and detach texture at drawing time. - GPUFrameBuffer: The wrapper starts to mimic opengl a bit closer. This allows to configure the framebuffer inside a context other than the one that will be rendering the framebuffer. We do the actual configuration when binding the FBO. We also Keep track of config validity and save drawbuffers state in the FBO. We remove the different bind/unbind functions. These make little sense now that we have separate contexts. - DRWFrameBuffer: We replace DRW_framebuffer functions by GPU_framebuffer ones to avoid another layer of abstraction. We move the DRW convenience functions to GPUFramebuffer instead and even add new ones. The MACRO GPU_framebuffer_ensure_config is pretty much all you need to create and config a GPUFramebuffer. - DRWTexture: Due to the removal of DRWFrameBuffer, we needed to create functions to create textures for thoses framebuffers. Pool textures are now using default texture parameters for the texture type asked. - DRWManager: Make sure no framebuffer object is bound when doing cache filling. - GPUViewport: Add new color_only_fb and depth_only_fb along with FB API usage update. This let draw engines render to color/depth only target and without the need to attach/detach textures. - WM_window: Assert when a framebuffer is bound when changing context. This balance the fact we are not track ogl context inside GPUFramebuffer. - Eevee, Clay, Mode engines: Update to new API. This comes with a lot of code simplification. This also come with some cleanups in some engine codes.
2018-03-25 17:46:48 +02:00
GPU_framebuffer_texture_layer_attach(
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
sldata->shadow_cascade_store_fb, sldata->shadow_cascade_blur, 0, linfo->current_shadow_cascade, 0);
GPU_framebuffer_bind(sldata->shadow_cascade_store_fb);
Eevee: Shadows: Filtering improvement. - Replace poisson by concentric samples: Less variance. They are sorted by radius then by angle. - Separate filtering into 2 blur. First blur is 3x3 box blur. Second is user dependant. - Group fetches by group of 4.
2017-09-08 20:21:57 +02:00
DRW_draw_pass(psl->shadow_cascade_copy_pass);
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
Eevee: Shadows: Filtering improvement. - Replace poisson by concentric samples: Less variance. They are sorted by radius then by angle. - Separate filtering into 2 blur. First blur is 3x3 box blur. Second is user dependant. - Group fetches by group of 4.
2017-09-08 20:21:57 +02:00
/* Push it to shadowmap array and blur more */
Eevee: Shadows: Add cubemap filtering and adaptive sample count. Filter size is constant in world space and not dependant of shadow resolution. The filter size is limited to the number of precomputed samples.
2017-09-09 21:11:22 +02:00
/* Adjust constants if concentric samples change. */
const float max_filter_size = 7.5f;
Eevee: Shadows: Compute Octahedron size from CubeMap size. This was the otherway around before. But since we can have a different size* for cube texture now, we can compute the correct-ish texture size. This will give us on average the same texture appearance when we will add support for real cubemap shadows.
2018-05-04 15:59:01 +02:00
const float magic = 3.2f; /* Arbitrary: less banding */
Eevee: Shadows: Add cubemap filtering and adaptive sample count. Filter size is constant in world space and not dependant of shadow resolution. The filter size is limited to the number of precomputed samples.
2017-09-09 21:11:22 +02:00
const int max_sample = 256;
if (filter_pixel_size > 2.0f) {
Eevee: Shadows: Compute Octahedron size from CubeMap size. This was the otherway around before. But since we can have a different size* for cube texture now, we can compute the correct-ish texture size. This will give us on average the same texture appearance when we will add support for real cubemap shadows.
2018-05-04 15:59:01 +02:00
linfo->filter_size = srd->stored_texel_size * max_filter_size * magic;
Eevee: Shadows: Add cubemap filtering and adaptive sample count. Filter size is constant in world space and not dependant of shadow resolution. The filter size is limited to the number of precomputed samples.
2017-09-09 21:11:22 +02:00
filter_pixel_size = max_ff(0.0f, filter_pixel_size - 3.0f);
/* Compute number of concentric samples. Depends directly on filter size. */
float pix_size_sqr = filter_pixel_size * filter_pixel_size;
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
srd->shadow_samples_len = min_ii(max_sample, 4 + 8 * (int)filter_pixel_size + 4 * (int)(pix_size_sqr));
Eevee: Shadows: Add cubemap filtering and adaptive sample count. Filter size is constant in world space and not dependant of shadow resolution. The filter size is limited to the number of precomputed samples.
2017-09-09 21:11:22 +02:00
}
else {
linfo->filter_size = 0.0f;
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
srd->shadow_samples_len = 4;
Eevee: Shadows: Add cubemap filtering and adaptive sample count. Filter size is constant in world space and not dependant of shadow resolution. The filter size is limited to the number of precomputed samples.
2017-09-09 21:11:22 +02:00
}
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
srd->shadow_samples_len_inv = 1.0f / (float)srd->shadow_samples_len;
Eevee: Shadows: Add cubemap filtering and adaptive sample count. Filter size is constant in world space and not dependant of shadow resolution. The filter size is limited to the number of precomputed samples.
2017-09-09 21:11:22 +02:00
DRW_uniformbuffer_update(sldata->shadow_render_ubo, &linfo->shadow_render_data);
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
int layer = evscd->layer_id + linfo->current_shadow_cascade;
Eevee: Shadows: Separate Cube and Cascade shadow maps into 2 texture array. This mean we can now have different shadow resolutions for both. However each shadow type keep the same size accross all lamps because of future "real" Cube Shadowmaps limitation and to save texture sampler slots. That said the cascade shadow resolution could (in the future) still be changed to be adjustable per sun lamp.
2018-05-04 14:39:05 +02:00
GPU_framebuffer_texture_layer_attach(sldata->shadow_cascade_store_fb, sldata->shadow_cascade_pool, 0, layer, 0);
GPU_framebuffer_bind(sldata->shadow_cascade_store_fb);
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
Cleanup: rename 'ct' to 'len' for size vars
2018-07-08 12:45:53 +02:00
DRWPass *store_pass = eevee_lights_cascade_store_pass_get(psl, sldata, linfo->shadow_method, srd->shadow_samples_len);
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
DRW_draw_pass(store_pass);
Eevee: Add Cascaded Shadow Map support with filtering. This brings some data structure changes. Shared shadow data are stored in ShadowData (in glsl) (aka EEVEE_Shadow in C). This structure contains the array indices of the first shadow element of this shadow "object". It also contains how many shadow to evaluate (to be used for Multiple shadow maps). The filtering is noisy and needs improvement.
2017-09-05 21:02:17 +02:00
}
}
Eevee: Shadows: Update cascaded shadowmaps when rendering probes. This is really resource intensive but there is no other way to correctly handle it.
2017-09-10 03:07:55 +02:00
DRW_stats_group_end();
Eevee: Make use of culling when rendering the shadowmaps.
2018-03-02 18:35:25 +01:00
DRW_viewport_matrix_override_set_all(&saved_mats);
Eevee: Shadows: Update cascaded shadowmaps when rendering probes. This is really resource intensive but there is no other way to correctly handle it.
2017-09-10 03:07:55 +02:00
DRW_uniformbuffer_update(sldata->light_ubo, &linfo->light_data);
DRW_uniformbuffer_update(sldata->shadow_ubo, &linfo->shadow_data); /* Update all data at once */
Eevee: Add partial support for the Light Path Node This makes it possible to tweak indirect lighting in the shader. Only a subset of the outputs is supported and the ray depth has not exactly the same meaning: Is Camera : Supported. Is Shadow : Supported. Is Diffuse : Supported. Is Glossy : Supported. Is Singular : Not supported. Same as Is Glossy. Is Reflection : Not supported. Same as Is Glossy. Is Transmission : Not supported. Same as Is Glossy. Ray Length : Not supported. Defaults to 1.0. Ray Depth : Indicate the current bounce when baking the light cache. Diffuse Depth : Same as Ray Depth but only when baking diffuse light. Glossy Depth : Same as Ray Depth but only when baking specular light. Transparent Depth : Not supported. Defaults to 0. Transmission Depth : Not supported. Same as Glossy Depth. Caveat: Is Glossy does not work with Screen Space Reflections but does work with reflection planes (when used with SSR or not). We have to render the world twice for that to work.
2018-11-08 19:17:41 +01:00
sldata->common_data.ray_type = saved_ray_type;
DRW_uniformbuffer_update(sldata->common_ubo, &sldata->common_data);
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
}
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
void EEVEE_lights_free(void)
{
DRW_SHADER_FREE_SAFE(e_data.shadow_sh);
Eevee: Add Variance Shadow Mapping This is an alternative to ESM. It does not suffer the same bleeding artifacts.
2017-09-01 18:39:39 +02:00
for (int i = 0; i < SHADOW_METHOD_MAX; ++i) {
DRW_SHADER_FREE_SAFE(e_data.shadow_store_cube_sh[i]);
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
DRW_SHADER_FREE_SAFE(e_data.shadow_store_cube_high_sh[i]);
Eevee: Add Variance Shadow Mapping This is an alternative to ESM. It does not suffer the same bleeding artifacts.
2017-09-01 18:39:39 +02:00
DRW_SHADER_FREE_SAFE(e_data.shadow_store_cascade_sh[i]);
Eevee: Improve load time. Only generate shadow store shaders on demand and create a simpler shader for small blur radius.
2018-06-03 22:47:01 +02:00
DRW_SHADER_FREE_SAFE(e_data.shadow_store_cascade_high_sh[i]);
Eevee: Shadows: Filtering improvement. - Replace poisson by concentric samples: Less variance. They are sorted by radius then by angle. - Separate filtering into 2 blur. First blur is 3x3 box blur. Second is user dependant. - Group fetches by group of 4.
2017-09-08 20:21:57 +02:00
DRW_SHADER_FREE_SAFE(e_data.shadow_copy_cube_sh[i]);
DRW_SHADER_FREE_SAFE(e_data.shadow_copy_cascade_sh[i]);
Eevee: Add Variance Shadow Mapping This is an alternative to ESM. It does not suffer the same bleeding artifacts.
2017-09-01 18:39:39 +02:00
}
Cleanup: BLI headers first Also move descriptions into doxy header
2017-11-20 14:11:45 +11:00
}
Copy Permalink