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