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