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