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