Merge remote-tracking branch 'origin/master' into blender2.8
[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         BKE_mask_evaluate(mask, ctime, false);
1423 }
1424
1425 void BKE_mask_evaluate_all_masks(Main *bmain, float ctime, const bool do_newframe)
1426 {
1427         Mask *mask;
1428
1429         for (mask = bmain->mask.first; mask; mask = mask->id.next) {
1430                 BKE_mask_evaluate(mask, ctime, do_newframe);
1431         }
1432 }
1433
1434 void BKE_mask_parent_init(MaskParent *parent)
1435 {
1436         parent->id_type = ID_MC;
1437 }
1438
1439
1440 /* *** own animation/shapekey implementation ***
1441  * BKE_mask_layer_shape_XXX */
1442
1443 int BKE_mask_layer_shape_totvert(MaskLayer *masklay)
1444 {
1445         int tot = 0;
1446         MaskSpline *spline;
1447
1448         for (spline = masklay->splines.first; spline; spline = spline->next) {
1449                 tot += spline->tot_point;
1450         }
1451
1452         return tot;
1453 }
1454
1455 static void mask_layer_shape_from_mask_point(BezTriple *bezt, float fp[MASK_OBJECT_SHAPE_ELEM_SIZE])
1456 {
1457         copy_v2_v2(&fp[0], bezt->vec[0]);
1458         copy_v2_v2(&fp[2], bezt->vec[1]);
1459         copy_v2_v2(&fp[4], bezt->vec[2]);
1460         fp[6] = bezt->weight;
1461         fp[7] = bezt->radius;
1462 }
1463
1464 static void mask_layer_shape_to_mask_point(BezTriple *bezt, float fp[MASK_OBJECT_SHAPE_ELEM_SIZE])
1465 {
1466         copy_v2_v2(bezt->vec[0], &fp[0]);
1467         copy_v2_v2(bezt->vec[1], &fp[2]);
1468         copy_v2_v2(bezt->vec[2], &fp[4]);
1469         bezt->weight = fp[6];
1470         bezt->radius = fp[7];
1471 }
1472
1473 /* these functions match. copy is swapped */
1474 void BKE_mask_layer_shape_from_mask(MaskLayer *masklay, MaskLayerShape *masklay_shape)
1475 {
1476         int tot = BKE_mask_layer_shape_totvert(masklay);
1477
1478         if (masklay_shape->tot_vert == tot) {
1479                 float *fp = masklay_shape->data;
1480
1481                 MaskSpline *spline;
1482                 for (spline = masklay->splines.first; spline; spline = spline->next) {
1483                         int i;
1484                         for (i = 0; i < spline->tot_point; i++) {
1485                                 mask_layer_shape_from_mask_point(&spline->points[i].bezt, fp);
1486                                 fp += MASK_OBJECT_SHAPE_ELEM_SIZE;
1487                         }
1488                 }
1489         }
1490         else {
1491                 printf("%s: vert mismatch %d != %d (frame %d)\n",
1492                        __func__, masklay_shape->tot_vert, tot, masklay_shape->frame);
1493         }
1494 }
1495
1496 void BKE_mask_layer_shape_to_mask(MaskLayer *masklay, MaskLayerShape *masklay_shape)
1497 {
1498         int tot = BKE_mask_layer_shape_totvert(masklay);
1499
1500         if (masklay_shape->tot_vert == tot) {
1501                 float *fp = masklay_shape->data;
1502
1503                 MaskSpline *spline;
1504                 for (spline = masklay->splines.first; spline; spline = spline->next) {
1505                         int i;
1506                         for (i = 0; i < spline->tot_point; i++) {
1507                                 mask_layer_shape_to_mask_point(&spline->points[i].bezt, fp);
1508                                 fp += MASK_OBJECT_SHAPE_ELEM_SIZE;
1509                         }
1510                 }
1511         }
1512         else {
1513                 printf("%s: vert mismatch %d != %d (frame %d)\n",
1514                        __func__, masklay_shape->tot_vert, tot, masklay_shape->frame);
1515         }
1516 }
1517
1518 BLI_INLINE void interp_v2_v2v2_flfl(float target[2], const float a[2], const float b[2],
1519                                     const float t, const float s)
1520 {
1521         target[0] = s * a[0] + t * b[0];
1522         target[1] = s * a[1] + t * b[1];
1523 }
1524
1525 /* linear interpolation only */
1526 void BKE_mask_layer_shape_to_mask_interp(MaskLayer *masklay,
1527                                          MaskLayerShape *masklay_shape_a,
1528                                          MaskLayerShape *masklay_shape_b,
1529                                          const float fac)
1530 {
1531         int tot = BKE_mask_layer_shape_totvert(masklay);
1532         if (masklay_shape_a->tot_vert == tot && masklay_shape_b->tot_vert == tot) {
1533                 const float *fp_a = masklay_shape_a->data;
1534                 const float *fp_b = masklay_shape_b->data;
1535                 const float ifac = 1.0f - fac;
1536
1537                 MaskSpline *spline;
1538                 for (spline = masklay->splines.first; spline; spline = spline->next) {
1539                         int i;
1540                         for (i = 0; i < spline->tot_point; i++) {
1541                                 BezTriple *bezt = &spline->points[i].bezt;
1542                                 /* *** BKE_mask_layer_shape_from_mask - swapped *** */
1543                                 interp_v2_v2v2_flfl(bezt->vec[0], fp_a, fp_b, fac, ifac); fp_a += 2; fp_b += 2;
1544                                 interp_v2_v2v2_flfl(bezt->vec[1], fp_a, fp_b, fac, ifac); fp_a += 2; fp_b += 2;
1545                                 interp_v2_v2v2_flfl(bezt->vec[2], fp_a, fp_b, fac, ifac); fp_a += 2; fp_b += 2;
1546                                 bezt->weight = (fp_a[0] * ifac) + (fp_b[0] * fac);
1547                                 bezt->radius = (fp_a[1] * ifac) + (fp_b[1] * fac); fp_a += 2; fp_b += 2;
1548                         }
1549                 }
1550         }
1551         else {
1552                 printf("%s: vert mismatch %d != %d != %d (frame %d - %d)\n",
1553                        __func__, masklay_shape_a->tot_vert, masklay_shape_b->tot_vert, tot,
1554                        masklay_shape_a->frame, masklay_shape_b->frame);
1555         }
1556 }
1557
1558 MaskLayerShape *BKE_mask_layer_shape_find_frame(MaskLayer *masklay, const int frame)
1559 {
1560         MaskLayerShape *masklay_shape;
1561
1562         for (masklay_shape = masklay->splines_shapes.first;
1563              masklay_shape;
1564              masklay_shape = masklay_shape->next)
1565         {
1566                 if (frame == masklay_shape->frame) {
1567                         return masklay_shape;
1568                 }
1569                 else if (frame < masklay_shape->frame) {
1570                         break;
1571                 }
1572         }
1573
1574         return NULL;
1575 }
1576
1577 /* when returning 2 - the frame isnt found but before/after frames are */
1578 int BKE_mask_layer_shape_find_frame_range(MaskLayer *masklay, const float frame,
1579                                           MaskLayerShape **r_masklay_shape_a,
1580                                           MaskLayerShape **r_masklay_shape_b)
1581 {
1582         MaskLayerShape *masklay_shape;
1583
1584         for (masklay_shape = masklay->splines_shapes.first;
1585              masklay_shape;
1586              masklay_shape = masklay_shape->next)
1587         {
1588                 if (frame == masklay_shape->frame) {
1589                         *r_masklay_shape_a = masklay_shape;
1590                         *r_masklay_shape_b = NULL;
1591                         return 1;
1592                 }
1593                 else if (frame < masklay_shape->frame) {
1594                         if (masklay_shape->prev) {
1595                                 *r_masklay_shape_a = masklay_shape->prev;
1596                                 *r_masklay_shape_b = masklay_shape;
1597                                 return 2;
1598                         }
1599                         else {
1600                                 *r_masklay_shape_a = masklay_shape;
1601                                 *r_masklay_shape_b = NULL;
1602                                 return 1;
1603                         }
1604                 }
1605         }
1606
1607         if ((masklay_shape = masklay->splines_shapes.last)) {
1608                 *r_masklay_shape_a = masklay_shape;
1609                 *r_masklay_shape_b = NULL;
1610                 return 1;
1611         }
1612         else {
1613                 *r_masklay_shape_a = NULL;
1614                 *r_masklay_shape_b = NULL;
1615
1616                 return 0;
1617         }
1618 }
1619
1620 MaskLayerShape *BKE_mask_layer_shape_verify_frame(MaskLayer *masklay, const int frame)
1621 {
1622         MaskLayerShape *masklay_shape;
1623
1624         masklay_shape = BKE_mask_layer_shape_find_frame(masklay, frame);
1625
1626         if (masklay_shape == NULL) {
1627                 masklay_shape = BKE_mask_layer_shape_alloc(masklay, frame);
1628                 BLI_addtail(&masklay->splines_shapes, masklay_shape);
1629                 BKE_mask_layer_shape_sort(masklay);
1630         }
1631
1632         return masklay_shape;
1633 }
1634
1635 MaskLayerShape *BKE_mask_layer_shape_duplicate(MaskLayerShape *masklay_shape)
1636 {
1637         MaskLayerShape *masklay_shape_copy;
1638
1639         masklay_shape_copy = MEM_dupallocN(masklay_shape);
1640
1641         if (LIKELY(masklay_shape_copy->data)) {
1642                 masklay_shape_copy->data = MEM_dupallocN(masklay_shape_copy->data);
1643         }
1644
1645         return masklay_shape_copy;
1646 }
1647
1648 void BKE_mask_layer_shape_unlink(MaskLayer *masklay, MaskLayerShape *masklay_shape)
1649 {
1650         BLI_remlink(&masklay->splines_shapes, masklay_shape);
1651
1652         BKE_mask_layer_shape_free(masklay_shape);
1653 }
1654
1655 static int mask_layer_shape_sort_cb(const void *masklay_shape_a_ptr, const void *masklay_shape_b_ptr)
1656 {
1657         const MaskLayerShape *masklay_shape_a = masklay_shape_a_ptr;
1658         const MaskLayerShape *masklay_shape_b = masklay_shape_b_ptr;
1659
1660         if      (masklay_shape_a->frame < masklay_shape_b->frame)  return -1;
1661         else if (masklay_shape_a->frame > masklay_shape_b->frame)  return  1;
1662         else                                                       return  0;
1663 }
1664
1665 void BKE_mask_layer_shape_sort(MaskLayer *masklay)
1666 {
1667         BLI_listbase_sort(&masklay->splines_shapes, mask_layer_shape_sort_cb);
1668 }
1669
1670 bool BKE_mask_layer_shape_spline_from_index(MaskLayer *masklay, int index,
1671                                             MaskSpline **r_masklay_shape, int *r_index)
1672 {
1673         MaskSpline *spline;
1674
1675         for (spline = masklay->splines.first; spline; spline = spline->next) {
1676                 if (index < spline->tot_point) {
1677                         *r_masklay_shape = spline;
1678                         *r_index = index;
1679                         return true;
1680                 }
1681                 index -= spline->tot_point;
1682         }
1683
1684         return false;
1685 }
1686
1687 int BKE_mask_layer_shape_spline_to_index(MaskLayer *masklay, MaskSpline *spline)
1688 {
1689         MaskSpline *spline_iter;
1690         int i_abs = 0;
1691         for (spline_iter = masklay->splines.first;
1692              spline_iter && spline_iter != spline;
1693              i_abs += spline_iter->tot_point, spline_iter = spline_iter->next)
1694         {
1695                 /* pass */
1696         }
1697
1698         return i_abs;
1699 }
1700
1701 /* basic 2D interpolation functions, could make more comprehensive later */
1702 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])
1703 {
1704         float pt_on_line[2];
1705         r_uv[0] = closest_to_line_v2(pt_on_line, pt, pt_a, pt_b);
1706         r_uv[1] = (len_v2v2(pt_on_line, pt) / len_v2v2(pt_a, pt_b)) *
1707                   ((line_point_side_v2(pt_a, pt_b, pt) < 0.0f) ? -1.0f : 1.0f);  /* this line only sets the sign */
1708 }
1709
1710
1711 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])
1712 {
1713         const float dvec[2] = {pt_b[0] - pt_a[0],
1714                                pt_b[1] - pt_a[1]};
1715
1716         /* u */
1717         madd_v2_v2v2fl(r_pt, pt_a, dvec, uv[0]);
1718
1719         /* v */
1720         r_pt[0] += -dvec[1] * uv[1];
1721         r_pt[1] +=  dvec[0] * uv[1];
1722 }
1723
1724 /* when a new points added - resize all shapekey array  */
1725 void BKE_mask_layer_shape_changed_add(MaskLayer *masklay, int index,
1726                                       bool do_init, bool do_init_interpolate)
1727 {
1728         MaskLayerShape *masklay_shape;
1729
1730         /* spline index from masklay */
1731         MaskSpline *spline;
1732         int spline_point_index;
1733
1734         if (BKE_mask_layer_shape_spline_from_index(masklay, index,
1735                                                    &spline, &spline_point_index))
1736         {
1737                 /* sanity check */
1738                 /* the point has already been removed in this array so subtract one when comparing with the shapes */
1739                 int tot = BKE_mask_layer_shape_totvert(masklay) - 1;
1740
1741                 /* for interpolation */
1742                 /* TODO - assumes closed curve for now */
1743                 float uv[3][2]; /* 3x 2D handles */
1744                 const int pi_curr =   spline_point_index;
1745                 const int pi_prev = ((spline_point_index - 1) + spline->tot_point) % spline->tot_point;
1746                 const int pi_next =  (spline_point_index + 1)                      % spline->tot_point;
1747
1748                 const int index_offset = index - spline_point_index;
1749                 /* const int pi_curr_abs = index; */
1750                 const int pi_prev_abs = pi_prev + index_offset;
1751                 const int pi_next_abs = pi_next + index_offset;
1752
1753                 int i;
1754                 if (do_init_interpolate) {
1755                         for (i = 0; i < 3; i++) {
1756                                 interp_weights_uv_v2_calc(uv[i],
1757                                                           spline->points[pi_curr].bezt.vec[i],
1758                                                           spline->points[pi_prev].bezt.vec[i],
1759                                                           spline->points[pi_next].bezt.vec[i]);
1760                         }
1761                 }
1762
1763                 for (masklay_shape = masklay->splines_shapes.first;
1764                      masklay_shape;
1765                      masklay_shape = masklay_shape->next)
1766                 {
1767                         if (tot == masklay_shape->tot_vert) {
1768                                 float *data_resized;
1769
1770                                 masklay_shape->tot_vert++;
1771                                 data_resized = MEM_mallocN(masklay_shape->tot_vert * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE, __func__);
1772                                 if (index > 0) {
1773                                         memcpy(data_resized,
1774                                                masklay_shape->data,
1775                                                index * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
1776                                 }
1777
1778                                 if (index != masklay_shape->tot_vert - 1) {
1779                                         memcpy(&data_resized[(index + 1) * MASK_OBJECT_SHAPE_ELEM_SIZE],
1780                                                masklay_shape->data + (index * MASK_OBJECT_SHAPE_ELEM_SIZE),
1781                                                (masklay_shape->tot_vert - (index + 1)) * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
1782                                 }
1783
1784                                 if (do_init) {
1785                                         float *fp = &data_resized[index * MASK_OBJECT_SHAPE_ELEM_SIZE];
1786
1787                                         mask_layer_shape_from_mask_point(&spline->points[spline_point_index].bezt, fp);
1788
1789                                         if (do_init_interpolate && spline->tot_point > 2) {
1790                                                 for (i = 0; i < 3; i++) {
1791                                                         interp_weights_uv_v2_apply(uv[i],
1792                                                                                    &fp[i * 2],
1793                                                                                    &data_resized[(pi_prev_abs * MASK_OBJECT_SHAPE_ELEM_SIZE) + (i * 2)],
1794                                                                                    &data_resized[(pi_next_abs * MASK_OBJECT_SHAPE_ELEM_SIZE) + (i * 2)]);
1795                                                 }
1796                                         }
1797                                 }
1798                                 else {
1799                                         memset(&data_resized[index * MASK_OBJECT_SHAPE_ELEM_SIZE],
1800                                                0,
1801                                                sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
1802                                 }
1803
1804                                 MEM_freeN(masklay_shape->data);
1805                                 masklay_shape->data = data_resized;
1806                         }
1807                         else {
1808                                 printf("%s: vert mismatch %d != %d (frame %d)\n",
1809                                        __func__, masklay_shape->tot_vert, tot, masklay_shape->frame);
1810                         }
1811                 }
1812         }
1813 }
1814
1815
1816 /* move array to account for removed point */
1817 void BKE_mask_layer_shape_changed_remove(MaskLayer *masklay, int index, int count)
1818 {
1819         MaskLayerShape *masklay_shape;
1820
1821         /* the point has already been removed in this array so add one when comparing with the shapes */
1822         int tot = BKE_mask_layer_shape_totvert(masklay);
1823
1824         for (masklay_shape = masklay->splines_shapes.first;
1825              masklay_shape;
1826              masklay_shape = masklay_shape->next)
1827         {
1828                 if (tot == masklay_shape->tot_vert - count) {
1829                         float *data_resized;
1830
1831                         masklay_shape->tot_vert -= count;
1832                         data_resized = MEM_mallocN(masklay_shape->tot_vert * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE, __func__);
1833                         if (index > 0) {
1834                                 memcpy(data_resized,
1835                                        masklay_shape->data,
1836                                        index * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
1837                         }
1838
1839                         if (index != masklay_shape->tot_vert) {
1840                                 memcpy(&data_resized[index * MASK_OBJECT_SHAPE_ELEM_SIZE],
1841                                        masklay_shape->data + ((index + count) * MASK_OBJECT_SHAPE_ELEM_SIZE),
1842                                        (masklay_shape->tot_vert - index) * 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 - count, tot, masklay_shape->frame);
1851                 }
1852         }
1853 }
1854
1855 int BKE_mask_get_duration(Mask *mask)
1856 {
1857         return max_ii(1, mask->efra - mask->sfra);
1858 }
1859
1860 /*********************** clipboard *************************/
1861
1862 static void mask_clipboard_free_ex(bool final_free)
1863 {
1864         BKE_mask_spline_free_list(&mask_clipboard.splines);
1865         BLI_listbase_clear(&mask_clipboard.splines);
1866         if (mask_clipboard.id_hash) {
1867                 if (final_free) {
1868                         BLI_ghash_free(mask_clipboard.id_hash, NULL, MEM_freeN);
1869                 }
1870                 else {
1871                         BLI_ghash_clear(mask_clipboard.id_hash, NULL, MEM_freeN);
1872                 }
1873         }
1874 }
1875
1876 /* Free the clipboard. */
1877 void BKE_mask_clipboard_free(void)
1878 {
1879         mask_clipboard_free_ex(true);
1880 }
1881
1882 /* Copy selected visible splines from the given layer to clipboard. */
1883 void BKE_mask_clipboard_copy_from_layer(MaskLayer *mask_layer)
1884 {
1885         MaskSpline *spline;
1886
1887         /* Nothing to do if selection if disabled for the given layer. */
1888         if (mask_layer->restrictflag & MASK_RESTRICT_SELECT) {
1889                 return;
1890         }
1891
1892         mask_clipboard_free_ex(false);
1893         if (mask_clipboard.id_hash == NULL) {
1894                 mask_clipboard.id_hash = BLI_ghash_ptr_new("mask clipboard ID hash");
1895         }
1896
1897         for (spline = mask_layer->splines.first; spline; spline = spline->next) {
1898                 if (spline->flag & SELECT) {
1899                         MaskSpline *spline_new = BKE_mask_spline_copy(spline);
1900                         int i;
1901                         for (i = 0; i < spline_new->tot_point; i++) {
1902                                 MaskSplinePoint *point = &spline_new->points[i];
1903                                 if (point->parent.id) {
1904                                         if (!BLI_ghash_lookup(mask_clipboard.id_hash, point->parent.id)) {
1905                                                 int len = strlen(point->parent.id->name);
1906                                                 char *name_copy = MEM_mallocN(len + 1, "mask clipboard ID name");
1907                                                 strcpy(name_copy, point->parent.id->name);
1908                                                 BLI_ghash_insert(mask_clipboard.id_hash,
1909                                                                  point->parent.id,
1910                                                                  name_copy);
1911                                         }
1912                                 }
1913                         }
1914
1915                         BLI_addtail(&mask_clipboard.splines, spline_new);
1916                 }
1917         }
1918 }
1919
1920 /* Check clipboard is empty. */
1921 bool BKE_mask_clipboard_is_empty(void)
1922 {
1923         return BLI_listbase_is_empty(&mask_clipboard.splines);
1924 }
1925
1926 /* Paste the contents of clipboard to given mask layer */
1927 void BKE_mask_clipboard_paste_to_layer(Main *bmain, MaskLayer *mask_layer)
1928 {
1929         MaskSpline *spline;
1930
1931         for (spline = mask_clipboard.splines.first; spline; spline = spline->next) {
1932                 MaskSpline *spline_new = BKE_mask_spline_copy(spline);
1933                 int i;
1934
1935                 for (i = 0; i < spline_new->tot_point; i++) {
1936                         MaskSplinePoint *point = &spline_new->points[i];
1937                         if (point->parent.id) {
1938                                 const char *id_name = BLI_ghash_lookup(mask_clipboard.id_hash, point->parent.id);
1939                                 ListBase *listbase;
1940
1941                                 BLI_assert(id_name != NULL);
1942
1943                                 listbase = which_libbase(bmain, GS(id_name));
1944                                 point->parent.id = BLI_findstring(listbase, id_name + 2, offsetof(ID, name) + 2);
1945                         }
1946                 }
1947
1948                 BLI_addtail(&mask_layer->splines, spline_new);
1949         }
1950 }