Cleanup: use BKE_ prefix for BKE_colortools.h

14 files changed, 289 insertions, 275 deletions

diff --git a/source/blender/blenkernel/BKE_colortools.h b/source/blender/blenkernel/BKE_colortools.h
index a6eb12c3708..643073b3470 100644
--- a/source/blender/blenkernel/BKE_colortools.h
+++ b/source/blender/blenkernel/BKE_colortools.h
@@ -34,17 +34,19 @@ struct ImBuf;
 struct Scopes;
 struct rctf;
 
-void curvemapping_set_defaults(
+void BKE_curvemapping_set_defaults(
     struct CurveMapping *cumap, int tot, float minx, float miny, float maxx, float maxy);
-struct CurveMapping *curvemapping_add(int tot, float minx, float miny, float maxx, float maxy);
-void curvemapping_free_data(struct CurveMapping *cumap);
-void curvemapping_free(struct CurveMapping *cumap);
-void curvemapping_copy_data(struct CurveMapping *target, const struct CurveMapping *cumap);
-struct CurveMapping *curvemapping_copy(const struct CurveMapping *cumap);
-void curvemapping_set_black_white_ex(const float black[3], const float white[3], float r_bwmul[3]);
-void curvemapping_set_black_white(struct CurveMapping *cumap,
-                                  const float black[3],
-                                  const float white[3]);
+struct CurveMapping *BKE_curvemapping_add(int tot, float minx, float miny, float maxx, float maxy);
+void BKE_curvemapping_free_data(struct CurveMapping *cumap);
+void BKE_curvemapping_free(struct CurveMapping *cumap);
+void BKE_curvemapping_copy_data(struct CurveMapping *target, const struct CurveMapping *cumap);
+struct CurveMapping *BKE_curvemapping_copy(const struct CurveMapping *cumap);
+void BKE_curvemapping_set_black_white_ex(const float black[3],
+                                         const float white[3],
+                                         float r_bwmul[3]);
+void BKE_curvemapping_set_black_white(struct CurveMapping *cumap,
+                                      const float black[3],
+                                      const float white[3]);
 
 enum {
   CURVEMAP_SLOPE_NEGATIVE = 0,
@@ -52,56 +54,56 @@ enum {
   CURVEMAP_SLOPE_POS_NEG = 2,
 };
 
-void curvemap_reset(struct CurveMap *cuma, const struct rctf *clipr, int preset, int slope);
-void curvemap_remove(struct CurveMap *cuma, const short flag);
-bool curvemap_remove_point(struct CurveMap *cuma, struct CurveMapPoint *cmp);
-struct CurveMapPoint *curvemap_insert(struct CurveMap *cuma, float x, float y);
-void curvemap_handle_set(struct CurveMap *cuma, int type);
+void BKE_curvemap_reset(struct CurveMap *cuma, const struct rctf *clipr, int preset, int slope);
+void BKE_curvemap_remove(struct CurveMap *cuma, const short flag);
+bool BKE_curvemap_remove_point(struct CurveMap *cuma, struct CurveMapPoint *cmp);
+struct CurveMapPoint *BKE_curvemap_insert(struct CurveMap *cuma, float x, float y);
+void BKE_curvemap_handle_set(struct CurveMap *cuma, int type);
 
-void curvemapping_changed(struct CurveMapping *cumap, const bool rem_doubles);
-void curvemapping_changed_all(struct CurveMapping *cumap);
+void BKE_curvemapping_changed(struct CurveMapping *cumap, const bool rem_doubles);
+void BKE_curvemapping_changed_all(struct CurveMapping *cumap);
 
 /* call before _all_ evaluation functions */
-void curvemapping_initialize(struct CurveMapping *cumap);
+void BKE_curvemapping_initialize(struct CurveMapping *cumap);
 
 /* keep these (const CurveMap) - to help with thread safety */
 /* single curve, no table check */
-float curvemap_evaluateF(const struct CurveMap *cuma, float value);
+float BKE_curvemap_evaluateF(const struct CurveMap *cuma, float value);
 /* single curve, with table check */
-float curvemapping_evaluateF(const struct CurveMapping *cumap, int cur, float value);
-void curvemapping_evaluate3F(const struct CurveMapping *cumap,
-                             float vecout[3],
-                             const float vecin[3]);
-void curvemapping_evaluateRGBF(const struct CurveMapping *cumap,
-                               float vecout[3],
-                               const float vecin[3]);
-void curvemapping_evaluate_premulRGB(const struct CurveMapping *cumap,
-                                     unsigned char vecout_byte[3],
-                                     const unsigned char vecin_byte[3]);
-void curvemapping_evaluate_premulRGBF_ex(const struct CurveMapping *cumap,
-                                         float vecout[3],
-                                         const float vecin[3],
-                                         const float black[3],
-                                         const float bwmul[3]);
-void curvemapping_evaluate_premulRGBF(const struct CurveMapping *cumap,
-                                      float vecout[3],
-                                      const float vecin[3]);
-int curvemapping_RGBA_does_something(const struct CurveMapping *cumap);
-void curvemapping_table_RGBA(const struct CurveMapping *cumap, float **array, int *size);
+float BKE_curvemapping_evaluateF(const struct CurveMapping *cumap, int cur, float value);
+void BKE_curvemapping_evaluate3F(const struct CurveMapping *cumap,
+                                 float vecout[3],
+                                 const float vecin[3]);
+void BKE_curvemapping_evaluateRGBF(const struct CurveMapping *cumap,
+                                   float vecout[3],
+                                   const float vecin[3]);
+void BKE_curvemapping_evaluate_premulRGB(const struct CurveMapping *cumap,
+                                         unsigned char vecout_byte[3],
+                                         const unsigned char vecin_byte[3]);
+void BKE_curvemapping_evaluate_premulRGBF_ex(const struct CurveMapping *cumap,
+                                             float vecout[3],
+                                             const float vecin[3],
+                                             const float black[3],
+                                             const float bwmul[3]);
+void BKE_curvemapping_evaluate_premulRGBF(const struct CurveMapping *cumap,
+                                          float vecout[3],
+                                          const float vecin[3]);
+int BKE_curvemapping_RGBA_does_something(const struct CurveMapping *cumap);
+void BKE_curvemapping_table_RGBA(const struct CurveMapping *cumap, float **array, int *size);
 
 /* non-const, these modify the curve */
-void curvemapping_premultiply(struct CurveMapping *cumap, int restore);
+void BKE_curvemapping_premultiply(struct CurveMapping *cumap, int restore);
 
 void BKE_histogram_update_sample_line(struct Histogram *hist,
                                       struct ImBuf *ibuf,
                                       const struct ColorManagedViewSettings *view_settings,
                                       const struct ColorManagedDisplaySettings *display_settings);
-void scopes_update(struct Scopes *scopes,
-                   struct ImBuf *ibuf,
-                   const struct ColorManagedViewSettings *view_settings,
-                   const struct ColorManagedDisplaySettings *display_settings);
-void scopes_free(struct Scopes *scopes);
-void scopes_new(struct Scopes *scopes);
+void BKE_scopes_update(struct Scopes *scopes,
+                       struct ImBuf *ibuf,
+                       const struct ColorManagedViewSettings *view_settings,
+                       const struct ColorManagedDisplaySettings *display_settings);
+void BKE_scopes_free(struct Scopes *scopes);
+void BKE_scopes_new(struct Scopes *scopes);
 
 void BKE_color_managed_display_settings_init(struct ColorManagedDisplaySettings *settings);
 void BKE_color_managed_display_settings_copy(struct ColorManagedDisplaySettings *new_settings,
diff --git a/source/blender/blenkernel/intern/brush.c b/source/blender/blenkernel/intern/brush.c
index 709f74808a3..b2d3ccfebc3 100644
--- a/source/blender/blenkernel/intern/brush.c
+++ b/source/blender/blenkernel/intern/brush.c
@@ -184,9 +184,9 @@ void BKE_brush_init_gpencil_settings(Brush *brush)
   brush->gpencil_settings->flag |= GP_BRUSH_ENABLE_CURSOR;
 
   /* curves */
-  brush->gpencil_settings->curve_sensitivity = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
-  brush->gpencil_settings->curve_strength = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
-  brush->gpencil_settings->curve_jitter = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+  brush->gpencil_settings->curve_sensitivity = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+  brush->gpencil_settings->curve_strength = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+  brush->gpencil_settings->curve_jitter = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
 }
 
 /* add a new gp-brush */
@@ -386,8 +386,8 @@ void BKE_brush_gpencil_presets(bContext *C)
 
   /* Curve */
   custom_curve = brush->gpencil_settings->curve_sensitivity;
-  curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
-  curvemapping_initialize(custom_curve);
+  BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
+  BKE_curvemapping_initialize(custom_curve);
   brush_gpencil_curvemap_reset(custom_curve->cm, 3, GPCURVE_PRESET_INK);
 
   /* Ink Noise brush */
@@ -423,8 +423,8 @@ void BKE_brush_gpencil_presets(bContext *C)
 
   /* Curve */
   custom_curve = brush->gpencil_settings->curve_sensitivity;
-  curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
-  curvemapping_initialize(custom_curve);
+  BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
+  BKE_curvemapping_initialize(custom_curve);
   brush_gpencil_curvemap_reset(custom_curve->cm, 3, GPCURVE_PRESET_INKNOISE);
 
   brush->gpencil_settings->gradient_f = 1.0f;
@@ -495,8 +495,8 @@ void BKE_brush_gpencil_presets(bContext *C)
   brush->smooth_stroke_factor = SMOOTH_STROKE_FACTOR;
   /* Curve */
   custom_curve = brush->gpencil_settings->curve_sensitivity;
-  curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
-  curvemapping_initialize(custom_curve);
+  BKE_curvemapping_set_defaults(custom_curve, 0, 0.0f, 0.0f, 1.0f, 1.0f);
+  BKE_curvemapping_initialize(custom_curve);
   brush_gpencil_curvemap_reset(custom_curve->cm, 4, GPCURVE_PRESET_MARKER);
 
   brush->gpencil_settings->gradient_f = 1.0f;
@@ -649,14 +649,14 @@ void BKE_brush_copy_data(Main *UNUSED(bmain),
     brush_dst->preview = NULL;
   }
 
-  brush_dst->curve = curvemapping_copy(brush_src->curve);
+  brush_dst->curve = BKE_curvemapping_copy(brush_src->curve);
   if (brush_src->gpencil_settings != NULL) {
     brush_dst->gpencil_settings = MEM_dupallocN(brush_src->gpencil_settings);
-    brush_dst->gpencil_settings->curve_sensitivity = curvemapping_copy(
+    brush_dst->gpencil_settings->curve_sensitivity = BKE_curvemapping_copy(
         brush_src->gpencil_settings->curve_sensitivity);
-    brush_dst->gpencil_settings->curve_strength = curvemapping_copy(
+    brush_dst->gpencil_settings->curve_strength = BKE_curvemapping_copy(
         brush_src->gpencil_settings->curve_strength);
-    brush_dst->gpencil_settings->curve_jitter = curvemapping_copy(
+    brush_dst->gpencil_settings->curve_jitter = BKE_curvemapping_copy(
         brush_src->gpencil_settings->curve_jitter);
   }
 
@@ -677,12 +677,12 @@ void BKE_brush_free(Brush *brush)
   if (brush->icon_imbuf) {
     IMB_freeImBuf(brush->icon_imbuf);
   }
-  curvemapping_free(brush->curve);
+  BKE_curvemapping_free(brush->curve);
 
   if (brush->gpencil_settings != NULL) {
-    curvemapping_free(brush->gpencil_settings->curve_sensitivity);
-    curvemapping_free(brush->gpencil_settings->curve_strength);
-    curvemapping_free(brush->gpencil_settings->curve_jitter);
+    BKE_curvemapping_free(brush->gpencil_settings->curve_sensitivity);
+    BKE_curvemapping_free(brush->gpencil_settings->curve_strength);
+    BKE_curvemapping_free(brush->gpencil_settings->curve_jitter);
     MEM_SAFE_FREE(brush->gpencil_settings);
   }
 
@@ -917,15 +917,15 @@ void BKE_brush_curve_preset(Brush *b, eCurveMappingPreset preset)
   CurveMap *cm = NULL;
 
   if (!b->curve) {
-    b->curve = curvemapping_add(1, 0, 0, 1, 1);
+    b->curve = BKE_curvemapping_add(1, 0, 0, 1, 1);
   }
 
   cm = b->curve->cm;
   cm->flag &= ~CUMA_EXTEND_EXTRAPOLATE;
 
   b->curve->preset = preset;
-  curvemap_reset(cm, &b->curve->clipr, b->curve->preset, CURVEMAP_SLOPE_NEGATIVE);
-  curvemapping_changed(b->curve, false);
+  BKE_curvemap_reset(cm, &b->curve->clipr, b->curve->preset, CURVEMAP_SLOPE_NEGATIVE);
+  BKE_curvemapping_changed(b->curve, false);
 }
 
 /* Generic texture sampler for 3D painting systems. point has to be either in
@@ -1412,7 +1412,7 @@ float BKE_brush_curve_strength(const Brush *br, float p, const float len)
 
   switch (br->curve_preset) {
     case BRUSH_CURVE_CUSTOM:
-      strength = curvemapping_evaluateF(br->curve, 0, 1.0f - p);
+      strength = BKE_curvemapping_evaluateF(br->curve, 0, 1.0f - p);
       break;
     case BRUSH_CURVE_SHARP:
       strength = p * p;
@@ -1498,7 +1498,7 @@ struct ImBuf *BKE_brush_gen_radial_control_imbuf(Brush *br, bool secondary)
   int half = side / 2;
   int i, j;
 
-  curvemapping_initialize(br->curve);
+  BKE_curvemapping_initialize(br->curve);
   texcache = BKE_brush_gen_texture_cache(br, half, secondary);
   im->rect_float = MEM_callocN(sizeof(float) * side * side, "radial control rect");
   im->x = im->y = side;
diff --git a/source/blender/blenkernel/intern/colortools.c b/source/blender/blenkernel/intern/colortools.c
index aa5f74c6297..b129bf14bb8 100644
--- a/source/blender/blenkernel/intern/colortools.c
+++ b/source/blender/blenkernel/intern/colortools.c
@@ -48,7 +48,7 @@
 
 /* ***************** operations on full struct ************* */
 
-void curvemapping_set_defaults(
+void BKE_curvemapping_set_defaults(
     CurveMapping *cumap, int tot, float minx, float miny, float maxx, float maxy)
 {
   int a;
@@ -84,18 +84,18 @@ void curvemapping_set_defaults(
   cumap->changed_timestamp = 0;
 }
 
-CurveMapping *curvemapping_add(int tot, float minx, float miny, float maxx, float maxy)
+CurveMapping *BKE_curvemapping_add(int tot, float minx, float miny, float maxx, float maxy)
 {
   CurveMapping *cumap;
 
   cumap = MEM_callocN(sizeof(CurveMapping), "new curvemap");
 
-  curvemapping_set_defaults(cumap, tot, minx, miny, maxx, maxy);
+  BKE_curvemapping_set_defaults(cumap, tot, minx, miny, maxx, maxy);
 
   return cumap;
 }
 
-void curvemapping_free_data(CurveMapping *cumap)
+void BKE_curvemapping_free_data(CurveMapping *cumap)
 {
   int a;
 
@@ -115,15 +115,15 @@ void curvemapping_free_data(CurveMapping *cumap)
   }
 }
 
-void curvemapping_free(CurveMapping *cumap)
+void BKE_curvemapping_free(CurveMapping *cumap)
 {
   if (cumap) {
-    curvemapping_free_data(cumap);
+    BKE_curvemapping_free_data(cumap);
     MEM_freeN(cumap);
   }
 }
 
-void curvemapping_copy_data(CurveMapping *target, const CurveMapping *cumap)
+void BKE_curvemapping_copy_data(CurveMapping *target, const CurveMapping *cumap)
 {
   int a;
 
@@ -142,17 +142,19 @@ void curvemapping_copy_data(CurveMapping *target, const CurveMapping *cumap)
   }
 }
 
-CurveMapping *curvemapping_copy(const CurveMapping *cumap)
+CurveMapping *BKE_curvemapping_copy(const CurveMapping *cumap)
 {
   if (cumap) {
     CurveMapping *cumapn = MEM_dupallocN(cumap);
-    curvemapping_copy_data(cumapn, cumap);
+    BKE_curvemapping_copy_data(cumapn, cumap);
     return cumapn;
   }
   return NULL;
 }
 
-void curvemapping_set_black_white_ex(const float black[3], const float white[3], float r_bwmul[3])
+void BKE_curvemapping_set_black_white_ex(const float black[3],
+                                         const float white[3],
+                                         float r_bwmul[3])
 {
   int a;
 
@@ -162,7 +164,9 @@ void curvemapping_set_black_white_ex(const float black[3], const float white[3],
   }
 }
 
-void curvemapping_set_black_white(CurveMapping *cumap, const float black[3], const float white[3])
+void BKE_curvemapping_set_black_white(CurveMapping *cumap,
+                                      const float black[3],
+                                      const float white[3])
 {
   if (white) {
     copy_v3_v3(cumap->white, white);
@@ -171,15 +175,15 @@ void curvemapping_set_black_white(CurveMapping *cumap, const float black[3], con
     copy_v3_v3(cumap->black, black);
   }
 
-  curvemapping_set_black_white_ex(cumap->black, cumap->white, cumap->bwmul);
+  BKE_curvemapping_set_black_white_ex(cumap->black, cumap->white, cumap->bwmul);
   cumap->changed_timestamp++;
 }
 
 /* ***************** operations on single curve ************* */
-/* ********** NOTE: requires curvemapping_changed() call after ******** */
+/* ********** NOTE: requires BKE_curvemapping_changed() call after ******** */
 
 /* remove specified point */
-bool curvemap_remove_point(CurveMap *cuma, CurveMapPoint *point)
+bool BKE_curvemap_remove_point(CurveMap *cuma, CurveMapPoint *point)
 {
   CurveMapPoint *cmp;
   int a, b, removed = 0;
@@ -209,7 +213,7 @@ bool curvemap_remove_point(CurveMap *cuma, CurveMapPoint *point)
 }
 
 /* removes with flag set */
-void curvemap_remove(CurveMap *cuma, const short flag)
+void BKE_curvemap_remove(CurveMap *cuma, const short flag)
 {
   CurveMapPoint *cmp = MEM_mallocN((cuma->totpoint) * sizeof(CurveMapPoint), "curve points");
   int a, b, removed = 0;
@@ -232,7 +236,7 @@ void curvemap_remove(CurveMap *cuma, const short flag)
   cuma->totpoint -= removed;
 }
 
-CurveMapPoint *curvemap_insert(CurveMap *cuma, float x, float y)
+CurveMapPoint *BKE_curvemap_insert(CurveMap *cuma, float x, float y)
 {
   CurveMapPoint *cmp = MEM_callocN((cuma->totpoint + 1) * sizeof(CurveMapPoint), "curve points");
   CurveMapPoint *newcmp = NULL;
@@ -266,7 +270,7 @@ CurveMapPoint *curvemap_insert(CurveMap *cuma, float x, float y)
   return newcmp;
 }
 
-void curvemap_reset(CurveMap *cuma, const rctf *clipr, int preset, int slope)
+void BKE_curvemap_reset(CurveMap *cuma, const rctf *clipr, int preset, int slope)
 {
   if (cuma->curve) {
     MEM_freeN(cuma->curve);
@@ -439,7 +443,7 @@ void curvemap_reset(CurveMap *cuma, const rctf *clipr, int preset, int slope)
 /**
  * \param type: eBezTriple_Handle
  */
-void curvemap_handle_set(CurveMap *cuma, int type)
+void BKE_curvemap_handle_set(CurveMap *cuma, int type)
 {
   int a;
 
@@ -800,7 +804,7 @@ static void curvemap_make_table(CurveMap *cuma, const rctf *clipr)
 
 /* call when you do images etc, needs restore too. also verifies tables */
 /* it uses a flag to prevent premul or free to happen twice */
-void curvemapping_premultiply(CurveMapping *cumap, int restore)
+void BKE_curvemapping_premultiply(CurveMapping *cumap, int restore)
 {
   int a;
 
@@ -841,7 +845,7 @@ void curvemapping_premultiply(CurveMapping *cumap, int restore)
       for (a = 0; a < 3; a++) {
         int b;
         for (b = 0; b <= CM_TABLE; b++) {
-          cumap->cm[a].table[b].y = curvemap_evaluateF(cumap->cm + 3, cumap->cm[a].table[b].y);
+          cumap->cm[a].table[b].y = BKE_curvemap_evaluateF(cumap->cm + 3, cumap->cm[a].table[b].y);
         }
 
         copy_v2_v2(cumap->cm[a].premul_ext_in, cumap->cm[a].ext_in);
@@ -871,7 +875,7 @@ static int sort_curvepoints(const void *a1, const void *a2)
 /* ************************ more CurveMapping calls *************** */
 
 /* note; only does current curvemap! */
-void curvemapping_changed(CurveMapping *cumap, const bool rem_doubles)
+void BKE_curvemapping_changed(CurveMapping *cumap, const bool rem_doubles)
 {
   CurveMap *cuma = cumap->cm + cumap->cur;
   CurveMapPoint *cmp = cuma->curve;
@@ -942,20 +946,20 @@ void curvemapping_changed(CurveMapping *cumap, const bool rem_doubles)
       }
     }
     if (a != cuma->totpoint - 1) {
-      curvemap_remove(cuma, 2);
+      BKE_curvemap_remove(cuma, 2);
     }
   }
   curvemap_make_table(cuma, clipr);
 }
 
-void curvemapping_changed_all(CurveMapping *cumap)
+void BKE_curvemapping_changed_all(CurveMapping *cumap)
 {
   int a, cur = cumap->cur;
 
   for (a = 0; a < CM_TOT; a++) {
     if (cumap->cm[a].curve) {
       cumap->cur = a;
-      curvemapping_changed(cumap, false);
+      BKE_curvemapping_changed(cumap, false);
     }
   }
 
@@ -963,7 +967,7 @@ void curvemapping_changed_all(CurveMapping *cumap)
 }
 
 /* table should be verified */
-float curvemap_evaluateF(const CurveMap *cuma, float value)
+float BKE_curvemap_evaluateF(const CurveMap *cuma, float value)
 {
   float fi;
   int i;
@@ -990,10 +994,10 @@ float curvemap_evaluateF(const CurveMap *cuma, float value)
 }
 
 /* works with curve 'cur' */
-float curvemapping_evaluateF(const CurveMapping *cumap, int cur, float value)
+float BKE_curvemapping_evaluateF(const CurveMapping *cumap, int cur, float value)
 {
   const CurveMap *cuma = cumap->cm + cur;
-  float val = curvemap_evaluateF(cuma, value);
+  float val = BKE_curvemap_evaluateF(cuma, value);
 
   /* account for clipping */
   if (cumap->flag & CUMA_DO_CLIP) {
@@ -1009,19 +1013,24 @@ float curvemapping_evaluateF(const CurveMapping *cumap, int cur, float value)
 }
 
 /* vector case */
-void curvemapping_evaluate3F(const CurveMapping *cumap, float vecout[3], const float vecin[3])
+void BKE_curvemapping_evaluate3F(const CurveMapping *cumap, float vecout[3], const float vecin[3])
 {
-  vecout[0] = curvemap_evaluateF(&cumap->cm[0], vecin[0]);
-  vecout[1] = curvemap_evaluateF(&cumap->cm[1], vecin[1]);
-  vecout[2] = curvemap_evaluateF(&cumap->cm[2], vecin[2]);
+  vecout[0] = BKE_curvemap_evaluateF(&cumap->cm[0], vecin[0]);
+  vecout[1] = BKE_curvemap_evaluateF(&cumap->cm[1], vecin[1]);
+  vecout[2] = BKE_curvemap_evaluateF(&cumap->cm[2], vecin[2]);
 }
 
 /* RGB case, no black/white points, no premult */
-void curvemapping_evaluateRGBF(const CurveMapping *cumap, float vecout[3], const float vecin[3])
+void BKE_curvemapping_evaluateRGBF(const CurveMapping *cumap,
+                                   float vecout[3],
+                                   const float vecin[3])
 {
-  vecout[0] = curvemap_evaluateF(&cumap->cm[0], curvemap_evaluateF(&cumap->cm[3], vecin[0]));
-  vecout[1] = curvemap_evaluateF(&cumap->cm[1], curvemap_evaluateF(&cumap->cm[3], vecin[1]));
-  vecout[2] = curvemap_evaluateF(&cumap->cm[2], curvemap_evaluateF(&cumap->cm[3], vecin[2]));
+  vecout[0] = BKE_curvemap_evaluateF(&cumap->cm[0],
+                                     BKE_curvemap_evaluateF(&cumap->cm[3], vecin[0]));
+  vecout[1] = BKE_curvemap_evaluateF(&cumap->cm[1],
+                                     BKE_curvemap_evaluateF(&cumap->cm[3], vecin[1]));
+  vecout[2] = BKE_curvemap_evaluateF(&cumap->cm[2],
+                                     BKE_curvemap_evaluateF(&cumap->cm[3], vecin[2]));
 }
 
 static void curvemapping_evaluateRGBF_filmlike(const CurveMapping *cumap,
@@ -1033,8 +1042,8 @@ static void curvemapping_evaluateRGBF_filmlike(const CurveMapping *cumap,
   const float v1in = vecin[channel_offset[1]];
   const float v2in = vecin[channel_offset[2]];
 
-  const float v0 = curvemap_evaluateF(&cumap->cm[channel_offset[0]], v0in);
-  const float v2 = curvemap_evaluateF(&cumap->cm[channel_offset[2]], v2in);
+  const float v0 = BKE_curvemap_evaluateF(&cumap->cm[channel_offset[0]], v0in);
+  const float v2 = BKE_curvemap_evaluateF(&cumap->cm[channel_offset[2]], v2in);
   const float v1 = v2 + ((v0 - v2) * (v1in - v2in) / (v0in - v2in));
 
   vecout[channel_offset[0]] = v0;
@@ -1042,20 +1051,20 @@ static void curvemapping_evaluateRGBF_filmlike(const CurveMapping *cumap,
   vecout[channel_offset[2]] = v2;
 }
 
-/** same as #curvemapping_evaluate_premulRGBF
+/** same as #BKE_curvemapping_evaluate_premulRGBF
  * but black/bwmul are passed as args for the compositor
  * where they can change per pixel.
  *
- * Use in conjunction with #curvemapping_set_black_white_ex
+ * Use in conjunction with #BKE_curvemapping_set_black_white_ex
  *
  * \param black: Use instead of cumap->black
  * \param bwmul: Use instead of cumap->bwmul
  */
-void curvemapping_evaluate_premulRGBF_ex(const CurveMapping *cumap,
-                                         float vecout[3],
-                                         const float vecin[3],
-                                         const float black[3],
-                                         const float bwmul[3])
+void BKE_curvemapping_evaluate_premulRGBF_ex(const CurveMapping *cumap,
+                                             float vecout[3],
+                                             const float vecin[3],
+                                             const float black[3],
+                                             const float bwmul[3])
 {
   const float r = (vecin[0] - black[0]) * bwmul[0];
   const float g = (vecin[1] - black[1]) * bwmul[1];
@@ -1064,9 +1073,9 @@ void curvemapping_evaluate_premulRGBF_ex(const CurveMapping *cumap,
   switch (cumap->tone) {
     default:
     case CURVE_TONE_STANDARD: {
-      vecout[0] = curvemap_evaluateF(&cumap->cm[0], r);
-      vecout[1] = curvemap_evaluateF(&cumap->cm[1], g);
-      vecout[2] = curvemap_evaluateF(&cumap->cm[2], b);
+      vecout[0] = BKE_curvemap_evaluateF(&cumap->cm[0], r);
+      vecout[1] = BKE_curvemap_evaluateF(&cumap->cm[1], g);
+      vecout[2] = BKE_curvemap_evaluateF(&cumap->cm[2], b);
       break;
     }
     case CURVE_TONE_FILMLIKE: {
@@ -1088,8 +1097,9 @@ void curvemapping_evaluate_premulRGBF_ex(const CurveMapping *cumap,
         }
         else {
           /* Case 4: r >= g == b */
-          copy_v2_fl2(
-              vecout, curvemap_evaluateF(&cumap->cm[0], r), curvemap_evaluateF(&cumap->cm[1], g));
+          copy_v2_fl2(vecout,
+                      BKE_curvemap_evaluateF(&cumap->cm[0], r),
+                      BKE_curvemap_evaluateF(&cumap->cm[1], g));
           vecout[2] = vecout[1];
         }
       }
@@ -1116,17 +1126,17 @@ void curvemapping_evaluate_premulRGBF_ex(const CurveMapping *cumap,
 }
 
 /* RGB with black/white points and premult. tables are checked */
-void curvemapping_evaluate_premulRGBF(const CurveMapping *cumap,
-                                      float vecout[3],
-                                      const float vecin[3])
+void BKE_curvemapping_evaluate_premulRGBF(const CurveMapping *cumap,
+                                          float vecout[3],
+                                          const float vecin[3])
 {
-  curvemapping_evaluate_premulRGBF_ex(cumap, vecout, vecin, cumap->black, cumap->bwmul);
+  BKE_curvemapping_evaluate_premulRGBF_ex(cumap, vecout, vecin, cumap->black, cumap->bwmul);
 }
 
 /* same as above, byte version */
-void curvemapping_evaluate_premulRGB(const CurveMapping *cumap,
-                                     unsigned char vecout_byte[3],
-                                     const unsigned char vecin_byte[3])
+void BKE_curvemapping_evaluate_premulRGB(const CurveMapping *cumap,
+                                         unsigned char vecout_byte[3],
+                                         const unsigned char vecin_byte[3])
 {
   float vecin[3], vecout[3];
 
@@ -1134,14 +1144,14 @@ void curvemapping_evaluate_premulRGB(const CurveMapping *cumap,
   vecin[1] = (float)vecin_byte[1] / 255.0f;
   vecin[2] = (float)vecin_byte[2] / 255.0f;
 
-  curvemapping_evaluate_premulRGBF(cumap, vecout, vecin);
+  BKE_curvemapping_evaluate_premulRGBF(cumap, vecout, vecin);
 
   vecout_byte[0] = unit_float_to_uchar_clamp(vecout[0]);
   vecout_byte[1] = unit_float_to_uchar_clamp(vecout[1]);
   vecout_byte[2] = unit_float_to_uchar_clamp(vecout[2]);
 }
 
-int curvemapping_RGBA_does_something(const CurveMapping *cumap)
+int BKE_curvemapping_RGBA_does_something(const CurveMapping *cumap)
 {
   int a;
 
@@ -1187,7 +1197,7 @@ int curvemapping_RGBA_does_something(const CurveMapping *cumap)
   return 0;
 }
 
-void curvemapping_initialize(CurveMapping *cumap)
+void BKE_curvemapping_initialize(CurveMapping *cumap)
 {
   int a;
 
@@ -1202,7 +1212,7 @@ void curvemapping_initialize(CurveMapping *cumap)
   }
 }
 
-void curvemapping_table_RGBA(const CurveMapping *cumap, float **array, int *size)
+void BKE_curvemapping_table_RGBA(const CurveMapping *cumap, float **array, int *size)
 {
   int a;
 
@@ -1520,10 +1530,10 @@ static void scopes_update_finalize(void *__restrict userdata, void *__restrict u
   }
 }
 
-void scopes_update(Scopes *scopes,
-                   ImBuf *ibuf,
-                   const ColorManagedViewSettings *view_settings,
-                   const ColorManagedDisplaySettings *display_settings)
+void BKE_scopes_update(Scopes *scopes,
+                       ImBuf *ibuf,
+                       const ColorManagedViewSettings *view_settings,
+                       const ColorManagedDisplaySettings *display_settings)
 {
   int a;
   unsigned int nl, na, nr, ng, nb;
@@ -1685,7 +1695,7 @@ void scopes_update(Scopes *scopes,
   scopes->ok = 1;
 }
 
-void scopes_free(Scopes *scopes)
+void BKE_scopes_free(Scopes *scopes)
 {
   if (scopes->waveform_1) {
     MEM_freeN(scopes->waveform_1);
@@ -1705,7 +1715,7 @@ void scopes_free(Scopes *scopes)
   }
 }
 
-void scopes_new(Scopes *scopes)
+void BKE_scopes_new(Scopes *scopes)
 {
   scopes->accuracy = 30.0;
   scopes->hist.mode = HISTO_MODE_RGB;
@@ -1781,7 +1791,7 @@ void BKE_color_managed_view_settings_copy(ColorManagedViewSettings *new_settings
   new_settings->gamma = settings->gamma;
 
   if (settings->curve_mapping) {
-    new_settings->curve_mapping = curvemapping_copy(settings->curve_mapping);
+    new_settings->curve_mapping = BKE_curvemapping_copy(settings->curve_mapping);
   }
   else {
     new_settings->curve_mapping = NULL;
@@ -1791,7 +1801,7 @@ void BKE_color_managed_view_settings_copy(ColorManagedViewSettings *new_settings
 void BKE_color_managed_view_settings_free(ColorManagedViewSettings *settings)
 {
   if (settings->curve_mapping) {
-    curvemapping_free(settings->curve_mapping);
+    BKE_curvemapping_free(settings->curve_mapping);
   }
 }
 
diff --git a/source/blender/blenkernel/intern/gpencil.c b/source/blender/blenkernel/intern/gpencil.c
index 731e9aff926..3ae20642b15 100644
--- a/source/blender/blenkernel/intern/gpencil.c
+++ b/source/blender/blenkernel/intern/gpencil.c
@@ -1632,13 +1632,13 @@ float BKE_gpencil_multiframe_falloff_calc(
   if (gpf->framenum < actnum) {
     fnum = (float)(gpf->framenum - f_init) / (actnum - f_init);
     fnum *= 0.5f;
-    value = curvemapping_evaluateF(cur_falloff, 0, fnum);
+    value = BKE_curvemapping_evaluateF(cur_falloff, 0, fnum);
   }
   /* frames to the left of the active frame */
   else if (gpf->framenum > actnum) {
     fnum = (float)(gpf->framenum - actnum) / (f_end - actnum);
     fnum *= 0.5f;
-    value = curvemapping_evaluateF(cur_falloff, 0, fnum + 0.5f);
+    value = BKE_curvemapping_evaluateF(cur_falloff, 0, fnum + 0.5f);
   }
   else {
     value = 1.0f;
diff --git a/source/blender/blenkernel/intern/light.c b/source/blender/blenkernel/intern/light.c
index 271bf58fcc6..75c9e0e42a5 100644
--- a/source/blender/blenkernel/intern/light.c
+++ b/source/blender/blenkernel/intern/light.c
@@ -69,7 +69,7 @@ void BKE_light_init(Light *la)
   la->coeff_const = 1.0f;
   la->coeff_lin = 0.0f;
   la->coeff_quad = 0.0f;
-  la->curfalloff = curvemapping_add(1, 0.0f, 1.0f, 1.0f, 0.0f);
+  la->curfalloff = BKE_curvemapping_add(1, 0.0f, 1.0f, 1.0f, 0.0f);
   la->cascade_max_dist = 200.0f;
   la->cascade_count = 4;
   la->cascade_exponent = 0.8f;
@@ -82,7 +82,7 @@ void BKE_light_init(Light *la)
   la->att_dist = 40.0f;
   la->sun_angle = DEG2RADF(0.526f);
 
-  curvemapping_initialize(la->curfalloff);
+  BKE_curvemapping_initialize(la->curfalloff);
 }
 
 Light *BKE_light_add(Main *bmain, const char *name)
@@ -108,7 +108,7 @@ Light *BKE_light_add(Main *bmain, const char *name)
  */
 void BKE_light_copy_data(Main *bmain, Light *la_dst, const Light *la_src, const int flag)
 {
-  la_dst->curfalloff = curvemapping_copy(la_src->curfalloff);
+  la_dst->curfalloff = BKE_curvemapping_copy(la_src->curfalloff);
 
   if (la_src->nodetree) {
     /* Note: nodetree is *not* in bmain, however this specific case is handled at lower level
@@ -145,7 +145,7 @@ Light *BKE_light_localize(Light *la)
 
   Light *lan = BKE_libblock_copy_for_localize(&la->id);
 
-  lan->curfalloff = curvemapping_copy(la->curfalloff);
+  lan->curfalloff = BKE_curvemapping_copy(la->curfalloff);
 
   if (la->nodetree) {
     lan->nodetree = ntreeLocalize(la->nodetree);
@@ -167,7 +167,7 @@ void BKE_light_free(Light *la)
 {
   BKE_animdata_free((ID *)la, false);
 
-  curvemapping_free(la->curfalloff);
+  BKE_curvemapping_free(la->curfalloff);
 
   /* is no lib link block, but light extension */
   if (la->nodetree) {
diff --git a/source/blender/blenkernel/intern/linestyle.c b/source/blender/blenkernel/intern/linestyle.c
index 31e6d2e89e5..7bfe5a7c8ff 100644
--- a/source/blender/blenkernel/intern/linestyle.c
+++ b/source/blender/blenkernel/intern/linestyle.c
@@ -512,13 +512,13 @@ LineStyleModifier *BKE_linestyle_alpha_modifier_add(FreestyleLineStyle *linestyl
   switch (type) {
     case LS_MODIFIER_ALONG_STROKE: {
       LineStyleAlphaModifier_AlongStroke *p = (LineStyleAlphaModifier_AlongStroke *)m;
-      p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+      p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
       break;
     }
     case LS_MODIFIER_DISTANCE_FROM_CAMERA: {
       LineStyleAlphaModifier_DistanceFromCamera *p = (LineStyleAlphaModifier_DistanceFromCamera *)
           m;
-      p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+      p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
       p->range_min = 0.0f;
       p->range_max = 10000.0f;
       break;
@@ -527,25 +527,25 @@ LineStyleModifier *BKE_linestyle_alpha_modifier_add(FreestyleLineStyle *linestyl
       LineStyleAlphaModifier_DistanceFromObject *p = (LineStyleAlphaModifier_DistanceFromObject *)
           m;
       p->target = NULL;
-      p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+      p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
       p->range_min = 0.0f;
       p->range_max = 10000.0f;
       break;
     }
     case LS_MODIFIER_MATERIAL: {
       LineStyleAlphaModifier_Material *p = (LineStyleAlphaModifier_Material *)m;
-      p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+      p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
       p->mat_attr = LS_MODIFIER_MATERIAL_LINE_A;
       break;
     }
     case LS_MODIFIER_TANGENT: {
       LineStyleAlphaModifier_Tangent *p = (LineStyleAlphaModifier_Tangent *)m;
-      p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+      p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
       break;
     }
     case LS_MODIFIER_NOISE: {
       LineStyleAlphaModifier_Noise *p = (LineStyleAlphaModifier_Noise *)m;
-      p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+      p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
       ((LineStyleAlphaModifier_Noise *)m)->amplitude = 10.0f;
       ((LineStyleAlphaModifier_Noise *)m)->period = 10.0f;
       ((LineStyleAlphaModifier_Noise *)m)->seed = 512;
@@ -553,14 +553,14 @@ LineStyleModifier *BKE_linestyle_alpha_modifier_add(FreestyleLineStyle *linestyl
     }
     case LS_MODIFIER_CREASE_ANGLE: {
       LineStyleAlphaModifier_CreaseAngle *p = (LineStyleAlphaModifier_CreaseAngle *)m;
-      p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+      p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
       ((LineStyleAlphaModifier_CreaseAngle *)m)->min_angle = 0.0f;
       ((LineStyleAlphaModifier_CreaseAngle *)m)->max_angle = DEG2RADF(180.0f);
       break;
     }
     case LS_MODIFIER_CURVATURE_3D: {
       LineStyleAlphaModifier_Curvature_3D *p = (LineStyleAlphaModifier_Curvature_3D *)m;
-      p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+      p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
       ((LineStyleAlphaModifier_Curvature_3D *)m)->min_curvature = 0.0f;
       ((LineStyleAlphaModifier_Curvature_3D *)m)->max_curvature = 0.5f;
       break;
@@ -588,7 +588,7 @@ LineStyleModifier *BKE_linestyle_alpha_modifier_copy(FreestyleLineStyle *linesty
     case LS_MODIFIER_ALONG_STROKE: {
       LineStyleAlphaModifier_AlongStroke *p = (LineStyleAlphaModifier_AlongStroke *)m;
       LineStyleAlphaModifier_AlongStroke *q = (LineStyleAlphaModifier_AlongStroke *)new_m;
-      q->curve = curvemapping_copy(p->curve);
+      q->curve = BKE_curvemapping_copy(p->curve);
       q->flags = p->flags;
       break;
     }
@@ -597,7 +597,7 @@ LineStyleModifier *BKE_linestyle_alpha_modifier_copy(FreestyleLineStyle *linesty
           m;
       LineStyleAlphaModifier_DistanceFromCamera *q = (LineStyleAlphaModifier_DistanceFromCamera *)
           new_m;
-      q->curve = curvemapping_copy(p->curve);
+      q->curve = BKE_curvemapping_copy(p->curve);
       q->flags = p->flags;
       q->range_min = p->range_min;
       q->range_max = p->range_max;
@@ -612,7 +612,7 @@ LineStyleModifier *BKE_linestyle_alpha_modifier_copy(FreestyleLineStyle *linesty
         id_us_plus(&p->target->id);
       }
       q->target = p->target;
-      q->curve = curvemapping_copy(p->curve);
+      q->curve = BKE_curvemapping_copy(p->curve);
       q->flags = p->flags;
       q->range_min = p->range_min;
       q->range_max = p->range_max;
@@ -621,7 +621,7 @@ LineStyleModifier *BKE_linestyle_alpha_modifier_copy(FreestyleLineStyle *linesty
     case LS_MODIFIER_MATERIAL: {
       LineStyleAlphaModifier_Material *p = (LineStyleAlphaModifier_Material *)m;
       LineStyleAlphaModifier_Material *q = (LineStyleAlphaModifier_Material *)new_m;
-      q->curve = curvemapping_copy(p->curve);
+      q->curve = BKE_curvemapping_copy(p->curve);
       q->flags = p->flags;
       q->mat_attr = p->mat_attr;
       break;
@@ -629,14 +629,14 @@ LineStyleModifier *BKE_linestyle_alpha_modifier_copy(FreestyleLineStyle *linesty
     case LS_MODIFIER_TANGENT: {
       LineStyleAlphaModifier_Tangent *p = (LineStyleAlphaModifier_Tangent *)m;
       LineStyleAlphaModifier_Tangent *q = (LineStyleAlphaModifier_Tangent *)new_m;
-      q->curve = curvemapping_copy(p->curve);
+      q->curve = BKE_curvemapping_copy(p->curve);
       q->flags = p->flags;
       break;
     }
     case LS_MODIFIER_NOISE: {
       LineStyleAlphaModifier_Noise *p = (LineStyleAlphaModifier_Noise *)m;
       LineStyleAlphaModifier_Noise *q = (LineStyleAlphaModifier_Noise *)new_m;
-      q->curve = curvemapping_copy(p->curve);
+      q->curve = BKE_curvemapping_copy(p->curve);
       q->flags = p->flags;
       q->amplitude = p->amplitude;
       q->period = p->period;
@@ -646,7 +646,7 @@ LineStyleModifier *BKE_linestyle_alpha_modifier_copy(FreestyleLineStyle *linesty
     case LS_MODIFIER_CREASE_ANGLE: {
       LineStyleAlphaModifier_CreaseAngle *p = (LineStyleAlphaModifier_CreaseAngle *)m;
       LineStyleAlphaModifier_CreaseAngle *q = (LineStyleAlphaModifier_CreaseAngle *)new_m;
-      q->curve = curvemapping_copy(p->curve);
+      q->curve = BKE_curvemapping_copy(p->curve);
       q->flags = p->flags;
       q->min_angle = p->min_angle;
       q->max_angle = p->max_angle;
@@ -655,7 +655,7 @@ LineStyleModifier *BKE_linestyle_alpha_modifier_copy(FreestyleLineStyle *linesty
     case LS_MODIFIER_CURVATURE_3D: {
       LineStyleAlphaModifier_Curvature_3D *p = (LineStyleAlphaModifier_Curvature_3D *)m;
       LineStyleAlphaModifier_Curvature_3D *q = (LineStyleAlphaModifier_Curvature_3D *)new_m;
-      q->curve = curvemapping_copy(p->curve);
+      q->curve = BKE_curvemapping_copy(p->curve);
       q->flags = p->flags;
       q->min_curvature = p->min_curvature;
       q->max_curvature = p->max_curvature;
@@ -676,28 +676,28 @@ int BKE_linestyle_alpha_modifier_remove(FreestyleLineStyle *linestyle, LineStyle
   }
   switch (m->type) {
     case LS_MODIFIER_ALONG_STROKE:
-      curvemapping_free(((LineStyleAlphaModifier_AlongStroke *)m)->curve);
+      BKE_curvemapping_free(((LineStyleAlphaModifier_AlongStroke *)m)->curve);
       break;
     case LS_MODIFIER_DISTANCE_FROM_CAMERA:
-      curvemapping_free(((LineStyleAlphaModifier_DistanceFromCamera *)m)->curve);
+      BKE_curvemapping_free(((LineStyleAlphaModifier_DistanceFromCamera *)m)->curve);
       break;
     case LS_MODIFIER_DISTANCE_FROM_OBJECT:
-      curvemapping_free(((LineStyleAlphaModifier_DistanceFromObject *)m)->curve);
+      BKE_curvemapping_free(((LineStyleAlphaModifier_DistanceFromObject *)m)->curve);
       break;
     case LS_MODIFIER_MATERIAL:
-      curvemapping_free(((LineStyleAlphaModifier_Material *)m)->curve);
+      BKE_curvemapping_free(((LineStyleAlphaModifier_Material *)m)->curve);
       break;
     case LS_MODIFIER_TANGENT:
-      curvemapping_free(((LineStyleAlphaModifier_Tangent *)m)->curve);
+      BKE_curvemapping_free(((LineStyleAlphaModifier_Tangent *)m)->curve);
       break;
     case LS_MODIFIER_NOISE:
-      curvemapping_free(((LineStyleAlphaModifier_Noise *)m)->curve);
+      BKE_curvemapping_free(((LineStyleAlphaModifier_Noise *)m)->curve);
       break;
     case LS_MODIFIER_CREASE_ANGLE:
-      curvemapping_free(((LineStyleAlphaModifier_CreaseAngle *)m)->curve);
+      BKE_curvemapping_free(((LineStyleAlphaModifier_CreaseAngle *)m)->curve);
       break;
     case LS_MODIFIER_CURVATURE_3D:
-      curvemapping_free(((LineStyleAlphaModifier_Curvature_3D *)m)->curve);
+      BKE_curvemapping_free(((LineStyleAlphaModifier_Curvature_3D *)m)->curve);
       break;
   }
   BLI_freelinkN(&linestyle->alpha_modifiers, m);
@@ -755,7 +755,7 @@ LineStyleModifier *BKE_linestyle_thickness_modifier_add(FreestyleLineStyle *line
   switch (type) {
     case LS_MODIFIER_ALONG_STROKE: {
       LineStyleThicknessModifier_AlongStroke *p = (LineStyleThicknessModifier_AlongStroke *)m;
-      p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+      p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
       p->value_min = 0.0f;
       p->value_max = 1.0f;
       break;
@@ -763,7 +763,7 @@ LineStyleModifier *BKE_linestyle_thickness_modifier_add(FreestyleLineStyle *line
     case LS_MODIFIER_DISTANCE_FROM_CAMERA: {
       LineStyleThicknessModifier_DistanceFromCamera *p =
           (LineStyleThicknessModifier_DistanceFromCamera *)m;
-      p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+      p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
       p->range_min = 0.0f;
       p->range_max = 1000.0f;
       p->value_min = 0.0f;
@@ -774,7 +774,7 @@ LineStyleModifier *BKE_linestyle_thickness_modifier_add(FreestyleLineStyle *line
       LineStyleThicknessModifier_DistanceFromObject *p =
           (LineStyleThicknessModifier_DistanceFromObject *)m;
       p->target = NULL;
-      p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+      p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
       p->range_min = 0.0f;
       p->range_max = 1000.0f;
       p->value_min = 0.0f;
@@ -783,7 +783,7 @@ LineStyleModifier *BKE_linestyle_thickness_modifier_add(FreestyleLineStyle *line
     }
     case LS_MODIFIER_MATERIAL: {
       LineStyleThicknessModifier_Material *p = (LineStyleThicknessModifier_Material *)m;
-      p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+      p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
       p->mat_attr = LS_MODIFIER_MATERIAL_LINE;
       p->value_min = 0.0f;
       p->value_max = 1.0f;
@@ -798,7 +798,7 @@ LineStyleModifier *BKE_linestyle_thickness_modifier_add(FreestyleLineStyle *line
     }
     case LS_MODIFIER_TANGENT: {
       LineStyleThicknessModifier_Tangent *p = (LineStyleThicknessModifier_Tangent *)m;
-      p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+      p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
       p->min_thickness = 1.0f;
       p->max_thickness = 10.0f;
       break;
@@ -813,7 +813,7 @@ LineStyleModifier *BKE_linestyle_thickness_modifier_add(FreestyleLineStyle *line
     }
     case LS_MODIFIER_CREASE_ANGLE: {
       LineStyleThicknessModifier_CreaseAngle *p = (LineStyleThicknessModifier_CreaseAngle *)m;
-      p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+      p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
       p->min_angle = 0.0f;
       p->max_angle = DEG2RADF(180.0f);
       p->min_thickness = 1.0f;
@@ -822,7 +822,7 @@ LineStyleModifier *BKE_linestyle_thickness_modifier_add(FreestyleLineStyle *line
     }
     case LS_MODIFIER_CURVATURE_3D: {
       LineStyleThicknessModifier_Curvature_3D *p = (LineStyleThicknessModifier_Curvature_3D *)m;
-      p->curve = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+      p->curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
       p->min_curvature = 0.0f;
       p->max_curvature = 0.5f;
       p->min_thickness = 1.0f;
@@ -855,7 +855,7 @@ LineStyleModifier *BKE_linestyle_thickness_modifier_copy(FreestyleLineStyle *lin
     case LS_MODIFIER_ALONG_STROKE: {
       LineStyleThicknessModifier_AlongStroke *p = (LineStyleThicknessModifier_AlongStroke *)m;
       LineStyleThicknessModifier_AlongStroke *q = (LineStyleThicknessModifier_AlongStroke *)new_m;
-      q->curve = curvemapping_copy(p->curve);
+      q->curve = BKE_curvemapping_copy(p->curve);
       q->flags = p->flags;
       q->value_min = p->value_min;
       q->value_max = p->value_max;
@@ -866,7 +866,7 @@ LineStyleModifier *BKE_linestyle_thickness_modifier_copy(FreestyleLineStyle *lin
           (LineStyleThicknessModifier_DistanceFromCamera *)m;
       LineStyleThicknessModifier_DistanceFromCamera *q =
           (LineStyleThicknessModifier_DistanceFromCamera *)new_m;
-      q->curve = curvemapping_copy(p->curve);
+      q->curve = BKE_curvemapping_copy(p->curve);
       q->flags = p->flags;
       q->range_min = p->range_min;
       q->range_max = p->range_max;
@@ -883,7 +883,7 @@ LineStyleModifier *BKE_linestyle_thickness_modifier_copy(FreestyleLineStyle *lin
       if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
         id_us_plus((ID *)q->target);
       }
-      q->curve = curvemapping_copy(p->curve);
+      q->curve = BKE_curvemapping_copy(p->curve);
       q->flags = p->flags;
       q->range_min = p->range_min;
       q->range_max = p->range_max;
@@ -894,7 +894,7 @@ LineStyleModifier *BKE_linestyle_thickness_modifier_copy(FreestyleLineStyle *lin
     case LS_MODIFIER_MATERIAL: {
       LineStyleThicknessModifier_Material *p = (LineStyleThicknessModifier_Material *)m;
       LineStyleThicknessModifier_Material *q = (LineStyleThicknessModifier_Material *)new_m;
-      q->curve = curvemapping_copy(p->curve);
+      q->curve = BKE_curvemapping_copy(p->curve);
       q->flags = p->flags;
       q->mat_attr = p->mat_attr;
       q->value_min = p->value_min;
@@ -912,7 +912,7 @@ LineStyleModifier *BKE_linestyle_thickness_modifier_copy(FreestyleLineStyle *lin
     case LS_MODIFIER_TANGENT: {
       LineStyleThicknessModifier_Tangent *p = (LineStyleThicknessModifier_Tangent *)m;
       LineStyleThicknessModifier_Tangent *q = (LineStyleThicknessModifier_Tangent *)new_m;
-      q->curve = curvemapping_copy(p->curve);
+      q->curve = BKE_curvemapping_copy(p->curve);
       q->flags = p->flags;
       q->min_thickness = p->min_thickness;
       q->max_thickness = p->max_thickness;
@@ -931,7 +931,7 @@ LineStyleModifier *BKE_linestyle_thickness_modifier_copy(FreestyleLineStyle *lin
       LineStyleThicknessModifier_Curvature_3D *p = (LineStyleThicknessModifier_Curvature_3D *)m;
       LineStyleThicknessModifier_Curvature_3D *q = (LineStyleThicknessModifier_Curvature_3D *)
           new_m;
-      q->curve = curvemapping_copy(p->curve);
+      q->curve = BKE_curvemapping_copy(p->curve);
       q->flags = p->flags;
       q->min_curvature = p->min_curvature;
       q->max_curvature = p->max_curvature;
@@ -942,7 +942,7 @@ LineStyleModifier *BKE_linestyle_thickness_modifier_copy(FreestyleLineStyle *lin
     case LS_MODIFIER_CREASE_ANGLE: {
       LineStyleThicknessModifier_CreaseAngle *p = (LineStyleThicknessModifier_CreaseAngle *)m;
       LineStyleThicknessModifier_CreaseAngle *q = (LineStyleThicknessModifier_CreaseAngle *)new_m;
-      q->curve = curvemapping_copy(p->curve);
+      q->curve = BKE_curvemapping_copy(p->curve);
       q->flags = p->flags;
       q->min_angle = p->min_angle;
       q->max_angle = p->max_angle;
@@ -965,21 +965,21 @@ int BKE_linestyle_thickness_modifier_remove(FreestyleLineStyle *linestyle, LineS
   }
   switch (m->type) {
     case LS_MODIFIER_ALONG_STROKE:
-      curvemapping_free(((LineStyleThicknessModifier_AlongStroke *)m)->curve);
+      BKE_curvemapping_free(((LineStyleThicknessModifier_AlongStroke *)m)->curve);
       break;
     case LS_MODIFIER_DISTANCE_FROM_CAMERA:
-      curvemapping_free(((LineStyleThicknessModifier_DistanceFromCamera *)m)->curve);
+      BKE_curvemapping_free(((LineStyleThicknessModifier_DistanceFromCamera *)m)->curve);
       break;
     case LS_MODIFIER_DISTANCE_FROM_OBJECT:
-      curvemapping_free(((LineStyleThicknessModifier_DistanceFromObject *)m)->curve);
+      BKE_curvemapping_free(((LineStyleThicknessModifier_DistanceFromObject *)m)->curve);
       break;
     case LS_MODIFIER_MATERIAL:
-      curvemapping_free(((LineStyleThicknessModifier_Material *)m)->curve);
+      BKE_curvemapping_free(((LineStyleThicknessModifier_Material *)m)->curve);
       break;
     case LS_MODIFIER_CALLIGRAPHY:
       break;
     case LS_MODIFIER_TANGENT:
-      curvemapping_free(((LineStyleThicknessModifier_Tangent *)m)->curve);
+      BKE_curvemapping_free(((LineStyleThicknessModifier_Tangent *)m)->curve);
       break;
     case LS_MODIFIER_NOISE:
       break;
diff --git a/source/blender/blenkernel/intern/paint.c b/source/blender/blenkernel/intern/paint.c
index 0e93c80ecb5..4a41ffbfa8c 100644
--- a/source/blender/blenkernel/intern/paint.c
+++ b/source/blender/blenkernel/intern/paint.c
@@ -658,15 +658,16 @@ void BKE_paint_cavity_curve_preset(Paint *p, int preset)
   CurveMap *cm = NULL;
 
   if (!p->cavity_curve) {
-    p->cavity_curve = curvemapping_add(1, 0, 0, 1, 1);
+    p->cavity_curve = BKE_curvemapping_add(1, 0, 0, 1, 1);
   }
 
   cm = p->cavity_curve->cm;
   cm->flag &= ~CUMA_EXTEND_EXTRAPOLATE;
 
   p->cavity_curve->preset = preset;
-  curvemap_reset(cm, &p->cavity_curve->clipr, p->cavity_curve->preset, CURVEMAP_SLOPE_POSITIVE);
-  curvemapping_changed(p->cavity_curve, false);
+  BKE_curvemap_reset(
+      cm, &p->cavity_curve->clipr, p->cavity_curve->preset, CURVEMAP_SLOPE_POSITIVE);
+  BKE_curvemapping_changed(p->cavity_curve, false);
 }
 
 eObjectMode BKE_paint_object_mode_from_paintmode(ePaintMode mode)
@@ -778,7 +779,7 @@ void BKE_paint_init(Main *bmain, Scene *sce, ePaintMode mode, const char col[3])
 
 void BKE_paint_free(Paint *paint)
 {
-  curvemapping_free(paint->cavity_curve);
+  BKE_curvemapping_free(paint->cavity_curve);
   MEM_SAFE_FREE(paint->tool_slots);
 }
 
@@ -789,7 +790,7 @@ void BKE_paint_free(Paint *paint)
 void BKE_paint_copy(Paint *src, Paint *tar, const int flag)
 {
   tar->brush = src->brush;
-  tar->cavity_curve = curvemapping_copy(src->cavity_curve);
+  tar->cavity_curve = BKE_curvemapping_copy(src->cavity_curve);
   tar->tool_slots = MEM_dupallocN(src->tool_slots);
 
   if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
diff --git a/source/blender/blenkernel/intern/particle.c b/source/blender/blenkernel/intern/particle.c
index 9cc49e39231..da00a044009 100644
--- a/source/blender/blenkernel/intern/particle.c
+++ b/source/blender/blenkernel/intern/particle.c
@@ -494,13 +494,13 @@ void BKE_particlesettings_free(ParticleSettings *part)
   }
 
   if (part->clumpcurve) {
-    curvemapping_free(part->clumpcurve);
+    BKE_curvemapping_free(part->clumpcurve);
   }
   if (part->roughcurve) {
-    curvemapping_free(part->roughcurve);
+    BKE_curvemapping_free(part->roughcurve);
   }
   if (part->twistcurve) {
-    curvemapping_free(part->twistcurve);
+    BKE_curvemapping_free(part->twistcurve);
   }
 
   BKE_partdeflect_free(part->pd);
@@ -2060,10 +2060,10 @@ int do_guides(Depsgraph *depsgraph,
       }
 
       if (clumpcurve) {
-        curvemapping_changed_all(clumpcurve);
+        BKE_curvemapping_changed_all(clumpcurve);
       }
       if (roughcurve) {
-        curvemapping_changed_all(roughcurve);
+        BKE_curvemapping_changed_all(roughcurve);
       }
 
       {
@@ -2368,22 +2368,22 @@ static bool psys_thread_context_init_path(ParticleThreadContext *ctx,
 
   /* prepare curvemapping tables */
   if ((part->child_flag & PART_CHILD_USE_CLUMP_CURVE) && part->clumpcurve) {
-    ctx->clumpcurve = curvemapping_copy(part->clumpcurve);
-    curvemapping_changed_all(ctx->clumpcurve);
+    ctx->clumpcurve = BKE_curvemapping_copy(part->clumpcurve);
+    BKE_curvemapping_changed_all(ctx->clumpcurve);
   }
   else {
     ctx->clumpcurve = NULL;
   }
   if ((part->child_flag & PART_CHILD_USE_ROUGH_CURVE) && part->roughcurve) {
-    ctx->roughcurve = curvemapping_copy(part->roughcurve);
-    curvemapping_changed_all(ctx->roughcurve);
+    ctx->roughcurve = BKE_curvemapping_copy(part->roughcurve);
+    BKE_curvemapping_changed_all(ctx->roughcurve);
   }
   else {
     ctx->roughcurve = NULL;
   }
   if ((part->child_flag & PART_CHILD_USE_TWIST_CURVE) && part->twistcurve) {
-    ctx->twistcurve = curvemapping_copy(part->twistcurve);
-    curvemapping_changed_all(ctx->twistcurve);
+    ctx->twistcurve = BKE_curvemapping_copy(part->twistcurve);
+    BKE_curvemapping_changed_all(ctx->twistcurve);
   }
   else {
     ctx->twistcurve = NULL;
@@ -3719,42 +3719,42 @@ ParticleSettings *BKE_particlesettings_add(Main *bmain, const char *name)
 
 void BKE_particlesettings_clump_curve_init(ParticleSettings *part)
 {
-  CurveMapping *cumap = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+  CurveMapping *cumap = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
 
   cumap->cm[0].curve[0].x = 0.0f;
   cumap->cm[0].curve[0].y = 1.0f;
   cumap->cm[0].curve[1].x = 1.0f;
   cumap->cm[0].curve[1].y = 1.0f;
 
-  curvemapping_initialize(cumap);
+  BKE_curvemapping_initialize(cumap);
 
   part->clumpcurve = cumap;
 }
 
 void BKE_particlesettings_rough_curve_init(ParticleSettings *part)
 {
-  CurveMapping *cumap = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+  CurveMapping *cumap = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
 
   cumap->cm[0].curve[0].x = 0.0f;
   cumap->cm[0].curve[0].y = 1.0f;
   cumap->cm[0].curve[1].x = 1.0f;
   cumap->cm[0].curve[1].y = 1.0f;
 
-  curvemapping_initialize(cumap);
+  BKE_curvemapping_initialize(cumap);
 
   part->roughcurve = cumap;
 }
 
 void BKE_particlesettings_twist_curve_init(ParticleSettings *part)
 {
-  CurveMapping *cumap = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+  CurveMapping *cumap = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
 
   cumap->cm[0].curve[0].x = 0.0f;
   cumap->cm[0].curve[0].y = 1.0f;
   cumap->cm[0].curve[1].x = 1.0f;
   cumap->cm[0].curve[1].y = 1.0f;
 
-  curvemapping_initialize(cumap);
+  BKE_curvemapping_initialize(cumap);
 
   part->twistcurve = cumap;
 }
@@ -3780,13 +3780,13 @@ void BKE_particlesettings_copy_data(Main *UNUSED(bmain),
   part_dst->fluid = MEM_dupallocN(part_src->fluid);
 
   if (part_src->clumpcurve) {
-    part_dst->clumpcurve = curvemapping_copy(part_src->clumpcurve);
+    part_dst->clumpcurve = BKE_curvemapping_copy(part_src->clumpcurve);
   }
   if (part_src->roughcurve) {
-    part_dst->roughcurve = curvemapping_copy(part_src->roughcurve);
+    part_dst->roughcurve = BKE_curvemapping_copy(part_src->roughcurve);
   }
   if (part_src->twistcurve) {
-    part_dst->twistcurve = curvemapping_copy(part_src->twistcurve);
+    part_dst->twistcurve = BKE_curvemapping_copy(part_src->twistcurve);
   }
 
   part_dst->boids = boid_copy_settings(part_src->boids);
diff --git a/source/blender/blenkernel/intern/particle_child.c b/source/blender/blenkernel/intern/particle_child.c
index b74fd3ff684..3b02e010e7f 100644
--- a/source/blender/blenkernel/intern/particle_child.c
+++ b/source/blender/blenkernel/intern/particle_child.c
@@ -597,7 +597,8 @@ static float do_clump_level(float result[3],
   float clump = 0.0f;
 
   if (clumpcurve) {
-    clump = pa_clump * (1.0f - clamp_f(curvemapping_evaluateF(clumpcurve, 0, time), 0.0f, 1.0f));
+    clump = pa_clump *
+            (1.0f - clamp_f(BKE_curvemapping_evaluateF(clumpcurve, 0, time), 0.0f, 1.0f));
 
     interp_v3_v3v3(result, co, par_co, clump);
   }
@@ -714,7 +715,7 @@ static void do_rough_curve(const float loc[3],
     return;
   }
 
-  fac *= clamp_f(curvemapping_evaluateF(roughcurve, 0, time), 0.0f, 1.0f);
+  fac *= clamp_f(BKE_curvemapping_evaluateF(roughcurve, 0, time), 0.0f, 1.0f);
 
   copy_v3_v3(rco, loc);
   mul_v3_fl(rco, time);
@@ -749,15 +750,15 @@ static void twist_get_axis(const ParticleChildModifierContext *modifier_ctx,
   }
 }
 
-static float curvemapping_integrate_clamped(CurveMapping *curve,
-                                            float start,
-                                            float end,
-                                            float step)
+static float BKE_curvemapping_integrate_clamped(CurveMapping *curve,
+                                                float start,
+                                                float end,
+                                                float step)
 {
   float integral = 0.0f;
   float x = start;
   while (x < end) {
-    float y = curvemapping_evaluateF(curve, 0, x);
+    float y = BKE_curvemapping_evaluateF(curve, 0, x);
     y = clamp_f(y, 0.0f, 1.0f);
     /* TODO(sergey): Clamp last step to end. */
     integral += y * step;
@@ -804,7 +805,7 @@ static void do_twist(const ParticleChildModifierContext *modifier_ctx,
   }
   if (twist_curve != NULL) {
     const int num_segments = twist_num_segments(modifier_ctx);
-    angle *= curvemapping_integrate_clamped(twist_curve, 0.0f, time, 1.0f / num_segments);
+    angle *= BKE_curvemapping_integrate_clamped(twist_curve, 0.0f, time, 1.0f / num_segments);
   }
   else {
     angle *= time;
diff --git a/source/blender/blenkernel/intern/particle_system.c b/source/blender/blenkernel/intern/particle_system.c
index 615870d099f..31484b59127 100644
--- a/source/blender/blenkernel/intern/particle_system.c
+++ b/source/blender/blenkernel/intern/particle_system.c
@@ -563,13 +563,13 @@ void psys_thread_context_free(ParticleThreadContext *ctx)
   BLI_kdtree_3d_free(ctx->tree);
 
   if (ctx->clumpcurve != NULL) {
-    curvemapping_free(ctx->clumpcurve);
+    BKE_curvemapping_free(ctx->clumpcurve);
   }
   if (ctx->roughcurve != NULL) {
-    curvemapping_free(ctx->roughcurve);
+    BKE_curvemapping_free(ctx->roughcurve);
   }
   if (ctx->twistcurve != NULL) {
-    curvemapping_free(ctx->twistcurve);
+    BKE_curvemapping_free(ctx->twistcurve);
   }
 }
 
diff --git a/source/blender/blenkernel/intern/scene.c b/source/blender/blenkernel/intern/scene.c
index b582b4f54bd..1ef93427253 100644
--- a/source/blender/blenkernel/intern/scene.c
+++ b/source/blender/blenkernel/intern/scene.c
@@ -176,10 +176,10 @@ ToolSettings *BKE_toolsettings_copy(ToolSettings *toolsettings, const int flag)
   ts->particle.object = NULL;
 
   /* duplicate Grease Pencil interpolation curve */
-  ts->gp_interpolate.custom_ipo = curvemapping_copy(ts->gp_interpolate.custom_ipo);
+  ts->gp_interpolate.custom_ipo = BKE_curvemapping_copy(ts->gp_interpolate.custom_ipo);
   /* duplicate Grease Pencil multiframe fallof */
-  ts->gp_sculpt.cur_falloff = curvemapping_copy(ts->gp_sculpt.cur_falloff);
-  ts->gp_sculpt.cur_primitive = curvemapping_copy(ts->gp_sculpt.cur_primitive);
+  ts->gp_sculpt.cur_falloff = BKE_curvemapping_copy(ts->gp_sculpt.cur_falloff);
+  ts->gp_sculpt.cur_primitive = BKE_curvemapping_copy(ts->gp_sculpt.cur_primitive);
   return ts;
 }
 
@@ -212,14 +212,14 @@ void BKE_toolsettings_free(ToolSettings *toolsettings)
 
   /* free Grease Pencil interpolation curve */
   if (toolsettings->gp_interpolate.custom_ipo) {
-    curvemapping_free(toolsettings->gp_interpolate.custom_ipo);
+    BKE_curvemapping_free(toolsettings->gp_interpolate.custom_ipo);
   }
   /* free Grease Pencil multiframe falloff curve */
   if (toolsettings->gp_sculpt.cur_falloff) {
-    curvemapping_free(toolsettings->gp_sculpt.cur_falloff);
+    BKE_curvemapping_free(toolsettings->gp_sculpt.cur_falloff);
   }
   if (toolsettings->gp_sculpt.cur_primitive) {
-    curvemapping_free(toolsettings->gp_sculpt.cur_primitive);
+    BKE_curvemapping_free(toolsettings->gp_sculpt.cur_primitive);
   }
 
   MEM_freeN(toolsettings);
@@ -291,7 +291,7 @@ void BKE_scene_copy_data(Main *bmain, Scene *sce_dst, const Scene *sce_src, cons
   BKE_color_managed_view_settings_copy(&sce_dst->r.bake.im_format.view_settings,
                                        &sce_src->r.bake.im_format.view_settings);
 
-  curvemapping_copy_data(&sce_dst->r.mblur_shutter_curve, &sce_src->r.mblur_shutter_curve);
+  BKE_curvemapping_copy_data(&sce_dst->r.mblur_shutter_curve, &sce_src->r.mblur_shutter_curve);
 
   /* tool settings */
   sce_dst->toolsettings = BKE_toolsettings_copy(sce_dst->toolsettings, flag_subdata);
@@ -347,7 +347,7 @@ Scene *BKE_scene_copy(Main *bmain, Scene *sce, int type)
     sce_copy = BKE_scene_add(bmain, sce->id.name + 2);
 
     rv = sce_copy->r.views;
-    curvemapping_free_data(&sce_copy->r.mblur_shutter_curve);
+    BKE_curvemapping_free_data(&sce_copy->r.mblur_shutter_curve);
     sce_copy->r = sce->r;
     sce_copy->r.views = rv;
     sce_copy->unit = sce->unit;
@@ -380,7 +380,7 @@ Scene *BKE_scene_copy(Main *bmain, Scene *sce, int type)
     BKE_color_managed_view_settings_copy(&sce_copy->r.bake.im_format.view_settings,
                                          &sce->r.bake.im_format.view_settings);
 
-    curvemapping_copy_data(&sce_copy->r.mblur_shutter_curve, &sce->r.mblur_shutter_curve);
+    BKE_curvemapping_copy_data(&sce_copy->r.mblur_shutter_curve, &sce->r.mblur_shutter_curve);
 
     /* viewport display settings */
     sce_copy->display = sce->display;
@@ -515,7 +515,7 @@ void BKE_scene_free_ex(Scene *sce, const bool do_id_user)
   BKE_color_managed_view_settings_free(&sce->view_settings);
 
   BKE_previewimg_free(&sce->preview);
-  curvemapping_free_data(&sce->r.mblur_shutter_curve);
+  BKE_curvemapping_free_data(&sce->r.mblur_shutter_curve);
 
   for (ViewLayer *view_layer = sce->view_layers.first, *view_layer_next; view_layer;
        view_layer = view_layer_next) {
@@ -653,12 +653,12 @@ void BKE_scene_init(Scene *sce)
   sce->r.unit_line_thickness = 1.0f;
 
   mblur_shutter_curve = &sce->r.mblur_shutter_curve;
-  curvemapping_set_defaults(mblur_shutter_curve, 1, 0.0f, 0.0f, 1.0f, 1.0f);
-  curvemapping_initialize(mblur_shutter_curve);
-  curvemap_reset(mblur_shutter_curve->cm,
-                 &mblur_shutter_curve->clipr,
-                 CURVE_PRESET_MAX,
-                 CURVEMAP_SLOPE_POS_NEG);
+  BKE_curvemapping_set_defaults(mblur_shutter_curve, 1, 0.0f, 0.0f, 1.0f, 1.0f);
+  BKE_curvemapping_initialize(mblur_shutter_curve);
+  BKE_curvemap_reset(mblur_shutter_curve->cm,
+                     &mblur_shutter_curve->clipr,
+                     CURVE_PRESET_MAX,
+                     CURVEMAP_SLOPE_POS_NEG);
 
   sce->toolsettings = MEM_callocN(sizeof(struct ToolSettings), "Tool Settings Struct");
 
@@ -704,19 +704,19 @@ void BKE_scene_init(Scene *sce)
   sce->toolsettings->imapaint.seam_bleed = 2;
 
   /* grease pencil multiframe falloff curve */
-  sce->toolsettings->gp_sculpt.cur_falloff = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+  sce->toolsettings->gp_sculpt.cur_falloff = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
   CurveMapping *gp_falloff_curve = sce->toolsettings->gp_sculpt.cur_falloff;
-  curvemapping_initialize(gp_falloff_curve);
-  curvemap_reset(
+  BKE_curvemapping_initialize(gp_falloff_curve);
+  BKE_curvemap_reset(
       gp_falloff_curve->cm, &gp_falloff_curve->clipr, CURVE_PRESET_GAUSS, CURVEMAP_SLOPE_POSITIVE);
 
-  sce->toolsettings->gp_sculpt.cur_primitive = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
+  sce->toolsettings->gp_sculpt.cur_primitive = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
   CurveMapping *gp_primitive_curve = sce->toolsettings->gp_sculpt.cur_primitive;
-  curvemapping_initialize(gp_primitive_curve);
-  curvemap_reset(gp_primitive_curve->cm,
-                 &gp_primitive_curve->clipr,
-                 CURVE_PRESET_BELL,
-                 CURVEMAP_SLOPE_POSITIVE);
+  BKE_curvemapping_initialize(gp_primitive_curve);
+  BKE_curvemap_reset(gp_primitive_curve->cm,
+                     &gp_primitive_curve->clipr,
+                     CURVE_PRESET_BELL,
+                     CURVEMAP_SLOPE_POSITIVE);
 
   sce->toolsettings->gp_sculpt.guide.spacing = 20.0f;
 
diff --git a/source/blender/blenkernel/intern/seqmodifier.c b/source/blender/blenkernel/intern/seqmodifier.c
index aceb8b7e4ad..a7543881dad 100644
--- a/source/blender/blenkernel/intern/seqmodifier.c
+++ b/source/blender/blenkernel/intern/seqmodifier.c
@@ -293,14 +293,14 @@ static void curves_init_data(SequenceModifierData *smd)
 {
   CurvesModifierData *cmd = (CurvesModifierData *)smd;
 
-  curvemapping_set_defaults(&cmd->curve_mapping, 4, 0.0f, 0.0f, 1.0f, 1.0f);
+  BKE_curvemapping_set_defaults(&cmd->curve_mapping, 4, 0.0f, 0.0f, 1.0f, 1.0f);
 }
 
 static void curves_free_data(SequenceModifierData *smd)
 {
   CurvesModifierData *cmd = (CurvesModifierData *)smd;
 
-  curvemapping_free_data(&cmd->curve_mapping);
+  BKE_curvemapping_free_data(&cmd->curve_mapping);
 }
 
 static void curves_copy_data(SequenceModifierData *target, SequenceModifierData *smd)
@@ -308,7 +308,7 @@ static void curves_copy_data(SequenceModifierData *target, SequenceModifierData
   CurvesModifierData *cmd = (CurvesModifierData *)smd;
   CurvesModifierData *cmd_target = (CurvesModifierData *)target;
 
-  curvemapping_copy_data(&cmd_target->curve_mapping, &cmd->curve_mapping);
+  BKE_curvemapping_copy_data(&cmd_target->curve_mapping, &cmd->curve_mapping);
 }
 
 static void curves_apply_threaded(int width,
@@ -330,7 +330,7 @@ static void curves_apply_threaded(int width,
         float *pixel = rect_float + pixel_index;
         float result[3];
 
-        curvemapping_evaluate_premulRGBF(curve_mapping, result, pixel);
+        BKE_curvemapping_evaluate_premulRGBF(curve_mapping, result, pixel);
 
         if (mask_rect_float) {
           const float *m = mask_rect_float + pixel_index;
@@ -351,7 +351,7 @@ static void curves_apply_threaded(int width,
 
         straight_uchar_to_premul_float(tempc, pixel);
 
-        curvemapping_evaluate_premulRGBF(curve_mapping, result, tempc);
+        BKE_curvemapping_evaluate_premulRGBF(curve_mapping, result, tempc);
 
         if (mask_rect) {
           float t[3];
@@ -381,14 +381,14 @@ static void curves_apply(struct SequenceModifierData *smd, ImBuf *ibuf, ImBuf *m
   float black[3] = {0.0f, 0.0f, 0.0f};
   float white[3] = {1.0f, 1.0f, 1.0f};
 
-  curvemapping_initialize(&cmd->curve_mapping);
+  BKE_curvemapping_initialize(&cmd->curve_mapping);
 
-  curvemapping_premultiply(&cmd->curve_mapping, 0);
-  curvemapping_set_black_white(&cmd->curve_mapping, black, white);
+  BKE_curvemapping_premultiply(&cmd->curve_mapping, 0);
+  BKE_curvemapping_set_black_white(&cmd->curve_mapping, black, white);
 
   modifier_apply_threaded(ibuf, mask, curves_apply_threaded, &cmd->curve_mapping);
 
-  curvemapping_premultiply(&cmd->curve_mapping, 1);
+  BKE_curvemapping_premultiply(&cmd->curve_mapping, 1);
 }
 
 static SequenceModifierTypeInfo seqModifier_Curves = {
@@ -408,13 +408,13 @@ static void hue_correct_init_data(SequenceModifierData *smd)
   HueCorrectModifierData *hcmd = (HueCorrectModifierData *)smd;
   int c;
 
-  curvemapping_set_defaults(&hcmd->curve_mapping, 1, 0.0f, 0.0f, 1.0f, 1.0f);
+  BKE_curvemapping_set_defaults(&hcmd->curve_mapping, 1, 0.0f, 0.0f, 1.0f, 1.0f);
   hcmd->curve_mapping.preset = CURVE_PRESET_MID9;
 
   for (c = 0; c < 3; c++) {
     CurveMap *cuma = &hcmd->curve_mapping.cm[c];
 
-    curvemap_reset(
+    BKE_curvemap_reset(
         cuma, &hcmd->curve_mapping.clipr, hcmd->curve_mapping.preset, CURVEMAP_SLOPE_POSITIVE);
   }
 
@@ -426,7 +426,7 @@ static void hue_correct_free_data(SequenceModifierData *smd)
 {
   HueCorrectModifierData *hcmd = (HueCorrectModifierData *)smd;
 
-  curvemapping_free_data(&hcmd->curve_mapping);
+  BKE_curvemapping_free_data(&hcmd->curve_mapping);
 }
 
 static void hue_correct_copy_data(SequenceModifierData *target, SequenceModifierData *smd)
@@ -434,7 +434,7 @@ static void hue_correct_copy_data(SequenceModifierData *target, SequenceModifier
   HueCorrectModifierData *hcmd = (HueCorrectModifierData *)smd;
   HueCorrectModifierData *hcmd_target = (HueCorrectModifierData *)target;
 
-  curvemapping_copy_data(&hcmd_target->curve_mapping, &hcmd->curve_mapping);
+  BKE_curvemapping_copy_data(&hcmd_target->curve_mapping, &hcmd->curve_mapping);
 }
 
 static void hue_correct_apply_threaded(int width,
@@ -464,15 +464,15 @@ static void hue_correct_apply_threaded(int width,
       rgb_to_hsv(pixel[0], pixel[1], pixel[2], hsv, hsv + 1, hsv + 2);
 
       /* adjust hue, scaling returned default 0.5 up to 1 */
-      f = curvemapping_evaluateF(curve_mapping, 0, hsv[0]);
+      f = BKE_curvemapping_evaluateF(curve_mapping, 0, hsv[0]);
       hsv[0] += f - 0.5f;
 
       /* adjust saturation, scaling returned default 0.5 up to 1 */
-      f = curvemapping_evaluateF(curve_mapping, 1, hsv[0]);
+      f = BKE_curvemapping_evaluateF(curve_mapping, 1, hsv[0]);
       hsv[1] *= (f * 2.0f);
 
       /* adjust value, scaling returned default 0.5 up to 1 */
-      f = curvemapping_evaluateF(curve_mapping, 2, hsv[0]);
+      f = BKE_curvemapping_evaluateF(curve_mapping, 2, hsv[0]);
       hsv[2] *= (f * 2.f);
 
       hsv[0] = hsv[0] - floorf(hsv[0]); /* mod 1.0 */
@@ -506,7 +506,7 @@ static void hue_correct_apply(struct SequenceModifierData *smd, ImBuf *ibuf, ImB
 {
   HueCorrectModifierData *hcmd = (HueCorrectModifierData *)smd;
 
-  curvemapping_initialize(&hcmd->curve_mapping);
+  BKE_curvemapping_initialize(&hcmd->curve_mapping);
 
   modifier_apply_threaded(ibuf, mask, hue_correct_apply_threaded, &hcmd->curve_mapping);
 }
diff --git a/source/blender/blenkernel/intern/smoke.c b/source/blender/blenkernel/intern/smoke.c
index 688af539bbb..74873db179d 100644
--- a/source/blender/blenkernel/intern/smoke.c
+++ b/source/blender/blenkernel/intern/smoke.c
@@ -1428,13 +1428,13 @@ static void emit_from_particles(Object *flow_ob,
 
     /* prepare curvemapping tables */
     if ((psys->part->child_flag & PART_CHILD_USE_CLUMP_CURVE) && psys->part->clumpcurve) {
-      curvemapping_changed_all(psys->part->clumpcurve);
+      BKE_curvemapping_changed_all(psys->part->clumpcurve);
     }
     if ((psys->part->child_flag & PART_CHILD_USE_ROUGH_CURVE) && psys->part->roughcurve) {
-      curvemapping_changed_all(psys->part->roughcurve);
+      BKE_curvemapping_changed_all(psys->part->roughcurve);
     }
     if ((psys->part->child_flag & PART_CHILD_USE_TWIST_CURVE) && psys->part->twistcurve) {
-      curvemapping_changed_all(psys->part->twistcurve);
+      BKE_curvemapping_changed_all(psys->part->twistcurve);
     }
 
     /* initialize particle cache */
diff --git a/source/blender/blenkernel/intern/texture.c b/source/blender/blenkernel/intern/texture.c
index 9baa8bd20e1..ad7c5e3f660 100644
--- a/source/blender/blenkernel/intern/texture.c
+++ b/source/blender/blenkernel/intern/texture.c
@@ -659,15 +659,15 @@ void BKE_texture_pointdensity_init_data(PointDensity *pd)
   pd->object = NULL;
   pd->psys = 0;
   pd->psys_cache_space = TEX_PD_WORLDSPACE;
-  pd->falloff_curve = curvemapping_add(1, 0, 0, 1, 1);
+  pd->falloff_curve = BKE_curvemapping_add(1, 0, 0, 1, 1);
 
   pd->falloff_curve->preset = CURVE_PRESET_LINE;
   pd->falloff_curve->cm->flag &= ~CUMA_EXTEND_EXTRAPOLATE;
-  curvemap_reset(pd->falloff_curve->cm,
-                 &pd->falloff_curve->clipr,
-                 pd->falloff_curve->preset,
-                 CURVEMAP_SLOPE_POSITIVE);
-  curvemapping_changed(pd->falloff_curve, false);
+  BKE_curvemap_reset(pd->falloff_curve->cm,
+                     &pd->falloff_curve->clipr,
+                     pd->falloff_curve->preset,
+                     CURVEMAP_SLOPE_POSITIVE);
+  BKE_curvemapping_changed(pd->falloff_curve, false);
 }
 
 PointDensity *BKE_texture_pointdensity_add(void)
@@ -687,7 +687,7 @@ PointDensity *BKE_texture_pointdensity_copy(const PointDensity *pd, const int UN
   if (pdn->coba) {
     pdn->coba = MEM_dupallocN(pdn->coba);
   }
-  pdn->falloff_curve = curvemapping_copy(pdn->falloff_curve); /* can be NULL */
+  pdn->falloff_curve = BKE_curvemapping_copy(pdn->falloff_curve); /* can be NULL */
   return pdn;
 }
 
@@ -706,7 +706,7 @@ void BKE_texture_pointdensity_free_data(PointDensity *pd)
     pd->coba = NULL;
   }
 
-  curvemapping_free(pd->falloff_curve); /* can be NULL */
+  BKE_curvemapping_free(pd->falloff_curve); /* can be NULL */
 }
 
 void BKE_texture_pointdensity_free(PointDensity *pd)