Incompatible usage of the Collada transparency value
[blender.git] / source / blender / depsgraph / intern / depsgraph_query.cc
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2013 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup depsgraph
22  *
23  * Implementation of Querying API
24  */
25
26 #include "MEM_guardedalloc.h"
27
28 extern "C" {
29 #include <string.h>  // XXX: memcpy
30
31 #include "BLI_utildefines.h"
32 #include "BLI_listbase.h"
33 #include "BLI_ghash.h"
34
35 #include "BKE_action.h"  // XXX: BKE_pose_channel_find_name
36 #include "BKE_customdata.h"
37 #include "BKE_idcode.h"
38 #include "BKE_main.h"
39
40 } /* extern "C" */
41
42 #include "DNA_object_types.h"
43 #include "DNA_scene_types.h"
44
45 #include "RNA_access.h"
46
47 #include "DEG_depsgraph.h"
48 #include "DEG_depsgraph_query.h"
49
50 #include "intern/depsgraph.h"
51 #include "intern/eval/deg_eval_copy_on_write.h"
52 #include "intern/node/deg_node_id.h"
53
54 struct Scene *DEG_get_input_scene(const Depsgraph *graph)
55 {
56   const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
57   return deg_graph->scene;
58 }
59
60 struct ViewLayer *DEG_get_input_view_layer(const Depsgraph *graph)
61 {
62   const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
63   return deg_graph->view_layer;
64 }
65
66 eEvaluationMode DEG_get_mode(const Depsgraph *graph)
67 {
68   const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
69   return deg_graph->mode;
70 }
71
72 float DEG_get_ctime(const Depsgraph *graph)
73 {
74   const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
75   return deg_graph->ctime;
76 }
77
78 bool DEG_id_type_updated(const Depsgraph *graph, short id_type)
79 {
80   const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
81   return deg_graph->id_type_updated[BKE_idcode_to_index(id_type)] != 0;
82 }
83
84 bool DEG_id_type_any_updated(const Depsgraph *graph)
85 {
86   const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
87
88   /* Loop over all ID types. */
89   for (int id_type_index = 0; id_type_index < MAX_LIBARRAY; id_type_index++) {
90     if (deg_graph->id_type_updated[id_type_index]) {
91       return true;
92     }
93   }
94
95   return false;
96 }
97
98 bool DEG_id_type_any_exists(const Depsgraph *depsgraph, short id_type)
99 {
100   const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(depsgraph);
101   return deg_graph->id_type_exist[BKE_idcode_to_index(id_type)] != 0;
102 }
103
104 uint32_t DEG_get_eval_flags_for_id(const Depsgraph *graph, ID *id)
105 {
106   if (graph == NULL) {
107     /* Happens when converting objects to mesh from a python script
108      * after modifying scene graph.
109      *
110      * Currently harmless because it's only called for temporary
111      * objects which are out of the DAG anyway. */
112     return 0;
113   }
114
115   const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
116   const DEG::IDNode *id_node = deg_graph->find_id_node(DEG_get_original_id(id));
117   if (id_node == NULL) {
118     /* TODO(sergey): Does it mean we need to check set scene? */
119     return 0;
120   }
121
122   return id_node->eval_flags;
123 }
124
125 void DEG_get_customdata_mask_for_object(const Depsgraph *graph,
126                                         Object *ob,
127                                         CustomData_MeshMasks *r_mask)
128 {
129   if (graph == NULL) {
130     /* Happens when converting objects to mesh from a python script
131      * after modifying scene graph.
132      *
133      * Currently harmless because it's only called for temporary
134      * objects which are out of the DAG anyway. */
135     return;
136   }
137
138   const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
139   const DEG::IDNode *id_node = deg_graph->find_id_node(DEG_get_original_id(&ob->id));
140   if (id_node == NULL) {
141     /* TODO(sergey): Does it mean we need to check set scene? */
142     return;
143   }
144
145   r_mask->vmask |= id_node->customdata_masks.vert_mask;
146   r_mask->emask |= id_node->customdata_masks.edge_mask;
147   r_mask->fmask |= id_node->customdata_masks.face_mask;
148   r_mask->lmask |= id_node->customdata_masks.loop_mask;
149   r_mask->pmask |= id_node->customdata_masks.poly_mask;
150 }
151
152 Scene *DEG_get_evaluated_scene(const Depsgraph *graph)
153 {
154   const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
155   Scene *scene_cow = deg_graph->scene_cow;
156   /* TODO(sergey): Shall we expand data-block here? Or is it OK to assume
157    * that calleer is OK with just a pointer in case scene is not updated
158    * yet? */
159   BLI_assert(scene_cow != NULL && DEG::deg_copy_on_write_is_expanded(&scene_cow->id));
160   return scene_cow;
161 }
162
163 ViewLayer *DEG_get_evaluated_view_layer(const Depsgraph *graph)
164 {
165   const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
166   Scene *scene_cow = DEG_get_evaluated_scene(graph);
167   if (scene_cow == NULL) {
168     return NULL; /* Happens with new, not-yet-built/evaluated graphes. */
169   }
170   /* Do name-based lookup. */
171   /* TODO(sergey): Can this be optimized? */
172   ViewLayer *view_layer_orig = deg_graph->view_layer;
173   ViewLayer *view_layer_cow = (ViewLayer *)BLI_findstring(
174       &scene_cow->view_layers, view_layer_orig->name, offsetof(ViewLayer, name));
175   BLI_assert(view_layer_cow != NULL);
176   return view_layer_cow;
177 }
178
179 Object *DEG_get_evaluated_object(const Depsgraph *depsgraph, Object *object)
180 {
181   return (Object *)DEG_get_evaluated_id(depsgraph, &object->id);
182 }
183
184 ID *DEG_get_evaluated_id(const Depsgraph *depsgraph, ID *id)
185 {
186   if (id == NULL) {
187     return NULL;
188   }
189   /* TODO(sergey): This is a duplicate of Depsgraph::get_cow_id(),
190    * but here we never do assert, since we don't know nature of the
191    * incoming ID data-block. */
192   const DEG::Depsgraph *deg_graph = (const DEG::Depsgraph *)depsgraph;
193   const DEG::IDNode *id_node = deg_graph->find_id_node(id);
194   if (id_node == NULL) {
195     return id;
196   }
197   return id_node->id_cow;
198 }
199
200 /* Get evaluated version of data pointed to by RNA pointer */
201 void DEG_get_evaluated_rna_pointer(const Depsgraph *depsgraph,
202                                    PointerRNA *ptr,
203                                    PointerRNA *r_ptr_eval)
204 {
205   if ((ptr == NULL) || (r_ptr_eval == NULL)) {
206     return;
207   }
208   ID *orig_id = (ID *)ptr->id.data;
209   ID *cow_id = DEG_get_evaluated_id(depsgraph, orig_id);
210   if (ptr->id.data == ptr->data) {
211     /* For ID pointers, it's easy... */
212     r_ptr_eval->id.data = (void *)cow_id;
213     r_ptr_eval->data = (void *)cow_id;
214     r_ptr_eval->type = ptr->type;
215   }
216   else if (ptr->type == &RNA_PoseBone) {
217     /* HACK: Since bone keyframing is quite commonly used,
218      * speed things up for this case by doing a special lookup
219      * for bones */
220     const Object *ob_eval = (Object *)cow_id;
221     bPoseChannel *pchan = (bPoseChannel *)ptr->data;
222     const bPoseChannel *pchan_eval = BKE_pose_channel_find_name(ob_eval->pose, pchan->name);
223     r_ptr_eval->id.data = (void *)cow_id;
224     r_ptr_eval->data = (void *)pchan_eval;
225     r_ptr_eval->type = ptr->type;
226   }
227   else {
228     /* For everything else, try to get RNA Path of the BMain-pointer,
229      * then use that to look up what the COW-domain one should be
230      * given the COW ID pointer as the new lookup point */
231     /* TODO: Find a faster alternative, or implement support for other
232      * common types too above (e.g. modifiers) */
233     char *path = RNA_path_from_ID_to_struct(ptr);
234     if (path) {
235       PointerRNA cow_id_ptr;
236       RNA_id_pointer_create(cow_id, &cow_id_ptr);
237       if (!RNA_path_resolve(&cow_id_ptr, path, r_ptr_eval, NULL)) {
238         /* Couldn't find COW copy of data */
239         fprintf(stderr,
240                 "%s: Couldn't resolve RNA path ('%s') relative to COW ID (%p) for '%s'\n",
241                 __func__,
242                 path,
243                 (void *)cow_id,
244                 orig_id->name);
245       }
246     }
247     else {
248       /* Path resolution failed - XXX: Hide this behind a debug flag */
249       fprintf(stderr,
250               "%s: Couldn't get RNA path for %s relative to %s\n",
251               __func__,
252               RNA_struct_identifier(ptr->type),
253               orig_id->name);
254     }
255   }
256 }
257
258 Object *DEG_get_original_object(Object *object)
259 {
260   return (Object *)DEG_get_original_id(&object->id);
261 }
262
263 ID *DEG_get_original_id(ID *id)
264 {
265   if (id == NULL) {
266     return NULL;
267   }
268   if (id->orig_id == NULL) {
269     return id;
270   }
271   BLI_assert((id->tag & LIB_TAG_COPIED_ON_WRITE) != 0);
272   return (ID *)id->orig_id;
273 }
274
275 bool DEG_is_original_id(ID *id)
276 {
277   /* Some explanation of the logic.
278    *
279    * What we want here is to be able to tell whether given ID is a result of dependency graph
280    * evaluation or not.
281    *
282    * All the data-blocks which are created by copy-on-write mechanism will have will be tagged with
283    * LIB_TAG_COPIED_ON_WRITE tag. Those data-blocks can not be original.
284    *
285    * Modifier stack evaluation might create special data-blocks which have all the modifiers
286    * applied, and those will be tagged with LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT. Such data-blocks
287    * can not be original as well.
288    *
289    * Localization is usually happening from evaluated data-block, or will have some special pointer
290    * magic which will make them to act as evaluated.
291    *
292    * NOTE: We consider ID evaluated if ANY of those flags is set. We do NOT require ALL of them. */
293   if (id->tag &
294       (LIB_TAG_COPIED_ON_WRITE | LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT | LIB_TAG_LOCALIZED)) {
295     return false;
296   }
297   return true;
298 }
299
300 bool DEG_is_original_object(Object *object)
301 {
302   return DEG_is_original_id(&object->id);
303 }
304
305 bool DEG_is_evaluated_id(ID *id)
306 {
307   return !DEG_is_original_id(id);
308 }
309
310 bool DEG_is_evaluated_object(Object *object)
311 {
312   return !DEG_is_original_object(object);
313 }
314
315 bool DEG_is_fully_evaluated(const struct Depsgraph *depsgraph)
316 {
317   const DEG::Depsgraph *deg_graph = (const DEG::Depsgraph *)depsgraph;
318   /* Check whether relations are up to date. */
319   if (deg_graph->need_update) {
320     return false;
321   }
322   /* Check whether IDs are up to date. */
323   if (BLI_gset_len(deg_graph->entry_tags) > 0) {
324     return false;
325   }
326   return true;
327 }