3f23a376ea33cdb84491365daa5bff09d43e1d36
[blender.git] / source / blender / makesrna / intern / rna_mask.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation,
19  *                 Sergey Sharybin
20  *
21  * ***** END GPL LICENSE BLOCK *****
22  */
23
24 /** \file blender/makesrna/intern/rna_mask.c
25  *  \ingroup RNA
26  */
27
28
29 #include <stdlib.h>
30 #include <limits.h>
31
32 #include "MEM_guardedalloc.h"
33
34 #include "BKE_movieclip.h"
35 #include "BKE_tracking.h"
36
37 #include "RNA_define.h"
38 #include "RNA_enum_types.h"
39
40 #include "rna_internal.h"
41
42 #include "DNA_mask_types.h"
43 #include "DNA_object_types.h"   /* SELECT */
44 #include "DNA_scene_types.h"
45
46 #include "WM_types.h"
47
48 #include "IMB_imbuf_types.h"
49 #include "IMB_imbuf.h"
50
51 #ifdef RNA_RUNTIME
52
53 #include "DNA_mask_types.h"
54 #include "DNA_movieclip_types.h"
55
56 #include "BKE_depsgraph.h"
57 #include "BKE_mask.h"
58 #include "BKE_tracking.h"
59
60 #include "BLI_math.h"
61
62 #include "RNA_access.h"
63
64 #include "WM_api.h"
65
66 static void rna_Mask_update_data(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
67 {
68         Mask *mask = ptr->id.data;
69
70         WM_main_add_notifier(NC_MASK | ND_DATA, mask);
71         DAG_id_tag_update( &mask->id, 0);
72 }
73
74 static void rna_Mask_update_parent(Main *bmain, Scene *scene, PointerRNA *ptr)
75 {
76         MaskParent *parent = ptr->data;
77
78         if (parent->id) {
79                 if (GS(parent->id->name) == ID_MC) {
80                         MovieClip *clip = (MovieClip *) parent->id;
81                         MovieTracking *tracking = &clip->tracking;
82                         MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, parent->parent);
83
84                         if (object) {
85                                 MovieTrackingTrack *track = BKE_tracking_track_get_named(tracking, object, parent->sub_parent);
86
87                                 if (track) {
88                                         int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, scene->r.cfra);
89                                         MovieTrackingMarker *marker = BKE_tracking_marker_get(track, clip_framenr);
90                                         float marker_pos_ofs[2], parmask_pos[2];
91                                         MovieClipUser user = {0};
92
93                                         BKE_movieclip_user_set_frame(&user, scene->r.cfra);
94
95                                         add_v2_v2v2(marker_pos_ofs, marker->pos, track->offset);
96
97                                         BKE_mask_coord_from_movieclip(clip, &user, parmask_pos, marker_pos_ofs);
98
99                                         copy_v2_v2(parent->parent_orig, parmask_pos);
100                                 }
101                         }
102                 }
103         }
104
105         rna_Mask_update_data(bmain, scene, ptr);
106 }
107
108 /* note: this function exists only to avoid id refcounting */
109 static void rna_MaskParent_id_set(PointerRNA *ptr, PointerRNA value)
110 {
111         MaskParent *mpar = (MaskParent *) ptr->data;
112
113         mpar->id = value.data;
114 }
115
116 static StructRNA *rna_MaskParent_id_typef(PointerRNA *ptr)
117 {
118         MaskParent *mpar = (MaskParent *) ptr->data;
119
120         return ID_code_to_RNA_type(mpar->id_type);
121 }
122
123 static void rna_MaskParent_id_type_set(PointerRNA *ptr, int value)
124 {
125         MaskParent *mpar = (MaskParent *) ptr->data;
126
127         /* change ID-type to the new type */
128         mpar->id_type = value;
129
130         /* clear the id-block if the type is invalid */
131         if ((mpar->id) && (GS(mpar->id->name) != mpar->id_type))
132                 mpar->id = NULL;
133 }
134
135 static void rna_Mask_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
136 {
137         Mask *mask = (Mask *)ptr->id.data;
138
139         rna_iterator_listbase_begin(iter, &mask->masklayers, NULL);
140 }
141
142 static int rna_Mask_layer_active_index_get(PointerRNA *ptr)
143 {
144         Mask *mask = (Mask *)ptr->id.data;
145
146         return mask->masklay_act;
147 }
148
149 static void rna_Mask_layer_active_index_set(PointerRNA *ptr, int value)
150 {
151         Mask *mask = (Mask *)ptr->id.data;
152
153         mask->masklay_act = value;
154 }
155
156 static void rna_Mask_layer_active_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
157 {
158         Mask *mask = (Mask *)ptr->id.data;
159
160         *min = 0;
161         *max = max_ii(0, mask->masklay_tot - 1);
162
163         *softmin = *min;
164         *softmax = *max;
165 }
166
167 static char *rna_MaskLayer_path(PointerRNA *ptr)
168 {
169         return BLI_sprintfN("layers[\"%s\"]", ((MaskLayer *)ptr->data)->name);
170 }
171
172 static PointerRNA rna_Mask_layer_active_get(PointerRNA *ptr)
173 {
174         Mask *mask = (Mask *)ptr->id.data;
175         MaskLayer *masklay = BKE_mask_layer_active(mask);
176
177         return rna_pointer_inherit_refine(ptr, &RNA_MaskLayer, masklay);
178 }
179
180 static void rna_Mask_layer_active_set(PointerRNA *ptr, PointerRNA value)
181 {
182         Mask *mask = (Mask *)ptr->id.data;
183         MaskLayer *masklay = (MaskLayer *)value.data;
184
185         BKE_mask_layer_active_set(mask, masklay);
186 }
187
188 static void rna_MaskLayer_splines_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
189 {
190         MaskLayer *masklay = (MaskLayer *)ptr->data;
191
192         rna_iterator_listbase_begin(iter, &masklay->splines, NULL);
193 }
194
195 static void rna_MaskLayer_name_set(PointerRNA *ptr, const char *value)
196 {
197         Mask *mask = (Mask *)ptr->id.data;
198         MaskLayer *masklay = (MaskLayer *)ptr->data;
199
200         BLI_strncpy(masklay->name, value, sizeof(masklay->name));
201
202         BKE_mask_layer_unique_name(mask, masklay);
203 }
204
205 static PointerRNA rna_MaskLayer_active_spline_get(PointerRNA *ptr)
206 {
207         MaskLayer *masklay = (MaskLayer *)ptr->data;
208
209         return rna_pointer_inherit_refine(ptr, &RNA_MaskSpline, masklay->act_spline);
210 }
211
212 static void rna_MaskLayer_active_spline_set(PointerRNA *ptr, PointerRNA value)
213 {
214         MaskLayer *masklay = (MaskLayer *)ptr->data;
215         MaskSpline *spline = (MaskSpline *)value.data;
216         int index = BLI_findindex(&masklay->splines, spline);
217
218         if (index >= 0)
219                 masklay->act_spline = spline;
220         else
221                 masklay->act_spline = NULL;
222 }
223
224 static PointerRNA rna_MaskLayer_active_spline_point_get(PointerRNA *ptr)
225 {
226         MaskLayer *masklay = (MaskLayer *)ptr->data;
227
228         return rna_pointer_inherit_refine(ptr, &RNA_MaskSplinePoint, masklay->act_point);
229 }
230
231 static void rna_MaskLayer_active_spline_point_set(PointerRNA *ptr, PointerRNA value)
232 {
233         MaskLayer *masklay = (MaskLayer *)ptr->data;
234         MaskSpline *spline;
235         MaskSplinePoint *point = (MaskSplinePoint *)value.data;
236
237         masklay->act_point = NULL;
238
239         for (spline = masklay->splines.first; spline; spline = spline->next) {
240                 if (point >= spline->points && point < spline->points + spline->tot_point) {
241                         masklay->act_point = point;
242
243                         break;
244                 }
245         }
246 }
247
248 static void rna_MaskSplinePoint_handle1_get(PointerRNA *ptr, float *values)
249 {
250         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
251         BezTriple *bezt = &point->bezt;
252         copy_v2_v2(values, bezt->vec[0]);
253 }
254
255 static void rna_MaskSplinePoint_handle1_set(PointerRNA *ptr, const float *values)
256 {
257         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
258         BezTriple *bezt = &point->bezt;
259         copy_v2_v2(bezt->vec[0], values);
260 }
261
262 static void rna_MaskSplinePoint_handle2_get(PointerRNA *ptr, float *values)
263 {
264         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
265         BezTriple *bezt = &point->bezt;
266         copy_v2_v2(values, bezt->vec[2]);
267 }
268
269 static void rna_MaskSplinePoint_handle2_set(PointerRNA *ptr, const float *values)
270 {
271         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
272         BezTriple *bezt = &point->bezt;
273         copy_v2_v2(bezt->vec[2], values);
274 }
275
276 static void rna_MaskSplinePoint_ctrlpoint_get(PointerRNA *ptr, float *values)
277 {
278         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
279         BezTriple *bezt = &point->bezt;
280         copy_v2_v2(values, bezt->vec[1]);
281 }
282
283 static void rna_MaskSplinePoint_ctrlpoint_set(PointerRNA *ptr, const float *values)
284 {
285         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
286         BezTriple *bezt = &point->bezt;
287         copy_v2_v2(bezt->vec[1], values);
288 }
289
290 static int rna_MaskSplinePoint_handle_type_get(PointerRNA *ptr)
291 {
292         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
293         BezTriple *bezt = &point->bezt;
294
295         return bezt->h1;
296 }
297
298 static void rna_MaskSplinePoint_handle_type_set(PointerRNA *ptr, int value)
299 {
300         MaskSplinePoint *point = (MaskSplinePoint *) ptr->data;
301         BezTriple *bezt = &point->bezt;
302
303         bezt->h1 = bezt->h2 = value;
304 }
305
306 /* ** API **  */
307
308 static MaskLayer *rna_Mask_layers_new(Mask *mask, const char *name)
309 {
310         MaskLayer *masklay = BKE_mask_layer_new(mask, name);
311
312         WM_main_add_notifier(NC_MASK | NA_EDITED, mask);
313
314         return masklay;
315 }
316
317 static void rna_Mask_layers_remove(Mask *mask, ReportList *reports, PointerRNA *masklay_ptr)
318 {
319         MaskLayer *masklay = masklay_ptr->data;
320         if (BLI_findindex(&mask->masklayers, masklay) == -1) {
321                 BKE_reportf(reports, RPT_ERROR, "Mask layer '%s' not found in mask '%s'", masklay->name, mask->id.name + 2);
322                 return;
323         }
324
325         BKE_mask_layer_remove(mask, masklay);
326         RNA_POINTER_INVALIDATE(masklay_ptr);
327
328         WM_main_add_notifier(NC_MASK | NA_EDITED, mask);
329 }
330
331 static void rna_Mask_layers_clear(Mask *mask)
332 {
333         BKE_mask_layer_free_list(&mask->masklayers);
334
335         WM_main_add_notifier(NC_MASK | NA_EDITED, mask);
336 }
337
338 static void rna_MaskLayer_spline_add(ID *id, MaskLayer *masklay, int number)
339 {
340         Mask *mask = (Mask *) id;
341         int i;
342
343         for (i = 0; i < number; i++)
344                 BKE_mask_spline_add(masklay);
345
346         WM_main_add_notifier(NC_MASK | NA_EDITED, mask);
347 }
348
349 static void rna_Mask_start_frame_set(PointerRNA *ptr, int value)
350 {
351         Mask *data = (Mask *)ptr->data;
352         /* MINFRAME not MINAFRAME, since some output formats can't taken negative frames */
353         CLAMP(value, MINFRAME, MAXFRAME);
354         data->sfra = value;
355
356         if (data->sfra >= data->efra) {
357                 data->efra = MIN2(data->sfra, MAXFRAME);
358         }
359 }
360
361 static void rna_Mask_end_frame_set(PointerRNA *ptr, int value)
362 {
363         Mask *data = (Mask *)ptr->data;
364         CLAMP(value, MINFRAME, MAXFRAME);
365         data->efra = value;
366
367         if (data->sfra >= data->efra) {
368                 data->sfra = MAX2(data->efra, MINFRAME);
369         }
370 }
371
372 #else
373
374 static void rna_def_maskParent(BlenderRNA *brna)
375 {
376         StructRNA *srna;
377         PropertyRNA *prop;
378
379         static EnumPropertyItem mask_id_type_items[] = {
380                 {ID_MC, "MOVIECLIP", ICON_SEQUENCE, "Movie Clip", ""},
381                 {0, NULL, 0, NULL, NULL}};
382
383         srna = RNA_def_struct(brna, "MaskParent", NULL);
384         RNA_def_struct_ui_text(srna, "Mask Parent", "Parenting settings for masking element");
385
386         /* Target Properties - ID-block to Drive */
387         prop = RNA_def_property(srna, "id", PROP_POINTER, PROP_NONE);
388         RNA_def_property_struct_type(prop, "ID");
389         RNA_def_property_flag(prop, PROP_EDITABLE);
390         // RNA_def_property_editable_func(prop, "rna_maskSpline_id_editable");
391         /* note: custom set function is ONLY to avoid rna setting a user for this. */
392         RNA_def_property_pointer_funcs(prop, NULL, "rna_MaskParent_id_set", "rna_MaskParent_id_typef", NULL);
393         RNA_def_property_ui_text(prop, "ID", "ID-block to which masking element would be parented to or to it's property");
394         RNA_def_property_update(prop, 0, "rna_Mask_update_parent");
395
396         prop = RNA_def_property(srna, "id_type", PROP_ENUM, PROP_NONE);
397         RNA_def_property_enum_sdna(prop, NULL, "id_type");
398         RNA_def_property_enum_items(prop, mask_id_type_items);
399         RNA_def_property_enum_default(prop, ID_MC);
400         RNA_def_property_enum_funcs(prop, NULL, "rna_MaskParent_id_type_set", NULL);
401         //RNA_def_property_editable_func(prop, "rna_MaskParent_id_type_editable");
402         RNA_def_property_ui_text(prop, "ID Type", "Type of ID-block that can be used");
403         RNA_def_property_update(prop, 0, "rna_Mask_update_parent");
404
405         /* parent */
406         prop = RNA_def_property(srna, "parent", PROP_STRING, PROP_NONE);
407         RNA_def_property_ui_text(prop, "Parent", "Name of parent object in specified data block to which parenting happens");
408         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
409         RNA_def_property_update(prop, 0, "rna_Mask_update_parent");
410
411         /* sub_parent */
412         prop = RNA_def_property(srna, "sub_parent", PROP_STRING, PROP_NONE);
413         RNA_def_property_ui_text(prop, "Sub Parent", "Name of parent sub-object in specified data block to which parenting happens");
414         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
415         RNA_def_property_update(prop, 0, "rna_Mask_update_parent");
416 }
417
418 static void rna_def_maskSplinePointUW(BlenderRNA *brna)
419 {
420         StructRNA *srna;
421         PropertyRNA *prop;
422
423         srna = RNA_def_struct(brna, "MaskSplinePointUW", NULL);
424         RNA_def_struct_ui_text(srna, "Mask Spline UW Point", "Single point in spline segment defining feather");
425
426         /* u */
427         prop = RNA_def_property(srna, "u", PROP_FLOAT, PROP_NONE);
428         RNA_def_property_float_sdna(prop, NULL, "u");
429         RNA_def_property_range(prop, 0.0, 1.0);
430         RNA_def_property_ui_text(prop, "U", "U coordinate of point along spline segment");
431         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
432
433         /* weight */
434         prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
435         RNA_def_property_float_sdna(prop, NULL, "w");
436         RNA_def_property_range(prop, 0.0, 1.0);
437         RNA_def_property_ui_text(prop, "Weight", "Weight of feather point");
438         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
439
440         /* select */
441         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
442         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
443         RNA_def_property_ui_text(prop, "Select", "Selection status");
444         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
445 }
446
447 static void rna_def_maskSplinePoint(BlenderRNA *brna)
448 {
449         StructRNA *srna;
450         PropertyRNA *prop;
451
452         static EnumPropertyItem handle_type_items[] = {
453                 {HD_AUTO, "AUTO", 0, "Auto", ""},
454                 {HD_VECT, "VECTOR", 0, "Vector", ""},
455                 {HD_ALIGN, "ALIGNED", 0, "Aligned", ""},
456                 {0, NULL, 0, NULL, NULL}};
457
458         rna_def_maskSplinePointUW(brna);
459
460         srna = RNA_def_struct(brna, "MaskSplinePoint", NULL);
461         RNA_def_struct_ui_text(srna, "Mask Spline Point", "Single point in spline used for defining mask");
462
463         /* Vector values */
464         prop = RNA_def_property(srna, "handle_left", PROP_FLOAT, PROP_TRANSLATION);
465         RNA_def_property_array(prop, 2);
466         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_handle1_get", "rna_MaskSplinePoint_handle1_set", NULL);
467         RNA_def_property_ui_text(prop, "Handle 1", "Coordinates of the first handle");
468         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
469
470         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
471         RNA_def_property_array(prop, 2);
472         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_ctrlpoint_get", "rna_MaskSplinePoint_ctrlpoint_set", NULL);
473         RNA_def_property_ui_text(prop, "Control Point", "Coordinates of the control point");
474         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
475
476         prop = RNA_def_property(srna, "handle_right", PROP_FLOAT, PROP_TRANSLATION);
477         RNA_def_property_array(prop, 2);
478         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_handle2_get", "rna_MaskSplinePoint_handle2_set", NULL);
479         RNA_def_property_ui_text(prop, "Handle 2", "Coordinates of the second handle");
480         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
481
482         /* handle_type */
483         prop = RNA_def_property(srna, "handle_type", PROP_ENUM, PROP_NONE);
484         RNA_def_property_enum_funcs(prop, "rna_MaskSplinePoint_handle_type_get", "rna_MaskSplinePoint_handle_type_set", NULL);
485         RNA_def_property_enum_items(prop, handle_type_items);
486         RNA_def_property_ui_text(prop, "Handle Type", "Handle type");
487         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
488
489         /* select */
490         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
491         RNA_def_property_boolean_sdna(prop, NULL, "bezt.f1", SELECT);
492         RNA_def_property_ui_text(prop, "Select", "Selection status");
493         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
494
495         /* parent */
496         prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
497         RNA_def_property_struct_type(prop, "MaskParent");
498
499         /* feather points */
500         prop = RNA_def_property(srna, "feather_points", PROP_COLLECTION, PROP_NONE);
501         RNA_def_property_struct_type(prop, "MaskSplinePointUW");
502         RNA_def_property_collection_sdna(prop, NULL, "uw", "tot_uw");
503         RNA_def_property_ui_text(prop, "Feather Points", "Points defining feather");
504 }
505
506 static void rna_def_mask_splines(BlenderRNA *brna)
507 {
508         StructRNA *srna;
509         FunctionRNA *func;
510         PropertyRNA *prop;
511
512         srna = RNA_def_struct(brna, "MaskSplines", NULL);
513         RNA_def_struct_sdna(srna, "MaskLayer");
514         RNA_def_struct_ui_text(srna, "Mask Splines", "Collection of masking splines");
515
516         func = RNA_def_function(srna, "add", "rna_MaskLayer_spline_add");
517         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
518         RNA_def_function_ui_description(func, "Add a number of splines to mask layer");
519         RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of splines to add to the layer", 0, INT_MAX);
520
521         /* active spline */
522         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
523         RNA_def_property_struct_type(prop, "MaskSpline");
524         RNA_def_property_pointer_funcs(prop, "rna_MaskLayer_active_spline_get", "rna_MaskLayer_active_spline_set", NULL, NULL);
525         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
526         RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking layer");
527
528         /* active point */
529         prop = RNA_def_property(srna, "active_point", PROP_POINTER, PROP_NONE);
530         RNA_def_property_struct_type(prop, "MaskSplinePoint");
531         RNA_def_property_pointer_funcs(prop, "rna_MaskLayer_active_spline_point_get", "rna_MaskLayer_active_spline_point_set", NULL, NULL);
532         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
533         RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking layer");
534 }
535
536 static void rna_def_maskSpline(BlenderRNA *brna)
537 {
538         static EnumPropertyItem spline_interpolation_items[] = {
539                 {MASK_SPLINE_INTERP_LINEAR, "LINEAR", 0, "Linear", ""},
540                 {MASK_SPLINE_INTERP_EASE, "EASE", 0, "Ease", ""},
541                 {0, NULL, 0, NULL, NULL}
542         };
543
544         static EnumPropertyItem spline_offset_mode_items[] = {
545                 {MASK_SPLINE_OFFSET_EVEN, "EVEN", 0, "Even", "Calculate even feather offset"},
546                 {MASK_SPLINE_OFFSET_SMOOTH, "SMOOTH", 0, "Smooth", "Calculate feather offset as a second curve"},
547                 {0, NULL, 0, NULL, NULL}
548         };
549
550         StructRNA *srna;
551         PropertyRNA *prop;
552
553         rna_def_maskSplinePoint(brna);
554
555         srna = RNA_def_struct(brna, "MaskSpline", NULL);
556         RNA_def_struct_ui_text(srna, "Mask spline", "Single spline used for defining mask shape");
557
558         /* offset mode */
559         prop = RNA_def_property(srna, "offset_mode", PROP_ENUM, PROP_NONE);
560         RNA_def_property_enum_sdna(prop, NULL, "offset_mode");
561         RNA_def_property_enum_items(prop, spline_offset_mode_items);
562         RNA_def_property_ui_text(prop, "Feather Offset", "The method used for calculating the feather offset");
563         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
564
565         /* weight interpolation */
566         prop = RNA_def_property(srna, "weight_interpolation", PROP_ENUM, PROP_NONE);
567         RNA_def_property_enum_sdna(prop, NULL, "weight_interp");
568         RNA_def_property_enum_items(prop, spline_interpolation_items);
569         RNA_def_property_ui_text(prop, "Weight Interpolation", "The type of weight interpolation for spline");
570         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
571
572         /* cyclic */
573         prop = RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
574         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
575         RNA_def_property_boolean_sdna(prop, NULL, "flag", MASK_SPLINE_CYCLIC);
576         RNA_def_property_ui_text(prop, "Cyclic", "Make this spline a closed loop");
577         RNA_def_property_update(prop, NC_MASK | NA_EDITED, "rna_Mask_update_data");
578
579         /* fill */
580         prop = RNA_def_property(srna, "use_fill", PROP_BOOLEAN, PROP_NONE);
581         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
582         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", MASK_SPLINE_NOFILL);
583         RNA_def_property_ui_text(prop, "Fill", "Make this spline filled");
584         RNA_def_property_update(prop, NC_MASK | NA_EDITED, "rna_Mask_update_data");
585
586         /* self-intersection check */
587         prop = RNA_def_property(srna, "use_self_intersection_check", PROP_BOOLEAN, PROP_NONE);
588         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
589         RNA_def_property_boolean_sdna(prop, NULL, "flag", MASK_SPLINE_NOINTERSECT);
590         RNA_def_property_ui_text(prop, "Self Intersection Check", "Prevent feather from self-intersections");
591         RNA_def_property_update(prop, NC_MASK | NA_EDITED, "rna_Mask_update_data");
592 }
593
594 static void rna_def_mask_layer(BlenderRNA *brna)
595 {
596         static EnumPropertyItem masklay_blend_mode_items[] = {
597                 {MASK_BLEND_MERGE_ADD, "MERGE_ADD", 0, "Merge Add", ""},
598                 {MASK_BLEND_MERGE_SUBTRACT, "MERGE_SUBTRACT", 0, "Merge Subtract", ""},
599                 {MASK_BLEND_ADD, "ADD", 0, "Add", ""},
600                 {MASK_BLEND_SUBTRACT, "SUBTRACT", 0, "Subtract", ""},
601                 {MASK_BLEND_LIGHTEN, "LIGHTEN", 0, "Lighten", ""},
602                 {MASK_BLEND_DARKEN, "DARKEN", 0, "Darken", ""},
603                 {MASK_BLEND_MUL, "MUL", 0, "Multiply", ""},
604                 {MASK_BLEND_REPLACE, "REPLACE", 0, "Replace", ""},
605                 {MASK_BLEND_DIFFERENCE, "DIFFERENCE", 0, "Difference", ""},
606                 {0, NULL, 0, NULL, NULL}
607         };
608
609         StructRNA *srna;
610         PropertyRNA *prop;
611
612         rna_def_maskSpline(brna);
613         rna_def_mask_splines(brna);
614
615         srna = RNA_def_struct(brna, "MaskLayer", NULL);
616         RNA_def_struct_ui_text(srna, "Mask Layer", "Single layer used for masking pixels");
617         RNA_def_struct_path_func(srna, "rna_MaskLayer_path");
618
619         /* name */
620         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
621         RNA_def_property_ui_text(prop, "Name", "Unique name of layer");
622         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MaskLayer_name_set");
623         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
624         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
625         RNA_def_struct_name_property(srna, prop);
626
627         /* splines */
628         prop = RNA_def_property(srna, "splines", PROP_COLLECTION, PROP_NONE);
629         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);
630         RNA_def_property_struct_type(prop, "MaskSpline");
631         RNA_def_property_ui_text(prop, "Splines", "Collection of splines which defines this layer");
632         RNA_def_property_srna(prop, "MaskSplines");
633
634         /* restrict */
635         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
636         RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_VIEW);
637         RNA_def_property_ui_text(prop, "Restrict View", "Restrict visibility in the viewport");
638         RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_OFF, 1);
639         RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
640
641         prop = RNA_def_property(srna, "hide_select", PROP_BOOLEAN, PROP_NONE);
642         RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_SELECT);
643         RNA_def_property_ui_text(prop, "Restrict Select", "Restrict selection in the viewport");
644         RNA_def_property_ui_icon(prop, ICON_RESTRICT_SELECT_OFF, 1);
645         RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
646
647         prop = RNA_def_property(srna, "hide_render", PROP_BOOLEAN, PROP_NONE);
648         RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_RENDER);
649         RNA_def_property_ui_text(prop, "Restrict Render", "Restrict renderability");
650         RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
651         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
652
653         /* select (for dopesheet)*/
654         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
655         RNA_def_property_boolean_sdna(prop, NULL, "flag", MASK_LAYERFLAG_SELECT);
656         RNA_def_property_ui_text(prop, "Select", "Layer is selected for editing in the DopeSheet");
657 //      RNA_def_property_update(prop, NC_SCREEN | ND_MASK, NULL);
658
659         /* render settings */
660         prop = RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_NONE);
661         RNA_def_property_float_sdna(prop, NULL, "alpha");
662         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.1, 3);
663         RNA_def_property_ui_text(prop, "Opacity", "Render Opacity");
664         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
665
666         /* weight interpolation */
667         prop = RNA_def_property(srna, "blend", PROP_ENUM, PROP_NONE);
668         RNA_def_property_enum_sdna(prop, NULL, "blend");
669         RNA_def_property_enum_items(prop, masklay_blend_mode_items);
670         RNA_def_property_ui_text(prop, "Blend", "Method of blending mask layers");
671         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
672         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
673
674         prop = RNA_def_property(srna, "invert", PROP_BOOLEAN, PROP_NONE);
675         RNA_def_property_boolean_sdna(prop, NULL, "blend_flag", MASK_BLENDFLAG_INVERT);
676         RNA_def_property_ui_text(prop, "Restrict View", "Invert the mask black/white");
677         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
678
679         prop = RNA_def_property(srna, "falloff", PROP_ENUM, PROP_NONE);
680         RNA_def_property_enum_sdna(prop, NULL, "falloff");
681         RNA_def_property_enum_items(prop, proportional_falloff_curve_only_items);
682         RNA_def_property_ui_text(prop, "Falloff", "Falloff type the feather");
683         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
684
685 }
686
687 static void rna_def_masklayers(BlenderRNA *brna, PropertyRNA *cprop)
688 {
689         StructRNA *srna;
690         PropertyRNA *prop;
691
692         FunctionRNA *func;
693         PropertyRNA *parm;
694
695         RNA_def_property_srna(cprop, "MaskLayers");
696         srna = RNA_def_struct(brna, "MaskLayers", NULL);
697         RNA_def_struct_sdna(srna, "Mask");
698         RNA_def_struct_ui_text(srna, "Mask Layers", "Collection of layers used by mask");
699
700         func = RNA_def_function(srna, "new", "rna_Mask_layers_new");
701         RNA_def_function_ui_description(func, "Add layer to this mask");
702         RNA_def_string(func, "name", "", 0, "Name", "Name of new layer");
703         parm = RNA_def_pointer(func, "layer", "MaskLayer", "", "New mask layer");
704         RNA_def_function_return(func, parm);
705
706         func = RNA_def_function(srna, "remove", "rna_Mask_layers_remove");
707         RNA_def_function_flag(func, FUNC_USE_REPORTS);
708         RNA_def_function_ui_description(func, "Remove layer from this mask");
709         parm = RNA_def_pointer(func, "layer", "MaskLayer", "", "Shape to be removed");
710         RNA_def_property_flag(parm, PROP_REQUIRED | PROP_NEVER_NULL | PROP_RNAPTR);
711         RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
712
713         /* clear all layers */
714         func = RNA_def_function(srna, "clear", "rna_Mask_layers_clear");
715         RNA_def_function_ui_description(func, "Remove all mask layers");
716
717         /* active layer */
718         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
719         RNA_def_property_struct_type(prop, "MaskLayer");
720         RNA_def_property_pointer_funcs(prop, "rna_Mask_layer_active_get", "rna_Mask_layer_active_set", NULL, NULL);
721         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
722         RNA_def_property_ui_text(prop, "Active Shape", "Active layer in this mask");
723 }
724
725 static void rna_def_mask(BlenderRNA *brna)
726 {
727         StructRNA *srna;
728         PropertyRNA *prop;
729
730         rna_def_mask_layer(brna);
731
732         srna = RNA_def_struct(brna, "Mask", "ID");
733         RNA_def_struct_ui_text(srna, "Mask", "Mask datablock defining mask for compositing");
734         RNA_def_struct_ui_icon(srna, ICON_MOD_MASK);
735
736         /* mask layers */
737         prop = RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);
738         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);
739         RNA_def_property_struct_type(prop, "MaskLayer");
740         RNA_def_property_ui_text(prop, "Layers", "Collection of layers which defines this mask");
741         rna_def_masklayers(brna, prop);
742
743         /* active masklay index */
744         prop = RNA_def_property(srna, "active_layer_index", PROP_INT, PROP_NONE);
745         RNA_def_property_int_sdna(prop, NULL, "masklay_act");
746         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
747         RNA_def_property_int_funcs(prop, "rna_Mask_layer_active_index_get", "rna_Mask_layer_active_index_set", "rna_Mask_layer_active_index_range");
748         RNA_def_property_ui_text(prop, "Active Shape Index", "Index of active layer in list of all mask's layers");
749         RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
750
751         /* frame range */
752         prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_TIME);
753         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
754         RNA_def_property_int_sdna(prop, NULL, "sfra");
755         RNA_def_property_int_funcs(prop, NULL, "rna_Mask_start_frame_set", NULL);
756         RNA_def_property_range(prop, MINFRAME, MAXFRAME);
757         RNA_def_property_ui_text(prop, "Start Frame", "First frame of the mask (used for sequencer)");
758         RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
759
760         prop = RNA_def_property(srna, "frame_end", PROP_INT, PROP_TIME);
761         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
762         RNA_def_property_int_sdna(prop, NULL, "efra");
763         RNA_def_property_int_funcs(prop, NULL, "rna_Mask_end_frame_set", NULL);
764         RNA_def_property_range(prop, MINFRAME, MAXFRAME);
765         RNA_def_property_ui_text(prop, "End Frame", "Final frame of the mask (used for sequencer)");
766         RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
767
768         /* pointers */
769         rna_def_animdata_common(srna);
770 }
771
772 void RNA_def_mask(BlenderRNA *brna)
773 {
774         rna_def_maskParent(brna);
775         rna_def_mask(brna);
776 }
777
778 #endif