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