diff options
22 files changed, 670 insertions, 670 deletions
diff --git a/release/scripts/startup/bl_ui/space_clip.py b/release/scripts/startup/bl_ui/space_clip.py index a5b1996ae0d..ab1bd817490 100644 --- a/release/scripts/startup/bl_ui/space_clip.py +++ b/release/scripts/startup/bl_ui/space_clip.py @@ -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() diff --git a/source/blender/blenkernel/BKE_mask.h b/source/blender/blenkernel/BKE_mask.h index 5663aa69e8b..8fc979e941b 100644 --- a/source/blender/blenkernel/BKE_mask.h +++ b/source/blender/blenkernel/BKE_mask.h @@ -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); - -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_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, +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_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_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); diff --git a/source/blender/blenkernel/intern/mask.c b/source/blender/blenkernel/intern/mask.c index 9e509c10989..e6f328546f5 100644 --- a/source/blender/blenkernel/intern/mask.c +++ b/source/blender/blenkernel/intern/mask.c @@ -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) { diff --git a/source/blender/blenloader/intern/readfile.c b/source/blender/blenloader/intern/readfile.c index 9122e01fb2a..602c410dc21 100644 --- a/source/blender/blenloader/intern/readfile.c +++ b/source/blender/blenloader/intern/readfile.c @@ -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; diff --git a/source/blender/blenloader/intern/writefile.c b/source/blender/blenloader/intern/writefile.c index 0b552ce220c..74287f0e693 100644 --- a/source/blender/blenloader/intern/writefile.c +++ b/source/blender/blenloader/intern/writefile.c @@ -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); } } } diff --git a/source/blender/editors/animation/keyframes_draw.c b/source/blender/editors/animation/keyframes_draw.c index 579527dfc56..cee8d15a807 100644 --- a/source/blender/editors/animation/keyframes_draw.c +++ b/source/blender/editors/animation/keyframes_draw.c @@ -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); } } } diff --git a/source/blender/editors/include/ED_keyframes_draw.h b/source/blender/editors/include/ED_keyframes_draw.h index d90b5648c23..e24c21bc133 100644 --- a/source/blender/editors/include/ED_keyframes_draw.h +++ b/source/blender/editors/include/ED_keyframes_draw.h @@ -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 */ diff --git a/source/blender/editors/include/ED_mask.h b/source/blender/editors/include/ED_mask.h index b7dee09cbe9..0c4c2f4788c 100644 --- a/source/blender/editors/include/ED_mask.h +++ b/source/blender/editors/include/ED_mask.h @@ -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 */ diff --git a/source/blender/editors/interface/interface_templates.c b/source/blender/editors/interface/interface_templates.c index d23cd88cf05..daba096696c 100644 --- a/source/blender/editors/interface/interface_templates.c +++ b/source/blender/editors/interface/interface_templates.c @@ -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); diff --git a/source/blender/editors/mask/mask_draw.c b/source/blender/editors/mask/mask_draw.c index c282153acbf..5b8bf1075b4 100644 --- a/source/blender/editors/mask/mask_draw.c +++ b/source/blender/editors/mask/mask_draw.c @@ -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); } diff --git a/source/blender/editors/mask/mask_editor.c b/source/blender/editors/mask/mask_editor.c index a0b47be8ea3..778990726e5 100644 --- a/source/blender/editors/mask/mask_editor.c +++ b/source/blender/editors/mask/mask_editor.c @@ -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); diff --git a/source/blender/editors/mask/mask_intern.h b/source/blender/editors/mask/mask_intern.h index b17d7e7173a..5940b76abf0 100644 --- a/source/blender/editors/mask/mask_intern.h +++ b/source/blender/editors/mask/mask_intern.h @@ -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); diff --git a/source/blender/editors/mask/mask_ops.c b/source/blender/editors/mask/mask_ops.c index 2eaae673364..e56eb181a51 100644 --- a/source/blender/editors/mask/mask_ops.c +++ b/source/blender/editors/mask/mask_ops.c @@ -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"); } diff --git a/source/blender/editors/mask/mask_relationships.c b/source/blender/editors/mask/mask_relationships.c index bf57bce9957..8a8427c024b 100644 --- a/source/blender/editors/mask/mask_relationships.c +++ b/source/blender/editors/mask/mask_relationships.c @@ -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]; diff --git a/source/blender/editors/mask/mask_select.c b/source/blender/editors/mask/mask_select.c index c204dbf0110..95c2808bc3e 100644 --- a/source/blender/editors/mask/mask_select.c +++ b/source/blender/editors/mask/mask_select.c @@ -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++) { diff --git a/source/blender/editors/mask/mask_shapekey.c b/source/blender/editors/mask/mask_shapekey.c index e323a6abe15..94aebb9f3a1 100644 --- a/source/blender/editors/mask/mask_shapekey.c +++ b/source/blender/editors/mask/mask_shapekey.c @@ -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; } diff --git a/source/blender/editors/screen/screen_ops.c b/source/blender/editors/screen/screen_ops.c index 7caff30807d..89c7896d53c 100644 --- a/source/blender/editors/screen/screen_ops.c +++ b/source/blender/editors/screen/screen_ops.c @@ -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); } } } diff --git a/source/blender/editors/space_clip/clip_draw.c b/source/blender/editors/space_clip/clip_draw.c index fd47bc376c7..003fa5c5cef 100644 --- a/source/blender/editors/space_clip/clip_draw.c +++ b/source/blender/editors/space_clip/clip_draw.c @@ -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); */ diff --git a/source/blender/editors/transform/transform_conversions.c b/source/blender/editors/transform/transform_conversions.c index 8211df67b17..23a88e6e547 100644 --- a/source/blender/editors/transform/transform_conversions.c +++ b/source/blender/editors/transform/transform_conversions.c @@ -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++) { diff --git a/source/blender/makesdna/DNA_mask_types.h b/source/blender/makesdna/DNA_mask_types.h index d677239e300..28fc9466613 100644 --- a/source/blender/makesdna/DNA_mask_types.h +++ b/source/blender/makesdna/DNA_mask_types.h @@ -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) }; diff --git a/source/blender/makesrna/RNA_access.h b/source/blender/makesrna/RNA_access.h index 9c465619b95..319e93b3084 100644 --- a/source/blender/makesrna/RNA_access.h +++ b/source/blender/makesrna/RNA_access.h @@ -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; diff --git a/source/blender/makesrna/intern/rna_mask.c b/source/blender/makesrna/intern/rna_mask.c index c072676b665..c356cae81af 100644 --- a/source/blender/makesrna/intern/rna_mask.c +++ b/source/blender/makesrna/intern/rna_mask.c @@ -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); |