blender-archive/source/blender/gpu/intern/gpu_shader.c

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2005 Blender Foundation.
 * All rights reserved.
 */

/** \file
 * \ingroup gpu
 */

#include "MEM_guardedalloc.h"

#include "BLI_utildefines.h"
#include "BLI_math_base.h"
#include "BLI_math_vector.h"
#include "BLI_path_util.h"
#include "BLI_string.h"
#include "BLI_string_utils.h"

#include "BKE_appdir.h"
#include "BKE_global.h"

#include "DNA_space_types.h"

#include "GPU_extensions.h"
#include "GPU_context.h"
#include "GPU_matrix.h"
#include "GPU_shader.h"
#include "GPU_texture.h"
#include "GPU_uniformbuffer.h"

#include "gpu_shader_private.h"

/* Adjust these constants as needed. */
#define MAX_DEFINE_LENGTH 256
#define MAX_EXT_DEFINE_LENGTH 256

/* Non-generated shaders */
extern char datatoc_gpu_shader_depth_only_frag_glsl[];
extern char datatoc_gpu_shader_uniform_color_frag_glsl[];
extern char datatoc_gpu_shader_checker_frag_glsl[];
extern char datatoc_gpu_shader_diag_stripes_frag_glsl[];
extern char datatoc_gpu_shader_simple_lighting_frag_glsl[];
extern char datatoc_gpu_shader_simple_lighting_flat_color_frag_glsl[];
extern char datatoc_gpu_shader_simple_lighting_smooth_color_frag_glsl[];
extern char datatoc_gpu_shader_simple_lighting_smooth_color_alpha_frag_glsl[];
extern char datatoc_gpu_shader_flat_color_frag_glsl[];
extern char datatoc_gpu_shader_flat_color_alpha_test_0_frag_glsl[];
extern char datatoc_gpu_shader_flat_id_frag_glsl[];
extern char datatoc_gpu_shader_2D_area_borders_vert_glsl[];
extern char datatoc_gpu_shader_2D_area_borders_frag_glsl[];
extern char datatoc_gpu_shader_2D_vert_glsl[];
extern char datatoc_gpu_shader_2D_flat_color_vert_glsl[];
extern char datatoc_gpu_shader_2D_smooth_color_uniform_alpha_vert_glsl[];
extern char datatoc_gpu_shader_2D_smooth_color_vert_glsl[];
extern char datatoc_gpu_shader_2D_smooth_color_frag_glsl[];
extern char datatoc_gpu_shader_2D_smooth_color_dithered_frag_glsl[];
extern char datatoc_gpu_shader_2D_image_vert_glsl[];
extern char datatoc_gpu_shader_2D_image_rect_vert_glsl[];
extern char datatoc_gpu_shader_2D_image_multi_rect_vert_glsl[];
extern char datatoc_gpu_shader_2D_widget_base_vert_glsl[];
extern char datatoc_gpu_shader_2D_widget_base_frag_glsl[];
extern char datatoc_gpu_shader_2D_widget_shadow_vert_glsl[];
extern char datatoc_gpu_shader_2D_widget_shadow_frag_glsl[];
extern char datatoc_gpu_shader_2D_nodelink_frag_glsl[];
extern char datatoc_gpu_shader_2D_nodelink_vert_glsl[];

extern char datatoc_gpu_shader_3D_image_vert_glsl[];
extern char datatoc_gpu_shader_image_frag_glsl[];
extern char datatoc_gpu_shader_image_linear_frag_glsl[];
extern char datatoc_gpu_shader_image_color_frag_glsl[];
extern char datatoc_gpu_shader_image_desaturate_frag_glsl[];
extern char datatoc_gpu_shader_image_varying_color_frag_glsl[];
extern char datatoc_gpu_shader_image_alpha_color_frag_glsl[];
extern char datatoc_gpu_shader_image_shuffle_color_frag_glsl[];
extern char datatoc_gpu_shader_image_interlace_frag_glsl[];
extern char datatoc_gpu_shader_image_mask_uniform_color_frag_glsl[];
extern char datatoc_gpu_shader_image_modulate_alpha_frag_glsl[];
extern char datatoc_gpu_shader_image_depth_linear_frag_glsl[];
extern char datatoc_gpu_shader_image_depth_copy_frag_glsl[];
extern char datatoc_gpu_shader_image_multisample_resolve_frag_glsl[];
extern char datatoc_gpu_shader_3D_vert_glsl[];
extern char datatoc_gpu_shader_3D_normal_vert_glsl[];
extern char datatoc_gpu_shader_3D_flat_color_vert_glsl[];
extern char datatoc_gpu_shader_3D_smooth_color_vert_glsl[];
extern char datatoc_gpu_shader_3D_normal_flat_color_vert_glsl[];
extern char datatoc_gpu_shader_3D_normal_smooth_color_vert_glsl[];
extern char datatoc_gpu_shader_3D_smooth_color_frag_glsl[];
extern char datatoc_gpu_shader_3D_passthrough_vert_glsl[];
extern char datatoc_gpu_shader_3D_clipped_uniform_color_vert_glsl[];

extern char datatoc_gpu_shader_instance_vert_glsl[];
extern char datatoc_gpu_shader_instance_variying_size_variying_color_vert_glsl[];
extern char datatoc_gpu_shader_instance_variying_size_variying_id_vert_glsl[];
extern char datatoc_gpu_shader_instance_objectspace_variying_color_vert_glsl[];
extern char datatoc_gpu_shader_instance_screenspace_variying_color_vert_glsl[];
extern char datatoc_gpu_shader_instance_screen_aligned_vert_glsl[];
extern char datatoc_gpu_shader_instance_camera_vert_glsl[];
extern char datatoc_gpu_shader_instance_distance_line_vert_glsl[];
extern char datatoc_gpu_shader_instance_edges_variying_color_geom_glsl[];
extern char datatoc_gpu_shader_instance_edges_variying_color_vert_glsl[];
extern char datatoc_gpu_shader_instance_mball_handles_vert_glsl[];

extern char datatoc_gpu_shader_3D_groundpoint_vert_glsl[];
extern char datatoc_gpu_shader_3D_groundline_geom_glsl[];

extern char datatoc_gpu_shader_point_uniform_color_frag_glsl[];
extern char datatoc_gpu_shader_point_uniform_color_aa_frag_glsl[];
extern char datatoc_gpu_shader_point_uniform_color_outline_aa_frag_glsl[];
extern char datatoc_gpu_shader_point_varying_color_outline_aa_frag_glsl[];
extern char datatoc_gpu_shader_point_varying_color_varying_outline_aa_frag_glsl[];
extern char datatoc_gpu_shader_point_varying_color_frag_glsl[];
extern char datatoc_gpu_shader_3D_point_fixed_size_varying_color_vert_glsl[];
extern char datatoc_gpu_shader_3D_point_varying_size_vert_glsl[];
extern char datatoc_gpu_shader_3D_point_varying_size_varying_color_vert_glsl[];
extern char datatoc_gpu_shader_3D_point_uniform_size_aa_vert_glsl[];
extern char datatoc_gpu_shader_3D_point_uniform_size_outline_aa_vert_glsl[];
extern char datatoc_gpu_shader_2D_point_varying_size_varying_color_vert_glsl[];
extern char datatoc_gpu_shader_2D_point_uniform_size_aa_vert_glsl[];
extern char datatoc_gpu_shader_2D_point_uniform_size_outline_aa_vert_glsl[];
extern char datatoc_gpu_shader_2D_point_uniform_size_varying_color_outline_aa_vert_glsl[];

extern char datatoc_gpu_shader_2D_edituvs_points_vert_glsl[];
extern char datatoc_gpu_shader_2D_edituvs_facedots_vert_glsl[];
extern char datatoc_gpu_shader_2D_edituvs_edges_vert_glsl[];
extern char datatoc_gpu_shader_2D_edituvs_faces_vert_glsl[];
extern char datatoc_gpu_shader_2D_edituvs_stretch_vert_glsl[];

extern char datatoc_gpu_shader_3D_selection_id_vert_glsl[];
extern char datatoc_gpu_shader_selection_id_frag_glsl[];

extern char datatoc_gpu_shader_2D_line_dashed_uniform_color_vert_glsl[];
extern char datatoc_gpu_shader_2D_line_dashed_frag_glsl[];
extern char datatoc_gpu_shader_2D_line_dashed_geom_glsl[];
extern char datatoc_gpu_shader_3D_line_dashed_uniform_color_legacy_vert_glsl[];
extern char datatoc_gpu_shader_3D_line_dashed_uniform_color_vert_glsl[];

extern char datatoc_gpu_shader_edges_front_back_persp_vert_glsl[];
extern char datatoc_gpu_shader_edges_front_back_persp_geom_glsl[];
extern char datatoc_gpu_shader_edges_front_back_persp_legacy_vert_glsl[];
extern char datatoc_gpu_shader_edges_front_back_ortho_vert_glsl[];
extern char datatoc_gpu_shader_edges_overlay_vert_glsl[];
extern char datatoc_gpu_shader_edges_overlay_geom_glsl[];
extern char datatoc_gpu_shader_edges_overlay_simple_geom_glsl[];
extern char datatoc_gpu_shader_edges_overlay_frag_glsl[];
extern char datatoc_gpu_shader_text_vert_glsl[];
extern char datatoc_gpu_shader_text_geom_glsl[];
extern char datatoc_gpu_shader_text_frag_glsl[];
extern char datatoc_gpu_shader_text_simple_vert_glsl[];
extern char datatoc_gpu_shader_text_simple_geom_glsl[];
extern char datatoc_gpu_shader_keyframe_diamond_vert_glsl[];
extern char datatoc_gpu_shader_keyframe_diamond_frag_glsl[];

extern char datatoc_gpu_shader_gpencil_stroke_vert_glsl[];
extern char datatoc_gpu_shader_gpencil_stroke_frag_glsl[];
extern char datatoc_gpu_shader_gpencil_stroke_geom_glsl[];

extern char datatoc_gpu_shader_gpencil_fill_vert_glsl[];
extern char datatoc_gpu_shader_gpencil_fill_frag_glsl[];
extern char datatoc_gpu_shader_cfg_world_clip_lib_glsl[];

const struct GPUShaderConfigData GPU_shader_cfg_data[GPU_SHADER_CFG_LEN] = {
	[GPU_SHADER_CFG_DEFAULT] = {
		.lib = "",
		.def = "",
	},
	[GPU_SHADER_CFG_CLIPPED] = {
		.lib = datatoc_gpu_shader_cfg_world_clip_lib_glsl,
		.def = "#define USE_WORLD_CLIP_PLANES\n",
	},
};

/* cache of built-in shaders (each is created on first use) */
static GPUShader *builtin_shaders[GPU_SHADER_CFG_LEN][GPU_SHADER_BUILTIN_LEN] = {{NULL}};

#ifndef NDEBUG
static uint g_shaderid = 0;
#endif

typedef struct {
	const char *vert;
	/** Optional. */
	const char *geom;
	const char *frag;
	/** Optional. */
	const char *defs;
} GPUShaderStages;

static void shader_print_errors(const char *task, const char *log, const char **code, int totcode)
{
	int line = 1;

	fprintf(stderr, "GPUShader: %s error:\n", task);

	for (int i = 0; i < totcode; i++) {
		const char *c, *pos, *end = code[i] + strlen(code[i]);

		if (G.debug & G_DEBUG) {
			fprintf(stderr, "===== shader string %d ====\n", i + 1);

			c = code[i];
			while ((c < end) && (pos = strchr(c, '\n'))) {
				fprintf(stderr, "%2d  ", line);
				fwrite(c, (pos + 1) - c, 1, stderr);
				c = pos + 1;
				line++;
			}

			fprintf(stderr, "%s", c);
		}
	}

	fprintf(stderr, "%s\n", log);
}

static const char *gpu_shader_version(void)
{
	return "#version 330\n";
}

static void gpu_shader_standard_extensions(char defines[MAX_EXT_DEFINE_LENGTH])
{
	/* enable extensions for features that are not part of our base GLSL version
	 * don't use an extension for something already available!
	 */

	if (GLEW_ARB_texture_gather) {
		/* There is a bug on older Nvidia GPU where GL_ARB_texture_gather
		 * is reported to be supported but yield a compile error (see T55802). */
		if (!GPU_type_matches(GPU_DEVICE_NVIDIA, GPU_OS_ANY, GPU_DRIVER_ANY) || GLEW_VERSION_4_0) {
			strcat(defines, "#extension GL_ARB_texture_gather: enable\n");

			/* Some drivers don't agree on GLEW_ARB_texture_gather and the actual support in the
			 * shader so double check the preprocessor define (see T56544). */
			if (!GPU_type_matches(GPU_DEVICE_NVIDIA, GPU_OS_ANY, GPU_DRIVER_ANY) && !GLEW_VERSION_4_0) {
				strcat(defines, "#ifdef GL_ARB_texture_gather\n");
				strcat(defines, "#  define GPU_ARB_texture_gather\n");
				strcat(defines, "#endif\n");
			}
			else {
				strcat(defines, "#define GPU_ARB_texture_gather\n");
			}
		}
	}
	if (GLEW_ARB_texture_query_lod) {
		/* a #version 400 feature, but we use #version 330 maximum so use extension */
		strcat(defines, "#extension GL_ARB_texture_query_lod: enable\n");
	}
}

static void gpu_shader_standard_defines(char defines[MAX_DEFINE_LENGTH])
{
	/* some useful defines to detect GPU type */
	if (GPU_type_matches(GPU_DEVICE_ATI, GPU_OS_ANY, GPU_DRIVER_ANY))
		strcat(defines, "#define GPU_ATI\n");
	else if (GPU_type_matches(GPU_DEVICE_NVIDIA, GPU_OS_ANY, GPU_DRIVER_ANY))
		strcat(defines, "#define GPU_NVIDIA\n");
	else if (GPU_type_matches(GPU_DEVICE_INTEL, GPU_OS_ANY, GPU_DRIVER_ANY))
		strcat(defines, "#define GPU_INTEL\n");

	/* some useful defines to detect OS type */
	if (GPU_type_matches(GPU_DEVICE_ANY, GPU_OS_WIN, GPU_DRIVER_ANY))
		strcat(defines, "#define OS_WIN\n");
	else if (GPU_type_matches(GPU_DEVICE_ANY, GPU_OS_MAC, GPU_DRIVER_ANY))
		strcat(defines, "#define OS_MAC\n");
	else if (GPU_type_matches(GPU_DEVICE_ANY, GPU_OS_UNIX, GPU_DRIVER_ANY))
		strcat(defines, "#define OS_UNIX\n");

	return;
}

GPUShader *GPU_shader_create(
        const char *vertexcode,
        const char *fragcode,
        const char *geocode,
        const char *libcode,
        const char *defines,
        const char *shname)
{
	return GPU_shader_create_ex(
	        vertexcode,
	        fragcode,
	        geocode,
	        libcode,
	        defines,
	        GPU_SHADER_TFB_NONE,
	        NULL,
	        0,
	        shname);
}

#define DEBUG_SHADER_NONE ""
#define DEBUG_SHADER_VERTEX "vert"
#define DEBUG_SHADER_FRAGMENT "frag"
#define DEBUG_SHADER_GEOMETRY "geom"

/**
 * Dump GLSL shaders to disk
 *
 * This is used for profiling shader performance externally and debug if shader code is correct.
 * If called with no code, it simply bumps the shader index, so different shaders for the same
 * program share the same index.
 */
static void gpu_dump_shaders(const char **code, const int num_shaders, const char *extension)
{
	if ((G.debug & G_DEBUG_GPU_SHADERS) == 0) {
		return;
	}

	/* We use the same shader index for shaders in the same program.
	 * So we call this function once before calling for the individual shaders. */
	static int shader_index = 0;
	if (code == NULL) {
		shader_index++;
		BLI_assert(STREQ(DEBUG_SHADER_NONE, extension));
		return;
	}

	/* Determine the full path of the new shader. */
	char shader_path[FILE_MAX];

	char file_name[512] = {'\0'};
	sprintf(file_name, "%04d.%s", shader_index, extension);

	BLI_join_dirfile(shader_path, sizeof(shader_path), BKE_tempdir_session(), file_name);

	/* Write shader to disk. */
	FILE *f = fopen(shader_path, "w");
	if (f == NULL) {
		printf("Error writing to file: %s\n", shader_path);
	}
	for (int j = 0; j < num_shaders; j++) {
		fprintf(f, "%s", code[j]);
	}
	fclose(f);
	printf("Shader file written to disk: %s\n", shader_path);
}

GPUShader *GPU_shader_create_ex(
        const char *vertexcode,
        const char *fragcode,
        const char *geocode,
        const char *libcode,
        const char *defines,
        const eGPUShaderTFBType tf_type,
        const char **tf_names,
        const int tf_count,
        const char *shname)
{
	GLint status;
	GLchar log[5000];
	GLsizei length = 0;
	GPUShader *shader;
	char standard_defines[MAX_DEFINE_LENGTH] = "";
	char standard_extensions[MAX_EXT_DEFINE_LENGTH] = "";

	shader = MEM_callocN(sizeof(GPUShader), "GPUShader");
	gpu_dump_shaders(NULL, 0, DEBUG_SHADER_NONE);

#ifndef NDEBUG
	BLI_snprintf(shader->name, sizeof(shader->name), "%s_%u", shname, g_shaderid++);
#else
	UNUSED_VARS(shname);
#endif

	/* At least a vertex shader and a fragment shader are required. */
	BLI_assert((fragcode != NULL) && (vertexcode != NULL));

	if (vertexcode)
		shader->vertex = glCreateShader(GL_VERTEX_SHADER);
	if (fragcode)
		shader->fragment = glCreateShader(GL_FRAGMENT_SHADER);
	if (geocode)
		shader->geometry = glCreateShader(GL_GEOMETRY_SHADER);

	shader->program = glCreateProgram();

	if (!shader->program ||
	    (vertexcode && !shader->vertex) ||
	    (fragcode && !shader->fragment) ||
	    (geocode && !shader->geometry))
	{
		fprintf(stderr, "GPUShader, object creation failed.\n");
		GPU_shader_free(shader);
		return NULL;
	}

	gpu_shader_standard_defines(standard_defines);
	gpu_shader_standard_extensions(standard_extensions);

	if (vertexcode) {
		const char *source[6];
		/* custom limit, may be too small, beware */
		int num_source = 0;

		source[num_source++] = gpu_shader_version();
		source[num_source++] = "#define GPU_VERTEX_SHADER\n";
		source[num_source++] = standard_extensions;
		source[num_source++] = standard_defines;

		if (defines) source[num_source++] = defines;
		source[num_source++] = vertexcode;

		gpu_dump_shaders(source, num_source, DEBUG_SHADER_VERTEX);

		glAttachShader(shader->program, shader->vertex);
		glShaderSource(shader->vertex, num_source, source, NULL);

		glCompileShader(shader->vertex);
		glGetShaderiv(shader->vertex, GL_COMPILE_STATUS, &status);

		if (!status) {
			glGetShaderInfoLog(shader->vertex, sizeof(log), &length, log);
			shader_print_errors("compile", log, source, num_source);

			GPU_shader_free(shader);
			return NULL;
		}
	}

	if (fragcode) {
		const char *source[7];
		int num_source = 0;

		source[num_source++] = gpu_shader_version();
		source[num_source++] = "#define GPU_FRAGMENT_SHADER\n";
		source[num_source++] = standard_extensions;
		source[num_source++] = standard_defines;

		if (defines) source[num_source++] = defines;
		if (libcode) source[num_source++] = libcode;
		source[num_source++] = fragcode;

		gpu_dump_shaders(source, num_source, DEBUG_SHADER_FRAGMENT);

		glAttachShader(shader->program, shader->fragment);
		glShaderSource(shader->fragment, num_source, source, NULL);

		glCompileShader(shader->fragment);
		glGetShaderiv(shader->fragment, GL_COMPILE_STATUS, &status);

		if (!status) {
			glGetShaderInfoLog(shader->fragment, sizeof(log), &length, log);
			shader_print_errors("compile", log, source, num_source);

			GPU_shader_free(shader);
			return NULL;
		}
	}

	if (geocode) {
		const char *source[6];
		int num_source = 0;

		source[num_source++] = gpu_shader_version();
		source[num_source++] = "#define GPU_GEOMETRY_SHADER\n";
		source[num_source++] = standard_extensions;
		source[num_source++] = standard_defines;

		if (defines) source[num_source++] = defines;
		source[num_source++] = geocode;

		gpu_dump_shaders(source, num_source, DEBUG_SHADER_GEOMETRY);

		glAttachShader(shader->program, shader->geometry);
		glShaderSource(shader->geometry, num_source, source, NULL);

		glCompileShader(shader->geometry);
		glGetShaderiv(shader->geometry, GL_COMPILE_STATUS, &status);

		if (!status) {
			glGetShaderInfoLog(shader->geometry, sizeof(log), &length, log);
			shader_print_errors("compile", log, source, num_source);

			GPU_shader_free(shader);
			return NULL;
		}
	}

	if (tf_names != NULL) {
		glTransformFeedbackVaryings(shader->program, tf_count, tf_names, GL_INTERLEAVED_ATTRIBS);
		/* Primitive type must be setup */
		BLI_assert(tf_type != GPU_SHADER_TFB_NONE);
		shader->feedback_transform_type = tf_type;
	}

	glLinkProgram(shader->program);
	glGetProgramiv(shader->program, GL_LINK_STATUS, &status);
	if (!status) {
		glGetProgramInfoLog(shader->program, sizeof(log), &length, log);
		/* print attached shaders in pipeline order */
		if (vertexcode) shader_print_errors("linking", log, &vertexcode, 1);
		if (geocode) shader_print_errors("linking", log, &geocode, 1);
		if (libcode) shader_print_errors("linking", log, &libcode, 1);
		if (fragcode) shader_print_errors("linking", log, &fragcode, 1);

		GPU_shader_free(shader);
		return NULL;
	}

	shader->interface = GPU_shaderinterface_create(shader->program);

	return shader;
}

#undef DEBUG_SHADER_GEOMETRY
#undef DEBUG_SHADER_FRAGMENT
#undef DEBUG_SHADER_VERTEX
#undef DEBUG_SHADER_NONE

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 #GPU_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 = GPU_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 *GPU_shader_create_from_arrays_impl(
        const struct GPU_ShaderCreateFromArray_Params *params)
{
	struct { const char *str; bool is_alloc;} str_dst[4] = {{0}};
	const char **str_src[4] = {params->vert, params->frag, params->geom, 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 = GPU_shader_create(
	        str_dst[0].str, str_dst[1].str, str_dst[2].str, NULL, str_dst[3].str, __func__);

	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;
}

void GPU_shader_bind(GPUShader *shader)
{
	BLI_assert(shader && shader->program);

	glUseProgram(shader->program);
	GPU_matrix_bind(shader->interface);
}

void GPU_shader_unbind(void)
{
	glUseProgram(0);
}

bool GPU_shader_transform_feedback_enable(GPUShader *shader, uint vbo_id)
{
	if (shader->feedback_transform_type == GPU_SHADER_TFB_NONE) {
		return false;
	}

	glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, vbo_id);

	switch (shader->feedback_transform_type) {
		case GPU_SHADER_TFB_POINTS:    glBeginTransformFeedback(GL_POINTS);    return true;
		case GPU_SHADER_TFB_LINES:     glBeginTransformFeedback(GL_LINES);     return true;
		case GPU_SHADER_TFB_TRIANGLES: glBeginTransformFeedback(GL_TRIANGLES); return true;
		default: return false;
	}
}

void GPU_shader_transform_feedback_disable(GPUShader *UNUSED(shader))
{
	glEndTransformFeedback();
}

void GPU_shader_free(GPUShader *shader)
{
#if 0 /* Would be nice to have, but for now the Deferred compilation
       * does not have a GPUContext. */
	BLI_assert(GPU_context_active_get() != NULL);
#endif
	BLI_assert(shader);

	if (shader->vertex)
		glDeleteShader(shader->vertex);
	if (shader->geometry)
		glDeleteShader(shader->geometry);
	if (shader->fragment)
		glDeleteShader(shader->fragment);
	if (shader->program)
		glDeleteProgram(shader->program);

	if (shader->interface)
		GPU_shaderinterface_discard(shader->interface);

	MEM_freeN(shader);
}

int GPU_shader_get_uniform(GPUShader *shader, const char *name)
{
	BLI_assert(shader && shader->program);
	const GPUShaderInput *uniform = GPU_shaderinterface_uniform(shader->interface, name);
	return uniform ? uniform->location : -2;
}

int GPU_shader_get_uniform_ensure(GPUShader *shader, const char *name)
{
	BLI_assert(shader && shader->program);
	const GPUShaderInput *uniform = GPU_shaderinterface_uniform_ensure(shader->interface, name);
	return uniform ? uniform->location : -1;
}

int GPU_shader_get_builtin_uniform(GPUShader *shader, int builtin)
{
	BLI_assert(shader && shader->program);
	const GPUShaderInput *uniform = GPU_shaderinterface_uniform_builtin(shader->interface, builtin);
	return uniform ? uniform->location : -1;
}

int GPU_shader_get_uniform_block(GPUShader *shader, const char *name)
{
	BLI_assert(shader && shader->program);
	const GPUShaderInput *ubo = GPU_shaderinterface_ubo(shader->interface, name);
	return ubo ? ubo->location : -1;
}

void *GPU_shader_get_interface(GPUShader *shader)
{
	return shader->interface;
}

/* Clement : Temp */
int GPU_shader_get_program(GPUShader *shader)
{
	return (int)shader->program;
}

void GPU_shader_uniform_float(GPUShader *UNUSED(shader), int location, float value)
{
	if (location == -1)
		return;

	glUniform1f(location, value);
}

void GPU_shader_uniform_vector(GPUShader *UNUSED(shader), int location, int length, int arraysize, const float *value)
{
	if (location == -1 || value == NULL)
		return;

	if (length == 1) glUniform1fv(location, arraysize, value);
	else if (length == 2) glUniform2fv(location, arraysize, value);
	else if (length == 3) glUniform3fv(location, arraysize, value);
	else if (length == 4) glUniform4fv(location, arraysize, value);
	else if (length == 9) glUniformMatrix3fv(location, arraysize, 0, value);
	else if (length == 16) glUniformMatrix4fv(location, arraysize, 0, value);
}

void GPU_shader_uniform_vector_int(GPUShader *UNUSED(shader), int location, int length, int arraysize, const int *value)
{
	if (location == -1)
		return;

	if (length == 1) glUniform1iv(location, arraysize, value);
	else if (length == 2) glUniform2iv(location, arraysize, value);
	else if (length == 3) glUniform3iv(location, arraysize, value);
	else if (length == 4) glUniform4iv(location, arraysize, value);
}

void GPU_shader_uniform_int(GPUShader *UNUSED(shader), int location, int value)
{
	if (location == -1)
		return;

	glUniform1i(location, value);
}

void GPU_shader_uniform_buffer(GPUShader *shader, int location, GPUUniformBuffer *ubo)
{
	int bindpoint = GPU_uniformbuffer_bindpoint(ubo);

	if (location == -1) {
		return;
	}

	glUniformBlockBinding(shader->program, location, bindpoint);
}

void GPU_shader_uniform_texture(GPUShader *UNUSED(shader), int location, GPUTexture *tex)
{
	int number = GPU_texture_bound_number(tex);

	if (number == -1) {
		fprintf(stderr, "Texture is not bound.\n");
		BLI_assert(0);
		return;
	}

	if (location == -1)
		return;

	glUniform1i(location, number);
}

int GPU_shader_get_attribute(GPUShader *shader, const char *name)
{
	BLI_assert(shader && shader->program);
	const GPUShaderInput *attr = GPU_shaderinterface_attr(shader->interface, name);
	return attr ? attr->location : -1;
}

static const GPUShaderStages builtin_shader_stages[GPU_SHADER_BUILTIN_LEN] = {
	[GPU_SHADER_TEXT] = {
		.vert = datatoc_gpu_shader_text_vert_glsl,
		.geom = datatoc_gpu_shader_text_geom_glsl,
		.frag = datatoc_gpu_shader_text_frag_glsl,
	},
	[GPU_SHADER_TEXT_SIMPLE] = {
		.vert = datatoc_gpu_shader_text_simple_vert_glsl,
		.geom = datatoc_gpu_shader_text_simple_geom_glsl,
		.frag = datatoc_gpu_shader_text_frag_glsl,
	},
	[GPU_SHADER_KEYFRAME_DIAMOND] = {
		.vert = datatoc_gpu_shader_keyframe_diamond_vert_glsl,
		.frag = datatoc_gpu_shader_keyframe_diamond_frag_glsl,
	},
	/*  This version is magical but slow!  */
	[GPU_SHADER_EDGES_FRONT_BACK_PERSP] = {
		.vert = datatoc_gpu_shader_edges_front_back_persp_vert_glsl,
		.geom = datatoc_gpu_shader_edges_front_back_persp_geom_glsl,
		.frag = datatoc_gpu_shader_flat_color_frag_glsl,
	},
	[GPU_SHADER_EDGES_FRONT_BACK_ORTHO] = {
		.vert = datatoc_gpu_shader_edges_front_back_ortho_vert_glsl,
		.frag = datatoc_gpu_shader_flat_color_frag_glsl,
	},
	[GPU_SHADER_EDGES_OVERLAY_SIMPLE] = {
		.vert = datatoc_gpu_shader_3D_vert_glsl,
		.geom = datatoc_gpu_shader_edges_overlay_simple_geom_glsl,
		.frag = datatoc_gpu_shader_edges_overlay_frag_glsl,
	},
	[GPU_SHADER_EDGES_OVERLAY] = {
		.vert = datatoc_gpu_shader_edges_overlay_vert_glsl,
		.geom = datatoc_gpu_shader_edges_overlay_geom_glsl,
		.frag = datatoc_gpu_shader_edges_overlay_frag_glsl,
	},
	[GPU_SHADER_SIMPLE_LIGHTING] = {
		.vert = datatoc_gpu_shader_3D_normal_vert_glsl,
		.frag = datatoc_gpu_shader_simple_lighting_frag_glsl,
	},
	/* Use 'USE_FLAT_NORMAL' to make flat shader from smooth  */
	[GPU_SHADER_SIMPLE_LIGHTING_FLAT_COLOR] = {
		.vert = datatoc_gpu_shader_3D_normal_smooth_color_vert_glsl,
		.frag = datatoc_gpu_shader_simple_lighting_smooth_color_frag_glsl,
		.defs =
		"#define USE_FLAT_NORMAL\n",
	},
	[GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR] = {
		.vert = datatoc_gpu_shader_3D_normal_smooth_color_vert_glsl,
		.frag = datatoc_gpu_shader_simple_lighting_smooth_color_frag_glsl,
	},
	[GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR_ALPHA] = {
		.vert = datatoc_gpu_shader_3D_normal_smooth_color_vert_glsl,
		.frag = datatoc_gpu_shader_simple_lighting_smooth_color_alpha_frag_glsl,
	},

	[GPU_SHADER_2D_IMAGE_MASK_UNIFORM_COLOR] = {
		.vert = datatoc_gpu_shader_3D_image_vert_glsl,
		.frag = datatoc_gpu_shader_image_mask_uniform_color_frag_glsl,
	},
	[GPU_SHADER_3D_IMAGE_MODULATE_ALPHA] = {
		.vert = datatoc_gpu_shader_3D_image_vert_glsl,
		.frag = datatoc_gpu_shader_image_modulate_alpha_frag_glsl,
	},
	[GPU_SHADER_3D_IMAGE_DEPTH] = {
		.vert = datatoc_gpu_shader_3D_image_vert_glsl,
		.frag = datatoc_gpu_shader_image_depth_linear_frag_glsl,
	},
	[GPU_SHADER_3D_IMAGE_DEPTH_COPY] = {
		.vert = datatoc_gpu_shader_3D_image_vert_glsl,
		.frag = datatoc_gpu_shader_image_depth_copy_frag_glsl,
	},
	[GPU_SHADER_2D_IMAGE_MULTISAMPLE_2] = {
		.vert = datatoc_gpu_shader_2D_vert_glsl,
		.frag = datatoc_gpu_shader_image_multisample_resolve_frag_glsl,
		.defs =
		"#define SAMPLES 2\n",
	},
	[GPU_SHADER_2D_IMAGE_MULTISAMPLE_4] = {
		.vert = datatoc_gpu_shader_2D_vert_glsl,
		.frag = datatoc_gpu_shader_image_multisample_resolve_frag_glsl,
		.defs =
		"#define SAMPLES 4\n",
	},
	[GPU_SHADER_2D_IMAGE_MULTISAMPLE_8] = {
		.vert = datatoc_gpu_shader_2D_vert_glsl,
		.frag = datatoc_gpu_shader_image_multisample_resolve_frag_glsl,
		.defs =
		"#define SAMPLES 8\n",
	},
	[GPU_SHADER_2D_IMAGE_MULTISAMPLE_16] = {
		.vert = datatoc_gpu_shader_2D_vert_glsl,
		.frag = datatoc_gpu_shader_image_multisample_resolve_frag_glsl,
		.defs =
		"#define SAMPLES 16\n",
	},
	[GPU_SHADER_2D_IMAGE_MULTISAMPLE_2_DEPTH_TEST] = {
		.vert = datatoc_gpu_shader_2D_vert_glsl,
		.frag = datatoc_gpu_shader_image_multisample_resolve_frag_glsl,
		.defs =
		"#define SAMPLES 2\n"
		"#define USE_DEPTH\n",
	},
	[GPU_SHADER_2D_IMAGE_MULTISAMPLE_4_DEPTH_TEST] = {
		.vert = datatoc_gpu_shader_2D_vert_glsl,
		.frag = datatoc_gpu_shader_image_multisample_resolve_frag_glsl,
		.defs =
		"#define SAMPLES 4\n"
		"#define USE_DEPTH\n",
	},
	[GPU_SHADER_2D_IMAGE_MULTISAMPLE_8_DEPTH_TEST] = {
		.vert = datatoc_gpu_shader_2D_vert_glsl,
		.frag = datatoc_gpu_shader_image_multisample_resolve_frag_glsl,
		.defs =
		"#define SAMPLES 8\n"
		"#define USE_DEPTH\n",
	},
	[GPU_SHADER_2D_IMAGE_MULTISAMPLE_16_DEPTH_TEST] = {
		.vert = datatoc_gpu_shader_2D_vert_glsl,
		.frag = datatoc_gpu_shader_image_multisample_resolve_frag_glsl,
		.defs =
		"#define SAMPLES 16\n"
		"#define USE_DEPTH\n",
	},

	[GPU_SHADER_2D_IMAGE_INTERLACE] = {
		.vert = datatoc_gpu_shader_2D_image_vert_glsl,
		.frag = datatoc_gpu_shader_image_interlace_frag_glsl,
	},
	[GPU_SHADER_2D_CHECKER] = {
		.vert = datatoc_gpu_shader_2D_vert_glsl,
		.frag = datatoc_gpu_shader_checker_frag_glsl,
	},

	[GPU_SHADER_2D_DIAG_STRIPES] = {
		.vert = datatoc_gpu_shader_2D_vert_glsl,
		.frag = datatoc_gpu_shader_diag_stripes_frag_glsl,
	},

	[GPU_SHADER_2D_UNIFORM_COLOR] = {
		.vert = datatoc_gpu_shader_2D_vert_glsl,
		.frag = datatoc_gpu_shader_uniform_color_frag_glsl,
	},
	[GPU_SHADER_2D_FLAT_COLOR] = {
		.vert = datatoc_gpu_shader_2D_flat_color_vert_glsl,
		.frag = datatoc_gpu_shader_flat_color_frag_glsl,
	},
	[GPU_SHADER_2D_SMOOTH_COLOR] = {
		.vert = datatoc_gpu_shader_2D_smooth_color_vert_glsl,
		.frag = datatoc_gpu_shader_2D_smooth_color_frag_glsl,
	},
	[GPU_SHADER_2D_SMOOTH_COLOR_DITHER] = {
		.vert = datatoc_gpu_shader_2D_smooth_color_vert_glsl,
		.frag = datatoc_gpu_shader_2D_smooth_color_dithered_frag_glsl,
	},
	[GPU_SHADER_2D_IMAGE_LINEAR_TO_SRGB] = {
		.vert = datatoc_gpu_shader_2D_image_vert_glsl,
		.frag = datatoc_gpu_shader_image_linear_frag_glsl,
	},
	[GPU_SHADER_2D_IMAGE] = {
		.vert = datatoc_gpu_shader_2D_image_vert_glsl,
		.frag = datatoc_gpu_shader_image_frag_glsl,
	},
	[GPU_SHADER_2D_IMAGE_COLOR] = {
		.vert = datatoc_gpu_shader_2D_image_vert_glsl,
		.frag = datatoc_gpu_shader_image_color_frag_glsl,
	},
	[GPU_SHADER_2D_IMAGE_DESATURATE_COLOR] = {
		.vert = datatoc_gpu_shader_2D_image_vert_glsl,
		.frag = datatoc_gpu_shader_image_desaturate_frag_glsl,
	},
	[GPU_SHADER_2D_IMAGE_ALPHA_COLOR] = {
		.vert = datatoc_gpu_shader_2D_image_vert_glsl,
		.frag = datatoc_gpu_shader_image_alpha_color_frag_glsl,
	},
	[GPU_SHADER_2D_IMAGE_SHUFFLE_COLOR] = {
		.vert = datatoc_gpu_shader_2D_image_vert_glsl,
		.frag = datatoc_gpu_shader_image_shuffle_color_frag_glsl,
	},
	[GPU_SHADER_2D_IMAGE_RECT_COLOR] = {
		.vert = datatoc_gpu_shader_2D_image_rect_vert_glsl,
		.frag = datatoc_gpu_shader_image_color_frag_glsl,
	},
	[GPU_SHADER_2D_IMAGE_MULTI_RECT_COLOR] = {
		.vert = datatoc_gpu_shader_2D_image_multi_rect_vert_glsl,
		.frag = datatoc_gpu_shader_image_varying_color_frag_glsl,
	},

	[GPU_SHADER_3D_UNIFORM_COLOR] = {
		.vert = datatoc_gpu_shader_3D_vert_glsl,
		.frag = datatoc_gpu_shader_uniform_color_frag_glsl,
	},
	[GPU_SHADER_3D_UNIFORM_COLOR_BACKGROUND] = {
		.vert = datatoc_gpu_shader_3D_vert_glsl,
		.frag = datatoc_gpu_shader_uniform_color_frag_glsl,
		.defs =
		"#define USE_BACKGROUND\n",
	},
	[GPU_SHADER_3D_FLAT_COLOR] = {
		.vert = datatoc_gpu_shader_3D_flat_color_vert_glsl,
		.frag = datatoc_gpu_shader_flat_color_frag_glsl,
	},
	[GPU_SHADER_3D_SMOOTH_COLOR] = {
		.vert = datatoc_gpu_shader_3D_smooth_color_vert_glsl,
		.frag = datatoc_gpu_shader_3D_smooth_color_frag_glsl,
	},
	[GPU_SHADER_3D_DEPTH_ONLY] = {
		.vert = datatoc_gpu_shader_3D_vert_glsl,
		.frag = datatoc_gpu_shader_depth_only_frag_glsl,
	},
	[GPU_SHADER_3D_CLIPPED_UNIFORM_COLOR] = {
		.vert = datatoc_gpu_shader_3D_clipped_uniform_color_vert_glsl,
		.frag = datatoc_gpu_shader_uniform_color_frag_glsl,
	},

	[GPU_SHADER_3D_GROUNDPOINT] = {
		.vert = datatoc_gpu_shader_3D_groundpoint_vert_glsl,
		.frag = datatoc_gpu_shader_point_uniform_color_frag_glsl,
	},
	[GPU_SHADER_3D_GROUNDLINE] = {
		.vert = datatoc_gpu_shader_3D_passthrough_vert_glsl,
		.geom = datatoc_gpu_shader_3D_groundline_geom_glsl,
		.frag = datatoc_gpu_shader_uniform_color_frag_glsl,
	},

	[GPU_SHADER_2D_LINE_DASHED_UNIFORM_COLOR] = {
		.vert = datatoc_gpu_shader_2D_line_dashed_uniform_color_vert_glsl,
		.geom = datatoc_gpu_shader_2D_line_dashed_geom_glsl,
		.frag = datatoc_gpu_shader_2D_line_dashed_frag_glsl,
	},
	[GPU_SHADER_3D_LINE_DASHED_UNIFORM_COLOR] = {
		.vert = datatoc_gpu_shader_3D_line_dashed_uniform_color_vert_glsl,
		.geom = datatoc_gpu_shader_2D_line_dashed_geom_glsl,
		.frag = datatoc_gpu_shader_2D_line_dashed_frag_glsl,
	},

	[GPU_SHADER_3D_OBJECTSPACE_SIMPLE_LIGHTING_VARIYING_COLOR] = {
		.vert = datatoc_gpu_shader_instance_objectspace_variying_color_vert_glsl,
		.frag = datatoc_gpu_shader_simple_lighting_frag_glsl,
		.defs =
		"#define USE_INSTANCE_COLOR\n",
	},
	[GPU_SHADER_3D_OBJECTSPACE_VARIYING_COLOR] = {
		.vert = datatoc_gpu_shader_instance_objectspace_variying_color_vert_glsl,
		.frag = datatoc_gpu_shader_flat_color_frag_glsl,
	},
	[GPU_SHADER_3D_SCREENSPACE_VARIYING_COLOR] = {
		.vert = datatoc_gpu_shader_instance_screenspace_variying_color_vert_glsl,
		.frag = datatoc_gpu_shader_flat_color_frag_glsl,
	},
	[GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED_AXIS] = {
		.vert = datatoc_gpu_shader_instance_screen_aligned_vert_glsl,
		.frag = datatoc_gpu_shader_flat_color_frag_glsl,
		.defs =
		"#define AXIS_NAME\n",
	},
	[GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED] = {
		.vert = datatoc_gpu_shader_instance_screen_aligned_vert_glsl,
		.frag = datatoc_gpu_shader_flat_color_frag_glsl,
	},

	[GPU_SHADER_CAMERA] = {
		.vert = datatoc_gpu_shader_instance_camera_vert_glsl,
		.frag = datatoc_gpu_shader_flat_color_frag_glsl,
	},
	[GPU_SHADER_DISTANCE_LINES] = {
		.vert = datatoc_gpu_shader_instance_distance_line_vert_glsl,
		.frag = datatoc_gpu_shader_flat_color_frag_glsl,
	},

	[GPU_SHADER_2D_POINT_FIXED_SIZE_UNIFORM_COLOR] = {
		.vert = datatoc_gpu_shader_2D_vert_glsl,
		.frag = datatoc_gpu_shader_point_uniform_color_frag_glsl,
	},
	[GPU_SHADER_2D_POINT_VARYING_SIZE_VARYING_COLOR] = {
		.vert = datatoc_gpu_shader_2D_point_varying_size_varying_color_vert_glsl,
		.frag = datatoc_gpu_shader_point_varying_color_frag_glsl,
	},
	[GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA] = {
		.vert = datatoc_gpu_shader_2D_point_uniform_size_aa_vert_glsl,
		.frag = datatoc_gpu_shader_point_uniform_color_aa_frag_glsl,
	},
	[GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA] = {
		.vert = datatoc_gpu_shader_2D_point_uniform_size_outline_aa_vert_glsl,
		.frag = datatoc_gpu_shader_point_uniform_color_outline_aa_frag_glsl,
	},
	[GPU_SHADER_2D_POINT_UNIFORM_SIZE_VARYING_COLOR_OUTLINE_AA] = {
		.vert = datatoc_gpu_shader_2D_point_uniform_size_varying_color_outline_aa_vert_glsl,
		.frag = datatoc_gpu_shader_point_varying_color_outline_aa_frag_glsl,
	},
	[GPU_SHADER_3D_POINT_FIXED_SIZE_UNIFORM_COLOR] = {
		.vert = datatoc_gpu_shader_3D_vert_glsl,
		.frag = datatoc_gpu_shader_point_uniform_color_frag_glsl,
	},
	[GPU_SHADER_3D_POINT_FIXED_SIZE_VARYING_COLOR] = {
		.vert = datatoc_gpu_shader_3D_point_fixed_size_varying_color_vert_glsl,
		.frag = datatoc_gpu_shader_point_varying_color_frag_glsl,
	},
	[GPU_SHADER_3D_POINT_VARYING_SIZE_UNIFORM_COLOR] = {
		.vert = datatoc_gpu_shader_3D_point_varying_size_vert_glsl,
		.frag = datatoc_gpu_shader_point_uniform_color_frag_glsl,
	},
	[GPU_SHADER_3D_POINT_VARYING_SIZE_VARYING_COLOR] = {
		.vert = datatoc_gpu_shader_3D_point_varying_size_varying_color_vert_glsl,
		.frag = datatoc_gpu_shader_point_varying_color_frag_glsl,
	},
	[GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA] = {
		.vert = datatoc_gpu_shader_3D_point_uniform_size_aa_vert_glsl,
		.frag = datatoc_gpu_shader_point_uniform_color_aa_frag_glsl,
	},
	[GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA] = {
		.vert = datatoc_gpu_shader_3D_point_uniform_size_outline_aa_vert_glsl,
		.frag = datatoc_gpu_shader_point_uniform_color_outline_aa_frag_glsl,
	},

	[GPU_SHADER_INSTANCE_UNIFORM_COLOR] = {
		.vert = datatoc_gpu_shader_instance_vert_glsl,
		.frag = datatoc_gpu_shader_uniform_color_frag_glsl,
	},
	[GPU_SHADER_INSTANCE_VARIYING_ID_VARIYING_SIZE] = {
		.vert = datatoc_gpu_shader_instance_variying_size_variying_id_vert_glsl,
		.frag = datatoc_gpu_shader_flat_id_frag_glsl,
		.defs =
		"#define UNIFORM_SCALE\n",
	},
	[GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE] = {
		.vert = datatoc_gpu_shader_instance_variying_size_variying_color_vert_glsl,
		.frag = datatoc_gpu_shader_flat_color_frag_glsl,
		.defs =
		"#define UNIFORM_SCALE\n",
	},
	[GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SCALE] = {
		.vert = datatoc_gpu_shader_instance_variying_size_variying_color_vert_glsl,
		.frag = datatoc_gpu_shader_flat_color_frag_glsl,
	},
	[GPU_SHADER_INSTANCE_EDGES_VARIYING_COLOR] = {
		.vert = datatoc_gpu_shader_instance_edges_variying_color_vert_glsl,
		.geom = datatoc_gpu_shader_instance_edges_variying_color_geom_glsl,
		.frag = datatoc_gpu_shader_flat_color_frag_glsl,
	},

	[GPU_SHADER_2D_AREA_EDGES] = {
		.vert = datatoc_gpu_shader_2D_area_borders_vert_glsl,
		.frag = datatoc_gpu_shader_2D_area_borders_frag_glsl,
	},
	[GPU_SHADER_2D_WIDGET_BASE] = {
		.vert = datatoc_gpu_shader_2D_widget_base_vert_glsl,
		.frag = datatoc_gpu_shader_2D_widget_base_frag_glsl,
	},
	[GPU_SHADER_2D_WIDGET_BASE_INST] = {
		.vert = datatoc_gpu_shader_2D_widget_base_vert_glsl,
		.frag = datatoc_gpu_shader_2D_widget_base_frag_glsl,
		.defs =
		"#define USE_INSTANCE\n",
	},
	[GPU_SHADER_2D_WIDGET_SHADOW] = {
		.vert = datatoc_gpu_shader_2D_widget_shadow_vert_glsl,
		.frag = datatoc_gpu_shader_2D_widget_shadow_frag_glsl,
	},
	[GPU_SHADER_2D_NODELINK] = {
		.vert = datatoc_gpu_shader_2D_nodelink_vert_glsl,
		.frag = datatoc_gpu_shader_2D_nodelink_frag_glsl,
	},
	[GPU_SHADER_2D_NODELINK_INST] = {
		.vert = datatoc_gpu_shader_2D_nodelink_vert_glsl,
		.frag = datatoc_gpu_shader_2D_nodelink_frag_glsl,
		.defs =
		"#define USE_INSTANCE\n",
	},

	[GPU_SHADER_2D_UV_UNIFORM_COLOR] = {
		.vert = datatoc_gpu_shader_2D_vert_glsl,
		.frag = datatoc_gpu_shader_uniform_color_frag_glsl,
		.defs =
		"#define UV_POS\n",
	},
	[GPU_SHADER_2D_UV_VERTS] = {
		.vert = datatoc_gpu_shader_2D_edituvs_points_vert_glsl,
		.frag = datatoc_gpu_shader_point_varying_color_varying_outline_aa_frag_glsl,
	},
	[GPU_SHADER_2D_UV_FACEDOTS] = {
		.vert = datatoc_gpu_shader_2D_edituvs_facedots_vert_glsl,
		.frag = datatoc_gpu_shader_point_varying_color_frag_glsl,
	},
	[GPU_SHADER_2D_UV_EDGES] = {
		.vert = datatoc_gpu_shader_2D_edituvs_edges_vert_glsl,
		.frag = datatoc_gpu_shader_flat_color_frag_glsl,
	},
	[GPU_SHADER_2D_UV_EDGES_SMOOTH] = {
		.vert = datatoc_gpu_shader_2D_edituvs_edges_vert_glsl,
		.frag = datatoc_gpu_shader_2D_smooth_color_frag_glsl,
		.defs =
		"#define SMOOTH_COLOR\n",
	},
	[GPU_SHADER_2D_UV_FACES] = {
		.vert = datatoc_gpu_shader_2D_edituvs_faces_vert_glsl,
		.frag = datatoc_gpu_shader_flat_color_frag_glsl,
	},
	[GPU_SHADER_2D_UV_FACES_STRETCH_AREA] = {
		.vert = datatoc_gpu_shader_2D_edituvs_stretch_vert_glsl,
		.frag = datatoc_gpu_shader_2D_smooth_color_frag_glsl,
	},
	[GPU_SHADER_2D_UV_FACES_STRETCH_ANGLE] = {
		.vert = datatoc_gpu_shader_2D_edituvs_stretch_vert_glsl,
		.frag = datatoc_gpu_shader_2D_smooth_color_frag_glsl,
		.defs =
		"#define STRETCH_ANGLE\n",
	},

	[GPU_SHADER_3D_FLAT_SELECT_ID] = {
		.vert = datatoc_gpu_shader_3D_selection_id_vert_glsl,
		.frag = datatoc_gpu_shader_selection_id_frag_glsl,
	},
	[GPU_SHADER_3D_UNIFORM_SELECT_ID] = {
		.vert = datatoc_gpu_shader_3D_selection_id_vert_glsl,
		.frag = datatoc_gpu_shader_selection_id_frag_glsl,
		.defs =
		"#define UNIFORM_ID\n",
	},

	[GPU_SHADER_GPENCIL_STROKE] = {
		.vert = datatoc_gpu_shader_gpencil_stroke_vert_glsl,
		.geom = datatoc_gpu_shader_gpencil_stroke_geom_glsl,
		.frag = datatoc_gpu_shader_gpencil_stroke_frag_glsl,
	},

	[GPU_SHADER_GPENCIL_FILL] = {
		.vert = datatoc_gpu_shader_gpencil_fill_vert_glsl,
		.frag = datatoc_gpu_shader_gpencil_fill_frag_glsl,
	},
};

GPUShader *GPU_shader_get_builtin_shader_with_config(
        eGPUBuiltinShader shader, eGPUShaderConfig sh_cfg)
{
	BLI_assert(shader < GPU_SHADER_BUILTIN_LEN);
	BLI_assert(sh_cfg < GPU_SHADER_CFG_LEN);
	GPUShader **sh_p = &builtin_shaders[sh_cfg][shader];

	if (*sh_p == NULL) {
		GPUShaderStages stages_legacy = {NULL};
		const GPUShaderStages *stages = &builtin_shader_stages[shader];

		if (shader == GPU_SHADER_EDGES_FRONT_BACK_PERSP) {
			/* TODO: remove after switch to core profile (maybe) */
			if (!GLEW_VERSION_3_2) {
				stages_legacy.vert = datatoc_gpu_shader_edges_front_back_persp_legacy_vert_glsl;
				stages_legacy.frag = datatoc_gpu_shader_flat_color_alpha_test_0_frag_glsl;
				stages = &stages_legacy;
			}
		}
		else if (shader == GPU_SHADER_3D_LINE_DASHED_UNIFORM_COLOR) {
			/* Dashed need geometry shader, which are not supported by legacy OpenGL, fallback to solid lines. */
			/* TODO: remove after switch to core profile (maybe) */
			if (!GLEW_VERSION_3_2) {
				stages_legacy.vert = datatoc_gpu_shader_3D_line_dashed_uniform_color_legacy_vert_glsl;
				stages_legacy.frag = datatoc_gpu_shader_2D_line_dashed_frag_glsl;
				stages = &stages_legacy;
			}
		}

		/* common case */
		if (sh_cfg == GPU_SHADER_CFG_DEFAULT) {
			*sh_p = GPU_shader_create(stages->vert, stages->frag, stages->geom, NULL, stages->defs, __func__);
		}
		else if (sh_cfg == GPU_SHADER_CFG_CLIPPED) {
			/* Remove eventually, for now ensure support for each shader has been added. */
			BLI_assert(ELEM(shader,
			                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,
			                GPU_SHADER_3D_FLAT_SELECT_ID,
			                GPU_SHADER_3D_UNIFORM_SELECT_ID) ||
			           ELEM(shader,
			                GPU_SHADER_3D_FLAT_COLOR,
			                GPU_SHADER_3D_LINE_DASHED_UNIFORM_COLOR));
			const char *world_clip_lib = datatoc_gpu_shader_cfg_world_clip_lib_glsl;
			const char *world_clip_def = "#define USE_WORLD_CLIP_PLANES\n";
			/* In rare cases geometry shaders calculate clipping themselves. */
			*sh_p = GPU_shader_create_from_arrays({
			        .vert = (const char *[]){world_clip_lib, stages->vert, NULL},
			        .geom = (const char *[]){stages->geom ? world_clip_lib : NULL, stages->geom, NULL},
			        .frag = (const char *[]){stages->frag, NULL},
			        .defs = (const char *[]){world_clip_def, stages->defs, NULL},
			});
		}
		else {
			BLI_assert(0);
		}
	}

	return *sh_p;
}
GPUShader *GPU_shader_get_builtin_shader(eGPUBuiltinShader shader)
{
	return GPU_shader_get_builtin_shader_with_config(shader, GPU_SHADER_CFG_DEFAULT);
}

void GPU_shader_get_builtin_shader_code(
        eGPUBuiltinShader shader,
        const char **r_vert, const char **r_frag,
        const char **r_geom, const char **r_defines)
{
	const GPUShaderStages *stages = &builtin_shader_stages[shader];
	*r_vert = stages->vert;
	*r_frag = stages->frag;
	*r_geom = stages->geom;
	*r_defines = stages->defs;
}

void GPU_shader_free_builtin_shaders(void)
{
	for (int i = 0; i < GPU_SHADER_CFG_LEN; i++) {
		for (int j = 0; j < GPU_SHADER_BUILTIN_LEN; j++) {
			if (builtin_shaders[i][j]) {
				GPU_shader_free(builtin_shaders[i][j]);
				builtin_shaders[i][j] = NULL;
			}
		}
	}
}