merged from master

18 files changed, 285 insertions, 430 deletions

diff --git a/source/blender/draw/engines/eevee/eevee_lightcache.c b/source/blender/draw/engines/eevee/eevee_lightcache.c
index 6d2577d5b78..a785d27c2db 100644
--- a/source/blender/draw/engines/eevee/eevee_lightcache.c
+++ b/source/blender/draw/engines/eevee/eevee_lightcache.c
@@ -1302,8 +1302,8 @@ void EEVEE_lightbake_job(void *custom_data, short *stop, short *do_update, float
   EEVEE_LightBake *lbake = (EEVEE_LightBake *)custom_data;
   Depsgraph *depsgraph = lbake->depsgraph;
 
-  DEG_graph_relations_update(depsgraph, lbake->bmain, lbake->scene, lbake->view_layer_input);
-  DEG_evaluate_on_framechange(lbake->bmain, depsgraph, lbake->frame);
+  DEG_graph_relations_update(depsgraph);
+  DEG_evaluate_on_framechange(depsgraph, lbake->frame);
 
   lbake->view_layer = DEG_get_evaluated_view_layer(depsgraph);
   lbake->stop = stop;
diff --git a/source/blender/draw/engines/eevee/eevee_occlusion.c b/source/blender/draw/engines/eevee/eevee_occlusion.c
index 9aae801197f..052fb485b19 100644
--- a/source/blender/draw/engines/eevee/eevee_occlusion.c
+++ b/source/blender/draw/engines/eevee/eevee_occlusion.c
@@ -78,7 +78,8 @@ int EEVEE_occlusion_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
     e_data.dummy_horizon_tx = DRW_texture_create_2d(1, 1, GPU_RGBA8, DRW_TEX_WRAP, pixel);
   }
 
-  if (scene_eval->eevee.flag & SCE_EEVEE_GTAO_ENABLED) {
+  if (scene_eval->eevee.flag & SCE_EEVEE_GTAO_ENABLED ||
+      stl->g_data->render_passes & EEVEE_RENDER_PASS_AO) {
     const float *viewport_size = DRW_viewport_size_get();
     const int fs_size[2] = {(int)viewport_size[0], (int)viewport_size[1]};
 
@@ -101,10 +102,11 @@ int EEVEE_occlusion_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
 
     common_data->ao_bounce_fac = (scene_eval->eevee.flag & SCE_EEVEE_GTAO_BOUNCE) ? 1.0f : 0.0f;
 
-    effects->gtao_horizons = DRW_texture_pool_query_2d(
+    effects->gtao_horizons_renderpass = DRW_texture_pool_query_2d(
         fs_size[0], fs_size[1], GPU_RGBA8, &draw_engine_eevee_type);
     GPU_framebuffer_ensure_config(
-        &fbl->gtao_fb, {GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(effects->gtao_horizons)});
+        &fbl->gtao_fb,
+        {GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(effects->gtao_horizons_renderpass)});
 
     if (G.debug_value == 6) {
       effects->gtao_horizons_debug = DRW_texture_pool_query_2d(
@@ -117,10 +119,15 @@ int EEVEE_occlusion_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
       effects->gtao_horizons_debug = NULL;
     }
 
+    effects->gtao_horizons = (scene_eval->eevee.flag & SCE_EEVEE_GTAO_ENABLED) ?
+                                 effects->gtao_horizons_renderpass :
+                                 e_data.dummy_horizon_tx;
+
     return EFFECT_GTAO | EFFECT_NORMAL_BUFFER;
   }
 
   /* Cleanup */
+  effects->gtao_horizons_renderpass = e_data.dummy_horizon_tx;
   effects->gtao_horizons = e_data.dummy_horizon_tx;
   GPU_FRAMEBUFFER_FREE_SAFE(fbl->gtao_fb);
   common_data->ao_settings = 0.0f;
@@ -136,45 +143,41 @@ void EEVEE_occlusion_output_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata
   EEVEE_PassList *psl = vedata->psl;
   EEVEE_EffectsInfo *effects = stl->effects;
 
-  const DRWContextState *draw_ctx = DRW_context_state_get();
-  const Scene *scene_eval = DEG_get_evaluated_scene(draw_ctx->depsgraph);
-
-  if (scene_eval->eevee.flag & SCE_EEVEE_GTAO_ENABLED) {
-    const eGPUTextureFormat texture_format = (tot_samples > 128) ? GPU_R32F : GPU_R16F;
+  const eGPUTextureFormat texture_format = (tot_samples > 128) ? GPU_R32F : GPU_R16F;
 
-    DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
-    const float clear[4] = {0.0f, 0.0f, 0.0f, 0.0f};
-
-    /* Should be enough precision for many samples. */
-    DRW_texture_ensure_fullscreen_2d(&txl->ao_accum, texture_format, 0);
+  DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
+  const float clear[4] = {0.0f, 0.0f, 0.0f, 0.0f};
 
-    GPU_framebuffer_ensure_config(&fbl->ao_accum_fb,
-                                  {GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(txl->ao_accum)});
+  /* Should be enough precision for many samples. */
+  DRW_texture_ensure_fullscreen_2d(&txl->ao_accum, texture_format, 0);
 
-    /* Clear texture. */
-    if (effects->taa_current_sample == 1) {
-      GPU_framebuffer_bind(fbl->ao_accum_fb);
-      GPU_framebuffer_clear_color(fbl->ao_accum_fb, clear);
-    }
+  GPU_framebuffer_ensure_config(&fbl->ao_accum_fb,
+                                {GPU_ATTACHMENT_NONE, GPU_ATTACHMENT_TEXTURE(txl->ao_accum)});
 
-    /* Accumulation pass */
-    DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD;
-    DRW_PASS_CREATE(psl->ao_accum_ps, state);
-    DRWShadingGroup *grp = DRW_shgroup_create(e_data.gtao_debug_sh, psl->ao_accum_ps);
-    DRW_shgroup_uniform_texture(grp, "utilTex", EEVEE_materials_get_util_tex());
-    DRW_shgroup_uniform_texture_ref(grp, "maxzBuffer", &txl->maxzbuffer);
-    DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
-    DRW_shgroup_uniform_texture_ref(grp, "normalBuffer", &effects->ssr_normal_input);
-    DRW_shgroup_uniform_texture_ref(grp, "horizonBuffer", &effects->gtao_horizons);
-    DRW_shgroup_uniform_block(grp, "common_block", sldata->common_ubo);
-    DRW_shgroup_uniform_block(grp, "renderpass_block", sldata->renderpass_ubo.combined);
-    DRW_shgroup_call(grp, DRW_cache_fullscreen_quad_get(), NULL);
+  /* Clear texture. */
+  if (effects->taa_current_sample == 1) {
+    GPU_framebuffer_bind(fbl->ao_accum_fb);
+    GPU_framebuffer_clear_color(fbl->ao_accum_fb, clear);
   }
-  else {
-    /* Cleanup to release memory */
-    DRW_TEXTURE_FREE_SAFE(txl->ao_accum);
-    GPU_FRAMEBUFFER_FREE_SAFE(fbl->ao_accum_fb);
+
+  /* Clear texture. */
+  if (DRW_state_is_image_render() || effects->taa_current_sample == 1) {
+    GPU_framebuffer_bind(fbl->ao_accum_fb);
+    GPU_framebuffer_clear_color(fbl->ao_accum_fb, clear);
   }
+
+  /* Accumulation pass */
+  DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_ADD;
+  DRW_PASS_CREATE(psl->ao_accum_ps, state);
+  DRWShadingGroup *grp = DRW_shgroup_create(e_data.gtao_debug_sh, psl->ao_accum_ps);
+  DRW_shgroup_uniform_texture(grp, "utilTex", EEVEE_materials_get_util_tex());
+  DRW_shgroup_uniform_texture_ref(grp, "maxzBuffer", &txl->maxzbuffer);
+  DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
+  DRW_shgroup_uniform_texture_ref(grp, "normalBuffer", &effects->ssr_normal_input);
+  DRW_shgroup_uniform_texture_ref(grp, "horizonBuffer", &effects->gtao_horizons_renderpass);
+  DRW_shgroup_uniform_block(grp, "common_block", sldata->common_ubo);
+  DRW_shgroup_uniform_block(grp, "renderpass_block", sldata->renderpass_ubo.combined);
+  DRW_shgroup_call(grp, DRW_cache_fullscreen_quad_get(), NULL);
 }
 
 void EEVEE_occlusion_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
@@ -225,7 +228,7 @@ void EEVEE_occlusion_cache_init(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
       DRW_shgroup_uniform_texture_ref(grp, "maxzBuffer", &txl->maxzbuffer);
       DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
       DRW_shgroup_uniform_texture_ref(grp, "normalBuffer", &effects->ssr_normal_input);
-      DRW_shgroup_uniform_texture_ref(grp, "horizonBuffer", &effects->gtao_horizons);
+      DRW_shgroup_uniform_texture_ref(grp, "horizonBuffer", &effects->gtao_horizons_renderpass);
       DRW_shgroup_uniform_block(grp, "common_block", sldata->common_ubo);
       DRW_shgroup_uniform_block(grp, "renderpass_block", sldata->renderpass_ubo.combined);
       DRW_shgroup_call(grp, quad, NULL);
diff --git a/source/blender/draw/engines/eevee/eevee_private.h b/source/blender/draw/engines/eevee/eevee_private.h
index 1e2de521cdf..40d7676c38c 100644
--- a/source/blender/draw/engines/eevee/eevee_private.h
+++ b/source/blender/draw/engines/eevee/eevee_private.h
@@ -679,8 +679,9 @@ typedef struct EEVEE_EffectsInfo {
   struct DRWView *taa_view;
   /* Ambient Occlusion */
   int ao_depth_layer;
-  struct GPUTexture *ao_src_depth;  /* pointer copy */
-  struct GPUTexture *gtao_horizons; /* Textures from pool */
+  struct GPUTexture *ao_src_depth;             /* pointer copy */
+  struct GPUTexture *gtao_horizons;            /* Textures from pool */
+  struct GPUTexture *gtao_horizons_renderpass; /* Texture when rendering render pass */
   struct GPUTexture *gtao_horizons_debug;
   /* Motion Blur */
   float current_ndc_to_world[4][4];
diff --git a/source/blender/draw/engines/eevee/eevee_render.c b/source/blender/draw/engines/eevee/eevee_render.c
index 21a4013e309..65a856c39e1 100644
--- a/source/blender/draw/engines/eevee/eevee_render.c
+++ b/source/blender/draw/engines/eevee/eevee_render.c
@@ -359,11 +359,6 @@ static void eevee_render_result_occlusion(RenderLayer *rl,
                                           EEVEE_Data *vedata,
                                           EEVEE_ViewLayerData *sldata)
 {
-  if ((vedata->stl->effects->enabled_effects & EFFECT_GTAO) == 0) {
-    /* AO is not enabled. */
-    return;
-  }
-
   if ((vedata->stl->g_data->render_passes & EEVEE_RENDER_PASS_AO) != 0) {
     EEVEE_renderpasses_postprocess(sldata, vedata, EEVEE_RENDER_PASS_AO);
     eevee_render_color_result(
diff --git a/source/blender/draw/engines/eevee/eevee_renderpasses.c b/source/blender/draw/engines/eevee/eevee_renderpasses.c
index 089d8b7a287..55fe5882211 100644
--- a/source/blender/draw/engines/eevee/eevee_renderpasses.c
+++ b/source/blender/draw/engines/eevee/eevee_renderpasses.c
@@ -90,12 +90,8 @@ void EEVEE_renderpasses_init(EEVEE_Data *vedata)
   if (v3d) {
     const Scene *scene = draw_ctx->scene;
     eViewLayerEEVEEPassType render_pass = v3d->shading.render_pass;
-    if (render_pass == EEVEE_RENDER_PASS_AO &&
-        ((scene->eevee.flag & SCE_EEVEE_GTAO_ENABLED) == 0)) {
-      render_pass = EEVEE_RENDER_PASS_COMBINED;
-    }
-    else if (render_pass == EEVEE_RENDER_PASS_BLOOM &&
-             ((scene->eevee.flag & SCE_EEVEE_BLOOM_ENABLED) == 0)) {
+    if (render_pass == EEVEE_RENDER_PASS_BLOOM &&
+        ((scene->eevee.flag & SCE_EEVEE_BLOOM_ENABLED) == 0)) {
       render_pass = EEVEE_RENDER_PASS_COMBINED;
     }
     g_data->render_passes = render_pass;
@@ -392,8 +388,6 @@ void EEVEE_renderpasses_draw(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
       ((stl->g_data->render_passes & EEVEE_RENDERPASSES_LIGHT_PASS) != 0) ?
           (stl->g_data->render_passes & EEVEE_RENDERPASSES_LIGHT_PASS) :
           stl->g_data->render_passes;
-  const DRWContextState *draw_ctx = DRW_context_state_get();
-  const Scene *scene_eval = DEG_get_evaluated_scene(draw_ctx->depsgraph);
 
   bool is_valid = (render_pass & EEVEE_RENDERPASSES_ALL) > 0;
   bool needs_color_transfer = (render_pass & EEVEE_RENDERPASSES_COLOR_PASS) > 0 &&
@@ -405,12 +399,6 @@ void EEVEE_renderpasses_draw(EEVEE_ViewLayerData *sldata, EEVEE_Data *vedata)
     is_valid = false;
   }
 
-  /* When SSS isn't available, but the pass is requested, we mark it as invalid */
-  if ((render_pass & EEVEE_RENDER_PASS_AO) != 0 &&
-      (scene_eval->eevee.flag & SCE_EEVEE_GTAO_ENABLED) == 0) {
-    is_valid = false;
-  }
-
   const int current_sample = stl->effects->taa_current_sample;
   const int total_samples = stl->effects->taa_total_sample;
   if ((render_pass & EEVEE_RENDERPASSES_POST_PROCESS_ON_FIRST_SAMPLE) &&
@@ -462,10 +450,10 @@ void EEVEE_renderpasses_draw_debug(EEVEE_Data *vedata)
       tx = txl->color_double_buffer;
       break;
     case 6:
-      tx = effects->gtao_horizons;
+      tx = effects->gtao_horizons_renderpass;
       break;
     case 7:
-      tx = effects->gtao_horizons;
+      tx = effects->gtao_horizons_renderpass;
       break;
     case 8:
       tx = effects->sss_irradiance;
diff --git a/source/blender/draw/engines/overlay/shaders/edit_curve_handle_geom.glsl b/source/blender/draw/engines/overlay/shaders/edit_curve_handle_geom.glsl
index a400aadb052..9311542a79e 100644
--- a/source/blender/draw/engines/overlay/shaders/edit_curve_handle_geom.glsl
+++ b/source/blender/draw/engines/overlay/shaders/edit_curve_handle_geom.glsl
@@ -58,7 +58,7 @@ void main()
   if ((curveHandleDisplay != CURVE_HANDLE_ALL) && (!handle_selected)) {
     /* Nurbs must show the handles always. */
     bool is_u_segment = (((vertFlag[1] ^ vertFlag[0]) & EVEN_U_BIT) != 0);
-    if (!is_u_segment) {
+    if ((!is_u_segment) && (color_id <= 4)) {
       return;
     }
   }
diff --git a/source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl
index 5818d8eca52..a6161d36a07 100644
--- a/source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl
+++ b/source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl
@@ -73,7 +73,7 @@ void main()
   }
 
 #ifdef USE_POINTS
-  gl_PointSize = sizeVertex * 2.0;
+  gl_PointSize = sizeVertexGpencil * 2.0;
 
   if (is_point_dimmed) {
     finalColor.rgb = clamp(colorUnselect.rgb + vec3(0.3), 0.0, 1.0);
diff --git a/source/blender/draw/engines/workbench/shaders/workbench_effect_dof_frag.glsl b/source/blender/draw/engines/workbench/shaders/workbench_effect_dof_frag.glsl
index 71816f6ff6e..899ada852f9 100644
--- a/source/blender/draw/engines/workbench/shaders/workbench_effect_dof_frag.glsl
+++ b/source/blender/draw/engines/workbench/shaders/workbench_effect_dof_frag.glsl
@@ -1,4 +1,4 @@
-
+#pragma BLENDER_REQUIRE(common_view_lib.glsl)
 #pragma BLENDER_REQUIRE(common_math_lib.glsl)
 
 /**
diff --git a/source/blender/draw/engines/workbench/workbench_shader.c b/source/blender/draw/engines/workbench/workbench_shader.c
index 9cc5087bd36..af3b5d31b2b 100644
--- a/source/blender/draw/engines/workbench/workbench_shader.c
+++ b/source/blender/draw/engines/workbench/workbench_shader.c
@@ -380,24 +380,26 @@ void workbench_shader_depth_of_field_get(GPUShader **prepare_sh,
                                          GPUShader **resolve_sh)
 {
   if (e_data.dof_prepare_sh == NULL) {
-    char *frag = BLI_string_joinN(datatoc_common_view_lib_glsl,
-                                  datatoc_workbench_effect_dof_frag_glsl);
-    e_data.dof_prepare_sh = DRW_shader_create_fullscreen(frag, "#define PREPARE\n");
-    e_data.dof_downsample_sh = DRW_shader_create_fullscreen(frag, "#define DOWNSAMPLE\n");
+    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(frag,
-                                                           "#define FLATTEN_VERTICAL\n");
-    e_data.dof_flatten_h_sh = DRW_shader_create_fullscreen(frag,
-                                                           "#define FLATTEN_HORIZONTAL\n");
-    e_data.dof_dilate_v_sh = DRW_shader_create_fullscreen(frag,
-                                                          "#define DILATE_VERTICAL\n");
-    e_data.dof_dilate_h_sh = DRW_shader_create_fullscreen(frag,
-                                                          "#define DILATE_HORIZONTAL\n");
+    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(frag, "#define BLUR1\n");
-    e_data.dof_blur2_sh = DRW_shader_create_fullscreen(frag, "#define BLUR2\n");
-    e_data.dof_resolve_sh = DRW_shader_create_fullscreen(frag, "#define RESOLVE\n");
-    MEM_freeN(frag);
+    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;
diff --git a/source/blender/draw/intern/DRW_render.h b/source/blender/draw/intern/DRW_render.h
index 956bddfb357..63625fae185 100644
--- a/source/blender/draw/intern/DRW_render.h
+++ b/source/blender/draw/intern/DRW_render.h
@@ -208,27 +208,44 @@ typedef void (*GPUMaterialEvalCallbackFn)(struct GPUMaterial *mat,
                                           const char **defines);
 #endif
 
-struct GPUShader *DRW_shader_create(const char *vert,
-                                    const char *geom,
-                                    const char *frag,
-                                    const char *defines);
-struct GPUShader *DRW_shader_create_with_lib(
-    const char *vert, const char *geom, const char *frag, const char *lib, const char *defines);
-struct GPUShader *DRW_shader_create_with_shaderlib(const char *vert,
-                                                   const char *geom,
-                                                   const char *frag,
-                                                   const DRWShaderLibrary *lib,
-                                                   const char *defines);
+struct GPUShader *DRW_shader_create_ex(
+    const char *vert, const char *geom, const char *frag, const char *defines, const char *func);
+struct GPUShader *DRW_shader_create_with_lib_ex(const char *vert,
+                                                const char *geom,
+                                                const char *frag,
+                                                const char *lib,
+                                                const char *defines,
+                                                const char *func);
+struct GPUShader *DRW_shader_create_with_shaderlib_ex(const char *vert,
+                                                      const char *geom,
+                                                      const char *frag,
+                                                      const DRWShaderLibrary *lib,
+                                                      const char *defines,
+                                                      const char *func);
 struct GPUShader *DRW_shader_create_with_transform_feedback(const char *vert,
                                                             const char *geom,
                                                             const char *defines,
                                                             const eGPUShaderTFBType prim_type,
                                                             const char **varying_names,
                                                             const int varying_count);
-struct GPUShader *DRW_shader_create_fullscreen(const char *frag, const char *defines);
-struct GPUShader *DRW_shader_create_fullscreen_with_shaderlib(const char *frag,
-                                                              const DRWShaderLibrary *lib,
-                                                              const char *defines);
+struct GPUShader *DRW_shader_create_fullscreen_ex(const char *frag,
+                                                  const char *defines,
+                                                  const char *func);
+struct GPUShader *DRW_shader_create_fullscreen_with_shaderlib_ex(const char *frag,
+                                                                 const DRWShaderLibrary *lib,
+                                                                 const char *defines,
+                                                                 const char *func);
+#define DRW_shader_create(vert, geom, frag, defines) \
+  DRW_shader_create_ex(vert, geom, frag, defines, __func__)
+#define DRW_shader_create_with_lib(vert, geom, frag, lib, defines) \
+  DRW_shader_create_with_lib_ex(vert, geom, frag, lib, defines, __func__)
+#define DRW_shader_create_with_shaderlib(vert, geom, frag, lib, defines) \
+  DRW_shader_create_with_shaderlib_ex(vert, geom, frag, lib, defines, __func__)
+#define DRW_shader_create_fullscreen(frag, defines) \
+  DRW_shader_create_fullscreen_ex(frag, defines, __func__)
+#define DRW_shader_create_fullscreen_with_shaderlib(frag, lib, defines) \
+  DRW_shader_create_fullscreen_with_shaderlib_ex(frag, lib, defines, __func__)
+
 struct GPUMaterial *DRW_shader_find_from_world(struct World *wo,
                                                const void *engine_type,
                                                const int options,
@@ -344,6 +361,10 @@ typedef enum {
 
 #define DRW_STATE_DEFAULT \
   (DRW_STATE_WRITE_DEPTH | DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS_EQUAL)
+#define DRW_STATE_BLEND_ENABLED \
+  (DRW_STATE_BLEND_ADD | DRW_STATE_BLEND_ADD_FULL | DRW_STATE_BLEND_ALPHA | \
+   DRW_STATE_BLEND_ALPHA_PREMUL | DRW_STATE_BLEND_BACKGROUND | DRW_STATE_BLEND_OIT | \
+   DRW_STATE_BLEND_MUL | DRW_STATE_BLEND_SUB | DRW_STATE_BLEND_CUSTOM | DRW_STATE_LOGIC_INVERT)
 #define DRW_STATE_RASTERIZER_ENABLED \
   (DRW_STATE_WRITE_DEPTH | DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_STENCIL | \
    DRW_STATE_WRITE_STENCIL_SHADOW_PASS | DRW_STATE_WRITE_STENCIL_SHADOW_FAIL)
@@ -718,7 +739,6 @@ bool DRW_state_draw_background(void);
 
 /* Avoid too many lookups while drawing */
 typedef struct DRWContextState {
-
   struct ARegion *region;    /* 'CTX_wm_region(C)' */
   struct RegionView3D *rv3d; /* 'CTX_wm_region_view3d(C)' */
   struct View3D *v3d;        /* 'CTX_wm_view3d(C)' */
diff --git a/source/blender/draw/intern/draw_common.c b/source/blender/draw/intern/draw_common.c
index f0d73d5bb84..aac9af088de 100644
--- a/source/blender/draw/intern/draw_common.c
+++ b/source/blender/draw/intern/draw_common.c
@@ -187,6 +187,7 @@ void DRW_globals_update(void)
   /* M_SQRT2 to be at least the same size of the old square */
   gb->sizeVertex = U.pixelsize *
                    (max_ff(1.0f, UI_GetThemeValuef(TH_VERTEX_SIZE) * (float)M_SQRT2 / 2.0f));
+  gb->sizeVertexGpencil = U.pixelsize * UI_GetThemeValuef(TH_GP_VERTEX_SIZE);
   gb->sizeFaceDot = U.pixelsize * UI_GetThemeValuef(TH_FACEDOT_SIZE);
   gb->sizeEdge = U.pixelsize * (1.0f / 2.0f); /* TODO Theme */
   gb->sizeEdgeFix = U.pixelsize * (0.5f + 2.0f * (2.0f * (gb->sizeEdge * (float)M_SQRT1_2)));
diff --git a/source/blender/draw/intern/draw_common.h b/source/blender/draw/intern/draw_common.h
index 6060dce47ac..d6402127e5e 100644
--- a/source/blender/draw/intern/draw_common.h
+++ b/source/blender/draw/intern/draw_common.h
@@ -150,8 +150,7 @@ typedef struct GlobalsUboStorage {
   float sizeObjectCenter, sizeLightCenter, sizeLightCircle, sizeLightCircleShadow;
   float sizeVertex, sizeEdge, sizeEdgeFix, sizeFaceDot;
   float sizeChecker;
-
-  float pad_globalsBlock;
+  float sizeVertexGpencil;
 } GlobalsUboStorage;
 /* Keep in sync with globalsBlock in shaders */
 BLI_STATIC_ASSERT_ALIGN(GlobalsUboStorage, 16)
diff --git a/source/blender/draw/intern/draw_manager.c b/source/blender/draw/intern/draw_manager.c
index e436424b460..d90d7d36ebc 100644
--- a/source/blender/draw/intern/draw_manager.c
+++ b/source/blender/draw/intern/draw_manager.c
@@ -1595,8 +1595,7 @@ void DRW_draw_render_loop_offscreen(struct Depsgraph *depsgraph,
     GPU_clear_color(0.0f, 0.0f, 0.0f, 1.0f);
     GPU_clear(GPU_COLOR_BIT);
     /* Premult Alpha over black background. */
-    GPU_blend_set_func(GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
-    GPU_blend(true);
+    GPU_blend(GPU_BLEND_ALPHA_PREMULT);
   }
 
   GPU_matrix_identity_set();
@@ -1606,9 +1605,7 @@ void DRW_draw_render_loop_offscreen(struct Depsgraph *depsgraph,
 
   if (draw_background) {
     /* Reset default. */
-    GPU_blend_set_func_separate(
-        GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
-    GPU_blend(false);
+    GPU_blend(GPU_BLEND_NONE);
   }
 
   /* Free temporary viewport. */
@@ -1758,8 +1755,6 @@ void DRW_render_to_image(RenderEngine *engine, struct Depsgraph *depsgraph)
     BLI_rcti_init(&render_rect, 0, size[0], 0, size[1]);
   }
 
-  /* Set the default Blender draw state */
-  GPU_state_init();
   /* Reset state before drawing */
   DRW_state_reset();
 
@@ -2475,7 +2470,7 @@ void DRW_draw_depth_object(
                                                           GPU_SHADER_CFG_DEFAULT;
       GPU_batch_program_set_builtin_with_config(batch, GPU_SHADER_3D_DEPTH_ONLY, sh_cfg);
       if (world_clip_planes != NULL) {
-        GPU_batch_uniform_4fv_array(batch, "WorldClipPlanes", 6, world_clip_planes[0]);
+        GPU_batch_uniform_4fv_array(batch, "WorldClipPlanes", 6, world_clip_planes);
       }
 
       GPU_batch_draw(batch);
@@ -2788,8 +2783,6 @@ void DRW_opengl_context_create(void)
   if (!G.background) {
     immActivate();
   }
-  /* Set default Blender OpenGL state */
-  GPU_state_init();
   /* So we activate the window's one afterwards. */
   wm_window_reset_drawable();
 }
diff --git a/source/blender/draw/intern/draw_manager_exec.c b/source/blender/draw/intern/draw_manager_exec.c
index b931bdd0cbe..44e2eec04d9 100644
--- a/source/blender/draw/intern/draw_manager_exec.c
+++ b/source/blender/draw/intern/draw_manager_exec.c
@@ -31,8 +31,8 @@
 
 #include "GPU_extensions.h"
 #include "GPU_platform.h"
-#include "intern/gpu_primitive_private.h"
-#include "intern/gpu_shader_private.h"
+#include "GPU_shader.h"
+#include "GPU_state.h"
 
 #ifdef USE_GPU_SELECT
 #  include "GPU_select.h"
@@ -82,309 +82,169 @@ void drw_state_set(DRWState state)
     return;
   }
 
-#define CHANGED_TO(f) \
-  ((DST.state_lock & (f)) ? \
-       0 : \
-       (((DST.state & (f)) ? ((state & (f)) ? 0 : -1) : ((state & (f)) ? 1 : 0))))
+  eGPUWriteMask write_mask = 0;
+  eGPUBlend blend = 0;
+  eGPUFaceCullTest culling_test = 0;
+  eGPUDepthTest depth_test = 0;
+  eGPUStencilTest stencil_test = 0;
+  eGPUStencilOp stencil_op = 0;
+  eGPUProvokingVertex provoking_vert = 0;
 
-#define CHANGED_ANY(f) (((DST.state & (f)) != (state & (f))) && ((DST.state_lock & (f)) == 0))
-
-#define CHANGED_ANY_STORE_VAR(f, enabled) \
-  (((DST.state & (f)) != (enabled = (state & (f)))) && (((DST.state_lock & (f)) == 0)))
-
-  /* Depth Write */
-  {
-    int test;
-    if ((test = CHANGED_TO(DRW_STATE_WRITE_DEPTH))) {
-      GPU_depth_mask(test == 1);
-    }
+  if (state & DRW_STATE_WRITE_DEPTH) {
+    write_mask |= GPU_WRITE_DEPTH;
   }
-
-  /* Stencil Write */
-  {
-    DRWState test;
-    if (CHANGED_ANY_STORE_VAR(DRW_STATE_WRITE_STENCIL_ENABLED, test)) {
-      /* Stencil Write */
-      if (test) {
-        glStencilMask(0xFF);
-        switch (test) {
-          case DRW_STATE_WRITE_STENCIL:
-            glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
-            break;
-          case DRW_STATE_WRITE_STENCIL_SHADOW_PASS:
-            glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_INCR_WRAP);
-            glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_DECR_WRAP);
-            break;
-          case DRW_STATE_WRITE_STENCIL_SHADOW_FAIL:
-            glStencilOpSeparate(GL_BACK, GL_KEEP, GL_DECR_WRAP, GL_KEEP);
-            glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_INCR_WRAP, GL_KEEP);
-            break;
-          default:
-            BLI_assert(0);
-        }
-      }
-      else {
-        glStencilMask(0x00);
-        glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
-      }
-    }
+  if (state & DRW_STATE_WRITE_COLOR) {
+    write_mask |= GPU_WRITE_COLOR;
   }
 
-  /* Color Write */
-  {
-    int test;
-    if ((test = CHANGED_TO(DRW_STATE_WRITE_COLOR))) {
-      if (test == 1) {
-        GPU_color_mask(true, true, true, true);
-      }
-      else {
-        GPU_color_mask(false, false, false, false);
-      }
-    }
+  switch (state & (DRW_STATE_CULL_BACK | DRW_STATE_CULL_FRONT)) {
+    case DRW_STATE_CULL_BACK:
+      culling_test = GPU_CULL_BACK;
+      break;
+    case DRW_STATE_CULL_FRONT:
+      culling_test = GPU_CULL_FRONT;
+      break;
+    default:
+      culling_test = GPU_CULL_NONE;
+      break;
   }
 
-  /* Raster Discard */
-  {
-    if (CHANGED_ANY(DRW_STATE_RASTERIZER_ENABLED)) {
-      if ((state & DRW_STATE_RASTERIZER_ENABLED) != 0) {
-        glDisable(GL_RASTERIZER_DISCARD);
-      }
-      else {
-        glEnable(GL_RASTERIZER_DISCARD);
-      }
-    }
+  switch (state & DRW_STATE_DEPTH_TEST_ENABLED) {
+    case DRW_STATE_DEPTH_LESS:
+      depth_test = GPU_DEPTH_LESS;
+      break;
+    case DRW_STATE_DEPTH_LESS_EQUAL:
+      depth_test = GPU_DEPTH_LESS_EQUAL;
+      break;
+    case DRW_STATE_DEPTH_EQUAL:
+      depth_test = GPU_DEPTH_EQUAL;
+      break;
+    case DRW_STATE_DEPTH_GREATER:
+      depth_test = GPU_DEPTH_GREATER;
+      break;
+    case DRW_STATE_DEPTH_GREATER_EQUAL:
+      depth_test = GPU_DEPTH_GREATER_EQUAL;
+      break;
+    case DRW_STATE_DEPTH_ALWAYS:
+      depth_test = GPU_DEPTH_ALWAYS;
+      break;
+    default:
+      depth_test = GPU_DEPTH_NONE;
+      break;
   }
 
-  /* Cull */
-  {
-    DRWState test;
-    if (CHANGED_ANY_STORE_VAR(DRW_STATE_CULL_BACK | DRW_STATE_CULL_FRONT, test)) {
-      if (test) {
-        glEnable(GL_CULL_FACE);
-
-        if ((state & DRW_STATE_CULL_BACK) != 0) {
-          glCullFace(GL_BACK);
-        }
-        else if ((state & DRW_STATE_CULL_FRONT) != 0) {
-          glCullFace(GL_FRONT);
-        }
-        else {
-          BLI_assert(0);
-        }
-      }
-      else {
-        glDisable(GL_CULL_FACE);
-      }
-    }
+  switch (state & DRW_STATE_WRITE_STENCIL_ENABLED) {
+    case DRW_STATE_WRITE_STENCIL:
+      stencil_op = GPU_STENCIL_OP_REPLACE;
+      GPU_stencil_write_mask_set(0xFF);
+      break;
+    case DRW_STATE_WRITE_STENCIL_SHADOW_PASS:
+      stencil_op = GPU_STENCIL_OP_COUNT_DEPTH_PASS;
+      GPU_stencil_write_mask_set(0xFF);
+      break;
+    case DRW_STATE_WRITE_STENCIL_SHADOW_FAIL:
+      stencil_op = GPU_STENCIL_OP_COUNT_DEPTH_FAIL;
+      GPU_stencil_write_mask_set(0xFF);
+      break;
+    default:
+      stencil_op = GPU_STENCIL_OP_NONE;
+      GPU_stencil_write_mask_set(0x00);
+      break;
   }
 
-  /* Depth Test */
-  {
-    DRWState test;
-    if (CHANGED_ANY_STORE_VAR(DRW_STATE_DEPTH_TEST_ENABLED, test)) {
-      if (test) {
-        glEnable(GL_DEPTH_TEST);
-
-        switch (test) {
-          case DRW_STATE_DEPTH_LESS:
-            glDepthFunc(GL_LESS);
-            break;
-          case DRW_STATE_DEPTH_LESS_EQUAL:
-            glDepthFunc(GL_LEQUAL);
-            break;
-          case DRW_STATE_DEPTH_EQUAL:
-            glDepthFunc(GL_EQUAL);
-            break;
-          case DRW_STATE_DEPTH_GREATER:
-            glDepthFunc(GL_GREATER);
-            break;
-          case DRW_STATE_DEPTH_GREATER_EQUAL:
-            glDepthFunc(GL_GEQUAL);
-            break;
-          case DRW_STATE_DEPTH_ALWAYS:
-            glDepthFunc(GL_ALWAYS);
-            break;
-          default:
-            BLI_assert(0);
-        }
-      }
-      else {
-        glDisable(GL_DEPTH_TEST);
-      }
-    }
+  switch (state & DRW_STATE_STENCIL_TEST_ENABLED) {
+    case DRW_STATE_STENCIL_ALWAYS:
+      stencil_test = GPU_STENCIL_ALWAYS;
+      break;
+    case DRW_STATE_STENCIL_EQUAL:
+      stencil_test = GPU_STENCIL_EQUAL;
+      break;
+    case DRW_STATE_STENCIL_NEQUAL:
+      stencil_test = GPU_STENCIL_NEQUAL;
+      break;
+    default:
+      stencil_test = GPU_STENCIL_NONE;
+      break;
   }
 
-  /* Stencil Test */
-  {
-    int test;
-    if (CHANGED_ANY_STORE_VAR(DRW_STATE_STENCIL_TEST_ENABLED, test)) {
-      if (test) {
-        glEnable(GL_STENCIL_TEST);
-      }
-      else {
-        glDisable(GL_STENCIL_TEST);
-      }
-    }
+  switch (state & DRW_STATE_BLEND_ENABLED) {
+    case DRW_STATE_BLEND_ADD:
+      blend = GPU_BLEND_ADDITIVE;
+      break;
+    case DRW_STATE_BLEND_ADD_FULL:
+      blend = GPU_BLEND_ADDITIVE_PREMULT;
+      break;
+    case DRW_STATE_BLEND_ALPHA:
+      blend = GPU_BLEND_ALPHA;
+      break;
+    case DRW_STATE_BLEND_ALPHA_PREMUL:
+      blend = GPU_BLEND_ALPHA_PREMULT;
+      break;
+    case DRW_STATE_BLEND_BACKGROUND:
+      blend = GPU_BLEND_BACKGROUND;
+      break;
+    case DRW_STATE_BLEND_OIT:
+      blend = GPU_BLEND_OIT;
+      break;
+    case DRW_STATE_BLEND_MUL:
+      blend = GPU_BLEND_MULTIPLY;
+      break;
+    case DRW_STATE_BLEND_SUB:
+      blend = GPU_BLEND_SUBTRACT;
+      break;
+    case DRW_STATE_BLEND_CUSTOM:
+      blend = GPU_BLEND_CUSTOM;
+      break;
+    case DRW_STATE_LOGIC_INVERT:
+      blend = GPU_BLEND_INVERT;
+      break;
+    default:
+      blend = GPU_BLEND_NONE;
+      break;
   }
 
-  /* Blending (all buffer) */
-  {
-    int test;
-    if (CHANGED_ANY_STORE_VAR(DRW_STATE_BLEND_ALPHA | DRW_STATE_BLEND_ALPHA_PREMUL |
-                                  DRW_STATE_BLEND_ADD | DRW_STATE_BLEND_MUL |
-                                  DRW_STATE_BLEND_ADD_FULL | DRW_STATE_BLEND_OIT |
-                                  DRW_STATE_BLEND_BACKGROUND | DRW_STATE_BLEND_CUSTOM |
-                                  DRW_STATE_LOGIC_INVERT | DRW_STATE_BLEND_SUB,
-                              test)) {
-      if (test) {
-        glEnable(GL_BLEND);
-
-        switch (test) {
-          case DRW_STATE_BLEND_ALPHA:
-            glBlendFuncSeparate(GL_SRC_ALPHA,
-                                GL_ONE_MINUS_SRC_ALPHA, /* RGB */
-                                GL_ONE,
-                                GL_ONE_MINUS_SRC_ALPHA); /* Alpha */
-            break;
-          case DRW_STATE_BLEND_BACKGROUND:
-            /* Special blend to add color under and multiply dst by alpha. */
-            glBlendFuncSeparate(GL_ONE_MINUS_DST_ALPHA,
-                                GL_SRC_ALPHA, /* RGB */
-                                GL_ZERO,
-                                GL_SRC_ALPHA); /* Alpha */
-            break;
-          case DRW_STATE_BLEND_ALPHA_PREMUL:
-            glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-            break;
-          case DRW_STATE_BLEND_MUL:
-            glBlendFunc(GL_DST_COLOR, GL_ZERO);
-            break;
-          case DRW_STATE_BLEND_OIT:
-            glBlendFuncSeparate(GL_ONE,
-                                GL_ONE, /* RGB */
-                                GL_ZERO,
-                                GL_ONE_MINUS_SRC_ALPHA); /* Alpha */
-            break;
-          case DRW_STATE_BLEND_ADD:
-            /* Do not let alpha accumulate but premult the source RGB by it. */
-            glBlendFuncSeparate(GL_SRC_ALPHA,
-                                GL_ONE, /* RGB */
-                                GL_ZERO,
-                                GL_ONE); /* Alpha */
-            break;
-          case DRW_STATE_BLEND_ADD_FULL:
-            /* Let alpha accumulate. */
-            glBlendFunc(GL_ONE, GL_ONE);
-            break;
-          case DRW_STATE_BLEND_SUB:
-            glBlendFunc(GL_ONE, GL_ONE);
-            break;
-          case DRW_STATE_BLEND_CUSTOM:
-            /* Custom blend parameters using dual source blending.
-             * Can only be used with one Draw Buffer. */
-            glBlendFunc(GL_ONE, GL_SRC1_COLOR);
-            break;
-          case DRW_STATE_LOGIC_INVERT:
-            /* Replace logic op by blend func to support floating point framebuffer. */
-            glBlendFuncSeparate(GL_ONE_MINUS_DST_COLOR,
-                                GL_ZERO, /* RGB */
-                                GL_ZERO,
-                                GL_ONE); /* Alpha */
-            break;
-          default:
-            BLI_assert(0);
-        }
+  GPU_state_set(
+      write_mask, blend, culling_test, depth_test, stencil_test, stencil_op, provoking_vert);
 
-        if (test == DRW_STATE_BLEND_SUB) {
-          glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
-        }
-        else {
-          glBlendEquation(GL_FUNC_ADD);
-        }
-      }
-      else {
-        glDisable(GL_BLEND);
-        glBlendFunc(GL_ONE, GL_ONE); /* Don't multiply incoming color by alpha. */
-      }
-    }
+  if (state & DRW_STATE_SHADOW_OFFSET) {
+    GPU_shadow_offset(true);
   }
-
-  /* Shadow Bias */
-  {
-    int test;
-    if ((test = CHANGED_TO(DRW_STATE_SHADOW_OFFSET))) {
-      if (test == 1) {
-        glEnable(GL_POLYGON_OFFSET_FILL);
-        glEnable(GL_POLYGON_OFFSET_LINE);
-        /* 2.0 Seems to be the lowest possible slope bias that works in every case. */
-        glPolygonOffset(2.0f, 1.0f);
-      }
-      else {
-        glDisable(GL_POLYGON_OFFSET_FILL);
-        glDisable(GL_POLYGON_OFFSET_LINE);
-      }
-    }
+  else {
+    GPU_shadow_offset(false);
   }
 
-  /* In Front objects selection */
-  {
-    int test;
-    if ((test = CHANGED_TO(DRW_STATE_IN_FRONT_SELECT))) {
-      if (test == 1) {
-        /* XXX `GPU_depth_range` is not a perfect solution
-         * since very distant geometries can still be occluded.
-         * Also the depth test precision of these geometries is impaired.
-         * However, it solves the selection for the vast majority of cases. */
-        GPU_depth_range(0.0f, 0.01f);
-      }
-      else {
-        GPU_depth_range(0.0f, 1.0f);
-      }
-    }
+  /* TODO this should be part of shader state. */
+  if (state & DRW_STATE_CLIP_PLANES) {
+    GPU_clip_distances(DST.view_active->clip_planes_len);
   }
-
-  /* Clip Planes */
-  {
-    int test;
-    if ((test = CHANGED_TO(DRW_STATE_CLIP_PLANES))) {
-      if (test == 1) {
-        GPU_clip_distances(DST.view_active->clip_planes_len);
-      }
-      else {
-        GPU_clip_distances(0);
-      }
-    }
+  else {
+    GPU_clip_distances(0);
   }
 
-  /* Program Points Size */
-  {
-    int test;
-    if ((test = CHANGED_TO(DRW_STATE_PROGRAM_POINT_SIZE))) {
-      if (test == 1) {
-        GPU_program_point_size(true);
-      }
-      else {
-        GPU_program_point_size(false);
-      }
-    }
+  if (state & DRW_STATE_IN_FRONT_SELECT) {
+    /* XXX `GPU_depth_range` is not a perfect solution
+     * since very distant geometries can still be occluded.
+     * Also the depth test precision of these geometries is impaired.
+     * However, it solves the selection for the vast majority of cases. */
+    GPU_depth_range(0.0f, 0.01f);
+  }
+  else {
+    GPU_depth_range(0.0f, 1.0f);
   }
 
-  /* Provoking Vertex */
-  {
-    int test;
-    if ((test = CHANGED_TO(DRW_STATE_FIRST_VERTEX_CONVENTION))) {
-      if (test == 1) {
-        glProvokingVertex(GL_FIRST_VERTEX_CONVENTION);
-      }
-      else {
-        glProvokingVertex(GL_LAST_VERTEX_CONVENTION);
-      }
-    }
+  if (state & DRW_STATE_PROGRAM_POINT_SIZE) {
+    GPU_program_point_size(true);
+  }
+  else {
+    GPU_program_point_size(false);
   }
 
-#undef CHANGED_TO
-#undef CHANGED_ANY
-#undef CHANGED_ANY_STORE_VAR
+  if (state & DRW_STATE_FIRST_VERTEX_CONVENTION) {
+    GPU_provoking_vertex(GPU_VERTEX_FIRST);
+  }
+  else {
+    GPU_provoking_vertex(GPU_VERTEX_LAST);
+  }
 
   DST.state = state;
 }
@@ -396,17 +256,9 @@ static void drw_stencil_state_set(uint write_mask, uint reference, uint compare_
    *   stencil_value being the value stored in the stencil buffer.
    * - (write-mask & reference) is what gets written if the test condition is fulfilled.
    **/
-  glStencilMask(write_mask);
-  DRWState stencil_test = DST.state & DRW_STATE_STENCIL_TEST_ENABLED;
-  if (stencil_test == DRW_STATE_STENCIL_ALWAYS) {
-    glStencilFunc(GL_ALWAYS, reference, compare_mask);
-  }
-  else if (stencil_test == DRW_STATE_STENCIL_EQUAL) {
-    glStencilFunc(GL_EQUAL, reference, compare_mask);
-  }
-  else if (stencil_test == DRW_STATE_STENCIL_NEQUAL) {
-    glStencilFunc(GL_NOTEQUAL, reference, compare_mask);
-  }
+  GPU_stencil_write_mask_set(write_mask);
+  GPU_stencil_reference_set(reference);
+  GPU_stencil_compare_mask_set(compare_mask);
 }
 
 /* Reset state to not interfer with other UI drawcall */
@@ -821,8 +673,8 @@ static void draw_update_uniforms(DRWShadingGroup *shgroup,
           break;
         case DRW_UNIFORM_TFEEDBACK_TARGET:
           BLI_assert(uni->pvalue && (*use_tfeedback == false));
-          *use_tfeedback = GPU_shader_transform_feedback_enable(
-              shgroup->shader, ((GPUVertBuf *)uni->pvalue)->vbo_id);
+          *use_tfeedback = GPU_shader_transform_feedback_enable(shgroup->shader,
+                                                                ((GPUVertBuf *)uni->pvalue));
           break;
           /* Legacy/Fallback support. */
         case DRW_UNIFORM_BASE_INSTANCE:
@@ -922,7 +774,7 @@ static void draw_call_resource_bind(DRWCommandsState *state, const DRWResourceHa
   int chunk = DRW_handle_chunk_get(handle);
   if (state->resource_chunk != chunk) {
     if (state->chunkid_loc != -1) {
-      GPU_shader_uniform_int(NULL, state->chunkid_loc, chunk);
+      GPU_shader_uniform_int(DST.shader, state->chunkid_loc, chunk);
     }
     if (state->obmats_loc != -1) {
       GPU_uniformbuffer_unbind(DST.vmempool->matrices_ubo[state->resource_chunk]);
@@ -938,7 +790,7 @@ static void draw_call_resource_bind(DRWCommandsState *state, const DRWResourceHa
   if (state->resourceid_loc != -1) {
     int id = DRW_handle_id_get(handle);
     if (state->resource_id != id) {
-      GPU_shader_uniform_int(NULL, state->resourceid_loc, id);
+      GPU_shader_uniform_int(DST.shader, state->resourceid_loc, id);
       state->resource_id = id;
     }
   }
diff --git a/source/blender/draw/intern/draw_manager_shader.c b/source/blender/draw/intern/draw_manager_shader.c
index 1c260721efb..7602bbb39ac 100644
--- a/source/blender/draw/intern/draw_manager_shader.c
+++ b/source/blender/draw/intern/draw_manager_shader.c
@@ -312,16 +312,18 @@ void DRW_deferred_shader_remove(GPUMaterial *mat)
 
 /** \{ */
 
-GPUShader *DRW_shader_create(const char *vert,
-                             const char *geom,
-                             const char *frag,
-                             const char *defines)
+GPUShader *DRW_shader_create_ex(
+    const char *vert, const char *geom, const char *frag, const char *defines, const char *name)
 {
-  return GPU_shader_create(vert, frag, geom, NULL, defines, __func__);
+  return GPU_shader_create(vert, frag, geom, NULL, defines, name);
 }
 
-GPUShader *DRW_shader_create_with_lib(
-    const char *vert, const char *geom, const char *frag, const char *lib, const char *defines)
+GPUShader *DRW_shader_create_with_lib_ex(const char *vert,
+                                         const char *geom,
+                                         const char *frag,
+                                         const char *lib,
+                                         const char *defines,
+                                         const char *name)
 {
   GPUShader *sh;
   char *vert_with_lib = NULL;
@@ -334,7 +336,7 @@ GPUShader *DRW_shader_create_with_lib(
     geom_with_lib = BLI_string_joinN(lib, geom);
   }
 
-  sh = GPU_shader_create(vert_with_lib, frag_with_lib, geom_with_lib, NULL, defines, __func__);
+  sh = GPU_shader_create(vert_with_lib, frag_with_lib, geom_with_lib, NULL, defines, name);
 
   MEM_freeN(vert_with_lib);
   MEM_freeN(frag_with_lib);
@@ -345,18 +347,19 @@ GPUShader *DRW_shader_create_with_lib(
   return sh;
 }
 
-GPUShader *DRW_shader_create_with_shaderlib(const char *vert,
-                                            const char *geom,
-                                            const char *frag,
-                                            const DRWShaderLibrary *lib,
-                                            const char *defines)
+GPUShader *DRW_shader_create_with_shaderlib_ex(const char *vert,
+                                               const char *geom,
+                                               const char *frag,
+                                               const DRWShaderLibrary *lib,
+                                               const char *defines,
+                                               const char *name)
 {
   GPUShader *sh;
   char *vert_with_lib = DRW_shader_library_create_shader_string(lib, vert);
   char *frag_with_lib = DRW_shader_library_create_shader_string(lib, frag);
   char *geom_with_lib = (geom) ? DRW_shader_library_create_shader_string(lib, geom) : NULL;
 
-  sh = GPU_shader_create(vert_with_lib, frag_with_lib, geom_with_lib, NULL, defines, __func__);
+  sh = GPU_shader_create(vert_with_lib, frag_with_lib, geom_with_lib, NULL, defines, name);
 
   MEM_SAFE_FREE(vert_with_lib);
   MEM_SAFE_FREE(frag_with_lib);
@@ -383,22 +386,22 @@ GPUShader *DRW_shader_create_with_transform_feedback(const char *vert,
                               __func__);
 }
 
-GPUShader *DRW_shader_create_fullscreen(const char *frag, const char *defines)
+GPUShader *DRW_shader_create_fullscreen_ex(const char *frag, const char *defines, const char *name)
 {
-  return GPU_shader_create(
-      datatoc_common_fullscreen_vert_glsl, frag, NULL, NULL, defines, __func__);
+  return GPU_shader_create(datatoc_common_fullscreen_vert_glsl, frag, NULL, NULL, defines, name);
 }
 
-GPUShader *DRW_shader_create_fullscreen_with_shaderlib(const char *frag,
-                                                       const DRWShaderLibrary *lib,
-                                                       const char *defines)
+GPUShader *DRW_shader_create_fullscreen_with_shaderlib_ex(const char *frag,
+                                                          const DRWShaderLibrary *lib,
+                                                          const char *defines,
+                                                          const char *name)
 {
 
   GPUShader *sh;
   char *vert = datatoc_common_fullscreen_vert_glsl;
   char *frag_with_lib = DRW_shader_library_create_shader_string(lib, frag);
 
-  sh = GPU_shader_create(vert, frag_with_lib, NULL, NULL, defines, __func__);
+  sh = GPU_shader_create(vert, frag_with_lib, NULL, NULL, defines, name);
 
   MEM_SAFE_FREE(frag_with_lib);
 
diff --git a/source/blender/draw/intern/draw_view.c b/source/blender/draw/intern/draw_view.c
index 1458ff5341c..0dc35d44788 100644
--- a/source/blender/draw/intern/draw_view.c
+++ b/source/blender/draw/intern/draw_view.c
@@ -123,7 +123,7 @@ void DRW_draw_cursor(void)
 
       /* Draw nice Anti Aliased cursor. */
       GPU_line_width(1.0f);
-      GPU_blend(true);
+      GPU_blend(GPU_BLEND_ALPHA);
       GPU_line_smooth(true);
 
       float eps = 1e-5f;
@@ -188,7 +188,7 @@ void DRW_draw_cursor(void)
 
       GPU_batch_draw(cursor_batch);
 
-      GPU_blend(false);
+      GPU_blend(GPU_BLEND_NONE);
       GPU_line_smooth(false);
       GPU_matrix_pop();
       GPU_matrix_projection_set(original_proj);
diff --git a/source/blender/draw/intern/shaders/common_globals_lib.glsl b/source/blender/draw/intern/shaders/common_globals_lib.glsl
index 40a527a6ba4..bd1b1fb6f3a 100644
--- a/source/blender/draw/intern/shaders/common_globals_lib.glsl
+++ b/source/blender/draw/intern/shaders/common_globals_lib.glsl
@@ -117,8 +117,7 @@ layout(std140) uniform globalsBlock
   float sizeEdgeFix;
   float sizeFaceDot;
   float sizeChecker;
-
-  float pad_globalsBlock;
+  float sizeVertexGpencil;
 };
 
 #define sizeViewportInv (sizeViewport.zw)
diff --git a/source/blender/draw/intern/smaa_textures.h b/source/blender/draw/intern/smaa_textures.h
index 7556f3a1952..fcf0ced1eed 100644
--- a/source/blender/draw/intern/smaa_textures.h
+++ b/source/blender/draw/intern/smaa_textures.h
@@ -15081,4 +15081,3 @@ static const unsigned char searchTexBytes[] = {
 };
 
 /* clang-format off */
-