Drivers: "Scripted Expression" drivers (i.e. PyDrivers) work again

Now it is possible to write a Python Expression using the variable names for driver targets (see mockup from initial commit) to substitute the appropriate values into the expression.

In the __global__ namespace for PyDriver evaluation, the following modules are available:
* __builtins__ - i.e. the builtin Python functions
* bpy - new Python API
* math or m - math module

For example:
Consider a driver with three targets, named: A, B, C
Now, you could write an expression like:
   C if A < 5 else B
or even:
   2*C if A < 5 or A > 20 else m.PI*B

Of course, you don't have to have three targets, the above was just an example.

TODO:
* Bring back way to load pydrivers.py
* Blender.Noise equivalent would be nice to have

P.S.  I hope I haven't made any terrible Python API coding errors here (i.e. mem leaks, etc.)

1 files changed, 199 insertions, 0 deletions

diff --git a/source/blender/python/intern/bpy_interface.c b/source/blender/python/intern/bpy_interface.c
index ecf1cc828f3..86406134253 100644
--- a/source/blender/python/intern/bpy_interface.c
+++ b/source/blender/python/intern/bpy_interface.c
@@ -20,6 +20,7 @@
 #include "bpy_operator.h"
 #include "bpy_ui.h"
 
+#include "DNA_anim_types.h"
 #include "DNA_space_types.h"
 #include "DNA_text_types.h"
 
@@ -29,6 +30,7 @@
 #include "BLI_string.h"
 
 #include "BKE_context.h"
+#include "BKE_fcurve.h"
 #include "BKE_text.h"
 
 #include "BPY_extern.h"
@@ -415,3 +417,200 @@ void BPY_run_ui_scripts(bContext *C)
 #endif
 }
 
+/* ****************************************** */
+/* Drivers - PyExpression Evaluation */
+// XXX Hopefully I haven't committed any PyAPI coding sins here ;)  - Aligorith, 2009Apr20
+
+/* for pydrivers (drivers using one-line Python expressions to express relationships between targets) */
+PyObject *bpy_pydriver_Dict = NULL;
+
+/* For faster execution we keep a special dictionary for pydrivers, with
+ * the needed modules and aliases. 
+ */
+static int bpy_pydriver_create_dict(void)
+{
+	PyObject *d, *mod;
+	
+	/* validate namespace for driver evaluation */
+	if (bpy_pydriver_Dict) return -1;
+
+	d = PyDict_New();
+	if (d == NULL) 
+		return -1;
+	else
+		bpy_pydriver_Dict = d;
+
+	/* import some modules: builtins, bpy, math, (Blender.noise )*/
+	PyDict_SetItemString(d, "__builtins__", PyEval_GetBuiltins());
+
+	mod = PyImport_ImportModule("math");
+	if (mod) {
+		PyDict_Merge(d, PyModule_GetDict(mod), 0); /* 0 - dont overwrite existing values */
+		
+		/* Only keep for backwards compat! - just import all math into root, they are standard */
+		PyDict_SetItemString(d, "math", mod);
+		PyDict_SetItemString(d, "m", mod);
+		Py_DECREF(mod);
+	} 
+	
+	/* add bpy to global namespace */
+	mod= PyImport_ImportModuleLevel("bpy", NULL, NULL, NULL, 0);
+	if (mod) {
+		PyDict_SetItemString(bpy_pydriver_Dict, "bpy", mod);
+		Py_DECREF(mod);
+	}
+	
+	
+#if 0 // non existant yet
+	mod = PyImport_ImportModule("Blender.Noise");
+	if (mod) {
+		PyDict_SetItemString(d, "noise", mod);
+		PyDict_SetItemString(d, "n", mod);
+		Py_DECREF(mod);
+	} else {
+		PyErr_Clear();
+	}
+	
+	/* If there's a Blender text called pydrivers.py, import it.
+	 * Users can add their own functions to this module. 
+	 */
+	if (G.f & G_DOSCRIPTLINKS) {
+		mod = importText("pydrivers"); /* can also use PyImport_Import() */
+		if (mod) {
+			PyDict_SetItemString(d, "pydrivers", mod);
+			PyDict_SetItemString(d, "p", mod);
+			Py_DECREF(mod);
+		} else {
+			PyErr_Clear();
+		}
+	}
+#endif // non existant yet
+	
+	return 0;
+}
+
+/* Update function, it gets rid of pydrivers global dictionary, forcing
+ * BPY_pydriver_eval to recreate it. This function is used to force
+ * reloading the Blender text module "pydrivers.py", if available, so
+ * updates in it reach pydriver evaluation. 
+ */
+void BPY_pydriver_update(void)
+{
+	PyGILState_STATE gilstate = PyGILState_Ensure();
+
+	if (bpy_pydriver_Dict) { /* free the global dict used by pydrivers */
+		PyDict_Clear(bpy_pydriver_Dict);
+		Py_DECREF(bpy_pydriver_Dict);
+		bpy_pydriver_Dict = NULL;
+	}
+
+	PyGILState_Release(gilstate);
+
+	return;
+}
+
+/* error return function for BPY_eval_pydriver */
+static float pydriver_error(ChannelDriver *driver) 
+{
+	if (bpy_pydriver_Dict) { /* free the global dict used by pydrivers */
+		PyDict_Clear(bpy_pydriver_Dict);
+		Py_DECREF(bpy_pydriver_Dict);
+		bpy_pydriver_Dict = NULL;
+	}
+
+	driver->flag |= DRIVER_FLAG_INVALID; /* py expression failed */
+	fprintf(stderr, "\nError in Driver: The following Python expression failed:\n\t'%s'\n\n", driver->expression);
+	
+	PyErr_Print();
+
+	return 0.0f;
+}
+
+/* This evals py driver expressions, 'expr' is a Python expression that
+ * should evaluate to a float number, which is returned. 
+ */
+float BPY_pydriver_eval (ChannelDriver *driver)
+{
+	PyObject *driver_vars=NULL;
+	PyObject *retval;
+	PyGILState_STATE gilstate;
+	
+	DriverTarget *dtar;
+	float result = 0.0f; /* default return */
+	char *expr = NULL;
+	short targets_ok= 1;
+	
+	/* sanity checks - should driver be executed? */
+	if ((driver == NULL) /*|| (G.f & G_DOSCRIPTLINKS)==0*/) 
+		return result;
+	
+	/* get the py expression to be evaluated */
+	expr = driver->expression; 
+	if ((expr == NULL) || (expr[0]=='\0')) 
+		return result;
+
+	gilstate = PyGILState_Ensure();
+	
+	/* init global dictionary for py-driver evaluation settings */
+	if (!bpy_pydriver_Dict) {
+		if (bpy_pydriver_create_dict() != 0) {
+			fprintf(stderr, "Pydriver error: couldn't create Python dictionary");
+			PyGILState_Release(gilstate);
+			return result;
+		}
+	}
+	
+	/* add target values to a py dictionary that we add to the drivers dict as 'd' */
+	driver_vars = PyDict_New(); // XXX do we need to decref this?
+	for (dtar= driver->targets.first; dtar; dtar= dtar->next) {
+		PyObject *driver_arg = NULL;
+		float tval = 0.0f;
+		
+		/* try to get variable value */
+		tval= driver_get_target_value(driver, dtar);
+		driver_arg= PyFloat_FromDouble((double)tval);
+		if (driver_arg == NULL) continue;
+		
+		/* try to add to dictionary */
+		if (PyDict_SetItemString(driver_vars, dtar->name, driver_arg)) {
+			/* this target failed */
+			if (targets_ok) {
+				/* first one - print some extra info for easier identification */
+				fprintf(stderr, "\nBPY_pydriver_eval() - Error while evaluating PyDriver:\n");
+				targets_ok= 0;
+			}
+			
+			fprintf(stderr, "\tBPY_pydriver_eval() - couldn't add variable '%s' to namespace \n", dtar->name);
+			PyErr_Print();
+		}
+	}
+	
+	/* execute expression to get a value */
+	retval = PyRun_String(expr, Py_eval_input, bpy_pydriver_Dict, driver_vars);
+	
+	/* decref the driver vars first...  */
+	Py_DECREF(driver_vars);
+	
+	/* process the result */
+	if (retval == NULL) {
+		result = pydriver_error(driver);
+		PyGILState_Release(gilstate);
+		return result;
+	}
+
+	result = (float)PyFloat_AsDouble(retval);
+	Py_DECREF(retval);
+	
+	if ((result == -1) && PyErr_Occurred()) {
+		result = pydriver_error(driver);
+		PyGILState_Release(gilstate);
+		return result;
+	}
+	
+	/* all fine, make sure the "invalid expression" flag is cleared */
+	driver->flag &= ~DRIVER_FLAG_INVALID;
+
+	PyGILState_Release(gilstate);
+
+	return result;
+}