Blender  V3.3
eevee_shaders.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2016 Blender Foundation. */
3 
8 #include "DRW_render.h"
9 
10 #include "BKE_lib_id.h"
11 #include "BKE_node.h"
12 
13 #include "BLI_dynstr.h"
14 #include "BLI_string_utils.h"
15 
16 #include "DNA_world_types.h"
17 
18 #include "MEM_guardedalloc.h"
19 
20 #include "GPU_capabilities.h"
21 #include "GPU_material.h"
22 #include "GPU_shader.h"
23 
24 #include "NOD_shader.h"
25 
26 #include "eevee_engine.h"
27 #include "eevee_private.h"
28 
29 static const char *filter_defines =
30 #if defined(IRRADIANCE_SH_L2)
31  "#define IRRADIANCE_SH_L2\n";
32 #elif defined(IRRADIANCE_HL2)
33  "#define IRRADIANCE_HL2\n";
34 #endif
35 
36 static struct {
37  /* Lookdev */
40 
41  /* Probes */
50 
51  /* Velocity Resolve */
53 
54  /* Temporal Anti Aliasing */
57 
58  /* Bloom */
63 
64  /* Depth Of Field */
73  struct GPUShader *dof_scatter_sh[2][2];
74  struct GPUShader *dof_resolve_sh[2][2];
75 
76  /* General purpose Shaders. */
79 
80  /* Down-sample Depth */
90 
91  /* Simple Down-sample. */
95 
96  /* Mist */
97  struct GPUShader *mist_sh;
98 
99  /* Motion Blur */
105 
106  /* Ground Truth Ambient Occlusion */
110 
111  /* GGX LUT */
114 
115  /* Render Passes */
118 
119  /* Screen Space Reflection */
122 
123  /* Shadows */
126 
127  /* Subsurface */
128  struct GPUShader *sss_sh[3];
129 
130  /* Volume */
137 
138  /* Shader strings */
142 
144 
145  /* LookDev Materials */
148 
150 
152 
153  /* Default Material */
154  struct {
161 
162  struct {
163  bNodeTree *ntree;
165  } world;
166 } e_data = {NULL}; /* Engine data */
167 
168 extern char datatoc_common_hair_lib_glsl[];
169 extern char datatoc_common_math_lib_glsl[];
171 extern char datatoc_common_view_lib_glsl[];
173 
175 extern char datatoc_background_vert_glsl[];
176 extern char datatoc_bsdf_common_lib_glsl[];
177 extern char datatoc_bsdf_lut_frag_glsl[];
178 extern char datatoc_bsdf_sampling_lib_glsl[];
179 extern char datatoc_btdf_lut_frag_glsl[];
180 extern char datatoc_closure_type_lib_glsl[];
183 extern char datatoc_common_utiltex_lib_glsl[];
184 extern char datatoc_cryptomatte_lib_glsl[];
185 extern char datatoc_cryptomatte_frag_glsl[];
186 extern char datatoc_cryptomatte_vert_glsl[];
187 extern char datatoc_cubemap_lib_glsl[];
188 extern char datatoc_default_frag_glsl[];
189 extern char datatoc_lookdev_world_frag_glsl[];
190 extern char datatoc_effect_bloom_frag_glsl[];
197 extern char datatoc_effect_dof_lib_glsl[];
205 extern char datatoc_effect_gtao_frag_glsl[];
207 extern char datatoc_effect_mist_frag_glsl[];
213 extern char datatoc_effect_temporal_aa_glsl[];
217 extern char datatoc_irradiance_lib_glsl[];
223 extern char datatoc_lightprobe_geom_glsl[];
227 extern char datatoc_lightprobe_lib_glsl[];
233 extern char datatoc_lightprobe_vert_glsl[];
234 extern char datatoc_lights_lib_glsl[];
235 extern char datatoc_closure_eval_lib_glsl[];
241 extern char datatoc_ltc_lib_glsl[];
242 extern char datatoc_object_motion_frag_glsl[];
243 extern char datatoc_object_motion_vert_glsl[];
244 extern char datatoc_octahedron_lib_glsl[];
245 extern char datatoc_prepass_frag_glsl[];
246 extern char datatoc_random_lib_glsl[];
247 extern char datatoc_raytrace_lib_glsl[];
248 extern char datatoc_renderpass_lib_glsl[];
250 extern char datatoc_shadow_accum_frag_glsl[];
251 extern char datatoc_shadow_frag_glsl[];
252 extern char datatoc_shadow_vert_glsl[];
253 extern char datatoc_ssr_lib_glsl[];
254 extern char datatoc_surface_frag_glsl[];
255 extern char datatoc_surface_geom_glsl[];
256 extern char datatoc_surface_lib_glsl[];
257 extern char datatoc_surface_vert_glsl[];
258 extern char datatoc_update_noise_frag_glsl[];
260 extern char datatoc_volumetric_frag_glsl[];
261 extern char datatoc_volumetric_geom_glsl[];
263 extern char datatoc_volumetric_lib_glsl[];
266 extern char datatoc_volumetric_vert_glsl[];
267 extern char datatoc_world_vert_glsl[];
268 
269 /* *********** FUNCTIONS *********** */
270 
272 {
273  if (e_data.lib == NULL) {
275  /* NOTE: These need to be ordered by dependencies. */
276  DRW_SHADER_LIB_ADD(e_data.lib, common_math_lib);
277  DRW_SHADER_LIB_ADD(e_data.lib, common_math_geom_lib);
278  DRW_SHADER_LIB_ADD(e_data.lib, common_hair_lib);
279  DRW_SHADER_LIB_ADD(e_data.lib, common_view_lib);
280  DRW_SHADER_LIB_ADD(e_data.lib, common_uniforms_lib);
281  DRW_SHADER_LIB_ADD(e_data.lib, gpu_shader_codegen_lib);
282  DRW_SHADER_LIB_ADD(e_data.lib, random_lib);
283  DRW_SHADER_LIB_ADD(e_data.lib, renderpass_lib);
284  DRW_SHADER_LIB_ADD(e_data.lib, bsdf_common_lib);
285  DRW_SHADER_LIB_ADD(e_data.lib, common_utiltex_lib);
286  DRW_SHADER_LIB_ADD(e_data.lib, bsdf_sampling_lib);
287  DRW_SHADER_LIB_ADD(e_data.lib, cubemap_lib);
288  DRW_SHADER_LIB_ADD(e_data.lib, raytrace_lib);
289  DRW_SHADER_LIB_ADD(e_data.lib, ambient_occlusion_lib);
290  DRW_SHADER_LIB_ADD(e_data.lib, octahedron_lib);
291  DRW_SHADER_LIB_ADD(e_data.lib, irradiance_lib);
292  DRW_SHADER_LIB_ADD(e_data.lib, lightprobe_lib);
293  DRW_SHADER_LIB_ADD(e_data.lib, ltc_lib);
294  DRW_SHADER_LIB_ADD(e_data.lib, lights_lib);
295  DRW_SHADER_LIB_ADD(e_data.lib, surface_lib);
296  DRW_SHADER_LIB_ADD(e_data.lib, volumetric_lib);
297  DRW_SHADER_LIB_ADD(e_data.lib, ssr_lib);
298  DRW_SHADER_LIB_ADD(e_data.lib, effect_dof_lib);
299  DRW_SHADER_LIB_ADD(e_data.lib, effect_reflection_lib);
300  DRW_SHADER_LIB_ADD(e_data.lib, closure_type_lib);
301  DRW_SHADER_LIB_ADD(e_data.lib, closure_eval_lib);
302  DRW_SHADER_LIB_ADD(e_data.lib, closure_eval_diffuse_lib);
303  DRW_SHADER_LIB_ADD(e_data.lib, closure_eval_glossy_lib);
304  DRW_SHADER_LIB_ADD(e_data.lib, closure_eval_translucent_lib);
305  DRW_SHADER_LIB_ADD(e_data.lib, closure_eval_refraction_lib);
306  DRW_SHADER_LIB_ADD(e_data.lib, closure_eval_surface_lib);
307  DRW_SHADER_LIB_ADD(e_data.lib, closure_eval_volume_lib);
308  DRW_SHADER_LIB_ADD(e_data.lib, cryptomatte_lib);
309  DRW_SHADER_LIB_ADD(e_data.lib, surface_vert);
310 
313 
314  e_data.surface_prepass_frag = DRW_shader_library_create_shader_string(
316 
317  e_data.surface_geom_barycentric = DRW_shader_library_create_shader_string(
319  }
320 }
321 
323 {
326 }
327 
329 {
331  return e_data.lib;
332 }
333 
335 {
336  if (e_data.probe_filter_glossy_sh == NULL) {
337  e_data.probe_filter_glossy_sh = DRW_shader_create_with_shaderlib(
341  e_data.lib,
343  }
344  return e_data.probe_filter_glossy_sh;
345 }
346 
348 {
349  if (e_data.probe_filter_diffuse_sh == NULL) {
350  e_data.probe_filter_diffuse_sh = DRW_shader_create_fullscreen_with_shaderlib(
352  }
353  return e_data.probe_filter_diffuse_sh;
354 }
355 
357 {
358  if (e_data.probe_filter_visibility_sh == NULL) {
359  e_data.probe_filter_visibility_sh = DRW_shader_create_fullscreen_with_shaderlib(
361  }
362  return e_data.probe_filter_visibility_sh;
363 }
364 
366 {
367  if (e_data.probe_grid_fill_sh == NULL) {
370  }
371  return e_data.probe_grid_fill_sh;
372 }
373 
375 {
376  if (e_data.probe_planar_downsample_sh == NULL) {
377  e_data.probe_planar_downsample_sh = DRW_shader_create_with_shaderlib(
381  e_data.lib,
382  NULL);
383  }
384  return e_data.probe_planar_downsample_sh;
385 }
386 
388 {
389  if (e_data.studiolight_probe_sh == NULL) {
391  NULL,
393  e_data.lib,
395  }
396  return e_data.studiolight_probe_sh;
397 }
398 
400 {
401  if (e_data.studiolight_background_sh == NULL) {
402  e_data.studiolight_background_sh = DRW_shader_create_with_shaderlib(
404  NULL,
406  e_data.lib,
407  "#define LOOKDEV_BG\n" SHADER_DEFINES);
408  }
409  return e_data.studiolight_background_sh;
410 }
411 
413 {
414  if (e_data.probe_cube_display_sh == NULL) {
415  e_data.probe_cube_display_sh = DRW_shader_create_with_shaderlib(
417  NULL,
419  e_data.lib,
421  }
422  return e_data.probe_cube_display_sh;
423 }
424 
426 {
427  if (e_data.probe_grid_display_sh == NULL) {
428  e_data.probe_grid_display_sh = DRW_shader_create_with_shaderlib(
430  NULL,
432  e_data.lib,
434  }
435  return e_data.probe_grid_display_sh;
436 }
437 
439 {
440  if (e_data.probe_planar_display_sh == NULL) {
441  e_data.probe_planar_display_sh = DRW_shader_create_with_shaderlib(
443  NULL,
445  e_data.lib,
446  NULL);
447  }
448  return e_data.probe_planar_display_sh;
449 }
450 
451 /* -------------------------------------------------------------------- */
456 {
457  if (e_data.color_copy_sh == NULL) {
459  datatoc_effect_downsample_frag_glsl, e_data.lib, "#define COPY_SRC\n");
460  }
461  return e_data.color_copy_sh;
462 }
463 
465 {
466  if (e_data.downsample_sh == NULL) {
469  }
470  return e_data.downsample_sh;
471 }
472 
474 {
475  if (e_data.downsample_cube_sh == NULL) {
476  e_data.downsample_cube_sh = DRW_shader_create_with_shaderlib(
480  e_data.lib,
481  NULL);
482  }
483  return e_data.downsample_cube_sh;
484 }
485 
487 {
488  if (e_data.minz_downlevel_sh == NULL) {
490  "#define MIN_PASS\n");
491  }
492  return e_data.minz_downlevel_sh;
493 }
494 
496 {
497  if (e_data.maxz_downlevel_sh == NULL) {
499  "#define MAX_PASS\n");
500  }
501  return e_data.maxz_downlevel_sh;
502 }
503 
505 {
506  if (e_data.minz_downdepth_sh == NULL) {
508  "#define MIN_PASS\n");
509  }
510  return e_data.minz_downdepth_sh;
511 }
512 
514 {
515  if (e_data.maxz_downdepth_sh == NULL) {
517  "#define MAX_PASS\n");
518  }
519  return e_data.maxz_downdepth_sh;
520 }
521 
523 {
524  if (e_data.minz_downdepth_layer_sh == NULL) {
526  "#define MIN_PASS\n"
527  "#define LAYERED\n");
528  }
529  return e_data.minz_downdepth_layer_sh;
530 }
531 
533 {
534  if (e_data.maxz_downdepth_layer_sh == NULL) {
536  "#define MAX_PASS\n"
537  "#define LAYERED\n");
538  }
539  return e_data.maxz_downdepth_layer_sh;
540 }
541 
543 {
544  if (e_data.maxz_copydepth_layer_sh == NULL) {
546  "#define MAX_PASS\n"
547  "#define COPY_DEPTH\n"
548  "#define LAYERED\n");
549  }
550  return e_data.maxz_copydepth_layer_sh;
551 }
552 
554 {
555  if (e_data.minz_copydepth_sh == NULL) {
557  "#define MIN_PASS\n"
558  "#define COPY_DEPTH\n");
559  }
560  return e_data.minz_copydepth_sh;
561 }
562 
564 {
565  if (e_data.maxz_copydepth_sh == NULL) {
567  "#define MAX_PASS\n"
568  "#define COPY_DEPTH\n");
569  }
570  return e_data.maxz_copydepth_sh;
571 }
572 
575 /* -------------------------------------------------------------------- */
580 {
581  if (e_data.ggx_lut_sh == NULL) {
584  }
585  return e_data.ggx_lut_sh;
586 }
587 
589 {
590  if (e_data.ggx_refraction_lut_sh == NULL) {
591  e_data.ggx_refraction_lut_sh = DRW_shader_create_fullscreen_with_shaderlib(
593  }
594  return e_data.ggx_refraction_lut_sh;
595 }
596 
599 /* -------------------------------------------------------------------- */
604 {
605  if (e_data.mist_sh == NULL) {
607  datatoc_effect_mist_frag_glsl, e_data.lib, "#define FIRST_PASS\n");
608  }
609  return e_data.mist_sh;
610 }
611 
614 /* -------------------------------------------------------------------- */
618 #define TILE_SIZE_STR "#define EEVEE_VELOCITY_TILE_SIZE " STRINGIFY(EEVEE_VELOCITY_TILE_SIZE) "\n"
620 {
621  if (e_data.motion_blur_sh == NULL) {
624  }
625  return e_data.motion_blur_sh;
626 }
627 
629 {
630  if (e_data.motion_blur_object_sh == NULL) {
631  e_data.motion_blur_object_sh = DRW_shader_create_with_shaderlib(
633  }
634  return e_data.motion_blur_object_sh;
635 }
636 
638 {
639  if (e_data.motion_blur_hair_sh == NULL) {
641  NULL,
643  e_data.lib,
644  "#define HAIR\n");
645  }
646  return e_data.motion_blur_hair_sh;
647 }
648 
650 {
651  if (e_data.velocity_tiles_sh == NULL) {
653  "#define TILE_GATHER\n" TILE_SIZE_STR);
654  }
655  return e_data.velocity_tiles_sh;
656 }
657 
659 {
660  if (e_data.velocity_tiles_expand_sh == NULL) {
661  e_data.velocity_tiles_expand_sh = DRW_shader_create_fullscreen(
662  datatoc_effect_velocity_tile_frag_glsl, "#define TILE_EXPANSION\n" TILE_SIZE_STR);
663  }
664  return e_data.velocity_tiles_expand_sh;
665 }
666 
667 #undef TILE_SIZE_STR
668 
671 /* -------------------------------------------------------------------- */
676 {
677  if (e_data.gtao_sh == NULL) {
680  }
681  return e_data.gtao_sh;
682 }
683 
685 {
686  if (e_data.gtao_debug_sh == NULL) {
689  e_data.lib,
690  "#define DEBUG_AO\n"
691  "#define ENABLE_DEFERED_AO");
692  }
693  return e_data.gtao_debug_sh;
694 }
695 
698 /* -------------------------------------------------------------------- */
703 {
704  if (e_data.postprocess_sh == NULL) {
707  }
708  return e_data.postprocess_sh;
709 }
710 
713 /* -------------------------------------------------------------------- */
718 {
719  const int index = is_hair ? 1 : 0;
720  if (e_data.cryptomatte_sh[index] == NULL) {
721  DynStr *ds = BLI_dynstr_new();
723  BLI_dynstr_append(ds, "#define attrib_load() \n");
724  if (is_hair) {
725  BLI_dynstr_append(ds, "#define HAIR_SHADER\n");
726  }
727  else {
728  BLI_dynstr_append(ds, "#define MESH_SHADER\n");
729  }
730  char *defines = BLI_dynstr_get_cstring(ds);
731  e_data.cryptomatte_sh[index] = DRW_shader_create_with_shaderlib(
733  BLI_dynstr_free(ds);
734  MEM_freeN(defines);
735  }
736  return e_data.cryptomatte_sh[index];
737 }
738 
741 /* -------------------------------------------------------------------- */
746 {
747  if (e_data.reflection_trace == NULL) {
750  e_data.lib,
751  SHADER_DEFINES "#define STEP_RAYTRACE\n");
752  }
753  return e_data.reflection_trace;
754 }
755 
757 {
758  if (e_data.reflection_resolve == NULL) {
761  e_data.lib,
762  SHADER_DEFINES "#define STEP_RESOLVE\n");
763  }
764  return e_data.reflection_resolve;
765 }
766 
769 /* -------------------------------------------------------------------- */
774 {
775  if (e_data.shadow_sh == NULL) {
778  }
779  return e_data.shadow_sh;
780 }
781 
783 {
784  if (e_data.shadow_accum_sh == NULL) {
787  }
788  return e_data.shadow_accum_sh;
789 }
790 
793 /* -------------------------------------------------------------------- */
798 {
799  if (e_data.sss_sh[0] == NULL) {
801  datatoc_effect_subsurface_frag_glsl, e_data.lib, "#define FIRST_PASS\n");
802  }
803  return e_data.sss_sh[0];
804 }
805 
807 {
808  if (e_data.sss_sh[1] == NULL) {
810  datatoc_effect_subsurface_frag_glsl, e_data.lib, "#define SECOND_PASS\n");
811  }
812  return e_data.sss_sh[1];
813 }
814 
816 {
817  if (e_data.sss_sh[2] == NULL) {
820  e_data.lib,
821  "#define EEVEE_TRANSLUCENCY\n" SHADER_DEFINES);
822  }
823  return e_data.sss_sh[2];
824 }
825 
828 /* -------------------------------------------------------------------- */
833 {
834  if (e_data.volumetric_clear_sh == NULL) {
838  e_data.lib,
840  "#define STANDALONE\n"
841  "#define VOLUMETRICS\n"
842  "#define CLEAR\n");
843  }
844  return e_data.volumetric_clear_sh;
845 }
846 
848 {
849  if (e_data.scatter_sh == NULL) {
853  e_data.lib,
855  "#define STANDALONE\n"
856  "#define VOLUMETRICS\n"
857  "#define VOLUME_SHADOW\n");
858  }
859  return e_data.scatter_sh;
860 }
861 
863 {
864  if (e_data.scatter_with_lights_sh == NULL) {
865  e_data.scatter_with_lights_sh = DRW_shader_create_with_shaderlib(
869  e_data.lib,
871  "#define STANDALONE\n"
872  "#define VOLUMETRICS\n"
873  "#define VOLUME_LIGHTING\n"
874  "#define VOLUME_SHADOW\n");
875  }
876  return e_data.scatter_with_lights_sh;
877 }
878 
880 {
881  if (e_data.volumetric_integration_sh == NULL) {
882  e_data.volumetric_integration_sh = DRW_shader_create_with_shaderlib(
886  e_data.lib,
887  USE_VOLUME_OPTI ? "#define USE_VOLUME_OPTI\n"
888  "#define STANDALONE\n" SHADER_DEFINES :
889  "#define STANDALONE\n" SHADER_DEFINES);
890  }
891  return e_data.volumetric_integration_sh;
892 }
893 
895 {
896  const int index = accum ? 1 : 0;
897  if (e_data.volumetric_resolve_sh[index] == NULL) {
898  e_data.volumetric_resolve_sh[index] = DRW_shader_create_fullscreen_with_shaderlib(
900  e_data.lib,
901  accum ? "#define VOLUMETRICS_ACCUM\n" SHADER_DEFINES : SHADER_DEFINES);
902  }
903  return e_data.volumetric_resolve_sh[index];
904 }
905 
907 {
908  if (e_data.volumetric_accum_sh == NULL) {
911  }
912  return e_data.volumetric_accum_sh;
913 }
914 
918 {
919  if (e_data.velocity_resolve_sh == NULL) {
922  }
923  return e_data.velocity_resolve_sh;
924 }
925 
927 {
928  if (e_data.update_noise_sh == NULL) {
931  }
932  return e_data.update_noise_sh;
933 }
934 
936 {
937  GPUShader **sh;
938  const char *define = NULL;
939  if (enabled_effects & EFFECT_TAA_REPROJECT) {
940  sh = &e_data.taa_resolve_reproject_sh;
941  define = "#define USE_REPROJECTION\n";
942  }
943  else {
944  sh = &e_data.taa_resolve_sh;
945  }
946  if (*sh == NULL) {
949  }
950 
951  return *sh;
952 }
953 
954 /* -------------------------------------------------------------------- */
959 {
960  int index = high_quality ? 1 : 0;
961 
962  if (e_data.bloom_blit_sh[index] == NULL) {
963  const char *define = high_quality ? "#define STEP_BLIT\n"
964  "#define HIGH_QUALITY\n" :
965  "#define STEP_BLIT\n";
968  }
969  return e_data.bloom_blit_sh[index];
970 }
971 
973 {
974  int index = high_quality ? 1 : 0;
975 
976  if (e_data.bloom_downsample_sh[index] == NULL) {
977  const char *define = high_quality ? "#define STEP_DOWNSAMPLE\n"
978  "#define HIGH_QUALITY\n" :
979  "#define STEP_DOWNSAMPLE\n";
980  e_data.bloom_downsample_sh[index] = DRW_shader_create_fullscreen_with_shaderlib(
982  }
983  return e_data.bloom_downsample_sh[index];
984 }
985 
987 {
988  int index = high_quality ? 1 : 0;
989 
990  if (e_data.bloom_upsample_sh[index] == NULL) {
991  const char *define = high_quality ? "#define STEP_UPSAMPLE\n"
992  "#define HIGH_QUALITY\n" :
993  "#define STEP_UPSAMPLE\n";
994  e_data.bloom_upsample_sh[index] = DRW_shader_create_fullscreen_with_shaderlib(
996  }
997  return e_data.bloom_upsample_sh[index];
998 }
999 
1001 {
1002  int index = high_quality ? 1 : 0;
1003 
1004  if (e_data.bloom_resolve_sh[index] == NULL) {
1005  const char *define = high_quality ? "#define STEP_RESOLVE\n"
1006  "#define HIGH_QUALITY\n" :
1007  "#define STEP_RESOLVE\n";
1008  e_data.bloom_resolve_sh[index] = DRW_shader_create_fullscreen_with_shaderlib(
1010  }
1011  return e_data.bloom_resolve_sh[index];
1012 }
1013 
1016 /* -------------------------------------------------------------------- */
1021 {
1022  if (e_data.dof_bokeh_sh == NULL) {
1025  }
1026  return e_data.dof_bokeh_sh;
1027 }
1028 
1030 {
1031  if (e_data.dof_setup_sh == NULL) {
1034  }
1035  return e_data.dof_setup_sh;
1036 }
1037 
1039 {
1040  if (e_data.dof_flatten_tiles_sh == NULL) {
1041  e_data.dof_flatten_tiles_sh = DRW_shader_create_fullscreen_with_shaderlib(
1043  }
1044  return e_data.dof_flatten_tiles_sh;
1045 }
1046 
1048 {
1049  int pass = b_pass;
1050  if (e_data.dof_dilate_tiles_sh[pass] == NULL) {
1051  e_data.dof_dilate_tiles_sh[pass] = DRW_shader_create_fullscreen_with_shaderlib(
1053  e_data.lib,
1054  (pass == 0) ? DOF_SHADER_DEFINES "#define DILATE_MODE_MIN_MAX\n" :
1055  DOF_SHADER_DEFINES "#define DILATE_MODE_MIN_ABS\n");
1056  }
1057  return e_data.dof_dilate_tiles_sh[pass];
1058 }
1059 
1061 {
1062  if (e_data.dof_downsample_sh == NULL) {
1065  }
1066  return e_data.dof_downsample_sh;
1067 }
1068 
1070 {
1071  int is_copy_pass = b_is_copy_pass;
1072  if (e_data.dof_reduce_sh[is_copy_pass] == NULL) {
1073  e_data.dof_reduce_sh[is_copy_pass] = DRW_shader_create_fullscreen_with_shaderlib(
1075  e_data.lib,
1076  (is_copy_pass) ? DOF_SHADER_DEFINES "#define COPY_PASS\n" :
1077  DOF_SHADER_DEFINES "#define REDUCE_PASS\n");
1078  }
1079  return e_data.dof_reduce_sh[is_copy_pass];
1080 }
1081 
1083 {
1084  int use_bokeh_tx = b_use_bokeh_tx;
1085  if (e_data.dof_gather_sh[pass][use_bokeh_tx] == NULL) {
1086  DynStr *ds = BLI_dynstr_new();
1087 
1089 
1090  switch (pass) {
1091  case DOF_GATHER_FOREGROUND:
1092  BLI_dynstr_append(ds, "#define DOF_FOREGROUND_PASS\n");
1093  break;
1094  case DOF_GATHER_BACKGROUND:
1095  BLI_dynstr_append(ds, "#define DOF_BACKGROUND_PASS\n");
1096  break;
1097  case DOF_GATHER_HOLEFILL:
1098  BLI_dynstr_append(ds,
1099  "#define DOF_BACKGROUND_PASS\n"
1100  "#define DOF_HOLEFILL_PASS\n");
1101  break;
1102  default:
1103  break;
1104  }
1105 
1106  if (use_bokeh_tx) {
1107  BLI_dynstr_append(ds, "#define DOF_BOKEH_TEXTURE\n");
1108  }
1109 
1110  char *define = BLI_dynstr_get_cstring(ds);
1111  BLI_dynstr_free(ds);
1112 
1113  e_data.dof_gather_sh[pass][use_bokeh_tx] = DRW_shader_create_fullscreen_with_shaderlib(
1115 
1116  MEM_freeN(define);
1117  }
1118  return e_data.dof_gather_sh[pass][use_bokeh_tx];
1119 }
1120 
1122 {
1123  if (e_data.dof_filter_sh == NULL) {
1126  }
1127  return e_data.dof_filter_sh;
1128 }
1129 
1130 GPUShader *EEVEE_shaders_depth_of_field_scatter_get(bool b_is_foreground, bool b_use_bokeh_tx)
1131 {
1132  int is_foreground = b_is_foreground;
1133  int use_bokeh_tx = b_use_bokeh_tx;
1134  if (e_data.dof_scatter_sh[is_foreground][use_bokeh_tx] == NULL) {
1135  DynStr *ds = BLI_dynstr_new();
1136 
1139  ds, (is_foreground) ? "#define DOF_FOREGROUND_PASS\n" : "#define DOF_BACKGROUND_PASS\n");
1140 
1141  if (use_bokeh_tx) {
1142  BLI_dynstr_append(ds, "#define DOF_BOKEH_TEXTURE\n");
1143  }
1144 
1145  char *define = BLI_dynstr_get_cstring(ds);
1146  BLI_dynstr_free(ds);
1147 
1148  e_data.dof_scatter_sh[is_foreground][use_bokeh_tx] = DRW_shader_create_with_shaderlib(
1150  NULL,
1152  e_data.lib,
1153  define);
1154 
1155  MEM_freeN(define);
1156  }
1157  return e_data.dof_scatter_sh[is_foreground][use_bokeh_tx];
1158 }
1159 
1160 GPUShader *EEVEE_shaders_depth_of_field_resolve_get(bool b_use_bokeh_tx, bool b_use_hq_gather)
1161 {
1162  int use_hq_gather = b_use_hq_gather;
1163  int use_bokeh_tx = b_use_bokeh_tx;
1164  if (e_data.dof_resolve_sh[use_bokeh_tx][use_hq_gather] == NULL) {
1165  DynStr *ds = BLI_dynstr_new();
1166 
1168  BLI_dynstr_append(ds, "#define DOF_RESOLVE_PASS\n");
1169 
1170  if (use_bokeh_tx) {
1171  BLI_dynstr_append(ds, "#define DOF_BOKEH_TEXTURE\n");
1172  }
1173 
1174  BLI_dynstr_appendf(ds, "#define DOF_SLIGHT_FOCUS_DENSITY %d\n", use_hq_gather ? 4 : 2);
1175 
1176  char *define = BLI_dynstr_get_cstring(ds);
1177  BLI_dynstr_free(ds);
1178 
1179  e_data.dof_resolve_sh[use_bokeh_tx][use_hq_gather] =
1182 
1183  MEM_freeN(define);
1184  }
1185  return e_data.dof_resolve_sh[use_bokeh_tx][use_hq_gather];
1186 }
1187 
1191 {
1192  if (!e_data.diffuse_mat) {
1193  Material *ma = BKE_id_new_nomain(ID_MA, "EEVEEE default diffuse");
1194 
1195  bNodeTree *ntree = ntreeAddTree(NULL, "Shader Nodetree", ntreeType_Shader->idname);
1196  ma->nodetree = ntree;
1197  ma->use_nodes = true;
1198 
1200  bNodeSocket *base_color = nodeFindSocket(bsdf, SOCK_IN, "Color");
1201  copy_v3_fl(((bNodeSocketValueRGBA *)base_color->default_value)->value, 0.8f);
1202 
1204 
1206  bsdf,
1207  nodeFindSocket(bsdf, SOCK_OUT, "BSDF"),
1208  output,
1209  nodeFindSocket(output, SOCK_IN, "Surface"));
1210 
1212  e_data.diffuse_mat = ma;
1213  }
1214  return e_data.diffuse_mat;
1215 }
1216 
1218 {
1219  if (!e_data.glossy_mat) {
1220  Material *ma = BKE_id_new_nomain(ID_MA, "EEVEEE default metal");
1221 
1222  bNodeTree *ntree = ntreeAddTree(NULL, "Shader Nodetree", ntreeType_Shader->idname);
1223  ma->nodetree = ntree;
1224  ma->use_nodes = true;
1225 
1227  bNodeSocket *base_color = nodeFindSocket(bsdf, SOCK_IN, "Color");
1228  copy_v3_fl(((bNodeSocketValueRGBA *)base_color->default_value)->value, 1.0f);
1229  bNodeSocket *roughness = nodeFindSocket(bsdf, SOCK_IN, "Roughness");
1230  ((bNodeSocketValueFloat *)roughness->default_value)->value = 0.0f;
1231 
1233 
1235  bsdf,
1236  nodeFindSocket(bsdf, SOCK_OUT, "BSDF"),
1237  output,
1238  nodeFindSocket(output, SOCK_IN, "Surface"));
1239 
1241  e_data.glossy_mat = ma;
1242  }
1243  return e_data.glossy_mat;
1244 }
1245 
1247 {
1248  if (!e_data.error_mat) {
1249  Material *ma = BKE_id_new_nomain(ID_MA, "EEVEEE default error");
1250 
1251  bNodeTree *ntree = ntreeAddTree(NULL, "Shader Nodetree", ntreeType_Shader->idname);
1252  ma->nodetree = ntree;
1253  ma->use_nodes = true;
1254 
1255  /* Use emission and output material to be compatible with both World and Material. */
1257  bNodeSocket *color = nodeFindSocket(bsdf, SOCK_IN, "Color");
1258  copy_v3_fl3(((bNodeSocketValueRGBA *)color->default_value)->value, 1.0f, 0.0f, 1.0f);
1259 
1261 
1263  bsdf,
1264  nodeFindSocket(bsdf, SOCK_OUT, "Emission"),
1265  output,
1266  nodeFindSocket(output, SOCK_IN, "Surface"));
1267 
1269  e_data.error_mat = ma;
1270  }
1271  return e_data.error_mat;
1272 }
1273 
1275 {
1276  /* WARNING: This function is not threadsafe. Which is not a problem for the moment. */
1277  if (!e_data.surface.ntree) {
1278  bNodeTree *ntree = ntreeAddTree(NULL, "Shader Nodetree", ntreeType_Shader->idname);
1281  bNodeSocket *bsdf_out = nodeFindSocket(bsdf, SOCK_OUT, "BSDF");
1282  bNodeSocket *output_in = nodeFindSocket(output, SOCK_IN, "Surface");
1283  nodeAddLink(ntree, bsdf, bsdf_out, output, output_in);
1285 
1286  e_data.surface.color_socket = nodeFindSocket(bsdf, SOCK_IN, "Base Color")->default_value;
1287  e_data.surface.metallic_socket = nodeFindSocket(bsdf, SOCK_IN, "Metallic")->default_value;
1288  e_data.surface.roughness_socket = nodeFindSocket(bsdf, SOCK_IN, "Roughness")->default_value;
1289  e_data.surface.specular_socket = nodeFindSocket(bsdf, SOCK_IN, "Specular")->default_value;
1290  e_data.surface.ntree = ntree;
1291  }
1292  /* Update */
1293  copy_v3_fl3(e_data.surface.color_socket->value, ma->r, ma->g, ma->b);
1294  e_data.surface.metallic_socket->value = ma->metallic;
1295  e_data.surface.roughness_socket->value = ma->roughness;
1296  e_data.surface.specular_socket->value = ma->spec;
1297 
1298  return e_data.surface.ntree;
1299 }
1300 
1302 {
1303  /* WARNING: This function is not threadsafe. Which is not a problem for the moment. */
1304  if (!e_data.world.ntree) {
1305  bNodeTree *ntree = ntreeAddTree(NULL, "Shader Nodetree", ntreeType_Shader->idname);
1308  bNodeSocket *bg_out = nodeFindSocket(bg, SOCK_OUT, "Background");
1309  bNodeSocket *output_in = nodeFindSocket(output, SOCK_IN, "Surface");
1310  nodeAddLink(ntree, bg, bg_out, output, output_in);
1312 
1313  e_data.world.color_socket = nodeFindSocket(bg, SOCK_IN, "Color")->default_value;
1314  e_data.world.ntree = ntree;
1315  }
1316 
1317  copy_v3_fl3(e_data.world.color_socket->value, wo->horr, wo->horg, wo->horb);
1318 
1319  return e_data.world.ntree;
1320 }
1321 
1323 {
1324  if (e_data.default_world == NULL) {
1325  e_data.default_world = BKE_id_new_nomain(ID_WO, "EEVEEE default world");
1326  copy_v3_fl(&e_data.default_world->horr, 0.0f);
1327  e_data.default_world->use_nodes = 0;
1328  e_data.default_world->nodetree = NULL;
1329  BLI_listbase_clear(&e_data.default_world->gpumaterial);
1330  }
1331  return e_data.default_world;
1332 }
1333 
1334 static char *eevee_get_defines(int options)
1335 {
1336  char *str = NULL;
1337 
1338  DynStr *ds = BLI_dynstr_new();
1340 
1341  if ((options & VAR_WORLD_BACKGROUND) != 0) {
1342  BLI_dynstr_append(ds, "#define WORLD_BACKGROUND\n");
1343  }
1344  if ((options & VAR_MAT_VOLUME) != 0) {
1345  BLI_dynstr_append(ds, "#define VOLUMETRICS\n");
1346  }
1347  if ((options & VAR_MAT_MESH) != 0) {
1348  BLI_dynstr_append(ds, "#define MESH_SHADER\n");
1349  }
1350  if ((options & VAR_MAT_DEPTH) != 0) {
1351  BLI_dynstr_append(ds, "#define DEPTH_SHADER\n");
1352  }
1353  if ((options & VAR_MAT_HAIR) != 0) {
1354  BLI_dynstr_append(ds, "#define HAIR_SHADER\n");
1355  }
1356  if ((options & VAR_MAT_POINTCLOUD) != 0) {
1357  BLI_dynstr_append(ds, "#define POINTCLOUD_SHADER\n");
1358  }
1359  if ((options & VAR_WORLD_PROBE) != 0) {
1360  BLI_dynstr_append(ds, "#define PROBE_CAPTURE\n");
1361  }
1362  if ((options & VAR_MAT_HASH) != 0) {
1363  BLI_dynstr_append(ds, "#define USE_ALPHA_HASH\n");
1364  }
1365  if ((options & VAR_MAT_BLEND) != 0) {
1366  BLI_dynstr_append(ds, "#define USE_ALPHA_BLEND\n");
1367  }
1368  if ((options & VAR_MAT_REFRACT) != 0) {
1369  BLI_dynstr_append(ds, "#define USE_REFRACTION\n");
1370  }
1371  if ((options & VAR_MAT_LOOKDEV) != 0) {
1372  BLI_dynstr_append(ds, "#define LOOKDEV\n");
1373  }
1374  if ((options & VAR_MAT_HOLDOUT) != 0) {
1375  BLI_dynstr_append(ds, "#define HOLDOUT\n");
1376  }
1377 
1379  BLI_dynstr_free(ds);
1380 
1381  return str;
1382 }
1383 
1384 static char *eevee_get_vert(int options)
1385 {
1386  char *str = NULL;
1387 
1388  if ((options & VAR_MAT_VOLUME) != 0) {
1390  }
1391  else if ((options & (VAR_WORLD_PROBE | VAR_WORLD_BACKGROUND)) != 0) {
1393  }
1394  else {
1396  }
1397 
1398  return str;
1399 }
1400 
1401 static char *eevee_get_geom(int options)
1402 {
1403  char *str = NULL;
1404 
1405  if ((options & VAR_MAT_VOLUME) != 0) {
1407  }
1408 
1409  return str;
1410 }
1411 
1412 static char *eevee_get_frag(int options)
1413 {
1414  char *str = NULL;
1415 
1416  if ((options & VAR_MAT_VOLUME) != 0) {
1418  }
1419  else if ((options & VAR_MAT_DEPTH) != 0) {
1420  str = BLI_strdup(e_data.surface_prepass_frag);
1421  }
1422  else {
1423  str = BLI_strdup(e_data.surface_lit_frag);
1424  }
1425 
1426  return str;
1427 }
1428 
1429 static void eevee_material_post_eval(void *UNUSED(thunk),
1430  GPUMaterial *mat,
1431  GPUCodegenOutput *codegen)
1432 {
1434 
1435  char *vert = eevee_get_vert(options);
1436  char *geom = eevee_get_geom(options);
1437  char *frag = eevee_get_frag(options);
1438  char *defines = eevee_get_defines(options);
1439 
1440  eevee_shader_material_create_info_amend(mat, codegen, frag, vert, geom, defines);
1441 
1442  MEM_SAFE_FREE(defines);
1443  MEM_SAFE_FREE(vert);
1444  MEM_SAFE_FREE(geom);
1445  MEM_SAFE_FREE(frag);
1446 }
1447 
1449  struct Scene *UNUSED(scene), Material *ma, World *wo, int options, bool deferred)
1450 {
1451  BLI_assert(ma || wo);
1452  const bool is_volume = (options & VAR_MAT_VOLUME) != 0;
1453  const bool is_default = (options & VAR_DEFAULT) != 0;
1454 
1455  GPUMaterial *mat = NULL;
1457 
1458  if (ma) {
1460  mat = DRW_shader_from_material(ma, ntree, options, is_volume, deferred, cbfn, NULL);
1461  }
1462  else {
1463  bNodeTree *ntree = !is_default ? wo->nodetree : EEVEE_shader_default_world_nodetree(wo);
1464  mat = DRW_shader_from_world(wo, ntree, options, is_volume, deferred, cbfn, NULL);
1465  }
1466  return mat;
1467 }
1468 
1470 {
1473  BLI_assert(def_ma->use_nodes && def_ma->nodetree);
1474 
1475  return eevee_material_get_ex(scene, def_ma, NULL, options, false);
1476 }
1477 
1479  EEVEE_Data *vedata, struct Scene *scene, Material *ma, World *wo, int options)
1480 {
1481  if ((ma && (!ma->use_nodes || !ma->nodetree)) || (wo && (!wo->use_nodes || !wo->nodetree))) {
1482  options |= VAR_DEFAULT;
1483  }
1484 
1485  /* Meh, implicit option. World probe cannot be deferred because they need
1486  * to be rendered immediately. */
1487  const bool deferred = (options & VAR_WORLD_PROBE) == 0;
1488 
1489  GPUMaterial *mat = eevee_material_get_ex(scene, ma, wo, options, deferred);
1490 
1491  int status = GPU_material_status(mat);
1492  /* Return null material and bypass drawing for volume shaders. */
1493  if ((options & VAR_MAT_VOLUME) && status != GPU_MAT_SUCCESS) {
1494  return NULL;
1495  }
1496  switch (status) {
1497  case GPU_MAT_SUCCESS:
1498  break;
1499  case GPU_MAT_QUEUED:
1500  vedata->stl->g_data->queued_shaders_count++;
1502  break;
1503  case GPU_MAT_FAILED:
1504  default:
1506  mat = eevee_material_get_ex(scene, ma, NULL, options, false);
1507  break;
1508  }
1509  /* Returned material should be ready to be drawn. */
1511  return mat;
1512 }
1513 
1515 {
1517  MEM_SAFE_FREE(e_data.surface_prepass_frag);
1518  MEM_SAFE_FREE(e_data.surface_lit_frag);
1519  MEM_SAFE_FREE(e_data.surface_geom_barycentric);
1520  DRW_SHADER_FREE_SAFE(e_data.lookdev_background);
1521  DRW_SHADER_FREE_SAFE(e_data.update_noise_sh);
1522  DRW_SHADER_FREE_SAFE(e_data.color_copy_sh);
1523  DRW_SHADER_FREE_SAFE(e_data.downsample_sh);
1524  DRW_SHADER_FREE_SAFE(e_data.downsample_cube_sh);
1525  DRW_SHADER_FREE_SAFE(e_data.minz_downlevel_sh);
1526  DRW_SHADER_FREE_SAFE(e_data.maxz_downlevel_sh);
1527  DRW_SHADER_FREE_SAFE(e_data.minz_downdepth_sh);
1528  DRW_SHADER_FREE_SAFE(e_data.maxz_downdepth_sh);
1529  DRW_SHADER_FREE_SAFE(e_data.minz_downdepth_layer_sh);
1530  DRW_SHADER_FREE_SAFE(e_data.maxz_downdepth_layer_sh);
1531  DRW_SHADER_FREE_SAFE(e_data.maxz_copydepth_layer_sh);
1532  DRW_SHADER_FREE_SAFE(e_data.minz_copydepth_sh);
1533  DRW_SHADER_FREE_SAFE(e_data.maxz_copydepth_sh);
1534  DRW_SHADER_FREE_SAFE(e_data.ggx_lut_sh);
1535  DRW_SHADER_FREE_SAFE(e_data.ggx_refraction_lut_sh);
1536  DRW_SHADER_FREE_SAFE(e_data.mist_sh);
1537  DRW_SHADER_FREE_SAFE(e_data.motion_blur_sh);
1538  DRW_SHADER_FREE_SAFE(e_data.motion_blur_object_sh);
1539  DRW_SHADER_FREE_SAFE(e_data.motion_blur_hair_sh);
1540  DRW_SHADER_FREE_SAFE(e_data.velocity_tiles_sh);
1541  DRW_SHADER_FREE_SAFE(e_data.velocity_tiles_expand_sh);
1542  DRW_SHADER_FREE_SAFE(e_data.gtao_sh);
1543  DRW_SHADER_FREE_SAFE(e_data.gtao_layer_sh);
1544  DRW_SHADER_FREE_SAFE(e_data.gtao_debug_sh);
1545  DRW_SHADER_FREE_SAFE(e_data.velocity_resolve_sh);
1546  DRW_SHADER_FREE_SAFE(e_data.postprocess_sh);
1547  DRW_SHADER_FREE_SAFE(e_data.shadow_sh);
1548  DRW_SHADER_FREE_SAFE(e_data.shadow_accum_sh);
1549  DRW_SHADER_FREE_SAFE(e_data.sss_sh[0]);
1550  DRW_SHADER_FREE_SAFE(e_data.sss_sh[1]);
1551  DRW_SHADER_FREE_SAFE(e_data.sss_sh[2]);
1552  DRW_SHADER_FREE_SAFE(e_data.volumetric_clear_sh);
1553  DRW_SHADER_FREE_SAFE(e_data.scatter_sh);
1554  DRW_SHADER_FREE_SAFE(e_data.scatter_with_lights_sh);
1555  DRW_SHADER_FREE_SAFE(e_data.volumetric_integration_sh);
1556  DRW_SHADER_FREE_SAFE(e_data.volumetric_resolve_sh[0]);
1557  DRW_SHADER_FREE_SAFE(e_data.volumetric_resolve_sh[1]);
1558  DRW_SHADER_FREE_SAFE(e_data.volumetric_accum_sh);
1559  DRW_SHADER_FREE_SAFE(e_data.probe_filter_glossy_sh);
1560  DRW_SHADER_FREE_SAFE(e_data.probe_filter_diffuse_sh);
1561  DRW_SHADER_FREE_SAFE(e_data.probe_filter_visibility_sh);
1562  DRW_SHADER_FREE_SAFE(e_data.probe_grid_fill_sh);
1563  DRW_SHADER_FREE_SAFE(e_data.probe_planar_downsample_sh);
1564  DRW_SHADER_FREE_SAFE(e_data.studiolight_probe_sh);
1565  DRW_SHADER_FREE_SAFE(e_data.studiolight_background_sh);
1566  DRW_SHADER_FREE_SAFE(e_data.probe_grid_display_sh);
1567  DRW_SHADER_FREE_SAFE(e_data.probe_cube_display_sh);
1568  DRW_SHADER_FREE_SAFE(e_data.probe_planar_display_sh);
1569  DRW_SHADER_FREE_SAFE(e_data.velocity_resolve_sh);
1570  DRW_SHADER_FREE_SAFE(e_data.taa_resolve_sh);
1571  DRW_SHADER_FREE_SAFE(e_data.taa_resolve_reproject_sh);
1572  DRW_SHADER_FREE_SAFE(e_data.dof_bokeh_sh);
1573  DRW_SHADER_FREE_SAFE(e_data.dof_setup_sh);
1574  DRW_SHADER_FREE_SAFE(e_data.dof_flatten_tiles_sh);
1575  DRW_SHADER_FREE_SAFE(e_data.dof_dilate_tiles_sh[0]);
1576  DRW_SHADER_FREE_SAFE(e_data.dof_dilate_tiles_sh[1]);
1577  DRW_SHADER_FREE_SAFE(e_data.dof_downsample_sh);
1578  DRW_SHADER_FREE_SAFE(e_data.dof_reduce_sh[0]);
1579  DRW_SHADER_FREE_SAFE(e_data.dof_reduce_sh[1]);
1580  for (int i = 0; i < DOF_GATHER_MAX_PASS; i++) {
1581  DRW_SHADER_FREE_SAFE(e_data.dof_gather_sh[i][0]);
1582  DRW_SHADER_FREE_SAFE(e_data.dof_gather_sh[i][1]);
1583  }
1584  DRW_SHADER_FREE_SAFE(e_data.dof_filter_sh);
1585  DRW_SHADER_FREE_SAFE(e_data.dof_scatter_sh[0][0]);
1586  DRW_SHADER_FREE_SAFE(e_data.dof_scatter_sh[0][1]);
1587  DRW_SHADER_FREE_SAFE(e_data.dof_scatter_sh[1][0]);
1588  DRW_SHADER_FREE_SAFE(e_data.dof_scatter_sh[1][1]);
1589  DRW_SHADER_FREE_SAFE(e_data.dof_resolve_sh[0][0]);
1590  DRW_SHADER_FREE_SAFE(e_data.dof_resolve_sh[0][1]);
1591  DRW_SHADER_FREE_SAFE(e_data.dof_resolve_sh[1][0]);
1592  DRW_SHADER_FREE_SAFE(e_data.dof_resolve_sh[1][1]);
1593  DRW_SHADER_FREE_SAFE(e_data.cryptomatte_sh[0]);
1594  DRW_SHADER_FREE_SAFE(e_data.cryptomatte_sh[1]);
1595  for (int i = 0; i < 2; i++) {
1596  DRW_SHADER_FREE_SAFE(e_data.bloom_blit_sh[i]);
1597  DRW_SHADER_FREE_SAFE(e_data.bloom_downsample_sh[i]);
1598  DRW_SHADER_FREE_SAFE(e_data.bloom_upsample_sh[i]);
1599  DRW_SHADER_FREE_SAFE(e_data.bloom_resolve_sh[i]);
1600  }
1601  DRW_SHADER_FREE_SAFE(e_data.reflection_trace);
1602  DRW_SHADER_FREE_SAFE(e_data.reflection_resolve);
1604 
1605  if (e_data.default_world) {
1606  BKE_id_free(NULL, e_data.default_world);
1607  e_data.default_world = NULL;
1608  }
1609  if (e_data.glossy_mat) {
1610  BKE_id_free(NULL, e_data.glossy_mat);
1611  e_data.glossy_mat = NULL;
1612  }
1613  if (e_data.diffuse_mat) {
1614  BKE_id_free(NULL, e_data.diffuse_mat);
1615  e_data.diffuse_mat = NULL;
1616  }
1617  if (e_data.error_mat) {
1618  BKE_id_free(NULL, e_data.error_mat);
1619  e_data.error_mat = NULL;
1620  }
1621  if (e_data.surface.ntree) {
1622  ntreeFreeEmbeddedTree(e_data.surface.ntree);
1623  MEM_freeN(e_data.surface.ntree);
1624  e_data.surface.ntree = NULL;
1625  }
1626  if (e_data.world.ntree) {
1627  ntreeFreeEmbeddedTree(e_data.world.ntree);
1628  MEM_freeN(e_data.world.ntree);
1629  e_data.world.ntree = NULL;
1630  }
1631 }
void * BKE_id_new_nomain(short type, const char *name)
Definition: lib_id.c:1173
void BKE_id_free(struct Main *bmain, void *idv)
struct Material * BKE_material_default_surface(void)
Definition: material.c:2051
struct Material * BKE_material_default_volume(void)
Definition: material.c:2056
#define SH_NODE_BSDF_PRINCIPLED
Definition: BKE_node.h:1164
#define SH_NODE_EMISSION
Definition: BKE_node.h:1115
#define SH_NODE_BSDF_DIFFUSE
Definition: BKE_node.h:1109
#define SH_NODE_OUTPUT_MATERIAL
Definition: BKE_node.h:1101
void ntreeFreeEmbeddedTree(struct bNodeTree *ntree)
Definition: node.cc:3112
struct bNodeLink * nodeAddLink(struct bNodeTree *ntree, struct bNode *fromnode, struct bNodeSocket *fromsock, struct bNode *tonode, struct bNodeSocket *tosock)
Definition: node.cc:2296
#define SH_NODE_BACKGROUND
Definition: BKE_node.h:1107
struct bNodeSocket * nodeFindSocket(const struct bNode *node, eNodeSocketInOut in_out, const char *identifier)
#define SH_NODE_BSDF_GLOSSY
Definition: BKE_node.h:1110
struct bNodeTree * ntreeAddTree(struct Main *bmain, const char *name, const char *idname)
Definition: node.cc:2674
struct bNode * nodeAddStaticNode(const struct bContext *C, struct bNodeTree *ntree, int type)
Definition: node.cc:2151
void nodeSetActive(struct bNodeTree *ntree, struct bNode *node)
Definition: node.cc:3644
#define BLI_assert(a)
Definition: BLI_assert.h:46
A dynamically sized string ADT.
DynStr * BLI_dynstr_new(void) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
Definition: BLI_dynstr.c:50
char * BLI_dynstr_get_cstring(const DynStr *ds) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition: BLI_dynstr.c:256
void BLI_dynstr_free(DynStr *ds) ATTR_NONNULL()
Definition: BLI_dynstr.c:281
void BLI_dynstr_appendf(DynStr *__restrict ds, const char *__restrict format,...) ATTR_PRINTF_FORMAT(2
void BLI_dynstr_append(DynStr *__restrict ds, const char *cstr) ATTR_NONNULL()
Definition: BLI_dynstr.c:75
BLI_INLINE void BLI_listbase_clear(struct ListBase *lb)
Definition: BLI_listbase.h:273
MINLINE void copy_v3_fl3(float v[3], float x, float y, float z)
MINLINE void copy_v3_fl(float r[3], float f)
char * BLI_strdup(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL() ATTR_MALLOC
Definition: string.c:42
#define UNUSED(x)
@ ID_WO
Definition: DNA_ID_enums.h:59
@ ID_MA
Definition: DNA_ID_enums.h:51
@ SOCK_OUT
@ SOCK_IN
#define DRW_SHADER_LIB_FREE_SAFE(lib)
Definition: DRW_render.h:281
#define DRW_shader_create_fullscreen(frag, defines)
Definition: DRW_render.h:234
#define DRW_SHADER_LIB_ADD(lib, lib_name)
Definition: DRW_render.h:270
#define DRW_SHADER_FREE_SAFE(shader)
Definition: DRW_render.h:254
#define DRW_shader_create_with_shaderlib(vert, geom, frag, lib, defines)
Definition: DRW_render.h:232
#define DRW_shader_create_fullscreen_with_shaderlib(frag, lib, defines)
Definition: DRW_render.h:236
uint64_t GPU_material_uuid_get(GPUMaterial *mat)
Definition: gpu_material.c:619
void(* GPUCodegenCallbackFn)(void *thunk, GPUMaterial *mat, GPUCodegenOutput *codegen)
Definition: GPU_material.h:137
eGPUMaterialStatus GPU_material_status(GPUMaterial *mat)
Definition: gpu_material.c:574
@ GPU_MAT_QUEUED
Definition: GPU_material.h:116
@ GPU_MAT_FAILED
Definition: GPU_material.h:114
@ GPU_MAT_SUCCESS
Definition: GPU_material.h:117
struct GPUShader GPUShader
Definition: GPU_shader.h:20
Read Guarded memory(de)allocation.
#define MEM_SAFE_FREE(v)
struct bNodeTreeType * ntreeType_Shader
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue Hue Saturation Apply a color transformation in the HSV color model Specular Similar to the Principled BSDF node but uses the specular workflow instead of which functions by specifying the so the result may not be physically accurate SH_NODE_OUTPUT_WORLD
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a color
CCL_NAMESPACE_BEGIN struct Options options
Scene scene
GPUMaterial * DRW_shader_from_world(World *wo, struct bNodeTree *ntree, const uint64_t shader_id, const bool is_volume_shader, bool deferred, GPUCodegenCallbackFn callback, void *thunk)
GPUMaterial * DRW_shader_from_material(Material *ma, struct bNodeTree *ntree, const uint64_t shader_id, const bool is_volume_shader, bool deferred, GPUCodegenCallbackFn callback, void *thunk)
DRWShaderLibrary * DRW_shader_library_create(void)
char * DRW_shader_library_create_shader_string(const DRWShaderLibrary *lib, const char *shader_code)
define("MAT_AOV_SUPPORT") .image_array_out(6
EEVEE_DofGatherPass
@ DOF_GATHER_HOLEFILL
@ DOF_GATHER_FOREGROUND
@ DOF_GATHER_BACKGROUND
@ DOF_GATHER_MAX_PASS
@ VAR_WORLD_BACKGROUND
@ VAR_MAT_HOLDOUT
@ VAR_MAT_BLEND
@ VAR_MAT_HASH
@ VAR_MAT_DEPTH
@ VAR_DEFAULT
@ VAR_WORLD_PROBE
@ VAR_MAT_LOOKDEV
@ VAR_MAT_VOLUME
@ VAR_MAT_REFRACT
@ VAR_MAT_POINTCLOUD
@ VAR_MAT_MESH
@ VAR_MAT_HAIR
void eevee_shader_extra_exit(void)
void eevee_shader_material_create_info_amend(GPUMaterial *gpumat, GPUCodegenOutput *codegen, char *frag, char *vert, char *geom, char *defines)
#define DOF_SHADER_DEFINES
void eevee_shader_extra_init(void)
EEVEE_EffectsFlag
@ EFFECT_TAA_REPROJECT
#define SHADER_DEFINES
Definition: eevee_private.h:60
#define USE_VOLUME_OPTI
Definition: eevee_private.h:75
char datatoc_lightprobe_cube_display_frag_glsl[]
struct GPUShader * EEVEE_shaders_volumes_clear_sh_get()
GPUShader * EEVEE_shaders_effect_motion_blur_velocity_tiles_sh_get(void)
GPUShader * EEVEE_shaders_probe_planar_display_sh_get(void)
char datatoc_object_motion_vert_glsl[]
char datatoc_btdf_lut_frag_glsl[]
static char * eevee_get_geom(int options)
char datatoc_effect_dof_gather_frag_glsl[]
struct GPUShader * volumetric_clear_sh
GPUShader * EEVEE_shaders_effect_maxz_copydepth_sh_get(void)
char datatoc_lightprobe_grid_display_vert_glsl[]
GPUShader * EEVEE_shaders_ggx_refraction_lut_sh_get(void)
char datatoc_lightprobe_grid_display_frag_glsl[]
char datatoc_renderpass_lib_glsl[]
char datatoc_lightprobe_filter_diffuse_frag_glsl[]
struct GPUShader * probe_grid_display_sh
Definition: eevee_shaders.c:42
struct GPUShader * maxz_downdepth_sh
Definition: eevee_shaders.c:84
void EEVEE_shaders_free(void)
char datatoc_gpu_shader_codegen_lib_glsl[]
char datatoc_prepass_frag_glsl[]
char datatoc_effect_temporal_aa_glsl[]
struct GPUShader * dof_bokeh_sh
Definition: eevee_shaders.c:65
char datatoc_cubemap_lib_glsl[]
struct GPUShader * reflection_trace
char datatoc_volumetric_geom_glsl[]
DRWShaderLibrary * EEVEE_shader_lib_get(void)
char datatoc_closure_type_lib_glsl[]
char datatoc_surface_lib_glsl[]
char datatoc_background_vert_glsl[]
struct GPUShader * dof_downsample_sh
Definition: eevee_shaders.c:69
char datatoc_effect_downsample_cube_frag_glsl[]
GPUShader * EEVEE_shaders_effect_motion_blur_hair_sh_get(void)
struct GPUShader * probe_filter_diffuse_sh
Definition: eevee_shaders.c:46
GPUShader * EEVEE_shaders_depth_of_field_gather_get(EEVEE_DofGatherPass pass, bool b_use_bokeh_tx)
GPUShader * EEVEE_shaders_effect_motion_blur_object_sh_get(void)
char datatoc_surface_frag_glsl[]
char datatoc_closure_eval_lib_glsl[]
char datatoc_effect_velocity_tile_frag_glsl[]
char datatoc_effect_dof_lib_glsl[]
struct GPUShader * downsample_cube_sh
Definition: eevee_shaders.c:94
char datatoc_effect_dof_dilate_tiles_frag_glsl[]
bNodeSocketValueFloat * metallic_socket
GPUShader * EEVEE_shaders_effect_ambient_occlusion_debug_sh_get(void)
static char * eevee_get_defines(int options)
struct GPUShader * EEVEE_shaders_subsurface_second_pass_sh_get()
char datatoc_common_uniforms_lib_glsl[]
char datatoc_bsdf_lut_frag_glsl[]
struct GPUShader * motion_blur_hair_sh
struct GPUShader * taa_resolve_reproject_sh
Definition: eevee_shaders.c:56
char datatoc_effect_velocity_resolve_frag_glsl[]
char datatoc_shadow_vert_glsl[]
GPUShader * EEVEE_shaders_bloom_upsample_get(bool high_quality)
char datatoc_effect_gtao_frag_glsl[]
struct GPUShader * bloom_resolve_sh[2]
Definition: eevee_shaders.c:62
char datatoc_effect_dof_downsample_frag_glsl[]
char datatoc_cryptomatte_frag_glsl[]
GPUShader * EEVEE_shaders_depth_of_field_setup_get(void)
struct GPUShader * reflection_resolve
char datatoc_ssr_lib_glsl[]
struct GPUShader * velocity_tiles_sh
char datatoc_effect_dof_filter_frag_glsl[]
char datatoc_effect_dof_bokeh_frag_glsl[]
char datatoc_irradiance_lib_glsl[]
char datatoc_closure_eval_diffuse_lib_glsl[]
char datatoc_effect_motion_blur_frag_glsl[]
GPUShader * EEVEE_shaders_taa_resolve_sh_get(EEVEE_EffectsFlag enabled_effects)
char datatoc_effect_subsurface_frag_glsl[]
char datatoc_lightprobe_cube_display_vert_glsl[]
struct GPUShader * velocity_tiles_expand_sh
char datatoc_volumetric_resolve_frag_glsl[]
World * EEVEE_world_default_get(void)
GPUShader * EEVEE_shaders_bloom_resolve_get(bool high_quality)
static const char * filter_defines
Definition: eevee_shaders.c:29
struct GPUShader * EEVEE_shaders_volumes_scatter_with_lights_sh_get()
GPUShader * EEVEE_shaders_studiolight_background_sh_get(void)
char datatoc_cryptomatte_lib_glsl[]
struct GPUShader * minz_downdepth_sh
Definition: eevee_shaders.c:83
char datatoc_effect_reflection_lib_glsl[]
char datatoc_common_utiltex_lib_glsl[]
struct GPUShader * update_noise_sh
Definition: eevee_shaders.c:78
struct GPUShader * bloom_downsample_sh[2]
Definition: eevee_shaders.c:60
GPUShader * EEVEE_shaders_probe_filter_diffuse_sh_get(void)
struct GPUShader * maxz_downdepth_layer_sh
Definition: eevee_shaders.c:86
struct GPUShader * dof_gather_sh[DOF_GATHER_MAX_PASS][2]
Definition: eevee_shaders.c:71
struct GPUShader * ggx_refraction_lut_sh
GPUShader * EEVEE_shaders_depth_of_field_reduce_get(bool b_is_copy_pass)
static struct GPUMaterial * eevee_material_get_ex(struct Scene *UNUSED(scene), Material *ma, World *wo, int options, bool deferred)
struct GPUShader * maxz_copydepth_layer_sh
Definition: eevee_shaders.c:87
char datatoc_volumetric_scatter_frag_glsl[]
GPUShader * EEVEE_shaders_bloom_downsample_get(bool high_quality)
GPUShader * EEVEE_shaders_depth_of_field_flatten_tiles_get(void)
struct GPUShader * gtao_debug_sh
struct GPUShader * volumetric_integration_sh
struct GPUShader * shadow_accum_sh
struct GPUShader * bloom_upsample_sh[2]
Definition: eevee_shaders.c:61
GPUShader * EEVEE_shaders_effect_downsample_sh_get(void)
GPUShader * EEVEE_shaders_effect_mist_sh_get(void)
struct GPUShader * gtao_sh
Material * EEVEE_material_default_diffuse_get(void)
struct GPUShader * maxz_downlevel_sh
Definition: eevee_shaders.c:82
Material * error_mat
struct GPUShader * shadow_sh
GPUShader * EEVEE_shaders_effect_minz_downdepth_sh_get(void)
GPUShader * EEVEE_shaders_effect_ambient_occlusion_sh_get(void)
char datatoc_effect_mist_frag_glsl[]
char * surface_geom_barycentric
struct GPUShader * EEVEE_shaders_effect_reflection_trace_sh_get(void)
struct GPUShader * dof_reduce_sh[2]
Definition: eevee_shaders.c:70
static struct @211 e_data
char datatoc_effect_dof_resolve_frag_glsl[]
char datatoc_lightprobe_planar_display_vert_glsl[]
GPUShader * EEVEE_shaders_probe_filter_glossy_sh_get(void)
char datatoc_lightprobe_planar_downsample_frag_glsl[]
Material * EEVEE_material_default_glossy_get(void)
struct GPUShader * EEVEE_shaders_effect_reflection_resolve_sh_get(void)
struct GPUShader * EEVEE_shaders_subsurface_translucency_sh_get()
struct GPUShader * dof_dilate_tiles_sh[2]
Definition: eevee_shaders.c:68
struct GPUShader * probe_grid_fill_sh
Definition: eevee_shaders.c:48
char datatoc_ltc_lib_glsl[]
GPUShader * EEVEE_shaders_effect_maxz_downdepth_layer_sh_get(void)
struct bNodeTree * EEVEE_shader_default_surface_nodetree(Material *ma)
char datatoc_effect_dof_setup_frag_glsl[]
struct GPUShader * cryptomatte_sh[2]
char datatoc_common_hair_lib_glsl[]
Definition: draw_shader.cc:19
char datatoc_surface_vert_glsl[]
char datatoc_lightprobe_filter_visibility_frag_glsl[]
GPUShader * EEVEE_shaders_effect_minz_copydepth_sh_get(void)
GPUShader * EEVEE_shaders_depth_of_field_resolve_get(bool b_use_bokeh_tx, bool b_use_hq_gather)
char datatoc_effect_dof_flatten_tiles_frag_glsl[]
char datatoc_effect_minmaxz_frag_glsl[]
char datatoc_common_view_lib_glsl[]
struct GPUShader * postprocess_sh
char datatoc_world_vert_glsl[]
char * surface_lit_frag
static char * eevee_get_vert(int options)
struct GPUShader * ggx_lut_sh
GPUShader * EEVEE_shaders_effect_maxz_downlevel_sh_get(void)
Material * diffuse_mat
char datatoc_effect_reflection_trace_frag_glsl[]
char datatoc_lightprobe_planar_downsample_vert_glsl[]
struct GPUShader * gtao_layer_sh
struct GPUMaterial * EEVEE_material_default_get(struct Scene *scene, Material *ma, int options)
char datatoc_default_frag_glsl[]
char datatoc_lightprobe_planar_downsample_geom_glsl[]
char datatoc_update_noise_frag_glsl[]
struct GPUShader * motion_blur_object_sh
struct bNodeTree * EEVEE_shader_default_world_nodetree(World *wo)
struct GPUShader * sss_sh[3]
struct GPUShader * probe_planar_downsample_sh
Definition: eevee_shaders.c:49
struct GPUShader * dof_flatten_tiles_sh
Definition: eevee_shaders.c:67
char datatoc_effect_dof_scatter_frag_glsl[]
char datatoc_random_lib_glsl[]
char * surface_prepass_frag
GPUShader * EEVEE_shaders_effect_minz_downlevel_sh_get(void)
GPUShader * EEVEE_shaders_probe_cube_display_sh_get(void)
GPUShader * EEVEE_shaders_probe_grid_fill_sh_get(void)
bNodeTree * ntree
struct GPUShader * mist_sh
Definition: eevee_shaders.c:97
static char * eevee_get_frag(int options)
struct GPUShader * studiolight_probe_sh
Definition: eevee_shaders.c:38
struct GPUShader * probe_cube_display_sh
Definition: eevee_shaders.c:43
char datatoc_common_math_lib_glsl[]
DRWShaderLibrary * lib
GPUShader * EEVEE_shaders_bloom_blit_get(bool high_quality)
char datatoc_lightprobe_grid_fill_frag_glsl[]
GPUShader * EEVEE_shaders_effect_maxz_copydepth_layer_sh_get(void)
GPUShader * EEVEE_shaders_update_noise_sh_get(void)
GPUShader * EEVEE_shaders_studiolight_probe_sh_get(void)
struct GPUShader * bloom_blit_sh[2]
Definition: eevee_shaders.c:59
char datatoc_bsdf_sampling_lib_glsl[]
struct GPUShader * probe_planar_display_sh
Definition: eevee_shaders.c:44
struct GPUShader * volumetric_accum_sh
struct GPUShader * minz_downlevel_sh
Definition: eevee_shaders.c:81
char datatoc_lightprobe_lib_glsl[]
char datatoc_shadow_frag_glsl[]
GPUShader * EEVEE_shaders_effect_downsample_cube_sh_get(void)
struct @211::@213 world
struct GPUShader * EEVEE_shaders_shadow_accum_sh_get()
struct GPUShader * EEVEE_shaders_volumes_integration_sh_get()
struct GPUShader * probe_filter_visibility_sh
Definition: eevee_shaders.c:47
struct GPUShader * downsample_sh
Definition: eevee_shaders.c:93
struct GPUShader * motion_blur_sh
GPUShader * EEVEE_shaders_depth_of_field_bokeh_get(void)
GPUShader * EEVEE_shaders_ggx_lut_sh_get(void)
char datatoc_surface_geom_glsl[]
struct GPUShader * taa_resolve_sh
Definition: eevee_shaders.c:55
#define TILE_SIZE_STR
struct @211::@212 surface
struct GPUShader * EEVEE_shaders_volumes_accum_sh_get()
struct GPUMaterial * EEVEE_material_get(EEVEE_Data *vedata, struct Scene *scene, Material *ma, World *wo, int options)
bNodeSocketValueFloat * specular_socket
Material * EEVEE_material_default_error_get(void)
struct GPUShader * dof_setup_sh
Definition: eevee_shaders.c:66
struct GPUShader * studiolight_background_sh
Definition: eevee_shaders.c:39
Material * glossy_mat
char datatoc_raytrace_lib_glsl[]
GPUShader * EEVEE_shaders_depth_of_field_filter_get(void)
char datatoc_effect_bloom_frag_glsl[]
char datatoc_closure_eval_translucent_lib_glsl[]
struct GPUShader * EEVEE_shaders_subsurface_first_pass_sh_get()
struct GPUShader * velocity_resolve_sh
Definition: eevee_shaders.c:52
char datatoc_octahedron_lib_glsl[]
struct GPUShader * maxz_copydepth_sh
Definition: eevee_shaders.c:89
GPUShader * EEVEE_shaders_velocity_resolve_sh_get(void)
GPUShader * EEVEE_shaders_renderpasses_post_process_sh_get(void)
char datatoc_closure_eval_surface_lib_glsl[]
char datatoc_object_motion_frag_glsl[]
GPUShader * EEVEE_shaders_cryptomatte_sh_get(bool is_hair)
char datatoc_bsdf_common_lib_glsl[]
GPUShader * EEVEE_shaders_effect_minz_downdepth_layer_sh_get(void)
bNodeSocketValueRGBA * color_socket
char datatoc_lightprobe_planar_display_frag_glsl[]
char datatoc_lightprobe_filter_glossy_frag_glsl[]
GPUShader * EEVEE_shaders_depth_of_field_dilate_tiles_get(bool b_pass)
GPUShader * EEVEE_shaders_effect_maxz_downdepth_sh_get(void)
GPUShader * EEVEE_shaders_probe_grid_display_sh_get(void)
struct GPUShader * scatter_with_lights_sh
struct GPUShader * EEVEE_shaders_volumes_resolve_sh_get(bool accum)
struct GPUShader * color_copy_sh
Definition: eevee_shaders.c:92
GPUShader * EEVEE_shaders_effect_motion_blur_sh_get(void)
static void eevee_material_post_eval(void *UNUSED(thunk), GPUMaterial *mat, GPUCodegenOutput *codegen)
struct GPUShader * minz_copydepth_sh
Definition: eevee_shaders.c:88
GPUShader * EEVEE_shaders_probe_planar_downsample_sh_get(void)
GPUShader * EEVEE_shaders_effect_color_copy_sh_get(void)
char datatoc_volumetric_integration_frag_glsl[]
struct GPUShader * dof_scatter_sh[2][2]
Definition: eevee_shaders.c:73
char datatoc_lookdev_world_frag_glsl[]
char datatoc_closure_eval_volume_lib_glsl[]
char datatoc_cryptomatte_vert_glsl[]
char datatoc_lights_lib_glsl[]
struct GPUShader * dof_filter_sh
Definition: eevee_shaders.c:72
char datatoc_effect_reflection_resolve_frag_glsl[]
char datatoc_volumetric_frag_glsl[]
char datatoc_volumetric_vert_glsl[]
char datatoc_lightprobe_geom_glsl[]
char datatoc_effect_dof_reduce_frag_glsl[]
struct GPUShader * minz_downdepth_layer_sh
Definition: eevee_shaders.c:85
World * default_world
char datatoc_volumetric_accum_frag_glsl[]
bNodeSocketValueFloat * roughness_socket
char datatoc_effect_downsample_frag_glsl[]
struct GPUShader * probe_filter_glossy_sh
Definition: eevee_shaders.c:45
char datatoc_ambient_occlusion_lib_glsl[]
char datatoc_shadow_accum_frag_glsl[]
GPUShader * EEVEE_shaders_probe_filter_visibility_sh_get(void)
char datatoc_renderpass_postprocess_frag_glsl[]
struct GPUShader * dof_resolve_sh[2][2]
Definition: eevee_shaders.c:74
char datatoc_volumetric_lib_glsl[]
char datatoc_common_math_geom_lib_glsl[]
GPUShader * EEVEE_shaders_depth_of_field_scatter_get(bool b_is_foreground, bool b_use_bokeh_tx)
char datatoc_effect_translucency_frag_glsl[]
struct GPUShader * scatter_sh
void EEVEE_shaders_material_shaders_init(void)
char datatoc_closure_eval_refraction_lib_glsl[]
GPUShader * EEVEE_shaders_depth_of_field_downsample_get(void)
char datatoc_lightprobe_vert_glsl[]
static void eevee_shader_library_ensure(void)
struct GPUShader * volumetric_resolve_sh[2]
struct GPUShader * EEVEE_shaders_shadow_sh_get()
struct GPUShader * EEVEE_shaders_volumes_scatter_sh_get()
GPUShader * EEVEE_shaders_effect_motion_blur_velocity_tiles_expand_sh_get(void)
struct GPUShader * lookdev_background
Definition: eevee_shaders.c:77
char datatoc_closure_eval_glossy_lib_glsl[]
char datatoc_effect_dof_scatter_vert_glsl[]
#define str(s)
ccl_global KernelShaderEvalInput ccl_global float * output
ccl_gpu_kernel_postfix ccl_global float int int int int sh
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
static const pxr::TfToken roughness("roughness", pxr::TfToken::Immortal)
unsigned __int64 uint64_t
Definition: stdint.h:90
EEVEE_StorageList * stl
struct EEVEE_PrivateData * g_data
Material * ma
Definition: gpu_material.c:71
eGPUMaterialStatus status
Definition: gpu_material.c:57
struct bNodeTree * nodetree
struct bNodeTree * nodetree
float horg
short use_nodes
float horb
float horr
void * default_value
char idname[64]
Definition: BKE_node.h:375