GPU: refactor clipped drawing from DRW into GPU

Needed to fix T61196, supporting clipped back-buffer in the 3D view
which is done outside the draw module.

It was also inconvenient having DRW_shader_* versions of GPU_shader_*
API calls.

- Clipping distances are now supported as a shader configuration
  for builtin shaders.
- Add shader config argument when accessing builtin shaders.
- Move GPU_shader_create_from_arrays() from DRW to GPU.

7 files changed, 74 insertions, 304 deletions

diff --git a/source/blender/draw/intern/DRW_render.h b/source/blender/draw/intern/DRW_render.h
index 87a1add4e81..d9b2e893354 100644
--- a/source/blender/draw/intern/DRW_render.h
+++ b/source/blender/draw/intern/DRW_render.h
@@ -240,11 +240,6 @@ void DRW_multisamples_resolve(
 /* Shaders */
 struct GPUShader *DRW_shader_create(
         const char *vert, const char *geom, const char *frag, const char *defines);
-struct DRW_ShaderCreateFromArray_Params { const char **vert, **geom, **frag, **defs; };
-struct GPUShader *DRW_shader_create_from_arrays_impl(
-        const struct DRW_ShaderCreateFromArray_Params *params);
-#define DRW_shader_create_from_arrays(...) \
-	DRW_shader_create_from_arrays_impl(&(const struct DRW_ShaderCreateFromArray_Params)__VA_ARGS__)
 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_transform_feedback(
@@ -253,7 +248,7 @@ struct GPUShader *DRW_shader_create_with_transform_feedback(
 struct GPUShader *DRW_shader_create_2D(const char *frag, const char *defines);
 struct GPUShader *DRW_shader_create_3D(const char *frag, const char *defines);
 struct GPUShader *DRW_shader_create_fullscreen(const char *frag, const char *defines);
-struct GPUShader *DRW_shader_create_3D_depth_only(eDRW_ShaderSlot slot);
+struct GPUShader *DRW_shader_create_3D_depth_only(eGPUShaderConfig slot);
 struct GPUMaterial *DRW_shader_find_from_world(struct World *wo, const void *engine_type, int options, bool deferred);
 struct GPUMaterial *DRW_shader_find_from_material(struct Material *ma, const void *engine_type, int options, bool deferred);
 struct GPUMaterial *DRW_shader_create_from_world(
@@ -584,7 +579,7 @@ typedef struct DRWContextState {
 
 	eObjectMode object_mode;
 
-	eDRW_ShaderSlot shader_slot;
+	eGPUShaderConfig shader_cfg;
 
 	/** Last resort (some functions take this as an arg so we can't easily avoid).
 	 * May be NULL when used for selection or depth buffer. */
diff --git a/source/blender/draw/intern/draw_builtin_shader.c b/source/blender/draw/intern/draw_builtin_shader.c
deleted file mode 100644
index 5da2271cf16..00000000000
--- a/source/blender/draw/intern/draw_builtin_shader.c
+++ /dev/null
@@ -1,116 +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.
- */
-
-/** \file draw_builtin_shader.c
- *  \ingroup draw
- * Draw manager versions of #eGPUBuiltinShader, see #GPU_shader_get_builtin_shader.
- *
- * Allows for modifications to shaders (currently only clipping support).
- * Follow GPU_shader.h conventions to avoid annoyance.
- */
-
-#include "BLI_utildefines.h"
-
-#include "GPU_shader.h"
-
-#include "DRW_render.h"
-
-#include "draw_builtin_shader.h"  /* own include */
-
-
-extern char datatoc_common_world_clip_lib_glsl[];
-
-/* Add shaders to this list when support is added. */
-#define GPU_SHADER_IS_SUPPORTED(shader_id) \
-	ELEM(shader_id, \
-	     GPU_SHADER_3D_UNIFORM_COLOR, \
-	     GPU_SHADER_3D_SMOOTH_COLOR, \
-	     GPU_SHADER_3D_DEPTH_ONLY, \
-	     GPU_SHADER_CAMERA, \
-	     GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE, \
-	     GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SCALE, \
-	     GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA, \
-	     GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA, \
-	     GPU_SHADER_3D_SCREENSPACE_VARIYING_COLOR, \
-	     GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED, \
-	     GPU_SHADER_3D_GROUNDLINE, \
-	     GPU_SHADER_3D_GROUNDPOINT, \
-	     GPU_SHADER_DISTANCE_LINES, \
-	     GPU_SHADER_INSTANCE_EDGES_VARIYING_COLOR)
-
-/* cache of built-in shaders (each is created on first use) */
-static struct {
-	GPUShader *builtin_shaders[GPU_NUM_BUILTIN_SHADERS];
-} g_sh_data[DRW_SHADER_SLOT_LEN - 1] = {{{NULL}}};
-
-static GPUShader *drw_shader_get_builtin_shader_clipped(eGPUBuiltinShader shader_id)
-{
-	const char *world_clip_lib = datatoc_common_world_clip_lib_glsl;
-	const char *world_clip_def = "#define USE_WORLD_CLIP_PLANES\n";
-
-	struct  { const char *vert, *frag, *geom, *defs; } shader_code;
-	GPU_shader_get_builtin_shader_code(
-	        shader_id,
-	        &shader_code.vert,
-	        &shader_code.frag,
-	        &shader_code.geom,
-	        &shader_code.defs);
-
-	/* In rare cases geometry shaders calculate clipping themselves. */
-	return DRW_shader_create_from_arrays({
-	        .vert = (const char *[]){world_clip_lib, shader_code.vert, NULL},
-	        .geom = (const char *[]){shader_code.geom ? world_clip_lib : NULL, shader_code.geom, NULL},
-	        .frag = (const char *[]){shader_code.frag, NULL},
-	        .defs = (const char *[]){world_clip_def, shader_code.defs, NULL},
-	});
-}
-
-GPUShader *DRW_shader_get_builtin_shader(eGPUBuiltinShader shader_id, eDRW_ShaderSlot slot)
-{
-	BLI_assert(GPU_SHADER_IS_SUPPORTED(shader_id));
-
-	if (slot == DRW_SHADER_SLOT_DEFAULT) {
-		return GPU_shader_get_builtin_shader(shader_id);
-	}
-
-	GPUShader **builtin_shaders = g_sh_data[slot - 1].builtin_shaders;
-
-	if (builtin_shaders[shader_id] != NULL) {
-		return builtin_shaders[shader_id];
-	}
-
-	if (slot == DRW_SHADER_SLOT_CLIPPED) {
-		builtin_shaders[shader_id] = drw_shader_get_builtin_shader_clipped(shader_id);
-		return builtin_shaders[shader_id];
-	}
-	else {
-		BLI_assert(0);
-		return NULL;
-	}
-}
-
-void DRW_shader_free_builtin_shaders(void)
-{
-	for (int j = 0; j < (DRW_SHADER_SLOT_LEN - 1); j++) {
-		GPUShader **builtin_shaders = g_sh_data[j].builtin_shaders;
-		for (int i = 0; i < GPU_NUM_BUILTIN_SHADERS; i++) {
-			if (builtin_shaders[i]) {
-				GPU_shader_free(builtin_shaders[i]);
-				builtin_shaders[i] = NULL;
-			}
-		}
-	}
-}
diff --git a/source/blender/draw/intern/draw_builtin_shader.h b/source/blender/draw/intern/draw_builtin_shader.h
deleted file mode 100644
index f8bf3c77149..00000000000
--- a/source/blender/draw/intern/draw_builtin_shader.h
+++ /dev/null
@@ -1,29 +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.
- */
-
-/** \file draw_builtin_shader.h
- *  \ingroup draw
- */
-
-#ifndef __DRAW_BUILTIN_SHADER_H__
-#define __DRAW_BUILTIN_SHADER_H__
-
-struct GPUShader;
-
-struct GPUShader *DRW_shader_get_builtin_shader(eGPUBuiltinShader shader_id, eDRW_ShaderSlot slot);
-void DRW_shader_free_builtin_shaders(void);
-
-#endif  /* __DRAW_BUILTIN_SHADER_H__ */
diff --git a/source/blender/draw/intern/draw_common.c b/source/blender/draw/intern/draw_common.c
index f43efa14451..0b0510a5ea2 100644
--- a/source/blender/draw/intern/draw_common.c
+++ b/source/blender/draw/intern/draw_common.c
@@ -32,7 +32,6 @@
 #include "BKE_colorband.h"
 
 #include "draw_common.h"
-#include "draw_builtin_shader.h"
 
 #if 0
 #define UI_COLOR_RGB_FROM_U8(r, g, b, v4) \
@@ -230,7 +229,7 @@ extern char datatoc_armature_stick_frag_glsl[];
 extern char datatoc_armature_dof_vert_glsl[];
 
 extern char datatoc_common_globals_lib_glsl[];
-extern char datatoc_common_world_clip_lib_glsl[];
+extern char datatoc_gpu_shader_cfg_world_clip_lib_glsl[];
 
 extern char datatoc_gpu_shader_flat_color_frag_glsl[];
 extern char datatoc_gpu_shader_3D_smooth_color_frag_glsl[];
@@ -261,7 +260,7 @@ typedef struct COMMON_Shaders {
 	struct GPUShader *mball_handles;
 } COMMON_Shaders;
 
-static COMMON_Shaders g_shaders[DRW_SHADER_SLOT_LEN] = {{NULL}};
+static COMMON_Shaders g_shaders[GPU_SHADER_CFG_LEN] = {{NULL}};
 
 static struct {
 	struct GPUVertFormat *instance_screenspace;
@@ -292,7 +291,7 @@ void DRW_globals_free(void)
 		MEM_SAFE_FREE(*format);
 	}
 
-	for (int j = 0; j < DRW_SHADER_SLOT_LEN; j++) {
+	for (int j = 0; j < GPU_SHADER_CFG_LEN; j++) {
 		struct GPUShader **shader = &g_shaders[j].shape_outline;
 		for (int i = 0; i < sizeof(g_shaders[j]) / sizeof(void *); ++i, ++shader) {
 			DRW_SHADER_FREE_SAFE(*shader);
@@ -338,49 +337,49 @@ DRWShadingGroup *shgroup_dynlines_dashed_uniform_color(DRWPass *pass, const floa
 }
 
 DRWShadingGroup *shgroup_dynpoints_uniform_color(
-        DRWPass *pass, const float color[4], const float *size, eDRW_ShaderSlot shader_slot)
+        DRWPass *pass, const float color[4], const float *size, eGPUShaderConfig shader_cfg)
 {
-	GPUShader *sh = DRW_shader_get_builtin_shader(GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA, shader_slot);
+	GPUShader *sh = GPU_shader_get_builtin_shader_with_config(GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA, shader_cfg);
 
 	DRWShadingGroup *grp = DRW_shgroup_point_batch_create(sh, pass);
 	DRW_shgroup_uniform_vec4(grp, "color", color, 1);
 	DRW_shgroup_uniform_float(grp, "size", size, 1);
 	DRW_shgroup_state_enable(grp, DRW_STATE_POINT);
-	if (shader_slot == DRW_SHADER_SLOT_CLIPPED) {
+	if (shader_cfg == GPU_SHADER_CFG_CLIPPED) {
 		DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
 	}
 	return grp;
 }
 
-DRWShadingGroup *shgroup_groundlines_uniform_color(DRWPass *pass, const float color[4], eDRW_ShaderSlot shader_slot)
+DRWShadingGroup *shgroup_groundlines_uniform_color(DRWPass *pass, const float color[4], eGPUShaderConfig shader_cfg)
 {
-	GPUShader *sh = DRW_shader_get_builtin_shader(GPU_SHADER_3D_GROUNDLINE, shader_slot);
+	GPUShader *sh = GPU_shader_get_builtin_shader_with_config(GPU_SHADER_3D_GROUNDLINE, shader_cfg);
 
 	DRWShadingGroup *grp = DRW_shgroup_point_batch_create(sh, pass);
 	DRW_shgroup_uniform_vec4(grp, "color", color, 1);
-	if (shader_slot == DRW_SHADER_SLOT_CLIPPED) {
+	if (shader_cfg == GPU_SHADER_CFG_CLIPPED) {
 		DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
 	}
 	return grp;
 }
 
-DRWShadingGroup *shgroup_groundpoints_uniform_color(DRWPass *pass, const float color[4], eDRW_ShaderSlot shader_slot)
+DRWShadingGroup *shgroup_groundpoints_uniform_color(DRWPass *pass, const float color[4], eGPUShaderConfig shader_cfg)
 {
-	GPUShader *sh = DRW_shader_get_builtin_shader(GPU_SHADER_3D_GROUNDPOINT, shader_slot);
+	GPUShader *sh = GPU_shader_get_builtin_shader_with_config(GPU_SHADER_3D_GROUNDPOINT, shader_cfg);
 
 	DRWShadingGroup *grp = DRW_shgroup_point_batch_create(sh, pass);
 	DRW_shgroup_uniform_vec4(grp, "color", color, 1);
 	DRW_shgroup_state_enable(grp, DRW_STATE_POINT);
-	if (shader_slot == DRW_SHADER_SLOT_CLIPPED) {
+	if (shader_cfg == GPU_SHADER_CFG_CLIPPED) {
 		DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
 	}
 	return grp;
 }
 
 DRWShadingGroup *shgroup_instance_screenspace(
-        DRWPass *pass, struct GPUBatch *geom, const float *size, eDRW_ShaderSlot shader_slot)
+        DRWPass *pass, struct GPUBatch *geom, const float *size, eGPUShaderConfig shader_cfg)
 {
-	GPUShader *sh = DRW_shader_get_builtin_shader(GPU_SHADER_3D_SCREENSPACE_VARIYING_COLOR, shader_slot);
+	GPUShader *sh = GPU_shader_get_builtin_shader_with_config(GPU_SHADER_3D_SCREENSPACE_VARIYING_COLOR, shader_cfg);
 
 	DRW_shgroup_instance_format(g_formats.instance_screenspace, {
 		{"world_pos", DRW_ATTR_FLOAT, 3},
@@ -391,7 +390,7 @@ DRWShadingGroup *shgroup_instance_screenspace(
 	DRW_shgroup_uniform_float(grp, "size", size, 1);
 	DRW_shgroup_uniform_float(grp, "pixel_size", DRW_viewport_pixelsize_get(), 1);
 	DRW_shgroup_uniform_vec3(grp, "screen_vecs[0]", DRW_viewport_screenvecs_get(), 2);
-	if (shader_slot == DRW_SHADER_SLOT_CLIPPED) {
+	if (shader_cfg == GPU_SHADER_CFG_CLIPPED) {
 		DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
 	}
 	return grp;
@@ -428,9 +427,9 @@ DRWShadingGroup *shgroup_instance_wire(DRWPass *pass, struct GPUBatch *geom)
 }
 
 DRWShadingGroup *shgroup_instance_screen_aligned(
-        DRWPass *pass, struct GPUBatch *geom, eDRW_ShaderSlot shader_slot)
+        DRWPass *pass, struct GPUBatch *geom, eGPUShaderConfig shader_cfg)
 {
-	GPUShader *sh = DRW_shader_get_builtin_shader(GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED, shader_slot);
+	GPUShader *sh = GPU_shader_get_builtin_shader_with_config(GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED, shader_cfg);
 
 	DRW_shgroup_instance_format(g_formats.instance_screen_aligned, {
 		{"color",               DRW_ATTR_FLOAT, 3},
@@ -440,15 +439,15 @@ DRWShadingGroup *shgroup_instance_screen_aligned(
 
 	DRWShadingGroup *grp = DRW_shgroup_instance_create(sh, pass, geom, g_formats.instance_screen_aligned);
 	DRW_shgroup_uniform_vec3(grp, "screen_vecs[0]", DRW_viewport_screenvecs_get(), 2);
-	if (shader_slot == DRW_SHADER_SLOT_CLIPPED) {
+	if (shader_cfg == GPU_SHADER_CFG_CLIPPED) {
 		DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
 	}
 	return grp;
 }
 
-DRWShadingGroup *shgroup_instance_scaled(DRWPass *pass, struct GPUBatch *geom, eDRW_ShaderSlot shader_slot)
+DRWShadingGroup *shgroup_instance_scaled(DRWPass *pass, struct GPUBatch *geom, eGPUShaderConfig shader_cfg)
 {
-	GPUShader *sh_inst = DRW_shader_get_builtin_shader(GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SCALE, shader_slot);
+	GPUShader *sh_inst = GPU_shader_get_builtin_shader_with_config(GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SCALE, shader_cfg);
 
 	DRW_shgroup_instance_format(g_formats.instance_scaled, {
 		{"color",               DRW_ATTR_FLOAT, 3},
@@ -457,15 +456,15 @@ DRWShadingGroup *shgroup_instance_scaled(DRWPass *pass, struct GPUBatch *geom, e
 	});
 
 	DRWShadingGroup *grp = DRW_shgroup_instance_create(sh_inst, pass, geom, g_formats.instance_scaled);
-	if (shader_slot == DRW_SHADER_SLOT_CLIPPED) {
+	if (shader_cfg == GPU_SHADER_CFG_CLIPPED) {
 		DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
 	}
 	return grp;
 }
 
-DRWShadingGroup *shgroup_instance(DRWPass *pass, struct GPUBatch *geom, eDRW_ShaderSlot shader_slot)
+DRWShadingGroup *shgroup_instance(DRWPass *pass, struct GPUBatch *geom, eGPUShaderConfig shader_cfg)
 {
-	GPUShader *sh_inst = DRW_shader_get_builtin_shader(GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE, shader_slot);
+	GPUShader *sh_inst = GPU_shader_get_builtin_shader_with_config(GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE, shader_cfg);
 
 	DRW_shgroup_instance_format(g_formats.instance_sized, {
 		{"color",               DRW_ATTR_FLOAT, 4},
@@ -475,15 +474,15 @@ DRWShadingGroup *shgroup_instance(DRWPass *pass, struct GPUBatch *geom, eDRW_Sha
 
 	DRWShadingGroup *grp = DRW_shgroup_instance_create(sh_inst, pass, geom, g_formats.instance_sized);
 	DRW_shgroup_state_disable(grp, DRW_STATE_BLEND);
-	if (shader_slot == DRW_SHADER_SLOT_CLIPPED) {
+	if (shader_cfg == GPU_SHADER_CFG_CLIPPED) {
 		DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
 	}
 	return grp;
 }
 
-DRWShadingGroup *shgroup_instance_alpha(DRWPass *pass, struct GPUBatch *geom, eDRW_ShaderSlot shader_slot)
+DRWShadingGroup *shgroup_instance_alpha(DRWPass *pass, struct GPUBatch *geom, eGPUShaderConfig shader_cfg)
 {
-	GPUShader *sh_inst = DRW_shader_get_builtin_shader(GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE, shader_slot);
+	GPUShader *sh_inst = GPU_shader_get_builtin_shader_with_config(GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE, shader_cfg);
 
 	DRW_shgroup_instance_format(g_formats.instance_sized, {
 		{"color",               DRW_ATTR_FLOAT, 4},
@@ -492,19 +491,19 @@ DRWShadingGroup *shgroup_instance_alpha(DRWPass *pass, struct GPUBatch *geom, eD
 	});
 
 	DRWShadingGroup *grp = DRW_shgroup_instance_create(sh_inst, pass, geom, g_formats.instance_sized);
-	if (shader_slot == DRW_SHADER_SLOT_CLIPPED) {
+	if (shader_cfg == GPU_SHADER_CFG_CLIPPED) {
 		DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
 	}
 	return grp;
 }
 
-DRWShadingGroup *shgroup_instance_empty_axes(DRWPass *pass, struct GPUBatch *geom, eDRW_ShaderSlot shader_slot)
+DRWShadingGroup *shgroup_instance_empty_axes(DRWPass *pass, struct GPUBatch *geom, eGPUShaderConfig shader_cfg)
 {
-	COMMON_Shaders *sh_data = &g_shaders[shader_slot];
-	const char *world_clip_lib_or_empty = (shader_slot == DRW_SHADER_SLOT_CLIPPED) ? datatoc_common_world_clip_lib_glsl : "";
-	const char *world_clip_def_or_empty = (shader_slot == DRW_SHADER_SLOT_CLIPPED) ? "#define USE_WORLD_CLIP_PLANES\n" : "";
+	COMMON_Shaders *sh_data = &g_shaders[shader_cfg];
+	const char *world_clip_lib_or_empty = (shader_cfg == GPU_SHADER_CFG_CLIPPED) ? datatoc_gpu_shader_cfg_world_clip_lib_glsl : "";
+	const char *world_clip_def_or_empty = (shader_cfg == GPU_SHADER_CFG_CLIPPED) ? "#define USE_WORLD_CLIP_PLANES\n" : "";
 	if (sh_data->empty_axes_sh == NULL) {
-		sh_data->empty_axes_sh = DRW_shader_create_from_arrays({
+		sh_data->empty_axes_sh = GPU_shader_create_from_arrays({
 		        .vert = (const char *[]){world_clip_lib_or_empty, datatoc_object_empty_axes_vert_glsl, NULL},
 		        .frag = (const char *[]){datatoc_gpu_shader_flat_color_frag_glsl, NULL},
 		        .defs = (const char *[]){world_clip_def_or_empty, NULL},
@@ -519,7 +518,7 @@ DRWShadingGroup *shgroup_instance_empty_axes(DRWPass *pass, struct GPUBatch *geo
 
 	DRWShadingGroup *grp = DRW_shgroup_instance_create(sh_data->empty_axes_sh, pass, geom, g_formats.instance_sized);
 	DRW_shgroup_uniform_vec3(grp, "screenVecs[0]", DRW_viewport_screenvecs_get(), 2);
-	if (shader_slot == DRW_SHADER_SLOT_CLIPPED) {
+	if (shader_cfg == GPU_SHADER_CFG_CLIPPED) {
 		DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
 	}
 	return grp;
@@ -541,9 +540,9 @@ DRWShadingGroup *shgroup_instance_outline(DRWPass *pass, struct GPUBatch *geom,
 	return grp;
 }
 
-DRWShadingGroup *shgroup_camera_instance(DRWPass *pass, struct GPUBatch *geom, eDRW_ShaderSlot shader_slot)
+DRWShadingGroup *shgroup_camera_instance(DRWPass *pass, struct GPUBatch *geom, eGPUShaderConfig shader_cfg)
 {
-	GPUShader *sh_inst = DRW_shader_get_builtin_shader(GPU_SHADER_CAMERA, shader_slot);
+	GPUShader *sh_inst = GPU_shader_get_builtin_shader_with_config(GPU_SHADER_CAMERA, shader_cfg);
 
 	DRW_shgroup_instance_format(g_formats.instance_camera, {
 		{"color",               DRW_ATTR_FLOAT, 3},
@@ -554,15 +553,15 @@ DRWShadingGroup *shgroup_camera_instance(DRWPass *pass, struct GPUBatch *geom, e
 	});
 
 	DRWShadingGroup *grp = DRW_shgroup_instance_create(sh_inst, pass, geom, g_formats.instance_camera);
-	if (shader_slot == DRW_SHADER_SLOT_CLIPPED) {
+	if (shader_cfg == GPU_SHADER_CFG_CLIPPED) {
 		DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
 	}
 	return grp;
 }
 
-DRWShadingGroup *shgroup_distance_lines_instance(DRWPass *pass, struct GPUBatch *geom, eDRW_ShaderSlot shader_slot)
+DRWShadingGroup *shgroup_distance_lines_instance(DRWPass *pass, struct GPUBatch *geom, eGPUShaderConfig shader_cfg)
 {
-	GPUShader *sh_inst = DRW_shader_get_builtin_shader(GPU_SHADER_DISTANCE_LINES, shader_slot);
+	GPUShader *sh_inst = GPU_shader_get_builtin_shader_with_config(GPU_SHADER_DISTANCE_LINES, shader_cfg);
 	static float point_size = 4.0f;
 
 	DRW_shgroup_instance_format(g_formats.instance_distance_lines, {
@@ -574,15 +573,15 @@ DRWShadingGroup *shgroup_distance_lines_instance(DRWPass *pass, struct GPUBatch
 
 	DRWShadingGroup *grp = DRW_shgroup_instance_create(sh_inst, pass, geom, g_formats.instance_distance_lines);
 	DRW_shgroup_uniform_float(grp, "size", &point_size, 1);
-	if (shader_slot == DRW_SHADER_SLOT_CLIPPED) {
+	if (shader_cfg == GPU_SHADER_CFG_CLIPPED) {
 		DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
 	}
 	return grp;
 }
 
-DRWShadingGroup *shgroup_spot_instance(DRWPass *pass, struct GPUBatch *geom, eDRW_ShaderSlot shader_slot)
+DRWShadingGroup *shgroup_spot_instance(DRWPass *pass, struct GPUBatch *geom, eGPUShaderConfig shader_cfg)
 {
-	GPUShader *sh_inst = DRW_shader_get_builtin_shader(GPU_SHADER_INSTANCE_EDGES_VARIYING_COLOR, shader_slot);
+	GPUShader *sh_inst = GPU_shader_get_builtin_shader_with_config(GPU_SHADER_INSTANCE_EDGES_VARIYING_COLOR, shader_cfg);
 	static const int True = true;
 	static const int False = false;
 
@@ -595,7 +594,7 @@ DRWShadingGroup *shgroup_spot_instance(DRWPass *pass, struct GPUBatch *geom, eDR
 	DRW_shgroup_uniform_bool(grp, "drawFront", &False, 1);
 	DRW_shgroup_uniform_bool(grp, "drawBack", &False, 1);
 	DRW_shgroup_uniform_bool(grp, "drawSilhouette", &True, 1);
-	if (shader_slot == DRW_SHADER_SLOT_CLIPPED) {
+	if (shader_cfg == GPU_SHADER_CFG_CLIPPED) {
 		DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
 	}
 	return grp;
@@ -603,7 +602,7 @@ DRWShadingGroup *shgroup_spot_instance(DRWPass *pass, struct GPUBatch *geom, eDR
 
 DRWShadingGroup *shgroup_instance_bone_axes(DRWPass *pass)
 {
-	COMMON_Shaders *sh_data = &g_shaders[DRW_SHADER_SLOT_DEFAULT];
+	COMMON_Shaders *sh_data = &g_shaders[GPU_SHADER_CFG_DEFAULT];
 	if (sh_data->bone_axes == NULL) {
 		sh_data->bone_axes = DRW_shader_create(
 		        datatoc_armature_axes_vert_glsl, NULL,
@@ -626,7 +625,7 @@ DRWShadingGroup *shgroup_instance_bone_axes(DRWPass *pass)
 
 DRWShadingGroup *shgroup_instance_bone_envelope_outline(DRWPass *pass)
 {
-	COMMON_Shaders *sh_data = &g_shaders[DRW_SHADER_SLOT_DEFAULT];
+	COMMON_Shaders *sh_data = &g_shaders[GPU_SHADER_CFG_DEFAULT];
 	if (sh_data->bone_envelope_outline == NULL) {
 		sh_data->bone_envelope_outline = DRW_shader_create(
 		        datatoc_armature_envelope_outline_vert_glsl, NULL,
@@ -651,7 +650,7 @@ DRWShadingGroup *shgroup_instance_bone_envelope_outline(DRWPass *pass)
 
 DRWShadingGroup *shgroup_instance_bone_envelope_distance(DRWPass *pass)
 {
-	COMMON_Shaders *sh_data = &g_shaders[DRW_SHADER_SLOT_DEFAULT];
+	COMMON_Shaders *sh_data = &g_shaders[GPU_SHADER_CFG_DEFAULT];
 	if (sh_data->bone_envelope_distance == NULL) {
 		sh_data->bone_envelope_distance = DRW_shader_create(
 		        datatoc_armature_envelope_solid_vert_glsl, NULL,
@@ -674,7 +673,7 @@ DRWShadingGroup *shgroup_instance_bone_envelope_distance(DRWPass *pass)
 
 DRWShadingGroup *shgroup_instance_bone_envelope_solid(DRWPass *pass, bool transp)
 {
-	COMMON_Shaders *sh_data = &g_shaders[DRW_SHADER_SLOT_DEFAULT];
+	COMMON_Shaders *sh_data = &g_shaders[GPU_SHADER_CFG_DEFAULT];
 	if (sh_data->bone_envelope == NULL) {
 		sh_data->bone_envelope = DRW_shader_create(
 		        datatoc_armature_envelope_solid_vert_glsl, NULL,
@@ -700,7 +699,7 @@ DRWShadingGroup *shgroup_instance_bone_envelope_solid(DRWPass *pass, bool transp
 
 DRWShadingGroup *shgroup_instance_mball_handles(DRWPass *pass)
 {
-	COMMON_Shaders *sh_data = &g_shaders[DRW_SHADER_SLOT_DEFAULT];
+	COMMON_Shaders *sh_data = &g_shaders[GPU_SHADER_CFG_DEFAULT];
 	if (sh_data->mball_handles == NULL) {
 		sh_data->mball_handles = DRW_shader_create(
 		        datatoc_object_mball_handles_vert_glsl, NULL,
@@ -725,7 +724,7 @@ DRWShadingGroup *shgroup_instance_mball_handles(DRWPass *pass)
 /* Only works with batches with adjacency infos. */
 DRWShadingGroup *shgroup_instance_bone_shape_outline(DRWPass *pass, struct GPUBatch *geom)
 {
-	COMMON_Shaders *sh_data = &g_shaders[DRW_SHADER_SLOT_DEFAULT];
+	COMMON_Shaders *sh_data = &g_shaders[GPU_SHADER_CFG_DEFAULT];
 	if (sh_data->shape_outline == NULL) {
 		sh_data->shape_outline = DRW_shader_create(
 		        datatoc_armature_shape_outline_vert_glsl,
@@ -749,7 +748,7 @@ DRWShadingGroup *shgroup_instance_bone_shape_outline(DRWPass *pass, struct GPUBa
 
 DRWShadingGroup *shgroup_instance_bone_shape_solid(DRWPass *pass, struct GPUBatch *geom, bool transp)
 {
-	COMMON_Shaders *sh_data = &g_shaders[DRW_SHADER_SLOT_DEFAULT];
+	COMMON_Shaders *sh_data = &g_shaders[GPU_SHADER_CFG_DEFAULT];
 	if (sh_data->shape_solid == NULL) {
 		sh_data->shape_solid = DRW_shader_create(
 		        datatoc_armature_shape_solid_vert_glsl, NULL,
@@ -772,7 +771,7 @@ DRWShadingGroup *shgroup_instance_bone_shape_solid(DRWPass *pass, struct GPUBatc
 
 DRWShadingGroup *shgroup_instance_bone_sphere_solid(DRWPass *pass, bool transp)
 {
-	COMMON_Shaders *sh_data = &g_shaders[DRW_SHADER_SLOT_DEFAULT];
+	COMMON_Shaders *sh_data = &g_shaders[GPU_SHADER_CFG_DEFAULT];
 	if (sh_data->bone_sphere == NULL) {
 		sh_data->bone_sphere = DRW_shader_create(
 		        datatoc_armature_sphere_solid_vert_glsl, NULL,
@@ -796,7 +795,7 @@ DRWShadingGroup *shgroup_instance_bone_sphere_solid(DRWPass *pass, bool transp)
 
 DRWShadingGroup *shgroup_instance_bone_sphere_outline(DRWPass *pass)
 {
-	COMMON_Shaders *sh_data = &g_shaders[DRW_SHADER_SLOT_DEFAULT];
+	COMMON_Shaders *sh_data = &g_shaders[GPU_SHADER_CFG_DEFAULT];
 	if (sh_data->bone_sphere_outline == NULL) {
 		sh_data->bone_sphere_outline = DRW_shader_create(
 		        datatoc_armature_sphere_outline_vert_glsl, NULL,
@@ -819,7 +818,7 @@ DRWShadingGroup *shgroup_instance_bone_sphere_outline(DRWPass *pass)
 
 DRWShadingGroup *shgroup_instance_bone_stick(DRWPass *pass)
 {
-	COMMON_Shaders *sh_data = &g_shaders[DRW_SHADER_SLOT_DEFAULT];
+	COMMON_Shaders *sh_data = &g_shaders[GPU_SHADER_CFG_DEFAULT];
 	if (sh_data->bone_stick == NULL) {
 		sh_data->bone_stick = DRW_shader_create(
 		        datatoc_armature_stick_vert_glsl, NULL,
@@ -847,7 +846,7 @@ DRWShadingGroup *shgroup_instance_bone_stick(DRWPass *pass)
 
 struct DRWShadingGroup *shgroup_instance_bone_dof(struct DRWPass *pass, struct GPUBatch *geom)
 {
-	COMMON_Shaders *sh_data = &g_shaders[DRW_SHADER_SLOT_DEFAULT];
+	COMMON_Shaders *sh_data = &g_shaders[GPU_SHADER_CFG_DEFAULT];
 	if (sh_data->bone_dofs == NULL) {
 		sh_data->bone_dofs = DRW_shader_create(
 		        datatoc_armature_dof_vert_glsl, NULL,
@@ -871,7 +870,7 @@ struct DRWShadingGroup *shgroup_instance_bone_dof(struct DRWPass *pass, struct G
 
 struct GPUShader *mpath_line_shader_get(void)
 {
-	COMMON_Shaders *sh_data = &g_shaders[DRW_SHADER_SLOT_DEFAULT];
+	COMMON_Shaders *sh_data = &g_shaders[GPU_SHADER_CFG_DEFAULT];
 	if (sh_data->mpath_line_sh == NULL) {
 		sh_data->mpath_line_sh = DRW_shader_create_with_lib(
 		        datatoc_animviz_mpath_lines_vert_glsl,
@@ -886,7 +885,7 @@ struct GPUShader *mpath_line_shader_get(void)
 
 struct GPUShader *mpath_points_shader_get(void)
 {
-	COMMON_Shaders *sh_data = &g_shaders[DRW_SHADER_SLOT_DEFAULT];
+	COMMON_Shaders *sh_data = &g_shaders[GPU_SHADER_CFG_DEFAULT];
 	if (sh_data->mpath_points_sh == NULL) {
 		sh_data->mpath_points_sh = DRW_shader_create_with_lib(
 		        datatoc_animviz_mpath_points_vert_glsl,
@@ -900,7 +899,7 @@ struct GPUShader *mpath_points_shader_get(void)
 
 struct GPUShader *volume_velocity_shader_get(bool use_needle)
 {
-	COMMON_Shaders *sh_data = &g_shaders[DRW_SHADER_SLOT_DEFAULT];
+	COMMON_Shaders *sh_data = &g_shaders[GPU_SHADER_CFG_DEFAULT];
 	if (use_needle) {
 		if (sh_data->volume_velocity_needle_sh == NULL) {
 			sh_data->volume_velocity_needle_sh = DRW_shader_create(
diff --git a/source/blender/draw/intern/draw_common.h b/source/blender/draw/intern/draw_common.h
index fc9c83e3ce1..43763f5e599 100644
--- a/source/blender/draw/intern/draw_common.h
+++ b/source/blender/draw/intern/draw_common.h
@@ -33,16 +33,6 @@ struct PTCacheEdit;
 struct ParticleSystem;
 struct ViewLayer;
 
-/**
- * Support selecting shaders with different options compiled in.
- * Needed for clipping support because it means using a separate set of shaders.
- */
-typedef enum eDRW_ShaderSlot {
-	DRW_SHADER_SLOT_DEFAULT = 0,
-	DRW_SHADER_SLOT_CLIPPED = 1,
-} eDRW_ShaderSlot;
-#define DRW_SHADER_SLOT_LEN 2
-
 #define UBO_FIRST_COLOR colorWire
 #define UBO_LAST_COLOR colorGridAxisZ
 
@@ -136,21 +126,21 @@ void DRW_shgroup_world_clip_planes_from_rv3d(struct DRWShadingGroup *shgrp, cons
 
 struct DRWShadingGroup *shgroup_dynlines_flat_color(struct DRWPass *pass);
 struct DRWShadingGroup *shgroup_dynlines_dashed_uniform_color(struct DRWPass *pass, const float color[4]);
-struct DRWShadingGroup *shgroup_dynpoints_uniform_color(struct DRWPass *pass, const float color[4], const float *size, eDRW_ShaderSlot shader_slot);
-struct DRWShadingGroup *shgroup_groundlines_uniform_color(struct DRWPass *pass, const float color[4], eDRW_ShaderSlot shader_slot);
-struct DRWShadingGroup *shgroup_groundpoints_uniform_color(struct DRWPass *pass, const float color[4], eDRW_ShaderSlot shader_slot);
-struct DRWShadingGroup *shgroup_instance_screenspace(struct DRWPass *pass, struct GPUBatch *geom, const float *size, eDRW_ShaderSlot shader_slot);
+struct DRWShadingGroup *shgroup_dynpoints_uniform_color(struct DRWPass *pass, const float color[4], const float *size, eGPUShaderConfig shader_cfg);
+struct DRWShadingGroup *shgroup_groundlines_uniform_color(struct DRWPass *pass, const float color[4], eGPUShaderConfig shader_cfg);
+struct DRWShadingGroup *shgroup_groundpoints_uniform_color(struct DRWPass *pass, const float color[4], eGPUShaderConfig shader_cfg);
+struct DRWShadingGroup *shgroup_instance_screenspace(struct DRWPass *pass, struct GPUBatch *geom, const float *size, eGPUShaderConfig shader_cfg);
 struct DRWShadingGroup *shgroup_instance_solid(struct DRWPass *pass, struct GPUBatch *geom);
 struct DRWShadingGroup *shgroup_instance_wire(struct DRWPass *pass, struct GPUBatch *geom);
-struct DRWShadingGroup *shgroup_instance_screen_aligned(struct DRWPass *pass, struct GPUBatch *geom, eDRW_ShaderSlot shader_slot);
-struct DRWShadingGroup *shgroup_instance_empty_axes(struct DRWPass *pass, struct GPUBatch *geom, eDRW_ShaderSlot shader_slot);
-struct DRWShadingGroup *shgroup_instance_scaled(struct DRWPass *pass, struct GPUBatch *geom, eDRW_ShaderSlot shader_slot);
-struct DRWShadingGroup *shgroup_instance(struct DRWPass *pass, struct GPUBatch *geom, eDRW_ShaderSlot shader_slot);
-struct DRWShadingGroup *shgroup_instance_alpha(struct DRWPass *pass, struct GPUBatch *geom, eDRW_ShaderSlot shader_slot);
+struct DRWShadingGroup *shgroup_instance_screen_aligned(struct DRWPass *pass, struct GPUBatch *geom, eGPUShaderConfig shader_cfg);
+struct DRWShadingGroup *shgroup_instance_empty_axes(struct DRWPass *pass, struct GPUBatch *geom, eGPUShaderConfig shader_cfg);
+struct DRWShadingGroup *shgroup_instance_scaled(struct DRWPass *pass, struct GPUBatch *geom, eGPUShaderConfig shader_cfg);
+struct DRWShadingGroup *shgroup_instance(struct DRWPass *pass, struct GPUBatch *geom, eGPUShaderConfig shader_cfg);
+struct DRWShadingGroup *shgroup_instance_alpha(struct DRWPass *pass, struct GPUBatch *geom, eGPUShaderConfig shader_cfg);
 struct DRWShadingGroup *shgroup_instance_outline(struct DRWPass *pass, struct GPUBatch *geom, int *baseid);
-struct DRWShadingGroup *shgroup_camera_instance(struct DRWPass *pass, struct GPUBatch *geom, eDRW_ShaderSlot shader_slot);
-struct DRWShadingGroup *shgroup_distance_lines_instance(struct DRWPass *pass, struct GPUBatch *geom, eDRW_ShaderSlot shader_slot);
-struct DRWShadingGroup *shgroup_spot_instance(struct DRWPass *pass, struct GPUBatch *geom, eDRW_ShaderSlot shader_slot);
+struct DRWShadingGroup *shgroup_camera_instance(struct DRWPass *pass, struct GPUBatch *geom, eGPUShaderConfig shader_cfg);
+struct DRWShadingGroup *shgroup_distance_lines_instance(struct DRWPass *pass, struct GPUBatch *geom, eGPUShaderConfig shader_cfg);
+struct DRWShadingGroup *shgroup_spot_instance(struct DRWPass *pass, struct GPUBatch *geom, eGPUShaderConfig shader_cfg);
 struct DRWShadingGroup *shgroup_instance_mball_handles(struct DRWPass *pass);
 struct DRWShadingGroup *shgroup_instance_bone_axes(struct DRWPass *pass);
 struct DRWShadingGroup *shgroup_instance_bone_envelope_distance(struct DRWPass *pass);
diff --git a/source/blender/draw/intern/draw_manager.c b/source/blender/draw/intern/draw_manager.c
index 2daeccdd572..6021b1c3881 100644
--- a/source/blender/draw/intern/draw_manager.c
+++ b/source/blender/draw/intern/draw_manager.c
@@ -72,7 +72,6 @@
 #include "draw_cache_impl.h"
 
 #include "draw_mode_engines.h"
-#include "draw_builtin_shader.h"
 #include "engines/eevee/eevee_engine.h"
 #include "engines/basic/basic_engine.h"
 #include "engines/workbench/workbench_engine.h"
@@ -538,9 +537,9 @@ static void drw_context_state_init(void)
 		DST.draw_ctx.object_pose = NULL;
 	}
 
-	DST.draw_ctx.shader_slot = DRW_SHADER_SLOT_DEFAULT;
+	DST.draw_ctx.shader_cfg = GPU_SHADER_CFG_DEFAULT;
 	if (DST.draw_ctx.rv3d && DST.draw_ctx.rv3d->rflag & RV3D_CLIPPING) {
-		DST.draw_ctx.shader_slot = DRW_SHADER_SLOT_CLIPPED;
+		DST.draw_ctx.shader_cfg = GPU_SHADER_CFG_CLIPPED;
 	}
 }
 
@@ -2602,7 +2601,6 @@ void DRW_engines_free(void)
 	DRW_shape_cache_free();
 	DRW_stats_free();
 	DRW_globals_free();
-	DRW_shader_free_builtin_shaders();
 
 	DrawEngineType *next;
 	for (DrawEngineType *type = DRW_engines.first; type; type = next) {
diff --git a/source/blender/draw/intern/draw_manager_shader.c b/source/blender/draw/intern/draw_manager_shader.c
index 35ac6e352d1..c91a66d7abe 100644
--- a/source/blender/draw/intern/draw_manager_shader.c
+++ b/source/blender/draw/intern/draw_manager_shader.c
@@ -40,7 +40,6 @@
 #include "WM_types.h"
 
 #include "draw_manager.h"
-#include "draw_builtin_shader.h"
 
 extern char datatoc_gpu_shader_2D_vert_glsl[];
 extern char datatoc_gpu_shader_3D_vert_glsl[];
@@ -263,72 +262,6 @@ GPUShader *DRW_shader_create(const char *vert, const char *geom, const char *fra
 	return GPU_shader_create(vert, frag, geom, NULL, defines, __func__);
 }
 
-static const char *string_join_array_maybe_alloc(const char **str_arr, bool *r_is_alloc)
-{
-	bool is_alloc = false;
-	if (str_arr == NULL) {
-		*r_is_alloc = false;
-		return NULL;
-	}
-	/* Skip empty strings (avoid alloc if we can). */
-	while (str_arr[0] && str_arr[0][0] == '\0') {
-		str_arr++;
-	}
-	int i;
-	for (i = 0; str_arr[i]; i++) {
-		if (i != 0 && str_arr[i][0] != '\0') {
-			is_alloc = true;
-		}
-	}
-	*r_is_alloc = is_alloc;
-	if (is_alloc) {
-		return BLI_string_join_arrayN(str_arr, i);
-	}
-	else {
-		return str_arr[0];
-	}
-}
-
-/**
- * Use via #DRW_shader_create_from_arrays macro (avoids passing in param).
- *
- * Similar to #DRW_shader_create_with_lib with the ability to include libs for each type of shader.
- *
- * It has the advantage that each item can be conditionally included
- * without having to build the string inline, then free it.
- *
- * \param params: NULL terminated arrays of strings.
- *
- * Example:
- * \code{.c}
- * sh = DRW_shader_create_from_arrays({
- *         .vert = (const char *[]){shader_lib_glsl, shader_vert_glsl, NULL},
- *         .geom = (const char *[]){shader_geom_glsl, NULL},
- *         .frag = (const char *[]){shader_frag_glsl, NULL},
- *         .defs = (const char *[]){"#define DEFINE\n", test ? "#define OTHER_DEFINE\n" : "", NULL},
- * });
- * \endcode
- */
-struct GPUShader *DRW_shader_create_from_arrays_impl(
-        const struct DRW_ShaderCreateFromArray_Params *params)
-{
-	struct { const char *str; bool is_alloc;} str_dst[4] = {0};
-	const char **str_src[4] = {params->vert, params->geom, params->frag, params->defs};
-
-	for (int i = 0; i < ARRAY_SIZE(str_src); i++) {
-		str_dst[i].str = string_join_array_maybe_alloc(str_src[i], &str_dst[i].is_alloc);
-	}
-
-	GPUShader *sh = DRW_shader_create(str_dst[0].str, str_dst[1].str, str_dst[2].str, str_dst[3].str);
-
-	for (int i = 0; i < ARRAY_SIZE(str_dst); i++) {
-		if (str_dst[i].is_alloc) {
-			MEM_freeN((void *)str_dst[i].str);
-		}
-	}
-	return sh;
-}
-
 GPUShader *DRW_shader_create_with_lib(
         const char *vert, const char *geom, const char *frag, const char *lib, const char *defines)
 {
@@ -379,9 +312,9 @@ GPUShader *DRW_shader_create_fullscreen(const char *frag, const char *defines)
 	return GPU_shader_create(datatoc_common_fullscreen_vert_glsl, frag, NULL, NULL, defines, __func__);
 }
 
-GPUShader *DRW_shader_create_3D_depth_only(eDRW_ShaderSlot slot)
+GPUShader *DRW_shader_create_3D_depth_only(eGPUShaderConfig shader_cfg)
 {
-	return DRW_shader_get_builtin_shader(GPU_SHADER_3D_DEPTH_ONLY, slot);
+	return GPU_shader_get_builtin_shader_with_config(GPU_SHADER_3D_DEPTH_ONLY, shader_cfg);
 }
 
 GPUMaterial *DRW_shader_find_from_world(World *wo, const void *engine_type, int options, bool deferred)