Depsgraph: remove EvaluationContext, pass Depsgraph instead.

The depsgraph was always created within a fixed evaluation context. Passing
both risks the depsgraph and evaluation context not matching, and it
complicates the Python API where we'd have to expose both which is not so
easy to understand.

This also removes the global evaluation context in main, which assumed there
to be a single active scene and view layer.

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

1 files changed, 14 insertions, 14 deletions

diff --git a/source/blender/blenkernel/intern/constraint.c b/source/blender/blenkernel/intern/constraint.c
index a759d0fa3f2..eca789b0f87 100644
--- a/source/blender/blenkernel/intern/constraint.c
+++ b/source/blender/blenkernel/intern/constraint.c
@@ -684,7 +684,7 @@ static bConstraintTypeInfo CTI_CONSTRNAME = {
 /* This function should be used for the get_target_matrix member of all 
  * constraints that are not picky about what happens to their target matrix.
  */
-static void default_get_tarmat(const struct EvaluationContext *UNUSED(eval_ctx), bConstraint *con, bConstraintOb *UNUSED(cob), bConstraintTarget *ct, float UNUSED(ctime))
+static void default_get_tarmat(struct Depsgraph *UNUSED(depsgraph), bConstraint *con, bConstraintOb *UNUSED(cob), bConstraintTarget *ct, float UNUSED(ctime))
 {
 	if (VALID_CONS_TARGET(ct))
 		constraint_target_to_mat4(ct->tar, ct->subtarget, ct->matrix, CONSTRAINT_SPACE_WORLD, ct->space, con->flag, con->headtail);
@@ -1153,7 +1153,7 @@ static void kinematic_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
 	}
 }
 
-static void kinematic_get_tarmat(const struct EvaluationContext *UNUSED(eval_ctx), bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime))
+static void kinematic_get_tarmat(struct Depsgraph *UNUSED(depsgraph), bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime))
 {
 	bKinematicConstraint *data = con->data;
 	
@@ -1240,7 +1240,7 @@ static void followpath_flush_tars(bConstraint *con, ListBase *list, bool no_copy
 	}
 }
 
-static void followpath_get_tarmat(const struct EvaluationContext *UNUSED(eval_ctx),
+static void followpath_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
                                   bConstraint *con, bConstraintOb *UNUSED(cob),
                                   bConstraintTarget *ct, float UNUSED(ctime))
 {
@@ -2019,7 +2019,7 @@ static void pycon_id_looper(bConstraint *con, ConstraintIDFunc func, void *userd
 }
 
 /* Whether this approach is maintained remains to be seen (aligorith) */
-static void pycon_get_tarmat(const struct EvaluationContext *UNUSED(eval_ctx),
+static void pycon_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
                              bConstraint *con, bConstraintOb *UNUSED(cob),
                              bConstraintTarget *ct, float UNUSED(ctime))
 {
@@ -2135,7 +2135,7 @@ static void actcon_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
 	}
 }
 
-static void actcon_get_tarmat(const struct EvaluationContext *UNUSED(eval_ctx), bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime))
+static void actcon_get_tarmat(struct Depsgraph *UNUSED(depsgraph), bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime))
 {
 	bActionConstraint *data = con->data;
 	
@@ -3124,7 +3124,7 @@ static void clampto_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
 	}
 }
 
-static void clampto_get_tarmat(const struct EvaluationContext *UNUSED(eval_ctx),
+static void clampto_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
                                bConstraint *UNUSED(con), bConstraintOb *UNUSED(cob),
                                bConstraintTarget *ct, float UNUSED(ctime))
 {
@@ -3461,7 +3461,7 @@ static void shrinkwrap_flush_tars(bConstraint *con, ListBase *list, bool no_copy
 }
 
 
-static void shrinkwrap_get_tarmat(const struct EvaluationContext *UNUSED(eval_ctx), bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime))
+static void shrinkwrap_get_tarmat(struct Depsgraph *UNUSED(depsgraph), bConstraint *con, bConstraintOb *cob, bConstraintTarget *ct, float UNUSED(ctime))
 {
 	bShrinkwrapConstraint *scon = (bShrinkwrapConstraint *) con->data;
 	
@@ -3793,7 +3793,7 @@ static void splineik_flush_tars(bConstraint *con, ListBase *list, bool no_copy)
 	}
 }
 
-static void splineik_get_tarmat(const struct EvaluationContext *UNUSED(eval_ctx),
+static void splineik_get_tarmat(struct Depsgraph *UNUSED(depsgraph),
                                 bConstraint *UNUSED(con), bConstraintOb *UNUSED(cob),
                                 bConstraintTarget *ct, float UNUSED(ctime))
 {
@@ -4845,7 +4845,7 @@ bool BKE_constraints_proxylocked_owner(Object *ob, bPoseChannel *pchan)
  * None of the actual calculations of the matrices should be done here! Also, this function is
  * not to be used by any new constraints, particularly any that have multiple targets.
  */
-void BKE_constraint_target_matrix_get(const struct EvaluationContext *eval_ctx, Scene *scene, bConstraint *con, int index, short ownertype, void *ownerdata, float mat[4][4], float ctime)
+void BKE_constraint_target_matrix_get(struct Depsgraph *depsgraph, Scene *scene, bConstraint *con, int index, short ownertype, void *ownerdata, float mat[4][4], float ctime)
 {
 	const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
 	ListBase targets = {NULL, NULL};
@@ -4896,7 +4896,7 @@ void BKE_constraint_target_matrix_get(const struct EvaluationContext *eval_ctx,
 		
 		if (ct) {
 			if (cti->get_target_matrix)
-				cti->get_target_matrix(eval_ctx, con, cob, ct, ctime);
+				cti->get_target_matrix(depsgraph, con, cob, ct, ctime);
 			copy_m4_m4(mat, ct->matrix);
 		}
 		
@@ -4912,7 +4912,7 @@ void BKE_constraint_target_matrix_get(const struct EvaluationContext *eval_ctx,
 }
 
 /* Get the list of targets required for solving a constraint */
-void BKE_constraint_targets_for_solving_get(const struct EvaluationContext *eval_ctx, bConstraint *con, bConstraintOb *cob, ListBase *targets, float ctime)
+void BKE_constraint_targets_for_solving_get(struct Depsgraph *depsgraph, bConstraint *con, bConstraintOb *cob, ListBase *targets, float ctime)
 {
 	const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
 	
@@ -4930,7 +4930,7 @@ void BKE_constraint_targets_for_solving_get(const struct EvaluationContext *eval
 		 */
 		if (cti->get_target_matrix) {
 			for (ct = targets->first; ct; ct = ct->next)
-				cti->get_target_matrix(eval_ctx, con, cob, ct, ctime);
+				cti->get_target_matrix(depsgraph, con, cob, ct, ctime);
 		}
 		else {
 			for (ct = targets->first; ct; ct = ct->next)
@@ -4947,7 +4947,7 @@ void BKE_constraint_targets_for_solving_get(const struct EvaluationContext *eval
  * BKE_constraints_make_evalob and BKE_constraints_clear_evalob should be called before and 
  * after running this function, to sort out cob
  */
-void BKE_constraints_solve(const struct EvaluationContext *eval_ctx, ListBase *conlist, bConstraintOb *cob, float ctime)
+void BKE_constraints_solve(struct Depsgraph *depsgraph, ListBase *conlist, bConstraintOb *cob, float ctime)
 {
 	bConstraint *con;
 	float oldmat[4][4];
@@ -4982,7 +4982,7 @@ void BKE_constraints_solve(const struct EvaluationContext *eval_ctx, ListBase *c
 		BKE_constraint_mat_convertspace(cob->ob, cob->pchan, cob->matrix, CONSTRAINT_SPACE_WORLD, con->ownspace, false);
 		
 		/* prepare targets for constraint solving */
-		BKE_constraint_targets_for_solving_get(eval_ctx, con, cob, &targets, ctime);
+		BKE_constraint_targets_for_solving_get(depsgraph, con, cob, &targets, ctime);
 		
 		/* Solve the constraint and put result in cob->matrix */
 		cti->evaluate_constraint(con, cob, &targets);