remove references to raskter from compositor and BKE mask.
[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 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 static BezTriple *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;
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 int BKE_mask_spline_resolution(MaskSpline *spline, int width, int height)
269 {
270         float max_segment = 0.01f;
271         int i, resol = 1;
272
273         if (width != 0 && height != 0) {
274                 if (width >= height)
275                         max_segment = 1.0f / (float) width;
276                 else
277                         max_segment = 1.0f / (float) height;
278         }
279
280         for (i = 0; i < spline->tot_point; i++) {
281                 MaskSplinePoint *point = &spline->points[i];
282                 BezTriple *bezt, *bezt_next;
283                 float a, b, c, len;
284                 int cur_resol;
285
286                 bezt = &point->bezt;
287                 bezt_next = mask_spline_point_next_bezt(spline, spline->points, point);
288
289                 if (bezt_next == NULL) {
290                         break;
291                 }
292
293                 a = len_v3v3(bezt->vec[1], bezt->vec[2]);
294                 b = len_v3v3(bezt->vec[2], bezt_next->vec[0]);
295                 c = len_v3v3(bezt_next->vec[0], bezt_next->vec[1]);
296
297                 len = a + b + c;
298                 cur_resol = len / max_segment;
299
300                 resol = MAX2(resol, cur_resol);
301         }
302
303         BLI_assert(resol > 0);
304
305         if (resol > MASK_RESOL_MAX) {
306                 resol = MASK_RESOL_MAX;
307         }
308
309         return resol;
310 }
311
312 int BKE_mask_spline_feather_resolution(MaskSpline *spline, int width, int height)
313 {
314         const float max_segment = 0.005;
315         int resol = BKE_mask_spline_resolution(spline, width, height);
316         float max_jump = 0.0f;
317         int i;
318
319         for (i = 0; i < spline->tot_point; i++) {
320                 MaskSplinePoint *point = &spline->points[i];
321                 float prev_u, prev_w;
322                 int j;
323
324                 prev_u = 0.0f;
325                 prev_w = point->bezt.weight;
326
327                 for (j = 0; j < point->tot_uw; j++) {
328                         float jump = fabsf((point->uw[j].w - prev_w) / (point->uw[j].u - prev_u));
329
330                         max_jump = MAX2(max_jump, jump);
331
332                         prev_u = point->uw[j].u;
333                         prev_w = point->uw[j].w;
334                 }
335         }
336
337         resol += max_jump / max_segment;
338
339         BLI_assert(resol > 0);
340
341         if (resol > MASK_RESOL_MAX) {
342                 resol = MASK_RESOL_MAX;
343         }
344
345         return resol;
346 }
347
348 int BKE_mask_spline_differentiate_calc_total(const MaskSpline *spline, const int resol)
349 {
350         int len;
351
352         /* count */
353         len = (spline->tot_point - 1) * resol;
354
355         if (spline->flag & MASK_SPLINE_CYCLIC) {
356                 len += resol;
357         }
358         else {
359                 len++;
360         }
361
362         return len;
363 }
364
365 float (*BKE_mask_spline_differentiate_with_resolution_ex(MaskSpline *spline,
366                                                          int *tot_diff_point,
367                                                          const int resol
368                                                          ))[2]
369 {
370         MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
371
372         MaskSplinePoint *point, *prev;
373         float (*diff_points)[2], (*fp)[2];
374         const int tot = BKE_mask_spline_differentiate_calc_total(spline, resol);
375         int a;
376
377         if (spline->tot_point <= 1) {
378                 /* nothing to differentiate */
379                 *tot_diff_point = 0;
380                 return NULL;
381         }
382
383         /* len+1 because of 'forward_diff_bezier' function */
384         *tot_diff_point = tot;
385         diff_points = fp = MEM_mallocN((tot + 1) * sizeof(*diff_points), "mask spline vets");
386
387         a = spline->tot_point - 1;
388         if (spline->flag & MASK_SPLINE_CYCLIC)
389                 a++;
390
391         prev = points_array;
392         point = prev + 1;
393
394         while (a--) {
395                 BezTriple *prevbezt;
396                 BezTriple *bezt;
397                 int j;
398
399                 if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC))
400                         point = points_array;
401
402                 prevbezt = &prev->bezt;
403                 bezt = &point->bezt;
404
405                 for (j = 0; j < 2; j++) {
406                         BKE_curve_forward_diff_bezier(prevbezt->vec[1][j], prevbezt->vec[2][j],
407                                                       bezt->vec[0][j], bezt->vec[1][j],
408                                                       &(*fp)[j], resol, 2 * sizeof(float));
409                 }
410
411                 fp += resol;
412
413                 if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC) == 0) {
414                         copy_v2_v2(*fp, bezt->vec[1]);
415                 }
416
417                 prev = point;
418                 point++;
419         }
420
421         return diff_points;
422 }
423
424 float (*BKE_mask_spline_differentiate_with_resolution(MaskSpline *spline, int width, int height,
425                                                       int *tot_diff_point
426                                                       ))[2]
427 {
428         int resol = BKE_mask_spline_resolution(spline, width, height);
429
430         return BKE_mask_spline_differentiate_with_resolution_ex(spline, tot_diff_point, resol);
431 }
432
433 float (*BKE_mask_spline_differentiate(MaskSpline *spline, int *tot_diff_point))[2]
434 {
435         return BKE_mask_spline_differentiate_with_resolution(spline, 0, 0, tot_diff_point);
436 }
437
438 /* ** feather points self-intersection collapse routine ** */
439
440 typedef struct FeatherEdgesBucket {
441         int tot_segment;
442         int (*segments)[2];
443         int alloc_segment;
444 } FeatherEdgesBucket;
445
446 static void feather_bucket_add_edge(FeatherEdgesBucket *bucket, int start, int end)
447 {
448         const int alloc_delta = 256;
449
450         if (bucket->tot_segment >= bucket->alloc_segment) {
451                 if (!bucket->segments) {
452                         bucket->segments = MEM_callocN(alloc_delta * sizeof(*bucket->segments), "feather bucket segments");
453                 }
454                 else {
455                         bucket->segments = MEM_reallocN(bucket->segments,
456                                         (alloc_delta + bucket->tot_segment) * sizeof(*bucket->segments));
457                 }
458
459                 bucket->alloc_segment += alloc_delta;
460         }
461
462         bucket->segments[bucket->tot_segment][0] = start;
463         bucket->segments[bucket->tot_segment][1] = end;
464
465         bucket->tot_segment++;
466 }
467
468 static void feather_bucket_check_intersect(float (*feather_points)[2], int tot_feather_point, FeatherEdgesBucket *bucket,
469                                            int cur_a, int cur_b)
470 {
471         int i;
472
473         float *v1 = (float *) feather_points[cur_a];
474         float *v2 = (float *) feather_points[cur_b];
475
476         for (i = 0; i < bucket->tot_segment; i++) {
477                 int check_a = bucket->segments[i][0];
478                 int check_b = bucket->segments[i][1];
479
480                 float *v3 = (float *) feather_points[check_a];
481                 float *v4 = (float *) feather_points[check_b];
482
483                 if (check_a >= cur_a - 1 || cur_b == check_a)
484                         continue;
485
486                 if (isect_seg_seg_v2(v1, v2, v3, v4)) {
487                         int k, len;
488                         float p[2];
489
490                         isect_seg_seg_v2_point(v1, v2, v3, v4, p);
491
492                         /* TODO: for now simply choose the shortest loop, could be made smarter in some way */
493                         len = cur_a - check_b;
494                         if (len < tot_feather_point - len) {
495                                 for (k = check_b; k <= cur_a; k++) {
496                                         copy_v2_v2(feather_points[k], p);
497                                 }
498                         }
499                         else {
500                                 for (k = 0; k <= check_a; k++) {
501                                         copy_v2_v2(feather_points[k], p);
502                                 }
503
504                                 if (cur_b != 0) {
505                                         for (k = cur_b; k < tot_feather_point; k++) {
506                                                 copy_v2_v2(feather_points[k], p);
507                                         }
508                                 }
509                         }
510                 }
511         }
512 }
513
514 static int feather_bucket_index_from_coord(float co[2], const float min[2], const float bucket_scale[2],
515                                            const int buckets_per_side)
516 {
517         int x = (int) ((co[0] - min[0]) * bucket_scale[0]);
518         int y = (int) ((co[1] - min[1]) * bucket_scale[1]);
519
520         if (x == buckets_per_side)
521                 x--;
522
523         if (y == buckets_per_side)
524                 y--;
525
526         return y * buckets_per_side + x;
527 }
528
529 static void feather_bucket_get_diagonal(FeatherEdgesBucket *buckets, int start_bucket_index, int end_bucket_index,
530                                         int buckets_per_side, FeatherEdgesBucket **diagonal_bucket_a_r,
531                                         FeatherEdgesBucket **diagonal_bucket_b_r)
532 {
533         int start_bucket_x = start_bucket_index % buckets_per_side;
534         int start_bucket_y = start_bucket_index / buckets_per_side;
535
536         int end_bucket_x = end_bucket_index % buckets_per_side;
537         int end_bucket_y = end_bucket_index / buckets_per_side;
538
539         int diagonal_bucket_a_index = start_bucket_y * buckets_per_side + end_bucket_x;
540         int diagonal_bucket_b_index = end_bucket_y * buckets_per_side + start_bucket_x;
541
542         *diagonal_bucket_a_r = &buckets[diagonal_bucket_a_index];
543         *diagonal_bucket_b_r = &buckets[diagonal_bucket_b_index];
544 }
545
546 static void spline_feather_collapse_inner_loops(MaskSpline *spline, float (*feather_points)[2], int tot_feather_point)
547 {
548 #define BUCKET_INDEX(co) \
549         feather_bucket_index_from_coord(co, min, bucket_scale, buckets_per_side)
550
551         int buckets_per_side, tot_bucket;
552         float bucket_size, bucket_scale[2];
553
554         FeatherEdgesBucket *buckets;
555
556         int i;
557         float min[2], max[2];
558         float max_delta_x = -1.0f, max_delta_y = -1.0f, max_delta;
559
560         if (tot_feather_point < 4) {
561                 /* self-intersection works only for quads at least,
562                  * in other cases polygon can't be self-intersecting anyway
563                  */
564
565                 return;
566         }
567
568         /* find min/max corners of mask to build buckets in that space */
569         INIT_MINMAX2(min, max);
570
571         for (i = 0; i < tot_feather_point; i++) {
572                 int next = i + 1;
573                 float delta;
574
575                 DO_MINMAX2(feather_points[i], min, max);
576
577                 if (next == tot_feather_point) {
578                         if (spline->flag & MASK_SPLINE_CYCLIC)
579                                 next = 0;
580                         else
581                                 break;
582                 }
583
584                 delta = fabsf(feather_points[i][0] - feather_points[next][0]);
585                 if (delta > max_delta_x)
586                         max_delta_x = delta;
587
588                 delta = fabsf(feather_points[i][1] - feather_points[next][1]);
589                 if (delta > max_delta_y)
590                         max_delta_y = delta;
591         }
592
593         /* prevent divisionsby zero by ensuring bounding box is not collapsed */
594         if (max[0] - min[0] < FLT_EPSILON) {
595                 max[0] += 0.01f;
596                 min[0] -= 0.01f;
597         }
598
599         if (max[1] - min[1] < FLT_EPSILON) {
600                 max[1] += 0.01f;
601                 min[1] -= 0.01f;
602         }
603
604         /* use dynamically calculated buckets per side, so we likely wouldn't
605          * run into a situation when segment doesn't fit two buckets which is
606          * pain collecting candidates for intersection
607          */
608
609         max_delta_x /= max[0] - min[0];
610         max_delta_y /= max[1] - min[1];
611
612         max_delta = MAX2(max_delta_x, max_delta_y);
613
614         buckets_per_side = MIN2(512, 0.9f / max_delta);
615
616         if (buckets_per_side == 0) {
617                 /* happens when some segment fills the whole bounding box across some of dimension */
618
619                 buckets_per_side = 1;
620         }
621
622         tot_bucket = buckets_per_side * buckets_per_side;
623         bucket_size = 1.0f / buckets_per_side;
624
625         /* pre-compute multipliers, to save mathematical operations in loops */
626         bucket_scale[0] = 1.0f / ((max[0] - min[0]) * bucket_size);
627         bucket_scale[1] = 1.0f / ((max[1] - min[1]) * bucket_size);
628
629         /* fill in buckets' edges */
630         buckets = MEM_callocN(sizeof(FeatherEdgesBucket) * tot_bucket, "feather buckets");
631
632         for (i = 0; i < tot_feather_point; i++) {
633                 int start = i, end = i + 1;
634                 int start_bucket_index, end_bucket_index;
635
636                 if (end == tot_feather_point) {
637                         if (spline->flag & MASK_SPLINE_CYCLIC)
638                                 end = 0;
639                         else
640                                 break;
641                 }
642
643                 start_bucket_index = BUCKET_INDEX(feather_points[start]);
644                 end_bucket_index = BUCKET_INDEX(feather_points[end]);
645
646                 feather_bucket_add_edge(&buckets[start_bucket_index], start, end);
647
648                 if (start_bucket_index != end_bucket_index) {
649                         FeatherEdgesBucket *end_bucket = &buckets[end_bucket_index];
650                         FeatherEdgesBucket *diagonal_bucket_a, *diagonal_bucket_b;
651
652                         feather_bucket_get_diagonal(buckets, start_bucket_index, end_bucket_index, buckets_per_side,
653                                                     &diagonal_bucket_a, &diagonal_bucket_b);
654
655                         feather_bucket_add_edge(end_bucket, start, end);
656                         feather_bucket_add_edge(diagonal_bucket_a, start, end);
657                         feather_bucket_add_edge(diagonal_bucket_a, start, end);
658                 }
659         }
660
661         /* check all edges for intersection with edges from their buckets */
662         for (i = 0; i < tot_feather_point; i++) {
663                 int cur_a = i, cur_b = i + 1;
664                 int start_bucket_index, end_bucket_index;
665
666                 FeatherEdgesBucket *start_bucket;
667
668                 if (cur_b == tot_feather_point)
669                         cur_b = 0;
670
671                 start_bucket_index = BUCKET_INDEX(feather_points[cur_a]);
672                 end_bucket_index = BUCKET_INDEX(feather_points[cur_b]);
673
674                 start_bucket = &buckets[start_bucket_index];
675
676                 feather_bucket_check_intersect(feather_points, tot_feather_point, start_bucket, cur_a, cur_b);
677
678                 if (start_bucket_index != end_bucket_index) {
679                         FeatherEdgesBucket *end_bucket = &buckets[end_bucket_index];
680                         FeatherEdgesBucket *diagonal_bucket_a, *diagonal_bucket_b;
681
682                         feather_bucket_get_diagonal(buckets, start_bucket_index, end_bucket_index, buckets_per_side,
683                                                     &diagonal_bucket_a, &diagonal_bucket_b);
684
685                         feather_bucket_check_intersect(feather_points, tot_feather_point, end_bucket, cur_a, cur_b);
686                         feather_bucket_check_intersect(feather_points, tot_feather_point, diagonal_bucket_a, cur_a, cur_b);
687                         feather_bucket_check_intersect(feather_points, tot_feather_point, diagonal_bucket_b, cur_a, cur_b);
688                 }
689         }
690
691         /* free buckets */
692         for (i = 0; i < tot_bucket; i++) {
693                 if (buckets[i].segments)
694                         MEM_freeN(buckets[i].segments);
695         }
696
697         MEM_freeN(buckets);
698
699 #undef BUCKET_INDEX
700 }
701
702 /**
703  * values align with #BKE_mask_spline_differentiate_with_resolution_ex
704  * when \a resol arguments match.
705  */
706 float (*BKE_mask_spline_feather_differentiated_points_with_resolution_ex(MaskSpline *spline,
707                                                                          int *tot_feather_point,
708                                                                          const int resol,
709                                                                          const int do_collapse
710                                                                          ))[2]
711 {
712         MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
713         MaskSplinePoint *point, *prev;
714         float (*feather)[2], (*fp)[2];
715
716         const int tot = BKE_mask_spline_differentiate_calc_total(spline, resol);
717         int a;
718
719         /* tot+1 because of 'forward_diff_bezier' function */
720         feather = fp = MEM_mallocN((tot + 1) * sizeof(*feather), "mask spline feather diff points");
721
722         a = spline->tot_point - 1;
723         if (spline->flag & MASK_SPLINE_CYCLIC)
724                 a++;
725
726         prev = points_array;
727         point = prev + 1;
728
729         while (a--) {
730                 /* BezTriple *prevbezt; */  /* UNUSED */
731                 /* BezTriple *bezt; */      /* UNUSED */
732                 int j;
733
734                 if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC))
735                         point = points_array;
736
737
738                 /* prevbezt = &prev->bezt; */
739                 /* bezt = &point->bezt; */
740
741                 for (j = 0; j < resol; j++, fp++) {
742                         float u = (float) j / resol, weight;
743                         float co[2], n[2];
744
745                         /* TODO - these calls all calculate similar things
746                          * could be unified for some speed */
747                         BKE_mask_point_segment_co(spline, prev, u, co);
748                         BKE_mask_point_normal(spline, prev, u, n);
749                         weight = BKE_mask_point_weight(spline, prev, u);
750
751                         madd_v2_v2v2fl(*fp, co, n, weight);
752                 }
753
754                 if (a == 0 && (spline->flag & MASK_SPLINE_CYCLIC) == 0) {
755                         float u = 1.0f, weight;
756                         float co[2], n[2];
757
758                         BKE_mask_point_segment_co(spline, prev, u, co);
759                         BKE_mask_point_normal(spline, prev, u, n);
760                         weight = BKE_mask_point_weight(spline, prev, u);
761
762                         madd_v2_v2v2fl(*fp, co, n, weight);
763                 }
764
765                 prev = point;
766                 point++;
767         }
768
769         *tot_feather_point = tot;
770
771         /* this is slow! - don't do on draw */
772         if (do_collapse) {
773                 spline_feather_collapse_inner_loops(spline, feather, tot);
774         }
775
776         return feather;
777 }
778
779 float (*BKE_mask_spline_feather_differentiated_points_with_resolution(MaskSpline *spline, int width, int height,
780                                                                       int *tot_feather_point))[2]
781 {
782         int resol = BKE_mask_spline_feather_resolution(spline, width, height);
783
784         return BKE_mask_spline_feather_differentiated_points_with_resolution_ex(spline, tot_feather_point, resol, FALSE);
785 }
786
787 float (*BKE_mask_spline_feather_differentiated_points(MaskSpline *spline, int *tot_feather_point))[2]
788 {
789         return BKE_mask_spline_feather_differentiated_points_with_resolution(spline, 0, 0, tot_feather_point);
790 }
791
792 float (*BKE_mask_spline_feather_points(MaskSpline *spline, int *tot_feather_point))[2]
793 {
794         MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
795
796         int i, tot = 0;
797         float (*feather)[2], (*fp)[2];
798
799         /* count */
800         for (i = 0; i < spline->tot_point; i++) {
801                 MaskSplinePoint *point = &points_array[i];
802
803                 tot += point->tot_uw + 1;
804         }
805
806         /* create data */
807         feather = fp = MEM_mallocN(tot * sizeof(*feather), "mask spline feather points");
808
809         for (i = 0; i < spline->tot_point; i++) {
810                 MaskSplinePoint *point = &points_array[i];
811                 BezTriple *bezt = &point->bezt;
812                 float weight, n[2];
813                 int j;
814
815                 BKE_mask_point_normal(spline, point, 0.0f, n);
816                 weight = BKE_mask_point_weight(spline, point, 0.0f);
817
818                 madd_v2_v2v2fl(*fp, bezt->vec[1], n, weight);
819                 fp++;
820
821                 for (j = 0; j < point->tot_uw; j++) {
822                         float u = point->uw[j].u;
823                         float co[2];
824
825                         BKE_mask_point_segment_co(spline, point, u, co);
826                         BKE_mask_point_normal(spline, point, u, n);
827                         weight = BKE_mask_point_weight(spline, point, u);
828
829                         madd_v2_v2v2fl(*fp, co, n, weight);
830                         fp++;
831                 }
832         }
833
834         *tot_feather_point = tot;
835
836         return feather;
837 }
838
839 void BKE_mask_point_direction_switch(MaskSplinePoint *point)
840 {
841         const int tot_uw = point->tot_uw;
842         const int tot_uw_half = tot_uw / 2;
843         int i;
844
845         float co_tmp[2];
846
847         /* swap handles */
848         copy_v2_v2(co_tmp, point->bezt.vec[0]);
849         copy_v2_v2(point->bezt.vec[0], point->bezt.vec[2]);
850         copy_v2_v2(point->bezt.vec[2], co_tmp);
851         /* in this case the flags are unlikely to be different but swap anyway */
852         SWAP(char, point->bezt.f1, point->bezt.f3);
853         SWAP(char, point->bezt.h1, point->bezt.h2);
854
855
856         /* swap UW's */
857         if (tot_uw > 1) {
858                 /* count */
859                 for (i = 0; i < tot_uw_half; i++) {
860                         MaskSplinePointUW *uw_a = &point->uw[i];
861                         MaskSplinePointUW *uw_b = &point->uw[tot_uw - (i + 1)];
862                         SWAP(MaskSplinePointUW, *uw_a, *uw_b);
863                 }
864         }
865
866         for (i = 0; i < tot_uw; i++) {
867                 MaskSplinePointUW *uw = &point->uw[i];
868                 uw->u = 1.0f - uw->u;
869         }
870 }
871
872 void BKE_mask_spline_direction_switch(MaskLayer *masklay, MaskSpline *spline)
873 {
874         const int tot_point = spline->tot_point;
875         const int tot_point_half = tot_point / 2;
876         int i, i_prev;
877
878         if (tot_point < 2) {
879                 return;
880         }
881
882         /* count */
883         for (i = 0; i < tot_point_half; i++) {
884                 MaskSplinePoint *point_a = &spline->points[i];
885                 MaskSplinePoint *point_b = &spline->points[tot_point - (i + 1)];
886                 SWAP(MaskSplinePoint, *point_a, *point_b);
887         }
888
889         /* correct UW's */
890         i_prev = tot_point - 1;
891         for (i = 0; i < tot_point; i++) {
892
893                 BKE_mask_point_direction_switch(&spline->points[i]);
894
895                 SWAP(MaskSplinePointUW *, spline->points[i].uw,     spline->points[i_prev].uw);
896                 SWAP(int,                 spline->points[i].tot_uw, spline->points[i_prev].tot_uw);
897
898                 i_prev = i;
899         }
900
901         /* correct animation */
902         if (masklay->splines_shapes.first) {
903                 MaskLayerShape *masklay_shape;
904
905                 const int spline_index = BKE_mask_layer_shape_spline_to_index(masklay, spline);
906
907                 for (masklay_shape = masklay->splines_shapes.first;
908                      masklay_shape;
909                      masklay_shape = masklay_shape->next)
910                 {
911                         MaskLayerShapeElem *fp_arr = (MaskLayerShapeElem *)masklay_shape->data;
912
913                         for (i = 0; i < tot_point_half; i++) {
914                                 MaskLayerShapeElem *fp_a = &fp_arr[spline_index +              (i)     ];
915                                 MaskLayerShapeElem *fp_b = &fp_arr[spline_index + (tot_point - (i + 1))];
916                                 SWAP(MaskLayerShapeElem, *fp_a, *fp_b);
917                         }
918                 }
919         }
920 }
921
922
923 float BKE_mask_spline_project_co(MaskSpline *spline, MaskSplinePoint *point,
924                                  float start_u, const float co[2], const eMaskSign sign)
925 {
926         const float proj_eps         = 1e-3;
927         const float proj_eps_squared = proj_eps * proj_eps;
928         const int N = 1000;
929         float u = -1.0f, du = 1.0f / N, u1 = start_u, u2 = start_u;
930         float ang = -1.0f;
931
932         BLI_assert(ABS(sign) <= 1); /* (-1, 0, 1) */
933
934         while (u1 > 0.0f || u2 < 1.0f) {
935                 float n1[2], n2[2], co1[2], co2[2];
936                 float v1[2], v2[2];
937                 float ang1, ang2;
938
939                 if (u1 >= 0.0f) {
940                         BKE_mask_point_segment_co(spline, point, u1, co1);
941                         BKE_mask_point_normal(spline, point, u1, n1);
942                         sub_v2_v2v2(v1, co, co1);
943
944                         if ((sign == MASK_PROJ_ANY) ||
945                             ((sign == MASK_PROJ_NEG) && (dot_v2v2(v1, n1) <= 0.0f)) ||
946                             ((sign == MASK_PROJ_POS) && (dot_v2v2(v1, n1) >= 0.0f)))
947                         {
948
949                                 if (len_squared_v2(v1) > proj_eps_squared) {
950                                         ang1 = angle_v2v2(v1, n1);
951                                         if (ang1 > M_PI / 2.0f)
952                                                 ang1 = M_PI  - ang1;
953
954                                         if (ang < 0.0f || ang1 < ang) {
955                                                 ang = ang1;
956                                                 u = u1;
957                                         }
958                                 }
959                                 else {
960                                         u = u1;
961                                         break;
962                                 }
963                         }
964                 }
965
966                 if (u2 <= 1.0f) {
967                         BKE_mask_point_segment_co(spline, point, u2, co2);
968                         BKE_mask_point_normal(spline, point, u2, n2);
969                         sub_v2_v2v2(v2, co, co2);
970
971                         if ((sign == MASK_PROJ_ANY) ||
972                             ((sign == MASK_PROJ_NEG) && (dot_v2v2(v2, n2) <= 0.0f)) ||
973                             ((sign == MASK_PROJ_POS) && (dot_v2v2(v2, n2) >= 0.0f)))
974                         {
975
976                                 if (len_squared_v2(v2) > proj_eps_squared) {
977                                         ang2 = angle_v2v2(v2, n2);
978                                         if (ang2 > M_PI / 2.0f)
979                                                 ang2 = M_PI  - ang2;
980
981                                         if (ang2 < ang) {
982                                                 ang = ang2;
983                                                 u = u2;
984                                         }
985                                 }
986                                 else {
987                                         u = u2;
988                                         break;
989                                 }
990                         }
991                 }
992
993                 u1 -= du;
994                 u2 += du;
995         }
996
997         return u;
998 }
999
1000 /* point */
1001
1002 int BKE_mask_point_has_handle(MaskSplinePoint *point)
1003 {
1004         BezTriple *bezt = &point->bezt;
1005
1006         return bezt->h1 == HD_ALIGN;
1007 }
1008
1009 void BKE_mask_point_handle(MaskSplinePoint *point, float handle[2])
1010 {
1011         float vec[2];
1012
1013         sub_v2_v2v2(vec, point->bezt.vec[0], point->bezt.vec[1]);
1014
1015         handle[0] = (point->bezt.vec[1][0] + vec[1]);
1016         handle[1] = (point->bezt.vec[1][1] - vec[0]);
1017 }
1018
1019 void BKE_mask_point_set_handle(MaskSplinePoint *point, float loc[2], int keep_direction,
1020                                float orig_handle[2], float orig_vec[3][3])
1021 {
1022         BezTriple *bezt = &point->bezt;
1023         float v1[2], v2[2], vec[2];
1024
1025         if (keep_direction) {
1026                 sub_v2_v2v2(v1, loc, orig_vec[1]);
1027                 sub_v2_v2v2(v2, orig_handle, orig_vec[1]);
1028
1029                 project_v2_v2v2(vec, v1, v2);
1030
1031                 if (dot_v2v2(v2, vec) > 0) {
1032                         float len = len_v2(vec);
1033
1034                         sub_v2_v2v2(v1, orig_vec[0], orig_vec[1]);
1035
1036                         mul_v2_fl(v1, len / len_v2(v1));
1037
1038                         add_v2_v2v2(bezt->vec[0], bezt->vec[1], v1);
1039                         sub_v2_v2v2(bezt->vec[2], bezt->vec[1], v1);
1040                 }
1041                 else {
1042                         copy_v3_v3(bezt->vec[0], bezt->vec[1]);
1043                         copy_v3_v3(bezt->vec[2], bezt->vec[1]);
1044                 }
1045         }
1046         else {
1047                 sub_v2_v2v2(v1, loc, bezt->vec[1]);
1048
1049                 v2[0] = -v1[1];
1050                 v2[1] =  v1[0];
1051
1052                 add_v2_v2v2(bezt->vec[0], bezt->vec[1], v2);
1053                 sub_v2_v2v2(bezt->vec[2], bezt->vec[1], v2);
1054         }
1055 }
1056
1057 float *BKE_mask_point_segment_feather_diff_with_resolution(MaskSpline *spline, MaskSplinePoint *point,
1058                                                            int width, int height,
1059                                                            int *tot_feather_point)
1060 {
1061         float *feather, *fp;
1062         int i, resol = BKE_mask_spline_feather_resolution(spline, width, height);
1063
1064         feather = fp = MEM_callocN(2 * resol * sizeof(float), "mask point spline feather diff points");
1065
1066         for (i = 0; i < resol; i++, fp += 2) {
1067                 float u = (float)(i % resol) / resol, weight;
1068                 float co[2], n[2];
1069
1070                 BKE_mask_point_segment_co(spline, point, u, co);
1071                 BKE_mask_point_normal(spline, point, u, n);
1072                 weight = BKE_mask_point_weight(spline, point, u);
1073
1074                 fp[0] = co[0] + n[0] * weight;
1075                 fp[1] = co[1] + n[1] * weight;
1076         }
1077
1078         *tot_feather_point = resol;
1079
1080         return feather;
1081 }
1082
1083 float *BKE_mask_point_segment_feather_diff(MaskSpline *spline, MaskSplinePoint *point, int *tot_feather_point)
1084 {
1085         return BKE_mask_point_segment_feather_diff_with_resolution(spline, point, 0, 0, tot_feather_point);
1086 }
1087
1088 float *BKE_mask_point_segment_diff_with_resolution(MaskSpline *spline, MaskSplinePoint *point,
1089                                                    int width, int height, int *tot_diff_point)
1090 {
1091         MaskSplinePoint *points_array = BKE_mask_spline_point_array_from_point(spline, point);
1092
1093         BezTriple *bezt, *bezt_next;
1094         float *diff_points, *fp;
1095         int j, resol = BKE_mask_spline_resolution(spline, width, height);
1096
1097         bezt = &point->bezt;
1098         bezt_next = mask_spline_point_next_bezt(spline, points_array, point);
1099
1100         if (!bezt_next)
1101                 return NULL;
1102
1103         /* resol+1 because of 'forward_diff_bezier' function */
1104         *tot_diff_point = resol + 1;
1105         diff_points = fp = MEM_callocN((resol + 1) * 2 * sizeof(float), "mask segment vets");
1106
1107         for (j = 0; j < 2; j++) {
1108                 BKE_curve_forward_diff_bezier(bezt->vec[1][j], bezt->vec[2][j],
1109                                               bezt_next->vec[0][j], bezt_next->vec[1][j],
1110                                               fp + j, resol, 2 * sizeof(float));
1111         }
1112
1113         copy_v2_v2(fp + 2 * resol, bezt_next->vec[1]);
1114
1115         return diff_points;
1116 }
1117
1118 float *BKE_mask_point_segment_diff(MaskSpline *spline, MaskSplinePoint *point, int *tot_diff_point)
1119 {
1120         return BKE_mask_point_segment_diff_with_resolution(spline, point, 0, 0, tot_diff_point);
1121 }
1122
1123 void BKE_mask_point_segment_co(MaskSpline *spline, MaskSplinePoint *point, float u, float co[2])
1124 {
1125         MaskSplinePoint *points_array = BKE_mask_spline_point_array_from_point(spline, point);
1126
1127         BezTriple *bezt = &point->bezt, *bezt_next;
1128         float q0[2], q1[2], q2[2], r0[2], r1[2];
1129
1130         bezt_next = mask_spline_point_next_bezt(spline, points_array, point);
1131
1132         if (!bezt_next) {
1133                 copy_v2_v2(co, bezt->vec[1]);
1134                 return;
1135         }
1136
1137         interp_v2_v2v2(q0, bezt->vec[1], bezt->vec[2], u);
1138         interp_v2_v2v2(q1, bezt->vec[2], bezt_next->vec[0], u);
1139         interp_v2_v2v2(q2, bezt_next->vec[0], bezt_next->vec[1], u);
1140
1141         interp_v2_v2v2(r0, q0, q1, u);
1142         interp_v2_v2v2(r1, q1, q2, u);
1143
1144         interp_v2_v2v2(co, r0, r1, u);
1145 }
1146
1147 void BKE_mask_point_normal(MaskSpline *spline, MaskSplinePoint *point, float u, float n[2])
1148 {
1149         MaskSplinePoint *points_array = BKE_mask_spline_point_array_from_point(spline, point);
1150
1151         BezTriple *bezt = &point->bezt, *bezt_next;
1152         float q0[2], q1[2], q2[2], r0[2], r1[2], vec[2];
1153
1154         bezt_next = mask_spline_point_next_bezt(spline, points_array, point);
1155
1156         if (!bezt_next) {
1157                 BKE_mask_point_handle(point, vec);
1158
1159                 sub_v2_v2v2(n, vec, bezt->vec[1]);
1160                 normalize_v2(n);
1161                 return;
1162         }
1163
1164         interp_v2_v2v2(q0, bezt->vec[1], bezt->vec[2], u);
1165         interp_v2_v2v2(q1, bezt->vec[2], bezt_next->vec[0], u);
1166         interp_v2_v2v2(q2, bezt_next->vec[0], bezt_next->vec[1], u);
1167
1168         interp_v2_v2v2(r0, q0, q1, u);
1169         interp_v2_v2v2(r1, q1, q2, u);
1170
1171         sub_v2_v2v2(vec, r1, r0);
1172
1173         n[0] = -vec[1];
1174         n[1] =  vec[0];
1175
1176         normalize_v2(n);
1177 }
1178
1179 static float mask_point_interp_weight(BezTriple *bezt, BezTriple *bezt_next, const float u)
1180 {
1181         return (bezt->weight * (1.0f - u)) + (bezt_next->weight * u);
1182 }
1183
1184 float BKE_mask_point_weight_scalar(MaskSpline *spline, MaskSplinePoint *point, const float u)
1185 {
1186         MaskSplinePoint *points_array = BKE_mask_spline_point_array_from_point(spline, point);
1187         BezTriple *bezt = &point->bezt, *bezt_next;
1188
1189         bezt_next = mask_spline_point_next_bezt(spline, points_array, point);
1190
1191         if (!bezt_next) {
1192                 return bezt->weight;
1193         }
1194         else if (u <= 0.0) {
1195                 return bezt->weight;
1196         }
1197         else if (u >= 1.0f) {
1198                 return bezt_next->weight;
1199         }
1200         else {
1201                 return mask_point_interp_weight(bezt, bezt_next, u);
1202         }
1203 }
1204
1205 float BKE_mask_point_weight(MaskSpline *spline, MaskSplinePoint *point, const float u)
1206 {
1207         MaskSplinePoint *points_array = BKE_mask_spline_point_array_from_point(spline, point);
1208         BezTriple *bezt = &point->bezt, *bezt_next;
1209
1210         bezt_next = mask_spline_point_next_bezt(spline, points_array, point);
1211
1212         if (!bezt_next) {
1213                 return bezt->weight;
1214         }
1215         else if (u <= 0.0) {
1216                 return bezt->weight;
1217         }
1218         else if (u >= 1.0f) {
1219                 return bezt_next->weight;
1220         }
1221         else {
1222                 float cur_u = 0.0f, cur_w = 0.0f, next_u = 0.0f, next_w = 0.0f, fac; /* Quite warnings */
1223                 int i;
1224
1225                 for (i = 0; i < point->tot_uw + 1; i++) {
1226
1227                         if (i == 0) {
1228                                 cur_u = 0.0f;
1229                                 cur_w = 1.0f; /* mask_point_interp_weight will scale it */
1230                         }
1231                         else {
1232                                 cur_u = point->uw[i - 1].u;
1233                                 cur_w = point->uw[i - 1].w;
1234                         }
1235
1236                         if (i == point->tot_uw) {
1237                                 next_u = 1.0f;
1238                                 next_w = 1.0f; /* mask_point_interp_weight will scale it */
1239                         }
1240                         else {
1241                                 next_u = point->uw[i].u;
1242                                 next_w = point->uw[i].w;
1243                         }
1244
1245                         if (u >= cur_u && u <= next_u) {
1246                                 break;
1247                         }
1248                 }
1249
1250                 fac = (u - cur_u) / (next_u - cur_u);
1251
1252                 cur_w  *= mask_point_interp_weight(bezt, bezt_next, cur_u);
1253                 next_w *= mask_point_interp_weight(bezt, bezt_next, next_u);
1254
1255                 if (spline->weight_interp == MASK_SPLINE_INTERP_EASE) {
1256                         return cur_w + (next_w - cur_w) * (3.0f * fac * fac - 2.0f * fac * fac * fac);
1257                 }
1258                 else {
1259                         return (1.0f - fac) * cur_w + fac * next_w;
1260                 }
1261         }
1262 }
1263
1264 MaskSplinePointUW *BKE_mask_point_sort_uw(MaskSplinePoint *point, MaskSplinePointUW *uw)
1265 {
1266         if (point->tot_uw > 1) {
1267                 int idx = uw - point->uw;
1268
1269                 if (idx > 0 && point->uw[idx - 1].u > uw->u) {
1270                         while (idx > 0 && point->uw[idx - 1].u > point->uw[idx].u) {
1271                                 SWAP(MaskSplinePointUW, point->uw[idx - 1], point->uw[idx]);
1272                                 idx--;
1273                         }
1274                 }
1275
1276                 if (idx < point->tot_uw - 1 && point->uw[idx + 1].u < uw->u) {
1277                         while (idx < point->tot_uw - 1 && point->uw[idx + 1].u < point->uw[idx].u) {
1278                                 SWAP(MaskSplinePointUW, point->uw[idx + 1], point->uw[idx]);
1279                                 idx++;
1280                         }
1281                 }
1282
1283                 return &point->uw[idx];
1284         }
1285
1286         return uw;
1287 }
1288
1289 void BKE_mask_point_add_uw(MaskSplinePoint *point, float u, float w)
1290 {
1291         if (!point->uw)
1292                 point->uw = MEM_callocN(sizeof(*point->uw), "mask point uw");
1293         else
1294                 point->uw = MEM_reallocN(point->uw, (point->tot_uw + 1) * sizeof(*point->uw));
1295
1296         point->uw[point->tot_uw].u = u;
1297         point->uw[point->tot_uw].w = w;
1298
1299         point->tot_uw++;
1300
1301         BKE_mask_point_sort_uw(point, &point->uw[point->tot_uw - 1]);
1302 }
1303
1304 void BKE_mask_point_select_set(MaskSplinePoint *point, const short do_select)
1305 {
1306         int i;
1307
1308         if (do_select) {
1309                 MASKPOINT_SEL_ALL(point);
1310         }
1311         else {
1312                 MASKPOINT_DESEL_ALL(point);
1313         }
1314
1315         for (i = 0; i < point->tot_uw; i++) {
1316                 if (do_select) {
1317                         point->uw[i].flag |= SELECT;
1318                 }
1319                 else {
1320                         point->uw[i].flag &= ~SELECT;
1321                 }
1322         }
1323 }
1324
1325 void BKE_mask_point_select_set_handle(MaskSplinePoint *point, const short do_select)
1326 {
1327         if (do_select) {
1328                 MASKPOINT_SEL_HANDLE(point);
1329         }
1330         else {
1331                 MASKPOINT_DESEL_HANDLE(point);
1332         }
1333 }
1334
1335 /* only mask block itself */
1336 static Mask *mask_alloc(const char *name)
1337 {
1338         Mask *mask;
1339
1340         mask = BKE_libblock_alloc(&G.main->mask, ID_MSK, name);
1341
1342         return mask;
1343 }
1344
1345 Mask *BKE_mask_new(const char *name)
1346 {
1347         Mask *mask;
1348         char mask_name[MAX_ID_NAME - 2];
1349
1350         if (name && name[0])
1351                 BLI_strncpy(mask_name, name, sizeof(mask_name));
1352         else
1353                 strcpy(mask_name, "Mask");
1354
1355         mask = mask_alloc(mask_name);
1356
1357         /* arbitrary defaults */
1358         mask->sfra = 1;
1359         mask->efra = 100;
1360
1361         return mask;
1362 }
1363
1364 Mask *BKE_mask_copy_nolib(Mask *mask)
1365 {
1366         Mask *mask_new;
1367
1368         mask_new = MEM_dupallocN(mask);
1369
1370         /*take care here! - we may want to copy anim data  */
1371         mask_new->adt = NULL;
1372
1373         mask_new->masklayers.first = NULL;
1374         mask_new->masklayers.last = NULL;
1375
1376         BKE_mask_layer_copy_list(&mask_new->masklayers, &mask->masklayers);
1377
1378         /* enable fake user by default */
1379         if (!(mask_new->id.flag & LIB_FAKEUSER)) {
1380                 mask_new->id.flag |= LIB_FAKEUSER;
1381                 mask_new->id.us++;
1382         }
1383
1384         return mask_new;
1385 }
1386
1387 Mask *BKE_mask_copy(Mask *mask)
1388 {
1389         Mask *mask_new;
1390
1391         mask_new = BKE_libblock_copy(&mask->id);
1392
1393         mask_new->masklayers.first = NULL;
1394         mask_new->masklayers.last = NULL;
1395
1396         BKE_mask_layer_copy_list(&mask_new->masklayers, &mask->masklayers);
1397
1398         /* enable fake user by default */
1399         if (!(mask_new->id.flag & LIB_FAKEUSER)) {
1400                 mask_new->id.flag |= LIB_FAKEUSER;
1401                 mask_new->id.us++;
1402         }
1403
1404         return mask_new;
1405 }
1406
1407 void BKE_mask_point_free(MaskSplinePoint *point)
1408 {
1409         if (point->uw)
1410                 MEM_freeN(point->uw);
1411 }
1412
1413 void BKE_mask_spline_free(MaskSpline *spline)
1414 {
1415         int i = 0;
1416
1417         for (i = 0; i < spline->tot_point; i++) {
1418                 MaskSplinePoint *point;
1419                 point = &spline->points[i];
1420                 BKE_mask_point_free(point);
1421
1422                 if (spline->points_deform) {
1423                         point = &spline->points_deform[i];
1424                         BKE_mask_point_free(point);
1425                 }
1426         }
1427
1428         MEM_freeN(spline->points);
1429
1430         if (spline->points_deform) {
1431                 MEM_freeN(spline->points_deform);
1432         }
1433
1434         MEM_freeN(spline);
1435 }
1436
1437 static MaskSplinePoint *mask_spline_points_copy(MaskSplinePoint *points, int tot_point)
1438 {
1439         MaskSplinePoint *npoints;
1440         int i;
1441
1442         npoints = MEM_dupallocN(points);
1443
1444         for (i = 0; i < tot_point; i++) {
1445                 MaskSplinePoint *point = &npoints[i];
1446
1447                 if (point->uw)
1448                         point->uw = MEM_dupallocN(point->uw);
1449         }
1450
1451         return npoints;
1452 }
1453
1454 MaskSpline *BKE_mask_spline_copy(MaskSpline *spline)
1455 {
1456         MaskSpline *nspline = MEM_callocN(sizeof(MaskSpline), "new spline");
1457
1458         *nspline = *spline;
1459
1460         nspline->points_deform = NULL;
1461         nspline->points = mask_spline_points_copy(spline->points, spline->tot_point);
1462
1463         if (spline->points_deform) {
1464                 nspline->points_deform = mask_spline_points_copy(spline->points_deform, spline->tot_point);
1465         }
1466
1467         return nspline;
1468 }
1469
1470 /* note: does NOT add to the list */
1471 MaskLayerShape *BKE_mask_layer_shape_alloc(MaskLayer *masklay, const int frame)
1472 {
1473         MaskLayerShape *masklay_shape;
1474         int tot_vert = BKE_mask_layer_shape_totvert(masklay);
1475
1476         masklay_shape = MEM_mallocN(sizeof(MaskLayerShape), __func__);
1477         masklay_shape->frame = frame;
1478         masklay_shape->tot_vert = tot_vert;
1479         masklay_shape->data = MEM_mallocN(tot_vert * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE, __func__);
1480
1481         return masklay_shape;
1482 }
1483
1484 void BKE_mask_layer_shape_free(MaskLayerShape *masklay_shape)
1485 {
1486         MEM_freeN(masklay_shape->data);
1487
1488         MEM_freeN(masklay_shape);
1489 }
1490
1491 /** \brief Free all animation keys for a mask layer
1492  */
1493 void BKE_mask_layer_free_shapes(MaskLayer *masklay)
1494 {
1495         MaskLayerShape *masklay_shape;
1496
1497         /* free animation data */
1498         masklay_shape = masklay->splines_shapes.first;
1499         while (masklay_shape) {
1500                 MaskLayerShape *next_masklay_shape = masklay_shape->next;
1501
1502                 BLI_remlink(&masklay->splines_shapes, masklay_shape);
1503                 BKE_mask_layer_shape_free(masklay_shape);
1504
1505                 masklay_shape = next_masklay_shape;
1506         }
1507 }
1508
1509 void BKE_mask_layer_free(MaskLayer *masklay)
1510 {
1511         MaskSpline *spline;
1512
1513         /* free splines */
1514         spline = masklay->splines.first;
1515         while (spline) {
1516                 MaskSpline *next_spline = spline->next;
1517
1518                 BLI_remlink(&masklay->splines, spline);
1519                 BKE_mask_spline_free(spline);
1520
1521                 spline = next_spline;
1522         }
1523
1524         /* free animation data */
1525         BKE_mask_layer_free_shapes(masklay);
1526
1527         MEM_freeN(masklay);
1528 }
1529
1530 void BKE_mask_layer_free_list(ListBase *masklayers)
1531 {
1532         MaskLayer *masklay = masklayers->first;
1533
1534         while (masklay) {
1535                 MaskLayer *masklay_next = masklay->next;
1536
1537                 BLI_remlink(masklayers, masklay);
1538                 BKE_mask_layer_free(masklay);
1539
1540                 masklay = masklay_next;
1541         }
1542 }
1543
1544 void BKE_mask_free(Mask *mask)
1545 {
1546         BKE_mask_layer_free_list(&mask->masklayers);
1547 }
1548
1549 void BKE_mask_unlink(Main *bmain, Mask *mask)
1550 {
1551         bScreen *scr;
1552         ScrArea *area;
1553         SpaceLink *sl;
1554
1555         for (scr = bmain->screen.first; scr; scr = scr->id.next) {
1556                 for (area = scr->areabase.first; area; area = area->next) {
1557                         for (sl = area->spacedata.first; sl; sl = sl->next) {
1558                                 if (sl->spacetype == SPACE_CLIP) {
1559                                         SpaceClip *sc = (SpaceClip *) sl;
1560
1561                                         if (sc->mask_info.mask == mask)
1562                                                 sc->mask_info.mask = NULL;
1563                                 }
1564                         }
1565                 }
1566         }
1567
1568         mask->id.us = 0;
1569 }
1570
1571 void BKE_mask_coord_from_frame(float r_co[2], const float co[2], const float frame_size[2])
1572 {
1573         if (frame_size[0] == frame_size[1]) {
1574                 r_co[0] = co[0];
1575                 r_co[1] = co[1];
1576         }
1577         else if (frame_size[0] < frame_size[1]) {
1578                 r_co[0] = ((co[0] - 0.5f) * (frame_size[0] / frame_size[1])) + 0.5f;
1579                 r_co[1] = co[1];
1580         }
1581         else { /* (frame_size[0] > frame_size[1]) */
1582                 r_co[0] = co[0];
1583                 r_co[1] = ((co[1] - 0.5f) * (frame_size[1] / frame_size[0])) + 0.5f;
1584         }
1585 }
1586 void BKE_mask_coord_from_movieclip(MovieClip *clip, MovieClipUser *user, float r_co[2], const float co[2])
1587 {
1588         int width, height;
1589         float frame_size[2];
1590
1591         /* scaling for the clip */
1592         BKE_movieclip_get_size(clip, user, &width, &height);
1593
1594         frame_size[0] = (float)width;
1595         frame_size[1] = (float)height;
1596
1597         BKE_mask_coord_from_frame(r_co, co, frame_size);
1598 }
1599
1600 /* as above but divide */
1601 void BKE_mask_coord_to_frame(float r_co[2], const float co[2], const float frame_size[2])
1602 {
1603         if (frame_size[0] == frame_size[1]) {
1604                 r_co[0] = co[0];
1605                 r_co[1] = co[1];
1606         }
1607         else if (frame_size[0] < frame_size[1]) {
1608                 r_co[0] = ((co[0] - 0.5f) / (frame_size[0] / frame_size[1])) + 0.5f;
1609                 r_co[1] = co[1];
1610         }
1611         else { /* (frame_size[0] > frame_size[1]) */
1612                 r_co[0] = co[0];
1613                 r_co[1] = ((co[1] - 0.5f) / (frame_size[1] / frame_size[0])) + 0.5f;
1614         }
1615 }
1616 void BKE_mask_coord_to_movieclip(MovieClip *clip, MovieClipUser *user, float r_co[2], const float co[2])
1617 {
1618         int width, height;
1619         float frame_size[2];
1620
1621         /* scaling for the clip */
1622         BKE_movieclip_get_size(clip, user, &width, &height);
1623
1624         frame_size[0] = (float)width;
1625         frame_size[1] = (float)height;
1626
1627         BKE_mask_coord_to_frame(r_co, co, frame_size);
1628 }
1629
1630 static int BKE_mask_evaluate_parent(MaskParent *parent, float ctime, float r_co[2])
1631 {
1632         if (!parent)
1633                 return FALSE;
1634
1635         if (parent->id_type == ID_MC) {
1636                 if (parent->id) {
1637                         MovieClip *clip = (MovieClip *) parent->id;
1638                         MovieTracking *tracking = (MovieTracking *) &clip->tracking;
1639                         MovieTrackingObject *ob = BKE_tracking_object_get_named(tracking, parent->parent);
1640
1641                         if (ob) {
1642                                 MovieTrackingTrack *track = BKE_tracking_track_get_named(tracking, ob, parent->sub_parent);
1643                                 float clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, ctime);
1644
1645                                 MovieClipUser user = {0};
1646                                 user.framenr = ctime;
1647
1648                                 if (track) {
1649                                         float marker_pos_ofs[2];
1650                                         BKE_tracking_marker_get_subframe_position(track, clip_framenr, marker_pos_ofs);
1651                                         BKE_mask_coord_from_movieclip(clip, &user, r_co, marker_pos_ofs);
1652
1653                                         return TRUE;
1654                                 }
1655                         }
1656                 }
1657         }
1658
1659         return FALSE;
1660 }
1661
1662 int BKE_mask_evaluate_parent_delta(MaskParent *parent, float ctime, float r_delta[2])
1663 {
1664         float parent_co[2];
1665
1666         if (BKE_mask_evaluate_parent(parent, ctime, parent_co)) {
1667                 sub_v2_v2v2(r_delta, parent_co, parent->parent_orig);
1668                 return TRUE;
1669         }
1670         else {
1671                 return FALSE;
1672         }
1673 }
1674
1675 static void mask_calc_point_handle(MaskSplinePoint *point, MaskSplinePoint *point_prev, MaskSplinePoint *point_next)
1676 {
1677         BezTriple *bezt = &point->bezt;
1678         BezTriple *bezt_prev = NULL, *bezt_next = NULL;
1679         //int handle_type = bezt->h1;
1680
1681         if (point_prev)
1682                 bezt_prev = &point_prev->bezt;
1683
1684         if (point_next)
1685                 bezt_next = &point_next->bezt;
1686
1687 #if 1
1688         if (bezt_prev || bezt_next) {
1689                 BKE_nurb_handle_calc(bezt, bezt_prev, bezt_next, 0);
1690         }
1691 #else
1692         if (handle_type == HD_VECT) {
1693                 BKE_nurb_handle_calc(bezt, bezt_prev, bezt_next, 0);
1694         }
1695         else if (handle_type == HD_AUTO) {
1696                 BKE_nurb_handle_calc(bezt, bezt_prev, bezt_next, 0);
1697         }
1698         else if (handle_type == HD_ALIGN) {
1699                 float v1[3], v2[3];
1700                 float vec[3], h[3];
1701
1702                 sub_v3_v3v3(v1, bezt->vec[0], bezt->vec[1]);
1703                 sub_v3_v3v3(v2, bezt->vec[2], bezt->vec[1]);
1704                 add_v3_v3v3(vec, v1, v2);
1705
1706                 if (len_v3(vec) > 1e-3) {
1707                         h[0] = vec[1];
1708                         h[1] = -vec[0];
1709                         h[2] = 0.0f;
1710                 }
1711                 else {
1712                         copy_v3_v3(h, v1);
1713                 }
1714
1715                 add_v3_v3v3(bezt->vec[0], bezt->vec[1], h);
1716                 sub_v3_v3v3(bezt->vec[2], bezt->vec[1], h);
1717         }
1718 #endif
1719 }
1720
1721 void BKE_mask_get_handle_point_adjacent(MaskSpline *spline, MaskSplinePoint *point,
1722                                         MaskSplinePoint **r_point_prev, MaskSplinePoint **r_point_next)
1723 {
1724         /* TODO, could avoid calling this at such low level */
1725         MaskSplinePoint *points_array = BKE_mask_spline_point_array_from_point(spline, point);
1726
1727         *r_point_prev = mask_spline_point_prev(spline, points_array, point);
1728         *r_point_next = mask_spline_point_next(spline, points_array, point);
1729 }
1730
1731 /* calculates the tanget of a point by its previous and next
1732  * (ignoring handles - as if its a poly line) */
1733 void BKE_mask_calc_tangent_polyline(MaskSpline *spline, MaskSplinePoint *point, float t[2])
1734 {
1735         float tvec_a[2], tvec_b[2];
1736
1737         MaskSplinePoint *point_prev, *point_next;
1738
1739         BKE_mask_get_handle_point_adjacent(spline, point,
1740                                            &point_prev, &point_next);
1741
1742         if (point_prev) {
1743                 sub_v2_v2v2(tvec_a, point->bezt.vec[1], point_prev->bezt.vec[1]);
1744                 normalize_v2(tvec_a);
1745         }
1746         else {
1747                 zero_v2(tvec_a);
1748         }
1749
1750         if (point_next) {
1751                 sub_v2_v2v2(tvec_b, point_next->bezt.vec[1], point->bezt.vec[1]);
1752                 normalize_v2(tvec_b);
1753         }
1754         else {
1755                 zero_v2(tvec_b);
1756         }
1757
1758         add_v2_v2v2(t, tvec_a, tvec_b);
1759         normalize_v2(t);
1760 }
1761
1762 void BKE_mask_calc_handle_point(MaskSpline *spline, MaskSplinePoint *point)
1763 {
1764         MaskSplinePoint *point_prev, *point_next;
1765
1766         BKE_mask_get_handle_point_adjacent(spline, point,
1767                                            &point_prev, &point_next);
1768
1769         mask_calc_point_handle(point, point_prev, point_next);
1770 }
1771
1772 static void enforce_dist_v2_v2fl(float v1[2], const float v2[2], const float dist)
1773 {
1774         if (!equals_v2v2(v2, v1)) {
1775                 float nor[2];
1776
1777                 sub_v2_v2v2(nor, v1, v2);
1778                 normalize_v2(nor);
1779                 madd_v2_v2v2fl(v1, v2, nor, dist);
1780         }
1781 }
1782
1783 void BKE_mask_calc_handle_adjacent_interp(MaskSpline *spline, MaskSplinePoint *point, const float u)
1784 {
1785         /* TODO! - make this interpolate between siblings - not always midpoint! */
1786         int length_tot = 0;
1787         float length_average = 0.0f;
1788         float weight_average = 0.0f;
1789
1790
1791         MaskSplinePoint *point_prev, *point_next;
1792
1793         BLI_assert(u >= 0.0f && u <= 1.0f);
1794
1795         BKE_mask_get_handle_point_adjacent(spline, point,
1796                                            &point_prev, &point_next);
1797
1798         if (point_prev && point_next) {
1799                 length_average = ((len_v2v2(point_prev->bezt.vec[0], point_prev->bezt.vec[1]) * (1.0f - u)) +
1800                                   (len_v2v2(point_next->bezt.vec[2], point_next->bezt.vec[1]) * u));
1801
1802                 weight_average = (point_prev->bezt.weight * (1.0f - u) +
1803                                   point_next->bezt.weight * u);
1804                 length_tot = 1;
1805         }
1806         else {
1807                 if (point_prev) {
1808                         length_average += len_v2v2(point_prev->bezt.vec[0], point_prev->bezt.vec[1]);
1809                         weight_average += point_prev->bezt.weight;
1810                         length_tot++;
1811                 }
1812
1813                 if (point_next) {
1814                         length_average += len_v2v2(point_next->bezt.vec[2], point_next->bezt.vec[1]);
1815                         weight_average += point_next->bezt.weight;
1816                         length_tot++;
1817                 }
1818         }
1819
1820         if (length_tot) {
1821                 length_average /= (float)length_tot;
1822                 weight_average /= (float)length_tot;
1823
1824                 enforce_dist_v2_v2fl(point->bezt.vec[0], point->bezt.vec[1], length_average);
1825                 enforce_dist_v2_v2fl(point->bezt.vec[2], point->bezt.vec[1], length_average);
1826                 point->bezt.weight = weight_average;
1827         }
1828 }
1829
1830
1831 /**
1832  * \brief Resets auto handles even for non-auto bezier points
1833  *
1834  * Useful for giving sane defaults.
1835  */
1836 void BKE_mask_calc_handle_point_auto(MaskSpline *spline, MaskSplinePoint *point,
1837                                      const short do_recalc_length)
1838 {
1839         MaskSplinePoint *point_prev, *point_next;
1840         const char h_back[2] = {point->bezt.h1, point->bezt.h2};
1841         const float length_average = (do_recalc_length) ? 0.0f /* dummy value */ :
1842                                      (len_v3v3(point->bezt.vec[0], point->bezt.vec[1]) +
1843                                       len_v3v3(point->bezt.vec[1], point->bezt.vec[2])) / 2.0f;
1844
1845         BKE_mask_get_handle_point_adjacent(spline, point,
1846                                            &point_prev, &point_next);
1847
1848         point->bezt.h1 = HD_AUTO;
1849         point->bezt.h2 = HD_AUTO;
1850         mask_calc_point_handle(point, point_prev, point_next);
1851
1852         point->bezt.h1 = h_back[0];
1853         point->bezt.h2 = h_back[1];
1854
1855         /* preserve length by applying it back */
1856         if (do_recalc_length == FALSE) {
1857                 enforce_dist_v2_v2fl(point->bezt.vec[0], point->bezt.vec[1], length_average);
1858                 enforce_dist_v2_v2fl(point->bezt.vec[2], point->bezt.vec[1], length_average);
1859         }
1860 }
1861
1862 void BKE_mask_layer_calc_handles(MaskLayer *masklay)
1863 {
1864         MaskSpline *spline;
1865         for (spline = masklay->splines.first; spline; spline = spline->next) {
1866                 int i;
1867                 for (i = 0; i < spline->tot_point; i++) {
1868                         BKE_mask_calc_handle_point(spline, &spline->points[i]);
1869                 }
1870         }
1871 }
1872
1873 void BKE_mask_layer_calc_handles_deform(MaskLayer *masklay)
1874 {
1875         MaskSpline *spline;
1876         for (spline = masklay->splines.first; spline; spline = spline->next) {
1877                 int i;
1878                 for (i = 0; i < spline->tot_point; i++) {
1879                         BKE_mask_calc_handle_point(spline, &spline->points_deform[i]);
1880                 }
1881         }
1882 }
1883
1884 void BKE_mask_calc_handles(Mask *mask)
1885 {
1886         MaskLayer *masklay;
1887         for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
1888                 BKE_mask_layer_calc_handles(masklay);
1889         }
1890 }
1891
1892 void BKE_mask_update_deform(Mask *mask)
1893 {
1894         MaskLayer *masklay;
1895
1896         for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
1897                 MaskSpline *spline;
1898
1899                 for (spline = masklay->splines.first; spline; spline = spline->next) {
1900                         int i;
1901
1902                         for (i = 0; i < spline->tot_point; i++) {
1903                                 const int i_prev = (i - 1) % spline->tot_point;
1904                                 const int i_next = (i + 1) % spline->tot_point;
1905
1906                                 BezTriple *bezt_prev = &spline->points[i_prev].bezt;
1907                                 BezTriple *bezt      = &spline->points[i].bezt;
1908                                 BezTriple *bezt_next = &spline->points[i_next].bezt;
1909
1910                                 BezTriple *bezt_def_prev = &spline->points_deform[i_prev].bezt;
1911                                 BezTriple *bezt_def      = &spline->points_deform[i].bezt;
1912                                 BezTriple *bezt_def_next = &spline->points_deform[i_next].bezt;
1913
1914                                 float w_src[4];
1915                                 int j;
1916
1917                                 for (j = 0; j <= 2; j += 2) { /* (0, 2) */
1918                                         printf("--- %d %d, %d, %d\n", i, j, i_prev, i_next);
1919                                         barycentric_weights_v2(bezt_prev->vec[1], bezt->vec[1], bezt_next->vec[1],
1920                                                                bezt->vec[j], w_src);
1921                                         interp_v3_v3v3v3(bezt_def->vec[j],
1922                                                          bezt_def_prev->vec[1], bezt_def->vec[1], bezt_def_next->vec[1], w_src);
1923                                 }
1924                         }
1925                 }
1926         }
1927 }
1928
1929 void BKE_mask_spline_ensure_deform(MaskSpline *spline)
1930 {
1931         int allocated_points = (MEM_allocN_len(spline->points_deform) / sizeof(*spline->points_deform));
1932         // printf("SPLINE ALLOC %p %d\n", spline->points_deform, allocated_points);
1933
1934         if (spline->points_deform == NULL || allocated_points != spline->tot_point) {
1935                 // printf("alloc new deform spline\n");
1936
1937                 if (spline->points_deform) {
1938                         int i;
1939
1940                         for (i = 0; i < allocated_points; i++) {
1941                                 MaskSplinePoint *point = &spline->points_deform[i];
1942                                 BKE_mask_point_free(point);
1943                         }
1944
1945                         MEM_freeN(spline->points_deform);
1946                 }
1947
1948                 spline->points_deform = MEM_callocN(sizeof(*spline->points_deform) * spline->tot_point, __func__);
1949         }
1950         else {
1951                 // printf("alloc spline done\n");
1952         }
1953 }
1954
1955 void BKE_mask_layer_evaluate(MaskLayer *masklay, const float ctime, const int do_newframe)
1956 {
1957         /* animation if available */
1958         if (do_newframe) {
1959                 MaskLayerShape *masklay_shape_a;
1960                 MaskLayerShape *masklay_shape_b;
1961                 int found;
1962
1963                 if ((found = BKE_mask_layer_shape_find_frame_range(masklay, ctime,
1964                                                                    &masklay_shape_a, &masklay_shape_b)))
1965                 {
1966                         if (found == 1) {
1967 #if 0
1968                                 printf("%s: exact %d %d (%d)\n", __func__, (int)ctime, BLI_countlist(&masklay->splines_shapes),
1969                                        masklay_shape_a->frame);
1970 #endif
1971
1972                                 BKE_mask_layer_shape_to_mask(masklay, masklay_shape_a);
1973                         }
1974                         else if (found == 2) {
1975                                 float w = masklay_shape_b->frame - masklay_shape_a->frame;
1976 #if 0
1977                                 printf("%s: tween %d %d (%d %d)\n", __func__, (int)ctime, BLI_countlist(&masklay->splines_shapes),
1978                                        masklay_shape_a->frame, masklay_shape_b->frame);
1979 #endif
1980                                 BKE_mask_layer_shape_to_mask_interp(masklay, masklay_shape_a, masklay_shape_b,
1981                                                                     (ctime - masklay_shape_a->frame) / w);
1982                         }
1983                         else {
1984                                 /* always fail, should never happen */
1985                                 BLI_assert(found == 2);
1986                         }
1987                 }
1988         }
1989         /* animation done... */
1990
1991         BKE_mask_layer_calc_handles(masklay);
1992
1993         /* update deform */
1994         {
1995                 MaskSpline *spline;
1996
1997                 for (spline = masklay->splines.first; spline; spline = spline->next) {
1998                         int i;
1999                         int has_auto = FALSE;
2000
2001                         BKE_mask_spline_ensure_deform(spline);
2002
2003                         for (i = 0; i < spline->tot_point; i++) {
2004                                 MaskSplinePoint *point = &spline->points[i];
2005                                 MaskSplinePoint *point_deform = &spline->points_deform[i];
2006                                 float delta[2];
2007
2008                                 BKE_mask_point_free(point_deform);
2009
2010                                 *point_deform = *point;
2011                                 point_deform->uw = point->uw ? MEM_dupallocN(point->uw) : NULL;
2012
2013                                 if (BKE_mask_evaluate_parent_delta(&point->parent, ctime, delta)) {
2014                                         add_v2_v2(point_deform->bezt.vec[0], delta);
2015                                         add_v2_v2(point_deform->bezt.vec[1], delta);
2016                                         add_v2_v2(point_deform->bezt.vec[2], delta);
2017                                 }
2018
2019                                 if (point->bezt.h1 == HD_AUTO) {
2020                                         has_auto = TRUE;
2021                                 }
2022                         }
2023
2024                         /* if the spline has auto handles, these need to be recalculated after deformation */
2025                         if (has_auto) {
2026                                 for (i = 0; i < spline->tot_point; i++) {
2027                                         MaskSplinePoint *point_deform = &spline->points_deform[i];
2028                                         if (point_deform->bezt.h1 == HD_AUTO) {
2029                                                 BKE_mask_calc_handle_point(spline, point_deform);
2030                                         }
2031                                 }
2032                         }
2033                         /* end extra calc handles loop */
2034                 }
2035         }
2036 }
2037
2038 void BKE_mask_evaluate(Mask *mask, const float ctime, const int do_newframe)
2039 {
2040         MaskLayer *masklay;
2041
2042         for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
2043                 BKE_mask_layer_evaluate(masklay, ctime, do_newframe);
2044         }
2045 }
2046
2047 /* the purpose of this function is to ensure spline->points_deform is never out of date.
2048  * for now re-evaluate all. eventually this might work differently */
2049 void BKE_mask_update_display(Mask *mask, float ctime)
2050 {
2051 #if 0
2052         MaskLayer *masklay;
2053
2054         for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
2055                 MaskSpline *spline;
2056
2057                 for (spline = masklay->splines.first; spline; spline = spline->next) {
2058                         if (spline->points_deform) {
2059                                 int i = 0;
2060
2061                                 for (i = 0; i < spline->tot_point; i++) {
2062                                         MaskSplinePoint *point;
2063
2064                                         if (spline->points_deform) {
2065                                                 point = &spline->points_deform[i];
2066                                                 BKE_mask_point_free(point);
2067                                         }
2068                                 }
2069                                 if (spline->points_deform) {
2070                                         MEM_freeN(spline->points_deform);
2071                                 }
2072
2073                                 spline->points_deform = NULL;
2074                         }
2075                 }
2076         }
2077 #endif
2078
2079         BKE_mask_evaluate(mask, ctime, FALSE);
2080 }
2081
2082 void BKE_mask_evaluate_all_masks(Main *bmain, float ctime, const int do_newframe)
2083 {
2084         Mask *mask;
2085
2086         for (mask = bmain->mask.first; mask; mask = mask->id.next) {
2087                 BKE_mask_evaluate(mask, ctime, do_newframe);
2088         }
2089 }
2090
2091 void BKE_mask_update_scene(Main *bmain, Scene *scene, const int do_newframe)
2092 {
2093         Mask *mask;
2094
2095         for (mask = bmain->mask.first; mask; mask = mask->id.next) {
2096                 if (mask->id.flag & LIB_ID_RECALC) {
2097                         BKE_mask_evaluate_all_masks(bmain, CFRA, do_newframe);
2098                 }
2099         }
2100 }
2101
2102 void BKE_mask_parent_init(MaskParent *parent)
2103 {
2104         parent->id_type = ID_MC;
2105 }
2106
2107
2108 /* *** own animation/shapekey implimentation ***
2109  * BKE_mask_layer_shape_XXX */
2110
2111 int BKE_mask_layer_shape_totvert(MaskLayer *masklay)
2112 {
2113         int tot = 0;
2114         MaskSpline *spline;
2115
2116         for (spline = masklay->splines.first; spline; spline = spline->next) {
2117                 tot += spline->tot_point;
2118         }
2119
2120         return tot;
2121 }
2122
2123 static void mask_layer_shape_from_mask_point(BezTriple *bezt, float fp[MASK_OBJECT_SHAPE_ELEM_SIZE])
2124 {
2125         copy_v2_v2(&fp[0], bezt->vec[0]);
2126         copy_v2_v2(&fp[2], bezt->vec[1]);
2127         copy_v2_v2(&fp[4], bezt->vec[2]);
2128         fp[6] = bezt->weight;
2129         fp[7] = bezt->radius;
2130 }
2131
2132 static void mask_layer_shape_to_mask_point(BezTriple *bezt, float fp[MASK_OBJECT_SHAPE_ELEM_SIZE])
2133 {
2134         copy_v2_v2(bezt->vec[0], &fp[0]);
2135         copy_v2_v2(bezt->vec[1], &fp[2]);
2136         copy_v2_v2(bezt->vec[2], &fp[4]);
2137         bezt->weight = fp[6];
2138         bezt->radius = fp[7];
2139 }
2140
2141 /* these functions match. copy is swapped */
2142 void BKE_mask_layer_shape_from_mask(MaskLayer *masklay, MaskLayerShape *masklay_shape)
2143 {
2144         int tot = BKE_mask_layer_shape_totvert(masklay);
2145
2146         if (masklay_shape->tot_vert == tot) {
2147                 float *fp = masklay_shape->data;
2148
2149                 MaskSpline *spline;
2150                 for (spline = masklay->splines.first; spline; spline = spline->next) {
2151                         int i;
2152                         for (i = 0; i < spline->tot_point; i++) {
2153                                 mask_layer_shape_from_mask_point(&spline->points[i].bezt, fp);
2154                                 fp += MASK_OBJECT_SHAPE_ELEM_SIZE;
2155                         }
2156                 }
2157         }
2158         else {
2159                 printf("%s: vert mismatch %d != %d (frame %d)\n",
2160                        __func__, masklay_shape->tot_vert, tot, masklay_shape->frame);
2161         }
2162 }
2163
2164 void BKE_mask_layer_shape_to_mask(MaskLayer *masklay, MaskLayerShape *masklay_shape)
2165 {
2166         int tot = BKE_mask_layer_shape_totvert(masklay);
2167
2168         if (masklay_shape->tot_vert == tot) {
2169                 float *fp = masklay_shape->data;
2170
2171                 MaskSpline *spline;
2172                 for (spline = masklay->splines.first; spline; spline = spline->next) {
2173                         int i;
2174                         for (i = 0; i < spline->tot_point; i++) {
2175                                 mask_layer_shape_to_mask_point(&spline->points[i].bezt, fp);
2176                                 fp += MASK_OBJECT_SHAPE_ELEM_SIZE;
2177                         }
2178                 }
2179         }
2180         else {
2181                 printf("%s: vert mismatch %d != %d (frame %d)\n",
2182                        __func__, masklay_shape->tot_vert, tot, masklay_shape->frame);
2183         }
2184 }
2185
2186 BLI_INLINE void interp_v2_v2v2_flfl(float target[2], const float a[2], const float b[2],
2187                                     const float t, const float s)
2188 {
2189         target[0] = s * a[0] + t * b[0];
2190         target[1] = s * a[1] + t * b[1];
2191 }
2192
2193 /* linear interpolation only */
2194 void BKE_mask_layer_shape_to_mask_interp(MaskLayer *masklay,
2195                                          MaskLayerShape *masklay_shape_a,
2196                                          MaskLayerShape *masklay_shape_b,
2197                                          const float fac)
2198 {
2199         int tot = BKE_mask_layer_shape_totvert(masklay);
2200         if (masklay_shape_a->tot_vert == tot && masklay_shape_b->tot_vert == tot) {
2201                 float *fp_a = masklay_shape_a->data;
2202                 float *fp_b = masklay_shape_b->data;
2203                 const float ifac = 1.0f - fac;
2204
2205                 MaskSpline *spline;
2206                 for (spline = masklay->splines.first; spline; spline = spline->next) {
2207                         int i;
2208                         for (i = 0; i < spline->tot_point; i++) {
2209                                 BezTriple *bezt = &spline->points[i].bezt;
2210                                 /* *** BKE_mask_layer_shape_from_mask - swapped *** */
2211                                 interp_v2_v2v2_flfl(bezt->vec[0], fp_a, fp_b, fac, ifac); fp_a += 2; fp_b += 2;
2212                                 interp_v2_v2v2_flfl(bezt->vec[1], fp_a, fp_b, fac, ifac); fp_a += 2; fp_b += 2;
2213                                 interp_v2_v2v2_flfl(bezt->vec[2], fp_a, fp_b, fac, ifac); fp_a += 2; fp_b += 2;
2214                                 bezt->weight = (fp_a[0] * ifac) + (fp_b[0] * fac);
2215                                 bezt->radius = (fp_a[1] * ifac) + (fp_b[1] * fac); fp_a += 2; fp_b += 2;
2216                         }
2217                 }
2218         }
2219         else {
2220                 printf("%s: vert mismatch %d != %d != %d (frame %d - %d)\n",
2221                        __func__, masklay_shape_a->tot_vert, masklay_shape_b->tot_vert, tot,
2222                        masklay_shape_a->frame, masklay_shape_b->frame);
2223         }
2224 }
2225
2226 MaskLayerShape *BKE_mask_layer_shape_find_frame(MaskLayer *masklay, const int frame)
2227 {
2228         MaskLayerShape *masklay_shape;
2229
2230         for (masklay_shape = masklay->splines_shapes.first;
2231              masklay_shape;
2232              masklay_shape = masklay_shape->next)
2233         {
2234                 if (frame == masklay_shape->frame) {
2235                         return masklay_shape;
2236                 }
2237                 else if (frame < masklay_shape->frame) {
2238                         break;
2239                 }
2240         }
2241
2242         return NULL;
2243 }
2244
2245 /* when returning 2 - the frame isnt found but before/after frames are */
2246 int BKE_mask_layer_shape_find_frame_range(MaskLayer *masklay, const float frame,
2247                                           MaskLayerShape **r_masklay_shape_a,
2248                                           MaskLayerShape **r_masklay_shape_b)
2249 {
2250         MaskLayerShape *masklay_shape;
2251
2252         for (masklay_shape = masklay->splines_shapes.first;
2253              masklay_shape;
2254              masklay_shape = masklay_shape->next)
2255         {
2256                 if (frame == masklay_shape->frame) {
2257                         *r_masklay_shape_a = masklay_shape;
2258                         *r_masklay_shape_b = NULL;
2259                         return 1;
2260                 }
2261                 else if (frame < masklay_shape->frame) {
2262                         if (masklay_shape->prev) {
2263                                 *r_masklay_shape_a = masklay_shape->prev;
2264                                 *r_masklay_shape_b = masklay_shape;
2265                                 return 2;
2266                         }
2267                         else {
2268                                 *r_masklay_shape_a = masklay_shape;
2269                                 *r_masklay_shape_b = NULL;
2270                                 return 1;
2271                         }
2272                 }
2273         }
2274
2275         if ((masklay_shape = masklay->splines_shapes.last)) {
2276                 *r_masklay_shape_a = masklay_shape;
2277                 *r_masklay_shape_b = NULL;
2278                 return 1;
2279         }
2280         else {
2281                 *r_masklay_shape_a = NULL;
2282                 *r_masklay_shape_b = NULL;
2283
2284                 return 0;
2285         }
2286 }
2287
2288 MaskLayerShape *BKE_mask_layer_shape_varify_frame(MaskLayer *masklay, const int frame)
2289 {
2290         MaskLayerShape *masklay_shape;
2291
2292         masklay_shape = BKE_mask_layer_shape_find_frame(masklay, frame);
2293
2294         if (masklay_shape == NULL) {
2295                 masklay_shape = BKE_mask_layer_shape_alloc(masklay, frame);
2296                 BLI_addtail(&masklay->splines_shapes, masklay_shape);
2297                 BKE_mask_layer_shape_sort(masklay);
2298         }
2299
2300 #if 0
2301         {
2302                 MaskLayerShape *masklay_shape;
2303                 int i = 0;
2304                 for (masklay_shape = masklay->splines_shapes.first;
2305                      masklay_shape;
2306                      masklay_shape = masklay_shape->next)
2307                 {
2308                         printf("mask %d, %d\n", i++, masklay_shape->frame);
2309                 }
2310         }
2311 #endif
2312
2313         return masklay_shape;
2314 }
2315
2316 MaskLayerShape *BKE_mask_layer_shape_duplicate(MaskLayerShape *masklay_shape)
2317 {
2318         MaskLayerShape *masklay_shape_copy;
2319
2320         masklay_shape_copy = MEM_dupallocN(masklay_shape);
2321
2322         if (LIKELY(masklay_shape_copy->data)) {
2323                 masklay_shape_copy->data = MEM_dupallocN(masklay_shape_copy->data);
2324         }
2325
2326         return masklay_shape_copy;
2327 }
2328
2329 void BKE_mask_layer_shape_unlink(MaskLayer *masklay, MaskLayerShape *masklay_shape)
2330 {
2331         BLI_remlink(&masklay->splines_shapes, masklay_shape);
2332
2333         BKE_mask_layer_shape_free(masklay_shape);
2334 }
2335
2336 static int mask_layer_shape_sort_cb(void *masklay_shape_a_ptr, void *masklay_shape_b_ptr)
2337 {
2338         MaskLayerShape *masklay_shape_a = (MaskLayerShape *)masklay_shape_a_ptr;
2339         MaskLayerShape *masklay_shape_b = (MaskLayerShape *)masklay_shape_b_ptr;
2340
2341         if      (masklay_shape_a->frame < masklay_shape_b->frame)  return -1;
2342         else if (masklay_shape_a->frame > masklay_shape_b->frame)  return  1;
2343         else                                                       return  0;
2344 }
2345
2346 void BKE_mask_layer_shape_sort(MaskLayer *masklay)
2347 {
2348         BLI_sortlist(&masklay->splines_shapes, mask_layer_shape_sort_cb);
2349 }
2350
2351 int BKE_mask_layer_shape_spline_from_index(MaskLayer *masklay, int index,
2352                                            MaskSpline **r_masklay_shape, int *r_index)
2353 {
2354         MaskSpline *spline;
2355
2356         for (spline = masklay->splines.first; spline; spline = spline->next) {
2357                 if (index < spline->tot_point) {
2358                         *r_masklay_shape = spline;
2359                         *r_index = index;
2360                         return TRUE;
2361                 }
2362                 index -= spline->tot_point;
2363         }
2364
2365         return FALSE;
2366 }
2367
2368 int BKE_mask_layer_shape_spline_to_index(MaskLayer *masklay, MaskSpline *spline)
2369 {
2370         MaskSpline *spline_iter;
2371         int i_abs = 0;
2372         for (spline_iter = masklay->splines.first;
2373              spline_iter && spline_iter != spline;
2374              i_abs += spline_iter->tot_point, spline_iter = spline_iter->next)
2375         {
2376                 /* pass */
2377         }
2378
2379         return i_abs;
2380 }
2381
2382 /* basic 2D interpolation functions, could make more comprehensive later */
2383 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])
2384 {
2385         float pt_on_line[2];
2386         r_uv[0] = closest_to_line_v2(pt_on_line, pt, pt_a, pt_b);
2387         r_uv[1] = (len_v2v2(pt_on_line, pt) / len_v2v2(pt_a, pt_b)) *
2388                   ((line_point_side_v2(pt_a, pt_b, pt) < 0.0f) ? -1.0 : 1.0);  /* this line only sets the sign */
2389 }
2390
2391
2392 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])
2393 {
2394         const float dvec[2] = {pt_b[0] - pt_a[0],
2395                                pt_b[1] - pt_a[1]};
2396
2397         /* u */
2398         madd_v2_v2v2fl(r_pt, pt_a, dvec, uv[0]);
2399
2400         /* v */
2401         r_pt[0] += -dvec[1] * uv[1];
2402         r_pt[1] +=  dvec[0] * uv[1];
2403 }
2404
2405 /* when a now points added - resize all shapekey array  */
2406 void BKE_mask_layer_shape_changed_add(MaskLayer *masklay, int index,
2407                                       int do_init, int do_init_interpolate)
2408 {
2409         MaskLayerShape *masklay_shape;
2410
2411         /* spline index from masklay */
2412         MaskSpline *spline;
2413         int spline_point_index;
2414
2415         if (BKE_mask_layer_shape_spline_from_index(masklay, index,
2416                                                    &spline, &spline_point_index))
2417         {
2418                 /* sanity check */
2419                 /* the point has already been removed in this array so subtract one when comparing with the shapes */
2420                 int tot = BKE_mask_layer_shape_totvert(masklay) - 1;
2421
2422                 /* for interpolation */
2423                 /* TODO - assumes closed curve for now */
2424                 float uv[3][2]; /* 3x 2D handles */
2425                 const int pi_curr =   spline_point_index;
2426                 const int pi_prev = ((spline_point_index - 1) + spline->tot_point) % spline->tot_point;
2427                 const int pi_next =  (spline_point_index + 1)                      % spline->tot_point;
2428
2429                 const int index_offset = index - spline_point_index;
2430                 /* const int pi_curr_abs = index; */
2431                 const int pi_prev_abs = pi_prev + index_offset;
2432                 const int pi_next_abs = pi_next + index_offset;
2433
2434                 int i;
2435                 if (do_init_interpolate) {
2436                         for (i = 0; i < 3; i++) {
2437                                 interp_weights_uv_v2_calc(uv[i],
2438                                                           spline->points[pi_curr].bezt.vec[i],
2439                                                           spline->points[pi_prev].bezt.vec[i],
2440                                                           spline->points[pi_next].bezt.vec[i]);
2441                         }
2442                 }
2443
2444                 for (masklay_shape = masklay->splines_shapes.first;
2445                      masklay_shape;
2446                      masklay_shape = masklay_shape->next)
2447                 {
2448                         if (tot == masklay_shape->tot_vert) {
2449                                 float *data_resized;
2450
2451                                 masklay_shape->tot_vert++;
2452                                 data_resized = MEM_mallocN(masklay_shape->tot_vert * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE, __func__);
2453                                 if (index > 0) {
2454                                         memcpy(data_resized,
2455                                                masklay_shape->data,
2456                                                index * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
2457                                 }
2458
2459                                 if (index != masklay_shape->tot_vert - 1) {
2460                                         memcpy(&data_resized[(index + 1) * MASK_OBJECT_SHAPE_ELEM_SIZE],
2461                                                masklay_shape->data + (index * MASK_OBJECT_SHAPE_ELEM_SIZE),
2462                                                (masklay_shape->tot_vert - (index + 1)) * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
2463                                 }
2464
2465                                 if (do_init) {
2466                                         float *fp = &data_resized[index * MASK_OBJECT_SHAPE_ELEM_SIZE];
2467
2468                                         mask_layer_shape_from_mask_point(&spline->points[spline_point_index].bezt, fp);
2469
2470                                         if (do_init_interpolate && spline->tot_point > 2) {
2471                                                 for (i = 0; i < 3; i++) {
2472                                                         interp_weights_uv_v2_apply(uv[i],
2473                                                                                    &fp[i * 2],
2474                                                                                    &data_resized[(pi_prev_abs * MASK_OBJECT_SHAPE_ELEM_SIZE) + (i * 2)],
2475                                                                                    &data_resized[(pi_next_abs * MASK_OBJECT_SHAPE_ELEM_SIZE) + (i * 2)]);
2476                                                 }
2477                                         }
2478                                 }
2479                                 else {
2480                                         memset(&data_resized[index * MASK_OBJECT_SHAPE_ELEM_SIZE],
2481                                                0,
2482                                                sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
2483                                 }
2484
2485                                 MEM_freeN(masklay_shape->data);
2486                                 masklay_shape->data = data_resized;
2487                         }
2488                         else {
2489                                 printf("%s: vert mismatch %d != %d (frame %d)\n",
2490                                        __func__, masklay_shape->tot_vert, tot, masklay_shape->frame);
2491                         }
2492                 }
2493         }
2494 }
2495
2496
2497 /* move array to account for removed point */
2498 void BKE_mask_layer_shape_changed_remove(MaskLayer *masklay, int index, int count)
2499 {
2500         MaskLayerShape *masklay_shape;
2501
2502         /* the point has already been removed in this array so add one when comparing with the shapes */
2503         int tot = BKE_mask_layer_shape_totvert(masklay);
2504
2505         for (masklay_shape = masklay->splines_shapes.first;
2506              masklay_shape;
2507              masklay_shape = masklay_shape->next)
2508         {
2509                 if (tot == masklay_shape->tot_vert - count) {
2510                         float *data_resized;
2511
2512                         masklay_shape->tot_vert -= count;
2513                         data_resized = MEM_mallocN(masklay_shape->tot_vert * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE, __func__);
2514                         if (index > 0) {
2515                                 memcpy(data_resized,
2516                                        masklay_shape->data,
2517                                        index * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
2518                         }
2519
2520                         if (index != masklay_shape->tot_vert) {
2521                                 memcpy(&data_resized[index * MASK_OBJECT_SHAPE_ELEM_SIZE],
2522                                        masklay_shape->data + ((index + count) * MASK_OBJECT_SHAPE_ELEM_SIZE),
2523                                        (masklay_shape->tot_vert - index) * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
2524                         }
2525
2526                         MEM_freeN(masklay_shape->data);
2527                         masklay_shape->data = data_resized;
2528                 }
2529                 else {
2530                         printf("%s: vert mismatch %d != %d (frame %d)\n",
2531                                __func__, masklay_shape->tot_vert - count, tot, masklay_shape->frame);
2532                 }
2533         }
2534 }
2535
2536 int BKE_mask_get_duration(Mask *mask)
2537 {
2538         return maxi(1, mask->efra - mask->sfra);
2539 }