Improve formating

This is a prototype to support `#include` directive inside glsl sources.
The sources are aggregated into a list before being translated to byte_array.
This list is used to generate a mapping between the filename and the
associated byte_array. For each byte_array, we search for any `#include`
and store the file to merge.

At runtime, for one input filename we concatenate all byte_arrays that
are needed following the include order and avoiding double include.

This is meant to evolve into a fully supported `#include` system.

.clang-format

@@ -269,5 +269,9 @@ StatementMacros:
   - PyObject_HEAD
   - PyObject_VAR_HEAD
 
+StatementMacros:
+  - GPU_STAGE_INTERFACE_CREATE
+  - GPU_SHADER_DESCRIPTOR
+
 MacroBlockBegin: "^BSDF_CLOSURE_CLASS_BEGIN$"
 MacroBlockEnd: "^BSDF_CLOSURE_CLASS_END$"

source/blender/draw/CMakeLists.txt

@@ -237,256 +237,283 @@ set(LIB
   bf_windowmanager
 )
 
-data_to_c_simple(engines/eevee/shaders/ambient_occlusion_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/background_vert.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/common_uniforms_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/common_utiltex_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lights_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lightprobe_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lightprobe_filter_glossy_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lightprobe_filter_diffuse_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lightprobe_filter_visibility_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lightprobe_geom.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lightprobe_vert.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lightprobe_cube_display_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lightprobe_cube_display_vert.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lightprobe_grid_display_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lightprobe_grid_display_vert.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lightprobe_grid_fill_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lightprobe_planar_display_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lightprobe_planar_display_vert.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lookdev_world_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/closure_eval_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/closure_eval_diffuse_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/closure_eval_glossy_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/closure_eval_refraction_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/closure_eval_translucent_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/closure_type_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_bloom_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_dof_bokeh_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_dof_dilate_tiles_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_dof_downsample_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_dof_filter_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_dof_flatten_tiles_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_dof_gather_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_dof_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_dof_reduce_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_dof_resolve_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_dof_scatter_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_dof_scatter_vert.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_dof_setup_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_reflection_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_reflection_resolve_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_reflection_trace_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_downsample_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_downsample_cube_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_gtao_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_velocity_resolve_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_velocity_tile_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_minmaxz_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_mist_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_motion_blur_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_subsurface_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_translucency_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/effect_temporal_aa.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lightprobe_planar_downsample_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lightprobe_planar_downsample_geom.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/lightprobe_planar_downsample_vert.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/object_motion_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/object_motion_vert.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/prepass_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/prepass_vert.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/shadow_accum_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/shadow_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/shadow_vert.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/bsdf_lut_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/btdf_lut_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/bsdf_common_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/irradiance_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/octahedron_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/cubemap_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/bsdf_sampling_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/random_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/raytrace_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/renderpass_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/renderpass_postprocess_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/cryptomatte_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/ltc_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/ssr_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/surface_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/surface_geom.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/surface_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/surface_vert.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/update_noise_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/volumetric_accum_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/volumetric_lib.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/volumetric_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/volumetric_geom.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/volumetric_vert.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/volumetric_resolve_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/volumetric_scatter_frag.glsl SRC)
-data_to_c_simple(engines/eevee/shaders/volumetric_integration_frag.glsl SRC)
+set(GLSL_SRC
+  engines/eevee/shaders/ambient_occlusion_lib.glsl
+  engines/eevee/shaders/background_vert.glsl
+  engines/eevee/shaders/common_uniforms_lib.glsl
+  engines/eevee/shaders/common_utiltex_lib.glsl
+  engines/eevee/shaders/lights_lib.glsl
+  engines/eevee/shaders/lightprobe_lib.glsl
+  engines/eevee/shaders/lightprobe_filter_glossy_frag.glsl
+  engines/eevee/shaders/lightprobe_filter_diffuse_frag.glsl
+  engines/eevee/shaders/lightprobe_filter_visibility_frag.glsl
+  engines/eevee/shaders/lightprobe_geom.glsl
+  engines/eevee/shaders/lightprobe_vert.glsl
+  engines/eevee/shaders/lightprobe_cube_display_frag.glsl
+  engines/eevee/shaders/lightprobe_cube_display_vert.glsl
+  engines/eevee/shaders/lightprobe_grid_display_frag.glsl
+  engines/eevee/shaders/lightprobe_grid_display_vert.glsl
+  engines/eevee/shaders/lightprobe_grid_fill_frag.glsl
+  engines/eevee/shaders/lightprobe_planar_display_frag.glsl
+  engines/eevee/shaders/lightprobe_planar_display_vert.glsl
+  engines/eevee/shaders/lookdev_world_frag.glsl
+  engines/eevee/shaders/closure_eval_lib.glsl
+  engines/eevee/shaders/closure_eval_diffuse_lib.glsl
+  engines/eevee/shaders/closure_eval_glossy_lib.glsl
+  engines/eevee/shaders/closure_eval_refraction_lib.glsl
+  engines/eevee/shaders/closure_eval_translucent_lib.glsl
+  engines/eevee/shaders/closure_type_lib.glsl
+  engines/eevee/shaders/effect_bloom_frag.glsl
+  engines/eevee/shaders/effect_dof_bokeh_frag.glsl
+  engines/eevee/shaders/effect_dof_dilate_tiles_frag.glsl
+  engines/eevee/shaders/effect_dof_downsample_frag.glsl
+  engines/eevee/shaders/effect_dof_filter_frag.glsl
+  engines/eevee/shaders/effect_dof_flatten_tiles_frag.glsl
+  engines/eevee/shaders/effect_dof_gather_frag.glsl
+  engines/eevee/shaders/effect_dof_lib.glsl
+  engines/eevee/shaders/effect_dof_reduce_frag.glsl
+  engines/eevee/shaders/effect_dof_resolve_frag.glsl
+  engines/eevee/shaders/effect_dof_scatter_frag.glsl
+  engines/eevee/shaders/effect_dof_scatter_vert.glsl
+  engines/eevee/shaders/effect_dof_setup_frag.glsl
+  engines/eevee/shaders/effect_reflection_lib.glsl
+  engines/eevee/shaders/effect_reflection_resolve_frag.glsl
+  engines/eevee/shaders/effect_reflection_trace_frag.glsl
+  engines/eevee/shaders/effect_downsample_frag.glsl
+  engines/eevee/shaders/effect_downsample_cube_frag.glsl
+  engines/eevee/shaders/effect_gtao_frag.glsl
+  engines/eevee/shaders/effect_velocity_resolve_frag.glsl
+  engines/eevee/shaders/effect_velocity_tile_frag.glsl
+  engines/eevee/shaders/effect_minmaxz_frag.glsl
+  engines/eevee/shaders/effect_mist_frag.glsl
+  engines/eevee/shaders/effect_motion_blur_frag.glsl
+  engines/eevee/shaders/effect_subsurface_frag.glsl
+  engines/eevee/shaders/effect_translucency_frag.glsl
+  engines/eevee/shaders/effect_temporal_aa.glsl
+  engines/eevee/shaders/lightprobe_planar_downsample_frag.glsl
+  engines/eevee/shaders/lightprobe_planar_downsample_geom.glsl
+  engines/eevee/shaders/lightprobe_planar_downsample_vert.glsl
+  engines/eevee/shaders/object_motion_frag.glsl
+  engines/eevee/shaders/object_motion_vert.glsl
+  engines/eevee/shaders/prepass_frag.glsl
+  engines/eevee/shaders/prepass_vert.glsl
+  engines/eevee/shaders/shadow_accum_frag.glsl
+  engines/eevee/shaders/shadow_frag.glsl
+  engines/eevee/shaders/shadow_vert.glsl
+  engines/eevee/shaders/bsdf_lut_frag.glsl
+  engines/eevee/shaders/btdf_lut_frag.glsl
+  engines/eevee/shaders/bsdf_common_lib.glsl
+  engines/eevee/shaders/irradiance_lib.glsl
+  engines/eevee/shaders/octahedron_lib.glsl
+  engines/eevee/shaders/cubemap_lib.glsl
+  engines/eevee/shaders/bsdf_sampling_lib.glsl
+  engines/eevee/shaders/random_lib.glsl
+  engines/eevee/shaders/raytrace_lib.glsl
+  engines/eevee/shaders/renderpass_lib.glsl
+  engines/eevee/shaders/renderpass_postprocess_frag.glsl
+  engines/eevee/shaders/cryptomatte_frag.glsl
+  engines/eevee/shaders/ltc_lib.glsl
+  engines/eevee/shaders/ssr_lib.glsl
+  engines/eevee/shaders/surface_frag.glsl
+  engines/eevee/shaders/surface_geom.glsl
+  engines/eevee/shaders/surface_lib.glsl
+  engines/eevee/shaders/surface_vert.glsl
+  engines/eevee/shaders/update_noise_frag.glsl
+  engines/eevee/shaders/volumetric_accum_frag.glsl
+  engines/eevee/shaders/volumetric_lib.glsl
+  engines/eevee/shaders/volumetric_frag.glsl
+  engines/eevee/shaders/volumetric_geom.glsl
+  engines/eevee/shaders/volumetric_vert.glsl
+  engines/eevee/shaders/volumetric_resolve_frag.glsl
+  engines/eevee/shaders/volumetric_scatter_frag.glsl
+  engines/eevee/shaders/volumetric_integration_frag.glsl
 
-data_to_c_simple(engines/workbench/shaders/workbench_cavity_lib.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_common_lib.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_composite_frag.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_curvature_lib.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_data_lib.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_effect_cavity_frag.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_effect_dof_frag.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_effect_outline_frag.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_effect_smaa_frag.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_effect_smaa_vert.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_effect_taa_frag.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_image_lib.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_matcap_lib.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_material_lib.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_merge_infront_frag.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_prepass_frag.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_prepass_hair_vert.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_prepass_pointcloud_vert.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_prepass_vert.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_shader_interface_lib.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_shadow_caps_geom.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_shadow_debug_frag.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_shadow_geom.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_shadow_vert.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_transparent_accum_frag.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_transparent_resolve_frag.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_volume_frag.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_volume_vert.glsl SRC)
-data_to_c_simple(engines/workbench/shaders/workbench_world_light_lib.glsl SRC)
+  engines/workbench/shaders/workbench_cavity_lib.glsl
+  engines/workbench/shaders/workbench_common_lib.glsl
+  engines/workbench/shaders/workbench_composite_frag.glsl
+  engines/workbench/shaders/workbench_curvature_lib.glsl
+  engines/workbench/shaders/workbench_data_lib.glsl
+  engines/workbench/shaders/workbench_effect_cavity_frag.glsl
+  engines/workbench/shaders/workbench_effect_dof_frag.glsl
+  engines/workbench/shaders/workbench_effect_outline_frag.glsl
+  engines/workbench/shaders/workbench_effect_smaa_frag.glsl
+  engines/workbench/shaders/workbench_effect_smaa_vert.glsl
+  engines/workbench/shaders/workbench_effect_taa_frag.glsl
+  engines/workbench/shaders/workbench_image_lib.glsl
+  engines/workbench/shaders/workbench_matcap_lib.glsl
+  engines/workbench/shaders/workbench_material_lib.glsl
+  engines/workbench/shaders/workbench_merge_infront_frag.glsl
+  engines/workbench/shaders/workbench_prepass_frag.glsl
+  engines/workbench/shaders/workbench_prepass_hair_vert.glsl
+  engines/workbench/shaders/workbench_prepass_pointcloud_vert.glsl
+  engines/workbench/shaders/workbench_prepass_vert.glsl
+  engines/workbench/shaders/workbench_shader_interface_lib.glsl
+  engines/workbench/shaders/workbench_shadow_caps_geom.glsl
+  engines/workbench/shaders/workbench_shadow_debug_frag.glsl
+  engines/workbench/shaders/workbench_shadow_geom.glsl
+  engines/workbench/shaders/workbench_shadow_vert.glsl
+  engines/workbench/shaders/workbench_transparent_accum_frag.glsl
+  engines/workbench/shaders/workbench_transparent_resolve_frag.glsl
+  engines/workbench/shaders/workbench_volume_frag.glsl
+  engines/workbench/shaders/workbench_volume_vert.glsl
+  engines/workbench/shaders/workbench_world_light_lib.glsl
 
-data_to_c_simple(intern/shaders/common_colormanagement_lib.glsl SRC)
-data_to_c_simple(intern/shaders/common_globals_lib.glsl SRC)
-data_to_c_simple(intern/shaders/common_pointcloud_lib.glsl SRC)
-data_to_c_simple(intern/shaders/common_hair_lib.glsl SRC)
-data_to_c_simple(intern/shaders/common_hair_refine_vert.glsl SRC)
-data_to_c_simple(intern/shaders/common_hair_refine_comp.glsl SRC)
-data_to_c_simple(intern/shaders/common_math_lib.glsl SRC)
-data_to_c_simple(intern/shaders/common_math_geom_lib.glsl SRC)
-data_to_c_simple(intern/shaders/common_view_lib.glsl SRC)
-data_to_c_simple(intern/shaders/common_fxaa_lib.glsl SRC)
-data_to_c_simple(intern/shaders/common_smaa_lib.glsl SRC)
-data_to_c_simple(intern/shaders/common_fullscreen_vert.glsl SRC)
+  intern/shaders/common_colormanagement_lib.glsl
+  intern/shaders/common_globals_lib.glsl
+  intern/shaders/common_pointcloud_lib.glsl
+  intern/shaders/common_hair_lib.glsl
+  intern/shaders/common_hair_refine_vert.glsl
+  intern/shaders/common_hair_refine_comp.glsl
+  intern/shaders/common_math_lib.glsl
+  intern/shaders/common_math_geom_lib.glsl
+  intern/shaders/common_view_lib.glsl
+  intern/shaders/common_fxaa_lib.glsl
+  intern/shaders/common_smaa_lib.glsl
+  intern/shaders/common_fullscreen_vert.glsl
 
-data_to_c_simple(engines/gpencil/shaders/gpencil_frag.glsl SRC)
-data_to_c_simple(engines/gpencil/shaders/gpencil_vert.glsl SRC)
-data_to_c_simple(engines/gpencil/shaders/gpencil_antialiasing_frag.glsl SRC)
-data_to_c_simple(engines/gpencil/shaders/gpencil_antialiasing_vert.glsl SRC)
-data_to_c_simple(engines/gpencil/shaders/gpencil_common_lib.glsl SRC)
-data_to_c_simple(engines/gpencil/shaders/gpencil_layer_blend_frag.glsl SRC)
-data_to_c_simple(engines/gpencil/shaders/gpencil_mask_invert_frag.glsl SRC)
-data_to_c_simple(engines/gpencil/shaders/gpencil_depth_merge_frag.glsl SRC)
-data_to_c_simple(engines/gpencil/shaders/gpencil_depth_merge_vert.glsl SRC)
-data_to_c_simple(engines/gpencil/shaders/gpencil_vfx_frag.glsl SRC)
+  engines/gpencil/shaders/gpencil_frag.glsl
+  engines/gpencil/shaders/gpencil_vert.glsl
+  engines/gpencil/shaders/gpencil_antialiasing_frag.glsl
+  engines/gpencil/shaders/gpencil_antialiasing_vert.glsl
+  engines/gpencil/shaders/gpencil_common_lib.glsl
+  engines/gpencil/shaders/gpencil_layer_blend_frag.glsl
+  engines/gpencil/shaders/gpencil_mask_invert_frag.glsl
+  engines/gpencil/shaders/gpencil_depth_merge_frag.glsl
+  engines/gpencil/shaders/gpencil_depth_merge_vert.glsl
+  engines/gpencil/shaders/gpencil_vfx_frag.glsl
 
-data_to_c_simple(engines/select/shaders/selection_id_3D_vert.glsl SRC)
-data_to_c_simple(engines/select/shaders/selection_id_frag.glsl SRC)
+  engines/select/shaders/selection_id_3D_vert.glsl
+  engines/select/shaders/selection_id_frag.glsl
 
-data_to_c_simple(engines/basic/shaders/conservative_depth_geom.glsl SRC)
-data_to_c_simple(engines/basic/shaders/depth_vert.glsl SRC)
-data_to_c_simple(engines/basic/shaders/depth_frag.glsl SRC)
+  engines/basic/shaders/conservative_depth_geom.glsl
+  engines/basic/shaders/depth_vert.glsl
+  engines/basic/shaders/depth_frag.glsl
 
-data_to_c_simple(engines/overlay/shaders/common_overlay_lib.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/antialiasing_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/antialiasing_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/armature_dof_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/armature_dof_solid_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/armature_envelope_outline_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/armature_envelope_solid_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/armature_envelope_solid_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/armature_shape_outline_geom.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/armature_shape_outline_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/armature_shape_solid_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/armature_shape_solid_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/armature_shape_wire_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/armature_sphere_outline_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/armature_sphere_solid_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/armature_sphere_solid_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/armature_stick_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/armature_stick_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/armature_wire_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/armature_wire_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/background_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/clipbound_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/depth_only_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_curve_handle_geom.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_curve_handle_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_curve_point_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_curve_wire_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_gpencil_canvas_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_gpencil_guide_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_gpencil_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_lattice_point_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_lattice_wire_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_mesh_common_lib.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_mesh_facefill_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_mesh_facefill_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_mesh_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_mesh_geom.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_mesh_normal_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_mesh_analysis_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_mesh_analysis_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_mesh_skin_root_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_mesh_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_particle_strand_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_particle_point_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_uv_edges_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_uv_edges_geom.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_uv_edges_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_uv_verts_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_uv_verts_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_uv_faces_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_uv_face_dots_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_uv_image_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_uv_image_mask_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_uv_stretching_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/edit_uv_tiled_image_borders_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/extra_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/extra_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/extra_groundline_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/extra_lightprobe_grid_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/extra_loose_point_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/extra_loose_point_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/extra_point_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/extra_wire_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/extra_wire_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/facing_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/facing_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/grid_background_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/grid_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/grid_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/image_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/image_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/motion_path_line_geom.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/motion_path_line_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/motion_path_point_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/outline_detect_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/outline_prepass_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/outline_prepass_geom.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/outline_prepass_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/paint_face_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/paint_point_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/paint_texture_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/paint_texture_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/paint_vertcol_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/paint_vertcol_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/paint_weight_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/paint_weight_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/paint_wire_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/particle_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/particle_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/sculpt_mask_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/sculpt_mask_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/volume_velocity_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/volume_gridlines_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/wireframe_vert.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/wireframe_frag.glsl SRC)
-data_to_c_simple(engines/overlay/shaders/xray_fade_frag.glsl SRC)
+  engines/overlay/shaders/common_overlay_lib.glsl
+  engines/overlay/shaders/antialiasing_frag.glsl
+  engines/overlay/shaders/antialiasing_vert.glsl
+  engines/overlay/shaders/armature_dof_vert.glsl
+  engines/overlay/shaders/armature_dof_solid_frag.glsl
+  engines/overlay/shaders/armature_envelope_outline_vert.glsl
+  engines/overlay/shaders/armature_envelope_solid_frag.glsl
+  engines/overlay/shaders/armature_envelope_solid_vert.glsl
+  engines/overlay/shaders/armature_shape_outline_geom.glsl
+  engines/overlay/shaders/armature_shape_outline_vert.glsl
+  engines/overlay/shaders/armature_shape_solid_frag.glsl
+  engines/overlay/shaders/armature_shape_solid_vert.glsl
+  engines/overlay/shaders/armature_shape_wire_vert.glsl
+  engines/overlay/shaders/armature_sphere_outline_vert.glsl
+  engines/overlay/shaders/armature_sphere_solid_frag.glsl
+  engines/overlay/shaders/armature_sphere_solid_vert.glsl
+  engines/overlay/shaders/armature_stick_frag.glsl
+  engines/overlay/shaders/armature_stick_vert.glsl
+  engines/overlay/shaders/armature_wire_frag.glsl
+  engines/overlay/shaders/armature_wire_vert.glsl
+  engines/overlay/shaders/background_frag.glsl
+  engines/overlay/shaders/clipbound_vert.glsl
+  engines/overlay/shaders/depth_only_vert.glsl
+  engines/overlay/shaders/edit_curve_handle_geom.glsl
+  engines/overlay/shaders/edit_curve_handle_vert.glsl
+  engines/overlay/shaders/edit_curve_point_vert.glsl
+  engines/overlay/shaders/edit_curve_wire_vert.glsl
+  engines/overlay/shaders/edit_gpencil_canvas_vert.glsl
+  engines/overlay/shaders/edit_gpencil_guide_vert.glsl
+  engines/overlay/shaders/edit_gpencil_vert.glsl
+  engines/overlay/shaders/edit_lattice_point_vert.glsl
+  engines/overlay/shaders/edit_lattice_wire_vert.glsl
+  engines/overlay/shaders/edit_mesh_common_lib.glsl
+  engines/overlay/shaders/edit_mesh_facefill_frag.glsl
+  engines/overlay/shaders/edit_mesh_facefill_vert.glsl
+  engines/overlay/shaders/edit_mesh_frag.glsl
+  engines/overlay/shaders/edit_mesh_geom.glsl
+  engines/overlay/shaders/edit_mesh_normal_vert.glsl
+  engines/overlay/shaders/edit_mesh_analysis_frag.glsl
+  engines/overlay/shaders/edit_mesh_analysis_vert.glsl
+  engines/overlay/shaders/edit_mesh_skin_root_vert.glsl
+  engines/overlay/shaders/edit_mesh_vert.glsl
+  engines/overlay/shaders/edit_particle_strand_vert.glsl
+  engines/overlay/shaders/edit_particle_point_vert.glsl
+  engines/overlay/shaders/edit_uv_edges_vert.glsl
+  engines/overlay/shaders/edit_uv_edges_geom.glsl
+  engines/overlay/shaders/edit_uv_edges_frag.glsl
+  engines/overlay/shaders/edit_uv_verts_vert.glsl
+  engines/overlay/shaders/edit_uv_verts_frag.glsl
+  engines/overlay/shaders/edit_uv_faces_vert.glsl
+  engines/overlay/shaders/edit_uv_face_dots_vert.glsl
+  engines/overlay/shaders/edit_uv_image_vert.glsl
+  engines/overlay/shaders/edit_uv_image_mask_frag.glsl
+  engines/overlay/shaders/edit_uv_stretching_vert.glsl
+  engines/overlay/shaders/edit_uv_tiled_image_borders_vert.glsl
+  engines/overlay/shaders/extra_frag.glsl
+  engines/overlay/shaders/extra_vert.glsl
+  engines/overlay/shaders/extra_groundline_vert.glsl
+  engines/overlay/shaders/extra_lightprobe_grid_vert.glsl
+  engines/overlay/shaders/extra_loose_point_frag.glsl
+  engines/overlay/shaders/extra_loose_point_vert.glsl
+  engines/overlay/shaders/extra_point_vert.glsl
+  engines/overlay/shaders/extra_wire_frag.glsl
+  engines/overlay/shaders/extra_wire_vert.glsl
+  engines/overlay/shaders/facing_frag.glsl
+  engines/overlay/shaders/facing_vert.glsl
+  engines/overlay/shaders/grid_background_frag.glsl
+  engines/overlay/shaders/grid_frag.glsl
+  engines/overlay/shaders/grid_vert.glsl
+  engines/overlay/shaders/image_vert.glsl
+  engines/overlay/shaders/image_frag.glsl
+  engines/overlay/shaders/motion_path_line_geom.glsl
+  engines/overlay/shaders/motion_path_line_vert.glsl
+  engines/overlay/shaders/motion_path_point_vert.glsl
+  engines/overlay/shaders/outline_detect_frag.glsl
+  engines/overlay/shaders/outline_prepass_frag.glsl
+  engines/overlay/shaders/outline_prepass_geom.glsl
+  engines/overlay/shaders/outline_prepass_vert.glsl
+  engines/overlay/shaders/paint_face_vert.glsl
+  engines/overlay/shaders/paint_point_vert.glsl
+  engines/overlay/shaders/paint_texture_frag.glsl
+  engines/overlay/shaders/paint_texture_vert.glsl
+  engines/overlay/shaders/paint_vertcol_frag.glsl
+  engines/overlay/shaders/paint_vertcol_vert.glsl
+  engines/overlay/shaders/paint_weight_frag.glsl
+  engines/overlay/shaders/paint_weight_vert.glsl
+  engines/overlay/shaders/paint_wire_vert.glsl
+  engines/overlay/shaders/particle_vert.glsl
+  engines/overlay/shaders/particle_frag.glsl
+  engines/overlay/shaders/sculpt_mask_vert.glsl
+  engines/overlay/shaders/sculpt_mask_frag.glsl
+  engines/overlay/shaders/volume_velocity_vert.glsl
+  engines/overlay/shaders/volume_gridlines_vert.glsl
+  engines/overlay/shaders/wireframe_vert.glsl
+  engines/overlay/shaders/wireframe_frag.glsl
+  engines/overlay/shaders/xray_fade_frag.glsl
 
-data_to_c_simple(engines/image/shaders/engine_image_frag.glsl SRC)
-data_to_c_simple(engines/image/shaders/engine_image_vert.glsl SRC)
+  engines/image/shaders/engine_image_frag.glsl
+  engines/image/shaders/engine_image_vert.glsl
+)
+
+set(GLSL_C)
+foreach(GLSL_FILE ${GLSL_SRC})
+  data_to_c_simple(${GLSL_FILE} GLSL_C)
+endforeach()
+
+blender_add_lib(bf_draw_shaders "${GLSL_C}" "" "" "")
+
+list(APPEND LIB
+  bf_draw_shaders
+)
+
+set(GLSL_SOURCE_CONTENT "")
+foreach(GLSL_FILE ${GLSL_SRC})
+  get_filename_component(GLSL_FILE_NAME ${GLSL_FILE} NAME)
+  string(REPLACE "." "_" GLSL_FILE_NAME_UNDERSCORES ${GLSL_FILE_NAME})
+  string(APPEND GLSL_SOURCE_CONTENT "SHADER_SOURCE\(datatoc_${GLSL_FILE_NAME_UNDERSCORES}, \"${GLSL_FILE_NAME}\"\)\n")
+endforeach()
+
+set(glsl_source_list_file "${CMAKE_CURRENT_BINARY_DIR}/glsl_draw_source_list.h")
+file(GENERATE OUTPUT ${glsl_source_list_file} CONTENT "${GLSL_SOURCE_CONTENT}")
+list(APPEND SRC ${glsl_source_list_file})
+list(APPEND INC ${CMAKE_CURRENT_BINARY_DIR})
+
+target_include_directories(bf_draw_shaders PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
 
 list(APPEND INC
 )

source/blender/draw/engines/workbench/shaders/workbench_effect_cavity.desc.h

@@ -0,0 +1,25 @@
+
+#include "gpu_shader_descriptor.h"
+
+GPU_SHADER_DESCRIPTOR(workbench_effect_cavity)
+{
+    .do_static_compilation = true,
+    .fragment_outputs =
+        {
+            [0] = FRAGMENT_OUTPUT(VEC4, "fragColor"),
+        },
+    .resources =
+        {
+            [DESCRIPTOR_SET_1] =
+                {
+                    [0] = SAMPLER(FLOAT_2D, "depthBuffer", GPU_SAMPLER_DEFAULT),
+                    [1] = SAMPLER(FLOAT_2D, "normalBuffer", GPU_SAMPLER_DEFAULT),
+                    [2] = SAMPLER(UINT_2D, "objectIdBuffer", GPU_SAMPLER_DEFAULT),
+                },
+        },
+    .fragment_source = "workbench_effect_cavity_frag.glsl",
+    .additional_descriptors =
+        {
+            "draw_fullscreen",
+        },
+};

source/blender/draw/engines/workbench/shaders/workbench_prepass.desc.h

@@ -0,0 +1,259 @@
+
+#include "gpu_shader_descriptor.h"
+
+/* -------------------------------------------------------------------- */
+/** \name Object Type
+ * \{ */
+
+GPU_SHADER_DESCRIPTOR(workbench_mesh)
+{
+    .vertex_inputs =
+        {
+            [0] = VERTEX_INPUT(VEC3, "pos"),
+            [1] = VERTEX_INPUT(VEC3, "nor"),
+            [2] = VERTEX_INPUT(VEC4, "ac"),
+            [3] = VERTEX_INPUT(VEC2, "au"),
+        },
+    .vertex_source = "workbench_prepass_vert.glsl",
+};
+
+GPU_SHADER_DESCRIPTOR(workbench_hair)
+{
+    .resources =
+        {
+            [DESCRIPTOR_SET_0] =
+                {
+                    [0] = SAMPLER(FLOAT_BUFFER, "ac", GPU_SAMPLER_DEFAULT),
+                    [1] = SAMPLER(FLOAT_BUFFER, "au", GPU_SAMPLER_DEFAULT),
+                },
+        },
+    .vertex_source = "workbench_prepass_hair_vert.glsl",
+    /* TODO */
+    // .additional_descriptors = { "draw_hair", },
+};
+
+GPU_SHADER_DESCRIPTOR(workbench_pointcloud)
+{
+    .vertex_inputs =
+        {
+            [0] = VERTEX_INPUT(VEC4, "pos"),
+            /* ---- Instanced attribs ---- */
+            [1] = VERTEX_INPUT(VEC3, "pos_inst"),
+            [2] = VERTEX_INPUT(VEC3, "nor"),
+        },
+    .vertex_source = "workbench_prepass_pointcloud_vert.glsl",
+    /* TODO */
+    // .additional_descriptors = { "draw_pointcloud", },
+};
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Texture Type
+ * \{ */
+
+GPU_SHADER_DESCRIPTOR(workbench_texture_none)
+{
+    .defines =
+        {
+            [0] = "#define TEXTURE_NONE\n",
+        },
+};
+
+GPU_SHADER_DESCRIPTOR(workbench_texture_single)
+{
+    .resources =
+        {
+            [DESCRIPTOR_SET_0] =
+                {
+                    /* ---- Hair buffers ---- */
+                    // [0] = SAMPLER(FLOAT_BUFFER, "ac", GPU_SAMPLER_DEFAULT),
+                    // [1] = SAMPLER(FLOAT_BUFFER, "au", GPU_SAMPLER_DEFAULT),
+                    [2] = SAMPLER(FLOAT_2D, "imageTexture", GPU_SAMPLER_DEFAULT),
+                },
+        },
+    .defines =
+        {
+            [0] = "#define V3D_SHADING_TEXTURE_COLOR\n",
+        },
+};
+
+GPU_SHADER_DESCRIPTOR(workbench_texture_tile)
+{
+    .resources =
+        {
+            [DESCRIPTOR_SET_0] =
+                {
+                    /* ---- Hair buffers ---- */
+                    // [0] = SAMPLER(FLOAT_BUFFER, "ac", GPU_SAMPLER_DEFAULT),
+                    // [1] = SAMPLER(FLOAT_BUFFER, "au", GPU_SAMPLER_DEFAULT),
+                    [2] = SAMPLER(FLOAT_2D_ARRAY, "imageTileArray", GPU_SAMPLER_DEFAULT),
+                    [3] = SAMPLER(FLOAT_1D_ARRAY, "imageTileData", GPU_SAMPLER_DEFAULT),
+                },
+        },
+    .defines =
+        {
+            [0] = "#define TEXTURE_IMAGE_ARRAY\n",
+        },
+};
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Lighting Type
+ * \{ */
+
+GPU_SHADER_DESCRIPTOR(workbench_lighting_studio)
+{
+    .defines =
+        {
+            [1] = "#define V3D_LIGHTING_STUDIO\n",
+        },
+};
+
+GPU_SHADER_DESCRIPTOR(workbench_lighting_matcap)
+{
+    .defines =
+        {
+            [1] = "#define V3D_LIGHTING_MATCAP\n",
+        },
+};
+
+GPU_SHADER_DESCRIPTOR(workbench_lighting_flat)
+{
+    .defines =
+        {
+            [1] = "#define V3D_LIGHTING_FLAT\n",
+        },
+};
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Material Interface
+ * \{ */
+
+GPU_STAGE_INTERFACE_CREATE(workbench_material_iface)
+{
+    {VEC3, "normal_interp"},
+    {VEC3, "color_interp"},
+    {FLOAT, "alpha_interp"},
+    {VEC2, "uv_interp"},
+    {INT, "object_id", FLAT},
+    {FLOAT, "roughness", FLAT},
+    {FLOAT, "metallic", FLAT},
+};
+
+GPU_SHADER_DESCRIPTOR(workbench_material)
+{
+    .vertex_out_interfaces =
+        {
+            [0] = STAGE_INTERFACE("", workbench_material_iface),
+        },
+    .additional_descriptors =
+        {
+            "draw_view",
+        },
+};
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Pipeline Type
+ * \{ */
+
+GPU_SHADER_DESCRIPTOR(workbench_transparent_accum)
+{
+
+    .fragment_outputs =
+        {
+            /* Note: Blending will be skipped on objectId because output is a
+               non-normalized integer buffer. */
+            [0] = FRAGMENT_OUTPUT(VEC4, "transparentAccum"),
+            [1] = FRAGMENT_OUTPUT(VEC4, "revealageAccum"),
+            [2] = FRAGMENT_OUTPUT(UINT, "objectId"),
+        },
+    .fragment_source = "workbench_effect_cavity_frag.glsl",
+    .additional_descriptors =
+        {
+            "workbench_material",
+        },
+};
+
+GPU_SHADER_DESCRIPTOR(workbench_opaque)
+{
+
+    .fragment_outputs =
+        {
+            /* Note: Blending will be skipped on objectId because output is a
+               non-normalized integer buffer. */
+            [0] = FRAGMENT_OUTPUT(VEC4, "materialData"),
+            [1] = FRAGMENT_OUTPUT(VEC2, "normalData"),
+            [2] = FRAGMENT_OUTPUT(UINT, "objectId"),
+        },
+    .resources =
+        {
+            [DESCRIPTOR_SET_0] =
+                {
+                    [4] = UNIFORM_BUFFER("WB_Scene", "scene"),
+                },
+        },
+    .fragment_source = "workbench_effect_cavity_frag.glsl",
+    .additional_descriptors =
+        {
+            "workbench_material",
+        },
+};
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Variations Declaration
+ * \{ */
+
+#define WORKBENCH_SURFACETYPE_VARIATIONS(prefix, ...) \
+  GPU_SHADER_DESCRIPTOR(prefix##_mesh) \
+  { \
+      .additional_descriptors = \
+          { \
+              "workbench_mesh", \
+              __VA_ARGS__, \
+          }, \
+  }; \
+  GPU_SHADER_DESCRIPTOR(prefix##_hair) \
+  { \
+      .additional_descriptors = \
+          { \
+              "workbench_hair", \
+              __VA_ARGS__, \
+          }, \
+  }; \
+  GPU_SHADER_DESCRIPTOR(prefix##_ptcloud) \
+  { \
+      .additional_descriptors = \
+          { \
+              "workbench_pointcloud", \
+              __VA_ARGS__, \
+          }, \
+  };
+
+#define WORKBENCH_PIPELINE_VARIATIONS(prefix, ...) \
+  WORKBENCH_SURFACETYPE_VARIATIONS(prefix##_transp_studio, \
+                                   "workbench_transparent_accum", \
+                                   "workbench_lighting_studio", \
+                                   __VA_ARGS__) \
+  WORKBENCH_SURFACETYPE_VARIATIONS(prefix##_transp_matcap, \
+                                   "workbench_transparent_accum", \
+                                   "workbench_lighting_matcap", \
+                                   __VA_ARGS__) \
+  WORKBENCH_SURFACETYPE_VARIATIONS(prefix##_transp_flat, \
+                                   "workbench_transparent_accum", \
+                                   "workbench_lighting_flat", \
+                                   __VA_ARGS__) \
+  WORKBENCH_SURFACETYPE_VARIATIONS(prefix##_opaque, "workbench_opaque", __VA_ARGS__)
+
+WORKBENCH_PIPELINE_VARIATIONS(workbench_tex_none, "workbench_texture_none")
+WORKBENCH_PIPELINE_VARIATIONS(workbench_tex_single, "workbench_texture_single")
+WORKBENCH_PIPELINE_VARIATIONS(workbench_tex_tile, "workbench_texture_tile")
+
+/** \} */

source/blender/draw/intern/shaders/draw_fullscreen.desc.h

@@ -0,0 +1,16 @@
+
+#include "gpu_shader_descriptor.h"
+
+GPU_STAGE_INTERFACE_CREATE(fullscreen_iface)
+{
+    {VEC4, "uvcoordsvar"},
+};
+
+GPU_SHADER_DESCRIPTOR(draw_fullscreen)
+{
+    .vertex_out_interfaces =
+        {
+            [0] = STAGE_INTERFACE("", fullscreen_iface),
+        },
+    .vertex_source = "common_fullscreen_vert.glsl",
+};

source/blender/draw/intern/shaders/draw_object_infos.desc.h

@@ -0,0 +1,13 @@
+
+#include "gpu_shader_descriptor.h"
+
+GPU_SHADER_DESCRIPTOR(draw_object_infos)
+{
+    .resources =
+        {
+            [DESCRIPTOR_SET_1] =
+                {
+                    [2] = UNIFORM_BUFFER("ObjectInfos", "drw_infos[DRW_RESOURCE_CHUNK_LEN]"),
+                },
+        },
+};

source/blender/draw/intern/shaders/draw_view.desc.h

@@ -0,0 +1,14 @@
+
+#include "gpu_shader_descriptor.h"
+
+GPU_SHADER_DESCRIPTOR(draw_view)
+{
+    .resources =
+        {
+            [DESCRIPTOR_SET_1] =
+                {
+                    [0] = UNIFORM_BUFFER("ViewInfos", "drw_view"),
+                    [1] = UNIFORM_BUFFER("ObjectMatrices", "drw_matrices[DRW_RESOURCE_CHUNK_LEN]"),
+                },
+        },
+};

source/blender/gpu/CMakeLists.txt

@@ -83,6 +83,7 @@ set(SRC
   intern/gpu_select_sample_query.cc
   intern/gpu_shader.cc
   intern/gpu_shader_builtin.c
+  intern/gpu_shader_dependency.cc
   intern/gpu_shader_interface.cc
   intern/gpu_shader_log.cc
   intern/gpu_state.cc
@@ -197,186 +198,254 @@ if(NOT WITH_SYSTEM_GLEW)
   )
 endif()
 
-data_to_c_simple(shaders/gpu_shader_depth_only_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_uniform_color_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_checker_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_diag_stripes_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_simple_lighting_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_flat_color_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_flat_color_alpha_test_0_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_flat_id_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_area_borders_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_area_borders_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_widget_base_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_widget_base_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_widget_shadow_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_widget_shadow_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_nodelink_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_nodelink_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_flat_color_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_line_dashed_uniform_color_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_line_dashed_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_smooth_color_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_smooth_color_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_image_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_image_rect_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_image_multi_rect_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_image_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_image_desaturate_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_image_overlays_merge_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_image_overlays_stereo_merge_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_image_modulate_alpha_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_image_shuffle_color_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_image_color_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_image_varying_color_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_3D_image_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_3D_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_3D_normal_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_3D_flat_color_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_3D_line_dashed_uniform_color_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_3D_polyline_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_3D_polyline_geom.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_3D_polyline_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_3D_smooth_color_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_3D_smooth_color_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_3D_passthrough_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_3D_clipped_uniform_color_vert.glsl SRC)
+set(GLSL_SRC
+  shaders/gpu_shader_depth_only_frag.glsl
+  shaders/gpu_shader_uniform_color_frag.glsl
+  shaders/gpu_shader_checker_frag.glsl
+  shaders/gpu_shader_diag_stripes_frag.glsl
+  shaders/gpu_shader_simple_lighting_frag.glsl
+  shaders/gpu_shader_flat_color_frag.glsl
+  shaders/gpu_shader_flat_color_alpha_test_0_frag.glsl
+  shaders/gpu_shader_flat_id_frag.glsl
+  shaders/gpu_shader_2D_vert.glsl
+  shaders/gpu_shader_2D_area_borders_vert.glsl
+  shaders/gpu_shader_2D_area_borders_frag.glsl
+  shaders/gpu_shader_2D_widget_base_vert.glsl
+  shaders/gpu_shader_2D_widget_base_frag.glsl
+  shaders/gpu_shader_2D_widget_shadow_vert.glsl
+  shaders/gpu_shader_2D_widget_shadow_frag.glsl
+  shaders/gpu_shader_2D_nodelink_frag.glsl
+  shaders/gpu_shader_2D_nodelink_vert.glsl
+  shaders/gpu_shader_2D_flat_color_vert.glsl
+  shaders/gpu_shader_2D_line_dashed_uniform_color_vert.glsl
+  shaders/gpu_shader_2D_line_dashed_frag.glsl
+  shaders/gpu_shader_2D_smooth_color_vert.glsl
+  shaders/gpu_shader_2D_smooth_color_frag.glsl
+  shaders/gpu_shader_2D_image_vert.glsl
+  shaders/gpu_shader_2D_image_rect_vert.glsl
+  shaders/gpu_shader_2D_image_multi_rect_vert.glsl
+  shaders/gpu_shader_image_frag.glsl
+  shaders/gpu_shader_image_desaturate_frag.glsl
+  shaders/gpu_shader_image_overlays_merge_frag.glsl
+  shaders/gpu_shader_image_overlays_stereo_merge_frag.glsl
+  shaders/gpu_shader_image_modulate_alpha_frag.glsl
+  shaders/gpu_shader_image_shuffle_color_frag.glsl
+  shaders/gpu_shader_image_color_frag.glsl
+  shaders/gpu_shader_image_varying_color_frag.glsl
+  shaders/gpu_shader_3D_image_vert.glsl
+  shaders/gpu_shader_3D_vert.glsl
+  shaders/gpu_shader_3D_normal_vert.glsl
+  shaders/gpu_shader_3D_flat_color_vert.glsl
+  shaders/gpu_shader_3D_line_dashed_uniform_color_vert.glsl
+  shaders/gpu_shader_3D_polyline_frag.glsl
+  shaders/gpu_shader_3D_polyline_geom.glsl
+  shaders/gpu_shader_3D_polyline_vert.glsl
+  shaders/gpu_shader_3D_smooth_color_vert.glsl
+  shaders/gpu_shader_3D_smooth_color_frag.glsl
+  shaders/gpu_shader_3D_passthrough_vert.glsl
+  shaders/gpu_shader_3D_clipped_uniform_color_vert.glsl
 
-data_to_c_simple(shaders/gpu_shader_instance_variying_size_variying_color_vert.glsl SRC)
+  shaders/gpu_shader_instance_variying_size_variying_color_vert.glsl
 
-data_to_c_simple(shaders/gpu_shader_point_uniform_color_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_point_uniform_color_aa_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_point_uniform_color_outline_aa_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_point_varying_color_outline_aa_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_point_varying_color_varying_outline_aa_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_point_varying_color_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_3D_point_fixed_size_varying_color_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_3D_point_varying_size_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_3D_point_varying_size_varying_color_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_3D_point_uniform_size_aa_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_3D_point_uniform_size_outline_aa_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_point_varying_size_varying_color_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_point_uniform_size_aa_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_point_uniform_size_outline_aa_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_point_uniform_size_varying_color_outline_aa_vert.glsl SRC)
+  shaders/gpu_shader_point_uniform_color_frag.glsl
+  shaders/gpu_shader_point_uniform_color_aa_frag.glsl
+  shaders/gpu_shader_point_uniform_color_outline_aa_frag.glsl
+  shaders/gpu_shader_point_varying_color_outline_aa_frag.glsl
+  shaders/gpu_shader_point_varying_color_varying_outline_aa_frag.glsl
+  shaders/gpu_shader_point_varying_color_frag.glsl
+  shaders/gpu_shader_3D_point_fixed_size_varying_color_vert.glsl
+  shaders/gpu_shader_3D_point_varying_size_vert.glsl
+  shaders/gpu_shader_3D_point_varying_size_varying_color_vert.glsl
+  shaders/gpu_shader_3D_point_uniform_size_aa_vert.glsl
+  shaders/gpu_shader_3D_point_uniform_size_outline_aa_vert.glsl
+  shaders/gpu_shader_2D_point_varying_size_varying_color_vert.glsl
+  shaders/gpu_shader_2D_point_uniform_size_aa_vert.glsl
+  shaders/gpu_shader_2D_point_uniform_size_outline_aa_vert.glsl
+  shaders/gpu_shader_2D_point_uniform_size_varying_color_outline_aa_vert.glsl
 
-data_to_c_simple(shaders/gpu_shader_2D_edituvs_points_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_edituvs_facedots_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_edituvs_edges_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_edituvs_edges_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_edituvs_faces_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_2D_edituvs_stretch_vert.glsl SRC)
+  shaders/gpu_shader_2D_edituvs_points_vert.glsl
+  shaders/gpu_shader_2D_edituvs_facedots_vert.glsl
+  shaders/gpu_shader_2D_edituvs_edges_vert.glsl
+  shaders/gpu_shader_2D_edituvs_edges_frag.glsl
+  shaders/gpu_shader_2D_edituvs_faces_vert.glsl
+  shaders/gpu_shader_2D_edituvs_stretch_vert.glsl
 
-data_to_c_simple(shaders/gpu_shader_text_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_text_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_keyframe_shape_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_keyframe_shape_frag.glsl SRC)
+  shaders/gpu_shader_text_vert.glsl
+  shaders/gpu_shader_text_frag.glsl
+  shaders/gpu_shader_keyframe_shape_vert.glsl
+  shaders/gpu_shader_keyframe_shape_frag.glsl
 
-data_to_c_simple(shaders/gpu_shader_codegen_lib.glsl SRC)
+  shaders/gpu_shader_codegen_lib.glsl
 
-data_to_c_simple(shaders/gpu_shader_geometry.glsl SRC)
+  shaders/gpu_shader_geometry.glsl
 
-data_to_c_simple(shaders/material/gpu_shader_material_add_shader.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_ambient_occlusion.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_anisotropic.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_attribute.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_background.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_bevel.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_wavelength.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_blackbody.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_bright_contrast.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_bump.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_camera.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_clamp.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_color_ramp.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_color_util.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_combine_hsv.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_combine_rgb.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_combine_xyz.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_diffuse.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_displacement.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_eevee_specular.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_emission.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_float_curve.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_fractal_noise.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_fresnel.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_gamma.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_geometry.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_glass.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_glossy.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_hair_info.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_hash.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_holdout.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_hue_sat_val.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_invert.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_layer_weight.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_light_falloff.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_light_path.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_mapping.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_map_range.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_math.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_math_util.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_mix_rgb.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_mix_shader.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_noise.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_normal.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_normal_map.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_object_info.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_output_aov.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_output_material.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_output_world.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_particle_info.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_principled.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_refraction.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_rgb_curves.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_rgb_to_bw.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_separate_hsv.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_separate_rgb.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_separate_xyz.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_set.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_shader_to_rgba.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_squeeze.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_subsurface_scattering.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_tangent.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_tex_brick.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_tex_checker.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_tex_environment.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_tex_gradient.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_tex_image.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_tex_magic.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_tex_musgrave.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_tex_noise.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_tex_sky.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_texture_coordinates.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_tex_voronoi.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_tex_wave.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_tex_white_noise.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_toon.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_translucent.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_transparent.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_uv_map.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_vector_curves.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_vector_displacement.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_vector_math.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_vector_rotate.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_velvet.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_vertex_color.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_volume_absorption.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_volume_info.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_volume_principled.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_volume_scatter.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_wireframe.glsl SRC)
-data_to_c_simple(shaders/material/gpu_shader_material_world_normals.glsl SRC)
+  shaders/material/gpu_shader_material_add_shader.glsl
+  shaders/material/gpu_shader_material_ambient_occlusion.glsl
+  shaders/material/gpu_shader_material_anisotropic.glsl
+  shaders/material/gpu_shader_material_attribute.glsl
+  shaders/material/gpu_shader_material_background.glsl
+  shaders/material/gpu_shader_material_bevel.glsl
+  shaders/material/gpu_shader_material_wavelength.glsl
+  shaders/material/gpu_shader_material_blackbody.glsl
+  shaders/material/gpu_shader_material_bright_contrast.glsl
+  shaders/material/gpu_shader_material_bump.glsl
+  shaders/material/gpu_shader_material_camera.glsl
+  shaders/material/gpu_shader_material_clamp.glsl
+  shaders/material/gpu_shader_material_color_ramp.glsl
+  shaders/material/gpu_shader_material_color_util.glsl
+  shaders/material/gpu_shader_material_combine_hsv.glsl
+  shaders/material/gpu_shader_material_combine_rgb.glsl
+  shaders/material/gpu_shader_material_combine_xyz.glsl
+  shaders/material/gpu_shader_material_diffuse.glsl
+  shaders/material/gpu_shader_material_displacement.glsl
+  shaders/material/gpu_shader_material_eevee_specular.glsl
+  shaders/material/gpu_shader_material_emission.glsl
+  shaders/material/gpu_shader_material_float_curve.glsl
+  shaders/material/gpu_shader_material_fractal_noise.glsl
+  shaders/material/gpu_shader_material_fresnel.glsl
+  shaders/material/gpu_shader_material_gamma.glsl
+  shaders/material/gpu_shader_material_geometry.glsl
+  shaders/material/gpu_shader_material_glass.glsl
+  shaders/material/gpu_shader_material_glossy.glsl
+  shaders/material/gpu_shader_material_hair_info.glsl
+  shaders/material/gpu_shader_material_hash.glsl
+  shaders/material/gpu_shader_material_holdout.glsl
+  shaders/material/gpu_shader_material_hue_sat_val.glsl
+  shaders/material/gpu_shader_material_invert.glsl
+  shaders/material/gpu_shader_material_layer_weight.glsl
+  shaders/material/gpu_shader_material_light_falloff.glsl
+  shaders/material/gpu_shader_material_light_path.glsl
+  shaders/material/gpu_shader_material_mapping.glsl
+  shaders/material/gpu_shader_material_map_range.glsl
+  shaders/material/gpu_shader_material_math.glsl
+  shaders/material/gpu_shader_material_math_util.glsl
+  shaders/material/gpu_shader_material_mix_rgb.glsl
+  shaders/material/gpu_shader_material_mix_shader.glsl
+  shaders/material/gpu_shader_material_noise.glsl
+  shaders/material/gpu_shader_material_normal.glsl
+  shaders/material/gpu_shader_material_normal_map.glsl
+  shaders/material/gpu_shader_material_object_info.glsl
+  shaders/material/gpu_shader_material_output_aov.glsl
+  shaders/material/gpu_shader_material_output_material.glsl
+  shaders/material/gpu_shader_material_output_world.glsl
+  shaders/material/gpu_shader_material_particle_info.glsl
+  shaders/material/gpu_shader_material_principled.glsl
+  shaders/material/gpu_shader_material_refraction.glsl
+  shaders/material/gpu_shader_material_rgb_curves.glsl
+  shaders/material/gpu_shader_material_rgb_to_bw.glsl
+  shaders/material/gpu_shader_material_separate_hsv.glsl
+  shaders/material/gpu_shader_material_separate_rgb.glsl
+  shaders/material/gpu_shader_material_separate_xyz.glsl
+  shaders/material/gpu_shader_material_set.glsl
+  shaders/material/gpu_shader_material_shader_to_rgba.glsl
+  shaders/material/gpu_shader_material_squeeze.glsl
+  shaders/material/gpu_shader_material_subsurface_scattering.glsl
+  shaders/material/gpu_shader_material_tangent.glsl
+  shaders/material/gpu_shader_material_tex_brick.glsl
+  shaders/material/gpu_shader_material_tex_checker.glsl
+  shaders/material/gpu_shader_material_tex_environment.glsl
+  shaders/material/gpu_shader_material_tex_gradient.glsl
+  shaders/material/gpu_shader_material_tex_image.glsl
+  shaders/material/gpu_shader_material_tex_magic.glsl
+  shaders/material/gpu_shader_material_tex_musgrave.glsl
+  shaders/material/gpu_shader_material_tex_noise.glsl
+  shaders/material/gpu_shader_material_tex_sky.glsl
+  shaders/material/gpu_shader_material_texture_coordinates.glsl
+  shaders/material/gpu_shader_material_tex_voronoi.glsl
+  shaders/material/gpu_shader_material_tex_wave.glsl
+  shaders/material/gpu_shader_material_tex_white_noise.glsl
+  shaders/material/gpu_shader_material_toon.glsl
+  shaders/material/gpu_shader_material_translucent.glsl
+  shaders/material/gpu_shader_material_transparent.glsl
+  shaders/material/gpu_shader_material_uv_map.glsl
+  shaders/material/gpu_shader_material_vector_curves.glsl
+  shaders/material/gpu_shader_material_vector_displacement.glsl
+  shaders/material/gpu_shader_material_vector_math.glsl
+  shaders/material/gpu_shader_material_vector_rotate.glsl
+  shaders/material/gpu_shader_material_velvet.glsl
+  shaders/material/gpu_shader_material_vertex_color.glsl
+  shaders/material/gpu_shader_material_volume_absorption.glsl
+  shaders/material/gpu_shader_material_volume_info.glsl
+  shaders/material/gpu_shader_material_volume_principled.glsl
+  shaders/material/gpu_shader_material_volume_scatter.glsl
+  shaders/material/gpu_shader_material_wireframe.glsl
+  shaders/material/gpu_shader_material_world_normals.glsl
 
-data_to_c_simple(shaders/gpu_shader_gpencil_stroke_vert.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_gpencil_stroke_frag.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_gpencil_stroke_geom.glsl SRC)
+  shaders/gpu_shader_gpencil_stroke_vert.glsl
+  shaders/gpu_shader_gpencil_stroke_frag.glsl
+  shaders/gpu_shader_gpencil_stroke_geom.glsl
 
-data_to_c_simple(shaders/gpu_shader_cfg_world_clip_lib.glsl SRC)
-data_to_c_simple(shaders/gpu_shader_colorspace_lib.glsl SRC)
+  shaders/gpu_shader_cfg_world_clip_lib.glsl
+  shaders/gpu_shader_colorspace_lib.glsl
 
-data_to_c_simple(shaders/gpu_shader_common_obinfos_lib.glsl SRC)
+  shaders/gpu_shader_common_obinfos_lib.glsl
+)
+
+set(GLSL_C)
+foreach(GLSL_FILE ${GLSL_SRC})
+  data_to_c_simple(${GLSL_FILE} GLSL_C)
+endforeach()
+
+blender_add_lib(bf_gpu_shaders "${GLSL_C}" "" "" "")
+
+list(APPEND LIB
+  bf_gpu_shaders
+)
+
+set(GLSL_SOURCE_CONTENT "")
+foreach(GLSL_FILE ${GLSL_SRC})
+  get_filename_component(GLSL_FILE_NAME ${GLSL_FILE} NAME)
+  string(REPLACE "." "_" GLSL_FILE_NAME_UNDERSCORES ${GLSL_FILE_NAME})
+  string(APPEND GLSL_SOURCE_CONTENT "SHADER_SOURCE\(datatoc_${GLSL_FILE_NAME_UNDERSCORES}, \"${GLSL_FILE_NAME}\"\)\n")
+endforeach()
+
+set(glsl_source_list_file "${CMAKE_CURRENT_BINARY_DIR}/glsl_gpu_source_list.h")
+file(GENERATE OUTPUT ${glsl_source_list_file} CONTENT "${GLSL_SOURCE_CONTENT}")
+list(APPEND SRC ${glsl_source_list_file})
+list(APPEND INC ${CMAKE_CURRENT_BINARY_DIR})
+
+set(SHADER_DESCRIPTORS
+  ../draw/engines/workbench/shaders/workbench_effect_cavity.desc.h
+  ../draw/engines/workbench/shaders/workbench_prepass.desc.h
+  ../draw/intern/shaders/draw_fullscreen.desc.h
+  ../draw/intern/shaders/draw_view.desc.h
+  ../draw/intern/shaders/draw_object_infos.desc.h
+  shaders/gpu_shader_3D_flat_color.desc.h
+  shaders/gpu_clip_planes.desc.h
+)
+
+set(SHADER_DESCRIPTORS_CONTENT "")
+foreach(DESCRIPTOR_FILE ${SHADER_DESCRIPTORS})
+  string(APPEND SHADER_DESCRIPTORS_CONTENT "#include \"${DESCRIPTOR_FILE}\"\n")
+endforeach()
+
+set(shader_descriptor_list_file "${CMAKE_CURRENT_BINARY_DIR}/gpu_shader_descriptor_list.h")
+file(GENERATE OUTPUT ${shader_descriptor_list_file} CONTENT "${SHADER_DESCRIPTORS_CONTENT}")
+
+add_executable(shader_builder
+  intern/gpu_shader_builder.c
+  intern/gpu_shader_dependency.cc
+  ${shader_descriptor_list_file}
+)
+target_link_libraries(shader_builder PRIVATE
+  bf_intern_guardedalloc
+  bf_blenlib
+  bf_gpu_shaders
+  bf_draw_shaders
+  ${PLATFORM_LINKLIBS})
+target_include_directories(shader_builder PRIVATE ${INC} ${CMAKE_CURRENT_BINARY_DIR})
+
+set(BAKED_DESCRIPTORS_FILE ${CMAKE_CURRENT_BINARY_DIR}/shader_descriptors_baked.c)
+
+add_custom_command(
+  OUTPUT
+    ${BAKED_DESCRIPTORS_FILE}
+  COMMAND
+    "$<TARGET_FILE:shader_builder>" ${BAKED_DESCRIPTORS_FILE}
+  DEPENDS shader_builder
+)
+
+list(APPEND SRC ${BAKED_DESCRIPTORS_FILE})
 
 
 if(WITH_MOD_FLUID)
@@ -390,6 +459,10 @@ if(WITH_IMAGE_DDS)
 endif()
 
 blender_add_lib(bf_gpu "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")
+target_link_libraries(bf_gpu PUBLIC
+  bf_draw_shaders
+  bf_gpu_shaders
+)
 
 if(CXX_WARN_NO_SUGGEST_OVERRIDE)
   target_compile_options(bf_gpu PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-Wsuggest-override>)

source/blender/gpu/intern/gpu_init_exit.c

@@ -32,6 +32,7 @@
 #include "intern/gpu_codegen.h"
 #include "intern/gpu_material_library.h"
 #include "intern/gpu_private.h"
+#include "intern/gpu_shader_dependency_private.h"
 
 /**
  * although the order of initialization and shutdown should not matter
@@ -49,6 +50,8 @@ void GPU_init(void)
 
   initialized = true;
 
+  gpu_shader_dependency_init();
+
   gpu_codegen_init();
   gpu_material_library_init();
 
@@ -70,6 +73,8 @@ void GPU_exit(void)
   gpu_material_library_exit();
   gpu_codegen_exit();
 
+  gpu_shader_dependency_exit();
+
   initialized = false;
 }
 

source/blender/gpu/intern/gpu_shader_builder.c

@@ -0,0 +1,541 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2021 Blender Foundation.
+ * All rights reserved.
+ */
+
+/** \file
+ * \ingroup gpu
+ *
+ * Compile time automation of shader compilation and validation.
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "gpu_shader_dependency_private.h"
+
+#include "gpu_shader_descriptor.h"
+#undef GPU_STAGE_INTERFACE_CREATE
+#undef GPU_SHADER_DESCRIPTOR
+
+static const GPUShaderDescriptor *find_descriptor_by_name(const GPUShaderDescriptor **descriptors,
+                                                          const char *name)
+{
+  const GPUShaderDescriptor **result = descriptors;
+  while (*result) {
+    if (strcmp((*result)->name, name) == 0) {
+      return *result;
+    }
+    result++;
+  }
+  return NULL;
+}
+
+/* Return 0 on success. (Recursive). */
+static bool descriptor_flatten(const GPUShaderDescriptor **descriptors,
+                               const GPUShaderDescriptor *input,
+                               GPUShaderDescriptor *output)
+{
+  int errors = 0;
+
+  if (output->name == NULL) {
+    output->name = input->name;
+  }
+
+  if (input->do_static_compilation) {
+    /* If one descriptor is valid, final one is too. */
+    output->do_static_compilation = true;
+  }
+
+  if (input->vertex_source) {
+    if (output->vertex_source) {
+      printf("Error: %s.vertex_source cannot be overriden by %s.\n", output->name, input->name);
+    }
+    else {
+      output->vertex_source = input->vertex_source;
+    }
+  }
+  if (input->geometry_source) {
+    if (output->geometry_source) {
+      printf("Error: %s.geometry_source cannot be overriden by %s.\n", output->name, input->name);
+    }
+    else {
+      output->geometry_source = input->geometry_source;
+    }
+  }
+  if (input->fragment_source) {
+    if (output->fragment_source) {
+      printf("Error: %s.fragment_source cannot be overriden by %s.\n", output->name, input->name);
+    }
+    else {
+      output->fragment_source = input->fragment_source;
+    }
+  }
+  if (input->compute_source) {
+    if (output->compute_source) {
+      printf("Error: %s.compute_source cannot be overriden by %s.\n", output->name, input->name);
+    }
+    else {
+      output->compute_source = input->compute_source;
+    }
+  }
+
+  for (int i = 0; i < ARRAY_SIZE(input->defines); i++) {
+    if (input->defines[i]) {
+      if (output->defines[i]) {
+        printf("Error: %s.defines[%d] cannot be overriden by %s.\n", output->name, i, input->name);
+      }
+      else {
+        output->defines[i] = input->defines[i];
+      }
+    }
+  }
+
+  for (int i = 0; i < ARRAY_SIZE(input->vertex_inputs); i++) {
+    if (input->vertex_inputs[i].type == UNUSED) {
+      continue;
+    }
+    else if (output->vertex_inputs[i].type != UNUSED) {
+      printf("Error: vertex_inputs[%d] is already used by \"%s\".\n",
+             i,
+             output->vertex_inputs[i].name);
+      errors++;
+    }
+    else {
+      output->vertex_inputs[i] = input->vertex_inputs[i];
+    }
+  }
+
+  for (int i = 0; i < ARRAY_SIZE(input->fragment_outputs); i++) {
+    if (input->fragment_outputs[i].type == UNUSED) {
+      continue;
+    }
+    else if (output->fragment_outputs[i].type != UNUSED) {
+      printf("Error: fragment_outputs[%d] is already used by \"%s\".\n",
+             i,
+             output->fragment_outputs[i].name);
+      errors++;
+    }
+    else {
+      output->fragment_outputs[i] = input->fragment_outputs[i];
+    }
+  }
+
+  for (int i = 0; i < ARRAY_SIZE(input->vertex_out_interfaces); i++) {
+    if (input->vertex_out_interfaces[i].inouts_len == 0) {
+      continue;
+    }
+    else if (output->vertex_out_interfaces[i].inouts_len != 0) {
+      printf("Error: vertex_out_interfaces[%d] is already used by \"%s\".\n",
+             i,
+             output->vertex_out_interfaces[i].name);
+      errors++;
+    }
+    else {
+      output->vertex_out_interfaces[i] = input->vertex_out_interfaces[i];
+    }
+  }
+
+  for (int i = 0; i < ARRAY_SIZE(input->geometry_out_interfaces); i++) {
+    if (input->geometry_out_interfaces[i].inouts_len == 0) {
+      continue;
+    }
+    else if (output->geometry_out_interfaces[i].inouts_len != 0) {
+      printf("Error: geometry_out_interfaces[%d] is already used by \"%s\".\n",
+             i,
+             output->geometry_out_interfaces[i].name);
+      errors++;
+    }
+    else {
+      output->geometry_out_interfaces[i] = input->geometry_out_interfaces[i];
+    }
+  }
+
+  for (int i = 0; i < ARRAY_SIZE(input->resources); i++) {
+    for (int j = 0; j < ARRAY_SIZE(input->resources[i]); j++) {
+      if (input->resources[i][j].bind_type == UNUSED) {
+        continue;
+      }
+      else if (output->resources[i][j].bind_type != UNUSED) {
+        printf("Error: resources[%d][%d] is already used by \"%s\".\n",
+               i,
+               j,
+               output->resources[i][j].name);
+        errors++;
+      }
+      else {
+        output->resources[i][j] = input->resources[i][j];
+      }
+    }
+  }
+
+  for (int i = 0; i < ARRAY_SIZE(input->push_constants); i++) {
+    if (input->push_constants[i].type == UNUSED) {
+      continue;
+    }
+    else if (output->push_constants[i].type != UNUSED) {
+      printf("Error: push_constants[%d] is already used by \"%s\".\n",
+             i,
+             output->push_constants[i].name);
+      errors++;
+    }
+    else {
+      output->push_constants[i] = input->push_constants[i];
+    }
+  }
+
+  if (errors) {
+    printf("Error: Cannot merge %s into %s.\n", input->name, output->name);
+    return errors;
+  }
+
+  for (int i = 0; i < ARRAY_SIZE(input->additional_descriptors); i++) {
+    if (input->additional_descriptors[i]) {
+      const GPUShaderDescriptor *deps = find_descriptor_by_name(descriptors,
+                                                                input->additional_descriptors[i]);
+      if (deps) {
+        errors += descriptor_flatten(descriptors, deps, output);
+      }
+      else {
+        printf("Error: %s : Could not find dependency %s.\n",
+               input->name,
+               input->additional_descriptors[i]);
+        errors++;
+      }
+    }
+  }
+  return errors;
+}
+
+#define ENUM_TO_STR(_enum) [_enum] = #_enum
+
+static const char *inout_type_to_str(eGPUInOutType type)
+{
+  const char *strings[] = {
+      ENUM_TO_STR(UNUSED),         ENUM_TO_STR(BOOL),          ENUM_TO_STR(FLOAT),
+      ENUM_TO_STR(VEC2),           ENUM_TO_STR(VEC3),          ENUM_TO_STR(VEC4),
+      ENUM_TO_STR(UINT),           ENUM_TO_STR(UVEC2),         ENUM_TO_STR(UVEC3),
+      ENUM_TO_STR(UVEC4),          ENUM_TO_STR(INT),           ENUM_TO_STR(IVEC2),
+      ENUM_TO_STR(IVEC3),          ENUM_TO_STR(IVEC4),         ENUM_TO_STR(FLOAT_1D),
+      ENUM_TO_STR(FLOAT_1D_ARRAY), ENUM_TO_STR(FLOAT_2D),      ENUM_TO_STR(FLOAT_2D_ARRAY),
+      ENUM_TO_STR(FLOAT_3D),       ENUM_TO_STR(INT_1D),        ENUM_TO_STR(INT_1D_ARRAY),
+      ENUM_TO_STR(INT_2D),         ENUM_TO_STR(INT_2D_ARRAY),  ENUM_TO_STR(INT_3D),
+      ENUM_TO_STR(UINT_1D),        ENUM_TO_STR(UINT_1D_ARRAY), ENUM_TO_STR(UINT_2D),
+      ENUM_TO_STR(UINT_2D_ARRAY),  ENUM_TO_STR(UINT_3D),       ENUM_TO_STR(STRUCT),
+  };
+  return strings[type];
+}
+
+#undef ENUM_TO_STR
+
+/* Write newlines as separated lines. */
+static void write_str(FILE *fp,
+                      const char *indent,
+                      const char *iface_type,
+                      const GPUShaderDescriptor *desc,
+                      const char *const *src)
+{
+  (void)desc;
+  (void)iface_type;
+  const char *str = *src;
+  int n_char = strcspn(str, "\n");
+  do {
+    if (str != *src) {
+      fprintf(fp, "\n%s", indent);
+    }
+    fprintf(fp, "\"%.*s\\n\"", n_char, str);
+    str += n_char + 1;
+    n_char = strcspn(str, "\n");
+  } while (n_char > 1);
+}
+
+static void write_inout(FILE *fp,
+                        const char *indent,
+                        const char *iface_type,
+                        const GPUShaderDescriptor *desc,
+                        const GPUInOut *inout)
+{
+  (void)indent;
+  (void)desc;
+  (void)iface_type;
+  fprintf(
+      fp, "{%s, \"%s\", %u}", inout_type_to_str(inout->type), inout->name, (uint32_t)inout->qual);
+}
+
+static void write_interface_declaration(FILE *fp,
+                                        const char *indent,
+                                        const char *iface_type,
+                                        const GPUShaderDescriptor *desc,
+                                        const GPUInterfaceBlockDescription *iface)
+{
+  (void)indent;
+  fprintf(fp, "GPUInOut %s_%s_%s[] = {\n", desc->name, iface_type, iface->name);
+  for (int i = 0; i < iface->inouts_len; i++) {
+    fprintf(fp, "  ");
+    write_inout(fp, indent, iface_type, desc, &iface->inouts[i]);
+    fprintf(fp, ",\n");
+  }
+  fprintf(fp, "};\n");
+}
+
+static void write_interface(FILE *fp,
+                            const char *indent,
+                            const char *iface_type,
+                            const GPUShaderDescriptor *desc,
+                            const GPUInterfaceBlockDescription *iface)
+{
+  (void)indent;
+  if (iface->inouts_len > 0) {
+    fprintf(
+        fp, "STAGE_INTERFACE(\"%s\", %s_%s_%s)", iface->name, desc->name, iface_type, iface->name);
+  }
+  else {
+    fprintf(fp, "{NULL, 0, NULL}");
+  }
+}
+
+#define write_array(fp, desc, array, array_name, _used, write_function, iface_type, indent) \
+  { \
+    int used_slots = 0; \
+    for (int i = 0; i < ARRAY_SIZE(array); i++) { \
+      used_slots += (array[i] _used != UNUSED); \
+    } \
+    if (used_slots) { \
+      if (#array_name[0] != '\0') { \
+        fprintf(fp, "%s  " #array_name " = ", indent); \
+      } \
+      else { \
+        fprintf(fp, "%s  ", indent); \
+      } \
+      fprintf(fp, "{\n"); \
+      for (int i = 0; i < ARRAY_SIZE(array); i++) { \
+        if (array[i] _used != UNUSED) { \
+          fprintf(fp, "%s    [%d] = ", indent, i); \
+          write_function(fp, indent, iface_type, desc, &array[i]); \
+          fprintf(fp, ",\n"); \
+        } \
+      } \
+      fprintf(fp, "%s  },\n", indent); \
+    } \
+  }
+
+static void write_resource_bind(FILE *fp,
+                                const char *indent,
+                                const char *iface_type,
+                                const GPUShaderDescriptor *desc,
+                                const GPUResourceBind *bind)
+{
+  (void)indent;
+  (void)desc;
+  (void)iface_type;
+  fprintf(fp,
+          "{%u, %u, %u, %u, \"%s\", \"%s\"}",
+          (uint32_t)bind->bind_type,
+          (uint32_t)bind->type,
+          (uint32_t)bind->qual,
+          (uint32_t)bind->sampler,
+          bind->type_name ? bind->type_name : "",
+          bind->name);
+}
+
+static void write_descriptor(FILE *fp, const GPUShaderDescriptor *desc)
+{
+  fprintf(fp, "extern const GPUShaderDescriptor %s;\n", desc->name);
+
+  for (int i = 0; i < ARRAY_SIZE(desc->vertex_out_interfaces); i++) {
+    if (desc->vertex_out_interfaces[i].inouts_len != 0) {
+      write_interface_declaration(fp, "", "vert", desc, &desc->vertex_out_interfaces[i]);
+    }
+  }
+  for (int i = 0; i < ARRAY_SIZE(desc->geometry_out_interfaces); i++) {
+    if (desc->geometry_out_interfaces[i].inouts_len != 0) {
+      write_interface_declaration(fp, "", "geom", desc, &desc->geometry_out_interfaces[i]);
+    }
+  }
+
+  fprintf(fp, "const GPUShaderDescriptor %s = {\n", desc->name);
+  write_array(fp, desc, desc->vertex_inputs, .vertex_inputs, .type, write_inout, "", "");
+  write_array(fp, desc, desc->fragment_outputs, .fragment_outputs, .type, write_inout, "", "");
+  write_array(fp,
+              desc,
+              desc->vertex_out_interfaces,
+              .vertex_out_interfaces,
+              .inouts_len,
+              write_interface,
+              "vert",
+              "");
+  write_array(fp,
+              desc,
+              desc->geometry_out_interfaces,
+              .geometry_out_interfaces,
+              .inouts_len,
+              write_interface,
+              "frag",
+              "");
+  {
+    int used_slots_1 = 0;
+    for (int i = 0; i < ARRAY_SIZE(desc->resources); i++) {
+      for (int j = 0; j < ARRAY_SIZE(desc->resources[i]); j++) {
+        used_slots_1 += (desc->resources[i][j].bind_type != UNUSED);
+      }
+    }
+    if (used_slots_1) {
+      fprintf(fp, "  .resources = {\n");
+      write_array(fp,
+                  desc,
+                  desc->resources[0],
+                  [DESCRIPTOR_SET_0],
+                  .bind_type,
+                  write_resource_bind,
+                  "",
+                  "  ");
+      write_array(fp,
+                  desc,
+                  desc->resources[1],
+                  [DESCRIPTOR_SET_1],
+                  .bind_type,
+                  write_resource_bind,
+                  "",
+                  "  ");
+      fprintf(fp, "  },\n");
+    }
+  }
+  write_array(fp, desc, desc->push_constants, .push_constants, .type, write_inout, "", "");
+  write_array(fp, desc, desc->defines, .defines, , write_str, "", "");
+
+  if (desc->vertex_source) {
+    fprintf(fp, "  .vertex_source = \"%s\",\n", desc->vertex_source);
+  }
+  if (desc->geometry_source) {
+    fprintf(fp, "  .geometry_source = \"%s\",\n", desc->geometry_source);
+  }
+  if (desc->fragment_source) {
+    fprintf(fp, "  .fragment_source = \"%s\",\n", desc->fragment_source);
+  }
+  if (desc->compute_source) {
+    fprintf(fp, "  .compute_source = \"%s\",\n", desc->compute_source);
+  }
+
+  fprintf(fp, "};\n\n");
+}
+
+int main(int argc, char const *argv[])
+{
+  if (argc < 1) {
+    printf("Usage: shader_builder <data_file_to>\n");
+    exit(1);
+  }
+
+  size_t descriptors_len = 0;
+/* Count number of descriptors. Define interfaces. */
+#define GPU_STAGE_INTERFACE_CREATE(_interface) GPUInOut _interface[] =
+#define GPU_SHADER_DESCRIPTOR(_descriptor) \
+  descriptors_len++; \
+  (void)(GPUShaderDescriptor)
+#include "gpu_shader_descriptor_list.h"
+#undef GPU_STAGE_INTERFACE_CREATE
+#undef GPU_SHADER_DESCRIPTOR
+/* Discard interfaces then. */
+#define GPU_STAGE_INTERFACE_CREATE(_interface) (void)(GPUInOut[])
+
+  /* Null ended array. */
+  GPUShaderDescriptor **descriptors = calloc(descriptors_len + 1, sizeof(void *));
+
+  size_t index = 0;
+/* Declare everything first to be able to avoid dependency for references. */
+#define GPU_SHADER_DESCRIPTOR(_descriptor) \
+  GPUShaderDescriptor _descriptor; \
+  descriptors[index++] = &_descriptor; \
+  (void)(GPUShaderDescriptor)
+#include "gpu_shader_descriptor_list.h"
+#undef GPU_SHADER_DESCRIPTOR
+
+/* Set values. */
+#define GPU_SHADER_DESCRIPTOR(_descriptor) _descriptor = (GPUShaderDescriptor)
+#include "gpu_shader_descriptor_list.h"
+#undef GPU_SHADER_DESCRIPTOR
+
+/* Set name. */
+#define GPU_SHADER_DESCRIPTOR(_descriptor) \
+  _descriptor.name = #_descriptor; \
+  (void)(GPUShaderDescriptor)
+#include "gpu_shader_descriptor_list.h"
+#undef GPU_SHADER_DESCRIPTOR
+
+  FILE *fp = fopen(argv[1], "w");
+
+  fprintf(fp, "#include \"gpu_shader_descriptor.h\"\n");
+
+#if 1 /* TEST */
+  gpu_shader_dependency_init();
+#endif
+
+  int result = 0;
+  for (size_t i = 0; i < descriptors_len; i++) {
+    const GPUShaderDescriptor *descriptor = descriptors[i];
+
+    GPUShaderDescriptor flattened_descriptor = {0};
+
+    int errors = descriptor_flatten(descriptors, descriptor, &flattened_descriptor);
+    if (errors != 0) {
+      result = 1;
+      continue;
+    }
+
+    descriptor = &flattened_descriptor;
+
+    /* TODO(fclem): Validate push constant alignment & overlapping. */
+
+    if (descriptor->do_static_compilation) {
+#if 0 /* TODO */
+      descriptor->vulkan_spirv = vk_shader_compile(descriptor);
+      if (descriptor->vulkan_spirv == nullptr) {
+        result = 1;
+      }
+#endif
+#if 0 /* TODO */
+      if (gl_shader_validate(descriptor) == false) {
+        result = 1;
+      }
+#endif
+#if 1 /* TEST */
+      if (descriptor->vertex_source) {
+        char *src = gpu_shader_dependency_get_resolved_source(descriptor->vertex_source);
+
+        FILE *test_fp = fopen(descriptor->vertex_source, "w");
+        fprintf(test_fp, "%s", src);
+        fclose(test_fp);
+
+        free(src);
+      }
+#endif
+    }
+    write_descriptor(fp, descriptor);
+  }
+
+#if 1 /* TEST */
+  gpu_shader_dependency_exit();
+#endif
+
+  fclose(fp);
+
+  free(descriptors);
+
+  return result;
+}

source/blender/gpu/intern/gpu_shader_dependency.cc

@@ -0,0 +1,138 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2021 Blender Foundation.
+ * All rights reserved.
+ */
+
+/** \file
+ * \ingroup gpu
+ *
+ * Shader source dependency builder that make possible to support #include directive inside the
+ * shader files.
+ */
+
+#include <iostream>
+
+#include "BLI_map.hh"
+#include "BLI_set.hh"
+#include "BLI_string_ref.hh"
+
+#include "gpu_shader_dependency_private.h"
+
+extern "C" {
+#define SHADER_SOURCE(datatoc, filename) extern char datatoc[];
+#include "glsl_draw_source_list.h"
+#include "glsl_gpu_source_list.h"
+#undef SHADER_SOURCE
+}
+
+namespace blender::gpu {
+
+using GPUSourceDictionnary = Map<StringRef, struct GPUSource *>;
+
+struct GPUSource {
+  StringRefNull filename;
+  StringRefNull source;
+  Set<GPUSource *> dependencies;
+  bool dependencies_init = false;
+
+  GPUSource(const char *file, const char *datatoc) : filename(file), source(datatoc){};
+
+  void init_dependencies(const GPUSourceDictionnary &dict)
+  {
+    if (dependencies_init) {
+      return;
+    }
+    dependencies_init = true;
+    int64_t pos = 0;
+    while (1) {
+      pos = source.find("#pragma BLENDER_REQUIRE(", pos);
+      if (pos == -1) {
+        return;
+      }
+      int64_t start = source.find("(", pos) + 1;
+      int64_t end = source.find(")", pos);
+      if (end == -1) {
+        /* TODO Use clog. */
+        std::cout << "Error: " << filename << " : Malformed BLENDER_REQUIRE: Missing \")\"."
+                  << std::endl;
+        return;
+      }
+      StringRef dependency_name = source.substr(start, end - start);
+      GPUSource *source = dict.lookup_default(dependency_name, nullptr);
+      if (source == nullptr) {
+        /* TODO Use clog. */
+        std::cout << "Error: " << filename << " : Dependency not found \"" << dependency_name
+                  << "\"." << std::endl;
+        return;
+      }
+      /* Recursive. */
+      source->init_dependencies(dict);
+
+      for (auto dep : source->dependencies) {
+        dependencies.add(dep);
+      }
+      dependencies.add(source);
+      pos++;
+    };
+  }
+
+  /* Returns the final string with all inlcudes done. */
+  void build(std::string &str)
+  {
+    for (auto dep : dependencies) {
+      str += dep->source;
+    }
+    str += source;
+  }
+};
+
+}  // namespace blender::gpu
+
+using namespace blender::gpu;
+
+static GPUSourceDictionnary *g_sources = nullptr;
+
+void gpu_shader_dependency_init()
+{
+  g_sources = new GPUSourceDictionnary();
+
+#define SHADER_SOURCE(datatoc, filename) \
+  g_sources->add_new(filename, new GPUSource(filename, datatoc));
+#include "glsl_draw_source_list.h"
+#include "glsl_source_list.h"
+#undef SHADER_SOURCE
+
+  for (auto value : g_sources->values()) {
+    value->init_dependencies(*g_sources);
+  }
+}
+
+void gpu_shader_dependency_exit()
+{
+  for (auto value : g_sources->values()) {
+    delete value;
+  }
+  delete g_sources;
+}
+
+char *gpu_shader_dependency_get_resolved_source(const char *shader_source_name)
+{
+  GPUSource *source = g_sources->lookup(shader_source_name);
+  std::string str;
+  source->build(str);
+  return strdup(str.c_str());
+}

source/blender/gpu/intern/gpu_shader_dependency_private.h

@@ -0,0 +1,40 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2021 Blender Foundation.
+ * All rights reserved.
+ */
+
+/** \file
+ * \ingroup gpu
+ *
+ * Shader source dependency builder that make possible to support #include directive inside the
+ * shader files.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void gpu_shader_dependency_init(void);
+
+void gpu_shader_dependency_exit(void);
+
+/* User must free the resulting string using MEM_freeN. */
+char *gpu_shader_dependency_get_resolved_source(const char *shader_source_name);
+
+#ifdef __cplusplus
+}
+#endif

source/blender/gpu/intern/gpu_shader_descriptor.h

@@ -0,0 +1,243 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2021 Blender Foundation.
+ * All rights reserved.
+ */
+
+/** \file
+ * \ingroup gpu
+ *
+ * Descriptior type used to define shader structure, resources and interfaces.
+ *
+ * Some rule of thumb:
+ * - Do not include anything else than this file in each descriptor file.
+ */
+
+#pragma once
+
+#include <stdbool.h>
+
+/* For helping intellisense. */
+#ifndef GPU_SHADER_DESCRIPTOR
+#  define GPU_STAGE_INTERFACE_CREATE(_interface) GPUInOut _interface[] =
+#  define GPU_SHADER_DESCRIPTOR(_descriptor) GPUShaderDescriptor _descriptor =
+#endif
+
+#ifndef ARRAY_SIZE
+#  define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(*(arr)))
+#endif
+
+#define UNUSED 0
+
+typedef enum eGPUInOutType {
+  /* UNUSED = 0 */
+  FLOAT = 1,
+  VEC2,
+  VEC3,
+  VEC4,
+  UINT,
+  UVEC2,
+  UVEC3,
+  UVEC4,
+  INT,
+  IVEC2,
+  IVEC3,
+  IVEC4,
+  BOOL,
+  /* Samplers & images. */
+  FLOAT_BUFFER,
+  FLOAT_1D,
+  FLOAT_1D_ARRAY,
+  FLOAT_2D,
+  FLOAT_2D_ARRAY,
+  FLOAT_3D,
+  INT_BUFFER,
+  INT_1D,
+  INT_1D_ARRAY,
+  INT_2D,
+  INT_2D_ARRAY,
+  INT_3D,
+  UINT_BUFFER,
+  UINT_1D,
+  UINT_1D_ARRAY,
+  UINT_2D,
+  UINT_2D_ARRAY,
+  UINT_3D,
+  /* Custom structure. */
+  STRUCT,
+} eGPUInOutType;
+
+typedef enum eGPUInOutQualifier {
+  /* Storage qualifiers. */
+  RESTRICT = (1 << 0),
+  READ_ONLY = (1 << 1),
+  WRITE_ONLY = (1 << 2),
+  /* Interp qualifiers. */
+  SMOOTH = (1 << 3),
+  FLAT = (2 << 3),
+  NO_PERSPECTIVE = (3 << 3),
+  /* Dual Source Blending Index. */
+  OUTPUT_INDEX_0 = (4 << 3),
+  OUTPUT_INDEX_1 = (5 << 3),
+} eGPUInOutQualifier;
+
+typedef enum eGPUBindType {
+  GPU_BIND_UNIFORM_BUFFER = 1,
+  GPU_BIND_STORAGE_BUFFER,
+  GPU_BIND_SAMPLER,
+  GPU_BIND_IMAGE,
+} eGPUBindType;
+
+/* Syntaxic suggar. */
+#define DESCRIPTOR_SET_0 0
+#define DESCRIPTOR_SET_1 1
+#define DESCRIPTOR_SET_2 2
+#define DESCRIPTOR_SET_3 3
+
+typedef struct GPUInOut {
+  eGPUInOutType type;
+  const char *name;
+  eGPUInOutQualifier qual;
+} GPUInOut;
+
+#define VERTEX_INPUT(_type, _name) \
+  { \
+    .type = _type, .name = _name \
+  }
+
+#define FRAGMENT_OUTPUT(_type, _name) \
+  { \
+    .type = _type, .name = _name \
+  }
+
+#define FRAGMENT_OUTPUT_DUALBLEND(_type, _name, _index) \
+  { \
+    .type = _type, .name = _name, .qual = _index \
+  }
+
+#define PUSH_CONSTANT(_type, _name) \
+  { \
+    .type = _type, .name = _name \
+  }
+
+typedef enum eGPUSamplerState {
+  GPU_SAMPLER_DEFAULT = 0,
+  GPU_SAMPLER_FILTER = (1 << 0),
+  GPU_SAMPLER_MIPMAP = (1 << 1),
+  GPU_SAMPLER_REPEAT_S = (1 << 2),
+  GPU_SAMPLER_REPEAT_T = (1 << 3),
+  GPU_SAMPLER_REPEAT_R = (1 << 4),
+  GPU_SAMPLER_CLAMP_BORDER = (1 << 5), /* Clamp to border color instead of border texel. */
+  GPU_SAMPLER_COMPARE = (1 << 6),
+  GPU_SAMPLER_ANISO = (1 << 7),
+  GPU_SAMPLER_ICON = (1 << 8),
+
+  GPU_SAMPLER_REPEAT = (GPU_SAMPLER_REPEAT_S | GPU_SAMPLER_REPEAT_T | GPU_SAMPLER_REPEAT_R),
+} eGPUSamplerState;
+
+typedef struct GPUResourceBind {
+  eGPUBindType bind_type;
+  eGPUInOutType type;
+  eGPUInOutQualifier qual;
+  eGPUSamplerState sampler;
+  /* Defined type name. */
+  const char *type_name;
+  /* Name can contain array size (i.e: "colors[6]"). Note: supports unsized arrays for SSBO. */
+  const char *name;
+} GPUResourceBind;
+
+#define UNIFORM_BUFFER(_typename, _name) \
+  { \
+    .bind_type = GPU_BIND_UNIFORM_BUFFER, .type_name = _typename, .name = _name, \
+  }
+
+#define STORAGE_BUFFER(_typename, _name, _qual) \
+  { \
+    .bind_type = GPU_BIND_STORAGE_BUFFER, .type_name = _typename, .name = _name, .qual = _qual, \
+  }
+
+#define SAMPLER(_type, _name, _sampler) \
+  { \
+    .bind_type = GPU_BIND_SAMPLER, .type = _type, .name = _name, .sampler = _sampler, \
+  }
+
+#define IMAGE(_type, _name, _qual) \
+  { \
+    .bind_type = GPU_BIND_IMAGE, .type = _type, .name = _name, .qual = _qual, \
+  }
+
+typedef struct GPUInterfaceBlockDescription {
+  /** Name of the instance of the block (used to access). Can be empty "". */
+  const char *name;
+  /** List of all members of the interface. */
+  int inouts_len;
+  GPUInOut *inouts;
+} GPUInterfaceBlockDescription;
+
+#define STAGE_INTERFACE(_name, _inouts) \
+  { \
+    .name = _name, .inouts_len = ARRAY_SIZE(_inouts), .inouts = _inouts \
+  }
+
+/* Vulkan garantee 4 distinct descriptior set. */
+#define GPU_MAX_DESCIPTOR_SET 2
+/* Should be tweaked to be as large as the maximum supported by the low end hardware we support. */
+#define GPU_MAX_RESOURCE_PER_DESCRIPTOR 8
+
+/**
+ * @brief Describe inputs & outputs, stage interfaces, resources and sources of a shader.
+ *        If all data is correctly provided, this is all that is needed to create and compile
+ *        a GPUShader.
+ *
+ * IMPORTANT: All strings are references only. Make sure all the strings used by a
+ *            GPUShaderDescriptor are not freed until it is consumed or deleted.
+ */
+typedef struct GPUShaderDescriptor {
+  /** Shader name for debugging. */
+  const char *name;
+  /** True if the shader is static and can be precompiled at compile time. */
+  bool do_static_compilation;
+
+  GPUInOut vertex_inputs[16];
+  GPUInOut fragment_outputs[8];
+
+  GPUInterfaceBlockDescription vertex_out_interfaces[4];
+  GPUInterfaceBlockDescription geometry_out_interfaces[4];
+
+  GPUResourceBind resources[GPU_MAX_DESCIPTOR_SET][GPU_MAX_RESOURCE_PER_DESCRIPTOR];
+
+  /**
+   * Data managed by GPUShader. Can be set through uniform functions. Must be less than 128bytes.
+   * One slot represents 4bytes. Each element needs to have enough empty space left after it.
+   * example:
+   * [0] = PUSH_CONSTANT(MAT4, "ModelMatrix"),
+   * ---- 16 slots occupied by ModelMatrix ----
+   * [16] = PUSH_CONSTANT(VEC4, "color"),
+   * ---- 4 slots occupied by color ----
+   * [20] = PUSH_CONSTANT(BOOL, "srgbToggle"),
+   */
+  GPUInOut push_constants[32];
+
+  const char *vertex_source, *geometry_source, *fragment_source, *compute_source;
+
+  const char *defines[8];
+
+  /**
+   * Name of other descriptors to recursively merge with this one.
+   * No data slot must overlap otherwise we throw an error.
+   */
+  const char *additional_descriptors[4];
+} GPUShaderDescriptor;

source/blender/gpu/shaders/gpu_clip_planes.desc.h

@@ -0,0 +1,17 @@
+
+#include "gpu_shader_descriptor.h"
+
+GPU_SHADER_DESCRIPTOR(gpu_clip_planes)
+{
+    .resources =
+        {
+            [DESCRIPTOR_SET_0] =
+                {
+                    [1] = UNIFORM_BUFFER("GPUClipPlanes", "clipPlanes"),
+                },
+        },
+    .defines =
+        {
+            [5] = "#define USE_WORLD_CLIP_PLANES\n",
+        },
+};

source/blender/gpu/shaders/gpu_shader_3D_flat_color.desc.h

@@ -0,0 +1,39 @@
+
+#include "gpu_shader_descriptor.h"
+
+GPU_STAGE_INTERFACE_CREATE(flat_color_iface)
+{
+    {VEC4, "finalColor", FLAT},
+};
+
+GPU_SHADER_DESCRIPTOR(gpu_shader_3D_flat_color)
+{
+    .vertex_inputs =
+        {
+            [0] = VERTEX_INPUT(VEC3, "pos"),
+            [1] = VERTEX_INPUT(VEC4, "col"),
+        },
+    .vertex_out_interfaces =
+        {
+            [0] = STAGE_INTERFACE("", flat_color_iface),
+        },
+    .fragment_outputs =
+        {
+            [0] = FRAGMENT_OUTPUT(VEC4, "fragColor"),
+        },
+    .push_constants =
+        {
+            [1] = PUSH_CONSTANT(BOOL, "srgbTarget"),
+        },
+    .vertex_source = "gpu_shader_3D_flat_color_vert.glsl",
+    .fragment_source = "gpu_shader_flat_color_frag.glsl",
+};
+
+GPU_SHADER_DESCRIPTOR(gpu_shader_3D_flat_color_clipped)
+{
+    .additional_descriptors =
+        {
+            "gpu_shader_3D_flat_color",
+            "gpu_clip_planes",
+        },
+};