Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / animation / anim_motion_paths.c
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
17 /** \file
18  * \ingroup bke
19  */
20
21 #include "MEM_guardedalloc.h"
22
23 #include <stdlib.h>
24
25 #include "BLI_listbase.h"
26 #include "BLI_math.h"
27 #include "BLI_dlrbTree.h"
28
29 #include "DNA_anim_types.h"
30 #include "DNA_armature_types.h"
31 #include "DNA_scene_types.h"
32
33 #include "BKE_animsys.h"
34 #include "BKE_action.h"
35 #include "BKE_main.h"
36 #include "BKE_scene.h"
37
38 #include "DEG_depsgraph.h"
39 #include "DEG_depsgraph_query.h"
40
41 #include "GPU_batch.h"
42 #include "GPU_vertex_buffer.h"
43
44 #include "ED_anim_api.h"
45 #include "ED_keyframes_draw.h"
46
47 #include "CLG_log.h"
48
49 static CLG_LogRef LOG = {"ed.anim.motion_paths"};
50
51 /* Motion path needing to be baked (mpt) */
52 typedef struct MPathTarget {
53   struct MPathTarget *next, *prev;
54
55   bMotionPath *mpath; /* motion path in question */
56
57   DLRBT_Tree keys; /* temp, to know where the keyframes are */
58
59   /* Original (Source Objects) */
60   Object *ob;          /* source object */
61   bPoseChannel *pchan; /* source posechannel (if applicable) */
62
63   /* "Evaluated" Copies (these come from the background COW copie
64    * that provide all the coordinates we want to save off)
65    */
66   Object *ob_eval; /* evaluated object */
67 } MPathTarget;
68
69 /* ........ */
70
71 /* get list of motion paths to be baked for the given object
72  * - assumes the given list is ready to be used
73  */
74 /* TODO: it would be nice in future to be able to update objects dependent on these bones too? */
75 void animviz_get_object_motionpaths(Object *ob, ListBase *targets)
76 {
77   MPathTarget *mpt;
78
79   /* object itself first */
80   if ((ob->avs.recalc & ANIMVIZ_RECALC_PATHS) && (ob->mpath)) {
81     /* new target for object */
82     mpt = MEM_callocN(sizeof(MPathTarget), "MPathTarget Ob");
83     BLI_addtail(targets, mpt);
84
85     mpt->mpath = ob->mpath;
86     mpt->ob = ob;
87   }
88
89   /* bones */
90   if ((ob->pose) && (ob->pose->avs.recalc & ANIMVIZ_RECALC_PATHS)) {
91     bArmature *arm = ob->data;
92     bPoseChannel *pchan;
93
94     for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
95       if ((pchan->bone) && (arm->layer & pchan->bone->layer) && (pchan->mpath)) {
96         /* new target for bone */
97         mpt = MEM_callocN(sizeof(MPathTarget), "MPathTarget PoseBone");
98         BLI_addtail(targets, mpt);
99
100         mpt->mpath = pchan->mpath;
101         mpt->ob = ob;
102         mpt->pchan = pchan;
103       }
104     }
105   }
106 }
107
108 /* ........ */
109
110 /* update scene for current frame */
111 static void motionpaths_calc_update_scene(Main *bmain, struct Depsgraph *depsgraph)
112 {
113   /* Do all updates
114    *  - if this is too slow, resort to using a more efficient way
115    *    that doesn't force complete update, but for now, this is the
116    *    most accurate way!
117    *
118    * TODO(segey): Bring back partial updates, which became impossible
119    * with the new depsgraph due to unsorted nature of bases.
120    *
121    * TODO(sergey): Use evaluation context dedicated to motion paths.
122    */
123   BKE_scene_graph_update_for_newframe(depsgraph, bmain);
124 }
125
126 /* ........ */
127
128 /* perform baking for the targets on the current frame */
129 static void motionpaths_calc_bake_targets(ListBase *targets, int cframe)
130 {
131   MPathTarget *mpt;
132
133   /* for each target, check if it can be baked on the current frame */
134   for (mpt = targets->first; mpt; mpt = mpt->next) {
135     bMotionPath *mpath = mpt->mpath;
136
137     /* current frame must be within the range the cache works for
138      * - is inclusive of the first frame, but not the last otherwise we get buffer overruns
139      */
140     if ((cframe < mpath->start_frame) || (cframe >= mpath->end_frame)) {
141       continue;
142     }
143
144     /* get the relevant cache vert to write to */
145     bMotionPathVert *mpv = mpath->points + (cframe - mpath->start_frame);
146
147     Object *ob_eval = mpt->ob_eval;
148
149     /* Lookup evaluated pose channel, here because the depsgraph
150      * evaluation can change them so they are not cached in mpt. */
151     bPoseChannel *pchan_eval = NULL;
152     if (mpt->pchan) {
153       pchan_eval = BKE_pose_channel_find_name(ob_eval->pose, mpt->pchan->name);
154     }
155
156     /* pose-channel or object path baking? */
157     if (pchan_eval) {
158       /* heads or tails */
159       if (mpath->flag & MOTIONPATH_FLAG_BHEAD) {
160         copy_v3_v3(mpv->co, pchan_eval->pose_head);
161       }
162       else {
163         copy_v3_v3(mpv->co, pchan_eval->pose_tail);
164       }
165
166       /* result must be in worldspace */
167       mul_m4_v3(ob_eval->obmat, mpv->co);
168     }
169     else {
170       /* worldspace object location */
171       copy_v3_v3(mpv->co, ob_eval->obmat[3]);
172     }
173
174     float mframe = (float)(cframe);
175
176     /* Tag if it's a keyframe */
177     if (BLI_dlrbTree_search_exact(&mpt->keys, compare_ak_cfraPtr, &mframe)) {
178       mpv->flag |= MOTIONPATH_VERT_KEY;
179     }
180     else {
181       mpv->flag &= ~MOTIONPATH_VERT_KEY;
182     }
183
184     /* Incremental update on evaluated object if possible, for fast updating
185      * while dragging in transform. */
186     bMotionPath *mpath_eval = NULL;
187     if (mpt->pchan) {
188       mpath_eval = (pchan_eval) ? pchan_eval->mpath : NULL;
189     }
190     else {
191       mpath_eval = ob_eval->mpath;
192     }
193
194     if (mpath_eval && mpath_eval->length == mpath->length) {
195       bMotionPathVert *mpv_eval = mpath_eval->points + (cframe - mpath_eval->start_frame);
196       *mpv_eval = *mpv;
197
198       GPU_VERTBUF_DISCARD_SAFE(mpath_eval->points_vbo);
199       GPU_BATCH_DISCARD_SAFE(mpath_eval->batch_line);
200       GPU_BATCH_DISCARD_SAFE(mpath_eval->batch_points);
201     }
202   }
203 }
204
205 /* Perform baking of the given object's and/or its bones' transforms to motion paths
206  * - scene: current scene
207  * - ob: object whose flagged motionpaths should get calculated
208  * - recalc: whether we need to
209  */
210 /* TODO: include reports pointer? */
211 void animviz_calc_motionpaths(Depsgraph *depsgraph,
212                               Main *bmain,
213                               Scene *scene,
214                               ListBase *targets,
215                               bool restore,
216                               bool current_frame_only)
217 {
218   /* sanity check */
219   if (ELEM(NULL, targets, targets->first)) {
220     return;
221   }
222
223   /* Compute frame range to bake within.
224    * TODO: this method could be improved...
225    * 1) max range for standard baking
226    * 2) minimum range for recalc baking (i.e. between keyframes, but how?) */
227   int sfra = INT_MAX;
228   int efra = INT_MIN;
229
230   for (MPathTarget *mpt = targets->first; mpt; mpt = mpt->next) {
231     /* try to increase area to do (only as much as needed) */
232     sfra = MIN2(sfra, mpt->mpath->start_frame);
233     efra = MAX2(efra, mpt->mpath->end_frame);
234   }
235
236   if (efra <= sfra) {
237     return;
238   }
239
240   /* Limit frame range if we are updating just the current frame. */
241   /* set frame values */
242   int cfra = CFRA;
243   if (current_frame_only) {
244     if (cfra < sfra || cfra > efra) {
245       return;
246     }
247     sfra = efra = cfra;
248   }
249
250   /* get copies of objects/bones to get the calculated results from
251    * (for copy-on-write evaluation), so that we actually get some results
252    */
253   // TODO: Create a copy of background depsgraph that only contain these entities,
254   // and only evaluates them.
255   for (MPathTarget *mpt = targets->first; mpt; mpt = mpt->next) {
256     mpt->ob_eval = DEG_get_evaluated_object(depsgraph, mpt->ob);
257
258     AnimData *adt = BKE_animdata_from_id(&mpt->ob_eval->id);
259
260     /* build list of all keyframes in active action for object or pchan */
261     BLI_dlrbTree_init(&mpt->keys);
262
263     if (adt) {
264       bAnimVizSettings *avs;
265
266       /* get pointer to animviz settings for each target */
267       if (mpt->pchan) {
268         avs = &mpt->ob->pose->avs;
269       }
270       else {
271         avs = &mpt->ob->avs;
272       }
273
274       /* it is assumed that keyframes for bones are all grouped in a single group
275        * unless an option is set to always use the whole action
276        */
277       if ((mpt->pchan) && (avs->path_viewflag & MOTIONPATH_VIEW_KFACT) == 0) {
278         bActionGroup *agrp = BKE_action_group_find_name(adt->action, mpt->pchan->name);
279
280         if (agrp) {
281           agroup_to_keylist(adt, agrp, &mpt->keys, 0);
282         }
283       }
284       else {
285         action_to_keylist(adt, adt->action, &mpt->keys, 0);
286       }
287     }
288   }
289
290   /* calculate path over requested range */
291   CLOG_INFO(&LOG,
292             1,
293             "Calculating MotionPaths between frames %d - %d (%d frames)",
294             sfra,
295             efra,
296             efra - sfra + 1);
297   for (CFRA = sfra; CFRA <= efra; CFRA++) {
298     if (current_frame_only) {
299       /* For current frame, only update tagged. */
300       BKE_scene_graph_update_tagged(depsgraph, bmain);
301     }
302     else {
303       /* Update relevant data for new frame. */
304       motionpaths_calc_update_scene(bmain, depsgraph);
305     }
306
307     /* perform baking for targets */
308     motionpaths_calc_bake_targets(targets, CFRA);
309   }
310
311   /* reset original environment */
312   /* NOTE: We don't always need to reevaluate the main scene, as the depsgraph
313    * may be a temporary one that works on a subset of the data. We always have
314    * to resoture the current frame though. */
315   CFRA = cfra;
316   if (!current_frame_only && restore) {
317     motionpaths_calc_update_scene(bmain, depsgraph);
318   }
319
320   /* clear recalc flags from targets */
321   for (MPathTarget *mpt = targets->first; mpt; mpt = mpt->next) {
322     bAnimVizSettings *avs;
323     bMotionPath *mpath = mpt->mpath;
324
325     /* get pointer to animviz settings for each target */
326     if (mpt->pchan) {
327       avs = &mpt->ob->pose->avs;
328     }
329     else {
330       avs = &mpt->ob->avs;
331     }
332
333     /* clear the flag requesting recalculation of targets */
334     avs->recalc &= ~ANIMVIZ_RECALC_PATHS;
335
336     /* Clean temp data */
337     BLI_dlrbTree_free(&mpt->keys);
338
339     /* Free previous batches to force update. */
340     GPU_VERTBUF_DISCARD_SAFE(mpath->points_vbo);
341     GPU_BATCH_DISCARD_SAFE(mpath->batch_line);
342     GPU_BATCH_DISCARD_SAFE(mpath->batch_points);
343   }
344 }