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