Merge branch 'master' into asset-browser-grid-viewasset-browser-grid-view

94 files changed, 388 insertions, 2316 deletions

diff --git a/source/blender/gpu/shaders/common/gpu_shader_common_math.glsl b/source/blender/gpu/shaders/common/gpu_shader_common_math.glsl
index 5f640f64056..1e858bd4760 100644
--- a/source/blender/gpu/shaders/common/gpu_shader_common_math.glsl
+++ b/source/blender/gpu/shaders/common/gpu_shader_common_math.glsl
@@ -126,7 +126,7 @@ void math_pingpong(float a, float b, float c, out float result)
   result = (b != 0.0) ? abs(fract((a - b) / (b * 2.0)) * b * 2.0 - b) : 0.0;
 }
 
-/* Adapted from godotengine math_funcs.h. */
+/* Adapted from GODOT-engine math_funcs.h. */
 void math_wrap(float a, float b, float c, out float result)
 {
   result = wrap(a, b, c);
diff --git a/source/blender/gpu/shaders/common/gpu_shader_common_math_utils.glsl b/source/blender/gpu/shaders/common/gpu_shader_common_math_utils.glsl
index 1ba22b4c5da..47f8e26db0b 100644
--- a/source/blender/gpu/shaders/common/gpu_shader_common_math_utils.glsl
+++ b/source/blender/gpu/shaders/common/gpu_shader_common_math_utils.glsl
@@ -132,7 +132,7 @@ vec3 fallback_pow(vec3 a, float b, vec3 fallback)
               fallback_pow(a.z, b, fallback.z));
 }
 
-/* Matirx Math */
+/* Matrix Math */
 
 /* Return a 2D rotation matrix with the angle that the input 2D vector makes with the x axis. */
 mat2 vector_to_rotation_matrix(vec2 vector)
diff --git a/source/blender/gpu/shaders/compositor/compositor_alpha_crop.glsl b/source/blender/gpu/shaders/compositor/compositor_alpha_crop.glsl
deleted file mode 100644
index d55c8efd4c6..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_alpha_crop.glsl
+++ /dev/null
@@ -1,11 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-  /* The lower bound is inclusive and upper bound is exclusive. */
-  bool is_inside = all(greaterThanEqual(texel, lower_bound)) && all(lessThan(texel, upper_bound));
-  /* Write the pixel color if it is inside the cropping region, otherwise, write zero. */
-  vec4 color = is_inside ? texture_load(input_tx, texel) : vec4(0.0);
-  imageStore(output_img, texel, color);
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_bilateral_blur.glsl b/source/blender/gpu/shaders/compositor/compositor_bilateral_blur.glsl
deleted file mode 100644
index c7c5ada7a9f..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_bilateral_blur.glsl
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-
-  vec4 center_determinator = texture_load(determinator_tx, texel);
-
-  /* Go over the pixels in the blur window of the specified radius around the center pixel, and for
-   * pixels whose determinator is close enough to the determinator of the center pixel, accumulate
-   * their color as well as their weights. */
-  float accumulated_weight = 0.0;
-  vec4 accumulated_color = vec4(0.0);
-  for (int y = -radius; y <= radius; y++) {
-    for (int x = -radius; x <= radius; x++) {
-      vec4 determinator = texture_load(determinator_tx, texel + ivec2(x, y));
-      float difference = dot(abs(center_determinator - determinator).rgb, vec3(1.0));
-
-      if (difference < threshold) {
-        accumulated_weight += 1.0;
-        accumulated_color += texture_load(input_tx, texel + ivec2(x, y));
-      }
-    }
-  }
-
-  /* Write the accumulated color divided by the accumulated weight if any pixel in the window was
-   * accumulated, otherwise, write a fallback black color. */
-  vec4 fallback = vec4(vec3(0.0), 1.0);
-  vec4 color = (accumulated_weight != 0.0) ? (accumulated_color / accumulated_weight) : fallback;
-  imageStore(output_img, texel, color);
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_blur.glsl b/source/blender/gpu/shaders/compositor/compositor_blur.glsl
deleted file mode 100644
index 4f981c84f59..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_blur.glsl
+++ /dev/null
@@ -1,55 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_common_math_utils.glsl)
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-vec4 load_input(ivec2 texel)
-{
-  vec4 color;
-  if (extend_bounds) {
-    /* If bounds are extended, then we treat the input as padded by a radius amount of pixels. So
-     * we load the input with an offset by the radius amount and fallback to a transparent color if
-     * it is out of bounds. */
-    color = texture_load(input_tx, texel - radius, vec4(0.0));
-  }
-  else {
-    color = texture_load(input_tx, texel);
-  }
-
-  return color;
-}
-
-/* Given the texel in the range [-radius, radius] in both axis, load the appropriate weight from
- * the weights texture, where the texel (0, 0) is considered the center of weights texture. */
-vec4 load_weight(ivec2 texel)
-{
-  /* Add the radius to transform the texel into the range [0, radius * 2], then divide by the upper
-   * bound plus one to transform the texel into the normalized range [0, 1] needed to sample the
-   * weights sampler. Finally, also add 0.5 to sample at the center of the pixels. */
-  return texture(weights_tx, (texel + vec2(radius + 0.5)) / (radius * 2 + 1));
-}
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-
-  /* The mask input is treated as a boolean. If it is zero, then no blurring happens for this
-   * pixel. Otherwise, the pixel is blurred normally and the mask value is irrelevant. */
-  float mask = texture_load(mask_tx, texel).x;
-  if (mask == 0.0) {
-    imageStore(output_img, texel, texture_load(input_tx, texel));
-    return;
-  }
-
-  /* Go over the window of the given radius and accumulate the colors multiplied by their
-   * respective weights as well as the weights themselves. */
-  vec4 accumulated_color = vec4(0.0);
-  vec4 accumulated_weight = vec4(0.0);
-  for (int y = -radius; y <= radius; y++) {
-    for (int x = -radius; x <= radius; x++) {
-      vec4 weight = load_weight(ivec2(x, y));
-      accumulated_color += load_input(texel + ivec2(x, y)) * weight;
-      accumulated_weight += weight;
-    }
-  }
-
-  imageStore(output_img, texel, safe_divide(accumulated_color, accumulated_weight));
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_bokeh_image.glsl b/source/blender/gpu/shaders/compositor/compositor_bokeh_image.glsl
deleted file mode 100644
index 6e98aa9fe17..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_bokeh_image.glsl
+++ /dev/null
@@ -1,118 +0,0 @@
-#pragma BLENDER_REQUIRE(common_math_lib.glsl)
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-/* Get the 2D vertex position of the vertex with the given index in the regular polygon
- * representing this bokeh. The polygon is rotated by the rotation amount and have a unit
- * circumradius. The regular polygon is one whose vertices' exterior angles are given by
- * exterior_angle. See the bokeh function for more information. */
-vec2 get_regular_polygon_vertex_position(int vertex_index)
-{
-  float angle = exterior_angle * vertex_index - rotation;
-  return vec2(cos(angle), sin(angle));
-}
-
-/* Find the closest point to the given point on the given line. This assumes the length of the
- * given line is not zero. */
-vec2 closest_point_on_line(vec2 point, vec2 line_start, vec2 line_end)
-{
-  vec2 line_vector = line_end - line_start;
-  vec2 point_vector = point - line_start;
-  float line_length_squared = dot(line_vector, line_vector);
-  float parameter = dot(point_vector, line_vector) / line_length_squared;
-  return line_start + line_vector * parameter;
-}
-
-/* Compute the value of the bokeh at the given point. The computed bokeh is essentially a regular
- * polygon centered in space having the given circumradius. The regular polygon is one whose
- * vertices' exterior angles are given by "exterior_angle", which relates to the number of vertices
- * n through the equation "exterior angle = 2 pi / n". The regular polygon may additionally morph
- * into a shape with the given properties:
- *
- * - The regular polygon may have a circular hole in its center whose radius is controlled by the
- *   "catadioptric" value.
- * - The regular polygon is rotated by the "rotation" value.
- * - The regular polygon can morph into a circle controlled by the "roundness" value, such that it
- *   becomes a full circle at unit roundness.
- *
- * The function returns 0 when the point lies inside the regular polygon and 1 otherwise. However,
- * at the edges, it returns a narrow band gradient as a form of anti-aliasing. */
-float bokeh(vec2 point, float circumradius)
-{
-  /* Get the index of the vertex of the regular polygon whose polar angle is maximum but less than
-   * the polar angle of the given point, taking rotation into account. This essentially finds the
-   * vertex closest to the given point in the clock-wise direction. */
-  float angle = mod(atan(point.y, point.x) + rotation, M_2PI);
-  int vertex_index = int(angle / exterior_angle);
-
-  /* Compute the shortest distance between the origin and the polygon edge composed from the
-   * previously selected vertex and the one following it. */
-  vec2 first_vertex = get_regular_polygon_vertex_position(vertex_index) * circumradius;
-  vec2 second_vertex = get_regular_polygon_vertex_position(vertex_index + 1) * circumradius;
-  vec2 closest_point = closest_point_on_line(point, first_vertex, second_vertex);
-  float distance_to_edge = length(closest_point);
-
-  /* Mix the distance to the edge with the circumradius, making it tend to the distance to a
-   * circle when roundness tends to 1. */
-  float distance_to_edge_round = mix(distance_to_edge, circumradius, roundness);
-
-  /* The point is outside of the bokeh, so we return 0. */
-  float distance = length(point);
-  if (distance > distance_to_edge_round) {
-    return 0.0;
-  }
-
-  /* The point is inside the catadioptric hole and is not part of the bokeh, so we return 0. */
-  float catadioptric_distance = distance_to_edge_round * catadioptric;
-  if (distance < catadioptric_distance) {
-    return 0.0;
-  }
-
-  /* The point is very close to the edge of the bokeh, so we return the difference between the
-   * distance to the edge and the distance as a form of anti-aliasing. */
-  if (distance_to_edge_round - distance < 1.0) {
-    return distance_to_edge_round - distance;
-  }
-
-  /* The point is very close to the edge of the catadioptric hole, so we return the difference
-   * between the distance to the hole and the distance as a form of anti-aliasing. */
-  if (catadioptric != 0.0 && distance - catadioptric_distance < 1.0) {
-    return distance - catadioptric_distance;
-  }
-
-  /* Otherwise, the point is part of the bokeh and we return 1. */
-  return 1.0;
-}
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-
-  /* Since we need the regular polygon to occupy the entirety of the output image, the circumradius
-   * of the regular polygon is half the width of the output image. */
-  float circumradius = float(imageSize(output_img).x) / 2.0;
-
-  /* Move the texel coordinates such that the regular polygon is centered. */
-  vec2 point = vec2(texel) - circumradius;
-
-  /* Each of the color channels of the output image contains a bokeh with a different circumradius.
-   * The largest one occupies the whole image as stated above, while the other two have circumradii
-   * that are shifted by an amount that is proportional to the "lens_shift" value. The alpha
-   * channel of the output is the average of all three values. */
-  float min_shift = abs(lens_shift * circumradius);
-  float min = mix(bokeh(point, circumradius - min_shift), 0.0, min_shift == circumradius);
-
-  float median_shift = min_shift / 2.0;
-  float median = bokeh(point, circumradius - median_shift);
-
-  float max = bokeh(point, circumradius);
-  vec4 bokeh = vec4(min, median, max, (max + median + min) / 3.0);
-
-  /* If the lens shift is negative, swap the min and max bokeh values, which are stored in the red
-   * and blue channels respectively. Note that we take the absolute value of the lens shift above,
-   * so the sign of the lens shift only controls this swap. */
-  if (lens_shift < 0) {
-    bokeh = bokeh.zyxw;
-  }
-
-  imageStore(output_img, texel, bokeh);
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_box_mask.glsl b/source/blender/gpu/shaders/compositor/compositor_box_mask.glsl
deleted file mode 100644
index fad23f28fde..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_box_mask.glsl
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-
-  vec2 uv = vec2(texel) / vec2(domain_size - ivec2(1));
-  uv -= location;
-  uv.y *= float(domain_size.y) / float(domain_size.x);
-  uv = mat2(cos_angle, -sin_angle, sin_angle, cos_angle) * uv;
-  bool is_inside = all(lessThan(abs(uv), size));
-
-  float base_mask_value = texture_load(base_mask_tx, texel).x;
-  float value = texture_load(mask_value_tx, texel).x;
-
-#if defined(CMP_NODE_MASKTYPE_ADD)
-  float output_mask_value = is_inside ? max(base_mask_value, value) : base_mask_value;
-#elif defined(CMP_NODE_MASKTYPE_SUBTRACT)
-  float output_mask_value = is_inside ? clamp(base_mask_value - value, 0.0, 1.0) : base_mask_value;
-#elif defined(CMP_NODE_MASKTYPE_MULTIPLY)
-  float output_mask_value = is_inside ? base_mask_value * value : 0.0;
-#elif defined(CMP_NODE_MASKTYPE_NOT)
-  float output_mask_value = is_inside ? (base_mask_value > 0.0 ? 0.0 : value) : base_mask_value;
-#endif
-
-  imageStore(output_mask_img, texel, vec4(output_mask_value));
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_convert.glsl b/source/blender/gpu/shaders/compositor/compositor_convert.glsl
deleted file mode 100644
index 044fb057ca5..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_convert.glsl
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-  vec4 value = texture_load(input_tx, texel);
-  imageStore(output_img, texel, CONVERT_EXPRESSION(value));
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_despeckle.glsl b/source/blender/gpu/shaders/compositor/compositor_despeckle.glsl
deleted file mode 100644
index e4743d69d17..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_despeckle.glsl
+++ /dev/null
@@ -1,70 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-/* Returns true if the given color is close enough to the given reference color within the
- * threshold supplied by the user, and returns false otherwise. */
-bool is_close(vec4 reference_color, vec4 color)
-{
-  return all(lessThan(abs(reference_color - color).rgb, vec3(threshold)));
-}
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-
-  /* A 3x3 weights kernel whose weights are the inverse of the distance to the center of the
-   * kernel. So the center weight is zero, the corners weights are (1 / sqrt(2)), and the rest
-   * of the weights are 1. The total sum of weights is 4 plus quadruple the corner weight. */
-  float corner_weight = 1.0 / sqrt(2.0);
-  float sum_of_weights = 4.0 + corner_weight * 4.0;
-  mat3 weights = mat3(vec3(corner_weight, 1.0, corner_weight),
-                      vec3(1.0, 0.0, 1.0),
-                      vec3(corner_weight, 1.0, corner_weight));
-
-  vec4 center_color = texture_load(input_tx, texel);
-
-  /* Go over the pixels in the 3x3 window around the center pixel and compute the total sum of
-   * their colors multiplied by their weights. Additionally, for pixels whose colors are not close
-   * enough to the color of the center pixel, accumulate their color as well as their weights. */
-  vec4 sum_of_colors = vec4(0);
-  float accumulated_weight = 0.0;
-  vec4 accumulated_color = vec4(0);
-  for (int j = 0; j < 3; j++) {
-    for (int i = 0; i < 3; i++) {
-      float weight = weights[j][i];
-      vec4 color = texture_load(input_tx, texel + ivec2(i - 1, j - 1)) * weight;
-      sum_of_colors += color;
-      if (!is_close(center_color, color)) {
-        accumulated_color += color;
-        accumulated_weight += weight;
-      }
-    }
-  }
-
-  /* If the accumulated weight is zero, that means all pixels in the 3x3 window are similar and no
-   * need to despeckle anything, so write the original center color and return. */
-  if (accumulated_weight == 0.0) {
-    imageStore(output_img, texel, center_color);
-    return;
-  }
-
-  /* If the ratio between the accumulated weights and the total sum of weights is not larger than
-   * the user specified neighbor threshold, then the number of pixels in the neighborhood that are
-   * not close enough to the center pixel is low, and no need to despeckle anything, so write the
-   * original center color and return. */
-  if (accumulated_weight / sum_of_weights < neighbor_threshold) {
-    imageStore(output_img, texel, center_color);
-    return;
-  }
-
-  /* If the weighted average color of the neighborhood is close enough to the center pixel, then no
-   * need to despeckle anything, so write the original center color and return. */
-  if (is_close(center_color, sum_of_colors / sum_of_weights)) {
-    imageStore(output_img, texel, center_color);
-    return;
-  }
-
-  /* We need to despeckle, so write the mean accumulated color. */
-  float factor = texture_load(factor_tx, texel).x;
-  vec4 mean_color = accumulated_color / accumulated_weight;
-  imageStore(output_img, texel, mix(center_color, mean_color, factor));
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_directional_blur.glsl b/source/blender/gpu/shaders/compositor/compositor_directional_blur.glsl
deleted file mode 100644
index 1805cb5a7f5..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_directional_blur.glsl
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-  ivec2 input_size = texture_size(input_tx);
-
-  /* Add 0.5 to evaluate the input sampler at the center of the pixel. */
-  vec2 coordinates = vec2(texel) + vec2(0.5);
-
-  /* For each iteration, accumulate the input at the normalize coordinates, hence the divide by
-   * input size, then transform the coordinates for the next iteration. */
-  vec4 accumulated_color = vec4(0.0);
-  for (int i = 0; i < iterations; i++) {
-    accumulated_color += texture(input_tx, coordinates / input_size);
-    coordinates = (mat3(inverse_transformation) * vec3(coordinates, 1.0)).xy;
-  }
-
-  /* Write the accumulated color divided by the number of iterations. */
-  imageStore(output_img, texel, accumulated_color / iterations);
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_edge_filter.glsl b/source/blender/gpu/shaders/compositor/compositor_edge_filter.glsl
deleted file mode 100644
index 67e27c22602..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_edge_filter.glsl
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-
-  /* Compute the dot product between the 3x3 window around the pixel and the edge detection kernel
-   * in the X direction and Y direction. The Y direction kernel is computed by transposing the
-   * given X direction kernel. */
-  vec3 color_x = vec3(0);
-  vec3 color_y = vec3(0);
-  for (int j = 0; j < 3; j++) {
-    for (int i = 0; i < 3; i++) {
-      vec3 color = texture_load(input_tx, texel + ivec2(i - 1, j - 1)).rgb;
-      color_x += color * kernel[j][i];
-      color_y += color * kernel[i][j];
-    }
-  }
-
-  /* Compute the channel-wise magnitude of the 2D vector composed from the X and Y edge detection
-   * filter results. */
-  vec3 magnitude = sqrt(color_x * color_x + color_y * color_y);
-
-  /* Mix the channel-wise magnitude with the original color at the center of the kernel using the
-   * input factor. */
-  vec4 color = texture_load(input_tx, texel);
-  magnitude = mix(color.rgb, magnitude, texture_load(factor_tx, texel).x);
-
-  /* Store the channel-wise magnitude with the original alpha of the input. */
-  imageStore(output_img, texel, vec4(magnitude, color.a));
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_ellipse_mask.glsl b/source/blender/gpu/shaders/compositor/compositor_ellipse_mask.glsl
deleted file mode 100644
index 28f725067e0..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_ellipse_mask.glsl
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-
-  vec2 uv = vec2(texel) / vec2(domain_size - ivec2(1));
-  uv -= location;
-  uv.y *= float(domain_size.y) / float(domain_size.x);
-  uv = mat2(cos_angle, -sin_angle, sin_angle, cos_angle) * uv;
-  bool is_inside = length(uv / radius) < 1.0;
-
-  float base_mask_value = texture_load(base_mask_tx, texel).x;
-  float value = texture_load(mask_value_tx, texel).x;
-
-#if defined(CMP_NODE_MASKTYPE_ADD)
-  float output_mask_value = is_inside ? max(base_mask_value, value) : base_mask_value;
-#elif defined(CMP_NODE_MASKTYPE_SUBTRACT)
-  float output_mask_value = is_inside ? clamp(base_mask_value - value, 0.0, 1.0) : base_mask_value;
-#elif defined(CMP_NODE_MASKTYPE_MULTIPLY)
-  float output_mask_value = is_inside ? base_mask_value * value : 0.0;
-#elif defined(CMP_NODE_MASKTYPE_NOT)
-  float output_mask_value = is_inside ? (base_mask_value > 0.0 ? 0.0 : value) : base_mask_value;
-#endif
-
-  imageStore(output_mask_img, texel, vec4(output_mask_value));
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_filter.glsl b/source/blender/gpu/shaders/compositor/compositor_filter.glsl
deleted file mode 100644
index e501c563dda..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_filter.glsl
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-
-  /* Compute the dot product between the 3x3 window around the pixel and the filter kernel. */
-  vec4 color = vec4(0);
-  for (int j = 0; j < 3; j++) {
-    for (int i = 0; i < 3; i++) {
-      color += texture_load(input_tx, texel + ivec2(i - 1, j - 1)) * kernel[j][i];
-    }
-  }
-
-  /* Mix with the original color at the center of the kernel using the input factor. */
-  color = mix(texture_load(input_tx, texel), color, texture_load(factor_tx, texel).x);
-
-  /* Store the color making sure it is not negative. */
-  imageStore(output_img, texel, max(color, 0.0));
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_flip.glsl b/source/blender/gpu/shaders/compositor/compositor_flip.glsl
deleted file mode 100644
index 919c454ee63..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_flip.glsl
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-  ivec2 size = texture_size(input_tx);
-  ivec2 flipped_texel = texel;
-  if (flip_x) {
-    flipped_texel.x = size.x - texel.x - 1;
-  }
-  if (flip_y) {
-    flipped_texel.y = size.y - texel.y - 1;
-  }
-  imageStore(output_img, texel, texture_load(input_tx, flipped_texel));
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_image_crop.glsl b/source/blender/gpu/shaders/compositor/compositor_image_crop.glsl
deleted file mode 100644
index f20e033dee4..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_image_crop.glsl
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-  imageStore(output_img, texel, texture_load(input_tx, texel + lower_bound));
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_morphological_distance.glsl b/source/blender/gpu/shaders/compositor/compositor_morphological_distance.glsl
deleted file mode 100644
index 09f896b7a9d..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_morphological_distance.glsl
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma BLENDER_REQUIRE(common_math_lib.glsl)
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-
-  /* Find the minimum/maximum value in the circular window of the given radius around the pixel. By
-   * circular window, we mean that pixels in the window whose distance to the center of window is
-   * larger than the given radius are skipped and not considered. Consequently, the dilation or
-   * erosion that take place produces round results as opposed to squarish ones. This is
-   * essentially a morphological operator with a circular structuring element. The LIMIT value
-   * should be FLT_MAX if OPERATOR is min and FLT_MIN if OPERATOR is max. */
-  float value = LIMIT;
-  for (int y = -radius; y <= radius; y++) {
-    for (int x = -radius; x <= radius; x++) {
-      if (x * x + y * y <= radius * radius) {
-        value = OPERATOR(value, texture_load(input_tx, texel + ivec2(x, y), vec4(LIMIT)).x);
-      }
-    }
-  }
-
-  imageStore(output_img, texel, vec4(value));
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_morphological_distance_feather.glsl b/source/blender/gpu/shaders/compositor/compositor_morphological_distance_feather.glsl
deleted file mode 100644
index acdd8a40342..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_morphological_distance_feather.glsl
+++ /dev/null
@@ -1,101 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-/* The Morphological Distance Feather operation is a linear combination between the result of two
- * operations. The first operation is a Gaussian blur with a radius equivalent to the dilate/erode
- * distance, which is straightforward and implemented as a separable filter similar to the blur
- * operation.
- *
- * The second operation is an approximation of a morphological inverse distance operation evaluated
- * at a distance falloff function. The result of a morphological inverse distance operation is a
- * narrow band distance field that starts at its maximum value at boundaries where a difference in
- * values took place and linearly deceases until it reaches zero in the span of a number of pixels
- * equivalent to the erode/dilate distance. Additionally, instead of linearly decreasing, the user
- * may choose a different falloff which is evaluated at the computed distance. For dilation, the
- * distance field decreases outwards, and for erosion, the distance field decreased inwards.
- *
- * The reason why the result of a Gaussian blur is mixed in with the distance field is because the
- * distance field is merely approximated and not accurately computed, the defects of which is more
- * apparent away from boundaries and especially at corners where the distance field should take a
- * circular shape. That's why the Gaussian blur is mostly mixed only further from boundaries.
- *
- * The morphological inverse distance operation is approximated using a separable implementation
- * and intertwined with the Gaussian blur implementation as follows. A search window of a radius
- * equivalent to the dilate/erode distance is applied on the image to find either the minimum or
- * maximum pixel value multiplied by its corresponding falloff value in the window. For dilation,
- * we try to find the maximum, and for erosion, we try to find the minimum. Additionally, we also
- * save the falloff value where the minimum or maximum was found. The found value will be that of
- * the narrow band distance field and the saved falloff value will be used as the mixing factor
- * with the Gaussian blur.
- *
- * To make sense of the aforementioned algorithm, assume we are dilating a binary image by 5 pixels
- * whose half has a value of 1 and the other half has a value of zero. Consider the following:
- *
- * - A pixel of value 1 already has the maximum possible value, so its value will remain unchanged
- *   regardless of its position.
- * - A pixel of value 0 that is right at the boundary of the 1's region will have a maximum value
- *   of around 0.8 depending on the falloff. That's because the search window intersects the 1's
- *   region, which when multiplied by the falloff gives the first value of the falloff, which is
- *   larger than the initially zero value computed at the center of the search window.
- * - A pixel of value 0 that is 3 pixels away from the boundary will have a maximum value of around
- *   0.4 depending on the falloff. That's because the search window intersects the 1's region,
- *   which when multiplied by the falloff gives the third value of the falloff, which is larger
- *   than the initially zero value computed at the center of the search window.
- * - Finally, a pixel of value 0 that is 6 pixels away from the boundary will have a maximum value
- *   of 0, because the search window doesn't intersects the 1's region and only spans zero values.
- *
- * The previous example demonstrates how the distance field naturally arises, and the same goes for
- * the erode case, except the minimum value is computed instead.
- */
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-
-  /* A value for accumulating the blur result. */
-  float accumulated_value = 0.0;
-
-  /* Compute the contribution of the center pixel to the blur result. */
-  float center_value = texture_load(input_tx, texel).x;
-  accumulated_value += center_value * texture_load(weights_tx, 0).x;
-
-  /* Start with the center value as the maximum/minimum distance and reassign to the true maximum
-   * or minimum in the search loop below. Additionally, the center falloff is always 1.0, so start
-   * with that. */
-  float limit_distance = center_value;
-  float limit_distance_falloff = 1.0;
-
-  /* Compute the contributions of the pixels to the right and left, noting that the weights and
-   * falloffs textures only store the weights and falloffs for the positive half, but since the
-   * they are both symmetric, the same weights and falloffs are used for the negative half and we
-   * compute both of their contributions. */
-  for (int i = 1; i < texture_size(weights_tx); i++) {
-    float weight = texture_load(weights_tx, i).x;
-    float falloff = texture_load(falloffs_tx, i).x;
-
-    /* Loop for two iterations, where s takes the value of -1 and 1, which is used as the sign
-     * needed to evaluated the positive and negative sides as explain above. */
-    for (int s = -1; s < 2; s += 2) {
-      /* Compute the contribution of the pixel to the blur result. */
-      float value = texture_load(input_tx, texel + ivec2(s * i, 0)).x;
-      accumulated_value += value * weight;
-
-      /* The distance is computed such that its highest value is the pixel value itself, so
-       * multiply the distance falloff by the pixel value. */
-      float falloff_distance = value * falloff;
-
-      /* Find either the maximum or the minimum for the dilate and erode cases respectively. */
-      if (COMPARE(falloff_distance, limit_distance)) {
-        limit_distance = falloff_distance;
-        limit_distance_falloff = falloff;
-      }
-    }
-  }
-
-  /* Mix between the limit distance and the blurred accumulated value such that the limit distance
-   * is used for pixels closer to the boundary and the blurred value is used for pixels away from
-   * the boundary. */
-  float value = mix(accumulated_value, limit_distance, limit_distance_falloff);
-
-  /* Write the value using the transposed texel. See the execute_distance_feather_horizontal_pass
-   * method for more information on the rational behind this. */
-  imageStore(output_img, texel.yx, vec4(value));
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_morphological_distance_threshold.glsl b/source/blender/gpu/shaders/compositor/compositor_morphological_distance_threshold.glsl
deleted file mode 100644
index e6625e7419f..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_morphological_distance_threshold.glsl
+++ /dev/null
@@ -1,88 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-/* The Morphological Distance Threshold operation is effectively three consecutive operations
- * implemented as a single operation. The three operations are as follows:
- *
- * .-----------.   .--------------.   .----------------.
- * | Threshold |-->| Dilate/Erode |-->| Distance Inset |
- * '-----------'   '--------------'   '----------------'
- *
- * The threshold operation just converts the input into a binary image, where the pixel is 1 if it
- * is larger than 0.5 and 0 otherwise. Pixels that are 1 in the output of the threshold operation
- * are said to be masked. The dilate/erode operation is a dilate or erode morphological operation
- * with a circular structuring element depending on the sign of the distance, where it is a dilate
- * operation if the distance is positive and an erode operation otherwise. This is equivalent to
- * the Morphological Distance operation, see its implementation for more information. Finally, the
- * distance inset is an operation that converts the binary image into a narrow band distance field.
- * That is, pixels that are unmasked will remain 0, while pixels that are masked will start from
- * zero at the boundary of the masked region and linearly increase until reaching 1 in the span of
- * a number pixels given by the inset value.
- *
- * As a performance optimization, the dilate/erode operation is omitted and its effective result is
- * achieved by slightly adjusting the distance inset operation. The base distance inset operation
- * works by computing the signed distance from the current center pixel to the nearest pixel with a
- * different value. Since our image is a binary image, that means that if the pixel is masked, we
- * compute the signed distance to the nearest unmasked pixel, and if the pixel unmasked, we compute
- * the signed distance to the nearest masked pixel. The distance is positive if the pixel is masked
- * and negative otherwise. The distance is then normalized by dividing by the given inset value and
- * clamped to the [0, 1] range. Since distances larger than the inset value are eventually clamped,
- * the distance search window is limited to a radius equivalent to the inset value.
- *
- * To archive the effective result of the omitted dilate/erode operation, we adjust the distance
- * inset operation as follows. First, we increase the radius of the distance search window by the
- * radius of the dilate/erode operation. Then we adjust the resulting narrow band signed distance
- * field as follows.
- *
- * For the erode case, we merely subtract the erode distance, which makes the outermost erode
- * distance number of pixels zero due to clamping, consequently achieving the result of the erode,
- * while retaining the needed inset because we increased the distance search window by the same
- * amount we subtracted.
- *
- * Similarly, for the dilate case, we add the dilate distance, which makes the dilate distance
- * number of pixels just outside of the masked region positive and part of the narrow band distance
- * field, consequently achieving the result of the dilate, while at the same time, the innermost
- * dilate distance number of pixels become 1 due to clamping, retaining the needed inset because we
- * increased the distance search window by the same amount we added.
- *
- * Since the erode/dilate distance is already signed appropriately as described before, we just add
- * it in both cases. */
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-
-  /* Apply a threshold operation on the center pixel, where the threshold is currently hard-coded
-   * at 0.5. The pixels with values larger than the threshold are said to be masked. */
-  bool is_center_masked = texture_load(input_tx, texel).x > 0.5;
-
-  /* Since the distance search window will access pixels outside of the bounds of the image, we use
-   * a texture loader with a fallback value. And since we don't want those values to affect the
-   * result, the fallback value is chosen such that the inner condition fails, which is when the
-   * sampled pixel and the center pixel are the same, so choose a fallback that will be considered
-   * masked if the center pixel is masked and unmasked otherwise. */
-  vec4 fallback = vec4(is_center_masked ? 1.0 : 0.0);
-
-  /* Since the distance search window is limited to the given radius, the maximum possible squared
-   * distance to the center is double the squared radius. */
-  int minimum_squared_distance = radius * radius * 2;
-
-  /* Find the squared distance to the nearest different pixel in the search window of the given
-   * radius. */
-  for (int y = -radius; y <= radius; y++) {
-    for (int x = -radius; x <= radius; x++) {
-      bool is_sample_masked = texture_load(input_tx, texel + ivec2(x, y), fallback).x > 0.5;
-      if (is_center_masked != is_sample_masked) {
-        minimum_squared_distance = min(minimum_squared_distance, x * x + y * y);
-      }
-    }
-  }
-
-  /* Compute the actual distance from the squared distance and assign it an appropriate sign
-   * depending on whether it lies in a masked region or not. */
-  float signed_minimum_distance = sqrt(minimum_squared_distance) * (is_center_masked ? 1.0 : -1.0);
-
-  /* Add the erode/dilate distance and divide by the inset amount as described in the discussion,
-   * then clamp to the [0, 1] range. */
-  float value = clamp((signed_minimum_distance + distance) / inset, 0.0, 1.0);
-
-  imageStore(output_img, texel, vec4(value));
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_morphological_step.glsl b/source/blender/gpu/shaders/compositor/compositor_morphological_step.glsl
deleted file mode 100644
index 6992bc2afa5..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_morphological_step.glsl
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma BLENDER_REQUIRE(common_math_lib.glsl)
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-
-  /* Find the minimum/maximum value in the window of the given radius around the pixel. This is
-   * essentially a morphological operator with a square structuring element. The LIMIT value should
-   * be FLT_MAX if OPERATOR is min and FLT_MIN if OPERATOR is max. */
-  float value = LIMIT;
-  for (int i = -radius; i <= radius; i++) {
-    value = OPERATOR(value, texture_load(input_tx, texel + ivec2(i, 0), vec4(LIMIT)).x);
-  }
-
-  /* Write the value using the transposed texel. See the execute_step_horizontal_pass method for
-   * more information on the rational behind this. */
-  imageStore(output_img, texel.yx, vec4(value));
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_projector_lens_distortion.glsl b/source/blender/gpu/shaders/compositor/compositor_projector_lens_distortion.glsl
deleted file mode 100644
index ab44dac93e6..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_projector_lens_distortion.glsl
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-
-  /* Get the normalized coordinates of the pixel centers. */
-  vec2 normalized_texel = (vec2(texel) + vec2(0.5)) / vec2(texture_size(input_tx));
-
-  /* Sample the red and blue channels shifted by the dispersion amount. */
-  const float red = texture(input_tx, normalized_texel + vec2(dispersion, 0.0)).r;
-  const float green = texture_load(input_tx, texel).g;
-  const float blue = texture(input_tx, normalized_texel - vec2(dispersion, 0.0)).b;
-
-  imageStore(output_img, texel, vec4(red, green, blue, 1.0));
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_realize_on_domain.glsl b/source/blender/gpu/shaders/compositor/compositor_realize_on_domain.glsl
deleted file mode 100644
index b8561e5f059..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_realize_on_domain.glsl
+++ /dev/null
@@ -1,29 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-
-  /* Add 0.5 to evaluate the input sampler at the center of the pixel. */
-  vec2 coordinates = vec2(texel) + vec2(0.5);
-
-  /* Transform the input image by transforming the domain coordinates with the inverse of input
-   * image's transformation. The inverse transformation is an affine matrix and thus the
-   * coordinates should be in homogeneous coordinates. */
-  coordinates = (mat3(inverse_transformation) * vec3(coordinates, 1.0)).xy;
-
-  /* Since an input image with an identity transformation is supposed to be centered in the domain,
-   * we subtract the offset between the lower left corners of the input image and the domain, which
-   * is half the difference between their sizes, because the difference in size is on both sides of
-   * the centered image. Additionally, we floor the offset to retain the 0.5 offset added above in
-   * case the difference in sizes was odd. */
-  ivec2 domain_size = imageSize(domain_img);
-  ivec2 input_size = texture_size(input_tx);
-  vec2 offset = floor((domain_size - input_size) / 2.0);
-
-  /* Subtract the offset and divide by the input image size to get the relevant coordinates into
-   * the sampler's expected [0, 1] range. */
-  vec2 normalized_coordinates = (coordinates - offset) / input_size;
-
-  imageStore(domain_img, texel, texture(input_tx, normalized_coordinates));
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_screen_lens_distortion.glsl b/source/blender/gpu/shaders/compositor/compositor_screen_lens_distortion.glsl
deleted file mode 100644
index dc572ea5aaf..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_screen_lens_distortion.glsl
+++ /dev/null
@@ -1,151 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_common_hash.glsl)
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-/* A model that approximates lens distortion parameterized by a distortion parameter and dependent
- * on the squared distance to the center of the image. The distorted pixel is then computed as the
- * scalar multiplication of the pixel coordinates with the value returned by this model. See the
- * compute_distorted_uv function for more details. */
-float compute_distortion_scale(float distortion, float distance_squared)
-{
-  return 1.0 / (1.0 + sqrt(max(0.0, 1.0 - distortion * distance_squared)));
-}
-
-/* A vectorized version of compute_distortion_scale that is applied on the chromatic distortion
- * parameters passed to the shader. */
-vec3 compute_chromatic_distortion_scale(float distance_squared)
-{
-  return 1.0 / (1.0 + sqrt(max(vec3(0.0), 1.0 - chromatic_distortion * distance_squared)));
-}
-
-/* Compute the image coordinates after distortion by the given distortion scale computed by the
- * compute_distortion_scale function. Note that the function expects centered normalized UV
- * coordinates but outputs non-centered image coordinates. */
-vec2 compute_distorted_uv(vec2 uv, float scale)
-{
-  return (uv * scale + 0.5) * texture_size(input_tx) - 0.5;
-}
-
-/* Compute the number of integration steps that should be used to approximate the distorted pixel
- * using a heuristic, see the compute_number_of_steps function for more details. The numbers of
- * steps is proportional to the number of pixels spanned by the distortion amount. For jitter
- * distortion, the square root of the distortion amount plus 1 is used with a minimum of 2 steps.
- * For non-jitter distortion, the distortion amount plus 1 is used as the number of steps */
-int compute_number_of_integration_steps_heuristic(float distortion)
-{
-#if defined(JITTER)
-  return distortion < 4.0 ? 2 : int(sqrt(distortion + 1.0));
-#else
-  return int(distortion + 1.0);
-#endif
-}
-
-/* Compute the number of integration steps that should be used to compute each channel of the
- * distorted pixel. Each of the channels are distorted by their respective chromatic distortion
- * amount, then the amount of distortion between each two consecutive channels is computed, this
- * amount is then used to heuristically infer the number of needed integration steps, see the
- * integrate_distortion function for more information. */
-ivec3 compute_number_of_integration_steps(vec2 uv, float distance_squared)
-{
-  /* Distort each channel by its respective chromatic distortion amount. */
-  vec3 distortion_scale = compute_chromatic_distortion_scale(distance_squared);
-  vec2 distorted_uv_red = compute_distorted_uv(uv, distortion_scale.r);
-  vec2 distorted_uv_green = compute_distorted_uv(uv, distortion_scale.g);
-  vec2 distorted_uv_blue = compute_distorted_uv(uv, distortion_scale.b);
-
-  /* Infer the number of needed integration steps to compute the distorted red channel starting
-   * from the green channel. */
-  float distortion_red = distance(distorted_uv_red, distorted_uv_green);
-  int steps_red = compute_number_of_integration_steps_heuristic(distortion_red);
-
-  /* Infer the number of needed integration steps to compute the distorted blue channel starting
-   * from the green channel. */
-  float distortion_blue = distance(distorted_uv_green, distorted_uv_blue);
-  int steps_blue = compute_number_of_integration_steps_heuristic(distortion_blue);
-
-  /* The number of integration steps used to compute the green channel is the sum of both the red
-   * and the blue channel steps because it is computed once with each of them. */
-  return ivec3(steps_red, steps_red + steps_blue, steps_blue);
-}
-
-/* Returns a random jitter amount, which is essentially a random value in the [0, 1] range. If
- * jitter is not enabled, return a constant 0.5 value instead. */
-float get_jitter(int seed)
-{
-#if defined(JITTER)
-  return hash_uint3_to_float(gl_GlobalInvocationID.x, gl_GlobalInvocationID.y, seed);
-#else
-  return 0.5;
-#endif
-}
-
-/* Each color channel may have a different distortion with the guarantee that the red will have the
- * lowest distortion while the blue will have the highest one. If each channel is distorted
- * independently, the image will look disintegrated, with each channel seemingly merely shifted.
- * Consequently, the distorted pixels needs to be computed by integrating along the path of change
- * of distortion starting from one channel to another. For instance, to compute the distorted red
- * from the distorted green, we accumulate the color of the distorted pixel starting from the
- * distortion of the red, taking small steps until we reach the distortion of the green. The pixel
- * color is weighted such that it is maximum at the start distortion and zero at the end distortion
- * in an arithmetic progression. The integration steps can be augmented with random values to
- * simulate lens jitter. Finally, it should be noted that this function integrates both the start
- * and end channels in reverse directions for more efficient computation. */
-vec3 integrate_distortion(int start, int end, float distance_squared, vec2 uv, int steps)
-{
-  vec3 accumulated_color = vec3(0.0);
-  float distortion_amount = chromatic_distortion[end] - chromatic_distortion[start];
-  for (int i = 0; i < steps; i++) {
-    /* The increment will be in the [0, 1) range across iterations. */
-    float increment = (i + get_jitter(i)) / steps;
-    float distortion = chromatic_distortion[start] + increment * distortion_amount;
-    float distortion_scale = compute_distortion_scale(distortion, distance_squared);
-
-    /* Sample the color at the distorted coordinates and accumulate it weighted by the increment
-     * value for both the start and end channels. */
-    vec2 distorted_uv = compute_distorted_uv(uv, distortion_scale);
-    vec4 color = texture(input_tx, distorted_uv / texture_size(input_tx));
-    accumulated_color[start] += (1.0 - increment) * color[start];
-    accumulated_color[end] += increment * color[end];
-  }
-  return accumulated_color;
-}
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-
-  /* Compute the UV image coordinates in the range [-1, 1] as well as the squared distance to the
-   * center of the image, which is at (0, 0) in the UV coordinates. */
-  vec2 center = texture_size(input_tx) / 2.0;
-  vec2 uv = scale * (texel + 0.5 - center) / center;
-  float distance_squared = dot(uv, uv);
-
-  /* If any of the color channels will get distorted outside of the screen beyond what is possible,
-   * write a zero transparent color and return. */
-  if (any(greaterThan(chromatic_distortion * distance_squared, vec3(1.0)))) {
-    imageStore(output_img, texel, vec4(0.0));
-    return;
-  }
-
-  /* Compute the number of integration steps that should be used to compute each channel of the
-   * distorted pixel. */
-  ivec3 number_of_steps = compute_number_of_integration_steps(uv, distance_squared);
-
-  /* Integrate the distortion of the red and green, then the green and blue channels. That means
-   * the green will be integrated twice, but this is accounted for in the number of steps which the
-   * color will later be divided by. See the compute_number_of_integration_steps function for more
-   * details. */
-  vec3 color = vec3(0.0);
-  color += integrate_distortion(0, 1, distance_squared, uv, number_of_steps.r);
-  color += integrate_distortion(1, 2, distance_squared, uv, number_of_steps.b);
-
-  /* The integration above performed weighted accumulation, and thus the color needs to be divided
-   * by the sum of the weights. Assuming no jitter, the weights are generated as an arithmetic
-   * progression starting from (0.5 / n) to ((n - 0.5) / n) for n terms. The sum of an arithmetic
-   * progression can be computed as (n * (start + end) / 2), which when subsisting the start and
-   * end reduces to (n / 2). So the color should be multiplied by 2 / n. The jitter sequence
-   * approximately sums to the same value because it is a uniform random value whose mean value is
-   * 0.5, so the expression doesn't change regardless of jitter. */
-  color *= 2.0 / vec3(number_of_steps);
-
-  imageStore(output_img, texel, vec4(color, 1.0));
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_set_alpha.glsl b/source/blender/gpu/shaders/compositor/compositor_set_alpha.glsl
deleted file mode 100644
index 7dd40581790..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_set_alpha.glsl
+++ /dev/null
@@ -1,8 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-  vec4 color = vec4(texture_load(image_tx, texel).rgb, texture_load(alpha_tx, texel).x);
-  imageStore(output_img, texel, color);
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_split_viewer.glsl b/source/blender/gpu/shaders/compositor/compositor_split_viewer.glsl
deleted file mode 100644
index 866b9045da2..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_split_viewer.glsl
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-#if defined(SPLIT_HORIZONTAL)
-  bool condition = (view_size.x * split_ratio) < texel.x;
-#elif defined(SPLIT_VERTICAL)
-  bool condition = (view_size.y * split_ratio) < texel.y;
-#endif
-  vec4 color = condition ? texture_load(first_image_tx, texel) :
-                           texture_load(second_image_tx, texel);
-  imageStore(output_img, texel, color);
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_symmetric_blur.glsl b/source/blender/gpu/shaders/compositor/compositor_symmetric_blur.glsl
deleted file mode 100644
index df08991a35c..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_symmetric_blur.glsl
+++ /dev/null
@@ -1,77 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_blur_common.glsl)
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-vec4 load_input(ivec2 texel)
-{
-  vec4 color;
-  if (extend_bounds) {
-    /* If bounds are extended, then we treat the input as padded by a radius amount of pixels. So
-     * we load the input with an offset by the radius amount and fallback to a transparent color if
-     * it is out of bounds. Notice that we subtract 1 because the weights texture have an extra
-     * center weight, see the SymmetricBlurWeights for more information. */
-    ivec2 blur_size = texture_size(weights_tx) - 1;
-    color = texture_load(input_tx, texel - blur_size, vec4(0.0));
-  }
-  else {
-    color = texture_load(input_tx, texel);
-  }
-
-  if (gamma_correct) {
-    color = gamma_correct_blur_input(color);
-  }
-
-  return color;
-}
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-
-  vec4 accumulated_color = vec4(0.0);
-
-  /* First, compute the contribution of the center pixel. */
-  vec4 center_color = load_input(texel);
-  accumulated_color += center_color * texture_load(weights_tx, ivec2(0)).x;
-
-  ivec2 weights_size = texture_size(weights_tx);
-
-  /* Then, compute the contributions of the pixels along the x axis of the filter, noting that the
-   * weights texture only stores the weights for the positive half, but since the filter is
-   * symmetric, the same weight is used for the negative half and we add both of their
-   * contributions. */
-  for (int x = 1; x < weights_size.x; x++) {
-    float weight = texture_load(weights_tx, ivec2(x, 0)).x;
-    accumulated_color += load_input(texel + ivec2(x, 0)) * weight;
-    accumulated_color += load_input(texel + ivec2(-x, 0)) * weight;
-  }
-
-  /* Then, compute the contributions of the pixels along the y axis of the filter, noting that the
-   * weights texture only stores the weights for the positive half, but since the filter is
-   * symmetric, the same weight is used for the negative half and we add both of their
-   * contributions. */
-  for (int y = 1; y < weights_size.y; y++) {
-    float weight = texture_load(weights_tx, ivec2(0, y)).x;
-    accumulated_color += load_input(texel + ivec2(0, y)) * weight;
-    accumulated_color += load_input(texel + ivec2(0, -y)) * weight;
-  }
-
-  /* Finally, compute the contributions of the pixels in the four quadrants of the filter, noting
-   * that the weights texture only stores the weights for the upper right quadrant, but since the
-   * filter is symmetric, the same weight is used for the rest of the quadrants and we add all four
-   * of their contributions. */
-  for (int y = 1; y < weights_size.y; y++) {
-    for (int x = 1; x < weights_size.x; x++) {
-      float weight = texture_load(weights_tx, ivec2(x, y)).x;
-      accumulated_color += load_input(texel + ivec2(x, y)) * weight;
-      accumulated_color += load_input(texel + ivec2(-x, y)) * weight;
-      accumulated_color += load_input(texel + ivec2(x, -y)) * weight;
-      accumulated_color += load_input(texel + ivec2(-x, -y)) * weight;
-    }
-  }
-
-  if (gamma_correct) {
-    accumulated_color = gamma_uncorrect_blur_output(accumulated_color);
-  }
-
-  imageStore(output_img, texel, accumulated_color);
-}
diff --git a/source/blender/gpu/shaders/compositor/compositor_symmetric_separable_blur.glsl b/source/blender/gpu/shaders/compositor/compositor_symmetric_separable_blur.glsl
deleted file mode 100644
index ab0c7baa787..00000000000
--- a/source/blender/gpu/shaders/compositor/compositor_symmetric_separable_blur.glsl
+++ /dev/null
@@ -1,53 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_blur_common.glsl)
-#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
-
-vec4 load_input(ivec2 texel)
-{
-  vec4 color;
-  if (extend_bounds) {
-    /* If bounds are extended, then we treat the input as padded by a radius amount of pixels. So
-     * we load the input with an offset by the radius amount and fallback to a transparent color if
-     * it is out of bounds. Notice that we subtract 1 because the weights texture have an extra
-     * center weight, see the SymmetricSeparableBlurWeights for more information. */
-    int blur_size = texture_size(weights_tx) - 1;
-    color = texture_load(input_tx, texel - ivec2(blur_size, 0), vec4(0.0));
-  }
-  else {
-    color = texture_load(input_tx, texel);
-  }
-
-  if (gamma_correct_input) {
-    color = gamma_correct_blur_input(color);
-  }
-
-  return color;
-}
-
-void main()
-{
-  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
-
-  vec4 accumulated_color = vec4(0.0);
-
-  /* First, compute the contribution of the center pixel. */
-  vec4 center_color = load_input(texel);
-  accumulated_color += center_color * texture_load(weights_tx, 0).x;
-
-  /* Then, compute the contributions of the pixel to the right and left, noting that the
-   * weights texture only stores the weights for the positive half, but since the filter is
-   * symmetric, the same weight is used for the negative half and we add both of their
-   * contributions. */
-  for (int i = 1; i < texture_size(weights_tx); i++) {
-    float weight = texture_load(weights_tx, i).x;
-    accumulated_color += load_input(texel + ivec2(i, 0)) * weight;
-    accumulated_color += load_input(texel + ivec2(-i, 0)) * weight;
-  }
-
-  if (gamma_uncorrect_output) {
-    accumulated_color = gamma_uncorrect_blur_output(accumulated_color);
-  }
-
-  /* Write the color using the transposed texel. See the execute_separable_blur_horizontal_pass
-   * method for more information on the rational behind this. */
-  imageStore(output_img, texel.yx, accumulated_color);
-}
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_alpha_crop_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_alpha_crop_info.hh
deleted file mode 100644
index 11f2f329cd8..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_alpha_crop_info.hh
+++ /dev/null
@@ -1,12 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_alpha_crop)
-    .local_group_size(16, 16)
-    .push_constant(Type::IVEC2, "lower_bound")
-    .push_constant(Type::IVEC2, "upper_bound")
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_alpha_crop.glsl")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_bilateral_blur_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_bilateral_blur_info.hh
deleted file mode 100644
index 301cd6acd9e..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_bilateral_blur_info.hh
+++ /dev/null
@@ -1,13 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_bilateral_blur)
-    .local_group_size(16, 16)
-    .push_constant(Type::INT, "radius")
-    .push_constant(Type::FLOAT, "threshold")
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .sampler(1, ImageType::FLOAT_2D, "determinator_tx")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_bilateral_blur.glsl")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_blur_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_blur_info.hh
deleted file mode 100644
index 36b772aa486..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_blur_info.hh
+++ /dev/null
@@ -1,14 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_blur)
-    .local_group_size(16, 16)
-    .push_constant(Type::INT, "radius")
-    .push_constant(Type::BOOL, "extend_bounds")
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .sampler(1, ImageType::FLOAT_2D, "weights_tx")
-    .sampler(2, ImageType::FLOAT_2D, "mask_tx")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_blur.glsl")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_bokeh_image_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_bokeh_image_info.hh
deleted file mode 100644
index 3541de53070..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_bokeh_image_info.hh
+++ /dev/null
@@ -1,14 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_bokeh_image)
-    .local_group_size(16, 16)
-    .push_constant(Type::FLOAT, "exterior_angle")
-    .push_constant(Type::FLOAT, "rotation")
-    .push_constant(Type::FLOAT, "roundness")
-    .push_constant(Type::FLOAT, "catadioptric")
-    .push_constant(Type::FLOAT, "lens_shift")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_bokeh_image.glsl")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_box_mask_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_box_mask_info.hh
deleted file mode 100644
index ecb253bbab1..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_box_mask_info.hh
+++ /dev/null
@@ -1,35 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_box_mask_shared)
-    .local_group_size(16, 16)
-    .push_constant(Type::IVEC2, "domain_size")
-    .push_constant(Type::VEC2, "location")
-    .push_constant(Type::VEC2, "size")
-    .push_constant(Type::FLOAT, "cos_angle")
-    .push_constant(Type::FLOAT, "sin_angle")
-    .sampler(0, ImageType::FLOAT_2D, "base_mask_tx")
-    .sampler(1, ImageType::FLOAT_2D, "mask_value_tx")
-    .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_mask_img")
-    .compute_source("compositor_box_mask.glsl");
-
-GPU_SHADER_CREATE_INFO(compositor_box_mask_add)
-    .additional_info("compositor_box_mask_shared")
-    .define("CMP_NODE_MASKTYPE_ADD")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_box_mask_subtract)
-    .additional_info("compositor_box_mask_shared")
-    .define("CMP_NODE_MASKTYPE_SUBTRACT")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_box_mask_multiply)
-    .additional_info("compositor_box_mask_shared")
-    .define("CMP_NODE_MASKTYPE_MULTIPLY")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_box_mask_not)
-    .additional_info("compositor_box_mask_shared")
-    .define("CMP_NODE_MASKTYPE_NOT")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_convert_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_convert_info.hh
deleted file mode 100644
index 35e60056736..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_convert_info.hh
+++ /dev/null
@@ -1,69 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_convert_shared)
-    .local_group_size(16, 16)
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .typedef_source("gpu_shader_compositor_type_conversion.glsl")
-    .compute_source("compositor_convert.glsl");
-
-GPU_SHADER_CREATE_INFO(compositor_convert_float_to_vector)
-    .additional_info("compositor_convert_shared")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .define("CONVERT_EXPRESSION(value)", "vec4(vec3_from_float(value.x), 0.0)")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_convert_float_to_color)
-    .additional_info("compositor_convert_shared")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .define("CONVERT_EXPRESSION(value)", "vec4_from_float(value.x)")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_convert_color_to_float)
-    .additional_info("compositor_convert_shared")
-    .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .define("CONVERT_EXPRESSION(value)", "vec4(float_from_vec4(value), vec3(0.0))")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_convert_color_to_vector)
-    .additional_info("compositor_convert_shared")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .define("CONVERT_EXPRESSION(value)", "vec4(vec3_from_vec4(value), 0.0)")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_convert_vector_to_float)
-    .additional_info("compositor_convert_shared")
-    .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .define("CONVERT_EXPRESSION(value)", "vec4(float_from_vec3(value.xyz), vec3(0.0))")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_convert_vector_to_color)
-    .additional_info("compositor_convert_shared")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .define("CONVERT_EXPRESSION(value)", "vec4_from_vec3(value.xyz)")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_extract_alpha_from_color)
-    .additional_info("compositor_convert_shared")
-    .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .define("CONVERT_EXPRESSION(value)", "vec4(value.a, vec3(0.0))")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_convert_color_to_half_color)
-    .additional_info("compositor_convert_shared")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .define("CONVERT_EXPRESSION(value)", "value")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_convert_float_to_half_float)
-    .additional_info("compositor_convert_shared")
-    .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .define("CONVERT_EXPRESSION(value)", "vec4(value.r, vec3(0.0))")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_convert_color_to_opaque)
-    .additional_info("compositor_convert_shared")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .define("CONVERT_EXPRESSION(value)", "vec4(value.rgb, 1.0)")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_despeckle_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_despeckle_info.hh
deleted file mode 100644
index df86c3a8258..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_despeckle_info.hh
+++ /dev/null
@@ -1,13 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_despeckle)
-    .local_group_size(16, 16)
-    .push_constant(Type::FLOAT, "threshold")
-    .push_constant(Type::FLOAT, "neighbor_threshold")
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .sampler(1, ImageType::FLOAT_2D, "factor_tx")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_despeckle.glsl")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_directional_blur_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_directional_blur_info.hh
deleted file mode 100644
index bb9199dcd26..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_directional_blur_info.hh
+++ /dev/null
@@ -1,12 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_directional_blur)
-    .local_group_size(16, 16)
-    .push_constant(Type::INT, "iterations")
-    .push_constant(Type::MAT4, "inverse_transformation")
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_directional_blur.glsl")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_edge_filter_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_edge_filter_info.hh
deleted file mode 100644
index 916ec62bdba..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_edge_filter_info.hh
+++ /dev/null
@@ -1,12 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_edge_filter)
-    .local_group_size(16, 16)
-    .push_constant(Type::MAT4, "kernel")
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .sampler(1, ImageType::FLOAT_2D, "factor_tx")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_edge_filter.glsl")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_ellipse_mask_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_ellipse_mask_info.hh
deleted file mode 100644
index 52db91c94e5..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_ellipse_mask_info.hh
+++ /dev/null
@@ -1,35 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_ellipse_mask_shared)
-    .local_group_size(16, 16)
-    .push_constant(Type::IVEC2, "domain_size")
-    .push_constant(Type::VEC2, "location")
-    .push_constant(Type::VEC2, "radius")
-    .push_constant(Type::FLOAT, "cos_angle")
-    .push_constant(Type::FLOAT, "sin_angle")
-    .sampler(0, ImageType::FLOAT_2D, "base_mask_tx")
-    .sampler(1, ImageType::FLOAT_2D, "mask_value_tx")
-    .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_mask_img")
-    .compute_source("compositor_ellipse_mask.glsl");
-
-GPU_SHADER_CREATE_INFO(compositor_ellipse_mask_add)
-    .additional_info("compositor_ellipse_mask_shared")
-    .define("CMP_NODE_MASKTYPE_ADD")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_ellipse_mask_subtract)
-    .additional_info("compositor_ellipse_mask_shared")
-    .define("CMP_NODE_MASKTYPE_SUBTRACT")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_ellipse_mask_multiply)
-    .additional_info("compositor_ellipse_mask_shared")
-    .define("CMP_NODE_MASKTYPE_MULTIPLY")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_ellipse_mask_not)
-    .additional_info("compositor_ellipse_mask_shared")
-    .define("CMP_NODE_MASKTYPE_NOT")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_filter_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_filter_info.hh
deleted file mode 100644
index 9d565cf4b8a..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_filter_info.hh
+++ /dev/null
@@ -1,12 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_filter)
-    .local_group_size(16, 16)
-    .push_constant(Type::MAT4, "kernel")
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .sampler(1, ImageType::FLOAT_2D, "factor_tx")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_filter.glsl")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_flip_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_flip_info.hh
deleted file mode 100644
index db831518cb7..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_flip_info.hh
+++ /dev/null
@@ -1,12 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_flip)
-    .local_group_size(16, 16)
-    .push_constant(Type::BOOL, "flip_x")
-    .push_constant(Type::BOOL, "flip_y")
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_flip.glsl")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_image_crop_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_image_crop_info.hh
deleted file mode 100644
index e7736744c40..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_image_crop_info.hh
+++ /dev/null
@@ -1,11 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_image_crop)
-    .local_group_size(16, 16)
-    .push_constant(Type::IVEC2, "lower_bound")
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_image_crop.glsl")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_feather_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_feather_info.hh
deleted file mode 100644
index 9f17f60129d..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_feather_info.hh
+++ /dev/null
@@ -1,21 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_morphological_distance_feather_shared)
-    .local_group_size(16, 16)
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .sampler(1, ImageType::FLOAT_1D, "weights_tx")
-    .sampler(2, ImageType::FLOAT_1D, "falloffs_tx")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_morphological_distance_feather.glsl");
-
-GPU_SHADER_CREATE_INFO(compositor_morphological_distance_feather_dilate)
-    .additional_info("compositor_morphological_distance_feather_shared")
-    .define("COMPARE(x, y)", "x > y")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_morphological_distance_feather_erode)
-    .additional_info("compositor_morphological_distance_feather_shared")
-    .define("COMPARE(x, y)", "x < y")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_info.hh
deleted file mode 100644
index fc960e119e5..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_info.hh
+++ /dev/null
@@ -1,22 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_morphological_distance_shared)
-    .local_group_size(16, 16)
-    .push_constant(Type::INT, "radius")
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_morphological_distance.glsl");
-
-GPU_SHADER_CREATE_INFO(compositor_morphological_distance_dilate)
-    .additional_info("compositor_morphological_distance_shared")
-    .define("OPERATOR(a, b)", "max(a, b)")
-    .define("LIMIT", "FLT_MIN")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_morphological_distance_erode)
-    .additional_info("compositor_morphological_distance_shared")
-    .define("OPERATOR(a, b)", "min(a, b)")
-    .define("LIMIT", "FLT_MAX")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_threshold_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_threshold_info.hh
deleted file mode 100644
index b1d64f61b80..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_threshold_info.hh
+++ /dev/null
@@ -1,13 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_morphological_distance_threshold)
-    .local_group_size(16, 16)
-    .push_constant(Type::INT, "radius")
-    .push_constant(Type::INT, "distance")
-    .push_constant(Type::FLOAT, "inset")
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_morphological_distance_threshold.glsl")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_morphological_step_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_morphological_step_info.hh
deleted file mode 100644
index e97ffd9feea..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_morphological_step_info.hh
+++ /dev/null
@@ -1,22 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_morphological_step_shared)
-    .local_group_size(16, 16)
-    .push_constant(Type::INT, "radius")
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_morphological_step.glsl");
-
-GPU_SHADER_CREATE_INFO(compositor_morphological_step_dilate)
-    .additional_info("compositor_morphological_step_shared")
-    .define("OPERATOR(a, b)", "max(a, b)")
-    .define("LIMIT", "FLT_MIN")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_morphological_step_erode)
-    .additional_info("compositor_morphological_step_shared")
-    .define("OPERATOR(a, b)", "min(a, b)")
-    .define("LIMIT", "FLT_MAX")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_projector_lens_distortion_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_projector_lens_distortion_info.hh
deleted file mode 100644
index 98fe1731703..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_projector_lens_distortion_info.hh
+++ /dev/null
@@ -1,11 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_projector_lens_distortion)
-    .local_group_size(16, 16)
-    .push_constant(Type::FLOAT, "dispersion")
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_projector_lens_distortion.glsl")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_realize_on_domain_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_realize_on_domain_info.hh
deleted file mode 100644
index 4528649ae98..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_realize_on_domain_info.hh
+++ /dev/null
@@ -1,24 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_realize_on_domain_shared)
-    .local_group_size(16, 16)
-    .push_constant(Type::MAT4, "inverse_transformation")
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .compute_source("compositor_realize_on_domain.glsl");
-
-GPU_SHADER_CREATE_INFO(compositor_realize_on_domain_color)
-    .additional_info("compositor_realize_on_domain_shared")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "domain_img")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_realize_on_domain_vector)
-    .additional_info("compositor_realize_on_domain_shared")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "domain_img")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_realize_on_domain_float)
-    .additional_info("compositor_realize_on_domain_shared")
-    .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "domain_img")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_screen_lens_distortion_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_screen_lens_distortion_info.hh
deleted file mode 100644
index c42f2b328d4..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_screen_lens_distortion_info.hh
+++ /dev/null
@@ -1,20 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_screen_lens_distortion_shared)
-    .local_group_size(16, 16)
-    .push_constant(Type::VEC3, "chromatic_distortion")
-    .push_constant(Type::FLOAT, "scale")
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_screen_lens_distortion.glsl");
-
-GPU_SHADER_CREATE_INFO(compositor_screen_lens_distortion)
-    .additional_info("compositor_screen_lens_distortion_shared")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_screen_lens_distortion_jitter)
-    .additional_info("compositor_screen_lens_distortion_shared")
-    .define("JITTER")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_set_alpha_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_set_alpha_info.hh
deleted file mode 100644
index ca28194e921..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_set_alpha_info.hh
+++ /dev/null
@@ -1,11 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_set_alpha)
-    .local_group_size(16, 16)
-    .sampler(0, ImageType::FLOAT_2D, "image_tx")
-    .sampler(1, ImageType::FLOAT_2D, "alpha_tx")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_set_alpha.glsl")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_split_viewer_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_split_viewer_info.hh
deleted file mode 100644
index d5793b0ce59..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_split_viewer_info.hh
+++ /dev/null
@@ -1,22 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_split_viewer_shared)
-    .local_group_size(16, 16)
-    .push_constant(Type::FLOAT, "split_ratio")
-    .push_constant(Type::IVEC2, "view_size")
-    .sampler(0, ImageType::FLOAT_2D, "first_image_tx")
-    .sampler(1, ImageType::FLOAT_2D, "second_image_tx")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_split_viewer.glsl");
-
-GPU_SHADER_CREATE_INFO(compositor_split_viewer_horizontal)
-    .additional_info("compositor_split_viewer_shared")
-    .define("SPLIT_HORIZONTAL")
-    .do_static_compilation(true);
-
-GPU_SHADER_CREATE_INFO(compositor_split_viewer_vertical)
-    .additional_info("compositor_split_viewer_shared")
-    .define("SPLIT_VERTICAL")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_symmetric_blur_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_symmetric_blur_info.hh
deleted file mode 100644
index 8ba2b4e04ef..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_symmetric_blur_info.hh
+++ /dev/null
@@ -1,13 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_symmetric_blur)
-    .local_group_size(16, 16)
-    .push_constant(Type::BOOL, "extend_bounds")
-    .push_constant(Type::BOOL, "gamma_correct")
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .sampler(1, ImageType::FLOAT_2D, "weights_tx")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_symmetric_blur.glsl")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_symmetric_separable_blur_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_symmetric_separable_blur_info.hh
deleted file mode 100644
index 57247dba4b8..00000000000
--- a/source/blender/gpu/shaders/compositor/infos/compositor_symmetric_separable_blur_info.hh
+++ /dev/null
@@ -1,14 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "gpu_shader_create_info.hh"
-
-GPU_SHADER_CREATE_INFO(compositor_symmetric_separable_blur)
-    .local_group_size(16, 16)
-    .push_constant(Type::BOOL, "extend_bounds")
-    .push_constant(Type::BOOL, "gamma_correct_input")
-    .push_constant(Type::BOOL, "gamma_uncorrect_output")
-    .sampler(0, ImageType::FLOAT_2D, "input_tx")
-    .sampler(1, ImageType::FLOAT_1D, "weights_tx")
-    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .compute_source("compositor_symmetric_separable_blur.glsl")
-    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_alpha_over.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_alpha_over.glsl
deleted file mode 100644
index 8e3e033147f..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_alpha_over.glsl
+++ /dev/null
@@ -1,48 +0,0 @@
-void node_composite_alpha_over_mixed(
-    float factor, vec4 color, vec4 over_color, float premultiply_factor, out vec4 result)
-{
-  if (over_color.a <= 0.0) {
-    result = color;
-  }
-  else if (factor == 1.0 && over_color.a >= 1.0) {
-    result = over_color;
-  }
-  else {
-    float add_factor = 1.0 - premultiply_factor + over_color.a * premultiply_factor;
-    float premultiplier = factor * add_factor;
-    float multiplier = 1.0 - factor * over_color.a;
-
-    result = multiplier * color + vec2(premultiplier, factor).xxxy * over_color;
-  }
-}
-
-void node_composite_alpha_over_key(float factor, vec4 color, vec4 over_color, out vec4 result)
-{
-  if (over_color.a <= 0.0) {
-    result = color;
-  }
-  else if (factor == 1.0 && over_color.a >= 1.0) {
-    result = over_color;
-  }
-  else {
-    result = mix(color, vec4(over_color.rgb, 1.0), factor * over_color.a);
-  }
-}
-
-void node_composite_alpha_over_premultiply(float factor,
-                                           vec4 color,
-                                           vec4 over_color,
-                                           out vec4 result)
-{
-  if (over_color.a < 0.0) {
-    result = color;
-  }
-  else if (factor == 1.0 && over_color.a >= 1.0) {
-    result = over_color;
-  }
-  else {
-    float multiplier = 1.0 - factor * over_color.a;
-
-    result = multiplier * color + factor * over_color;
-  }
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_blur_common.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_blur_common.glsl
deleted file mode 100644
index e404c03bbb0..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_blur_common.glsl
+++ /dev/null
@@ -1,32 +0,0 @@
-/* Preprocess the input of the blur filter by squaring it in its alpha straight form, assuming the
- * given color is alpha premultiplied. */
-vec4 gamma_correct_blur_input(vec4 color)
-{
-  /* Unpremultiply alpha. */
-  color.rgb /= color.a > 0.0 ? color.a : 1.0;
-
-  /* Square color channel if it is positive, otherwise zero it. */
-  color.rgb *= mix(color.rgb, vec3(0.0), lessThan(color.rgb, vec3(0.0)));
-
-  /* Premultiply alpha to undo previous alpha unpremultiplication. */
-  color.rgb *= color.a > 0.0 ? color.a : 1.0;
-
-  return color;
-}
-
-/* Postprocess the output of the blur filter by taking its square root it in its alpha straight
- * form, assuming the given color is alpha premultiplied. This essential undoes the processing done
- * by the gamma_correct_blur_input function. */
-vec4 gamma_uncorrect_blur_output(vec4 color)
-{
-  /* Unpremultiply alpha. */
-  color.rgb /= color.a > 0.0 ? color.a : 1.0;
-
-  /* Take the square root of the color channel if it is positive, otherwise zero it. */
-  color.rgb = mix(sqrt(color.rgb), vec3(0.0), lessThan(color.rgb, vec3(0.0)));
-
-  /* Premultiply alpha to undo previous alpha unpremultiplication. */
-  color.rgb *= color.a > 0.0 ? color.a : 1.0;
-
-  return color;
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_bright_contrast.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_bright_contrast.glsl
deleted file mode 100644
index ce71b4fd8a4..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_bright_contrast.glsl
+++ /dev/null
@@ -1,38 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl)
-
-/* The algorithm is by Werner D. Streidt
- * (http://visca.com/ffactory/archives/5-99/msg00021.html)
- * Extracted of OpenCV demhist.c
- */
-
-#define FLT_EPSILON 1.192092896e-07F
-
-void node_composite_bright_contrast(
-    vec4 color, float brightness, float contrast, const float use_premultiply, out vec4 result)
-{
-  brightness /= 100.0;
-  float delta = contrast / 200.0;
-
-  float multiplier, offset;
-  if (contrast > 0.0) {
-    multiplier = 1.0 - delta * 2.0;
-    multiplier = 1.0 / max(multiplier, FLT_EPSILON);
-    offset = multiplier * (brightness - delta);
-  }
-  else {
-    delta *= -1.0;
-    multiplier = max(1.0 - delta * 2.0, 0.0);
-    offset = multiplier * brightness + delta;
-  }
-
-  if (use_premultiply != 0.0) {
-    color_alpha_unpremultiply(color, color);
-  }
-
-  result.rgb = color.rgb * multiplier + offset;
-  result.a = color.a;
-
-  if (use_premultiply != 0.0) {
-    color_alpha_premultiply(result, result);
-  }
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_channel_matte.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_channel_matte.glsl
deleted file mode 100644
index f2dcc9543f2..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_channel_matte.glsl
+++ /dev/null
@@ -1,52 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl)
-
-#define CMP_NODE_CHANNEL_MATTE_CS_RGB 1.0
-#define CMP_NODE_CHANNEL_MATTE_CS_HSV 2.0
-#define CMP_NODE_CHANNEL_MATTE_CS_YUV 3.0
-#define CMP_NODE_CHANNEL_MATTE_CS_YCC 4.0
-
-void node_composite_channel_matte(vec4 color,
-                                  const float color_space,
-                                  const float matte_channel,
-                                  const vec2 limit_channels,
-                                  float max_limit,
-                                  float min_limit,
-                                  out vec4 result,
-                                  out float matte)
-{
-  vec4 channels;
-  if (color_space == CMP_NODE_CHANNEL_MATTE_CS_HSV) {
-    rgb_to_hsv(color, channels);
-  }
-  else if (color_space == CMP_NODE_CHANNEL_MATTE_CS_YUV) {
-    rgba_to_yuva_itu_709(color, channels);
-  }
-  else if (color_space == CMP_NODE_CHANNEL_MATTE_CS_YCC) {
-    rgba_to_ycca_itu_709(color, channels);
-  }
-  else {
-    channels = color;
-  }
-
-  float matte_value = channels[int(matte_channel)];
-  float limit_value = max(channels[int(limit_channels.x)], channels[int(limit_channels.y)]);
-
-  float alpha = 1.0 - (matte_value - limit_value);
-  if (alpha > max_limit) {
-    alpha = color.a;
-  }
-  else if (alpha < min_limit) {
-    alpha = 0.0;
-  }
-  else {
-    alpha = (alpha - min_limit) / (max_limit - min_limit);
-  }
-
-  matte = min(alpha, color.a);
-  result = color * matte;
-}
-
-#undef CMP_NODE_CHANNEL_MATTE_CS_RGB
-#undef CMP_NODE_CHANNEL_MATTE_CS_HSV
-#undef CMP_NODE_CHANNEL_MATTE_CS_YUV
-#undef CMP_NODE_CHANNEL_MATTE_CS_YCC
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_chroma_matte.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_chroma_matte.glsl
deleted file mode 100644
index 5d6bea0c9db..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_chroma_matte.glsl
+++ /dev/null
@@ -1,43 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_common_math_utils.glsl)
-#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl)
-
-/* Algorithm from the book Video Demystified. Chapter 7. Chroma Keying. */
-void node_composite_chroma_matte(vec4 color,
-                                 vec4 key,
-                                 float acceptance,
-                                 float cutoff,
-                                 float falloff,
-                                 out vec4 result,
-                                 out float matte)
-{
-  vec4 color_ycca;
-  rgba_to_ycca_itu_709(color, color_ycca);
-  vec4 key_ycca;
-  rgba_to_ycca_itu_709(key, key_ycca);
-
-  /* Normalize the CrCb components into the [-1, 1] range. */
-  vec2 color_cc = color_ycca.yz * 2.0 - 1.0;
-  vec2 key_cc = key_ycca.yz * 2.0 - 1.0;
-
-  /* Rotate the color onto the space of the key such that x axis of the color space passes through
-   * the key color. */
-  color_cc = vector_to_rotation_matrix(key_cc * vec2(1.0, -1.0)) * color_cc;
-
-  /* Compute foreground key. If positive, the value is in the [0, 1] range. */
-  float foreground_key = color_cc.x - (abs(color_cc.y) / acceptance);
-
-  /* Negative foreground key values retain the original alpha. Positive values are scaled by the
-   * falloff, while colors that make an angle less than the cutoff angle get a zero alpha. */
-  float alpha = color.a;
-  if (foreground_key > 0.0) {
-    alpha = 1.0 - (foreground_key / falloff);
-
-    if (abs(atan(color_cc.y, color_cc.x)) < (cutoff / 2.0)) {
-      alpha = 0.0;
-    }
-  }
-
-  /* Compute output. */
-  matte = min(alpha, color.a);
-  result = color * matte;
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_balance.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_balance.glsl
deleted file mode 100644
index bffb94cdedb..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_balance.glsl
+++ /dev/null
@@ -1,34 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl)
-
-void node_composite_color_balance_lgg(
-    float factor, vec4 color, vec3 lift, vec3 gamma, vec3 gain, out vec4 result)
-{
-  lift = 2.0 - lift;
-  vec3 srgb_color = linear_rgb_to_srgb(color.rgb);
-  vec3 lift_balanced = ((srgb_color - 1.0) * lift) + 1.0;
-
-  vec3 gain_balanced = lift_balanced * gain;
-  gain_balanced = max(gain_balanced, vec3(0.0));
-
-  vec3 linear_color = srgb_to_linear_rgb(gain_balanced);
-  gamma = mix(gamma, vec3(1e-6), equal(gamma, vec3(0.0)));
-  vec3 gamma_balanced = pow(linear_color, 1.0 / gamma);
-
-  result.rgb = mix(color.rgb, gamma_balanced, min(factor, 1.0));
-  result.a = color.a;
-}
-
-void node_composite_color_balance_asc_cdl(float factor,
-                                          vec4 color,
-                                          vec3 offset,
-                                          vec3 power,
-                                          vec3 slope,
-                                          float offset_basis,
-                                          out vec4 result)
-{
-  offset += offset_basis;
-  vec3 balanced = color.rgb * slope + offset;
-  balanced = pow(max(balanced, vec3(0.0)), power);
-  result.rgb = mix(color.rgb, balanced, min(factor, 1.0));
-  result.a = color.a;
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_correction.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_correction.glsl
deleted file mode 100644
index 9b4858f03be..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_correction.glsl
+++ /dev/null
@@ -1,87 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_common_math_utils.glsl)
-#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl)
-
-void node_composite_color_correction(vec4 color,
-                                     float mask,
-                                     const vec3 enabled_channels,
-                                     float start_midtones,
-                                     float end_midtones,
-                                     float master_saturation,
-                                     float master_contrast,
-                                     float master_gamma,
-                                     float master_gain,
-                                     float master_lift,
-                                     float shadows_saturation,
-                                     float shadows_contrast,
-                                     float shadows_gamma,
-                                     float shadows_gain,
-                                     float shadows_lift,
-                                     float midtones_saturation,
-                                     float midtones_contrast,
-                                     float midtones_gamma,
-                                     float midtones_gain,
-                                     float midtones_lift,
-                                     float highlights_saturation,
-                                     float highlights_contrast,
-                                     float highlights_gamma,
-                                     float highlights_gain,
-                                     float highlights_lift,
-                                     const vec3 luminance_coefficients,
-                                     out vec4 result)
-{
-  const float margin = 0.10;
-  const float margin_divider = 0.5 / margin;
-  float level = (color.r + color.g + color.b) / 3.0;
-  float level_shadows = 0.0;
-  float level_midtones = 0.0;
-  float level_highlights = 0.0;
-  if (level < (start_midtones - margin)) {
-    level_shadows = 1.0;
-  }
-  else if (level < (start_midtones + margin)) {
-    level_midtones = ((level - start_midtones) * margin_divider) + 0.5;
-    level_shadows = 1.0 - level_midtones;
-  }
-  else if (level < (end_midtones - margin)) {
-    level_midtones = 1.0;
-  }
-  else if (level < (end_midtones + margin)) {
-    level_highlights = ((level - end_midtones) * margin_divider) + 0.5;
-    level_midtones = 1.0 - level_highlights;
-  }
-  else {
-    level_highlights = 1.0;
-  }
-
-  float contrast = level_shadows * shadows_contrast;
-  contrast += level_midtones * midtones_contrast;
-  contrast += level_highlights * highlights_contrast;
-  contrast *= master_contrast;
-  float saturation = level_shadows * shadows_saturation;
-  saturation += level_midtones * midtones_saturation;
-  saturation += level_highlights * highlights_saturation;
-  saturation *= master_saturation;
-  float gamma = level_shadows * shadows_gamma;
-  gamma += level_midtones * midtones_gamma;
-  gamma += level_highlights * highlights_gamma;
-  gamma *= master_gamma;
-  float gain = level_shadows * shadows_gain;
-  gain += level_midtones * midtones_gain;
-  gain += level_highlights * highlights_gain;
-  gain *= master_gain;
-  float lift = level_shadows * shadows_lift;
-  lift += level_midtones * midtones_lift;
-  lift += level_highlights * highlights_lift;
-  lift += master_lift;
-
-  float inverse_gamma = 1.0 / gamma;
-  float luma = get_luminance(color.rgb, luminance_coefficients);
-
-  vec3 corrected = luma + saturation * (color.rgb - luma);
-  corrected = 0.5 + (corrected - 0.5) * contrast;
-  corrected = fallback_pow(corrected * gain + lift, inverse_gamma, corrected);
-  corrected = mix(color.rgb, corrected, min(mask, 1.0));
-
-  result.rgb = mix(corrected, color.rgb, equal(enabled_channels, vec3(0.0)));
-  result.a = color.a;
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_matte.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_matte.glsl
deleted file mode 100644
index 038471bc1bc..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_matte.glsl
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl)
-
-void node_composite_color_matte(vec4 color,
-                                vec4 key,
-                                float hue_epsilon,
-                                float saturation_epsilon,
-                                float value_epsilon,
-                                out vec4 result,
-                                out float matte)
-
-{
-  vec4 color_hsva;
-  rgb_to_hsv(color, color_hsva);
-  vec4 key_hsva;
-  rgb_to_hsv(key, key_hsva);
-
-  bool is_within_saturation = distance(color_hsva.y, key_hsva.y) < saturation_epsilon;
-  bool is_within_value = distance(color_hsva.z, key_hsva.z) < value_epsilon;
-  bool is_within_hue = distance(color_hsva.x, key_hsva.x) < hue_epsilon;
-  /* Hue wraps around, so check the distance around the boundary. */
-  float min_hue = min(color_hsva.x, key_hsva.x);
-  float max_hue = max(color_hsva.x, key_hsva.x);
-  is_within_hue = is_within_hue || ((min_hue + (1.0 - max_hue)) < hue_epsilon);
-
-  matte = (is_within_hue && is_within_saturation && is_within_value) ? 0.0 : color.a;
-  result = color * matte;
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_spill.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_spill.glsl
deleted file mode 100644
index 0adad53ad80..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_spill.glsl
+++ /dev/null
@@ -1,13 +0,0 @@
-void node_composite_color_spill(vec4 color,
-                                float factor,
-                                const float spill_channel,
-                                vec3 spill_scale,
-                                const vec2 limit_channels,
-                                float limit_scale,
-                                out vec4 result)
-{
-  float average_limit = (color[int(limit_channels.x)] + color[int(limit_channels.y)]) / 2.0;
-  float map = factor * color[int(spill_channel)] - limit_scale * average_limit;
-  result.rgb = map > 0.0 ? color.rgb + spill_scale * map : color.rgb;
-  result.a = color.a;
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_to_luminance.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_to_luminance.glsl
deleted file mode 100644
index bcdd625bd4f..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_to_luminance.glsl
+++ /dev/null
@@ -1,6 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl)
-
-void color_to_luminance(vec4 color, const vec3 luminance_coefficients, out float result)
-{
-  result = get_luminance(color.rgb, luminance_coefficients);
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_difference_matte.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_difference_matte.glsl
deleted file mode 100644
index d769cadce3c..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_difference_matte.glsl
+++ /dev/null
@@ -1,10 +0,0 @@
-void node_composite_difference_matte(
-    vec4 color, vec4 key, float tolerance, float falloff, out vec4 result, out float matte)
-{
-  vec4 difference = abs(color - key);
-  float average_difference = (difference.r + difference.g + difference.b) / 3.0;
-  bool is_opaque = average_difference > tolerance + falloff;
-  float alpha = is_opaque ? color.a : (max(0.0, average_difference - tolerance) / falloff);
-  matte = min(alpha, color.a);
-  result = color * matte;
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_distance_matte.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_distance_matte.glsl
deleted file mode 100644
index 9beed66826c..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_distance_matte.glsl
+++ /dev/null
@@ -1,26 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl)
-
-void node_composite_distance_matte_rgba(
-    vec4 color, vec4 key, float tolerance, float falloff, out vec4 result, out float matte)
-{
-  float difference = distance(color.rgb, key.rgb);
-  bool is_opaque = difference > tolerance + falloff;
-  float alpha = is_opaque ? color.a : max(0.0, difference - tolerance) / falloff;
-  matte = min(alpha, color.a);
-  result = color * matte;
-}
-
-void node_composite_distance_matte_ycca(
-    vec4 color, vec4 key, float tolerance, float falloff, out vec4 result, out float matte)
-{
-  vec4 color_ycca;
-  rgba_to_ycca_itu_709(color, color_ycca);
-  vec4 key_ycca;
-  rgba_to_ycca_itu_709(key, key_ycca);
-
-  float difference = distance(color_ycca.yz, key_ycca.yz);
-  bool is_opaque = difference > tolerance + falloff;
-  float alpha = is_opaque ? color.a : max(0.0, difference - tolerance) / falloff;
-  matte = min(alpha, color.a);
-  result = color * matte;
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_exposure.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_exposure.glsl
deleted file mode 100644
index f246635a91e..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_exposure.glsl
+++ /dev/null
@@ -1,6 +0,0 @@
-void node_composite_exposure(vec4 color, float exposure, out vec4 result)
-{
-  float multiplier = exp2(exposure);
-  result.rgb = color.rgb * multiplier;
-  result.a = color.a;
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_gamma.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_gamma.glsl
deleted file mode 100644
index 53070d4b0e2..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_gamma.glsl
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_common_math_utils.glsl)
-
-void node_composite_gamma(vec4 color, float gamma, out vec4 result)
-{
-  result.rgb = fallback_pow(color.rgb, gamma, color.rgb);
-  result.a = color.a;
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_hue_correct.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_hue_correct.glsl
deleted file mode 100644
index 99eb125cdf2..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_hue_correct.glsl
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl)
-
-/* Curve maps are stored in sampler objects that are evaluated in the [0, 1] range, so normalize
- * parameters accordingly. */
-#define NORMALIZE_PARAMETER(parameter, minimum, range) ((parameter - minimum) * range)
-
-void node_composite_hue_correct(float factor,
-                                vec4 color,
-                                sampler1DArray curve_map,
-                                const float layer,
-                                vec3 minimums,
-                                vec3 range_dividers,
-                                out vec4 result)
-{
-  vec4 hsv;
-  rgb_to_hsv(color, hsv);
-
-  /* First, adjust the hue channel on its own, since corrections in the saturation and value
-   * channels depends on the new value of the hue, not its original value. A curve map value of 0.5
-   * means no change in hue, so adjust the value to get an identity at 0.5. Since the identity of
-   * addition is 0, we subtract 0.5 (0.5 - 0.5 = 0). */
-  const float hue_parameter = NORMALIZE_PARAMETER(hsv.x, minimums.x, range_dividers.x);
-  hsv.x += texture(curve_map, vec2(hue_parameter, layer)).x - 0.5;
-
-  /* Second, adjust the saturation and value based on the new value of the hue. A curve map value
-   * of 0.5 means no change in hue, so adjust the value to get an identity at 0.5. Since the
-   * identity of duplication is 1, we multiply by 2 (0.5 * 2 = 1). */
-  vec2 parameters = NORMALIZE_PARAMETER(hsv.x, minimums.yz, range_dividers.yz);
-  hsv.y *= texture(curve_map, vec2(parameters.x, layer)).y * 2.0;
-  hsv.z *= texture(curve_map, vec2(parameters.y, layer)).z * 2.0;
-
-  /* Sanitize the new hue and saturation values. */
-  hsv.x = fract(hsv.x);
-  hsv.y = clamp(hsv.y, 0.0, 1.0);
-
-  hsv_to_rgb(hsv, result);
-
-  result = mix(color, result, factor);
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_hue_saturation_value.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_hue_saturation_value.glsl
deleted file mode 100644
index dd5eb33d318..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_hue_saturation_value.glsl
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl)
-
-void node_composite_hue_saturation_value(
-    vec4 color, float hue, float saturation, float value, float factor, out vec4 result)
-{
-  vec4 hsv;
-  rgb_to_hsv(color, hsv);
-
-  hsv.x = fract(hsv.x + hue + 0.5);
-  hsv.y = clamp(hsv.y * saturation, 0.0, 1.0);
-  hsv.z = hsv.z * value;
-
-  hsv_to_rgb(hsv, result);
-
-  result = mix(color, result, factor);
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_invert.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_invert.glsl
deleted file mode 100644
index 59be746da7f..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_invert.glsl
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl)
-
-void node_composite_invert(float fac, vec4 color, float do_rgb, float do_alpha, out vec4 result)
-{
-  result = color;
-  if (do_rgb != 0.0) {
-    result.rgb = 1.0 - result.rgb;
-  }
-  if (do_alpha != 0.0) {
-    result.a = 1.0 - result.a;
-  }
-  result = mix(color, result, fac);
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_luminance_matte.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_luminance_matte.glsl
deleted file mode 100644
index 3647ac583fe..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_luminance_matte.glsl
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl)
-
-void node_composite_luminance_matte(vec4 color,
-                                    float high,
-                                    float low,
-                                    const vec3 luminance_coefficients,
-                                    out vec4 result,
-                                    out float matte)
-{
-  float luminance = get_luminance(color.rgb, luminance_coefficients);
-  float alpha = clamp(0.0, 1.0, (luminance - low) / (high - low));
-  matte = min(alpha, color.a);
-  result = color * matte;
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_main.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_main.glsl
deleted file mode 100644
index 27624223dbc..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_main.glsl
+++ /dev/null
@@ -1,7 +0,0 @@
-/* The compute shader that will be dispatched by the compositor ShaderOperation. It just calls the
- * evaluate function that will be dynamically generated and appended to this shader in the
- * ShaderOperation::generate_code method. */
-void main()
-{
-  evaluate();
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_map_value.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_map_value.glsl
deleted file mode 100644
index 20874b4ef44..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_map_value.glsl
+++ /dev/null
@@ -1,56 +0,0 @@
-/* An arbitrary value determined by Blender. */
-#define BLENDER_ZMAX 10000.0
-
-void node_composite_map_range(float value,
-                              float from_min,
-                              float from_max,
-                              float to_min,
-                              float to_max,
-                              const float should_clamp,
-                              out float result)
-{
-  if (abs(from_max - from_min) < 1e-6) {
-    result = 0.0;
-  }
-  else {
-    if (value >= -BLENDER_ZMAX && value <= BLENDER_ZMAX) {
-      result = (value - from_min) / (from_max - from_min);
-      result = to_min + result * (to_max - to_min);
-    }
-    else if (value > BLENDER_ZMAX) {
-      result = to_max;
-    }
-    else {
-      result = to_min;
-    }
-
-    if (should_clamp != 0.0) {
-      if (to_max > to_min) {
-        result = clamp(result, to_min, to_max);
-      }
-      else {
-        result = clamp(result, to_max, to_min);
-      }
-    }
-  }
-}
-
-void node_composite_map_value(float value,
-                              float offset,
-                              float size,
-                              const float use_min,
-                              float min,
-                              const float use_max,
-                              float max,
-                              out float result)
-{
-  result = (value + offset) * size;
-
-  if (use_min != 0.0 && result < min) {
-    result = min;
-  }
-
-  if (use_max != 0.0 && result > max) {
-    result = max;
-  }
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_normal.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_normal.glsl
deleted file mode 100644
index a2e3b6c4aaa..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_normal.glsl
+++ /dev/null
@@ -1,9 +0,0 @@
-void node_composite_normal(vec3 input_vector,
-                           vec3 input_normal,
-                           out vec3 result_normal,
-                           out float result_dot)
-{
-  vec3 normal = normalize(input_normal);
-  result_normal = normal;
-  result_dot = -dot(input_vector, normal);
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_posterize.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_posterize.glsl
deleted file mode 100644
index ee8ae234abe..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_posterize.glsl
+++ /dev/null
@@ -1,6 +0,0 @@
-void node_composite_posterize(vec4 color, float steps, out vec4 result)
-{
-  steps = clamp(steps, 2.0, 1024.0);
-  result = floor(color * steps) / steps;
-  result.a = color.a;
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_separate_combine.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_separate_combine.glsl
deleted file mode 100644
index d72d2260394..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_separate_combine.glsl
+++ /dev/null
@@ -1,132 +0,0 @@
-#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl)
-
-/* ** Combine/Separate XYZ ** */
-
-void node_composite_combine_xyz(float x, float y, float z, out vec3 vector)
-{
-  vector = vec3(x, y, z);
-}
-
-void node_composite_separate_xyz(vec3 vector, out float x, out float y, out float z)
-{
-  x = vector.x;
-  y = vector.y;
-  z = vector.z;
-}
-
-/* ** Combine/Separate RGBA ** */
-
-void node_composite_combine_rgba(float r, float g, float b, float a, out vec4 color)
-{
-  color = vec4(r, g, b, a);
-}
-
-void node_composite_separate_rgba(vec4 color, out float r, out float g, out float b, out float a)
-{
-  r = color.r;
-  g = color.g;
-  b = color.b;
-  a = color.a;
-}
-
-/* ** Combine/Separate HSVA ** */
-
-void node_composite_combine_hsva(float h, float s, float v, float a, out vec4 color)
-{
-  hsv_to_rgb(vec4(h, s, v, a), color);
-}
-
-void node_composite_separate_hsva(vec4 color, out float h, out float s, out float v, out float a)
-{
-  vec4 hsva;
-  rgb_to_hsv(color, hsva);
-  h = hsva.x;
-  s = hsva.y;
-  v = hsva.z;
-  a = hsva.a;
-}
-
-/* ** Combine/Separate HSLA ** */
-
-void node_composite_combine_hsla(float h, float s, float l, float a, out vec4 color)
-{
-  hsl_to_rgb(vec4(h, s, l, a), color);
-}
-
-void node_composite_separate_hsla(vec4 color, out float h, out float s, out float l, out float a)
-{
-  vec4 hsla;
-  rgb_to_hsl(color, hsla);
-  h = hsla.x;
-  s = hsla.y;
-  l = hsla.z;
-  a = hsla.a;
-}
-
-/* ** Combine/Separate YCCA ** */
-
-void node_composite_combine_ycca_itu_601(float y, float cb, float cr, float a, out vec4 color)
-{
-  ycca_to_rgba_itu_601(vec4(y, cb, cr, a), color);
-}
-
-void node_composite_combine_ycca_itu_709(float y, float cb, float cr, float a, out vec4 color)
-{
-  ycca_to_rgba_itu_709(vec4(y, cb, cr, a), color);
-}
-
-void node_composite_combine_ycca_jpeg(float y, float cb, float cr, float a, out vec4 color)
-{
-  ycca_to_rgba_jpeg(vec4(y, cb, cr, a), color);
-}
-
-void node_composite_separate_ycca_itu_601(
-    vec4 color, out float y, out float cb, out float cr, out float a)
-{
-  vec4 ycca;
-  rgba_to_ycca_itu_601(color, ycca);
-  y = ycca.x;
-  cb = ycca.y;
-  cr = ycca.z;
-  a = ycca.a;
-}
-
-void node_composite_separate_ycca_itu_709(
-    vec4 color, out float y, out float cb, out float cr, out float a)
-{
-  vec4 ycca;
-  rgba_to_ycca_itu_709(color, ycca);
-  y = ycca.x;
-  cb = ycca.y;
-  cr = ycca.z;
-  a = ycca.a;
-}
-
-void node_composite_separate_ycca_jpeg(
-    vec4 color, out float y, out float cb, out float cr, out float a)
-{
-  vec4 ycca;
-  rgba_to_ycca_jpeg(color, ycca);
-  y = ycca.x;
-  cb = ycca.y;
-  cr = ycca.z;
-  a = ycca.a;
-}
-
-/* ** Combine/Separate YUVA ** */
-
-void node_composite_combine_yuva_itu_709(float y, float u, float v, float a, out vec4 color)
-{
-  yuva_to_rgba_itu_709(vec4(y, u, v, a), color);
-}
-
-void node_composite_separate_yuva_itu_709(
-    vec4 color, out float y, out float u, out float v, out float a)
-{
-  vec4 yuva;
-  rgba_to_yuva_itu_709(color, yuva);
-  y = yuva.x;
-  u = yuva.y;
-  v = yuva.z;
-  a = yuva.a;
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_set_alpha.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_set_alpha.glsl
deleted file mode 100644
index 95380d1ed0f..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_set_alpha.glsl
+++ /dev/null
@@ -1,9 +0,0 @@
-void node_composite_set_alpha_apply(vec4 color, float alpha, out vec4 result)
-{
-  result = color * alpha;
-}
-
-void node_composite_set_alpha_replace(vec4 color, float alpha, out vec4 result)
-{
-  result = vec4(color.rgb, alpha);
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_store_output.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_store_output.glsl
deleted file mode 100644
index 7fba26907b5..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_store_output.glsl
+++ /dev/null
@@ -1,26 +0,0 @@
-/* The following functions are called to store the given value in the output identified by the
- * given ID. The ID is an unsigned integer that is encoded in a float, so floatBitsToUint is called
- * to get the actual identifier. The functions have an output value as their last argument that is
- * used to establish an output link that is then used to track the nodes that contribute to the
- * output of the compositor node tree.
- *
- * The store_[float|vector|color] functions are dynamically generated in
- * ShaderOperation::generate_code_for_outputs. */
-
-void node_compositor_store_output_float(const float id, float value, out float out_value)
-{
-  store_float(floatBitsToUint(id), value);
-  out_value = value;
-}
-
-void node_compositor_store_output_vector(const float id, vec3 vector, out vec3 out_vector)
-{
-  store_vector(floatBitsToUint(id), vector);
-  out_vector = vector;
-}
-
-void node_compositor_store_output_color(const float id, vec4 color, out vec4 out_color)
-{
-  store_color(floatBitsToUint(id), color);
-  out_color = color;
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_texture_utilities.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_texture_utilities.glsl
deleted file mode 100644
index 128fc6aeaf5..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_texture_utilities.glsl
+++ /dev/null
@@ -1,35 +0,0 @@
-/* A shorthand for 1D textureSize with a zero LOD. */
-int texture_size(sampler1D sampler)
-{
-  return textureSize(sampler, 0);
-}
-
-/* A shorthand for 1D texelFetch with zero LOD and bounded access clamped to border. */
-vec4 texture_load(sampler1D sampler, int x)
-{
-  const int texture_bound = texture_size(sampler) - 1;
-  return texelFetch(sampler, clamp(x, 0, texture_bound), 0);
-}
-
-/* A shorthand for 2D textureSize with a zero LOD. */
-ivec2 texture_size(sampler2D sampler)
-{
-  return textureSize(sampler, 0);
-}
-
-/* A shorthand for 2D texelFetch with zero LOD and bounded access clamped to border. */
-vec4 texture_load(sampler2D sampler, ivec2 texel)
-{
-  const ivec2 texture_bounds = texture_size(sampler) - ivec2(1);
-  return texelFetch(sampler, clamp(texel, ivec2(0), texture_bounds), 0);
-}
-
-/* A shorthand for 2D texelFetch with zero LOD and a fallback value for out-of-bound access. */
-vec4 texture_load(sampler2D sampler, ivec2 texel, vec4 fallback)
-{
-  const ivec2 texture_bounds = texture_size(sampler) - ivec2(1);
-  if (any(lessThan(texel, ivec2(0))) || any(greaterThan(texel, texture_bounds))) {
-    return fallback;
-  }
-  return texelFetch(sampler, texel, 0);
-}
diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_type_conversion.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_type_conversion.glsl
deleted file mode 100644
index 75c76fd7341..00000000000
--- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_type_conversion.glsl
+++ /dev/null
@@ -1,29 +0,0 @@
-float float_from_vec4(vec4 vector)
-{
-  return dot(vector.rgb, vec3(1.0)) / 3.0;
-}
-
-float float_from_vec3(vec3 vector)
-{
-  return dot(vector, vec3(1.0)) / 3.0;
-}
-
-vec3 vec3_from_vec4(vec4 vector)
-{
-  return vector.rgb;
-}
-
-vec3 vec3_from_float(float value)
-{
-  return vec3(value);
-}
-
-vec4 vec4_from_vec3(vec3 vector)
-{
-  return vec4(vector, 1.0);
-}
-
-vec4 vec4_from_float(float value)
-{
-  return vec4(vec3(value), 1.0);
-}
diff --git a/source/blender/gpu/shaders/gpu_shader_2D_widget_base_frag.glsl b/source/blender/gpu/shaders/gpu_shader_2D_widget_base_frag.glsl
index 662589fb2ce..cd8ff73b833 100644
--- a/source/blender/gpu/shaders/gpu_shader_2D_widget_base_frag.glsl
+++ b/source/blender/gpu/shaders/gpu_shader_2D_widget_base_frag.glsl
@@ -6,7 +6,7 @@ vec3 compute_masks(vec2 uv)
   bool right_half = uv.x > outRectSize.x * 0.5;
   float corner_rad;
 
-  /* Correct aspect ratio for 2D views not using uniform scalling.
+  /* Correct aspect ratio for 2D views not using uniform scaling.
    * uv is already in pixel space so a uniform scale should give us a ratio of 1. */
   float ratio = (butCo != -2.0) ? (dFdy(uv.y) / dFdx(uv.x)) : 1.0;
   vec2 uv_sdf = uv;
diff --git a/source/blender/gpu/shaders/gpu_shader_2D_widget_base_vert.glsl b/source/blender/gpu/shaders/gpu_shader_2D_widget_base_vert.glsl
index c102b422211..d6c93df9849 100644
--- a/source/blender/gpu/shaders/gpu_shader_2D_widget_base_vert.glsl
+++ b/source/blender/gpu/shaders/gpu_shader_2D_widget_base_vert.glsl
@@ -124,8 +124,8 @@ vec2 do_tria()
   }
   else if (triaType == 4.0) {
     /* ROUNDBOX_TRIA_CHECK */
-    /* A bit more hacky: We use the two trias joined together to render
-     * both sides of the checkmark with different length. */
+    /* A bit more hacky: We use the two triangles joined together to render
+     * both sides of the check-mark with different length. */
     pos = arrow_pos[min(vidx, 2)];                                    /* Only keep 1 triangle. */
     pos.y = tria2 ? -pos.y : pos.y;                                   /* Mirror along X */
     pos = pos.x * vec2(0.0872, -0.996) + pos.y * vec2(0.996, 0.0872); /* Rotate (85deg) */
diff --git a/source/blender/gpu/shaders/gpu_shader_3D_polyline_frag.glsl b/source/blender/gpu/shaders/gpu_shader_3D_polyline_frag.glsl
index 27740c8d71b..f912bad8a14 100644
--- a/source/blender/gpu/shaders/gpu_shader_3D_polyline_frag.glsl
+++ b/source/blender/gpu/shaders/gpu_shader_3D_polyline_frag.glsl
@@ -7,7 +7,7 @@ void main()
     discard;
   }
 #endif
-  fragColor = interp.color;
+  fragColor = interp.final_color;
   if (lineSmooth) {
     fragColor.a *= clamp((lineWidth + SMOOTH_WIDTH) * 0.5 - abs(interp.smoothline), 0.0, 1.0);
   }
diff --git a/source/blender/gpu/shaders/gpu_shader_3D_polyline_geom.glsl b/source/blender/gpu/shaders/gpu_shader_3D_polyline_geom.glsl
index 1c824023234..6d23e03c835 100644
--- a/source/blender/gpu/shaders/gpu_shader_3D_polyline_geom.glsl
+++ b/source/blender/gpu/shaders/gpu_shader_3D_polyline_geom.glsl
@@ -18,14 +18,14 @@ vec4 clip_line_point_homogeneous_space(vec4 p, vec4 q)
 void do_vertex(const int i, vec4 pos, vec2 ofs)
 {
 #if defined(UNIFORM)
-  interp_out.color = color;
+  interp_out.final_color = color;
 
 #elif defined(FLAT)
   /* WATCH: Assuming last provoking vertex. */
-  interp_out.color = interp_in[1].color;
+  interp_out.final_color = interp_in[1].final_color;
 
 #elif defined(SMOOTH)
-  interp_out.color = interp_in[i].color;
+  interp_out.final_color = interp_in[i].final_color;
 #endif
 
 #ifdef CLIP
diff --git a/source/blender/gpu/shaders/gpu_shader_3D_polyline_vert.glsl b/source/blender/gpu/shaders/gpu_shader_3D_polyline_vert.glsl
index d4ef3e6142f..5119db2437c 100644
--- a/source/blender/gpu/shaders/gpu_shader_3D_polyline_vert.glsl
+++ b/source/blender/gpu/shaders/gpu_shader_3D_polyline_vert.glsl
@@ -3,7 +3,7 @@ void main()
 {
   gl_Position = ModelViewProjectionMatrix * vec4(pos, 1.0);
 #ifndef UNIFORM
-  interp.color = color;
+  interp.final_color = color;
 #endif
 #ifdef CLIP
   interp.clip = dot(ModelMatrix * vec4(pos, 1.0), ClipPlane);
diff --git a/source/blender/gpu/shaders/gpu_shader_3D_polyline_vert_no_geom.glsl b/source/blender/gpu/shaders/gpu_shader_3D_polyline_vert_no_geom.glsl
new file mode 100644
index 00000000000..4c1aebd9caf
--- /dev/null
+++ b/source/blender/gpu/shaders/gpu_shader_3D_polyline_vert_no_geom.glsl
@@ -0,0 +1,162 @@
+
+#pragma USE_SSBO_VERTEX_FETCH(TriangleList, 6)
+
+/* Local vars to store results per input vertex. */
+#if !defined(UNIFORM)
+vec4 finalColor_g[2];
+#endif
+
+#ifdef CLIP
+float clip_g[2];
+#endif
+
+#define SMOOTH_WIDTH 1.0
+
+/* Clips point to near clip plane before perspective divide. */
+vec4 clip_line_point_homogeneous_space(vec4 p, vec4 q)
+{
+  if (p.z < -p.w) {
+    /* Just solves p + (q - p) * A; for A when p.z / p.w = -1.0. */
+    float denom = q.z - p.z + q.w - p.w;
+    if (denom == 0.0) {
+      /* No solution. */
+      return p;
+    }
+    float A = (-p.z - p.w) / denom;
+    p = p + (q - p) * A;
+  }
+  return p;
+}
+
+void do_vertex(int index, vec4 pos, vec2 ofs, float flip)
+{
+#if defined(UNIFORM)
+  interp.final_color = color;
+
+#elif defined(FLAT)
+  /* WATCH: Assuming last provoking vertex. */
+  interp.final_color = finalColor_g[index];
+
+#elif defined(SMOOTH)
+  interp.final_color = finalColor_g[index];
+#endif
+
+#ifdef CLIP
+  interp.clip = clip_g[index];
+#endif
+
+  interp.smoothline = flip * (lineWidth + SMOOTH_WIDTH * float(lineSmooth)) * 0.5;
+  gl_Position = pos;
+  gl_Position.xy += flip * ofs * pos.w;
+}
+
+void main()
+{
+  /** Determine output quad primitive structure. */
+  /* Index of the quad primitive. Each quad corresponds to one line in the input primitive. */
+  int quad_id = gl_VertexID / 6;
+
+  /* Determine vertex within the quad (A, B, C)(A, C, D).*/
+  int quad_vertex_id = gl_VertexID % 6;
+
+  uint src_index_a;
+  uint src_index_b;
+  if (vertex_fetch_get_input_prim_type() == GPU_PRIM_LINE_STRIP) {
+    src_index_a = quad_id;
+    src_index_b = quad_id + 1;
+  }
+  else if (vertex_fetch_get_input_prim_type() == GPU_PRIM_LINES) {
+    src_index_a = quad_id * 2;
+    src_index_b = quad_id * 2 + 1;
+  }
+  else if (vertex_fetch_get_input_prim_type() == GPU_PRIM_LINE_LOOP) {
+    src_index_a = quad_id;
+    src_index_b = quad_id + 1;
+    if (quad_id == vertex_fetch_get_input_vert_count() - 1) {
+      src_index_b = 0;
+    }
+  }
+  else {
+    src_index_a = 0;
+    src_index_b = 0;
+  }
+
+  /* Fetch input attributes for line prims -- either provided as vec2 or vec3 -- So we need to
+   * query the type. */
+  vec3 in_pos0, in_pos1;
+  in_pos0 = vec3(0.0);
+  in_pos1 = vec3(0.0);
+  if (vertex_fetch_get_attr_type(pos) == GPU_SHADER_ATTR_TYPE_VEC4) {
+    in_pos0 = vertex_fetch_attribute(src_index_a, pos, vec4).xyz;
+    in_pos1 = vertex_fetch_attribute(src_index_b, pos, vec4).xyz;
+  }
+  else if (vertex_fetch_get_attr_type(pos) == GPU_SHADER_ATTR_TYPE_VEC3) {
+    in_pos0 = vertex_fetch_attribute(src_index_a, pos, vec3);
+    in_pos1 = vertex_fetch_attribute(src_index_b, pos, vec3);
+  }
+  else if (vertex_fetch_get_attr_type(pos) == GPU_SHADER_ATTR_TYPE_VEC2) {
+    in_pos0 = vec3(vertex_fetch_attribute(src_index_a, pos, vec2), 0.0);
+    in_pos1 = vec3(vertex_fetch_attribute(src_index_b, pos, vec2), 0.0);
+  }
+#if !defined(UNIFORM)
+  vec4 in_color0 = vec4(0.0);
+  vec4 in_color1 = vec4(0.0);
+
+  if (vertex_fetch_get_attr_type(color) == GPU_SHADER_ATTR_TYPE_VEC4) {
+    in_color0 = vertex_fetch_attribute(src_index_a, color, vec4);
+    in_color1 = vertex_fetch_attribute(src_index_b, color, vec4);
+  }
+  else if (vertex_fetch_get_attr_type(color) == GPU_SHADER_ATTR_TYPE_VEC3) {
+    in_color0 = vec4(vertex_fetch_attribute(src_index_a, color, vec3), 1.0);
+    in_color1 = vec4(vertex_fetch_attribute(src_index_b, color, vec3), 1.0);
+  }
+  else if (vertex_fetch_get_attr_type(color) == GPU_SHADER_ATTR_TYPE_UCHAR4_NORM) {
+    in_color0 = vec4(vertex_fetch_attribute(src_index_a, color, uchar4)) / vec4(255.0);
+    in_color1 = vec4(vertex_fetch_attribute(src_index_b, color, uchar4)) / vec4(255.0);
+  }
+  else if (vertex_fetch_get_attr_type(color) == GPU_SHADER_ATTR_TYPE_UCHAR3_NORM) {
+    in_color0 = vec4(vec3(vertex_fetch_attribute(src_index_a, color, uchar3)) / vec3(255.0), 1.0);
+    in_color1 = vec4(vec3(vertex_fetch_attribute(src_index_b, color, uchar3)) / vec3(255.0), 1.0);
+  }
+#endif
+
+  /* Calculate Vertex shader for both points in Line. */
+  vec4 out_pos0 = ModelViewProjectionMatrix * vec4(in_pos0, 1.0);
+  vec4 out_pos1 = ModelViewProjectionMatrix * vec4(in_pos1, 1.0);
+#if !defined(UNIFORM)
+  finalColor_g[0] = in_color0;
+  finalColor_g[1] = in_color1;
+#endif
+#ifdef CLIP
+  clip_g[0] = dot(ModelMatrix * vec4(in_pos0, 1.0), ClipPlane);
+  clip_g[1] = dot(ModelMatrix * vec4(in_pos1, 1.0), ClipPlane);
+#endif
+
+  /*** Geometry Shader Alternative. ***/
+  vec4 p0 = clip_line_point_homogeneous_space(out_pos0, out_pos1);
+  vec4 p1 = clip_line_point_homogeneous_space(out_pos1, out_pos0);
+  vec2 e = normalize(((p1.xy / p1.w) - (p0.xy / p0.w)) * viewportSize.xy);
+
+#if 0 /* Hard turn when line direction changes quadrant. */
+  e = abs(e);
+  vec2 ofs = (e.x > e.y) ? vec2(0.0, 1.0 / e.x) : vec2(1.0 / e.y, 0.0);
+#else /* Use perpendicular direction. */
+  vec2 ofs = vec2(-e.y, e.x);
+#endif
+
+  ofs /= viewportSize.xy;
+  ofs *= lineWidth + SMOOTH_WIDTH * float(lineSmooth);
+
+  if (quad_vertex_id == 0) {
+    do_vertex(0, p0, ofs, 1.0);
+  }
+  else if (quad_vertex_id == 1 || quad_vertex_id == 3) {
+    do_vertex(0, p0, ofs, -1.0);
+  }
+  else if (quad_vertex_id == 2 || quad_vertex_id == 5) {
+    do_vertex(1, p1, ofs, 1.0);
+  }
+  else if (quad_vertex_id == 4) {
+    do_vertex(1, p1, ofs, -1.0);
+  }
+}
diff --git a/source/blender/gpu/shaders/gpu_shader_codegen_lib.glsl b/source/blender/gpu/shaders/gpu_shader_codegen_lib.glsl
index 94707de71ed..38734d5bbaf 100644
--- a/source/blender/gpu/shaders/gpu_shader_codegen_lib.glsl
+++ b/source/blender/gpu/shaders/gpu_shader_codegen_lib.glsl
@@ -67,7 +67,7 @@ vec3 orco_get(vec3 local_pos, mat4 modelmatinv, vec4 orco_madd[2], vec4 orco)
   /* If the object does not have any deformation, the orco layer calculation is done on the fly
    * using the orco_madd factors.
    * We know when there is no orco layer when orco.w is 1.0 because it uses the generic vertex
-   * attrib (which is [0,0,0,1]). */
+   * attribute (which is [0,0,0,1]). */
   if (orco.w == 0.0) {
     return orco.xyz * 0.5 + 0.5;
   }
diff --git a/source/blender/gpu/shaders/gpu_shader_icon_frag.glsl b/source/blender/gpu/shaders/gpu_shader_icon_frag.glsl
new file mode 100644
index 00000000000..4452349f23c
--- /dev/null
+++ b/source/blender/gpu/shaders/gpu_shader_icon_frag.glsl
@@ -0,0 +1,42 @@
+/**
+ * Draw the icons, leaving a semi-transparent rectangle on top of the icon.
+ *
+ * The top-left corner of the rectangle is rounded and drawned with anti-alias.
+ * The anti-alias is done by transitioning from the outer to the inner radius of
+ * the rounded corner, and the rectangle sides.
+ */
+
+void main()
+{
+  /* Top-left rounded corner parameters. */
+  const float circle_radius_outer = 0.1;
+  const float circle_radius_inner = 0.075;
+
+  /**
+   * Add a bit transparency to see a bit of the icon, without
+   * getting on the way of readability. */
+  const float mask_transparency = 0.25;
+
+  vec2 circle_center = vec2(circle_radius_outer - text_width, 0.5);
+  fragColor = texture(image, texCoord_interp) * color;
+
+  /* radius in icon space (1 is the icon width).  */
+  float radius = length(mask_coord_interp - circle_center);
+  float mask = smoothstep(circle_radius_inner, circle_radius_outer, radius);
+
+  bool lower_half = mask_coord_interp.y < circle_center.y;
+  bool right_half = mask_coord_interp.x > circle_center.x;
+
+  if (right_half && mask_coord_interp.y < circle_center.y + circle_radius_outer) {
+    mask = smoothstep(circle_center.y + circle_radius_inner,
+                      circle_center.y + circle_radius_outer,
+                      mask_coord_interp.y);
+  }
+  if (lower_half && mask_coord_interp.x > circle_center.x - circle_radius_outer) {
+    mask = smoothstep(circle_center.x - circle_radius_inner,
+                      circle_center.x - circle_radius_outer,
+                      mask_coord_interp.x);
+  }
+
+  fragColor = mix(vec4(0.0), fragColor, max(mask_transparency, mask));
+}
diff --git a/source/blender/gpu/shaders/gpu_shader_icon_vert.glsl b/source/blender/gpu/shaders/gpu_shader_icon_vert.glsl
new file mode 100644
index 00000000000..25f64bfe0b6
--- /dev/null
+++ b/source/blender/gpu/shaders/gpu_shader_icon_vert.glsl
@@ -0,0 +1,37 @@
+/**
+ * Simple shader that just draw one icon at the specified location
+ * does not need any vertex input (producing less call to immBegin/End)
+ */
+
+void main()
+{
+  vec2 uv;
+  vec2 co;
+
+  if (gl_VertexID == 0) {
+    co = rect_geom.xw;
+    uv = rect_icon.xw;
+    mask_coord_interp = vec2(0, 1);
+  }
+  else if (gl_VertexID == 1) {
+    co = rect_geom.xy;
+    uv = rect_icon.xy;
+    mask_coord_interp = vec2(0, 0);
+  }
+  else if (gl_VertexID == 2) {
+    co = rect_geom.zw;
+    uv = rect_icon.zw;
+    mask_coord_interp = vec2(1, 1);
+  }
+  else {
+    co = rect_geom.zy;
+    uv = rect_icon.zy;
+    mask_coord_interp = vec2(1, 0);
+  }
+
+  /* Put origin in lower right corner. */
+  mask_coord_interp.x -= 1;
+
+  gl_Position = ModelViewProjectionMatrix * vec4(co, 0.0f, 1.0f);
+  texCoord_interp = uv;
+}
diff --git a/source/blender/gpu/shaders/gpu_shader_text_vert.glsl b/source/blender/gpu/shaders/gpu_shader_text_vert.glsl
index 47527d907f4..87e464b6cce 100644
--- a/source/blender/gpu/shaders/gpu_shader_text_vert.glsl
+++ b/source/blender/gpu/shaders/gpu_shader_text_vert.glsl
@@ -6,7 +6,7 @@ void main()
   glyph_dim = abs(glyph_size);
   interp_size = int(glyph_size.x < 0) + int(glyph_size.y < 0);
 
-  /* Quad expension using instanced rendering. */
+  /* Quad expansion using instanced rendering. */
   float x = float(gl_VertexID % 2);
   float y = float(gl_VertexID / 2);
   vec2 quad = vec2(x, y);
diff --git a/source/blender/gpu/shaders/infos/gpu_interface_info.hh b/source/blender/gpu/shaders/infos/gpu_interface_info.hh
index d77c65e48a7..060def16f81 100644
--- a/source/blender/gpu/shaders/infos/gpu_interface_info.hh
+++ b/source/blender/gpu/shaders/infos/gpu_interface_info.hh
@@ -18,3 +18,6 @@ GPU_SHADER_INTERFACE_INFO(smooth_radii_outline_iface, "").smooth(Type::VEC4, "ra
 GPU_SHADER_INTERFACE_INFO(flat_color_smooth_tex_coord_interp_iface, "")
     .flat(Type::VEC4, "finalColor")
     .smooth(Type::VEC2, "texCoord_interp");
+GPU_SHADER_INTERFACE_INFO(smooth_icon_interp_iface, "")
+    .smooth(Type::VEC2, "texCoord_interp")
+    .smooth(Type::VEC2, "mask_coord_interp");
diff --git a/source/blender/gpu/shaders/infos/gpu_shader_3D_polyline_info.hh b/source/blender/gpu/shaders/infos/gpu_shader_3D_polyline_info.hh
index 396ee64454c..23f6790abfc 100644
--- a/source/blender/gpu/shaders/infos/gpu_shader_3D_polyline_info.hh
+++ b/source/blender/gpu/shaders/infos/gpu_shader_3D_polyline_info.hh
@@ -9,7 +9,7 @@
 #include "gpu_shader_create_info.hh"
 
 GPU_SHADER_INTERFACE_INFO(gpu_shader_3D_polyline_iface, "interp")
-    .smooth(Type::VEC4, "color")
+    .smooth(Type::VEC4, "final_color")
     .smooth(Type::FLOAT, "clip")
     .no_perspective(Type::FLOAT, "smoothline");
 
@@ -29,12 +29,31 @@ GPU_SHADER_CREATE_INFO(gpu_shader_3D_polyline)
     .fragment_source("gpu_shader_3D_polyline_frag.glsl")
     .additional_info("gpu_srgb_to_framebuffer_space");
 
+GPU_SHADER_CREATE_INFO(gpu_shader_3D_polyline_no_geom)
+    .define("SMOOTH_WIDTH", "1.0")
+    .push_constant(Type::MAT4, "ModelViewProjectionMatrix")
+    .push_constant(Type::VEC2, "viewportSize")
+    .push_constant(Type::FLOAT, "lineWidth")
+    .push_constant(Type::BOOL, "lineSmooth")
+    .vertex_in(0, Type::VEC3, "pos")
+    .vertex_out(gpu_shader_3D_polyline_iface)
+    .fragment_out(0, Type::VEC4, "fragColor")
+    .vertex_source("gpu_shader_3D_polyline_vert_no_geom.glsl")
+    .fragment_source("gpu_shader_3D_polyline_frag.glsl")
+    .additional_info("gpu_srgb_to_framebuffer_space");
+
 GPU_SHADER_CREATE_INFO(gpu_shader_3D_polyline_uniform_color)
     .do_static_compilation(true)
     .define("UNIFORM")
     .push_constant(Type::VEC4, "color")
     .additional_info("gpu_shader_3D_polyline");
 
+GPU_SHADER_CREATE_INFO(gpu_shader_3D_polyline_uniform_color_no_geom)
+    // .do_static_compilation(true) /* TODO fix on GL */
+    .define("UNIFORM")
+    .push_constant(Type::VEC4, "color")
+    .additional_info("gpu_shader_3D_polyline_no_geom");
+
 GPU_SHADER_CREATE_INFO(gpu_shader_3D_polyline_uniform_color_clipped)
     .do_static_compilation(true)
     /* TODO(fclem): Put in a UBO to fit the 128byte requirement. */
@@ -43,14 +62,34 @@ GPU_SHADER_CREATE_INFO(gpu_shader_3D_polyline_uniform_color_clipped)
     .define("CLIP")
     .additional_info("gpu_shader_3D_polyline_uniform_color");
 
+GPU_SHADER_CREATE_INFO(gpu_shader_3D_polyline_uniform_color_clipped_no_geom)
+    // .do_static_compilation(true) /* TODO fix on GL */
+    /* TODO(fclem): Put in an UBO to fit the 128byte requirement. */
+    .push_constant(Type::MAT4, "ModelMatrix")
+    .push_constant(Type::VEC4, "ClipPlane")
+    .define("CLIP")
+    .additional_info("gpu_shader_3D_polyline_uniform_color_no_geom");
+
 GPU_SHADER_CREATE_INFO(gpu_shader_3D_polyline_flat_color)
     .do_static_compilation(true)
     .define("FLAT")
     .vertex_in(1, Type::VEC4, "color")
     .additional_info("gpu_shader_3D_polyline");
 
+GPU_SHADER_CREATE_INFO(gpu_shader_3D_polyline_flat_color_no_geom)
+    // .do_static_compilation(true) /* TODO fix on GL */
+    .define("FLAT")
+    .vertex_in(1, Type::VEC4, "color")
+    .additional_info("gpu_shader_3D_polyline_no_geom");
+
 GPU_SHADER_CREATE_INFO(gpu_shader_3D_polyline_smooth_color)
     .do_static_compilation(true)
     .define("SMOOTH")
     .vertex_in(1, Type::VEC4, "color")
     .additional_info("gpu_shader_3D_polyline");
+
+GPU_SHADER_CREATE_INFO(gpu_shader_3D_polyline_smooth_color_no_geom)
+    // .do_static_compilation(true) /* TODO fix on GL */
+    .define("SMOOTH")
+    .vertex_in(1, Type::VEC4, "color")
+    .additional_info("gpu_shader_3D_polyline_no_geom");
diff --git a/source/blender/gpu/shaders/infos/gpu_shader_icon_info.hh b/source/blender/gpu/shaders/infos/gpu_shader_icon_info.hh
new file mode 100644
index 00000000000..3d4077bdb09
--- /dev/null
+++ b/source/blender/gpu/shaders/infos/gpu_shader_icon_info.hh
@@ -0,0 +1,22 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later
+ * Copyright 2022 Blender Foundation. All rights reserved. */
+
+/** \file
+ * \ingroup gpu
+ */
+
+#include "gpu_interface_info.hh"
+#include "gpu_shader_create_info.hh"
+
+GPU_SHADER_CREATE_INFO(gpu_shader_icon)
+    .vertex_out(smooth_icon_interp_iface)
+    .fragment_out(0, Type::VEC4, "fragColor")
+    .push_constant(Type::MAT4, "ModelViewProjectionMatrix")
+    .push_constant(Type::VEC4, "color")
+    .push_constant(Type::VEC4, "rect_icon")
+    .push_constant(Type::VEC4, "rect_geom")
+    .push_constant(Type::FLOAT, "text_width")
+    .sampler(0, ImageType::FLOAT_2D, "image")
+    .vertex_source("gpu_shader_icon_vert.glsl")
+    .fragment_source("gpu_shader_icon_frag.glsl")
+    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/material/gpu_shader_material_attribute.glsl b/source/blender/gpu/shaders/material/gpu_shader_material_attribute.glsl
index bacf089deb1..8d0016a2206 100644
--- a/source/blender/gpu/shaders/material/gpu_shader_material_attribute.glsl
+++ b/source/blender/gpu/shaders/material/gpu_shader_material_attribute.glsl
@@ -29,6 +29,31 @@ void node_attribute_uniform(vec4 attr, const float attr_hash, out vec4 out_attr)
   out_attr = attr_load_uniform(attr, floatBitsToUint(attr_hash));
 }
 
+vec4 attr_load_layer(const uint attr_hash)
+{
+#ifdef VLATTR_LIB
+  /* The first record of the buffer stores the length. */
+  uint left = 0, right = drw_layer_attrs[0].buffer_length;
+
+  while (left < right) {
+    uint mid = (left + right) / 2;
+    uint hash = drw_layer_attrs[mid].hash_code;
+
+    if (hash < attr_hash) {
+      left = mid + 1;
+    }
+    else if (hash > attr_hash) {
+      right = mid;
+    }
+    else {
+      return drw_layer_attrs[mid].data;
+    }
+  }
+#endif
+
+  return vec4(0.0);
+}
+
 void node_attribute(
     vec4 attr, out vec4 outcol, out vec3 outvec, out float outf, out float outalpha)
 {
diff --git a/source/blender/gpu/shaders/material/gpu_shader_material_principled.glsl b/source/blender/gpu/shaders/material/gpu_shader_material_principled.glsl
index 0d8f2272c10..0833809cc42 100644
--- a/source/blender/gpu/shaders/material/gpu_shader_material_principled.glsl
+++ b/source/blender/gpu/shaders/material/gpu_shader_material_principled.glsl
@@ -91,7 +91,7 @@ void node_bsdf_principled(vec4 base_color,
   diffuse_data.sss_id = uint(do_sss);
 
   /* NOTE(@fclem): We need to blend the reflection color but also need to avoid applying the
-   * weights so we compule the ratio. */
+   * weights so we compute the ratio. */
   float reflection_weight = specular_weight + glass_reflection_weight;
   float reflection_weight_inv = safe_rcp(reflection_weight);
   specular_weight *= reflection_weight_inv;
@@ -150,7 +150,7 @@ void node_bsdf_principled(vec4 base_color,
   refraction_data.ior = ior;
 
   /* Ref. T98190: Defines are optimizations for old compilers.
-   * Might become unecessary with EEVEE-Next. */
+   * Might become unnecessary with EEVEE-Next. */
   if (do_diffuse == 0.0 && do_refraction == 0.0 && do_clearcoat != 0.0) {
 #ifdef PRINCIPLED_CLEARCOAT
     /* Metallic & Clearcoat case. */
diff --git a/source/blender/gpu/shaders/material/gpu_shader_material_tex_sky.glsl b/source/blender/gpu/shaders/material/gpu_shader_material_tex_sky.glsl
index b6aad5904ff..c4b47bc1756 100644
--- a/source/blender/gpu/shaders/material/gpu_shader_material_tex_sky.glsl
+++ b/source/blender/gpu/shaders/material/gpu_shader_material_tex_sky.glsl
@@ -144,7 +144,47 @@ void node_tex_sky_hosekwilkie(vec3 co,
   color = vec4(dot(xyz_to_r, xyz), dot(xyz_to_g, xyz), dot(xyz_to_b, xyz), 1);
 }
 
-void node_tex_sky_nishita(vec3 co, out vec4 color)
+void node_tex_sky_nishita(vec3 co,
+                          float sun_rotation,
+                          vec3 xyz_to_r,
+                          vec3 xyz_to_g,
+                          vec3 xyz_to_b,
+                          sampler2DArray ima,
+                          float layer,
+                          out vec4 color)
 {
-  color = vec4(1.0);
+  vec3 spherical = sky_spherical_coordinates(co);
+
+  vec3 xyz;
+  if (co.z < -0.4) {
+    /* too far below the horizon, just return black */
+    color = vec4(0, 0, 0, 1);
+  }
+  else {
+    /* evaluate longitudinal position on the map */
+    float x = (spherical.y + M_PI + sun_rotation) / M_2PI;
+    if (x > 1.0) {
+      x -= 1.0;
+    }
+
+    float fade;
+    float y;
+    if (co.z < 0.0) {
+      /* we're below the horizon, so extend the map by blending from values at the horizon
+       * to zero according to a cubic falloff */
+      fade = 1.0 + co.z * 2.5;
+      fade = fade * fade * fade;
+      y = 0.0;
+    }
+    else {
+      /* we're above the horizon, so compute the lateral position by inverting the remapped
+       * coordinates that are preserve to have more detail near the horizon. */
+      fade = 1.0;
+      y = sqrt((M_PI_2 - spherical.x) / M_PI_2);
+    }
+
+    /* look up color in the precomputed map and convert to RGB */
+    xyz = fade * texture(ima, vec3(x, y, layer)).rgb;
+    color = vec4(dot(xyz_to_r, xyz), dot(xyz_to_g, xyz), dot(xyz_to_b, xyz), 1);
+  }
 }
diff --git a/source/blender/gpu/shaders/opengl/glsl_shader_defines.glsl b/source/blender/gpu/shaders/opengl/glsl_shader_defines.glsl
index 0515a737e6e..706bae3e940 100644
--- a/source/blender/gpu/shaders/opengl/glsl_shader_defines.glsl
+++ b/source/blender/gpu/shaders/opengl/glsl_shader_defines.glsl
@@ -1,5 +1,5 @@
 
-/* Texture format tokens -- Type explictness required by other Graphics APIs. */
+/* Texture format tokens -- Type explicitness required by other Graphics APIs. */
 #define depth2D sampler2D
 #define depth2DArray sampler2DArray
 #define depth2DMS sampler2DMS