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