archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
00025c74b49bb32b1803858b2d7731751a074514
blender-archive/source/blender/blenkernel/BKE_mask.h

231 lines
13 KiB
C++
Raw Normal View History

mask header from tomato/
2012-06-04 15:45:04 +00:00
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2012 Blender Foundation.
* All rights reserved.
*
* Contributor(s): Blender Foundation,
code cleanup: split out mask spline evaluation into its own file.
2012-08-26 13:41:40 +00:00
* Sergey Sharybin,
* Campbell Barton
mask header from tomato/
2012-06-04 15:45:04 +00:00
*
* ***** END GPL LICENSE BLOCK *****
*/
#ifndef __BKE_MASK_H__
#define __BKE_MASK_H__
fix [#31946] Masking doesn't respect pixel ratio
2012-09-13 05:29:38 +00:00
struct ImageUser;
struct Image;
Mask node: create a copy of layers to be rasterized in initExecution This creates a list of splines to be rasterized in nitExecution which is being called from main thread. This should resolve possible threading issues discovered in tomato branch.
2012-07-04 07:10:23 +00:00
struct ListBase;
mask header from tomato/
2012-06-04 15:45:04 +00:00
struct Main;
struct Mask;
struct MaskParent;
struct MaskLayer;
struct MaskLayerShape;
struct MaskSpline;
struct MaskSplinePoint;
struct MaskSplinePointUW;
struct MovieClip;
struct MovieClipUser;
struct Scene;
struct MaskSplinePoint *BKE_mask_spline_point_array(struct MaskSpline *spline);
struct MaskSplinePoint *BKE_mask_spline_point_array_from_point(struct MaskSpline *spline, struct MaskSplinePoint *point_ref);
/* mask layers */
struct MaskLayer *BKE_mask_layer_new(struct Mask *mask, const char *name);
struct MaskLayer *BKE_mask_layer_active(struct Mask *mask);
void BKE_mask_layer_active_set(struct Mask *mask, struct MaskLayer *masklay);
void BKE_mask_layer_remove(struct Mask *mask, struct MaskLayer *masklay);
mango request - highlight active mask layers. - remove keyframes when all layer data is removed.
2012-06-13 08:35:50 +00:00
void BKE_mask_layer_free_shapes(struct MaskLayer *masklay);
mask header from tomato/
2012-06-04 15:45:04 +00:00
void BKE_mask_layer_free(struct MaskLayer *masklay);
Mask node: create a copy of layers to be rasterized in initExecution This creates a list of splines to be rasterized in nitExecution which is being called from main thread. This should resolve possible threading issues discovered in tomato branch.
2012-07-04 07:10:23 +00:00
void BKE_mask_layer_free_list(struct ListBase *masklayers);
mask header from tomato/
2012-06-04 15:45:04 +00:00
void BKE_mask_spline_free(struct MaskSpline *spline);
struct MaskSpline *BKE_mask_spline_copy(struct MaskSpline *spline);
void BKE_mask_point_free(struct MaskSplinePoint *point);
void BKE_mask_layer_unique_name(struct Mask *mask, struct MaskLayer *masklay);
Mask node: create a copy of layers to be rasterized in initExecution This creates a list of splines to be rasterized in nitExecution which is being called from main thread. This should resolve possible threading issues discovered in tomato branch.
2012-07-04 07:10:23 +00:00
struct MaskLayer *BKE_mask_layer_copy(struct MaskLayer *layer);
void BKE_mask_layer_copy_list(struct ListBase *masklayers_new, struct ListBase *masklayers);
mask header from tomato/
2012-06-04 15:45:04 +00:00
/* splines */
struct MaskSpline *BKE_mask_spline_add(struct MaskLayer *masklay);
void BKE_mask_point_direction_switch(struct MaskSplinePoint *point);
void BKE_mask_spline_direction_switch(struct MaskLayer *masklay, struct MaskSpline *spline);
mask editing - clear feather weights (alt+s) - fix for glitch where placing the feather would jitter.
2012-06-05 09:37:44 +00:00
code cleanup: split out mask spline evaluation into its own file.
2012-08-26 13:41:40 +00:00
struct BezTriple *BKE_mask_spline_point_next_bezt(struct MaskSpline *spline, struct MaskSplinePoint *points_array,
struct MaskSplinePoint *point);
mask editing - clear feather weights (alt+s) - fix for glitch where placing the feather would jitter.
2012-06-05 09:37:44 +00:00
typedef enum {
MASK_PROJ_NEG = -1,
MASK_PROJ_ANY = 0,
MASK_PROJ_POS = 1
} eMaskSign;
float BKE_mask_spline_project_co(struct MaskSpline *spline, struct MaskSplinePoint *point,
float start_u, const float co[2], const eMaskSign sign);
mask header from tomato/
2012-06-04 15:45:04 +00:00
/* point */
int BKE_mask_point_has_handle(struct MaskSplinePoint *point);
void BKE_mask_point_handle(struct MaskSplinePoint *point, float handle[2]);
void BKE_mask_point_set_handle(struct MaskSplinePoint *point, float loc[2], int keep_direction,
float orig_handle[2], float orig_vec[3][3]);
void BKE_mask_point_segment_co(struct MaskSpline *spline, struct MaskSplinePoint *point, float u, float co[2]);
void BKE_mask_point_normal(struct MaskSpline *spline, struct MaskSplinePoint *point,
float u, float n[2]);
mask point slide now accounts for scaled bezier weights,
2012-06-05 12:51:11 +00:00
float BKE_mask_point_weight_scalar(struct MaskSpline *spline, struct MaskSplinePoint *point, const float u);
Quite some warnings...
2012-06-07 18:21:07 +00:00
float BKE_mask_point_weight(struct MaskSpline *spline, struct MaskSplinePoint *point, const float u);
mask header from tomato/
2012-06-04 15:45:04 +00:00
struct MaskSplinePointUW *BKE_mask_point_sort_uw(struct MaskSplinePoint *point, struct MaskSplinePointUW *uw);
void BKE_mask_point_add_uw(struct MaskSplinePoint *point, float u, float w);
void BKE_mask_point_select_set(struct MaskSplinePoint *point, const short do_select);
void BKE_mask_point_select_set_handle(struct MaskSplinePoint *point, const short do_select);
/* general */
struct Mask *BKE_mask_new(const char *name);
copy support for mask datablocks
2012-07-27 08:18:11 +00:00
struct Mask *BKE_mask_copy_nolib(struct Mask *mask);
struct Mask *BKE_mask_copy(struct Mask *mask);
mask header from tomato/
2012-06-04 15:45:04 +00:00
fix for 2 crashes freeing masks - freeing a mask from RNA BKE_libblock_free() twice on the mask. - loading a new blend file would only free the mask and not unlink it from nodes - it would access freed memory.
2012-09-14 01:15:08 +00:00
void BKE_mask_free_nolib(struct Mask *mask);
void BKE_mask_free(struct Main *bmain, struct Mask *mask);
mask header from tomato/
2012-06-04 15:45:04 +00:00
mask/image viewer now works with non 1:1 image aspect, editing masks in the image viewer should be generally usable now though still some TODO's left.
2012-07-25 20:39:49 +00:00
void BKE_mask_coord_from_frame(float r_co[2], const float co[2], const float frame_size[2]);
fix [#31946] Masking doesn't respect pixel ratio
2012-09-13 05:29:38 +00:00
void BKE_mask_coord_from_movieclip(struct MovieClip *clip, struct MovieClipUser *user, float r_co[2], const float co[2]);
void BKE_mask_coord_from_image(struct Image *image, struct ImageUser *iuser, float r_co[2], const float co[2]);
mask/image viewer now works with non 1:1 image aspect, editing masks in the image viewer should be generally usable now though still some TODO's left.
2012-07-25 20:39:49 +00:00
void BKE_mask_coord_to_frame(float r_co[2], const float co[2], const float frame_size[2]);
fix [#31946] Masking doesn't respect pixel ratio
2012-09-13 05:29:38 +00:00
void BKE_mask_coord_to_movieclip(struct MovieClip *clip, struct MovieClipUser *user, float r_co[2], const float co[2]);
void BKE_mask_coord_to_image(struct Image *image, struct ImageUser *iuser, float r_co[2], const float co[2]);
mask header from tomato/
2012-06-04 15:45:04 +00:00
/* parenting */
void BKE_mask_update_display(struct Mask *mask, float ctime);
void BKE_mask_evaluate_all_masks(struct Main *bmain, float ctime, const int do_newframe);
support for subframe animation evaluation for masks.
2012-06-08 09:35:51 +00:00
void BKE_mask_evaluate(struct Mask *mask, const float ctime, const int do_newframe);
mask re-key feature - mango request. ability to reset selected points shape key data. useful if you add many keys to one part of a curve, then later want to key another part - but dont want to continuously make the same corrections.
2012-06-22 11:53:49 +00:00
void BKE_mask_layer_evaluate(struct MaskLayer *masklay, const float ctime, const int do_newframe);
mask header from tomato/
2012-06-04 15:45:04 +00:00
void BKE_mask_update_scene(struct Main *bmain, struct Scene *scene, const int do_newframe);
void BKE_mask_parent_init(struct MaskParent *parent);
code cleanup: remove unused mask args
2012-06-06 20:05:58 +00:00
void BKE_mask_calc_handle_adjacent_interp(struct MaskSpline *spline, struct MaskSplinePoint *point, const float u);
void BKE_mask_calc_tangent_polyline(struct MaskSpline *spline, struct MaskSplinePoint *point, float t[2]);
void BKE_mask_calc_handle_point(struct MaskSpline *spline, struct MaskSplinePoint *point);
void BKE_mask_calc_handle_point_auto(struct MaskSpline *spline, struct MaskSplinePoint *point,
mask header from tomato/
2012-06-04 15:45:04 +00:00
const short do_recalc_length);
code cleanup: remove unused mask args
2012-06-06 20:05:58 +00:00
void BKE_mask_get_handle_point_adjacent(struct MaskSpline *spline, struct MaskSplinePoint *point,
mask header from tomato/
2012-06-04 15:45:04 +00:00
struct MaskSplinePoint **r_point_prev, struct MaskSplinePoint **r_point_next);
fix for bug where auto-handles were not calculated correctly for animated curves.
2012-06-06 20:26:26 +00:00
void BKE_mask_layer_calc_handles(struct MaskLayer *masklay);
void BKE_mask_layer_calc_handles_deform(struct MaskLayer *masklay);
mask header from tomato/
2012-06-04 15:45:04 +00:00
void BKE_mask_calc_handles(struct Mask *mask);
quiet -Wmissing-prototypes warnings, and enable this warning by default for C with gcc. helps for finding unused functions and making functions static, also did some minor code cleanup.
2012-09-15 01:52:28 +00:00
void BKE_mask_update_deform(struct Mask *mask);
mask header from tomato/
2012-06-04 15:45:04 +00:00
void BKE_mask_spline_ensure_deform(struct MaskSpline *spline);
/* animation */
int BKE_mask_layer_shape_totvert(struct MaskLayer *masklay);
void BKE_mask_layer_shape_from_mask(struct MaskLayer *masklay, struct MaskLayerShape *masklay_shape);
void BKE_mask_layer_shape_to_mask(struct MaskLayer *masklay, struct MaskLayerShape *masklay_shape);
void BKE_mask_layer_shape_to_mask_interp(struct MaskLayer *masklay,
struct MaskLayerShape *masklay_shape_a,
struct MaskLayerShape *masklay_shape_b,
const float fac);
operator to reset feather weights on all shape keys
2012-06-05 19:39:12 +00:00
struct MaskLayerShape *BKE_mask_layer_shape_find_frame(struct MaskLayer *masklay, const int frame);
support for subframe animation evaluation for masks.
2012-06-08 09:35:51 +00:00
int BKE_mask_layer_shape_find_frame_range(struct MaskLayer *masklay, const float frame,
mask header from tomato/
2012-06-04 15:45:04 +00:00
struct MaskLayerShape **r_masklay_shape_a,
struct MaskLayerShape **r_masklay_shape_b);
operator to reset feather weights on all shape keys
2012-06-05 19:39:12 +00:00
struct MaskLayerShape *BKE_mask_layer_shape_alloc(struct MaskLayer *masklay, const int frame);
void BKE_mask_layer_shape_free(struct MaskLayerShape *masklay_shape);
struct MaskLayerShape *BKE_mask_layer_shape_varify_frame(struct MaskLayer *masklay, const int frame);
mask animation keys now editable in the dope sheet (duplicate, transform, delete, select- etc).
2012-06-08 14:31:38 +00:00
struct MaskLayerShape *BKE_mask_layer_shape_duplicate(struct MaskLayerShape *masklay_shape);
mask header from tomato/
2012-06-04 15:45:04 +00:00
void BKE_mask_layer_shape_unlink(struct MaskLayer *masklay, struct MaskLayerShape *masklay_shape);
void BKE_mask_layer_shape_sort(struct MaskLayer *masklay);
int BKE_mask_layer_shape_spline_from_index(struct MaskLayer *masklay, int index,
struct MaskSpline **r_masklay_shape, int *r_index);
int BKE_mask_layer_shape_spline_to_index(struct MaskLayer *masklay, struct MaskSpline *spline);
void BKE_mask_layer_shape_changed_add(struct MaskLayer *masklay, int index,
int do_init, int do_init_interpolate);
void BKE_mask_layer_shape_changed_remove(struct MaskLayer *masklay, int index, int count);
new sequence strip type for masks.
2012-06-07 18:24:36 +00:00
int BKE_mask_get_duration(struct Mask *mask);
Mask node: create a copy of layers to be rasterized in initExecution This creates a list of splines to be rasterized in nitExecution which is being called from main thread. This should resolve possible threading issues discovered in tomato branch.
2012-07-04 07:10:23 +00:00
fix incorrect macro for mask handle selection checking.
2012-09-15 06:10:48 +00:00
#define MASKPOINT_ISSEL_ANY(p) ( ((p)->bezt.f1 | (p)->bezt.f2 | (p)->bezt.f3) & SELECT)
mask header from tomato/
2012-06-04 15:45:04 +00:00
#define MASKPOINT_ISSEL_KNOT(p) ( (p)->bezt.f2 & SELECT)
fix incorrect macro for mask handle selection checking.
2012-09-15 06:10:48 +00:00
#define MASKPOINT_ISSEL_HANDLE_ONLY(p) ( (((p)->bezt.f1 | (p)->bezt.f3) & SELECT) && (((p)->bezt.f2 & SELECT) == 0) )
#define MASKPOINT_ISSEL_HANDLE(p) ( (((p)->bezt.f1 | (p)->bezt.f3) & SELECT) )
mask header from tomato/
2012-06-04 15:45:04 +00:00
#define MASKPOINT_SEL_ALL(p) { (p)->bezt.f1 |= SELECT; (p)->bezt.f2 |= SELECT; (p)->bezt.f3 |= SELECT; } (void)0
#define MASKPOINT_DESEL_ALL(p) { (p)->bezt.f1 &= ~SELECT; (p)->bezt.f2 &= ~SELECT; (p)->bezt.f3 &= ~SELECT; } (void)0
#define MASKPOINT_INVSEL_ALL(p) { (p)->bezt.f1 ^= SELECT; (p)->bezt.f2 ^= SELECT; (p)->bezt.f3 ^= SELECT; } (void)0
#define MASKPOINT_SEL_HANDLE(p) { (p)->bezt.f1 |= SELECT; (p)->bezt.f3 |= SELECT; } (void)0
#define MASKPOINT_DESEL_HANDLE(p) { (p)->bezt.f1 &= ~SELECT; (p)->bezt.f3 &= ~SELECT; } (void)0
clamp mask resolution, the occasional crash would happen failing to alloc when adding feather points very close together.
2012-07-27 11:05:08 +00:00
#define MASK_RESOL_MAX 128
code cleanup: remove dead assignments, gave mask vars clearer names & moved some mask evaluation funcs into mask_evaluate.c
2012-08-26 18:09:01 +00:00
code cleanup: split out mask spline evaluation into its own file.
2012-08-26 13:41:40 +00:00
/* mask_evaluate.c */
unsigned int BKE_mask_spline_resolution(struct MaskSpline *spline, int width, int height);
unsigned int BKE_mask_spline_feather_resolution(struct MaskSpline *spline, int width, int height);
int BKE_mask_spline_differentiate_calc_total(const struct MaskSpline *spline, const unsigned int resol);
float (*BKE_mask_spline_differentiate(struct MaskSpline *spline, int *tot_diff_point))[2];
float (*BKE_mask_spline_feather_differentiated_points(struct MaskSpline *spline, int *tot_feather_point))[2];
float (*BKE_mask_spline_differentiate_with_resolution_ex(struct MaskSpline *spline, int *tot_diff_point,
const unsigned int resol))[2];
void BKE_mask_spline_feather_collapse_inner_loops(struct MaskSpline *spline, float (*feather_points)[2], const int tot_feather_point);
float (*BKE_mask_spline_differentiate_with_resolution(struct MaskSpline *spline, int width, int height, int *tot_diff_point))[2];
float (*BKE_mask_spline_feather_differentiated_points_with_resolution_ex(struct MaskSpline *spline, int *tot_feather_point,
const unsigned int resol, const int do_feather_isect))[2];
float (*BKE_mask_spline_feather_differentiated_points_with_resolution(struct MaskSpline *spline, int width, int height,
int *tot_feather_point, const int do_feather_isect))[2];
code cleanup: remove dead assignments, gave mask vars clearer names & moved some mask evaluation funcs into mask_evaluate.c
2012-08-26 18:09:01 +00:00
/* *** mask point functions which involve evaluation *** */
code cleanup: split out mask spline evaluation into its own file.
2012-08-26 13:41:40 +00:00
float (*BKE_mask_spline_feather_points(struct MaskSpline *spline, int *tot_feather_point))[2];
code cleanup: remove dead assignments, gave mask vars clearer names & moved some mask evaluation funcs into mask_evaluate.c
2012-08-26 18:09:01 +00:00
float *BKE_mask_point_segment_diff(struct MaskSpline *spline, struct MaskSplinePoint *point,
unsigned int *tot_diff_point);
float *BKE_mask_point_segment_feather_diff(struct MaskSpline *spline, struct MaskSplinePoint *point,
unsigned int *tot_feather_point);
float *BKE_mask_point_segment_diff_with_resolution(struct MaskSpline *spline, struct MaskSplinePoint *point,
int width, int height,
unsigned int *tot_diff_point);
float *BKE_mask_point_segment_feather_diff_with_resolution(struct MaskSpline *spline, struct MaskSplinePoint *point,
int width, int height,
unsigned int *tot_feather_point);
code cleanup: split out mask spline evaluation into its own file.
2012-08-26 13:41:40 +00:00
new mask rasterizer written to take advantage of the compositors threading, mostly functional but disabled by default (still a little wip).
2012-07-12 20:10:41 +00:00
/* mask_rasterize.c */
struct MaskRasterHandle;
typedef struct MaskRasterHandle MaskRasterHandle;
correct own naming error BLI -> BKE
2012-07-16 08:53:11 +00:00
MaskRasterHandle *BKE_maskrasterize_handle_new(void);
void BKE_maskrasterize_handle_free(MaskRasterHandle *mr_handle);
void BKE_maskrasterize_handle_init(MaskRasterHandle *mr_handle, struct Mask *mask,
new mask rasterizer written to take advantage of the compositors threading, mostly functional but disabled by default (still a little wip).
2012-07-12 20:10:41 +00:00
const int width, const int height,
const short do_aspect_correct, const short do_mask_aa,
const short do_feather);
correct own naming error BLI -> BKE
2012-07-16 08:53:11 +00:00
float BKE_maskrasterize_handle_sample(MaskRasterHandle *mr_handle, const float xy[2]);
use the same rasterizer as the compositor for the sequencer.
2012-07-31 15:45:01 +00:00
void BKE_maskrasterize_buffer(MaskRasterHandle *mr_handle,
const unsigned int width, const unsigned int height,
float *buffer);
new mask rasterizer written to take advantage of the compositors threading, mostly functional but disabled by default (still a little wip).
2012-07-12 20:10:41 +00:00
#endif /* __BKE_MASK_H__ */
Copy Permalink