Depsgraph/Python: callbacks and properties to detect datablock changes
authorBrecht Van Lommel <brechtvanlommel@pandora.be>
Wed, 2 Nov 2011 20:56:52 +0000 (20:56 +0000)
committerBrecht Van Lommel <brechtvanlommel@pandora.be>
Wed, 2 Nov 2011 20:56:52 +0000 (20:56 +0000)
* Adds two new python handlers: scene_update_pre() and scene_update_post()
  These run before and after Blender does a scene update on making modifications
  to the scene.
* Datablocks now have an is_updated property. This will be set to true in the
  above callbacks if the datablock was tagged to be updated. This works for the
  most common datablocks used for rendering: object, material, world, lamsp,
  texture, mesh, curve.
* Datablock collections also have an is_updated property. If this is set, it
  means one datablock of this type was added, removed or modified. It's also
  useful as a quick check to avoid looping over all datablocks.
* RenderEngine.view_update() can also check these properties, for interactive
  viewport rendering.

http://wiki.blender.org/index.php/Dev:2.6/Source/Render/UpdateAPI

14 files changed:
source/blender/blenkernel/BKE_depsgraph.h
source/blender/blenkernel/BKE_scene.h
source/blender/blenkernel/intern/depsgraph.c
source/blender/blenkernel/intern/scene.c
source/blender/blenlib/BLI_callbacks.h
source/blender/editors/object/object_add.c
source/blender/editors/object/object_edit.c
source/blender/makesdna/DNA_ID.h
source/blender/makesrna/intern/rna_ID.c
source/blender/makesrna/intern/rna_main_api.c
source/blender/makesrna/intern/rna_object.c
source/blender/makesrna/intern/rna_scene_api.c
source/blender/python/intern/bpy_app_handlers.c
source/blender/windowmanager/intern/wm_event_system.c

index 59b7712..0b0637f 100644 (file)
@@ -120,6 +120,12 @@ void       DAG_ids_flush_update(struct Main *bmain, int time);
 void   DAG_id_tag_update(struct ID *id, short flag);
                /* flush all tagged updates */
 void   DAG_ids_flush_tagged(struct Main *bmain);
+               /* check and clear ID recalc flags */
+void   DAG_ids_check_recalc(struct Main *bmain);
+void   DAG_ids_clear_recalc(struct Main *bmain);
+               /* test if any of this id type is tagged for update */
+void   DAG_id_type_tag(struct Main *bmain, short idtype);
+int            DAG_id_type_tagged(struct Main *bmain, short idtype);
 
                /* (re)-create dependency graph for armature pose */
 void   DAG_pose_sort(struct Object *ob);
index 45ee6fd..4806a28 100644 (file)
@@ -88,6 +88,8 @@ int scene_check_setscene(struct Main *bmain, struct Scene *sce);
 float BKE_curframe(struct Scene *scene);
 
 void scene_update_tagged(struct Main *bmain, struct Scene *sce);
+void scene_clear_tagged(struct Main *bmain, struct Scene *sce);
+
 void scene_update_for_newframe(struct Main *bmain, struct Scene *sce, unsigned int lay);
 
 void scene_add_render_layer(struct Scene *sce);
index c9df8a1..9d51571 100644 (file)
@@ -1761,9 +1761,22 @@ void DAG_scene_sort(Main *bmain, Scene *sce)
        sce->recalc |= SCE_PRV_CHANGED; /* test for 3d preview */
 }
 
+static void lib_id_recalc_tag(Main *bmain, ID *id)
+{
+       id->flag |= LIB_ID_RECALC;
+       bmain->id_tag_update[id->name[0]] = 1;
+}
+
+static void lib_id_recalc_data_tag(Main *bmain, ID *id)
+{
+       id->flag |= LIB_ID_RECALC_DATA;
+       bmain->id_tag_update[id->name[0]] = 1;
+}
+
 /* node was checked to have lasttime != curtime and is if type ID_OB */
 static void flush_update_node(DagNode *node, unsigned int layer, int curtime)
 {
+       Main *bmain= G.main;
        DagAdjList *itA;
        Object *ob, *obc;
        int oldflag, changed=0;
@@ -1789,20 +1802,24 @@ static void flush_update_node(DagNode *node, unsigned int layer, int curtime)
                                                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;
@@ -1833,6 +1850,7 @@ static void flush_update_node(DagNode *node, unsigned int layer, int curtime)
                                        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);
                                        }
                                }
                        }
@@ -1872,6 +1890,7 @@ static unsigned int flush_layer_node(Scene *sce, DagNode *node, int curtime)
 /* node was checked to have lasttime != curtime , and is of type ID_OB */
 static void flush_pointcache_reset(Scene *scene, DagNode *node, int curtime, int reset)
 {
+       Main *bmain= G.main;
        DagAdjList *itA;
        Object *ob;
        
@@ -1883,8 +1902,10 @@ static void flush_pointcache_reset(Scene *scene, DagNode *node, int curtime, int
                                ob= (Object*)(itA->node->ob);
 
                                if(reset || (ob->recalc & OB_RECALC_ALL)) {
-                                       if(BKE_ptcache_object_reset(scene, ob, PTCACHE_RESET_DEPSGRAPH))
+                                       if(BKE_ptcache_object_reset(scene, ob, PTCACHE_RESET_DEPSGRAPH)) {
                                                ob->recalc |= OB_RECALC_DATA;
+                                               lib_id_recalc_data_tag(bmain, &ob->id);
+                                       }
 
                                        flush_pointcache_reset(scene, itA->node, curtime, 1);
                                }
@@ -2001,8 +2022,10 @@ void DAG_scene_flush_update(Main *bmain, Scene *sce, unsigned int lay, const sho
                                ob= (Object*)(itA->node->ob);
 
                                if(ob->recalc & OB_RECALC_ALL) {
-                                       if(BKE_ptcache_object_reset(sce, ob, PTCACHE_RESET_DEPSGRAPH))
+                                       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(sce, itA->node, lasttime, 1);
                                }
@@ -2204,6 +2227,12 @@ static void dag_object_time_update_flags(Object *ob)
                        }
                }
        }               
+
+       if(ob->recalc & OB_RECALC_OB)
+               lib_id_recalc_tag(G.main, &ob->id);
+       if(ob->recalc & OB_RECALC_DATA)
+               lib_id_recalc_data_tag(G.main, &ob->id);
+
 }
 /* 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 */
@@ -2362,6 +2391,9 @@ void DAG_on_visible_update(Main *bmain, const short do_time)
                DAG_scene_update_flags(bmain, scene, lay, do_time);
                scene->lay_updated |= lay;
        }
+
+       /* hack to get objects updating on layer changes */
+       DAG_id_type_tag(bmain, ID_OB);
 }
 
 static void dag_id_flush_update__isDependentTexture(void *userData, Object *UNUSED(ob), ID **idpoin)
@@ -2408,6 +2440,7 @@ static void dag_id_flush_update(Scene *sce, ID *id)
                        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);
                                }
                        }
@@ -2421,8 +2454,10 @@ static void dag_id_flush_update(Scene *sce, ID *id)
                                data.is_dependent= 0;
 
                                modifiers_foreachIDLink(obt, dag_id_flush_update__isDependentTexture, &data);
-                               if (data.is_dependent)
+                               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) {
@@ -2435,7 +2470,8 @@ static void dag_id_flush_update(Scene *sce, ID *id)
                                                        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)
@@ -2455,6 +2491,8 @@ static void dag_id_flush_update(Scene *sce, ID *id)
                                Key *key= ob_get_key(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);
                                }
                        }
@@ -2479,7 +2517,7 @@ void DAG_ids_flush_tagged(Main *bmain)
        ListBase *lbarray[MAX_LIBARRAY];
        Scene *sce;
        unsigned int lay;
-       int a, have_tag = 0;
+       int a, do_flush = 0;
 
        dag_current_scene_layers(bmain, &sce, &lay);
 
@@ -2497,23 +2535,64 @@ void DAG_ids_flush_tagged(Main *bmain)
                   looping over all ID's in case there are no tags */
                if(id && bmain->id_tag_update[id->name[0]]) {
                        for(; id; id=id->next) {
-                               if(id->flag & LIB_ID_RECALC) {
+                               if(id->flag & (LIB_ID_RECALC|LIB_ID_RECALC_DATA)) {
                                        dag_id_flush_update(sce, id);
-                                       id->flag &= ~LIB_ID_RECALC;
+                                       do_flush = 1;
                                }
                        }
+               }
+       }
+
+       /* flush changes to other objects */
+       if(do_flush)
+               DAG_scene_flush_update(bmain, sce, lay, 0);
+}
+
+void DAG_ids_check_recalc(Main *bmain)
+{
+       ListBase *lbarray[MAX_LIBARRAY];
+       int a;
+
+       /* loop over all ID types */
+       a  = set_listbasepointers(bmain, lbarray);
+
+       while(a--) {
+               ListBase *lb = lbarray[a];
+               ID *id = lb->first;
 
-                       have_tag = 1;
+               /* we tag based on first ID type character to avoid 
+                  looping over all ID's in case there are no tags */
+               if(id && bmain->id_tag_update[id->name[0]]) {
+                       /* do editors update */
+                       dag_editors_update(bmain, NULL);
+                       return;
                }
        }
+}
 
-       if(have_tag) {
-               /* clear tags */
-               memset(bmain->id_tag_update, 0, sizeof(bmain->id_tag_update));
 
-               /* flush changes to other objects */
-               DAG_scene_flush_update(bmain, sce, lay, 0);
+void DAG_ids_clear_recalc(Main *bmain)
+{
+       ListBase *lbarray[MAX_LIBARRAY];
+       int a;
+
+       /* loop over all ID types */
+       a  = set_listbasepointers(bmain, lbarray);
+
+       while(a--) {
+               ListBase *lb = lbarray[a];
+               ID *id = lb->first;
+
+               /* we tag based on first ID type character to avoid 
+                  looping over all ID's in case there are no tags */
+               if(id && bmain->id_tag_update[id->name[0]]) {
+                       for(; id; id=id->next)
+                               if(id->flag & (LIB_ID_RECALC|LIB_ID_RECALC_DATA))
+                                       id->flag &= ~(LIB_ID_RECALC|LIB_ID_RECALC_DATA);
+               }
        }
+
+       memset(bmain->id_tag_update, 0, sizeof(bmain->id_tag_update));
 }
 
 void DAG_id_tag_update(ID *id, short flag)
@@ -2523,8 +2602,14 @@ void DAG_id_tag_update(ID *id, short flag)
        if(id==NULL) return;
        
        /* tag ID for update */
-       id->flag |= LIB_ID_RECALC;
-       bmain->id_tag_update[id->name[0]] = 1;
+       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) {
@@ -2556,6 +2641,16 @@ void DAG_id_tag_update(ID *id, short flag)
        }
 }
 
+void DAG_id_type_tag(struct Main *bmain, short idtype)
+{
+       bmain->id_tag_update[((char*)&idtype)[0]] = 1;
+}
+
+int DAG_id_type_tagged(Main *bmain, short idtype)
+{
+       return bmain->id_tag_update[((char*)&idtype)[0]];
+}
+
 #if 0 // UNUSED
 /* recursively descends tree, each node only checked once */
 /* node is checked to be of type object */
index c902bee..b25120c 100644 (file)
@@ -992,6 +992,8 @@ void scene_update_tagged(Main *bmain, Scene *scene)
 {
        DAG_ids_flush_tagged(bmain);
 
+       BLI_exec_cb(bmain, &scene->id, BLI_CB_EVT_SCENE_UPDATE_PRE);
+
        scene->physics_settings.quick_cache_step= 0;
 
        /* update all objects: drivers, matrices, displists, etc. flags set
@@ -1011,10 +1013,19 @@ void scene_update_tagged(Main *bmain, Scene *scene)
        if (scene->physics_settings.quick_cache_step)
                BKE_ptcache_quick_cache_all(bmain, scene);
 
+       DAG_ids_check_recalc(bmain);
+
+       BLI_exec_cb(bmain, &scene->id, BLI_CB_EVT_SCENE_UPDATE_POST);
+
        /* in the future this should handle updates for all datablocks, not
           only objects and scenes. - brecht */
 }
 
+void scene_clear_tagged(Main *bmain, Scene *UNUSED(scene))
+{
+       DAG_ids_clear_recalc(bmain);
+}
+
 /* applies changes right away, does all sets too */
 void scene_update_for_newframe(Main *bmain, Scene *sce, unsigned int lay)
 {
@@ -1039,6 +1050,8 @@ void scene_update_for_newframe(Main *bmain, Scene *sce, unsigned int lay)
         * so dont call within 'scene_update_tagged_recursive' */
        DAG_scene_update_flags(bmain, sce, lay, TRUE);   // only stuff that moves or needs display still
 
+       BLI_exec_cb(bmain, (ID *)sce, BLI_CB_EVT_SCENE_UPDATE_PRE);
+
        /* All 'standard' (i.e. without any dependencies) animation is handled here,
         * with an 'local' to 'macro' order of evaluation. This should ensure that
         * settings stored nestled within a hierarchy (i.e. settings in a Texture block
@@ -1052,6 +1065,7 @@ void scene_update_for_newframe(Main *bmain, Scene *sce, unsigned int lay)
        scene_update_tagged_recursive(bmain, sce, sce);
 
        /* keep this last */
+       BLI_exec_cb(bmain, (ID *)sce, BLI_CB_EVT_SCENE_UPDATE_POST);
        BLI_exec_cb(bmain, (ID *)sce, BLI_CB_EVT_FRAME_CHANGE_POST);
 }
 
index 5322ce0..7e4fad5 100644 (file)
@@ -47,6 +47,8 @@ typedef enum {
        BLI_CB_EVT_LOAD_POST,
        BLI_CB_EVT_SAVE_PRE,
        BLI_CB_EVT_SAVE_POST,
+       BLI_CB_EVT_SCENE_UPDATE_PRE,
+       BLI_CB_EVT_SCENE_UPDATE_POST,
        BLI_CB_EVT_TOT
 } eCbEvent;
 
index 452e7e4..7ff233f 100644 (file)
@@ -863,6 +863,7 @@ void OBJECT_OT_group_instance_add(wmOperatorType *ot)
 /* note: now unlinks constraints as well */
 void ED_base_object_free_and_unlink(Main *bmain, Scene *scene, Base *base)
 {
+       DAG_id_type_tag(bmain, ID_OB);
        BLI_remlink(&scene->base, base);
        free_libblock_us(&bmain->object, base->object);
        if(scene->basact==base) scene->basact= NULL;
index 04272b4..d347322 100644 (file)
@@ -145,6 +145,7 @@ static int object_hide_view_clear_exec(bContext *C, wmOperator *UNUSED(op))
                }
        }
        if (changed) {
+               DAG_id_type_tag(bmain, ID_OB);
                DAG_scene_sort(bmain, scene);
                WM_event_add_notifier(C, NC_SCENE|ND_OB_SELECT, scene);
        }
@@ -197,6 +198,7 @@ static int object_hide_view_set_exec(bContext *C, wmOperator *op)
        CTX_DATA_END;
 
        if (changed) {
+               DAG_id_type_tag(bmain, ID_OB);
                DAG_scene_sort(bmain, scene);
                
                WM_event_add_notifier(C, NC_SCENE|ND_OB_SELECT, CTX_data_scene(C));
index d2c7d49..6f2933d 100644 (file)
@@ -235,6 +235,7 @@ typedef struct PreviewImage {
 #define LIB_PRE_EXISTING       2048
 /* runtime */
 #define LIB_ID_RECALC          4096
+#define LIB_ID_RECALC_DATA     8192
 
 #ifdef __cplusplus
 }
index 194c3e8..e4692d3 100644 (file)
@@ -486,6 +486,16 @@ static void rna_def_ID(BlenderRNA *brna)
        RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
        RNA_def_property_ui_text(prop, "Tag", "Tools can use this to tag data (initial state is undefined)");
 
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", LIB_ID_RECALC);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_ui_text(prop, "Is Updated", "Datablock is tagged for recalculation");
+
+       prop= RNA_def_property(srna, "is_updated_data", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", LIB_ID_RECALC_DATA);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_ui_text(prop, "Is Updated Data", "Datablock data is tagged for recalculation");
+
        prop= RNA_def_property(srna, "library", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "lib");
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
index 3f7cdf8..1b80e33 100644 (file)
@@ -62,6 +62,7 @@
 #include "BKE_particle.h"
 #include "BKE_font.h"
 #include "BKE_node.h"
+#include "BKE_depsgraph.h"
 #include "BKE_speaker.h"
 
 #include "DNA_armature_types.h"
@@ -548,6 +549,33 @@ void rna_Main_actions_tag(Main *bmain, int value) { tag_main_lb(&bmain->action,
 void rna_Main_particles_tag(Main *bmain, int value) { tag_main_lb(&bmain->particle, value); }
 void rna_Main_gpencil_tag(Main *bmain, int value) { tag_main_lb(&bmain->gpencil, value); }
 
+static int rna_Main_cameras_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_CA); }
+static int rna_Main_scenes_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_SCE); }
+static int rna_Main_objects_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_OB); }
+static int rna_Main_materials_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_MA); }
+static int rna_Main_node_groups_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_NT); }
+static int rna_Main_meshes_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_ME); }
+static int rna_Main_lamps_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_LA); }
+static int rna_Main_libraries_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_LI); }
+static int rna_Main_screens_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_SCR); }
+static int rna_Main_window_managers_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_WM); }
+static int rna_Main_images_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_IM); }
+static int rna_Main_lattices_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_LT); }
+static int rna_Main_curves_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_CU); }
+static int rna_Main_metaballs_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_MB); }
+static int rna_Main_fonts_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_VF); }
+static int rna_Main_textures_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_TE); }
+static int rna_Main_brushes_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_BR); }
+static int rna_Main_worlds_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_WO); }
+static int rna_Main_groups_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_GR); }
+static int rna_Main_texts_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_TXT); }
+static int rna_Main_speakers_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_SPK); }
+static int rna_Main_sounds_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_SO); }
+static int rna_Main_armatures_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_AR); }
+static int rna_Main_actions_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_AC); }
+static int rna_Main_particles_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_PA); }
+static int rna_Main_gpencil_is_updated_get(PointerRNA *ptr) { return DAG_id_type_tagged(ptr->data, ID_GD); }
+
 #else
 
 void RNA_api_main(StructRNA *srna)
@@ -574,6 +602,7 @@ void RNA_def_main_cameras(BlenderRNA *brna, PropertyRNA *cprop)
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataCameras");
        srna= RNA_def_struct(brna, "BlendDataCameras", NULL);
@@ -597,6 +626,10 @@ void RNA_def_main_cameras(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_cameras_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_cameras_is_updated_get", NULL);
 }
 
 void RNA_def_main_scenes(BlenderRNA *brna, PropertyRNA *cprop)
@@ -604,6 +637,7 @@ void RNA_def_main_scenes(BlenderRNA *brna, PropertyRNA *cprop)
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataScenes");
        srna= RNA_def_struct(brna, "BlendDataScenes", NULL);
@@ -623,6 +657,10 @@ void RNA_def_main_scenes(BlenderRNA *brna, PropertyRNA *cprop)
        RNA_def_function_ui_description(func, "Remove a scene from the current blendfile");
        parm= RNA_def_pointer(func, "scene", "Scene", "", "Scene to remove");
        RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_scenes_is_updated_get", NULL);
 }
 
 void RNA_def_main_objects(BlenderRNA *brna, PropertyRNA *cprop)
@@ -630,6 +668,7 @@ void RNA_def_main_objects(BlenderRNA *brna, PropertyRNA *cprop)
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataObjects");
        srna= RNA_def_struct(brna, "BlendDataObjects", NULL);
@@ -657,6 +696,10 @@ void RNA_def_main_objects(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_objects_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_objects_is_updated_get", NULL);
 }
 
 void RNA_def_main_materials(BlenderRNA *brna, PropertyRNA *cprop)
@@ -664,6 +707,7 @@ void RNA_def_main_materials(BlenderRNA *brna, PropertyRNA *cprop)
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataMaterials");
        srna= RNA_def_struct(brna, "BlendDataMaterials", NULL);
@@ -687,12 +731,17 @@ void RNA_def_main_materials(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_materials_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_materials_is_updated_get", NULL);
 }
 void RNA_def_main_node_groups(BlenderRNA *brna, PropertyRNA *cprop)
 {
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        static EnumPropertyItem node_nodetree_items[] = {
        {0, "SHADER",       0,    "Shader",       ""},
@@ -724,12 +773,17 @@ void RNA_def_main_node_groups(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_node_groups_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_node_groups_is_updated_get", NULL);
 }
 void RNA_def_main_meshes(BlenderRNA *brna, PropertyRNA *cprop)
 {
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataMeshes");
        srna= RNA_def_struct(brna, "BlendDataMeshes", NULL);
@@ -753,12 +807,17 @@ void RNA_def_main_meshes(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_meshes_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_meshes_is_updated_get", NULL);
 }
 void RNA_def_main_lamps(BlenderRNA *brna, PropertyRNA *cprop)
 {
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataLamps");
        srna= RNA_def_struct(brna, "BlendDataLamps", NULL);
@@ -784,6 +843,10 @@ void RNA_def_main_lamps(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_lamps_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_lamps_is_updated_get", NULL);
 }
 
 void RNA_def_main_libraries(BlenderRNA *brna, PropertyRNA *cprop)
@@ -791,6 +854,7 @@ void RNA_def_main_libraries(BlenderRNA *brna, PropertyRNA *cprop)
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataLibraries");
        srna= RNA_def_struct(brna, "BlendDataLibraries", NULL);
@@ -800,6 +864,10 @@ void RNA_def_main_libraries(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_libraries_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_libraries_is_updated_get", NULL);
 }
 
 void RNA_def_main_screens(BlenderRNA *brna, PropertyRNA *cprop)
@@ -807,6 +875,7 @@ void RNA_def_main_screens(BlenderRNA *brna, PropertyRNA *cprop)
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataScreens");
        srna= RNA_def_struct(brna, "BlendDataScreens", NULL);
@@ -816,6 +885,10 @@ void RNA_def_main_screens(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_screens_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_screens_is_updated_get", NULL);
 }
 
 void RNA_def_main_window_managers(BlenderRNA *brna, PropertyRNA *cprop)
@@ -823,6 +896,7 @@ void RNA_def_main_window_managers(BlenderRNA *brna, PropertyRNA *cprop)
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataWindowManagers");
        srna= RNA_def_struct(brna, "BlendDataWindowManagers", NULL);
@@ -832,12 +906,17 @@ void RNA_def_main_window_managers(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_window_managers_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_window_managers_is_updated_get", NULL);
 }
 void RNA_def_main_images(BlenderRNA *brna, PropertyRNA *cprop)
 {
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataImages");
        srna= RNA_def_struct(brna, "BlendDataImages", NULL);
@@ -876,6 +955,10 @@ void RNA_def_main_images(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_images_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_images_is_updated_get", NULL);
 }
 
 void RNA_def_main_lattices(BlenderRNA *brna, PropertyRNA *cprop)
@@ -883,6 +966,7 @@ void RNA_def_main_lattices(BlenderRNA *brna, PropertyRNA *cprop)
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataLattices");
        srna= RNA_def_struct(brna, "BlendDataLattices", NULL);
@@ -906,12 +990,17 @@ void RNA_def_main_lattices(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_lattices_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_lattices_is_updated_get", NULL);
 }
 void RNA_def_main_curves(BlenderRNA *brna, PropertyRNA *cprop)
 {
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataCurves");
        srna= RNA_def_struct(brna, "BlendDataCurves", NULL);
@@ -937,12 +1026,17 @@ void RNA_def_main_curves(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_curves_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_curves_is_updated_get", NULL);
 }
 void RNA_def_main_metaballs(BlenderRNA *brna, PropertyRNA *cprop)
 {
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataMetaBalls");
        srna= RNA_def_struct(brna, "BlendDataMetaBalls", NULL);
@@ -966,12 +1060,17 @@ void RNA_def_main_metaballs(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_metaballs_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_metaballs_is_updated_get", NULL);
 }
 void RNA_def_main_fonts(BlenderRNA *brna, PropertyRNA *cprop)
 {
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataFonts");
        srna= RNA_def_struct(brna, "BlendDataFonts", NULL);
@@ -996,12 +1095,17 @@ void RNA_def_main_fonts(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_fonts_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_fonts_is_updated_get", NULL);
 }
 void RNA_def_main_textures(BlenderRNA *brna, PropertyRNA *cprop)
 {
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataTextures");
        srna= RNA_def_struct(brna, "BlendDataTextures", NULL);
@@ -1027,12 +1131,17 @@ void RNA_def_main_textures(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_textures_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_textures_is_updated_get", NULL);
 }
 void RNA_def_main_brushes(BlenderRNA *brna, PropertyRNA *cprop)
 {
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataBrushes");
        srna= RNA_def_struct(brna, "BlendDataBrushes", NULL);
@@ -1056,6 +1165,10 @@ void RNA_def_main_brushes(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_brushes_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_brushes_is_updated_get", NULL);
 }
 
 void RNA_def_main_worlds(BlenderRNA *brna, PropertyRNA *cprop)
@@ -1063,6 +1176,7 @@ void RNA_def_main_worlds(BlenderRNA *brna, PropertyRNA *cprop)
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataWorlds");
        srna= RNA_def_struct(brna, "BlendDataWorlds", NULL);
@@ -1086,6 +1200,10 @@ void RNA_def_main_worlds(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_worlds_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_worlds_is_updated_get", NULL);
 }
 
 void RNA_def_main_groups(BlenderRNA *brna, PropertyRNA *cprop)
@@ -1093,6 +1211,7 @@ void RNA_def_main_groups(BlenderRNA *brna, PropertyRNA *cprop)
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataGroups");
        srna= RNA_def_struct(brna, "BlendDataGroups", NULL);
@@ -1115,6 +1234,10 @@ void RNA_def_main_groups(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_groups_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_groups_is_updated_get", NULL);
 }
 
 void RNA_def_main_speakers(BlenderRNA *brna, PropertyRNA *cprop)
@@ -1122,6 +1245,7 @@ void RNA_def_main_speakers(BlenderRNA *brna, PropertyRNA *cprop)
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataSpeakers");
        srna= RNA_def_struct(brna, "BlendDataSpeakers", NULL);
@@ -1145,6 +1269,10 @@ void RNA_def_main_speakers(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_speakers_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_speakers_is_updated_get", NULL);
 }
 
 void RNA_def_main_texts(BlenderRNA *brna, PropertyRNA *cprop)
@@ -1152,6 +1280,7 @@ void RNA_def_main_texts(BlenderRNA *brna, PropertyRNA *cprop)
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataTexts");
        srna= RNA_def_struct(brna, "BlendDataTexts", NULL);
@@ -1184,6 +1313,10 @@ void RNA_def_main_texts(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_texts_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_texts_is_updated_get", NULL);
 }
 
 void RNA_def_main_sounds(BlenderRNA *brna, PropertyRNA *cprop)
@@ -1191,6 +1324,7 @@ void RNA_def_main_sounds(BlenderRNA *brna, PropertyRNA *cprop)
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataSounds");
        srna= RNA_def_struct(brna, "BlendDataSounds", NULL);
@@ -1202,6 +1336,10 @@ void RNA_def_main_sounds(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_sounds_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_sounds_is_updated_get", NULL);
 }
 
 void RNA_def_main_armatures(BlenderRNA *brna, PropertyRNA *cprop)
@@ -1209,6 +1347,7 @@ void RNA_def_main_armatures(BlenderRNA *brna, PropertyRNA *cprop)
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataArmatures");
        srna= RNA_def_struct(brna, "BlendDataArmatures", NULL);
@@ -1232,12 +1371,17 @@ void RNA_def_main_armatures(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_armatures_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_armatures_is_updated_get", NULL);
 }
 void RNA_def_main_actions(BlenderRNA *brna, PropertyRNA *cprop)
 {
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataActions");
        srna= RNA_def_struct(brna, "BlendDataActions", NULL);
@@ -1261,12 +1405,17 @@ void RNA_def_main_actions(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_actions_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_actions_is_updated_get", NULL);
 }
 void RNA_def_main_particles(BlenderRNA *brna, PropertyRNA *cprop)
 {
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataParticles");
        srna= RNA_def_struct(brna, "BlendDataParticles", NULL);
@@ -1290,6 +1439,10 @@ void RNA_def_main_particles(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_particles_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_particles_is_updated_get", NULL);
 }
 
 void RNA_def_main_gpencil(BlenderRNA *brna, PropertyRNA *cprop)
@@ -1297,6 +1450,7 @@ void RNA_def_main_gpencil(BlenderRNA *brna, PropertyRNA *cprop)
        StructRNA *srna;
        FunctionRNA *func;
        PropertyRNA *parm;
+       PropertyRNA *prop;
 
        RNA_def_property_srna(cprop, "BlendDataGreasePencils");
        srna= RNA_def_struct(brna, "BlendDataGreasePencils", NULL);
@@ -1306,6 +1460,10 @@ void RNA_def_main_gpencil(BlenderRNA *brna, PropertyRNA *cprop)
        func= RNA_def_function(srna, "tag", "rna_Main_gpencil_tag");
        parm= RNA_def_boolean(func, "value", 0, "Value", "");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       prop= RNA_def_property(srna, "is_updated", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_boolean_funcs(prop, "rna_Main_gpencil_is_updated_get", NULL);
 }
 
 #endif
index 137eebe..0fa6367 100644 (file)
@@ -286,6 +286,8 @@ static void rna_Object_layer_update__internal(Main *bmain, Scene *scene, Base *b
        else {
                DAG_scene_sort(bmain, scene);
        }
+
+       DAG_id_type_tag(bmain, ID_OB);
 }
 
 static void rna_Object_layer_update(Main *bmain, Scene *scene, PointerRNA *ptr)
index 345ebb2..250c61e 100644 (file)
@@ -69,6 +69,7 @@ static void rna_Scene_frame_set(Scene *scene, int frame, float subframe)
 static void rna_Scene_update_tagged(Scene *scene)
 {
        scene_update_tagged(G.main, scene);
+       scene_clear_tagged(G.main, scene);
 }
 
 static void rna_SceneRender_get_frame_path(RenderData *rd, int frame, char *name)
index 7008aed..e7f7456 100644 (file)
@@ -47,6 +47,8 @@ static PyStructSequence_Field app_cb_info_fields[]= {
        {(char *)"load_post", NULL},
        {(char *)"save_pre", NULL},
        {(char *)"save_post", NULL},
+       {(char *)"scene_update_pre", NULL},
+       {(char *)"scene_update_post", NULL},
        {NULL}
 };
 
index 0e22ccd..03b0d63 100644 (file)
@@ -323,6 +323,8 @@ void wm_event_do_notifiers(bContext *C)
                        scene_update_tagged(bmain, win->screen->scene);
 
                        ED_render_engine_update_tagged(C, bmain);
+
+                       scene_clear_tagged(bmain, win->screen->scene);
                }
        }