Merge branch 'master' into blender2.8
authorCampbell Barton <ideasman42@gmail.com>
Fri, 30 Nov 2018 04:11:32 +0000 (15:11 +1100)
committerCampbell Barton <ideasman42@gmail.com>
Fri, 30 Nov 2018 04:11:32 +0000 (15:11 +1100)
16 files changed:
source/blender/blenkernel/BKE_fcurve.h
source/blender/blenkernel/intern/anim_sys.c
source/blender/blenkernel/intern/depsgraph.c [new file with mode: 0644]
source/blender/blenkernel/intern/fcurve.c
source/blender/blenkernel/intern/library_query.c
source/blender/blenkernel/intern/object.c
source/blender/blenloader/intern/readfile.c
source/blender/blenloader/intern/versioning_270.c
source/blender/blenloader/intern/writefile.c
source/blender/depsgraph/intern/builder/deg_builder_nodes.cc
source/blender/depsgraph/intern/builder/deg_builder_relations.cc
source/blender/editors/animation/anim_filter.c
source/blender/editors/armature/armature_relations.c
source/blender/editors/gpencil/gpencil_data.c
source/blender/editors/space_outliner/outliner_tree.c
source/gameengine/Converter/BL_ShapeDeformer.cpp [new file with mode: 0644]

index 0b7ffb338d8d59cebb88fea8cdceb689be1da8e0..f64909305305eebad026c2e83524768e4a06aa21 100644 (file)
@@ -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)
 
 /* ---------------------- */
 
index 7693485e042bb595fdd45fde2e15bf74dea9abd4..8e8000f3ea07cca809dbe8290ba9e30cf0fb3497 100644 (file)
@@ -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 (file)
index 0000000..15d08f5
--- /dev/null
@@ -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
index ed3874ae1c254e5478beb8fae54c536cf0e2f4e5..2f0c70a4e124e085bfde077d142d13e0a2b2eb6d 100644 (file)
@@ -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) */
index ea1b35e4c1efd57e7670d75ab10f005fbb03ec74..902cabad85746b4d5810a7b4d0b7854688dd2e58 100644 (file)
@@ -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;
                }
        }
 
index 87aa99f5d40798ab5bd77ea9050cb70c497a96ec..67edcff49a68587708997e4de1b9bcfec57cdd5c 100644 (file)
@@ -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;
                        }
                }
        }
index 76162beb1cbfbc8c20fea1e08919a779ef0b67c1..fe4d38e16188f46d9947ece3a4e3df45fcca7bf5 100644 (file)
@@ -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;
                        }
                }
 
index 22fea82ced0152257cb8ffbe13edf21c7a26da9a..c45db306006d37758684590198dde1469083ccee 100644 (file)
@@ -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);
index 7bf8babd3c99720baf6626b467cbccfebfcf0b9a..6398d0f59f21773efc6a471e27c7ab2418b4f924 100644 (file)
@@ -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;
                        }
                }
 
index e59de4224c0ff411491df59a7c463135e4ec581b..1485079c41829d7cba604de628cc76663f801758 100644 (file)
@@ -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;
        }
 }
 
index b5a221a2215a7a41845836374bfc7a0d9115025f..8af6b2f3a9701e52dfed51408128321ddb97ac1f 100644 (file)
@@ -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;
        }
 }
 
index 5f23762386e0214dee6ae74bbfddee4ecac93ed5..2d528a0f0b91bd6c2a7f55719a36d1f70e7adcc6 100644 (file)
@@ -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;
                }
        }
 
index ee65d76cae7bf9023f163d240a786c0b525c9604..16eb67c9df25fb271c01f8bcfea0005b6bd3746d 100644 (file)
@@ -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;
                }
        }
 }
index e9b650097816ab01a987abfcdbe2b555e2f52d25..236d6964c26b07c92047ad15a2bc9ffa1a1c2e90 100644 (file)
@@ -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;
                }
        }
 }
index 902235779cfb5a3e469a32c40c685cd5d08ebf56..60467854e73095150026d46d45d51cb330a364e8 100644 (file)
@@ -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 (file)
index 0000000..ca32e49
--- /dev/null
@@ -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;
+}