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