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
7a28dea1e173aefd08ef2130a9efc401d049e150
blender-archive/source/blender/draw/engines/eevee/eevee_lights.c

1243 lines
44 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: 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: 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];
struct GPUShader *shadow_store_cascade_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: Support for dupli lamps without shadows.
2018-01-09 18:01:56 +01:00
/* Prototype */
static void eevee_light_setup(Object *ob, EEVEE_Light *evli);
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: use 'uint' in draw manager
2018-05-11 07:48:52 +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: 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. */
linfo->shadow_cube_store_size = (int)ceil(sqrt((sh_cube_size * sh_cube_size) * 6.0f));
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. */
if ((sh_method == SHADOW_ESM) && !e_data.shadow_store_cube_sh[SHADOW_ESM]) {
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);
e_data.shadow_store_cube_sh[SHADOW_ESM] = DRW_shader_create_fullscreen(
store_shadow_shader_str,
"#define ESM\n");
e_data.shadow_store_cascade_sh[SHADOW_ESM] = DRW_shader_create_fullscreen(
store_shadow_shader_str,
"#define ESM\n"
"#define CSM\n");
MEM_freeN(store_shadow_shader_str);
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");
}
else if ((sh_method == SHADOW_VSM) && !e_data.shadow_store_cube_sh[SHADOW_VSM]) {
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);
e_data.shadow_store_cube_sh[SHADOW_VSM] = DRW_shader_create_fullscreen(
store_shadow_shader_str,
"#define VSM\n");
e_data.shadow_store_cascade_sh[SHADOW_VSM] = DRW_shader_create_fullscreen(
store_shadow_shader_str,
"#define VSM\n"
"#define CSM\n");
MEM_freeN(store_shadow_shader_str);
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
}
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;
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->gpu_cube_ct = linfo->gpu_cascade_ct = linfo->gpu_shadow_ct = 0;
linfo->cpu_cube_ct = linfo->cpu_cascade_ct = 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
{
psl->shadow_cube_store_pass = DRW_pass_create("Shadow Storage 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_store_cube_sh[linfo->shadow_method], psl->shadow_cube_store_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_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
DRW_shgroup_uniform_block(grp, "shadow_render_block", sldata->shadow_render_ubo);
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_shgroup_uniform_float(grp, "shadowFilterSize", &linfo->filter_size, 1);
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
DRW_shgroup_call_add(grp, DRW_cache_fullscreen_quad_get(), NULL);
}
{
psl->shadow_cascade_store_pass = DRW_pass_create("Shadow Cascade Storage 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_store_cascade_sh[linfo->shadow_method], psl->shadow_cascade_store_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_blur);
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
DRW_shgroup_uniform_block(grp, "shadow_render_block", sldata->shadow_render_ubo);
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_shgroup_uniform_int(grp, "cascadeId", &linfo->current_shadow_cascade, 1);
DRW_shgroup_uniform_float(grp, "shadowFilterSize", &linfo->filter_size, 1);
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_shgroup_call_add(grp, DRW_cache_fullscreen_quad_get(), 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
{
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: 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
DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS;
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: 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) {
Fix Eevee error message That said, this should be informed to the user, not printed in the console.
2018-01-25 10:59:41 -02:00
printf("Too many lamps 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: 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 sh_nbr = 1; /* TODO : MSM */
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
if ((linfo->gpu_cascade_ct + sh_nbr) <= MAX_SHADOW_CASCADE) {
/* Save Light object. */
linfo->shadow_cascade_ref[linfo->cpu_cascade_ct] = ob;
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;
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
data->shadow_id = linfo->gpu_shadow_ct;
data->cascade_id = linfo->gpu_cascade_ct;
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. */
linfo->gpu_shadow_ct += 1;
linfo->gpu_cascade_ct += sh_nbr;
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_cascade_layer += sh_nbr * 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
linfo->cpu_cascade_ct += 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: 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) {
int sh_nbr = 1; /* TODO : MSM */
if ((linfo->gpu_cube_ct + sh_nbr) <= MAX_SHADOW_CUBE) {
/* Save Light object. */
linfo->shadow_cube_ref[linfo->cpu_cube_ct] = ob;
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
{
linfo->new_shadow_id[prev_cube_sh_id] = linfo->cpu_cube_ct;
}
led->prev_cube_shadow_id = linfo->cpu_cube_ct;
/* Saving lamp bounds for later. */
BLI_assert(linfo->cpu_cube_ct >= 0 && linfo->cpu_cube_ct < MAX_LIGHT);
copy_v3_v3(linfo->shadow_bounds[linfo->cpu_cube_ct].center, ob->obmat[3]);
linfo->shadow_bounds[linfo->cpu_cube_ct].radius = la->clipend;
EEVEE_ShadowCubeData *data = &led->data.scd;
/* Store indices. */
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
data->shadow_id = linfo->gpu_shadow_ct;
data->cube_id = linfo->gpu_cube_ct;
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. */
linfo->gpu_shadow_ct += 1;
linfo->gpu_cube_ct += sh_nbr;
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 += sh_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
linfo->cpu_cube_ct += 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: 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(
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_ViewLayerData *UNUSED(sldata), EEVEE_StorageList *stl, struct Gwn_Batch *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: 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_ViewLayerData *UNUSED(sldata), EEVEE_PassList *psl, struct GPUMaterial *gpumat,
struct Gwn_Batch *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: 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;
}
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_finish(EEVEE_ViewLayerData *sldata)
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_lights_update(sldata);
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
/* Update buffer with lamp data */
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: 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
Lamp *la = (Lamp *)ob->data;
float mat[4][4], scale[3], power;
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
/* Position */
copy_v3_v3(evli->position, ob->obmat[3]);
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: 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
/* Color */
Eevee : fix light colors
2017-05-29 12:37:34 +02:00
copy_v3_v3(evli->color, &la->r);
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 Lamp Specular multiplier. It's usefull in some scenario to tweak the specular intensity of a light without modifying the diffuse contribution. Cycles allows it via lamps material which we currently not support in Eevee. This is a good workaround for now.
2018-05-02 18:39:17 +02:00
evli->spec = la->spec_fac;
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
/* Influence Radius */
evli->dist = la->dist;
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: 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
/* Vectors */
normalize_m4_m4_ex(mat, ob->obmat, scale);
copy_v3_v3(evli->forwardvec, mat[2]);
normalize_v3(evli->forwardvec);
negate_v3(evli->forwardvec);
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: 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
copy_v3_v3(evli->rightvec, mat[0]);
normalize_v3(evli->rightvec);
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: 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
copy_v3_v3(evli->upvec, mat[1]);
normalize_v3(evli->upvec);
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: 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
/* Spot size & blend */
if (la->type == LA_SPOT) {
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: Change MAX2 to max_ff
2017-04-27 22:27:41 +02:00
evli->sizex = max_ff(0.0001f, la->area_size * scale[0] * 0.5f);
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->area_shape == LA_AREA_RECT) {
Eevee: Change MAX2 to max_ff
2017-04-27 22:27:41 +02:00
evli->sizey = max_ff(0.0001f, 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: Change MAX2 to max_ff
2017-04-27 22:27:41 +02:00
evli->sizey = max_ff(0.0001f, 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: 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: 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 */
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: 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
power = 1.0f / (4.0f * evli->radius * evli->radius * M_PI * M_PI) * /* 1/(r²*Pi) */
12.5f; /* XXX : Empirical, Fit cycles 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
}
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
/* Lamp Type */
evli->lamptype = (float)la->type;
/* No shadow by default */
evli->shadowid = -1.0f;
}
static void eevee_shadow_cube_setup(Object *ob, EEVEE_LampsInfo *linfo, EEVEE_LampEngineData *led)
{
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: 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 sh_nbr = 1; /* TODO: MSM */
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
for (int i = 0; i < sh_nbr; ++i) {
/* TODO : choose MSM sample point here. */
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: 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;
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);
ubo_data->multi_shadow_count = (float)(sh_nbr);
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: 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,
DRWMatrixState *saved_mats, float view_near, float view_far)
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 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 sh_nbr = 1; /* TODO : MSM */
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
invert_m4(viewmat);
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
invert_m4_m4(sh_data->viewinv, 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]},
{ 1.0f, -1.0f, splits_start_ndc[c]},
{-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]},
{ 1.0f, -1.0f, splits_end_ndc[c]},
{-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: Cleanup cascaded shadowmap code.
2018-02-24 04:25:25 +01:00
/* Project into lightspace */
mul_mat3_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: 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);
ubo_data->multi_shadow_count = (float)(sh_nbr);
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: 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
void EEVEE_lights_update(EEVEE_ViewLayerData *sldata)
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
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;
for (int j = 0; j < linfo->cpu_cube_ct; j++, bsphere++) {
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: 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_shadow_cube_setup(ob, linfo, led);
if (lightbits_get(&update_bits, i) != 0) {
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 */
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_draw_shadows(EEVEE_ViewLayerData *sldata, EEVEE_PassList *psl)
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;
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: 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]},
.radius = la->dist
};
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);
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: Transparency: Add support for Clip and Stochastic shadows.
2017-07-11 01:10:57 +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
perspective_m4(winmat, -la->clipsta, la->clipsta, -la->clipsta, la->clipsta, la->clipsta, la->clipend);
Eevee: Make use of culling when rendering the shadowmaps.
2018-03-02 18:35:25 +01: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;
srd->clip_far = la->clipend;
copy_v3_v3(srd->position, ob->obmat[3]);
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: 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: 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 */
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
/* Render 6 faces separatly: seems to be faster for the general case.
* The only time it's more beneficial is when the CPU culling overhead
* outweight the instancing overhead. which is rarelly the case. */
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;
srd->shadow_samples_ct = 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;
srd->shadow_samples_ct = 4;
}
srd->shadow_inv_samples_ct = 1.0f / (float)srd->shadow_samples_ct;
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: 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_store_pass);
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 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
eevee_shadow_cascade_setup(ob, linfo, led, &saved_mats, near, far);
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 */
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
/* Render cascade separatly: seems to be faster for the general case.
* The only time it's more beneficial is when the CPU culling overhead
* outweight the instancing overhead. which is rarelly the case. */
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;
srd->shadow_samples_ct = min_ii(max_sample, 4 + 8 * (int)filter_pixel_size + 4 * (int)(pix_size_sqr));
}
else {
linfo->filter_size = 0.0f;
srd->shadow_samples_ct = 4;
}
srd->shadow_inv_samples_ct = 1.0f / (float)srd->shadow_samples_ct;
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: 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_draw_pass(psl->shadow_cascade_store_pass);
}
}
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: 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]);
DRW_SHADER_FREE_SAFE(e_data.shadow_store_cascade_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