EEVEE: Refactor curve nodes

This patches rewrites the GPU shaders of curve nodes for easier future
development. This is a non-functional change. The new code avoids code
duplication by moving common code into BKE curve mapping functions. It
also avoids ambiguous data embedding into the gradient vectors that are
passed to vectors and reduces the size of uniforms uploaded to the
shader by avoiding redundancies.

This is needed in preparation for the viewport compositor, which will
utilize and extend this implementation.

Reviewed By: fclem

Differential Revision: https://developer.blender.org/D14689

5 files changed, 163 insertions, 150 deletions

diff --git a/source/blender/gpu/CMakeLists.txt b/source/blender/gpu/CMakeLists.txt
index dc542411596..5fee9167362 100644
--- a/source/blender/gpu/CMakeLists.txt
+++ b/source/blender/gpu/CMakeLists.txt
@@ -305,6 +305,7 @@ set(GLSL_SRC
 
   shaders/common/gpu_shader_common_color_ramp.glsl
   shaders/common/gpu_shader_common_color_utils.glsl
+  shaders/common/gpu_shader_common_curves.glsl
   shaders/common/gpu_shader_common_hash.glsl
   shaders/common/gpu_shader_common_math.glsl
   shaders/common/gpu_shader_common_math_utils.glsl
@@ -330,7 +331,6 @@ set(GLSL_SRC
   shaders/material/gpu_shader_material_displacement.glsl
   shaders/material/gpu_shader_material_eevee_specular.glsl
   shaders/material/gpu_shader_material_emission.glsl
-  shaders/material/gpu_shader_material_float_curve.glsl
   shaders/material/gpu_shader_material_fractal_noise.glsl
   shaders/material/gpu_shader_material_fresnel.glsl
   shaders/material/gpu_shader_material_gamma.glsl
@@ -359,7 +359,6 @@ set(GLSL_SRC
   shaders/material/gpu_shader_material_point_info.glsl
   shaders/material/gpu_shader_material_principled.glsl
   shaders/material/gpu_shader_material_refraction.glsl
-  shaders/material/gpu_shader_material_rgb_curves.glsl
   shaders/material/gpu_shader_material_rgb_to_bw.glsl
   shaders/material/gpu_shader_material_separate_color.glsl
   shaders/material/gpu_shader_material_separate_hsv.glsl
@@ -388,7 +387,6 @@ set(GLSL_SRC
   shaders/material/gpu_shader_material_translucent.glsl
   shaders/material/gpu_shader_material_transparent.glsl
   shaders/material/gpu_shader_material_uv_map.glsl
-  shaders/material/gpu_shader_material_vector_curves.glsl
   shaders/material/gpu_shader_material_vector_displacement.glsl
   shaders/material/gpu_shader_material_vector_math.glsl
   shaders/material/gpu_shader_material_vector_rotate.glsl
diff --git a/source/blender/gpu/shaders/common/gpu_shader_common_curves.glsl b/source/blender/gpu/shaders/common/gpu_shader_common_curves.glsl
new file mode 100644
index 00000000000..8948ed77557
--- /dev/null
+++ b/source/blender/gpu/shaders/common/gpu_shader_common_curves.glsl
@@ -0,0 +1,162 @@
+vec4 white_balance(vec4 color, vec4 black_level, vec4 white_level)
+{
+  vec4 range = max(white_level - black_level, vec4(1e-5f));
+  return (color - black_level) / range;
+}
+
+float extrapolate_if_needed(float parameter, float value, float start_slope, float end_slope)
+{
+  if (parameter < 0.0) {
+    return value + parameter * start_slope;
+  }
+
+  if (parameter > 1.0) {
+    return value + (parameter - 1.0) * end_slope;
+  }
+
+  return value;
+}
+
+/* Same as extrapolate_if_needed but vectorized. */
+vec3 extrapolate_if_needed(vec3 parameters, vec3 values, vec3 start_slopes, vec3 end_slopes)
+{
+  vec3 end_or_zero_slopes = mix(vec3(0.0), end_slopes, greaterThan(parameters, vec3(1.0)));
+  vec3 slopes = mix(end_or_zero_slopes, start_slopes, lessThan(parameters, vec3(0.0)));
+  parameters = parameters - mix(vec3(0.0), vec3(1.0), greaterThan(parameters, vec3(1.0)));
+  return values + parameters * slopes;
+}
+
+/* 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 curves_combined_rgb(float factor,
+                         vec4 color,
+                         vec4 black_level,
+                         vec4 white_level,
+                         sampler1DArray curve_map,
+                         const float layer,
+                         vec4 range_minimums,
+                         vec4 range_dividers,
+                         vec4 start_slopes,
+                         vec4 end_slopes,
+                         out vec4 result)
+{
+  vec4 balanced = white_balance(color, black_level, white_level);
+
+  /* First, evaluate alpha curve map at all channels. The alpha curve is the Combined curve in the
+   * UI. */
+  vec3 parameters = NORMALIZE_PARAMETER(balanced.rgb, range_minimums.aaa, range_dividers.aaa);
+  result.r = texture(curve_map, vec2(parameters.x, layer)).a;
+  result.g = texture(curve_map, vec2(parameters.y, layer)).a;
+  result.b = texture(curve_map, vec2(parameters.z, layer)).a;
+
+  /* Then, extrapolate if needed. */
+  result.rgb = extrapolate_if_needed(parameters, result.rgb, start_slopes.aaa, end_slopes.aaa);
+
+  /* Then, evaluate each channel on its curve map. */
+  parameters = NORMALIZE_PARAMETER(result.rgb, range_minimums.rgb, range_dividers.rgb);
+  result.r = texture(curve_map, vec2(parameters.r, layer)).r;
+  result.g = texture(curve_map, vec2(parameters.g, layer)).g;
+  result.b = texture(curve_map, vec2(parameters.b, layer)).b;
+
+  /* Then, extrapolate again if needed. */
+  result.rgb = extrapolate_if_needed(parameters, result.rgb, start_slopes.rgb, end_slopes.rgb);
+  result.a = color.a;
+
+  result = mix(color, result, factor);
+}
+
+void curves_combined_only(float factor,
+                          vec4 color,
+                          vec4 black_level,
+                          vec4 white_level,
+                          sampler1DArray curve_map,
+                          const float layer,
+                          float range_minimum,
+                          float range_divider,
+                          float start_slope,
+                          float end_slope,
+                          out vec4 result)
+{
+  vec4 balanced = white_balance(color, black_level, white_level);
+
+  /* Evaluate alpha curve map at all channels. The alpha curve is the Combined curve in the
+   * UI. */
+  vec3 parameters = NORMALIZE_PARAMETER(balanced.rgb, range_minimum, range_divider);
+  result.r = texture(curve_map, vec2(parameters.x, layer)).a;
+  result.g = texture(curve_map, vec2(parameters.y, layer)).a;
+  result.b = texture(curve_map, vec2(parameters.z, layer)).a;
+
+  /* Then, extrapolate if needed. */
+  result.rgb = extrapolate_if_needed(parameters, result.rgb, vec3(start_slope), vec3(end_slope));
+  result.a = color.a;
+
+  result = mix(color, result, factor);
+}
+
+void curves_vector(vec3 vector,
+                   sampler1DArray curve_map,
+                   const float layer,
+                   vec3 range_minimums,
+                   vec3 range_dividers,
+                   vec3 start_slopes,
+                   vec3 end_slopes,
+                   out vec3 result)
+{
+  /* Evaluate each component on its curve map. */
+  vec3 parameters = NORMALIZE_PARAMETER(vector, range_minimums, range_dividers);
+  result.x = texture(curve_map, vec2(parameters.x, layer)).x;
+  result.y = texture(curve_map, vec2(parameters.y, layer)).y;
+  result.z = texture(curve_map, vec2(parameters.z, layer)).z;
+
+  /* Then, extrapolate if needed. */
+  result = extrapolate_if_needed(parameters, result, start_slopes, end_slopes);
+}
+
+void curves_vector_mixed(float factor,
+                         vec3 vector,
+                         sampler1DArray curve_map,
+                         const float layer,
+                         vec3 range_minimums,
+                         vec3 range_dividers,
+                         vec3 start_slopes,
+                         vec3 end_slopes,
+                         out vec3 result)
+{
+  curves_vector(
+      vector, curve_map, layer, range_minimums, range_dividers, start_slopes, end_slopes, result);
+  result = mix(vector, result, factor);
+}
+
+void curves_float(float value,
+                  sampler1DArray curve_map,
+                  const float layer,
+                  float range_minimum,
+                  float range_divider,
+                  float start_slope,
+                  float end_slope,
+                  out float result)
+{
+  /* Evaluate the normalized value on the first curve map. */
+  float parameter = NORMALIZE_PARAMETER(value, range_minimum, range_divider);
+  result = texture(curve_map, vec2(parameter, layer)).x;
+
+  /* Then, extrapolate if needed. */
+  result = extrapolate_if_needed(parameter, result, start_slope, end_slope);
+}
+
+void curves_float_mixed(float factor,
+                        float value,
+                        sampler1DArray curve_map,
+                        const float layer,
+                        float range_minimum,
+                        float range_divider,
+                        float start_slope,
+                        float end_slope,
+                        out float result)
+{
+  curves_float(
+      value, curve_map, layer, range_minimum, range_divider, start_slope, end_slope, result);
+  result = mix(value, result, factor);
+}
diff --git a/source/blender/gpu/shaders/material/gpu_shader_material_float_curve.glsl b/source/blender/gpu/shaders/material/gpu_shader_material_float_curve.glsl
deleted file mode 100644
index 514409f7fdf..00000000000
--- a/source/blender/gpu/shaders/material/gpu_shader_material_float_curve.glsl
+++ /dev/null
@@ -1,33 +0,0 @@
-/* ext is vec4(in_x, in_dy, out_x, out_dy). */
-float curve_float_extrapolate(float x, float y, vec4 ext)
-{
-  if (x < 0.0) {
-    return y + x * ext.y;
-  }
-  else if (x > 1.0) {
-    return y + (x - 1.0) * ext.w;
-  }
-  else {
-    return y;
-  }
-}
-
-#define RANGE_RESCALE(x, min, range) ((x - min) * range)
-
-void curve_float(float fac,
-                 float vec,
-                 sampler1DArray curvemap,
-                 float layer,
-                 float range,
-                 vec4 ext,
-                 out float outvec)
-{
-  float xyz_min = ext.x;
-  vec = RANGE_RESCALE(vec, xyz_min, range);
-
-  outvec = texture(curvemap, vec2(vec, layer)).x;
-
-  outvec = curve_float_extrapolate(vec, outvec, ext);
-
-  outvec = mix(vec, outvec, fac);
-}
diff --git a/source/blender/gpu/shaders/material/gpu_shader_material_rgb_curves.glsl b/source/blender/gpu/shaders/material/gpu_shader_material_rgb_curves.glsl
deleted file mode 100644
index 054fdddf7c3..00000000000
--- a/source/blender/gpu/shaders/material/gpu_shader_material_rgb_curves.glsl
+++ /dev/null
@@ -1,73 +0,0 @@
-/* ext is vec4(in_x, in_dy, out_x, out_dy). */
-float curve_extrapolate(float x, float y, vec4 ext)
-{
-  if (x < 0.0) {
-    return y + x * ext.y;
-  }
-  else if (x > 1.0) {
-    return y + (x - 1.0) * ext.w;
-  }
-  else {
-    return y;
-  }
-}
-
-#define RANGE_RESCALE(x, min, range) ((x - min) * range)
-
-void curves_rgb(float fac,
-                vec4 col,
-                sampler1DArray curvemap,
-                float layer,
-                vec4 range,
-                vec4 ext_r,
-                vec4 ext_g,
-                vec4 ext_b,
-                vec4 ext_a,
-                out vec4 outcol)
-{
-  vec4 co = vec4(RANGE_RESCALE(col.rgb, ext_a.x, range.a), layer);
-  vec3 samp;
-  samp.r = texture(curvemap, co.xw).a;
-  samp.g = texture(curvemap, co.yw).a;
-  samp.b = texture(curvemap, co.zw).a;
-
-  samp.r = curve_extrapolate(co.x, samp.r, ext_a);
-  samp.g = curve_extrapolate(co.y, samp.g, ext_a);
-  samp.b = curve_extrapolate(co.z, samp.b, ext_a);
-
-  vec3 rgb_min = vec3(ext_r.x, ext_g.x, ext_b.x);
-  co.xyz = RANGE_RESCALE(samp.rgb, rgb_min, range.rgb);
-
-  samp.r = texture(curvemap, co.xw).r;
-  samp.g = texture(curvemap, co.yw).g;
-  samp.b = texture(curvemap, co.zw).b;
-
-  outcol.r = curve_extrapolate(co.x, samp.r, ext_r);
-  outcol.g = curve_extrapolate(co.y, samp.g, ext_g);
-  outcol.b = curve_extrapolate(co.z, samp.b, ext_b);
-  outcol.a = col.a;
-
-  outcol = mix(col, outcol, fac);
-}
-
-void curves_rgb_opti(float fac,
-                     vec4 col,
-                     sampler1DArray curvemap,
-                     float layer,
-                     vec4 range,
-                     vec4 ext_a,
-                     out vec4 outcol)
-{
-  vec4 co = vec4(RANGE_RESCALE(col.rgb, ext_a.x, range.a), layer);
-  vec3 samp;
-  samp.r = texture(curvemap, co.xw).a;
-  samp.g = texture(curvemap, co.yw).a;
-  samp.b = texture(curvemap, co.zw).a;
-
-  outcol.r = curve_extrapolate(co.x, samp.r, ext_a);
-  outcol.g = curve_extrapolate(co.y, samp.g, ext_a);
-  outcol.b = curve_extrapolate(co.z, samp.b, ext_a);
-  outcol.a = col.a;
-
-  outcol = mix(col, outcol, fac);
-}
diff --git a/source/blender/gpu/shaders/material/gpu_shader_material_vector_curves.glsl b/source/blender/gpu/shaders/material/gpu_shader_material_vector_curves.glsl
deleted file mode 100644
index f6dec1b24e2..00000000000
--- a/source/blender/gpu/shaders/material/gpu_shader_material_vector_curves.glsl
+++ /dev/null
@@ -1,41 +0,0 @@
-/* ext is vec4(in_x, in_dy, out_x, out_dy). */
-float curve_vec_extrapolate(float x, float y, vec4 ext)
-{
-  if (x < 0.0) {
-    return y + x * ext.y;
-  }
-  else if (x > 1.0) {
-    return y + (x - 1.0) * ext.w;
-  }
-  else {
-    return y;
-  }
-}
-
-#define RANGE_RESCALE(x, min, range) ((x - min) * range)
-
-void curves_vec(float fac,
-                vec3 vec,
-                sampler1DArray curvemap,
-                float layer,
-                vec3 range,
-                vec4 ext_x,
-                vec4 ext_y,
-                vec4 ext_z,
-                out vec3 outvec)
-{
-  vec4 co = vec4(vec, layer);
-
-  vec3 xyz_min = vec3(ext_x.x, ext_y.x, ext_z.x);
-  co.xyz = RANGE_RESCALE(co.xyz, xyz_min, range);
-
-  outvec.x = texture(curvemap, co.xw).x;
-  outvec.y = texture(curvemap, co.yw).y;
-  outvec.z = texture(curvemap, co.zw).z;
-
-  outvec.x = curve_vec_extrapolate(co.x, outvec.r, ext_x);
-  outvec.y = curve_vec_extrapolate(co.y, outvec.g, ext_y);
-  outvec.z = curve_vec_extrapolate(co.z, outvec.b, ext_z);
-
-  outvec = mix(vec, outvec, fac);
-}