Drivers: add lerp and clamp functions to namespace.

Implementation of lerp without a function requires repeating one of
the arguments, which is not ideal. To avoid that, add a new function
to the driver namespace. In addition, provide a function for clamping
between 0 and 1 to support easy clamped lerp, and a smoothstep function
from GLSL that is somewhat related.

The function implementations are added to a new bl_math module.
As an aside, add the round function and two-argument log to the
pylike expression subset.

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

5 files changed, 211 insertions, 0 deletions

diff --git a/source/blender/python/generic/CMakeLists.txt b/source/blender/python/generic/CMakeLists.txt
index 822f05bad90..785c1d66407 100644
--- a/source/blender/python/generic/CMakeLists.txt
+++ b/source/blender/python/generic/CMakeLists.txt
@@ -36,12 +36,14 @@ set(SRC
   bpy_threads.c
   idprop_py_api.c
   imbuf_py_api.c
+  bl_math_py_api.c
   py_capi_utils.c
 
   bgl.h
   blf_py_api.h
   idprop_py_api.h
   imbuf_py_api.h
+  bl_math_py_api.h
   py_capi_utils.h
 
   # header-only
diff --git a/source/blender/python/generic/bl_math_py_api.c b/source/blender/python/generic/bl_math_py_api.c
new file mode 100644
index 00000000000..4d5a63ffba3
--- /dev/null
+++ b/source/blender/python/generic/bl_math_py_api.c
@@ -0,0 +1,163 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+/**
+ * \file
+ * \ingroup pygen
+ *
+ * This file defines the 'bl_math' module, a module for math utilities.
+ */
+
+#include <Python.h>
+
+#include "BLI_math.h"
+#include "BLI_utildefines.h"
+
+#include "py_capi_utils.h"
+
+#include "bl_math_py_api.h"
+
+/*------------------------------------------------------------*/
+/**
+ * \name Module doc string
+ * \{ */
+
+PyDoc_STRVAR(M_Math_doc, "Miscellaneous math utilities module");
+
+/** \} */
+/*------------------------------------------------------------*/
+/**
+ * \name Python functions
+ * \{ */
+
+PyDoc_STRVAR(M_Math_clamp_doc,
+             ".. function:: clamp(value, min=0, max=1)\n"
+             "\n"
+             "   Clamps the float value between minimum and maximum. To avoid\n"
+             "   confusion, any call must use either one or all three arguments.\n"
+             "\n"
+             "   :arg value: The value to clamp.\n"
+             "   :type value: float\n"
+             "   :arg min: The minimum value, defaults to 0.\n"
+             "   :type min: float\n"
+             "   :arg max: The maximum value, defaults to 1.\n"
+             "   :type max: float\n"
+             "   :return: The clamped value.\n"
+             "   :rtype: float\n");
+static PyObject *M_Math_clamp(PyObject *UNUSED(self), PyObject *args)
+{
+  double x, minv = 0.0, maxv = 1.0;
+
+  if (PyTuple_Size(args) <= 1) {
+    if (!PyArg_ParseTuple(args, "d:clamp", &x)) {
+      return NULL;
+    }
+  }
+  else {
+    if (!PyArg_ParseTuple(args, "ddd:clamp", &x, &minv, &maxv)) {
+      return NULL;
+    }
+  }
+
+  CLAMP(x, minv, maxv);
+
+  return PyFloat_FromDouble(x);
+}
+
+PyDoc_STRVAR(M_Math_lerp_doc,
+             ".. function:: lerp(from, to, factor)\n"
+             "\n"
+             "   Linearly interpolate between two float values based on factor.\n"
+             "\n"
+             "   :arg from: The value to return when factor is 0.\n"
+             "   :type from: float\n"
+             "   :arg to: The value to return when factor is 1.\n"
+             "   :type to: float\n"
+             "   :arg factor: The interpolation value, normally in [0.0, 1.0].\n"
+             "   :type factor: float\n"
+             "   :return: The interpolated value.\n"
+             "   :rtype: float\n");
+static PyObject *M_Math_lerp(PyObject *UNUSED(self), PyObject *args)
+{
+  double a, b, x;
+  if (!PyArg_ParseTuple(args, "ddd:lerp", &a, &b, &x)) {
+    return NULL;
+  }
+
+  return PyFloat_FromDouble(a * (1.0 - x) + b * x);
+}
+
+PyDoc_STRVAR(
+    M_Math_smoothstep_doc,
+    ".. function:: smoothstep(from, to, value)\n"
+    "\n"
+    "   Performs smooth interpolation between 0 and 1 as value changes between from and to.\n"
+    "   Outside the range the function returns the same value as the nearest edge.\n"
+    "\n"
+    "   :arg from: The edge value where the result is 0.\n"
+    "   :type from: float\n"
+    "   :arg to: The edge value where the result is 1.\n"
+    "   :type to: float\n"
+    "   :arg factor: The interpolation value.\n"
+    "   :type factor: float\n"
+    "   :return: The interpolated value in [0.0, 1.0].\n"
+    "   :rtype: float\n");
+static PyObject *M_Math_smoothstep(PyObject *UNUSED(self), PyObject *args)
+{
+  double a, b, x;
+  if (!PyArg_ParseTuple(args, "ddd:smoothstep", &a, &b, &x)) {
+    return NULL;
+  }
+
+  double t = (x - a) / (b - a);
+
+  CLAMP(t, 0.0, 1.0);
+
+  return PyFloat_FromDouble(t * t * (3.0 - 2.0 * t));
+}
+
+/** \} */
+/*------------------------------------------------------------*/
+/**
+ * \name Module definition
+ * \{ */
+
+static PyMethodDef M_Math_methods[] = {
+    {"clamp", (PyCFunction)M_Math_clamp, METH_VARARGS, M_Math_clamp_doc},
+    {"lerp", (PyCFunction)M_Math_lerp, METH_VARARGS, M_Math_lerp_doc},
+    {"smoothstep", (PyCFunction)M_Math_smoothstep, METH_VARARGS, M_Math_smoothstep_doc},
+    {NULL, NULL, 0, NULL},
+};
+
+static struct PyModuleDef M_Math_module_def = {
+    PyModuleDef_HEAD_INIT,
+    "bl_math",      /* m_name */
+    M_Math_doc,     /* m_doc */
+    0,              /* m_size */
+    M_Math_methods, /* m_methods */
+    NULL,           /* m_reload */
+    NULL,           /* m_traverse */
+    NULL,           /* m_clear */
+    NULL,           /* m_free */
+};
+
+PyMODINIT_FUNC BPyInit_bl_math(void)
+{
+  PyObject *submodule = PyModule_Create(&M_Math_module_def);
+  return submodule;
+}
+
+/** \} */
diff --git a/source/blender/python/generic/bl_math_py_api.h b/source/blender/python/generic/bl_math_py_api.h
new file mode 100644
index 00000000000..9183573abfc
--- /dev/null
+++ b/source/blender/python/generic/bl_math_py_api.h
@@ -0,0 +1,27 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+/**
+ * \file
+ * \ingroup pygen
+ */
+
+#ifndef __BL_MATH_PY_API_H__
+#define __BL_MATH_PY_API_H__
+
+PyMODINIT_FUNC BPyInit_bl_math(void);
+
+#endif /* __BL_MATH_PY_API_H__ */
diff --git a/source/blender/python/intern/bpy_driver.c b/source/blender/python/intern/bpy_driver.c
index 3d83eb90da6..5e2162c9e2d 100644
--- a/source/blender/python/intern/bpy_driver.c
+++ b/source/blender/python/intern/bpy_driver.c
@@ -114,6 +114,19 @@ int bpy_pydriver_create_dict(void)
     Py_DECREF(mod);
   }
 
+  /* Add math utility functions. */
+  mod = PyImport_ImportModuleLevel("bl_math", NULL, NULL, NULL, 0);
+  if (mod) {
+    static const char *names[] = {"clamp", "lerp", "smoothstep", NULL};
+
+    for (const char **pname = names; *pname; ++pname) {
+      PyObject *func = PyDict_GetItemString(PyModule_GetDict(mod), *pname);
+      PyDict_SetItemString(bpy_pydriver_Dict, *pname, func);
+    }
+
+    Py_DECREF(mod);
+  }
+
 #ifdef USE_BYTECODE_WHITELIST
   /* setup the whitelist */
   {
@@ -133,6 +146,10 @@ int bpy_pydriver_create_dict(void)
         "bool",
         "float",
         "int",
+        /* bl_math */
+        "clamp",
+        "lerp",
+        "smoothstep",
 
         NULL,
     };
diff --git a/source/blender/python/intern/bpy_interface.c b/source/blender/python/intern/bpy_interface.c
index ed5e505176c..a880d2cd285 100644
--- a/source/blender/python/intern/bpy_interface.c
+++ b/source/blender/python/intern/bpy_interface.c
@@ -68,6 +68,7 @@
 /* inittab initialization functions */
 #include "../bmesh/bmesh_py_api.h"
 #include "../generic/bgl.h"
+#include "../generic/bl_math_py_api.h"
 #include "../generic/blf_py_api.h"
 #include "../generic/idprop_py_api.h"
 #include "../generic/imbuf_py_api.h"
@@ -228,6 +229,7 @@ static struct _inittab bpy_internal_modules[] = {
     {"_bpy_path", BPyInit__bpy_path},
     {"bgl", BPyInit_bgl},
     {"blf", BPyInit_blf},
+    {"bl_math", BPyInit_bl_math},
     {"imbuf", BPyInit_imbuf},
     {"bmesh", BPyInit_bmesh},
 #if 0