Merge branch 'master' into greasepencil-edit-curve

6 files changed, 211 insertions, 343 deletions

diff --git a/source/blender/draw/engines/eevee/eevee_lightcache.c b/source/blender/draw/engines/eevee/eevee_lightcache.c
index b5364a71378..a785d27c2db 100644
--- a/source/blender/draw/engines/eevee/eevee_lightcache.c
+++ b/source/blender/draw/engines/eevee/eevee_lightcache.c
@@ -1303,7 +1303,7 @@ void EEVEE_lightbake_job(void *custom_data, short *stop, short *do_update, float
   Depsgraph *depsgraph = lbake->depsgraph;
 
   DEG_graph_relations_update(depsgraph);
-  DEG_evaluate_on_framechange(lbake->bmain, depsgraph, lbake->frame);
+  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/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_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..47892b958d0 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:
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);