UI: Remove Width/Percentage control from Bevel tool settings
[blender.git] / source / blender / blenkernel / BKE_mask.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2012 Blender Foundation.
17  * All rights reserved.
18  */
19
20 #ifndef __BKE_MASK_H__
21 #define __BKE_MASK_H__
22
23 /** \file
24  * \ingroup bke
25  */
26
27 struct Depsgraph;
28 struct Image;
29 struct ImageUser;
30 struct ListBase;
31 struct Main;
32 struct Mask;
33 struct MaskLayer;
34 struct MaskLayerShape;
35 struct MaskParent;
36 struct MaskSpline;
37 struct MaskSplinePoint;
38 struct MaskSplinePointUW;
39 struct MovieClip;
40 struct MovieClipUser;
41
42 /* mask_ops.c */
43 typedef enum {
44   MASK_WHICH_HANDLE_NONE = 0,
45   MASK_WHICH_HANDLE_STICK = 1,
46   MASK_WHICH_HANDLE_LEFT = 2,
47   MASK_WHICH_HANDLE_RIGHT = 3,
48   MASK_WHICH_HANDLE_BOTH = 4,
49 } eMaskWhichHandle;
50
51 typedef enum {
52   MASK_HANDLE_MODE_STICK = 1,
53   MASK_HANDLE_MODE_INDIVIDUAL_HANDLES = 2,
54 } eMaskhandleMode;
55
56 struct MaskSplinePoint *BKE_mask_spline_point_array(struct MaskSpline *spline);
57 struct MaskSplinePoint *BKE_mask_spline_point_array_from_point(
58     struct MaskSpline *spline, const struct MaskSplinePoint *point_ref);
59
60 /* mask layers */
61 struct MaskLayer *BKE_mask_layer_new(struct Mask *mask, const char *name);
62 struct MaskLayer *BKE_mask_layer_active(struct Mask *mask);
63 void BKE_mask_layer_active_set(struct Mask *mask, struct MaskLayer *masklay);
64 void BKE_mask_layer_remove(struct Mask *mask, struct MaskLayer *masklay);
65
66 void BKE_mask_layer_free_shapes(struct MaskLayer *masklay);
67 void BKE_mask_layer_free(struct MaskLayer *masklay);
68 void BKE_mask_layer_free_list(struct ListBase *masklayers);
69 void BKE_mask_spline_free(struct MaskSpline *spline);
70 void BKE_mask_spline_free_list(struct ListBase *splines);
71 struct MaskSpline *BKE_mask_spline_copy(const struct MaskSpline *spline);
72 void BKE_mask_point_free(struct MaskSplinePoint *point);
73
74 void BKE_mask_layer_unique_name(struct Mask *mask, struct MaskLayer *masklay);
75 void BKE_mask_layer_rename(struct Mask *mask,
76                            struct MaskLayer *masklay,
77                            char *oldname,
78                            char *newname);
79
80 struct MaskLayer *BKE_mask_layer_copy(const struct MaskLayer *layer);
81 void BKE_mask_layer_copy_list(struct ListBase *masklayers_new, const struct ListBase *masklayers);
82
83 /* splines */
84 struct MaskSpline *BKE_mask_spline_add(struct MaskLayer *masklay);
85 bool BKE_mask_spline_remove(struct MaskLayer *mask_layer, struct MaskSpline *spline);
86 void BKE_mask_point_direction_switch(struct MaskSplinePoint *point);
87 void BKE_mask_spline_direction_switch(struct MaskLayer *masklay, struct MaskSpline *spline);
88
89 struct BezTriple *BKE_mask_spline_point_next_bezt(struct MaskSpline *spline,
90                                                   struct MaskSplinePoint *points_array,
91                                                   struct MaskSplinePoint *point);
92
93 typedef enum {
94   MASK_PROJ_NEG = -1,
95   MASK_PROJ_ANY = 0,
96   MASK_PROJ_POS = 1,
97 } eMaskSign;
98 float BKE_mask_spline_project_co(struct MaskSpline *spline,
99                                  struct MaskSplinePoint *point,
100                                  float start_u,
101                                  const float co[2],
102                                  const eMaskSign sign);
103
104 /* point */
105 eMaskhandleMode BKE_mask_point_handles_mode_get(struct MaskSplinePoint *point);
106 void BKE_mask_point_handle(struct MaskSplinePoint *point,
107                            eMaskWhichHandle which_handle,
108                            float handle[2]);
109 void BKE_mask_point_set_handle(struct MaskSplinePoint *point,
110                                eMaskWhichHandle which_handle,
111                                float loc[2],
112                                bool keep_direction,
113                                float orig_handle[2],
114                                float orig_vec[3][3]);
115
116 void BKE_mask_point_segment_co(struct MaskSpline *spline,
117                                struct MaskSplinePoint *point,
118                                float u,
119                                float co[2]);
120 void BKE_mask_point_normal(struct MaskSpline *spline,
121                            struct MaskSplinePoint *point,
122                            float u,
123                            float n[2]);
124 float BKE_mask_point_weight_scalar(struct MaskSpline *spline,
125                                    struct MaskSplinePoint *point,
126                                    const float u);
127 float BKE_mask_point_weight(struct MaskSpline *spline,
128                             struct MaskSplinePoint *point,
129                             const float u);
130 struct MaskSplinePointUW *BKE_mask_point_sort_uw(struct MaskSplinePoint *point,
131                                                  struct MaskSplinePointUW *uw);
132 void BKE_mask_point_add_uw(struct MaskSplinePoint *point, float u, float w);
133
134 void BKE_mask_point_select_set(struct MaskSplinePoint *point, const bool do_select);
135 void BKE_mask_point_select_set_handle(struct MaskSplinePoint *point,
136                                       const eMaskWhichHandle which_handle,
137                                       const bool do_select);
138
139 /* general */
140 struct Mask *BKE_mask_new(struct Main *bmain, const char *name);
141 void BKE_mask_copy_data(struct Main *bmain,
142                         struct Mask *mask_dst,
143                         const struct Mask *mask_src,
144                         const int flag);
145 struct Mask *BKE_mask_copy_nolib(struct Mask *mask);
146 struct Mask *BKE_mask_copy(struct Main *bmain, const struct Mask *mask);
147
148 void BKE_mask_make_local(struct Main *bmain, struct Mask *mask, const bool lib_local);
149
150 void BKE_mask_free(struct Mask *mask);
151
152 void BKE_mask_coord_from_frame(float r_co[2], const float co[2], const float frame_size[2]);
153 void BKE_mask_coord_from_movieclip(struct MovieClip *clip,
154                                    struct MovieClipUser *user,
155                                    float r_co[2],
156                                    const float co[2]);
157 void BKE_mask_coord_from_image(struct Image *image,
158                                struct ImageUser *iuser,
159                                float r_co[2],
160                                const float co[2]);
161 void BKE_mask_coord_to_frame(float r_co[2], const float co[2], const float frame_size[2]);
162 void BKE_mask_coord_to_movieclip(struct MovieClip *clip,
163                                  struct MovieClipUser *user,
164                                  float r_co[2],
165                                  const float co[2]);
166 void BKE_mask_coord_to_image(struct Image *image,
167                              struct ImageUser *iuser,
168                              float r_co[2],
169                              const float co[2]);
170
171 /* parenting */
172
173 void BKE_mask_evaluate(struct Mask *mask, const float ctime, const bool do_newframe);
174 void BKE_mask_layer_evaluate(struct MaskLayer *masklay, const float ctime, const bool do_newframe);
175 void BKE_mask_parent_init(struct MaskParent *parent);
176 void BKE_mask_calc_handle_adjacent_interp(struct MaskSpline *spline,
177                                           struct MaskSplinePoint *point,
178                                           const float u);
179 void BKE_mask_calc_tangent_polyline(struct MaskSpline *spline,
180                                     struct MaskSplinePoint *point,
181                                     float t[2]);
182 void BKE_mask_calc_handle_point(struct MaskSpline *spline, struct MaskSplinePoint *point);
183 void BKE_mask_calc_handle_point_auto(struct MaskSpline *spline,
184                                      struct MaskSplinePoint *point,
185                                      const bool do_recalc_length);
186 void BKE_mask_get_handle_point_adjacent(struct MaskSpline *spline,
187                                         struct MaskSplinePoint *point,
188                                         struct MaskSplinePoint **r_point_prev,
189                                         struct MaskSplinePoint **r_point_next);
190 void BKE_mask_layer_calc_handles(struct MaskLayer *masklay);
191 void BKE_mask_spline_ensure_deform(struct MaskSpline *spline);
192 void BKE_mask_point_parent_matrix_get(struct MaskSplinePoint *point,
193                                       float ctime,
194                                       float parent_matrix[3][3]);
195
196 /* animation */
197 int BKE_mask_layer_shape_totvert(struct MaskLayer *masklay);
198 void BKE_mask_layer_shape_from_mask(struct MaskLayer *masklay,
199                                     struct MaskLayerShape *masklay_shape);
200 void BKE_mask_layer_shape_to_mask(struct MaskLayer *masklay, struct MaskLayerShape *masklay_shape);
201 void BKE_mask_layer_shape_to_mask_interp(struct MaskLayer *masklay,
202                                          struct MaskLayerShape *masklay_shape_a,
203                                          struct MaskLayerShape *masklay_shape_b,
204                                          const float fac);
205 struct MaskLayerShape *BKE_mask_layer_shape_find_frame(struct MaskLayer *masklay, const int frame);
206 int BKE_mask_layer_shape_find_frame_range(struct MaskLayer *masklay,
207                                           const float frame,
208                                           struct MaskLayerShape **r_masklay_shape_a,
209                                           struct MaskLayerShape **r_masklay_shape_b);
210 struct MaskLayerShape *BKE_mask_layer_shape_alloc(struct MaskLayer *masklay, const int frame);
211 void BKE_mask_layer_shape_free(struct MaskLayerShape *masklay_shape);
212 struct MaskLayerShape *BKE_mask_layer_shape_verify_frame(struct MaskLayer *masklay,
213                                                          const int frame);
214 struct MaskLayerShape *BKE_mask_layer_shape_duplicate(struct MaskLayerShape *masklay_shape);
215 void BKE_mask_layer_shape_unlink(struct MaskLayer *masklay, struct MaskLayerShape *masklay_shape);
216 void BKE_mask_layer_shape_sort(struct MaskLayer *masklay);
217
218 bool BKE_mask_layer_shape_spline_from_index(struct MaskLayer *masklay,
219                                             int index,
220                                             struct MaskSpline **r_masklay_shape,
221                                             int *r_index);
222 int BKE_mask_layer_shape_spline_to_index(struct MaskLayer *masklay, struct MaskSpline *spline);
223
224 void BKE_mask_layer_shape_changed_add(struct MaskLayer *masklay,
225                                       int index,
226                                       bool do_init,
227                                       bool do_init_interpolate);
228
229 void BKE_mask_layer_shape_changed_remove(struct MaskLayer *masklay, int index, int count);
230
231 int BKE_mask_get_duration(struct Mask *mask);
232
233 /* clipboard */
234 void BKE_mask_clipboard_free(void);
235 void BKE_mask_clipboard_copy_from_layer(struct MaskLayer *mask_layer);
236 bool BKE_mask_clipboard_is_empty(void);
237 void BKE_mask_clipboard_paste_to_layer(struct Main *bmain, struct MaskLayer *mask_layer);
238
239 #define MASKPOINT_ISSEL_ANY(p) ((((p)->bezt.f1 | (p)->bezt.f2 | (p)->bezt.f3) & SELECT) != 0)
240 #define MASKPOINT_ISSEL_KNOT(p) (((p)->bezt.f2 & SELECT) != 0)
241
242 #define MASKPOINT_ISSEL_HANDLE(point, which_handle) \
243   (((which_handle == MASK_WHICH_HANDLE_STICK) ? \
244         ((((point)->bezt.f1 | (point)->bezt.f3) & SELECT)) : \
245         ((which_handle == MASK_WHICH_HANDLE_LEFT) ? ((point)->bezt.f1 & SELECT) : \
246                                                     ((point)->bezt.f3 & SELECT))) != 0)
247
248 #define MASKPOINT_SEL_ALL(p) \
249   { \
250     (p)->bezt.f1 |= SELECT; \
251     (p)->bezt.f2 |= SELECT; \
252     (p)->bezt.f3 |= SELECT; \
253   } \
254   (void)0
255 #define MASKPOINT_DESEL_ALL(p) \
256   { \
257     (p)->bezt.f1 &= ~SELECT; \
258     (p)->bezt.f2 &= ~SELECT; \
259     (p)->bezt.f3 &= ~SELECT; \
260   } \
261   (void)0
262 #define MASKPOINT_INVSEL_ALL(p) \
263   { \
264     (p)->bezt.f1 ^= SELECT; \
265     (p)->bezt.f2 ^= SELECT; \
266     (p)->bezt.f3 ^= SELECT; \
267   } \
268   (void)0
269
270 #define MASK_RESOL_MAX 128
271
272 /* mask_evaluate.c */
273 unsigned int BKE_mask_spline_resolution(struct MaskSpline *spline, int width, int height);
274 unsigned int BKE_mask_spline_feather_resolution(struct MaskSpline *spline, int width, int height);
275 int BKE_mask_spline_differentiate_calc_total(const struct MaskSpline *spline,
276                                              const unsigned int resol);
277
278 float (*BKE_mask_spline_differentiate_with_resolution(struct MaskSpline *spline,
279                                                       unsigned int *tot_diff_point,
280                                                       const unsigned int resol))[2];
281 void BKE_mask_spline_feather_collapse_inner_loops(struct MaskSpline *spline,
282                                                   float (*feather_points)[2],
283                                                   const unsigned int tot_feather_point);
284 float (*BKE_mask_spline_differentiate(
285     struct MaskSpline *spline, int width, int height, unsigned int *tot_diff_point))[2];
286 float (*BKE_mask_spline_feather_differentiated_points_with_resolution(
287     struct MaskSpline *spline,
288     unsigned int *tot_feather_point,
289     const unsigned int resol,
290     const bool do_feather_isect))[2];
291
292 /* *** mask point functions which involve evaluation *** */
293 float (*BKE_mask_spline_feather_points(struct MaskSpline *spline, int *tot_feather_point))[2];
294
295 float *BKE_mask_point_segment_diff(struct MaskSpline *spline,
296                                    struct MaskSplinePoint *point,
297                                    int width,
298                                    int height,
299                                    unsigned int *tot_diff_point);
300
301 float *BKE_mask_point_segment_feather_diff(struct MaskSpline *spline,
302                                            struct MaskSplinePoint *point,
303                                            int width,
304                                            int height,
305                                            unsigned int *tot_feather_point);
306
307 void BKE_mask_layer_evaluate_animation(struct MaskLayer *masklay, const float ctime);
308 void BKE_mask_layer_evaluate_deform(struct MaskLayer *masklay, const float ctime);
309
310 void BKE_mask_eval_animation(struct Depsgraph *depsgraph, struct Mask *mask);
311 void BKE_mask_eval_update(struct Depsgraph *depsgraph, struct Mask *mask);
312
313 /* mask_rasterize.c */
314 struct MaskRasterHandle;
315 typedef struct MaskRasterHandle MaskRasterHandle;
316
317 MaskRasterHandle *BKE_maskrasterize_handle_new(void);
318 void BKE_maskrasterize_handle_free(MaskRasterHandle *mr_handle);
319 void BKE_maskrasterize_handle_init(MaskRasterHandle *mr_handle,
320                                    struct Mask *mask,
321                                    const int width,
322                                    const int height,
323                                    const bool do_aspect_correct,
324                                    const bool do_mask_aa,
325                                    const bool do_feather);
326 float BKE_maskrasterize_handle_sample(MaskRasterHandle *mr_handle, const float xy[2]);
327
328 void BKE_maskrasterize_buffer(MaskRasterHandle *mr_handle,
329                               const unsigned int width,
330                               const unsigned int height,
331                               float *buffer);
332
333 #endif /* __BKE_MASK_H__ */