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

1091 lines
38 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: 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"
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: Material code refactor. Separate material handling inside another file. Make use of enums to identify shader variations. Group all 64*64 LUTs into one array texture. Only update world probe if world changes.
2017-06-04 12:12:58 +02:00
/* Theses are the structs stored inside Objects.
* It works with even if the object is in multiple layers
* because we don't get the same "Object *" for each 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
typedef struct EEVEE_LightData {
short light_id, shadow_id;
} EEVEE_LightData;
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
typedef struct EEVEE_ShadowCubeData {
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
short light_id, shadow_id, cube_id, layer_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
} EEVEE_ShadowCubeData;
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
typedef struct EEVEE_ShadowCascadeData {
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
short light_id, shadow_id, cascade_id, layer_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
float viewprojmat[MAX_CASCADE_NUM][4][4]; /* World->Lamp->NDC : used for rendering the shadow map. */
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
float radius[MAX_CASCADE_NUM];
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_ShadowCascadeData;
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
typedef struct ShadowCaster {
struct ShadowCaster *next, *prev;
void *ob;
bool prune;
} ShadowCaster;
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_geom_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: 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
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
void EEVEE_lights_init(EEVEE_SceneLayerData *sldata)
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
const unsigned int shadow_ubo_size = sizeof(EEVEE_Shadow) * MAX_SHADOW +
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();
SceneLayer *scene_layer = draw_ctx->scene_layer;
IDProperty *props = BKE_scene_layer_engine_evaluated_get(scene_layer, COLLECTION_MODE_NONE, RE_engine_id_BLENDER_EEVEE);
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(
datatoc_shadow_vert_glsl, datatoc_shadow_geom_glsl, datatoc_shadow_frag_glsl, 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
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);
Cleanup: line length, right shift
2017-11-20 14:28:24 +11:00
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");
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");
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
MEM_freeN(store_shadow_shader_str);
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: line length, right shift
2017-11-20 14:28:24 +11:00
e_data.shadow_copy_cube_sh[SHADOW_ESM] = DRW_shader_create_fullscreen(
datatoc_shadow_copy_frag_glsl,
"#define ESM\n"
"#define COPY\n");
e_data.shadow_copy_cascade_sh[SHADOW_ESM] = DRW_shader_create_fullscreen(
datatoc_shadow_copy_frag_glsl, "#define ESM\n"
"#define COPY\n"
"#define CSM\n");
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: 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: 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
int sh_method = BKE_collection_engine_property_value_get_int(props, "shadow_method");
int sh_size = BKE_collection_engine_property_value_get_int(props, "shadow_size");
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
int sh_high_bitdepth = BKE_collection_engine_property_value_get_int(props, "shadow_high_bitdepth");
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: 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
if ((linfo->shadow_size != sh_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: 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
BLI_assert((sh_size > 0) && (sh_size <= 8192));
DRW_TEXTURE_FREE_SAFE(sldata->shadow_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: 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_TEXTURE_FREE_SAFE(sldata->shadow_cascade_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);
DRW_TEXTURE_FREE_SAFE(sldata->shadow_cascade_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: 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
linfo->shadow_high_bitdepth = sh_high_bitdepth;
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
linfo->shadow_method = sh_method;
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
linfo->shadow_size = sh_size;
linfo->shadow_render_data.stored_texel_size = 1.0 / (float)linfo->shadow_size;
/* Compute adequate size for the cubemap render target.
* The 3.0f factor is here to make sure there is no under sampling between
* the octahedron mapping and the cubemap. */
int new_cube_target_size = (int)ceil(sqrt((float)(sh_size * sh_size) / 6.0f) * 3.0f);
CLAMP(new_cube_target_size, 1, 4096);
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
linfo->shadow_cube_target_size = new_cube_target_size;
linfo->shadow_render_data.cube_texel_size = 1.0 / (float)linfo->shadow_cube_target_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: 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
void EEVEE_lights_cache_init(EEVEE_SceneLayerData *sldata, EEVEE_PassList *psl)
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
{
Eevee: Put shadows and probes inside SceneLayerEngineData This remove the duplication of data for each viewport improving memory usage.
2017-05-30 22:29:20 +02:00
EEVEE_LampsInfo *linfo = sldata->lamps;
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
Eevee: Add 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;
linfo->num_layer = 0;
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: 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);
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_shgroup_uniform_buffer(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);
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_buffer(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);
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_buffer(grp, "shadowTexture", &sldata->shadow_cube_target);
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);
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_buffer(grp, "shadowTexture", &sldata->shadow_cascade_target);
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
{
Cleanup: line length, right shift
2017-11-20 14:28:24 +11:00
psl->shadow_cube_pass = DRW_pass_create(
"Shadow Cube Pass",
DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS);
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
}
{
Cleanup: line length, right shift
2017-11-20 14:28:24 +11:00
psl->shadow_cascade_pass = DRW_pass_create(
"Shadow Cascade Pass",
DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS);
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: 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
/* Reset shadow casters list */
BLI_freelistN(&sldata->shadow_casters);
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
void EEVEE_lights_cache_add(EEVEE_SceneLayerData *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) {
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
printf("Too much lamps in the scene !!!\n");
Eevee: Fix T52546 : 129th light crashes Blender
2017-09-12 13:13:20 +02:00
linfo->num_light = MAX_LIGHT - 1;
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: Cleanup. Group data functions into one file.
2017-06-03 00:53:47 +02:00
EEVEE_LampEngineData *led = EEVEE_lamp_data_get(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
if ((ob->deg_update_flag & DEG_RUNTIME_DATA_UPDATE) != 0) {
led->need_update = true;
}
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01: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
MEM_SAFE_FREE(led->storage);
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->mode & (LA_SHAD_BUF | LA_SHAD_RAY)) {
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 */
int cascade_nbr = MAX_CASCADE_NUM; /* TODO : Custom cascade number */
if ((linfo->gpu_cascade_ct + sh_nbr) <= MAX_SHADOW_CASCADE) {
/* Save Light object. */
linfo->shadow_cascade_ref[linfo->cpu_cascade_ct] = ob;
/* Create storage and store indices. */
Cleanup: line length, right shift
2017-11-20 14:28:24 +11:00
EEVEE_ShadowCascadeData *data = MEM_mallocN(
sizeof(EEVEE_ShadowCascadeData), "EEVEE_ShadowCascadeData");
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;
data->layer_id = linfo->num_layer;
led->storage = data;
/* Increment indices. */
linfo->gpu_shadow_ct += 1;
linfo->gpu_cascade_ct += sh_nbr;
linfo->num_layer += sh_nbr * cascade_nbr;
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;
/* Create storage and store indices. */
Cleanup: line length, right shift
2017-11-20 14:28:24 +11:00
EEVEE_ShadowCubeData *data = MEM_mallocN(
sizeof(EEVEE_ShadowCubeData), "EEVEE_ShadowCubeData");
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;
data->layer_id = linfo->num_layer;
led->storage = data;
/* Increment indices. */
linfo->gpu_shadow_ct += 1;
linfo->gpu_cube_ct += sh_nbr;
linfo->num_layer += sh_nbr;
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: 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
/* Default light without shadows */
if (!led->storage) {
led->storage = MEM_mallocN(sizeof(EEVEE_LightData), "EEVEE_LightData");
((EEVEE_LightData *)led->storage)->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
}
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_LightData *)led->storage)->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_SceneLayerData *sldata, EEVEE_PassList *psl, struct Gwn_Batch *geom, float (*obmat)[4])
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
{
DRWShadingGroup *grp = DRW_shgroup_instance_create(e_data.shadow_sh, psl->shadow_cube_pass, geom);
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: 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_uniform_mat4(grp, "ShadowModelMatrix", (float *)obmat);
Eevee: Remove uses of DRW_shgroup_call_dynamic_add_empty in shadows and probe rendering. This was adding an unecessary high number of DRWCall per objects.
2017-11-06 16:54:33 +01:00
DRW_shgroup_set_instance_count(grp, 6);
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
grp = DRW_shgroup_instance_create(e_data.shadow_sh, psl->shadow_cascade_pass, geom);
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: 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_uniform_mat4(grp, "ShadowModelMatrix", (float *)obmat);
Eevee: Remove uses of DRW_shgroup_call_dynamic_add_empty in shadows and probe rendering. This was adding an unecessary high number of DRWCall per objects.
2017-11-06 16:54:33 +01:00
DRW_shgroup_set_instance_count(grp, MAX_CASCADE_NUM);
Eevee: Move cube shadows to octahedron shadowmaps. We render linear distance to the light in a R32 texture and store it into an octahedron projection inside a 2D texture array. This render the sampling function much more simpler and without edge artifacts.
2017-05-20 13:16:14 +02:00
}
Eevee: Transparency: Add support for Clip and Stochastic shadows.
2017-07-11 01:10:57 +02:00
void EEVEE_lights_cache_shcaster_material_add(
Eevee: Fix wrong shadow Orco mapping.
2017-09-12 15:06:07 +02:00
EEVEE_SceneLayerData *sldata, EEVEE_PassList *psl, struct GPUMaterial *gpumat,
struct Gwn_Batch *geom, struct Object *ob, float (*obmat)[4], float *alpha_threshold)
Eevee: Transparency: Add support for Clip and Stochastic shadows.
2017-07-11 01:10:57 +02:00
{
Eevee: Fix wrong shadow Orco mapping.
2017-09-12 15:06:07 +02:00
DRWShadingGroup *grp = DRW_shgroup_material_instance_create(gpumat, psl->shadow_cube_pass, geom, ob);
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
DRW_shgroup_uniform_block(grp, "shadow_render_block", sldata->shadow_render_ubo);
DRW_shgroup_uniform_mat4(grp, "ShadowModelMatrix", (float *)obmat);
if (alpha_threshold != NULL)
DRW_shgroup_uniform_float(grp, "alphaThreshold", alpha_threshold, 1);
Eevee: Remove uses of DRW_shgroup_call_dynamic_add_empty in shadows and probe rendering. This was adding an unecessary high number of DRWCall per objects.
2017-11-06 16:54:33 +01:00
DRW_shgroup_set_instance_count(grp, 6);
Eevee: Transparency: Add support for Clip and Stochastic shadows.
2017-07-11 01:10:57 +02:00
Eevee: Fix wrong shadow Orco mapping.
2017-09-12 15:06:07 +02:00
grp = DRW_shgroup_material_instance_create(gpumat, psl->shadow_cascade_pass, geom, ob);
Eevee: Transparency: Add support for Clip and Stochastic shadows.
2017-07-11 01:10:57 +02:00
DRW_shgroup_uniform_block(grp, "shadow_render_block", sldata->shadow_render_ubo);
DRW_shgroup_uniform_mat4(grp, "ShadowModelMatrix", (float *)obmat);
if (alpha_threshold != NULL)
DRW_shgroup_uniform_float(grp, "alphaThreshold", alpha_threshold, 1);
Eevee: Remove uses of DRW_shgroup_call_dynamic_add_empty in shadows and probe rendering. This was adding an unecessary high number of DRWCall per objects.
2017-11-06 16:54:33 +01:00
DRW_shgroup_set_instance_count(grp, MAX_CASCADE_NUM);
Eevee: Transparency: Add support for Clip and Stochastic shadows.
2017-07-11 01:10:57 +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
void EEVEE_lights_cache_finish(EEVEE_SceneLayerData *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;
Eevee: Silence warning
2017-10-28 14:08:30 +02:00
DRWTextureFormat shadow_pool_format = DRW_TEX_R_32;
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01: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
/* Setup enough layers. */
/* Free textures if number mismatch. */
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->num_layer != linfo->cache_num_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
DRW_TEXTURE_FREE_SAFE(sldata->shadow_pool);
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->cache_num_layer = linfo->num_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
linfo->update_flag |= LIGHT_UPDATE_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
}
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) {
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
case SHADOW_ESM: shadow_pool_format = ((linfo->shadow_high_bitdepth) ? DRW_TEX_R_32 : DRW_TEX_R_16); break;
case SHADOW_VSM: shadow_pool_format = ((linfo->shadow_high_bitdepth) ? DRW_TEX_RG_32 : DRW_TEX_RG_16); 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
if (!sldata->shadow_cube_target) {
/* TODO render everything on the same 2d render target using clip planes and no Geom Shader. */
/* Cubemaps */
Cleanup: line length, right shift
2017-11-20 14:28:24 +11:00
sldata->shadow_cube_target = DRW_texture_create_cube(
linfo->shadow_cube_target_size, DRW_TEX_DEPTH_24, 0, NULL);
sldata->shadow_cube_blur = DRW_texture_create_cube(
linfo->shadow_cube_target_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: 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) {
/* CSM */
sldata->shadow_cascade_target = DRW_texture_create_2D_array(
linfo->shadow_size, linfo->shadow_size, MAX_CASCADE_NUM, DRW_TEX_DEPTH_24, 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(
linfo->shadow_size, linfo->shadow_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: 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
/* Initialize Textures Array first so DRW_framebuffer_init just bind them. */
if (!sldata->shadow_pool) {
/* All shadows fit in this array */
sldata->shadow_pool = DRW_texture_create_2D_array(
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->shadow_size, linfo->shadow_size, max_ff(1, linfo->num_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
}
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
/* Render FB */
DRWFboTexture tex_cascade = {&sldata->shadow_cube_target, DRW_TEX_DEPTH_24, 0};
DRW_framebuffer_init(&sldata->shadow_target_fb, &draw_engine_eevee_type,
linfo->shadow_size, linfo->shadow_size,
&tex_cascade, 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
/* Storage FB */
DRWFboTexture tex_pool = {&sldata->shadow_pool, shadow_pool_format, DRW_TEX_FILTER};
DRW_framebuffer_init(&sldata->shadow_store_fb, &draw_engine_eevee_type,
linfo->shadow_size, linfo->shadow_size,
&tex_pool, 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
/* Restore */
DRW_framebuffer_texture_detach(sldata->shadow_cube_target);
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 */
static void eevee_light_setup(Object *ob, EEVEE_LampsInfo *linfo, EEVEE_LampEngineData *led)
Eevee: Initial commit Basic support for lamps. Only diffuse.
2017-03-17 00:00:46 +01:00
{
/* TODO only update if data changes */
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_LightData *evld = led->storage;
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_Light *evli = linfo->light_data + evld->light_id;
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: 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²) */
M_PI * 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 {
power = 1.0f;
}
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: 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_ShadowCubeData *sh_data = (EEVEE_ShadowCubeData *)led->storage;
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: 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: 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
static void frustum_min_bounding_sphere(const float corners[8][4], float r_center[3], float *r_radius)
{
#if 0 /* Simple solution but waist too much space. */
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
/* Make the bouding sphere always centered on the front diagonal */
add_v3_v3v3(r_center, corners[4], corners[7]);
mul_v3_fl(r_center, 0.5f);
*r_radius = len_v3v3(corners[0], r_center);
/* Search the largest distance between the sphere center
* and the front plane corners. */
for (int i = 0; i < 4; ++i) {
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
float rad = len_v3v3(corners[4 + 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;
}
}
#endif
}
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
static void eevee_shadow_cascade_setup(Object *ob, EEVEE_LampsInfo *linfo, EEVEE_LampEngineData *led)
{
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 */
float persmat[4][4], persinv[4][4];
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 viewprojmat[4][4], projinv[4][4];
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
float view_near, 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
float near_v[4] = {0.0f, 0.0f, -1.0f, 1.0f};
float far_v[4] = {0.0f, 0.0f, 1.0f, 1.0f};
bool is_persp = DRW_viewport_is_persp_get();
DRW_viewport_matrix_get(persmat, DRW_MAT_PERS);
invert_m4_m4(persinv, persmat);
/* FIXME : Get near / far from Draw manager? */
DRW_viewport_matrix_get(viewprojmat, DRW_MAT_WIN);
invert_m4_m4(projinv, viewprojmat);
mul_m4_v4(projinv, near_v);
mul_m4_v4(projinv, far_v);
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
view_near = near_v[2];
view_far = far_v[2]; /* TODO: Should be a shadow parameter */
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
view_near /= near_v[3];
view_far /= far_v[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
}
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
/* Lamps Matrices */
float viewmat[4][4], projmat[4][4];
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: 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_ShadowCascadeData *sh_data = (EEVEE_ShadowCascadeData *)led->storage;
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
/* 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 */
mul_m4_v4(viewprojmat, p);
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 */
mul_m4_v4(viewprojmat, p);
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 */
mul_m4_v4(viewprojmat, p);
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 */
mul_m4_v4(viewprojmat, 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) {
/* Given 8 frustum corners */
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
float corners[8][4] = {
/* Near Cap */
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
{-1.0f, -1.0f, splits_start_ndc[c], 1.0f},
{ 1.0f, -1.0f, splits_start_ndc[c], 1.0f},
{-1.0f, 1.0f, splits_start_ndc[c], 1.0f},
{ 1.0f, 1.0f, splits_start_ndc[c], 1.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
/* Far Cap */
Eevee: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
{-1.0f, -1.0f, splits_end_ndc[c], 1.0f},
{ 1.0f, -1.0f, splits_end_ndc[c], 1.0f},
{-1.0f, 1.0f, splits_end_ndc[c], 1.0f},
{ 1.0f, 1.0f, splits_end_ndc[c], 1.0f}
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: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
mul_m4_v4(persinv, corners[i]);
mul_v3_fl(corners[i], 1.0f / corners[i][3]);
corners[i][3] = 1.0f;
}
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
/* Project them into light space */
invert_m4_m4(viewmat, ob->obmat);
normalize_v3(viewmat[0]);
normalize_v3(viewmat[1]);
normalize_v3(viewmat[2]);
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
for (int i = 0; i < 8; ++i) {
Eevee: Start Implementation of Cascaded Shadow Maps
2017-04-20 13:07:24 +02:00
mul_m4_v4(viewmat, corners[i]);
}
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
float center[3];
frustum_min_bounding_sphere(corners, 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
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. */
mul_v2_v2fl(shadow_origin, center, linfo->shadow_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. */
shadow_texco[0] = round(shadow_origin[0]);
shadow_texco[1] = round(shadow_origin[1]);
/* Compute offset. */
sub_v2_v2(shadow_texco, shadow_origin);
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_v2_fl(shadow_texco, (2.0f * sh_data->radius[c]) / linfo->shadow_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 */
orthographic_m4(projmat,
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
center[0] - sh_data->radius[c],
center[0] + sh_data->radius[c],
center[1] - sh_data->radius[c],
center[1] + 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
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: 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. */
static bool cube_bbox_intersect(const float cube_center[3], float cube_half_dim, const BoundBox *bb, float (*obmat)[4])
{
float min[3], max[4], tmp[4][4];
unit_m4(tmp);
translate_m4(tmp, -cube_center[0], -cube_center[1], -cube_center[2]);
mul_m4_m4m4(tmp, tmp, obmat);
/* Just simple AABB intersection test in world space. */
INIT_MINMAX(min, max);
for (int i = 0; i < 8; ++i) {
float vec[3];
copy_v3_v3(vec, bb->vec[i]);
mul_m4_v3(tmp, vec);
minmax_v3v3_v3(min, max, vec);
}
Cleanup: style, duplicate includes
2017-10-07 15:57:14 +11:00
if (MAX3(max[0], max[1], max[2]) < -cube_half_dim) return false;
if (MIN3(min[0], min[1], min[2]) > cube_half_dim) return false;
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
return true;
}
static ShadowCaster *search_object_in_list(ListBase *list, Object *ob)
{
for (ShadowCaster *ldata = list->first; ldata; ldata = ldata->next) {
if (ldata->ob == ob)
return ldata;
}
return NULL;
}
static void delete_pruned_shadowcaster(EEVEE_LampEngineData *led)
{
ShadowCaster *next;
for (ShadowCaster *ldata = led->shadow_caster_list.first; ldata; ldata = next) {
next = ldata->next;
if (ldata->prune == true) {
Eevee: fix light update when a shadow caster is deleted
2017-06-02 20:51:35 +02:00
led->need_update = 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
BLI_freelinkN(&led->shadow_caster_list, ldata);
}
}
}
static void light_tag_shadow_update(Object *lamp, Object *ob)
{
Lamp *la = lamp->data;
Eevee: Cleanup. Group data functions into one file.
2017-06-03 00:53:47 +02:00
EEVEE_LampEngineData *led = EEVEE_lamp_data_get(lamp);
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
bool is_inside_range = cube_bbox_intersect(lamp->obmat[3], la->clipend, BKE_object_boundbox_get(ob), ob->obmat);
ShadowCaster *ldata = search_object_in_list(&led->shadow_caster_list, ob);
if (is_inside_range) {
if (ldata == NULL) {
/* Object was not a shadow caster previously but is now. Add it. */
ldata = MEM_callocN(sizeof(ShadowCaster), "ShadowCaster");
ldata->ob = ob;
BLI_addtail(&led->shadow_caster_list, ldata);
led->need_update = true;
}
else {
Eevee: Cleanup. Group data functions into one file.
2017-06-03 00:53:47 +02:00
EEVEE_ObjectEngineData *oedata = EEVEE_object_data_get(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
if (oedata->need_update) {
led->need_update = true;
}
}
ldata->prune = false;
}
else if (ldata != NULL) {
/* Object was a shadow caster previously and is not anymore. Remove it. */
led->need_update = true;
BLI_freelinkN(&led->shadow_caster_list, ldata);
}
}
static void eevee_lights_shcaster_updated(EEVEE_SceneLayerData *sldata, Object *ob)
{
Object *lamp;
EEVEE_LampsInfo *linfo = sldata->lamps;
/* Iterate over all shadow casting lamps to see if
* each of them needs update because of this object */
for (int i = 0; (lamp = linfo->shadow_cube_ref[i]) && (i < MAX_SHADOW_CUBE); i++) {
light_tag_shadow_update(lamp, ob);
}
}
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
void EEVEE_lights_update(EEVEE_SceneLayerData *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;
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: 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
/* Prune shadow casters to remove if object does not exists anymore (unprune them if object exists) */
Object *lamp;
for (i = 0; (lamp = linfo->shadow_cube_ref[i]) && (i < MAX_SHADOW_CUBE); i++) {
Eevee: Cleanup. Group data functions into one file.
2017-06-03 00:53:47 +02:00
EEVEE_LampEngineData *led = EEVEE_lamp_data_get(lamp);
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
if ((linfo->update_flag & LIGHT_UPDATE_SHADOW_CUBE) != 0) {
led->need_update = true;
}
for (ShadowCaster *ldata = led->shadow_caster_list.first; ldata; ldata = ldata->next) {
ldata->prune = true;
}
}
for (LinkData *ldata = sldata->shadow_casters.first; ldata; ldata = ldata->next) {
eevee_lights_shcaster_updated(sldata, ldata->data);
}
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 (i = 0; (ob = linfo->light_ref[i]) && (i < MAX_LIGHT); i++) {
Eevee: Cleanup. Group data functions into one file.
2017-06-03 00:53:47 +02:00
EEVEE_LampEngineData *led = EEVEE_lamp_data_get(ob);
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_light_setup(ob, linfo, led);
}
for (i = 0; (ob = linfo->shadow_cube_ref[i]) && (i < MAX_SHADOW_CUBE); i++) {
Eevee: Cleanup. Group data functions into one file.
2017-06-03 00:53:47 +02:00
EEVEE_LampEngineData *led = EEVEE_lamp_data_get(ob);
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_shadow_cube_setup(ob, linfo, led);
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
delete_pruned_shadowcaster(led);
Eevee: First Shadows implementation Using Texture Arrays to store shadow maps so less texture slots are used when shading. This means a large amount of shadows can be supported. Support Projection Shadow Map for sun like in old BI/BGE. Support Cube Shadow Map for Point/Spot/Area lights. the benefit of using it for spot light is that the spot angle does not change shadow resolution (at the cost of more memory used). The implementation of the cubemap sampling is targeted for 3.3 core. We rely on 2D texture arrays to store cubemaps faces and sample the right one manualy. Significant performance improvement can be done using Cubemap Arrays on supported hardware. Shadows are only hardware filtered. Prefiltered shadows and settings comming next.
2017-04-10 12:06:17 +02:00
}
}
/* this refresh lamps shadow buffers */
Eevee: 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
void EEVEE_draw_shadows(EEVEE_SceneLayerData *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: 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
float clear_col[4] = {FLT_MAX};
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: 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_framebuffer_texture_attach(sldata->shadow_target_fb, sldata->shadow_cube_target, 0, 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
/* 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. Group data functions into one file.
2017-06-03 00:53:47 +02:00
EEVEE_LampEngineData *led = EEVEE_lamp_data_get(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: 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
float cube_projmat[4][4];
perspective_m4(cube_projmat, -la->clipsta, la->clipsta, -la->clipsta, la->clipsta, la->clipsta, la->clipend);
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
if (led->need_update) {
EEVEE_ShadowRender *srd = &linfo->shadow_render_data;
Eevee: Fix bug with cubemap shadows.
2017-09-26 22:30:48 +02:00
EEVEE_ShadowCubeData *evscd = (EEVEE_ShadowCubeData *)led->storage;
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: 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
srd->clip_near = la->clipsta;
srd->clip_far = la->clipend;
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
copy_v3_v3(srd->position, ob->obmat[3]);
Eevee small cleanups
2017-07-13 12:04:30 +02:00
for (int j = 0; j < 6; j++) {
Eevee: Transparency: Add support for Clip and Stochastic shadows.
2017-07-11 01:10:57 +02:00
float tmp[4][4];
unit_m4(tmp);
negate_v3_v3(tmp[3], ob->obmat[3]);
Eevee: Fix crash on eevee lamps and shadows
2017-07-13 12:04:05 +02:00
mul_m4_m4m4(srd->viewmat[j], cubefacemat[j], tmp);
Eevee: Transparency: Add support for Clip and Stochastic shadows.
2017-07-11 01:10:57 +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(srd->shadowmat[j], cube_projmat, srd->viewmat[j]);
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: 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_uniformbuffer_update(sldata->shadow_render_ubo, srd);
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: 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_framebuffer_bind(sldata->shadow_target_fb);
DRW_framebuffer_clear(true, true, false, clear_col, 1.0f);
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: 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
/* Render shadow cube */
DRW_draw_pass(psl->shadow_cube_pass);
Eevee: Do shadow cube render in one pass.
2017-04-19 22:07:53 +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
/* 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;
float filter_pixel_size = ceil(filter_texture_size / linfo->shadow_render_data.cube_texel_size);
linfo->filter_size = linfo->shadow_render_data.cube_texel_size * ((filter_pixel_size > 1.0f) ? 1.5f : 0.0f);
/* TODO: OPTI: Filter all faces in one/two draw call */
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
for (linfo->current_shadow_face = 0;
linfo->current_shadow_face < 6;
linfo->current_shadow_face++)
{
/* Copy using a small 3x3 box filter */
DRW_framebuffer_cubeface_attach(sldata->shadow_store_fb, sldata->shadow_cube_blur, 0, linfo->current_shadow_face, 0);
DRW_framebuffer_bind(sldata->shadow_store_fb);
DRW_draw_pass(psl->shadow_cube_copy_pass);
DRW_framebuffer_texture_detach(sldata->shadow_cube_blur);
}
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
/* Push it to shadowmap array */
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;
const float previous_box_filter_size = 9.0f; /* Dunno why but that works. */
const int max_sample = 256;
if (filter_pixel_size > 2.0f) {
linfo->filter_size = linfo->shadow_render_data.cube_texel_size * max_filter_size * previous_box_filter_size;
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, srd);
Eevee: Fix bug with cubemap shadows.
2017-09-26 22:30:48 +02:00
DRW_framebuffer_texture_layer_attach(sldata->shadow_store_fb, sldata->shadow_pool, 0, evscd->layer_id, 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
DRW_framebuffer_bind(sldata->shadow_store_fb);
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
DRW_draw_pass(psl->shadow_cube_store_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: 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 = 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: 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
DRW_framebuffer_texture_detach(sldata->shadow_cube_target);
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: 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
DRW_framebuffer_texture_attach(sldata->shadow_target_fb, sldata->shadow_cascade_target, 0, 0);
for (i = 0; (ob = linfo->shadow_cascade_ref[i]) && (i < MAX_SHADOW_CASCADE); i++) {
EEVEE_LampEngineData *led = EEVEE_lamp_data_get(ob);
Lamp *la = (Lamp *)ob->data;
EEVEE_ShadowCascadeData *evscd = (EEVEE_ShadowCascadeData *)led->storage;
EEVEE_ShadowRender *srd = &linfo->shadow_render_data;
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_shadow_cascade_setup(ob, linfo, led);
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: Add Cascaded Shadow Map options.
2017-09-07 15:31:11 +02:00
for (int j = 0; j < la->cascade_count; ++j) {
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
copy_m4_m4(srd->shadowmat[j], evscd->viewprojmat[j]);
}
DRW_uniformbuffer_update(sldata->shadow_render_ubo, &linfo->shadow_render_data);
DRW_framebuffer_bind(sldata->shadow_target_fb);
DRW_framebuffer_clear(false, true, false, NULL, 1.0);
/* Render shadow cascades */
DRW_draw_pass(psl->shadow_cascade_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
/* 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];
float filter_pixel_size = ceil(linfo->shadow_size * filter_texture_size);
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: 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
linfo->filter_size = linfo->shadow_render_data.stored_texel_size * ((filter_pixel_size > 1.0f) ? 1.0f : 0.0f);
Cleanup: line length, right shift
2017-11-20 14:28:24 +11:00
DRW_framebuffer_texture_layer_attach(
sldata->shadow_store_fb, sldata->shadow_cascade_blur, 0, linfo->current_shadow_cascade, 0);
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_framebuffer_bind(sldata->shadow_store_fb);
DRW_draw_pass(psl->shadow_cascade_copy_pass);
DRW_framebuffer_texture_detach(sldata->shadow_cascade_blur);
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;
const float previous_box_filter_size = 3.2f; /* Arbitrary: less banding */
const int max_sample = 256;
if (filter_pixel_size > 2.0f) {
linfo->filter_size = linfo->shadow_render_data.stored_texel_size * max_filter_size * previous_box_filter_size;
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;
DRW_framebuffer_texture_layer_attach(sldata->shadow_store_fb, sldata->shadow_pool, 0, layer, 0);
DRW_framebuffer_bind(sldata->shadow_store_fb);
DRW_draw_pass(psl->shadow_cascade_store_pass);
}
}
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_framebuffer_texture_detach(sldata->shadow_cascade_target);
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();
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