Merge branch 'master' into tmp-workbench-shader-create-infos

# Conflicts:
#	source/blender/draw/intern/shaders/common_hair_lib.glsl

source/blender/draw/CMakeLists.txt

@@ -154,7 +154,7 @@ set(SRC
   engines/workbench/workbench_materials.c
   engines/workbench/workbench_opaque.c
   engines/workbench/workbench_render.c
-  engines/workbench/workbench_shader.c
+  engines/workbench/workbench_shader.cc
   engines/workbench/workbench_shadow.c
   engines/workbench/workbench_transparent.c
   engines/workbench/workbench_volume.c
@@ -342,7 +342,6 @@ set(GLSL_SRC
   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
@@ -357,7 +356,6 @@ set(GLSL_SRC
   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
@@ -378,6 +376,7 @@ set(GLSL_SRC
   intern/shaders/common_hair_refine_comp.glsl
   intern/shaders/common_math_lib.glsl
   intern/shaders/common_math_geom_lib.glsl
+  intern/shaders/common_view_clipping_lib.glsl
   intern/shaders/common_view_lib.glsl
   intern/shaders/common_fxaa_lib.glsl
   intern/shaders/common_smaa_lib.glsl

source/blender/draw/engines/workbench/shaders/infos/workbench_composite_info.hh

@@ -0,0 +1,41 @@
+
+#include "gpu_shader_create_info.hh"
+
+/* -------------------------------------------------------------------- */
+/** \name Base Composite
+ * \{ */
+
+GPU_SHADER_CREATE_INFO(workbench_composite)
+    .sampler(0, ImageType::FLOAT_2D, "normalBuffer", Frequency::PASS)
+    .sampler(1, ImageType::FLOAT_2D, "materialBuffer", Frequency::PASS)
+    .uniform_buf(4, "WorldData", "world_data", Frequency::PASS)
+    .push_constant(0, Type::BOOL, "forceShadowing")
+    .fragment_out(0, Type::VEC4, "fragColor")
+    .typedef_source("workbench_shader_shared.h")
+    .fragment_source("workbench_composite_frag.glsl")
+    .additional_info("draw_fullscreen");
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Lighting Type
+ * \{ */
+
+GPU_SHADER_CREATE_INFO(workbench_composite_studio)
+    .define("V3D_LIGHTING_STUDIO")
+    .additional_info("workbench_composite")
+    .do_static_compilation(true);
+
+GPU_SHADER_CREATE_INFO(workbench_composite_matcap)
+    .define("V3D_LIGHTING_MATCAP")
+    .sampler(2, ImageType::FLOAT_2D, "matcap_diffuse_tx", Frequency::PASS)
+    .sampler(3, ImageType::FLOAT_2D, "matcap_specular_tx", Frequency::PASS)
+    .additional_info("workbench_composite")
+    .do_static_compilation(true);
+
+GPU_SHADER_CREATE_INFO(workbench_composite_flat)
+    .define("V3D_LIGHTING_FLAT")
+    .additional_info("workbench_composite")
+    .do_static_compilation(true);
+
+/** \} */

source/blender/draw/engines/workbench/shaders/infos/workbench_effect_antialiasing_info.hh

@@ -0,0 +1,64 @@
+
+#include "gpu_shader_create_info.hh"
+
+/* -------------------------------------------------------------------- */
+/** \name TAA
+ * \{ */
+
+GPU_SHADER_CREATE_INFO(workbench_taa)
+    .sampler(0, ImageType::FLOAT_2D, "colorBuffer")
+    .push_constant(0, Type::FLOAT, "samplesWeights", 9)
+    .fragment_out(0, Type::VEC4, "fragColor")
+    .fragment_source("workbench_effect_taa_frag.glsl")
+    .additional_info("draw_fullscreen")
+    .do_static_compilation(true);
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name SMAA
+ * \{ */
+
+GPU_SHADER_INTERFACE_INFO(workbench_smaa_iface, "")
+    .smooth(Type::VEC2, "uvs")
+    .smooth(Type::VEC2, "pixcoord")
+    .smooth(Type::VEC4, "offset[3]");
+
+GPU_SHADER_CREATE_INFO(workbench_smaa)
+    .define("SMAA_GLSL_3")
+    .define("SMAA_RT_METRICS", "viewportMetrics")
+    .define("SMAA_PRESET_HIGH")
+    .define("SMAA_LUMA_WEIGHT", "float4(1.0, 1.0, 1.0, 1.0)")
+    .define("SMAA_NO_DISCARD")
+    .vertex_out(workbench_smaa_iface)
+    .push_constant(1, Type::VEC4, "viewportMetrics")
+    .vertex_source("workbench_effect_smaa_vert.glsl")
+    .fragment_source("workbench_effect_smaa_frag.glsl");
+
+GPU_SHADER_CREATE_INFO(workbench_smaa_stage_0)
+    .define("SMAA_STAGE", "0")
+    .sampler(0, ImageType::FLOAT_2D, "colorTex")
+    .fragment_out(0, Type::VEC2, "out_edges")
+    .additional_info("workbench_smaa")
+    .do_static_compilation(true);
+
+GPU_SHADER_CREATE_INFO(workbench_smaa_stage_1)
+    .define("SMAA_STAGE", "1")
+    .sampler(0, ImageType::FLOAT_2D, "edgesTex")
+    .sampler(1, ImageType::FLOAT_2D, "areaTex")
+    .sampler(2, ImageType::FLOAT_2D, "searchTex")
+    .fragment_out(0, Type::VEC4, "out_weights")
+    .additional_info("workbench_smaa")
+    .do_static_compilation(true);
+
+GPU_SHADER_CREATE_INFO(workbench_smaa_stage_2)
+    .define("SMAA_STAGE", "2")
+    .sampler(0, ImageType::FLOAT_2D, "colorTex")
+    .sampler(1, ImageType::FLOAT_2D, "blendTex")
+    .push_constant(2, Type::FLOAT, "mixFactor")
+    .push_constant(3, Type::FLOAT, "taaAccumulatedWeight")
+    .fragment_out(0, Type::VEC4, "out_color")
+    .additional_info("workbench_smaa")
+    .do_static_compilation(true);
+
+/** \} */

source/blender/draw/engines/workbench/shaders/infos/workbench_effect_cavity_info.hh

@@ -3,10 +3,13 @@
 
 GPU_SHADER_CREATE_INFO(workbench_effect_cavity_common)
     .fragment_out(0, Type::VEC4, "fragColor")
-    .sampler(0, ImageType::FLOAT_2D, "depthBuffer")
+    .sampler(0, ImageType::DEPTH_2D, "depthBuffer")
     .sampler(1, ImageType::FLOAT_2D, "normalBuffer")
     .sampler(2, ImageType::UINT_2D, "objectIdBuffer")
+    .sampler(3, ImageType::FLOAT_2D, "cavityJitter")
     .uniform_buf(3, "vec4", "samples_coords[512]")
+    .uniform_buf(4, "WorldData", "world_data", Frequency::PASS)
+    .typedef_source("workbench_shader_shared.h")
     .fragment_source("workbench_effect_cavity_frag.glsl")
     .additional_info("draw_fullscreen")
     .additional_info("draw_view");

source/blender/draw/engines/workbench/shaders/infos/workbench_effect_dof_info.hh

@@ -0,0 +1,55 @@
+
+#include "gpu_shader_create_info.hh"
+
+GPU_SHADER_CREATE_INFO(workbench_effect_dof)
+    /* TODO(fclem): Split resources per stage. */
+    .sampler(0, ImageType::FLOAT_2D, "inputCocTex")
+    .sampler(1, ImageType::FLOAT_2D, "maxCocTilesTex")
+    .sampler(2, ImageType::FLOAT_2D, "sceneColorTex")
+    .sampler(3, ImageType::FLOAT_2D, "sceneDepthTex")
+    .sampler(4, ImageType::FLOAT_2D, "backgroundTex")
+    .sampler(5, ImageType::FLOAT_2D, "halfResColorTex")
+    .sampler(6, ImageType::FLOAT_2D, "blurTex")
+    .sampler(7, ImageType::FLOAT_2D, "noiseTex")
+    .push_constant(0, Type::VEC2, "invertedViewportSize")
+    .push_constant(1, Type::VEC2, "nearFar")
+    .push_constant(2, Type::VEC3, "dofParams")
+    .push_constant(3, Type::FLOAT, "noiseOffset")
+    .fragment_source("workbench_effect_dof_frag.glsl")
+    .additional_info("draw_fullscreen")
+    .additional_info("draw_view");
+
+GPU_SHADER_CREATE_INFO(workbench_effect_dof_prepare)
+    .define("PREPARE")
+    .fragment_out(0, Type::VEC4, "halfResColor")
+    .fragment_out(1, Type::VEC2, "normalizedCoc")
+    .additional_info("workbench_effect_dof")
+    .do_static_compilation(true);
+
+GPU_SHADER_CREATE_INFO(workbench_effect_dof_downsample)
+    .define("DOWNSAMPLE")
+    .fragment_out(0, Type::VEC4, "outColor")
+    .fragment_out(1, Type::VEC2, "outCocs")
+    .additional_info("workbench_effect_dof")
+    .do_static_compilation(true);
+
+GPU_SHADER_CREATE_INFO(workbench_effect_dof_blur1)
+    .define("BLUR1")
+    .define("NUM_SAMPLES", "49")
+    .uniform_buf(1, "vec4", "samples[49]")
+    .fragment_out(0, Type::VEC4, "blurColor")
+    .additional_info("workbench_effect_dof")
+    .do_static_compilation(true);
+
+GPU_SHADER_CREATE_INFO(workbench_effect_dof_blur2)
+    .define("BLUR2")
+    .fragment_out(0, Type::VEC4, "finalColor")
+    .additional_info("workbench_effect_dof")
+    .do_static_compilation(true);
+
+GPU_SHADER_CREATE_INFO(workbench_effect_dof_resolve)
+    .define("RESOLVE")
+    .fragment_out(0, Type::VEC4, "finalColorAdd", DualBlend::SRC_0)
+    .fragment_out(0, Type::VEC4, "finalColorMul", DualBlend::SRC_1)
+    .additional_info("workbench_effect_dof")
+    .do_static_compilation(true);

source/blender/draw/engines/workbench/shaders/infos/workbench_effect_outline_info.hh

@@ -0,0 +1,11 @@
+
+#include "gpu_shader_create_info.hh"
+
+GPU_SHADER_CREATE_INFO(workbench_effect_outline)
+    .typedef_source("workbench_shader_shared.h")
+    .fragment_source("workbench_effect_outline_frag.glsl")
+    .sampler(0, ImageType::UINT_2D, "objectIdBuffer")
+    .uniform_buf(4, "WorldData", "world_data", Frequency::PASS)
+    .fragment_out(0, Type::VEC4, "fragColor")
+    .additional_info("draw_fullscreen")
+    .do_static_compilation(true);

source/blender/draw/engines/workbench/shaders/infos/workbench_merge_infront_info.hh

@@ -0,0 +1,9 @@
+
+#include "gpu_shader_create_info.hh"
+
+GPU_SHADER_CREATE_INFO(workbench_merge_infront)
+    .fragment_out(0, Type::VEC4, "fragColor")
+    .sampler(0, ImageType::DEPTH_2D, "depthBuffer")
+    .fragment_source("workbench_merge_infront_frag.glsl")
+    .additional_info("draw_fullscreen")
+    .do_static_compilation(true);

source/blender/draw/engines/workbench/shaders/infos/workbench_prepass_info.hh

@@ -11,17 +11,20 @@ GPU_SHADER_CREATE_INFO(workbench_mesh)
     .vertex_in(2, Type::VEC4, "ac")
     .vertex_in(3, Type::VEC2, "au")
     .vertex_source("workbench_prepass_vert.glsl")
-    .additional_info("draw_mesh");
+    .additional_info("draw_mesh")
+    .additional_info("draw_resource_handle");
 
 GPU_SHADER_CREATE_INFO(workbench_hair)
     .sampler(0, ImageType::FLOAT_BUFFER, "ac", Frequency::BATCH)
     .sampler(1, ImageType::FLOAT_BUFFER, "au", Frequency::BATCH)
     .vertex_source("workbench_prepass_hair_vert.glsl")
-    .additional_info("draw_hair");
+    .additional_info("draw_hair")
+    .additional_info("draw_resource_handle");
 
 GPU_SHADER_CREATE_INFO(workbench_pointcloud)
     .vertex_source("workbench_prepass_pointcloud_vert.glsl")
-    .additional_info("draw_pointcloud");
+    .additional_info("draw_pointcloud")
+    .additional_info("draw_resource_handle");
 
 /** \} */
 
@@ -42,17 +45,21 @@ GPU_SHADER_CREATE_INFO(workbench_texture_tile)
     .sampler(3, ImageType::FLOAT_1D_ARRAY, "imageTileData", Frequency::BATCH)
     .push_constant(1, Type::BOOL, "imagePremult")
     .push_constant(2, Type::FLOAT, "imageTransparencyCutoff")
+    .define("V3D_SHADING_TEXTURE_COLOR")
     .define("TEXTURE_IMAGE_ARRAY");
 
 /** \} */
 
 /* -------------------------------------------------------------------- */
-/** \name Lighting Type
+/** \name Lighting Type (only for transparent)
  * \{ */
 
-GPU_SHADER_CREATE_INFO(workbench_lighting_studio).define("V3D_LIGHTING_STUDIO");
-GPU_SHADER_CREATE_INFO(workbench_lighting_matcap).define("V3D_LIGHTING_MATCAP");
 GPU_SHADER_CREATE_INFO(workbench_lighting_flat).define("V3D_LIGHTING_FLAT");
+GPU_SHADER_CREATE_INFO(workbench_lighting_studio).define("V3D_LIGHTING_STUDIO");
+GPU_SHADER_CREATE_INFO(workbench_lighting_matcap)
+    .define("V3D_LIGHTING_MATCAP")
+    .sampler(4, ImageType::FLOAT_2D, "matcap_diffuse_tx", Frequency::PASS)
+    .sampler(5, ImageType::FLOAT_2D, "matcap_specular_tx", Frequency::PASS);
 
 /** \} */
 
@@ -69,7 +76,12 @@ GPU_SHADER_INTERFACE_INFO(workbench_material_iface, "")
     .flat(Type::FLOAT, "roughness")
     .flat(Type::FLOAT, "metallic");
 
-GPU_SHADER_CREATE_INFO(workbench_material).vertex_out(workbench_material_iface);
+GPU_SHADER_CREATE_INFO(workbench_material)
+    .uniform_buf(4, "WorldData", "world_data", Frequency::PASS)
+    .uniform_buf(5, "vec4", "materials_data[4096]", Frequency::PASS)
+    .push_constant(4, Type::INT, "materialIndex")
+    .push_constant(5, Type::BOOL, "useMatcap")
+    .vertex_out(workbench_material_iface);
 
 /** \} */
 
@@ -83,19 +95,16 @@ GPU_SHADER_CREATE_INFO(workbench_transparent_accum)
     .fragment_out(0, Type::VEC4, "transparentAccum")
     .fragment_out(1, Type::VEC4, "revealageAccum")
     .fragment_out(2, Type::UINT, "objectId")
-    .uniform_buf(4, "WorldData", "world_data", Frequency::PASS)
+    .push_constant(3, Type::BOOL, "forceShadowing")
     .typedef_source("workbench_shader_shared.h")
-    .fragment_source("workbench_transparent_accum_frag.glsl")
-    .additional_info("workbench_material");
+    .fragment_source("workbench_transparent_accum_frag.glsl");
 
 GPU_SHADER_CREATE_INFO(workbench_opaque)
     .fragment_out(0, Type::VEC4, "materialData")
     .fragment_out(1, Type::VEC2, "normalData")
     .fragment_out(2, Type::UINT, "objectId")
-    .uniform_buf(4, "WorldData", "world_data", Frequency::PASS)
     .typedef_source("workbench_shader_shared.h")
-    .fragment_source("workbench_prepass_frag.glsl")
-    .additional_info("workbench_material");
+    .fragment_source("workbench_prepass_frag.glsl");
 
 /** \} */
 
@@ -103,34 +112,38 @@ GPU_SHADER_CREATE_INFO(workbench_opaque)
 /** \name Variations Declaration
  * \{ */
 
-#define WORKBENCH_SURFACETYPE_VARIATIONS(prefix, ...) \
-  GPU_SHADER_CREATE_INFO(prefix##_mesh) \
-      .additional_info("workbench_mesh", __VA_ARGS__) \
-      .do_static_compilation(true); \
-  GPU_SHADER_CREATE_INFO(prefix##_hair) \
-      .additional_info("workbench_hair", __VA_ARGS__) \
-      .do_static_compilation(true); \
-  GPU_SHADER_CREATE_INFO(prefix##_ptcloud) \
-      .additional_info("workbench_pointcloud", __VA_ARGS__) \
-      .do_static_compilation(true);
+#define WORKBENCH_FINAL_VARIATION(name, ...) \
+  GPU_SHADER_CREATE_INFO(name).additional_info(__VA_ARGS__).do_static_compilation(true);
+
+#define WORKBENCH_CLIPPING_VARIATIONS(prefix, ...) \
+  WORKBENCH_FINAL_VARIATION(prefix##_clip, "drw_clipped", __VA_ARGS__) \
+  WORKBENCH_FINAL_VARIATION(prefix##_no_clip, __VA_ARGS__)
+
+#define WORKBENCH_TEXTURE_VARIATIONS(prefix, ...) \
+  WORKBENCH_CLIPPING_VARIATIONS(prefix##_tex_none, "workbench_texture_none", __VA_ARGS__) \
+  WORKBENCH_CLIPPING_VARIATIONS(prefix##_tex_single, "workbench_texture_single", __VA_ARGS__) \
+  WORKBENCH_CLIPPING_VARIATIONS(prefix##_tex_tile, "workbench_texture_tile", __VA_ARGS__)
+
+#define WORKBENCH_DATATYPE_VARIATIONS(prefix, ...) \
+  WORKBENCH_TEXTURE_VARIATIONS(prefix##_mesh, "workbench_mesh", __VA_ARGS__) \
+  WORKBENCH_TEXTURE_VARIATIONS(prefix##_hair, "workbench_hair", __VA_ARGS__) \
+  WORKBENCH_TEXTURE_VARIATIONS(prefix##_ptcloud, "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_DATATYPE_VARIATIONS(prefix##_transp_studio, \
+                                "workbench_transparent_accum", \
+                                "workbench_lighting_studio", \
+                                __VA_ARGS__) \
+  WORKBENCH_DATATYPE_VARIATIONS(prefix##_transp_matcap, \
+                                "workbench_transparent_accum", \
+                                "workbench_lighting_matcap", \
+                                __VA_ARGS__) \
+  WORKBENCH_DATATYPE_VARIATIONS(prefix##_transp_flat, \
+                                "workbench_transparent_accum", \
+                                "workbench_lighting_flat", \
+                                __VA_ARGS__) \
+  WORKBENCH_DATATYPE_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")
+WORKBENCH_PIPELINE_VARIATIONS(workbench, "workbench_material");
 
 /** \} */

source/blender/draw/engines/workbench/shaders/infos/workbench_shadow_info.hh

@@ -0,0 +1,98 @@
+
+#include "gpu_shader_create_info.hh"
+
+/* -------------------------------------------------------------------- */
+/** \name Common
+ * \{ */
+
+GPU_SHADER_INTERFACE_INFO(workbench_shadow_iface, "vData")
+    .smooth(Type::VEC3, "pos")
+    .smooth(Type::VEC4, "frontPosition")
+    .smooth(Type::VEC4, "backPosition");
+
+GPU_SHADER_CREATE_INFO(workbench_shadow_common)
+    .vertex_in(0, Type::VEC3, "pos")
+    .vertex_out(workbench_shadow_iface)
+    .push_constant(0, Type::FLOAT, "lightDistance")
+    .push_constant(1, Type::VEC3, "lightDirection")
+    .vertex_source("workbench_shadow_vert.glsl")
+    .additional_info("draw_mesh");
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Manifold Type
+ * \{ */
+
+GPU_SHADER_CREATE_INFO(workbench_shadow_manifold)
+    .geometry_layout(PrimitiveIn::LINES_ADJACENCY, PrimitiveOut::TRIANGLE_STRIP, 4, 1)
+    .geometry_source("workbench_shadow_geom.glsl");
+
+GPU_SHADER_CREATE_INFO(workbench_shadow_no_manifold)
+    .geometry_layout(PrimitiveIn::LINES_ADJACENCY, PrimitiveOut::TRIANGLE_STRIP, 4, 2)
+    .geometry_source("workbench_shadow_geom.glsl");
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Caps Type
+ * \{ */
+
+GPU_SHADER_CREATE_INFO(workbench_shadow_caps)
+    .geometry_layout(PrimitiveIn::TRIANGLES, PrimitiveOut::TRIANGLE_STRIP, 3, 2)
+    .geometry_source("workbench_shadow_caps_geom.glsl");
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Debug Type
+ * \{ */
+
+GPU_SHADER_CREATE_INFO(workbench_shadow_no_debug)
+    .fragment_source("gpu_shader_depth_only_frag.glsl");
+
+GPU_SHADER_CREATE_INFO(workbench_shadow_debug)
+    .fragment_out(0, Type::VEC4, "materialData")
+    .fragment_out(1, Type::VEC4, "normalData")
+    .fragment_out(2, Type::UINT, "objectId")
+    .fragment_source("workbench_shadow_debug_frag.glsl");
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Variations Declaration
+ * \{ */
+
+#define WORKBENCH_SHADOW_VARIATIONS(suffix, ...) \
+  GPU_SHADER_CREATE_INFO(workbench_shadow_pass_manifold_no_caps##suffix) \
+      .define("SHADOW_PASS") \
+      .additional_info("workbench_shadow_common", "workbench_shadow_manifold", __VA_ARGS__) \
+      .do_static_compilation(true); \
+  GPU_SHADER_CREATE_INFO(workbench_shadow_pass_no_manifold_no_caps##suffix) \
+      .define("SHADOW_PASS") \
+      .define("DOUBLE_MANIFOLD") \
+      .additional_info("workbench_shadow_common", "workbench_shadow_no_manifold", __VA_ARGS__) \
+      .do_static_compilation(true); \
+  GPU_SHADER_CREATE_INFO(workbench_shadow_fail_manifold_caps##suffix) \
+      .define("SHADOW_FAIL") \
+      .additional_info("workbench_shadow_common", "workbench_shadow_caps", __VA_ARGS__) \
+      .do_static_compilation(true); \
+  GPU_SHADER_CREATE_INFO(workbench_shadow_fail_manifold_no_caps##suffix) \
+      .define("SHADOW_FAIL") \
+      .additional_info("workbench_shadow_common", "workbench_shadow_manifold", __VA_ARGS__) \
+      .do_static_compilation(true); \
+  GPU_SHADER_CREATE_INFO(workbench_shadow_fail_no_manifold_caps##suffix) \
+      .define("SHADOW_FAIL") \
+      .define("DOUBLE_MANIFOLD") \
+      .additional_info("workbench_shadow_common", "workbench_shadow_caps", __VA_ARGS__) \
+      .do_static_compilation(true); \
+  GPU_SHADER_CREATE_INFO(workbench_shadow_fail_no_manifold_no_caps##suffix) \
+      .define("SHADOW_FAIL") \
+      .define("DOUBLE_MANIFOLD") \
+      .additional_info("workbench_shadow_common", "workbench_shadow_no_manifold", __VA_ARGS__) \
+      .do_static_compilation(true);
+
+WORKBENCH_SHADOW_VARIATIONS(, "workbench_shadow_no_debug")
+WORKBENCH_SHADOW_VARIATIONS(_debug, "workbench_shadow_debug")
+
+/** \} */

source/blender/draw/engines/workbench/shaders/infos/workbench_transparent_resolve_info.hh

@@ -0,0 +1,10 @@
+
+#include "gpu_shader_create_info.hh"
+
+GPU_SHADER_CREATE_INFO(workbench_transparent_resolve)
+    .fragment_out(0, Type::VEC4, "fragColor")
+    .sampler(0, ImageType::FLOAT_2D, "transparentAccum")
+    .sampler(1, ImageType::FLOAT_2D, "transparentRevealage")
+    .fragment_source("workbench_transparent_resolve_frag.glsl")
+    .additional_info("draw_fullscreen")
+    .do_static_compilation(true);

source/blender/draw/engines/workbench/shaders/infos/workbench_volume_info.hh

@@ -0,0 +1,114 @@
+
+#include "gpu_shader_create_info.hh"
+
+/* -------------------------------------------------------------------- */
+/** \name Volume shader base
+ * \{ */
+
+GPU_SHADER_CREATE_INFO(workbench_volume)
+    .vertex_in(0, Type::VEC3, "pos")
+    .fragment_out(0, Type::VEC4, "fragColor")
+    .sampler(0, ImageType::DEPTH_2D, "depthBuffer")
+    .sampler(1, ImageType::FLOAT_3D, "densityTexture")
+    .push_constant(28, Type::INT, "samplesLen")
+    .push_constant(29, Type::FLOAT, "noiseOfs")
+    .push_constant(30, Type::FLOAT, "stepLength")
+    .push_constant(31, Type::FLOAT, "densityScale")
+    .vertex_source("workbench_volume_vert.glsl")
+    .fragment_source("workbench_volume_frag.glsl")
+    .additional_info("draw_object_infos");
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Smoke variation
+ * \{ */
+
+GPU_SHADER_CREATE_INFO(workbench_volume_smoke)
+    .define("VOLUME_SMOKE")
+    .sampler(2, ImageType::FLOAT_3D, "flameTexture")
+    .sampler(3, ImageType::FLOAT_1D, "flameColorTexture")
+    .additional_info("draw_mesh", "draw_resource_id_varying");
+
+GPU_SHADER_CREATE_INFO(workbench_volume_object)
+    .define("VOLUME_OBJECT")
+    .push_constant(0, Type::MAT4, "volumeTextureToObject")
+    /* FIXME(fclem): This overflow the push_constant limit. */
+    .push_constant(16, Type::MAT4, "volumeObjectToTexture")
+    .additional_info("draw_volume", "draw_resource_id_varying");
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Color Band variation
+ * \{ */
+
+GPU_SHADER_CREATE_INFO(workbench_volume_coba)
+    .define("USE_COBA")
+    .sampler(4, ImageType::UINT_3D, "flagTexture")
+    .sampler(5, ImageType::FLOAT_1D, "transferTexture")
+    .push_constant(18, Type::BOOL, "showPhi")
+    .push_constant(19, Type::BOOL, "showFlags")
+    .push_constant(20, Type::BOOL, "showPressure")
+    .push_constant(21, Type::FLOAT, "gridScale");
+
+GPU_SHADER_CREATE_INFO(workbench_volume_no_coba)
+    .sampler(4, ImageType::FLOAT_3D, "shadowTexture")
+    .sampler(5, ImageType::UINT_2D, "transferTexture")
+    .push_constant(18, Type::VEC3, "activeColor");
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Sampling variation
+ * \{ */
+
+GPU_SHADER_CREATE_INFO(workbench_volume_linear).define("USE_TRILINEAR");
+GPU_SHADER_CREATE_INFO(workbench_volume_cubic).define("USE_TRICUBIC");
+GPU_SHADER_CREATE_INFO(workbench_volume_closest).define("USE_CLOSEST");
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Slice variation
+ * \{ */
+
+GPU_SHADER_INTERFACE_INFO(workbench_volume_iface, "").smooth(Type::VEC3, "localPos");
+
+GPU_SHADER_CREATE_INFO(workbench_volume_slice)
+    .define("VOLUME_SLICE")
+    .vertex_in(1, Type::VEC3, "uvs")
+    .vertex_out(workbench_volume_iface)
+    .push_constant(32, Type::INT, "sliceAxis") /* -1 is no slice. */
+    .push_constant(33, Type::FLOAT, "slicePosition");
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Variations Declaration
+ * \{ */
+
+#define WORKBENCH_VOLUME_SLICE_VARIATIONS(prefix, ...) \
+  GPU_SHADER_CREATE_INFO(prefix##_slice) \
+      .additional_info("workbench_volume_slice", __VA_ARGS__) \
+      .do_static_compilation(true); \
+  GPU_SHADER_CREATE_INFO(prefix##_no_slice) \
+      .additional_info(__VA_ARGS__) \
+      .do_static_compilation(true);
+
+#define WORKBENCH_VOLUME_COBA_VARIATIONS(prefix, ...) \
+  WORKBENCH_VOLUME_SLICE_VARIATIONS(prefix##_coba, "workbench_volume_coba", __VA_ARGS__) \
+  WORKBENCH_VOLUME_SLICE_VARIATIONS(prefix##_no_coba, "workbench_volume_no_coba", __VA_ARGS__)
+
+#define WORKBENCH_VOLUME_INTERP_VARIATIONS(prefix, ...) \
+  WORKBENCH_VOLUME_COBA_VARIATIONS(prefix##_linear, "workbench_volume_linear", __VA_ARGS__) \
+  WORKBENCH_VOLUME_COBA_VARIATIONS(prefix##_cubic, "workbench_volume_cubic", __VA_ARGS__) \
+  WORKBENCH_VOLUME_COBA_VARIATIONS(prefix##_closest, "workbench_volume_closest", __VA_ARGS__)
+
+#define WORKBENCH_VOLUME_SMOKE_VARIATIONS(prefix, ...) \
+  WORKBENCH_VOLUME_INTERP_VARIATIONS(prefix##_smoke, "workbench_volume_smoke", __VA_ARGS__) \
+  WORKBENCH_VOLUME_INTERP_VARIATIONS(prefix##_object, "workbench_volume_object", __VA_ARGS__)
+
+WORKBENCH_VOLUME_SMOKE_VARIATIONS(workbench_volume, "workbench_volume")
+
+/** \} */

source/blender/draw/engines/workbench/shaders/workbench_cavity_lib.glsl

@@ -1,15 +1,7 @@
 
 #pragma BLENDER_REQUIRE(common_view_lib.glsl)
-#pragma BLENDER_REQUIRE(workbench_data_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_common_lib.glsl)
 
-layout(std140) uniform samples_block
-{
-  vec4 samples_coords[512];
-};
-
-uniform sampler2D cavityJitter;
-
 /*  From The Alchemy screen-space ambient obscurance algorithm
  * http://graphics.cs.williams.edu/papers/AlchemyHPG11/VV11AlchemyAO.pdf */
 

source/blender/draw/engines/workbench/shaders/workbench_composite_frag.glsl

@@ -4,13 +4,6 @@
 #pragma BLENDER_REQUIRE(workbench_matcap_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_world_light_lib.glsl)
 
-uniform sampler2D materialBuffer;
-uniform sampler2D normalBuffer;
-
-in vec4 uvcoordsvar;
-
-out vec4 fragColor;
-
 void main()
 {
   /* Normal and Incident vector are in viewspace. Lighting is evaluated in viewspace. */
@@ -27,7 +20,7 @@ void main()
   /* When using matcaps, mat_data.a is the back-face sign. */
   N = (mat_data.a > 0.0) ? N : -N;
 
-  fragColor.rgb = get_matcap_lighting(base_color, N, I);
+  fragColor.rgb = get_matcap_lighting(matcap_diffuse_tx, matcap_specular_tx, base_color, N, I);
 #endif
 
 #ifdef V3D_LIGHTING_STUDIO
@@ -38,7 +31,7 @@ void main()
   fragColor.rgb = base_color;
 #endif
 
-  fragColor.rgb *= get_shadow(N);
+  fragColor.rgb *= get_shadow(N, forceShadowing);
 
   fragColor.a = 1.0;
 }

source/blender/draw/engines/workbench/shaders/workbench_curvature_lib.glsl

@@ -1,6 +1,4 @@
 
-#pragma BLENDER_REQUIRE(workbench_data_lib.glsl)
-
 float curvature_soft_clamp(float curvature, float control)
 {
   if (curvature < 0.5 / control) {

source/blender/draw/engines/workbench/shaders/workbench_data_lib.glsl

@@ -1,48 +0,0 @@
-
-#ifndef WORKBENCH_SHADER_SHARED_H
-struct LightData {
-  vec4 direction;
-  vec4 specular_color;
-  vec4 diffuse_color_wrap; /* rgb: diffuse col a: wrapped lighting factor */
-};
-
-struct WorldData {
-  vec4 viewport_size;
-  vec4 object_outline_color;
-  vec4 shadow_direction_vs;
-  float shadow_focus;
-  float shadow_shift;
-  float shadow_mul;
-  float shadow_add;
-  /* - 16 bytes alignment - */
-  LightData lights[4];
-  vec4 ambient_color;
-
-  int cavity_sample_start;
-  int cavity_sample_end;
-  float cavity_sample_count_inv;
-  float cavity_jitter_scale;
-
-  float cavity_valley_factor;
-  float cavity_ridge_factor;
-  float cavity_attenuation;
-  float cavity_distance;
-
-  float curvature_ridge;
-  float curvature_valley;
-  float ui_scale;
-  float _pad0;
-
-  int matcap_orientation;
-  bool use_specular;
-  int _pad1;
-  int _pad2;
-};
-
-#  define viewport_size_inv viewport_size.zw
-
-layout(std140) uniform world_block
-{
-  WorldData world_data;
-};
-#endif

source/blender/draw/engines/workbench/shaders/workbench_effect_cavity_frag.glsl

@@ -4,18 +4,6 @@
 #pragma BLENDER_REQUIRE(workbench_cavity_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_curvature_lib.glsl)
 
-#ifndef DRW_SHADER_SHARED_H
-
-uniform sampler2D depthBuffer;
-uniform sampler2D normalBuffer;
-uniform usampler2D objectIdBuffer;
-
-in vec4 uvcoordsvar;
-
-out vec4 fragColor;
-
-#endif
-
 void main()
 {
   float cavity = 0.0, edges = 0.0, curvature = 0.0;

source/blender/draw/engines/workbench/shaders/workbench_effect_dof_frag.glsl

@@ -7,19 +7,6 @@
  * Converted and adapted from HLSL to GLSL by Clément Foucault
  */
 
-uniform vec2 invertedViewportSize;
-uniform vec2 nearFar;
-uniform vec3 dofParams;
-uniform float noiseOffset;
-uniform sampler2D inputCocTex;
-uniform sampler2D maxCocTilesTex;
-uniform sampler2D sceneColorTex;
-uniform sampler2D sceneDepthTex;
-uniform sampler2D backgroundTex;
-uniform sampler2D halfResColorTex;
-uniform sampler2D blurTex;
-uniform sampler2D noiseTex;
-
 #define dof_aperturesize dofParams.x
 #define dof_distance dofParams.y
 #define dof_invsensorsize dofParams.z
@@ -53,9 +40,6 @@ float decode_signed_coc(vec2 cocs)
  */
 #ifdef PREPARE
 
-layout(location = 0) out vec4 halfResColor;
-layout(location = 1) out vec2 normalizedCoc;
-
 void main()
 {
   ivec4 texel = ivec4(gl_FragCoord.xyxy) * 2 + ivec4(0, 0, 1, 1);
@@ -99,9 +83,6 @@ void main()
  */
 #ifdef DOWNSAMPLE
 
-layout(location = 0) out vec4 outColor;
-layout(location = 1) out vec2 outCocs;
-
 void main()
 {
   vec4 texel = vec4(gl_FragCoord.xyxy) * 2.0 + vec4(0.0, 0.0, 1.0, 1.0);
@@ -216,14 +197,6 @@ void main()
  * Outputs vertical blur and combined blur in MRT
  */
 #ifdef BLUR1
-layout(location = 0) out vec4 blurColor;
-
-#  define NUM_SAMPLES 49
-
-layout(std140) uniform dofSamplesBlock
-{
-  vec4 samples[NUM_SAMPLES];
-};
 
 vec2 get_random_vector(float offset)
 {
@@ -308,7 +281,6 @@ void main()
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #ifdef BLUR2
-out vec4 finalColor;
 
 void main()
 {
@@ -385,9 +357,6 @@ void main()
  */
 #ifdef RESOLVE
 
-layout(location = 0, index = 0) out vec4 finalColorAdd;
-layout(location = 0, index = 1) out vec4 finalColorMul;
-
 void main()
 {
   /* Fullscreen pass */

source/blender/draw/engines/workbench/shaders/workbench_effect_outline_frag.glsl

@@ -1,12 +1,4 @@
 
-#pragma BLENDER_REQUIRE(workbench_data_lib.glsl)
-
-uniform usampler2D objectIdBuffer;
-
-in vec4 uvcoordsvar;
-
-out vec4 fragColor;
-
 void main()
 {
   vec3 offset = vec3(world_data.viewport_size_inv, 0.0) * world_data.ui_scale;

source/blender/draw/engines/workbench/shaders/workbench_effect_smaa_frag.glsl

@@ -1,50 +1,35 @@
 
-uniform sampler2D edgesTex;
-uniform sampler2D areaTex;
-uniform sampler2D searchTex;
-uniform sampler2D blendTex;
-uniform sampler2D colorTex;
-uniform float mixFactor;
-uniform float taaAccumulatedWeight;
-
-in vec2 uvs;
-in vec2 pixcoord;
-in vec4 offset[3];
-
-#if SMAA_STAGE == 0
-out vec2 fragColor;
-#else
-out vec4 fragColor;
-#endif
+#pragma BLENDER_REQUIRE(common_smaa_lib.glsl)
 
 void main()
 {
 #if SMAA_STAGE == 0
   /* Detect edges in color and revealage buffer. */
-  fragColor = SMAALumaEdgeDetectionPS(uvs, offset, colorTex);
+  out_edges = SMAALumaEdgeDetectionPS(uvs, offset, colorTex);
   /* Discard if there is no edge. */
-  if (dot(fragColor, float2(1.0, 1.0)) == 0.0) {
+  if (dot(out_edges, float2(1.0, 1.0)) == 0.0) {
     discard;
   }
 
 #elif SMAA_STAGE == 1
-  fragColor = SMAABlendingWeightCalculationPS(
+  out_weights = SMAABlendingWeightCalculationPS(
       uvs, pixcoord, offset, edgesTex, areaTex, searchTex, vec4(0));
 
 #elif SMAA_STAGE == 2
-  fragColor = vec4(0.0);
+  out_color = vec4(0.0);
   if (mixFactor > 0.0) {
-    fragColor += SMAANeighborhoodBlendingPS(uvs, offset[0], colorTex, blendTex) * mixFactor;
+    out_color += SMAANeighborhoodBlendingPS(uvs, offset[0], colorTex, blendTex) * mixFactor;
   }
   if (mixFactor < 1.0) {
-    fragColor += texture(colorTex, uvs) * (1.0 - mixFactor);
+    out_color += texture(colorTex, uvs) * (1.0 - mixFactor);
   }
-  fragColor /= taaAccumulatedWeight;
-  fragColor = exp2(fragColor) - 0.5;
+  out_color /= taaAccumulatedWeight;
+  /* Exit log2 space used for Antialiasing. */
+  out_color = exp2(out_color) - 0.5;
 
   /* Avoid float precision issue. */
-  if (fragColor.a > 0.999) {
-    fragColor.a = 1.0;
+  if (out_color.a > 0.999) {
+    out_color.a = 1.0;
   }
 #endif
 }

source/blender/draw/engines/workbench/shaders/workbench_effect_smaa_vert.glsl

@@ -1,7 +1,5 @@
 
-out vec2 uvs;
-out vec2 pixcoord;
-out vec4 offset[3];
+#pragma BLENDER_REQUIRE(common_smaa_lib.glsl)
 
 void main()
 {

source/blender/draw/engines/workbench/shaders/workbench_effect_taa_frag.glsl

@@ -1,9 +1,4 @@
 
-uniform sampler2D colorBuffer;
-uniform float samplesWeights[9];
-
-out vec4 fragColor;
-
 void main()
 {
   vec2 texel_size = 1.0 / vec2(textureSize(colorBuffer, 0));

source/blender/draw/engines/workbench/shaders/workbench_image_lib.glsl

@@ -25,15 +25,6 @@ bool node_tex_tile_lookup(inout vec3 co, sampler2DArray ima, sampler1DArray map)
   return true;
 }
 
-#ifndef WORKBENCH_SHADER_SHARED_H
-uniform sampler2DArray imageTileArray;
-uniform sampler1DArray imageTileData;
-uniform sampler2D imageTexture;
-
-uniform float imageTransparencyCutoff = 0.1;
-uniform bool imagePremult;
-#endif
-
 vec3 workbench_image_color(vec2 uvs)
 {
 #ifdef V3D_SHADING_TEXTURE_COLOR

source/blender/draw/engines/workbench/shaders/workbench_matcap_lib.glsl

@@ -1,6 +1,4 @@
 
-#pragma BLENDER_REQUIRE(workbench_data_lib.glsl)
-
 vec2 matcap_uv_compute(vec3 I, vec3 N, bool flipped)
 {
   /* Quick creation of an orthonormal basis */
@@ -15,16 +13,14 @@ vec2 matcap_uv_compute(vec3 I, vec3 N, bool flipped)
   return matcap_uv * 0.496 + 0.5;
 }
 
-uniform sampler2D matcapDiffuseImage;
-uniform sampler2D matcapSpecularImage;
-
-vec3 get_matcap_lighting(vec3 base_color, vec3 N, vec3 I)
+vec3 get_matcap_lighting(
+    sampler2D diffuse_matcap, sampler2D specular_matcap, vec3 base_color, vec3 N, vec3 I)
 {
   bool flipped = world_data.matcap_orientation != 0;
   vec2 uv = matcap_uv_compute(I, N, flipped);
 
-  vec3 diffuse = textureLod(matcapDiffuseImage, uv, 0.0).rgb;
-  vec3 specular = textureLod(matcapSpecularImage, uv, 0.0).rgb;
+  vec3 diffuse = textureLod(diffuse_matcap, uv, 0.0).rgb;
+  vec3 specular = textureLod(specular_matcap, uv, 0.0).rgb;
 
   return diffuse * base_color + specular * float(world_data.use_specular);
 }

source/blender/draw/engines/workbench/shaders/workbench_material_lib.glsl

@@ -1,17 +1,9 @@
 
-layout(std140) uniform material_block
-{
-  vec4 mat_data[4096];
-};
-
-/* If set to -1, the resource handle is used instead. */
-uniform int materialIndex;
-
 void workbench_material_data_get(
     int handle, out vec3 color, out float alpha, out float roughness, out float metallic)
 {
   handle = (materialIndex != -1) ? materialIndex : handle;
-  vec4 data = mat_data[uint(handle) & 0xFFFu];
+  vec4 data = materials_data[uint(handle) & 0xFFFu];
   color = data.rgb;
 
   uint encoded_data = floatBitsToUint(data.w);

source/blender/draw/engines/workbench/shaders/workbench_merge_infront_frag.glsl

@@ -1,10 +1,4 @@
 
-uniform sampler2D depthBuffer;
-
-in vec4 uvcoordsvar;
-
-out vec4 fragColor;
-
 void main()
 {
   float depth = texture(depthBuffer, uvcoordsvar.st).r;

source/blender/draw/engines/workbench/shaders/workbench_prepass_frag.glsl

@@ -1,22 +1,13 @@
 
 #pragma BLENDER_REQUIRE(common_view_lib.glsl)
-#pragma BLENDER_REQUIRE(workbench_shader_interface_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_common_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_image_lib.glsl)
 
-#ifndef WORKBENCH_SHADER_SHARED_H
-layout(location = 0) out vec4 materialData;
-layout(location = 1) out vec2 normalData;
-layout(location = 2) out uint objectId;
-#endif
-
-uniform bool useMatcap = false;
-
 void main()
 {
   normalData = workbench_normal_encode(gl_FrontFacing, normal_interp);
 
-  materialData = vec4(color_interp, packed_rough_metal);
+  materialData = vec4(color_interp, workbench_float_pair_encode(roughness, metallic));
 
   objectId = uint(object_id);
 

source/blender/draw/engines/workbench/shaders/workbench_prepass_hair_vert.glsl

@@ -1,15 +1,10 @@
 #pragma BLENDER_REQUIRE(common_hair_lib.glsl)
 #pragma BLENDER_REQUIRE(common_view_lib.glsl)
-#pragma BLENDER_REQUIRE(workbench_shader_interface_lib.glsl)
+#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_common_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_material_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_image_lib.glsl)
 
-#ifndef WORKBENCH_SHADER_SHARED_H
-uniform samplerBuffer ac; /* active color layer */
-uniform samplerBuffer au; /* active texture layer */
-#endif
-
 /* From http://libnoise.sourceforge.net/noisegen/index.html */
 float integer_noise(int n)
 {
@@ -65,19 +60,12 @@ void main()
   float hair_rand = integer_noise(hair_get_strand_id());
   vec3 nor = workbench_hair_random_normal(tan, binor, hair_rand);
 
-#ifdef USE_WORLD_CLIP_PLANES
-  world_clip_planes_calc_clip_distance(world_pos);
-#endif
+  view_clipping_distances(world_pos);
 
   uv_interp = hair_get_customdata_vec2(au);
 
   normal_interp = normalize(normal_world_to_view(nor));
 
-#ifndef WORKBENCH_SHADER_SHARED_H
-#  ifdef OPAQUE_MATERIAL
-  float metallic, roughness;
-#  endif
-#endif
   workbench_material_data_get(resource_handle, color_interp, alpha_interp, roughness, metallic);
 
   if (materialIndex == 0) {
@@ -90,9 +78,5 @@ void main()
 
   workbench_hair_random_material(hair_rand, color_interp, roughness, metallic);
 
-#ifdef OPAQUE_MATERIAL
-  packed_rough_metal = workbench_float_pair_encode(roughness, metallic);
-#endif
-
   object_id = int(uint(resource_handle) & 0xFFFFu) + 1;
 }

source/blender/draw/engines/workbench/shaders/workbench_prepass_pointcloud_vert.glsl

@@ -1,7 +1,7 @@
 
+#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl)
 #pragma BLENDER_REQUIRE(common_view_lib.glsl)
 #pragma BLENDER_REQUIRE(common_pointcloud_lib.glsl)
-#pragma BLENDER_REQUIRE(workbench_shader_interface_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_common_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_material_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_image_lib.glsl)
@@ -15,26 +15,15 @@ void main()
 
   gl_Position = point_world_to_ndc(world_pos);
 
-#ifdef USE_WORLD_CLIP_PLANES
-  world_clip_planes_calc_clip_distance(world_pos);
-#endif
+  view_clipping_distances(world_pos);
 
   uv_interp = vec2(0.0);
 
-#ifndef WORKBENCH_SHADER_SHARED_H
-#  ifdef OPAQUE_MATERIAL
-  float metallic, roughness;
-#  endif
-#endif
   workbench_material_data_get(resource_handle, color_interp, alpha_interp, roughness, metallic);
 
   if (materialIndex == 0) {
     color_interp = vec3(1.0);
   }
 
-#ifdef OPAQUE_MATERIAL
-  packed_rough_metal = workbench_float_pair_encode(roughness, metallic);
-#endif
-
   object_id = int(uint(resource_handle) & 0xFFFFu) + 1;
 }

source/blender/draw/engines/workbench/shaders/workbench_prepass_vert.glsl

@@ -1,44 +1,26 @@
 
+#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl)
 #pragma BLENDER_REQUIRE(common_view_lib.glsl)
-#pragma BLENDER_REQUIRE(workbench_shader_interface_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_common_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_material_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_image_lib.glsl)
 
-#ifndef WORKBENCH_SHADER_SHARED_H
-in vec3 pos;
-in vec3 nor;
-in vec4 ac; /* active color */
-in vec2 au; /* active texture layer */
-#endif
-
 void main()
 {
   vec3 world_pos = point_object_to_world(pos);
   gl_Position = point_world_to_ndc(world_pos);
 
-#ifdef USE_WORLD_CLIP_PLANES
-  world_clip_planes_calc_clip_distance(world_pos);
-#endif
+  view_clipping_distances(world_pos);
 
   uv_interp = au;
 
   normal_interp = normalize(normal_object_to_view(nor));
 
-#ifndef WORKBENCH_SHADER_SHARED_H
-#  ifdef OPAQUE_MATERIAL
-  float metallic, roughness;
-#  endif
-#endif
   workbench_material_data_get(resource_handle, color_interp, alpha_interp, roughness, metallic);
 
   if (materialIndex == 0) {
     color_interp = ac.rgb;
   }
 
-#ifdef OPAQUE_MATERIAL
-  packed_rough_metal = workbench_float_pair_encode(roughness, metallic);
-#endif
-
   object_id = int(uint(resource_handle) & 0xFFFFu) + 1;
 }

source/blender/draw/engines/workbench/shaders/workbench_shader_interface_lib.glsl

@@ -1,17 +0,0 @@
-
-#ifndef WORKBENCH_SHADER_SHARED_H
-IN_OUT ShaderStageInterface
-{
-  vec3 normal_interp;
-  vec3 color_interp;
-  float alpha_interp;
-  vec2 uv_interp;
-#  ifdef TRANSPARENT_MATERIAL
-  flat float roughness;
-  flat float metallic;
-#  else
-  flat float packed_rough_metal;
-#  endif
-  flat int object_id;
-};
-#endif

source/blender/draw/engines/workbench/shaders/workbench_shadow_caps_geom.glsl

@@ -2,38 +2,6 @@
 #  define USE_INVOC_EXT
 #endif
 
-#ifdef DOUBLE_MANIFOLD
-#  ifdef USE_INVOC_EXT
-#    define invoc_len 2
-#  else
-#    define vert_len 6
-#  endif
-#else
-#  ifdef USE_INVOC_EXT
-#    define invoc_len 2
-#  else
-#    define vert_len 6
-#  endif
-#endif
-
-#ifdef USE_INVOC_EXT
-layout(triangles, invocations = invoc_len) in;
-layout(triangle_strip, max_vertices = 3) out;
-#else
-layout(triangles) in;
-layout(triangle_strip, max_vertices = vert_len) out;
-#endif
-
-uniform vec3 lightDirection = vec3(0.57, 0.57, -0.57);
-
-in VertexData
-{
-  vec3 pos;           /* local position */
-  vec4 frontPosition; /* final ndc position */
-  vec4 backPosition;
-}
-vData[];
-
 vec4 get_pos(int v, bool backface)
 {
   return (backface) ? vData[v].backPosition : vData[v].frontPosition;
@@ -74,18 +42,19 @@ void main()
   /* In case of non manifold geom, we only increase/decrease
    * the stencil buffer by one but do every faces as they were facing the light. */
   bool invert = backface;
+  const bool is_manifold = false;
 #else
   const bool invert = false;
-  if (!backface) {
+  const bool is_manifold = true;
 #endif
+
+  if (!is_manifold || !backface) {
 #ifdef USE_INVOC_EXT
-  bool do_front = (gl_InvocationID & 1) == 0;
-  emit_cap(do_front, invert);
+    bool do_front = (gl_InvocationID & 1) == 0;
+    emit_cap(do_front, invert);
 #else
     emit_cap(true, invert);
     emit_cap(false, invert);
 #endif
-#ifndef DOUBLE_MANIFOLD
-}
-#endif
+  }
 }

source/blender/draw/engines/workbench/shaders/workbench_shadow_debug_frag.glsl

@@ -1,10 +1,4 @@
 
-out vec4 fragColor;
-
-layout(location = 0) out vec4 materialData;
-layout(location = 1) out vec4 normalData;
-layout(location = 2) out uint objectId;
-
 void main()
 {
   const float a = 0.25;

source/blender/draw/engines/workbench/shaders/workbench_shadow_geom.glsl

@@ -2,38 +2,6 @@
 #  define USE_INVOC_EXT
 #endif
 
-#ifdef DOUBLE_MANIFOLD
-#  ifdef USE_INVOC_EXT
-#    define invoc_len 2
-#  else
-#    define vert_len 8
-#  endif
-#else
-#  ifdef USE_INVOC_EXT
-#    define invoc_len 1
-#  else
-#    define vert_len 4
-#  endif
-#endif
-
-#ifdef USE_INVOC_EXT
-layout(lines_adjacency, invocations = invoc_len) in;
-layout(triangle_strip, max_vertices = 4) out;
-#else
-layout(lines_adjacency) in;
-layout(triangle_strip, max_vertices = vert_len) out;
-#endif
-
-uniform vec3 lightDirection = vec3(0.57, 0.57, -0.57);
-
-in VertexData
-{
-  vec3 pos;           /* local position */
-  vec4 frontPosition; /* final ndc position */
-  vec4 backPosition;
-}
-vData[];
-
 #define DEGENERATE_TRIS_WORKAROUND
 #define DEGENERATE_TRIS_AREA_THRESHOLD 4e-17
 

source/blender/draw/engines/workbench/shaders/workbench_shadow_vert.glsl

@@ -1,17 +1,5 @@
-#define INFINITE 1000.0
 
-uniform vec3 lightDirection = vec3(0.57, 0.57, -0.57);
-uniform float lightDistance = 1e4;
-
-in vec3 pos;
-
-out VertexData
-{
-  vec3 pos;           /* local position */
-  vec4 frontPosition; /* final ndc position */
-  vec4 backPosition;
-}
-vData;
+#pragma BLENDER_REQUIRE(common_view_lib.glsl)
 
 void main()
 {

source/blender/draw/engines/workbench/shaders/workbench_transparent_accum_frag.glsl

@@ -1,21 +1,10 @@
 
 #pragma BLENDER_REQUIRE(common_view_lib.glsl)
-#pragma BLENDER_REQUIRE(workbench_shader_interface_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_common_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_image_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_matcap_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_world_light_lib.glsl)
 
-#ifndef WORKBENCH_SHADER_SHARED_H
-/* Revealage is actually stored in transparentAccum alpha channel.
- * This is a workaround to older hardware not having separate blend equation per render target. */
-layout(location = 0) out vec4 transparentAccum;
-layout(location = 1) out vec4 revealageAccum;
-
-/* NOTE: Blending will be skipped on objectId because output is a non-normalized integer buffer. */
-layout(location = 2) out uint objectId;
-#endif
-
 /* Special function only to be used with calculate_transparent_weight(). */
 float linear_zdepth(float depth, vec4 viewvecs[2], mat4 proj_mat)
 {
@@ -69,7 +58,7 @@ void main()
 #endif
 
 #ifdef V3D_LIGHTING_MATCAP
-  vec3 shaded_color = get_matcap_lighting(color, N, I);
+  vec3 shaded_color = get_matcap_lighting(matcap_diffuse_tx, matcap_specular_tx, color, N, I);
 #endif
 
 #ifdef V3D_LIGHTING_STUDIO
@@ -80,7 +69,7 @@ void main()
   vec3 shaded_color = color;
 #endif
 
-  shaded_color *= get_shadow(N);
+  shaded_color *= get_shadow(N, forceShadowing);
 
   /* Listing 4 */
   float weight = calculate_transparent_weight() * alpha_interp;

source/blender/draw/engines/workbench/shaders/workbench_transparent_resolve_frag.glsl

@@ -1,11 +1,4 @@
 
-uniform sampler2D transparentAccum;
-uniform sampler2D transparentRevealage;
-
-in vec4 uvcoordsvar;
-
-out vec4 fragColor;
-
 /* Based on :
  * McGuire and Bavoil, Weighted Blended Order-Independent Transparency, Journal of
  * Computer Graphics Techniques (JCGT), vol. 2, no. 2, 122–141, 2013

source/blender/draw/engines/workbench/shaders/workbench_volume_frag.glsl

@@ -1,40 +1,8 @@
 
 #pragma BLENDER_REQUIRE(common_math_lib.glsl)
 #pragma BLENDER_REQUIRE(common_view_lib.glsl)
-#pragma BLENDER_REQUIRE(gpu_shader_common_obinfos_lib.glsl)
-#pragma BLENDER_REQUIRE(workbench_data_lib.glsl)
 #pragma BLENDER_REQUIRE(workbench_common_lib.glsl)
 
-uniform sampler2D depthBuffer;
-
-uniform sampler3D densityTexture;
-uniform sampler3D shadowTexture;
-uniform sampler3D flameTexture;
-uniform usampler3D flagTexture;
-uniform sampler1D flameColorTexture;
-uniform sampler1D transferTexture;
-uniform mat4 volumeObjectToTexture;
-
-uniform int samplesLen = 256;
-uniform float noiseOfs = 0.0;
-uniform float stepLength;   /* Step length in local space. */
-uniform float densityScale; /* Simple Opacity multiplicator. */
-uniform float gridScale;    /* Multiplicator for grid scaling. */
-uniform vec3 activeColor;
-
-uniform float slicePosition;
-uniform int sliceAxis; /* -1 is no slice, 0 is X, 1 is Y, 2 is Z. */
-
-uniform bool showPhi = false;
-uniform bool showFlags = false;
-uniform bool showPressure = false;
-
-#ifdef VOLUME_SLICE
-in vec3 localPos;
-#endif
-
-out vec4 fragColor;
-
 float phase_function_isotropic()
 {
   return 1.0 / (4.0 * M_PI);

source/blender/draw/engines/workbench/shaders/workbench_volume_vert.glsl

@@ -1,22 +1,8 @@
 
 #pragma BLENDER_REQUIRE(common_view_lib.glsl)
-#pragma BLENDER_REQUIRE(gpu_shader_common_obinfos_lib.glsl)
-
-uniform float slicePosition;
-uniform int sliceAxis; /* -1 is no slice, 0 is X, 1 is Y, 2 is Z. */
-
-uniform mat4 volumeTextureToObject;
-
-in vec3 pos;
 
 RESOURCE_ID_VARYING
 
-#ifdef VOLUME_SLICE
-in vec3 uvs;
-
-out vec3 localPos;
-#endif
-
 void main()
 {
 #ifdef VOLUME_SLICE

source/blender/draw/engines/workbench/shaders/workbench_world_light_lib.glsl

@@ -1,6 +1,4 @@
 
-#pragma BLENDER_REQUIRE(workbench_data_lib.glsl)
-
 /* [Drobot2014a] Low Level Optimizations for GCN */
 vec4 fast_rcp(vec4 v)
 {
@@ -120,12 +118,10 @@ vec3 get_world_lighting(vec3 base_color, float roughness, float metallic, vec3 N
   return diffuse_light + specular_light;
 }
 
-uniform bool forceShadowing = false;
-
-float get_shadow(vec3 N)
+float get_shadow(vec3 N, bool force_shadowing)
 {
   float light_factor = -dot(N, world_data.shadow_direction_vs.xyz);
   float shadow_mix = smoothstep(world_data.shadow_shift, world_data.shadow_focus, light_factor);
-  shadow_mix *= forceShadowing ? 0.0 : world_data.shadow_mul;
+  shadow_mix *= force_shadowing ? 0.0 : world_data.shadow_mul;
   return shadow_mix + world_data.shadow_add;
 }

source/blender/draw/engines/workbench/workbench_effect_cavity.c

@@ -165,7 +165,7 @@ void workbench_cavity_cache_init(WORKBENCH_Data *data)
     grp = DRW_shgroup_create(sh, psl->cavity_ps);
     DRW_shgroup_uniform_texture(grp, "normalBuffer", wpd->normal_buffer_tx);
     DRW_shgroup_uniform_block(grp, "samples_block", wpd->vldata->cavity_sample_ubo);
-    DRW_shgroup_uniform_block(grp, "world_block", wpd->world_ubo);
+    DRW_shgroup_uniform_block(grp, "world_data", wpd->world_ubo);
 
     if (SSAO_ENABLED(wpd)) {
       DRW_shgroup_uniform_texture(grp, "depthBuffer", dtxl->depth);

source/blender/draw/engines/workbench/workbench_effect_dof.c

@@ -328,7 +328,7 @@ void workbench_dof_cache_init(WORKBENCH_Data *vedata)
 
     float offset = wpd->taa_sample / (float)max_ii(1, wpd->taa_sample_len);
     DRWShadingGroup *grp = DRW_shgroup_create(blur1_sh, psl->dof_blur1_ps);
-    DRW_shgroup_uniform_block(grp, "dofSamplesBlock", wpd->vldata->dof_sample_ubo);
+    DRW_shgroup_uniform_block(grp, "samples", wpd->vldata->dof_sample_ubo);
     DRW_shgroup_uniform_texture(grp, "noiseTex", wpd->vldata->cavity_jitter_tx);
     DRW_shgroup_uniform_texture(grp, "inputCocTex", txl->coc_halfres_tx);
     DRW_shgroup_uniform_texture(grp, "halfResColorTex", txl->dof_source_tx);

source/blender/draw/engines/workbench/workbench_effect_outline.c

@@ -46,7 +46,7 @@ void workbench_outline_cache_init(WORKBENCH_Data *data)
     grp = DRW_shgroup_create(sh, psl->outline_ps);
     DRW_shgroup_uniform_texture(grp, "objectIdBuffer", wpd->object_id_tx);
     DRW_shgroup_uniform_texture(grp, "depthBuffer", dtxl->depth);
-    DRW_shgroup_uniform_block(grp, "world_block", wpd->world_ubo);
+    DRW_shgroup_uniform_block(grp, "world_data", wpd->world_ubo);
     DRW_shgroup_call_procedural_triangles(grp, NULL, 1);
   }
   else {

source/blender/draw/engines/workbench/workbench_engine.c

@@ -51,8 +51,6 @@ void workbench_engine_init(void *ved)
   WORKBENCH_StorageList *stl = vedata->stl;
   WORKBENCH_TextureList *txl = vedata->txl;
 
-  workbench_shader_library_ensure();
-
   workbench_private_data_alloc(stl);
   WORKBENCH_PrivateData *wpd = stl->wpd;
   workbench_private_data_init(wpd);

source/blender/draw/engines/workbench/workbench_materials.c

@@ -210,7 +210,7 @@ DRWShadingGroup *workbench_material_setup_ex(WORKBENCH_PrivateData *wpd,
 
       DRWShadingGroup *grp = prepass->common_shgrp;
       *grp_mat = grp = DRW_shgroup_create_sub(grp);
-      DRW_shgroup_uniform_block(grp, "material_block", wpd->material_ubo_curr);
+      DRW_shgroup_uniform_block(grp, "materials_data", wpd->material_ubo_curr);
       DRW_shgroup_uniform_int_copy(grp, "materialIndex", mat_id);
       return grp;
     }
@@ -234,7 +234,7 @@ DRWShadingGroup *workbench_material_setup_ex(WORKBENCH_PrivateData *wpd,
       DRWShadingGroup **grp = &wpd->prepass[transp][infront][datatype].common_shgrp;
       if (resource_changed) {
         *grp = DRW_shgroup_create_sub(*grp);
-        DRW_shgroup_uniform_block(*grp, "material_block", wpd->material_ubo_curr);
+        DRW_shgroup_uniform_block(*grp, "materials_data", wpd->material_ubo_curr);
       }
       if (r_transp && transp) {
         *r_transp = true;
@@ -293,5 +293,6 @@ DRWShadingGroup *workbench_image_setup_ex(WORKBENCH_PrivateData *wpd,
     DRW_shgroup_uniform_texture_ex(grp, "imageTexture", tex, sampler);
   }
   DRW_shgroup_uniform_bool_copy(grp, "imagePremult", (ima && ima->alpha_mode == IMA_ALPHA_PREMUL));
+  DRW_shgroup_uniform_float_copy(grp, "imageTransparencyCutoff", 0.1f);
   return grp;
 }

source/blender/draw/engines/workbench/workbench_opaque.c

@@ -88,26 +88,26 @@ void workbench_opaque_cache_init(WORKBENCH_Data *vedata)
         sh = workbench_shader_opaque_get(wpd, data);
 
         wpd->prepass[opaque][infront][data].common_shgrp = grp = DRW_shgroup_create(sh, pass);
-        DRW_shgroup_uniform_block(grp, "material_block", wpd->material_ubo_curr);
+        DRW_shgroup_uniform_block(grp, "materials_data", wpd->material_ubo_curr);
         DRW_shgroup_uniform_int_copy(grp, "materialIndex", -1);
         DRW_shgroup_uniform_bool_copy(grp, "useMatcap", use_matcap);
 
         wpd->prepass[opaque][infront][data].vcol_shgrp = grp = DRW_shgroup_create(sh, pass);
-        DRW_shgroup_uniform_block(grp, "material_block", wpd->material_ubo_curr);
+        DRW_shgroup_uniform_block(grp, "materials_data", wpd->material_ubo_curr);
         DRW_shgroup_uniform_int_copy(grp, "materialIndex", 0); /* Default material. (uses vcol) */
         DRW_shgroup_uniform_bool_copy(grp, "useMatcap", use_matcap);
 
         sh = workbench_shader_opaque_image_get(wpd, data, false);
 
         wpd->prepass[opaque][infront][data].image_shgrp = grp = DRW_shgroup_create(sh, pass);
-        DRW_shgroup_uniform_block(grp, "material_block", wpd->material_ubo_curr);
+        DRW_shgroup_uniform_block(grp, "materials_data", wpd->material_ubo_curr);
         DRW_shgroup_uniform_int_copy(grp, "materialIndex", 0); /* Default material. */
         DRW_shgroup_uniform_bool_copy(grp, "useMatcap", use_matcap);
 
         sh = workbench_shader_opaque_image_get(wpd, data, true);
 
         wpd->prepass[opaque][infront][data].image_tiled_shgrp = grp = DRW_shgroup_create(sh, pass);
-        DRW_shgroup_uniform_block(grp, "material_block", wpd->material_ubo_curr);
+        DRW_shgroup_uniform_block(grp, "materials_data", wpd->material_ubo_curr);
         DRW_shgroup_uniform_int_copy(grp, "materialIndex", 0); /* Default material. */
         DRW_shgroup_uniform_bool_copy(grp, "useMatcap", use_matcap);
       }
@@ -121,7 +121,7 @@ void workbench_opaque_cache_init(WORKBENCH_Data *vedata)
     sh = workbench_shader_composite_get(wpd);
 
     grp = DRW_shgroup_create(sh, psl->composite_ps);
-    DRW_shgroup_uniform_block(grp, "world_block", wpd->world_ubo);
+    DRW_shgroup_uniform_block(grp, "world_data", wpd->world_ubo);
     DRW_shgroup_uniform_texture(grp, "materialBuffer", wpd->material_buffer_tx);
     DRW_shgroup_uniform_texture(grp, "normalBuffer", wpd->normal_buffer_tx);
     DRW_shgroup_uniform_bool_copy(grp, "forceShadowing", false);
@@ -135,8 +135,8 @@ void workbench_opaque_cache_init(WORKBENCH_Data *vedata)
       struct GPUTexture *spec_tx = wpd->studio_light->matcap_specular.gputexture;
       const bool use_spec = workbench_is_specular_highlight_enabled(wpd);
       spec_tx = (use_spec && spec_tx) ? spec_tx : diff_tx;
-      DRW_shgroup_uniform_texture(grp, "matcapDiffuseImage", diff_tx);
-      DRW_shgroup_uniform_texture(grp, "matcapSpecularImage", spec_tx);
+      DRW_shgroup_uniform_texture(grp, "matcap_diffuse_tx", diff_tx);
+      DRW_shgroup_uniform_texture(grp, "matcap_specular_tx", spec_tx);
     }
     DRW_shgroup_call_procedural_triangles(grp, NULL, 1);
 

source/blender/draw/engines/workbench/workbench_private.h

@@ -459,7 +459,6 @@ void workbench_shader_depth_of_field_get(GPUShader **prepare_sh,
                                          GPUShader **blur2_sh,
                                          GPUShader **resolve_sh);
 
-void workbench_shader_library_ensure(void);
 void workbench_shader_free(void);
 
 /* workbench_effect_antialiasing.c */

source/blender/draw/engines/workbench/workbench_shader.c

@@ -1,562 +0,0 @@
-/*
- * 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.
- *
- * Copyright 2020, Blender Foundation.
- */
-
-/** \file
- * \ingroup draw_engine
- */
-
-#include "DRW_render.h"
-
-#include "BLI_dynstr.h"
-#include "BLI_string_utils.h"
-
-#include "workbench_engine.h"
-#include "workbench_private.h"
-
-extern char datatoc_common_math_lib_glsl[];
-extern char datatoc_common_math_geom_lib_glsl[];
-extern char datatoc_common_hair_lib_glsl[];
-extern char datatoc_common_pointcloud_lib_glsl[];
-extern char datatoc_common_view_lib_glsl[];
-extern char datatoc_common_smaa_lib_glsl[];
-
-extern char datatoc_workbench_prepass_vert_glsl[];
-extern char datatoc_workbench_prepass_hair_vert_glsl[];
-extern char datatoc_workbench_prepass_pointcloud_vert_glsl[];
-extern char datatoc_workbench_prepass_frag_glsl[];
-
-extern char datatoc_workbench_effect_cavity_frag_glsl[];
-extern char datatoc_workbench_effect_outline_frag_glsl[];
-extern char datatoc_workbench_effect_dof_frag_glsl[];
-extern char datatoc_workbench_effect_taa_frag_glsl[];
-extern char datatoc_workbench_effect_smaa_frag_glsl[];
-extern char datatoc_workbench_effect_smaa_vert_glsl[];
-
-extern char datatoc_workbench_composite_frag_glsl[];
-
-extern char datatoc_workbench_transparent_accum_frag_glsl[];
-extern char datatoc_workbench_transparent_resolve_frag_glsl[];
-
-extern char datatoc_workbench_merge_infront_frag_glsl[];
-
-extern char datatoc_workbench_shadow_vert_glsl[];
-extern char datatoc_workbench_shadow_geom_glsl[];
-extern char datatoc_workbench_shadow_caps_geom_glsl[];
-extern char datatoc_workbench_shadow_debug_frag_glsl[];
-
-extern char datatoc_workbench_volume_vert_glsl[];
-extern char datatoc_workbench_volume_frag_glsl[];
-
-extern char datatoc_workbench_cavity_lib_glsl[];
-extern char datatoc_workbench_common_lib_glsl[];
-extern char datatoc_workbench_curvature_lib_glsl[];
-extern char datatoc_workbench_data_lib_glsl[];
-extern char datatoc_workbench_image_lib_glsl[];
-extern char datatoc_workbench_matcap_lib_glsl[];
-extern char datatoc_workbench_material_lib_glsl[];
-extern char datatoc_workbench_shader_interface_lib_glsl[];
-extern char datatoc_workbench_world_light_lib_glsl[];
-
-extern char datatoc_gpu_shader_depth_only_frag_glsl[];
-extern char datatoc_gpu_shader_common_obinfos_lib_glsl[];
-
-/* Maximum number of variations. */
-#define MAX_LIGHTING 3
-#define MAX_COLOR 3
-
-enum {
-  VOLUME_SH_SLICE = 0,
-  VOLUME_SH_COBA,
-  VOLUME_SH_CUBIC,
-};
-
-#define VOLUME_SH_MAX (1 << (VOLUME_SH_CUBIC + 1))
-
-static struct {
-  struct GPUShader *opaque_prepass_sh_cache[GPU_SHADER_CFG_LEN][WORKBENCH_DATATYPE_MAX][MAX_COLOR];
-  struct GPUShader *transp_prepass_sh_cache[GPU_SHADER_CFG_LEN][WORKBENCH_DATATYPE_MAX]
-                                           [MAX_LIGHTING][MAX_COLOR];
-
-  struct GPUShader *opaque_composite_sh[MAX_LIGHTING];
-  struct GPUShader *oit_resolve_sh;
-  struct GPUShader *outline_sh;
-  struct GPUShader *merge_infront_sh;
-
-  struct GPUShader *shadow_depth_pass_sh[2];
-  struct GPUShader *shadow_depth_fail_sh[2][2];
-
-  struct GPUShader *cavity_sh[2][2];
-
-  struct GPUShader *dof_prepare_sh;
-  struct GPUShader *dof_downsample_sh;
-  struct GPUShader *dof_blur1_sh;
-  struct GPUShader *dof_blur2_sh;
-  struct GPUShader *dof_resolve_sh;
-
-  struct GPUShader *aa_accum_sh;
-  struct GPUShader *smaa_sh[3];
-
-  struct GPUShader *volume_sh[2][2][3][2];
-
-  struct DRWShaderLibrary *lib;
-} e_data = {{{{NULL}}}};
-
-void workbench_shader_library_ensure(void)
-{
-  if (e_data.lib == NULL) {
-    e_data.lib = DRW_shader_library_create();
-    /* NOTE: These need to be ordered by dependencies. */
-    DRW_SHADER_LIB_ADD(e_data.lib, common_math_lib);
-    DRW_SHADER_LIB_ADD(e_data.lib, common_math_geom_lib);
-    DRW_SHADER_LIB_ADD(e_data.lib, common_hair_lib);
-    DRW_SHADER_LIB_ADD(e_data.lib, common_view_lib);
-    DRW_SHADER_LIB_ADD(e_data.lib, common_pointcloud_lib);
-    DRW_SHADER_LIB_ADD(e_data.lib, gpu_shader_common_obinfos_lib);
-    DRW_SHADER_LIB_ADD(e_data.lib, workbench_shader_interface_lib);
-    DRW_SHADER_LIB_ADD(e_data.lib, workbench_common_lib);
-    DRW_SHADER_LIB_ADD(e_data.lib, workbench_image_lib);
-    DRW_SHADER_LIB_ADD(e_data.lib, workbench_material_lib);
-    DRW_SHADER_LIB_ADD(e_data.lib, workbench_data_lib);
-    DRW_SHADER_LIB_ADD(e_data.lib, workbench_matcap_lib);
-    DRW_SHADER_LIB_ADD(e_data.lib, workbench_cavity_lib);
-    DRW_SHADER_LIB_ADD(e_data.lib, workbench_curvature_lib);
-    DRW_SHADER_LIB_ADD(e_data.lib, workbench_world_light_lib);
-  }
-}
-
-static char *workbench_build_defines(
-    WORKBENCH_PrivateData *wpd, bool textured, bool tiled, bool cavity, bool curvature)
-{
-  char *str = NULL;
-
-  DynStr *ds = BLI_dynstr_new();
-
-  if (wpd && wpd->shading.light == V3D_LIGHTING_STUDIO) {
-    BLI_dynstr_append(ds, "#define V3D_LIGHTING_STUDIO\n");
-  }
-  else if (wpd && wpd->shading.light == V3D_LIGHTING_MATCAP) {
-    BLI_dynstr_append(ds, "#define V3D_LIGHTING_MATCAP\n");
-  }
-  else {
-    BLI_dynstr_append(ds, "#define V3D_LIGHTING_FLAT\n");
-  }
-
-  if (NORMAL_ENCODING_ENABLED()) {
-    BLI_dynstr_append(ds, "#define WORKBENCH_ENCODE_NORMALS\n");
-  }
-
-  if (textured) {
-    BLI_dynstr_append(ds, "#define V3D_SHADING_TEXTURE_COLOR\n");
-  }
-  if (tiled) {
-    BLI_dynstr_append(ds, "#define TEXTURE_IMAGE_ARRAY\n");
-  }
-  if (cavity) {
-    BLI_dynstr_append(ds, "#define USE_CAVITY\n");
-  }
-  if (curvature) {
-    BLI_dynstr_append(ds, "#define USE_CURVATURE\n");
-  }
-
-  str = BLI_dynstr_get_cstring(ds);
-  BLI_dynstr_free(ds);
-  return str;
-}
-
-static int workbench_color_index(WORKBENCH_PrivateData *UNUSED(wpd), bool textured, bool tiled)
-{
-  BLI_assert(2 < MAX_COLOR);
-  return (textured) ? (tiled ? 2 : 1) : 0;
-}
-
-static GPUShader *workbench_shader_get_ex(WORKBENCH_PrivateData *wpd,
-                                          bool transp,
-                                          eWORKBENCH_DataType datatype,
-                                          bool textured,
-                                          bool tiled)
-{
-  int color = workbench_color_index(wpd, textured, tiled);
-  int light = wpd->shading.light;
-  BLI_assert(light < MAX_LIGHTING);
-  struct GPUShader **shader =
-      (transp) ? &e_data.transp_prepass_sh_cache[wpd->sh_cfg][datatype][light][color] :
-                 &e_data.opaque_prepass_sh_cache[wpd->sh_cfg][datatype][color];
-
-  if (*shader == NULL) {
-    char *defines = workbench_build_defines(wpd, textured, tiled, false, false);
-
-    char *frag_file = transp ? datatoc_workbench_transparent_accum_frag_glsl :
-                               datatoc_workbench_prepass_frag_glsl;
-    char *frag_src = DRW_shader_library_create_shader_string(e_data.lib, frag_file);
-
-    char *vert_file = (datatype == WORKBENCH_DATATYPE_HAIR) ?
-                          datatoc_workbench_prepass_hair_vert_glsl :
-                          ((datatype == WORKBENCH_DATATYPE_POINTCLOUD) ?
-                               datatoc_workbench_prepass_pointcloud_vert_glsl :
-                               datatoc_workbench_prepass_vert_glsl);
-    char *vert_src = DRW_shader_library_create_shader_string(e_data.lib, vert_file);
-
-    const GPUShaderConfigData *sh_cfg_data = &GPU_shader_cfg_data[wpd->sh_cfg];
-
-    *shader = GPU_shader_create_from_arrays({
-        .vert = (const char *[]){sh_cfg_data->lib, vert_src, NULL},
-        .frag = (const char *[]){frag_src, NULL},
-        .defs = (const char *[]){sh_cfg_data->def,
-                                 defines,
-                                 transp ? "#define TRANSPARENT_MATERIAL\n" :
-                                          "#define OPAQUE_MATERIAL\n",
-                                 (datatype == WORKBENCH_DATATYPE_POINTCLOUD) ?
-                                     "#define UNIFORM_RESOURCE_ID\n"
-                                     "#define INSTANCED_ATTR\n" :
-                                     NULL,
-                                 NULL},
-    });
-
-    MEM_freeN(defines);
-    MEM_freeN(frag_src);
-    MEM_freeN(vert_src);
-  }
-  return *shader;
-}
-
-GPUShader *workbench_shader_opaque_get(WORKBENCH_PrivateData *wpd, eWORKBENCH_DataType datatype)
-{
-  return workbench_shader_get_ex(wpd, false, datatype, false, false);
-}
-
-GPUShader *workbench_shader_opaque_image_get(WORKBENCH_PrivateData *wpd,
-                                             eWORKBENCH_DataType datatype,
-                                             bool tiled)
-{
-  return workbench_shader_get_ex(wpd, false, datatype, true, tiled);
-}
-
-GPUShader *workbench_shader_transparent_get(WORKBENCH_PrivateData *wpd,
-                                            eWORKBENCH_DataType datatype)
-{
-  return workbench_shader_get_ex(wpd, true, datatype, false, false);
-}
-
-GPUShader *workbench_shader_transparent_image_get(WORKBENCH_PrivateData *wpd,
-                                                  eWORKBENCH_DataType datatype,
-                                                  bool tiled)
-{
-  return workbench_shader_get_ex(wpd, true, datatype, true, tiled);
-}
-
-GPUShader *workbench_shader_composite_get(WORKBENCH_PrivateData *wpd)
-{
-  int light = wpd->shading.light;
-  struct GPUShader **shader = &e_data.opaque_composite_sh[light];
-  BLI_assert(light < MAX_LIGHTING);
-
-  if (*shader == NULL) {
-    char *defines = workbench_build_defines(wpd, false, false, false, false);
-    char *frag = DRW_shader_library_create_shader_string(e_data.lib,
-                                                         datatoc_workbench_composite_frag_glsl);
-
-    *shader = DRW_shader_create_fullscreen(frag, defines);
-
-    MEM_freeN(defines);
-    MEM_freeN(frag);
-  }
-  return *shader;
-}
-
-GPUShader *workbench_shader_merge_infront_get(WORKBENCH_PrivateData *UNUSED(wpd))
-{
-  if (e_data.merge_infront_sh == NULL) {
-    char *frag = DRW_shader_library_create_shader_string(
-        e_data.lib, datatoc_workbench_merge_infront_frag_glsl);
-
-    e_data.merge_infront_sh = DRW_shader_create_fullscreen(frag, NULL);
-
-    MEM_freeN(frag);
-  }
-  return e_data.merge_infront_sh;
-}
-
-GPUShader *workbench_shader_transparent_resolve_get(WORKBENCH_PrivateData *wpd)
-{
-  if (e_data.oit_resolve_sh == NULL) {
-    char *defines = workbench_build_defines(wpd, false, false, false, false);
-
-    e_data.oit_resolve_sh = DRW_shader_create_fullscreen(
-        datatoc_workbench_transparent_resolve_frag_glsl, defines);
-
-    MEM_freeN(defines);
-  }
-  return e_data.oit_resolve_sh;
-}
-
-static GPUShader *workbench_shader_shadow_pass_get_ex(bool depth_pass, bool manifold, bool cap)
-{
-  struct GPUShader **shader = (depth_pass) ? &e_data.shadow_depth_pass_sh[manifold] :
-                                             &e_data.shadow_depth_fail_sh[manifold][cap];
-
-  if (*shader == NULL) {
-#if DEBUG_SHADOW_VOLUME
-    const char *shadow_frag = datatoc_workbench_shadow_debug_frag_glsl;
-#else
-    const char *shadow_frag = datatoc_gpu_shader_depth_only_frag_glsl;
-#endif
-
-    *shader = GPU_shader_create_from_arrays({
-        .vert = (const char *[]){datatoc_common_view_lib_glsl,
-                                 datatoc_workbench_shadow_vert_glsl,
-                                 NULL},
-        .geom = (const char *[]){(cap) ? datatoc_workbench_shadow_caps_geom_glsl :
-                                         datatoc_workbench_shadow_geom_glsl,
-                                 NULL},
-        .frag = (const char *[]){shadow_frag, NULL},
-        .defs = (const char *[]){(depth_pass) ? "#define SHADOW_PASS\n" : "#define SHADOW_FAIL\n",
-                                 (manifold) ? "" : "#define DOUBLE_MANIFOLD\n",
-                                 NULL},
-    });
-  }
-  return *shader;
-}
-
-GPUShader *workbench_shader_shadow_pass_get(bool manifold)
-{
-  return workbench_shader_shadow_pass_get_ex(true, manifold, false);
-}
-
-GPUShader *workbench_shader_shadow_fail_get(bool manifold, bool cap)
-{
-  return workbench_shader_shadow_pass_get_ex(false, manifold, cap);
-}
-
-GPUShader *workbench_shader_cavity_get(bool cavity, bool curvature)
-{
-  BLI_assert(cavity || curvature);
-  struct GPUShader **shader = &e_data.cavity_sh[cavity][curvature];
-
-  if (*shader == NULL) {
-    char *defines = workbench_build_defines(NULL, false, false, cavity, curvature);
-    char *frag = DRW_shader_library_create_shader_string(
-        e_data.lib, datatoc_workbench_effect_cavity_frag_glsl);
-
-    *shader = DRW_shader_create_fullscreen(frag, defines);
-
-    MEM_freeN(defines);
-    MEM_freeN(frag);
-  }
-  return *shader;
-}
-
-GPUShader *workbench_shader_outline_get(void)
-{
-  if (e_data.outline_sh == NULL) {
-    char *frag = DRW_shader_library_create_shader_string(
-        e_data.lib, datatoc_workbench_effect_outline_frag_glsl);
-
-    e_data.outline_sh = DRW_shader_create_fullscreen(frag, NULL);
-
-    MEM_freeN(frag);
-  }
-  return e_data.outline_sh;
-}
-
-void workbench_shader_depth_of_field_get(GPUShader **prepare_sh,
-                                         GPUShader **downsample_sh,
-                                         GPUShader **blur1_sh,
-                                         GPUShader **blur2_sh,
-                                         GPUShader **resolve_sh)
-{
-  if (e_data.dof_prepare_sh == NULL) {
-    e_data.dof_prepare_sh = DRW_shader_create_fullscreen_with_shaderlib(
-        datatoc_workbench_effect_dof_frag_glsl, e_data.lib, "#define PREPARE\n");
-    e_data.dof_downsample_sh = DRW_shader_create_fullscreen_with_shaderlib(
-        datatoc_workbench_effect_dof_frag_glsl, e_data.lib, "#define DOWNSAMPLE\n");
-#if 0 /* TODO(fclem): finish COC min_max optimization */
-    e_data.dof_flatten_v_sh = DRW_shader_create_fullscreen_with_shaderlib(
-        datatoc_workbench_effect_dof_frag_glsl, e_data.lib, "#define FLATTEN_VERTICAL\n");
-    e_data.dof_flatten_h_sh = DRW_shader_create_fullscreen_with_shaderlib(
-        datatoc_workbench_effect_dof_frag_glsl, e_data.lib, "#define FLATTEN_HORIZONTAL\n");
-    e_data.dof_dilate_v_sh = DRW_shader_create_fullscreen_with_shaderlib(
-        datatoc_workbench_effect_dof_frag_glsl, e_data.lib, "#define DILATE_VERTICAL\n");
-    e_data.dof_dilate_h_sh = DRW_shader_create_fullscreen_with_shaderlib(
-        datatoc_workbench_effect_dof_frag_glsl, e_data.lib, "#define DILATE_HORIZONTAL\n");
-#endif
-    e_data.dof_blur1_sh = DRW_shader_create_fullscreen_with_shaderlib(
-        datatoc_workbench_effect_dof_frag_glsl, e_data.lib, "#define BLUR1\n");
-    e_data.dof_blur2_sh = DRW_shader_create_fullscreen_with_shaderlib(
-        datatoc_workbench_effect_dof_frag_glsl, e_data.lib, "#define BLUR2\n");
-    e_data.dof_resolve_sh = DRW_shader_create_fullscreen_with_shaderlib(
-        datatoc_workbench_effect_dof_frag_glsl, e_data.lib, "#define RESOLVE\n");
-  }
-
-  *prepare_sh = e_data.dof_prepare_sh;
-  *downsample_sh = e_data.dof_downsample_sh;
-  *blur1_sh = e_data.dof_blur1_sh;
-  *blur2_sh = e_data.dof_blur2_sh;
-  *resolve_sh = e_data.dof_resolve_sh;
-}
-
-GPUShader *workbench_shader_antialiasing_accumulation_get(void)
-{
-  if (e_data.aa_accum_sh == NULL) {
-    char *frag = DRW_shader_library_create_shader_string(e_data.lib,
-                                                         datatoc_workbench_effect_taa_frag_glsl);
-
-    e_data.aa_accum_sh = DRW_shader_create_fullscreen(frag, NULL);
-
-    MEM_freeN(frag);
-  }
-  return e_data.aa_accum_sh;
-}
-
-GPUShader *workbench_shader_antialiasing_get(int stage)
-{
-  BLI_assert(stage < 3);
-  if (!e_data.smaa_sh[stage]) {
-    char stage_define[32];
-    BLI_snprintf(stage_define, sizeof(stage_define), "#define SMAA_STAGE %d\n", stage);
-
-    e_data.smaa_sh[stage] = GPU_shader_create_from_arrays({
-        .vert =
-            (const char *[]){
-                "#define SMAA_INCLUDE_VS 1\n",
-                "#define SMAA_INCLUDE_PS 0\n",
-                "uniform vec4 viewportMetrics;\n",
-                datatoc_common_smaa_lib_glsl,
-                datatoc_workbench_effect_smaa_vert_glsl,
-                NULL,
-            },
-        .frag =
-            (const char *[]){
-                "#define SMAA_INCLUDE_VS 0\n",
-                "#define SMAA_INCLUDE_PS 1\n",
-                "uniform vec4 viewportMetrics;\n",
-                datatoc_common_smaa_lib_glsl,
-                datatoc_workbench_effect_smaa_frag_glsl,
-                NULL,
-            },
-        .defs =
-            (const char *[]){
-                "#define SMAA_GLSL_3\n",
-                "#define SMAA_RT_METRICS viewportMetrics\n",
-                "#define SMAA_PRESET_HIGH\n",
-                "#define SMAA_LUMA_WEIGHT float4(1.0, 1.0, 1.0, 1.0)\n",
-                "#define SMAA_NO_DISCARD\n",
-                stage_define,
-                NULL,
-            },
-    });
-  }
-  return e_data.smaa_sh[stage];
-}
-
-GPUShader *workbench_shader_volume_get(bool slice,
-                                       bool coba,
-                                       eWORKBENCH_VolumeInterpType interp_type,
-                                       bool smoke)
-{
-  GPUShader **shader = &e_data.volume_sh[slice][coba][interp_type][smoke];
-
-  if (*shader == NULL) {
-    DynStr *ds = BLI_dynstr_new();
-
-    if (slice) {
-      BLI_dynstr_append(ds, "#define VOLUME_SLICE\n");
-    }
-    if (coba) {
-      BLI_dynstr_append(ds, "#define USE_COBA\n");
-    }
-    switch (interp_type) {
-      case WORKBENCH_VOLUME_INTERP_LINEAR:
-        BLI_dynstr_append(ds, "#define USE_TRILINEAR\n");
-        break;
-      case WORKBENCH_VOLUME_INTERP_CUBIC:
-        BLI_dynstr_append(ds, "#define USE_TRICUBIC\n");
-        break;
-      case WORKBENCH_VOLUME_INTERP_CLOSEST:
-        BLI_dynstr_append(ds, "#define USE_CLOSEST\n");
-        break;
-    }
-    if (smoke) {
-      BLI_dynstr_append(ds, "#define VOLUME_SMOKE\n");
-    }
-
-    char *defines = BLI_dynstr_get_cstring(ds);
-    BLI_dynstr_free(ds);
-
-    char *vert = DRW_shader_library_create_shader_string(e_data.lib,
-                                                         datatoc_workbench_volume_vert_glsl);
-    char *frag = DRW_shader_library_create_shader_string(e_data.lib,
-                                                         datatoc_workbench_volume_frag_glsl);
-
-    *shader = DRW_shader_create(vert, NULL, frag, defines);
-
-    MEM_freeN(vert);
-    MEM_freeN(frag);
-    MEM_freeN(defines);
-  }
-  return *shader;
-}
-
-void workbench_shader_free(void)
-{
-  for (int j = 0; j < sizeof(e_data.opaque_prepass_sh_cache) / sizeof(void *); j++) {
-    struct GPUShader **sh_array = &e_data.opaque_prepass_sh_cache[0][0][0];
-    DRW_SHADER_FREE_SAFE(sh_array[j]);
-  }
-  for (int j = 0; j < sizeof(e_data.transp_prepass_sh_cache) / sizeof(void *); j++) {
-    struct GPUShader **sh_array = &e_data.transp_prepass_sh_cache[0][0][0][0];
-    DRW_SHADER_FREE_SAFE(sh_array[j]);
-  }
-  for (int j = 0; j < ARRAY_SIZE(e_data.opaque_composite_sh); j++) {
-    struct GPUShader **sh_array = &e_data.opaque_composite_sh[0];
-    DRW_SHADER_FREE_SAFE(sh_array[j]);
-  }
-  for (int j = 0; j < ARRAY_SIZE(e_data.shadow_depth_pass_sh); j++) {
-    struct GPUShader **sh_array = &e_data.shadow_depth_pass_sh[0];
-    DRW_SHADER_FREE_SAFE(sh_array[j]);
-  }
-  for (int j = 0; j < sizeof(e_data.shadow_depth_fail_sh) / sizeof(void *); j++) {
-    struct GPUShader **sh_array = &e_data.shadow_depth_fail_sh[0][0];
-    DRW_SHADER_FREE_SAFE(sh_array[j]);
-  }
-  for (int j = 0; j < sizeof(e_data.cavity_sh) / sizeof(void *); j++) {
-    struct GPUShader **sh_array = &e_data.cavity_sh[0][0];
-    DRW_SHADER_FREE_SAFE(sh_array[j]);
-  }
-  for (int j = 0; j < ARRAY_SIZE(e_data.smaa_sh); j++) {
-    struct GPUShader **sh_array = &e_data.smaa_sh[0];
-    DRW_SHADER_FREE_SAFE(sh_array[j]);
-  }
-  for (int j = 0; j < sizeof(e_data.volume_sh) / sizeof(void *); j++) {
-    struct GPUShader **sh_array = &e_data.volume_sh[0][0][0][0];
-    DRW_SHADER_FREE_SAFE(sh_array[j]);
-  }
-
-  DRW_SHADER_FREE_SAFE(e_data.oit_resolve_sh);
-  DRW_SHADER_FREE_SAFE(e_data.outline_sh);
-  DRW_SHADER_FREE_SAFE(e_data.merge_infront_sh);
-
-  DRW_SHADER_FREE_SAFE(e_data.dof_prepare_sh);
-  DRW_SHADER_FREE_SAFE(e_data.dof_downsample_sh);
-  DRW_SHADER_FREE_SAFE(e_data.dof_blur1_sh);
-  DRW_SHADER_FREE_SAFE(e_data.dof_blur2_sh);
-  DRW_SHADER_FREE_SAFE(e_data.dof_resolve_sh);
-
-  DRW_SHADER_FREE_SAFE(e_data.aa_accum_sh);
-
-  DRW_SHADER_LIB_FREE_SAFE(e_data.lib);
-}

source/blender/draw/engines/workbench/workbench_shader.cc

@@ -0,0 +1,444 @@
+/*
+ * 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.
+ *
+ * Copyright 2020, Blender Foundation.
+ */
+
+/** \file
+ * \ingroup draw_engine
+ */
+
+#include "DRW_render.h"
+
+#include <string>
+
+#include "workbench_engine.h"
+#include "workbench_private.h"
+
+extern char datatoc_common_math_lib_glsl[];
+extern char datatoc_common_math_geom_lib_glsl[];
+extern char datatoc_common_hair_lib_glsl[];
+extern char datatoc_common_pointcloud_lib_glsl[];
+extern char datatoc_common_view_lib_glsl[];
+extern char datatoc_common_smaa_lib_glsl[];
+
+extern char datatoc_workbench_prepass_vert_glsl[];
+extern char datatoc_workbench_prepass_hair_vert_glsl[];
+extern char datatoc_workbench_prepass_pointcloud_vert_glsl[];
+extern char datatoc_workbench_prepass_frag_glsl[];
+
+extern char datatoc_workbench_effect_cavity_frag_glsl[];
+extern char datatoc_workbench_effect_outline_frag_glsl[];
+extern char datatoc_workbench_effect_dof_frag_glsl[];
+extern char datatoc_workbench_effect_taa_frag_glsl[];
+extern char datatoc_workbench_effect_smaa_frag_glsl[];
+extern char datatoc_workbench_effect_smaa_vert_glsl[];
+
+extern char datatoc_workbench_composite_frag_glsl[];
+
+extern char datatoc_workbench_transparent_accum_frag_glsl[];
+extern char datatoc_workbench_transparent_resolve_frag_glsl[];
+
+extern char datatoc_workbench_merge_infront_frag_glsl[];
+
+extern char datatoc_workbench_shadow_vert_glsl[];
+extern char datatoc_workbench_shadow_geom_glsl[];
+extern char datatoc_workbench_shadow_caps_geom_glsl[];
+extern char datatoc_workbench_shadow_debug_frag_glsl[];
+
+extern char datatoc_workbench_volume_vert_glsl[];
+extern char datatoc_workbench_volume_frag_glsl[];
+
+extern char datatoc_workbench_cavity_lib_glsl[];
+extern char datatoc_workbench_common_lib_glsl[];
+extern char datatoc_workbench_curvature_lib_glsl[];
+extern char datatoc_workbench_data_lib_glsl[];
+extern char datatoc_workbench_image_lib_glsl[];
+extern char datatoc_workbench_matcap_lib_glsl[];
+extern char datatoc_workbench_material_lib_glsl[];
+extern char datatoc_workbench_world_light_lib_glsl[];
+
+extern char datatoc_gpu_shader_depth_only_frag_glsl[];
+extern char datatoc_gpu_shader_common_obinfos_lib_glsl[];
+
+/* Maximum number of variations. */
+#define MAX_LIGHTING 3
+
+enum eWORKBENCH_TextureType {
+  TEXTURE_SH_NONE = 0,
+  TEXTURE_SH_SINGLE,
+  TEXTURE_SH_TILED,
+  TEXTURE_SH_MAX,
+};
+
+static struct {
+  struct GPUShader
+      *opaque_prepass_sh_cache[GPU_SHADER_CFG_LEN][WORKBENCH_DATATYPE_MAX][TEXTURE_SH_MAX];
+  struct GPUShader *transp_prepass_sh_cache[GPU_SHADER_CFG_LEN][WORKBENCH_DATATYPE_MAX]
+                                           [MAX_LIGHTING][TEXTURE_SH_MAX];
+
+  struct GPUShader *opaque_composite_sh[MAX_LIGHTING];
+  struct GPUShader *oit_resolve_sh;
+  struct GPUShader *outline_sh;
+  struct GPUShader *merge_infront_sh;
+
+  struct GPUShader *shadow_depth_pass_sh[2];
+  struct GPUShader *shadow_depth_fail_sh[2][2];
+
+  struct GPUShader *cavity_sh[2][2];
+
+  struct GPUShader *dof_prepare_sh;
+  struct GPUShader *dof_downsample_sh;
+  struct GPUShader *dof_blur1_sh;
+  struct GPUShader *dof_blur2_sh;
+  struct GPUShader *dof_resolve_sh;
+
+  struct GPUShader *aa_accum_sh;
+  struct GPUShader *smaa_sh[3];
+
+  struct GPUShader *volume_sh[2][2][3][2];
+
+} e_data = {{{{NULL}}}};
+
+/* -------------------------------------------------------------------- */
+/** \name Conversions
+ * \{ */
+
+static const char *workbench_lighting_mode_to_str(int light)
+{
+  switch (light) {
+    default:
+      BLI_assert_msg(0, "Error: Unknown lighting mode.");
+      ATTR_FALLTHROUGH;
+    case V3D_LIGHTING_STUDIO:
+      return "_studio";
+    case V3D_LIGHTING_MATCAP:
+      return "_matcap";
+    case V3D_LIGHTING_FLAT:
+      return "_flat";
+      return "";
+  }
+}
+
+static const char *workbench_datatype_mode_to_str(eWORKBENCH_DataType datatype)
+{
+  switch (datatype) {
+    default:
+      BLI_assert_msg(0, "Error: Unknown data mode.");
+      ATTR_FALLTHROUGH;
+    case WORKBENCH_DATATYPE_MESH:
+      return "_mesh";
+    case WORKBENCH_DATATYPE_HAIR:
+      return "_hair";
+    case WORKBENCH_DATATYPE_POINTCLOUD:
+      return "_ptcloud";
+  }
+}
+
+static const char *workbench_volume_interp_to_str(eWORKBENCH_VolumeInterpType interp_type)
+{
+  switch (interp_type) {
+    default:
+      BLI_assert_msg(0, "Error: Unknown lighting mode.");
+      ATTR_FALLTHROUGH;
+    case WORKBENCH_VOLUME_INTERP_LINEAR:
+      return "_linear";
+    case WORKBENCH_VOLUME_INTERP_CUBIC:
+      return "_cubic";
+    case WORKBENCH_VOLUME_INTERP_CLOSEST:
+      return "_closest";
+  }
+}
+
+static const char *workbench_texture_type_to_str(eWORKBENCH_TextureType tex_type)
+{
+  switch (tex_type) {
+    default:
+      BLI_assert_msg(0, "Error: Unknown texture mode.");
+      ATTR_FALLTHROUGH;
+    case TEXTURE_SH_NONE:
+      return "_tex_none";
+    case TEXTURE_SH_TILED:
+      return "_tex_tile";
+    case TEXTURE_SH_SINGLE:
+      return "_tex_single";
+  }
+}
+
+static eWORKBENCH_TextureType workbench_texture_type_get(bool textured, bool tiled)
+{
+  return textured ? (tiled ? TEXTURE_SH_TILED : TEXTURE_SH_SINGLE) : TEXTURE_SH_NONE;
+}
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Shader request
+ * \{ */
+
+static GPUShader *workbench_shader_get_ex(WORKBENCH_PrivateData *wpd,
+                                          bool transp,
+                                          eWORKBENCH_DataType datatype,
+                                          bool textured,
+                                          bool tiled)
+{
+  eWORKBENCH_TextureType tex_type = workbench_texture_type_get(textured, tiled);
+  int light = wpd->shading.light;
+  BLI_assert(light < MAX_LIGHTING);
+  struct GPUShader **shader =
+      (transp) ? &e_data.transp_prepass_sh_cache[wpd->sh_cfg][datatype][light][tex_type] :
+                 &e_data.opaque_prepass_sh_cache[wpd->sh_cfg][datatype][tex_type];
+
+  if (*shader == nullptr) {
+    std::string create_info_name = "workbench";
+    create_info_name += (transp) ? "_transp" : "_opaque";
+    if (transp) {
+      create_info_name += workbench_lighting_mode_to_str(light);
+    }
+    create_info_name += workbench_datatype_mode_to_str(datatype);
+    create_info_name += workbench_texture_type_to_str(tex_type);
+    create_info_name += (wpd->sh_cfg == GPU_SHADER_CFG_CLIPPED) ? "_clip" : "_no_clip";
+
+    *shader = GPU_shader_create_from_info_name(create_info_name.c_str());
+  }
+  return *shader;
+}
+
+GPUShader *workbench_shader_opaque_get(WORKBENCH_PrivateData *wpd, eWORKBENCH_DataType datatype)
+{
+  return workbench_shader_get_ex(wpd, false, datatype, false, false);
+}
+
+GPUShader *workbench_shader_opaque_image_get(WORKBENCH_PrivateData *wpd,
+                                             eWORKBENCH_DataType datatype,
+                                             bool tiled)
+{
+  return workbench_shader_get_ex(wpd, false, datatype, true, tiled);
+}
+
+GPUShader *workbench_shader_transparent_get(WORKBENCH_PrivateData *wpd,
+                                            eWORKBENCH_DataType datatype)
+{
+  return workbench_shader_get_ex(wpd, true, datatype, false, false);
+}
+
+GPUShader *workbench_shader_transparent_image_get(WORKBENCH_PrivateData *wpd,
+                                                  eWORKBENCH_DataType datatype,
+                                                  bool tiled)
+{
+  return workbench_shader_get_ex(wpd, true, datatype, true, tiled);
+}
+
+GPUShader *workbench_shader_composite_get(WORKBENCH_PrivateData *wpd)
+{
+  int light = wpd->shading.light;
+  struct GPUShader **shader = &e_data.opaque_composite_sh[light];
+  BLI_assert(light < MAX_LIGHTING);
+
+  if (*shader == nullptr) {
+    std::string create_info_name = "workbench_composite";
+    create_info_name += workbench_lighting_mode_to_str(light);
+    *shader = GPU_shader_create_from_info_name(create_info_name.c_str());
+  }
+  return *shader;
+}
+
+GPUShader *workbench_shader_merge_infront_get(WORKBENCH_PrivateData *UNUSED(wpd))
+{
+  if (e_data.merge_infront_sh == nullptr) {
+    e_data.merge_infront_sh = GPU_shader_create_from_info_name("workbench_merge_infront");
+  }
+  return e_data.merge_infront_sh;
+}
+
+GPUShader *workbench_shader_transparent_resolve_get(WORKBENCH_PrivateData *UNUSED(wpd))
+{
+  if (e_data.oit_resolve_sh == nullptr) {
+    e_data.oit_resolve_sh = GPU_shader_create_from_info_name("workbench_transparent_resolve");
+  }
+  return e_data.oit_resolve_sh;
+}
+
+static GPUShader *workbench_shader_shadow_pass_get_ex(bool depth_pass, bool manifold, bool cap)
+{
+  struct GPUShader **shader = (depth_pass) ? &e_data.shadow_depth_pass_sh[manifold] :
+                                             &e_data.shadow_depth_fail_sh[manifold][cap];
+
+  if (*shader == nullptr) {
+    std::string create_info_name = "workbench_shadow";
+    create_info_name += (depth_pass) ? "_pass" : "_fail";
+    create_info_name += (manifold) ? "_manifold" : "_no_manifold";
+    create_info_name += (cap) ? "_caps" : "_no_caps";
+#if DEBUG_SHADOW_VOLUME
+    create_info_name += "_debug";
+#endif
+    *shader = GPU_shader_create_from_info_name(create_info_name.c_str());
+  }
+  return *shader;
+}
+
+GPUShader *workbench_shader_shadow_pass_get(bool manifold)
+{
+  return workbench_shader_shadow_pass_get_ex(true, manifold, false);
+}
+
+GPUShader *workbench_shader_shadow_fail_get(bool manifold, bool cap)
+{
+  return workbench_shader_shadow_pass_get_ex(false, manifold, cap);
+}
+
+GPUShader *workbench_shader_cavity_get(bool cavity, bool curvature)
+{
+  BLI_assert(cavity || curvature);
+  struct GPUShader **shader = &e_data.cavity_sh[cavity][curvature];
+
+  if (*shader == nullptr) {
+    std::string create_info_name = "workbench_effect";
+    create_info_name += (cavity) ? "_cavity" : "";
+    create_info_name += (curvature) ? "_curvature" : "";
+    *shader = GPU_shader_create_from_info_name(create_info_name.c_str());
+  }
+  return *shader;
+}
+
+GPUShader *workbench_shader_outline_get(void)
+{
+  if (e_data.outline_sh == nullptr) {
+    e_data.outline_sh = GPU_shader_create_from_info_name("workbench_effect_outline");
+  }
+  return e_data.outline_sh;
+}
+
+void workbench_shader_depth_of_field_get(GPUShader **prepare_sh,
+                                         GPUShader **downsample_sh,
+                                         GPUShader **blur1_sh,
+                                         GPUShader **blur2_sh,
+                                         GPUShader **resolve_sh)
+{
+  if (e_data.dof_prepare_sh == nullptr) {
+    e_data.dof_prepare_sh = GPU_shader_create_from_info_name("workbench_effect_dof_prepare");
+    e_data.dof_downsample_sh = GPU_shader_create_from_info_name("workbench_effect_dof_downsample");
+#if 0 /* TODO(fclem): finish COC min_max optimization */
+    e_data.dof_flatten_v_sh = GPU_shader_create_from_info_name("workbench_effect_dof_flatten_v");
+    e_data.dof_flatten_h_sh = GPU_shader_create_from_info_name("workbench_effect_dof_flatten_h");
+    e_data.dof_dilate_v_sh = GPU_shader_create_from_info_name("workbench_effect_dof_dilate_v");
+    e_data.dof_dilate_h_sh = GPU_shader_create_from_info_name("workbench_effect_dof_dilate_h");
+#endif
+    e_data.dof_blur1_sh = GPU_shader_create_from_info_name("workbench_effect_dof_blur1");
+    e_data.dof_blur2_sh = GPU_shader_create_from_info_name("workbench_effect_dof_blur2");
+    e_data.dof_resolve_sh = GPU_shader_create_from_info_name("workbench_effect_dof_resolve");
+  }
+
+  *prepare_sh = e_data.dof_prepare_sh;
+  *downsample_sh = e_data.dof_downsample_sh;
+  *blur1_sh = e_data.dof_blur1_sh;
+  *blur2_sh = e_data.dof_blur2_sh;
+  *resolve_sh = e_data.dof_resolve_sh;
+}
+
+GPUShader *workbench_shader_antialiasing_accumulation_get(void)
+{
+  if (e_data.aa_accum_sh == nullptr) {
+    e_data.aa_accum_sh = GPU_shader_create_from_info_name("workbench_taa");
+  }
+  return e_data.aa_accum_sh;
+}
+
+GPUShader *workbench_shader_antialiasing_get(int stage)
+{
+  BLI_assert(stage < 3);
+  GPUShader **shader = &e_data.smaa_sh[stage];
+
+  if (*shader == nullptr) {
+    std::string create_info_name = "workbench_smaa_stage_";
+    create_info_name += std::to_string(stage);
+    *shader = GPU_shader_create_from_info_name(create_info_name.c_str());
+  }
+  return e_data.smaa_sh[stage];
+}
+
+GPUShader *workbench_shader_volume_get(bool slice,
+                                       bool coba,
+                                       eWORKBENCH_VolumeInterpType interp_type,
+                                       bool smoke)
+{
+  GPUShader **shader = &e_data.volume_sh[slice][coba][interp_type][smoke];
+
+  if (*shader == nullptr) {
+    std::string create_info_name = "workbench_volume";
+    create_info_name += (smoke) ? "_smoke" : "_object";
+    create_info_name += workbench_volume_interp_to_str(interp_type);
+    create_info_name += (coba) ? "_coba" : "_no_coba";
+    create_info_name += (slice) ? "_slice" : "_no_slice";
+    *shader = GPU_shader_create_from_info_name(create_info_name.c_str());
+  }
+  return *shader;
+}
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Cleanup
+ * \{ */
+
+void workbench_shader_free(void)
+{
+  for (int j = 0; j < sizeof(e_data.opaque_prepass_sh_cache) / sizeof(void *); j++) {
+    struct GPUShader **sh_array = &e_data.opaque_prepass_sh_cache[0][0][0];
+    DRW_SHADER_FREE_SAFE(sh_array[j]);
+  }
+  for (int j = 0; j < sizeof(e_data.transp_prepass_sh_cache) / sizeof(void *); j++) {
+    struct GPUShader **sh_array = &e_data.transp_prepass_sh_cache[0][0][0][0];
+    DRW_SHADER_FREE_SAFE(sh_array[j]);
+  }
+  for (int j = 0; j < ARRAY_SIZE(e_data.opaque_composite_sh); j++) {
+    struct GPUShader **sh_array = &e_data.opaque_composite_sh[0];
+    DRW_SHADER_FREE_SAFE(sh_array[j]);
+  }
+  for (int j = 0; j < ARRAY_SIZE(e_data.shadow_depth_pass_sh); j++) {
+    struct GPUShader **sh_array = &e_data.shadow_depth_pass_sh[0];
+    DRW_SHADER_FREE_SAFE(sh_array[j]);
+  }
+  for (int j = 0; j < sizeof(e_data.shadow_depth_fail_sh) / sizeof(void *); j++) {
+    struct GPUShader **sh_array = &e_data.shadow_depth_fail_sh[0][0];
+    DRW_SHADER_FREE_SAFE(sh_array[j]);
+  }
+  for (int j = 0; j < sizeof(e_data.cavity_sh) / sizeof(void *); j++) {
+    struct GPUShader **sh_array = &e_data.cavity_sh[0][0];
+    DRW_SHADER_FREE_SAFE(sh_array[j]);
+  }
+  for (int j = 0; j < ARRAY_SIZE(e_data.smaa_sh); j++) {
+    struct GPUShader **sh_array = &e_data.smaa_sh[0];
+    DRW_SHADER_FREE_SAFE(sh_array[j]);
+  }
+  for (int j = 0; j < sizeof(e_data.volume_sh) / sizeof(void *); j++) {
+    struct GPUShader **sh_array = &e_data.volume_sh[0][0][0][0];
+    DRW_SHADER_FREE_SAFE(sh_array[j]);
+  }
+
+  DRW_SHADER_FREE_SAFE(e_data.oit_resolve_sh);
+  DRW_SHADER_FREE_SAFE(e_data.outline_sh);
+  DRW_SHADER_FREE_SAFE(e_data.merge_infront_sh);
+
+  DRW_SHADER_FREE_SAFE(e_data.dof_prepare_sh);
+  DRW_SHADER_FREE_SAFE(e_data.dof_downsample_sh);
+  DRW_SHADER_FREE_SAFE(e_data.dof_blur1_sh);
+  DRW_SHADER_FREE_SAFE(e_data.dof_blur2_sh);
+  DRW_SHADER_FREE_SAFE(e_data.dof_resolve_sh);
+
+  DRW_SHADER_FREE_SAFE(e_data.aa_accum_sh);
+}
+
+/** \} */

source/blender/draw/engines/workbench/workbench_shader_shared.h

@@ -45,4 +45,3 @@ struct WorldData {
 };
 
 #define viewport_size_inv viewport_size.zw
-#define packed_rough_metal roughness

source/blender/draw/engines/workbench/workbench_transparent.c

@@ -65,7 +65,7 @@ void workbench_transparent_engine_init(WORKBENCH_Data *data)
 static void workbench_transparent_lighting_uniforms(WORKBENCH_PrivateData *wpd,
                                                     DRWShadingGroup *grp)
 {
-  DRW_shgroup_uniform_block(grp, "world_block", wpd->world_ubo);
+  DRW_shgroup_uniform_block(grp, "world_data", wpd->world_ubo);
   DRW_shgroup_uniform_bool_copy(grp, "forceShadowing", false);
 
   if (STUDIOLIGHT_TYPE_MATCAP_ENABLED(wpd)) {
@@ -76,8 +76,8 @@ static void workbench_transparent_lighting_uniforms(WORKBENCH_PrivateData *wpd,
     struct GPUTexture *spec_tx = wpd->studio_light->matcap_specular.gputexture;
     const bool use_spec = workbench_is_specular_highlight_enabled(wpd);
     spec_tx = (use_spec && spec_tx) ? spec_tx : diff_tx;
-    DRW_shgroup_uniform_texture(grp, "matcapDiffuseImage", diff_tx);
-    DRW_shgroup_uniform_texture(grp, "matcapSpecularImage", spec_tx);
+    DRW_shgroup_uniform_texture(grp, "matcap_diffuse_tx", diff_tx);
+    DRW_shgroup_uniform_texture(grp, "matcap_specular_tx", spec_tx);
   }
 }
 
@@ -111,25 +111,25 @@ void workbench_transparent_cache_init(WORKBENCH_Data *vedata)
         sh = workbench_shader_transparent_get(wpd, data);
 
         wpd->prepass[transp][infront][data].common_shgrp = grp = DRW_shgroup_create(sh, pass);
-        DRW_shgroup_uniform_block(grp, "material_block", wpd->material_ubo_curr);
+        DRW_shgroup_uniform_block(grp, "materials_data", wpd->material_ubo_curr);
         DRW_shgroup_uniform_int_copy(grp, "materialIndex", -1);
         workbench_transparent_lighting_uniforms(wpd, grp);
 
         wpd->prepass[transp][infront][data].vcol_shgrp = grp = DRW_shgroup_create(sh, pass);
-        DRW_shgroup_uniform_block(grp, "material_block", wpd->material_ubo_curr);
+        DRW_shgroup_uniform_block(grp, "materials_data", wpd->material_ubo_curr);
         DRW_shgroup_uniform_int_copy(grp, "materialIndex", 0); /* Default material. (uses vcol) */
 
         sh = workbench_shader_transparent_image_get(wpd, data, false);
 
         wpd->prepass[transp][infront][data].image_shgrp = grp = DRW_shgroup_create(sh, pass);
-        DRW_shgroup_uniform_block(grp, "material_block", wpd->material_ubo_curr);
+        DRW_shgroup_uniform_block(grp, "materials_data", wpd->material_ubo_curr);
         DRW_shgroup_uniform_int_copy(grp, "materialIndex", 0); /* Default material. */
         workbench_transparent_lighting_uniforms(wpd, grp);
 
         sh = workbench_shader_transparent_image_get(wpd, data, true);
 
         wpd->prepass[transp][infront][data].image_tiled_shgrp = grp = DRW_shgroup_create(sh, pass);
-        DRW_shgroup_uniform_block(grp, "material_block", wpd->material_ubo_curr);
+        DRW_shgroup_uniform_block(grp, "materials_data", wpd->material_ubo_curr);
         DRW_shgroup_uniform_int_copy(grp, "materialIndex", 0); /* Default material. */
         workbench_transparent_lighting_uniforms(wpd, grp);
       }

source/blender/draw/engines/workbench/workbench_volume.c

@@ -129,7 +129,7 @@ static void workbench_volume_modifier_cache_populate(WORKBENCH_Data *vedata,
     float step_length = max_ff(1e-16f, dim[axis] * 0.05f);
 
     grp = DRW_shgroup_create(sh, vedata->psl->volume_ps);
-    DRW_shgroup_uniform_block(grp, "world_block", wpd->world_ubo);
+    DRW_shgroup_uniform_block(grp, "world_data", wpd->world_ubo);
     DRW_shgroup_uniform_float_copy(grp, "slicePosition", fds->slice_depth);
     DRW_shgroup_uniform_int_copy(grp, "sliceAxis", axis);
     DRW_shgroup_uniform_float_copy(grp, "stepLength", step_length);
@@ -148,7 +148,7 @@ static void workbench_volume_modifier_cache_populate(WORKBENCH_Data *vedata,
     step_length = len_v3(dim);
 
     grp = DRW_shgroup_create(sh, vedata->psl->volume_ps);
-    DRW_shgroup_uniform_block(grp, "world_block", wpd->world_ubo);
+    DRW_shgroup_uniform_block(grp, "world_data", wpd->world_ubo);
     DRW_shgroup_uniform_int_copy(grp, "samplesLen", max_slice);
     DRW_shgroup_uniform_float_copy(grp, "stepLength", step_length);
     DRW_shgroup_uniform_float_copy(grp, "noiseOfs", noise_ofs);
@@ -272,7 +272,7 @@ static void workbench_volume_object_cache_populate(WORKBENCH_Data *vedata,
     const float slice_position = volume->display.slice_depth;
 
     grp = DRW_shgroup_create(sh, vedata->psl->volume_ps);
-    DRW_shgroup_uniform_block(grp, "world_block", wpd->world_ubo);
+    DRW_shgroup_uniform_block(grp, "world_data", wpd->world_ubo);
     DRW_shgroup_uniform_float_copy(grp, "slicePosition", slice_position);
     DRW_shgroup_uniform_int_copy(grp, "sliceAxis", axis);
     DRW_shgroup_uniform_float_copy(grp, "stepLength", step_length);
@@ -299,7 +299,7 @@ static void workbench_volume_object_cache_populate(WORKBENCH_Data *vedata,
 
     /* Set uniforms. */
     grp = DRW_shgroup_create(sh, vedata->psl->volume_ps);
-    DRW_shgroup_uniform_block(grp, "world_block", wpd->world_ubo);
+    DRW_shgroup_uniform_block(grp, "world_data", wpd->world_ubo);
     DRW_shgroup_uniform_int_copy(grp, "samplesLen", max_slice);
     DRW_shgroup_uniform_float_copy(grp, "stepLength", step_length);
     DRW_shgroup_uniform_float_copy(grp, "noiseOfs", noise_ofs);

source/blender/draw/intern/draw_manager_data.c

@@ -528,7 +528,7 @@ static void drw_call_obinfos_init(DRWObjectInfos *ob_infos, Object *ob)
   drw_call_calc_orco(ob, ob_infos->orcotexfac);
   /* Random float value. */
   uint random = (DST.dupli_source) ?
-                     DST.dupli_source->random_id :
+                    DST.dupli_source->random_id :
                      /* TODO(fclem): this is rather costly to do at runtime. Maybe we can
                       * put it in ob->runtime and make depsgraph ensure it is up to date. */
                      BLI_hash_int_2d(BLI_hash_string(ob->id.name + 2), 0);
@@ -1248,6 +1248,17 @@ static void drw_shgroup_init(DRWShadingGroup *shgroup, GPUShader *shader)
   int chunkid_location = GPU_shader_get_builtin_uniform(shader, GPU_UNIFORM_RESOURCE_CHUNK);
   int resourceid_location = GPU_shader_get_builtin_uniform(shader, GPU_UNIFORM_RESOURCE_ID);
 
+  /* TODO(fclem) Will take the place of the above after the GPUShaderCreateInfo port. */
+  if (view_ubo_location == -1) {
+    view_ubo_location = GPU_shader_get_builtin_block(shader, GPU_UNIFORM_BLOCK_DRW_VIEW);
+  }
+  if (model_ubo_location == -1) {
+    model_ubo_location = GPU_shader_get_builtin_block(shader, GPU_UNIFORM_BLOCK_DRW_MODEL);
+  }
+  if (info_ubo_location == -1) {
+    info_ubo_location = GPU_shader_get_builtin_block(shader, GPU_UNIFORM_BLOCK_DRW_INFOS);
+  }
+
   if (chunkid_location != -1) {
     drw_shgroup_uniform_create_ex(
         shgroup, chunkid_location, DRW_UNIFORM_RESOURCE_CHUNK, NULL, 0, 0, 1);

source/blender/draw/intern/draw_shader_shared.h

@@ -16,7 +16,7 @@ struct ViewInfos {
   float4x4 winmat;
   float4x4 wininv;
 
-  float4 clipplanes[6];
+  float4 clip_planes[6];
   float4 viewvecs[2];
   /* Should not be here. Not view dependent (only main view). */
   float4 viewcamtexcofac;
@@ -30,7 +30,7 @@ BLI_STATIC_ASSERT_ALIGN(ViewInfos, 16)
 #define ViewMatrixInverse drw_view.viewinv
 #define ProjectionMatrix drw_view.winmat
 #define ProjectionMatrixInverse drw_view.wininv
-#define clipPlanes drw_view.clipplanes
+#define clipPlanes drw_view.clip_planes
 #define ViewVecs drw_view.viewvecs
 #define CameraTexCoFactors drw_view.viewcamtexcofac
 
@@ -39,3 +39,14 @@ struct ObjectMatrices {
   float4x4 drw_modelMatrixInverse;
 };
 BLI_STATIC_ASSERT_ALIGN(ViewInfos, 16)
+
+struct ObjectInfos {
+  vec4 drw_OrcoTexCoFactors[2];
+  vec4 drw_ObjectColor;
+  vec4 drw_Infos;
+};
+BLI_STATIC_ASSERT_ALIGN(ViewInfos, 16)
+
+#define OrcoTexCoFactors (drw_infos[resource_id].drw_OrcoTexCoFactors)
+#define ObjectInfo (drw_infos[resource_id].drw_Infos)
+#define ObjectColor (drw_infos[resource_id].drw_ObjectColor)

source/blender/draw/intern/shaders/common_hair_lib.glsl

@@ -5,7 +5,9 @@
  * of data the CPU has to precompute and transfer for each update.
  */
 
+/* TODO(fclem): Keep documentation but remove the uniform declaration. */
 #ifndef USE_GPU_SHADER_CREATE_INFO
+
 /**
  * hairStrandsRes: Number of points per hair strand.
  * 2 - no subdivision

source/blender/draw/intern/shaders/common_smaa_lib.glsl

@@ -736,9 +736,11 @@ float2 SMAALumaEdgeDetectionPS(float2 texcoord,
   float2 edges = step(threshold, delta.xy);
 
 #  ifndef SMAA_NO_DISCARD
+#    ifdef GPU_FRAGMENT_SHADER
   // Then discard if there is no edge:
   if (dot(edges, float2(1.0, 1.0)) == 0.0)
     discard;
+#    endif
 #  endif
 
   // Calculate right and bottom deltas:
@@ -804,9 +806,11 @@ float2 SMAAColorEdgeDetectionPS(float2 texcoord,
   float2 edges = step(threshold, delta.xy);
 
 #  ifndef SMAA_NO_DISCARD
+#    ifdef GPU_FRAGMENT_SHADER
   // Then discard if there is no edge:
   if (dot(edges, float2(1.0, 1.0)) == 0.0)
     discard;
+#    endif
 #  endif
 
   // Calculate right and bottom deltas:
@@ -851,8 +855,10 @@ float2 SMAADepthEdgeDetectionPS(float2 texcoord, float4 offset[3], SMAATexture2D
   float2 delta = abs(neighbours.xx - float2(neighbours.y, neighbours.z));
   float2 edges = step(SMAA_DEPTH_THRESHOLD, delta);
 
+#  ifdef GPU_FRAGMENT_SHADER
   if (dot(edges, float2(1.0, 1.0)) == 0.0)
     discard;
+#  endif
 
   return edges;
 }

source/blender/draw/intern/shaders/common_view_clipping_lib.glsl

@@ -0,0 +1,33 @@
+
+#pragma BLENDER_REQUIRE(common_view_lib.glsl)
+
+#if defined(GPU_VERTEX_SHADER) || defined(GPU_GEOMETRY_SHADER)
+
+void view_clipping_distances(vec3 wpos)
+{
+#  ifdef USE_WORLD_CLIP_PLANES
+  vec4 pos = vec4(wpos, 1.0);
+  gl_ClipDistance[0] = dot(drw_view.clip_planes[0], pos);
+  gl_ClipDistance[1] = dot(drw_view.clip_planes[1], pos);
+  gl_ClipDistance[2] = dot(drw_view.clip_planes[2], pos);
+  gl_ClipDistance[3] = dot(drw_view.clip_planes[3], pos);
+  gl_ClipDistance[4] = dot(drw_view.clip_planes[4], pos);
+  gl_ClipDistance[5] = dot(drw_view.clip_planes[5], pos);
+#  endif
+}
+
+/* Kept as define for compiler compatibility. */
+#  ifdef USE_WORLD_CLIP_PLANES
+#    define view_clipping_distances_set(c) \
+      gl_ClipDistance[0] = (c).gl_ClipDistance[0]; \
+      gl_ClipDistance[1] = (c).gl_ClipDistance[1]; \
+      gl_ClipDistance[2] = (c).gl_ClipDistance[2]; \
+      gl_ClipDistance[3] = (c).gl_ClipDistance[3]; \
+      gl_ClipDistance[4] = (c).gl_ClipDistance[4]; \
+      gl_ClipDistance[5] = (c).gl_ClipDistance[5];
+
+#  else
+#    define view_clipping_distances_set(c)
+#  endif
+
+#endif

source/blender/draw/intern/shaders/common_view_lib.glsl

@@ -84,66 +84,91 @@ vec4 pack_line_data(vec2 frag_co, vec2 edge_start, vec2 edge_pos)
   }
 }
 
-uniform int resourceChunk;
+/* Temporary until we fully make the switch. */
+#ifndef DRW_SHADER_SHARED_H
+uniform int drw_resourceChunk;
+#endif /* DRW_SHADER_SHARED_H */
 
 #ifdef GPU_VERTEX_SHADER
-#  ifdef GPU_ARB_shader_draw_parameters
-#    define baseInstance gl_BaseInstanceARB
-#  else /* no ARB_shader_draw_parameters */
-uniform int baseInstance;
-#  endif
 
-#  if defined(IN_PLACE_INSTANCES) || defined(INSTANCED_ATTR)
+/* Temporary until we fully make the switch. */
+#  ifndef DRW_SHADER_SHARED_H
+
+/* clang-format off */
+#    if defined(IN_PLACE_INSTANCES) || defined(INSTANCED_ATTR) || defined(DRW_LEGACY_MODEL_MATRIX) || defined(GPU_DEPRECATED_AMD_DRIVER)
+/* clang-format on */
 /* When drawing instances of an object at the same position. */
-#    define instanceId 0
-#  elif defined(GPU_DEPRECATED_AMD_DRIVER)
-/* A driver bug make it so that when using an attribute with GL_INT_2_10_10_10_REV as format,
- * the gl_InstanceID is incremented by the 2 bit component of the attribute.
- * Ignore gl_InstanceID then. */
-#    define instanceId 0
-#  else
-#    define instanceId gl_InstanceID
-#  endif
+#      define instanceId 0
+#    else
+#      define instanceId gl_InstanceID
+#    endif
 
-#  ifdef UNIFORM_RESOURCE_ID
-/* This is in the case we want to do a special instance drawcall but still want to have the
- * right resourceId and all the correct ubo datas. */
-uniform int resourceId;
-#    define resource_id resourceId
-#  else
-#    define resource_id (baseInstance + instanceId)
-#  endif
+#    if defined(UNIFORM_RESOURCE_ID)
+/* This is in the case we want to do a special instance drawcall for one object but still want to
+ * have the right resourceId and all the correct ubo datas. */
+uniform int drw_resourceId;
+#      define resource_id drw_resourceId
+#    else
+#      define resource_id (gpu_BaseInstance + instanceId)
+#    endif
 
 /* Use this to declare and pass the value if
  * the fragment shader uses the resource_id. */
-#  ifdef USE_GEOMETRY_SHADER
-#    define RESOURCE_ID_VARYING flat out int resourceIDGeom;
-#    define PASS_RESOURCE_ID resourceIDGeom = resource_id;
-#  else
-#    define RESOURCE_ID_VARYING flat out int resourceIDFrag;
-#    define PASS_RESOURCE_ID resourceIDFrag = resource_id;
-#  endif
-#endif
+#    ifdef USE_GEOMETRY_SHADER
+#      define RESOURCE_ID_VARYING flat out int resourceIDGeom;
+#      define PASS_RESOURCE_ID resourceIDGeom = resource_id;
+#    else
+#      define RESOURCE_ID_VARYING flat out int resourceIDFrag;
+#      define PASS_RESOURCE_ID resourceIDFrag = resource_id;
+#    endif
 
+#  endif /* DRW_SHADER_SHARED_H */
+
+#endif /* GPU_VERTEX_SHADER */
+
+/* Temporary until we fully make the switch. */
+#ifdef DRW_SHADER_SHARED_H
+/* TODO(fclem): Rename PASS_RESOURCE_ID to DRW_RESOURCE_ID_VARYING_SET */
+#  if defined(UNIFORM_RESOURCE_ID)
+#    define resource_id drw_ResourceID
+#    define PASS_RESOURCE_ID
+
+#  elif defined(GPU_VERTEX_SHADER)
+#    define resource_id gpu_InstanceIndex
+#    define PASS_RESOURCE_ID drw_ResourceID_iface.resource_index = resource_id;
+
+#  elif defined(GPU_GEOMETRY_SHADER)
+#    define resource_id drw_ResourceID_iface_in[0].index
+#    define PASS_RESOURCE_ID drw_ResourceID_iface_out.resource_index = resource_id;
+
+#  elif defined(GPU_FRAGMENT_SHADER)
+#    define resource_id drw_ResourceID_iface.resource_index
+#  endif
+
+/* TODO(fclem): Remove. */
+#  define RESOURCE_ID_VARYING
+
+#else
 /* If used in a fragment / geometry shader, we pass
  * resource_id as varying. */
-#ifdef GPU_GEOMETRY_SHADER
-#  define RESOURCE_ID_VARYING \
-    flat out int resourceIDFrag; \
-    flat in int resourceIDGeom[];
+#  ifdef GPU_GEOMETRY_SHADER
+#    define RESOURCE_ID_VARYING \
+      flat out int resourceIDFrag; \
+      flat in int resourceIDGeom[];
 
-#  define resource_id resourceIDGeom
-#  define PASS_RESOURCE_ID resourceIDFrag = resource_id[0];
-#endif
+#    define resource_id resourceIDGeom
+#    define PASS_RESOURCE_ID resourceIDFrag = resource_id[0];
+#  endif
 
-#ifdef GPU_FRAGMENT_SHADER
+#  ifdef GPU_FRAGMENT_SHADER
 flat in int resourceIDFrag;
-#  define resource_id resourceIDFrag
+#    define resource_id resourceIDFrag
+#  endif
 #endif
 
 /* Breaking this across multiple lines causes issues for some older GLSL compilers. */
 /* clang-format off */
-#if !defined(GPU_INTEL) && !defined(GPU_DEPRECATED_AMD_DRIVER) && !defined(OS_MAC) && !defined(INSTANCED_ATTR)
+#if !defined(GPU_INTEL) && !defined(GPU_DEPRECATED_AMD_DRIVER) && !defined(OS_MAC) && !defined(INSTANCED_ATTR) && !defined(DRW_LEGACY_MODEL_MATRIX)
 /* clang-format on */
 
 /* Temporary until we fully make the switch. */
@@ -158,10 +183,10 @@ layout(std140) uniform modelBlock
 {
   ObjectMatrices drw_matrices[DRW_RESOURCE_CHUNK_LEN];
 };
-#  endif /* DRW_SHADER_SHARED_H */
 
-#  define ModelMatrix (drw_matrices[resource_id].drw_modelMatrix)
-#  define ModelMatrixInverse (drw_matrices[resource_id].drw_modelMatrixInverse)
+#    define ModelMatrix (drw_matrices[resource_id].drw_modelMatrix)
+#    define ModelMatrixInverse (drw_matrices[resource_id].drw_modelMatrixInverse)
+#  endif /* DRW_SHADER_SHARED_H */
 
 #else /* GPU_INTEL */
 
@@ -177,7 +202,10 @@ uniform mat4 ModelMatrixInverse;
 
 #endif
 
-#define resource_handle (resourceChunk * DRW_RESOURCE_CHUNK_LEN + resource_id)
+/* Temporary until we fully make the switch. */
+#ifndef DRW_SHADER_SHARED_H
+#  define resource_handle (drw_resourceChunk * DRW_RESOURCE_CHUNK_LEN + resource_id)
+#endif
 
 /** Transform shortcuts. */
 /* Rule of thumb: Try to reuse world positions and normals because converting through viewspace

source/blender/draw/intern/shaders/draw_object_infos_info.hh

@@ -2,4 +2,5 @@
 #include "gpu_shader_create_info.hh"
 
 GPU_SHADER_CREATE_INFO(draw_object_infos)
+    .typedef_source("draw_shader_shared.h")
     .uniform_buf(1, "ObjectInfos", "drw_infos[DRW_RESOURCE_CHUNK_LEN]", Frequency::BATCH);

source/blender/draw/intern/shaders/draw_view_info.hh

@@ -1,6 +1,43 @@
 
 #include "gpu_shader_create_info.hh"
 
+/* -------------------------------------------------------------------- */
+/** \name Resource ID
+ *
+ * This is used to fetch per object data in drw_matrices and other object indexed
+ * buffers. There is multiple possibilities depending on how we are drawing the object.
+ *
+ * \{ */
+
+/* Standard way. Use gpu_InstanceIndex to index the object data. */
+GPU_SHADER_CREATE_INFO(draw_resource_id).define("DYNAMIC_RESOURCE_ID");
+
+/**
+ * Used if the resource index needs to be passed to the fragment shader.
+ * IMPORTANT: Vertex and Geometry shaders need to use PASS_RESOURCE_ID in main().
+ */
+GPU_SHADER_INTERFACE_INFO(draw_resource_id_iface, "drw_ResourceID_iface")
+    .flat(Type::INT, "resource_index");
+
+GPU_SHADER_CREATE_INFO(draw_resource_id_varying)
+    .vertex_out(draw_resource_id_iface)
+    .geometry_out(draw_resource_id_iface); /* Used if needed. */
+
+/* Variation used when drawing multiple instances for one object. */
+GPU_SHADER_CREATE_INFO(draw_resource_id_uniform)
+    .define("UNIFORM_RESOURCE_ID")
+    .push_constant(64, Type::INT, "drw_ResourceID");
+
+/**
+ * Declare a resource handle that identify a unique object.
+ * Requires draw_resource_id[_constant].
+ */
+GPU_SHADER_CREATE_INFO(draw_resource_handle)
+    .define("resource_handle (drw_resourceChunk * DRW_RESOURCE_CHUNK_LEN + resource_id)")
+    .push_constant(63, Type::INT, "drw_resourceChunk");
+
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Draw View
  * \{ */
@@ -9,32 +46,60 @@ GPU_SHADER_CREATE_INFO(draw_view)
     .uniform_buf(0, "ViewInfos", "drw_view", Frequency::PASS)
     .typedef_source("draw_shader_shared.h");
 
-GPU_SHADER_CREATE_INFO(draw_view_instanced_attr)
+GPU_SHADER_CREATE_INFO(draw_modelmat)
+    .uniform_buf(8, "ObjectMatrices", "drw_matrices[DRW_RESOURCE_CHUNK_LEN]", Frequency::BATCH)
+    .define("ModelMatrix", "(drw_matrices[resource_id].drw_modelMatrix)")
+    .define("ModelMatrixInverse", "(drw_matrices[resource_id].drw_modelMatrixInverse)")
+    .additional_info("draw_view");
+
+GPU_SHADER_CREATE_INFO(draw_modelmat_legacy)
+    .define("DRW_LEGACY_MODEL_MATRIX")
+    .push_constant(38, Type::MAT4, "ModelMatrix")
+    .push_constant(54, Type::MAT4, "ModelMatrixInverse")
+    .additional_info("draw_view");
+
+GPU_SHADER_CREATE_INFO(draw_modelmat_instanced_attr)
     .push_constant(0, Type::MAT4, "ModelMatrix")
     .push_constant(16, Type::MAT4, "ModelMatrixInverse")
     .additional_info("draw_view");
 
 /** \} */
 
+/* -------------------------------------------------------------------- */
+/** \name Draw View
+ * \{ */
+
+GPU_SHADER_CREATE_INFO(drw_clipped).define("USE_WORLD_CLIP_PLANES");
+
+/** \} */
+
 /* -------------------------------------------------------------------- */
 /** \name Geometry Type
  * \{ */
 
-GPU_SHADER_CREATE_INFO(draw_mesh)
-    .uniform_buf(8, "ObjectMatrices", "drw_matrices[DRW_RESOURCE_CHUNK_LEN]", Frequency::BATCH)
-    .additional_info("draw_view");
+GPU_SHADER_CREATE_INFO(draw_mesh).additional_info("draw_modelmat", "draw_resource_id");
 
 GPU_SHADER_CREATE_INFO(draw_hair)
-    /* TODO(fclem) Finish */
-    .uniform_buf(8, "ObjectMatrices", "drw_matrices[DRW_RESOURCE_CHUNK_LEN]", Frequency::BATCH)
-    .additional_info("draw_view");
+    .sampler(15, ImageType::FLOAT_BUFFER, "hairPointBuffer")
+    .sampler(14, ImageType::UINT_BUFFER, "hairStrandBuffer")
+    .sampler(13, ImageType::UINT_BUFFER, "hairStrandSegBuffer")
+    /* TODO(fclem) Pack thoses into one UBO. */
+    .push_constant(9, Type::INT, "hairStrandsRes")
+    .push_constant(10, Type::INT, "hairThicknessRes")
+    .push_constant(11, Type::FLOAT, "hairRadRoot")
+    .push_constant(12, Type::FLOAT, "hairRadTip")
+    .push_constant(13, Type::FLOAT, "hairRadShape")
+    .push_constant(14, Type::BOOL, "hairCloseTip")
+    .push_constant(15, Type::INT, "hairStrandOffset")
+    .push_constant(16, Type::VEC4, "hairDupliMatrix", 4)
+    .additional_info("draw_modelmat", "draw_resource_id");
 
 GPU_SHADER_CREATE_INFO(draw_pointcloud)
     .vertex_in(0, Type::VEC4, "pos")
     .vertex_in(1, Type::VEC3, "pos_inst")
     .vertex_in(2, Type::VEC3, "nor")
-    .define("UNIFORM_RESOURCE_ID")
-    .define("INSTANCED_ATTR")
-    .additional_info("draw_view_instanced_attr");
+    .additional_info("draw_modelmat_instanced_attr", "draw_resource_id_uniform");
+
+GPU_SHADER_CREATE_INFO(draw_volume).additional_info("draw_modelmat", "draw_resource_id_uniform");
 
 /** \} */

source/blender/draw/tests/shaders_test.cc

@@ -27,8 +27,6 @@ using namespace blender::draw::image_engine;
 
 static void test_workbench_glsl_shaders()
 {
-  workbench_shader_library_ensure();
-
   const int MAX_WPD = 6;
   WORKBENCH_PrivateData wpds[MAX_WPD];
 

source/blender/gpu/CMakeLists.txt

@@ -402,8 +402,16 @@ list(APPEND SRC ${glsl_source_list_file})
 list(APPEND INC ${CMAKE_CURRENT_BINARY_DIR})
 
 set(SHADER_CREATE_INFOS
-#../draw/engines/workbench/shaders/workbench_effect_cavity_info.hh
-#../draw/engines/workbench/shaders/workbench_prepass_info.hh
+../draw/engines/workbench/shaders/infos/workbench_composite_info.hh
+../draw/engines/workbench/shaders/infos/workbench_effect_antialiasing_info.hh
+../draw/engines/workbench/shaders/infos/workbench_effect_cavity_info.hh
+../draw/engines/workbench/shaders/infos/workbench_effect_dof_info.hh
+../draw/engines/workbench/shaders/infos/workbench_effect_outline_info.hh
+../draw/engines/workbench/shaders/infos/workbench_merge_infront_info.hh
+../draw/engines/workbench/shaders/infos/workbench_prepass_info.hh
+../draw/engines/workbench/shaders/infos/workbench_shadow_info.hh
+../draw/engines/workbench/shaders/infos/workbench_transparent_resolve_info.hh
+../draw/engines/workbench/shaders/infos/workbench_volume_info.hh
 ../draw/intern/shaders/draw_fullscreen_info.hh
 ../draw/intern/shaders/draw_object_infos_info.hh
 ../draw/intern/shaders/draw_view_info.hh

source/blender/gpu/GPU_shader.h

@@ -149,9 +149,14 @@ typedef enum {
 } GPUUniformBuiltin;
 
 typedef enum {
+  /** Deprecated */
   GPU_UNIFORM_BLOCK_VIEW = 0, /* viewBlock */
   GPU_UNIFORM_BLOCK_MODEL,    /* modelBlock */
   GPU_UNIFORM_BLOCK_INFO,     /* infoBlock */
+  /** New ones */
+  GPU_UNIFORM_BLOCK_DRW_VIEW,
+  GPU_UNIFORM_BLOCK_DRW_MODEL,
+  GPU_UNIFORM_BLOCK_DRW_INFOS,
 
   GPU_NUM_UNIFORM_BLOCKS, /* Special value, denotes number of builtin uniforms block. */
 } GPUUniformBlockBuiltin;

source/blender/gpu/intern/gpu_shader_create_info.cc

@@ -27,6 +27,8 @@
 #include "BLI_set.hh"
 #include "BLI_string_ref.hh"
 
+#include "GPU_capabilities.h"
+#include "GPU_platform.h"
 #include "GPU_shader.h"
 #include "GPU_texture.h"
 
@@ -58,6 +60,11 @@ void ShaderCreateInfo::finalize()
     /* Recursive. */
     const_cast<ShaderCreateInfo &>(info).finalize();
 
+#if 0 /* Enabled for debugging merging. TODO(fclem) exception handling and error reporting in \
+         console. */
+    std::cout << "Merging : " << info_name << " > " << name_ << std::endl;
+#endif
+
     interface_names_size_ += info.interface_names_size_;
 
     vertex_inputs_.extend(info.vertex_inputs_);
@@ -70,7 +77,7 @@ void ShaderCreateInfo::finalize()
 
     batch_resources_.extend(info.batch_resources_);
     pass_resources_.extend(info.pass_resources_);
-    typedef_sources_.extend(info.typedef_sources_);
+    typedef_sources_.extend_non_duplicates(info.typedef_sources_);
 
     validate(info);
 
@@ -194,6 +201,13 @@ void gpu_shader_create_info_init()
 #  include "gpu_shader_baked.hh"
 #endif
 
+  /* WORKAROUND: Replace draw_mesh info with the legacy one for systems that have problems with UBO
+   * indexing. */
+  if (GPU_type_matches(GPU_DEVICE_INTEL | GPU_DEVICE_INTEL_UHD, GPU_OS_ANY, GPU_DRIVER_ANY) ||
+      GPU_type_matches(GPU_DEVICE_ANY, GPU_OS_MAC, GPU_DRIVER_ANY) || GPU_crappy_amd_driver()) {
+    draw_modelmat = draw_modelmat_legacy;
+  }
+
   /* TEST */
   // gpu_shader_create_info_compile_all();
 }
@@ -213,25 +227,37 @@ void gpu_shader_create_info_exit()
 
 bool gpu_shader_create_info_compile_all()
 {
+  int success = 0;
+  int total = 0;
   for (ShaderCreateInfo *info : g_create_infos->values()) {
     if (info->do_static_compilation_) {
-      // printf("Compiling %s: ... \n", info->name_.c_str());
+      total++;
       GPUShader *shader = GPU_shader_create_from_info(
           reinterpret_cast<const GPUShaderCreateInfo *>(info));
       if (shader == nullptr) {
         printf("Compilation %s Failed\n", info->name_.c_str());
-        return false;
+      }
+      else {
+        success++;
       }
       GPU_shader_free(shader);
-      // printf("Success\n");
     }
   }
-  return true;
+  printf("===============================\n");
+  printf("Shader Test compilation result: \n");
+  printf("%d Total\n", total);
+  printf("%d Passed\n", success);
+  printf("%d Failed\n", total - success);
+  printf("===============================\n");
+  return success == total;
 }
 
 /* Runtime create infos are not registered in the dictionary and cannot be searched. */
 const GPUShaderCreateInfo *gpu_shader_create_info_get(const char *info_name)
 {
+  if (g_create_infos->contains(info_name) == false) {
+    printf("Error: Cannot find shader create info named \"%s\"\n", info_name);
+  }
   ShaderCreateInfo *info = g_create_infos->lookup(info_name);
   return reinterpret_cast<const GPUShaderCreateInfo *>(info);
 }

source/blender/gpu/intern/gpu_shader_create_info.hh

@@ -559,7 +559,9 @@ struct ShaderCreateInfo {
                         StringRefNull info_name1 = "",
                         StringRefNull info_name2 = "",
                         StringRefNull info_name3 = "",
-                        StringRefNull info_name4 = "")
+                        StringRefNull info_name4 = "",
+                        StringRefNull info_name5 = "",
+                        StringRefNull info_name6 = "")
   {
     additional_infos_.append(info_name0);
     if (!info_name1.is_empty()) {
@@ -574,6 +576,12 @@ struct ShaderCreateInfo {
     if (!info_name4.is_empty()) {
       additional_infos_.append(info_name4);
     }
+    if (!info_name5.is_empty()) {
+      additional_infos_.append(info_name5);
+    }
+    if (!info_name6.is_empty()) {
+      additional_infos_.append(info_name6);
+    }
     return *(Self *)this;
   }
 

source/blender/gpu/intern/gpu_shader_interface.hh

@@ -189,7 +189,7 @@ inline const char *ShaderInterface::builtin_uniform_name(GPUUniformBuiltin u)
     case GPU_UNIFORM_COLOR:
       return "color";
     case GPU_UNIFORM_BASE_INSTANCE:
-      return "baseInstance";
+      return "gpu_BaseInstance";
     case GPU_UNIFORM_RESOURCE_CHUNK:
       return "resourceChunk";
     case GPU_UNIFORM_RESOURCE_ID:
@@ -211,6 +211,13 @@ inline const char *ShaderInterface::builtin_uniform_block_name(GPUUniformBlockBu
       return "modelBlock";
     case GPU_UNIFORM_BLOCK_INFO:
       return "infoBlock";
+
+    case GPU_UNIFORM_BLOCK_DRW_VIEW:
+      return "drw_view";
+    case GPU_UNIFORM_BLOCK_DRW_MODEL:
+      return "drw_matrices";
+    case GPU_UNIFORM_BLOCK_DRW_INFOS:
+      return "drw_infos";
     default:
       return NULL;
   }

source/blender/gpu/opengl/gl_shader.cc

@@ -217,6 +217,8 @@ static void print_image_type(std::ostream &os,
     case ImageType::UINT_2D_ARRAY:
     case ImageType::SHADOW_2D:
     case ImageType::SHADOW_2D_ARRAY:
+    case ImageType::DEPTH_2D:
+    case ImageType::DEPTH_2D_ARRAY:
       os << "2D";
       break;
     case ImageType::FLOAT_3D:
@@ -232,6 +234,8 @@ static void print_image_type(std::ostream &os,
     case ImageType::UINT_CUBE_ARRAY:
     case ImageType::SHADOW_CUBE:
     case ImageType::SHADOW_CUBE_ARRAY:
+    case ImageType::DEPTH_CUBE:
+    case ImageType::DEPTH_CUBE_ARRAY:
       os << "Cube";
       break;
     default:
@@ -250,6 +254,8 @@ static void print_image_type(std::ostream &os,
     case ImageType::UINT_CUBE_ARRAY:
     case ImageType::SHADOW_2D_ARRAY:
     case ImageType::SHADOW_CUBE_ARRAY:
+    case ImageType::DEPTH_2D_ARRAY:
+    case ImageType::DEPTH_CUBE_ARRAY:
       os << "Array";
       break;
     default: