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