51dfa020bea940e661035947a2e947b75cdbc2b8
[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
39 #include "rna_internal.h"
40
41 #include "DNA_mask_types.h"
42 #include "DNA_object_types.h"   /* SELECT */
43 #include "DNA_scene_types.h"
44
45 #include "WM_types.h"
46
47 #include "IMB_imbuf_types.h"
48 #include "IMB_imbuf.h"
49
50 #ifdef RNA_RUNTIME
51
52 #include "DNA_mask_types.h"
53 #include "DNA_movieclip_types.h"
54
55 #include "BKE_depsgraph.h"
56 #include "BKE_mask.h"
57 #include "BKE_tracking.h"
58
59 #include "BLI_math.h"
60
61 #include "RNA_access.h"
62
63 #include "WM_api.h"
64
65 static void rna_Mask_update_data(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
66 {
67         Mask *mask = ptr->id.data;
68
69         WM_main_add_notifier(NC_MASK|ND_DATA, mask);
70         DAG_id_tag_update( &mask->id, 0);
71 }
72
73 static void rna_Mask_update_parent(Main *bmain, Scene *scene, PointerRNA *ptr)
74 {
75         MaskParent *parent = ptr->data;
76
77         if (parent->id) {
78                 if (GS(parent->id->name) == ID_MC) {
79                         MovieClip *clip = (MovieClip *) parent->id;
80                         MovieTracking *tracking = &clip->tracking;
81                         MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, parent->parent);
82
83                         if (object) {
84                                 MovieTrackingTrack *track = BKE_tracking_track_get_named(tracking, object, parent->sub_parent);
85
86                                 if (track) {
87                                         int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, scene->r.cfra);
88                                         MovieTrackingMarker *marker = BKE_tracking_marker_get(track, clip_framenr);
89                                         float marker_pos_ofs[2], parmask_pos[2];
90                                         MovieClipUser user = {0};
91
92                                         BKE_movieclip_user_set_frame(&user, scene->r.cfra);
93
94                                         add_v2_v2v2(marker_pos_ofs, marker->pos, track->offset);
95
96                                         BKE_mask_coord_from_movieclip(clip, &user, parmask_pos, marker_pos_ofs);
97
98                                         copy_v2_v2(parent->parent_orig, parmask_pos);
99                                 }
100                         }
101                 }
102         }
103
104         rna_Mask_update_data(bmain, scene, ptr);
105 }
106
107 /* note: this function exists only to avoid id refcounting */
108 static void rna_MaskParent_id_set(PointerRNA *ptr, PointerRNA value)
109 {
110         MaskParent *mpar = (MaskParent*) ptr->data;
111
112         mpar->id = value.data;
113 }
114
115 static StructRNA *rna_MaskParent_id_typef(PointerRNA *ptr)
116 {
117         MaskParent *mpar = (MaskParent*) ptr->data;
118
119         return ID_code_to_RNA_type(mpar->id_type);
120 }
121
122 static void rna_MaskParent_id_type_set(PointerRNA *ptr, int value)
123 {
124         MaskParent *mpar = (MaskParent*) ptr->data;
125
126         /* change ID-type to the new type */
127         mpar->id_type = value;
128
129         /* clear the id-block if the type is invalid */
130         if ((mpar->id) && (GS(mpar->id->name) != mpar->id_type))
131                 mpar->id = NULL;
132 }
133
134 static void rna_Mask_layers_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
135 {
136         Mask *mask = (Mask *)ptr->id.data;
137
138         rna_iterator_listbase_begin(iter, &mask->masklayers, NULL);
139 }
140
141 static int rna_Mask_layer_active_index_get(PointerRNA *ptr)
142 {
143         Mask *mask = (Mask *)ptr->id.data;
144
145         return mask->masklay_act;
146 }
147
148 static void rna_Mask_layer_active_index_set(PointerRNA *ptr, int value)
149 {
150         Mask *mask = (Mask *)ptr->id.data;
151
152         mask->masklay_act = value;
153 }
154
155 static void rna_Mask_layer_active_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
156 {
157         Mask *mask = (Mask *)ptr->id.data;
158
159         *min = 0;
160         *max = mask->masklay_tot - 1;
161         *max = MAX2(0, *max);
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 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
253         values[0] = bezt->vec[0][0];
254         values[1] = bezt->vec[0][1];
255         values[2] = bezt->vec[0][2];
256 }
257
258 static void rna_MaskSplinePoint_handle1_set(PointerRNA *ptr, const float *values)
259 {
260         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
261         BezTriple *bezt = &point->bezt;
262
263         bezt->vec[0][0] = values[0];
264         bezt->vec[0][1] = values[1];
265         bezt->vec[0][2] = values[2];
266 }
267
268 static void rna_MaskSplinePoint_handle2_get(PointerRNA *ptr, float *values)
269 {
270         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
271         BezTriple *bezt = &point->bezt;
272
273         values[0] = bezt->vec[2][0];
274         values[1] = bezt->vec[2][1];
275         values[2] = bezt->vec[2][2];
276 }
277
278 static void rna_MaskSplinePoint_handle2_set(PointerRNA *ptr, const float *values)
279 {
280         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
281         BezTriple *bezt = &point->bezt;
282
283         bezt->vec[2][0] = values[0];
284         bezt->vec[2][1] = values[1];
285         bezt->vec[2][2] = values[2];
286 }
287
288 static void rna_MaskSplinePoint_ctrlpoint_get(PointerRNA *ptr, float *values)
289 {
290         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
291         BezTriple *bezt = &point->bezt;
292
293         values[0] = bezt->vec[1][0];
294         values[1] = bezt->vec[1][1];
295         values[2] = bezt->vec[1][2];
296 }
297
298 static void rna_MaskSplinePoint_ctrlpoint_set(PointerRNA *ptr, const float *values)
299 {
300         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
301         BezTriple *bezt = &point->bezt;
302
303         bezt->vec[1][0] = values[0];
304         bezt->vec[1][1] = values[1];
305         bezt->vec[1][2] = values[2];
306 }
307
308 static int rna_MaskSplinePoint_handle_type_get(PointerRNA *ptr)
309 {
310         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
311         BezTriple *bezt = &point->bezt;
312
313         return bezt->h1;
314 }
315
316 static void rna_MaskSplinePoint_handle_type_set(PointerRNA *ptr, int value)
317 {
318         MaskSplinePoint *point = (MaskSplinePoint*) ptr->data;
319         BezTriple *bezt = &point->bezt;
320
321         bezt->h1 = bezt->h2 = value;
322 }
323
324 /* ** API **  */
325
326 static MaskLayer *rna_Mask_layer_new(Mask *mask, const char *name)
327 {
328         MaskLayer *masklay = BKE_mask_layer_new(mask, name);
329
330         WM_main_add_notifier(NC_MASK|NA_EDITED, mask);
331
332         return masklay;
333 }
334
335 void rna_Mask_layer_remove(Mask *mask, MaskLayer *masklay)
336 {
337         BKE_mask_layer_remove(mask, masklay);
338
339         WM_main_add_notifier(NC_MASK|NA_EDITED, mask);
340 }
341
342 static void rna_MaskLayer_spline_add(ID *id, MaskLayer *masklay, int number)
343 {
344         Mask *mask = (Mask*) id;
345         int i;
346
347         for (i = 0; i < number; i++)
348                 BKE_mask_spline_add(masklay);
349
350         WM_main_add_notifier(NC_MASK|NA_EDITED, mask);
351 }
352
353 static void rna_Mask_start_frame_set(PointerRNA *ptr, int value)
354 {
355         Mask *data = (Mask *)ptr->data;
356         /* MINFRAME not MINAFRAME, since some output formats can't taken negative frames */
357         CLAMP(value, MINFRAME, MAXFRAME);
358         data->sfra = value;
359
360         if (data->sfra >= data->efra) {
361                 data->efra = MIN2(data->sfra, MAXFRAME);
362         }
363 }
364
365 static void rna_Mask_end_frame_set(PointerRNA *ptr, int value)
366 {
367         Mask *data = (Mask *)ptr->data;
368         CLAMP(value, MINFRAME, MAXFRAME);
369         data->efra = value;
370
371         if (data->sfra >= data->efra) {
372                 data->sfra = MAX2(data->efra, MINFRAME);
373         }
374 }
375
376 #else
377
378 static void rna_def_maskParent(BlenderRNA *brna)
379 {
380         StructRNA *srna;
381         PropertyRNA *prop;
382
383         static EnumPropertyItem mask_id_type_items[] = {
384                 {ID_MC, "MOVIECLIP", ICON_SEQUENCE, "Movie Clip", ""},
385                 {0, NULL, 0, NULL, NULL}};
386
387         srna = RNA_def_struct(brna, "MaskParent", NULL);
388         RNA_def_struct_ui_text(srna, "Mask Parent", "Parenting settings for masking element");
389
390         /* Target Properties - ID-block to Drive */
391         prop = RNA_def_property(srna, "id", PROP_POINTER, PROP_NONE);
392         RNA_def_property_struct_type(prop, "ID");
393         RNA_def_property_flag(prop, PROP_EDITABLE);
394         // RNA_def_property_editable_func(prop, "rna_maskSpline_id_editable");
395         /* note: custom set function is ONLY to avoid rna setting a user for this. */
396         RNA_def_property_pointer_funcs(prop, NULL, "rna_MaskParent_id_set", "rna_MaskParent_id_typef", NULL);
397         RNA_def_property_ui_text(prop, "ID", "ID-block to which masking element would be parented to or to it's property");
398         RNA_def_property_update(prop, 0, "rna_Mask_update_parent");
399
400         prop = RNA_def_property(srna, "id_type", PROP_ENUM, PROP_NONE);
401         RNA_def_property_enum_sdna(prop, NULL, "id_type");
402         RNA_def_property_enum_items(prop, mask_id_type_items);
403         RNA_def_property_enum_default(prop, ID_MC);
404         RNA_def_property_enum_funcs(prop, NULL, "rna_MaskParent_id_type_set", NULL);
405         //RNA_def_property_editable_func(prop, "rna_MaskParent_id_type_editable");
406         RNA_def_property_ui_text(prop, "ID Type", "Type of ID-block that can be used");
407         RNA_def_property_update(prop, 0, "rna_Mask_update_parent");
408
409         /* parent */
410         prop = RNA_def_property(srna, "parent", PROP_STRING, PROP_NONE);
411         RNA_def_property_ui_text(prop, "Parent", "Name of parent object in specified data block to which parenting happens");
412         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
413         RNA_def_property_update(prop, 0, "rna_Mask_update_parent");
414
415         /* sub_parent */
416         prop = RNA_def_property(srna, "sub_parent", PROP_STRING, PROP_NONE);
417         RNA_def_property_ui_text(prop, "Sub Parent", "Name of parent sub-object in specified data block to which parenting happens");
418         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
419         RNA_def_property_update(prop, 0, "rna_Mask_update_parent");
420 }
421
422 static void rna_def_maskSplinePointUW(BlenderRNA *brna)
423 {
424         StructRNA *srna;
425         PropertyRNA *prop;
426
427         srna = RNA_def_struct(brna, "MaskSplinePointUW", NULL);
428         RNA_def_struct_ui_text(srna, "Mask Spline UW Point", "Single point in spline segment defining feather");
429
430         /* u */
431         prop = RNA_def_property(srna, "u", PROP_FLOAT, PROP_NONE);
432         RNA_def_property_float_sdna(prop, NULL, "u");
433         RNA_def_property_range(prop, 0.0, 1.0);
434         RNA_def_property_ui_text(prop, "U", "U coordinate of point along spline segment");
435         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
436
437         /* weight */
438         prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
439         RNA_def_property_float_sdna(prop, NULL, "w");
440         RNA_def_property_range(prop, 0.0, 1.0);
441         RNA_def_property_ui_text(prop, "Weight", "Weight of feather point");
442         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
443
444         /* select */
445         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
446         RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
447         RNA_def_property_ui_text(prop, "Select", "Selection status");
448         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
449 }
450
451 static void rna_def_maskSplinePoint(BlenderRNA *brna)
452 {
453         StructRNA *srna;
454         PropertyRNA *prop;
455
456         static EnumPropertyItem handle_type_items[] = {
457                 {HD_AUTO, "AUTO", 0, "Auto", ""},
458                 {HD_VECT, "VECTOR", 0, "Vector", ""},
459                 {HD_ALIGN, "ALIGNED", 0, "Aligned", ""},
460                 {0, NULL, 0, NULL, NULL}};
461
462         rna_def_maskSplinePointUW(brna);
463
464         srna = RNA_def_struct(brna, "MaskSplinePoint", NULL);
465         RNA_def_struct_ui_text(srna, "Mask Spline Point", "Single point in spline used for defining mask");
466
467         /* Vector values */
468         prop = RNA_def_property(srna, "handle_left", PROP_FLOAT, PROP_TRANSLATION);
469         RNA_def_property_array(prop, 3);
470         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_handle1_get", "rna_MaskSplinePoint_handle1_set", NULL);
471         RNA_def_property_ui_text(prop, "Handle 1", "Coordinates of the first handle");
472         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
473
474         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
475         RNA_def_property_array(prop, 3);
476         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_ctrlpoint_get", "rna_MaskSplinePoint_ctrlpoint_set", NULL);
477         RNA_def_property_ui_text(prop, "Control Point", "Coordinates of the control point");
478         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
479
480         prop = RNA_def_property(srna, "handle_right", PROP_FLOAT, PROP_TRANSLATION);
481         RNA_def_property_array(prop, 3);
482         RNA_def_property_float_funcs(prop, "rna_MaskSplinePoint_handle2_get", "rna_MaskSplinePoint_handle2_set", NULL);
483         RNA_def_property_ui_text(prop, "Handle 2", "Coordinates of the second handle");
484         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
485
486         /* handle_type */
487         prop = RNA_def_property(srna, "handle_type", PROP_ENUM, PROP_NONE);
488         RNA_def_property_enum_funcs(prop, "rna_MaskSplinePoint_handle_type_get", "rna_MaskSplinePoint_handle_type_set", NULL);
489         RNA_def_property_enum_items(prop, handle_type_items);
490         RNA_def_property_ui_text(prop, "Handle Type", "Handle type");
491         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
492
493         /* select */
494         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
495         RNA_def_property_boolean_sdna(prop, NULL, "bezt.f1", SELECT);
496         RNA_def_property_ui_text(prop, "Select", "Selection status");
497         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
498
499         /* parent */
500         prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
501         RNA_def_property_struct_type(prop, "MaskParent");
502
503         /* feather points */
504         prop = RNA_def_property(srna, "feather_points", PROP_COLLECTION, PROP_NONE);
505         RNA_def_property_struct_type(prop, "MaskSplinePointUW");
506         RNA_def_property_collection_sdna(prop, NULL, "uw", "tot_uw");
507         RNA_def_property_ui_text(prop, "Feather Points", "Points defining feather");
508 }
509
510 static void rna_def_mask_splines(BlenderRNA *brna)
511 {
512         StructRNA *srna;
513         FunctionRNA *func;
514         PropertyRNA *prop;
515
516         srna = RNA_def_struct(brna, "MaskSplines", NULL);
517         RNA_def_struct_sdna(srna, "MaskLayer");
518         RNA_def_struct_ui_text(srna, "Mask Splines", "Collection of masking splines");
519
520         func = RNA_def_function(srna, "add", "rna_MaskLayer_spline_add");
521         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
522         RNA_def_function_ui_description(func, "Add a number of splines to mask layer");
523         RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of splines to add to the layer", 0, INT_MAX);
524
525         /* active spline */
526         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
527         RNA_def_property_struct_type(prop, "MaskSpline");
528         RNA_def_property_pointer_funcs(prop, "rna_MaskLayer_active_spline_get", "rna_MaskLayer_active_spline_set", NULL, NULL);
529         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
530         RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking layer");
531
532         /* active point */
533         prop = RNA_def_property(srna, "active_point", PROP_POINTER, PROP_NONE);
534         RNA_def_property_struct_type(prop, "MaskSplinePoint");
535         RNA_def_property_pointer_funcs(prop, "rna_MaskLayer_active_spline_point_get", "rna_MaskLayer_active_spline_point_set", NULL, NULL);
536         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
537         RNA_def_property_ui_text(prop, "Active Spline", "Active spline of masking layer");
538 }
539
540 static void rna_def_maskSpline(BlenderRNA *brna)
541 {
542         static EnumPropertyItem spline_interpolation_items[] = {
543                 {MASK_SPLINE_INTERP_LINEAR, "LINEAR", 0, "Linear", ""},
544                 {MASK_SPLINE_INTERP_EASE, "EASE", 0, "Ease", ""},
545                 {0, NULL, 0, NULL, NULL}
546         };
547
548         StructRNA *srna;
549         PropertyRNA *prop;
550
551         rna_def_maskSplinePoint(brna);
552
553         srna = RNA_def_struct(brna, "MaskSpline", NULL);
554         RNA_def_struct_ui_text(srna, "Mask spline", "Single spline used for defining mask shape");
555
556         /* weight interpolation */
557         prop = RNA_def_property(srna, "weight_interpolation", PROP_ENUM, PROP_NONE);
558         RNA_def_property_enum_sdna(prop, NULL, "weight_interp");
559         RNA_def_property_enum_items(prop, spline_interpolation_items);
560         RNA_def_property_ui_text(prop, "Weight Interpolation", "The type of weight interpolation for spline");
561         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
562
563         /* cyclic */
564         prop = RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
565         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
566         RNA_def_property_boolean_sdna(prop, NULL, "flag", MASK_SPLINE_CYCLIC);
567         RNA_def_property_ui_text(prop, "Cyclic", "Make this spline a closed loop");
568         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
569 }
570
571 static void rna_def_mask_layer(BlenderRNA *brna)
572 {
573         static EnumPropertyItem masklay_blend_mode_items[] = {
574                 {MASK_BLEND_ADD, "ADD", 0, "Add", ""},
575                 {MASK_BLEND_SUBTRACT, "SUBTRACT", 0, "Subtract", ""},
576                 {0, NULL, 0, NULL, NULL}
577         };
578
579         StructRNA *srna;
580         PropertyRNA *prop;
581
582         rna_def_maskSpline(brna);
583         rna_def_mask_splines(brna);
584
585         srna = RNA_def_struct(brna, "MaskLayer", NULL);
586         RNA_def_struct_ui_text(srna, "Mask Layer", "Single layer used for masking pixels");
587         RNA_def_struct_path_func(srna, "rna_MaskLayer_path");
588
589         /* name */
590         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
591         RNA_def_property_ui_text(prop, "Name", "Unique name of layer");
592         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MaskLayer_name_set");
593         RNA_def_property_string_maxlength(prop, MAX_ID_NAME - 2);
594         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
595         RNA_def_struct_name_property(srna, prop);
596
597         /* splines */
598         prop = RNA_def_property(srna, "splines", PROP_COLLECTION, PROP_NONE);
599         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);
600         RNA_def_property_struct_type(prop, "MaskSpline");
601         RNA_def_property_ui_text(prop, "Splines", "Collection of splines which defines this layer");
602         RNA_def_property_srna(prop, "MaskSplines");
603
604         /* restrict */
605         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
606         RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_VIEW);
607         RNA_def_property_ui_text(prop, "Restrict View", "Restrict visibility in the viewport");
608         RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_OFF, 1);
609         RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
610
611         prop = RNA_def_property(srna, "hide_select", PROP_BOOLEAN, PROP_NONE);
612         RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_SELECT);
613         RNA_def_property_ui_text(prop, "Restrict Select", "Restrict selection in the viewport");
614         RNA_def_property_ui_icon(prop, ICON_RESTRICT_SELECT_OFF, 1);
615         RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
616
617         prop = RNA_def_property(srna, "hide_render", PROP_BOOLEAN, PROP_NONE);
618         RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", MASK_RESTRICT_RENDER);
619         RNA_def_property_ui_text(prop, "Restrict Render", "Restrict renderability");
620         RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
621         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
622
623         /* select (for dopesheet)*/
624         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
625         RNA_def_property_boolean_sdna(prop, NULL, "flag", MASK_LAYERFLAG_SELECT);
626         RNA_def_property_ui_text(prop, "Select", "Layer is selected for editing in the DopeSheet");
627 //      RNA_def_property_update(prop, NC_SCREEN | ND_MASK, NULL);
628
629         /* render settings */
630         prop = RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_NONE);
631         RNA_def_property_float_sdna(prop, NULL, "alpha");
632         RNA_def_property_range(prop, 0.0, 1.0f);
633         RNA_def_property_ui_text(prop, "Opacity", "Render Opacity");
634         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
635
636         /* weight interpolation */
637         prop = RNA_def_property(srna, "blend", PROP_ENUM, PROP_NONE);
638         RNA_def_property_enum_sdna(prop, NULL, "blend");
639         RNA_def_property_enum_items(prop, masklay_blend_mode_items);
640         RNA_def_property_ui_text(prop, "Blend", "Method of blending mask layers");
641         RNA_def_property_update(prop, 0, "rna_Mask_update_data");
642         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
643
644         prop = RNA_def_property(srna, "invert", PROP_BOOLEAN, PROP_NONE);
645         RNA_def_property_boolean_sdna(prop, NULL, "blend_flag", MASK_BLENDFLAG_INVERT);
646         RNA_def_property_ui_text(prop, "Restrict View", "Invert the mask black/white");
647         RNA_def_property_update(prop, NC_MASK | NA_EDITED, NULL);
648
649 }
650
651 static void rna_def_masklayers(BlenderRNA *brna, PropertyRNA *cprop)
652 {
653         StructRNA *srna;
654         PropertyRNA *prop;
655
656         FunctionRNA *func;
657         PropertyRNA *parm;
658
659         RNA_def_property_srna(cprop, "MaskLayers");
660         srna = RNA_def_struct(brna, "MaskLayers", NULL);
661         RNA_def_struct_sdna(srna, "Mask");
662         RNA_def_struct_ui_text(srna, "Mask Layers", "Collection of layers used by mask");
663
664         func = RNA_def_function(srna, "new", "rna_Mask_layer_new");
665         RNA_def_function_ui_description(func, "Add layer to this mask");
666         RNA_def_string(func, "name", "", 0, "Name", "Name of new layer");
667         parm = RNA_def_pointer(func, "layer", "MaskLayer", "", "New mask layer");
668         RNA_def_function_return(func, parm);
669
670         func = RNA_def_function(srna, "remove", "rna_Mask_layer_remove");
671         RNA_def_function_ui_description(func, "Remove layer from this mask");
672         RNA_def_pointer(func, "layer", "MaskLayer", "", "Shape to be removed");
673
674         /* active layer */
675         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
676         RNA_def_property_struct_type(prop, "MaskLayer");
677         RNA_def_property_pointer_funcs(prop, "rna_Mask_layer_active_get", "rna_Mask_layer_active_set", NULL, NULL);
678         RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_UNLINK);
679         RNA_def_property_ui_text(prop, "Active Shape", "Active layer in this mask");
680 }
681
682 static void rna_def_mask(BlenderRNA *brna)
683 {
684         StructRNA *srna;
685         PropertyRNA *prop;
686
687         rna_def_mask_layer(brna);
688
689         srna = RNA_def_struct(brna, "Mask", "ID");
690         RNA_def_struct_ui_text(srna, "Mask", "Mask datablock defining mask for compositing");
691         RNA_def_struct_ui_icon(srna, ICON_MOD_MASK);
692
693         /* mask layers */
694         prop = RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);
695         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);
696         RNA_def_property_struct_type(prop, "MaskLayer");
697         RNA_def_property_ui_text(prop, "Layers", "Collection of layers which defines this mask");
698         rna_def_masklayers(brna, prop);
699
700         /* active masklay index */
701         prop = RNA_def_property(srna, "active_layer_index", PROP_INT, PROP_NONE);
702         RNA_def_property_int_sdna(prop, NULL, "masklay_act");
703         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
704         RNA_def_property_int_funcs(prop, "rna_Mask_layer_active_index_get", "rna_Mask_layer_active_index_set", "rna_Mask_layer_active_index_range");
705         RNA_def_property_ui_text(prop, "Active Shape Index", "Index of active layer in list of all mask's layers");
706         RNA_def_property_update(prop, NC_MASK | ND_DRAW, NULL);
707
708         /* frame range */
709         prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_TIME);
710         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
711         RNA_def_property_int_sdna(prop, NULL, "sfra");
712         RNA_def_property_int_funcs(prop, NULL, "rna_Mask_start_frame_set", NULL);
713         RNA_def_property_range(prop, MINFRAME, MAXFRAME);
714         RNA_def_property_ui_text(prop, "Start Frame", "First frame of the mask (used for sequencer)");
715         RNA_def_property_update(prop, NC_SCENE | ND_FRAME_RANGE, NULL);
716
717         prop = RNA_def_property(srna, "frame_end", PROP_INT, PROP_TIME);
718         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
719         RNA_def_property_int_sdna(prop, NULL, "efra");
720         RNA_def_property_int_funcs(prop, NULL, "rna_Mask_end_frame_set", NULL);
721         RNA_def_property_range(prop, MINFRAME, MAXFRAME);
722         RNA_def_property_ui_text(prop, "End Frame", "Final frame of the mask (used for sequencer)");
723         RNA_def_property_update(prop, NC_SCENE | ND_FRAME_RANGE, NULL);
724
725         /* pointers */
726         rna_def_animdata_common(srna);
727 }
728
729 void RNA_def_mask(BlenderRNA *brna)
730 {
731         rna_def_maskParent(brna);
732         rna_def_mask(brna);
733 }
734
735 #endif