Cleanup: style, use braces for blenkernel
[blender.git] / source / blender / blenkernel / intern / mask.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  * The Original Code is Copyright (C) 2012 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <stddef.h>
25 #include <string.h>
26
27 #include "CLG_log.h"
28
29 #include "MEM_guardedalloc.h"
30
31 #include "BLI_utildefines.h"
32 #include "BLI_ghash.h"
33 #include "BLI_string.h"
34 #include "BLI_string_utils.h"
35 #include "BLI_listbase.h"
36 #include "BLI_math.h"
37
38 #include "BLT_translation.h"
39
40 #include "DNA_mask_types.h"
41 #include "DNA_node_types.h"
42 #include "DNA_screen_types.h"
43 #include "DNA_space_types.h"
44 #include "DNA_sequence_types.h"
45
46 #include "BKE_animsys.h"
47 #include "BKE_curve.h"
48
49 #include "BKE_library.h"
50 #include "BKE_main.h"
51 #include "BKE_mask.h"
52 #include "BKE_node.h"
53 #include "BKE_sequencer.h"
54 #include "BKE_tracking.h"
55 #include "BKE_movieclip.h"
56 #include "BKE_image.h"
57
58 #include "DEG_depsgraph_build.h"
59
60 static CLG_LogRef LOG = {"bke.mask"};
61
62 static struct {
63   ListBase splines;
64   struct GHash *id_hash;
65 } mask_clipboard = {{NULL}};
66
67 static MaskSplinePoint *mask_spline_point_next(MaskSpline *spline,
68                                                MaskSplinePoint *points_array,
69                                                MaskSplinePoint *point)
70 {
71   if (point == &points_array[spline->tot_point - 1]) {
72     if (spline->flag & MASK_SPLINE_CYCLIC) {
73       return &points_array[0];
74     }
75     else {
76       return NULL;
77     }
78   }
79   else {
80     return point + 1;
81   }
82 }
83
84 static MaskSplinePoint *mask_spline_point_prev(MaskSpline *spline,
85                                                MaskSplinePoint *points_array,
86                                                MaskSplinePoint *point)
87 {
88   if (point == points_array) {
89     if (spline->flag & MASK_SPLINE_CYCLIC) {
90       return &points_array[spline->tot_point - 1];
91     }
92     else {
93       return NULL;
94     }
95   }
96   else {
97     return point - 1;
98   }
99 }
100
101 BezTriple *BKE_mask_spline_point_next_bezt(MaskSpline *spline,
102                                            MaskSplinePoint *points_array,
103                                            MaskSplinePoint *point)
104 {
105   if (point == &points_array[spline->tot_point - 1]) {
106     if (spline->flag & MASK_SPLINE_CYCLIC) {
107       return &(points_array[0].bezt);
108     }
109     else {
110       return NULL;
111     }
112   }
113   else {
114     return &((point + 1))->bezt;
115   }
116 }
117
118 MaskSplinePoint *BKE_mask_spline_point_array(MaskSpline *spline)
119 {
120   return spline->points_deform ? spline->points_deform : spline->points;
121 }
122
123 MaskSplinePoint *BKE_mask_spline_point_array_from_point(MaskSpline *spline,
124                                                         const MaskSplinePoint *point_ref)
125 {
126   if ((point_ref >= spline->points) && (point_ref < &spline->points[spline->tot_point])) {
127     return spline->points;
128   }
129
130   if ((point_ref >= spline->points_deform) &&
131       (point_ref < &spline->points_deform[spline->tot_point])) {
132     return spline->points_deform;
133   }
134
135   BLI_assert(!"wrong array");
136   return NULL;
137 }
138
139 /* mask layers */
140
141 MaskLayer *BKE_mask_layer_new(Mask *mask, const char *name)
142 {
143   MaskLayer *masklay = MEM_callocN(sizeof(MaskLayer), __func__);
144
145   if (name && name[0]) {
146     BLI_strncpy(masklay->name, name, sizeof(masklay->name));
147   }
148   else {
149     strcpy(masklay->name, "MaskLayer");
150   }
151
152   BLI_addtail(&mask->masklayers, masklay);
153
154   BKE_mask_layer_unique_name(mask, masklay);
155
156   mask->masklay_tot++;
157
158   masklay->blend = MASK_BLEND_MERGE_ADD;
159   masklay->alpha = 1.0f;
160   masklay->flag = MASK_LAYERFLAG_FILL_DISCRETE | MASK_LAYERFLAG_FILL_OVERLAP;
161
162   return masklay;
163 }
164
165 /* note: may still be hidden, caller needs to check */
166 MaskLayer *BKE_mask_layer_active(Mask *mask)
167 {
168   return BLI_findlink(&mask->masklayers, mask->masklay_act);
169 }
170
171 void BKE_mask_layer_active_set(Mask *mask, MaskLayer *masklay)
172 {
173   mask->masklay_act = BLI_findindex(&mask->masklayers, masklay);
174 }
175
176 void BKE_mask_layer_remove(Mask *mask, MaskLayer *masklay)
177 {
178   BLI_remlink(&mask->masklayers, masklay);
179   BKE_mask_layer_free(masklay);
180
181   mask->masklay_tot--;
182
183   if (mask->masklay_act >= mask->masklay_tot) {
184     mask->masklay_act = mask->masklay_tot - 1;
185   }
186 }
187
188 void BKE_mask_layer_unique_name(Mask *mask, MaskLayer *masklay)
189 {
190   BLI_uniquename(&mask->masklayers,
191                  masklay,
192                  DATA_("MaskLayer"),
193                  '.',
194                  offsetof(MaskLayer, name),
195                  sizeof(masklay->name));
196 }
197
198 void BKE_mask_layer_rename(Mask *mask, MaskLayer *masklay, char *oldname, char *newname)
199 {
200   BLI_strncpy(masklay->name, newname, sizeof(masklay->name));
201
202   BKE_mask_layer_unique_name(mask, masklay);
203
204   /* now fix animation paths */
205   BKE_animdata_fix_paths_rename_all(&mask->id, "layers", oldname, masklay->name);
206 }
207
208 MaskLayer *BKE_mask_layer_copy(const MaskLayer *masklay)
209 {
210   MaskLayer *masklay_new;
211   MaskSpline *spline;
212
213   masklay_new = MEM_callocN(sizeof(MaskLayer), "new mask layer");
214
215   BLI_strncpy(masklay_new->name, masklay->name, sizeof(masklay_new->name));
216
217   masklay_new->alpha = masklay->alpha;
218   masklay_new->blend = masklay->blend;
219   masklay_new->blend_flag = masklay->blend_flag;
220   masklay_new->flag = masklay->flag;
221   masklay_new->falloff = masklay->falloff;
222   masklay_new->restrictflag = masklay->restrictflag;
223
224   for (spline = masklay->splines.first; spline; spline = spline->next) {
225     MaskSpline *spline_new = BKE_mask_spline_copy(spline);
226
227     BLI_addtail(&masklay_new->splines, spline_new);
228   }
229
230   /* correct animation */
231   if (masklay->splines_shapes.first) {
232     MaskLayerShape *masklay_shape;
233     MaskLayerShape *masklay_shape_new;
234
235     for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
236          masklay_shape = masklay_shape->next) {
237       masklay_shape_new = MEM_callocN(sizeof(MaskLayerShape), "new mask layer shape");
238
239       masklay_shape_new->data = MEM_dupallocN(masklay_shape->data);
240       masklay_shape_new->tot_vert = masklay_shape->tot_vert;
241       masklay_shape_new->flag = masklay_shape->flag;
242       masklay_shape_new->frame = masklay_shape->frame;
243
244       BLI_addtail(&masklay_new->splines_shapes, masklay_shape_new);
245     }
246   }
247
248   return masklay_new;
249 }
250
251 void BKE_mask_layer_copy_list(ListBase *masklayers_new, const ListBase *masklayers)
252 {
253   MaskLayer *layer;
254
255   for (layer = masklayers->first; layer; layer = layer->next) {
256     MaskLayer *layer_new = BKE_mask_layer_copy(layer);
257
258     BLI_addtail(masklayers_new, layer_new);
259   }
260 }
261
262 /* splines */
263
264 MaskSpline *BKE_mask_spline_add(MaskLayer *masklay)
265 {
266   MaskSpline *spline;
267
268   spline = MEM_callocN(sizeof(MaskSpline), "new mask spline");
269   BLI_addtail(&masklay->splines, spline);
270
271   /* spline shall have one point at least */
272   spline->points = MEM_callocN(sizeof(MaskSplinePoint), "new mask spline point");
273   spline->tot_point = 1;
274
275   /* cyclic shapes are more usually used */
276   // spline->flag |= MASK_SPLINE_CYCLIC; // disable because its not so nice for drawing. could be done differently
277
278   spline->weight_interp = MASK_SPLINE_INTERP_EASE;
279
280   BKE_mask_parent_init(&spline->parent);
281
282   return spline;
283 }
284
285 bool BKE_mask_spline_remove(MaskLayer *mask_layer, MaskSpline *spline)
286 {
287   if (BLI_remlink_safe(&mask_layer->splines, spline) == false) {
288     return false;
289   }
290
291   BKE_mask_spline_free(spline);
292
293   return true;
294 }
295
296 void BKE_mask_point_direction_switch(MaskSplinePoint *point)
297 {
298   const int tot_uw = point->tot_uw;
299   const int tot_uw_half = tot_uw / 2;
300   int i;
301
302   float co_tmp[2];
303
304   /* swap handles */
305   copy_v2_v2(co_tmp, point->bezt.vec[0]);
306   copy_v2_v2(point->bezt.vec[0], point->bezt.vec[2]);
307   copy_v2_v2(point->bezt.vec[2], co_tmp);
308   /* in this case the flags are unlikely to be different but swap anyway */
309   SWAP(char, point->bezt.f1, point->bezt.f3);
310   SWAP(char, point->bezt.h1, point->bezt.h2);
311
312   /* swap UW's */
313   if (tot_uw > 1) {
314     /* count */
315     for (i = 0; i < tot_uw_half; i++) {
316       MaskSplinePointUW *uw_a = &point->uw[i];
317       MaskSplinePointUW *uw_b = &point->uw[tot_uw - (i + 1)];
318       SWAP(MaskSplinePointUW, *uw_a, *uw_b);
319     }
320   }
321
322   for (i = 0; i < tot_uw; i++) {
323     MaskSplinePointUW *uw = &point->uw[i];
324     uw->u = 1.0f - uw->u;
325   }
326 }
327
328 void BKE_mask_spline_direction_switch(MaskLayer *masklay, MaskSpline *spline)
329 {
330   const int tot_point = spline->tot_point;
331   const int tot_point_half = tot_point / 2;
332   int i, i_prev;
333
334   if (tot_point < 2) {
335     return;
336   }
337
338   /* count */
339   for (i = 0; i < tot_point_half; i++) {
340     MaskSplinePoint *point_a = &spline->points[i];
341     MaskSplinePoint *point_b = &spline->points[tot_point - (i + 1)];
342     SWAP(MaskSplinePoint, *point_a, *point_b);
343   }
344
345   /* correct UW's */
346   i_prev = tot_point - 1;
347   for (i = 0; i < tot_point; i++) {
348
349     BKE_mask_point_direction_switch(&spline->points[i]);
350
351     SWAP(MaskSplinePointUW *, spline->points[i].uw, spline->points[i_prev].uw);
352     SWAP(int, spline->points[i].tot_uw, spline->points[i_prev].tot_uw);
353
354     i_prev = i;
355   }
356
357   /* correct animation */
358   if (masklay->splines_shapes.first) {
359     MaskLayerShape *masklay_shape;
360
361     const int spline_index = BKE_mask_layer_shape_spline_to_index(masklay, spline);
362
363     for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
364          masklay_shape = masklay_shape->next) {
365       MaskLayerShapeElem *fp_arr = (MaskLayerShapeElem *)masklay_shape->data;
366
367       for (i = 0; i < tot_point_half; i++) {
368         MaskLayerShapeElem *fp_a = &fp_arr[spline_index + (i)];
369         MaskLayerShapeElem *fp_b = &fp_arr[spline_index + (tot_point - (i + 1))];
370         SWAP(MaskLayerShapeElem, *fp_a, *fp_b);
371       }
372     }
373   }
374 }
375
376 float BKE_mask_spline_project_co(MaskSpline *spline,
377                                  MaskSplinePoint *point,
378                                  float start_u,
379                                  const float co[2],
380                                  const eMaskSign sign)
381 {
382   const float proj_eps = 1e-3;
383   const float proj_eps_sq = proj_eps * proj_eps;
384   const int N = 1000;
385   float u = -1.0f, du = 1.0f / N, u1 = start_u, u2 = start_u;
386   float ang = -1.0f;
387
388   BLI_assert(ABS(sign) <= 1); /* (-1, 0, 1) */
389
390   while (u1 > 0.0f || u2 < 1.0f) {
391     float n1[2], n2[2], co1[2], co2[2];
392     float v1[2], v2[2];
393     float ang1, ang2;
394
395     if (u1 >= 0.0f) {
396       BKE_mask_point_segment_co(spline, point, u1, co1);
397       BKE_mask_point_normal(spline, point, u1, n1);
398       sub_v2_v2v2(v1, co, co1);
399
400       if ((sign == MASK_PROJ_ANY) || ((sign == MASK_PROJ_NEG) && (dot_v2v2(v1, n1) <= 0.0f)) ||
401           ((sign == MASK_PROJ_POS) && (dot_v2v2(v1, n1) >= 0.0f))) {
402
403         if (len_squared_v2(v1) > proj_eps_sq) {
404           ang1 = angle_v2v2(v1, n1);
405           if (ang1 > (float)M_PI / 2.0f) {
406             ang1 = (float)M_PI - ang1;
407           }
408
409           if (ang < 0.0f || ang1 < ang) {
410             ang = ang1;
411             u = u1;
412           }
413         }
414         else {
415           u = u1;
416           break;
417         }
418       }
419     }
420
421     if (u2 <= 1.0f) {
422       BKE_mask_point_segment_co(spline, point, u2, co2);
423       BKE_mask_point_normal(spline, point, u2, n2);
424       sub_v2_v2v2(v2, co, co2);
425
426       if ((sign == MASK_PROJ_ANY) || ((sign == MASK_PROJ_NEG) && (dot_v2v2(v2, n2) <= 0.0f)) ||
427           ((sign == MASK_PROJ_POS) && (dot_v2v2(v2, n2) >= 0.0f))) {
428
429         if (len_squared_v2(v2) > proj_eps_sq) {
430           ang2 = angle_v2v2(v2, n2);
431           if (ang2 > (float)M_PI / 2.0f) {
432             ang2 = (float)M_PI - ang2;
433           }
434
435           if (ang2 < ang) {
436             ang = ang2;
437             u = u2;
438           }
439         }
440         else {
441           u = u2;
442           break;
443         }
444       }
445     }
446
447     u1 -= du;
448     u2 += du;
449   }
450
451   return u;
452 }
453
454 /* point */
455
456 eMaskhandleMode BKE_mask_point_handles_mode_get(MaskSplinePoint *point)
457 {
458   BezTriple *bezt = &point->bezt;
459
460   if (bezt->h1 == bezt->h2 && bezt->h1 == HD_ALIGN) {
461     return MASK_HANDLE_MODE_STICK;
462   }
463
464   return MASK_HANDLE_MODE_INDIVIDUAL_HANDLES;
465 }
466
467 void BKE_mask_point_handle(MaskSplinePoint *point, eMaskWhichHandle which_handle, float handle[2])
468 {
469   BezTriple *bezt = &point->bezt;
470
471   if (which_handle == MASK_WHICH_HANDLE_STICK) {
472     float vec[2];
473
474     sub_v2_v2v2(vec, bezt->vec[0], bezt->vec[1]);
475
476     handle[0] = (bezt->vec[1][0] + vec[1]);
477     handle[1] = (bezt->vec[1][1] - vec[0]);
478   }
479   else if (which_handle == MASK_WHICH_HANDLE_LEFT) {
480     copy_v2_v2(handle, bezt->vec[0]);
481   }
482   else if (which_handle == MASK_WHICH_HANDLE_RIGHT) {
483     copy_v2_v2(handle, bezt->vec[2]);
484   }
485   else {
486     BLI_assert(!"Unknown handle passed to BKE_mask_point_handle");
487   }
488 }
489
490 void BKE_mask_point_set_handle(MaskSplinePoint *point,
491                                eMaskWhichHandle which_handle,
492                                float loc[2],
493                                bool keep_direction,
494                                float orig_handle[2],
495                                float orig_vec[3][3])
496 {
497   BezTriple *bezt = &point->bezt;
498
499   if (which_handle == MASK_WHICH_HANDLE_STICK) {
500     float v1[2], v2[2], vec[2];
501     if (keep_direction) {
502       sub_v2_v2v2(v1, loc, orig_vec[1]);
503       sub_v2_v2v2(v2, orig_handle, orig_vec[1]);
504
505       project_v2_v2v2(vec, v1, v2);
506
507       if (dot_v2v2(v2, vec) > 0) {
508         float len = len_v2(vec);
509
510         sub_v2_v2v2(v1, orig_vec[0], orig_vec[1]);
511
512         mul_v2_fl(v1, len / len_v2(v1));
513
514         add_v2_v2v2(bezt->vec[0], bezt->vec[1], v1);
515         sub_v2_v2v2(bezt->vec[2], bezt->vec[1], v1);
516       }
517       else {
518         copy_v3_v3(bezt->vec[0], bezt->vec[1]);
519         copy_v3_v3(bezt->vec[2], bezt->vec[1]);
520       }
521     }
522     else {
523       sub_v2_v2v2(v1, loc, bezt->vec[1]);
524
525       v2[0] = -v1[1];
526       v2[1] = v1[0];
527
528       add_v2_v2v2(bezt->vec[0], bezt->vec[1], v2);
529       sub_v2_v2v2(bezt->vec[2], bezt->vec[1], v2);
530     }
531   }
532   else if (which_handle == MASK_WHICH_HANDLE_LEFT) {
533     copy_v2_v2(bezt->vec[0], loc);
534   }
535   else if (which_handle == MASK_WHICH_HANDLE_RIGHT) {
536     copy_v2_v2(bezt->vec[2], loc);
537   }
538   else {
539     BLI_assert(!"unknown handle passed to BKE_mask_point_set_handle");
540   }
541 }
542
543 void BKE_mask_point_segment_co(MaskSpline *spline, MaskSplinePoint *point, float u, float co[2])
544 {
545   MaskSplinePoint *points_array = BKE_mask_spline_point_array_from_point(spline, point);
546
547   BezTriple *bezt = &point->bezt, *bezt_next;
548
549   bezt_next = BKE_mask_spline_point_next_bezt(spline, points_array, point);
550
551   if (!bezt_next) {
552     copy_v2_v2(co, bezt->vec[1]);
553     return;
554   }
555
556   interp_v2_v2v2v2v2_cubic(
557       co, bezt->vec[1], bezt->vec[2], bezt_next->vec[0], bezt_next->vec[1], u);
558 }
559
560 BLI_INLINE void orthogonal_direction_get(float vec[2], float result[2])
561 {
562   result[0] = -vec[1];
563   result[1] = vec[0];
564   normalize_v2(result);
565 }
566
567 /* TODO(sergey): This function will re-calculate loads of stuff again and again
568  *               when differentiating feather points. This might be easily cached
569  *               in the callee function for this case.
570  */
571 void BKE_mask_point_normal(MaskSpline *spline, MaskSplinePoint *point, float u, float n[2])
572 {
573
574   MaskSplinePoint *point_prev, *point_next;
575
576   /* TODO(sergey): This actually depends on a resolution. */
577   const float du = 0.05f;
578
579   BKE_mask_get_handle_point_adjacent(spline, point, &point_prev, &point_next);
580
581   if (u - du < 0.0f && point_prev == NULL) {
582     float co[2], dir[2];
583     BKE_mask_point_segment_co(spline, point, u + du, co);
584     sub_v2_v2v2(dir, co, point->bezt.vec[1]);
585     orthogonal_direction_get(dir, n);
586   }
587   else if (u + du > 1.0f && point_next == NULL) {
588     float co[2], dir[2];
589     BKE_mask_point_segment_co(spline, point, u - du, co);
590     sub_v2_v2v2(dir, point->bezt.vec[1], co);
591     orthogonal_direction_get(dir, n);
592   }
593   else {
594     float prev_co[2], next_co[2], co[2];
595     float dir1[2], dir2[2], dir[2];
596
597     if (u - du < 0.0f) {
598       BKE_mask_point_segment_co(spline, point_prev, 1.0f + (u - du), prev_co);
599     }
600     else {
601       BKE_mask_point_segment_co(spline, point, u - du, prev_co);
602     }
603
604     BKE_mask_point_segment_co(spline, point, u, co);
605
606     if (u + du > 1.0f) {
607       BKE_mask_point_segment_co(spline, point_next, u + du - 1.0f, next_co);
608     }
609     else {
610       BKE_mask_point_segment_co(spline, point, u + du, next_co);
611     }
612
613     sub_v2_v2v2(dir1, co, prev_co);
614     sub_v2_v2v2(dir2, next_co, co);
615
616     normalize_v2(dir1);
617     normalize_v2(dir2);
618     add_v2_v2v2(dir, dir1, dir2);
619
620     orthogonal_direction_get(dir, n);
621   }
622 }
623
624 static float mask_point_interp_weight(BezTriple *bezt, BezTriple *bezt_next, const float u)
625 {
626   return (bezt->weight * (1.0f - u)) + (bezt_next->weight * u);
627 }
628
629 float BKE_mask_point_weight_scalar(MaskSpline *spline, MaskSplinePoint *point, const float u)
630 {
631   MaskSplinePoint *points_array = BKE_mask_spline_point_array_from_point(spline, point);
632   BezTriple *bezt = &point->bezt, *bezt_next;
633
634   bezt_next = BKE_mask_spline_point_next_bezt(spline, points_array, point);
635
636   if (!bezt_next) {
637     return bezt->weight;
638   }
639   else if (u <= 0.0f) {
640     return bezt->weight;
641   }
642   else if (u >= 1.0f) {
643     return bezt_next->weight;
644   }
645   else {
646     return mask_point_interp_weight(bezt, bezt_next, u);
647   }
648 }
649
650 float BKE_mask_point_weight(MaskSpline *spline, MaskSplinePoint *point, const float u)
651 {
652   MaskSplinePoint *points_array = BKE_mask_spline_point_array_from_point(spline, point);
653   BezTriple *bezt = &point->bezt, *bezt_next;
654
655   bezt_next = BKE_mask_spline_point_next_bezt(spline, points_array, point);
656
657   if (!bezt_next) {
658     return bezt->weight;
659   }
660   else if (u <= 0.0f) {
661     return bezt->weight;
662   }
663   else if (u >= 1.0f) {
664     return bezt_next->weight;
665   }
666   else {
667     float cur_u = 0.0f, cur_w = 0.0f, next_u = 0.0f, next_w = 0.0f, fac; /* Quite warnings */
668     int i;
669
670     for (i = 0; i <= point->tot_uw; i++) {
671
672       if (i == 0) {
673         cur_u = 0.0f;
674         cur_w = 1.0f; /* mask_point_interp_weight will scale it */
675       }
676       else {
677         cur_u = point->uw[i - 1].u;
678         cur_w = point->uw[i - 1].w;
679       }
680
681       if (i == point->tot_uw) {
682         next_u = 1.0f;
683         next_w = 1.0f; /* mask_point_interp_weight will scale it */
684       }
685       else {
686         next_u = point->uw[i].u;
687         next_w = point->uw[i].w;
688       }
689
690       if (u >= cur_u && u <= next_u) {
691         break;
692       }
693     }
694
695     fac = (u - cur_u) / (next_u - cur_u);
696
697     cur_w *= mask_point_interp_weight(bezt, bezt_next, cur_u);
698     next_w *= mask_point_interp_weight(bezt, bezt_next, next_u);
699
700     if (spline->weight_interp == MASK_SPLINE_INTERP_EASE) {
701       return cur_w + (next_w - cur_w) * (3.0f * fac * fac - 2.0f * fac * fac * fac);
702     }
703     else {
704       return (1.0f - fac) * cur_w + fac * next_w;
705     }
706   }
707 }
708
709 MaskSplinePointUW *BKE_mask_point_sort_uw(MaskSplinePoint *point, MaskSplinePointUW *uw)
710 {
711   if (point->tot_uw > 1) {
712     int idx = uw - point->uw;
713
714     if (idx > 0 && point->uw[idx - 1].u > uw->u) {
715       while (idx > 0 && point->uw[idx - 1].u > point->uw[idx].u) {
716         SWAP(MaskSplinePointUW, point->uw[idx - 1], point->uw[idx]);
717         idx--;
718       }
719     }
720
721     if (idx < point->tot_uw - 1 && point->uw[idx + 1].u < uw->u) {
722       while (idx < point->tot_uw - 1 && point->uw[idx + 1].u < point->uw[idx].u) {
723         SWAP(MaskSplinePointUW, point->uw[idx + 1], point->uw[idx]);
724         idx++;
725       }
726     }
727
728     return &point->uw[idx];
729   }
730
731   return uw;
732 }
733
734 void BKE_mask_point_add_uw(MaskSplinePoint *point, float u, float w)
735 {
736   if (!point->uw) {
737     point->uw = MEM_mallocN(sizeof(*point->uw), "mask point uw");
738   }
739   else {
740     point->uw = MEM_reallocN(point->uw, (point->tot_uw + 1) * sizeof(*point->uw));
741   }
742
743   point->uw[point->tot_uw].u = u;
744   point->uw[point->tot_uw].w = w;
745   point->uw[point->tot_uw].flag = 0;
746
747   point->tot_uw++;
748
749   BKE_mask_point_sort_uw(point, &point->uw[point->tot_uw - 1]);
750 }
751
752 void BKE_mask_point_select_set(MaskSplinePoint *point, const bool do_select)
753 {
754   int i;
755
756   if (do_select) {
757     MASKPOINT_SEL_ALL(point);
758   }
759   else {
760     MASKPOINT_DESEL_ALL(point);
761   }
762
763   for (i = 0; i < point->tot_uw; i++) {
764     if (do_select) {
765       point->uw[i].flag |= SELECT;
766     }
767     else {
768       point->uw[i].flag &= ~SELECT;
769     }
770   }
771 }
772
773 void BKE_mask_point_select_set_handle(MaskSplinePoint *point,
774                                       const eMaskWhichHandle which_handle,
775                                       const bool do_select)
776 {
777   if (do_select) {
778     if (ELEM(which_handle, MASK_WHICH_HANDLE_STICK, MASK_WHICH_HANDLE_BOTH)) {
779       point->bezt.f1 |= SELECT;
780       point->bezt.f3 |= SELECT;
781     }
782     else if (which_handle == MASK_WHICH_HANDLE_LEFT) {
783       point->bezt.f1 |= SELECT;
784     }
785     else if (which_handle == MASK_WHICH_HANDLE_RIGHT) {
786       point->bezt.f3 |= SELECT;
787     }
788     else {
789       BLI_assert(!"Wrong which_handle passed to BKE_mask_point_select_set_handle");
790     }
791   }
792   else {
793     if (ELEM(which_handle, MASK_WHICH_HANDLE_STICK, MASK_WHICH_HANDLE_BOTH)) {
794       point->bezt.f1 &= ~SELECT;
795       point->bezt.f3 &= ~SELECT;
796     }
797     else if (which_handle == MASK_WHICH_HANDLE_LEFT) {
798       point->bezt.f1 &= ~SELECT;
799     }
800     else if (which_handle == MASK_WHICH_HANDLE_RIGHT) {
801       point->bezt.f3 &= ~SELECT;
802     }
803     else {
804       BLI_assert(!"Wrong which_handle passed to BKE_mask_point_select_set_handle");
805     }
806   }
807 }
808
809 /* only mask block itself */
810 static Mask *mask_alloc(Main *bmain, const char *name)
811 {
812   Mask *mask;
813
814   mask = BKE_libblock_alloc(bmain, ID_MSK, name, 0);
815
816   id_fake_user_set(&mask->id);
817
818   return mask;
819 }
820
821 Mask *BKE_mask_new(Main *bmain, const char *name)
822 {
823   Mask *mask;
824   char mask_name[MAX_ID_NAME - 2];
825
826   if (name && name[0]) {
827     BLI_strncpy(mask_name, name, sizeof(mask_name));
828   }
829   else {
830     strcpy(mask_name, "Mask");
831   }
832
833   mask = mask_alloc(bmain, mask_name);
834
835   /* arbitrary defaults */
836   mask->sfra = 1;
837   mask->efra = 100;
838
839   DEG_relations_tag_update(bmain);
840
841   return mask;
842 }
843
844 /* TODO(sergey): Use generic BKE_libblock_copy_nolib() instead. */
845 /* TODO(bastien): Use new super cool & generic BKE_id_copy_ex() instead! */
846 Mask *BKE_mask_copy_nolib(Mask *mask)
847 {
848   Mask *mask_new;
849
850   mask_new = MEM_dupallocN(mask);
851
852   /*take care here! - we may want to copy anim data  */
853   mask_new->adt = NULL;
854
855   BLI_listbase_clear(&mask_new->masklayers);
856
857   BKE_mask_layer_copy_list(&mask_new->masklayers, &mask->masklayers);
858
859   /* enable fake user by default */
860   id_fake_user_set(&mask->id);
861
862   return mask_new;
863 }
864
865 /**
866  * Only copy internal data of Mask ID from source to already allocated/initialized destination.
867  * You probably never want to use that directly, use BKE_id_copy or BKE_id_copy_ex for typical needs.
868  *
869  * WARNING! This function will not handle ID user count!
870  *
871  * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
872  */
873 void BKE_mask_copy_data(Main *UNUSED(bmain),
874                         Mask *mask_dst,
875                         const Mask *mask_src,
876                         const int UNUSED(flag))
877 {
878   BLI_listbase_clear(&mask_dst->masklayers);
879
880   BKE_mask_layer_copy_list(&mask_dst->masklayers,
881                            &mask_src->masklayers); /* TODO add unused flag to those as well. */
882
883   /* enable fake user by default */
884   id_fake_user_set(&mask_dst->id);
885 }
886
887 Mask *BKE_mask_copy(Main *bmain, const Mask *mask)
888 {
889   Mask *mask_copy;
890   BKE_id_copy(bmain, &mask->id, (ID **)&mask_copy);
891   return mask_copy;
892 }
893
894 void BKE_mask_make_local(Main *bmain, Mask *mask, const bool lib_local)
895 {
896   BKE_id_make_local_generic(bmain, &mask->id, true, lib_local);
897 }
898
899 void BKE_mask_point_free(MaskSplinePoint *point)
900 {
901   if (point->uw) {
902     MEM_freeN(point->uw);
903   }
904 }
905
906 void BKE_mask_spline_free(MaskSpline *spline)
907 {
908   int i = 0;
909
910   for (i = 0; i < spline->tot_point; i++) {
911     MaskSplinePoint *point;
912     point = &spline->points[i];
913     BKE_mask_point_free(point);
914
915     if (spline->points_deform) {
916       point = &spline->points_deform[i];
917       BKE_mask_point_free(point);
918     }
919   }
920
921   MEM_freeN(spline->points);
922
923   if (spline->points_deform) {
924     MEM_freeN(spline->points_deform);
925   }
926
927   MEM_freeN(spline);
928 }
929
930 void BKE_mask_spline_free_list(ListBase *splines)
931 {
932   MaskSpline *spline = splines->first;
933   while (spline) {
934     MaskSpline *next_spline = spline->next;
935
936     BLI_remlink(splines, spline);
937     BKE_mask_spline_free(spline);
938
939     spline = next_spline;
940   }
941 }
942
943 static MaskSplinePoint *mask_spline_points_copy(const MaskSplinePoint *points, int tot_point)
944 {
945   MaskSplinePoint *npoints;
946   int i;
947
948   npoints = MEM_dupallocN(points);
949
950   for (i = 0; i < tot_point; i++) {
951     MaskSplinePoint *point = &npoints[i];
952
953     if (point->uw) {
954       point->uw = MEM_dupallocN(point->uw);
955     }
956   }
957
958   return npoints;
959 }
960
961 MaskSpline *BKE_mask_spline_copy(const MaskSpline *spline)
962 {
963   MaskSpline *nspline = MEM_callocN(sizeof(MaskSpline), "new spline");
964
965   *nspline = *spline;
966
967   nspline->points_deform = NULL;
968   nspline->points = mask_spline_points_copy(spline->points, spline->tot_point);
969
970   if (spline->points_deform) {
971     nspline->points_deform = mask_spline_points_copy(spline->points_deform, spline->tot_point);
972   }
973
974   return nspline;
975 }
976
977 /* note: does NOT add to the list */
978 MaskLayerShape *BKE_mask_layer_shape_alloc(MaskLayer *masklay, const int frame)
979 {
980   MaskLayerShape *masklay_shape;
981   int tot_vert = BKE_mask_layer_shape_totvert(masklay);
982
983   masklay_shape = MEM_mallocN(sizeof(MaskLayerShape), __func__);
984   masklay_shape->frame = frame;
985   masklay_shape->tot_vert = tot_vert;
986   masklay_shape->data = MEM_mallocN(tot_vert * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE,
987                                     __func__);
988
989   return masklay_shape;
990 }
991
992 void BKE_mask_layer_shape_free(MaskLayerShape *masklay_shape)
993 {
994   if (masklay_shape->data) {
995     MEM_freeN(masklay_shape->data);
996   }
997
998   MEM_freeN(masklay_shape);
999 }
1000
1001 /** \brief Free all animation keys for a mask layer
1002  */
1003 void BKE_mask_layer_free_shapes(MaskLayer *masklay)
1004 {
1005   MaskLayerShape *masklay_shape;
1006
1007   /* free animation data */
1008   masklay_shape = masklay->splines_shapes.first;
1009   while (masklay_shape) {
1010     MaskLayerShape *next_masklay_shape = masklay_shape->next;
1011
1012     BLI_remlink(&masklay->splines_shapes, masklay_shape);
1013     BKE_mask_layer_shape_free(masklay_shape);
1014
1015     masklay_shape = next_masklay_shape;
1016   }
1017 }
1018
1019 void BKE_mask_layer_free(MaskLayer *masklay)
1020 {
1021   /* free splines */
1022   BKE_mask_spline_free_list(&masklay->splines);
1023
1024   /* free animation data */
1025   BKE_mask_layer_free_shapes(masklay);
1026
1027   MEM_freeN(masklay);
1028 }
1029
1030 void BKE_mask_layer_free_list(ListBase *masklayers)
1031 {
1032   MaskLayer *masklay = masklayers->first;
1033
1034   while (masklay) {
1035     MaskLayer *masklay_next = masklay->next;
1036
1037     BLI_remlink(masklayers, masklay);
1038     BKE_mask_layer_free(masklay);
1039
1040     masklay = masklay_next;
1041   }
1042 }
1043
1044 /** Free (or release) any data used by this mask (does not free the mask itself). */
1045 void BKE_mask_free(Mask *mask)
1046 {
1047   BKE_animdata_free((ID *)mask, false);
1048
1049   /* free mask data */
1050   BKE_mask_layer_free_list(&mask->masklayers);
1051 }
1052
1053 void BKE_mask_coord_from_frame(float r_co[2], const float co[2], const float frame_size[2])
1054 {
1055   if (frame_size[0] == frame_size[1]) {
1056     r_co[0] = co[0];
1057     r_co[1] = co[1];
1058   }
1059   else if (frame_size[0] < frame_size[1]) {
1060     r_co[0] = ((co[0] - 0.5f) * (frame_size[0] / frame_size[1])) + 0.5f;
1061     r_co[1] = co[1];
1062   }
1063   else { /* (frame_size[0] > frame_size[1]) */
1064     r_co[0] = co[0];
1065     r_co[1] = ((co[1] - 0.5f) * (frame_size[1] / frame_size[0])) + 0.5f;
1066   }
1067 }
1068
1069 void BKE_mask_coord_from_movieclip(MovieClip *clip,
1070                                    MovieClipUser *user,
1071                                    float r_co[2],
1072                                    const float co[2])
1073 {
1074   float aspx, aspy;
1075   float frame_size[2];
1076
1077   /* scaling for the clip */
1078   BKE_movieclip_get_size_fl(clip, user, frame_size);
1079   BKE_movieclip_get_aspect(clip, &aspx, &aspy);
1080
1081   frame_size[1] *= (aspy / aspx);
1082
1083   BKE_mask_coord_from_frame(r_co, co, frame_size);
1084 }
1085
1086 void BKE_mask_coord_from_image(Image *image, ImageUser *iuser, float r_co[2], const float co[2])
1087 {
1088   float aspx, aspy;
1089   float frame_size[2];
1090
1091   BKE_image_get_size_fl(image, iuser, frame_size);
1092   BKE_image_get_aspect(image, &aspx, &aspy);
1093
1094   frame_size[1] *= (aspy / aspx);
1095
1096   BKE_mask_coord_from_frame(r_co, co, frame_size);
1097 }
1098
1099 /* as above but divide */
1100 void BKE_mask_coord_to_frame(float r_co[2], const float co[2], const float frame_size[2])
1101 {
1102   if (frame_size[0] == frame_size[1]) {
1103     r_co[0] = co[0];
1104     r_co[1] = co[1];
1105   }
1106   else if (frame_size[0] < frame_size[1]) {
1107     r_co[0] = ((co[0] - 0.5f) / (frame_size[0] / frame_size[1])) + 0.5f;
1108     r_co[1] = co[1];
1109   }
1110   else { /* (frame_size[0] > frame_size[1]) */
1111     r_co[0] = co[0];
1112     r_co[1] = ((co[1] - 0.5f) / (frame_size[1] / frame_size[0])) + 0.5f;
1113   }
1114 }
1115
1116 void BKE_mask_coord_to_movieclip(MovieClip *clip,
1117                                  MovieClipUser *user,
1118                                  float r_co[2],
1119                                  const float co[2])
1120 {
1121   float aspx, aspy;
1122   float frame_size[2];
1123
1124   /* scaling for the clip */
1125   BKE_movieclip_get_size_fl(clip, user, frame_size);
1126   BKE_movieclip_get_aspect(clip, &aspx, &aspy);
1127
1128   frame_size[1] *= (aspy / aspx);
1129
1130   BKE_mask_coord_to_frame(r_co, co, frame_size);
1131 }
1132
1133 void BKE_mask_coord_to_image(Image *image, ImageUser *iuser, float r_co[2], const float co[2])
1134 {
1135   float aspx, aspy;
1136   float frame_size[2];
1137
1138   /* scaling for the clip */
1139   BKE_image_get_size_fl(image, iuser, frame_size);
1140   BKE_image_get_aspect(image, &aspx, &aspy);
1141
1142   frame_size[1] *= (aspy / aspx);
1143
1144   BKE_mask_coord_to_frame(r_co, co, frame_size);
1145 }
1146
1147 void BKE_mask_point_parent_matrix_get(MaskSplinePoint *point,
1148                                       float ctime,
1149                                       float parent_matrix[3][3])
1150 {
1151   MaskParent *parent = &point->parent;
1152
1153   unit_m3(parent_matrix);
1154
1155   if (!parent) {
1156     return;
1157   }
1158
1159   if (parent->id_type == ID_MC) {
1160     if (parent->id) {
1161       MovieClip *clip = (MovieClip *)parent->id;
1162       MovieTracking *tracking = (MovieTracking *)&clip->tracking;
1163       MovieTrackingObject *ob = BKE_tracking_object_get_named(tracking, parent->parent);
1164
1165       if (ob) {
1166         MovieClipUser user = {0};
1167         float clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, ctime);
1168         BKE_movieclip_user_set_frame(&user, ctime);
1169
1170         if (parent->type == MASK_PARENT_POINT_TRACK) {
1171           MovieTrackingTrack *track = BKE_tracking_track_get_named(
1172               tracking, ob, parent->sub_parent);
1173
1174           if (track) {
1175             float marker_position[2], parent_co[2];
1176             BKE_tracking_marker_get_subframe_position(track, clip_framenr, marker_position);
1177             BKE_mask_coord_from_movieclip(clip, &user, parent_co, marker_position);
1178             sub_v2_v2v2(parent_matrix[2], parent_co, parent->parent_orig);
1179           }
1180         }
1181         else /* if (parent->type == MASK_PARENT_PLANE_TRACK) */ {
1182           MovieTrackingPlaneTrack *plane_track = BKE_tracking_plane_track_get_named(
1183               tracking, ob, parent->sub_parent);
1184
1185           if (plane_track) {
1186             float corners[4][2];
1187             float aspx, aspy;
1188             float frame_size[2], H[3][3], mask_from_clip_matrix[3][3], mask_to_clip_matrix[3][3];
1189
1190             BKE_tracking_plane_marker_get_subframe_corners(plane_track, ctime, corners);
1191             BKE_tracking_homography_between_two_quads(parent->parent_corners_orig, corners, H);
1192
1193             unit_m3(mask_from_clip_matrix);
1194
1195             BKE_movieclip_get_size_fl(clip, &user, frame_size);
1196             BKE_movieclip_get_aspect(clip, &aspx, &aspy);
1197
1198             frame_size[1] *= (aspy / aspx);
1199             if (frame_size[0] == frame_size[1]) {
1200               /* pass */
1201             }
1202             else if (frame_size[0] < frame_size[1]) {
1203               mask_from_clip_matrix[0][0] = frame_size[1] / frame_size[0];
1204               mask_from_clip_matrix[2][0] = -0.5f * (frame_size[1] / frame_size[0]) + 0.5f;
1205             }
1206             else { /* (frame_size[0] > frame_size[1]) */
1207               mask_from_clip_matrix[1][1] = frame_size[1] / frame_size[0];
1208               mask_from_clip_matrix[2][1] = -0.5f * (frame_size[1] / frame_size[0]) + 0.5f;
1209             }
1210
1211             invert_m3_m3(mask_to_clip_matrix, mask_from_clip_matrix);
1212             mul_m3_series(parent_matrix, mask_from_clip_matrix, H, mask_to_clip_matrix);
1213           }
1214         }
1215       }
1216     }
1217   }
1218 }
1219
1220 static void mask_calc_point_handle(MaskSplinePoint *point,
1221                                    MaskSplinePoint *point_prev,
1222                                    MaskSplinePoint *point_next)
1223 {
1224   BezTriple *bezt = &point->bezt;
1225   BezTriple *bezt_prev = NULL, *bezt_next = NULL;
1226   //int handle_type = bezt->h1;
1227
1228   if (point_prev) {
1229     bezt_prev = &point_prev->bezt;
1230   }
1231
1232   if (point_next) {
1233     bezt_next = &point_next->bezt;
1234   }
1235
1236 #if 1
1237   if (bezt_prev || bezt_next) {
1238     BKE_nurb_handle_calc(bezt, bezt_prev, bezt_next, 0, 0);
1239   }
1240 #else
1241   if (handle_type == HD_VECT) {
1242     BKE_nurb_handle_calc(bezt, bezt_prev, bezt_next, 0, 0);
1243   }
1244   else if (handle_type == HD_AUTO) {
1245     BKE_nurb_handle_calc(bezt, bezt_prev, bezt_next, 0, 0);
1246   }
1247   else if (handle_type == HD_ALIGN || handle_type == HD_ALIGN_DOUBLESIDE) {
1248     float v1[3], v2[3];
1249     float vec[3], h[3];
1250
1251     sub_v3_v3v3(v1, bezt->vec[0], bezt->vec[1]);
1252     sub_v3_v3v3(v2, bezt->vec[2], bezt->vec[1]);
1253     add_v3_v3v3(vec, v1, v2);
1254
1255     if (len_squared_v3(vec) > (1e-3f * 1e-3f)) {
1256       h[0] = vec[1];
1257       h[1] = -vec[0];
1258       h[2] = 0.0f;
1259     }
1260     else {
1261       copy_v3_v3(h, v1);
1262     }
1263
1264     add_v3_v3v3(bezt->vec[0], bezt->vec[1], h);
1265     sub_v3_v3v3(bezt->vec[2], bezt->vec[1], h);
1266   }
1267 #endif
1268 }
1269
1270 void BKE_mask_get_handle_point_adjacent(MaskSpline *spline,
1271                                         MaskSplinePoint *point,
1272                                         MaskSplinePoint **r_point_prev,
1273                                         MaskSplinePoint **r_point_next)
1274 {
1275   /* TODO, could avoid calling this at such low level */
1276   MaskSplinePoint *points_array = BKE_mask_spline_point_array_from_point(spline, point);
1277
1278   *r_point_prev = mask_spline_point_prev(spline, points_array, point);
1279   *r_point_next = mask_spline_point_next(spline, points_array, point);
1280 }
1281
1282 /* calculates the tangent of a point by its previous and next
1283  * (ignoring handles - as if its a poly line) */
1284 void BKE_mask_calc_tangent_polyline(MaskSpline *spline, MaskSplinePoint *point, float t[2])
1285 {
1286   float tvec_a[2], tvec_b[2];
1287
1288   MaskSplinePoint *point_prev, *point_next;
1289
1290   BKE_mask_get_handle_point_adjacent(spline, point, &point_prev, &point_next);
1291
1292   if (point_prev) {
1293     sub_v2_v2v2(tvec_a, point->bezt.vec[1], point_prev->bezt.vec[1]);
1294     normalize_v2(tvec_a);
1295   }
1296   else {
1297     zero_v2(tvec_a);
1298   }
1299
1300   if (point_next) {
1301     sub_v2_v2v2(tvec_b, point_next->bezt.vec[1], point->bezt.vec[1]);
1302     normalize_v2(tvec_b);
1303   }
1304   else {
1305     zero_v2(tvec_b);
1306   }
1307
1308   add_v2_v2v2(t, tvec_a, tvec_b);
1309   normalize_v2(t);
1310 }
1311
1312 void BKE_mask_calc_handle_point(MaskSpline *spline, MaskSplinePoint *point)
1313 {
1314   MaskSplinePoint *point_prev, *point_next;
1315
1316   BKE_mask_get_handle_point_adjacent(spline, point, &point_prev, &point_next);
1317
1318   mask_calc_point_handle(point, point_prev, point_next);
1319 }
1320
1321 void BKE_mask_calc_handle_adjacent_interp(MaskSpline *spline,
1322                                           MaskSplinePoint *point,
1323                                           const float u)
1324 {
1325   /* TODO! - make this interpolate between siblings - not always midpoint! */
1326   int length_tot = 0;
1327   float length_average = 0.0f;
1328   float weight_average = 0.0f;
1329
1330   MaskSplinePoint *point_prev, *point_next;
1331
1332   BLI_assert(u >= 0.0f && u <= 1.0f);
1333
1334   BKE_mask_get_handle_point_adjacent(spline, point, &point_prev, &point_next);
1335
1336   if (point_prev && point_next) {
1337     length_average = ((len_v2v2(point_prev->bezt.vec[0], point_prev->bezt.vec[1]) * (1.0f - u)) +
1338                       (len_v2v2(point_next->bezt.vec[2], point_next->bezt.vec[1]) * u));
1339
1340     weight_average = (point_prev->bezt.weight * (1.0f - u) + point_next->bezt.weight * u);
1341     length_tot = 1;
1342   }
1343   else {
1344     if (point_prev) {
1345       length_average += len_v2v2(point_prev->bezt.vec[0], point_prev->bezt.vec[1]);
1346       weight_average += point_prev->bezt.weight;
1347       length_tot++;
1348     }
1349
1350     if (point_next) {
1351       length_average += len_v2v2(point_next->bezt.vec[2], point_next->bezt.vec[1]);
1352       weight_average += point_next->bezt.weight;
1353       length_tot++;
1354     }
1355   }
1356
1357   if (length_tot) {
1358     length_average /= (float)length_tot;
1359     weight_average /= (float)length_tot;
1360
1361     dist_ensure_v2_v2fl(point->bezt.vec[0], point->bezt.vec[1], length_average);
1362     dist_ensure_v2_v2fl(point->bezt.vec[2], point->bezt.vec[1], length_average);
1363     point->bezt.weight = weight_average;
1364   }
1365 }
1366
1367 /**
1368  * \brief Resets auto handles even for non-auto bezier points
1369  *
1370  * Useful for giving sane defaults.
1371  */
1372 void BKE_mask_calc_handle_point_auto(MaskSpline *spline,
1373                                      MaskSplinePoint *point,
1374                                      const bool do_recalc_length)
1375 {
1376   MaskSplinePoint *point_prev, *point_next;
1377   const char h_back[2] = {point->bezt.h1, point->bezt.h2};
1378   const float length_average = (do_recalc_length) ?
1379                                    0.0f /* dummy value */ :
1380                                    (len_v3v3(point->bezt.vec[0], point->bezt.vec[1]) +
1381                                     len_v3v3(point->bezt.vec[1], point->bezt.vec[2])) /
1382                                        2.0f;
1383
1384   BKE_mask_get_handle_point_adjacent(spline, point, &point_prev, &point_next);
1385
1386   point->bezt.h1 = HD_AUTO;
1387   point->bezt.h2 = HD_AUTO;
1388   mask_calc_point_handle(point, point_prev, point_next);
1389
1390   point->bezt.h1 = h_back[0];
1391   point->bezt.h2 = h_back[1];
1392
1393   /* preserve length by applying it back */
1394   if (do_recalc_length == false) {
1395     dist_ensure_v2_v2fl(point->bezt.vec[0], point->bezt.vec[1], length_average);
1396     dist_ensure_v2_v2fl(point->bezt.vec[2], point->bezt.vec[1], length_average);
1397   }
1398 }
1399
1400 void BKE_mask_layer_calc_handles(MaskLayer *masklay)
1401 {
1402   MaskSpline *spline;
1403   for (spline = masklay->splines.first; spline; spline = spline->next) {
1404     int i;
1405     for (i = 0; i < spline->tot_point; i++) {
1406       BKE_mask_calc_handle_point(spline, &spline->points[i]);
1407     }
1408   }
1409 }
1410
1411 void BKE_mask_spline_ensure_deform(MaskSpline *spline)
1412 {
1413   int allocated_points = (MEM_allocN_len(spline->points_deform) / sizeof(*spline->points_deform));
1414   // printf("SPLINE ALLOC %p %d\n", spline->points_deform, allocated_points);
1415
1416   if (spline->points_deform == NULL || allocated_points != spline->tot_point) {
1417     // printf("alloc new deform spline\n");
1418
1419     if (spline->points_deform) {
1420       int i;
1421
1422       for (i = 0; i < allocated_points; i++) {
1423         MaskSplinePoint *point = &spline->points_deform[i];
1424         BKE_mask_point_free(point);
1425       }
1426
1427       MEM_freeN(spline->points_deform);
1428     }
1429
1430     spline->points_deform = MEM_callocN(sizeof(*spline->points_deform) * spline->tot_point,
1431                                         __func__);
1432   }
1433   else {
1434     // printf("alloc spline done\n");
1435   }
1436 }
1437
1438 void BKE_mask_layer_evaluate(MaskLayer *masklay, const float ctime, const bool do_newframe)
1439 {
1440   /* Animation if available. */
1441   if (do_newframe) {
1442     BKE_mask_layer_evaluate_animation(masklay, ctime);
1443   }
1444   /* Update deform. */
1445   BKE_mask_layer_evaluate_deform(masklay, ctime);
1446 }
1447
1448 void BKE_mask_evaluate(Mask *mask, const float ctime, const bool do_newframe)
1449 {
1450   MaskLayer *masklay;
1451
1452   for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
1453     BKE_mask_layer_evaluate(masklay, ctime, do_newframe);
1454   }
1455 }
1456
1457 /* the purpose of this function is to ensure spline->points_deform is never out of date.
1458  * for now re-evaluate all. eventually this might work differently */
1459 void BKE_mask_update_display(Mask *mask, float ctime)
1460 {
1461   BKE_mask_evaluate(mask, ctime, false);
1462 }
1463
1464 void BKE_mask_evaluate_all_masks(Main *bmain, float ctime, const bool do_newframe)
1465 {
1466   Mask *mask;
1467
1468   for (mask = bmain->masks.first; mask; mask = mask->id.next) {
1469     BKE_mask_evaluate(mask, ctime, do_newframe);
1470   }
1471 }
1472
1473 void BKE_mask_parent_init(MaskParent *parent)
1474 {
1475   parent->id_type = ID_MC;
1476 }
1477
1478 /* *** own animation/shapekey implementation ***
1479  * BKE_mask_layer_shape_XXX */
1480
1481 int BKE_mask_layer_shape_totvert(MaskLayer *masklay)
1482 {
1483   int tot = 0;
1484   MaskSpline *spline;
1485
1486   for (spline = masklay->splines.first; spline; spline = spline->next) {
1487     tot += spline->tot_point;
1488   }
1489
1490   return tot;
1491 }
1492
1493 static void mask_layer_shape_from_mask_point(BezTriple *bezt,
1494                                              float fp[MASK_OBJECT_SHAPE_ELEM_SIZE])
1495 {
1496   copy_v2_v2(&fp[0], bezt->vec[0]);
1497   copy_v2_v2(&fp[2], bezt->vec[1]);
1498   copy_v2_v2(&fp[4], bezt->vec[2]);
1499   fp[6] = bezt->weight;
1500   fp[7] = bezt->radius;
1501 }
1502
1503 static void mask_layer_shape_to_mask_point(BezTriple *bezt, float fp[MASK_OBJECT_SHAPE_ELEM_SIZE])
1504 {
1505   copy_v2_v2(bezt->vec[0], &fp[0]);
1506   copy_v2_v2(bezt->vec[1], &fp[2]);
1507   copy_v2_v2(bezt->vec[2], &fp[4]);
1508   bezt->weight = fp[6];
1509   bezt->radius = fp[7];
1510 }
1511
1512 /* these functions match. copy is swapped */
1513 void BKE_mask_layer_shape_from_mask(MaskLayer *masklay, MaskLayerShape *masklay_shape)
1514 {
1515   int tot = BKE_mask_layer_shape_totvert(masklay);
1516
1517   if (masklay_shape->tot_vert == tot) {
1518     float *fp = masklay_shape->data;
1519
1520     MaskSpline *spline;
1521     for (spline = masklay->splines.first; spline; spline = spline->next) {
1522       int i;
1523       for (i = 0; i < spline->tot_point; i++) {
1524         mask_layer_shape_from_mask_point(&spline->points[i].bezt, fp);
1525         fp += MASK_OBJECT_SHAPE_ELEM_SIZE;
1526       }
1527     }
1528   }
1529   else {
1530     CLOG_ERROR(&LOG,
1531                "vert mismatch %d != %d (frame %d)",
1532                masklay_shape->tot_vert,
1533                tot,
1534                masklay_shape->frame);
1535   }
1536 }
1537
1538 void BKE_mask_layer_shape_to_mask(MaskLayer *masklay, MaskLayerShape *masklay_shape)
1539 {
1540   int tot = BKE_mask_layer_shape_totvert(masklay);
1541
1542   if (masklay_shape->tot_vert == tot) {
1543     float *fp = masklay_shape->data;
1544
1545     MaskSpline *spline;
1546     for (spline = masklay->splines.first; spline; spline = spline->next) {
1547       int i;
1548       for (i = 0; i < spline->tot_point; i++) {
1549         mask_layer_shape_to_mask_point(&spline->points[i].bezt, fp);
1550         fp += MASK_OBJECT_SHAPE_ELEM_SIZE;
1551       }
1552     }
1553   }
1554   else {
1555     CLOG_ERROR(&LOG,
1556                "vert mismatch %d != %d (frame %d)",
1557                masklay_shape->tot_vert,
1558                tot,
1559                masklay_shape->frame);
1560   }
1561 }
1562
1563 BLI_INLINE void interp_v2_v2v2_flfl(
1564     float target[2], const float a[2], const float b[2], const float t, const float s)
1565 {
1566   target[0] = s * a[0] + t * b[0];
1567   target[1] = s * a[1] + t * b[1];
1568 }
1569
1570 /* linear interpolation only */
1571 void BKE_mask_layer_shape_to_mask_interp(MaskLayer *masklay,
1572                                          MaskLayerShape *masklay_shape_a,
1573                                          MaskLayerShape *masklay_shape_b,
1574                                          const float fac)
1575 {
1576   int tot = BKE_mask_layer_shape_totvert(masklay);
1577   if (masklay_shape_a->tot_vert == tot && masklay_shape_b->tot_vert == tot) {
1578     const float *fp_a = masklay_shape_a->data;
1579     const float *fp_b = masklay_shape_b->data;
1580     const float ifac = 1.0f - fac;
1581
1582     MaskSpline *spline;
1583     for (spline = masklay->splines.first; spline; spline = spline->next) {
1584       int i;
1585       for (i = 0; i < spline->tot_point; i++) {
1586         BezTriple *bezt = &spline->points[i].bezt;
1587         /* *** BKE_mask_layer_shape_from_mask - swapped *** */
1588         interp_v2_v2v2_flfl(bezt->vec[0], fp_a, fp_b, fac, ifac);
1589         fp_a += 2;
1590         fp_b += 2;
1591         interp_v2_v2v2_flfl(bezt->vec[1], fp_a, fp_b, fac, ifac);
1592         fp_a += 2;
1593         fp_b += 2;
1594         interp_v2_v2v2_flfl(bezt->vec[2], fp_a, fp_b, fac, ifac);
1595         fp_a += 2;
1596         fp_b += 2;
1597         bezt->weight = (fp_a[0] * ifac) + (fp_b[0] * fac);
1598         bezt->radius = (fp_a[1] * ifac) + (fp_b[1] * fac);
1599         fp_a += 2;
1600         fp_b += 2;
1601       }
1602     }
1603   }
1604   else {
1605     CLOG_ERROR(&LOG,
1606                "vert mismatch %d != %d != %d (frame %d - %d)",
1607                masklay_shape_a->tot_vert,
1608                masklay_shape_b->tot_vert,
1609                tot,
1610                masklay_shape_a->frame,
1611                masklay_shape_b->frame);
1612   }
1613 }
1614
1615 MaskLayerShape *BKE_mask_layer_shape_find_frame(MaskLayer *masklay, const int frame)
1616 {
1617   MaskLayerShape *masklay_shape;
1618
1619   for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
1620        masklay_shape = masklay_shape->next) {
1621     if (frame == masklay_shape->frame) {
1622       return masklay_shape;
1623     }
1624     else if (frame < masklay_shape->frame) {
1625       break;
1626     }
1627   }
1628
1629   return NULL;
1630 }
1631
1632 /* when returning 2 - the frame isnt found but before/after frames are */
1633 int BKE_mask_layer_shape_find_frame_range(MaskLayer *masklay,
1634                                           const float frame,
1635                                           MaskLayerShape **r_masklay_shape_a,
1636                                           MaskLayerShape **r_masklay_shape_b)
1637 {
1638   MaskLayerShape *masklay_shape;
1639
1640   for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
1641        masklay_shape = masklay_shape->next) {
1642     if (frame == masklay_shape->frame) {
1643       *r_masklay_shape_a = masklay_shape;
1644       *r_masklay_shape_b = NULL;
1645       return 1;
1646     }
1647     else if (frame < masklay_shape->frame) {
1648       if (masklay_shape->prev) {
1649         *r_masklay_shape_a = masklay_shape->prev;
1650         *r_masklay_shape_b = masklay_shape;
1651         return 2;
1652       }
1653       else {
1654         *r_masklay_shape_a = masklay_shape;
1655         *r_masklay_shape_b = NULL;
1656         return 1;
1657       }
1658     }
1659   }
1660
1661   if ((masklay_shape = masklay->splines_shapes.last)) {
1662     *r_masklay_shape_a = masklay_shape;
1663     *r_masklay_shape_b = NULL;
1664     return 1;
1665   }
1666   else {
1667     *r_masklay_shape_a = NULL;
1668     *r_masklay_shape_b = NULL;
1669
1670     return 0;
1671   }
1672 }
1673
1674 MaskLayerShape *BKE_mask_layer_shape_verify_frame(MaskLayer *masklay, const int frame)
1675 {
1676   MaskLayerShape *masklay_shape;
1677
1678   masklay_shape = BKE_mask_layer_shape_find_frame(masklay, frame);
1679
1680   if (masklay_shape == NULL) {
1681     masklay_shape = BKE_mask_layer_shape_alloc(masklay, frame);
1682     BLI_addtail(&masklay->splines_shapes, masklay_shape);
1683     BKE_mask_layer_shape_sort(masklay);
1684   }
1685
1686   return masklay_shape;
1687 }
1688
1689 MaskLayerShape *BKE_mask_layer_shape_duplicate(MaskLayerShape *masklay_shape)
1690 {
1691   MaskLayerShape *masklay_shape_copy;
1692
1693   masklay_shape_copy = MEM_dupallocN(masklay_shape);
1694
1695   if (LIKELY(masklay_shape_copy->data)) {
1696     masklay_shape_copy->data = MEM_dupallocN(masklay_shape_copy->data);
1697   }
1698
1699   return masklay_shape_copy;
1700 }
1701
1702 void BKE_mask_layer_shape_unlink(MaskLayer *masklay, MaskLayerShape *masklay_shape)
1703 {
1704   BLI_remlink(&masklay->splines_shapes, masklay_shape);
1705
1706   BKE_mask_layer_shape_free(masklay_shape);
1707 }
1708
1709 static int mask_layer_shape_sort_cb(const void *masklay_shape_a_ptr,
1710                                     const void *masklay_shape_b_ptr)
1711 {
1712   const MaskLayerShape *masklay_shape_a = masklay_shape_a_ptr;
1713   const MaskLayerShape *masklay_shape_b = masklay_shape_b_ptr;
1714
1715   if (masklay_shape_a->frame < masklay_shape_b->frame) {
1716     return -1;
1717   }
1718   else if (masklay_shape_a->frame > masklay_shape_b->frame) {
1719     return 1;
1720   }
1721   else {
1722     return 0;
1723   }
1724 }
1725
1726 void BKE_mask_layer_shape_sort(MaskLayer *masklay)
1727 {
1728   BLI_listbase_sort(&masklay->splines_shapes, mask_layer_shape_sort_cb);
1729 }
1730
1731 bool BKE_mask_layer_shape_spline_from_index(MaskLayer *masklay,
1732                                             int index,
1733                                             MaskSpline **r_masklay_shape,
1734                                             int *r_index)
1735 {
1736   MaskSpline *spline;
1737
1738   for (spline = masklay->splines.first; spline; spline = spline->next) {
1739     if (index < spline->tot_point) {
1740       *r_masklay_shape = spline;
1741       *r_index = index;
1742       return true;
1743     }
1744     index -= spline->tot_point;
1745   }
1746
1747   return false;
1748 }
1749
1750 int BKE_mask_layer_shape_spline_to_index(MaskLayer *masklay, MaskSpline *spline)
1751 {
1752   MaskSpline *spline_iter;
1753   int i_abs = 0;
1754   for (spline_iter = masklay->splines.first; spline_iter && spline_iter != spline;
1755        i_abs += spline_iter->tot_point, spline_iter = spline_iter->next) {
1756     /* pass */
1757   }
1758
1759   return i_abs;
1760 }
1761
1762 /* basic 2D interpolation functions, could make more comprehensive later */
1763 static void interp_weights_uv_v2_calc(float r_uv[2],
1764                                       const float pt[2],
1765                                       const float pt_a[2],
1766                                       const float pt_b[2])
1767 {
1768   float pt_on_line[2];
1769   r_uv[0] = closest_to_line_v2(pt_on_line, pt, pt_a, pt_b);
1770   r_uv[1] = (len_v2v2(pt_on_line, pt) / len_v2v2(pt_a, pt_b)) *
1771             ((line_point_side_v2(pt_a, pt_b, pt) < 0.0f) ?
1772                  -1.0f :
1773                  1.0f); /* this line only sets the sign */
1774 }
1775
1776 static void interp_weights_uv_v2_apply(const float uv[2],
1777                                        float r_pt[2],
1778                                        const float pt_a[2],
1779                                        const float pt_b[2])
1780 {
1781   const float dvec[2] = {pt_b[0] - pt_a[0], pt_b[1] - pt_a[1]};
1782
1783   /* u */
1784   madd_v2_v2v2fl(r_pt, pt_a, dvec, uv[0]);
1785
1786   /* v */
1787   r_pt[0] += -dvec[1] * uv[1];
1788   r_pt[1] += dvec[0] * uv[1];
1789 }
1790
1791 /* when a new points added - resize all shapekey array  */
1792 void BKE_mask_layer_shape_changed_add(MaskLayer *masklay,
1793                                       int index,
1794                                       bool do_init,
1795                                       bool do_init_interpolate)
1796 {
1797   MaskLayerShape *masklay_shape;
1798
1799   /* spline index from masklay */
1800   MaskSpline *spline;
1801   int spline_point_index;
1802
1803   if (BKE_mask_layer_shape_spline_from_index(masklay, index, &spline, &spline_point_index)) {
1804     /* sanity check */
1805     /* the point has already been removed in this array so subtract one when comparing with the shapes */
1806     int tot = BKE_mask_layer_shape_totvert(masklay) - 1;
1807
1808     /* for interpolation */
1809     /* TODO - assumes closed curve for now */
1810     float uv[3][2]; /* 3x 2D handles */
1811     const int pi_curr = spline_point_index;
1812     const int pi_prev = ((spline_point_index - 1) + spline->tot_point) % spline->tot_point;
1813     const int pi_next = (spline_point_index + 1) % spline->tot_point;
1814
1815     const int index_offset = index - spline_point_index;
1816     /* const int pi_curr_abs = index; */
1817     const int pi_prev_abs = pi_prev + index_offset;
1818     const int pi_next_abs = pi_next + index_offset;
1819
1820     int i;
1821     if (do_init_interpolate) {
1822       for (i = 0; i < 3; i++) {
1823         interp_weights_uv_v2_calc(uv[i],
1824                                   spline->points[pi_curr].bezt.vec[i],
1825                                   spline->points[pi_prev].bezt.vec[i],
1826                                   spline->points[pi_next].bezt.vec[i]);
1827       }
1828     }
1829
1830     for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
1831          masklay_shape = masklay_shape->next) {
1832       if (tot == masklay_shape->tot_vert) {
1833         float *data_resized;
1834
1835         masklay_shape->tot_vert++;
1836         data_resized = MEM_mallocN(
1837             masklay_shape->tot_vert * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE, __func__);
1838         if (index > 0) {
1839           memcpy(data_resized,
1840                  masklay_shape->data,
1841                  index * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
1842         }
1843
1844         if (index != masklay_shape->tot_vert - 1) {
1845           memcpy(&data_resized[(index + 1) * MASK_OBJECT_SHAPE_ELEM_SIZE],
1846                  masklay_shape->data + (index * MASK_OBJECT_SHAPE_ELEM_SIZE),
1847                  (masklay_shape->tot_vert - (index + 1)) * sizeof(float) *
1848                      MASK_OBJECT_SHAPE_ELEM_SIZE);
1849         }
1850
1851         if (do_init) {
1852           float *fp = &data_resized[index * MASK_OBJECT_SHAPE_ELEM_SIZE];
1853
1854           mask_layer_shape_from_mask_point(&spline->points[spline_point_index].bezt, fp);
1855
1856           if (do_init_interpolate && spline->tot_point > 2) {
1857             for (i = 0; i < 3; i++) {
1858               interp_weights_uv_v2_apply(
1859                   uv[i],
1860                   &fp[i * 2],
1861                   &data_resized[(pi_prev_abs * MASK_OBJECT_SHAPE_ELEM_SIZE) + (i * 2)],
1862                   &data_resized[(pi_next_abs * MASK_OBJECT_SHAPE_ELEM_SIZE) + (i * 2)]);
1863             }
1864           }
1865         }
1866         else {
1867           memset(&data_resized[index * MASK_OBJECT_SHAPE_ELEM_SIZE],
1868                  0,
1869                  sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
1870         }
1871
1872         MEM_freeN(masklay_shape->data);
1873         masklay_shape->data = data_resized;
1874       }
1875       else {
1876         CLOG_ERROR(&LOG,
1877                    "vert mismatch %d != %d (frame %d)",
1878                    masklay_shape->tot_vert,
1879                    tot,
1880                    masklay_shape->frame);
1881       }
1882     }
1883   }
1884 }
1885
1886 /* move array to account for removed point */
1887 void BKE_mask_layer_shape_changed_remove(MaskLayer *masklay, int index, int count)
1888 {
1889   MaskLayerShape *masklay_shape;
1890
1891   /* the point has already been removed in this array so add one when comparing with the shapes */
1892   int tot = BKE_mask_layer_shape_totvert(masklay);
1893
1894   for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
1895        masklay_shape = masklay_shape->next) {
1896     if (tot == masklay_shape->tot_vert - count) {
1897       float *data_resized;
1898
1899       masklay_shape->tot_vert -= count;
1900       data_resized = MEM_mallocN(
1901           masklay_shape->tot_vert * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE, __func__);
1902       if (index > 0) {
1903         memcpy(data_resized,
1904                masklay_shape->data,
1905                index * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
1906       }
1907
1908       if (index != masklay_shape->tot_vert) {
1909         memcpy(&data_resized[index * MASK_OBJECT_SHAPE_ELEM_SIZE],
1910                masklay_shape->data + ((index + count) * MASK_OBJECT_SHAPE_ELEM_SIZE),
1911                (masklay_shape->tot_vert - index) * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
1912       }
1913
1914       MEM_freeN(masklay_shape->data);
1915       masklay_shape->data = data_resized;
1916     }
1917     else {
1918       CLOG_ERROR(&LOG,
1919                  "vert mismatch %d != %d (frame %d)",
1920                  masklay_shape->tot_vert - count,
1921                  tot,
1922                  masklay_shape->frame);
1923     }
1924   }
1925 }
1926
1927 int BKE_mask_get_duration(Mask *mask)
1928 {
1929   return max_ii(1, mask->efra - mask->sfra);
1930 }
1931
1932 /*********************** clipboard *************************/
1933
1934 static void mask_clipboard_free_ex(bool final_free)
1935 {
1936   BKE_mask_spline_free_list(&mask_clipboard.splines);
1937   BLI_listbase_clear(&mask_clipboard.splines);
1938   if (mask_clipboard.id_hash) {
1939     if (final_free) {
1940       BLI_ghash_free(mask_clipboard.id_hash, NULL, MEM_freeN);
1941     }
1942     else {
1943       BLI_ghash_clear(mask_clipboard.id_hash, NULL, MEM_freeN);
1944     }
1945   }
1946 }
1947
1948 /* Free the clipboard. */
1949 void BKE_mask_clipboard_free(void)
1950 {
1951   mask_clipboard_free_ex(true);
1952 }
1953
1954 /* Copy selected visible splines from the given layer to clipboard. */
1955 void BKE_mask_clipboard_copy_from_layer(MaskLayer *mask_layer)
1956 {
1957   MaskSpline *spline;
1958
1959   /* Nothing to do if selection if disabled for the given layer. */
1960   if (mask_layer->restrictflag & MASK_RESTRICT_SELECT) {
1961     return;
1962   }
1963
1964   mask_clipboard_free_ex(false);
1965   if (mask_clipboard.id_hash == NULL) {
1966     mask_clipboard.id_hash = BLI_ghash_ptr_new("mask clipboard ID hash");
1967   }
1968
1969   for (spline = mask_layer->splines.first; spline; spline = spline->next) {
1970     if (spline->flag & SELECT) {
1971       MaskSpline *spline_new = BKE_mask_spline_copy(spline);
1972       int i;
1973       for (i = 0; i < spline_new->tot_point; i++) {
1974         MaskSplinePoint *point = &spline_new->points[i];
1975         if (point->parent.id) {
1976           if (!BLI_ghash_lookup(mask_clipboard.id_hash, point->parent.id)) {
1977             int len = strlen(point->parent.id->name);
1978             char *name_copy = MEM_mallocN(len + 1, "mask clipboard ID name");
1979             strcpy(name_copy, point->parent.id->name);
1980             BLI_ghash_insert(mask_clipboard.id_hash, point->parent.id, name_copy);
1981           }
1982         }
1983       }
1984
1985       BLI_addtail(&mask_clipboard.splines, spline_new);
1986     }
1987   }
1988 }
1989
1990 /* Check clipboard is empty. */
1991 bool BKE_mask_clipboard_is_empty(void)
1992 {
1993   return BLI_listbase_is_empty(&mask_clipboard.splines);
1994 }
1995
1996 /* Paste the contents of clipboard to given mask layer */
1997 void BKE_mask_clipboard_paste_to_layer(Main *bmain, MaskLayer *mask_layer)
1998 {
1999   MaskSpline *spline;
2000
2001   for (spline = mask_clipboard.splines.first; spline; spline = spline->next) {
2002     MaskSpline *spline_new = BKE_mask_spline_copy(spline);
2003     int i;
2004
2005     for (i = 0; i < spline_new->tot_point; i++) {
2006       MaskSplinePoint *point = &spline_new->points[i];
2007       if (point->parent.id) {
2008         const char *id_name = BLI_ghash_lookup(mask_clipboard.id_hash, point->parent.id);
2009         ListBase *listbase;
2010
2011         BLI_assert(id_name != NULL);
2012
2013         listbase = which_libbase(bmain, GS(id_name));
2014         point->parent.id = BLI_findstring(listbase, id_name + 2, offsetof(ID, name) + 2);
2015       }
2016     }
2017
2018     BLI_addtail(&mask_layer->splines, spline_new);
2019   }
2020 }