Lights: change sun light size to be specified as angle
[blender.git] / source / blender / draw / engines / eevee / eevee_lights.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * Copyright 2016, Blender Foundation.
17  */
18
19 /** \file
20  * \ingroup DNA
21  */
22
23 #include "DRW_render.h"
24
25 #include "BLI_dynstr.h"
26 #include "BLI_rand.h"
27 #include "BLI_rect.h"
28
29 #include "BKE_object.h"
30
31 #include "DEG_depsgraph_query.h"
32
33 #include "eevee_private.h"
34
35 #define SHADOW_CASTER_ALLOC_CHUNK 16
36
37 // #define DEBUG_CSM
38 // #define DEBUG_SHADOW_DISTRIBUTION
39
40 static struct {
41   struct GPUShader *shadow_sh;
42   struct GPUShader *shadow_store_cube_sh[SHADOW_METHOD_MAX];
43   struct GPUShader *shadow_store_cube_high_sh[SHADOW_METHOD_MAX];
44   struct GPUShader *shadow_store_cascade_sh[SHADOW_METHOD_MAX];
45   struct GPUShader *shadow_store_cascade_high_sh[SHADOW_METHOD_MAX];
46   struct GPUShader *shadow_copy_cube_sh[SHADOW_METHOD_MAX];
47   struct GPUShader *shadow_copy_cascade_sh[SHADOW_METHOD_MAX];
48 } e_data = {NULL}; /* Engine data */
49
50 extern char datatoc_shadow_vert_glsl[];
51 extern char datatoc_shadow_frag_glsl[];
52 extern char datatoc_shadow_store_frag_glsl[];
53 extern char datatoc_shadow_copy_frag_glsl[];
54 extern char datatoc_concentric_samples_lib_glsl[];
55
56 extern char datatoc_common_view_lib_glsl[];
57
58 /* Prototypes */
59 static void eevee_light_setup(Object *ob, EEVEE_Light *evli);
60 static float light_attenuation_radius_get(Light *la, float light_threshold);
61
62 /* *********** LIGHT BITS *********** */
63 static void lightbits_set_single(EEVEE_LightBits *bitf, uint idx, bool val)
64 {
65   if (val) {
66     bitf->fields[idx / 8] |= (1 << (idx % 8));
67   }
68   else {
69     bitf->fields[idx / 8] &= ~(1 << (idx % 8));
70   }
71 }
72
73 static void lightbits_set_all(EEVEE_LightBits *bitf, bool val)
74 {
75   memset(bitf, (val) ? 0xFF : 0x00, sizeof(EEVEE_LightBits));
76 }
77
78 static void lightbits_or(EEVEE_LightBits *r, const EEVEE_LightBits *v)
79 {
80   for (int i = 0; i < MAX_LIGHTBITS_FIELDS; ++i) {
81     r->fields[i] |= v->fields[i];
82   }
83 }
84
85 static bool lightbits_get(const EEVEE_LightBits *r, uint idx)
86 {
87   return r->fields[idx / 8] & (1 << (idx % 8));
88 }
89
90 static void lightbits_convert(EEVEE_LightBits *r,
91                               const EEVEE_LightBits *bitf,
92                               const int *light_bit_conv_table,
93                               uint table_length)
94 {
95   for (int i = 0; i < table_length; ++i) {
96     if (lightbits_get(bitf, i) != 0) {
97       if (light_bit_conv_table[i] >= 0) {
98         r->fields[i / 8] |= (1 << (i % 8));
99       }
100     }
101   }
102 }
103
104 /* *********** FUNCTIONS *********** */
105
106 void EEVEE_lights_init(EEVEE_ViewLayerData *sldata)
107 {
108   const uint shadow_ubo_size = sizeof(EEVEE_Shadow) * MAX_SHADOW +
109                                sizeof(EEVEE_ShadowCube) * MAX_SHADOW_CUBE +
110                                sizeof(EEVEE_ShadowCascade) * MAX_SHADOW_CASCADE;
111
112   const DRWContextState *draw_ctx = DRW_context_state_get();
113   const Scene *scene_eval = DEG_get_evaluated_scene(draw_ctx->depsgraph);
114
115   if (!e_data.shadow_sh) {
116     e_data.shadow_sh = DRW_shader_create_with_lib(datatoc_shadow_vert_glsl,
117                                                   NULL,
118                                                   datatoc_shadow_frag_glsl,
119                                                   datatoc_common_view_lib_glsl,
120                                                   NULL);
121   }
122
123   if (!sldata->lights) {
124     sldata->lights = MEM_callocN(sizeof(EEVEE_LightsInfo), "EEVEE_LightsInfo");
125     sldata->light_ubo = DRW_uniformbuffer_create(sizeof(EEVEE_Light) * MAX_LIGHT, NULL);
126     sldata->shadow_ubo = DRW_uniformbuffer_create(shadow_ubo_size, NULL);
127     sldata->shadow_render_ubo = DRW_uniformbuffer_create(sizeof(EEVEE_ShadowRender), NULL);
128
129     for (int i = 0; i < 2; ++i) {
130       sldata->shcasters_buffers[i].shadow_casters = MEM_callocN(
131           sizeof(EEVEE_ShadowCaster) * SHADOW_CASTER_ALLOC_CHUNK, "EEVEE_ShadowCaster buf");
132       sldata->shcasters_buffers[i].flags = MEM_callocN(sizeof(sldata->shcasters_buffers[0].flags) *
133                                                            SHADOW_CASTER_ALLOC_CHUNK,
134                                                        "EEVEE_shcast_buffer flags buf");
135       sldata->shcasters_buffers[i].alloc_count = SHADOW_CASTER_ALLOC_CHUNK;
136       sldata->shcasters_buffers[i].count = 0;
137     }
138
139     sldata->lights->shcaster_frontbuffer = &sldata->shcasters_buffers[0];
140     sldata->lights->shcaster_backbuffer = &sldata->shcasters_buffers[1];
141   }
142
143   /* Flip buffers */
144   SWAP(EEVEE_ShadowCasterBuffer *,
145        sldata->lights->shcaster_frontbuffer,
146        sldata->lights->shcaster_backbuffer);
147
148   const int sh_method = scene_eval->eevee.shadow_method;
149   int sh_cube_size = scene_eval->eevee.shadow_cube_size;
150   int sh_cascade_size = scene_eval->eevee.shadow_cascade_size;
151   const bool sh_high_bitdepth = (scene_eval->eevee.flag & SCE_EEVEE_SHADOW_HIGH_BITDEPTH) != 0;
152   sldata->lights->soft_shadows = (scene_eval->eevee.flag & SCE_EEVEE_SHADOW_SOFT) != 0;
153
154   EEVEE_LightsInfo *linfo = sldata->lights;
155   if ((linfo->shadow_cube_size != sh_cube_size) || (linfo->shadow_method != sh_method) ||
156       (linfo->shadow_high_bitdepth != sh_high_bitdepth)) {
157     BLI_assert((sh_cube_size > 0) && (sh_cube_size <= 4096));
158     DRW_TEXTURE_FREE_SAFE(sldata->shadow_cube_pool);
159     DRW_TEXTURE_FREE_SAFE(sldata->shadow_cube_target);
160     DRW_TEXTURE_FREE_SAFE(sldata->shadow_cube_blur);
161
162     /* Compute adequate size for the octahedral map. */
163     linfo->shadow_cube_store_size = OCTAHEDRAL_SIZE_FROM_CUBESIZE(sh_cube_size);
164
165     CLAMP(linfo->shadow_cube_store_size, 1, 4096);
166     CLAMP(sh_cube_size, 1, 4096);
167
168     linfo->shadow_render_data.cube_texel_size = 1.0f / sh_cube_size;
169   }
170
171   if ((linfo->shadow_cascade_size != sh_cascade_size) || (linfo->shadow_method != sh_method) ||
172       (linfo->shadow_high_bitdepth != sh_high_bitdepth)) {
173     BLI_assert((sh_cascade_size > 0) && (sh_cascade_size <= 4096));
174     DRW_TEXTURE_FREE_SAFE(sldata->shadow_cascade_pool);
175     DRW_TEXTURE_FREE_SAFE(sldata->shadow_cascade_target);
176     DRW_TEXTURE_FREE_SAFE(sldata->shadow_cascade_blur);
177
178     CLAMP(sh_cascade_size, 1, 4096);
179   }
180
181   linfo->shadow_high_bitdepth = sh_high_bitdepth;
182   linfo->shadow_method = sh_method;
183   linfo->shadow_cube_size = sh_cube_size;
184   linfo->shadow_cascade_size = sh_cascade_size;
185
186   /* only compile the ones needed. reduce startup time. */
187   if ((sh_method == SHADOW_ESM) && !e_data.shadow_copy_cube_sh[SHADOW_ESM]) {
188     e_data.shadow_copy_cube_sh[SHADOW_ESM] = DRW_shader_create_fullscreen(
189         datatoc_shadow_copy_frag_glsl,
190         "#define ESM\n"
191         "#define COPY\n");
192     e_data.shadow_copy_cascade_sh[SHADOW_ESM] = DRW_shader_create_fullscreen(
193         datatoc_shadow_copy_frag_glsl,
194         "#define ESM\n"
195         "#define COPY\n"
196         "#define CSM\n");
197   }
198   else if ((sh_method == SHADOW_VSM) && !e_data.shadow_copy_cube_sh[SHADOW_VSM]) {
199     e_data.shadow_copy_cube_sh[SHADOW_VSM] = DRW_shader_create_fullscreen(
200         datatoc_shadow_copy_frag_glsl,
201         "#define VSM\n"
202         "#define COPY\n");
203     e_data.shadow_copy_cascade_sh[SHADOW_VSM] = DRW_shader_create_fullscreen(
204         datatoc_shadow_copy_frag_glsl,
205         "#define VSM\n"
206         "#define COPY\n"
207         "#define CSM\n");
208   }
209 }
210
211 static GPUShader *eevee_lights_get_store_sh(int shadow_method, bool high_blur, bool cascade)
212 {
213   GPUShader **shader;
214
215   if (cascade) {
216     shader = (high_blur) ? &e_data.shadow_store_cascade_high_sh[shadow_method] :
217                            &e_data.shadow_store_cascade_sh[shadow_method];
218   }
219   else {
220     shader = (high_blur) ? &e_data.shadow_store_cube_high_sh[shadow_method] :
221                            &e_data.shadow_store_cube_sh[shadow_method];
222   }
223
224   if (*shader == NULL) {
225     DynStr *ds_frag = BLI_dynstr_new();
226     BLI_dynstr_append(ds_frag, datatoc_concentric_samples_lib_glsl);
227     BLI_dynstr_append(ds_frag, datatoc_shadow_store_frag_glsl);
228     char *store_shadow_shader_str = BLI_dynstr_get_cstring(ds_frag);
229     BLI_dynstr_free(ds_frag);
230
231     ds_frag = BLI_dynstr_new();
232     BLI_dynstr_append(ds_frag, (shadow_method == SHADOW_VSM) ? "#define VSM\n" : "#define ESM\n");
233     if (high_blur) {
234       BLI_dynstr_append(ds_frag, "#define HIGH_BLUR\n");
235     }
236     if (cascade) {
237       BLI_dynstr_append(ds_frag, "#define CSM\n");
238     }
239     char *define_str = BLI_dynstr_get_cstring(ds_frag);
240     BLI_dynstr_free(ds_frag);
241
242     *shader = DRW_shader_create_fullscreen(store_shadow_shader_str, define_str);
243
244     MEM_freeN(store_shadow_shader_str);
245     MEM_freeN(define_str);
246   }
247
248   return *shader;
249 }
250
251 static DRWPass *eevee_lights_cube_store_pass_get(EEVEE_PassList *psl,
252                                                  EEVEE_ViewLayerData *sldata,
253                                                  int shadow_method,
254                                                  int shadow_samples_len)
255 {
256   bool high_blur = shadow_samples_len > 16;
257   DRWPass **pass = (high_blur) ? &psl->shadow_cube_store_pass : &psl->shadow_cube_store_high_pass;
258   if (*pass == NULL) {
259     EEVEE_LightsInfo *linfo = sldata->lights;
260     *pass = DRW_pass_create("Shadow Cube Storage Pass", DRW_STATE_WRITE_COLOR);
261     GPUShader *shader = eevee_lights_get_store_sh(shadow_method, high_blur, false);
262     DRWShadingGroup *grp = DRW_shgroup_create(shader, *pass);
263     DRW_shgroup_uniform_texture_ref(grp, "shadowTexture", &sldata->shadow_cube_blur);
264     DRW_shgroup_uniform_block(grp, "shadow_render_block", sldata->shadow_render_ubo);
265     DRW_shgroup_uniform_float(grp, "shadowFilterSize", &linfo->filter_size, 1);
266     DRW_shgroup_call(grp, DRW_cache_fullscreen_quad_get(), NULL);
267   }
268   return *pass;
269 }
270
271 static DRWPass *eevee_lights_cascade_store_pass_get(EEVEE_PassList *psl,
272                                                     EEVEE_ViewLayerData *sldata,
273                                                     int shadow_method,
274                                                     int shadow_samples_len)
275 {
276   bool high_blur = shadow_samples_len > 16;
277   DRWPass **pass = (high_blur) ? &psl->shadow_cascade_store_pass :
278                                  &psl->shadow_cascade_store_high_pass;
279   if (*pass == NULL) {
280     EEVEE_LightsInfo *linfo = sldata->lights;
281     *pass = DRW_pass_create("Shadow Cascade Storage Pass", DRW_STATE_WRITE_COLOR);
282     GPUShader *shader = eevee_lights_get_store_sh(shadow_method, high_blur, true);
283     DRWShadingGroup *grp = DRW_shgroup_create(shader, *pass);
284     DRW_shgroup_uniform_texture_ref(grp, "shadowTexture", &sldata->shadow_cascade_blur);
285     DRW_shgroup_uniform_block(grp, "shadow_render_block", sldata->shadow_render_ubo);
286     DRW_shgroup_uniform_int(grp, "cascadeId", &linfo->current_shadow_cascade, 1);
287     DRW_shgroup_uniform_float(grp, "shadowFilterSize", &linfo->filter_size, 1);
288     DRW_shgroup_call(grp, DRW_cache_fullscreen_quad_get(), NULL);
289   }
290   return *pass;
291 }
292
293 void EEVEE_lights_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
294 {
295   EEVEE_LightsInfo *linfo = sldata->lights;
296   EEVEE_StorageList *stl = vedata->stl;
297   EEVEE_PassList *psl = vedata->psl;
298
299   linfo->shcaster_frontbuffer->count = 0;
300   linfo->num_light = 0;
301   linfo->num_cube_layer = 0;
302   linfo->num_cascade_layer = 0;
303   linfo->gpu_cube_len = linfo->gpu_cascade_len = linfo->gpu_shadow_len = 0;
304   linfo->cpu_cube_len = linfo->cpu_cascade_len = 0;
305   memset(linfo->light_ref, 0, sizeof(linfo->light_ref));
306   memset(linfo->shadow_cube_ref, 0, sizeof(linfo->shadow_cube_ref));
307   memset(linfo->shadow_cascade_ref, 0, sizeof(linfo->shadow_cascade_ref));
308   memset(linfo->new_shadow_id, -1, sizeof(linfo->new_shadow_id));
309
310   /* Shadow Casters: Reset flags. */
311   memset(linfo->shcaster_backbuffer->flags,
312          (char)SHADOW_CASTER_PRUNED,
313          linfo->shcaster_backbuffer->alloc_count);
314   memset(linfo->shcaster_frontbuffer->flags, 0x00, linfo->shcaster_frontbuffer->alloc_count);
315
316   psl->shadow_cube_store_pass = NULL;
317   psl->shadow_cube_store_high_pass = NULL;
318   psl->shadow_cascade_store_pass = NULL;
319   psl->shadow_cascade_store_high_pass = NULL;
320
321   {
322     psl->shadow_cube_copy_pass = DRW_pass_create("Shadow Copy Pass", DRW_STATE_WRITE_COLOR);
323
324     DRWShadingGroup *grp = DRW_shgroup_create(e_data.shadow_copy_cube_sh[linfo->shadow_method],
325                                               psl->shadow_cube_copy_pass);
326     DRW_shgroup_uniform_texture_ref(grp, "shadowTexture", &sldata->shadow_cube_target);
327     DRW_shgroup_uniform_block(grp, "shadow_render_block", sldata->shadow_render_ubo);
328     DRW_shgroup_uniform_float(grp, "shadowFilterSize", &linfo->filter_size, 1);
329     DRW_shgroup_uniform_int(grp, "faceId", &linfo->current_shadow_face, 1);
330     DRW_shgroup_call(grp, DRW_cache_fullscreen_quad_get(), NULL);
331   }
332
333   {
334     psl->shadow_cascade_copy_pass = DRW_pass_create("Shadow Cascade Copy Pass",
335                                                     DRW_STATE_WRITE_COLOR);
336
337     DRWShadingGroup *grp = DRW_shgroup_create(e_data.shadow_copy_cascade_sh[linfo->shadow_method],
338                                               psl->shadow_cascade_copy_pass);
339     DRW_shgroup_uniform_texture_ref(grp, "shadowTexture", &sldata->shadow_cascade_target);
340     DRW_shgroup_uniform_block(grp, "shadow_render_block", sldata->shadow_render_ubo);
341     DRW_shgroup_uniform_float(grp, "shadowFilterSize", &linfo->filter_size, 1);
342     DRW_shgroup_uniform_int(grp, "cascadeId", &linfo->current_shadow_cascade, 1);
343     DRW_shgroup_call(grp, DRW_cache_fullscreen_quad_get(), NULL);
344   }
345
346   {
347     DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL;
348     psl->shadow_pass = DRW_pass_create("Shadow Pass", state);
349
350     stl->g_data->shadow_shgrp = DRW_shgroup_create(e_data.shadow_sh, psl->shadow_pass);
351   }
352 }
353
354 void EEVEE_lights_cache_add(EEVEE_ViewLayerData *sldata, Object *ob)
355 {
356   EEVEE_LightsInfo *linfo = sldata->lights;
357
358   const DRWContextState *draw_ctx = DRW_context_state_get();
359   const float threshold = draw_ctx->scene->eevee.light_threshold;
360   /* Step 1 find all lights in the scene and setup them */
361   if (linfo->num_light >= MAX_LIGHT) {
362     printf("Too many lights in the scene !!!\n");
363   }
364   else {
365     Light *la = (Light *)ob->data;
366
367     /* Early out if light has no power. */
368     if (la->energy == 0.0f || is_zero_v3(&la->r)) {
369       return;
370     }
371
372     EEVEE_Light *evli = linfo->light_data + linfo->num_light;
373     eevee_light_setup(ob, evli);
374
375     /* We do not support shadowmaps for dupli lights. */
376     if ((ob->base_flag & BASE_FROM_DUPLI) != 0) {
377       linfo->num_light++;
378       return;
379     }
380
381     EEVEE_LightEngineData *led = EEVEE_light_data_ensure(ob);
382
383     /* Save previous shadow id. */
384     int prev_cube_sh_id = led->prev_cube_shadow_id;
385
386     /* Default light without shadows */
387     led->data.ld.shadow_id = -1;
388     led->prev_cube_shadow_id = -1;
389
390     if (la->mode & LA_SHADOW) {
391       if (la->type == LA_SUN) {
392         int cascade_nbr = la->cascade_count;
393
394         if ((linfo->gpu_cascade_len + 1) <= MAX_SHADOW_CASCADE) {
395           /* Save Light object. */
396           linfo->shadow_cascade_ref[linfo->cpu_cascade_len] = ob;
397
398           /* Store indices. */
399           EEVEE_ShadowCascadeData *data = &led->data.scad;
400           data->shadow_id = linfo->gpu_shadow_len;
401           data->cascade_id = linfo->gpu_cascade_len;
402           data->layer_id = linfo->num_cascade_layer;
403
404           /* Increment indices. */
405           linfo->gpu_shadow_len += 1;
406           linfo->gpu_cascade_len += 1;
407           linfo->num_cascade_layer += cascade_nbr;
408
409           linfo->cpu_cascade_len += 1;
410         }
411       }
412       else if (la->type == LA_SPOT || la->type == LA_LOCAL || la->type == LA_AREA) {
413         if ((linfo->gpu_cube_len + 1) <= MAX_SHADOW_CUBE) {
414           /* Save Light object. */
415           linfo->shadow_cube_ref[linfo->cpu_cube_len] = ob;
416
417           /* For light update tracking. */
418           if ((prev_cube_sh_id >= 0) && (prev_cube_sh_id < linfo->shcaster_backbuffer->count)) {
419             linfo->new_shadow_id[prev_cube_sh_id] = linfo->cpu_cube_len;
420           }
421           led->prev_cube_shadow_id = linfo->cpu_cube_len;
422
423           /* Saving light bounds for later. */
424           BLI_assert(linfo->cpu_cube_len >= 0 && linfo->cpu_cube_len < MAX_LIGHT);
425           copy_v3_v3(linfo->shadow_bounds[linfo->cpu_cube_len].center, ob->obmat[3]);
426           linfo->shadow_bounds[linfo->cpu_cube_len].radius = light_attenuation_radius_get(
427               la, threshold);
428
429           EEVEE_ShadowCubeData *data = &led->data.scd;
430           /* Store indices. */
431           data->shadow_id = linfo->gpu_shadow_len;
432           data->cube_id = linfo->gpu_cube_len;
433           data->layer_id = linfo->num_cube_layer;
434
435           /* Increment indices. */
436           linfo->gpu_shadow_len += 1;
437           linfo->gpu_cube_len += 1;
438           linfo->num_cube_layer += 1;
439
440           linfo->cpu_cube_len += 1;
441         }
442       }
443     }
444
445     led->data.ld.light_id = linfo->num_light;
446     linfo->light_ref[linfo->num_light] = ob;
447     linfo->num_light++;
448   }
449 }
450
451 /* Add a shadow caster to the shadowpasses */
452 void EEVEE_lights_cache_shcaster_add(EEVEE_ViewLayerData *UNUSED(sldata),
453                                      EEVEE_StorageList *stl,
454                                      struct GPUBatch *geom,
455                                      Object *ob)
456 {
457   DRW_shgroup_call_object(stl->g_data->shadow_shgrp, geom, ob);
458 }
459
460 void EEVEE_lights_cache_shcaster_material_add(EEVEE_ViewLayerData *sldata,
461                                               EEVEE_PassList *psl,
462                                               struct GPUMaterial *gpumat,
463                                               struct GPUBatch *geom,
464                                               struct Object *ob,
465                                               float *alpha_threshold)
466 {
467   /* TODO / PERF : reuse the same shading group for objects with the same material */
468   DRWShadingGroup *grp = DRW_shgroup_material_create(gpumat, psl->shadow_pass);
469
470   if (grp == NULL) {
471     return;
472   }
473
474   /* Grrr needed for correctness but not 99% of the time not needed.
475    * TODO detect when needed? */
476   DRW_shgroup_uniform_block(grp, "probe_block", sldata->probe_ubo);
477   DRW_shgroup_uniform_block(grp, "grid_block", sldata->grid_ubo);
478   DRW_shgroup_uniform_block(grp, "planar_block", sldata->planar_ubo);
479   DRW_shgroup_uniform_block(grp, "light_block", sldata->light_ubo);
480   DRW_shgroup_uniform_block(grp, "shadow_block", sldata->shadow_ubo);
481   DRW_shgroup_uniform_block(grp, "common_block", sldata->common_ubo);
482
483   if (alpha_threshold != NULL) {
484     DRW_shgroup_uniform_float(grp, "alphaThreshold", alpha_threshold, 1);
485   }
486
487   DRW_shgroup_call_object(grp, geom, ob);
488 }
489
490 /* Make that object update shadow casting lights inside its influence bounding box. */
491 void EEVEE_lights_cache_shcaster_object_add(EEVEE_ViewLayerData *sldata, Object *ob)
492 {
493   if ((ob->base_flag & BASE_FROM_DUPLI) != 0) {
494     /* TODO: Special case for dupli objects because we cannot save the object pointer. */
495     return;
496   }
497
498   EEVEE_ObjectEngineData *oedata = EEVEE_object_data_ensure(ob);
499   EEVEE_LightsInfo *linfo = sldata->lights;
500   EEVEE_ShadowCasterBuffer *backbuffer = linfo->shcaster_backbuffer;
501   EEVEE_ShadowCasterBuffer *frontbuffer = linfo->shcaster_frontbuffer;
502   int past_id = oedata->shadow_caster_id;
503
504   /* Update flags in backbuffer. */
505   if (past_id > -1 && past_id < backbuffer->count) {
506     backbuffer->flags[past_id] &= ~SHADOW_CASTER_PRUNED;
507
508     if (oedata->need_update) {
509       backbuffer->flags[past_id] |= SHADOW_CASTER_UPDATED;
510     }
511   }
512
513   /* Update id. */
514   oedata->shadow_caster_id = frontbuffer->count++;
515
516   /* Make sure shadow_casters is big enough. */
517   if (oedata->shadow_caster_id >= frontbuffer->alloc_count) {
518     frontbuffer->alloc_count += SHADOW_CASTER_ALLOC_CHUNK;
519     frontbuffer->shadow_casters = MEM_reallocN(
520         frontbuffer->shadow_casters, sizeof(EEVEE_ShadowCaster) * frontbuffer->alloc_count);
521     frontbuffer->flags = MEM_reallocN(frontbuffer->flags,
522                                       sizeof(EEVEE_ShadowCaster) * frontbuffer->alloc_count);
523   }
524
525   EEVEE_ShadowCaster *shcaster = frontbuffer->shadow_casters + oedata->shadow_caster_id;
526
527   if (oedata->need_update) {
528     frontbuffer->flags[oedata->shadow_caster_id] = SHADOW_CASTER_UPDATED;
529   }
530
531   /* Update World AABB in frontbuffer. */
532   BoundBox *bb = BKE_object_boundbox_get(ob);
533   float min[3], max[3];
534   INIT_MINMAX(min, max);
535   for (int i = 0; i < 8; ++i) {
536     float vec[3];
537     copy_v3_v3(vec, bb->vec[i]);
538     mul_m4_v3(ob->obmat, vec);
539     minmax_v3v3_v3(min, max, vec);
540   }
541
542   EEVEE_BoundBox *aabb = &shcaster->bbox;
543   add_v3_v3v3(aabb->center, min, max);
544   mul_v3_fl(aabb->center, 0.5f);
545   sub_v3_v3v3(aabb->halfdim, aabb->center, max);
546
547   aabb->halfdim[0] = fabsf(aabb->halfdim[0]);
548   aabb->halfdim[1] = fabsf(aabb->halfdim[1]);
549   aabb->halfdim[2] = fabsf(aabb->halfdim[2]);
550
551   oedata->need_update = false;
552 }
553
554 void EEVEE_lights_cache_finish(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
555 {
556   EEVEE_LightsInfo *linfo = sldata->lights;
557   eGPUTextureFormat shadow_pool_format = GPU_R32F;
558
559   sldata->common_data.la_num_light = linfo->num_light;
560
561   /* Setup enough layers. */
562   /* Free textures if number mismatch. */
563   if (linfo->num_cube_layer != linfo->cache_num_cube_layer) {
564     DRW_TEXTURE_FREE_SAFE(sldata->shadow_cube_pool);
565     linfo->cache_num_cube_layer = linfo->num_cube_layer;
566     linfo->update_flag |= LIGHT_UPDATE_SHADOW_CUBE;
567   }
568
569   if (linfo->num_cascade_layer != linfo->cache_num_cascade_layer) {
570     DRW_TEXTURE_FREE_SAFE(sldata->shadow_cascade_pool);
571     linfo->cache_num_cascade_layer = linfo->num_cascade_layer;
572   }
573
574   switch (linfo->shadow_method) {
575     case SHADOW_ESM:
576       shadow_pool_format = ((linfo->shadow_high_bitdepth) ? GPU_R32F : GPU_R16F);
577       break;
578     case SHADOW_VSM:
579       shadow_pool_format = ((linfo->shadow_high_bitdepth) ? GPU_RG32F : GPU_RG16F);
580       break;
581     default:
582       BLI_assert(!"Incorrect Shadow Method");
583       break;
584   }
585
586   /* Cubemaps */
587   if (!sldata->shadow_cube_target) {
588     sldata->shadow_cube_target = DRW_texture_create_cube(
589         linfo->shadow_cube_size, GPU_DEPTH_COMPONENT24, 0, NULL);
590     sldata->shadow_cube_blur = DRW_texture_create_cube(
591         linfo->shadow_cube_size, shadow_pool_format, DRW_TEX_FILTER, NULL);
592   }
593   if (!sldata->shadow_cube_pool) {
594     sldata->shadow_cube_pool = DRW_texture_create_2d_array(linfo->shadow_cube_store_size,
595                                                            linfo->shadow_cube_store_size,
596                                                            max_ii(1, linfo->num_cube_layer),
597                                                            shadow_pool_format,
598                                                            DRW_TEX_FILTER,
599                                                            NULL);
600   }
601   GPU_framebuffer_ensure_config(&sldata->shadow_cube_target_fb,
602                                 {GPU_ATTACHMENT_TEXTURE(sldata->shadow_cube_target)});
603   GPU_framebuffer_ensure_config(
604       &sldata->shadow_cube_store_fb,
605       {GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(sldata->shadow_cube_pool)});
606
607   /* CSM */
608   if (!sldata->shadow_cascade_target) {
609     sldata->shadow_cascade_target = DRW_texture_create_2d_array(linfo->shadow_cascade_size,
610                                                                 linfo->shadow_cascade_size,
611                                                                 MAX_CASCADE_NUM,
612                                                                 GPU_DEPTH_COMPONENT24,
613                                                                 0,
614                                                                 NULL);
615     sldata->shadow_cascade_blur = DRW_texture_create_2d_array(linfo->shadow_cascade_size,
616                                                               linfo->shadow_cascade_size,
617                                                               MAX_CASCADE_NUM,
618                                                               shadow_pool_format,
619                                                               DRW_TEX_FILTER,
620                                                               NULL);
621   }
622   if (!sldata->shadow_cascade_pool) {
623     sldata->shadow_cascade_pool = DRW_texture_create_2d_array(linfo->shadow_cascade_size,
624                                                               linfo->shadow_cascade_size,
625                                                               max_ii(1, linfo->num_cascade_layer),
626                                                               shadow_pool_format,
627                                                               DRW_TEX_FILTER,
628                                                               NULL);
629   }
630   GPU_framebuffer_ensure_config(&sldata->shadow_cascade_target_fb,
631                                 {GPU_ATTACHMENT_TEXTURE(sldata->shadow_cascade_target)});
632   GPU_framebuffer_ensure_config(
633       &sldata->shadow_cascade_store_fb,
634       {GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(sldata->shadow_cascade_pool)});
635
636   /* Update Lights UBOs. */
637   EEVEE_lights_update(sldata, vedata);
638 }
639
640 float light_attenuation_radius_get(Light *la, float light_threshold)
641 {
642   if (la->mode & LA_CUSTOM_ATTENUATION) {
643     return la->att_dist;
644   }
645
646   /* Compute max light power. */
647   float power = max_fff(la->r, la->g, la->b);
648   power *= fabsf(la->energy / 100.0f);
649   power *= max_ff(1.0f, la->spec_fac);
650   /* Compute the distance (using the inverse square law)
651    * at which the light power reaches the light_threshold. */
652   float distance = sqrtf(max_ff(1e-16, power / max_ff(1e-16, light_threshold)));
653   return distance;
654 }
655
656 static void light_shape_parameters_set(EEVEE_Light *evli, const Light *la, float scale[3])
657 {
658   if (la->type == LA_SPOT) {
659     /* Spot size & blend */
660     evli->sizex = scale[0] / scale[2];
661     evli->sizey = scale[1] / scale[2];
662     evli->spotsize = cosf(la->spotsize * 0.5f);
663     evli->spotblend = (1.0f - evli->spotsize) * la->spotblend;
664     evli->radius = max_ff(0.001f, la->area_size);
665   }
666   else if (la->type == LA_AREA) {
667     evli->sizex = max_ff(0.003f, la->area_size * scale[0] * 0.5f);
668     if (ELEM(la->area_shape, LA_AREA_RECT, LA_AREA_ELLIPSE)) {
669       evli->sizey = max_ff(0.003f, la->area_sizey * scale[1] * 0.5f);
670     }
671     else {
672       evli->sizey = max_ff(0.003f, la->area_size * scale[1] * 0.5f);
673     }
674   }
675   else if (la->type == LA_SUN) {
676     evli->radius = max_ff(0.001f, tanf(la->sun_angle / 2.0f));
677   }
678   else {
679     evli->radius = max_ff(0.001f, la->area_size);
680   }
681 }
682
683 static float light_shape_power_get(const Light *la, const EEVEE_Light *evli)
684 {
685   float power;
686   /* Make illumination power constant */
687   if (la->type == LA_AREA) {
688     power = 1.0f / (evli->sizex * evli->sizey * 4.0f * M_PI) * /* 1/(w*h*Pi) */
689             0.8f; /* XXX : Empirical, Fit cycles power */
690     if (ELEM(la->area_shape, LA_AREA_DISK, LA_AREA_ELLIPSE)) {
691       /* Scale power to account for the lower area of the ellipse compared to the surrounding
692        * rectangle. */
693       power *= 4.0f / M_PI;
694     }
695   }
696   else if (la->type == LA_SPOT || la->type == LA_LOCAL) {
697     power = 1.0f / (4.0f * evli->radius * evli->radius * M_PI * M_PI); /* 1/(4*r²*Pi²) */
698
699     /* for point lights (a.k.a radius == 0.0) */
700     // power = M_PI * M_PI * 0.78; /* XXX : Empirical, Fit cycles power */
701   }
702   else {
703     power = 1.0f / (evli->radius * evli->radius * M_PI); /* 1/(r²*Pi) */
704     /* Make illumation power closer to cycles for bigger radii. Cycles uses a cos^3 term that we
705      * cannot reproduce so we account for that by scaling the light power. This function is the
706      * result of a rough manual fitting. */
707     power += 1.0f / (2.0f * M_PI); /* power *= 1 + r²/2 */
708   }
709   return power;
710 }
711
712 /* Update buffer with light data */
713 static void eevee_light_setup(Object *ob, EEVEE_Light *evli)
714 {
715   Light *la = (Light *)ob->data;
716   float mat[4][4], scale[3], power, att_radius;
717
718   const DRWContextState *draw_ctx = DRW_context_state_get();
719   const float light_threshold = draw_ctx->scene->eevee.light_threshold;
720
721   /* Position */
722   copy_v3_v3(evli->position, ob->obmat[3]);
723
724   /* Color */
725   copy_v3_v3(evli->color, &la->r);
726
727   evli->spec = la->spec_fac;
728
729   /* Influence Radius */
730   att_radius = light_attenuation_radius_get(la, light_threshold);
731   /* Take the inverse square of this distance. */
732   evli->invsqrdist = 1.0 / max_ff(1e-4f, att_radius * att_radius);
733
734   /* Vectors */
735   normalize_m4_m4_ex(mat, ob->obmat, scale);
736   copy_v3_v3(evli->forwardvec, mat[2]);
737   normalize_v3(evli->forwardvec);
738   negate_v3(evli->forwardvec);
739
740   copy_v3_v3(evli->rightvec, mat[0]);
741   normalize_v3(evli->rightvec);
742
743   copy_v3_v3(evli->upvec, mat[1]);
744   normalize_v3(evli->upvec);
745
746   /* Make sure we have a consistent Right Hand coord frame.
747    * (in case of negatively scaled Z axis) */
748   float cross[3];
749   cross_v3_v3v3(cross, evli->rightvec, evli->forwardvec);
750   if (dot_v3v3(cross, evli->upvec) < 0.0) {
751     negate_v3(evli->upvec);
752   }
753
754   light_shape_parameters_set(evli, la, scale);
755
756   /* Light Type */
757   evli->light_type = (float)la->type;
758   if ((la->type == LA_AREA) && ELEM(la->area_shape, LA_AREA_DISK, LA_AREA_ELLIPSE)) {
759     evli->light_type = LAMPTYPE_AREA_ELLIPSE;
760   }
761
762   power = light_shape_power_get(la, evli);
763   mul_v3_fl(evli->color, power * la->energy);
764
765   /* No shadow by default */
766   evli->shadowid = -1.0f;
767 }
768
769 /**
770  * Special ball distribution:
771  * Point are distributed in a way that when they are orthogonaly
772  * projected into any plane, the resulting distribution is (close to)
773  * a uniform disc distribution.
774  */
775 static void sample_ball(int sample_ofs, float radius, float rsample[3])
776 {
777   double ht_point[3];
778   double ht_offset[3] = {0.0, 0.0, 0.0};
779   uint ht_primes[3] = {2, 3, 7};
780
781   BLI_halton_3d(ht_primes, ht_offset, sample_ofs, ht_point);
782
783   float omega = ht_point[1] * 2.0f * M_PI;
784
785   rsample[2] = ht_point[0] * 2.0f - 1.0f; /* cos theta */
786
787   float r = sqrtf(fmaxf(0.0f, 1.0f - rsample[2] * rsample[2])); /* sin theta */
788
789   rsample[0] = r * cosf(omega);
790   rsample[1] = r * sinf(omega);
791
792   radius *= sqrt(sqrt(ht_point[2]));
793   mul_v3_fl(rsample, radius);
794 }
795
796 static void sample_rectangle(
797     int sample_ofs, float x_axis[3], float y_axis[3], float size_x, float size_y, float rsample[3])
798 {
799   double ht_point[2];
800   double ht_offset[2] = {0.0, 0.0};
801   uint ht_primes[2] = {2, 3};
802
803   BLI_halton_2d(ht_primes, ht_offset, sample_ofs, ht_point);
804
805   /* Change ditribution center to be 0,0 */
806   ht_point[0] = (ht_point[0] > 0.5f) ? ht_point[0] - 1.0f : ht_point[0];
807   ht_point[1] = (ht_point[1] > 0.5f) ? ht_point[1] - 1.0f : ht_point[1];
808
809   zero_v3(rsample);
810   madd_v3_v3fl(rsample, x_axis, (ht_point[0] * 2.0f) * size_x);
811   madd_v3_v3fl(rsample, y_axis, (ht_point[1] * 2.0f) * size_y);
812 }
813
814 static void sample_ellipse(
815     int sample_ofs, float x_axis[3], float y_axis[3], float size_x, float size_y, float rsample[3])
816 {
817   double ht_point[2];
818   double ht_offset[2] = {0.0, 0.0};
819   uint ht_primes[2] = {2, 3};
820
821   BLI_halton_2d(ht_primes, ht_offset, sample_ofs, ht_point);
822
823   /* Uniform disc sampling. */
824   float omega = ht_point[1] * 2.0f * M_PI;
825   float r = sqrtf(ht_point[0]);
826   ht_point[0] = r * cosf(omega) * size_x;
827   ht_point[1] = r * sinf(omega) * size_y;
828
829   zero_v3(rsample);
830   madd_v3_v3fl(rsample, x_axis, ht_point[0]);
831   madd_v3_v3fl(rsample, y_axis, ht_point[1]);
832 }
833
834 static void shadow_cube_random_position_set(EEVEE_Light *evli,
835                                             Light *la,
836                                             int sample_ofs,
837                                             float ws_sample_pos[3])
838 {
839   float jitter[3];
840
841 #ifndef DEBUG_SHADOW_DISTRIBUTION
842   int i = sample_ofs;
843 #else
844   for (int i = 0; i <= sample_ofs; ++i) {
845 #endif
846   switch (la->type) {
847     case LA_AREA:
848       if (ELEM(la->area_shape, LA_AREA_RECT, LA_AREA_SQUARE)) {
849         sample_rectangle(i, evli->rightvec, evli->upvec, evli->sizex, evli->sizey, jitter);
850       }
851       else {
852         sample_ellipse(i, evli->rightvec, evli->upvec, evli->sizex, evli->sizey, jitter);
853       }
854       break;
855     default:
856       sample_ball(i, evli->radius, jitter);
857   }
858 #ifdef DEBUG_SHADOW_DISTRIBUTION
859   float p[3];
860   add_v3_v3v3(p, jitter, ws_sample_pos);
861   DRW_debug_sphere(p, 0.01f, (float[4]){1.0f, (sample_ofs == i) ? 1.0f : 0.0f, 0.0f, 1.0f});
862 }
863 #endif
864 add_v3_v3(ws_sample_pos, jitter);
865 }
866
867 static void eevee_shadow_cube_setup(Object *ob,
868                                     EEVEE_LightsInfo *linfo,
869                                     EEVEE_LightEngineData *led,
870                                     int sample_ofs)
871 {
872   EEVEE_ShadowCubeData *sh_data = &led->data.scd;
873   EEVEE_Light *evli = linfo->light_data + sh_data->light_id;
874   EEVEE_Shadow *ubo_data = linfo->shadow_data + sh_data->shadow_id;
875   EEVEE_ShadowCube *cube_data = linfo->shadow_cube_data + sh_data->cube_id;
876   Light *la = (Light *)ob->data;
877
878   copy_v3_v3(cube_data->position, ob->obmat[3]);
879
880   if (linfo->soft_shadows) {
881     shadow_cube_random_position_set(evli, la, sample_ofs, cube_data->position);
882   }
883
884   ubo_data->bias = 0.05f * la->bias;
885   ubo_data->near = la->clipsta;
886   ubo_data->far = 1.0f / (evli->invsqrdist * evli->invsqrdist);
887   ubo_data->exp = (linfo->shadow_method == SHADOW_VSM) ? la->bleedbias : la->bleedexp;
888
889   evli->shadowid = (float)(sh_data->shadow_id);
890   ubo_data->shadow_start = (float)(sh_data->layer_id);
891   ubo_data->data_start = (float)(sh_data->cube_id);
892   ubo_data->shadow_blur = la->soft * 0.02f; /* Used by translucence shadowmap blur */
893
894   ubo_data->contact_dist = (la->mode & LA_SHAD_CONTACT) ? la->contact_dist : 0.0f;
895   ubo_data->contact_bias = 0.05f * la->contact_bias;
896   ubo_data->contact_spread = la->contact_spread;
897   ubo_data->contact_thickness = la->contact_thickness;
898 }
899
900 static void shadow_cascade_random_matrix_set(float mat[4][4], float radius, int sample_ofs)
901 {
902   float jitter[3];
903
904 #ifndef DEBUG_SHADOW_DISTRIBUTION
905   int i = sample_ofs;
906 #else
907     for (int i = 0; i <= sample_ofs; ++i) {
908 #endif
909   sample_ellipse(i, mat[0], mat[1], radius, radius, jitter);
910 #ifdef DEBUG_SHADOW_DISTRIBUTION
911   float p[3];
912   add_v3_v3v3(p, jitter, mat[2]);
913   DRW_debug_sphere(p, 0.01f, (float[4]){1.0f, (sample_ofs == i) ? 1.0f : 0.0f, 0.0f, 1.0f});
914 }
915 #endif
916
917 add_v3_v3(mat[2], jitter);
918 orthogonalize_m4(mat, 2);
919 }
920
921 #define LERP(t, a, b) ((a) + (t) * ((b) - (a)))
922
923 static double round_to_digits(double value, int digits)
924 {
925   double factor = pow(10.0, digits - ceil(log10(fabs(value))));
926   return round(value * factor) / factor;
927 }
928
929 static void frustum_min_bounding_sphere(const float corners[8][3],
930                                         float r_center[3],
931                                         float *r_radius)
932 {
933 #if 0 /* Simple solution but waste too much space. */
934   float minvec[3], maxvec[3];
935
936   /* compute the bounding box */
937   INIT_MINMAX(minvec, maxvec);
938   for (int i = 0; i < 8; ++i) {
939     minmax_v3v3_v3(minvec, maxvec, corners[i]);
940   }
941
942   /* compute the bounding sphere of this box */
943   r_radius = len_v3v3(minvec, maxvec) * 0.5f;
944   add_v3_v3v3(r_center, minvec, maxvec);
945   mul_v3_fl(r_center, 0.5f);
946 #else
947       /* Find averaged center. */
948       zero_v3(r_center);
949       for (int i = 0; i < 8; ++i) {
950         add_v3_v3(r_center, corners[i]);
951       }
952       mul_v3_fl(r_center, 1.0f / 8.0f);
953
954       /* Search the largest distance from the sphere center. */
955       *r_radius = 0.0f;
956       for (int i = 0; i < 8; ++i) {
957         float rad = len_squared_v3v3(corners[i], r_center);
958         if (rad > *r_radius) {
959           *r_radius = rad;
960         }
961       }
962
963       /* TODO try to reduce the radius further by moving the center.
964        * Remember we need a __stable__ solution! */
965
966       /* Try to reduce float imprecision leading to shimmering. */
967       *r_radius = (float)round_to_digits(sqrtf(*r_radius), 3);
968 #endif
969 }
970
971 static void eevee_shadow_cascade_setup(Object *ob,
972                                        EEVEE_LightsInfo *linfo,
973                                        EEVEE_LightEngineData *led,
974                                        DRWMatrixState *saved_mats,
975                                        float view_near,
976                                        float view_far,
977                                        int sample_ofs)
978 {
979   Light *la = (Light *)ob->data;
980
981   /* Camera Matrices */
982   float(*persinv)[4] = saved_mats->mat[DRW_MAT_PERSINV];
983   float(*vp_projmat)[4] = saved_mats->mat[DRW_MAT_WIN];
984   bool is_persp = DRW_viewport_is_persp_get();
985
986   /* Lights Matrices */
987   int cascade_nbr = la->cascade_count;
988
989   EEVEE_ShadowCascadeData *sh_data = &led->data.scad;
990   EEVEE_Light *evli = linfo->light_data + sh_data->light_id;
991   EEVEE_Shadow *ubo_data = linfo->shadow_data + sh_data->shadow_id;
992   EEVEE_ShadowCascade *cascade_data = linfo->shadow_cascade_data + sh_data->cascade_id;
993
994   /* obmat = Object Space > World Space */
995   /* viewmat = World Space > View Space */
996   float(*viewmat)[4] = sh_data->viewmat;
997 #if 0 /* done at culling time */
998   normalize_m4_m4(viewmat, ob->obmat);
999 #endif
1000
1001   if (linfo->soft_shadows) {
1002     shadow_cascade_random_matrix_set(viewmat, evli->radius, sample_ofs);
1003   }
1004
1005   copy_m4_m4(sh_data->viewinv, viewmat);
1006   invert_m4(viewmat);
1007
1008   /* The technique consists into splitting
1009    * the view frustum into several sub-frustum
1010    * that are individually receiving one shadow map */
1011
1012   float csm_start, csm_end;
1013
1014   if (is_persp) {
1015     csm_start = view_near;
1016     csm_end = max_ff(view_far, -la->cascade_max_dist);
1017     /* Avoid artifacts */
1018     csm_end = min_ff(view_near, csm_end);
1019   }
1020   else {
1021     csm_start = -view_far;
1022     csm_end = view_far;
1023   }
1024
1025   /* init near/far */
1026   for (int c = 0; c < MAX_CASCADE_NUM; ++c) {
1027     cascade_data->split_start[c] = csm_end;
1028     cascade_data->split_end[c] = csm_end;
1029   }
1030
1031   /* Compute split planes */
1032   float splits_start_ndc[MAX_CASCADE_NUM];
1033   float splits_end_ndc[MAX_CASCADE_NUM];
1034
1035   {
1036     /* Nearest plane */
1037     float p[4] = {1.0f, 1.0f, csm_start, 1.0f};
1038     /* TODO: we don't need full m4 multiply here */
1039     mul_m4_v4(vp_projmat, p);
1040     splits_start_ndc[0] = p[2];
1041     if (is_persp) {
1042       splits_start_ndc[0] /= p[3];
1043     }
1044   }
1045
1046   {
1047     /* Farthest plane */
1048     float p[4] = {1.0f, 1.0f, csm_end, 1.0f};
1049     /* TODO: we don't need full m4 multiply here */
1050     mul_m4_v4(vp_projmat, p);
1051     splits_end_ndc[cascade_nbr - 1] = p[2];
1052     if (is_persp) {
1053       splits_end_ndc[cascade_nbr - 1] /= p[3];
1054     }
1055   }
1056
1057   cascade_data->split_start[0] = csm_start;
1058   cascade_data->split_end[cascade_nbr - 1] = csm_end;
1059
1060   for (int c = 1; c < cascade_nbr; ++c) {
1061     /* View Space */
1062     float linear_split = LERP(((float)(c) / (float)cascade_nbr), csm_start, csm_end);
1063     float exp_split = csm_start * powf(csm_end / csm_start, (float)(c) / (float)cascade_nbr);
1064
1065     if (is_persp) {
1066       cascade_data->split_start[c] = LERP(la->cascade_exponent, linear_split, exp_split);
1067     }
1068     else {
1069       cascade_data->split_start[c] = linear_split;
1070     }
1071     cascade_data->split_end[c - 1] = cascade_data->split_start[c];
1072
1073     /* Add some overlap for smooth transition */
1074     cascade_data->split_start[c] = LERP(la->cascade_fade,
1075                                         cascade_data->split_end[c - 1],
1076                                         (c > 1) ? cascade_data->split_end[c - 2] :
1077                                                   cascade_data->split_start[0]);
1078
1079     /* NDC Space */
1080     {
1081       float p[4] = {1.0f, 1.0f, cascade_data->split_start[c], 1.0f};
1082       /* TODO: we don't need full m4 multiply here */
1083       mul_m4_v4(vp_projmat, p);
1084       splits_start_ndc[c] = p[2];
1085
1086       if (is_persp) {
1087         splits_start_ndc[c] /= p[3];
1088       }
1089     }
1090
1091     {
1092       float p[4] = {1.0f, 1.0f, cascade_data->split_end[c - 1], 1.0f};
1093       /* TODO: we don't need full m4 multiply here */
1094       mul_m4_v4(vp_projmat, p);
1095       splits_end_ndc[c - 1] = p[2];
1096
1097       if (is_persp) {
1098         splits_end_ndc[c - 1] /= p[3];
1099       }
1100     }
1101   }
1102
1103   /* Set last cascade split fade distance into the first split_start. */
1104   float prev_split = (cascade_nbr > 1) ? cascade_data->split_end[cascade_nbr - 2] :
1105                                          cascade_data->split_start[0];
1106   cascade_data->split_start[0] = LERP(
1107       la->cascade_fade, cascade_data->split_end[cascade_nbr - 1], prev_split);
1108
1109   /* For each cascade */
1110   for (int c = 0; c < cascade_nbr; ++c) {
1111     float(*projmat)[4] = sh_data->projmat[c];
1112     /* Given 8 frustum corners */
1113     float corners[8][3] = {
1114         /* Near Cap */
1115         {1.0f, -1.0f, splits_start_ndc[c]},
1116         {-1.0f, -1.0f, splits_start_ndc[c]},
1117         {-1.0f, 1.0f, splits_start_ndc[c]},
1118         {1.0f, 1.0f, splits_start_ndc[c]},
1119         /* Far Cap */
1120         {1.0f, -1.0f, splits_end_ndc[c]},
1121         {-1.0f, -1.0f, splits_end_ndc[c]},
1122         {-1.0f, 1.0f, splits_end_ndc[c]},
1123         {1.0f, 1.0f, splits_end_ndc[c]},
1124     };
1125
1126     /* Transform them into world space */
1127     for (int i = 0; i < 8; ++i) {
1128       mul_project_m4_v3(persinv, corners[i]);
1129     }
1130
1131     float center[3];
1132     frustum_min_bounding_sphere(corners, center, &(sh_data->radius[c]));
1133
1134 #ifdef DEBUG_CSM
1135     float dbg_col[4] = {0.0f, 0.0f, 0.0f, 1.0f};
1136     if (c < 3) {
1137       dbg_col[c] = 1.0f;
1138     }
1139     DRW_debug_bbox((BoundBox *)&corners, dbg_col);
1140     DRW_debug_sphere(center, sh_data->radius[c], dbg_col);
1141 #endif
1142
1143     /* Project into lightspace */
1144     mul_m4_v3(viewmat, center);
1145
1146     /* Snap projection center to nearest texel to cancel shimmering. */
1147     float shadow_origin[2], shadow_texco[2];
1148     /* Light to texture space. */
1149     mul_v2_v2fl(shadow_origin, center, linfo->shadow_cascade_size / (2.0f * sh_data->radius[c]));
1150
1151     /* Find the nearest texel. */
1152     shadow_texco[0] = roundf(shadow_origin[0]);
1153     shadow_texco[1] = roundf(shadow_origin[1]);
1154
1155     /* Compute offset. */
1156     sub_v2_v2(shadow_texco, shadow_origin);
1157     mul_v2_fl(shadow_texco,
1158               (2.0f * sh_data->radius[c]) /
1159                   linfo->shadow_cascade_size); /* Texture to light space. */
1160
1161     /* Apply offset. */
1162     add_v2_v2(center, shadow_texco);
1163
1164     /* Expand the projection to cover frustum range */
1165     rctf rect_cascade;
1166     BLI_rctf_init_pt_radius(&rect_cascade, center, sh_data->radius[c]);
1167     orthographic_m4(projmat,
1168                     rect_cascade.xmin,
1169                     rect_cascade.xmax,
1170                     rect_cascade.ymin,
1171                     rect_cascade.ymax,
1172                     la->clipsta,
1173                     la->clipend);
1174
1175     mul_m4_m4m4(sh_data->viewprojmat[c], projmat, viewmat);
1176     mul_m4_m4m4(cascade_data->shadowmat[c], texcomat, sh_data->viewprojmat[c]);
1177
1178 #ifdef DEBUG_CSM
1179     DRW_debug_m4_as_bbox(sh_data->viewprojmat[c], dbg_col, true);
1180 #endif
1181   }
1182
1183   ubo_data->bias = 0.05f * la->bias;
1184   ubo_data->near = la->clipsta;
1185   ubo_data->far = la->clipend;
1186   ubo_data->exp = (linfo->shadow_method == SHADOW_VSM) ? la->bleedbias : la->bleedexp;
1187
1188   evli->shadowid = (float)(sh_data->shadow_id);
1189   ubo_data->shadow_start = (float)(sh_data->layer_id);
1190   ubo_data->data_start = (float)(sh_data->cascade_id);
1191   ubo_data->shadow_blur = la->soft * 0.02f; /* Used by translucence shadowmap blur */
1192
1193   ubo_data->contact_dist = (la->mode & LA_SHAD_CONTACT) ? la->contact_dist : 0.0f;
1194   ubo_data->contact_bias = 0.05f * la->contact_bias;
1195   ubo_data->contact_spread = la->contact_spread;
1196   ubo_data->contact_thickness = la->contact_thickness;
1197 }
1198
1199 /* Used for checking if object is inside the shadow volume. */
1200 static bool sphere_bbox_intersect(const EEVEE_BoundSphere *bs, const EEVEE_BoundBox *bb)
1201 {
1202   /* We are testing using a rougher AABB vs AABB test instead of full AABB vs Sphere. */
1203   /* TODO test speed with AABB vs Sphere. */
1204   bool x = fabsf(bb->center[0] - bs->center[0]) <= (bb->halfdim[0] + bs->radius);
1205   bool y = fabsf(bb->center[1] - bs->center[1]) <= (bb->halfdim[1] + bs->radius);
1206   bool z = fabsf(bb->center[2] - bs->center[2]) <= (bb->halfdim[2] + bs->radius);
1207
1208   return x && y && z;
1209 }
1210
1211 void EEVEE_lights_update(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
1212 {
1213   EEVEE_StorageList *stl = vedata->stl;
1214   EEVEE_EffectsInfo *effects = stl->effects;
1215   EEVEE_LightsInfo *linfo = sldata->lights;
1216   Object *ob;
1217   int i;
1218   char *flag;
1219   EEVEE_ShadowCaster *shcaster;
1220   EEVEE_BoundSphere *bsphere;
1221   EEVEE_ShadowCasterBuffer *frontbuffer = linfo->shcaster_frontbuffer;
1222   EEVEE_ShadowCasterBuffer *backbuffer = linfo->shcaster_backbuffer;
1223
1224   EEVEE_LightBits update_bits = {{0}};
1225   if ((linfo->update_flag & LIGHT_UPDATE_SHADOW_CUBE) != 0) {
1226     /* Update all lights. */
1227     lightbits_set_all(&update_bits, true);
1228   }
1229   else {
1230     /* Search for deleted shadow casters and if shcaster WAS in shadow radius. */
1231     /* No need to run this if we already update all lights. */
1232     EEVEE_LightBits past_bits = {{0}};
1233     EEVEE_LightBits curr_bits = {{0}};
1234     shcaster = backbuffer->shadow_casters;
1235     flag = backbuffer->flags;
1236     for (i = 0; i < backbuffer->count; ++i, ++flag, ++shcaster) {
1237       /* If the shadowcaster has been deleted or updated. */
1238       if (*flag != 0) {
1239         /* Add the lights that were intersecting with its BBox. */
1240         lightbits_or(&past_bits, &shcaster->bits);
1241       }
1242     }
1243     /* Convert old bits to new bits and add result to final update bits. */
1244     /* NOTE: This might be overkill since all lights are tagged to refresh if
1245      * the light count changes. */
1246     lightbits_convert(&curr_bits, &past_bits, linfo->new_shadow_id, MAX_LIGHT);
1247     lightbits_or(&update_bits, &curr_bits);
1248   }
1249
1250   /* Search for updates in current shadow casters. */
1251   shcaster = frontbuffer->shadow_casters;
1252   flag = frontbuffer->flags;
1253   for (i = 0; i < frontbuffer->count; i++, flag++, shcaster++) {
1254     /* Run intersection checks to fill the bitfields. */
1255     bsphere = linfo->shadow_bounds;
1256     for (int j = 0; j < linfo->cpu_cube_len; j++, bsphere++) {
1257       bool iter = sphere_bbox_intersect(bsphere, &shcaster->bbox);
1258       lightbits_set_single(&shcaster->bits, j, iter);
1259     }
1260     /* Only add to final bits if objects has been updated. */
1261     if (*flag != 0) {
1262       lightbits_or(&update_bits, &shcaster->bits);
1263     }
1264   }
1265
1266   /* Setup shadow cube in UBO and tag for update if necessary. */
1267   for (i = 0; (i < MAX_SHADOW_CUBE) && (ob = linfo->shadow_cube_ref[i]); i++) {
1268     EEVEE_LightEngineData *led = EEVEE_light_data_ensure(ob);
1269
1270     eevee_shadow_cube_setup(ob, linfo, led, effects->taa_current_sample - 1);
1271     if (lightbits_get(&update_bits, i) != 0 || linfo->soft_shadows) {
1272       led->need_update = true;
1273     }
1274   }
1275
1276   /* Resize shcasters buffers if too big. */
1277   if (frontbuffer->alloc_count - frontbuffer->count > SHADOW_CASTER_ALLOC_CHUNK) {
1278     frontbuffer->alloc_count = (frontbuffer->count / SHADOW_CASTER_ALLOC_CHUNK) *
1279                                SHADOW_CASTER_ALLOC_CHUNK;
1280     frontbuffer->alloc_count += (frontbuffer->count % SHADOW_CASTER_ALLOC_CHUNK != 0) ?
1281                                     SHADOW_CASTER_ALLOC_CHUNK :
1282                                     0;
1283     frontbuffer->shadow_casters = MEM_reallocN(
1284         frontbuffer->shadow_casters, sizeof(EEVEE_ShadowCaster) * frontbuffer->alloc_count);
1285     frontbuffer->flags = MEM_reallocN(frontbuffer->flags,
1286                                       sizeof(EEVEE_ShadowCaster) * frontbuffer->alloc_count);
1287   }
1288 }
1289
1290 /* this refresh lights shadow buffers */
1291 void EEVEE_draw_shadows(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
1292 {
1293   EEVEE_PassList *psl = vedata->psl;
1294   EEVEE_StorageList *stl = vedata->stl;
1295   EEVEE_EffectsInfo *effects = stl->effects;
1296   EEVEE_LightsInfo *linfo = sldata->lights;
1297   const DRWContextState *draw_ctx = DRW_context_state_get();
1298   const float light_threshold = draw_ctx->scene->eevee.light_threshold;
1299   Object *ob;
1300   int i;
1301
1302   DRWMatrixState saved_mats;
1303   int saved_ray_type = sldata->common_data.ray_type;
1304
1305   /* TODO: make it optionnal if we don't draw shadows. */
1306   sldata->common_data.ray_type = EEVEE_RAY_SHADOW;
1307   DRW_uniformbuffer_update(sldata->common_ubo, &sldata->common_data);
1308
1309   /* Precompute all shadow/view test before rendering and trashing the culling cache. */
1310   bool cube_visible[MAX_SHADOW_CUBE];
1311   for (i = 0; (ob = linfo->shadow_cube_ref[i]) && (i < MAX_SHADOW_CUBE); i++) {
1312     Light *la = (Light *)ob->data;
1313     BoundSphere bsphere = {
1314         .center = {ob->obmat[3][0], ob->obmat[3][1], ob->obmat[3][2]},
1315         .radius = light_attenuation_radius_get(la, light_threshold),
1316     };
1317     cube_visible[i] = DRW_culling_sphere_test(&bsphere);
1318   }
1319   bool cascade_visible[MAX_SHADOW_CASCADE];
1320   for (i = 0; (ob = linfo->shadow_cascade_ref[i]) && (i < MAX_SHADOW_CASCADE); i++) {
1321     EEVEE_LightEngineData *led = EEVEE_light_data_get(ob);
1322     EEVEE_ShadowCascadeData *sh_data = &led->data.scad;
1323     float plane[4];
1324     normalize_m4_m4(sh_data->viewmat, ob->obmat);
1325
1326     plane_from_point_normal_v3(plane, sh_data->viewmat[3], sh_data->viewmat[2]);
1327     /* TODO: check against near/far instead of "local Z = 0" plane.
1328      * Or even the cascades AABB. */
1329     cascade_visible[i] = DRW_culling_plane_test(plane);
1330   }
1331
1332   /* We need to save the Matrices before overidding them */
1333   DRW_viewport_matrix_get_all(&saved_mats);
1334
1335   /* Cube Shadow Maps */
1336   DRW_stats_group_start("Cube Shadow Maps");
1337   /* Render each shadow to one layer of the array */
1338   for (i = 0; (ob = linfo->shadow_cube_ref[i]) && (i < MAX_SHADOW_CUBE); i++) {
1339     EEVEE_LightEngineData *led = EEVEE_light_data_ensure(ob);
1340     Light *la = (Light *)ob->data;
1341
1342     if (!led->need_update || !cube_visible[i]) {
1343       continue;
1344     }
1345
1346     DRWMatrixState render_mats;
1347     float(*winmat)[4] = render_mats.mat[DRW_MAT_WIN];
1348     float(*viewmat)[4] = render_mats.mat[DRW_MAT_VIEW];
1349     float(*persmat)[4] = render_mats.mat[DRW_MAT_PERS];
1350
1351     EEVEE_ShadowRender *srd = &linfo->shadow_render_data;
1352     EEVEE_ShadowCubeData *evscd = &led->data.scd;
1353     EEVEE_ShadowCube *cube_data = linfo->shadow_cube_data + evscd->cube_id;
1354
1355     srd->clip_near = la->clipsta;
1356     srd->clip_far = light_attenuation_radius_get(la, light_threshold);
1357     srd->stored_texel_size = 1.0 / (float)linfo->shadow_cube_store_size;
1358     srd->exponent = la->bleedexp;
1359     copy_v3_v3(srd->position, cube_data->position);
1360
1361     perspective_m4(winmat,
1362                    -srd->clip_near,
1363                    srd->clip_near,
1364                    -srd->clip_near,
1365                    srd->clip_near,
1366                    srd->clip_near,
1367                    srd->clip_far);
1368
1369     DRW_uniformbuffer_update(sldata->shadow_render_ubo, srd);
1370
1371     /* Render shadow cube */
1372     /* Render 6 faces separately: seems to be faster for the general case.
1373      * The only time it's more beneficial is when the CPU culling overhead
1374      * outweigh the instancing overhead. which is rarely the case. */
1375     for (int j = 0; j < 6; j++) {
1376       /* TODO optimize */
1377       float tmp[4][4];
1378       unit_m4(tmp);
1379       negate_v3_v3(tmp[3], srd->position);
1380       mul_m4_m4m4(viewmat, cubefacemat[j], tmp);
1381       mul_m4_m4m4(persmat, winmat, viewmat);
1382       invert_m4_m4(render_mats.mat[DRW_MAT_WININV], winmat);
1383       invert_m4_m4(render_mats.mat[DRW_MAT_VIEWINV], viewmat);
1384       invert_m4_m4(render_mats.mat[DRW_MAT_PERSINV], persmat);
1385
1386       DRW_viewport_matrix_override_set_all(&render_mats);
1387
1388       GPU_framebuffer_texture_cubeface_attach(
1389           sldata->shadow_cube_target_fb, sldata->shadow_cube_target, 0, j, 0);
1390       GPU_framebuffer_bind(sldata->shadow_cube_target_fb);
1391       GPU_framebuffer_clear_depth(sldata->shadow_cube_target_fb, 1.0f);
1392       DRW_draw_pass(psl->shadow_pass);
1393     }
1394
1395     /* 0.001f is arbitrary, but it should be relatively small so that filter size is not too big.
1396      */
1397     float filter_texture_size = la->soft * 0.001f;
1398     float filter_pixel_size = ceil(filter_texture_size / srd->cube_texel_size);
1399     linfo->filter_size = srd->cube_texel_size * ((filter_pixel_size > 1.0f) ? 1.5f : 0.0f);
1400
1401     /* TODO: OPTI: Filter all faces in one/two draw call */
1402     /* TODO: OPTI: Don't do this intermediate step if no filter is needed. */
1403     for (linfo->current_shadow_face = 0; linfo->current_shadow_face < 6;
1404          linfo->current_shadow_face++) {
1405       /* Copy using a small 3x3 box filter */
1406       GPU_framebuffer_texture_cubeface_attach(sldata->shadow_cube_store_fb,
1407                                               sldata->shadow_cube_blur,
1408                                               0,
1409                                               linfo->current_shadow_face,
1410                                               0);
1411       GPU_framebuffer_bind(sldata->shadow_cube_store_fb);
1412       DRW_draw_pass(psl->shadow_cube_copy_pass);
1413     }
1414
1415     /* Push it to shadowmap array */
1416
1417     /* Adjust constants if concentric samples change. */
1418     const float max_filter_size = 7.5f;
1419     const float magic = 4.5f; /* Dunno why but that works. */
1420     const int max_sample = 256;
1421
1422     if (filter_pixel_size > 2.0f) {
1423       linfo->filter_size = srd->cube_texel_size * max_filter_size * magic;
1424       filter_pixel_size = max_ff(0.0f, filter_pixel_size - 3.0f);
1425       /* Compute number of concentric samples. Depends directly on filter size. */
1426       float pix_size_sqr = filter_pixel_size * filter_pixel_size;
1427       srd->shadow_samples_len = min_ii(max_sample,
1428                                        4 + 8 * (int)filter_pixel_size + 4 * (int)(pix_size_sqr));
1429     }
1430     else {
1431       linfo->filter_size = 0.0f;
1432       srd->shadow_samples_len = 4;
1433     }
1434     srd->shadow_samples_len_inv = 1.0f / (float)srd->shadow_samples_len;
1435     DRW_uniformbuffer_update(sldata->shadow_render_ubo, srd);
1436
1437     GPU_framebuffer_texture_layer_attach(
1438         sldata->shadow_cube_store_fb, sldata->shadow_cube_pool, 0, evscd->layer_id, 0);
1439     GPU_framebuffer_bind(sldata->shadow_cube_store_fb);
1440
1441     DRWPass *store_pass = eevee_lights_cube_store_pass_get(
1442         psl, sldata, linfo->shadow_method, srd->shadow_samples_len);
1443     DRW_draw_pass(store_pass);
1444
1445     if (linfo->soft_shadows == false) {
1446       led->need_update = false;
1447     }
1448   }
1449   linfo->update_flag &= ~LIGHT_UPDATE_SHADOW_CUBE;
1450   DRW_stats_group_end();
1451
1452   DRW_viewport_matrix_override_set_all(&saved_mats);
1453   float near = DRW_viewport_near_distance_get();
1454   float far = DRW_viewport_far_distance_get();
1455
1456   /* Cascaded Shadow Maps */
1457   DRW_stats_group_start("Cascaded Shadow Maps");
1458   for (i = 0; (ob = linfo->shadow_cascade_ref[i]) && (i < MAX_SHADOW_CASCADE); i++) {
1459     if (!cascade_visible[i]) {
1460       continue;
1461     }
1462
1463     EEVEE_LightEngineData *led = EEVEE_light_data_ensure(ob);
1464     Light *la = (Light *)ob->data;
1465
1466     EEVEE_ShadowCascadeData *evscd = &led->data.scad;
1467     EEVEE_ShadowRender *srd = &linfo->shadow_render_data;
1468
1469     DRWMatrixState render_mats;
1470     float(*winmat)[4] = render_mats.mat[DRW_MAT_WIN];
1471     float(*viewmat)[4] = render_mats.mat[DRW_MAT_VIEW];
1472     float(*persmat)[4] = render_mats.mat[DRW_MAT_PERS];
1473
1474     eevee_shadow_cascade_setup(
1475         ob, linfo, led, &saved_mats, near, far, effects->taa_current_sample - 1);
1476
1477     srd->clip_near = la->clipsta;
1478     srd->clip_far = la->clipend;
1479     srd->stored_texel_size = 1.0 / (float)linfo->shadow_cascade_size;
1480
1481     DRW_uniformbuffer_update(sldata->shadow_render_ubo, &linfo->shadow_render_data);
1482
1483     copy_m4_m4(viewmat, evscd->viewmat);
1484     invert_m4_m4(render_mats.mat[DRW_MAT_VIEWINV], viewmat);
1485
1486     /* Render shadow cascades */
1487     /* Render cascade separately: seems to be faster for the general case.
1488      * The only time it's more beneficial is when the CPU culling overhead
1489      * outweigh the instancing overhead. which is rarely the case. */
1490     for (int j = 0; j < la->cascade_count; j++) {
1491       copy_m4_m4(winmat, evscd->projmat[j]);
1492       copy_m4_m4(persmat, evscd->viewprojmat[j]);
1493       invert_m4_m4(render_mats.mat[DRW_MAT_WININV], winmat);
1494       invert_m4_m4(render_mats.mat[DRW_MAT_PERSINV], persmat);
1495
1496       DRW_viewport_matrix_override_set_all(&render_mats);
1497
1498       GPU_framebuffer_texture_layer_attach(
1499           sldata->shadow_cascade_target_fb, sldata->shadow_cascade_target, 0, j, 0);
1500       GPU_framebuffer_bind(sldata->shadow_cascade_target_fb);
1501       GPU_framebuffer_clear_depth(sldata->shadow_cascade_target_fb, 1.0f);
1502       DRW_draw_pass(psl->shadow_pass);
1503     }
1504
1505     /* TODO: OPTI: Filter all cascade in one/two draw call */
1506     for (linfo->current_shadow_cascade = 0; linfo->current_shadow_cascade < la->cascade_count;
1507          ++linfo->current_shadow_cascade) {
1508       /* 0.01f factor to convert to percentage */
1509       float filter_texture_size = la->soft * 0.01f / evscd->radius[linfo->current_shadow_cascade];
1510       float filter_pixel_size = ceil(linfo->shadow_cascade_size * filter_texture_size);
1511
1512       /* Copy using a small 3x3 box filter */
1513       /* NOTE: We always do it in the case of CSM because of artifacts in the farthest cascade. */
1514       linfo->filter_size = srd->stored_texel_size;
1515       GPU_framebuffer_texture_layer_attach(sldata->shadow_cascade_store_fb,
1516                                            sldata->shadow_cascade_blur,
1517                                            0,
1518                                            linfo->current_shadow_cascade,
1519                                            0);
1520       GPU_framebuffer_bind(sldata->shadow_cascade_store_fb);
1521       DRW_draw_pass(psl->shadow_cascade_copy_pass);
1522
1523       /* Push it to shadowmap array and blur more */
1524
1525       /* Adjust constants if concentric samples change. */
1526       const float max_filter_size = 7.5f;
1527       const float magic = 3.2f; /* Arbitrary: less banding */
1528       const int max_sample = 256;
1529
1530       if (filter_pixel_size > 2.0f) {
1531         linfo->filter_size = srd->stored_texel_size * max_filter_size * magic;
1532         filter_pixel_size = max_ff(0.0f, filter_pixel_size - 3.0f);
1533         /* Compute number of concentric samples. Depends directly on filter size. */
1534         float pix_size_sqr = filter_pixel_size * filter_pixel_size;
1535         srd->shadow_samples_len = min_ii(max_sample,
1536                                          4 + 8 * (int)filter_pixel_size + 4 * (int)(pix_size_sqr));
1537       }
1538       else {
1539         linfo->filter_size = 0.0f;
1540         srd->shadow_samples_len = 4;
1541       }
1542       srd->shadow_samples_len_inv = 1.0f / (float)srd->shadow_samples_len;
1543       DRW_uniformbuffer_update(sldata->shadow_render_ubo, &linfo->shadow_render_data);
1544
1545       int layer = evscd->layer_id + linfo->current_shadow_cascade;
1546       GPU_framebuffer_texture_layer_attach(
1547           sldata->shadow_cascade_store_fb, sldata->shadow_cascade_pool, 0, layer, 0);
1548       GPU_framebuffer_bind(sldata->shadow_cascade_store_fb);
1549
1550       DRWPass *store_pass = eevee_lights_cascade_store_pass_get(
1551           psl, sldata, linfo->shadow_method, srd->shadow_samples_len);
1552       DRW_draw_pass(store_pass);
1553     }
1554   }
1555
1556   DRW_stats_group_end();
1557
1558   DRW_viewport_matrix_override_set_all(&saved_mats);
1559
1560   DRW_uniformbuffer_update(sldata->light_ubo, &linfo->light_data);
1561   DRW_uniformbuffer_update(sldata->shadow_ubo, &linfo->shadow_data); /* Update all data at once */
1562
1563   sldata->common_data.ray_type = saved_ray_type;
1564   DRW_uniformbuffer_update(sldata->common_ubo, &sldata->common_data);
1565 }
1566
1567 void EEVEE_lights_free(void)
1568 {
1569   DRW_SHADER_FREE_SAFE(e_data.shadow_sh);
1570   for (int i = 0; i < SHADOW_METHOD_MAX; ++i) {
1571     DRW_SHADER_FREE_SAFE(e_data.shadow_store_cube_sh[i]);
1572     DRW_SHADER_FREE_SAFE(e_data.shadow_store_cube_high_sh[i]);
1573     DRW_SHADER_FREE_SAFE(e_data.shadow_store_cascade_sh[i]);
1574     DRW_SHADER_FREE_SAFE(e_data.shadow_store_cascade_high_sh[i]);
1575     DRW_SHADER_FREE_SAFE(e_data.shadow_copy_cube_sh[i]);
1576     DRW_SHADER_FREE_SAFE(e_data.shadow_copy_cascade_sh[i]);
1577   }
1578 }