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