Merge branch 'master' into blender2.8

16 files changed, 4024 insertions, 42 deletions

diff --git a/source/blender/blenkernel/BKE_fcurve.h b/source/blender/blenkernel/BKE_fcurve.h
index 0b7ffb338d8..f6490930530 100644
--- a/source/blender/blenkernel/BKE_fcurve.h
+++ b/source/blender/blenkernel/BKE_fcurve.h
@@ -72,14 +72,14 @@ void bezt_add_to_cfra_elem(ListBase *lb, struct BezTriple *bezt);
  */
 
 /* convenience looper over ALL driver targets for a given variable (even the unused ones) */
-#define DRIVER_TARGETS_LOOPER(dvar) \
+#define DRIVER_TARGETS_LOOPER_BEGIN(dvar) \
 	{ \
 		DriverTarget *dtar = &dvar->targets[0]; \
 		int tarIndex = 0; \
 		for (; tarIndex < MAX_DRIVER_TARGETS; tarIndex++, dtar++)
 
 /* convenience looper over USED driver targets only */
-#define DRIVER_TARGETS_USED_LOOPER(dvar) \
+#define DRIVER_TARGETS_USED_LOOPER_BEGIN(dvar) \
 	{ \
 		DriverTarget *dtar = &dvar->targets[0]; \
 		int tarIndex = 0; \
@@ -87,7 +87,7 @@ void bezt_add_to_cfra_elem(ListBase *lb, struct BezTriple *bezt);
 
 /* tidy up for driver targets loopers */
 #define DRIVER_TARGETS_LOOPER_END \
-}
+} ((void)0)
 
 /* ---------------------- */
 
diff --git a/source/blender/blenkernel/intern/anim_sys.c b/source/blender/blenkernel/intern/anim_sys.c
index 7693485e042..8e8000f3ea0 100644
--- a/source/blender/blenkernel/intern/anim_sys.c
+++ b/source/blender/blenkernel/intern/anim_sys.c
@@ -405,13 +405,13 @@ void BKE_animdata_merge_copy(
 				DriverVar *dvar;
 
 				for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
-					DRIVER_TARGETS_USED_LOOPER(dvar)
+					DRIVER_TARGETS_USED_LOOPER_BEGIN(dvar)
 					{
 						if (dtar->id == src_id) {
 							dtar->id = dst_id;
 						}
 					}
-					DRIVER_TARGETS_LOOPER_END
+					DRIVER_TARGETS_LOOPER_END;
 				}
 			}
 		}
@@ -754,7 +754,7 @@ static void drivers_path_rename_fix(ID *owner_id, ID *ref_id, const char *prefix
 			/* driver variables */
 			for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
 				/* only change the used targets, since the others will need fixing manually anyway */
-				DRIVER_TARGETS_USED_LOOPER(dvar)
+				DRIVER_TARGETS_USED_LOOPER_BEGIN(dvar)
 				{
 					/* rename RNA path */
 					if (dtar->rna_path && dtar->id)
@@ -769,7 +769,7 @@ static void drivers_path_rename_fix(ID *owner_id, ID *ref_id, const char *prefix
 						}
 					}
 				}
-				DRIVER_TARGETS_LOOPER_END
+				DRIVER_TARGETS_LOOPER_END;
 			}
 		}
 	}
diff --git a/source/blender/blenkernel/intern/depsgraph.c b/source/blender/blenkernel/intern/depsgraph.c
new file mode 100644
index 00000000000..15d08f5a230
--- /dev/null
+++ b/source/blender/blenkernel/intern/depsgraph.c
@@ -0,0 +1,3745 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * 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.
+ *
+ * The Original Code is Copyright (C) 2004 Blender Foundation.
+ * All rights reserved.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/blenkernel/intern/depsgraph.c
+ *  \ingroup bke
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "MEM_guardedalloc.h"
+
+#ifdef WIN32
+#  include "BLI_winstuff.h"
+#endif
+
+#include "BLI_utildefines.h"
+#include "BLI_listbase.h"
+#include "BLI_ghash.h"
+#include "BLI_threads.h"
+
+#include "DNA_anim_types.h"
+#include "DNA_camera_types.h"
+#include "DNA_cachefile_types.h"
+#include "DNA_group_types.h"
+#include "DNA_lamp_types.h"
+#include "DNA_lattice_types.h"
+#include "DNA_key_types.h"
+#include "DNA_material_types.h"
+#include "DNA_mesh_types.h"
+#include "DNA_node_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_screen_types.h"
+#include "DNA_windowmanager_types.h"
+#include "DNA_movieclip_types.h"
+#include "DNA_mask_types.h"
+#include "DNA_modifier_types.h"
+#include "DNA_rigidbody_types.h"
+
+#include "BKE_anim.h"
+#include "BKE_animsys.h"
+#include "BKE_action.h"
+#include "BKE_DerivedMesh.h"
+#include "BKE_collision.h"
+#include "BKE_curve.h"
+#include "BKE_effect.h"
+#include "BKE_fcurve.h"
+#include "BKE_global.h"
+#include "BKE_idcode.h"
+#include "BKE_image.h"
+#include "BKE_key.h"
+#include "BKE_library.h"
+#include "BKE_main.h"
+#include "BKE_node.h"
+#include "BKE_material.h"
+#include "BKE_mball.h"
+#include "BKE_modifier.h"
+#include "BKE_object.h"
+#include "BKE_paint.h"
+#include "BKE_particle.h"
+#include "BKE_pointcache.h"
+#include "BKE_scene.h"
+#include "BKE_screen.h"
+#include "BKE_tracking.h"
+
+#include "GPU_buffers.h"
+
+#include "atomic_ops.h"
+
+#include "depsgraph_private.h"
+
+#include "DEG_depsgraph.h"
+#include "DEG_depsgraph_build.h"
+#include "DEG_depsgraph_debug.h"
+#include "DEG_depsgraph_query.h"
+
+#ifdef WITH_LEGACY_DEPSGRAPH
+
+static SpinLock threaded_update_lock;
+
+void DAG_init(void)
+{
+	BLI_spin_init(&threaded_update_lock);
+	DEG_register_node_types();
+}
+
+void DAG_exit(void)
+{
+	BLI_spin_end(&threaded_update_lock);
+	DEG_free_node_types();
+}
+
+/* Queue and stack operations for dag traversal
+ *
+ * the queue store a list of freenodes to avoid successive alloc/dealloc
+ */
+
+DagNodeQueue *queue_create(int slots)
+{
+	DagNodeQueue *queue;
+	DagNodeQueueElem *elem;
+	int i;
+
+	queue = MEM_mallocN(sizeof(DagNodeQueue), "DAG queue");
+	queue->freenodes = MEM_mallocN(sizeof(DagNodeQueue), "DAG queue");
+	queue->count = 0;
+	queue->maxlevel = 0;
+	queue->first = queue->last = NULL;
+	elem = MEM_mallocN(sizeof(DagNodeQueueElem), "DAG queue elem3");
+	elem->node = NULL;
+	elem->next = NULL;
+	queue->freenodes->first = queue->freenodes->last = elem;
+
+	for (i = 1; i < slots; i++) {
+		elem = MEM_mallocN(sizeof(DagNodeQueueElem), "DAG queue elem4");
+		elem->node = NULL;
+		elem->next = NULL;
+		queue->freenodes->last->next = elem;
+		queue->freenodes->last = elem;
+	}
+	queue->freenodes->count = slots;
+	return queue;
+}
+
+void queue_raz(DagNodeQueue *queue)
+{
+	DagNodeQueueElem *elem;
+
+	elem = queue->first;
+	if (queue->freenodes->last)
+		queue->freenodes->last->next = elem;
+	else
+		queue->freenodes->first = queue->freenodes->last = elem;
+
+	elem->node = NULL;
+	queue->freenodes->count++;
+	while (elem->next) {
+		elem = elem->next;
+		elem->node = NULL;
+		queue->freenodes->count++;
+	}
+	queue->freenodes->last = elem;
+	queue->count = 0;
+}
+
+void queue_delete(DagNodeQueue *queue)
+{
+	DagNodeQueueElem *elem;
+	DagNodeQueueElem *temp;
+
+	elem = queue->first;
+	while (elem) {
+		temp = elem;
+		elem = elem->next;
+		MEM_freeN(temp);
+	}
+
+	elem = queue->freenodes->first;
+	while (elem) {
+		temp = elem;
+		elem = elem->next;
+		MEM_freeN(temp);
+	}
+
+	MEM_freeN(queue->freenodes);
+	MEM_freeN(queue);
+}
+
+/* insert in queue, remove in front */
+void push_queue(DagNodeQueue *queue, DagNode *node)
+{
+	DagNodeQueueElem *elem;
+	int i;
+
+	if (node == NULL) {
+		fprintf(stderr, "pushing null node\n");
+		return;
+	}
+	/*fprintf(stderr, "BFS push : %s %d\n", ((ID *) node->ob)->name, queue->count);*/
+
+	elem = queue->freenodes->first;
+	if (elem != NULL) {
+		queue->freenodes->first = elem->next;
+		if (queue->freenodes->last == elem) {
+			queue->freenodes->last = NULL;
+			queue->freenodes->first = NULL;
+		}
+		queue->freenodes->count--;
+	}
+	else { /* alllocating more */
+		elem = MEM_mallocN(sizeof(DagNodeQueueElem), "DAG queue elem1");
+		elem->node = NULL;
+		elem->next = NULL;
+		queue->freenodes->first = queue->freenodes->last = elem;
+
+		for (i = 1; i < DAGQUEUEALLOC; i++) {
+			elem = MEM_mallocN(sizeof(DagNodeQueueElem), "DAG queue elem2");
+			elem->node = NULL;
+			elem->next = NULL;
+			queue->freenodes->last->next = elem;
+			queue->freenodes->last = elem;
+		}
+		queue->freenodes->count = DAGQUEUEALLOC;
+
+		elem = queue->freenodes->first;
+		queue->freenodes->first = elem->next;
+	}
+	elem->next = NULL;
+	elem->node = node;
+	if (queue->last != NULL)
+		queue->last->next = elem;
+	queue->last = elem;
+	if (queue->first == NULL) {
+		queue->first = elem;
+	}
+	queue->count++;
+}
+
+
+/* insert in front, remove in front */
+void push_stack(DagNodeQueue *queue, DagNode *node)
+{
+	DagNodeQueueElem *elem;
+	int i;
+
+	elem = queue->freenodes->first;
+	if (elem != NULL) {
+		queue->freenodes->first = elem->next;
+		if (queue->freenodes->last == elem) {
+			queue->freenodes->last = NULL;
+			queue->freenodes->first = NULL;
+		}
+		queue->freenodes->count--;
+	}
+	else { /* alllocating more */
+		elem = MEM_mallocN(sizeof(DagNodeQueueElem), "DAG queue elem1");
+		elem->node = NULL;
+		elem->next = NULL;
+		queue->freenodes->first = queue->freenodes->last = elem;
+
+		for (i = 1; i < DAGQUEUEALLOC; i++) {
+			elem = MEM_mallocN(sizeof(DagNodeQueueElem), "DAG queue elem2");
+			elem->node = NULL;
+			elem->next = NULL;
+			queue->freenodes->last->next = elem;
+			queue->freenodes->last = elem;
+		}
+		queue->freenodes->count = DAGQUEUEALLOC;
+
+		elem = queue->freenodes->first;
+		queue->freenodes->first = elem->next;
+	}
+	elem->next = queue->first;
+	elem->node = node;
+	queue->first = elem;
+	if (queue->last == NULL)
+		queue->last = elem;
+	queue->count++;
+}
+
+
+DagNode *pop_queue(DagNodeQueue *queue)
+{
+	DagNodeQueueElem *elem;
+	DagNode *node;
+
+	elem = queue->first;
+	if (elem) {
+		queue->first = elem->next;
+		if (queue->last == elem) {
+			queue->last = NULL;
+			queue->first = NULL;
+		}
+		queue->count--;
+		if (queue->freenodes->last)
+			queue->freenodes->last->next = elem;
+		queue->freenodes->last = elem;
+		if (queue->freenodes->first == NULL)
+			queue->freenodes->first = elem;
+		node = elem->node;
+		elem->node = NULL;
+		elem->next = NULL;
+		queue->freenodes->count++;
+		return node;
+	}
+	else {
+		fprintf(stderr, "return null\n");
+		return NULL;
+	}
+}
+
+DagNode *get_top_node_queue(DagNodeQueue *queue)
+{
+	return queue->first->node;
+}
+
+DagForest *dag_init(void)
+{
+	DagForest *forest;
+	/* use callocN to init all zero */
+	forest = MEM_callocN(sizeof(DagForest), "DAG root");
+	forest->ugly_hack_sorry = true;
+	return forest;
+}
+
+/* isdata = object data... */
+/* XXX this needs to be extended to be more flexible (so that not only objects are evaluated via depsgraph)... */
+static void dag_add_driver_relation(AnimData *adt, DagForest *dag, DagNode *node, int isdata)
+{
+	FCurve *fcu;
+	DagNode *node1;
+
+	for (fcu = adt->drivers.first; fcu; fcu = fcu->next) {
+		ChannelDriver *driver = fcu->driver;
+		DriverVar *dvar;
+		int isdata_fcu = (isdata) || (fcu->rna_path && strstr(fcu->rna_path, "modifiers["));
+
+		/* loop over variables to get the target relationships */
+		for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
+			/* only used targets */
+			DRIVER_TARGETS_USED_LOOPER_BEGIN(dvar)
+			{
+				if (dtar->id) {
+					/* FIXME: other data types need to be added here so that they can work! */
+					if (GS(dtar->id->name) == ID_OB) {
+						Object *ob = (Object *)dtar->id;
+
+						/* normal channel-drives-channel */
+						node1 = dag_get_node(dag, dtar->id);
+
+						/* check if bone... */
+						if ((ob->type == OB_ARMATURE) &&
+						    ( ((dtar->rna_path) && strstr(dtar->rna_path, "pose.bones[")) ||
+						      ((dtar->flag & DTAR_FLAG_STRUCT_REF) && (dtar->pchan_name[0])) ))
+						{
+							dag_add_relation(dag, node1, node, isdata_fcu ? DAG_RL_DATA_DATA : DAG_RL_DATA_OB, "Driver");
+						}
+						/* check if ob data */
+						else if (dtar->rna_path && strstr(dtar->rna_path, "data."))
+							dag_add_relation(dag, node1, node, isdata_fcu ? DAG_RL_DATA_DATA : DAG_RL_DATA_OB, "Driver");
+						/* normal */
+						else
+							dag_add_relation(dag, node1, node, isdata_fcu ? DAG_RL_OB_DATA : DAG_RL_OB_OB, "Driver");
+					}
+				}
+			}
+			DRIVER_TARGETS_LOOPER_END;
+		}
+	}
+}
+
+/* XXX: forward def for material driver handling... */
+static void dag_add_material_driver_relations(DagForest *dag, DagNode *node, Material *ma);
+
+/* recursive handling for shader nodetree drivers */
+static void dag_add_shader_nodetree_driver_relations(DagForest *dag, DagNode *node, bNodeTree *ntree)
+{
+	bNode *n;
+
+	/* nodetree itself */
+	if (ntree->adt) {
+		dag_add_driver_relation(ntree->adt, dag, node, 1);
+	}
+
+	/* nodetree's nodes... */
+	for (n = ntree->nodes.first; n; n = n->next) {
+		if (n->id) {
+			if (GS(n->id->name) == ID_MA) {
+				dag_add_material_driver_relations(dag, node, (Material *)n->id);
+			}
+			else if (n->type == NODE_GROUP) {
+				dag_add_shader_nodetree_driver_relations(dag, node, (bNodeTree *)n->id);
+			}
+		}
+	}
+}
+
+/* recursive handling for material drivers */
+static void dag_add_material_driver_relations(DagForest *dag, DagNode *node, Material *ma)
+{
+	/* Prevent infinite recursion by checking (and tagging the material) as having been visited
+	 * already (see build_dag()). This assumes ma->id.tag & LIB_TAG_DOIT isn't set by anything else
+	 * in the meantime... [#32017]
+	 */
+	if (ma->id.tag & LIB_TAG_DOIT)
+		return;
+
+	ma->id.tag |= LIB_TAG_DOIT;
+
+	/* material itself */
+	if (ma->adt)
+		dag_add_driver_relation(ma->adt, dag, node, 1);
+
+	/* textures */
+	// TODO...
+	//dag_add_texture_driver_relations(DagForest *dag, DagNode *node, ID *id);
+
+	/* material's nodetree */
+	if (ma->nodetree)
+		dag_add_shader_nodetree_driver_relations(dag, node, ma->nodetree);
+
+	ma->id.tag &= ~LIB_TAG_DOIT;
+}
+
+/* recursive handling for lamp drivers */
+static void dag_add_lamp_driver_relations(DagForest *dag, DagNode *node, Lamp *la)
+{
+	/* Prevent infinite recursion by checking (and tagging the lamp) as having been visited
+	 * already (see build_dag()). This assumes la->id.tag & LIB_TAG_DOIT isn't set by anything else
+	 * in the meantime... [#32017]
+	 */
+	if (la->id.tag & LIB_TAG_DOIT)
+		return;
+
+	la->id.tag |= LIB_TAG_DOIT;
+
+	/* lamp itself */
+	if (la->adt)
+		dag_add_driver_relation(la->adt, dag, node, 1);
+
+	/* textures */
+	// TODO...
+	//dag_add_texture_driver_relations(DagForest *dag, DagNode *node, ID *id);
+
+	/* lamp's nodetree */
+	if (la->nodetree)
+		dag_add_shader_nodetree_driver_relations(dag, node, la->nodetree);
+
+	la->id.tag &= ~LIB_TAG_DOIT;
+}
+
+static void create_collision_relation(DagForest *dag, DagNode *node, Object *ob1, const char *name)
+{
+	DagNode *node2 = dag_get_node(dag, ob1);
+	dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, name);
+}
+
+void dag_add_collision_relations(DagForest *dag, Scene *scene, Object *ob, DagNode *node, Group *group, int layer, unsigned int modifier_type, DagCollobjFilterFunction fn, bool dupli, const char *name)
+{
+	unsigned int numcollobj;
+	Object **collobjs = get_collisionobjects_ext(scene, ob, group, layer, &numcollobj, modifier_type, dupli);
+
+	for (unsigned int i = 0; i < numcollobj; i++) {
+		Object *ob1 = collobjs[i];
+
+		if (!fn || fn(ob1, modifiers_findByType(ob1, modifier_type))) {
+			create_collision_relation(dag, node, ob1, name);
+		}
+	}
+
+	if (collobjs)
+		MEM_freeN(collobjs);
+}
+
+void dag_add_forcefield_relations(DagForest *dag, Scene *scene, Object *ob, DagNode *node, EffectorWeights *effector_weights, bool add_absorption, int skip_forcefield, const char *name)
+{
+	ListBase *effectors = pdInitEffectors(scene, ob, NULL, effector_weights, false);
+
+	if (effectors) {
+		for (EffectorCache *eff = effectors->first; eff; eff = eff->next) {
+			if (eff->ob != ob && eff->pd->forcefield != skip_forcefield) {
+				create_collision_relation(dag, node, eff->ob, name);
+
+				if (eff->pd->forcefield == PFIELD_SMOKEFLOW && eff->pd->f_source) {
+					create_collision_relation(dag, node, eff->pd->f_source, "Smoke Force Domain");
+				}
+
+				if (add_absorption && (eff->pd->flag & PFIELD_VISIBILITY)) {
+					/* Actual code uses get_collider_cache */
+					dag_add_collision_relations(dag, scene, ob, node, NULL, eff->ob->lay, eModifierType_Collision, NULL, true, "Force Absorption");
+				}
+			}
+		}
+	}
+
+	pdEndEffectors(&effectors);
+}
+
+static bool build_deg_tracking_constraints(DagForest *dag,
+                                           Scene *scene,
+                                           DagNode *scenenode,
+                                           bConstraint *con,
+                                           const bConstraintTypeInfo *cti,
+                                           DagNode *node,
+                                           bool is_data)
+{
+	if (!ELEM(cti->type, CONSTRAINT_TYPE_FOLLOWTRACK,
+	          CONSTRAINT_TYPE_CAMERASOLVER,
+	          CONSTRAINT_TYPE_OBJECTSOLVER))
+	{
+		return false;
+	}
+	bool depends_on_camera = false;
+	if (cti->type == CONSTRAINT_TYPE_FOLLOWTRACK) {
+		bFollowTrackConstraint *data = (bFollowTrackConstraint *)con->data;
+		if ((data->clip || data->flag & FOLLOWTRACK_ACTIVECLIP) && data->track[0]) {
+			depends_on_camera = true;
+		}
+		if (data->depth_ob != NULL) {
+			DagNode *node2 = dag_get_node(dag, data->depth_ob);
+			dag_add_relation(dag,
+			                 node2, node,
+			                 (is_data) ? (DAG_RL_DATA_DATA | DAG_RL_OB_DATA)
+			                           : (DAG_RL_DATA_OB | DAG_RL_OB_OB),
+			                 cti->name);
+		}
+	}
+	else if (cti->type == CONSTRAINT_TYPE_OBJECTSOLVER) {
+		depends_on_camera = true;
+	}
+	if (depends_on_camera && scene->camera != NULL) {
+		DagNode *node2 = dag_get_node(dag, scene->camera);
+		dag_add_relation(dag,
+		                 node2, node,
+		                 (is_data) ? (DAG_RL_DATA_DATA | DAG_RL_OB_DATA)
+		                           : (DAG_RL_DATA_OB | DAG_RL_OB_OB),
+		                 cti->name);
+	}
+	dag_add_relation(dag, scenenode, node, DAG_RL_SCENE, "Scene Relation");
+	return true;
+}
+
+static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, Object *ob, int mask)
+{
+	bConstraint *con;
+	DagNode *node;
+	DagNode *node2;
+	DagNode *node3;
+	Key *key;
+	ParticleSystem *psys;
+	int addtoroot = 1;
+
+	node = dag_get_node(dag, ob);
+
+	if ((ob->data) && (mask & DAG_RL_DATA)) {
+		node2 = dag_get_node(dag, ob->data);
+		dag_add_relation(dag, node, node2, DAG_RL_DATA, "Object-Data Relation");
+		node2->first_ancestor = ob;
+		node2->ancestor_count += 1;
+	}
+
+	/* also build a custom data mask for dependencies that need certain layers */
+
+	if (ob->type == OB_ARMATURE) {
+		if (ob->pose) {
+			bPoseChannel *pchan;
+
+			for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
+				for (con = pchan->constraints.first; con; con = con->next) {
+					const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
+					ListBase targets = {NULL, NULL};
+					bConstraintTarget *ct;
+
+					if (!cti) {
+						continue;
+					}
+
+					if (build_deg_tracking_constraints(dag, scene, scenenode, con, cti, node, true)) {
+						/* pass */
+					}
+					else if (cti->get_constraint_targets) {
+						cti->get_constraint_targets(con, &targets);
+
+						for (ct = targets.first; ct; ct = ct->next) {
+							if (ct->tar && ct->tar != ob) {
+								// fprintf(stderr, "armature %s target :%s\n", ob->id.name, target->id.name);
+								node3 = dag_get_node(dag, ct->tar);
+
+								if (ct->subtarget[0]) {
+									dag_add_relation(dag, node3, node, DAG_RL_OB_DATA | DAG_RL_DATA_DATA, cti->name);
+									if (ct->tar->type == OB_MESH)
+										node3->customdata_mask |= CD_MASK_MDEFORMVERT;
+								}
+								else if (ELEM(con->type, CONSTRAINT_TYPE_FOLLOWPATH,
+								                         CONSTRAINT_TYPE_CLAMPTO,
+								                         CONSTRAINT_TYPE_SPLINEIK,
+								                         CONSTRAINT_TYPE_SHRINKWRAP))
+								{
+									dag_add_relation(dag, node3, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, cti->name);
+								}
+								else {
+									dag_add_relation(dag, node3, node, DAG_RL_OB_DATA, cti->name);
+								}
+							}
+						}
+
+						if (cti->flush_constraint_targets)
+							cti->flush_constraint_targets(con, &targets, 1);
+					}
+
+				}
+			}
+		}
+	}
+
+	/* driver dependencies, nla modifiers */
+#if 0 // XXX old animation system
+	if (ob->nlastrips.first) {
+		bActionStrip *strip;
+		bActionChannel *chan;
+		for (strip = ob->nlastrips.first; strip; strip = strip->next) {
+			if (strip->modifiers.first) {
+				bActionModifier *amod;
+				for (amod = strip->modifiers.first; amod; amod = amod->next) {
+					if (amod->ob) {
+						node2 = dag_get_node(dag, amod->ob);
+						dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "NLA Strip Modifier");
+					}
+				}
+			}
+		}
+	}
+#endif // XXX old animation system
+	if (ob->adt)
+		dag_add_driver_relation(ob->adt, dag, node, (ob->type == OB_ARMATURE));  // XXX isdata arg here doesn't give an accurate picture of situation
+
+	key = BKE_key_from_object(ob);
+	if (key && key->adt)
+		dag_add_driver_relation(key->adt, dag, node, 1);
+
+	if (ob->modifiers.first) {
+		ModifierData *md;
+		ModifierUpdateDepsgraphContext ctx = {
+			.scene = scene,
+			.object = ob,
+
+			.forest = dag,
+			.obNode = node,
+		};
+		for (md = ob->modifiers.first; md; md = md->next) {
+			const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
+
+			if (mti->updateDepgraph) mti->updateDepgraph(md, &ctx);
+		}
+	}
+	if (ob->parent) {
+		node2 = dag_get_node(dag, ob->parent);
+
+		switch (ob->partype) {
+			case PARSKEL:
+				dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_OB, "Parent");
+				break;
+			case PARVERT1: case PARVERT3:
+				dag_add_relation(dag, node2, node, DAG_RL_DATA_OB | DAG_RL_OB_OB, "Vertex Parent");
+				node2->customdata_mask |= CD_MASK_ORIGINDEX;
+				break;
+			case PARBONE:
+				dag_add_relation(dag, node2, node, DAG_RL_DATA_OB | DAG_RL_OB_OB, "Bone Parent");
+				break;
+			default:
+				if (ob->parent->type == OB_LATTICE)
+					dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_OB, "Lattice Parent");
+				else if (ob->parent->type == OB_CURVE) {
+					Curve *cu = ob->parent->data;
+					if (cu->flag & CU_PATH)
+						dag_add_relation(dag, node2, node, DAG_RL_DATA_OB | DAG_RL_OB_OB, "Curve Parent");
+					else
+						dag_add_relation(dag, node2, node, DAG_RL_OB_OB, "Curve Parent");
+				}
+				else
+					dag_add_relation(dag, node2, node, DAG_RL_OB_OB, "Parent");
+				break;
+		}
+		/* exception case: parent is duplivert */
+		if (ob->type == OB_MBALL && (ob->parent->transflag & OB_DUPLIVERTS)) {
+			dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_OB, "Duplivert");
+		}
+
+		addtoroot = 0;
+	}
+	if (ob->proxy) {
+		node2 = dag_get_node(dag, ob->proxy);
+		dag_add_relation(dag, node, node2, DAG_RL_DATA_DATA | DAG_RL_OB_OB, "Proxy");
+		/* inverted relation, so addtoroot shouldn't be set to zero */
+	}
+
+	if (ob->transflag & OB_DUPLI) {
+		if ((ob->transflag & OB_DUPLIGROUP) && ob->dup_group) {
+			GroupObject *go;
+			for (go = ob->dup_group->gobject.first; go; go = go->next) {
+				if (go->ob) {
+					node2 = dag_get_node(dag, go->ob);
+					/* node2 changes node1, this keeps animations updated in groups?? not logical? */
+					dag_add_relation(dag, node2, node, DAG_RL_OB_OB, "Dupligroup");
+				}
+			}
+		}
+	}
+
+	/* rigidbody force fields  */
+	if ((ob->type == OB_MESH) || (ob->type == OB_CURVE) || (ob->type == OB_LATTICE)) {
+		if (ob->rigidbody_object && scene->rigidbody_world) {
+			dag_add_forcefield_relations(dag, scene, ob, node, scene->rigidbody_world->effector_weights, true, 0, "Force Field");
+		}
+	}
+
+	/* object data drivers */
+	if (ob->data) {
+		AnimData *adt = BKE_animdata_from_id((ID *)ob->data);
+		if (adt)
+			dag_add_driver_relation(adt, dag, node, 1);
+	}
+
+	/* object type/data relationships */
+	switch (ob->type) {
+		case OB_CAMERA:
+		{
+			Camera *cam = (Camera *)ob->data;
+
+			if (cam->dof_ob) {
+				node2 = dag_get_node(dag, cam->dof_ob);
+				dag_add_relation(dag, node2, node, DAG_RL_OB_OB, "Camera DoF");
+			}
+			break;
+		}
+		case OB_MBALL:
+		{
+			Object *mom = BKE_mball_basis_find(G.main, G.main->eval_ctx, scene, ob);
+
+			if (mom != ob) {
+				node2 = dag_get_node(dag, mom);
+				dag_add_relation(dag, node, node2, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Metaball");  /* mom depends on children! */
+			}
+			break;
+		}
+		case OB_CURVE:
+		case OB_FONT:
+		{
+			Curve *cu = ob->data;
+
+			if (cu->bevobj) {
+				node2 = dag_get_node(dag, cu->bevobj);
+				dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Curve Bevel");
+			}
+			if (cu->taperobj) {
+				node2 = dag_get_node(dag, cu->taperobj);
+				dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Curve Taper");
+			}
+			if (ob->type == OB_FONT) {
+				/* Really rather dirty hack. needs to support font family to work
+				 * reliably on render export.
+				 *
+				 * This totally mimics behavior of regular verts duplication with
+				 * parenting. The only tricky thing here is to get list of objects
+				 * used for the custom "font".
+				 *
+				 * This shouldn't harm so much because this code only runs on DAG
+				 * rebuild and this feature is not that commonly used.
+				 *
+				 *                                                 - sergey -
+				 */
+				if (cu->family[0] != '\n') {
+					ListBase *duplilist;
+					DupliObject *dob;
+					duplilist = object_duplilist(G.main, G.main->eval_ctx, scene, ob);
+					for (dob = duplilist->first; dob; dob = dob->next) {
+						node2 = dag_get_node(dag, dob->ob);
+						dag_add_relation(dag, node, node2, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Object Font");
+					}
+					free_object_duplilist(duplilist);
+				}
+
+				if (cu->textoncurve) {
+					node2 = dag_get_node(dag, cu->textoncurve);
+					/* Text on curve requires path to be evaluated for the target curve. */
+					node2->eval_flags |= DAG_EVAL_NEED_CURVE_PATH;
+					dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Texture On Curve");
+				}
+			}
+			break;
+		}
+	}
+
+	/* material drivers */
+	if (ob->totcol) {
+		int a;
+
+		for (a = 1; a <= ob->totcol; a++) {
+			Material *ma = give_current_material(ob, a);
+
+			if (ma) {
+				/* recursively figure out if there are drivers, and hook these up to this object */
+				dag_add_material_driver_relations(dag, node, ma);
+			}
+		}
+	}
+	else if (ob->type == OB_LAMP) {
+		dag_add_lamp_driver_relations(dag, node, ob->data);
+	}
+
+	/* particles */
+	psys = ob->particlesystem.first;
+	if (psys) {
+		GroupObject *go;
+
+		for (; psys; psys = psys->next) {
+			BoidRule *rule = NULL;
+			BoidState *state = NULL;
+			ParticleSettings *part = psys->part;
+
+			if (part->adt) {
+				dag_add_driver_relation(part->adt, dag, node, 1);
+			}
+
+			dag_add_relation(dag, node, node, DAG_RL_OB_DATA, "Particle-Object Relation");
+
+			if (!psys_check_enabled(ob, psys, G.is_rendering))
+				continue;
+
+			if (ELEM(part->phystype, PART_PHYS_KEYED, PART_PHYS_BOIDS)) {
+				ParticleTarget *pt = psys->targets.first;
+
+				for (; pt; pt = pt->next) {
+					if (pt->ob && BLI_findlink(&pt->ob->particlesystem, pt->psys - 1)) {
+						node2 = dag_get_node(dag, pt->ob);
+						dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Particle Targets");
+					}
+				}
+			}
+
+			if (part->ren_as == PART_DRAW_OB && part->dup_ob) {
+				node2 = dag_get_node(dag, part->dup_ob);
+				/* note that this relation actually runs in the wrong direction, the problem
+				 * is that dupli system all have this (due to parenting), and the render
+				 * engine instancing assumes particular ordering of objects in list */
+				dag_add_relation(dag, node, node2, DAG_RL_OB_OB, "Particle Object Visualization");
+				if (part->dup_ob->type == OB_MBALL)
+					dag_add_relation(dag, node, node2, DAG_RL_DATA_DATA, "Particle Object Visualization");
+			}
+
+			if (part->ren_as == PART_DRAW_GR && part->dup_group) {
+				for (go = part->dup_group->gobject.first; go; go = go->next) {
+					node2 = dag_get_node(dag, go->ob);
+					dag_add_relation(dag, node2, node, DAG_RL_OB_OB, "Particle Group Visualization");
+				}
+			}
+
+			if (part->type != PART_HAIR) {
+				/* Actual code uses get_collider_cache */
+				dag_add_collision_relations(dag, scene, ob, node, part->collision_group, ob->lay, eModifierType_Collision, NULL, true, "Particle Collision");
+			}
+			else if ((psys->flag & PSYS_HAIR_DYNAMICS) && psys->clmd && psys->clmd->coll_parms) {
+				/* Hair uses cloth simulation, i.e. get_collision_objects */
+				dag_add_collision_relations(dag, scene, ob, node, psys->clmd->coll_parms->group, ob->lay | scene->lay, eModifierType_Collision, NULL, true, "Hair Collision");
+			}
+
+			dag_add_forcefield_relations(dag, scene, ob, node, part->effector_weights, part->type == PART_HAIR, 0, "Particle Force Field");
+
+			if (part->boids) {
+				for (state = part->boids->states.first; state; state = state->next) {
+					for (rule = state->rules.first; rule; rule = rule->next) {
+						Object *ruleob = NULL;
+						if (rule->type == eBoidRuleType_Avoid)
+							ruleob = ((BoidRuleGoalAvoid *)rule)->ob;
+						else if (rule->type == eBoidRuleType_FollowLeader)
+							ruleob = ((BoidRuleFollowLeader *)rule)->ob;
+
+						if (ruleob) {
+							node2 = dag_get_node(dag, ruleob);
+							dag_add_relation(dag, node2, node, DAG_RL_OB_DATA, "Boid Rule");
+						}
+					}
+				}
+			}
+		}
+	}
+
+	/* object constraints */
+	for (con = ob->constraints.first; con; con = con->next) {
+		const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
+		ListBase targets = {NULL, NULL};
+		bConstraintTarget *ct;
+
+		if (!cti)
+			continue;
+
+		/* special case for camera tracking -- it doesn't use targets to define relations */
+		if (build_deg_tracking_constraints(dag, scene, scenenode, con, cti, node, false)) {
+			addtoroot = 0;
+		}
+		else if (cti->get_constraint_targets) {
+			cti->get_constraint_targets(con, &targets);
+
+			for (ct = targets.first; ct; ct = ct->next) {
+				Object *obt;
+
+				if (ct->tar)
+					obt = ct->tar;
+				else
+					continue;
+
+				node2 = dag_get_node(dag, obt);
+				if (ELEM(con->type, CONSTRAINT_TYPE_FOLLOWPATH, CONSTRAINT_TYPE_CLAMPTO))
+					dag_add_relation(dag, node2, node, DAG_RL_DATA_OB | DAG_RL_OB_OB, cti->name);
+				else {
+					if (ELEM(obt->type, OB_ARMATURE, OB_MESH, OB_LATTICE) && (ct->subtarget[0])) {
+						dag_add_relation(dag, node2, node, DAG_RL_DATA_OB | DAG_RL_OB_OB, cti->name);
+						if (obt->type == OB_MESH)
+							node2->customdata_mask |= CD_MASK_MDEFORMVERT;
+					}
+					else if (cti->type == CONSTRAINT_TYPE_SHRINKWRAP) {
+						dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, cti->name);
+					}
+					else {
+						dag_add_relation(dag, node2, node, DAG_RL_OB_OB, cti->name);
+					}
+				}
+				addtoroot = 0;
+			}
+
+			if (cti->flush_constraint_targets)
+				cti->flush_constraint_targets(con, &targets, 1);
+		}
+	}
+
+	if (addtoroot == 1)
+		dag_add_relation(dag, scenenode, node, DAG_RL_SCENE, "Scene Relation");
+}
+
+static void build_dag_group(DagForest *dag, DagNode *scenenode, Main *bmain, Scene *scene, Group *group, short mask)
+{
+	GroupObject *go;
+
+	if (group->id.tag & LIB_TAG_DOIT)
+		return;
+
+	group->id.tag |= LIB_TAG_DOIT;
+
+	for (go = group->gobject.first; go; go = go->next) {
+		build_dag_object(dag, scenenode, scene, go->ob, mask);
+		if (go->ob->dup_group)
+			build_dag_group(dag, scenenode, bmain, scene, go->ob->dup_group, mask);
+	}
+}
+
+DagForest *build_dag(Main *bmain, Scene *sce, short mask)
+{
+	Base *base;
+	Object *ob;
+	DagNode *node;
+	DagNode *scenenode;
+	DagForest *dag;
+	DagAdjList *itA;
+
+	dag = sce->theDag;
+	if (dag)
+		free_forest(dag);
+	else {
+		dag = dag_init();
+		sce->theDag = dag;
+	}
+	dag->need_update = false;
+
+	BKE_main_id_tag_idcode(bmain, ID_OB, LIB_TAG_DOIT, false);
+
+	/* clear "LIB_TAG_DOIT" flag from all materials, to prevent infinite recursion problems later [#32017] */
+	BKE_main_id_tag_idcode(bmain, ID_MA, LIB_TAG_DOIT, false);
+	BKE_main_id_tag_idcode(bmain, ID_LA, LIB_TAG_DOIT, false);
+	BKE_main_id_tag_idcode(bmain, ID_GR, LIB_TAG_DOIT, false);
+
+	/* add base node for scene. scene is always the first node in DAG */
+	scenenode = dag_add_node(dag, sce);
+
+	/* add current scene objects */
+	for (base = sce->base.first; base; base = base->next) {
+		ob = base->object;
+		ob->id.tag |= LIB_TAG_DOIT;
+		build_dag_object(dag, scenenode, sce, ob, mask);
+		if (ob->proxy)
+			build_dag_object(dag, scenenode, sce, ob->proxy, mask);
+		if (ob->dup_group)
+			build_dag_group(dag, scenenode, bmain, sce, ob->dup_group, mask);
+	}
+
+	/* There might be situations when object from current scene depends on
+	 * objects form other scene AND objects from other scene has own
+	 * dependencies on objects from other scene.
+	 *
+	 * This is really important to include such indirect dependencies in order
+	 * to keep threaded update safe but since we don't really know if object is
+	 * coming from current scene or another scene we do rather stupid tag-based
+	 * check here: all the objects for which build_dag_object() was called are
+	 * getting tagged with LIB_TAG_DOIT. This way if some node has untagged
+	 * object we know it's an object from other scene.
+	 *
+	 * It should be enough to to it once, because if there's longer chain of
+	 * indirect dependencies, all the new nodes will be added to the end of the
+	 * list, meaning we'll keep covering them in this for loop.
+	 */
+	for (node = sce->theDag->DagNode.first; node != NULL; node = node->next) {
+		if (node->type == ID_OB) {
+			ob = node->ob;
+			if ((ob->id.tag & LIB_TAG_DOIT) == 0) {
+				ob->id.tag |= LIB_TAG_DOIT;
+				build_dag_object(dag, scenenode, sce, ob, mask);
+				if (ob->proxy)
+					build_dag_object(dag, scenenode, sce, ob->proxy, mask);
+				if (ob->dup_group)
+					build_dag_group(dag, scenenode, bmain, sce, ob->dup_group, mask);
+			}
+		}
+	}
+
+	BKE_main_id_tag_idcode(bmain, ID_GR, LIB_TAG_DOIT, false);
+
+	/* Now all relations were built, but we need to solve 1 exceptional case;
+	 * When objects have multiple "parents" (for example parent + constraint working on same object)
+	 * the relation type has to be synced. One of the parents can change, and should give same event to child */
+
+	/* nodes were callocced, so we can use node->color for temporal storage */
+	for (node = sce->theDag->DagNode.first; node; node = node->next) {
+		if (node->type == ID_OB) {
+			for (itA = node->child; itA; itA = itA->next) {
+				if (itA->node->type == ID_OB) {
+					itA->node->color |= itA->type;
+				}
+			}
+
+			/* also flush custom data mask */
+			((Object *)node->ob)->customdata_mask = node->customdata_mask;
+
+			if (node->parent == NULL) {
+				dag_add_relation(dag, scenenode, node, DAG_RL_SCENE, "Scene Relation");
+			}
+		}
+	}
+	/* now set relations equal, so that when only one parent changes, the correct recalcs are found */
+	for (node = sce->theDag->DagNode.first; node; node = node->next) {
+		if (node->type == ID_OB) {
+			for (itA = node->child; itA; itA = itA->next) {
+				if (itA->node->type == ID_OB) {
+					itA->type |= itA->node->color;
+				}
+			}
+		}
+	}
+
+	/* cycle detection and solving */
+	// solve_cycles(dag);
+
+	return dag;
+}
+
+
+void free_forest(DagForest *Dag)
+{  /* remove all nodes and deps */
+	DagNode *tempN;
+	DagAdjList *tempA;
+	DagAdjList *itA;
+	DagNode *itN = Dag->DagNode.first;
+
+	while (itN) {
+		itA = itN->child;
+		while (itA) {
+			tempA = itA;
+			itA = itA->next;
+			MEM_freeN(tempA);
+		}
+
+		itA = itN->parent;
+		while (itA) {
+			tempA = itA;
+			itA = itA->next;
+			MEM_freeN(tempA);
+		}
+
+		tempN = itN;
+		itN = itN->next;
+		MEM_freeN(tempN);
+	}
+
+	BLI_ghash_free(Dag->nodeHash, NULL, NULL);
+	Dag->nodeHash = NULL;
+	Dag->DagNode.first = NULL;
+	Dag->DagNode.last = NULL;
+	Dag->numNodes = 0;
+
+}
+
+DagNode *dag_find_node(DagForest *forest, void *fob)
+{
+	if (forest->nodeHash)
+		return BLI_ghash_lookup(forest->nodeHash, fob);
+
+	return NULL;
+}
+
+static int dag_print_dependencies = 0;  /* debugging */
+
+/* no checking of existence, use dag_find_node first or dag_get_node */
+DagNode *dag_add_node(DagForest *forest, void *fob)
+{
+	DagNode *node;
+
+	node = MEM_callocN(sizeof(DagNode), "DAG node");
+	if (node) {
+		node->ob = fob;
+		node->color = DAG_WHITE;
+
+		if (forest->ugly_hack_sorry) node->type = GS(((ID *) fob)->name);  /* sorry, done for pose sorting */
+		if (forest->numNodes) {
+			((DagNode *) forest->DagNode.last)->next = node;
+			forest->DagNode.last = node;
+			forest->numNodes++;
+		}
+		else {
+			forest->DagNode.last = node;
+			forest->DagNode.first = node;
+			forest->numNodes = 1;
+		}
+
+		if (!forest->nodeHash)
+			forest->nodeHash = BLI_ghash_ptr_new("dag_add_node gh");
+		BLI_ghash_insert(forest->nodeHash, fob, node);
+	}
+
+	return node;
+}
+
+DagNode *dag_get_node(DagForest *forest, void *fob)
+{
+	DagNode *node;
+
+	node = dag_find_node(forest, fob);
+	if (!node)
+		node = dag_add_node(forest, fob);
+	return node;
+}
+
+
+
+DagNode *dag_get_sub_node(DagForest *forest, void *fob)
+{
+	DagNode *node;
+	DagAdjList *mainchild, *prev = NULL;
+
+	mainchild = ((DagNode *) forest->DagNode.first)->child;
+	/* remove from first node (scene) adj list if present */
+	while (mainchild) {
+		if (mainchild->node == fob) {
+			if (prev) {
+				prev->next = mainchild->next;
+				MEM_freeN(mainchild);
+				break;
+			}
+			else {
+				((DagNode *) forest->DagNode.first)->child = mainchild->next;
+				MEM_freeN(mainchild);
+				break;
+			}
+		}
+		prev = mainchild;
+		mainchild = mainchild->next;
+	}
+	node = dag_find_node(forest, fob);
+	if (!node)
+		node = dag_add_node(forest, fob);
+	return node;
+}
+
+static void dag_add_parent_relation(DagForest *UNUSED(forest), DagNode *fob1, DagNode *fob2, short rel, const char *name)
+{
+	DagAdjList *itA = fob2->parent;
+
+	while (itA) { /* search if relation exist already */
+		if (itA->node == fob1) {
+			itA->type |= rel;
+			itA->count += 1;
+			return;
+		}
+		itA = itA->next;
+	}
+	/* create new relation and insert at head. MALLOC alert! */
+	itA = MEM_mallocN(sizeof(DagAdjList), "DAG adj list");
+	itA->node = fob1;
+	itA->type = rel;
+	itA->count = 1;
+	itA->next = fob2->parent;
+	itA->name = name;
+	fob2->parent = itA;
+}
+
+void dag_add_relation(DagForest *forest, DagNode *fob1, DagNode *fob2, short rel, const char *name)
+{
+	DagAdjList *itA = fob1->child;
+
+	/* parent relation is for cycle checking */
+	dag_add_parent_relation(forest, fob1, fob2, rel, name);
+
+	/* TODO(sergey): Find a better place for this. */
+#ifdef WITH_OPENSUBDIV
+	if ((rel & (DAG_RL_DATA_DATA | DAG_RL_DATA_OB)) != 0) {
+		if (fob1->type == ID_OB) {
+			if ((fob1->eval_flags & DAG_EVAL_NEED_CPU) == 0) {
+				Object *ob2 = fob2->ob;
+				if (ob2->recalc & OB_RECALC_ALL) {
+					/* Make sure object has all the data on CPU. */
+					Object *ob1 = fob1->ob;
+					ob1->recalc |= OB_RECALC_DATA;
+				}
+				fob1->eval_flags |= DAG_EVAL_NEED_CPU;
+			}
+		}
+	}
+#endif
+
+	while (itA) { /* search if relation exist already */
+		if (itA->node == fob2) {
+			itA->type |= rel;
+			itA->count += 1;
+			return;
+		}
+		itA = itA->next;
+	}
+	/* create new relation and insert at head. MALLOC alert! */
+	itA = MEM_mallocN(sizeof(DagAdjList), "DAG adj list");
+	itA->node = fob2;
+	itA->type = rel;
+	itA->count = 1;
+	itA->next = fob1->child;
+	itA->name = name;
+	fob1->child = itA;
+}
+
+static const char *dag_node_name(DagForest *dag, DagNode *node)
+{
+	if (node->ob == NULL)
+		return "null";
+	else if (dag->ugly_hack_sorry)
+		return ((ID *)(node->ob))->name + 2;
+	else
+		return ((bPoseChannel *)(node->ob))->name;
+}
+
+static void dag_node_print_dependencies(DagForest *dag, DagNode *node)
+{
+	DagAdjList *itA;
+
+	printf("%s depends on:\n", dag_node_name(dag, node));
+
+	for (itA = node->parent; itA; itA = itA->next)
+		printf("  %s through %s\n", dag_node_name(dag, itA->node), itA->name);
+	printf("\n");
+}
+
+static int dag_node_print_dependency_recurs(DagForest *dag, DagNode *node, DagNode *endnode)
+{
+	DagAdjList *itA;
+
+	if (node->color == DAG_BLACK)
+		return 0;
+
+	node->color = DAG_BLACK;
+
+	if (node == endnode)
+		return 1;
+
+	for (itA = node->parent; itA; itA = itA->next) {
+		if (dag_node_print_dependency_recurs(dag, itA->node, endnode)) {
+			printf("  %s depends on %s through %s.\n", dag_node_name(dag, node), dag_node_name(dag, itA->node), itA->name);
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+static void dag_node_print_dependency_cycle(DagForest *dag, DagNode *startnode, DagNode *endnode, const char *name)
+{
+	DagNode *node;
+
+	for (node = dag->DagNode.first; node; node = node->next)
+		node->color = DAG_WHITE;
+
+	printf("  %s depends on %s through %s.\n", dag_node_name(dag, endnode), dag_node_name(dag, startnode), name);
+	dag_node_print_dependency_recurs(dag, startnode, endnode);
+	printf("\n");
+}
+
+static int dag_node_recurs_level(DagNode *node, int level)
+{
+	DagAdjList *itA;
+	int newlevel;
+
+	node->color = DAG_BLACK; /* done */
+	newlevel = ++level;
+
+	for (itA = node->parent; itA; itA = itA->next) {
+		if (itA->node->color == DAG_WHITE) {
+			itA->node->ancestor_count = dag_node_recurs_level(itA->node, level);
+			newlevel = MAX2(newlevel, level + itA->node->ancestor_count);
+		}
+		else
+			newlevel = MAX2(newlevel, level + itA->node->ancestor_count);
+	}
+
+	return newlevel;
+}
+
+static void dag_check_cycle(DagForest *dag)
+{
+	DagNode *node;
+	DagAdjList *itA;
+
+	dag->is_acyclic = true;
+
+	/* debugging print */
+	if (dag_print_dependencies)
+		for (node = dag->DagNode.first; node; node = node->next)
+			dag_node_print_dependencies(dag, node);
+
+	/* tag nodes unchecked */
+	for (node = dag->DagNode.first; node; node = node->next)
+		node->color = DAG_WHITE;
+
+	for (node = dag->DagNode.first; node; node = node->next) {
+		if (node->color == DAG_WHITE) {
+			node->ancestor_count = dag_node_recurs_level(node, 0);
+		}
+	}
+
+	/* check relations, and print errors */
+	for (node = dag->DagNode.first; node; node = node->next) {
+		for (itA = node->parent; itA; itA = itA->next) {
+			if (itA->node->ancestor_count > node->ancestor_count) {
+				if (node->ob && itA->node->ob) {
+					dag->is_acyclic = false;
+					printf("Dependency cycle detected:\n");
+					dag_node_print_dependency_cycle(dag, itA->node, node, itA->name);
+				}
+			}
+		}
+	}
+
+	/* parent relations are only needed for cycle checking, so free now */
+	for (node = dag->DagNode.first; node; node = node->next) {
+		while (node->parent) {
+			itA = node->parent->next;
+			MEM_freeN(node->parent);
+			node->parent = itA;
+		}
+	}
+}
+
+/* debug test functions */
+
+void graph_print_queue(DagNodeQueue *nqueue)
+{
+	DagNodeQueueElem *queueElem;
+
+	queueElem = nqueue->first;
+	while (queueElem) {
+		fprintf(stderr, "** %s %i %i-%i ", ((ID *) queueElem->node->ob)->name, queueElem->node->color, queueElem->node->DFS_dvtm, queueElem->node->DFS_fntm);
+		queueElem = queueElem->next;
+	}
+	fprintf(stderr, "\n");
+}
+
+void graph_print_queue_dist(DagNodeQueue *nqueue)
+{
+	DagNodeQueueElem *queueElem;
+	int count;
+
+	queueElem = nqueue->first;
+	count = 0;
+	while (queueElem) {
+		fprintf(stderr, "** %25s %2.2i-%2.2i ", ((ID *) queueElem->node->ob)->name, queueElem->node->DFS_dvtm, queueElem->node->DFS_fntm);
+		while (count < queueElem->node->DFS_dvtm - 1) { fputc(' ', stderr); count++; }
+		fputc('|', stderr);
+		while (count < queueElem->node->DFS_fntm - 2) { fputc('-', stderr); count++; }
+		fputc('|', stderr);
+		fputc('\n', stderr);
+		count = 0;
+		queueElem = queueElem->next;
+	}
+	fprintf(stderr, "\n");
+}
+
+void graph_print_adj_list(DagForest *dag)
+{
+	DagNode *node;
+	DagAdjList *itA;
+
+	node = dag->DagNode.first;
+	while (node) {
+		fprintf(stderr, "node : %s col: %i", ((ID *) node->ob)->name, node->color);
+		itA = node->child;
+		while (itA) {
+			fprintf(stderr, "-- %s ", ((ID *) itA->node->ob)->name);
+
+			itA = itA->next;
+		}
+		fprintf(stderr, "\n");
+		node = node->next;
+	}
+}
+
+/* ************************ API *********************** */
+
+/* mechanism to allow editors to be informed of depsgraph updates,
+ * to do their own updates based on changes... */
+static void (*EditorsUpdateIDCb)(Main *bmain, ID *id) = NULL;
+static void (*EditorsUpdateSceneCb)(Main *bmain, Scene *scene, int updated) = NULL;
+static void (*EditorsUpdateScenePreCb)(Main *bmain, Scene *scene, bool time) = NULL;
+
+void DAG_editors_update_cb(void (*id_func)(Main *bmain, ID *id),
+                           void (*scene_func)(Main *bmain, Scene *scene, int updated),
+                           void (*scene_pre_func)(Main *bmain, Scene *scene, bool time))
+{
+	if (DEG_depsgraph_use_legacy()) {
+		EditorsUpdateIDCb = id_func;
+		EditorsUpdateSceneCb = scene_func;
+		EditorsUpdateScenePreCb = scene_pre_func;
+	}
+	else {
+		/* New dependency graph. */
+		DEG_editors_set_update_cb(id_func, scene_func, scene_pre_func);
+	}
+}
+
+void DAG_editors_update_pre(Main *bmain, Scene *scene, bool time)
+{
+	if (DEG_depsgraph_use_legacy()) {
+		if (EditorsUpdateScenePreCb != NULL) {
+			EditorsUpdateScenePreCb(bmain, scene, time);
+		}
+	}
+	else {
+		DEG_editors_update_pre(bmain, scene, time);
+	}
+}
+
+static void dag_editors_id_update(Main *bmain, ID *id)
+{
+	if (EditorsUpdateIDCb)
+		EditorsUpdateIDCb(bmain, id);
+}
+
+static void dag_editors_scene_update(Main *bmain, Scene *scene, int updated)
+{
+	if (EditorsUpdateSceneCb)
+		EditorsUpdateSceneCb(bmain, scene, updated);
+}
+
+/* groups with objects in this scene need to be put in the right order as well */
+static void scene_sort_groups(Main *bmain, Scene *sce)
+{
+	Base *base;
+	Group *group;
+	GroupObject *go;
+	Object *ob;
+
+	/* test; are group objects all in this scene? */
+	for (ob = bmain->object.first; ob; ob = ob->id.next) {
+		ob->id.tag &= ~LIB_TAG_DOIT;
+	}
+	for (base = sce->base.first; base; base = base->next)
+		base->object->id.tag |= LIB_TAG_DOIT;
+
+	for (group = bmain->group.first; group; group = group->id.next) {
+		for (go = group->gobject.first; go; go = go->next) {
+			if ((go->ob->id.tag & LIB_TAG_DOIT) == 0)
+				break;
+		}
+		/* this group is entirely in this scene */
+		if (go == NULL) {
+			ListBase listb = {NULL, NULL};
+
+			for (go = group->gobject.first; go; go = go->next)
+				go->ob->id.newid = (ID *)go;
+
+			/* in order of sorted bases we reinsert group objects */
+			for (base = sce->base.first; base; base = base->next) {
+
+				if (base->object->id.newid) {
+					go = (GroupObject *)base->object->id.newid;
+					base->object->id.newid = NULL;
+					BLI_remlink(&group->gobject, go);
+					BLI_addtail(&listb, go);
+				}
+			}
+			/* copy the newly sorted listbase */
+			group->gobject = listb;
+		}
+	}
+
+	/* newid abused for GroupObject, cleanup. */
+	for (ob = bmain->object.first; ob; ob = ob->id.next) {
+		ob->id.newid = NULL;
+	}
+}
+
+static void dag_scene_tag_rebuild(Scene *sce)
+{
+	if (sce->theDag) {
+		sce->theDag->need_update = true;
+	}
+}
+
+/* free the depency graph */
+static void dag_scene_free(Scene *sce)
+{
+	if (sce->theDag) {
+		free_forest(sce->theDag);
+		MEM_freeN(sce->theDag);
+		sce->theDag = NULL;
+	}
+}
+
+/* Check whether object data needs to be evaluated before it
+ * might be used by others.
+ *
+ * Means that mesh object needs to have proper derivedFinal,
+ * curves-typed objects are to have proper curve cache.
+ *
+ * Other objects or objects which are tagged for data update are
+ * not considered to be in need of evaluation.
+ */
+static bool check_object_needs_evaluation(Object *object)
+{
+	if (object->recalc & OB_RECALC_ALL) {
+		/* Object is tagged for update anyway, no need to re-tag it. */
+		return false;
+	}
+
+	if (object->type == OB_MESH) {
+		return object->derivedFinal == NULL;
+	}
+	else if (ELEM(object->type, OB_CURVE, OB_SURF, OB_FONT, OB_MBALL, OB_LATTICE)) {
+		return object->curve_cache == NULL;
+	}
+
+	return false;
+}
+
+/* Check whether object data is tagged for update. */
+static bool check_object_tagged_for_update(Object *object)
+{
+	if (object->recalc & OB_RECALC_ALL) {
+		return true;
+	}
+
+	if (ELEM(object->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT, OB_MBALL, OB_LATTICE)) {
+		ID *data_id = object->data;
+		return (data_id->recalc & ID_RECALC_ALL) != 0;
+	}
+
+	return false;
+}
+
+/* Flush changes from tagged objects in the scene to their
+ * dependencies which are not evaluated yet.
+ *
+ * This is needed to ensure all the dependencies are met
+ * before objects gets handled by object_handle_update(),
+ *
+ * This is needed when visible layers are changed or changing
+ * scene graph layout which involved usage of objects which
+ * aren't in the scene or weren't visible yet.
+ */
+static void dag_invisible_dependencies_flush(Scene *scene)
+{
+	DagNode *root_node = scene->theDag->DagNode.first, *node;
+	DagNodeQueue *queue;
+
+	for (node = root_node; node != NULL; node = node->next) {
+		node->color = DAG_WHITE;
+	}
+
+	queue = queue_create(DAGQUEUEALLOC);
+
+	for (node = root_node; node != NULL; node = node->next) {
+		if (node->color == DAG_WHITE) {
+			push_stack(queue, node);
+			node->color = DAG_GRAY;
+
+			while (queue->count) {
+				DagNode *current_node = get_top_node_queue(queue);
+				DagAdjList *itA;
+				bool skip = false;
+
+				for (itA = current_node->child; itA; itA = itA->next) {
+					if (itA->node->color == DAG_WHITE) {
+						itA->node->color = DAG_GRAY;
+						push_stack(queue, itA->node);
+						skip = true;
+						break;
+					}
+				}
+
+				if (!skip) {
+					current_node = pop_queue(queue);
+
+					if (current_node->type == ID_OB) {
+						Object *current_object = current_node->ob;
+						if (check_object_needs_evaluation(current_object)) {
+							for (itA = current_node->child; itA; itA = itA->next) {
+								if (itA->node->type == ID_OB) {
+									Object *object = itA->node->ob;
+									if (check_object_tagged_for_update(object)) {
+										current_object->recalc |= OB_RECALC_OB | OB_RECALC_DATA;
+									}
+								}
+							}
+						}
+					}
+					node->color = DAG_BLACK;
+				}
+			}
+		}
+	}
+
+	queue_delete(queue);
+}
+
+static void dag_invisible_dependencies_check_flush(Main *bmain, Scene *scene)
+{
+	if (DAG_id_type_tagged(bmain, ID_OB) ||
+	    DAG_id_type_tagged(bmain, ID_ME) ||  /* Mesh */
+	    DAG_id_type_tagged(bmain, ID_CU) ||  /* Curve */
+	    DAG_id_type_tagged(bmain, ID_MB) ||  /* MetaBall */
+	    DAG_id_type_tagged(bmain, ID_LT))    /* Lattice */
+	{
+		dag_invisible_dependencies_flush(scene);
+	}
+}
+
+/* sort the base list on dependency order */
+static void dag_scene_build(Main *bmain, Scene *sce)
+{
+	DagNode *node, *rootnode;
+	DagNodeQueue *nqueue;
+	DagAdjList *itA;
+	int time;
+	int skip = 0;
+	ListBase tempbase;
+	Base *base;
+
+	BLI_listbase_clear(&tempbase);
+
+	build_dag(bmain, sce, DAG_RL_ALL_BUT_DATA);
+
+	dag_check_cycle(sce->theDag);
+
+	nqueue = queue_create(DAGQUEUEALLOC);
+
+	for (node = sce->theDag->DagNode.first; node; node = node->next) {
+		node->color = DAG_WHITE;
+	}
+
+	time = 1;
+
+	rootnode = sce->theDag->DagNode.first;
+	rootnode->color = DAG_GRAY;
+	time++;
+	push_stack(nqueue, rootnode);
+
+	while (nqueue->count) {
+
+		skip = 0;
+		node = get_top_node_queue(nqueue);
+
+		itA = node->child;
+		while (itA != NULL) {
+			if (itA->node->color == DAG_WHITE) {
+				itA->node->DFS_dvtm = time;
+				itA->node->color = DAG_GRAY;
+
+				time++;
+				push_stack(nqueue, itA->node);
+				skip = 1;
+				break;
+			}
+			itA = itA->next;
+		}
+
+		if (!skip) {
+			if (node) {
+				node = pop_queue(nqueue);
+				if (node->ob == sce)  /* we are done */
+					break;
+				node->color = DAG_BLACK;
+
+				time++;
+				base = sce->base.first;
+				while (base && base->object != node->ob)
+					base = base->next;
+				if (base) {
+					BLI_remlink(&sce->base, base);
+					BLI_addhead(&tempbase, base);
+				}
+			}
+		}
+	}
+
+	/* temporal correction for circular dependencies */
+	base = sce->base.first;
+	while (base) {
+		BLI_remlink(&sce->base, base);
+		BLI_addhead(&tempbase, base);
+		//if (G.debug & G_DEBUG)
+		printf("cyclic %s\n", base->object->id.name);
+		base = sce->base.first;
+	}
+
+	sce->base = tempbase;
+	queue_delete(nqueue);
+
+	/* all groups with objects in this scene gets resorted too */
+	scene_sort_groups(bmain, sce);
+
+	if (G.debug & G_DEBUG) {
+		printf("\nordered\n");
+		for (base = sce->base.first; base; base = base->next) {
+			printf(" %s\n", base->object->id.name);
+		}
+	}
+
+	/* Make sure that new dependencies which came from invisible layers
+	 * are tagged for update (if they're needed for objects which were
+	 * tagged for update).
+	 */
+	dag_invisible_dependencies_check_flush(bmain, sce);
+}
+
+/* clear all dependency graphs */
+void DAG_relations_tag_update(Main *bmain)
+{
+	if (DEG_depsgraph_use_legacy()) {
+		Scene *sce;
+		for (sce = bmain->scene.first; sce; sce = sce->id.next) {
+			dag_scene_tag_rebuild(sce);
+		}
+	}
+	else {
+		/* New dependency graph. */
+		DEG_relations_tag_update(bmain);
+	}
+}
+
+/* rebuild dependency graph only for a given scene */
+void DAG_scene_relations_rebuild(Main *bmain, Scene *sce)
+{
+	if (DEG_depsgraph_use_legacy()) {
+		dag_scene_free(sce);
+		DAG_scene_relations_update(bmain, sce);
+	}
+	else {
+		/* New dependency graph. */
+		DEG_scene_relations_rebuild(bmain, sce);
+	}
+}
+
+/* create dependency graph if it was cleared or didn't exist yet */
+void DAG_scene_relations_update(Main *bmain, Scene *sce)
+{
+	if (DEG_depsgraph_use_legacy()) {
+		if (!sce->theDag || sce->theDag->need_update)
+			dag_scene_build(bmain, sce);
+	}
+	else {
+		/* New dependency graph. */
+		DEG_scene_relations_update(bmain, sce);
+	}
+}
+
+void DAG_scene_relations_validate(Main *bmain, Scene *sce)
+{
+	if (!DEG_depsgraph_use_legacy()) {
+		DEG_debug_scene_relations_validate(bmain, sce);
+	}
+}
+
+void DAG_scene_free(Scene *sce)
+{
+	if (DEG_depsgraph_use_legacy()) {
+		if (sce->theDag) {
+			free_forest(sce->theDag);
+			MEM_freeN(sce->theDag);
+			sce->theDag = NULL;
+		}
+	}
+	else {
+		if (sce->depsgraph) {
+			DEG_graph_free(sce->depsgraph);
+			sce->depsgraph = NULL;
+		}
+	}
+}
+
+static void lib_id_recalc_tag(Main *bmain, ID *id)
+{
+	id->recalc |= ID_RECALC;
+	DAG_id_type_tag(bmain, GS(id->name));
+}
+
+static void lib_id_recalc_data_tag(Main *bmain, ID *id)
+{
+	id->recalc |= ID_RECALC_DATA;
+	DAG_id_type_tag(bmain, GS(id->name));
+}
+
+/* node was checked to have lasttime != curtime and is if type ID_OB */
+static void flush_update_node(Main *bmain, DagNode *node, unsigned int layer, int curtime)
+{
+	DagAdjList *itA;
+	Object *ob, *obc;
+	int oldflag;
+	bool changed = false;
+	unsigned int all_layer;
+
+	node->lasttime = curtime;
+
+	ob = node->ob;
+	if (ob && (ob->recalc & OB_RECALC_ALL)) {
+		all_layer = node->scelay;
+
+		/* got an object node that changes, now check relations */
+		for (itA = node->child; itA; itA = itA->next) {
+			all_layer |= itA->lay;
+			/* the relationship is visible */
+			if ((itA->lay & layer)) { // XXX || (itA->node->ob == obedit)
+				if (itA->node->type == ID_OB) {
+					obc = itA->node->ob;
+					oldflag = obc->recalc;
+
+					/* got a ob->obc relation, now check if flag needs flush */
+					if (ob->recalc & OB_RECALC_OB) {
+						if (itA->type & DAG_RL_OB_OB) {
+							//printf("ob %s changes ob %s\n", ob->id.name, obc->id.name);
+							obc->recalc |= OB_RECALC_OB;
+							lib_id_recalc_tag(bmain, &obc->id);
+						}
+						if (itA->type & DAG_RL_OB_DATA) {
+							//printf("ob %s changes obdata %s\n", ob->id.name, obc->id.name);
+							obc->recalc |= OB_RECALC_DATA;
+							lib_id_recalc_data_tag(bmain, &obc->id);
+						}
+					}
+					if (ob->recalc & OB_RECALC_DATA) {
+						if (itA->type & DAG_RL_DATA_OB) {
+							//printf("obdata %s changes ob %s\n", ob->id.name, obc->id.name);
+							obc->recalc |= OB_RECALC_OB;
+							lib_id_recalc_tag(bmain, &obc->id);
+						}
+						if (itA->type & DAG_RL_DATA_DATA) {
+							//printf("obdata %s changes obdata %s\n", ob->id.name, obc->id.name);
+							obc->recalc |= OB_RECALC_DATA;
+							lib_id_recalc_data_tag(bmain, &obc->id);
+						}
+					}
+					if (oldflag != obc->recalc) changed = 1;
+				}
+			}
+		}
+		/* even nicer, we can clear recalc flags...  */
+		if ((all_layer & layer) == 0) { // XXX && (ob != obedit)) {
+			/* but existing displaylists or derivedmesh should be freed */
+			if (ob->recalc & OB_RECALC_DATA)
+				BKE_object_free_derived_caches(ob);
+
+			ob->recalc &= ~OB_RECALC_ALL;
+		}
+	}
+
+	/* check case where child changes and parent forcing obdata to change */
+	/* should be done regardless if this ob has recalc set */
+	/* could merge this in with loop above...? (ton) */
+	for (itA = node->child; itA; itA = itA->next) {
+		/* the relationship is visible */
+		if ((itA->lay & layer)) {       // XXX  || (itA->node->ob == obedit)
+			if (itA->node->type == ID_OB) {
+				obc = itA->node->ob;
+				/* child moves */
+				if ((obc->recalc & OB_RECALC_ALL) == OB_RECALC_OB) {
+					/* parent has deforming info */
+					if (itA->type & (DAG_RL_OB_DATA | DAG_RL_DATA_DATA)) {
+						// printf("parent %s changes ob %s\n", ob->id.name, obc->id.name);
+						obc->recalc |= OB_RECALC_DATA;
+						lib_id_recalc_data_tag(bmain, &obc->id);
+					}
+				}
+			}
+		}
+	}
+
+	/* we only go deeper if node not checked or something changed  */
+	for (itA = node->child; itA; itA = itA->next) {
+		if (changed || itA->node->lasttime != curtime)
+			flush_update_node(bmain, itA->node, layer, curtime);
+	}
+
+}
+
+/* node was checked to have lasttime != curtime, and is of type ID_OB */
+static unsigned int flush_layer_node(Scene *sce, DagNode *node, int curtime)
+{
+	DagAdjList *itA;
+
+	node->lasttime = curtime;
+	node->lay = node->scelay;
+
+	for (itA = node->child; itA; itA = itA->next) {
+		if (itA->node->type == ID_OB) {
+			if (itA->node->lasttime != curtime) {
+				itA->lay = flush_layer_node(sce, itA->node, curtime);  /* lay is only set once for each relation */
+			}
+			else {
+				itA->lay = itA->node->lay;
+			}
+
+			node->lay |= itA->lay;
+		}
+	}
+
+	return node->lay;
+}
+
+/* node was checked to have lasttime != curtime, and is of type ID_OB */
+static void flush_pointcache_reset(Main *bmain, Scene *scene, DagNode *node,
+                                   int curtime, unsigned int lay, bool reset)
+{
+	DagAdjList *itA;
+	Object *ob;
+
+	node->lasttime = curtime;
+
+	for (itA = node->child; itA; itA = itA->next) {
+		if (itA->node->type == ID_OB) {
+			if (itA->node->lasttime != curtime) {
+				ob = (Object *)(itA->node->ob);
+
+				if (reset || (ob->recalc & OB_RECALC_ALL)) {
+					if (BKE_ptcache_object_reset(scene, ob, PTCACHE_RESET_DEPSGRAPH)) {
+						/* Don't tag nodes which are on invisible layer. */
+						if (itA->node->lay & lay) {
+							ob->recalc |= OB_RECALC_DATA;
+							lib_id_recalc_data_tag(bmain, &ob->id);
+						}
+					}
+
+					flush_pointcache_reset(bmain, scene, itA->node, curtime, lay, true);
+				}
+				else
+					flush_pointcache_reset(bmain, scene, itA->node, curtime, lay, false);
+			}
+		}
+	}
+}
+
+/* flush layer flags to dependencies */
+static void dag_scene_flush_layers(Scene *sce, int lay)
+{
+	DagNode *node, *firstnode;
+	DagAdjList *itA;
+	Base *base;
+	int lasttime;
+
+	firstnode = sce->theDag->DagNode.first;  /* always scene node */
+
+	for (itA = firstnode->child; itA; itA = itA->next)
+		itA->lay = 0;
+
+	sce->theDag->time++;  /* so we know which nodes were accessed */
+	lasttime = sce->theDag->time;
+
+	/* update layer flags in nodes */
+	for (base = sce->base.first; base; base = base->next) {
+		node = dag_get_node(sce->theDag, base->object);
+		node->scelay = base->object->lay;
+	}
+
+	/* ensure cameras are set as if they are on a visible layer, because
+	 * they ared still used for rendering or setting the camera view
+	 *
+	 * XXX, this wont work for local view / unlocked camera's */
+	if (sce->camera) {
+		node = dag_get_node(sce->theDag, sce->camera);
+		node->scelay |= lay;
+	}
+
+#ifdef DURIAN_CAMERA_SWITCH
+	{
+		TimeMarker *m;
+
+		for (m = sce->markers.first; m; m = m->next) {
+			if (m->camera) {
+				node = dag_get_node(sce->theDag, m->camera);
+				node->scelay |= lay;
+			}
+		}
+	}
+#endif
+
+	/* flush layer nodes to dependencies */
+	for (itA = firstnode->child; itA; itA = itA->next)
+		if (itA->node->lasttime != lasttime && itA->node->type == ID_OB)
+			flush_layer_node(sce, itA->node, lasttime);
+}
+
+static void dag_tag_renderlayers(Scene *sce, unsigned int lay)
+{
+	if (sce->nodetree) {
+		bNode *node;
+		Base *base;
+		unsigned int lay_changed = 0;
+
+		for (base = sce->base.first; base; base = base->next)
+			if (base->lay & lay)
+				if (base->object->recalc)
+					lay_changed |= base->lay;
+
+		for (node = sce->nodetree->nodes.first; node; node = node->next) {
+			if (node->id == (ID *)sce) {
+				SceneRenderLayer *srl = BLI_findlink(&sce->r.layers, node->custom1);
+				if (srl && (srl->lay & lay_changed))
+					nodeUpdate(sce->nodetree, node);
+			}
+		}
+	}
+}
+
+/* flushes all recalc flags in objects down the dependency tree */
+void DAG_scene_flush_update(Main *bmain, Scene *sce, unsigned int lay, const short time)
+{
+	DagNode *firstnode;
+	DagAdjList *itA;
+	Object *ob;
+	int lasttime;
+
+	if (!DEG_depsgraph_use_legacy()) {
+		DEG_scene_flush_update(bmain, sce);
+		return;
+	}
+
+	if (sce->theDag == NULL || sce->theDag->need_update) {
+		printf("DAG zero... not allowed to happen!\n");
+		DAG_scene_relations_update(bmain, sce);
+	}
+
+	firstnode = sce->theDag->DagNode.first;  /* always scene node */
+
+	/* first we flush the layer flags */
+	dag_scene_flush_layers(sce, lay);
+
+	/* then we use the relationships + layer info to flush update events */
+	sce->theDag->time++;  /* so we know which nodes were accessed */
+	lasttime = sce->theDag->time;
+	for (itA = firstnode->child; itA; itA = itA->next)
+		if (itA->node->lasttime != lasttime && itA->node->type == ID_OB)
+			flush_update_node(bmain, itA->node, lay, lasttime);
+
+	/* if update is not due to time change, do pointcache clears */
+	if (!time) {
+		sce->theDag->time++;  /* so we know which nodes were accessed */
+		lasttime = sce->theDag->time;
+		for (itA = firstnode->child; itA; itA = itA->next) {
+			if (itA->node->lasttime != lasttime && itA->node->type == ID_OB) {
+				ob = (Object *)(itA->node->ob);
+
+				if (ob->recalc & OB_RECALC_ALL) {
+					if (BKE_ptcache_object_reset(sce, ob, PTCACHE_RESET_DEPSGRAPH)) {
+						ob->recalc |= OB_RECALC_DATA;
+						lib_id_recalc_data_tag(bmain, &ob->id);
+					}
+
+					flush_pointcache_reset(bmain, sce, itA->node, lasttime,
+					                       lay, true);
+				}
+				else
+					flush_pointcache_reset(bmain, sce, itA->node, lasttime,
+					                       lay, false);
+			}
+		}
+	}
+
+	dag_tag_renderlayers(sce, lay);
+}
+
+static bool modifier_nlastrips_use_time(ListBase *strips)
+{
+	NlaStrip *strip;
+
+	if (strips) {
+		for (strip = strips->first; strip; strip = strip->next) {
+			if (modifier_nlastrips_use_time(&strip->strips)) {
+				return true;
+			}
+			else if (strip->act) {
+				FCurve *fcu;
+
+				for (fcu = strip->act->curves.first; fcu; fcu = fcu->next) {
+					if (fcu->rna_path && strstr(fcu->rna_path, "modifiers["))
+						return true;
+				}
+			}
+		}
+	}
+
+	return false;
+}
+
+static bool object_modifiers_use_time(Object *ob)
+{
+	ModifierData *md;
+
+	/* check if a modifier in modifier stack needs time input */
+	for (md = ob->modifiers.first; md; md = md->next) {
+		if (modifier_dependsOnTime(md))
+			return true;
+	}
+
+	/* check whether any modifiers are animated */
+	if (ob->adt) {
+		AnimData *adt = ob->adt;
+		NlaTrack *nlt;
+		FCurve *fcu;
+
+		/* action - check for F-Curves with paths containing 'modifiers[' */
+		if (adt->action) {
+			for (fcu = adt->action->curves.first; fcu; fcu = fcu->next) {
+				if (fcu->rna_path && strstr(fcu->rna_path, "modifiers["))
+					return true;
+			}
+		}
+
+		/* This here allows modifier properties to get driven and still update properly
+		 *
+		 * Workaround to get [#26764] (e.g. subsurf levels not updating when animated/driven)
+		 * working, without the updating problems ([#28525] [#28690] [#28774] [#28777]) caused
+		 * by the RNA updates cache introduced in r.38649
+		 */
+		for (fcu = adt->drivers.first; fcu; fcu = fcu->next) {
+			if (fcu->rna_path && strstr(fcu->rna_path, "modifiers["))
+				return true;
+		}
+
+		/* Also check NLA Strips... [#T45938] */
+		for (nlt = adt->nla_tracks.first; nlt; nlt = nlt->next) {
+			if (modifier_nlastrips_use_time(&nlt->strips))
+				return true;
+		}
+	}
+
+	return false;
+}
+
+static short animdata_use_time(AnimData *adt)
+{
+	NlaTrack *nlt;
+
+	if (adt == NULL) return 0;
+
+	/* check action - only if assigned, and it has anim curves */
+	if (adt->action && adt->action->curves.first)
+		return 1;
+
+	/* check NLA tracks + strips */
+	for (nlt = adt->nla_tracks.first; nlt; nlt = nlt->next) {
+		if (nlt->strips.first)
+			return 1;
+	}
+
+	/* If we have drivers, more likely than not, on a frame change
+	 * they'll need updating because their owner changed
+	 *
+	 * This is kindof a hack to get around a whole host of problems
+	 * involving drivers using non-object datablock data (which the
+	 * depsgraph currently has no way of representing let alone correctly
+	 * dependency sort+tagging). By doing this, at least we ensure that
+	 * some commonly attempted drivers (such as scene -> current frame;
+	 * see "Driver updates fail" thread on Bf-committers dated July 2)
+	 * will work correctly, and that other non-object datablocks will have
+	 * their drivers update at least on frame change.
+	 *
+	 * -- Aligorith, July 4 2011
+	 */
+	if (adt->drivers.first)
+		return 1;
+
+	return 0;
+}
+
+static void dag_object_time_update_flags(Main *bmain, Scene *scene, Object *ob)
+{
+	if (ob->constraints.first) {
+		bConstraint *con;
+		for (con = ob->constraints.first; con; con = con->next) {
+			const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
+			ListBase targets = {NULL, NULL};
+			bConstraintTarget *ct;
+
+			if (cti) {
+				/* special case for camera tracking -- it doesn't use targets to define relations */
+				if (ELEM(cti->type,
+				         CONSTRAINT_TYPE_FOLLOWTRACK,
+				         CONSTRAINT_TYPE_CAMERASOLVER,
+				         CONSTRAINT_TYPE_OBJECTSOLVER,
+				         CONSTRAINT_TYPE_TRANSFORM_CACHE))
+				{
+					ob->recalc |= OB_RECALC_OB;
+				}
+				else if (cti->get_constraint_targets) {
+					cti->get_constraint_targets(con, &targets);
+
+					for (ct = targets.first; ct; ct = ct->next) {
+						if (ct->tar) {
+							ob->recalc |= OB_RECALC_OB;
+							break;
+						}
+					}
+
+					if (cti->flush_constraint_targets)
+						cti->flush_constraint_targets(con, &targets, 1);
+				}
+
+			}
+		}
+	}
+
+	if (ob->parent) {
+		/* motion path or bone child */
+		if (ob->parent->type == OB_CURVE || ob->parent->type == OB_ARMATURE) ob->recalc |= OB_RECALC_OB;
+	}
+
+#if 0 // XXX old animation system
+	if (ob->nlastrips.first) {
+		if (ob->dup_group) {
+			bActionStrip *strip;
+			/* this case is for groups with nla, whilst nla target has no action or nla */
+			for (strip = ob->nlastrips.first; strip; strip = strip->next) {
+				if (strip->object)
+					strip->object->recalc |= OB_RECALC_ALL;
+			}
+		}
+	}
+#endif // XXX old animation system
+
+	if (animdata_use_time(ob->adt)) {
+		ob->recalc |= OB_RECALC_OB;
+		ob->adt->recalc |= ADT_RECALC_ANIM;
+	}
+
+	if ((ob->adt) && (ob->type == OB_ARMATURE)) ob->recalc |= OB_RECALC_DATA;
+
+	if (object_modifiers_use_time(ob)) ob->recalc |= OB_RECALC_DATA;
+	if ((ob->pose) && (ob->pose->flag & POSE_CONSTRAINTS_TIMEDEPEND)) ob->recalc |= OB_RECALC_DATA;
+
+	// XXX: scene here may not be the scene that contains the rigidbody world affecting this!
+	if (ob->rigidbody_object && BKE_scene_check_rigidbody_active(scene))
+		ob->recalc |= OB_RECALC_OB;
+
+	{
+		AnimData *adt = BKE_animdata_from_id((ID *)ob->data);
+		Mesh *me;
+		Curve *cu;
+		Lattice *lt;
+
+		switch (ob->type) {
+			case OB_MESH:
+				me = ob->data;
+				if (me->key) {
+					if (!(ob->shapeflag & OB_SHAPE_LOCK)) {
+						ob->recalc |= OB_RECALC_DATA;
+					}
+				}
+				if (ob->particlesystem.first)
+					ob->recalc |= OB_RECALC_DATA;
+				break;
+			case OB_CURVE:
+			case OB_SURF:
+				cu = ob->data;
+				if (cu->key) {
+					if (!(ob->shapeflag & OB_SHAPE_LOCK)) {
+						ob->recalc |= OB_RECALC_DATA;
+					}
+				}
+				break;
+			case OB_FONT:
+				cu = ob->data;
+				if (cu->str && cu->vfont) {
+					/* Can be in the curve-cache or the curve. */
+					if (ob->curve_cache && !BLI_listbase_is_empty(&ob->curve_cache->disp)) {
+						/* pass */
+					}
+					else if (!BLI_listbase_is_empty(&cu->nurb)) {
+						/* pass */
+					}
+					else {
+						ob->recalc |= OB_RECALC_DATA;
+					}
+				}
+				break;
+			case OB_LATTICE:
+				lt = ob->data;
+				if (lt->key) {
+					if (!(ob->shapeflag & OB_SHAPE_LOCK)) {
+						ob->recalc |= OB_RECALC_DATA;
+					}
+				}
+				break;
+			case OB_MBALL:
+				if (ob->transflag & OB_DUPLI) ob->recalc |= OB_RECALC_DATA;
+				break;
+			case OB_EMPTY:
+				/* update animated images */
+				if (ob->empty_drawtype == OB_EMPTY_IMAGE && ob->data)
+					if (BKE_image_is_animated(ob->data))
+						ob->recalc |= OB_RECALC_DATA;
+				break;
+		}
+
+		if (animdata_use_time(adt)) {
+			ob->recalc |= OB_RECALC_DATA;
+			adt->recalc |= ADT_RECALC_ANIM;
+		}
+
+		if (ob->particlesystem.first) {
+			ParticleSystem *psys = ob->particlesystem.first;
+
+			for (; psys; psys = psys->next) {
+				if (psys_check_enabled(ob, psys, G.is_rendering)) {
+					ob->recalc |= OB_RECALC_DATA;
+					break;
+				}
+			}
+		}
+	}
+
+	if (ob->recalc & OB_RECALC_OB)
+		lib_id_recalc_tag(bmain, &ob->id);
+	if (ob->recalc & OB_RECALC_DATA)
+		lib_id_recalc_data_tag(bmain, &ob->id);
+
+}
+
+/* recursively update objects in groups, each group is done at most once */
+static void dag_group_update_flags(Main *bmain, Scene *scene, Group *group, const bool do_time)
+{
+	GroupObject *go;
+
+	if (group->id.tag & LIB_TAG_DOIT)
+		return;
+
+	group->id.tag |= LIB_TAG_DOIT;
+
+	for (go = group->gobject.first; go; go = go->next) {
+		if (do_time)
+			dag_object_time_update_flags(bmain, scene, go->ob);
+		if (go->ob->dup_group)
+			dag_group_update_flags(bmain, scene, go->ob->dup_group, do_time);
+	}
+}
+
+/* flag all objects that need recalc, for changes in time for example */
+/* do_time: make this optional because undo resets objects to their animated locations without this */
+void DAG_scene_update_flags(Main *bmain, Scene *scene, unsigned int lay, const bool do_time, const bool do_invisible_flush)
+{
+	Base *base;
+	Object *ob;
+	Group *group;
+	GroupObject *go;
+	Scene *sce_iter;
+
+	BKE_main_id_tag_idcode(bmain, ID_GR, LIB_TAG_DOIT, false);
+
+	/* set ob flags where animated systems are */
+	for (SETLOOPER(scene, sce_iter, base)) {
+		ob = base->object;
+
+		if (do_time) {
+			/* now if DagNode were part of base, the node->lay could be checked... */
+			/* we do all now, since the scene_flush checks layers and clears recalc flags even */
+
+			/* NOTE: "sce_iter" not "scene" so that rigidbodies in background scenes work
+			 * (i.e. muting + rbw availability can be checked and tagged properly) [#33970]
+			 */
+			dag_object_time_update_flags(bmain, sce_iter, ob);
+		}
+
+		/* recursively tag groups with LIB_TAG_DOIT, and update flags for objects */
+		if (ob->dup_group)
+			dag_group_update_flags(bmain, scene, ob->dup_group, do_time);
+	}
+
+	for (sce_iter = scene; sce_iter; sce_iter = sce_iter->set)
+		DAG_scene_flush_update(bmain, sce_iter, lay, 1);
+
+	if (do_time) {
+		/* test: set time flag, to disable baked systems to update */
+		for (SETLOOPER(scene, sce_iter, base)) {
+			ob = base->object;
+			if (ob->recalc & OB_RECALC_ALL)
+				ob->recalc |= OB_RECALC_TIME;
+		}
+
+		/* hrmf... an exception to look at once, for invisible camera object we do it over */
+		if (scene->camera)
+			dag_object_time_update_flags(bmain, scene, scene->camera);
+	}
+
+	/* and store the info in groupobject */
+	for (group = bmain->group.first; group; group = group->id.next) {
+		if (group->id.tag & LIB_TAG_DOIT) {
+			for (go = group->gobject.first; go; go = go->next) {
+				go->recalc = go->ob->recalc;
+				// printf("ob %s recalc %d\n", go->ob->id.name, go->recalc);
+			}
+			group->id.tag &= ~LIB_TAG_DOIT;
+		}
+	}
+
+	if (do_invisible_flush) {
+		dag_invisible_dependencies_check_flush(bmain, scene);
+	}
+}
+
+/* struct returned by DagSceneLayer */
+typedef struct DagSceneLayer {
+	struct DagSceneLayer *next, *prev;
+	Scene *scene;
+	unsigned int layer;
+} DagSceneLayer;
+
+/* returns visible scenes with valid DAG */
+static void dag_current_scene_layers(Main *bmain, ListBase *lb)
+{
+	wmWindowManager *wm;
+	wmWindow *win;
+
+	BLI_listbase_clear(lb);
+
+	/* if we have a windowmanager, look into windows */
+	if ((wm = bmain->wm.first)) {
+
+		BKE_main_id_flag_listbase(&bmain->scene, LIB_TAG_DOIT, 1);
+
+		for (win = wm->windows.first; win; win = win->next) {
+			if (win->screen && win->screen->scene->theDag) {
+				Scene *scene = win->screen->scene;
+				DagSceneLayer *dsl;
+
+				if (scene->id.tag & LIB_TAG_DOIT) {
+					dsl = MEM_mallocN(sizeof(DagSceneLayer), "dag scene layer");
+
+					BLI_addtail(lb, dsl);
+
+					dsl->scene = scene;
+					dsl->layer = BKE_screen_visible_layers(win->screen, scene);
+
+					scene->id.tag &= ~LIB_TAG_DOIT;
+				}
+				else {
+					/* It is possible that multiple windows shares the same scene
+					 * and have different layers visible.
+					 *
+					 * Here we deal with such cases by squashing layers bits from
+					 * multiple windoew to the DagSceneLayer.
+					 *
+					 * TODO(sergey): Such a lookup could be optimized perhaps,
+					 * however should be fine for now since we usually have only
+					 * few open windows.
+					 */
+					for (dsl = lb->first; dsl; dsl = dsl->next) {
+						if (dsl->scene == scene) {
+							dsl->layer |= BKE_screen_visible_layers(win->screen, scene);
+							break;
+						}
+					}
+				}
+			}
+		}
+	}
+	else {
+		/* if not, use the first sce */
+		DagSceneLayer *dsl = MEM_mallocN(sizeof(DagSceneLayer), "dag scene layer");
+
+		BLI_addtail(lb, dsl);
+
+		dsl->scene = bmain->scene.first;
+		dsl->layer = dsl->scene->lay;
+
+		/* XXX for background mode, we should get the scene
+		 * from somewhere, for the -S option, but it's in
+		 * the context, how to get it here? */
+	}
+}
+
+static void dag_group_on_visible_update(Scene *scene, Group *group)
+{
+	GroupObject *go;
+
+	if (group->id.tag & LIB_TAG_DOIT)
+		return;
+
+	group->id.tag |= LIB_TAG_DOIT;
+
+	for (go = group->gobject.first; go; go = go->next) {
+		if (ELEM(go->ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT, OB_MBALL, OB_LATTICE)) {
+			go->ob->recalc |= OB_RECALC_DATA;
+			go->ob->id.tag |= LIB_TAG_DOIT;
+			lib_id_recalc_tag(G.main, &go->ob->id);
+		}
+		if (go->ob->proxy_from) {
+			go->ob->recalc |= OB_RECALC_OB;
+			go->ob->id.tag |= LIB_TAG_DOIT;
+			lib_id_recalc_tag(G.main, &go->ob->id);
+		}
+
+		if (go->ob->dup_group)
+			dag_group_on_visible_update(scene, go->ob->dup_group);
+	}
+}
+
+void DAG_on_visible_update(Main *bmain, const bool do_time)
+{
+	ListBase listbase;
+	DagSceneLayer *dsl;
+
+	if (!DEG_depsgraph_use_legacy()) {
+		/* Inform new dependnecy graphs about visibility changes. */
+		DEG_on_visible_update(bmain, do_time);
+		return;
+	}
+
+	/* get list of visible scenes and layers */
+	dag_current_scene_layers(bmain, &listbase);
+
+	for (dsl = listbase.first; dsl; dsl = dsl->next) {
+		Scene *scene = dsl->scene;
+		Scene *sce_iter;
+		Base *base;
+		Object *ob;
+		DagNode *node;
+		unsigned int lay = dsl->layer, oblay;
+
+		/* derivedmeshes and displists are not saved to file so need to be
+		 * remade, tag them so they get remade in the scene update loop,
+		 * note armature poses or object matrices are preserved and do not
+		 * require updates, so we skip those */
+		for (sce_iter = scene; sce_iter; sce_iter = sce_iter->set)
+			dag_scene_flush_layers(sce_iter, lay);
+
+		BKE_main_id_tag_idcode(bmain, ID_GR, LIB_TAG_DOIT, false);
+
+		for (SETLOOPER(scene, sce_iter, base)) {
+			ob = base->object;
+			node = (sce_iter->theDag) ? dag_get_node(sce_iter->theDag, ob) : NULL;
+			oblay = (node) ? node->lay : ob->lay;
+
+			if ((oblay & lay) & ~scene->lay_updated) {
+				/* TODO(sergey): Why do we need armature here now but didn't need before? */
+				if (ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT, OB_MBALL, OB_LATTICE, OB_ARMATURE)) {
+					ob->recalc |= OB_RECALC_DATA;
+					lib_id_recalc_tag(bmain, &ob->id);
+				}
+				/* This should not be needed here, but in some cases, like after a redo, we can end up with
+				 * a wrong final matrix (see T42472).
+				 * Quoting Sergey, this comes from BKE_object_handle_update_ex, which is calling
+				 * BKE_object_where_is_calc_ex when it shouldn't, but that issue is not easily fixable.
+				 */
+				else {
+					ob->recalc |= OB_RECALC_OB;
+					lib_id_recalc_tag(bmain, &ob->id);
+				}
+				if (ob->proxy && (ob->proxy_group == NULL)) {
+					ob->proxy->recalc |= OB_RECALC_DATA;
+					lib_id_recalc_tag(bmain, &ob->id);
+				}
+				if (ob->dup_group)
+					dag_group_on_visible_update(scene, ob->dup_group);
+			}
+		}
+
+		BKE_main_id_tag_idcode(bmain, ID_GR, LIB_TAG_DOIT, false);
+
+		/* now tag update flags, to ensure deformers get calculated on redraw */
+		DAG_scene_update_flags(bmain, scene, lay, do_time, true);
+		scene->lay_updated |= lay;
+	}
+
+	BLI_freelistN(&listbase);
+
+	/* hack to get objects updating on layer changes */
+	DAG_id_type_tag(bmain, ID_OB);
+
+	/* so masks update on load */
+	if (bmain->mask.first) {
+		Mask *mask;
+
+		for (mask = bmain->mask.first; mask; mask = mask->id.next) {
+			DAG_id_tag_update(&mask->id, 0);
+		}
+	}
+}
+
+static void dag_id_flush_update__isDependentTexture(
+        void *userData, Object *UNUSED(ob), ID **idpoin, int UNUSED(cb_flag))
+{
+	struct { ID *id; bool is_dependent; } *data = userData;
+
+	if (*idpoin && GS((*idpoin)->name) == ID_TE) {
+		if (data->id == (*idpoin))
+			data->is_dependent = 1;
+	}
+}
+
+static void dag_id_flush_update(Main *bmain, Scene *sce, ID *id)
+{
+	Object *obt, *ob = NULL;
+	short idtype;
+
+	/* here we flush a few things before actual scene wide flush, mostly
+	 * due to only objects and not other datablocks being in the depsgraph */
+
+	/* set flags & pointcache for object */
+	if (GS(id->name) == ID_OB) {
+		ob = (Object *)id;
+		BKE_ptcache_object_reset(sce, ob, PTCACHE_RESET_DEPSGRAPH);
+
+		/* So if someone tagged object recalc directly,
+		 * id_tag_update bit-field stays relevant
+		 */
+		if (ob->recalc & OB_RECALC_ALL) {
+			DAG_id_type_tag(bmain, GS(id->name));
+		}
+
+		if (ob->recalc & OB_RECALC_DATA) {
+			/* all users of this ob->data should be checked */
+			id = ob->data;
+
+			/* no point in trying in this cases */
+			if (id && id->us <= 1) {
+				dag_editors_id_update(bmain, id);
+				id = NULL;
+			}
+		}
+	}
+
+	/* set flags & pointcache for object data */
+	if (id) {
+		idtype = GS(id->name);
+
+
+		if (OB_DATA_SUPPORT_ID(idtype)) {
+			for (obt = bmain->object.first; obt; obt = obt->id.next) {
+				if (!(ob && obt == ob) && obt->data == id) {
+					obt->recalc |= OB_RECALC_DATA;
+					lib_id_recalc_data_tag(bmain, &obt->id);
+					BKE_ptcache_object_reset(sce, obt, PTCACHE_RESET_DEPSGRAPH);
+				}
+			}
+		}
+		else if (idtype == ID_VF) {
+			for (obt = bmain->object.first; obt; obt = obt->id.next) {
+				if (obt->type == OB_FONT) {
+					Curve *cu = obt->data;
+					if (ELEM((struct VFont *)id, CURVE_VFONT_ANY(cu))) {
+						obt->recalc |= OB_RECALC_DATA;
+						lib_id_recalc_data_tag(bmain, &obt->id);
+					}
+				}
+			}
+		}
+
+		/* set flags based on textures - can influence depgraph via modifiers */
+		if (idtype == ID_TE) {
+			for (obt = bmain->object.first; obt; obt = obt->id.next) {
+				struct { ID *id; bool is_dependent; } data;
+				data.id = id;
+				data.is_dependent = 0;
+
+				modifiers_foreachIDLink(obt, dag_id_flush_update__isDependentTexture, &data);
+				if (data.is_dependent) {
+					obt->recalc |= OB_RECALC_DATA;
+					lib_id_recalc_data_tag(bmain, &obt->id);
+				}
+
+				/* particle settings can use the texture as well */
+				if (obt->particlesystem.first) {
+					ParticleSystem *psys = obt->particlesystem.first;
+					MTex **mtexp, *mtex;
+					int a;
+					for (; psys; psys = psys->next) {
+						mtexp = psys->part->mtex;
+						for (a = 0; a < MAX_MTEX; a++, mtexp++) {
+							mtex = *mtexp;
+							if (mtex && mtex->tex == (Tex *)id) {
+								obt->recalc |= OB_RECALC_DATA;
+								lib_id_recalc_data_tag(bmain, &obt->id);
+
+								if (mtex->mapto & PAMAP_INIT)
+									psys->recalc |= PSYS_RECALC_RESET;
+								if (mtex->mapto & PAMAP_CHILD)
+									psys->recalc |= PSYS_RECALC_CHILD;
+
+								BKE_ptcache_object_reset(sce, obt, PTCACHE_RESET_DEPSGRAPH);
+							}
+						}
+					}
+				}
+			}
+		}
+
+		/* set flags based on ShapeKey */
+		if (idtype == ID_KE) {
+			for (obt = bmain->object.first; obt; obt = obt->id.next) {
+				Key *key = BKE_key_from_object(obt);
+				if (!(ob && obt == ob) && ((ID *)key == id)) {
+					obt->flag |= (OB_RECALC_OB | OB_RECALC_DATA);
+					lib_id_recalc_tag(bmain, &obt->id);
+					lib_id_recalc_data_tag(bmain, &obt->id);
+					BKE_ptcache_object_reset(sce, obt, PTCACHE_RESET_DEPSGRAPH);
+				}
+			}
+		}
+
+		/* set flags based on particle settings */
+		if (idtype == ID_PA) {
+			ParticleSystem *psys;
+			for (obt = bmain->object.first; obt; obt = obt->id.next)
+				for (psys = obt->particlesystem.first; psys; psys = psys->next)
+					if (&psys->part->id == id)
+						BKE_ptcache_object_reset(sce, obt, PTCACHE_RESET_DEPSGRAPH);
+		}
+
+		if (ELEM(idtype, ID_MA, ID_TE)) {
+			obt = sce->basact ? sce->basact->object : NULL;
+			if (obt && obt->mode & OB_MODE_TEXTURE_PAINT) {
+				BKE_texpaint_slots_refresh_object(sce, obt);
+				BKE_paint_proj_mesh_data_check(sce, obt, NULL, NULL, NULL, NULL);
+				GPU_drawobject_free(obt->derivedFinal);
+			}
+		}
+
+		if (idtype == ID_MC) {
+			MovieClip *clip = (MovieClip *) id;
+
+			BKE_tracking_dopesheet_tag_update(&clip->tracking);
+
+			for (obt = bmain->object.first; obt; obt = obt->id.next) {
+				bConstraint *con;
+				for (con = obt->constraints.first; con; con = con->next) {
+					const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
+					if (ELEM(cti->type, CONSTRAINT_TYPE_FOLLOWTRACK, CONSTRAINT_TYPE_CAMERASOLVER,
+					          CONSTRAINT_TYPE_OBJECTSOLVER))
+					{
+						obt->recalc |= OB_RECALC_OB;
+						lib_id_recalc_tag(bmain, &obt->id);
+						break;
+					}
+				}
+			}
+
+			if (sce->nodetree) {
+				bNode *node;
+
+				for (node = sce->nodetree->nodes.first; node; node = node->next) {
+					if (node->id == id) {
+						nodeUpdate(sce->nodetree, node);
+					}
+				}
+			}
+		}
+
+		/* Not pretty to iterate all the nodes here, but it's as good as it
+		 * could be with the current depsgraph design/
+		 */
+		if (idtype == ID_IM) {
+			FOREACH_NODETREE(bmain, ntree, parent_id) {
+				if (ntree->type == NTREE_SHADER) {
+					bNode *node;
+					for (node = ntree->nodes.first; node; node = node->next) {
+						if (node->id == id) {
+							lib_id_recalc_tag(bmain, &ntree->id);
+							break;
+						}
+					}
+				}
+			} FOREACH_NODETREE_END
+		}
+
+		if (idtype == ID_MSK) {
+			if (sce->nodetree) {
+				bNode *node;
+
+				for (node = sce->nodetree->nodes.first; node; node = node->next) {
+					if (node->id == id) {
+						nodeUpdate(sce->nodetree, node);
+					}
+				}
+			}
+		}
+
+		/* camera's matrix is used to orient reconstructed stuff,
+		 * so it should happen tracking-related constraints recalculation
+		 * when camera is changing (sergey) */
+		if (sce->camera && &sce->camera->id == id) {
+			MovieClip *clip = BKE_object_movieclip_get(sce, sce->camera, true);
+
+			if (clip)
+				dag_id_flush_update(bmain, sce, &clip->id);
+		}
+
+		/* update editors */
+		dag_editors_id_update(bmain, id);
+	}
+}
+
+void DAG_ids_flush_tagged(Main *bmain)
+{
+	ListBase listbase;
+	DagSceneLayer *dsl;
+	ListBase *lbarray[MAX_LIBARRAY];
+	int a;
+	bool do_flush = false;
+
+	if (!DEG_depsgraph_use_legacy()) {
+		DEG_ids_flush_tagged(bmain);
+		return;
+	}
+
+	/* get list of visible scenes and layers */
+	dag_current_scene_layers(bmain, &listbase);
+
+	if (BLI_listbase_is_empty(&listbase))
+		return;
+
+	/* loop over all ID types */
+	a  = set_listbasepointers(bmain, lbarray);
+
+	while (a--) {
+		ListBase *lb = lbarray[a];
+		ID *id = lb->first;
+
+		if (id && bmain->id_tag_update[BKE_idcode_to_index(GS(id->name))]) {
+			for (; id; id = id->next) {
+				if (id->recalc & ID_RECALC_ALL) {
+					for (dsl = listbase.first; dsl; dsl = dsl->next)
+						dag_id_flush_update(bmain, dsl->scene, id);
+
+					do_flush = true;
+				}
+			}
+		}
+	}
+
+	/* flush changes to other objects */
+	if (do_flush) {
+		for (dsl = listbase.first; dsl; dsl = dsl->next)
+			DAG_scene_flush_update(bmain, dsl->scene, dsl->layer, 0);
+	}
+
+	BLI_freelistN(&listbase);
+}
+
+void DAG_ids_check_recalc(Main *bmain, Scene *scene, bool time)
+{
+	ListBase *lbarray[MAX_LIBARRAY];
+	int a;
+	bool updated = false;
+
+	if (!DEG_depsgraph_use_legacy()) {
+		DEG_ids_check_recalc(bmain, scene, time);
+		return;
+	}
+
+	/* loop over all ID types */
+	a  = set_listbasepointers(bmain, lbarray);
+
+	while (a--) {
+		ListBase *lb = lbarray[a];
+		ID *id = lb->first;
+
+		if (id && bmain->id_tag_update[BKE_idcode_to_index(GS(id->name))]) {
+			updated = true;
+			break;
+		}
+	}
+
+	dag_editors_scene_update(bmain, scene, (updated || time));
+}
+
+/* It is possible that scene_update_post and frame_update_post handlers
+ * will modify objects. The issue is that DAG_ids_clear_recalc is called
+ * just after callbacks, which leaves objects with recalc flags but no
+ * corresponding bit in ID recalc bitfield. This leads to some kind of
+ * regression when using ID type tag fields to check whether there objects
+ * to be updated internally comparing threaded DAG with legacy one.
+ *
+ * For now let's have a workaround which will preserve tag for ID_OB
+ * if there're objects with OB_RECALC_ALL bits. This keeps behavior
+ * unchanged comparing with 2.69 release.
+ *
+ * TODO(sergey): Need to get rid of such a workaround.
+ *
+ *                                                 - sergey -
+ */
+
+#define POST_UPDATE_HANDLER_WORKAROUND
+
+void DAG_ids_clear_recalc(Main *bmain)
+{
+	ListBase *lbarray[MAX_LIBARRAY];
+	bNodeTree *ntree;
+	int a;
+
+#ifdef POST_UPDATE_HANDLER_WORKAROUND
+	bool have_updated_objects = false;
+
+	if (DAG_id_type_tagged(bmain, ID_OB)) {
+		ListBase listbase;
+		DagSceneLayer *dsl;
+
+		/* We need to check all visible scenes, otherwise resetting
+		 * OB_ID changed flag will only work fine for first scene of
+		 * multiple visible and all the rest will skip update.
+		 *
+		 * This could also lead to wrong behavior scene update handlers
+		 * because of missing ID datablock changed flags.
+		 *
+		 * This is a bit of a bummer to allocate list here, but likely
+		 * it wouldn't become too much bad because it only happens when
+		 * objects were actually changed.
+		 */
+		dag_current_scene_layers(bmain, &listbase);
+
+		for (dsl = listbase.first; dsl; dsl = dsl->next) {
+			Scene *scene = dsl->scene;
+			DagNode *node;
+			for (node = scene->theDag->DagNode.first;
+			     node != NULL && have_updated_objects == false;
+			     node = node->next)
+			{
+				if (node->type == ID_OB) {
+					Object *object = (Object *) node->ob;
+					if (object->recalc & OB_RECALC_ALL) {
+						have_updated_objects = true;
+						break;
+					}
+				}
+			}
+		}
+
+		BLI_freelistN(&listbase);
+	}
+#endif
+
+	/* loop over all ID types */
+	a  = set_listbasepointers(bmain, lbarray);
+
+	while (a--) {
+		ListBase *lb = lbarray[a];
+		ID *id = lb->first;
+
+		if (id && bmain->id_tag_update[BKE_idcode_to_index(GS(id->name))]) {
+			for (; id; id = id->next) {
+				id->recalc &= ~ID_RECALC_ALL;
+
+				/* some ID's contain semi-datablock nodetree */
+				ntree = ntreeFromID(id);
+				if (ntree)
+					ntree->id.recalc &= ~ID_RECALC_ALL;
+			}
+		}
+	}
+
+	memset(bmain->id_tag_update, 0, sizeof(bmain->id_tag_update));
+
+#ifdef POST_UPDATE_HANDLER_WORKAROUND
+	if (have_updated_objects) {
+		DAG_id_type_tag(bmain, ID_OB);
+	}
+#endif
+}
+
+void DAG_id_tag_update_ex(Main *bmain, ID *id, short flag)
+{
+	if (!DEG_depsgraph_use_legacy()) {
+		DEG_id_tag_update_ex(bmain, id, flag);
+		return;
+	}
+
+	if (id == NULL) return;
+
+	if (G.debug & G_DEBUG_DEPSGRAPH_TAG) {
+		printf("%s: id=%s flag=%d\n", __func__, id->name, flag);
+	}
+
+	/* tag ID for update */
+	if (flag) {
+		if (flag & OB_RECALC_OB)
+			lib_id_recalc_tag(bmain, id);
+		if (flag & (OB_RECALC_DATA | PSYS_RECALC))
+			lib_id_recalc_data_tag(bmain, id);
+	}
+	else
+		lib_id_recalc_tag(bmain, id);
+
+	/* flag is for objects and particle systems */
+	if (flag) {
+		Object *ob;
+		short idtype = GS(id->name);
+
+		if (idtype == ID_OB) {
+			/* only quick tag */
+			ob = (Object *)id;
+			ob->recalc |= (flag & OB_RECALC_ALL);
+		}
+		else if (idtype == ID_PA) {
+			ParticleSystem *psys;
+			/* this is weak still, should be done delayed as well */
+			for (ob = bmain->object.first; ob; ob = ob->id.next) {
+				for (psys = ob->particlesystem.first; psys; psys = psys->next) {
+					if (&psys->part->id == id) {
+						ob->recalc |= (flag & OB_RECALC_ALL);
+						psys->recalc |= (flag & PSYS_RECALC);
+						lib_id_recalc_tag(bmain, &ob->id);
+						lib_id_recalc_data_tag(bmain, &ob->id);
+					}
+				}
+			}
+		}
+		else {
+			/* disable because this is called on various ID types automatically.
+			 * where printing warning is not useful. for now just ignore */
+			/* BLI_assert(!"invalid flag for this 'idtype'"); */
+		}
+	}
+	else if (GS(id->name) == ID_CF) {
+		for (Object *ob = bmain->object.first; ob; ob = ob->id.next) {
+			ModifierData *md = modifiers_findByType(ob, eModifierType_MeshSequenceCache);
+
+			if (md) {
+				MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *)md;
+
+				if (mcmd->cache_file && (&mcmd->cache_file->id == id)) {
+					ob->recalc |= OB_RECALC_ALL;
+					continue;
+				}
+			}
+
+			for (bConstraint *con = ob->constraints.first; con; con = con->next) {
+				if (con->type != CONSTRAINT_TYPE_TRANSFORM_CACHE) {
+					continue;
+				}
+
+				bTransformCacheConstraint *data = con->data;
+
+				if (data->cache_file && (&data->cache_file->id == id)) {
+					ob->recalc |= OB_RECALC_ALL;
+					break;
+				}
+			}
+		}
+	}
+}
+
+void DAG_id_tag_update(ID *id, short flag)
+{
+	DAG_id_tag_update_ex(G.main, id, flag);
+}
+
+void DAG_id_type_tag(Main *bmain, short idtype)
+{
+	if (idtype == ID_NT) {
+		/* stupid workaround so parent datablocks of nested nodetree get looped
+		 * over when we loop over tagged datablock types */
+		DAG_id_type_tag(bmain, ID_MA);
+		DAG_id_type_tag(bmain, ID_TE);
+		DAG_id_type_tag(bmain, ID_LA);
+		DAG_id_type_tag(bmain, ID_WO);
+		DAG_id_type_tag(bmain, ID_SCE);
+	}
+
+	atomic_fetch_and_or_uint8((uint8_t *)&bmain->id_tag_update[BKE_idcode_to_index(idtype)], 1);
+}
+
+int DAG_id_type_tagged(Main *bmain, short idtype)
+{
+	return bmain->id_tag_update[BKE_idcode_to_index(idtype)];
+}
+
+#if 0 // UNUSED
+/* recursively descends tree, each node only checked once */
+/* node is checked to be of type object */
+static int parent_check_node(DagNode *node, int curtime)
+{
+	DagAdjList *itA;
+
+	node->lasttime = curtime;
+
+	if (node->color == DAG_GRAY)
+		return DAG_GRAY;
+
+	for (itA = node->child; itA; itA = itA->next) {
+		if (itA->node->type == ID_OB) {
+
+			if (itA->node->color == DAG_GRAY)
+				return DAG_GRAY;
+
+			/* descend if not done */
+			if (itA->node->lasttime != curtime) {
+				itA->node->color = parent_check_node(itA->node, curtime);
+
+				if (itA->node->color == DAG_GRAY)
+					return DAG_GRAY;
+			}
+		}
+	}
+
+	return DAG_WHITE;
+}
+#endif
+
+/* ******************* DAG FOR ARMATURE POSE ***************** */
+
+/* we assume its an armature with pose */
+void DAG_pose_sort(Object *ob)
+{
+	bPose *pose = ob->pose;
+	bPoseChannel *pchan;
+	bConstraint *con;
+	DagNode *node;
+	DagNode *node2, *node3;
+	DagNode *rootnode;
+	DagForest *dag;
+	DagNodeQueue *nqueue;
+	DagAdjList *itA;
+	ListBase tempbase;
+	int skip = 0;
+
+	dag = dag_init();
+	dag->ugly_hack_sorry = false;  /* no ID structs */
+
+	rootnode = dag_add_node(dag, NULL);  /* node->ob becomes NULL */
+
+	/* we add the hierarchy and the constraints */
+	for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
+		int addtoroot = 1;
+
+		node = dag_get_node(dag, pchan);
+
+		if (pchan->parent) {
+			node2 = dag_get_node(dag, pchan->parent);
+			dag_add_relation(dag, node2, node, 0, "Parent Relation");
+			addtoroot = 0;
+		}
+		for (con = pchan->constraints.first; con; con = con->next) {
+			const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
+			ListBase targets = {NULL, NULL};
+			bConstraintTarget *ct;
+
+			if (cti && cti->get_constraint_targets) {
+				cti->get_constraint_targets(con, &targets);
+
+				for (ct = targets.first; ct; ct = ct->next) {
+					if (ct->tar == ob && ct->subtarget[0]) {
+						bPoseChannel *target = BKE_pose_channel_find_name(ob->pose, ct->subtarget);
+						if (target) {
+							node2 = dag_get_node(dag, target);
+							dag_add_relation(dag, node2, node, 0, "Pose Constraint");
+
+							if (con->type == CONSTRAINT_TYPE_KINEMATIC) {
+								bKinematicConstraint *data = (bKinematicConstraint *)con->data;
+								bPoseChannel *parchan;
+								int segcount = 0;
+
+								/* exclude tip from chain? */
+								if (!(data->flag & CONSTRAINT_IK_TIP))
+									parchan = pchan->parent;
+								else
+									parchan = pchan;
+
+								/* Walk to the chain's root */
+								while (parchan) {
+									node3 = dag_get_node(dag, parchan);
+									dag_add_relation(dag, node2, node3, 0, "IK Constraint");
+
+									segcount++;
+									if (segcount == data->rootbone || segcount > 255) break;  /* 255 is weak */
+									parchan = parchan->parent;
+								}
+							}
+						}
+					}
+				}
+
+				if (cti->flush_constraint_targets)
+					cti->flush_constraint_targets(con, &targets, 1);
+			}
+		}
+		if (addtoroot == 1) {
+			dag_add_relation(dag, rootnode, node, 0, "Root Bone Relation");
+		}
+	}
+
+	dag_check_cycle(dag);
+
+	/* now we try to sort... */
+	BLI_listbase_clear(&tempbase);
+
+	nqueue = queue_create(DAGQUEUEALLOC);
+
+	/* tag nodes unchecked */
+	for (node = dag->DagNode.first; node; node = node->next)
+		node->color = DAG_WHITE;
+
+	rootnode->color = DAG_GRAY;
+	push_stack(nqueue, rootnode);
+
+	while (nqueue->count) {
+
+		skip = 0;
+		node = get_top_node_queue(nqueue);
+
+		itA = node->child;
+		while (itA != NULL) {
+			if (itA->node->color == DAG_WHITE) {
+				itA->node->color = DAG_GRAY;
+				push_stack(nqueue, itA->node);
+				skip = 1;
+				break;
+			}
+			itA = itA->next;
+		}
+
+		if (!skip) {
+			if (node) {
+				node = pop_queue(nqueue);
+				if (node->ob == NULL)  /* we are done */
+					break;
+				node->color = DAG_BLACK;
+
+				/* put node in new list */
+				BLI_remlink(&pose->chanbase, node->ob);
+				BLI_addhead(&tempbase, node->ob);
+			}
+		}
+	}
+
+	/* temporal correction for circular dependencies */
+	while (pose->chanbase.first) {
+		pchan = pose->chanbase.first;
+		BLI_remlink(&pose->chanbase, pchan);
+		BLI_addhead(&tempbase, pchan);
+
+		printf("cyclic %s\n", pchan->name);
+	}
+
+	pose->chanbase = tempbase;
+	queue_delete(nqueue);
+
+//	printf("\nordered\n");
+//	for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
+//		printf(" %s\n", pchan->name);
+//	}
+
+	free_forest(dag);
+	MEM_freeN(dag);
+}
+
+/* ************************  DAG FOR THREADED UPDATE  ********************* */
+
+/* Initialize run-time data in the graph needed for traversing it
+ * from multiple threads and start threaded tree traversal by adding
+ * the root node to the queue.
+ *
+ * This will mark DAG nodes as object/non-object and will calculate
+ * num_pending_parents of nodes (which is how many non-updated parents node
+ * have, which helps a lot checking whether node could be scheduled
+ * already or not).
+ */
+void DAG_threaded_update_begin(Scene *scene,
+                               void (*func)(void *node, void *user_data),
+                               void *user_data)
+{
+	DagNode *node;
+
+	/* We reset num_pending_parents to zero first and tag node as not scheduled yet... */
+	for (node = scene->theDag->DagNode.first; node; node = node->next) {
+		node->num_pending_parents = 0;
+		node->scheduled = false;
+	}
+
+	/* ... and then iterate over all the nodes and
+	 * increase num_pending_parents for node childs.
+	 */
+	for (node = scene->theDag->DagNode.first; node; node = node->next) {
+		DagAdjList *itA;
+
+		for (itA = node->child; itA; itA = itA->next) {
+			if (itA->node != node) {
+				itA->node->num_pending_parents++;
+			}
+		}
+	}
+
+	/* Add root nodes to the queue. */
+	BLI_spin_lock(&threaded_update_lock);
+	for (node = scene->theDag->DagNode.first; node; node = node->next) {
+		if (node->num_pending_parents == 0) {
+			node->scheduled = true;
+			func(node, user_data);
+		}
+	}
+	BLI_spin_unlock(&threaded_update_lock);
+}
+
+/* This function is called when handling node is done.
+ *
+ * This function updates num_pending_parents for all childs and
+ * schedules them if they're ready.
+ */
+void DAG_threaded_update_handle_node_updated(void *node_v,
+                                             void (*func)(void *node, void *user_data),
+                                             void *user_data)
+{
+	DagNode *node = node_v;
+	DagAdjList *itA;
+
+	for (itA = node->child; itA; itA = itA->next) {
+		DagNode *child_node = itA->node;
+		if (child_node != node) {
+			atomic_sub_and_fetch_uint32(&child_node->num_pending_parents, 1);
+
+			if (child_node->num_pending_parents == 0) {
+				bool need_schedule;
+
+				BLI_spin_lock(&threaded_update_lock);
+				need_schedule = child_node->scheduled == false;
+				child_node->scheduled = true;
+				BLI_spin_unlock(&threaded_update_lock);
+
+				if (need_schedule) {
+					func(child_node, user_data);
+				}
+			}
+		}
+	}
+}
+
+/* ************************ DAG DEBUGGING ********************* */
+
+void DAG_print_dependencies(Main *bmain, Scene *scene, Object *ob)
+{
+	/* utility for debugging dependencies */
+	dag_print_dependencies = 1;
+
+	if (ob && (ob->mode & OB_MODE_POSE)) {
+		printf("\nDEPENDENCY RELATIONS for %s\n\n", ob->id.name + 2);
+		DAG_pose_sort(ob);
+	}
+	else {
+		printf("\nDEPENDENCY RELATIONS for %s\n\n", scene->id.name + 2);
+		DAG_scene_relations_rebuild(bmain, scene);
+	}
+
+	dag_print_dependencies = 0;
+}
+
+/* ************************ DAG querying ********************* */
+
+/* Will return Object ID if node represents Object,
+ * and will return NULL otherwise.
+ */
+Object *DAG_get_node_object(void *node_v)
+{
+	DagNode *node = node_v;
+
+	if (node->type == ID_OB) {
+		return node->ob;
+	}
+
+	return NULL;
+}
+
+/* Returns node name, used for debug output only, atm. */
+const char *DAG_get_node_name(Scene *scene, void *node_v)
+{
+	DagNode *node = node_v;
+
+	return dag_node_name(scene->theDag, node);
+}
+
+short DAG_get_eval_flags_for_object(Scene *scene, void *object)
+{
+	DagNode *node;
+
+	if (!DEG_depsgraph_use_legacy()) {
+		return DEG_get_eval_flags_for_id(scene->depsgraph, (ID *)object);
+	}
+
+	if (scene->theDag == NULL) {
+		/* Happens when converting objects to mesh from a python script
+		 * after modifying scene graph.
+		 *
+		 * Currently harmless because it's only called for temporary
+		 * objects which are out of the DAG anyway.
+		 */
+		return 0;
+	}
+
+	node = dag_find_node(scene->theDag, object);
+
+	if (node) {
+		return node->eval_flags;
+	}
+	else {
+		/* Happens when external render engine exports temporary objects
+		 * which are not in the DAG.
+		 */
+
+		/* TODO(sergey): Doublecheck objects with Curve Deform exports all fine. */
+
+		/* TODO(sergey): Weak but currently we can't really access proper DAG from
+		 * the modifiers stack. This is because in most cases modifier is to use
+		 * the foreground scene, but to access evaluation flags we need to know
+		 * active background scene, which we don't know.
+		 */
+		if (scene->set) {
+			return DAG_get_eval_flags_for_object(scene->set, object);
+		}
+		return 0;
+	}
+}
+
+bool DAG_is_acyclic(Scene *scene)
+{
+	return scene->theDag->is_acyclic;
+}
+
+#else
+
+/* *********************************************************************
+ * Stubs to avoid linking issues and make sure legacy crap is not used *
+ * *********************************************************************
+ */
+
+DagNodeQueue *queue_create(int UNUSED(slots))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+	return NULL;
+}
+
+void queue_raz(DagNodeQueue *UNUSED(queue))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+}
+
+void queue_delete(DagNodeQueue *UNUSED(queue))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+}
+
+void push_queue(DagNodeQueue *UNUSED(queue), DagNode *UNUSED(node))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+}
+
+void push_stack(DagNodeQueue *UNUSED(queue), DagNode *UNUSED(node))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+}
+
+DagNode *pop_queue(DagNodeQueue *UNUSED(queue))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+	return NULL;
+}
+
+DagNode *get_top_node_queue(DagNodeQueue *UNUSED(queue))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+	return NULL;
+}
+
+DagForest *dag_init(void)
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+	return NULL;
+}
+
+DagForest *build_dag(Main *UNUSED(bmain),
+                     Scene *UNUSED(sce),
+                     short UNUSED(mask))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+	return NULL;
+}
+
+void free_forest(DagForest *UNUSED(Dag))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+}
+
+DagNode *dag_find_node(DagForest *UNUSED(forest), void *UNUSED(fob))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+	return NULL;
+}
+
+DagNode *dag_add_node(DagForest *UNUSED(forest), void *UNUSED(fob))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+	return NULL;
+}
+
+DagNode *dag_get_node(DagForest *UNUSED(forest), void *UNUSED(fob))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+	return NULL;
+}
+
+DagNode *dag_get_sub_node(DagForest *UNUSED(forest), void *UNUSED(fob))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+	return NULL;
+}
+
+void dag_add_relation(DagForest *UNUSED(forest),
+                      DagNode *UNUSED(fob1),
+                      DagNode *UNUSED(fob2),
+                      short UNUSED(rel),
+                      const char *UNUSED(name))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+}
+
+/* debug test functions */
+
+void graph_print_queue(DagNodeQueue *UNUSED(nqueue))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+}
+
+void graph_print_queue_dist(DagNodeQueue *UNUSED(nqueue))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+}
+
+void graph_print_adj_list(DagForest *UNUSED(dag))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+}
+
+void DAG_scene_flush_update(Main *UNUSED(bmain),
+                            Scene *UNUSED(sce),
+                            unsigned int UNUSED(lay),
+                            const short UNUSED(time))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+}
+
+void DAG_scene_update_flags(Main *UNUSED(bmain),
+                            Scene *UNUSED(scene),
+                            unsigned int UNUSED(lay),
+                            const bool UNUSED(do_time),
+                            const bool UNUSED(do_invisible_flush))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+}
+
+/* ******************* DAG FOR ARMATURE POSE ***************** */
+
+void DAG_pose_sort(Object *UNUSED(ob))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+}
+
+/* ************************  DAG FOR THREADED UPDATE  ********************* */
+
+void DAG_threaded_update_begin(Scene *UNUSED(scene),
+                               void (*func)(void *node, void *user_data),
+                               void *UNUSED(user_data))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+	(void)func;
+}
+
+void DAG_threaded_update_handle_node_updated(void *UNUSED(node_v),
+                                             void (*func)(void *node, void *user_data),
+                                             void *UNUSED(user_data))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+	(void)func;
+}
+
+/* ************************ DAG querying ********************* */
+
+Object *DAG_get_node_object(void *UNUSED(node_v))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+	return NULL;
+}
+
+const char *DAG_get_node_name(Scene *UNUSED(scene), void *UNUSED(node_v))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+	return "INVALID";
+}
+
+bool DAG_is_acyclic(Scene *UNUSED(scene))
+{
+	BLI_assert(!"Should not be used with new dependnecy graph");
+	return false;
+}
+
+/* ************************************
+ * This functions are to be supported *
+ * ************************************
+ */
+
+void DAG_init(void)
+{
+	DEG_register_node_types();
+}
+
+void DAG_exit(void)
+{
+	DEG_free_node_types();
+}
+
+/* ************************ API *********************** */
+
+void DAG_editors_update_cb(DEG_EditorUpdateIDCb id_func,
+                           DEG_EditorUpdateSceneCb scene_func,
+                           DEG_EditorUpdateScenePreCb scene_func_pre)
+{
+	DEG_editors_set_update_cb(id_func, scene_func, scene_func_pre);
+}
+
+void DAG_editors_update_pre(Main *bmain, Scene *scene, bool time)
+{
+	DEG_editors_update_pre(bmain, scene, time);
+}
+
+/* Tag all relations for update. */
+void DAG_relations_tag_update(Main *bmain)
+{
+	DEG_relations_tag_update(bmain);
+}
+
+/* Rebuild dependency graph only for a given scene. */
+void DAG_scene_relations_rebuild(Main *bmain, Scene *scene)
+{
+	DEG_scene_relations_rebuild(bmain, scene);
+}
+
+/* Create dependency graph if it was cleared or didn't exist yet. */
+void DAG_scene_relations_update(Main *bmain, Scene *scene)
+{
+	DEG_scene_relations_update(bmain, scene);
+}
+
+void DAG_scene_relations_validate(Main *bmain, Scene *scene)
+{
+	DEG_debug_scene_relations_validate(bmain, scene);
+}
+
+void DAG_scene_free(Scene *scene)
+{
+	DEG_scene_graph_free(scene);
+}
+
+void DAG_on_visible_update(Main *bmain, const bool do_time)
+{
+	DEG_on_visible_update(bmain, do_time);
+}
+
+void DAG_ids_check_recalc(Main *bmain, Scene *scene, bool time)
+{
+	DEG_ids_check_recalc(bmain, scene, time);
+}
+
+void DAG_id_tag_update(ID *id, short flag)
+{
+	DEG_id_tag_update_ex(G.main, id, flag);
+}
+
+void DAG_id_tag_update_ex(Main *bmain, ID *id, short flag)
+{
+	DEG_id_tag_update_ex(bmain, id, flag);
+}
+
+void DAG_id_type_tag(Main *bmain, short idtype)
+{
+	DEG_id_type_tag(bmain, idtype);
+}
+
+int DAG_id_type_tagged(Main *bmain, short idtype)
+{
+	return DEG_id_type_tagged(bmain, idtype);
+}
+
+void DAG_ids_clear_recalc(Main *bmain)
+{
+	DEG_ids_clear_recalc(bmain);
+}
+
+short DAG_get_eval_flags_for_object(Scene *scene, void *object)
+{
+	return DEG_get_eval_flags_for_id(scene->depsgraph, (ID *)object);
+}
+
+void DAG_ids_flush_tagged(Main *bmain)
+{
+	DEG_ids_flush_tagged(bmain);
+}
+
+/* ************************ DAG DEBUGGING ********************* */
+
+void DAG_print_dependencies(Main *UNUSED(bmain),
+                            Scene *scene,
+                            Object *UNUSED(ob))
+{
+	DEG_debug_relations_graphviz(scene->depsgraph, stdout, "Depsgraph");
+}
+
+#endif
diff --git a/source/blender/blenkernel/intern/fcurve.c b/source/blender/blenkernel/intern/fcurve.c
index ed3874ae1c2..2f0c70a4e12 100644
--- a/source/blender/blenkernel/intern/fcurve.c
+++ b/source/blender/blenkernel/intern/fcurve.c
@@ -1315,7 +1315,7 @@ static short driver_check_valid_targets(ChannelDriver *driver, DriverVar *dvar)
 {
 	short valid_targets = 0;
 
-	DRIVER_TARGETS_USED_LOOPER(dvar)
+	DRIVER_TARGETS_USED_LOOPER_BEGIN(dvar)
 	{
 		Object *ob = (Object *)dtar_id_ensure_proxy_from(dtar->id);
 
@@ -1331,7 +1331,7 @@ static short driver_check_valid_targets(ChannelDriver *driver, DriverVar *dvar)
 			valid_targets++;
 		}
 	}
-	DRIVER_TARGETS_LOOPER_END
+	DRIVER_TARGETS_LOOPER_END;
 
 	return valid_targets;
 }
@@ -1418,7 +1418,7 @@ static float dvar_eval_locDiff(ChannelDriver *driver, DriverVar *dvar)
 
 	/* SECOND PASS: get two location values */
 	/* NOTE: for now, these are all just worldspace */
-	DRIVER_TARGETS_USED_LOOPER(dvar)
+	DRIVER_TARGETS_USED_LOOPER_BEGIN(dvar)
 	{
 		/* get pointer to loc values to store in */
 		Object *ob = (Object *)dtar_id_ensure_proxy_from(dtar->id);
@@ -1489,7 +1489,7 @@ static float dvar_eval_locDiff(ChannelDriver *driver, DriverVar *dvar)
 			copy_v3_v3(loc1, tmp_loc);
 		}
 	}
-	DRIVER_TARGETS_LOOPER_END
+	DRIVER_TARGETS_LOOPER_END;
 
 
 	/* if we're still here, there should now be two targets to use,
@@ -1674,13 +1674,13 @@ void driver_free_variable(ListBase *variables, DriverVar *dvar)
 	 *   currently, since there may be some lingering RNA paths from
 	 *   previous users needing freeing
 	 */
-	DRIVER_TARGETS_LOOPER(dvar)
+	DRIVER_TARGETS_LOOPER_BEGIN(dvar)
 	{
 		/* free RNA path if applicable */
 		if (dtar->rna_path)
 			MEM_freeN(dtar->rna_path);
 	}
-	DRIVER_TARGETS_LOOPER_END
+	DRIVER_TARGETS_LOOPER_END;
 
 	/* remove the variable from the driver */
 	BLI_freelinkN(variables, dvar);
@@ -1704,13 +1704,13 @@ void driver_variables_copy(ListBase *dst_vars, const ListBase *src_vars)
 
 	for (DriverVar *dvar = dst_vars->first; dvar; dvar = dvar->next) {
 		/* need to go over all targets so that we don't leave any dangling paths */
-		DRIVER_TARGETS_LOOPER(dvar)
+		DRIVER_TARGETS_LOOPER_BEGIN(dvar)
 		{
 			/* make a copy of target's rna path if available */
 			if (dtar->rna_path)
 				dtar->rna_path = MEM_dupallocN(dtar->rna_path);
 		}
-		DRIVER_TARGETS_LOOPER_END
+		DRIVER_TARGETS_LOOPER_END;
 	}
 }
 
@@ -1730,7 +1730,7 @@ void driver_change_variable_type(DriverVar *dvar, int type)
 	/* make changes to the targets based on the defines for these types
 	 * NOTE: only need to make sure the ones we're using here are valid...
 	 */
-	DRIVER_TARGETS_USED_LOOPER(dvar)
+	DRIVER_TARGETS_USED_LOOPER_BEGIN(dvar)
 	{
 		short flags = dvti->target_flags[tarIndex];
 
@@ -1741,7 +1741,7 @@ void driver_change_variable_type(DriverVar *dvar, int type)
 		if ((flags & DTAR_FLAG_ID_OB_ONLY) || (dtar->idtype == 0))
 			dtar->idtype = ID_OB;
 	}
-	DRIVER_TARGETS_LOOPER_END
+	DRIVER_TARGETS_LOOPER_END;
 }
 
 /* Validate driver name (after being renamed) */
diff --git a/source/blender/blenkernel/intern/library_query.c b/source/blender/blenkernel/intern/library_query.c
index ea1b35e4c1e..902cabad857 100644
--- a/source/blender/blenkernel/intern/library_query.c
+++ b/source/blender/blenkernel/intern/library_query.c
@@ -249,11 +249,11 @@ static void library_foreach_animationData(LibraryForeachIDData *data, AnimData *
 
 		for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
 			/* only used targets */
-			DRIVER_TARGETS_USED_LOOPER(dvar)
+			DRIVER_TARGETS_USED_LOOPER_BEGIN(dvar)
 			{
 				FOREACH_CALLBACK_INVOKE_ID(data, dtar->id, IDWALK_CB_NOP);
 			}
-			DRIVER_TARGETS_LOOPER_END
+			DRIVER_TARGETS_LOOPER_END;
 		}
 	}
 
diff --git a/source/blender/blenkernel/intern/object.c b/source/blender/blenkernel/intern/object.c
index 87aa99f5d40..67edcff49a6 100644
--- a/source/blender/blenkernel/intern/object.c
+++ b/source/blender/blenkernel/intern/object.c
@@ -1528,7 +1528,7 @@ void BKE_object_copy_proxy_drivers(Object *ob, Object *target)
 
 			for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
 				/* all drivers */
-				DRIVER_TARGETS_LOOPER(dvar)
+				DRIVER_TARGETS_LOOPER_BEGIN(dvar)
 				{
 					if (dtar->id) {
 						if ((Object *)dtar->id == target)
@@ -1542,7 +1542,7 @@ void BKE_object_copy_proxy_drivers(Object *ob, Object *target)
 						}
 					}
 				}
-				DRIVER_TARGETS_LOOPER_END
+				DRIVER_TARGETS_LOOPER_END;
 			}
 		}
 	}
diff --git a/source/blender/blenloader/intern/readfile.c b/source/blender/blenloader/intern/readfile.c
index 76162beb1cb..fe4d38e1618 100644
--- a/source/blender/blenloader/intern/readfile.c
+++ b/source/blender/blenloader/intern/readfile.c
@@ -2591,7 +2591,7 @@ static void lib_link_fcurves(FileData *fd, ID *id, ListBase *list)
 			DriverVar *dvar;
 
 			for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
-				DRIVER_TARGETS_LOOPER(dvar)
+				DRIVER_TARGETS_LOOPER_BEGIN(dvar)
 				{
 					/* only relink if still used */
 					if (tarIndex < dvar->num_targets)
@@ -2599,7 +2599,7 @@ static void lib_link_fcurves(FileData *fd, ID *id, ListBase *list)
 					else
 						dtar->id = NULL;
 				}
-				DRIVER_TARGETS_LOOPER_END
+				DRIVER_TARGETS_LOOPER_END;
 			}
 		}
 
@@ -2694,7 +2694,7 @@ static void direct_link_fcurves(FileData *fd, ListBase *list)
 			/* relink variables, targets and their paths */
 			link_list(fd, &driver->variables);
 			for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
-				DRIVER_TARGETS_LOOPER(dvar)
+				DRIVER_TARGETS_LOOPER_BEGIN(dvar)
 				{
 					/* only relink the targets being used */
 					if (tarIndex < dvar->num_targets)
@@ -2702,7 +2702,7 @@ static void direct_link_fcurves(FileData *fd, ListBase *list)
 					else
 						dtar->rna_path = NULL;
 				}
-				DRIVER_TARGETS_LOOPER_END
+				DRIVER_TARGETS_LOOPER_END;
 			}
 		}
 
@@ -9426,12 +9426,12 @@ static void expand_fcurves(FileData *fd, Main *mainvar, ListBase *list)
 			DriverVar *dvar;
 
 			for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
-				DRIVER_TARGETS_LOOPER(dvar)
+				DRIVER_TARGETS_LOOPER_BEGIN(dvar)
 				{
 					// TODO: only expand those that are going to get used?
 					expand_doit(fd, mainvar, dtar->id);
 				}
-				DRIVER_TARGETS_LOOPER_END
+				DRIVER_TARGETS_LOOPER_END;
 			}
 		}
 
diff --git a/source/blender/blenloader/intern/versioning_270.c b/source/blender/blenloader/intern/versioning_270.c
index 22fea82ced0..c45db306006 100644
--- a/source/blender/blenloader/intern/versioning_270.c
+++ b/source/blender/blenloader/intern/versioning_270.c
@@ -378,7 +378,7 @@ static void do_version_bbone_easing_fcurve_fix(ID *UNUSED(id), FCurve *fcu, void
 	/* Driver -> Driver Vars (for bbone_in/out) */
 	if (fcu->driver) {
 		for (DriverVar *dvar = fcu->driver->variables.first; dvar; dvar = dvar->next) {
-			DRIVER_TARGETS_LOOPER(dvar)
+			DRIVER_TARGETS_LOOPER_BEGIN(dvar)
 			{
 				if (dtar->rna_path) {
 					dtar->rna_path = replace_bbone_easing_rnapath(dtar->rna_path);
diff --git a/source/blender/blenloader/intern/writefile.c b/source/blender/blenloader/intern/writefile.c
index 7bf8babd3c9..6398d0f59f2 100644
--- a/source/blender/blenloader/intern/writefile.c
+++ b/source/blender/blenloader/intern/writefile.c
@@ -846,13 +846,13 @@ static void write_fcurves(WriteData *wd, ListBase *fcurves)
 			/* variables */
 			writelist(wd, DATA, DriverVar, &driver->variables);
 			for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
-				DRIVER_TARGETS_USED_LOOPER(dvar)
+				DRIVER_TARGETS_USED_LOOPER_BEGIN(dvar)
 				{
 					if (dtar->rna_path) {
 						writedata(wd, DATA, strlen(dtar->rna_path) + 1, dtar->rna_path);
 					}
 				}
-				DRIVER_TARGETS_LOOPER_END
+				DRIVER_TARGETS_LOOPER_END;
 			}
 		}
 
diff --git a/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc b/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc
index e59de4224c0..1485079c418 100644
--- a/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc
+++ b/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc
@@ -956,7 +956,7 @@ void DepsgraphNodeBuilder::build_driver_variables(ID * id, FCurve *fcurve)
 {
 	build_driver_id_property(id, fcurve->rna_path);
 	LISTBASE_FOREACH (DriverVar *, dvar, &fcurve->driver->variables) {
-		DRIVER_TARGETS_USED_LOOPER(dvar)
+		DRIVER_TARGETS_USED_LOOPER_BEGIN(dvar)
 		{
 			if (dtar->id == NULL) {
 				continue;
@@ -972,7 +972,7 @@ void DepsgraphNodeBuilder::build_driver_variables(ID * id, FCurve *fcurve)
 				build_driver_id_property(&proxy_from->id, dtar->rna_path);
 			}
 		}
-		DRIVER_TARGETS_LOOPER_END
+		DRIVER_TARGETS_LOOPER_END;
 	}
 }
 
diff --git a/source/blender/depsgraph/intern/builder/deg_builder_relations.cc b/source/blender/depsgraph/intern/builder/deg_builder_relations.cc
index b5a221a2215..8af6b2f3a97 100644
--- a/source/blender/depsgraph/intern/builder/deg_builder_relations.cc
+++ b/source/blender/depsgraph/intern/builder/deg_builder_relations.cc
@@ -1469,7 +1469,7 @@ void DepsgraphRelationBuilder::build_driver_variables(ID *id, FCurve *fcu)
 
 	LISTBASE_FOREACH (DriverVar *, dvar, &driver->variables) {
 		/* Only used targets. */
-		DRIVER_TARGETS_USED_LOOPER(dvar)
+		DRIVER_TARGETS_USED_LOOPER_BEGIN(dvar)
 		{
 			if (dtar->id == NULL) {
 				continue;
@@ -1543,7 +1543,7 @@ void DepsgraphRelationBuilder::build_driver_variables(ID *id, FCurve *fcu)
 				 * is an incomplete target reference, so nothing to do here. */
 			}
 		}
-		DRIVER_TARGETS_LOOPER_END
+		DRIVER_TARGETS_LOOPER_END;
 	}
 }
 
diff --git a/source/blender/editors/animation/anim_filter.c b/source/blender/editors/animation/anim_filter.c
index 5f23762386e..2d528a0f0b9 100644
--- a/source/blender/editors/animation/anim_filter.c
+++ b/source/blender/editors/animation/anim_filter.c
@@ -1173,12 +1173,12 @@ static bool fcurve_has_errors(FCurve *fcu)
 		/* check variables for other things that need linting... */
 		// TODO: maybe it would be more efficient just to have a quick flag for this?
 		for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
-			DRIVER_TARGETS_USED_LOOPER(dvar)
+			DRIVER_TARGETS_USED_LOOPER_BEGIN(dvar)
 			{
 				if (dtar->flag & DTAR_FLAG_INVALID)
 					return true;
 			}
-			DRIVER_TARGETS_LOOPER_END
+			DRIVER_TARGETS_LOOPER_END;
 		}
 	}
 
diff --git a/source/blender/editors/armature/armature_relations.c b/source/blender/editors/armature/armature_relations.c
index ee65d76cae7..16eb67c9df2 100644
--- a/source/blender/editors/armature/armature_relations.c
+++ b/source/blender/editors/armature/armature_relations.c
@@ -166,7 +166,7 @@ static void joined_armature_fix_animdata_cb(ID *id, FCurve *fcu, void *user_data
 		/* Fix driver references to invalid ID's */
 		for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
 			/* only change the used targets, since the others will need fixing manually anyway */
-			DRIVER_TARGETS_USED_LOOPER(dvar)
+			DRIVER_TARGETS_USED_LOOPER_BEGIN(dvar)
 			{
 				/* change the ID's used... */
 				if (dtar->id == src_id) {
@@ -199,7 +199,7 @@ static void joined_armature_fix_animdata_cb(ID *id, FCurve *fcu, void *user_data
 					}
 				}
 			}
-			DRIVER_TARGETS_LOOPER_END
+			DRIVER_TARGETS_LOOPER_END;
 		}
 	}
 }
diff --git a/source/blender/editors/gpencil/gpencil_data.c b/source/blender/editors/gpencil/gpencil_data.c
index e9b65009781..236d6964c26 100644
--- a/source/blender/editors/gpencil/gpencil_data.c
+++ b/source/blender/editors/gpencil/gpencil_data.c
@@ -1904,7 +1904,7 @@ static void joined_gpencil_fix_animdata_cb(ID *id, FCurve *fcu, void *user_data)
 		/* Fix driver references to invalid ID's */
 		for (DriverVar *dvar = fcu->driver->variables.first; dvar; dvar = dvar->next) {
 			/* only change the used targets, since the others will need fixing manually anyway */
-			DRIVER_TARGETS_USED_LOOPER(dvar)
+			DRIVER_TARGETS_USED_LOOPER_BEGIN(dvar)
 			{
 				/* change the ID's used... */
 				if (dtar->id == src_id) {
@@ -1933,7 +1933,7 @@ static void joined_gpencil_fix_animdata_cb(ID *id, FCurve *fcu, void *user_data)
 					}
 				}
 			}
-			DRIVER_TARGETS_LOOPER_END
+			DRIVER_TARGETS_LOOPER_END;
 		}
 	}
 }
diff --git a/source/blender/editors/space_outliner/outliner_tree.c b/source/blender/editors/space_outliner/outliner_tree.c
index 902235779cf..60467854e73 100644
--- a/source/blender/editors/space_outliner/outliner_tree.c
+++ b/source/blender/editors/space_outliner/outliner_tree.c
@@ -831,7 +831,7 @@ static TreeElement *outliner_add_element(SpaceOops *soops, ListBase *lb, void *i
 
 					for (dvar = driver->variables.first; dvar; dvar = dvar->next) {
 						/* loop over all targets used here */
-						DRIVER_TARGETS_USED_LOOPER(dvar)
+						DRIVER_TARGETS_USED_LOOPER_BEGIN(dvar)
 						{
 							if (lastadded != dtar->id) {
 								// XXX this lastadded check is rather lame, and also fails quite badly...
@@ -839,7 +839,7 @@ static TreeElement *outliner_add_element(SpaceOops *soops, ListBase *lb, void *i
 								lastadded = dtar->id;
 							}
 						}
-						DRIVER_TARGETS_LOOPER_END
+						DRIVER_TARGETS_LOOPER_END;
 					}
 				}
 			}
diff --git a/source/gameengine/Converter/BL_ShapeDeformer.cpp b/source/gameengine/Converter/BL_ShapeDeformer.cpp
new file mode 100644
index 00000000000..ca32e49ef5d
--- /dev/null
+++ b/source/gameengine/Converter/BL_ShapeDeformer.cpp
@@ -0,0 +1,237 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * 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.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file gameengine/Converter/BL_ShapeDeformer.cpp
+ *  \ingroup bgeconv
+ */
+
+#ifdef _MSC_VER
+#  pragma warning (disable:4786)
+#endif
+
+#include "MEM_guardedalloc.h"
+#include "BL_ShapeDeformer.h"
+#include "CTR_Map.h"
+#include "STR_HashedString.h"
+#include "RAS_IPolygonMaterial.h"
+#include "RAS_MeshObject.h"
+
+#include "DNA_anim_types.h"
+#include "DNA_armature_types.h"
+#include "DNA_action_types.h"
+#include "DNA_key_types.h"
+#include "DNA_mesh_types.h"
+#include "DNA_meshdata_types.h"
+#include "BKE_armature.h"
+#include "BKE_action.h"
+#include "BKE_global.h"
+#include "BKE_main.h"
+#include "BKE_key.h"
+#include "BKE_fcurve.h"
+#include "BKE_ipo.h"
+#include "BKE_library.h"
+#include "MT_Point3.h"
+
+extern "C"{
+	#include "BKE_lattice.h"
+	#include "BKE_animsys.h"
+}
+
+#include "BLI_blenlib.h"
+#include "BLI_math.h"
+
+#define __NLA_DEFNORMALS
+//#undef __NLA_DEFNORMALS
+
+BL_ShapeDeformer::BL_ShapeDeformer(BL_DeformableGameObject *gameobj,
+                                   Object *bmeshobj,
+                                   RAS_MeshObject *mesh)
+    :
+      BL_SkinDeformer(gameobj,bmeshobj, mesh),
+      m_useShapeDrivers(false),
+      m_lastShapeUpdate(-1)
+{
+	m_key = m_bmesh->key ? BKE_key_copy(G.main, m_bmesh->key) : NULL;
+};
+
+/* this second constructor is needed for making a mesh deformable on the fly. */
+BL_ShapeDeformer::BL_ShapeDeformer(BL_DeformableGameObject *gameobj,
+				Object *bmeshobj_old,
+				Object *bmeshobj_new,
+				RAS_MeshObject *mesh,
+				bool release_object,
+				bool recalc_normal,
+				BL_ArmatureObject* arma)
+				:
+					BL_SkinDeformer(gameobj, bmeshobj_old, bmeshobj_new, mesh, release_object, recalc_normal, arma),
+					m_useShapeDrivers(false),
+					m_lastShapeUpdate(-1)
+{
+	m_key = m_bmesh->key ? BKE_key_copy(G.main, m_bmesh->key) : NULL;
+};
+
+BL_ShapeDeformer::~BL_ShapeDeformer()
+{
+	if (m_key)
+	{
+		BKE_libblock_free(G.main, m_key);
+		m_key = NULL;
+	}
+};
+
+RAS_Deformer *BL_ShapeDeformer::GetReplica()
+{
+	BL_ShapeDeformer *result;
+
+	result = new BL_ShapeDeformer(*this);
+	result->ProcessReplica();
+	return result;
+}
+
+void BL_ShapeDeformer::ProcessReplica()
+{
+	BL_SkinDeformer::ProcessReplica();
+	m_lastShapeUpdate = -1;
+
+	m_key = m_key ? BKE_key_copy(G.main, m_key) : NULL;
+}
+
+bool BL_ShapeDeformer::LoadShapeDrivers(KX_GameObject* parent)
+{
+	// Only load shape drivers if we have a key
+	if (GetKey() == NULL) {
+		m_useShapeDrivers = false;
+		return false;
+	}
+
+	// Fix drivers since BL_ArmatureObject makes copies
+	if (parent->GetGameObjectType() == SCA_IObject::OBJ_ARMATURE && GetKey()->adt) {
+		BL_ArmatureObject *arma = (BL_ArmatureObject*)parent;
+		FCurve *fcu;
+
+		for (fcu = (FCurve*)GetKey()->adt->drivers.first; fcu; fcu = (FCurve*)fcu->next) {
+
+			DriverVar *dvar;
+			for (dvar = (DriverVar*)fcu->driver->variables.first; dvar; dvar = (DriverVar*)dvar->next) {
+				DRIVER_TARGETS_USED_LOOPER_BEGIN(dvar)
+				{
+					if (dtar->id) {
+						if ((Object*)dtar->id == arma->GetOrigArmatureObject())
+							dtar->id = (ID*)arma->GetArmatureObject();
+					}
+				}
+				DRIVER_TARGETS_LOOPER_END;
+			}
+		}
+	}
+
+	// This used to check if we had drivers from this armature,
+	// now we just assume we want to use shape drivers
+	// and let the animsys handle things.
+	m_useShapeDrivers = true;
+
+	return true;
+}
+
+bool BL_ShapeDeformer::ExecuteShapeDrivers(void)
+{
+	if (m_useShapeDrivers && PoseUpdated()) {
+		// We don't need an actual time, just use 0
+		BKE_animsys_evaluate_animdata(NULL, &GetKey()->id, GetKey()->adt, 0.f, ADT_RECALC_DRIVERS);
+
+		ForceUpdate();
+		m_bDynamic = true;
+		return true;
+	}
+	return false;
+}
+
+bool BL_ShapeDeformer::Update(void)
+{
+	bool bShapeUpdate = false;
+	bool bSkinUpdate = false;
+
+	ExecuteShapeDrivers();
+
+	/* See if the object shape has changed */
+	if (m_lastShapeUpdate != m_gameobj->GetLastFrame()) {
+		/* the key coefficient have been set already, we just need to blend the keys */
+		Object* blendobj = m_gameobj->GetBlendObject();
+
+		/* we will blend the key directly in m_transverts array: it is used by armature as the start position */
+		/* m_key can be NULL in case of Modifier deformer */
+		if (m_key) {
+			WeightsArrayCache cache = {0, NULL};
+			float **per_keyblock_weights;
+
+			/* store verts locally */
+			VerifyStorage();
+
+			per_keyblock_weights = BKE_keyblock_get_per_block_weights(blendobj, m_key, &cache);
+			BKE_key_evaluate_relative(0, m_bmesh->totvert, m_bmesh->totvert, (char *)(float *)m_transverts,
+			                          m_key, NULL, per_keyblock_weights, 0); /* last arg is ignored */
+			BKE_keyblock_free_per_block_weights(m_key, per_keyblock_weights, &cache);
+
+			m_bDynamic = true;
+		}
+
+		// Don't release the weight array as in Blender, it will most likely be reusable on next frame
+		// The weight array are ultimately deleted when the skin mesh is destroyed
+
+		/* Update the current frame */
+		m_lastShapeUpdate=m_gameobj->GetLastFrame();
+
+		// As we have changed, the mesh, the skin deformer must update as well.
+		// This will force the update
+		BL_SkinDeformer::ForceUpdate();
+		bShapeUpdate = true;
+	}
+	// check for armature deform
+	bSkinUpdate = BL_SkinDeformer::UpdateInternal(bShapeUpdate && m_bDynamic);
+
+	// non dynamic deformer = Modifer without armature and shape keys, no need to create storage
+	if (!bSkinUpdate && bShapeUpdate && m_bDynamic) {
+		// this means that there is no armature, we still need to
+		// update the normal (was not done after shape key calculation)
+
+#ifdef __NLA_DEFNORMALS
+		if (m_recalcNormal)
+			RecalcNormals();
+#endif
+
+		// We also need to handle transverts now (used to be in BL_SkinDeformer::Apply())
+		UpdateTransverts();
+		bSkinUpdate = true;
+	}
+
+	return bSkinUpdate;
+}
+
+Key *BL_ShapeDeformer::GetKey()
+{
+	return m_key;
+}