Nodes: Add Float Curve for GN and Shader nodes.

Replacement for float curve in legacy Attribute Curve Map node.

Float Curve defaults to [0.0-1.0] range.

Reviewed By: JacquesLucke, brecht

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

23 files changed, 456 insertions, 8 deletions

diff --git a/intern/cycles/blender/blender_shader.cpp b/intern/cycles/blender/blender_shader.cpp
index 8c4f789ffd0..0b8aea15d6c 100644
--- a/intern/cycles/blender/blender_shader.cpp
+++ b/intern/cycles/blender/blender_shader.cpp
@@ -279,7 +279,7 @@ static ShaderNode *add_node(Scene *scene,
     array<float3> curve_mapping_curves;
     float min_x, max_x;
     curvemapping_color_to_array(mapping, curve_mapping_curves, RAMP_TABLE_SIZE, true);
-    curvemapping_minmax(mapping, true, &min_x, &max_x);
+    curvemapping_minmax(mapping, 4, &min_x, &max_x);
     curves->set_min_x(min_x);
     curves->set_max_x(max_x);
     curves->set_curves(curve_mapping_curves);
@@ -292,12 +292,25 @@ static ShaderNode *add_node(Scene *scene,
     array<float3> curve_mapping_curves;
     float min_x, max_x;
     curvemapping_color_to_array(mapping, curve_mapping_curves, RAMP_TABLE_SIZE, false);
-    curvemapping_minmax(mapping, false, &min_x, &max_x);
+    curvemapping_minmax(mapping, 3, &min_x, &max_x);
     curves->set_min_x(min_x);
     curves->set_max_x(max_x);
     curves->set_curves(curve_mapping_curves);
     node = curves;
   }
+  else if (b_node.is_a(&RNA_ShaderNodeFloatCurve)) {
+    BL::ShaderNodeFloatCurve b_curve_node(b_node);
+    BL::CurveMapping mapping(b_curve_node.mapping());
+    FloatCurveNode *curve = graph->create_node<FloatCurveNode>();
+    array<float> curve_mapping_curve;
+    float min_x, max_x;
+    curvemapping_float_to_array(mapping, curve_mapping_curve, RAMP_TABLE_SIZE);
+    curvemapping_minmax(mapping, 1, &min_x, &max_x);
+    curve->set_min_x(min_x);
+    curve->set_max_x(max_x);
+    curve->set_curve(curve_mapping_curve);
+    node = curve;
+  }
   else if (b_node.is_a(&RNA_ShaderNodeValToRGB)) {
     RGBRampNode *ramp = graph->create_node<RGBRampNode>();
     BL::ShaderNodeValToRGB b_ramp_node(b_node);
diff --git a/intern/cycles/blender/blender_util.h b/intern/cycles/blender/blender_util.h
index 128fcbd7055..77b2bd5ac4f 100644
--- a/intern/cycles/blender/blender_util.h
+++ b/intern/cycles/blender/blender_util.h
@@ -171,12 +171,11 @@ static inline void curvemap_minmax_curve(/*const*/ BL::CurveMap &curve, float *m
 }
 
 static inline void curvemapping_minmax(/*const*/ BL::CurveMapping &cumap,
-                                       bool rgb_curve,
+                                       int num_curves,
                                        float *min_x,
                                        float *max_x)
 {
   // const int num_curves = cumap.curves.length(); /* Gives linking error so far. */
-  const int num_curves = rgb_curve ? 4 : 3;
   *min_x = FLT_MAX;
   *max_x = -FLT_MAX;
   for (int i = 0; i < num_curves; ++i) {
@@ -196,6 +195,28 @@ static inline void curvemapping_to_array(BL::CurveMapping &cumap, array<float> &
   }
 }
 
+static inline void curvemapping_float_to_array(BL::CurveMapping &cumap,
+                                               array<float> &data,
+                                               int size)
+{
+  float min = 0.0f, max = 1.0f;
+
+  curvemapping_minmax(cumap, 1, &min, &max);
+
+  const float range = max - min;
+
+  cumap.update();
+
+  BL::CurveMap map = cumap.curves[0];
+
+  data.resize(size);
+
+  for (int i = 0; i < size; i++) {
+    float t = min + (float)i / (float)(size - 1) * range;
+    data[i] = cumap.evaluate(map, t);
+  }
+}
+
 static inline void curvemapping_color_to_array(BL::CurveMapping &cumap,
                                                array<float3> &data,
                                                int size,
@@ -214,7 +235,8 @@ static inline void curvemapping_color_to_array(BL::CurveMapping &cumap,
    *
    * There might be some better estimations here tho.
    */
-  curvemapping_minmax(cumap, rgb_curve, &min_x, &max_x);
+  const int num_curves = rgb_curve ? 4 : 3;
+  curvemapping_minmax(cumap, num_curves, &min_x, &max_x);
 
   const float range_x = max_x - min_x;
 
diff --git a/intern/cycles/kernel/shaders/CMakeLists.txt b/intern/cycles/kernel/shaders/CMakeLists.txt
index 02be7813369..6b62e7bb52f 100644
--- a/intern/cycles/kernel/shaders/CMakeLists.txt
+++ b/intern/cycles/kernel/shaders/CMakeLists.txt
@@ -41,6 +41,7 @@ set(SRC_OSL
   node_vector_displacement.osl
   node_emission.osl
   node_environment_texture.osl
+  node_float_curve.osl
   node_fresnel.osl
   node_gamma.osl
   node_geometry.osl
diff --git a/intern/cycles/kernel/shaders/node_float_curve.osl b/intern/cycles/kernel/shaders/node_float_curve.osl
new file mode 100644
index 00000000000..f1f05fd88a9
--- /dev/null
+++ b/intern/cycles/kernel/shaders/node_float_curve.osl
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2011-2021 Blender Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "node_ramp_util.h"
+#include "stdcycles.h"
+
+shader node_float_curve(float ramp[] = {0.0},
+                        float min_x = 0.0,
+                        float max_x = 1.0,
+                        float ValueIn = 0.0,
+                        float Factor = 0.0,
+                        output float ValueOut = 0.0)
+{
+  float c = (ValueIn - min_x) / (max_x - min_x);
+
+  ValueOut = rgb_ramp_lookup(ramp, c, 1, 1);
+
+  ValueOut = mix(ValueIn, ValueOut, Factor);
+}
diff --git a/intern/cycles/kernel/svm/svm.h b/intern/cycles/kernel/svm/svm.h
index 4aee1ef11b3..ad609b15f86 100644
--- a/intern/cycles/kernel/svm/svm.h
+++ b/intern/cycles/kernel/svm/svm.h
@@ -493,11 +493,13 @@ ccl_device void svm_eval_nodes(INTEGRATOR_STATE_CONST_ARGS,
       case NODE_IES:
         svm_node_ies(kg, sd, stack, node);
         break;
-
       case NODE_RGB_CURVES:
       case NODE_VECTOR_CURVES:
         offset = svm_node_curves(kg, sd, stack, node, offset);
         break;
+      case NODE_FLOAT_CURVE:
+        offset = svm_node_curve(kg, sd, stack, node, offset);
+        break;
       case NODE_TANGENT:
         svm_node_tangent(kg, sd, stack, node);
         break;
diff --git a/intern/cycles/kernel/svm/svm_ramp.h b/intern/cycles/kernel/svm/svm_ramp.h
index e92df3c093c..563e5bcb5e4 100644
--- a/intern/cycles/kernel/svm/svm_ramp.h
+++ b/intern/cycles/kernel/svm/svm_ramp.h
@@ -21,6 +21,48 @@ CCL_NAMESPACE_BEGIN
 
 /* NOTE: svm_ramp.h, svm_ramp_util.h and node_ramp_util.h must stay consistent */
 
+ccl_device_inline float fetch_float(const KernelGlobals *kg, int offset)
+{
+  uint4 node = kernel_tex_fetch(__svm_nodes, offset);
+  return __uint_as_float(node.x);
+}
+
+ccl_device_inline float float_ramp_lookup(const KernelGlobals *kg,
+                                          int offset,
+                                          float f,
+                                          bool interpolate,
+                                          bool extrapolate,
+                                          int table_size)
+{
+  if ((f < 0.0f || f > 1.0f) && extrapolate) {
+    float t0, dy;
+    if (f < 0.0f) {
+      t0 = fetch_float(kg, offset);
+      dy = t0 - fetch_float(kg, offset + 1);
+      f = -f;
+    }
+    else {
+      t0 = fetch_float(kg, offset + table_size - 1);
+      dy = t0 - fetch_float(kg, offset + table_size - 2);
+      f = f - 1.0f;
+    }
+    return t0 + dy * f * (table_size - 1);
+  }
+
+  f = saturate(f) * (table_size - 1);
+
+  /* clamp int as well in case of NaN */
+  int i = clamp(float_to_int(f), 0, table_size - 1);
+  float t = f - (float)i;
+
+  float a = fetch_float(kg, offset + i);
+
+  if (interpolate && t > 0.0f)
+    a = (1.0f - t) * a + t * fetch_float(kg, offset + i + 1);
+
+  return a;
+}
+
 ccl_device_inline float4 rgb_ramp_lookup(const KernelGlobals *kg,
                                          int offset,
                                          float f,
@@ -105,6 +147,30 @@ ccl_device_noinline int svm_node_curves(
   return offset;
 }
 
+ccl_device_noinline int svm_node_curve(
+    const KernelGlobals *kg, ShaderData *sd, float *stack, uint4 node, int offset)
+{
+  uint fac_offset, value_in_offset, out_offset;
+  svm_unpack_node_uchar3(node.y, &fac_offset, &value_in_offset, &out_offset);
+
+  uint table_size = read_node(kg, &offset).x;
+
+  float fac = stack_load_float(stack, fac_offset);
+  float in = stack_load_float(stack, value_in_offset);
+
+  const float min = __int_as_float(node.z), max = __int_as_float(node.w);
+  const float range = max - min;
+  const float relpos = (in - min) / range;
+
+  float v = float_ramp_lookup(kg, offset, relpos, true, true, table_size);
+
+  in = (1.0f - fac) * in + fac * v;
+  stack_store_float(stack, out_offset, in);
+
+  offset += table_size;
+  return offset;
+}
+
 CCL_NAMESPACE_END
 
 #endif /* __SVM_RAMP_H__ */
diff --git a/intern/cycles/kernel/svm/svm_types.h b/intern/cycles/kernel/svm/svm_types.h
index 313bc3235b9..59a0e33acbc 100644
--- a/intern/cycles/kernel/svm/svm_types.h
+++ b/intern/cycles/kernel/svm/svm_types.h
@@ -122,6 +122,7 @@ typedef enum ShaderNodeType {
   NODE_AOV_START,
   NODE_AOV_COLOR,
   NODE_AOV_VALUE,
+  NODE_FLOAT_CURVE,
   /* NOTE: for best OpenCL performance, item definition in the enum must
    * match the switch case order in svm.h. */
 } ShaderNodeType;
diff --git a/intern/cycles/render/nodes.cpp b/intern/cycles/render/nodes.cpp
index 90f70cf19ec..1629895ff6e 100644
--- a/intern/cycles/render/nodes.cpp
+++ b/intern/cycles/render/nodes.cpp
@@ -6382,7 +6382,7 @@ void BumpNode::constant_fold(const ConstantFolder &folder)
   /* TODO(sergey): Ignore bump with zero strength. */
 }
 
-/* Curve node */
+/* Curves node */
 
 CurvesNode::CurvesNode(const NodeType *node_type) : ShaderNode(node_type)
 {
@@ -6531,6 +6531,83 @@ void VectorCurvesNode::compile(OSLCompiler &compiler)
   CurvesNode::compile(compiler, "node_vector_curves");
 }
 
+/* FloatCurveNode */
+
+NODE_DEFINE(FloatCurveNode)
+{
+  NodeType *type = NodeType::add("float_curve", create, NodeType::SHADER);
+
+  SOCKET_FLOAT_ARRAY(curve, "Curve", array<float>());
+  SOCKET_FLOAT(min_x, "Min X", 0.0f);
+  SOCKET_FLOAT(max_x, "Max X", 1.0f);
+
+  SOCKET_IN_FLOAT(fac, "Factor", 0.0f);
+  SOCKET_IN_FLOAT(value, "Value", 0.0f);
+
+  SOCKET_OUT_FLOAT(value, "Value");
+
+  return type;
+}
+
+FloatCurveNode::FloatCurveNode() : ShaderNode(get_node_type())
+{
+}
+
+void FloatCurveNode::constant_fold(const ConstantFolder &folder)
+{
+  ShaderInput *value_in = input("Value");
+  ShaderInput *fac_in = input("Factor");
+
+  /* evaluate fully constant node */
+  if (folder.all_inputs_constant()) {
+    if (curve.size() == 0) {
+      return;
+    }
+
+    float pos = (value - min_x) / (max_x - min_x);
+    float result = float_ramp_lookup(curve.data(), pos, true, true, curve.size());
+
+    folder.make_constant(value + fac * (result - value));
+  }
+  /* remove no-op node */
+  else if (!fac_in->link && fac == 0.0f) {
+    /* link is not null because otherwise all inputs are constant */
+    folder.bypass(value_in->link);
+  }
+}
+
+void FloatCurveNode::compile(SVMCompiler &compiler)
+{
+  if (curve.size() == 0)
+    return;
+
+  ShaderInput *value_in = input("Value");
+  ShaderInput *fac_in = input("Factor");
+  ShaderOutput *value_out = output("Value");
+
+  compiler.add_node(NODE_FLOAT_CURVE,
+                    compiler.encode_uchar4(compiler.stack_assign(fac_in),
+                                           compiler.stack_assign(value_in),
+                                           compiler.stack_assign(value_out)),
+                    __float_as_int(min_x),
+                    __float_as_int(max_x));
+
+  compiler.add_node(curve.size());
+  for (int i = 0; i < curve.size(); i++)
+    compiler.add_node(make_float4(curve[i]));
+}
+
+void FloatCurveNode::compile(OSLCompiler &compiler)
+{
+  if (curve.size() == 0)
+    return;
+
+  compiler.parameter_array("ramp", curve.data(), curve.size());
+  compiler.parameter(this, "min_x");
+  compiler.parameter(this, "max_x");
+  compiler.add(this, "node_float_curve");
+}
+
 /* RGBRampNode */
 
 NODE_DEFINE(RGBRampNode)
diff --git a/intern/cycles/render/nodes.h b/intern/cycles/render/nodes.h
index 22bdb06b059..5ac72835ac5 100644
--- a/intern/cycles/render/nodes.h
+++ b/intern/cycles/render/nodes.h
@@ -1398,6 +1398,18 @@ class VectorCurvesNode : public CurvesNode {
   void constant_fold(const ConstantFolder &folder);
 };
 
+class FloatCurveNode : public ShaderNode {
+ public:
+  SHADER_NODE_CLASS(FloatCurveNode)
+  void constant_fold(const ConstantFolder &folder);
+
+  NODE_SOCKET_API_ARRAY(array<float>, curve)
+  NODE_SOCKET_API(float, min_x)
+  NODE_SOCKET_API(float, max_x)
+  NODE_SOCKET_API(float, fac)
+  NODE_SOCKET_API(float, value)
+};
+
 class RGBRampNode : public ShaderNode {
  public:
   SHADER_NODE_CLASS(RGBRampNode)
diff --git a/release/scripts/startup/nodeitems_builtins.py b/release/scripts/startup/nodeitems_builtins.py
index 06992022edb..5e6f9b9a76a 100644
--- a/release/scripts/startup/nodeitems_builtins.py
+++ b/release/scripts/startup/nodeitems_builtins.py
@@ -279,6 +279,7 @@ shader_node_categories = [
     ]),
     ShaderNodeCategory("SH_NEW_CONVERTOR", "Converter", items=[
         NodeItem("ShaderNodeMapRange"),
+        NodeItem("ShaderNodeFloatCurve"),
         NodeItem("ShaderNodeClamp"),
         NodeItem("ShaderNodeMath"),
         NodeItem("ShaderNodeValToRGB"),
@@ -615,6 +616,7 @@ geometry_node_categories = [
     ]),
     GeometryNodeCategory("GEO_UTILITIES", "Utilities", items=[
         NodeItem("ShaderNodeMapRange"),
+        NodeItem("ShaderNodeFloatCurve"),
         NodeItem("ShaderNodeClamp"),
         NodeItem("ShaderNodeMath"),
         NodeItem("FunctionNodeBooleanMath"),
diff --git a/source/blender/blenkernel/BKE_colortools.h b/source/blender/blenkernel/BKE_colortools.h
index ec2262d4f60..109947cece4 100644
--- a/source/blender/blenkernel/BKE_colortools.h
+++ b/source/blender/blenkernel/BKE_colortools.h
@@ -97,6 +97,7 @@ void BKE_curvemapping_evaluate_premulRGBF(const struct CurveMapping *cumap,
                                           float vecout[3],
                                           const float vecin[3]);
 bool BKE_curvemapping_RGBA_does_something(const struct CurveMapping *cumap);
+void BKE_curvemapping_table_F(const struct CurveMapping *cumap, float **array, int *size);
 void BKE_curvemapping_table_RGBA(const struct CurveMapping *cumap, float **array, int *size);
 
 /* non-const, these modify the curve */
diff --git a/source/blender/blenkernel/BKE_node.h b/source/blender/blenkernel/BKE_node.h
index 76a3e75d285..a4fc4800fd2 100644
--- a/source/blender/blenkernel/BKE_node.h
+++ b/source/blender/blenkernel/BKE_node.h
@@ -1102,6 +1102,7 @@ void BKE_nodetree_remove_layer_n(struct bNodeTree *ntree,
 #define SH_NODE_VERTEX_COLOR 706
 #define SH_NODE_OUTPUT_AOV 707
 #define SH_NODE_VECTOR_ROTATE 708
+#define SH_NODE_CURVE_FLOAT 709
 
 /* custom defines options for Material node */
 // #define SH_NODE_MAT_DIFF 1
diff --git a/source/blender/blenkernel/intern/colortools.c b/source/blender/blenkernel/intern/colortools.c
index f2c2e552a9f..62b817487fc 100644
--- a/source/blender/blenkernel/intern/colortools.c
+++ b/source/blender/blenkernel/intern/colortools.c
@@ -1212,6 +1212,20 @@ void BKE_curvemapping_init(CurveMapping *cumap)
   }
 }
 
+void BKE_curvemapping_table_F(const CurveMapping *cumap, float **array, int *size)
+{
+  int a;
+
+  *size = CM_TABLE + 1;
+  *array = MEM_callocN(sizeof(float) * (*size) * 4, "CurveMapping");
+
+  for (a = 0; a < *size; a++) {
+    if (cumap->cm[0].table) {
+      (*array)[a * 4 + 0] = cumap->cm[0].table[a].y;
+    }
+  }
+}
+
 void BKE_curvemapping_table_RGBA(const CurveMapping *cumap, float **array, int *size)
 {
   int a;
diff --git a/source/blender/blenkernel/intern/node.cc b/source/blender/blenkernel/intern/node.cc
index a3a82bee8dc..66f917ffd96 100644
--- a/source/blender/blenkernel/intern/node.cc
+++ b/source/blender/blenkernel/intern/node.cc
@@ -538,7 +538,7 @@ void ntreeBlendWrite(BlendWriter *writer, bNodeTree *ntree)
     if (node->storage) {
       /* could be handlerized at some point, now only 1 exception still */
       if (ELEM(ntree->type, NTREE_SHADER, NTREE_GEOMETRY) &&
-          ELEM(node->type, SH_NODE_CURVE_VEC, SH_NODE_CURVE_RGB)) {
+          ELEM(node->type, SH_NODE_CURVE_VEC, SH_NODE_CURVE_RGB, SH_NODE_CURVE_FLOAT)) {
         BKE_curvemapping_blend_write(writer, (const CurveMapping *)node->storage);
       }
       else if ((ntree->type == NTREE_GEOMETRY) &&
@@ -714,6 +714,7 @@ void ntreeBlendReadData(BlendDataReader *reader, bNodeTree *ntree)
       switch (node->type) {
         case SH_NODE_CURVE_VEC:
         case SH_NODE_CURVE_RGB:
+        case SH_NODE_CURVE_FLOAT:
         case CMP_NODE_TIME:
         case CMP_NODE_CURVE_VEC:
         case CMP_NODE_CURVE_RGB:
@@ -5574,6 +5575,7 @@ static void registerShaderNodes()
   register_node_type_sh_shadertorgb();
   register_node_type_sh_normal();
   register_node_type_sh_mapping();
+  register_node_type_sh_curve_float();
   register_node_type_sh_curve_vec();
   register_node_type_sh_curve_rgb();
   register_node_type_sh_map_range();
diff --git a/source/blender/editors/space_node/drawnode.cc b/source/blender/editors/space_node/drawnode.cc
index b4a9b90434c..8d6d56fc383 100644
--- a/source/blender/editors/space_node/drawnode.cc
+++ b/source/blender/editors/space_node/drawnode.cc
@@ -164,6 +164,11 @@ static void node_buts_curvevec(uiLayout *layout, bContext *UNUSED(C), PointerRNA
   uiTemplateCurveMapping(layout, ptr, "mapping", 'v', false, false, false, false);
 }
 
+static void node_buts_curvefloat(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
+{
+  uiTemplateCurveMapping(layout, ptr, "mapping", 0, false, false, false, false);
+}
+
 #define SAMPLE_FLT_ISNONE FLT_MAX
 /* Bad bad, 2.5 will do better? ... no it won't! */
 static float _sample_col[4] = {SAMPLE_FLT_ISNONE};
@@ -1183,6 +1188,9 @@ static void node_shader_set_butfunc(bNodeType *ntype)
     case SH_NODE_CURVE_RGB:
       ntype->draw_buttons = node_buts_curvecol;
       break;
+    case SH_NODE_CURVE_FLOAT:
+      ntype->draw_buttons = node_buts_curvefloat;
+      break;
     case SH_NODE_MAPPING:
       ntype->draw_buttons = node_shader_buts_mapping;
       break;
diff --git a/source/blender/gpu/CMakeLists.txt b/source/blender/gpu/CMakeLists.txt
index df370c7079b..7a072900473 100644
--- a/source/blender/gpu/CMakeLists.txt
+++ b/source/blender/gpu/CMakeLists.txt
@@ -296,6 +296,7 @@ data_to_c_simple(shaders/material/gpu_shader_material_diffuse.glsl SRC)
 data_to_c_simple(shaders/material/gpu_shader_material_displacement.glsl SRC)
 data_to_c_simple(shaders/material/gpu_shader_material_eevee_specular.glsl SRC)
 data_to_c_simple(shaders/material/gpu_shader_material_emission.glsl SRC)
+data_to_c_simple(shaders/material/gpu_shader_material_float_curve.glsl SRC)
 data_to_c_simple(shaders/material/gpu_shader_material_fractal_noise.glsl SRC)
 data_to_c_simple(shaders/material/gpu_shader_material_fresnel.glsl SRC)
 data_to_c_simple(shaders/material/gpu_shader_material_gamma.glsl SRC)
diff --git a/source/blender/gpu/intern/gpu_material_library.c b/source/blender/gpu/intern/gpu_material_library.c
index 73a80c62bdc..74e0270c42a 100644
--- a/source/blender/gpu/intern/gpu_material_library.c
+++ b/source/blender/gpu/intern/gpu_material_library.c
@@ -62,6 +62,7 @@ extern char datatoc_gpu_shader_material_diffuse_glsl[];
 extern char datatoc_gpu_shader_material_displacement_glsl[];
 extern char datatoc_gpu_shader_material_eevee_specular_glsl[];
 extern char datatoc_gpu_shader_material_emission_glsl[];
+extern char datatoc_gpu_shader_material_float_curve_glsl[];
 extern char datatoc_gpu_shader_material_fractal_noise_glsl[];
 extern char datatoc_gpu_shader_material_fresnel_glsl[];
 extern char datatoc_gpu_shader_material_gamma_glsl[];
@@ -262,6 +263,11 @@ static GPUMaterialLibrary gpu_shader_material_emission_library = {
     .dependencies = {NULL},
 };
 
+static GPUMaterialLibrary gpu_shader_material_float_curve_library = {
+    .code = datatoc_gpu_shader_material_float_curve_glsl,
+    .dependencies = {NULL},
+};
+
 static GPUMaterialLibrary gpu_shader_material_fresnel_library = {
     .code = datatoc_gpu_shader_material_fresnel_glsl,
     .dependencies = {NULL},
@@ -591,6 +597,7 @@ static GPUMaterialLibrary *gpu_material_libraries[] = {
     &gpu_shader_material_color_util_library,
     &gpu_shader_material_hash_library,
     &gpu_shader_material_noise_library,
+    &gpu_shader_material_float_curve_library,
     &gpu_shader_material_fractal_noise_library,
     &gpu_shader_material_add_shader_library,
     &gpu_shader_material_ambient_occlusion_library,
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
new file mode 100644
index 00000000000..514409f7fdf
--- /dev/null
+++ b/source/blender/gpu/shaders/material/gpu_shader_material_float_curve.glsl
@@ -0,0 +1,33 @@
+/* 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/makesrna/RNA_access.h b/source/blender/makesrna/RNA_access.h
index ce53e3390e1..188f933dba5 100644
--- a/source/blender/makesrna/RNA_access.h
+++ b/source/blender/makesrna/RNA_access.h
@@ -558,6 +558,7 @@ extern StructRNA RNA_ShaderFxWave;
 extern StructRNA RNA_ShaderNode;
 extern StructRNA RNA_ShaderNodeCameraData;
 extern StructRNA RNA_ShaderNodeCombineRGB;
+extern StructRNA RNA_ShaderNodeFloatCurve;
 extern StructRNA RNA_ShaderNodeGamma;
 extern StructRNA RNA_ShaderNodeHueSaturation;
 extern StructRNA RNA_ShaderNodeInvert;
diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c
index 8fb55d37375..894a8bad6da 100644
--- a/source/blender/makesrna/intern/rna_nodetree.c
+++ b/source/blender/makesrna/intern/rna_nodetree.c
@@ -4900,6 +4900,17 @@ static void def_vector_curve(StructRNA *srna)
   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
 }
 
+static void def_float_curve(StructRNA *srna)
+{
+  PropertyRNA *prop;
+
+  prop = RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
+  RNA_def_property_pointer_sdna(prop, NULL, "storage");
+  RNA_def_property_struct_type(prop, "CurveMapping");
+  RNA_def_property_ui_text(prop, "Mapping", "");
+  RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
+}
+
 static void def_time(StructRNA *srna)
 {
   PropertyRNA *prop;
diff --git a/source/blender/nodes/NOD_shader.h b/source/blender/nodes/NOD_shader.h
index 2911e0fbea6..76c174201e8 100644
--- a/source/blender/nodes/NOD_shader.h
+++ b/source/blender/nodes/NOD_shader.h
@@ -49,6 +49,7 @@ void register_node_type_sh_normal(void);
 void register_node_type_sh_gamma(void);
 void register_node_type_sh_brightcontrast(void);
 void register_node_type_sh_mapping(void);
+void register_node_type_sh_curve_float(void);
 void register_node_type_sh_curve_vec(void);
 void register_node_type_sh_curve_rgb(void);
 void register_node_type_sh_map_range(void);
diff --git a/source/blender/nodes/NOD_static_types.h b/source/blender/nodes/NOD_static_types.h
index 3ee3faf6122..7972609aa27 100644
--- a/source/blender/nodes/NOD_static_types.h
+++ b/source/blender/nodes/NOD_static_types.h
@@ -132,6 +132,7 @@ DefNode(ShaderNode,     SH_NODE_VECTOR_DISPLACEMENT,def_sh_vector_displacement,"
 DefNode(ShaderNode,     SH_NODE_TEX_IES,            def_sh_tex_ies,         "TEX_IES",            TexIES,           "IES Texture",       ""       )
 DefNode(ShaderNode,     SH_NODE_TEX_WHITE_NOISE,    def_sh_tex_white_noise, "TEX_WHITE_NOISE",    TexWhiteNoise,    "White Noise",       ""       )
 DefNode(ShaderNode,     SH_NODE_OUTPUT_AOV,         def_sh_output_aov,      "OUTPUT_AOV",         OutputAOV,        "AOV Output",        ""       )
+DefNode(ShaderNode,     SH_NODE_CURVE_FLOAT,        def_float_curve,        "CURVE_FLOAT",        FloatCurve,       "Float Curve",       ""       )
 
 DefNode(CompositorNode, CMP_NODE_VIEWER,         def_cmp_viewer,         "VIEWER",         Viewer,           "Viewer",            ""              )
 DefNode(CompositorNode, CMP_NODE_RGB,            0,                      "RGB",            RGB,              "RGB",               ""              )
diff --git a/source/blender/nodes/shader/nodes/node_shader_curves.cc b/source/blender/nodes/shader/nodes/node_shader_curves.cc
index 887cc84bb76..253bb3cc4b6 100644
--- a/source/blender/nodes/shader/nodes/node_shader_curves.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_curves.cc
@@ -343,3 +343,142 @@ void register_node_type_sh_curve_rgb(void)
 
   nodeRegisterType(&ntype);
 }
+
+/* **************** CURVE FLOAT  ******************** */
+
+namespace blender::nodes {
+
+static void sh_node_curve_float_declare(NodeDeclarationBuilder &b)
+{
+  b.add_input<decl::Float>("Factor").min(0.0f).max(1.0f).default_value(1.0f).subtype(PROP_FACTOR);
+  b.add_input<decl::Float>("Value").default_value(1.0f);
+  b.add_output<decl::Float>("Value");
+};
+
+}  // namespace blender::nodes
+
+static void node_shader_exec_curve_float(void *UNUSED(data),
+                                         int UNUSED(thread),
+                                         bNode *node,
+                                         bNodeExecData *UNUSED(execdata),
+                                         bNodeStack **in,
+                                         bNodeStack **out)
+{
+  float value;
+  float fac;
+
+  nodestack_get_vec(&fac, SOCK_FLOAT, in[0]);
+  nodestack_get_vec(&value, SOCK_FLOAT, in[1]);
+  out[0]->vec[0] = BKE_curvemapping_evaluateF((CurveMapping *)node->storage, 0, value);
+  if (fac != 1.0f) {
+    out[0]->vec[0] = (1.0f - fac) * value + fac * out[0]->vec[0];
+  }
+}
+
+static void node_shader_init_curve_float(bNodeTree *ntree, bNode *node)
+{
+  node->storage = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+}
+
+static int gpu_shader_curve_float(GPUMaterial *mat,
+                                  bNode *node,
+                                  bNodeExecData *UNUSED(execdata),
+                                  GPUNodeStack *in,
+                                  GPUNodeStack *out)
+{
+  float *array, layer;
+  int size;
+
+  CurveMapping *cumap = (CurveMapping *)node->storage;
+
+  BKE_curvemapping_table_F(cumap, &array, &size);
+  GPUNodeLink *tex = GPU_color_band(mat, size, array, &layer);
+
+  float ext_xyz[4];
+  float range_x;
+
+  const CurveMap *cm = &cumap->cm[0];
+  ext_xyz[0] = cm->mintable;
+  ext_xyz[2] = cm->maxtable;
+  range_x = 1.0f / max_ff(1e-8f, cm->maxtable - cm->mintable);
+  /* Compute extrapolation gradients. */
+  if ((cumap->flag & CUMA_EXTEND_EXTRAPOLATE) != 0) {
+    ext_xyz[1] = (cm->ext_in[0] != 0.0f) ? (cm->ext_in[1] / (cm->ext_in[0] * range_x)) : 1e8f;
+    ext_xyz[3] = (cm->ext_out[0] != 0.0f) ? (cm->ext_out[1] / (cm->ext_out[0] * range_x)) : 1e8f;
+  }
+  else {
+    ext_xyz[1] = 0.0f;
+    ext_xyz[3] = 0.0f;
+  }
+  return GPU_stack_link(mat,
+                        node,
+                        "curve_float",
+                        in,
+                        out,
+                        tex,
+                        GPU_constant(&layer),
+                        GPU_uniform(&range_x),
+                        GPU_uniform(ext_xyz));
+}
+
+class CurveFloatFunction : public blender::fn::MultiFunction {
+ private:
+  const CurveMapping &cumap_;
+
+ public:
+  CurveFloatFunction(const CurveMapping &cumap) : cumap_(cumap)
+  {
+    static blender::fn::MFSignature signature = create_signature();
+    this->set_signature(&signature);
+  }
+
+  static blender::fn::MFSignature create_signature()
+  {
+    blender::fn::MFSignatureBuilder signature{"Curve Float"};
+    signature.single_input<float>("Factor");
+    signature.single_input<float>("Value");
+    signature.single_output<float>("Value");
+    return signature.build();
+  }
+
+  void call(blender::IndexMask mask,
+            blender::fn::MFParams params,
+            blender::fn::MFContext UNUSED(context)) const override
+  {
+    const blender::VArray<float> &fac = params.readonly_single_input<float>(0, "Factor");
+    const blender::VArray<float> &val_in = params.readonly_single_input<float>(1, "Value");
+    blender::MutableSpan<float> val_out = params.uninitialized_single_output<float>(2, "Value");
+
+    for (int64_t i : mask) {
+      val_out[i] = BKE_curvemapping_evaluateF(&cumap_, 0, val_in[i]);
+      if (fac[i] != 1.0f) {
+        val_out[i] = (1.0f - fac[i]) * val_in[i] + fac[i] * val_out[i];
+      }
+    }
+  }
+};
+
+static void sh_node_curve_float_build_multi_function(
+    blender::nodes::NodeMultiFunctionBuilder &builder)
+{
+  bNode &bnode = builder.node();
+  CurveMapping *cumap = (CurveMapping *)bnode.storage;
+  BKE_curvemapping_init(cumap);
+  builder.construct_and_set_matching_fn<CurveFloatFunction>(*cumap);
+}
+
+void register_node_type_sh_curve_float(void)
+{
+  static bNodeType ntype;
+
+  sh_fn_node_type_base(&ntype, SH_NODE_CURVE_FLOAT, "Float Curve", NODE_CLASS_CONVERTER, 0);
+  ntype.declare = blender::nodes::sh_node_curve_float_declare;
+  node_type_init(&ntype, node_shader_init_curve_float);
+  node_type_size_preset(&ntype, NODE_SIZE_LARGE);
+  node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves);
+  node_type_exec(&ntype, node_initexec_curves, nullptr, node_shader_exec_curve_float);
+  node_type_gpu(&ntype, gpu_shader_curve_float);
+  ntype.build_multi_function = sh_node_curve_float_build_multi_function;
+
+  nodeRegisterType(&ntype);
+}