mask/image viewer now works with non 1:1 image aspect, editing masks in the image...
[blender.git] / source / blender / blenkernel / BKE_mask.h
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 #ifndef __BKE_MASK_H__
28 #define __BKE_MASK_H__
29
30 struct ListBase;
31 struct Main;
32 struct Mask;
33 struct MaskParent;
34 struct MaskLayer;
35 struct MaskLayerShape;
36 struct MaskSpline;
37 struct MaskSplinePoint;
38 struct MaskSplinePointUW;
39 struct MovieClip;
40 struct MovieClipUser;
41 struct Scene;
42
43 struct MaskSplinePoint *BKE_mask_spline_point_array(struct MaskSpline *spline);
44 struct MaskSplinePoint *BKE_mask_spline_point_array_from_point(struct MaskSpline *spline, struct MaskSplinePoint *point_ref);
45
46 /* mask layers */
47 struct MaskLayer *BKE_mask_layer_new(struct Mask *mask, const char *name);
48 struct MaskLayer *BKE_mask_layer_active(struct Mask *mask);
49 void BKE_mask_layer_active_set(struct Mask *mask, struct MaskLayer *masklay);
50 void BKE_mask_layer_remove(struct Mask *mask, struct MaskLayer *masklay);
51
52 void BKE_mask_layer_free_shapes(struct MaskLayer *masklay);
53 void BKE_mask_layer_free(struct MaskLayer *masklay);
54 void BKE_mask_layer_free_list(struct ListBase *masklayers);
55 void BKE_mask_spline_free(struct MaskSpline *spline);
56 struct MaskSpline *BKE_mask_spline_copy(struct MaskSpline *spline);
57 void BKE_mask_point_free(struct MaskSplinePoint *point);
58
59 void BKE_mask_layer_unique_name(struct Mask *mask, struct MaskLayer *masklay);
60
61 struct MaskLayer *BKE_mask_layer_copy(struct MaskLayer *layer);
62 void BKE_mask_layer_copy_list(struct ListBase *masklayers_new, struct ListBase *masklayers);
63
64 /* splines */
65 struct MaskSpline *BKE_mask_spline_add(struct MaskLayer *masklay);
66
67 int BKE_mask_spline_resolution(struct MaskSpline *spline, int width, int height);
68 int BKE_mask_spline_feather_resolution(struct MaskSpline *spline, int width, int height);
69
70 int BKE_mask_spline_differentiate_calc_total(const struct MaskSpline *spline, const int resol);
71
72 float (*BKE_mask_spline_differentiate(struct MaskSpline *spline, int *tot_diff_point))[2];
73 float (*BKE_mask_spline_feather_differentiated_points(struct MaskSpline *spline, int *tot_feather_point))[2];
74
75 float (*BKE_mask_spline_differentiate_with_resolution_ex(struct MaskSpline *spline, int *tot_diff_point,
76                                                          const int resol))[2];
77 float (*BKE_mask_spline_differentiate_with_resolution(struct MaskSpline *spline, int width, int height, int *tot_diff_point))[2];
78 float (*BKE_mask_spline_feather_differentiated_points_with_resolution_ex(struct MaskSpline *spline, int *tot_feather_point,
79                                                                          const int resol, const int do_collapse))[2];
80 float (*BKE_mask_spline_feather_differentiated_points_with_resolution(struct MaskSpline *spline, int width, int height, int *tot_feather_point))[2];
81
82 float (*BKE_mask_spline_feather_points(struct MaskSpline *spline, int *tot_feather_point))[2];
83
84 void BKE_mask_point_direction_switch(struct MaskSplinePoint *point);
85 void BKE_mask_spline_direction_switch(struct MaskLayer *masklay, struct MaskSpline *spline);
86
87 typedef enum {
88         MASK_PROJ_NEG = -1,
89         MASK_PROJ_ANY = 0,
90         MASK_PROJ_POS = 1
91 } eMaskSign;
92 float BKE_mask_spline_project_co(struct MaskSpline *spline, struct MaskSplinePoint *point,
93                                  float start_u, const float co[2], const eMaskSign sign);
94
95 /* point */
96 int BKE_mask_point_has_handle(struct MaskSplinePoint *point);
97 void BKE_mask_point_handle(struct MaskSplinePoint *point, float handle[2]);
98 void BKE_mask_point_set_handle(struct MaskSplinePoint *point, float loc[2], int keep_direction,
99                                float orig_handle[2], float orig_vec[3][3]);
100
101 float *BKE_mask_point_segment_diff(struct MaskSpline *spline, struct MaskSplinePoint *point, int *tot_diff_point);
102 float *BKE_mask_point_segment_feather_diff(struct MaskSpline *spline, struct MaskSplinePoint *point,
103                                            int *tot_feather_point);
104
105 float *BKE_mask_point_segment_diff_with_resolution(struct MaskSpline *spline, struct MaskSplinePoint *point,
106                                                    int width, int height, int *tot_diff_point);
107
108 float *BKE_mask_point_segment_feather_diff_with_resolution(struct MaskSpline *spline, struct MaskSplinePoint *point,
109                                                            int width, int height,
110                                                            int *tot_feather_point);
111
112 void BKE_mask_point_segment_co(struct MaskSpline *spline, struct MaskSplinePoint *point, float u, float co[2]);
113 void BKE_mask_point_normal(struct MaskSpline *spline, struct MaskSplinePoint *point,
114                            float u, float n[2]);
115 float BKE_mask_point_weight_scalar(struct MaskSpline *spline, struct MaskSplinePoint *point, const float u);
116 float BKE_mask_point_weight(struct MaskSpline *spline, struct MaskSplinePoint *point, const float u);
117 struct MaskSplinePointUW *BKE_mask_point_sort_uw(struct MaskSplinePoint *point, struct MaskSplinePointUW *uw);
118 void BKE_mask_point_add_uw(struct MaskSplinePoint *point, float u, float w);
119
120 void BKE_mask_point_select_set(struct MaskSplinePoint *point, const short do_select);
121 void BKE_mask_point_select_set_handle(struct MaskSplinePoint *point, const short do_select);
122
123 /* general */
124 struct Mask *BKE_mask_new(const char *name);
125
126 void BKE_mask_free(struct Mask *mask);
127 void BKE_mask_unlink(struct Main *bmain, struct Mask *mask);
128
129 void BKE_mask_coord_from_movieclip(struct MovieClip *clip, struct MovieClipUser *user, float r_co[2], const float co[2]);
130 void BKE_mask_coord_from_frame(float r_co[2], const float co[2], const float frame_size[2]);
131 void BKE_mask_coord_to_movieclip(struct MovieClip *clip, struct MovieClipUser *user, float r_co[2], const float co[2]);
132 void BKE_mask_coord_to_frame(float r_co[2], const float co[2], const float frame_size[2]);
133
134 /* parenting */
135
136 void BKE_mask_update_display(struct Mask *mask, float ctime);
137
138 void BKE_mask_evaluate_all_masks(struct Main *bmain, float ctime, const int do_newframe);
139 void BKE_mask_evaluate(struct Mask *mask, const float ctime, const int do_newframe);
140 void BKE_mask_layer_evaluate(struct MaskLayer *masklay, const float ctime, const int do_newframe);
141 void BKE_mask_update_scene(struct Main *bmain, struct Scene *scene, const int do_newframe);
142 void BKE_mask_parent_init(struct MaskParent *parent);
143 void BKE_mask_calc_handle_adjacent_interp(struct MaskSpline *spline, struct MaskSplinePoint *point, const float u);
144 void BKE_mask_calc_tangent_polyline(struct MaskSpline *spline, struct MaskSplinePoint *point, float t[2]);
145 void BKE_mask_calc_handle_point(struct MaskSpline *spline, struct MaskSplinePoint *point);
146 void BKE_mask_calc_handle_point_auto(struct MaskSpline *spline, struct MaskSplinePoint *point,
147                                      const short do_recalc_length);
148 void BKE_mask_get_handle_point_adjacent(struct MaskSpline *spline, struct MaskSplinePoint *point,
149                                         struct MaskSplinePoint **r_point_prev, struct MaskSplinePoint **r_point_next);
150 void BKE_mask_layer_calc_handles(struct MaskLayer *masklay);
151 void BKE_mask_layer_calc_handles_deform(struct MaskLayer *masklay);
152 void BKE_mask_calc_handles(struct Mask *mask);
153 void BKE_mask_calc_handles_deform(struct Mask *mask);
154 void BKE_mask_spline_ensure_deform(struct MaskSpline *spline);
155
156 /* animation */
157 int  BKE_mask_layer_shape_totvert(struct MaskLayer *masklay);
158 void BKE_mask_layer_shape_from_mask(struct MaskLayer *masklay, struct MaskLayerShape *masklay_shape);
159 void BKE_mask_layer_shape_to_mask(struct MaskLayer *masklay, struct MaskLayerShape *masklay_shape);
160 void BKE_mask_layer_shape_to_mask_interp(struct MaskLayer *masklay,
161                                          struct MaskLayerShape *masklay_shape_a,
162                                          struct MaskLayerShape *masklay_shape_b,
163                                          const float fac);
164 struct MaskLayerShape *BKE_mask_layer_shape_find_frame(struct MaskLayer *masklay, const int frame);
165 int BKE_mask_layer_shape_find_frame_range(struct MaskLayer *masklay, const float frame,
166                                           struct MaskLayerShape **r_masklay_shape_a,
167                                           struct MaskLayerShape **r_masklay_shape_b);
168 struct MaskLayerShape *BKE_mask_layer_shape_alloc(struct MaskLayer *masklay, const int frame);
169 void BKE_mask_layer_shape_free(struct MaskLayerShape *masklay_shape);
170 struct MaskLayerShape *BKE_mask_layer_shape_varify_frame(struct MaskLayer *masklay, const int frame);
171 struct MaskLayerShape *BKE_mask_layer_shape_duplicate(struct MaskLayerShape *masklay_shape);
172 void BKE_mask_layer_shape_unlink(struct MaskLayer *masklay, struct MaskLayerShape *masklay_shape);
173 void BKE_mask_layer_shape_sort(struct MaskLayer *masklay);
174
175 int BKE_mask_layer_shape_spline_from_index(struct MaskLayer *masklay, int index,
176                                             struct MaskSpline **r_masklay_shape, int *r_index);
177 int BKE_mask_layer_shape_spline_to_index(struct MaskLayer *masklay, struct MaskSpline *spline);
178
179 int BKE_mask_layer_shape_spline_index(struct MaskLayer *masklay, int index,
180                                        struct MaskSpline **r_masklay_shape, int *r_index);
181 void BKE_mask_layer_shape_changed_add(struct MaskLayer *masklay, int index,
182                                        int do_init, int do_init_interpolate);
183
184 void BKE_mask_layer_shape_changed_remove(struct MaskLayer *masklay, int index, int count);
185
186 /* rasterization */
187 int BKE_mask_get_duration(struct Mask *mask);
188
189 void BKE_mask_rasterize_layers(struct ListBase *masklayers, int width, int height, float *buffer,
190                                const short do_aspect_correct, const short do_mask_aa,
191                                const short do_feather);
192
193 void BKE_mask_rasterize(struct Mask *mask, int width, int height, float *buffer,
194                         const short do_aspect_correct, const short do_mask_aa,
195                         const short do_feather);
196
197 /* initialization for tiling */
198 #ifdef __PLX_RASKTER_MT__
199 void BKE_mask_init_layers(Mask *mask, struct layer_init_data *mlayer_data, int width, int height,
200                                                          const short do_aspect_correct);
201 #endif
202
203 #define MASKPOINT_ISSEL_ANY(p)          ( ((p)->bezt.f1 | (p)->bezt.f2 | (p)->bezt.f2) & SELECT)
204 #define MASKPOINT_ISSEL_KNOT(p)         ( (p)->bezt.f2 & SELECT)
205 #define MASKPOINT_ISSEL_HANDLE_ONLY(p)  ( (((p)->bezt.f1 | (p)->bezt.f2) & SELECT) && (((p)->bezt.f2 & SELECT) == 0) )
206 #define MASKPOINT_ISSEL_HANDLE(p)       ( (((p)->bezt.f1 | (p)->bezt.f2) & SELECT) )
207
208 #define MASKPOINT_SEL_ALL(p)    { (p)->bezt.f1 |=  SELECT; (p)->bezt.f2 |=  SELECT; (p)->bezt.f3 |=  SELECT; } (void)0
209 #define MASKPOINT_DESEL_ALL(p)  { (p)->bezt.f1 &= ~SELECT; (p)->bezt.f2 &= ~SELECT; (p)->bezt.f3 &= ~SELECT; } (void)0
210 #define MASKPOINT_INVSEL_ALL(p) { (p)->bezt.f1 ^=  SELECT; (p)->bezt.f2 ^=  SELECT; (p)->bezt.f3 ^=  SELECT; } (void)0
211
212 #define MASKPOINT_SEL_HANDLE(p)     { (p)->bezt.f1 |=  SELECT; (p)->bezt.f3 |=  SELECT; } (void)0
213 #define MASKPOINT_DESEL_HANDLE(p)   { (p)->bezt.f1 &= ~SELECT; (p)->bezt.f3 &= ~SELECT; } (void)0
214
215 /* disable to test alternate rasterizer */
216 /* #define USE_RASKTER */
217
218 /* mask_rasterize.c */
219 #ifndef USE_RASKTER
220 struct MaskRasterHandle;
221 typedef struct MaskRasterHandle MaskRasterHandle;
222
223 MaskRasterHandle *BKE_maskrasterize_handle_new(void);
224 void              BKE_maskrasterize_handle_free(MaskRasterHandle *mr_handle);
225 void              BKE_maskrasterize_handle_init(MaskRasterHandle *mr_handle, struct Mask *mask,
226                                                 const int width, const int height,
227                                                 const short do_aspect_correct, const short do_mask_aa,
228                                                 const short do_feather);
229 float             BKE_maskrasterize_handle_sample(MaskRasterHandle *mr_handle, const float xy[2]);
230 #endif /* USE_RASKTER */
231
232 #endif /* __BKE_MASK_H__ */