Cleanup: remove redundant doxygen \file argument
[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 \ingroup depsgraph
21  *
22  * Implementation of Querying API
23  */
24
25 #include "MEM_guardedalloc.h"
26
27 extern "C" {
28 #include <string.h> // XXX: memcpy
29
30 #include "BLI_utildefines.h"
31 #include "BKE_idcode.h"
32 #include "BKE_main.h"
33 #include "BLI_listbase.h"
34
35 #include "BKE_action.h" // XXX: BKE_pose_channel_from_name
36 } /* extern "C" */
37
38 #include "DNA_object_types.h"
39 #include "DNA_scene_types.h"
40
41 #include "RNA_access.h"
42
43 #include "DEG_depsgraph.h"
44 #include "DEG_depsgraph_query.h"
45
46 #include "intern/depsgraph.h"
47 #include "intern/eval/deg_eval_copy_on_write.h"
48 #include "intern/node/deg_node_id.h"
49
50 struct Scene *DEG_get_input_scene(const Depsgraph *graph)
51 {
52         const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
53         return deg_graph->scene;
54 }
55
56 struct ViewLayer *DEG_get_input_view_layer(const Depsgraph *graph)
57 {
58         const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
59         return deg_graph->view_layer;
60 }
61
62 eEvaluationMode DEG_get_mode(const Depsgraph *graph)
63 {
64         const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
65         return deg_graph->mode;
66 }
67
68 float DEG_get_ctime(const Depsgraph *graph)
69 {
70         const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
71         return deg_graph->ctime;
72 }
73
74
75 bool DEG_id_type_updated(const Depsgraph *graph, short id_type)
76 {
77         const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
78         return deg_graph->id_type_updated[BKE_idcode_to_index(id_type)] != 0;
79 }
80
81 bool DEG_id_type_any_updated(const Depsgraph *graph)
82 {
83         const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
84
85         /* Loop over all ID types. */
86         for (int id_type_index = 0; id_type_index < MAX_LIBARRAY; id_type_index++) {
87                 if (deg_graph->id_type_updated[id_type_index]) {
88                         return true;
89                 }
90         }
91
92         return false;
93 }
94
95 uint32_t DEG_get_eval_flags_for_id(const Depsgraph *graph, ID *id)
96 {
97         if (graph == NULL) {
98                 /* Happens when converting objects to mesh from a python script
99                  * after modifying scene graph.
100                  *
101                  * Currently harmless because it's only called for temporary
102                  * objects which are out of the DAG anyway. */
103                 return 0;
104         }
105
106         const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
107         const DEG::IDNode *id_node = deg_graph->find_id_node(DEG_get_original_id(id));
108         if (id_node == NULL) {
109                 /* TODO(sergey): Does it mean we need to check set scene? */
110                 return 0;
111         }
112
113         return id_node->eval_flags;
114 }
115
116 uint64_t DEG_get_customdata_mask_for_object(const Depsgraph *graph, Object *ob)
117 {
118         if (graph == NULL) {
119                 /* Happens when converting objects to mesh from a python script
120                  * after modifying scene graph.
121                  *
122                  * Currently harmless because it's only called for temporary
123                  * objects which are out of the DAG anyway. */
124                 return 0;
125         }
126
127         const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
128         const DEG::IDNode *id_node = deg_graph->find_id_node(DEG_get_original_id(&ob->id));
129         if (id_node == NULL) {
130                 /* TODO(sergey): Does it mean we need to check set scene? */
131                 return 0;
132         }
133
134         return id_node->customdata_mask;
135 }
136
137 Scene *DEG_get_evaluated_scene(const Depsgraph *graph)
138 {
139         const DEG::Depsgraph *deg_graph =
140                 reinterpret_cast<const DEG::Depsgraph *>(graph);
141         Scene *scene_cow = deg_graph->scene_cow;
142         /* TODO(sergey): Shall we expand datablock here? Or is it OK to assume
143          * that calleer is OK with just a pointer in case scene is not updated
144          * yet? */
145         BLI_assert(scene_cow != NULL && DEG::deg_copy_on_write_is_expanded(&scene_cow->id));
146         return scene_cow;
147 }
148
149 ViewLayer *DEG_get_evaluated_view_layer(const Depsgraph *graph)
150 {
151         const DEG::Depsgraph *deg_graph =
152                 reinterpret_cast<const DEG::Depsgraph *>(graph);
153         Scene *scene_cow = DEG_get_evaluated_scene(graph);
154         if (scene_cow == NULL) {
155                 return NULL;  /* Happens with new, not-yet-built/evaluated graphes. */
156         }
157         /* Do name-based lookup. */
158         /* TODO(sergey): Can this be optimized? */
159         ViewLayer *view_layer_orig = deg_graph->view_layer;
160         ViewLayer *view_layer_cow =
161                 (ViewLayer *)BLI_findstring(&scene_cow->view_layers,
162                                              view_layer_orig->name,
163                                              offsetof(ViewLayer, name));
164         BLI_assert(view_layer_cow != NULL);
165         return view_layer_cow;
166 }
167
168 Object *DEG_get_evaluated_object(const Depsgraph *depsgraph, Object *object)
169 {
170         return (Object *)DEG_get_evaluated_id(depsgraph, &object->id);
171 }
172
173 ID *DEG_get_evaluated_id(const Depsgraph *depsgraph, ID *id)
174 {
175         if (id == NULL) {
176                 return NULL;
177         }
178         /* TODO(sergey): This is a duplicate of Depsgraph::get_cow_id(),
179          * but here we never do assert, since we don't know nature of the
180          * incoming ID datablock. */
181         const DEG::Depsgraph *deg_graph = (const DEG::Depsgraph *)depsgraph;
182         const DEG::IDNode *id_node = deg_graph->find_id_node(id);
183         if (id_node == NULL) {
184                 return id;
185         }
186         return id_node->id_cow;
187 }
188
189 /* Get evaluated version of data pointed to by RNA pointer */
190 void DEG_get_evaluated_rna_pointer(const Depsgraph *depsgraph, PointerRNA *ptr, PointerRNA *r_ptr_eval)
191 {
192         if ((ptr == NULL) || (r_ptr_eval == NULL)) {
193                 return;
194         }
195         ID *orig_id = (ID *)ptr->id.data;
196         ID *cow_id = DEG_get_evaluated_id(depsgraph, orig_id);
197         if (ptr->id.data == ptr->data) {
198                 /* For ID pointers, it's easy... */
199                 r_ptr_eval->id.data = (void *)cow_id;
200                 r_ptr_eval->data = (void *)cow_id;
201                 r_ptr_eval->type = ptr->type;
202         }
203         else if (ptr->type == &RNA_PoseBone) {
204                 /* HACK: Since bone keyframing is quite commonly used,
205                  * speed things up for this case by doing a special lookup
206                  * for bones */
207                 const Object *ob_eval = (Object *)cow_id;
208                 bPoseChannel *pchan = (bPoseChannel *)ptr->data;
209                 const bPoseChannel *pchan_eval = BKE_pose_channel_find_name(ob_eval->pose, pchan->name);
210                 r_ptr_eval->id.data = (void *)cow_id;
211                 r_ptr_eval->data = (void *)pchan_eval;
212                 r_ptr_eval->type = ptr->type;
213         }
214         else {
215                 /* For everything else, try to get RNA Path of the BMain-pointer,
216                  * then use that to look up what the COW-domain one should be
217                  * given the COW ID pointer as the new lookup point */
218                 /* TODO: Find a faster alternative, or implement support for other
219                  * common types too above (e.g. modifiers) */
220                 char *path = RNA_path_from_ID_to_struct(ptr);
221                 if (path) {
222                         PointerRNA cow_id_ptr;
223                         RNA_id_pointer_create(cow_id, &cow_id_ptr);
224                         if (!RNA_path_resolve(&cow_id_ptr, path, r_ptr_eval, NULL)) {
225                                 /* Couldn't find COW copy of data */
226                                 fprintf(stderr,
227                                         "%s: Couldn't resolve RNA path ('%s') relative to COW ID (%p) for '%s'\n",
228                                         __func__, path, (void *)cow_id, orig_id->name);
229                         }
230                 }
231                 else {
232                         /* Path resolution failed - XXX: Hide this behind a debug flag */
233                         fprintf(stderr,
234                                 "%s: Couldn't get RNA path for %s relative to %s\n",
235                                 __func__, RNA_struct_identifier(ptr->type), orig_id->name);
236                 }
237         }
238 }
239
240 Object *DEG_get_original_object(Object *object)
241 {
242         return (Object *)DEG_get_original_id(&object->id);
243 }
244
245 ID *DEG_get_original_id(ID *id)
246 {
247         if (id == NULL) {
248                 return NULL;
249         }
250         if (id->orig_id == NULL) {
251                 return id;
252         }
253         BLI_assert((id->tag & LIB_TAG_COPIED_ON_WRITE) != 0);
254         return (ID *)id->orig_id;
255 }