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