rename mask-objects to mask-layers.

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()

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);
+struct MaskLayerShape *BKE_mask_layer_shape_find_frame(struct MaskLayer *masklay, int frame);
+int BKE_mask_layer_shape_find_frame_range(struct MaskLayer *masklay, int frame,
+                                           struct MaskLayerShape **r_masklay_shape_a,
+                                           struct MaskLayerShape **r_masklay_shape_b);
+struct MaskLayerShape *BKE_mask_layer_shape_varify_frame(struct MaskLayer *masklay, int frame);
+void BKE_mask_layer_shape_unlink(struct MaskLayer *masklay, struct MaskLayerShape *masklay_shape);
+void BKE_mask_layer_shape_sort(struct MaskLayer *masklay);
 
-int BKE_mask_object_shape_spline_from_index(struct MaskObject *maskobj, int index,
-                                            struct MaskSpline **r_maskobj_shape, int *r_index);
-int BKE_mask_object_shape_spline_to_index(struct MaskObject *maskobj, struct MaskSpline *spline);
+int BKE_mask_layer_shape_spline_from_index(struct MaskLayer *masklay, int index,
+                                            struct MaskSpline **r_masklay_shape, int *r_index);
+int BKE_mask_layer_shape_spline_to_index(struct MaskLayer *masklay, struct MaskSpline *spline);
 
-int BKE_mask_object_shape_spline_index(struct MaskObject *maskobj, int index,
-                                       struct MaskSpline **r_maskobj_shape, int *r_index);
-void BKE_mask_object_shape_changed_add(struct MaskObject *maskobj, int index,
+int BKE_mask_layer_shape_spline_index(struct MaskLayer *masklay, int index,
+                                       struct MaskSpline **r_masklay_shape, int *r_index);
+void BKE_mask_layer_shape_changed_add(struct MaskLayer *masklay, int index,
                                        int do_init, int do_init_interpolate);
 
-void BKE_mask_object_shape_changed_remove(struct MaskObject *maskobj, int index, int count);
+void BKE_mask_layer_shape_changed_remove(struct MaskLayer *masklay, int index, int count);
 
 /* rasterization */
 void BKE_mask_rasterize(struct Mask *mask, int width, int height, float *buffer);

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) {

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;
 

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);
 				}
 			}
 		}

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);
 		}
 	}
 }

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 */

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 */

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);

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);
 }

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);

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);
 

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");
 
 }

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];
 

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++) {

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;
 	}
 

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);
 			}
 		}
 	}

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); */
 

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++) {

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)
 };

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;

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);