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