Merge branch 'master' into blender2.8
[blender.git] / source / blender / depsgraph / intern / depsgraph_tag.cc
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2013 Blender Foundation.
19  * All rights reserved.
20  *
21  * Original Author: Joshua Leung
22  * Contributor(s): None Yet
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file blender/depsgraph/intern/depsgraph_tag.cc
28  *  \ingroup depsgraph
29  *
30  * Core routines for how the Depsgraph works.
31  */
32
33 #include <stdio.h>
34 #include <cstring>  /* required for memset */
35 #include <queue>
36
37 #include "BLI_utildefines.h"
38 #include "BLI_task.h"
39 #include "BLI_listbase.h"
40
41 extern "C" {
42 #include "DNA_object_types.h"
43 #include "DNA_particle_types.h"
44 #include "DNA_screen_types.h"
45 #include "DNA_windowmanager_types.h"
46
47
48 #include "BKE_idcode.h"
49 #include "BKE_library.h"
50 #include "BKE_main.h"
51 #include "BKE_node.h"
52 #include "BKE_workspace.h"
53
54 #define new new_
55 #include "BKE_screen.h"
56 #undef new
57 } /* extern "C" */
58
59 #include "DEG_depsgraph.h"
60
61 #include "intern/builder/deg_builder.h"
62 #include "intern/eval/deg_eval_flush.h"
63 #include "intern/nodes/deg_node.h"
64 #include "intern/nodes/deg_node_component.h"
65 #include "intern/nodes/deg_node_operation.h"
66
67 #include "intern/depsgraph_intern.h"
68 #include "util/deg_util_foreach.h"
69
70 /* *********************** */
71 /* Update Tagging/Flushing */
72
73 /* Legacy depsgraph did some special trickery for things like particle systems
74  * when tagging ID for an update. Ideally that tagging needs to become obsolete
75  * in favor of havng dedicated node for that which gets tagged, but for until
76  * design of those areas is more clear we'll do the same legacy code here.
77  *                                                                  - sergey -
78  */
79 #define DEPSGRAPH_USE_LEGACY_TAGGING
80
81 namespace {
82
83 /* Data-Based Tagging ------------------------------- */
84
85 void lib_id_recalc_tag(Main *bmain, ID *id)
86 {
87         id->tag |= LIB_TAG_ID_RECALC;
88         DEG_id_type_tag(bmain, GS(id->name));
89 }
90
91 void lib_id_recalc_data_tag(Main *bmain, ID *id)
92 {
93         id->tag |= LIB_TAG_ID_RECALC_DATA;
94         DEG_id_type_tag(bmain, GS(id->name));
95 }
96
97 void lib_id_recalc_tag_flag(Main *bmain, ID *id, int flag)
98 {
99         if (flag) {
100                 /* This bit of code ensures legacy object->recalc flags
101                  * are still filled in the same way as it was expected
102                  * with the old dependency graph.
103                  *
104                  * This is because some areas like motion paths and likely
105                  * some other physics baking process are doing manual scene
106                  * update on all the frames, trying to minimize number of
107                  * updates.
108                  *
109                  * But this flag will also let us to re-construct entry
110                  * nodes for update after relations update and after layer
111                  * visibility changes.
112                  */
113                 short idtype = GS(id->name);
114                 if (idtype == ID_OB) {
115                         Object *object = (Object *)id;
116                         object->recalc |= (flag & OB_RECALC_ALL);
117                 }
118
119                 if (flag & OB_RECALC_OB)
120                         lib_id_recalc_tag(bmain, id);
121                 if (flag & (OB_RECALC_DATA | PSYS_RECALC))
122                         lib_id_recalc_data_tag(bmain, id);
123         }
124         else {
125                 lib_id_recalc_tag(bmain, id);
126         }
127 }
128
129 #ifdef DEPSGRAPH_USE_LEGACY_TAGGING
130 void depsgraph_legacy_handle_update_tag(Main *bmain, ID *id, short flag)
131 {
132         if (flag) {
133                 Object *object;
134                 short idtype = GS(id->name);
135                 if (idtype == ID_PA) {
136                         ParticleSystem *psys;
137                         for (object = (Object *)bmain->object.first;
138                              object != NULL;
139                              object = (Object *)object->id.next)
140                         {
141                                 for (psys = (ParticleSystem *)object->particlesystem.first;
142                                      psys != NULL;
143                                      psys = (ParticleSystem *)psys->next)
144                                 {
145                                         if (&psys->part->id == id) {
146                                                 DEG_id_tag_update_ex(bmain, &object->id, flag & OB_RECALC_ALL);
147                                                 psys->recalc |= (flag & PSYS_RECALC);
148                                         }
149                                 }
150                         }
151                 }
152         }
153 }
154 #endif
155
156 }  /* namespace */
157
158 /* Tag all nodes in ID-block for update.
159  * This is a crude measure, but is most convenient for old code.
160  */
161 void DEG_graph_id_tag_update(Main *bmain, Depsgraph *graph, ID *id)
162 {
163         DEG::Depsgraph *deg_graph = reinterpret_cast<DEG::Depsgraph *>(graph);
164         DEG::IDDepsNode *node = deg_graph->find_id_node(id);
165         lib_id_recalc_tag(bmain, id);
166         if (node != NULL) {
167                 node->tag_update(deg_graph);
168         }
169 }
170
171 /* Tag nodes related to a specific piece of data */
172 void DEG_graph_data_tag_update(Depsgraph *graph, const PointerRNA *ptr)
173 {
174         DEG::Depsgraph *deg_graph = reinterpret_cast<DEG::Depsgraph *>(graph);
175         DEG::DepsNode *node = deg_graph->find_node_from_pointer(ptr, NULL);
176         if (node != NULL) {
177                 node->tag_update(deg_graph);
178         }
179         else {
180                 printf("Missing node in %s\n", __func__);
181                 BLI_assert(!"Shouldn't happens since it'll miss crucial update.");
182         }
183 }
184
185 /* Tag nodes related to a specific property. */
186 void DEG_graph_property_tag_update(Depsgraph *graph,
187                                    const PointerRNA *ptr,
188                                    const PropertyRNA *prop)
189 {
190         DEG::Depsgraph *deg_graph = reinterpret_cast<DEG::Depsgraph *>(graph);
191         DEG::DepsNode *node = deg_graph->find_node_from_pointer(ptr, prop);
192         if (node != NULL) {
193                 node->tag_update(deg_graph);
194         }
195         else {
196                 printf("Missing node in %s\n", __func__);
197                 BLI_assert(!"Shouldn't happens since it'll miss crucial update.");
198         }
199 }
200
201 /* Tag given ID for an update in all the dependency graphs. */
202 void DEG_id_tag_update(ID *id, short flag)
203 {
204         DEG_id_tag_update_ex(G.main, id, flag);
205 }
206
207 void DEG_id_tag_update_ex(Main *bmain, ID *id, short flag)
208 {
209         if (id == NULL) {
210                 /* Ideally should not happen, but old depsgraph allowed this. */
211                 return;
212         }
213         DEG_DEBUG_PRINTF("%s: id=%s flag=%d\n", __func__, id->name, flag);
214         lib_id_recalc_tag_flag(bmain, id, flag);
215         for (Scene *scene = (Scene *)bmain->scene.first;
216              scene != NULL;
217              scene = (Scene *)scene->id.next)
218         {
219                 if (scene->depsgraph) {
220                         Depsgraph *graph = scene->depsgraph;
221                         if (flag == 0) {
222                                 /* TODO(sergey): Currently blender is still tagging IDs
223                                  * for recalc just using flag=0. This isn't totally correct
224                                  * but we'd better deal with such cases and don't fail.
225                                  */
226                                 DEG_graph_id_tag_update(bmain, graph, id);
227                                 continue;
228                         }
229                         if (flag & OB_RECALC_DATA && GS(id->name) == ID_OB) {
230                                 Object *object = (Object *)id;
231                                 if (object->data != NULL) {
232                                         DEG_graph_id_tag_update(bmain,
233                                                                 graph,
234                                                                 (ID *)object->data);
235                                 }
236                         }
237                         if (flag & (OB_RECALC_OB | OB_RECALC_DATA)) {
238                                 DEG_graph_id_tag_update(bmain, graph, id);
239                         }
240                         else if (flag & OB_RECALC_TIME) {
241                                 DEG_graph_id_tag_update(bmain, graph, id);
242                         }
243                 }
244         }
245
246 #ifdef DEPSGRAPH_USE_LEGACY_TAGGING
247         /* Special handling from the legacy depsgraph.
248          * TODO(sergey): Need to get rid of those once all the areas
249          * are re-formulated in terms of franular nodes.
250          */
251         depsgraph_legacy_handle_update_tag(bmain, id, flag);
252 #endif
253 }
254
255 /* Tag given ID type for update. */
256 void DEG_id_type_tag(Main *bmain, short idtype)
257 {
258         if (idtype == ID_NT) {
259                 /* Stupid workaround so parent datablocks of nested nodetree get looped
260                  * over when we loop over tagged datablock types.
261                  */
262                 DEG_id_type_tag(bmain, ID_MA);
263                 DEG_id_type_tag(bmain, ID_TE);
264                 DEG_id_type_tag(bmain, ID_LA);
265                 DEG_id_type_tag(bmain, ID_WO);
266                 DEG_id_type_tag(bmain, ID_SCE);
267         }
268
269         bmain->id_tag_update[BKE_idcode_to_index(idtype)] = 1;
270 }
271
272 /* Recursively push updates out to all nodes dependent on this,
273  * until all affected are tagged and/or scheduled up for eval
274  */
275 void DEG_ids_flush_tagged(Main *bmain)
276 {
277         for (Scene *scene = (Scene *)bmain->scene.first;
278              scene != NULL;
279              scene = (Scene *)scene->id.next)
280         {
281                 /* TODO(sergey): Only visible scenes? */
282                 if (scene->depsgraph != NULL) {
283                         DEG::deg_graph_flush_updates(
284                                 bmain,
285                                 reinterpret_cast<DEG::Depsgraph *>(scene->depsgraph));
286                 }
287         }
288 }
289
290 /* Update dependency graph when visible scenes/layers changes. */
291 void DEG_graph_on_visible_update(Main *bmain, Scene *scene)
292 {
293         (void) bmain;
294         DEG::Depsgraph *graph = reinterpret_cast<DEG::Depsgraph *>(scene->depsgraph);
295         GHASH_FOREACH_BEGIN(DEG::IDDepsNode *, id_node, graph->id_hash)
296         {
297                 id_node->tag_update(graph);
298         }
299         GHASH_FOREACH_END();
300 }
301
302 void DEG_on_visible_update(Main *bmain, const bool UNUSED(do_time))
303 {
304         for (Scene *scene = (Scene *)bmain->scene.first;
305              scene != NULL;
306              scene = (Scene *)scene->id.next)
307         {
308                 if (scene->depsgraph != NULL) {
309                         DEG_graph_on_visible_update(bmain, scene);
310                 }
311         }
312 }
313
314 /* Check if something was changed in the database and inform
315  * editors about this.
316  */
317 void DEG_ids_check_recalc(Main *bmain, Scene *scene, bool time)
318 {
319         ListBase *lbarray[MAX_LIBARRAY];
320         int a;
321         bool updated = false;
322
323         /* Loop over all ID types. */
324         a  = set_listbasepointers(bmain, lbarray);
325         while (a--) {
326                 ListBase *lb = lbarray[a];
327                 ID *id = (ID *)lb->first;
328
329                 if (id && bmain->id_tag_update[BKE_idcode_to_index(GS(id->name))]) {
330                         updated = true;
331                         break;
332                 }
333         }
334
335         DEG::deg_editors_scene_update(bmain, scene, (updated || time));
336 }
337
338 void DEG_ids_clear_recalc(Main *bmain)
339 {
340         ListBase *lbarray[MAX_LIBARRAY];
341         bNodeTree *ntree;
342         int a;
343
344         /* TODO(sergey): Re-implement POST_UPDATE_HANDLER_WORKAROUND using entry_tags
345          * and id_tags storage from the new dependency graph.
346          */
347
348         /* Loop over all ID types. */
349         a  = set_listbasepointers(bmain, lbarray);
350         while (a--) {
351                 ListBase *lb = lbarray[a];
352                 ID *id = (ID *)lb->first;
353
354                 if (id && bmain->id_tag_update[BKE_idcode_to_index(GS(id->name))]) {
355                         for (; id; id = (ID *)id->next) {
356                                 id->tag &= ~(LIB_TAG_ID_RECALC | LIB_TAG_ID_RECALC_DATA);
357
358                                 /* Some ID's contain semi-datablock nodetree */
359                                 ntree = ntreeFromID(id);
360                                 if (ntree != NULL) {
361                                         ntree->id.tag &= ~(LIB_TAG_ID_RECALC | LIB_TAG_ID_RECALC_DATA);
362                                 }
363                         }
364                 }
365         }
366
367         memset(bmain->id_tag_update, 0, sizeof(bmain->id_tag_update));
368 }