archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

rename mask-objects to mask-layers.

Browse Source
This commit is contained in:
Campbell Barton
2012-05-31 19:12:22 +00:00
parent 3834134cf0
commit 192a28bb32
22 changed files with 668 additions and 668 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
release/scripts/startup/bl_ui/space_clip.py
View File

@@ -565,7 +565,7 @@ class CLIP_PT_tracking_camera(Panel):
class CLIP_PT_mask_objects(Panel):
bl_space_type = 'CLIP_EDITOR'
bl_region_type = 'UI'
bl_label = "Mask Objects"
bl_label = "Mask Layers"
@classmethod
def poll(cls, context):
@@ -580,15 +580,15 @@ class CLIP_PT_mask_objects(Panel):
mask = sc.mask
row = layout.row()
row.template_list(mask, "objects",
mask, "active_object_index", rows=3)
row.template_list(mask, "layers",
mask, "active_layer_index", rows=3)
sub = row.column(align=True)
sub.operator("mask.object_new", icon='ZOOMIN', text="")
sub.operator("mask.object_remove", icon='ZOOMOUT', text="")
sub.operator("mask.layer_new", icon='ZOOMIN', text="")
sub.operator("mask.layer_remove", icon='ZOOMOUT', text="")
active = mask.objects.active
active = mask.layers.active
if active:
layout.prop(active, "name")
@@ -611,7 +611,7 @@ class CLIP_PT_active_mask_spline(Panel):
mask = sc.mask
if mask and sc.mode == 'MASKEDITING':
return mask.objects.active and mask.objects.active.splines.active
return mask.layers.active and mask.layers.active.splines.active
return False
@@ -620,7 +620,7 @@ class CLIP_PT_active_mask_spline(Panel):
sc = context.space_data
mask = sc.mask
spline = mask.objects.active.splines.active
spline = mask.layers.active.splines.active
col = layout.column()
col.prop(spline, "weight_interpolation")
@@ -638,7 +638,7 @@ class CLIP_PT_active_mask_point(Panel):
mask = sc.mask
if mask and sc.mode == 'MASKEDITING':
return mask.objects.active and mask.objects.active.splines.active_point
return mask.layers.active and mask.layers.active.splines.active_point
return False
@@ -647,7 +647,7 @@ class CLIP_PT_active_mask_point(Panel):
sc = context.space_data
mask = sc.mask
point = mask.objects.active.splines.active_point
point = mask.layers.active.splines.active_point
parent = point.parent
col = layout.column()

60
source/blender/blenkernel/BKE_mask.h
View File

@@ -30,8 +30,8 @@
struct Main;
struct Mask;
struct MaskParent;
struct MaskObject;
struct MaskObjectShape;
struct MaskLayer;
struct MaskLayerShape;
struct MaskSpline;
struct MaskSplinePoint;
struct MaskSplinePointUW;
@@ -42,20 +42,20 @@ 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 objects */
struct MaskObject *BKE_mask_object_new(struct Mask *mask, const char *name);
struct MaskObject *BKE_mask_object_active(struct Mask *mask);
void BKE_mask_object_active_set(struct Mask *mask, struct MaskObject *maskobj);
void BKE_mask_object_remove(struct Mask *mask, struct MaskObject *maskobj);
/* 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);
void BKE_mask_object_free(struct MaskObject *maskobj);
void BKE_mask_layer_free(struct MaskLayer *masklay);
void BKE_mask_spline_free(struct MaskSpline *spline);
void BKE_mask_point_free(struct MaskSplinePoint *point);
void BKE_mask_object_unique_name(struct Mask *mask, struct MaskObject *maskobj);
void BKE_mask_layer_unique_name(struct Mask *mask, struct MaskLayer *masklay);
/* splines */
struct MaskSpline *BKE_mask_spline_add(struct MaskObject *maskobj);
struct MaskSpline *BKE_mask_spline_add(struct MaskLayer *masklay);
int BKE_mask_spline_resolution(struct MaskSpline *spline, float max_seg_len);
float (*BKE_mask_spline_differentiate(struct MaskSpline *spline, int *tot_diff_point, int dynamic_res, float max_dseg_len))[2];
@@ -107,31 +107,31 @@ void BKE_mask_calc_handles(struct Mask *mask);
void BKE_mask_spline_ensure_deform(struct MaskSpline *spline);
/* animation */
int BKE_mask_object_shape_totvert(struct MaskObject *maskobj);
void BKE_mask_object_shape_from_mask(struct MaskObject *maskobj, struct MaskObjectShape *maskobj_shape);
void BKE_mask_object_shape_to_mask(struct MaskObject *maskobj, struct MaskObjectShape *maskobj_shape);
void BKE_mask_object_shape_to_mask_interp(struct MaskObject *maskobj,
struct MaskObjectShape *maskobj_shape_a,
struct MaskObjectShape *maskobj_shape_b,
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);
struct MaskObjectShape *BKE_mask_object_shape_find_frame(struct MaskObject *maskobj, int frame);
int BKE_mask_object_shape_find_frame_range(struct MaskObject *maskobj, int frame,
struct MaskObjectShape **r_maskobj_shape_a,
struct MaskObjectShape **r_maskobj_shape_b);
struct MaskObjectShape *BKE_mask_object_shape_varify_frame(struct MaskObject *maskobj, int frame);
void BKE_mask_object_shape_unlink(struct MaskObject *maskobj, struct MaskObjectShape *maskobj_shape);
void BKE_mask_object_shape_sort(struct MaskObject *maskobj);
struct MaskLayerShape *BKE_mask_layer_shape_find_frame(struct MaskLayer *masklay, int frame);
int BKE_mask_layer_shape_find_frame_range(struct MaskLayer *masklay, int frame,
struct MaskLayerShape **r_masklay_shape_a,
struct MaskLayerShape **r_masklay_shape_b);
struct MaskLayerShape *BKE_mask_layer_shape_varify_frame(struct MaskLayer *masklay, int frame);
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_object_shape_spline_from_index(struct MaskObject *maskobj, int index,
struct MaskSpline **r_maskobj_shape, int *r_index);
int BKE_mask_object_shape_spline_to_index(struct MaskObject *maskobj, struct MaskSpline *spline);
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);
int BKE_mask_object_shape_spline_index(struct MaskObject *maskobj, int index,
struct MaskSpline **r_maskobj_shape, int *r_index);
void BKE_mask_object_shape_changed_add(struct MaskObject *maskobj, int index,
int BKE_mask_layer_shape_spline_index(struct MaskLayer *masklay, int index,
struct MaskSpline **r_masklay_shape, int *r_index);
void BKE_mask_layer_shape_changed_add(struct MaskLayer *masklay, int index,
int do_init, int do_init_interpolate);
void BKE_mask_object_shape_changed_remove(struct MaskObject *maskobj, int index, int count);
void BKE_mask_layer_shape_changed_remove(struct MaskLayer *masklay, int index, int count);
/* rasterization */
void BKE_mask_rasterize(struct Mask *mask, int width, int height, float *buffer);

404
source/blender/blenkernel/intern/mask.c
View File

@@ -77,63 +77,63 @@ MaskSplinePoint *BKE_mask_spline_point_array_from_point(MaskSpline *spline, Mask
return NULL;
}
/* mask objects */
/* mask layers */
MaskObject *BKE_mask_object_new(Mask *mask, const char *name)
MaskLayer *BKE_mask_layer_new(Mask *mask, const char *name)
{
MaskObject *maskobj = MEM_callocN(sizeof(MaskObject), "new mask object");
MaskLayer *masklay = MEM_callocN(sizeof(MaskLayer), __func__);
if (name && name[0])
BLI_strncpy(maskobj->name, name, sizeof(maskobj->name));
BLI_strncpy(masklay->name, name, sizeof(masklay->name));
else
strcpy(maskobj->name, "MaskObject");
strcpy(masklay->name, "MaskLayer");
BLI_addtail(&mask->maskobjs, maskobj);
BLI_addtail(&mask->masklayers, masklay);
BKE_mask_object_unique_name(mask, maskobj);
BKE_mask_layer_unique_name(mask, masklay);
mask->tot_maskobj++;
mask->masklay_tot++;
maskobj->alpha = 1.0f;
masklay->alpha = 1.0f;
return maskobj;
return masklay;
}
/* note: may still be hidden, caller needs to check */
MaskObject *BKE_mask_object_active(Mask *mask)
MaskLayer *BKE_mask_layer_active(Mask *mask)
{
return BLI_findlink(&mask->maskobjs, mask->act_maskobj);
return BLI_findlink(&mask->masklayers, mask->masklay_act);
}
void BKE_mask_object_active_set(Mask *mask, MaskObject *maskobj)
void BKE_mask_layer_active_set(Mask *mask, MaskLayer *masklay)
{
mask->act_maskobj = BLI_findindex(&mask->maskobjs, maskobj);
mask->masklay_act = BLI_findindex(&mask->masklayers, masklay);
}
void BKE_mask_object_remove(Mask *mask, MaskObject *maskobj)
void BKE_mask_layer_remove(Mask *mask, MaskLayer *masklay)
{
BLI_remlink(&mask->maskobjs, maskobj);
BKE_mask_object_free(maskobj);
BLI_remlink(&mask->masklayers, masklay);
BKE_mask_layer_free(masklay);
mask->tot_maskobj--;
mask->masklay_tot--;
if (mask->act_maskobj >= mask->tot_maskobj)
mask->act_maskobj = mask->tot_maskobj - 1;
if (mask->masklay_act >= mask->masklay_tot)
mask->masklay_act = mask->masklay_tot - 1;
}
void BKE_mask_object_unique_name(Mask *mask, MaskObject *maskobj)
void BKE_mask_layer_unique_name(Mask *mask, MaskLayer *masklay)
{
BLI_uniquename(&mask->maskobjs, maskobj, "MaskObject", '.', offsetof(MaskObject, name), sizeof(maskobj->name));
BLI_uniquename(&mask->masklayers, masklay, "MaskLayer", '.', offsetof(MaskLayer, name), sizeof(masklay->name));
}
/* splines */
MaskSpline *BKE_mask_spline_add(MaskObject *maskobj)
MaskSpline *BKE_mask_spline_add(MaskLayer *masklay)
{
MaskSpline *spline;
spline = MEM_callocN(sizeof(MaskSpline), "new mask spline");
BLI_addtail(&maskobj->splines, spline);
BLI_addtail(&masklay->splines, spline);
/* spline shall have one point at least */
spline->points = MEM_callocN(sizeof(MaskSplinePoint), "new mask spline point");
@@ -747,54 +747,54 @@ void BKE_mask_spline_free(MaskSpline *spline)
MEM_freeN(spline);
}
void BKE_mask_object_shape_free(MaskObjectShape *maskobj_shape)
void BKE_mask_layer_shape_free(MaskLayerShape *masklay_shape)
{
MEM_freeN(maskobj_shape->data);
MEM_freeN(masklay_shape->data);
MEM_freeN(maskobj_shape);
MEM_freeN(masklay_shape);
}
void BKE_mask_object_free(MaskObject *maskobj)
void BKE_mask_layer_free(MaskLayer *masklay)
{
MaskSpline *spline;
MaskObjectShape *maskobj_shape;
MaskLayerShape *masklay_shape;
/* free splines */
spline = maskobj->splines.first;
spline = masklay->splines.first;
while (spline) {
MaskSpline *next_spline = spline->next;
BLI_remlink(&maskobj->splines, spline);
BLI_remlink(&masklay->splines, spline);
BKE_mask_spline_free(spline);
spline = next_spline;
}
/* free animation data */
maskobj_shape = maskobj->splines_shapes.first;
while (maskobj_shape) {
MaskObjectShape *next_maskobj_shape = maskobj_shape->next;
masklay_shape = masklay->splines_shapes.first;
while (masklay_shape) {
MaskLayerShape *next_masklay_shape = masklay_shape->next;
BLI_remlink(&maskobj->splines_shapes, maskobj_shape);
BKE_mask_object_shape_free(maskobj_shape);
BLI_remlink(&masklay->splines_shapes, masklay_shape);
BKE_mask_layer_shape_free(masklay_shape);
maskobj_shape = next_maskobj_shape;
masklay_shape = next_masklay_shape;
}
MEM_freeN(maskobj);
MEM_freeN(masklay);
}
void BKE_mask_free(Mask *mask)
{
MaskObject *maskobj = mask->maskobjs.first;
MaskLayer *masklay = mask->masklayers.first;
while (maskobj) {
MaskObject *next_maskobj = maskobj->next;
while (masklay) {
MaskLayer *next_masklay = masklay->next;
BLI_remlink(&mask->maskobjs, maskobj);
BKE_mask_object_free(maskobj);
BLI_remlink(&mask->masklayers, masklay);
BKE_mask_layer_free(masklay);
maskobj = next_maskobj;
masklay = next_masklay;
}
}
@@ -1107,12 +1107,12 @@ void BKE_mask_calc_handle_point_auto(Mask *mask, MaskSpline *spline, MaskSplineP
void BKE_mask_calc_handles(Mask *mask)
{
MaskObject *maskobj;
MaskLayer *masklay;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
int i;
for (i = 0; i < spline->tot_point; i++) {
@@ -1129,12 +1129,12 @@ void BKE_mask_calc_handles(Mask *mask)
void BKE_mask_update_deform(Mask *mask)
{
MaskObject *maskobj;
MaskLayer *masklay;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
int i;
for (i = 0; i < spline->tot_point; i++) {
@@ -1192,35 +1192,35 @@ void BKE_mask_spline_ensure_deform(MaskSpline *spline)
void BKE_mask_evaluate(Mask *mask, float ctime, const int do_newframe)
{
MaskObject *maskobj;
MaskLayer *masklay;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
/* animation if available */
if (do_newframe) {
MaskObjectShape *maskobj_shape_a;
MaskObjectShape *maskobj_shape_b;
MaskLayerShape *masklay_shape_a;
MaskLayerShape *masklay_shape_b;
int found;
if ((found = BKE_mask_object_shape_find_frame_range(maskobj, (int)ctime,
&maskobj_shape_a, &maskobj_shape_b)))
if ((found = BKE_mask_layer_shape_find_frame_range(masklay, (int)ctime,
&masklay_shape_a, &masklay_shape_b)))
{
if (found == 1) {
#if 0
printf("%s: exact %d %d (%d)\n", __func__, (int)ctime, BLI_countlist(&maskobj->splines_shapes),
maskobj_shape_a->frame);
printf("%s: exact %d %d (%d)\n", __func__, (int)ctime, BLI_countlist(&masklay->splines_shapes),
masklay_shape_a->frame);
#endif
BKE_mask_object_shape_to_mask(maskobj, maskobj_shape_a);
BKE_mask_layer_shape_to_mask(masklay, masklay_shape_a);
}
else if (found == 2) {
float w = maskobj_shape_b->frame - maskobj_shape_a->frame;
float w = masklay_shape_b->frame - masklay_shape_a->frame;
#if 0
printf("%s: tween %d %d (%d %d)\n", __func__, (int)ctime, BLI_countlist(&maskobj->splines_shapes),
maskobj_shape_a->frame, maskobj_shape_b->frame);
printf("%s: tween %d %d (%d %d)\n", __func__, (int)ctime, BLI_countlist(&masklay->splines_shapes),
masklay_shape_a->frame, masklay_shape_b->frame);
#endif
BKE_mask_object_shape_to_mask_interp(maskobj, maskobj_shape_a, maskobj_shape_b,
(ctime - maskobj_shape_a->frame) / w);
BKE_mask_layer_shape_to_mask_interp(masklay, masklay_shape_a, masklay_shape_b,
(ctime - masklay_shape_a->frame) / w);
}
else {
/* always fail, should never happen */
@@ -1234,11 +1234,11 @@ void BKE_mask_evaluate(Mask *mask, float ctime, const int do_newframe)
BKE_mask_calc_handles(mask);
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
int i;
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
BKE_mask_spline_ensure_deform(spline);
@@ -1267,12 +1267,12 @@ void BKE_mask_evaluate(Mask *mask, float ctime, const int do_newframe)
void BKE_mask_update_display(Mask *mask, float ctime)
{
#if 0
MaskObject *maskobj;
MaskLayer *masklay;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
if (spline->points_deform) {
int i = 0;
@@ -1324,21 +1324,21 @@ void BKE_mask_parent_init(MaskParent *parent)
/* *** own animation/shapekey implimentation ***
* BKE_mask_object_shape_XXX */
* BKE_mask_layer_shape_XXX */
int BKE_mask_object_shape_totvert(MaskObject *maskobj)
int BKE_mask_layer_shape_totvert(MaskLayer *masklay)
{
int tot = 0;
MaskSpline *spline;
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
tot += spline->tot_point;
}
return tot;
}
static void mask_object_shape_from_mask_point(BezTriple *bezt, float fp[MASK_OBJECT_SHAPE_ELEM_SIZE])
static void mask_layer_shape_from_mask_point(BezTriple *bezt, float fp[MASK_OBJECT_SHAPE_ELEM_SIZE])
{
copy_v2_v2(&fp[0], bezt->vec[0]);
copy_v2_v2(&fp[2], bezt->vec[1]);
@@ -1347,7 +1347,7 @@ static void mask_object_shape_from_mask_point(BezTriple *bezt, float fp[MASK_OBJ
fp[7] = bezt->radius;
}
static void mask_object_shape_to_mask_point(BezTriple *bezt, float fp[MASK_OBJECT_SHAPE_ELEM_SIZE])
static void mask_layer_shape_to_mask_point(BezTriple *bezt, float fp[MASK_OBJECT_SHAPE_ELEM_SIZE])
{
copy_v2_v2(bezt->vec[0], &fp[0]);
copy_v2_v2(bezt->vec[1], &fp[2]);
@@ -1357,47 +1357,47 @@ static void mask_object_shape_to_mask_point(BezTriple *bezt, float fp[MASK_OBJEC
}
/* these functions match. copy is swapped */
void BKE_mask_object_shape_from_mask(MaskObject *maskobj, MaskObjectShape *maskobj_shape)
void BKE_mask_layer_shape_from_mask(MaskLayer *masklay, MaskLayerShape *masklay_shape)
{
int tot = BKE_mask_object_shape_totvert(maskobj);
int tot = BKE_mask_layer_shape_totvert(masklay);
if (maskobj_shape->tot_vert == tot) {
float *fp = maskobj_shape->data;
if (masklay_shape->tot_vert == tot) {
float *fp = masklay_shape->data;
MaskSpline *spline;
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
int i;
for (i = 0; i < spline->tot_point; i++) {
mask_object_shape_from_mask_point(&spline->points[i].bezt, fp);
mask_layer_shape_from_mask_point(&spline->points[i].bezt, fp);
fp += MASK_OBJECT_SHAPE_ELEM_SIZE;
}
}
}
else {
printf("%s: vert mismatch %d != %d (frame %d)\n",
__func__, maskobj_shape->tot_vert, tot, maskobj_shape->frame);
__func__, masklay_shape->tot_vert, tot, masklay_shape->frame);
}
}
void BKE_mask_object_shape_to_mask(MaskObject *maskobj, MaskObjectShape *maskobj_shape)
void BKE_mask_layer_shape_to_mask(MaskLayer *masklay, MaskLayerShape *masklay_shape)
{
int tot = BKE_mask_object_shape_totvert(maskobj);
int tot = BKE_mask_layer_shape_totvert(masklay);
if (maskobj_shape->tot_vert == tot) {
float *fp = maskobj_shape->data;
if (masklay_shape->tot_vert == tot) {
float *fp = masklay_shape->data;
MaskSpline *spline;
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
int i;
for (i = 0; i < spline->tot_point; i++) {
mask_object_shape_to_mask_point(&spline->points[i].bezt, fp);
mask_layer_shape_to_mask_point(&spline->points[i].bezt, fp);
fp += MASK_OBJECT_SHAPE_ELEM_SIZE;
}
}
}
else {
printf("%s: vert mismatch %d != %d (frame %d)\n",
__func__, maskobj_shape->tot_vert, tot, maskobj_shape->frame);
__func__, masklay_shape->tot_vert, tot, masklay_shape->frame);
}
}
@@ -1409,23 +1409,23 @@ BLI_INLINE void interp_v2_v2v2_flfl(float target[2], const float a[2], const flo
}
/* linear interpolation only */
void BKE_mask_object_shape_to_mask_interp(MaskObject *maskobj,
MaskObjectShape *maskobj_shape_a,
MaskObjectShape *maskobj_shape_b,
void BKE_mask_layer_shape_to_mask_interp(MaskLayer *masklay,
MaskLayerShape *masklay_shape_a,
MaskLayerShape *masklay_shape_b,
const float fac)
{
int tot = BKE_mask_object_shape_totvert(maskobj);
if (maskobj_shape_a->tot_vert == tot && maskobj_shape_b->tot_vert == tot) {
float *fp_a = maskobj_shape_a->data;
float *fp_b = maskobj_shape_b->data;
int tot = BKE_mask_layer_shape_totvert(masklay);
if (masklay_shape_a->tot_vert == tot && masklay_shape_b->tot_vert == tot) {
float *fp_a = masklay_shape_a->data;
float *fp_b = masklay_shape_b->data;
const float ifac = 1.0f - fac;
MaskSpline *spline;
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
int i;
for (i = 0; i < spline->tot_point; i++) {
BezTriple *bezt = &spline->points[i].bezt;
/* *** BKE_mask_object_shape_from_mask - swapped *** */
/* *** BKE_mask_layer_shape_from_mask - swapped *** */
interp_v2_v2v2_flfl(bezt->vec[0], fp_a, fp_b, fac, ifac); fp_a += 2; fp_b += 2;
interp_v2_v2v2_flfl(bezt->vec[1], fp_a, fp_b, fac, ifac); fp_a += 2; fp_b += 2;
interp_v2_v2v2_flfl(bezt->vec[2], fp_a, fp_b, fac, ifac); fp_a += 2; fp_b += 2;
@@ -1436,23 +1436,23 @@ void BKE_mask_object_shape_to_mask_interp(MaskObject *maskobj,
}
else {
printf("%s: vert mismatch %d != %d != %d (frame %d - %d)\n",
__func__, maskobj_shape_a->tot_vert, maskobj_shape_b->tot_vert, tot,
maskobj_shape_a->frame, maskobj_shape_b->frame);
__func__, masklay_shape_a->tot_vert, masklay_shape_b->tot_vert, tot,
masklay_shape_a->frame, masklay_shape_b->frame);
}
}
MaskObjectShape *BKE_mask_object_shape_find_frame(MaskObject *maskobj, int frame)
MaskLayerShape *BKE_mask_layer_shape_find_frame(MaskLayer *masklay, int frame)
{
MaskObjectShape *maskobj_shape;
MaskLayerShape *masklay_shape;
for (maskobj_shape = maskobj->splines_shapes.first;
maskobj_shape;
maskobj_shape = maskobj_shape->next)
for (masklay_shape = masklay->splines_shapes.first;
masklay_shape;
masklay_shape = masklay_shape->next)
{
if (frame == maskobj_shape->frame) {
return maskobj_shape;
if (frame == masklay_shape->frame) {
return masklay_shape;
}
else if (frame < maskobj_shape->frame) {
else if (frame < masklay_shape->frame) {
break;
}
}
@@ -1461,106 +1461,106 @@ MaskObjectShape *BKE_mask_object_shape_find_frame(MaskObject *maskobj, int frame
}
/* when returning 2 - the frame isnt found but before/after frames are */
int BKE_mask_object_shape_find_frame_range(MaskObject *maskobj, int frame,
MaskObjectShape **r_maskobj_shape_a,
MaskObjectShape **r_maskobj_shape_b)
int BKE_mask_layer_shape_find_frame_range(MaskLayer *masklay, int frame,
MaskLayerShape **r_masklay_shape_a,
MaskLayerShape **r_masklay_shape_b)
{
MaskObjectShape *maskobj_shape;
MaskLayerShape *masklay_shape;
for (maskobj_shape = maskobj->splines_shapes.first;
maskobj_shape;
maskobj_shape = maskobj_shape->next)
for (masklay_shape = masklay->splines_shapes.first;
masklay_shape;
masklay_shape = masklay_shape->next)
{
if (frame == maskobj_shape->frame) {
*r_maskobj_shape_a = maskobj_shape;
*r_maskobj_shape_b = NULL;
if (frame == masklay_shape->frame) {
*r_masklay_shape_a = masklay_shape;
*r_masklay_shape_b = NULL;
return 1;
}
else if (frame < maskobj_shape->frame) {
if (maskobj_shape->prev) {
*r_maskobj_shape_a = maskobj_shape->prev;
*r_maskobj_shape_b = maskobj_shape;
else if (frame < masklay_shape->frame) {
if (masklay_shape->prev) {
*r_masklay_shape_a = masklay_shape->prev;
*r_masklay_shape_b = masklay_shape;
return 2;
}
else {
*r_maskobj_shape_a = maskobj_shape;
*r_maskobj_shape_b = NULL;
*r_masklay_shape_a = masklay_shape;
*r_masklay_shape_b = NULL;
return 1;
}
}
}
*r_maskobj_shape_a = NULL;
*r_maskobj_shape_b = NULL;
*r_masklay_shape_a = NULL;
*r_masklay_shape_b = NULL;
return 0;
}
MaskObjectShape *BKE_mask_object_shape_varify_frame(MaskObject *maskobj, int frame)
MaskLayerShape *BKE_mask_layer_shape_varify_frame(MaskLayer *masklay, int frame)
{
MaskObjectShape *maskobj_shape;
MaskLayerShape *masklay_shape;
maskobj_shape = BKE_mask_object_shape_find_frame(maskobj, frame);
masklay_shape = BKE_mask_layer_shape_find_frame(masklay, frame);
if (maskobj_shape == NULL) {
int tot_vert = BKE_mask_object_shape_totvert(maskobj);
if (masklay_shape == NULL) {
int tot_vert = BKE_mask_layer_shape_totvert(masklay);
maskobj_shape = MEM_mallocN(sizeof(MaskObjectShape), __func__);
maskobj_shape->frame = frame;
maskobj_shape->tot_vert = tot_vert;
maskobj_shape->data = MEM_mallocN(tot_vert * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE, __func__);
masklay_shape = MEM_mallocN(sizeof(MaskLayerShape), __func__);
masklay_shape->frame = frame;
masklay_shape->tot_vert = tot_vert;
masklay_shape->data = MEM_mallocN(tot_vert * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE, __func__);
BLI_addtail(&maskobj->splines_shapes, maskobj_shape);
BLI_addtail(&masklay->splines_shapes, masklay_shape);
BKE_mask_object_shape_sort(maskobj);
BKE_mask_layer_shape_sort(masklay);
}
#if 0
{
MaskObjectShape *maskobj_shape;
MaskLayerShape *masklay_shape;
int i = 0;
for (maskobj_shape = maskobj->splines_shapes.first;
maskobj_shape;
maskobj_shape = maskobj_shape->next)
for (masklay_shape = masklay->splines_shapes.first;
masklay_shape;
masklay_shape = masklay_shape->next)
{
printf("mask %d, %d\n", i++, maskobj_shape->frame);
printf("mask %d, %d\n", i++, masklay_shape->frame);
}
}
#endif
return maskobj_shape;
return masklay_shape;
}
void BKE_mask_object_shape_unlink(MaskObject *maskobj, MaskObjectShape *maskobj_shape)
void BKE_mask_layer_shape_unlink(MaskLayer *masklay, MaskLayerShape *masklay_shape)
{
BLI_remlink(&maskobj->splines_shapes, maskobj_shape);
BLI_remlink(&masklay->splines_shapes, masklay_shape);
BKE_mask_object_shape_free(maskobj_shape);
BKE_mask_layer_shape_free(masklay_shape);
}
static int mask_object_shape_sort_cb(void *maskobj_shape_a_ptr, void *maskobj_shape_b_ptr)
static int mask_layer_shape_sort_cb(void *masklay_shape_a_ptr, void *masklay_shape_b_ptr)
{
MaskObjectShape *maskobj_shape_a = (MaskObjectShape *)maskobj_shape_a_ptr;
MaskObjectShape *maskobj_shape_b = (MaskObjectShape *)maskobj_shape_b_ptr;
MaskLayerShape *masklay_shape_a = (MaskLayerShape *)masklay_shape_a_ptr;
MaskLayerShape *masklay_shape_b = (MaskLayerShape *)masklay_shape_b_ptr;
if (maskobj_shape_a->frame < maskobj_shape_b->frame) return -1;
else if (maskobj_shape_a->frame > maskobj_shape_b->frame) return 1;
if (masklay_shape_a->frame < masklay_shape_b->frame) return -1;
else if (masklay_shape_a->frame > masklay_shape_b->frame) return 1;
else return 0;
}
void BKE_mask_object_shape_sort(MaskObject *maskobj)
void BKE_mask_layer_shape_sort(MaskLayer *masklay)
{
BLI_sortlist(&maskobj->splines_shapes, mask_object_shape_sort_cb);
BLI_sortlist(&masklay->splines_shapes, mask_layer_shape_sort_cb);
}
int BKE_mask_object_shape_spline_from_index(MaskObject *maskobj, int index,
MaskSpline **r_maskobj_shape, int *r_index)
int BKE_mask_layer_shape_spline_from_index(MaskLayer *masklay, int index,
MaskSpline **r_masklay_shape, int *r_index)
{
MaskSpline *spline;
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
if (index < spline->tot_point) {
*r_maskobj_shape = spline;
*r_masklay_shape = spline;
*r_index = index;
return TRUE;
}
@@ -1570,11 +1570,11 @@ int BKE_mask_object_shape_spline_from_index(MaskObject *maskobj, int index,
return FALSE;
}
int BKE_mask_object_shape_spline_to_index(MaskObject *maskobj, MaskSpline *spline)
int BKE_mask_layer_shape_spline_to_index(MaskLayer *masklay, MaskSpline *spline)
{
MaskSpline *spline_iter;
int i_abs = 0;
for (spline_iter = maskobj->splines.first;
for (spline_iter = masklay->splines.first;
spline_iter && spline_iter != spline;
i_abs += spline_iter->tot_point, spline_iter = spline_iter->next)
{
@@ -1608,21 +1608,21 @@ static void interp_weights_uv_v2_apply(const float uv[2], float r_pt[2], const f
}
/* when a now points added - resize all shapekey array */
void BKE_mask_object_shape_changed_add(MaskObject *maskobj, int index,
void BKE_mask_layer_shape_changed_add(MaskLayer *masklay, int index,
int do_init, int do_init_interpolate)
{
MaskObjectShape *maskobj_shape;
MaskLayerShape *masklay_shape;
/* spline index from maskobj */
/* spline index from masklay */
MaskSpline *spline;
int spline_point_index;
if (BKE_mask_object_shape_spline_from_index(maskobj, index,
if (BKE_mask_layer_shape_spline_from_index(masklay, index,
&spline, &spline_point_index))
{
/* sanity check */
/* the point has already been removed in this array so subtract one when comparing with the shapes */
int tot = BKE_mask_object_shape_totvert(maskobj) - 1;
int tot = BKE_mask_layer_shape_totvert(masklay) - 1;
/* for interpolation */
/* TODO - assumes closed curve for now */
@@ -1646,31 +1646,31 @@ void BKE_mask_object_shape_changed_add(MaskObject *maskobj, int index,
}
}
for (maskobj_shape = maskobj->splines_shapes.first;
maskobj_shape;
maskobj_shape = maskobj_shape->next)
for (masklay_shape = masklay->splines_shapes.first;
masklay_shape;
masklay_shape = masklay_shape->next)
{
if (tot == maskobj_shape->tot_vert) {
if (tot == masklay_shape->tot_vert) {
float *data_resized;
maskobj_shape->tot_vert++;
data_resized = MEM_mallocN(maskobj_shape->tot_vert * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE, __func__);
masklay_shape->tot_vert++;
data_resized = MEM_mallocN(masklay_shape->tot_vert * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE, __func__);
if (index > 0) {
memcpy(data_resized,
maskobj_shape->data,
masklay_shape->data,
index * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
}
if (index != maskobj_shape->tot_vert - 1) {
if (index != masklay_shape->tot_vert - 1) {
memcpy(&data_resized[(index + 1) * MASK_OBJECT_SHAPE_ELEM_SIZE],
maskobj_shape->data + (index * MASK_OBJECT_SHAPE_ELEM_SIZE),
(maskobj_shape->tot_vert - (index + 1)) * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
masklay_shape->data + (index * MASK_OBJECT_SHAPE_ELEM_SIZE),
(masklay_shape->tot_vert - (index + 1)) * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
}
if (do_init) {
float *fp = &data_resized[index * MASK_OBJECT_SHAPE_ELEM_SIZE];
mask_object_shape_from_mask_point(&spline->points[spline_point_index].bezt, fp);
mask_layer_shape_from_mask_point(&spline->points[spline_point_index].bezt, fp);
if (do_init_interpolate && spline->tot_point > 2) {
for (i = 0; i < 3; i++) {
@@ -1687,12 +1687,12 @@ void BKE_mask_object_shape_changed_add(MaskObject *maskobj, int index,
sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
}
MEM_freeN(maskobj_shape->data);
maskobj_shape->data = data_resized;
MEM_freeN(masklay_shape->data);
masklay_shape->data = data_resized;
}
else {
printf("%s: vert mismatch %d != %d (frame %d)\n",
__func__, maskobj_shape->tot_vert, tot, maskobj_shape->frame);
__func__, masklay_shape->tot_vert, tot, masklay_shape->frame);
}
}
}
@@ -1700,40 +1700,40 @@ void BKE_mask_object_shape_changed_add(MaskObject *maskobj, int index,
/* move array to account for removed point */
void BKE_mask_object_shape_changed_remove(MaskObject *maskobj, int index, int count)
void BKE_mask_layer_shape_changed_remove(MaskLayer *masklay, int index, int count)
{
MaskObjectShape *maskobj_shape;
MaskLayerShape *masklay_shape;
/* the point has already been removed in this array so add one when comparing with the shapes */
int tot = BKE_mask_object_shape_totvert(maskobj);
int tot = BKE_mask_layer_shape_totvert(masklay);
for (maskobj_shape = maskobj->splines_shapes.first;
maskobj_shape;
maskobj_shape = maskobj_shape->next)
for (masklay_shape = masklay->splines_shapes.first;
masklay_shape;
masklay_shape = masklay_shape->next)
{
if (tot == maskobj_shape->tot_vert - count) {
if (tot == masklay_shape->tot_vert - count) {
float *data_resized;
maskobj_shape->tot_vert -= count;
data_resized = MEM_mallocN(maskobj_shape->tot_vert * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE, __func__);
masklay_shape->tot_vert -= count;
data_resized = MEM_mallocN(masklay_shape->tot_vert * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE, __func__);
if (index > 0) {
memcpy(data_resized,
maskobj_shape->data,
masklay_shape->data,
index * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
}
if (index != maskobj_shape->tot_vert) {
if (index != masklay_shape->tot_vert) {
memcpy(&data_resized[index * MASK_OBJECT_SHAPE_ELEM_SIZE],
maskobj_shape->data + ((index + count) * MASK_OBJECT_SHAPE_ELEM_SIZE),
(maskobj_shape->tot_vert - index) * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
masklay_shape->data + ((index + count) * MASK_OBJECT_SHAPE_ELEM_SIZE),
(masklay_shape->tot_vert - index) * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE);
}
MEM_freeN(maskobj_shape->data);
maskobj_shape->data = data_resized;
MEM_freeN(masklay_shape->data);
masklay_shape->data = data_resized;
}
else {
printf("%s: vert mismatch %d != %d (frame %d)\n",
__func__, maskobj_shape->tot_vert - count, tot, maskobj_shape->frame);
__func__, masklay_shape->tot_vert - count, tot, masklay_shape->frame);
}
}
}
@@ -1775,7 +1775,7 @@ static void linear_clamp_vn_vn(float *array, const int size)
/* rasterization */
void BKE_mask_rasterize(Mask *mask, int width, int height, float *buffer)
{
MaskObject *maskobj;
MaskLayer *masklay;
/* temp blending buffer */
const int buffer_size = width * height;
@@ -1789,17 +1789,17 @@ void BKE_mask_rasterize(Mask *mask, int width, int height, float *buffer)
}
max_dseg_len = 1.0f / max_dseg_len;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
float alpha;
if (maskobj->restrictflag & MASK_RESTRICT_RENDER) {
if (masklay->restrictflag & MASK_RESTRICT_RENDER) {
continue;
}
memset(buffer_tmp, 0, sizeof(float) * buffer_size);
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
float (*diff_points)[2];
int tot_diff_point;
@@ -1853,10 +1853,10 @@ void BKE_mask_rasterize(Mask *mask, int width, int height, float *buffer)
}
/* blend with original */
if (maskobj->blend_flag & MASK_BLENDFLAG_INVERT) {
if (masklay->blend_flag & MASK_BLENDFLAG_INVERT) {
/* apply alpha multiply before inverting */
if (maskobj->alpha != 1.0f) {
m_invert_vn_vn(buffer_tmp, maskobj->alpha, buffer_size);
if (masklay->alpha != 1.0f) {
m_invert_vn_vn(buffer_tmp, masklay->alpha, buffer_size);
}
else {
invert_vn_vn(buffer_tmp, buffer_size);
@@ -1865,10 +1865,10 @@ void BKE_mask_rasterize(Mask *mask, int width, int height, float *buffer)
alpha = 1.0f;
}
else {
alpha = maskobj->alpha;
alpha = masklay->alpha;
}
switch (maskobj->blend) {
switch (masklay->blend) {
case MASK_BLEND_SUBTRACT:
{
if (alpha == 1.0f) {

28
source/blender/blenloader/intern/readfile.c
View File

@@ -6182,19 +6182,19 @@ static void lib_link_movieclip(FileData *fd, Main *main)
static void direct_link_mask(FileData *fd, Mask *mask)
{
MaskObject *maskobj;
MaskLayer *masklay;
mask->adt = newdataadr(fd, mask->adt);
link_list(fd, &mask->maskobjs);
link_list(fd, &mask->masklayers);
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
MaskObjectShape *maskobj_shape;
MaskLayerShape *masklay_shape;
link_list(fd, &maskobj->splines);
link_list(fd, &masklay->splines);
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
int i;
spline->points = newdataadr(fd, spline->points);
@@ -6207,14 +6207,14 @@ static void direct_link_mask(FileData *fd, Mask *mask)
}
}
link_list(fd, &maskobj->splines_shapes);
link_list(fd, &masklay->splines_shapes);
for (maskobj_shape = maskobj->splines_shapes.first; maskobj_shape; maskobj_shape = maskobj_shape->next) {
maskobj_shape->data = newdataadr(fd, maskobj_shape->data);
for (masklay_shape = masklay->splines_shapes.first; masklay_shape; masklay_shape = masklay_shape->next) {
masklay_shape->data = newdataadr(fd, masklay_shape->data);
}
maskobj->act_spline = newdataadr(fd, maskobj->act_spline);
maskobj->act_point = newdataadr(fd, maskobj->act_point);
masklay->act_spline = newdataadr(fd, masklay->act_spline);
masklay->act_point = newdataadr(fd, masklay->act_point);
}
}
@@ -6230,15 +6230,15 @@ static void lib_link_mask(FileData *fd, Main *main)
mask = main->mask.first;
while (mask) {
if(mask->id.flag & LIB_NEEDLINK) {
MaskObject *maskobj;
MaskLayer *masklay;
if (mask->adt)
lib_link_animdata(fd, &mask->id, mask->adt);
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
spline = maskobj->splines.first;
spline = masklay->splines.first;
while (spline) {
int i;

16
source/blender/blenloader/intern/writefile.c
View File

@@ -2760,20 +2760,20 @@ static void write_masks(WriteData *wd, ListBase *idbase)
mask = idbase->first;
while (mask) {
if (mask->id.us > 0 || wd->current) {
MaskObject *maskobj;
MaskLayer *masklay;
writestruct(wd, ID_MSK, "Mask", 1, mask);
if (mask->adt)
write_animdata(wd, mask->adt);
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
MaskObjectShape *maskobj_shape;
MaskLayerShape *masklay_shape;
writestruct(wd, DATA, "MaskObject", 1, maskobj);
writestruct(wd, DATA, "MaskLayer", 1, masklay);
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
int i;
void *points_deform = spline->points_deform;
@@ -2792,9 +2792,9 @@ static void write_masks(WriteData *wd, ListBase *idbase)
}
}
for (maskobj_shape = maskobj->splines_shapes.first; maskobj_shape; maskobj_shape = maskobj_shape->next) {
writestruct(wd, DATA, "MaskObjectShape", 1, maskobj_shape);
writedata(wd, DATA, maskobj_shape->tot_vert * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE, maskobj_shape->data);
for (masklay_shape = masklay->splines_shapes.first; masklay_shape; masklay_shape = masklay_shape->next) {
writestruct(wd, DATA, "MaskLayerShape", 1, masklay_shape);
writedata(wd, DATA, masklay_shape->tot_vert * sizeof(float) * MASK_OBJECT_SHAPE_ELEM_SIZE, masklay_shape->data);
}
}
}

44
source/blender/editors/animation/keyframes_draw.c
View File

@@ -188,28 +188,28 @@ static void nupdate_ak_gpframe(void *node, void *data)
/* ......... */
/* Comparator callback used for ActKeyColumns and GPencil frame */
static short compare_ak_maskobjshape(void *node, void *data)
static short compare_ak_masklayshape(void *node, void *data)
{
ActKeyColumn *ak = (ActKeyColumn *)node;
MaskObjectShape *maskobj_shape = (MaskObjectShape *)data;
MaskLayerShape *masklay_shape = (MaskLayerShape *)data;
if (maskobj_shape->frame < ak->cfra)
if (masklay_shape->frame < ak->cfra)
return -1;
else if (maskobj_shape->frame > ak->cfra)
else if (masklay_shape->frame > ak->cfra)
return 1;
else
return 0;
}
/* New node callback used for building ActKeyColumns from GPencil frames */
static DLRBT_Node *nalloc_ak_maskobjshape(void *data)
static DLRBT_Node *nalloc_ak_masklayshape(void *data)
{
ActKeyColumn *ak = MEM_callocN(sizeof(ActKeyColumn), "ActKeyColumnGPF");
MaskObjectShape *maskobj_shape = (MaskObjectShape *)data;
MaskLayerShape *masklay_shape = (MaskLayerShape *)data;
/* store settings based on state of BezTriple */
ak->cfra = maskobj_shape->frame;
ak->sel = (maskobj_shape->flag & SELECT) ? SELECT : 0;
ak->cfra = masklay_shape->frame;
ak->sel = (masklay_shape->flag & SELECT) ? SELECT : 0;
/* set 'modified', since this is used to identify long keyframes */
ak->modified = 1;
@@ -218,13 +218,13 @@ static DLRBT_Node *nalloc_ak_maskobjshape(void *data)
}
/* Node updater callback used for building ActKeyColumns from GPencil frames */
static void nupdate_ak_maskobjshape(void *node, void *data)
static void nupdate_ak_masklayshape(void *node, void *data)
{
ActKeyColumn *ak = (ActKeyColumn *)node;
MaskObjectShape *maskobj_shape = (MaskObjectShape *)data;
MaskLayerShape *masklay_shape = (MaskLayerShape *)data;
/* set selection status and 'touched' status */
if (maskobj_shape->flag & SELECT) ak->sel = SELECT;
if (masklay_shape->flag & SELECT) ak->sel = SELECT;
ak->modified += 1;
}
@@ -249,13 +249,13 @@ static void add_gpframe_to_keycolumns_list(DLRBT_Tree *keys, bGPDframe *gpf)
BLI_dlrbTree_add(keys, compare_ak_gpframe, nalloc_ak_gpframe, nupdate_ak_gpframe, gpf);
}
/* Add the given MaskObjectShape Frame to the given 'list' of Keyframes */
static void add_maskobj_to_keycolumns_list(DLRBT_Tree *keys, MaskObjectShape *maskobj_shape)
/* Add the given MaskLayerShape Frame to the given 'list' of Keyframes */
static void add_masklay_to_keycolumns_list(DLRBT_Tree *keys, MaskLayerShape *masklay_shape)
{
if (ELEM(NULL, keys, maskobj_shape))
if (ELEM(NULL, keys, masklay_shape))
return;
else
BLI_dlrbTree_add(keys, compare_ak_maskobjshape, nalloc_ak_maskobjshape, nupdate_ak_maskobjshape, maskobj_shape);
BLI_dlrbTree_add(keys, compare_ak_masklayshape, nalloc_ak_masklayshape, nupdate_ak_masklayshape, masklay_shape);
}
/* ActBeztColumns (Helpers for Long Keyframes) ------------------------------ */
@@ -994,16 +994,16 @@ void gpl_to_keylist(bDopeSheet *UNUSED(ads), bGPDlayer *gpl, DLRBT_Tree *keys)
}
}
void mask_to_keylist(bDopeSheet *UNUSED(ads), MaskObject *maskobj, DLRBT_Tree *keys)
void mask_to_keylist(bDopeSheet *UNUSED(ads), MaskLayer *masklay, DLRBT_Tree *keys)
{
MaskObjectShape *maskobj_shape;
MaskLayerShape *masklay_shape;
if (maskobj && keys) {
for (maskobj_shape = maskobj->splines_shapes.first;
maskobj_shape;
maskobj_shape = maskobj_shape->next)
if (masklay && keys) {
for (masklay_shape = masklay->splines_shapes.first;
masklay_shape;
masklay_shape = masklay_shape->next)
{
add_maskobj_to_keycolumns_list(keys, maskobj_shape);
add_masklay_to_keycolumns_list(keys, masklay_shape);
}
}
}

4
source/blender/editors/include/ED_keyframes_draw.h
View File

@@ -42,7 +42,7 @@ struct bActionGroup;
struct Object;
struct ListBase;
struct bGPDlayer;
struct MaskObject;
struct MaskLayer;
struct Scene;
struct View2D;
struct DLRBT_Tree;
@@ -142,7 +142,7 @@ void summary_to_keylist(struct bAnimContext *ac, struct DLRBT_Tree *keys, struct
void gpl_to_keylist(struct bDopeSheet *ads, struct bGPDlayer *gpl, struct DLRBT_Tree *keys);
/* Mask */
// XXX not restored
void mask_to_keylist(struct bDopeSheet *UNUSED(ads), struct MaskObject *maskobj, struct DLRBT_Tree *keys);
void mask_to_keylist(struct bDopeSheet *UNUSED(ads), struct MaskLayer *masklay, struct DLRBT_Tree *keys);
/* ActKeyColumn API ---------------- */
/* Comparator callback used for ActKeyColumns and cframe float-value pointer */

2
source/blender/editors/include/ED_mask.h
View File

@@ -42,6 +42,6 @@ void ED_operatormacros_mask(void);
void ED_mask_draw(const bContext *C, const char draw_flag, const char draw_type);
/* mask_shapekey.c */
int ED_mask_object_shape_auto_key_all(struct Mask *mask, const int frame);
int ED_mask_layer_shape_auto_key_all(struct Mask *mask, const int frame);
#endif /* ED_TEXT_H */

2
source/blender/editors/interface/interface_templates.c
View File

@@ -2241,7 +2241,7 @@ static void list_item_row(bContext *C, uiLayout *layout, PointerRNA *ptr, Pointe
uiItemL(split, name, ICON_OBJECT_DATA);
}
}
else if (itemptr->type == &RNA_MaskObject) {
else if (itemptr->type == &RNA_MaskLayer) {
split = uiLayoutSplit(sub, 0.66f, 0);
uiItemL(split, name, icon);

54
source/blender/editors/mask/mask_draw.c
View File

@@ -49,11 +49,11 @@
#include "mask_intern.h" /* own include */
static void mask_spline_color_get(MaskObject *maskobj, MaskSpline *spline, const int is_sel,
static void mask_spline_color_get(MaskLayer *masklay, MaskSpline *spline, const int is_sel,
unsigned char r_rgb[4])
{
if (is_sel) {
if (maskobj->act_spline == spline) {
if (masklay->act_spline == spline) {
r_rgb[0] = r_rgb[1] = r_rgb[2] = 255;
}
else {
@@ -69,7 +69,7 @@ static void mask_spline_color_get(MaskObject *maskobj, MaskSpline *spline, const
r_rgb[3] = 255;
}
static void mask_spline_feather_color_get(MaskObject *UNUSED(maskobj), MaskSpline *UNUSED(spline), const int is_sel,
static void mask_spline_feather_color_get(MaskLayer *UNUSED(masklay), MaskSpline *UNUSED(spline), const int is_sel,
unsigned char r_rgb[4])
{
if (is_sel) {
@@ -85,7 +85,7 @@ static void mask_spline_feather_color_get(MaskObject *UNUSED(maskobj), MaskSplin
}
#if 0
static void draw_spline_parents(MaskObject *UNUSED(maskobj), MaskSpline *spline)
static void draw_spline_parents(MaskLayer *UNUSED(masklay), MaskSpline *spline)
{
int i;
MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
@@ -119,9 +119,9 @@ static void draw_spline_parents(MaskObject *UNUSED(maskobj), MaskSpline *spline)
#endif
/* return non-zero if spline is selected */
static void draw_spline_points(MaskObject *maskobj, MaskSpline *spline)
static void draw_spline_points(MaskLayer *masklay, MaskSpline *spline)
{
const int is_spline_sel = (spline->flag & SELECT) && (maskobj->restrictflag & MASK_RESTRICT_SELECT) == 0;
const int is_spline_sel = (spline->flag & SELECT) && (masklay->restrictflag & MASK_RESTRICT_SELECT) == 0;
unsigned char rgb_spline[4];
MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
@@ -135,7 +135,7 @@ static void draw_spline_points(MaskObject *maskobj, MaskSpline *spline)
glPointSize(hsize);
mask_spline_color_get(maskobj, spline, is_spline_sel, rgb_spline);
mask_spline_color_get(masklay, spline, is_spline_sel, rgb_spline);
/* feather points */
feather_points = fp = BKE_mask_spline_feather_points(spline, &tot_feather_point);
@@ -157,7 +157,7 @@ static void draw_spline_points(MaskObject *maskobj, MaskSpline *spline)
}
if (sel) {
if (point == maskobj->act_point)
if (point == masklay->act_point)
glColor3f(1.0f, 1.0f, 1.0f);
else
glColor3f(1.0f, 1.0f, 0.0f);
@@ -201,7 +201,7 @@ static void draw_spline_points(MaskObject *maskobj, MaskSpline *spline)
/* draw CV point */
if (MASKPOINT_ISSEL_KNOT(point)) {
if (point == maskobj->act_point)
if (point == masklay->act_point)
glColor3f(1.0f, 1.0f, 1.0f);
else
glColor3f(1.0f, 1.0f, 0.0f);
@@ -216,7 +216,7 @@ static void draw_spline_points(MaskObject *maskobj, MaskSpline *spline)
/* draw handle points */
if (has_handle) {
if (MASKPOINT_ISSEL_HANDLE(point)) {
if (point == maskobj->act_point)
if (point == masklay->act_point)
glColor3f(1.0f, 1.0f, 1.0f);
else
glColor3f(1.0f, 1.0f, 0.0f);
@@ -322,12 +322,12 @@ static void mask_draw_curve_type(MaskSpline *spline, float (*points)[2], int tot
}
static void draw_spline_curve(MaskObject *maskobj, MaskSpline *spline,
static void draw_spline_curve(MaskLayer *masklay, MaskSpline *spline,
const char draw_flag, const char draw_type)
{
unsigned char rgb_tmp[4];
const short is_spline_sel = (spline->flag & SELECT) && (maskobj->restrictflag & MASK_RESTRICT_SELECT) == 0;
const short is_spline_sel = (spline->flag & SELECT) && (masklay->restrictflag & MASK_RESTRICT_SELECT) == 0;
const short is_smooth = (draw_flag & MASK_DRAWFLAG_SMOOTH);
int tot_diff_point;
@@ -350,14 +350,14 @@ static void draw_spline_curve(MaskObject *maskobj, MaskSpline *spline,
feather_points = BKE_mask_spline_feather_differentiated_points(spline, &tot_feather_point, 0, 0.0f);
/* draw feather */
mask_spline_feather_color_get(maskobj, spline, is_spline_sel, rgb_tmp);
mask_spline_feather_color_get(masklay, spline, is_spline_sel, rgb_tmp);
mask_draw_curve_type(spline, feather_points, tot_feather_point,
TRUE, is_smooth,
rgb_tmp, draw_type);
MEM_freeN(feather_points);
/* draw main curve */
mask_spline_color_get(maskobj, spline, is_spline_sel, rgb_tmp);
mask_spline_color_get(masklay, spline, is_spline_sel, rgb_tmp);
mask_draw_curve_type(spline, diff_points, tot_diff_point,
FALSE, is_smooth,
rgb_tmp, draw_type);
@@ -371,28 +371,28 @@ static void draw_spline_curve(MaskObject *maskobj, MaskSpline *spline,
(void)draw_type;
}
static void draw_maskobjs(Mask *mask,
static void draw_masklays(Mask *mask,
const char draw_flag, const char draw_type)
{
MaskObject *maskobj;
MaskLayer *masklay;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
if (maskobj->restrictflag & MASK_RESTRICT_VIEW) {
if (masklay->restrictflag & MASK_RESTRICT_VIEW) {
continue;
}
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
/* draw curve itself first... */
draw_spline_curve(maskobj, spline, draw_flag, draw_type);
draw_spline_curve(masklay, spline, draw_flag, draw_type);
// draw_spline_parents(maskobj, spline);
// draw_spline_parents(masklay, spline);
if (!(maskobj->restrictflag & MASK_RESTRICT_SELECT)) {
if (!(masklay->restrictflag & MASK_RESTRICT_SELECT)) {
/* ...and then handles over the curve so they're nicely visible */
draw_spline_points(maskobj, spline);
draw_spline_points(masklay, spline);
}
/* show undeform for testing */
@@ -400,9 +400,9 @@ static void draw_maskobjs(Mask *mask,
void *back = spline->points_deform;
spline->points_deform = NULL;
draw_spline_curve(maskobj, spline, draw_flag, draw_type);
// draw_spline_parents(maskobj, spline);
draw_spline_points(maskobj, spline);
draw_spline_curve(masklay, spline, draw_flag, draw_type);
// draw_spline_parents(masklay, spline);
draw_spline_points(masklay, spline);
spline->points_deform = back;
}
}
@@ -417,5 +417,5 @@ void ED_mask_draw(const bContext *C,
if (!mask)
return;
draw_maskobjs(mask, draw_flag, draw_type);
draw_masklays(mask, draw_flag, draw_type);
}

6
source/blender/editors/mask/mask_editor.c
View File

@@ -189,9 +189,9 @@ void ED_operatortypes_mask(void)
{
WM_operatortype_append(MASK_OT_new);
/* mask objects */
WM_operatortype_append(MASK_OT_object_new);
WM_operatortype_append(MASK_OT_object_remove);
/* mask layers */
WM_operatortype_append(MASK_OT_layer_new);
WM_operatortype_append(MASK_OT_layer_remove);
/* geometry */
WM_operatortype_append(MASK_OT_add_vertex);

12
source/blender/editors/mask/mask_intern.h
View File

@@ -40,8 +40,8 @@ struct wmOperatorType;
/* mask_ops.c */
void MASK_OT_new(struct wmOperatorType *ot);
void MASK_OT_object_new(struct wmOperatorType *ot);
void MASK_OT_object_remove(struct wmOperatorType *ot);
void MASK_OT_layer_new(struct wmOperatorType *ot);
void MASK_OT_layer_remove(struct wmOperatorType *ot);
void MASK_OT_add_vertex(struct wmOperatorType *ot);
void MASK_OT_add_feather_vertex(struct wmOperatorType *ot);
@@ -58,12 +58,12 @@ void MASK_OT_handle_type_set(struct wmOperatorType *ot);
int ED_mask_feather_find_nearest(
struct bContext *C, struct Mask *mask, float normal_co[2], int threshold,
struct MaskObject **maskobj_r, struct MaskSpline **spline_r, struct MaskSplinePoint **point_r,
struct MaskLayer **masklay_r, struct MaskSpline **spline_r, struct MaskSplinePoint **point_r,
struct MaskSplinePointUW **uw_r, float *score);
struct MaskSplinePoint *ED_mask_point_find_nearest(
struct bContext *C, struct Mask *mask, float normal_co[2], int threshold,
struct MaskObject **maskobj_r, struct MaskSpline **spline_r, int *is_handle_r,
struct MaskLayer **masklay_r, struct MaskSpline **spline_r, int *is_handle_r,
float *score);
/* mask_relationships.c */
@@ -79,10 +79,10 @@ void MASK_OT_select_lasso(struct wmOperatorType *ot);
void MASK_OT_select_circle(struct wmOperatorType *ot);
int ED_mask_spline_select_check(struct MaskSplinePoint *points, int tot_point);
int ED_mask_object_select_check(struct MaskObject *maskobj);
int ED_mask_layer_select_check(struct MaskLayer *masklay);
int ED_mask_select_check(struct Mask *mask);
void ED_mask_object_select_set(struct MaskObject *maskobj, int select);
void ED_mask_layer_select_set(struct MaskLayer *masklay, int select);
void ED_mask_select_toggle_all(struct Mask *mask, int action);
void ED_mask_select_flush_all(struct Mask *mask);

286
source/blender/editors/mask/mask_ops.c
View File

@@ -122,11 +122,11 @@ static float projection_on_spline(MaskSpline *spline, MaskSplinePoint *point, fl
}
MaskSplinePoint *ED_mask_point_find_nearest(bContext *C, Mask *mask, float normal_co[2], int threshold,
MaskObject **maskobj_r, MaskSpline **spline_r, int *is_handle_r,
MaskLayer **masklay_r, MaskSpline **spline_r, int *is_handle_r,
float *score)
{
MaskObject *maskobj;
MaskObject *point_maskobj = NULL;
MaskLayer *masklay;
MaskLayer *point_masklay = NULL;
MaskSpline *point_spline = NULL;
MaskSplinePoint *point = NULL;
float co[2], aspx, aspy;
@@ -140,14 +140,14 @@ MaskSplinePoint *ED_mask_point_find_nearest(bContext *C, Mask *mask, float norma
co[0] = normal_co[0] * scalex;
co[1] = normal_co[1] * scaley;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
if (maskobj->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
continue;
}
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
int i;
@@ -168,7 +168,7 @@ MaskSplinePoint *ED_mask_point_find_nearest(bContext *C, Mask *mask, float norma
cur_len = len_v2v2(co, handle);
if (cur_len < len) {
point_maskobj = maskobj;
point_masklay = masklay;
point_spline = spline;
point = cur_point;
len = cur_len;
@@ -180,7 +180,7 @@ MaskSplinePoint *ED_mask_point_find_nearest(bContext *C, Mask *mask, float norma
if (cur_len < len) {
point_spline = spline;
point_maskobj = maskobj;
point_masklay = masklay;
point = cur_point;
len = cur_len;
is_handle = FALSE;
@@ -190,8 +190,8 @@ MaskSplinePoint *ED_mask_point_find_nearest(bContext *C, Mask *mask, float norma
}
if (len < threshold) {
if (maskobj_r)
*maskobj_r = point_maskobj;
if (masklay_r)
*masklay_r = point_masklay;
if (spline_r)
*spline_r = point_spline;
@@ -205,8 +205,8 @@ MaskSplinePoint *ED_mask_point_find_nearest(bContext *C, Mask *mask, float norma
return point;
}
if (maskobj_r)
*maskobj_r = NULL;
if (masklay_r)
*masklay_r = NULL;
if (spline_r)
*spline_r = NULL;
@@ -218,10 +218,10 @@ MaskSplinePoint *ED_mask_point_find_nearest(bContext *C, Mask *mask, float norma
}
int ED_mask_feather_find_nearest(bContext *C, Mask *mask, float normal_co[2], int threshold,
MaskObject **maskobj_r, MaskSpline **spline_r, MaskSplinePoint **point_r,
MaskLayer **masklay_r, MaskSpline **spline_r, MaskSplinePoint **point_r,
MaskSplinePointUW **uw_r, float *score)
{
MaskObject *maskobj, *point_maskobj = NULL;
MaskLayer *masklay, *point_masklay = NULL;
MaskSpline *point_spline = NULL;
MaskSplinePoint *point = NULL;
MaskSplinePointUW *uw = NULL;
@@ -236,16 +236,16 @@ int ED_mask_feather_find_nearest(bContext *C, Mask *mask, float normal_co[2], in
co[0] = normal_co[0] * scalex;
co[1] = normal_co[1] * scaley;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
//MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
int i, tot_feather_point;
float (*feather_points)[2], (*fp)[2];
if (maskobj->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
continue;
}
@@ -269,7 +269,7 @@ int ED_mask_feather_find_nearest(bContext *C, Mask *mask, float normal_co[2], in
else
uw = &cur_point->uw[j - 1];
point_maskobj = maskobj;
point_masklay = masklay;
point_spline = spline;
point = cur_point;
len = cur_len;
@@ -284,8 +284,8 @@ int ED_mask_feather_find_nearest(bContext *C, Mask *mask, float normal_co[2], in
}
if (len < threshold) {
if (maskobj_r)
*maskobj_r = point_maskobj;
if (masklay_r)
*masklay_r = point_masklay;
if (spline_r)
*spline_r = point_spline;
@@ -302,8 +302,8 @@ int ED_mask_feather_find_nearest(bContext *C, Mask *mask, float normal_co[2], in
return TRUE;
}
if (maskobj_r)
*maskobj_r = NULL;
if (masklay_r)
*masklay_r = NULL;
if (spline_r)
*spline_r = NULL;
@@ -315,10 +315,10 @@ int ED_mask_feather_find_nearest(bContext *C, Mask *mask, float normal_co[2], in
}
static int find_nearest_diff_point(bContext *C, Mask *mask, const float normal_co[2], int threshold, int feather,
MaskObject **maskobj_r, MaskSpline **spline_r, MaskSplinePoint **point_r,
MaskLayer **masklay_r, MaskSpline **spline_r, MaskSplinePoint **point_r,
float *u_r, float tangent[2])
{
MaskObject *maskobj, *point_maskobj;
MaskLayer *masklay, *point_masklay;
MaskSpline *point_spline;
MaskSplinePoint *point = NULL;
float dist, co[2];
@@ -333,14 +333,14 @@ static int find_nearest_diff_point(bContext *C, Mask *mask, const float normal_c
co[0] = normal_co[0] * scalex;
co[1] = normal_co[1] * scaley;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
if (maskobj->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
continue;
}
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
int i;
for (i = 0; i < spline->tot_point; i++) {
@@ -381,7 +381,7 @@ static int find_nearest_diff_point(bContext *C, Mask *mask, const float normal_c
if (tangent)
sub_v2_v2v2(tangent, &diff_points[2 * i + 2], &diff_points[2 * i]);
point_maskobj = maskobj;
point_masklay = masklay;
point_spline = spline;
point = cur_point;
dist = cur_dist;
@@ -400,8 +400,8 @@ static int find_nearest_diff_point(bContext *C, Mask *mask, const float normal_c
}
if (point && dist < threshold) {
if (maskobj_r)
*maskobj_r = point_maskobj;
if (masklay_r)
*masklay_r = point_masklay;
if (spline_r)
*spline_r = point_spline;
@@ -418,8 +418,8 @@ static int find_nearest_diff_point(bContext *C, Mask *mask, const float normal_c
return TRUE;
}
if (maskobj_r)
*maskobj_r = NULL;
if (masklay_r)
*masklay_r = NULL;
if (spline_r)
*spline_r = NULL;
@@ -466,50 +466,50 @@ void MASK_OT_new(wmOperatorType *ot)
RNA_def_string(ot->srna, "name", "", MAX_ID_NAME - 2, "Name", "Name of new mask");
}
/******************** create new maskobj *********************/
/******************** create new masklay *********************/
static int maskobj_new_exec(bContext *C, wmOperator *op)
static int masklay_new_exec(bContext *C, wmOperator *op)
{
Mask *mask = CTX_data_edit_mask(C);
char name[MAX_ID_NAME - 2];
RNA_string_get(op->ptr, "name", name);
BKE_mask_object_new(mask, name);
mask->act_maskobj = mask->tot_maskobj - 1;
BKE_mask_layer_new(mask, name);
mask->masklay_act = mask->masklay_tot - 1;
WM_event_add_notifier(C, NC_MASK | NA_EDITED, mask);
return OPERATOR_FINISHED;
}
void MASK_OT_object_new(wmOperatorType *ot)
void MASK_OT_layer_new(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Add Mask Object";
ot->description = "Add new mask object for masking";
ot->idname = "MASK_OT_object_new";
ot->name = "Add Mask Layer";
ot->description = "Add new mask layer for masking";
ot->idname = "MASK_OT_layer_new";
/* api callbacks */
ot->exec = maskobj_new_exec;
ot->exec = masklay_new_exec;
ot->poll = ED_maskediting_poll;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
/* properties */
RNA_def_string(ot->srna, "name", "", MAX_ID_NAME - 2, "Name", "Name of new mask object");
RNA_def_string(ot->srna, "name", "", MAX_ID_NAME - 2, "Name", "Name of new mask layer");
}
/******************** remove mask object *********************/
/******************** remove mask layer *********************/
static int maskobj_remove_exec(bContext *C, wmOperator *UNUSED(op))
static int masklay_remove_exec(bContext *C, wmOperator *UNUSED(op))
{
Mask *mask = CTX_data_edit_mask(C);
MaskObject *maskobj = BKE_mask_object_active(mask);
MaskLayer *masklay = BKE_mask_layer_active(mask);
if (maskobj) {
BKE_mask_object_remove(mask, maskobj);
if (masklay) {
BKE_mask_layer_remove(mask, masklay);
WM_event_add_notifier(C, NC_MASK | NA_EDITED, mask);
}
@@ -517,15 +517,15 @@ static int maskobj_remove_exec(bContext *C, wmOperator *UNUSED(op))
return OPERATOR_FINISHED;
}
void MASK_OT_object_remove(wmOperatorType *ot)
void MASK_OT_layer_remove(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Remove Mask Object";
ot->description = "Remove mask object";
ot->idname = "MASK_OT_object_remove";
ot->name = "Remove Mask Layer";
ot->description = "Remove mask layer";
ot->idname = "MASK_OT_layer_remove";
/* api callbacks */
ot->exec = maskobj_remove_exec;
ot->exec = masklay_remove_exec;
ot->poll = ED_maskediting_poll;
/* flags */
@@ -546,7 +546,7 @@ typedef struct SlidePointData {
float vec[3][3];
Mask *mask;
MaskObject *maskobj;
MaskLayer *masklay;
MaskSpline *spline;
MaskSplinePoint *point;
MaskSplinePointUW *uw;
@@ -562,7 +562,7 @@ static void *slide_point_customdata(bContext *C, wmOperator *op, wmEvent *event)
{
Mask *mask = CTX_data_edit_mask(C);
SlidePointData *customdata = NULL;
MaskObject *maskobj, *cv_maskobj, *feather_maskobj;
MaskLayer *masklay, *cv_masklay, *feather_masklay;
MaskSpline *spline, *cv_spline, *feather_spline;
MaskSplinePoint *point, *cv_point, *feather_point;
MaskSplinePointUW *uw = NULL;
@@ -574,13 +574,13 @@ static void *slide_point_customdata(bContext *C, wmOperator *op, wmEvent *event)
ED_mask_mouse_pos(C, event, co);
ED_mask_size(C, &width, &height);
cv_point = ED_mask_point_find_nearest(C, mask, co, threshold, &cv_maskobj, &cv_spline, &is_handle, &cv_score);
cv_point = ED_mask_point_find_nearest(C, mask, co, threshold, &cv_masklay, &cv_spline, &is_handle, &cv_score);
if (ED_mask_feather_find_nearest(C, mask, co, threshold, &feather_maskobj, &feather_spline, &feather_point, &uw, &feather_score)) {
if (ED_mask_feather_find_nearest(C, mask, co, threshold, &feather_masklay, &feather_spline, &feather_point, &uw, &feather_score)) {
if (slide_feather || !cv_point || feather_score < cv_score) {
action = SLIDE_ACTION_FEATHER;
maskobj = feather_maskobj;
masklay = feather_masklay;
spline = feather_spline;
point = feather_point;
}
@@ -592,7 +592,7 @@ static void *slide_point_customdata(bContext *C, wmOperator *op, wmEvent *event)
else
action = SLIDE_ACTION_POINT;
maskobj = cv_maskobj;
masklay = cv_masklay;
spline = cv_spline;
point = cv_point;
}
@@ -601,7 +601,7 @@ static void *slide_point_customdata(bContext *C, wmOperator *op, wmEvent *event)
customdata = MEM_callocN(sizeof(SlidePointData), "mask slide point data");
customdata->mask = mask;
customdata->maskobj = maskobj;
customdata->masklay = masklay;
customdata->spline = spline;
customdata->point = point;
customdata->width = width;
@@ -668,8 +668,8 @@ static int slide_point_invoke(bContext *C, wmOperator *op, wmEvent *event)
ED_mask_select_flush_all(mask);
}
slidedata->maskobj->act_spline = slidedata->spline;
slidedata->maskobj->act_point = slidedata->point;
slidedata->masklay->act_spline = slidedata->spline;
slidedata->masklay->act_point = slidedata->point;
WM_event_add_notifier(C, NC_MASK | ND_SELECT, mask);
@@ -794,7 +794,7 @@ static int slide_point_modal(bContext *C, wmOperator *op, wmEvent *event)
free_slide_point_data(op->customdata);
if (IS_AUTOKEY_ON(scene)) {
ED_mask_object_shape_auto_key_all(data->mask, CFRA);
ED_mask_layer_shape_auto_key_all(data->mask, CFRA);
}
WM_event_add_notifier(C, NC_MASK | NA_EDITED, data->mask);
@@ -986,13 +986,13 @@ static void mask_spline_add_point_at_index(MaskSpline *spline, int point_index)
static int add_vertex_subdivide(bContext *C, Mask *mask, const float co[2])
{
MaskObject *maskobj;
MaskLayer *masklay;
MaskSpline *spline;
MaskSplinePoint *point = NULL;
const float threshold = 9;
float tangent[2];
if (find_nearest_diff_point(C, mask, co, threshold, FALSE, &maskobj, &spline, &point, NULL, tangent)) {
if (find_nearest_diff_point(C, mask, co, threshold, FALSE, &masklay, &spline, &point, NULL, tangent)) {
MaskSplinePoint *new_point;
int point_index = point - spline->points;
@@ -1005,9 +1005,9 @@ static int add_vertex_subdivide(bContext *C, Mask *mask, const float co[2])
setup_vertex_point(C, mask, spline, new_point, co, tangent, NULL, TRUE);
/* TODO - we could pass the spline! */
BKE_mask_object_shape_changed_add(maskobj, BKE_mask_object_shape_spline_to_index(maskobj, spline) + point_index + 1, TRUE, TRUE);
BKE_mask_layer_shape_changed_add(masklay, BKE_mask_layer_shape_spline_to_index(masklay, spline) + point_index + 1, TRUE, TRUE);
maskobj->act_point = new_point;
masklay->act_point = new_point;
WM_event_add_notifier(C, NC_MASK | NA_EDITED, mask);
@@ -1019,17 +1019,17 @@ static int add_vertex_subdivide(bContext *C, Mask *mask, const float co[2])
/* **** add extrude vertex **** */
static void finSelectedSplinePoint(MaskObject *maskobj, MaskSpline **spline, MaskSplinePoint **point, short check_active)
static void finSelectedSplinePoint(MaskLayer *masklay, MaskSpline **spline, MaskSplinePoint **point, short check_active)
{
MaskSpline *cur_spline = maskobj->splines.first;
MaskSpline *cur_spline = masklay->splines.first;
*spline = NULL;
*point = NULL;
if (check_active) {
if (maskobj->act_spline && maskobj->act_point) {
*spline = maskobj->act_spline;
*point = maskobj->act_point;
if (masklay->act_spline && masklay->act_point) {
*spline = masklay->act_spline;
*point = masklay->act_point;
return;
}
}
@@ -1060,7 +1060,7 @@ static void finSelectedSplinePoint(MaskObject *maskobj, MaskSpline **spline, Mas
}
}
static int add_vertex_extrude(bContext *C, Mask *mask, MaskObject *maskobj, const float co[2])
static int add_vertex_extrude(bContext *C, Mask *mask, MaskLayer *masklay, const float co[2])
{
MaskSpline *spline;
MaskSplinePoint *point;
@@ -1076,11 +1076,11 @@ static int add_vertex_extrude(bContext *C, Mask *mask, MaskObject *maskobj, cons
ED_mask_select_toggle_all(mask, SEL_DESELECT);
if (!maskobj) {
if (!masklay) {
return FALSE;
}
else {
finSelectedSplinePoint(maskobj, &spline, &point, TRUE);
finSelectedSplinePoint(masklay, &spline, &point, TRUE);
}
point_index = (point - spline->points);
@@ -1141,13 +1141,13 @@ static int add_vertex_extrude(bContext *C, Mask *mask, MaskObject *maskobj, cons
new_point = &spline->points[point_index + 1];
}
maskobj->act_point = new_point;
masklay->act_point = new_point;
setup_vertex_point(C, mask, spline, new_point, co, NULL, ref_point, FALSE);
if (maskobj->splines_shapes.first) {
if (masklay->splines_shapes.first) {
point_index = (((int)(new_point - spline->points) + 0) % spline->tot_point);
BKE_mask_object_shape_changed_add(maskobj, BKE_mask_object_shape_spline_to_index(maskobj, spline) + point_index, TRUE, TRUE);
BKE_mask_layer_shape_changed_add(masklay, BKE_mask_layer_shape_spline_to_index(masklay, spline) + point_index, TRUE, TRUE);
}
if (do_recalc_src) {
@@ -1160,7 +1160,7 @@ static int add_vertex_extrude(bContext *C, Mask *mask, MaskObject *maskobj, cons
return TRUE;
}
static int add_vertex_new(bContext *C, Mask *mask, MaskObject *maskobj, const float co[2])
static int add_vertex_new(bContext *C, Mask *mask, MaskLayer *masklay, const float co[2])
{
MaskSpline *spline;
MaskSplinePoint *point;
@@ -1168,32 +1168,32 @@ static int add_vertex_new(bContext *C, Mask *mask, MaskObject *maskobj, const fl
ED_mask_select_toggle_all(mask, SEL_DESELECT);
if (!maskobj) {
/* if there's no maskobj currently operationg on, create new one */
maskobj = BKE_mask_object_new(mask, "");
mask->act_maskobj = mask->tot_maskobj - 1;
if (!masklay) {
/* if there's no masklay currently operationg on, create new one */
masklay = BKE_mask_layer_new(mask, "");
mask->masklay_act = mask->masklay_tot - 1;
spline = NULL;
point = NULL;
}
else {
finSelectedSplinePoint(maskobj, &spline, &point, TRUE);
finSelectedSplinePoint(masklay, &spline, &point, TRUE);
}
if (!spline) {
/* no selected splines in active maskobj, create new spline */
spline = BKE_mask_spline_add(maskobj);
/* no selected splines in active masklay, create new spline */
spline = BKE_mask_spline_add(masklay);
}
maskobj->act_spline = spline;
masklay->act_spline = spline;
new_point = spline->points;
maskobj->act_point = new_point;
masklay->act_point = new_point;
setup_vertex_point(C, mask, spline, new_point, co, NULL, ref_point, FALSE);
{
int point_index = (((int)(new_point - spline->points) + 0) % spline->tot_point);
BKE_mask_object_shape_changed_add(maskobj, BKE_mask_object_shape_spline_to_index(maskobj, spline) + point_index, TRUE, TRUE);
BKE_mask_layer_shape_changed_add(masklay, BKE_mask_layer_shape_spline_to_index(masklay, spline) + point_index, TRUE, TRUE);
}
WM_event_add_notifier(C, NC_MASK | NA_EDITED, mask);
@@ -1204,23 +1204,23 @@ static int add_vertex_new(bContext *C, Mask *mask, MaskObject *maskobj, const fl
static int add_vertex_exec(bContext *C, wmOperator *op)
{
Mask *mask = CTX_data_edit_mask(C);
MaskObject *maskobj;
MaskLayer *masklay;
float co[2];
maskobj = BKE_mask_object_active(mask);
masklay = BKE_mask_layer_active(mask);
if (maskobj && maskobj->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
maskobj = NULL;
if (masklay && masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
masklay = NULL;
}
RNA_float_get_array(op->ptr, "location", co);
if (maskobj && maskobj->act_point && MASKPOINT_ISSEL_ANY(maskobj->act_point)) {
if (masklay && masklay->act_point && MASKPOINT_ISSEL_ANY(masklay->act_point)) {
/* cheap trick - double click for cyclic */
MaskSpline *spline = maskobj->act_spline;
MaskSplinePoint *point = maskobj->act_point;
MaskSpline *spline = masklay->act_spline;
MaskSplinePoint *point = masklay->act_point;
int is_sta = (point == spline->points);
int is_end = (point == &spline->points[spline->tot_point - 1]);
@@ -1249,14 +1249,14 @@ static int add_vertex_exec(bContext *C, wmOperator *op)
}
if (!add_vertex_subdivide(C, mask, co)) {
if (!add_vertex_extrude(C, mask, maskobj, co)) {
if (!add_vertex_extrude(C, mask, masklay, co)) {
return OPERATOR_CANCELLED;
}
}
}
else {
if (!add_vertex_subdivide(C, mask, co)) {
if (!add_vertex_new(C, mask, maskobj, co)) {
if (!add_vertex_new(C, mask, masklay, co)) {
return OPERATOR_CANCELLED;
}
}
@@ -1304,7 +1304,7 @@ void MASK_OT_add_vertex(wmOperatorType *ot)
static int add_feather_vertex_exec(bContext *C, wmOperator *op)
{
Mask *mask = CTX_data_edit_mask(C);
MaskObject *maskobj;
MaskLayer *masklay;
MaskSpline *spline;
MaskSplinePoint *point = NULL;
const float threshold = 9;
@@ -1316,7 +1316,7 @@ static int add_feather_vertex_exec(bContext *C, wmOperator *op)
if (point)
return OPERATOR_FINISHED;
if (find_nearest_diff_point(C, mask, co, threshold, TRUE, &maskobj, &spline, &point, &u, NULL)) {
if (find_nearest_diff_point(C, mask, co, threshold, TRUE, &masklay, &spline, &point, &u, NULL)) {
Scene *scene = CTX_data_scene(C);
float w = BKE_mask_point_weight(spline, point, u);
@@ -1370,16 +1370,16 @@ void MASK_OT_add_feather_vertex(wmOperatorType *ot)
static int cyclic_toggle_exec(bContext *C, wmOperator *UNUSED(op))
{
Mask *mask = CTX_data_edit_mask(C);
MaskObject *maskobj;
MaskLayer *masklay;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
if (maskobj->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
continue;
}
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
if (ED_mask_spline_select_check(spline->points, spline->tot_point)) {
spline->flag ^= MASK_SPLINE_CYCLIC;
}
@@ -1447,17 +1447,17 @@ static void delete_feather_points(MaskSplinePoint *point)
static int delete_exec(bContext *C, wmOperator *UNUSED(op))
{
Mask *mask = CTX_data_edit_mask(C);
MaskObject *maskobj;
int mask_object_shape_ofs = 0;
MaskLayer *masklay;
int mask_layer_shape_ofs = 0;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
if (maskobj->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
continue;
}
spline = maskobj->splines.first;
spline = masklay->splines.first;
while (spline) {
const int tot_point_orig = spline->tot_point;
@@ -1475,15 +1475,15 @@ static int delete_exec(bContext *C, wmOperator *UNUSED(op))
if (count == 0) {
/* delete the whole spline */
BLI_remlink(&maskobj->splines, spline);
BLI_remlink(&masklay->splines, spline);
BKE_mask_spline_free(spline);
if (spline == maskobj->act_spline) {
maskobj->act_spline = NULL;
maskobj->act_point = NULL;
if (spline == masklay->act_spline) {
masklay->act_spline = NULL;
masklay->act_point = NULL;
}
BKE_mask_object_shape_changed_remove(maskobj, mask_object_shape_ofs, tot_point_orig);
BKE_mask_layer_shape_changed_remove(masklay, mask_layer_shape_ofs, tot_point_orig);
}
else {
MaskSplinePoint *new_points;
@@ -1495,8 +1495,8 @@ static int delete_exec(bContext *C, wmOperator *UNUSED(op))
MaskSplinePoint *point = &spline->points[i];
if (!MASKPOINT_ISSEL_ANY(point)) {
if (point == maskobj->act_point)
maskobj->act_point = &new_points[j];
if (point == masklay->act_point)
masklay->act_point = &new_points[j];
delete_feather_points(point);
@@ -1504,17 +1504,17 @@ static int delete_exec(bContext *C, wmOperator *UNUSED(op))
j++;
}
else {
if (point == maskobj->act_point)
maskobj->act_point = NULL;
if (point == masklay->act_point)
masklay->act_point = NULL;
BKE_mask_point_free(point);
spline->tot_point--;
BKE_mask_object_shape_changed_remove(maskobj, mask_object_shape_ofs + j, 1);
BKE_mask_layer_shape_changed_remove(masklay, mask_layer_shape_ofs + j, 1);
}
}
mask_object_shape_ofs += spline->tot_point;
mask_layer_shape_ofs += spline->tot_point;
MEM_freeN(spline->points);
spline->points = new_points;
@@ -1555,18 +1555,18 @@ void MASK_OT_delete(wmOperatorType *ot)
static int set_handle_type_exec(bContext *C, wmOperator *op)
{
Mask *mask = CTX_data_edit_mask(C);
MaskObject *maskobj;
MaskLayer *masklay;
int handle_type = RNA_enum_get(op->ptr, "type");
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
int i;
if (maskobj->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
continue;
}
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
for (i = 0; i < spline->tot_point; i++) {
MaskSplinePoint *point = &spline->points[i];
@@ -1616,14 +1616,14 @@ void MASK_OT_handle_type_set(wmOperatorType *ot)
static int mask_hide_view_clear_exec(bContext *C, wmOperator *UNUSED(op))
{
Mask *mask = CTX_data_edit_mask(C);
MaskObject *maskobj;
MaskLayer *masklay;
int changed = FALSE;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
if (maskobj->restrictflag & OB_RESTRICT_VIEW) {
ED_mask_object_select_set(maskobj, TRUE);
maskobj->restrictflag &= ~OB_RESTRICT_VIEW;
if (masklay->restrictflag & OB_RESTRICT_VIEW) {
ED_mask_layer_select_set(masklay, TRUE);
masklay->restrictflag &= ~OB_RESTRICT_VIEW;
changed = 1;
}
}
@@ -1644,7 +1644,7 @@ void MASK_OT_hide_view_clear(wmOperatorType *ot)
/* identifiers */
ot->name = "Clear Restrict View";
ot->description = "Reveal the object by setting the hide flag";
ot->description = "Reveal the layer by setting the hide flag";
ot->idname = "MASK_OT_hide_view_clear";
/* api callbacks */
@@ -1658,33 +1658,33 @@ void MASK_OT_hide_view_clear(wmOperatorType *ot)
static int mask_hide_view_set_exec(bContext *C, wmOperator *op)
{
Mask *mask = CTX_data_edit_mask(C);
MaskObject *maskobj;
MaskLayer *masklay;
const int unselected = RNA_boolean_get(op->ptr, "unselected");
int changed = FALSE;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
if (maskobj->restrictflag & MASK_RESTRICT_SELECT) {
if (masklay->restrictflag & MASK_RESTRICT_SELECT) {
continue;
}
if (!unselected) {
if (ED_mask_object_select_check(maskobj)) {
ED_mask_object_select_set(maskobj, FALSE);
if (ED_mask_layer_select_check(masklay)) {
ED_mask_layer_select_set(masklay, FALSE);
maskobj->restrictflag |= OB_RESTRICT_VIEW;
masklay->restrictflag |= OB_RESTRICT_VIEW;
changed = 1;
if (maskobj == BKE_mask_object_active(mask)) {
BKE_mask_object_active_set(mask, NULL);
if (masklay == BKE_mask_layer_active(mask)) {
BKE_mask_layer_active_set(mask, NULL);
}
}
}
else {
if (!ED_mask_object_select_check(maskobj)) {
maskobj->restrictflag |= OB_RESTRICT_VIEW;
if (!ED_mask_layer_select_check(masklay)) {
masklay->restrictflag |= OB_RESTRICT_VIEW;
changed = 1;
if (maskobj == BKE_mask_object_active(mask)) {
BKE_mask_object_active_set(mask, NULL);
if (masklay == BKE_mask_layer_active(mask)) {
BKE_mask_layer_active_set(mask, NULL);
}
}
}
@@ -1705,7 +1705,7 @@ void MASK_OT_hide_view_set(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Set Restrict View";
ot->description = "Hide the object by setting the hide flag";
ot->description = "Hide the layer by setting the hide flag";
ot->idname = "MASK_OT_hide_view_set";
/* api callbacks */
@@ -1715,6 +1715,6 @@ void MASK_OT_hide_view_set(wmOperatorType *ot)
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
RNA_def_boolean(ot->srna, "unselected", 0, "Unselected", "Hide unselected rather than selected objects");
RNA_def_boolean(ot->srna, "unselected", 0, "Unselected", "Hide unselected rather than selected layers");
}

16
source/blender/editors/mask/mask_relationships.c
View File

@@ -60,17 +60,17 @@
static int mask_parent_clear_exec(bContext *C, wmOperator *UNUSED(op))
{
Mask *mask = CTX_data_edit_mask(C);
MaskObject *maskobj;
MaskLayer *masklay;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
int i;
if (maskobj->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
continue;
}
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
for (i = 0; i < spline->tot_point; i++) {
MaskSplinePoint *point = &spline->points[i];
@@ -106,7 +106,7 @@ void MASK_OT_parent_clear(wmOperatorType *ot)
static int mask_parent_set_exec(bContext *C, wmOperator *UNUSED(op))
{
Mask *mask = CTX_data_edit_mask(C);
MaskObject *maskobj;
MaskLayer *masklay;
/* parent info */
SpaceClip *sc;
@@ -132,15 +132,15 @@ static int mask_parent_set_exec(bContext *C, wmOperator *UNUSED(op))
BKE_mask_coord_from_movieclip(clip, &sc->user, parmask_pos, marker_pos_ofs);
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
int i;
if (maskobj->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
continue;
}
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
for (i = 0; i < spline->tot_point; i++) {
MaskSplinePoint *point = &spline->points[i];

90
source/blender/editors/mask/mask_select.c
View File

@@ -71,15 +71,15 @@ int ED_mask_spline_select_check(MaskSplinePoint *points, int tot_point)
return FALSE;
}
int ED_mask_object_select_check(MaskObject *maskobj)
int ED_mask_layer_select_check(MaskLayer *masklay)
{
MaskSpline *spline;
if (maskobj->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
return FALSE;
}
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
if (ED_mask_spline_select_check(spline->points, spline->tot_point)) {
return TRUE;
}
@@ -90,10 +90,10 @@ int ED_mask_object_select_check(MaskObject *maskobj)
int ED_mask_select_check(Mask *mask)
{
MaskObject *maskobj;
MaskLayer *masklay;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
if (ED_mask_object_select_check(maskobj)) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
if (ED_mask_layer_select_check(masklay)) {
return TRUE;
}
}
@@ -101,17 +101,17 @@ int ED_mask_select_check(Mask *mask)
return FALSE;
}
void ED_mask_object_select_set(MaskObject *maskobj, int select)
void ED_mask_layer_select_set(MaskLayer *masklay, int select)
{
MaskSpline *spline;
if (maskobj->restrictflag & MASK_RESTRICT_SELECT) {
if (masklay->restrictflag & MASK_RESTRICT_SELECT) {
if (select == TRUE) {
return;
}
}
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
int i;
if (select)
@@ -129,7 +129,7 @@ void ED_mask_object_select_set(MaskObject *maskobj, int select)
void ED_mask_select_toggle_all(Mask *mask, int action)
{
MaskObject *maskobj;
MaskLayer *masklay;
if (action == SEL_TOGGLE) {
if (ED_mask_select_check(mask))
@@ -138,31 +138,31 @@ void ED_mask_select_toggle_all(Mask *mask, int action)
action = SEL_SELECT;
}
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
if (maskobj->restrictflag & MASK_RESTRICT_VIEW) {
if (masklay->restrictflag & MASK_RESTRICT_VIEW) {
continue;
}
ED_mask_object_select_set(maskobj, (action == SEL_SELECT) ? TRUE : FALSE);
ED_mask_layer_select_set(masklay, (action == SEL_SELECT) ? TRUE : FALSE);
}
}
void ED_mask_select_flush_all(Mask *mask)
{
MaskObject *maskobj;
MaskLayer *masklay;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
int i;
spline->flag &= ~SELECT;
/* intentionally _dont_ do this in the maskobj loop
/* intentionally _dont_ do this in the masklay loop
* so we clear flags on all splines */
if (maskobj->restrictflag & MASK_RESTRICT_VIEW) {
if (masklay->restrictflag & MASK_RESTRICT_VIEW) {
continue;
}
@@ -225,7 +225,7 @@ void MASK_OT_select_all(wmOperatorType *ot)
static int select_exec(bContext *C, wmOperator *op)
{
Mask *mask = CTX_data_edit_mask(C);
MaskObject *maskobj;
MaskLayer *masklay;
MaskSpline *spline;
MaskSplinePoint *point = NULL;
float co[2];
@@ -238,7 +238,7 @@ static int select_exec(bContext *C, wmOperator *op)
RNA_float_get_array(op->ptr, "location", co);
point = ED_mask_point_find_nearest(C, mask, co, threshold, &maskobj, &spline, &is_handle, NULL);
point = ED_mask_point_find_nearest(C, mask, co, threshold, &masklay, &spline, &is_handle, NULL);
if (point) {
if (extend == 0 && deselect == 0 && toggle == 0)
@@ -246,8 +246,8 @@ static int select_exec(bContext *C, wmOperator *op)
if (is_handle) {
if (extend) {
maskobj->act_spline = spline;
maskobj->act_point = point;
masklay->act_spline = spline;
masklay->act_point = point;
BKE_mask_point_select_set_handle(point, TRUE);
}
@@ -255,8 +255,8 @@ static int select_exec(bContext *C, wmOperator *op)
BKE_mask_point_select_set_handle(point, FALSE);
}
else {
maskobj->act_spline = spline;
maskobj->act_point = point;
masklay->act_spline = spline;
masklay->act_point = point;
if (!MASKPOINT_ISSEL_HANDLE(point)) {
BKE_mask_point_select_set_handle(point, TRUE);
@@ -268,8 +268,8 @@ static int select_exec(bContext *C, wmOperator *op)
}
else {
if (extend) {
maskobj->act_spline = spline;
maskobj->act_point = point;
masklay->act_spline = spline;
masklay->act_point = point;
BKE_mask_point_select_set(point, TRUE);
}
@@ -277,8 +277,8 @@ static int select_exec(bContext *C, wmOperator *op)
BKE_mask_point_select_set(point, FALSE);
}
else {
maskobj->act_spline = spline;
maskobj->act_point = point;
masklay->act_spline = spline;
masklay->act_point = point;
if (!MASKPOINT_ISSEL_ANY(point)) {
BKE_mask_point_select_set(point, TRUE);
@@ -289,8 +289,8 @@ static int select_exec(bContext *C, wmOperator *op)
}
}
maskobj->act_spline = spline;
maskobj->act_point = point;
masklay->act_spline = spline;
masklay->act_point = point;
ED_mask_select_flush_all(mask);
@@ -301,15 +301,15 @@ static int select_exec(bContext *C, wmOperator *op)
else {
MaskSplinePointUW *uw;
if (ED_mask_feather_find_nearest(C, mask, co, threshold, &maskobj, &spline, &point, &uw, NULL)) {
if (ED_mask_feather_find_nearest(C, mask, co, threshold, &masklay, &spline, &point, &uw, NULL)) {
if (!extend)
ED_mask_select_toggle_all(mask, SEL_DESELECT);
if (uw)
uw->flag |= SELECT;
maskobj->act_spline = spline;
maskobj->act_point = point;
masklay->act_spline = spline;
masklay->act_point = point;
ED_mask_select_flush_all(mask);
@@ -362,7 +362,7 @@ void MASK_OT_select(wmOperatorType *ot)
static int border_select_exec(bContext *C, wmOperator *op)
{
Mask *mask = CTX_data_edit_mask(C);
MaskObject *maskobj;
MaskLayer *masklay;
int i;
rcti rect;
@@ -382,14 +382,14 @@ static int border_select_exec(bContext *C, wmOperator *op)
extend = RNA_boolean_get(op->ptr, "extend");
/* do actual selection */
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
if (maskobj->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
continue;
}
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
for (i = 0; i < spline->tot_point; i++) {
@@ -447,7 +447,7 @@ void MASK_OT_select_border(wmOperatorType *ot)
static int do_lasso_select_mask(bContext *C, int mcords[][2], short moves, short select)
{
Mask *mask = CTX_data_edit_mask(C);
MaskObject *maskobj;
MaskLayer *masklay;
int i;
rcti rect;
@@ -457,14 +457,14 @@ static int do_lasso_select_mask(bContext *C, int mcords[][2], short moves, short
BLI_lasso_boundbox(&rect, mcords, moves);
/* do actual selection */
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
if (maskobj->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
continue;
}
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
for (i = 0; i < spline->tot_point; i++) {
@@ -559,7 +559,7 @@ static int mask_spline_point_inside_ellipse(BezTriple *bezt, float offset[2], fl
static int circle_select_exec(bContext *C, wmOperator *op)
{
Mask *mask = CTX_data_edit_mask(C);
MaskObject *maskobj;
MaskLayer *masklay;
int i;
SpaceClip *sc = CTX_wm_space_clip(C);
@@ -586,14 +586,14 @@ static int circle_select_exec(bContext *C, wmOperator *op)
ED_mask_point_pos(C, x, y, &offset[0], &offset[1]);
/* do actual selection */
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline;
if (maskobj->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
continue;
}
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
for (i = 0; i < spline->tot_point; i++) {

38
source/blender/editors/mask/mask_shapekey.c
View File

@@ -61,18 +61,18 @@ static int mask_shape_key_insert_exec(bContext *C, wmOperator *UNUSED(op))
Scene *scene = CTX_data_scene(C);
const int frame = CFRA;
Mask *mask = CTX_data_edit_mask(C);
MaskObject *maskobj;
MaskLayer *masklay;
int change = FALSE;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
MaskObjectShape *maskobj_shape;
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskLayerShape *masklay_shape;
if (!ED_mask_object_select_check(maskobj)) {
if (!ED_mask_layer_select_check(masklay)) {
continue;
}
maskobj_shape = BKE_mask_object_shape_varify_frame(maskobj, frame);
BKE_mask_object_shape_from_mask(maskobj, maskobj_shape);
masklay_shape = BKE_mask_layer_shape_varify_frame(masklay, frame);
BKE_mask_layer_shape_from_mask(masklay, masklay_shape);
change = TRUE;
}
@@ -107,20 +107,20 @@ static int mask_shape_key_clear_exec(bContext *C, wmOperator *UNUSED(op))
Scene *scene = CTX_data_scene(C);
const int frame = CFRA;
Mask *mask = CTX_data_edit_mask(C);
MaskObject *maskobj;
MaskLayer *masklay;
int change = FALSE;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
MaskObjectShape *maskobj_shape;
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskLayerShape *masklay_shape;
if (!ED_mask_object_select_check(maskobj)) {
if (!ED_mask_layer_select_check(masklay)) {
continue;
}
maskobj_shape = BKE_mask_object_shape_find_frame(maskobj, frame);
masklay_shape = BKE_mask_layer_shape_find_frame(masklay, frame);
if (maskobj_shape) {
BKE_mask_object_shape_unlink(maskobj, maskobj_shape);
if (masklay_shape) {
BKE_mask_layer_shape_unlink(masklay, masklay_shape);
change = TRUE;
}
}
@@ -151,16 +151,16 @@ void MASK_OT_shape_key_clear(wmOperatorType *ot)
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
}
int ED_mask_object_shape_auto_key_all(Mask *mask, const int frame)
int ED_mask_layer_shape_auto_key_all(Mask *mask, const int frame)
{
MaskObject *maskobj;
MaskLayer *masklay;
int change = FALSE;
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
MaskObjectShape *maskobj_shape;
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskLayerShape *masklay_shape;
maskobj_shape = BKE_mask_object_shape_varify_frame(maskobj, frame);
BKE_mask_object_shape_from_mask(maskobj, maskobj_shape);
masklay_shape = BKE_mask_layer_shape_varify_frame(masklay, frame);
BKE_mask_layer_shape_from_mask(masklay, masklay_shape);
change = TRUE;
}

4
source/blender/editors/screen/screen_ops.c
View File

@@ -1952,8 +1952,8 @@ static int keyframe_jump_exec(bContext *C, wmOperator *op)
SpaceClip *sc = CTX_wm_space_clip(C);
if (sc) {
if ((sc->mode == SC_MODE_MASKEDITING) && sc->mask) {
MaskObject *maskobj = BKE_mask_object_active(sc->mask);
mask_to_keylist(&ads, maskobj, &keys);
MaskLayer *masklay = BKE_mask_layer_active(sc->mask);
mask_to_keylist(&ads, masklay, &keys);
}
}
}

14
source/blender/editors/space_clip/clip_draw.c
View File

@@ -199,18 +199,18 @@ static void draw_movieclip_cache(SpaceClip *sc, ARegion *ar, MovieClip *clip, Sc
/* movie clip animation */
if ((sc->mode == SC_MODE_MASKEDITING) && sc->mask) {
MaskObject *maskobj = BKE_mask_object_active(sc->mask);
if (maskobj) {
MaskObjectShape *maskobj_shape;
MaskLayer *masklay = BKE_mask_layer_active(sc->mask);
if (masklay) {
MaskLayerShape *masklay_shape;
glColor4ub(255, 175, 0, 255);
glBegin(GL_LINES);
for (maskobj_shape = maskobj->splines_shapes.first;
maskobj_shape;
maskobj_shape = maskobj_shape->next)
for (masklay_shape = masklay->splines_shapes.first;
masklay_shape;
masklay_shape = masklay_shape->next)
{
i = maskobj_shape->frame;
i = masklay_shape->frame;
/* glRecti((i - sfra) * framelen, 0, (i - sfra + 1) * framelen, 4); */

20
source/blender/editors/transform/transform_conversions.c
View File

@@ -4915,7 +4915,7 @@ void special_aftertrans_update(bContext *C, TransInfo *t)
if (IS_AUTOKEY_ON(t->scene)) {
Scene *scene = t->scene;
ED_mask_object_shape_auto_key_all(mask, CFRA);
ED_mask_layer_shape_auto_key_all(mask, CFRA);
}
}
}
@@ -5974,7 +5974,7 @@ static void createTransMaskingData(bContext *C, TransInfo *t)
{
SpaceClip *sc = CTX_wm_space_clip(C);
Mask *mask = CTX_data_edit_mask(C);
MaskObject *maskobj;
MaskLayer *masklay;
TransData *td = NULL;
TransData2D *td2d = NULL;
TransDataMasking *tdm = NULL;
@@ -5982,14 +5982,14 @@ static void createTransMaskingData(bContext *C, TransInfo *t)
int propmode = t->flag & T_PROP_EDIT;
/* count */
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
MaskSpline *spline = maskobj->splines.first;
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline = masklay->splines.first;
if (maskobj->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
continue;
}
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
int i;
for (i = 0; i < spline->tot_point; i++) {
@@ -6021,14 +6021,14 @@ static void createTransMaskingData(bContext *C, TransInfo *t)
t->flag |= T_FREE_CUSTOMDATA;
/* create data */
for (maskobj = mask->maskobjs.first; maskobj; maskobj = maskobj->next) {
MaskSpline *spline = maskobj->splines.first;
for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
MaskSpline *spline = masklay->splines.first;
if (maskobj->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {
continue;
}
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
int i;
for (i = 0; i < spline->tot_point; i++) {

28
source/blender/makesdna/DNA_mask_types.h
View File

@@ -43,9 +43,9 @@
typedef struct Mask {
ID id;
struct AnimData *adt;
ListBase maskobjs; /* mask objects */
int act_maskobj; /* index of active mask object (-1 == None) */
int tot_maskobj; /* total number of mask objects */
ListBase masklayers; /* mask layers */
int masklay_act; /* index of active mask layer (-1 == None) */
int masklay_tot; /* total number of mask layers */
} Mask;
typedef struct MaskParent {
@@ -54,7 +54,7 @@ typedef struct MaskParent {
ID *id; /* ID block of entity to which mask/spline is parented to
* in case of parenting to movie tracking data set to MovieClip datablock */
char parent[64]; /* entity of parent to which parenting happened
* in case of parenting to movie tracking data contains name of object */
* in case of parenting to movie tracking data contains name of layer */
char sub_parent[64]; /* sub-entity of parent to which parenting happened
* in case of parenting to movie tracking data contains name of track */
float parent_orig[2]; /* track location at the moment of parenting */
@@ -87,22 +87,22 @@ typedef struct MaskSpline {
} MaskSpline;
/* one per frame */
typedef struct MaskObjectShape {
struct MaskObjectShape *next, *prev;
typedef struct MaskLayerShape {
struct MaskLayerShape *next, *prev;
float *data; /* u coordinate along spline segment and weight of this point */
int tot_vert; /* to ensure no buffer overruns's: alloc size is (tot_vert * MASK_OBJECT_SHAPE_ELEM_SIZE) */
int frame; /* different flags of this point */
char flag;
char pad[7];
} MaskObjectShape;
} MaskLayerShape;
typedef struct MaskObject {
struct MaskObject *next, *prev;
typedef struct MaskLayer {
struct MaskLayer *next, *prev;
char name[64]; /* name of the mask object (64 = MAD_ID_NAME - 2) */
char name[64]; /* name of the mask layer (64 = MAD_ID_NAME - 2) */
ListBase splines; /* list of splines which defines this mask object */
ListBase splines; /* list of splines which defines this mask layer */
ListBase splines_shapes;
struct MaskSpline *act_spline; /* active spline */
@@ -116,7 +116,7 @@ typedef struct MaskObject {
//char flag; /* not used yet */
char restrictflag; /* matching 'Object' flag of the same name - eventually use in the outliner */
char pad[1];
} MaskObject;
} MaskLayer;
/* MaskParent->flag */
#define MASK_PARENT_ACTIVE (1 << 0)
@@ -148,13 +148,13 @@ enum {
MASK_DT_WHITE
};
/* maskobj->blend */
/* masklay->blend */
enum {
MASK_BLEND_ADD = 0,
MASK_BLEND_SUBTRACT = 1
};
/* maskobj->blend_flag */
/* masklay->blend_flag */
enum {
MASK_BLENDFLAG_INVERT = (1 << 0)
};

2
source/blender/makesrna/RNA_access.h
View File

@@ -306,7 +306,7 @@ extern StructRNA RNA_MaterialSubsurfaceScattering;
extern StructRNA RNA_MaterialTextureSlot;
extern StructRNA RNA_MaterialVolume;
extern StructRNA RNA_Mask;
extern StructRNA RNA_MaskObject;
extern StructRNA RNA_MaskLayer;
extern StructRNA RNA_Menu;
extern StructRNA RNA_Mesh;
extern StructRNA RNA_MeshColor;

186
source/blender/makesrna/intern/rna_mask.c
View File

@@ -93,114 +93,114 @@ static void rna_MaskParent_id_type_set(PointerRNA *ptr, int value)
mpar->id = NULL;
}
static void rna_Mask_objects_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
static void rna_Mask_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
{
Mask *mask = (Mask *)ptr->id.data;
rna_iterator_listbase_begin(iter, &mask->maskobjs, NULL);
rna_iterator_listbase_begin(iter, &mask->masklayers, NULL);
}
static int rna_Mask_object_active_index_get(PointerRNA *ptr)
static int rna_Mask_layer_active_index_get(PointerRNA *ptr)
{
Mask *mask = (Mask *)ptr->id.data;
return mask->act_maskobj;
return mask->masklay_act;
}
static void rna_Mask_object_active_index_set(PointerRNA *ptr, int value)
static void rna_Mask_layer_active_index_set(PointerRNA *ptr, int value)
{
Mask *mask = (Mask *)ptr->id.data;
mask->act_maskobj = value;
mask->masklay_act = value;
}
static void rna_Mask_object_active_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
static void rna_Mask_layer_active_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
{
Mask *mask = (Mask *)ptr->id.data;
*min = 0;
*max = mask->tot_maskobj - 1;
*max = mask->masklay_tot - 1;
*max = MAX2(0, *max);
*softmin = *min;
*softmax = *max;
}
static char *rna_MaskObject_path(PointerRNA *ptr)
static char *rna_MaskLayer_path(PointerRNA *ptr)
{
return BLI_sprintfN("objects[\"%s\"]", ((MaskObject *)ptr->data)->name);
return BLI_sprintfN("layers[\"%s\"]", ((MaskLayer *)ptr->data)->name);
}
static PointerRNA rna_Mask_object_active_get(PointerRNA *ptr)
static PointerRNA rna_Mask_layer_active_get(PointerRNA *ptr)
{
Mask *mask = (Mask *)ptr->id.data;
MaskObject *maskobj = BKE_mask_object_active(mask);
MaskLayer *masklay = BKE_mask_layer_active(mask);
return rna_pointer_inherit_refine(ptr, &RNA_MaskObject, maskobj);
return rna_pointer_inherit_refine(ptr, &RNA_MaskLayer, masklay);
}
static void rna_Mask_object_active_set(PointerRNA *ptr, PointerRNA value)
static void rna_Mask_layer_active_set(PointerRNA *ptr, PointerRNA value)
{
Mask *mask = (Mask *)ptr->id.data;
MaskObject *maskobj = (MaskObject *)value.data;
MaskLayer *masklay = (MaskLayer *)value.data;
BKE_mask_object_active_set(mask, maskobj);
BKE_mask_layer_active_set(mask, masklay);
}
static void rna_MaskObject_splines_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
static void rna_MaskLayer_splines_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
{
MaskObject *maskobj = (MaskObject *)ptr->data;
MaskLayer *masklay = (MaskLayer *)ptr->data;
rna_iterator_listbase_begin(iter, &maskobj->splines, NULL);
rna_iterator_listbase_begin(iter, &masklay->splines, NULL);
}
void rna_MaskObject_name_set(PointerRNA *ptr, const char *value)
void rna_MaskLayer_name_set(PointerRNA *ptr, const char *value)
{
Mask *mask = (Mask *)ptr->id.data;
MaskObject *maskobj = (MaskObject *)ptr->data;
MaskLayer *masklay = (MaskLayer *)ptr->data;
BLI_strncpy(maskobj->name, value, sizeof(maskobj->name));
BLI_strncpy(masklay->name, value, sizeof(masklay->name));
BKE_mask_object_unique_name(mask, maskobj);
BKE_mask_layer_unique_name(mask, masklay);
}
static PointerRNA rna_MaskObject_active_spline_get(PointerRNA *ptr)
static PointerRNA rna_MaskLayer_active_spline_get(PointerRNA *ptr)
{
MaskObject *maskobj = (MaskObject *)ptr->data;
MaskLayer *masklay = (MaskLayer *)ptr->data;
return rna_pointer_inherit_refine(ptr, &RNA_MaskSpline, maskobj->act_spline);
return rna_pointer_inherit_refine(ptr, &RNA_MaskSpline, masklay->act_spline);
}
static void rna_MaskObject_active_spline_set(PointerRNA *ptr, PointerRNA value)
static void rna_MaskLayer_active_spline_set(PointerRNA *ptr, PointerRNA value)
{
MaskObject *maskobj = (MaskObject *)ptr->data;
MaskLayer *masklay = (MaskLayer *)ptr->data;
MaskSpline *spline = (MaskSpline *)value.data;
int index = BLI_findindex(&maskobj->splines, spline);
int index = BLI_findindex(&masklay->splines, spline);
if (index >= 0)
maskobj->act_spline = spline;
masklay->act_spline = spline;
else
maskobj->act_spline = NULL;
masklay->act_spline = NULL;
}
static PointerRNA rna_MaskObject_active_spline_point_get(PointerRNA *ptr)
static PointerRNA rna_MaskLayer_active_spline_point_get(PointerRNA *ptr)
{
MaskObject *maskobj = (MaskObject *)ptr->data;
MaskLayer *masklay = (MaskLayer *)ptr->data;
return rna_pointer_inherit_refine(ptr, &RNA_MaskSplinePoint, maskobj->act_point);
return rna_pointer_inherit_refine(ptr, &RNA_MaskSplinePoint, masklay->act_point);
}
static void rna_MaskObject_active_spline_point_set(PointerRNA *ptr, PointerRNA value)
static void rna_MaskLayer_active_spline_point_set(PointerRNA *ptr, PointerRNA value)
{
MaskObject *maskobj = (MaskObject *)ptr->data;
MaskLayer *masklay = (MaskLayer *)ptr->data;
MaskSpline *spline;
MaskSplinePoint *point = (MaskSplinePoint *)value.data;
maskobj->act_point = NULL;
masklay->act_point = NULL;
for (spline = maskobj->splines.first; spline; spline = spline->next) {
for (spline = masklay->splines.first; spline; spline = spline->next) {
if (point >= spline->points && point < spline->points + spline->tot_point) {
maskobj->act_point = point;
masklay->act_point = point;
break;
}
@@ -285,29 +285,29 @@ static void rna_MaskSplinePoint_handle_type_set(PointerRNA *ptr, int value)
/* ** API ** */
static MaskObject *rna_Mask_object_new(Mask *mask, const char *name)
static MaskLayer *rna_Mask_layer_new(Mask *mask, const char *name)
{
MaskObject *maskobj = BKE_mask_object_new(mask, name);
MaskLayer *masklay = BKE_mask_layer_new(mask, name);
WM_main_add_notifier(NC_MASK|NA_EDITED, mask);
return maskobj;
return masklay;
}
void rna_Mask_object_remove(Mask *mask, MaskObject *maskobj)
void rna_Mask_layer_remove(Mask *mask, MaskLayer *masklay)
{
BKE_mask_object_remove(mask, maskobj);
BKE_mask_layer_remove(mask, masklay);
WM_main_add_notifier(NC_MASK|NA_EDITED, mask);
}
static void rna_MaskObject_spline_add(ID *id, MaskObject *maskobj, int number)
static void rna_MaskLayer_spline_add(ID *id, MaskLayer *masklay, int number)
{
Mask *mask = (Mask*) id;
int i;
for (i = 0; i < number; i++)
BKE_mask_spline_add(maskobj);
BKE_mask_spline_add(masklay);
WM_main_add_notifier(NC_MASK|NA_EDITED, mask);
}
@@ -330,7 +330,7 @@ static void rna_def_maskParent(BlenderRNA *brna)
prop = RNA_def_property(srna, "use_parent", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", MASK_PARENT_ACTIVE);
RNA_def_property_ui_text(prop, "Use Parent", "Use parenting for this object");
RNA_def_property_ui_text(prop, "Use Parent", "Use parenting for this layer");
RNA_def_property_update(prop, 0, "rna_Mask_update_data");
/* Target Properties - ID-block to Drive */
@@ -460,27 +460,27 @@ static void rna_def_mask_splines(BlenderRNA *brna)
PropertyRNA *prop;
srna = RNA_def_struct(brna, "MaskSplines", NULL);
RNA_def_struct_sdna(srna, "MaskObject");
RNA_def_struct_sdna(srna, "MaskLayer");
RNA_def_struct_ui_text(srna, "Mask Splines", "Collection of masking splines");
func = RNA_def_function(srna, "add", "rna_MaskObject_spline_add");
func = RNA_def_function(srna, "add", "rna_MaskLayer_spline_add");
RNA_def_function_flag(func, FUNC_USE_SELF_ID);
RNA_def_function_ui_description(func, "Add a number of splines to mask object");
RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of splines to add to the object", 0, INT_MAX);
RNA_def_function_ui_description(func, "Add a number of splines to mask layer");
RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of splines to add to the layer", 0, INT_MAX);
/* active spline */
prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(prop, "MaskSpline");
RNA_def_property_pointer_funcs(prop, "rna_MaskObject_active_spline_get", "rna_MaskObject_active_spline_set", NULL, NULL);
RNA_def_property_pointer_funcs(prop, "rna_MaskLayer_active_spline_get", "rna_MaskLayer_active_spline_set", NULL, NULL);
RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking object");
RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking layer");
/* active point */
prop = RNA_def_property(srna, "active_point", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(prop, "MaskSplinePoint");
RNA_def_property_pointer_funcs(prop, "rna_MaskObject_active_spline_point_get", "rna_MaskObject_active_spline_point_set", NULL, NULL);
RNA_def_property_pointer_funcs(prop, "rna_MaskLayer_active_spline_point_get", "rna_MaskLayer_active_spline_point_set", NULL, NULL);
RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking object");
RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking layer");
}
static void rna_def_maskSpline(BlenderRNA *brna)
@@ -514,9 +514,9 @@ static void rna_def_maskSpline(BlenderRNA *brna)
RNA_def_property_update(prop, 0, "rna_Mask_update_data");
}
static void rna_def_mask_object(BlenderRNA *brna)
static void rna_def_mask_layer(BlenderRNA *brna)
{
static EnumPropertyItem maskobj_blend_mode_items[] = {
static EnumPropertyItem masklay_blend_mode_items[] = {
{MASK_BLEND_ADD, "ADD", 0, "Add", ""},
{MASK_BLEND_SUBTRACT, "SUBTRACT", 0, "Subtract", ""},
{0, NULL, 0, NULL, NULL}
@@ -528,23 +528,23 @@ static void rna_def_mask_object(BlenderRNA *brna)
rna_def_maskSpline(brna);
rna_def_mask_splines(brna);
srna = RNA_def_struct(brna, "MaskObject", NULL);
RNA_def_struct_ui_text(srna, "Mask Object", "Single object used for masking pixels");
RNA_def_struct_path_func(srna, "rna_MaskObject_path");
srna = RNA_def_struct(brna, "MaskLayer", NULL);
RNA_def_struct_ui_text(srna, "Mask Layer", "Single layer used for masking pixels");
RNA_def_struct_path_func(srna, "rna_MaskLayer_path");
/* name */
prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
RNA_def_property_ui_text(prop, "Name", "Unique name of object");
RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MaskObject_name_set");
RNA_def_property_ui_text(prop, "Name", "Unique name of layer");
RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MaskLayer_name_set");
RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
RNA_def_property_update(prop, 0, "rna_Mask_update_data");
RNA_def_struct_name_property(srna, prop);
/* splines */
prop = RNA_def_property(srna, "splines", PROP_COLLECTION, PROP_NONE);
RNA_def_property_collection_funcs(prop, "rna_MaskObject_splines_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", 0, 0, 0, 0);
RNA_def_property_collection_funcs(prop, "rna_MaskLayer_splines_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", 0, 0, 0, 0);
RNA_def_property_struct_type(prop, "MaskSpline");
RNA_def_property_ui_text(prop, "Splines", "Collection of splines which defines this object");
RNA_def_property_ui_text(prop, "Splines", "Collection of splines which defines this layer");
RNA_def_property_srna(prop, "MaskSplines");
/* restrict */
@@ -576,8 +576,8 @@ static void rna_def_mask_object(BlenderRNA *brna)
/* weight interpolation */
prop = RNA_def_property(srna, "blend", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "blend");
RNA_def_property_enum_items(prop, maskobj_blend_mode_items);
RNA_def_property_ui_text(prop, "Blend", "Method of blending mask objects");
RNA_def_property_enum_items(prop, masklay_blend_mode_items);
RNA_def_property_ui_text(prop, "Blend", "Method of blending mask layers");
RNA_def_property_update(prop, 0, "rna_Mask_update_data");
RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
@@ -588,7 +588,7 @@ static void rna_def_mask_object(BlenderRNA *brna)
}
static void rna_def_maskobjects(BlenderRNA *brna, PropertyRNA *cprop)
static void rna_def_masklayers(BlenderRNA *brna, PropertyRNA *cprop)
{
StructRNA *srna;
PropertyRNA *prop;
@@ -596,27 +596,27 @@ static void rna_def_maskobjects(BlenderRNA *brna, PropertyRNA *cprop)
FunctionRNA *func;
PropertyRNA *parm;
RNA_def_property_srna(cprop, "MaskObjects");
srna = RNA_def_struct(brna, "MaskObjects", NULL);
RNA_def_property_srna(cprop, "MaskLayers");
srna = RNA_def_struct(brna, "MaskLayers", NULL);
RNA_def_struct_sdna(srna, "Mask");
RNA_def_struct_ui_text(srna, "Mask Objects", "Collection of objects used by mask");
RNA_def_struct_ui_text(srna, "Mask Layers", "Collection of layers used by mask");
func = RNA_def_function(srna, "new", "rna_Mask_object_new");
RNA_def_function_ui_description(func, "Add object to this mask");
RNA_def_string(func, "name", "", 0, "Name", "Name of new object");
parm = RNA_def_pointer(func, "object", "MaskObject", "", "New mask object");
func = RNA_def_function(srna, "new", "rna_Mask_layer_new");
RNA_def_function_ui_description(func, "Add layer to this mask");
RNA_def_string(func, "name", "", 0, "Name", "Name of new layer");
parm = RNA_def_pointer(func, "layer", "MaskLayer", "", "New mask layer");
RNA_def_function_return(func, parm);
func = RNA_def_function(srna, "remove", "rna_Mask_object_remove");
RNA_def_function_ui_description(func, "Remove object from this mask");
RNA_def_pointer(func, "object", "MaskObject", "", "Shape to be removed");
func = RNA_def_function(srna, "remove", "rna_Mask_layer_remove");
RNA_def_function_ui_description(func, "Remove layer from this mask");
RNA_def_pointer(func, "layer", "MaskLayer", "", "Shape to be removed");
/* active object */
/* active layer */
prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(prop, "MaskObject");
RNA_def_property_pointer_funcs(prop, "rna_Mask_object_active_get", "rna_Mask_object_active_set", NULL, NULL);
RNA_def_property_struct_type(prop, "MaskLayer");
RNA_def_property_pointer_funcs(prop, "rna_Mask_layer_active_get", "rna_Mask_layer_active_set", NULL, NULL);
RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
RNA_def_property_ui_text(prop, "Active Shape", "Active object in this mask");
RNA_def_property_ui_text(prop, "Active Shape", "Active layer in this mask");
}
static void rna_def_mask(BlenderRNA *brna)
@@ -624,25 +624,25 @@ static void rna_def_mask(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
rna_def_mask_object(brna);
rna_def_mask_layer(brna);
srna = RNA_def_struct(brna, "Mask", "ID");
RNA_def_struct_ui_text(srna, "Mask", "Mask datablock defining mask for compositing");
RNA_def_struct_ui_icon(srna, ICON_MOD_MASK);
/* mask objects */
prop = RNA_def_property(srna, "objects", PROP_COLLECTION, PROP_NONE);
RNA_def_property_collection_funcs(prop, "rna_Mask_objects_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", 0, 0, 0, 0);
RNA_def_property_struct_type(prop, "MaskObject");
RNA_def_property_ui_text(prop, "Objects", "Collection of objects which defines this mask");
rna_def_maskobjects(brna, prop);
/* mask layers */
prop = RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);
RNA_def_property_collection_funcs(prop, "rna_Mask_layers_begin", "rna_iterator_listbase_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", 0, 0, 0, 0);
RNA_def_property_struct_type(prop, "MaskLayer");
RNA_def_property_ui_text(prop, "Layers", "Collection of layers which defines this mask");
rna_def_masklayers(brna, prop);
/* active maskobj index */
prop = RNA_def_property(srna, "active_object_index", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, NULL, "act_maskobj");
/* active masklay index */
prop = RNA_def_property(srna, "active_layer_index", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, NULL, "masklay_act");
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_int_funcs(prop, "rna_Mask_object_active_index_get", "rna_Mask_object_active_index_set", "rna_Mask_object_active_index_range");
RNA_def_property_ui_text(prop, "Active Shape Index", "Index of active object in list of all mask's objects");
RNA_def_property_int_funcs(prop, "rna_Mask_layer_active_index_get", "rna_Mask_layer_active_index_set", "rna_Mask_layer_active_index_range");
RNA_def_property_ui_text(prop, "Active Shape Index", "Index of active layer in list of all mask's layers");
/* pointers */
rna_def_animdata_common(srna);