Blender V5.3
BKE_mask.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2012 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#pragma once
6
10
11#include "BLI_array.hh"
12
13#include "DNA_listBase.h"
14#include "DNA_mask_types.h"
15
16namespace blender {
17
18#ifndef SELECT
19# define SELECT 1
20#endif
21
22struct BezTriple;
23struct Depsgraph;
24struct Image;
25struct ImageUser;
26struct Main;
27struct MovieClip;
28struct MovieClipUser;
29
30namespace bke {
40} // namespace bke
41
42/* `mask_ops.cc` */
43
51
56
57/* -------------------------------------------------------------------- */
60
61MaskLayer *BKE_mask_layer_new(Mask *mask, const char *name);
65MaskLayer *BKE_mask_layer_active(Mask *mask);
66MaskLayer *BKE_mask_layer_by_name(Mask *mask, const char *layer_name);
67void BKE_mask_layer_active_set(Mask *mask, MaskLayer *masklay);
68void BKE_mask_layer_remove(Mask *mask, MaskLayer *masklay);
69
71void BKE_mask_layer_free_shapes(MaskLayer *masklay);
72void BKE_mask_layer_free(MaskLayer *masklay);
73void BKE_mask_layer_free_list(ListBaseT<MaskLayer> *masklayers);
74void BKE_mask_spline_free(MaskSpline *spline);
75void BKE_mask_spline_free_list(ListBaseT<MaskSpline> *splines);
76MaskSpline *BKE_mask_spline_copy(const MaskSpline *spline);
77void BKE_mask_point_free(MaskSplinePoint *point);
78
79void BKE_mask_layer_unique_name(Mask *mask, MaskLayer *masklay);
81 Main &bmain, Mask *mask, MaskLayer *masklay, const char *oldname, const char *newname);
82
83MaskLayer *BKE_mask_layer_copy(const MaskLayer *masklay);
84void BKE_mask_layer_copy_list(ListBaseT<MaskLayer> *masklayers_new,
85 const ListBaseT<MaskLayer> *masklayers);
86
88 float point[3][2];
89 float weight;
90 float radius;
91};
92/* MaskLayerShapeElem is serialized as 8 floats in DNA data. */
93static_assert(sizeof(MaskLayerShapeElem) == 8 * sizeof(float),
94 "MaskLayerShapeElem expected size mismatch");
95
97
98/* -------------------------------------------------------------------- */
101
104 const MaskSplinePoint *point_ref);
105
108 MaskLayer *src_mask_layer,
109 MaskLayer *dst_mask_layer);
110bool BKE_mask_spline_remove(MaskLayer *mask_layer, MaskSpline *spline);
113
115 MaskSplinePoint *points_array,
116 MaskSplinePoint *point);
117
124 MaskSpline *spline, MaskSplinePoint *point, float start_u, const float co[2], eMaskSign sign);
125
127
128/* -------------------------------------------------------------------- */
131
132eMaskhandleMode BKE_mask_point_handles_mode_get(const MaskSplinePoint *point);
133void BKE_mask_point_handle(const MaskSplinePoint *point,
134 eMaskWhichHandle which_handle,
135 float r_handle[2]);
136void BKE_mask_point_set_handle(MaskSplinePoint *point,
137 eMaskWhichHandle which_handle,
138 float loc[2],
139 bool keep_direction,
140 float orig_handle[2],
141 float orig_vec[3][3]);
142
143void BKE_mask_point_segment_co(MaskSpline *spline, MaskSplinePoint *point, float u, float co[2]);
144void BKE_mask_point_normal(MaskSpline *spline, MaskSplinePoint *point, float u, float n[2]);
145float BKE_mask_point_weight_scalar(MaskSpline *spline, MaskSplinePoint *point, float u);
146float BKE_mask_point_weight(MaskSpline *spline, MaskSplinePoint *point, float u);
147MaskSplinePointUW *BKE_mask_point_sort_uw(MaskSplinePoint *point, MaskSplinePointUW *uw);
148void BKE_mask_point_add_uw(MaskSplinePoint *point, float u, float w);
149
150void BKE_mask_point_select_set(MaskSplinePoint *point, bool do_select);
151void BKE_mask_point_select_set_handle(MaskSplinePoint *point,
152 eMaskWhichHandle which_handle,
153 bool do_select);
154
156{
157 return ((p->bezt.f1 | p->bezt.f2 | p->bezt.f3) & SELECT) != 0;
158}
159
161{
162 return (p->bezt.f2 & SELECT) != 0;
163}
164
166 eMaskWhichHandle handle)
167{
168 return (handle == MASK_WHICH_HANDLE_STICK ? (point->bezt.f1 | point->bezt.f3) & SELECT :
169 (handle == MASK_WHICH_HANDLE_LEFT) ? (point->bezt.f1 & SELECT) :
170 (point->bezt.f3 & SELECT)) != 0;
171}
172
179
186
188
189/* -------------------------------------------------------------------- */
192
193Mask *BKE_mask_new(Main *bmain, const char *name);
194
195void BKE_mask_coord_from_frame(float r_co[2], const float co[2], const float frame_size[2]);
196void BKE_mask_coord_from_movieclip(MovieClip *clip,
197 MovieClipUser *user,
198 float r_co[2],
199 const float co[2]);
200void BKE_mask_coord_from_image(Image *image, ImageUser *iuser, float r_co[2], const float co[2]);
204void BKE_mask_coord_to_frame(float r_co[2], const float co[2], const float frame_size[2]);
205void BKE_mask_coord_to_movieclip(MovieClip *clip,
206 MovieClipUser *user,
207 float r_co[2],
208 const float co[2]);
209void BKE_mask_coord_to_image(Image *image, ImageUser *iuser, float r_co[2], const float co[2]);
210
212
213/* -------------------------------------------------------------------- */
216
217void BKE_mask_evaluate(Mask *mask, float ctime, bool do_newframe);
218void BKE_mask_layer_evaluate(MaskLayer *masklay, float ctime, bool do_newframe);
219void BKE_mask_parent_init(MaskParent *parent);
220void BKE_mask_calc_handle_adjacent_interp(MaskSpline *spline, MaskSplinePoint *point, float u);
225void BKE_mask_calc_tangent_polyline(MaskSpline *spline, MaskSplinePoint *point, float t[2]);
226void BKE_mask_calc_handle_point(MaskSpline *spline, MaskSplinePoint *point);
232void BKE_mask_calc_handle_point_auto(MaskSpline *spline,
233 MaskSplinePoint *point,
234 bool do_recalc_length);
235void BKE_mask_get_handle_point_adjacent(MaskSpline *spline,
236 MaskSplinePoint *point,
237 MaskSplinePoint **r_point_prev,
238 MaskSplinePoint **r_point_next);
239void BKE_mask_layer_calc_handles(MaskLayer *masklay);
240void BKE_mask_spline_ensure_deform(MaskSpline *spline);
241void BKE_mask_point_parent_matrix_get(MaskSplinePoint *point,
242 float ctime,
243 float parent_matrix[3][3]);
244
246
247/* -------------------------------------------------------------------- */
250
251bool BKE_mask_layer_is_animated(MaskLayer &mask_layer);
252bool BKE_mask_is_animated(Mask &mask);
253
254int BKE_mask_layer_shape_totvert(MaskLayer *masklay);
258void BKE_mask_layer_shape_from_mask(MaskLayer *masklay, MaskLayerShape *masklay_shape);
262void BKE_mask_layer_shape_to_mask(MaskLayer *masklay, MaskLayerShape *masklay_shape);
266void BKE_mask_layer_shape_to_mask_interp(MaskLayer *masklay,
267 MaskLayerShape *masklay_shape_a,
268 MaskLayerShape *masklay_shape_b,
269 float fac);
270MaskLayerShape *BKE_mask_layer_shape_find_frame(MaskLayer *masklay, int frame);
274int BKE_mask_layer_shape_find_frame_range(MaskLayer *masklay,
275 float frame,
276 MaskLayerShape **r_masklay_shape_a,
277 MaskLayerShape **r_masklay_shape_b);
281MaskLayerShape *BKE_mask_layer_shape_alloc(MaskLayer *masklay, int frame);
282void BKE_mask_layer_shape_free(MaskLayerShape *masklay_shape);
283MaskLayerShape *BKE_mask_layer_shape_verify_frame(MaskLayer *masklay, int frame);
284MaskLayerShape *BKE_mask_layer_shape_duplicate(MaskLayerShape *masklay_shape);
285void BKE_mask_layer_shape_unlink(MaskLayer *masklay, MaskLayerShape *masklay_shape);
286void BKE_mask_layer_shape_sort(MaskLayer *masklay);
287
288bool BKE_mask_layer_shape_spline_from_index(MaskLayer *masklay,
289 int index,
290 MaskSpline **r_masklay_shape,
291 int *r_index);
292int BKE_mask_layer_shape_spline_to_index(MaskLayer *masklay, MaskSpline *spline);
293
297void BKE_mask_layer_shape_changed_add(MaskLayer *masklay,
298 int index,
299 bool do_init,
300 bool do_init_interpolate);
301
305void BKE_mask_layer_shape_changed_remove(MaskLayer *masklay, int index, int count);
306
307int BKE_mask_get_duration(Mask *mask);
308
310
311/* -------------------------------------------------------------------- */
314
322void BKE_mask_clipboard_copy_from_layer(MaskLayer *mask_layer);
330void BKE_mask_clipboard_paste_to_layer(Main *bmain, MaskLayer *mask_layer);
331
333
334/* -------------------------------------------------------------------- */
337
338/* `mask_evaluate.cc` */
339
340int BKE_mask_spline_resolution(MaskSpline *spline, int width, int height);
341unsigned int BKE_mask_spline_feather_resolution(MaskSpline *spline, int width, int height);
342int BKE_mask_spline_differentiate_calc_total(const MaskSpline *spline, unsigned int resol);
343
345 unsigned int resol,
346 unsigned int *r_tot_diff_point))[2];
348 float (*feather_points)[2],
349 unsigned int tot_feather_point);
351 MaskSpline *spline, int width, int height, unsigned int *r_tot_diff_point))[2];
357 MaskSpline *spline,
358 unsigned int resol,
359 bool do_feather_isect,
360 unsigned int *r_tot_feather_point))[2];
361
362/* *** mask point functions which involve evaluation *** */
363
364float (*BKE_mask_spline_feather_points(MaskSpline *spline, int *tot_feather_point))[2];
365
366float *BKE_mask_point_segment_diff(MaskSpline *spline,
367 MaskSplinePoint *point,
368 int width,
369 int height,
370 unsigned int *r_tot_diff_point);
371
372/* *** mask point functions which involve evaluation *** */
373
374float *BKE_mask_point_segment_feather_diff(MaskSpline *spline,
375 MaskSplinePoint *point,
376 int width,
377 int height,
378 unsigned int *r_tot_feather_point);
379
380void BKE_mask_layer_evaluate_animation(MaskLayer *masklay, float ctime);
381void BKE_mask_layer_evaluate_deform(MaskLayer *masklay, float ctime);
382
383void BKE_mask_eval_animation(Depsgraph *depsgraph, Mask *mask);
384void BKE_mask_eval_update(Depsgraph *depsgraph, Mask *mask);
385
387
388/* -------------------------------------------------------------------- */
391
392/* `mask_rasterize.cc` */
393
394struct MaskRasterHandle;
395
396MaskRasterHandle *BKE_maskrasterize_handle_new();
397void BKE_maskrasterize_handle_free(MaskRasterHandle *mr_handle);
398void BKE_maskrasterize_handle_init(MaskRasterHandle *mr_handle,
399 Mask *mask,
400 int width,
401 int height,
402 bool do_aspect_correct,
403 bool do_mask_aa,
404 bool do_feather);
405float BKE_maskrasterize_handle_sample(MaskRasterHandle *mr_handle, const float xy[2]);
406
410void BKE_maskrasterize_buffer(MaskRasterHandle *mr_handle,
411 unsigned int width,
412 unsigned int height,
413 float *buffer);
414
416
417} // namespace blender
#define SELECT
Definition BKE_mask.hh:19
These structs are the foundation for all linked lists in the library system.
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
#define image(slot, qualifiers, format)
#define index(i)
constexpr T sign(T) RET
ccl_device_inline float2 mask(const MaskType mask, const float2 a)
BMesh Iterators.
eMaskWhichHandle
Definition BKE_mask.hh:44
@ MASK_WHICH_HANDLE_BOTH
Definition BKE_mask.hh:49
@ MASK_WHICH_HANDLE_LEFT
Definition BKE_mask.hh:47
@ MASK_WHICH_HANDLE_RIGHT
Definition BKE_mask.hh:48
@ MASK_WHICH_HANDLE_STICK
Definition BKE_mask.hh:46
@ MASK_WHICH_HANDLE_NONE
Definition BKE_mask.hh:45
bool BKE_mask_clipboard_is_empty()
void BKE_mask_point_select_set_handle(MaskSplinePoint *point, eMaskWhichHandle which_handle, bool do_select)
void BKE_mask_spline_free(MaskSpline *spline)
MaskRasterHandle * BKE_maskrasterize_handle_new()
void BKE_mask_layer_shape_changed_remove(MaskLayer *masklay, int index, int count)
void BKE_mask_layer_evaluate_deform(MaskLayer *masklay, float ctime)
MaskLayerShape * BKE_mask_layer_shape_duplicate(MaskLayerShape *masklay_shape)
void BKE_mask_point_handle(const MaskSplinePoint *point, eMaskWhichHandle which_handle, float r_handle[2])
void BKE_mask_clipboard_copy_from_layer(MaskLayer *mask_layer)
Mask * BKE_mask_new(Main *bmain, const char *name)
void BKE_mask_get_handle_point_adjacent(MaskSpline *spline, MaskSplinePoint *point, MaskSplinePoint **r_point_prev, MaskSplinePoint **r_point_next)
MaskLayer * BKE_mask_layer_new(Mask *mask, const char *name)
float BKE_maskrasterize_handle_sample(MaskRasterHandle *mr_handle, const float xy[2])
void BKE_mask_layer_unique_name(Mask *mask, MaskLayer *masklay)
@ MASK_PROJ_POS
Definition BKE_mask.hh:121
@ MASK_PROJ_NEG
Definition BKE_mask.hh:119
@ MASK_PROJ_ANY
Definition BKE_mask.hh:120
MaskLayerShape * BKE_mask_layer_shape_alloc(MaskLayer *masklay, int frame)
void BKE_mask_spline_free_list(ListBaseT< MaskSpline > *splines)
MaskSplinePoint * BKE_mask_spline_point_array_from_point(MaskSpline *spline, const MaskSplinePoint *point_ref)
MaskSpline * BKE_mask_spline_copy(const MaskSpline *spline)
void BKE_mask_eval_update(Depsgraph *depsgraph, Mask *mask)
void BKE_mask_point_parent_matrix_get(MaskSplinePoint *point, float ctime, float parent_matrix[3][3])
bool BKE_mask_spline_remove(MaskLayer *mask_layer, MaskSpline *spline)
void BKE_mask_layer_shape_to_mask(MaskLayer *masklay, MaskLayerShape *masklay_shape)
int BKE_mask_get_duration(Mask *mask)
void BKE_mask_calc_handle_adjacent_interp(MaskSpline *spline, MaskSplinePoint *point, float u)
void BKE_mask_evaluate(Mask *mask, float ctime, bool do_newframe)
int BKE_mask_layer_shape_find_frame_range(MaskLayer *masklay, float frame, MaskLayerShape **r_masklay_shape_a, MaskLayerShape **r_masklay_shape_b)
void BKE_mask_layer_evaluate(MaskLayer *masklay, float ctime, bool do_newframe)
void BKE_mask_layer_active_set(Mask *mask, MaskLayer *masklay)
bool BKE_mask_layer_is_animated(MaskLayer &mask_layer)
void BKE_mask_coord_to_movieclip(MovieClip *clip, MovieClipUser *user, float r_co[2], const float co[2])
void BKE_mask_coord_from_image(Image *image, ImageUser *iuser, float r_co[2], const float co[2])
void BKE_mask_layer_shape_from_mask(MaskLayer *masklay, MaskLayerShape *masklay_shape)
void BKE_mask_layer_shape_unlink(MaskLayer *masklay, MaskLayerShape *masklay_shape)
bool BKE_mask_point_selected(const MaskSplinePoint *p)
Definition BKE_mask.hh:155
BezTriple * BKE_mask_spline_point_next_bezt(MaskSpline *spline, MaskSplinePoint *points_array, MaskSplinePoint *point)
int BKE_mask_spline_resolution(MaskSpline *spline, int width, int height)
float BKE_mask_point_weight_scalar(MaskSpline *spline, MaskSplinePoint *point, float u)
float(* BKE_mask_spline_feather_differentiated_points_with_resolution(MaskSpline *spline, unsigned int resol, bool do_feather_isect, unsigned int *r_tot_feather_point))[2]
MaskSplinePointUW * BKE_mask_point_sort_uw(MaskSplinePoint *point, MaskSplinePointUW *uw)
void BKE_mask_coord_to_frame(float r_co[2], const float co[2], const float frame_size[2])
void BKE_mask_point_set_handle(MaskSplinePoint *point, eMaskWhichHandle which_handle, float loc[2], bool keep_direction, float orig_handle[2], float orig_vec[3][3])
MaskLayer * BKE_mask_layer_by_name(Mask *mask, const char *layer_name)
MaskSpline * BKE_mask_spline_add(MaskLayer *masklay)
void BKE_mask_coord_from_movieclip(MovieClip *clip, MovieClipUser *user, float r_co[2], const float co[2])
void BKE_mask_point_deselect_handles(MaskSplinePoint *p)
Definition BKE_mask.hh:180
void BKE_mask_coord_from_frame(float r_co[2], const float co[2], const float frame_size[2])
void BKE_mask_spline_feather_collapse_inner_loops(MaskSpline *spline, float(*feather_points)[2], unsigned int tot_feather_point)
void BKE_mask_spline_ensure_deform(MaskSpline *spline)
float(* BKE_mask_spline_feather_points(MaskSpline *spline, int *tot_feather_point))[2]
void BKE_maskrasterize_handle_init(MaskRasterHandle *mr_handle, Mask *mask, int width, int height, bool do_aspect_correct, bool do_mask_aa, bool do_feather)
MaskLayer * BKE_mask_layer_active(Mask *mask)
void BKE_mask_calc_tangent_polyline(MaskSpline *spline, MaskSplinePoint *point, float t[2])
void BKE_mask_layer_calc_handles(MaskLayer *masklay)
void BKE_maskrasterize_handle_free(MaskRasterHandle *mr_handle)
void BKE_mask_point_select_set(MaskSplinePoint *point, bool do_select)
bool BKE_mask_point_is_handle_selected(const MaskSplinePoint *point, eMaskWhichHandle handle)
Definition BKE_mask.hh:165
void BKE_mask_spline_move_to_layer(MaskSpline *spline, MaskLayer *src_mask_layer, MaskLayer *dst_mask_layer)
bool BKE_mask_point_selected_knot(const MaskSplinePoint *p)
Definition BKE_mask.hh:160
void BKE_mask_point_normal(MaskSpline *spline, MaskSplinePoint *point, float u, float n[2])
void BKE_mask_clipboard_paste_to_layer(Main *bmain, MaskLayer *mask_layer)
float * BKE_mask_point_segment_feather_diff(MaskSpline *spline, MaskSplinePoint *point, int width, int height, unsigned int *r_tot_feather_point)
bool BKE_mask_is_animated(Mask &mask)
void BKE_mask_layer_free(MaskLayer *masklay)
int BKE_mask_spline_differentiate_calc_total(const MaskSpline *spline, unsigned int resol)
void BKE_mask_layer_copy_list(ListBaseT< MaskLayer > *masklayers_new, const ListBaseT< MaskLayer > *masklayers)
void BKE_mask_layer_evaluate_animation(MaskLayer *masklay, float ctime)
int BKE_mask_layer_shape_totvert(MaskLayer *masklay)
float BKE_mask_point_weight(MaskSpline *spline, MaskSplinePoint *point, float u)
void BKE_mask_calc_handle_point(MaskSpline *spline, MaskSplinePoint *point)
int BKE_mask_layer_shape_spline_to_index(MaskLayer *masklay, MaskSpline *spline)
MaskLayer * BKE_mask_layer_copy(const MaskLayer *masklay)
void BKE_mask_layer_free_list(ListBaseT< MaskLayer > *masklayers)
void BKE_mask_parent_init(MaskParent *parent)
unsigned int BKE_mask_spline_feather_resolution(MaskSpline *spline, int width, int height)
MaskLayerShape * BKE_mask_layer_shape_find_frame(MaskLayer *masklay, int frame)
void BKE_mask_point_free(MaskSplinePoint *point)
MaskLayerShape * BKE_mask_layer_shape_verify_frame(MaskLayer *masklay, int frame)
void BKE_mask_layer_free_shapes(MaskLayer *masklay)
Free all animation keys for a mask layer.
void BKE_mask_coord_to_image(Image *image, ImageUser *iuser, float r_co[2], const float co[2])
void BKE_maskrasterize_buffer(MaskRasterHandle *mr_handle, unsigned int width, unsigned int height, float *buffer)
Rasterize a buffer from a single mask (threaded execution).
void BKE_mask_eval_animation(Depsgraph *depsgraph, Mask *mask)
void BKE_mask_point_add_uw(MaskSplinePoint *point, float u, float w)
void BKE_mask_layer_shape_free(MaskLayerShape *masklay_shape)
MaskSplinePoint * BKE_mask_spline_point_array(MaskSpline *spline)
void BKE_mask_layer_shape_to_mask_interp(MaskLayer *masklay, MaskLayerShape *masklay_shape_a, MaskLayerShape *masklay_shape_b, float fac)
void BKE_mask_point_direction_switch(MaskSplinePoint *point)
void BKE_mask_spline_direction_switch(MaskLayer *masklay, MaskSpline *spline)
eMaskhandleMode BKE_mask_point_handles_mode_get(const MaskSplinePoint *point)
void BKE_mask_layer_remove(Mask *mask, MaskLayer *masklay)
void BKE_mask_point_segment_co(MaskSpline *spline, MaskSplinePoint *point, float u, float co[2])
void BKE_mask_layer_shape_changed_add(MaskLayer *masklay, int index, bool do_init, bool do_init_interpolate)
float * BKE_mask_point_segment_diff(MaskSpline *spline, MaskSplinePoint *point, int width, int height, unsigned int *r_tot_diff_point)
eMaskhandleMode
Definition BKE_mask.hh:52
@ MASK_HANDLE_MODE_INDIVIDUAL_HANDLES
Definition BKE_mask.hh:54
@ MASK_HANDLE_MODE_STICK
Definition BKE_mask.hh:53
void BKE_mask_point_select_handles(MaskSplinePoint *p)
Definition BKE_mask.hh:173
bool BKE_mask_layer_shape_spline_from_index(MaskLayer *masklay, int index, MaskSpline **r_masklay_shape, int *r_index)
float BKE_mask_spline_project_co(MaskSpline *spline, MaskSplinePoint *point, float start_u, const float co[2], eMaskSign sign)
void BKE_mask_layer_shape_sort(MaskLayer *masklay)
void BKE_mask_layer_rename(Main &bmain, Mask *mask, MaskLayer *masklay, const char *oldname, const char *newname)
void BKE_mask_calc_handle_point_auto(MaskSpline *spline, MaskSplinePoint *point, bool do_recalc_length)
Resets auto handles even for non-auto bezier points.
float(* BKE_mask_spline_differentiate(MaskSpline *spline, int width, int height, unsigned int *r_tot_diff_point))[2]
float(* BKE_mask_spline_differentiate_with_resolution(MaskSpline *spline, unsigned int resol, unsigned int *r_tot_diff_point))[2]
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
eBezTriple_Flag f2
eBezTriple_Flag f3
eBezTriple_Flag f1
Array< MaskSplinePoint > points_deform
Definition BKE_mask.hh:38