GP: Cleanup API removing extra ID parameter
[blender.git] / source / blender / makesrna / intern / rna_gpencil.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 (2009), Joshua Leung, Antonio Vazquez
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_gpencil.c
24  *  \ingroup RNA
25  */
26
27 #include <stdlib.h>
28
29 #include "BLI_math.h"
30
31 #include "DNA_meshdata_types.h"
32 #include "DNA_gpencil_types.h"
33 #include "DNA_scene_types.h"
34 #include "DNA_brush_types.h"
35 #include "DNA_object_types.h"
36
37 #include "MEM_guardedalloc.h"
38
39 #include "BLI_string_utils.h"
40 #include "BLI_utildefines.h"
41
42 #include "BLT_translation.h"
43
44 #include "RNA_access.h"
45 #include "RNA_define.h"
46 #include "RNA_enum_types.h"
47
48 #include "rna_internal.h"
49
50 #include "WM_types.h"
51
52 /* parent type */
53 static const EnumPropertyItem parent_type_items[] = {
54         {PAROBJECT, "OBJECT", 0, "Object", "The layer is parented to an object"},
55         {PARSKEL, "ARMATURE", 0, "Armature", ""},
56         {PARBONE, "BONE", 0, "Bone", "The layer is parented to a bone"},
57         {0, NULL, 0, NULL, NULL}
58 };
59
60 #ifndef RNA_RUNTIME
61 static EnumPropertyItem rna_enum_gpencil_xraymodes_items[] = {
62         {GP_XRAY_FRONT, "FRONT", 0, "Front", "Draw all strokes in front"},
63         {GP_XRAY_3DSPACE, "3DSPACE", 0, "3D Space", "Draw strokes relative to other objects in 3D space"},
64         {GP_XRAY_BACK, "BACK", 0, "Back", "Draw all strokes last"},
65         {0, NULL, 0, NULL, NULL}
66 };
67
68 static EnumPropertyItem rna_enum_gpencil_onion_modes_items[] = {
69         {GP_ONION_MODE_ABSOLUTE, "ABSOLUTE", 0, "Frames", "Frames in absolute range of the scene frame"},
70         {GP_ONION_MODE_RELATIVE, "RELATIVE", 0, "Keyframes", "Frames in relative range of the Grease Pencil keyframes"},
71         {GP_ONION_MODE_SELECTED, "SELECTED", 0, "Selected", "Only selected keyframes"},
72         {0, NULL, 0, NULL, NULL}
73 };
74
75 const EnumPropertyItem rna_enum_gplayer_move_type_items[] = {
76    {-1, "UP", 0, "Up", ""},
77    {1, "DOWN", 0, "Down", ""},
78    {0, NULL, 0, NULL, NULL}
79 };
80
81 static const EnumPropertyItem rna_enum_layer_blend_modes_items[] = {
82         {eGplBlendMode_Normal, "NORMAL", 0, "Normal", "" },
83         {eGplBlendMode_Overlay, "OVERLAY", 0, "Overlay", "" },
84         {eGplBlendMode_Add, "ADD", 0, "Add", "" },
85         {eGplBlendMode_Subtract, "SUBTRACT", 0, "Subtract", "" },
86         {eGplBlendMode_Multiply, "MULTIPLY", 0, "Multiply", "" },
87         {eGplBlendMode_Divide, "DIVIDE", 0, "Divide", "" },
88         {0, NULL, 0, NULL, NULL }
89 };
90 #endif
91
92 #ifdef RNA_RUNTIME
93
94 #include "BLI_ghash.h"
95
96 #include "WM_api.h"
97
98 #include "BKE_action.h"
99 #include "BKE_animsys.h"
100 #include "BKE_gpencil.h"
101 #include "BKE_icons.h"
102
103 #include "DEG_depsgraph.h"
104
105
106 static void rna_GPencil_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
107 {
108         DEG_id_tag_update(ptr->id.data, ID_RECALC_GEOMETRY);
109         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
110 }
111
112 static void rna_GPencil_autolock(Main *bmain, Scene *scene, PointerRNA *ptr)
113 {
114         bGPdata *gpd = (bGPdata *)ptr->id.data;
115         bGPDlayer *gpl = NULL;
116
117         if (gpd->flag & GP_DATA_AUTOLOCK_LAYERS) {
118                 bGPDlayer *layer = BKE_gpencil_layer_getactive(gpd);
119
120                 /* Lock all other layers */
121                 for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
122                         /* unlock active layer */
123                         if (gpl == layer) {
124                                 gpl->flag &= ~GP_LAYER_LOCKED;
125                         }
126                         else {
127                                 gpl->flag |= GP_LAYER_LOCKED;
128                         }
129                 }
130         }
131         else {
132                 /* If disable is better unlock all layers by default or it looks there is
133                  * a problem in the UI because the user expects all layers will be unlocked
134                  */
135                 for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
136                         gpl->flag &= ~GP_LAYER_LOCKED;
137                 }
138         }
139
140         /* standard update */
141         rna_GPencil_update(bmain, scene, ptr);
142 }
143
144 static void rna_GPencil_editmode_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
145 {
146         bGPdata *gpd = (bGPdata *)ptr->id.data;
147         DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
148
149         /* Notify all places where GPencil data lives that the editing state is different */
150         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
151         WM_main_add_notifier(NC_SCENE | ND_MODE | NC_MOVIECLIP, NULL);
152 }
153
154 static void UNUSED_FUNCTION(rna_GPencil_onion_skinning_update)(Main *bmain, Scene *scene, PointerRNA *ptr)
155 {
156         bGPdata *gpd = (bGPdata *)ptr->id.data;
157         bGPDlayer *gpl;
158         bool enabled = false;
159
160         /* Ensure that the datablock's onionskinning toggle flag
161          * stays in sync with the status of the actual layers
162          */
163         for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
164                 if (gpl->onion_flag & GP_LAYER_ONIONSKIN) {
165                         enabled = true;
166                 }
167         }
168
169         if (enabled)
170                 gpd->flag |= GP_DATA_SHOW_ONIONSKINS;
171         else
172                 gpd->flag &= ~GP_DATA_SHOW_ONIONSKINS;
173
174
175         /* Now do standard updates... */
176         rna_GPencil_update(bmain, scene, ptr);
177 }
178
179
180 /* Poll Callback to filter GP Datablocks to only show those for Annotations */
181 bool rna_GPencil_datablocks_annotations_poll(PointerRNA *UNUSED(ptr), const PointerRNA value)
182 {
183         bGPdata *gpd = value.data;
184         return (gpd->flag & GP_DATA_ANNOTATIONS) != 0;
185 }
186
187 /* Poll Callback to filter GP Datablocks to only show those for GP Objects */
188 bool rna_GPencil_datablocks_obdata_poll(PointerRNA *UNUSED(ptr), const PointerRNA value)
189 {
190         bGPdata *gpd = value.data;
191         return (gpd->flag & GP_DATA_ANNOTATIONS) == 0;
192 }
193
194
195 static char *rna_GPencilLayer_path(PointerRNA *ptr)
196 {
197         bGPDlayer *gpl = (bGPDlayer *)ptr->data;
198         char name_esc[sizeof(gpl->info) * 2];
199
200         BLI_strescape(name_esc, gpl->info, sizeof(name_esc));
201
202         return BLI_sprintfN("layers[\"%s\"]", name_esc);
203 }
204
205 static int rna_GPencilLayer_active_frame_editable(PointerRNA *ptr, const char **UNUSED(r_info))
206 {
207         bGPDlayer *gpl = (bGPDlayer *)ptr->data;
208
209         /* surely there must be other criteria too... */
210         if (gpl->flag & GP_LAYER_LOCKED)
211                 return 0;
212         else
213                 return PROP_EDITABLE;
214 }
215
216 /* set parent */
217 static void set_parent(bGPDlayer *gpl, Object *par, const int type, const char *substr)
218 {
219         if (type == PAROBJECT) {
220                 invert_m4_m4(gpl->inverse, par->obmat);
221                 gpl->parent = par;
222                 gpl->partype |= PAROBJECT;
223                 gpl->parsubstr[0] = 0;
224         }
225         else if (type == PARSKEL) {
226                 invert_m4_m4(gpl->inverse, par->obmat);
227                 gpl->parent = par;
228                 gpl->partype |= PARSKEL;
229                 gpl->parsubstr[0] = 0;
230         }
231         else if (type == PARBONE) {
232                 bPoseChannel *pchan = BKE_pose_channel_find_name(par->pose, substr);
233                 if (pchan) {
234                         float tmp_mat[4][4];
235                         mul_m4_m4m4(tmp_mat, par->obmat, pchan->pose_mat);
236
237                         invert_m4_m4(gpl->inverse, tmp_mat);
238                         gpl->parent = par;
239                         gpl->partype |= PARBONE;
240                         BLI_strncpy(gpl->parsubstr, substr, sizeof(gpl->parsubstr));
241                 }
242         }
243 }
244
245 /* set parent object and inverse matrix */
246 static void rna_GPencilLayer_parent_set(PointerRNA *ptr, PointerRNA value)
247 {
248         bGPDlayer *gpl = (bGPDlayer *)ptr->data;
249         Object *par = (Object *)value.data;
250
251         if (par != NULL) {
252                 set_parent(gpl, par, gpl->partype, gpl->parsubstr);
253         }
254         else {
255                 /* clear parent */
256                 gpl->parent = NULL;
257         }
258 }
259
260 /* set parent type */
261 static void rna_GPencilLayer_parent_type_set(PointerRNA *ptr, int value)
262 {
263         bGPDlayer *gpl = (bGPDlayer *)ptr->data;
264         Object *par = gpl->parent;
265         gpl->partype = value;
266
267         if (par != NULL) {
268                 set_parent(gpl, par, value, gpl->parsubstr);
269         }
270 }
271
272 /* set parent bone */
273 static void rna_GPencilLayer_parent_bone_set(PointerRNA *ptr, const char *value)
274 {
275         bGPDlayer *gpl = (bGPDlayer *)ptr->data;
276
277         Object *par = gpl->parent;
278         gpl->partype = PARBONE;
279
280         if (par != NULL) {
281                 set_parent(gpl, par, gpl->partype, value);
282         }
283 }
284
285
286 /* parent types enum */
287 static const EnumPropertyItem *rna_Object_parent_type_itemf(
288         bContext *UNUSED(C), PointerRNA *ptr,
289         PropertyRNA *UNUSED(prop), bool *r_free)
290 {
291         bGPDlayer *gpl = (bGPDlayer *)ptr->data;
292         EnumPropertyItem *item = NULL;
293         int totitem = 0;
294
295         RNA_enum_items_add_value(&item, &totitem, parent_type_items, PAROBJECT);
296
297         if (gpl->parent) {
298                 Object *par = gpl->parent;
299
300                 if (par->type == OB_ARMATURE) {
301                         /* special hack: prevents this being overridden */
302                         RNA_enum_items_add_value(&item, &totitem, &parent_type_items[1], PARSKEL);
303                         RNA_enum_items_add_value(&item, &totitem, parent_type_items, PARBONE);
304                 }
305         }
306
307         RNA_enum_item_end(&item, &totitem);
308         *r_free = true;
309
310         return item;
311 }
312
313 static bool rna_GPencilLayer_is_parented_get(PointerRNA *ptr)
314 {
315         bGPDlayer *gpl = (bGPDlayer *)ptr->data;
316         return (gpl->parent != NULL);
317 }
318
319 static PointerRNA rna_GPencil_active_layer_get(PointerRNA *ptr)
320 {
321         bGPdata *gpd = ptr->id.data;
322
323         if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */
324                 bGPDlayer *gl;
325
326                 for (gl = gpd->layers.first; gl; gl = gl->next) {
327                         if (gl->flag & GP_LAYER_ACTIVE) {
328                                 break;
329                         }
330                 }
331
332                 if (gl) {
333                         return rna_pointer_inherit_refine(ptr, &RNA_GPencilLayer, gl);
334                 }
335         }
336
337         return rna_pointer_inherit_refine(ptr, NULL, NULL);
338 }
339
340 static void rna_GPencil_active_layer_set(PointerRNA *ptr, PointerRNA value)
341 {
342         bGPdata *gpd = ptr->id.data;
343
344         /* Don't allow setting active layer to NULL if layers exist
345          * as this breaks various tools. Tools should be used instead
346          * if it's necessary to remove layers
347          */
348         if (value.data == NULL) {
349                 printf("%s: Setting active layer to None is not allowed\n", __func__);
350                 return;
351         }
352
353         if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */
354                 bGPDlayer *gl;
355
356                 for (gl = gpd->layers.first; gl; gl = gl->next) {
357                         if (gl == value.data) {
358                                 gl->flag |= GP_LAYER_ACTIVE;
359                         }
360                         else {
361                                 gl->flag &= ~GP_LAYER_ACTIVE;
362                         }
363                 }
364
365                 WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
366         }
367 }
368
369 static int rna_GPencil_active_layer_index_get(PointerRNA *ptr)
370 {
371         bGPdata *gpd = (bGPdata *)ptr->id.data;
372         bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
373
374         return BLI_findindex(&gpd->layers, gpl);
375 }
376
377 static void rna_GPencil_active_layer_index_set(PointerRNA *ptr, int value)
378 {
379         bGPdata *gpd   = (bGPdata *)ptr->id.data;
380         bGPDlayer *gpl = BLI_findlink(&gpd->layers, value);
381
382         BKE_gpencil_layer_setactive(gpd, gpl);
383
384         /* Now do standard updates... */
385         DEG_id_tag_update(&gpd->id, ID_RECALC_GEOMETRY);
386         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED | ND_SPACE_PROPERTIES, NULL);
387 }
388
389 static void rna_GPencil_active_layer_index_range(PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax)
390 {
391         bGPdata *gpd = (bGPdata *)ptr->id.data;
392
393         *min = 0;
394         *max = max_ii(0, BLI_listbase_count(&gpd->layers) - 1);
395
396         *softmin = *min;
397         *softmax = *max;
398 }
399
400 static const EnumPropertyItem *rna_GPencil_active_layer_itemf(
401         bContext *C, PointerRNA *ptr, PropertyRNA *UNUSED(prop), bool *r_free)
402 {
403         bGPdata *gpd = (bGPdata *)ptr->id.data;
404         bGPDlayer *gpl;
405         EnumPropertyItem *item = NULL, item_tmp = {0};
406         int totitem = 0;
407         int i = 0;
408
409         if (ELEM(NULL, C, gpd)) {
410                 return DummyRNA_NULL_items;
411         }
412
413         /* Existing layers */
414         for (gpl = gpd->layers.first, i = 0; gpl; gpl = gpl->next, i++) {
415                 item_tmp.identifier = gpl->info;
416                 item_tmp.name = gpl->info;
417                 item_tmp.value = i;
418
419                 item_tmp.icon = BKE_icon_gplayer_color_ensure(gpl);
420
421                 RNA_enum_item_add(&item, &totitem, &item_tmp);
422         }
423
424         RNA_enum_item_end(&item, &totitem);
425         *r_free = true;
426
427         return item;
428 }
429
430 static void rna_GPencilLayer_info_set(PointerRNA *ptr, const char *value)
431 {
432         bGPdata *gpd = ptr->id.data;
433         bGPDlayer *gpl = ptr->data;
434
435         char oldname[128] = "";
436         BLI_strncpy(oldname, gpl->info, sizeof(oldname));
437
438         /* copy the new name into the name slot */
439         BLI_strncpy_utf8(gpl->info, value, sizeof(gpl->info));
440
441         BLI_uniquename(&gpd->layers, gpl, DATA_("GP_Layer"), '.', offsetof(bGPDlayer, info), sizeof(gpl->info));
442
443         /* now fix animation paths */
444         BKE_animdata_fix_paths_rename_all(&gpd->id, "layers", oldname, gpl->info);
445 }
446
447 static bGPDstroke *rna_GPencil_stroke_point_find_stroke(const bGPdata *gpd, const bGPDspoint *pt, bGPDlayer **r_gpl, bGPDframe **r_gpf)
448 {
449         bGPDlayer *gpl;
450         bGPDstroke *gps;
451
452         /* sanity checks */
453         if (ELEM(NULL, gpd, pt)) {
454                 return NULL;
455         }
456
457         if (r_gpl) *r_gpl = NULL;
458         if (r_gpf) *r_gpf = NULL;
459
460         /* there's no faster alternative than just looping over everything... */
461         for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
462                 if (gpl->actframe) {
463                         for (gps = gpl->actframe->strokes.first; gps; gps = gps->next) {
464                                 if ((pt >= gps->points) && (pt < &gps->points[gps->totpoints])) {
465                                         /* found it */
466                                         if (r_gpl) *r_gpl = gpl;
467                                         if (r_gpf) *r_gpf = gpl->actframe;
468
469                                         return gps;
470                                 }
471                         }
472                 }
473         }
474
475         /* didn't find it */
476         return NULL;
477 }
478
479 static void rna_GPencil_stroke_point_select_set(PointerRNA *ptr, const bool value)
480 {
481         bGPdata *gpd = ptr->id.data;
482         bGPDspoint *pt = ptr->data;
483         bGPDstroke *gps = NULL;
484
485         /* Ensure that corresponding stroke is set
486          * - Since we don't have direct access, we're going to have to search
487          * - We don't apply selection value unless we can find the corresponding
488          *   stroke, so that they don't get out of sync
489          */
490         gps = rna_GPencil_stroke_point_find_stroke(gpd, pt, NULL, NULL);
491         if (gps) {
492                 /* Set the new selection state for the point */
493                 if (value)
494                         pt->flag |= GP_SPOINT_SELECT;
495                 else
496                         pt->flag &= ~GP_SPOINT_SELECT;
497
498                 /* Check if the stroke should be selected or not... */
499                 BKE_gpencil_stroke_sync_selection(gps);
500         }
501 }
502
503 static void rna_GPencil_stroke_point_add(ID *id, bGPDstroke *stroke, int count, float pressure, float strength)
504 {
505         bGPdata *gpd = (bGPdata *)id;
506
507         if (count > 0) {
508                 /* create space at the end of the array for extra points */
509                 stroke->points = MEM_recallocN_id(stroke->points,
510                                                   sizeof(bGPDspoint) * (stroke->totpoints + count),
511                                                   "gp_stroke_points");
512                 stroke->dvert = MEM_recallocN_id(stroke->dvert,
513                                                   sizeof(MDeformVert) * (stroke->totpoints + count),
514                                                   "gp_stroke_weight");
515
516                 /* init the pressure and strength values so that old scripts won't need to
517                  * be modified to give these initial values...
518                  */
519                 for (int i = 0; i < count; i++) {
520                         bGPDspoint *pt = stroke->points + (stroke->totpoints + i);
521                         MDeformVert *dvert = stroke->dvert + (stroke->totpoints + i);
522                         pt->pressure = pressure;
523                         pt->strength = strength;
524
525                         dvert->totweight = 0;
526                         dvert->dw = NULL;
527                 }
528
529                 stroke->totpoints += count;
530
531                 stroke->flag |= GP_STROKE_RECALC_CACHES;
532
533                 gpd->flag |= GP_DATA_PYTHON_UPDATED;
534                 DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_COPY_ON_WRITE);
535
536                 WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
537         }
538 }
539
540 static void rna_GPencil_stroke_point_pop(ID *id, bGPDstroke *stroke, ReportList *reports, int index)
541 {
542         bGPdata *gpd = (bGPdata *)id;
543         bGPDspoint *pt_tmp = stroke->points;
544         MDeformVert *pt_dvert = stroke->dvert;
545
546         /* python style negative indexing */
547         if (index < 0) {
548                 index += stroke->totpoints;
549         }
550
551         if (stroke->totpoints <= index || index < 0) {
552                 BKE_report(reports, RPT_ERROR, "GPencilStrokePoints.pop: index out of range");
553                 return;
554         }
555
556         stroke->totpoints--;
557
558         stroke->points = MEM_callocN(sizeof(bGPDspoint) * stroke->totpoints, "gp_stroke_points");
559         if (pt_dvert != NULL) {
560                 stroke->dvert = MEM_callocN(sizeof(MDeformVert) * stroke->totpoints, "gp_stroke_weights");
561         }
562
563         if (index > 0) {
564                 memcpy(stroke->points, pt_tmp, sizeof(bGPDspoint) * index);
565                 /* verify weight data is available */
566                 if (pt_dvert != NULL) {
567                         memcpy(stroke->dvert, pt_dvert, sizeof(MDeformVert) * index);
568                 }
569         }
570
571         if (index < stroke->totpoints) {
572                 memcpy(&stroke->points[index], &pt_tmp[index + 1], sizeof(bGPDspoint) * (stroke->totpoints - index));
573                 if (pt_dvert != NULL) {
574                         memcpy(&stroke->dvert[index], &pt_dvert[index + 1], sizeof(MDeformVert) * (stroke->totpoints - index));
575                 }
576         }
577
578         /* free temp buffer */
579         MEM_freeN(pt_tmp);
580         if (pt_dvert != NULL) {
581                 MEM_freeN(pt_dvert);
582         }
583
584         stroke->flag |= GP_STROKE_RECALC_CACHES;
585
586         gpd->flag |= GP_DATA_PYTHON_UPDATED;
587         DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_COPY_ON_WRITE);
588
589         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
590 }
591
592 static bGPDstroke *rna_GPencil_stroke_new(bGPDframe *frame)
593 {
594         bGPDstroke *stroke = MEM_callocN(sizeof(bGPDstroke), "gp_stroke");
595         BLI_addtail(&frame->strokes, stroke);
596
597         return stroke;
598 }
599
600 static void rna_GPencil_stroke_remove(bGPDframe *frame, ReportList *reports, PointerRNA *stroke_ptr)
601 {
602         bGPDstroke *stroke = stroke_ptr->data;
603         if (BLI_findindex(&frame->strokes, stroke) == -1) {
604                 BKE_report(reports, RPT_ERROR, "Stroke not found in grease pencil frame");
605                 return;
606         }
607
608         BLI_freelinkN(&frame->strokes, stroke);
609         RNA_POINTER_INVALIDATE(stroke_ptr);
610
611         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
612 }
613
614 static void rna_GPencil_stroke_select_set(PointerRNA *ptr, const bool value)
615 {
616         bGPDstroke *gps = ptr->data;
617         bGPDspoint *pt;
618         int i;
619
620         /* set new value */
621         if (value)
622                 gps->flag |= GP_STROKE_SELECT;
623         else
624                 gps->flag &= ~GP_STROKE_SELECT;
625
626         /* ensure that the stroke's points are selected in the same way */
627         for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
628                 if (value)
629                         pt->flag |= GP_SPOINT_SELECT;
630                 else
631                         pt->flag &= ~GP_SPOINT_SELECT;
632         }
633 }
634
635 static bGPDframe *rna_GPencil_frame_new(bGPDlayer *layer, ReportList *reports, int frame_number)
636 {
637         bGPDframe *frame;
638
639         if (BKE_gpencil_layer_find_frame(layer, frame_number)) {
640                 BKE_reportf(reports, RPT_ERROR, "Frame already exists on this frame number %d", frame_number);
641                 return NULL;
642         }
643
644         frame = BKE_gpencil_frame_addnew(layer, frame_number);
645
646         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
647
648         return frame;
649 }
650
651 static void rna_GPencil_frame_remove(bGPDlayer *layer, ReportList *reports, PointerRNA *frame_ptr)
652 {
653         bGPDframe *frame = frame_ptr->data;
654         if (BLI_findindex(&layer->frames, frame) == -1) {
655                 BKE_report(reports, RPT_ERROR, "Frame not found in grease pencil layer");
656                 return;
657         }
658
659         BKE_gpencil_layer_delframe(layer, frame);
660         RNA_POINTER_INVALIDATE(frame_ptr);
661
662         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
663 }
664
665 static bGPDframe *rna_GPencil_frame_copy(bGPDlayer *layer, bGPDframe *src)
666 {
667         bGPDframe *frame = BKE_gpencil_frame_duplicate(src);
668
669         while (BKE_gpencil_layer_find_frame(layer, frame->framenum)) {
670                 frame->framenum++;
671         }
672
673         BLI_addtail(&layer->frames, frame);
674
675         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
676
677         return frame;
678 }
679
680 static bGPDlayer *rna_GPencil_layer_new(bGPdata *gpd, const char *name, bool setactive)
681 {
682         bGPDlayer *gpl = BKE_gpencil_layer_addnew(gpd, name, setactive != 0);
683
684         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
685
686         return gpl;
687 }
688
689 static void rna_GPencil_layer_remove(bGPdata *gpd, ReportList *reports, PointerRNA *layer_ptr)
690 {
691         bGPDlayer *layer = layer_ptr->data;
692         if (BLI_findindex(&gpd->layers, layer) == -1) {
693                 BKE_report(reports, RPT_ERROR, "Layer not found in grease pencil data");
694                 return;
695         }
696
697         BKE_gpencil_layer_delete(gpd, layer);
698         RNA_POINTER_INVALIDATE(layer_ptr);
699
700         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
701 }
702
703 static void rna_GPencil_layer_move(bGPdata *gpd, ReportList *reports, PointerRNA *layer_ptr, int type)
704 {
705         bGPDlayer *gpl = layer_ptr->data;
706         if (BLI_findindex(&gpd->layers, gpl) == -1) {
707                 BKE_report(reports, RPT_ERROR, "Layer not found in grease pencil data");
708                 return;
709         }
710
711         BLI_assert(ELEM(type, -1, 0, 1)); /* we use value below */
712
713         const int direction = type * -1;
714
715         if (BLI_listbase_link_move(&gpd->layers, gpl, direction)) {
716                 DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
717         }
718
719         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
720 }
721
722 static void rna_GPencil_frame_clear(bGPDframe *frame)
723 {
724         BKE_gpencil_free_strokes(frame);
725
726         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
727 }
728
729 static void rna_GPencil_layer_clear(bGPDlayer *layer)
730 {
731         BKE_gpencil_free_frames(layer);
732
733         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
734 }
735
736 static void rna_GPencil_clear(bGPdata *gpd)
737 {
738         BKE_gpencil_free_layers(&gpd->layers);
739
740         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
741 }
742
743 static void rna_GpencilVertex_groups_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
744 {
745         bGPDstroke *gps = ptr->data;
746
747         if (gps->dvert) {
748                 MDeformVert *dvert = gps->dvert;
749
750                 rna_iterator_array_begin(iter, (void *)dvert->dw, sizeof(MDeformWeight), dvert->totweight, 0, NULL);
751         }
752         else
753                 rna_iterator_array_begin(iter, NULL, 0, 0, 0, NULL);
754 }
755
756 static char *rna_GreasePencilGrid_path(PointerRNA *UNUSED(ptr))
757 {
758         return BLI_sprintfN("grid");
759 }
760
761 #else
762
763 static void rna_def_gpencil_stroke_point(BlenderRNA *brna)
764 {
765         StructRNA *srna;
766         PropertyRNA *prop;
767
768         srna = RNA_def_struct(brna, "GPencilStrokePoint", NULL);
769         RNA_def_struct_sdna(srna, "bGPDspoint");
770         RNA_def_struct_ui_text(srna, "Grease Pencil Stroke Point", "Data point for freehand stroke curve");
771
772         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_XYZ);
773         RNA_def_property_float_sdna(prop, NULL, "x");
774         RNA_def_property_array(prop, 3);
775         RNA_def_property_ui_text(prop, "Coordinates", "");
776         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
777
778         prop = RNA_def_property(srna, "pressure", PROP_FLOAT, PROP_NONE);
779         RNA_def_property_float_sdna(prop, NULL, "pressure");
780         RNA_def_property_range(prop, 0.0f, 1.0f);
781         RNA_def_property_ui_text(prop, "Pressure", "Pressure of tablet at point when drawing it");
782         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
783
784         prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
785         RNA_def_property_float_sdna(prop, NULL, "strength");
786         RNA_def_property_range(prop, 0.0f, 1.0f);
787         RNA_def_property_ui_text(prop, "Strength", "Color intensity (alpha factor)");
788         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
789
790         prop = RNA_def_property(srna, "uv_factor", PROP_FLOAT, PROP_NONE);
791         RNA_def_property_float_sdna(prop, NULL, "uv_fac");
792         RNA_def_property_range(prop, 0.0f, 1.0f);
793         RNA_def_property_ui_text(prop, "UV Factor", "Internal UV factor");
794         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
795
796         prop = RNA_def_property(srna, "uv_rotation", PROP_FLOAT, PROP_ANGLE);
797         RNA_def_property_float_sdna(prop, NULL, "uv_rot");
798         RNA_def_property_range(prop, 0.0f, M_PI * 2);
799         RNA_def_property_ui_text(prop, "UV Rotation", "Internal UV factor for dot mode");
800         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
801
802         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
803         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SPOINT_SELECT);
804         RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencil_stroke_point_select_set");
805         RNA_def_property_ui_text(prop, "Select", "Point is selected for viewport editing");
806         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
807
808 }
809
810 static void rna_def_gpencil_stroke_points_api(BlenderRNA *brna, PropertyRNA *cprop)
811 {
812         StructRNA *srna;
813         FunctionRNA *func;
814         PropertyRNA *parm;
815
816         RNA_def_property_srna(cprop, "GPencilStrokePoints");
817         srna = RNA_def_struct(brna, "GPencilStrokePoints", NULL);
818         RNA_def_struct_sdna(srna, "bGPDstroke");
819         RNA_def_struct_ui_text(srna, "Grease Pencil Stroke Points", "Collection of grease pencil stroke points");
820
821         func = RNA_def_function(srna, "add", "rna_GPencil_stroke_point_add");
822         RNA_def_function_ui_description(func, "Add a new grease pencil stroke point");
823         RNA_def_function_flag(func, FUNC_USE_SELF_ID);
824         parm = RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of points to add to the stroke", 0, INT_MAX);
825         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
826         RNA_def_float(func, "pressure", 1.0f, 0.0f, 1.0f, "Pressure", "Pressure for newly created points", 0.0f, 1.0f);
827         RNA_def_float(func, "strength", 1.0f, 0.0f, 1.0f, "Strength", "Color intensity (alpha factor) for newly created points", 0.0f, 1.0f);
828
829         func = RNA_def_function(srna, "pop", "rna_GPencil_stroke_point_pop");
830         RNA_def_function_ui_description(func, "Remove a grease pencil stroke point");
831         RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
832         RNA_def_int(func, "index", -1, INT_MIN, INT_MAX, "Index", "point index", INT_MIN, INT_MAX);
833 }
834
835 /* This information is read only and it can be used by add-ons */
836 static void rna_def_gpencil_triangle(BlenderRNA *brna)
837 {
838         StructRNA *srna;
839         PropertyRNA *prop;
840
841         srna = RNA_def_struct(brna, "GPencilTriangle", NULL);
842         RNA_def_struct_sdna(srna, "bGPDtriangle");
843         RNA_def_struct_ui_text(srna, "Triangle", "Triangulation data for Grease Pencil fills");
844
845         /* point v1 */
846         prop = RNA_def_property(srna, "v1", PROP_INT, PROP_NONE);
847         RNA_def_property_int_sdna(prop, NULL, "verts[0]");
848         RNA_def_property_ui_text(prop, "v1", "First triangle vertex index");
849         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
850
851         /* point v2 */
852         prop = RNA_def_property(srna, "v2", PROP_INT, PROP_NONE);
853         RNA_def_property_int_sdna(prop, NULL, "verts[1]");
854         RNA_def_property_ui_text(prop, "v2", "Second triangle vertex index");
855         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
856
857         /* point v3 */
858         prop = RNA_def_property(srna, "v3", PROP_INT, PROP_NONE);
859         RNA_def_property_int_sdna(prop, NULL, "verts[2]");
860         RNA_def_property_ui_text(prop, "v3", "Third triangle vertex index");
861         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
862
863         /* texture coord for point v1 */
864         prop = RNA_def_property(srna, "uv1", PROP_FLOAT, PROP_COORDS);
865         RNA_def_property_float_sdna(prop, NULL, "uv[0]");
866         RNA_def_property_array(prop, 2);
867         RNA_def_property_ui_text(prop, "uv1", "First triangle vertex texture coordinates");
868         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
869
870         /* texture coord for point v2 */
871         prop = RNA_def_property(srna, "uv2", PROP_FLOAT, PROP_COORDS);
872         RNA_def_property_float_sdna(prop, NULL, "uv[1]");
873         RNA_def_property_array(prop, 2);
874         RNA_def_property_ui_text(prop, "uv2", "Second triangle vertex texture coordinates");
875         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
876
877         /* texture coord for point v3 */
878         prop = RNA_def_property(srna, "uv3", PROP_FLOAT, PROP_COORDS);
879         RNA_def_property_float_sdna(prop, NULL, "uv[2]");
880         RNA_def_property_array(prop, 2);
881         RNA_def_property_ui_text(prop, "uv3", "Third triangle vertex texture coordinates");
882         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
883 }
884
885 static void rna_def_gpencil_mvert_group(BlenderRNA *brna)
886 {
887         StructRNA *srna;
888         PropertyRNA *prop;
889
890         srna = RNA_def_struct(brna, "GpencilVertexGroupElement", NULL);
891         RNA_def_struct_sdna(srna, "MDeformWeight");
892         RNA_def_struct_ui_text(srna, "Vertex Group Element", "Weight value of a vertex in a vertex group");
893         RNA_def_struct_ui_icon(srna, ICON_GROUP_VERTEX);
894
895         /* we can't point to actual group, it is in the object and so
896          * there is no unique group to point to, hence the index */
897         prop = RNA_def_property(srna, "group", PROP_INT, PROP_UNSIGNED);
898         RNA_def_property_int_sdna(prop, NULL, "def_nr");
899         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
900         RNA_def_property_ui_text(prop, "Group Index", "");
901         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
902
903         prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
904         RNA_def_property_range(prop, 0.0f, 1.0f);
905         RNA_def_property_ui_text(prop, "Weight", "Vertex Weight");
906         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
907 }
908
909 static void rna_def_gpencil_stroke(BlenderRNA *brna)
910 {
911         StructRNA *srna;
912         PropertyRNA *prop;
913
914         static const EnumPropertyItem stroke_display_mode_items[] = {
915                 {0, "SCREEN", 0, "Screen", "Stroke is in screen-space"},
916                 {GP_STROKE_3DSPACE, "3DSPACE", 0, "3D Space", "Stroke is in 3D-space"},
917                 {GP_STROKE_2DSPACE, "2DSPACE", 0, "2D Space", "Stroke is in 2D-space"},
918                 {GP_STROKE_2DIMAGE, "2DIMAGE", 0, "2D Image", "Stroke is in 2D-space (but with special 'image' scaling)"},
919                 {0, NULL, 0, NULL, NULL}
920         };
921
922         srna = RNA_def_struct(brna, "GPencilStroke", NULL);
923         RNA_def_struct_sdna(srna, "bGPDstroke");
924         RNA_def_struct_ui_text(srna, "Grease Pencil Stroke", "Freehand curve defining part of a sketch");
925
926         /* Points */
927         prop = RNA_def_property(srna, "points", PROP_COLLECTION, PROP_NONE);
928         RNA_def_property_collection_sdna(prop, NULL, "points", "totpoints");
929         RNA_def_property_struct_type(prop, "GPencilStrokePoint");
930         RNA_def_property_ui_text(prop, "Stroke Points", "Stroke data points");
931         rna_def_gpencil_stroke_points_api(brna, prop);
932
933         /* vertex groups */
934         prop = RNA_def_property(srna, "groups", PROP_COLLECTION, PROP_NONE);
935         RNA_def_property_collection_funcs(prop, "rna_GpencilVertex_groups_begin", "rna_iterator_array_next",
936                 "rna_iterator_array_end", "rna_iterator_array_get", NULL, NULL, NULL, NULL);
937         RNA_def_property_struct_type(prop, "GpencilVertexGroupElement");
938         RNA_def_property_ui_text(prop, "Groups", "Weights for the vertex groups this vertex is member of");
939
940         /* Triangles */
941         prop = RNA_def_property(srna, "triangles", PROP_COLLECTION, PROP_NONE);
942         RNA_def_property_collection_sdna(prop, NULL, "triangles", "tot_triangles");
943         RNA_def_property_struct_type(prop, "GPencilTriangle");
944         RNA_def_property_ui_text(prop, "Triangles", "Triangulation data for HQ fill");
945
946         /* Material Index */
947         prop = RNA_def_property(srna, "material_index", PROP_INT, PROP_NONE);
948         RNA_def_property_int_sdna(prop, NULL, "mat_nr");
949         RNA_def_property_ui_text(prop, "Material Index", "Index of material used in this stroke");
950         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
951
952         /* Settings */
953         prop = RNA_def_property(srna, "display_mode", PROP_ENUM, PROP_NONE);
954         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
955         RNA_def_property_enum_items(prop, stroke_display_mode_items);
956         RNA_def_property_ui_text(prop, "Draw Mode", "Coordinate space that stroke is in");
957         RNA_def_property_update(prop, 0, "rna_GPencil_update");
958
959         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
960         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STROKE_SELECT);
961         RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencil_stroke_select_set");
962         RNA_def_property_ui_text(prop, "Select", "Stroke is selected for viewport editing");
963         RNA_def_property_update(prop, 0, "rna_GPencil_update");
964
965         /* Cyclic: Draw a line from end to start point */
966         prop = RNA_def_property(srna, "draw_cyclic", PROP_BOOLEAN, PROP_NONE);
967         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STROKE_CYCLIC);
968         RNA_def_property_ui_text(prop, "Cyclic", "Enable cyclic drawing, closing the stroke");
969         RNA_def_property_update(prop, 0, "rna_GPencil_update");
970
971         /* No fill: The stroke never must fill area and must use fill color as stroke color (this is a special flag for fill brush) */
972         prop = RNA_def_property(srna, "is_nofill_stroke", PROP_BOOLEAN, PROP_NONE);
973         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STROKE_NOFILL);
974         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
975         RNA_def_property_ui_text(prop, "No Fill", "Special stroke to use as boundary for filling areas");
976         RNA_def_property_update(prop, 0, "rna_GPencil_update");
977
978         /* Line Thickness */
979         prop = RNA_def_property(srna, "line_width", PROP_INT, PROP_PIXEL);
980         RNA_def_property_int_sdna(prop, NULL, "thickness");
981         RNA_def_property_range(prop, 1, 1000);
982         RNA_def_property_ui_range(prop, 1, 10, 1, 0);
983         RNA_def_property_ui_text(prop, "Thickness", "Thickness of stroke (in pixels)");
984         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
985
986 }
987
988 static void rna_def_gpencil_strokes_api(BlenderRNA *brna, PropertyRNA *cprop)
989 {
990         StructRNA *srna;
991
992         FunctionRNA *func;
993         PropertyRNA *parm;
994
995         RNA_def_property_srna(cprop, "GPencilStrokes");
996         srna = RNA_def_struct(brna, "GPencilStrokes", NULL);
997         RNA_def_struct_sdna(srna, "bGPDframe");
998         RNA_def_struct_ui_text(srna, "Grease Pencil Frames", "Collection of grease pencil stroke");
999
1000         func = RNA_def_function(srna, "new", "rna_GPencil_stroke_new");
1001         RNA_def_function_ui_description(func, "Add a new grease pencil stroke");
1002         parm = RNA_def_pointer(func, "stroke", "GPencilStroke", "", "The newly created stroke");
1003         RNA_def_function_return(func, parm);
1004
1005         func = RNA_def_function(srna, "remove", "rna_GPencil_stroke_remove");
1006         RNA_def_function_ui_description(func, "Remove a grease pencil stroke");
1007         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1008         parm = RNA_def_pointer(func, "stroke", "GPencilStroke", "Stroke", "The stroke to remove");
1009         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1010         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1011 }
1012
1013 static void rna_def_gpencil_frame(BlenderRNA *brna)
1014 {
1015         StructRNA *srna;
1016         PropertyRNA *prop;
1017
1018         FunctionRNA *func;
1019
1020         srna = RNA_def_struct(brna, "GPencilFrame", NULL);
1021         RNA_def_struct_sdna(srna, "bGPDframe");
1022         RNA_def_struct_ui_text(srna, "Grease Pencil Frame", "Collection of related sketches on a particular frame");
1023
1024         /* Strokes */
1025         prop = RNA_def_property(srna, "strokes", PROP_COLLECTION, PROP_NONE);
1026         RNA_def_property_collection_sdna(prop, NULL, "strokes", NULL);
1027         RNA_def_property_struct_type(prop, "GPencilStroke");
1028         RNA_def_property_ui_text(prop, "Strokes", "Freehand curves defining the sketch on this frame");
1029         rna_def_gpencil_strokes_api(brna, prop);
1030
1031         /* Frame Number */
1032         prop = RNA_def_property(srna, "frame_number", PROP_INT, PROP_NONE);
1033         RNA_def_property_int_sdna(prop, NULL, "framenum");
1034         /* XXX note: this cannot occur on the same frame as another sketch */
1035         RNA_def_property_range(prop, -MAXFRAME, MAXFRAME);
1036         RNA_def_property_ui_text(prop, "Frame Number", "The frame on which this sketch appears");
1037
1038         /* Flags */
1039         prop = RNA_def_property(srna, "is_edited", PROP_BOOLEAN, PROP_NONE);
1040         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_FRAME_PAINT); /* XXX should it be editable? */
1041         RNA_def_property_ui_text(prop, "Paint Lock", "Frame is being edited (painted on)");
1042
1043         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1044         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_FRAME_SELECT);
1045         RNA_def_property_ui_text(prop, "Select", "Frame is selected for editing in the Dope Sheet");
1046
1047
1048         /* API */
1049         func = RNA_def_function(srna, "clear", "rna_GPencil_frame_clear");
1050         RNA_def_function_ui_description(func, "Remove all the grease pencil frame data");
1051 }
1052
1053 static void rna_def_gpencil_frames_api(BlenderRNA *brna, PropertyRNA *cprop)
1054 {
1055         StructRNA *srna;
1056
1057         FunctionRNA *func;
1058         PropertyRNA *parm;
1059
1060         RNA_def_property_srna(cprop, "GPencilFrames");
1061         srna = RNA_def_struct(brna, "GPencilFrames", NULL);
1062         RNA_def_struct_sdna(srna, "bGPDlayer");
1063         RNA_def_struct_ui_text(srna, "Grease Pencil Frames", "Collection of grease pencil frames");
1064
1065         func = RNA_def_function(srna, "new", "rna_GPencil_frame_new");
1066         RNA_def_function_ui_description(func, "Add a new grease pencil frame");
1067         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1068         parm = RNA_def_int(func, "frame_number", 1, MINAFRAME, MAXFRAME, "Frame Number",
1069                            "The frame on which this sketch appears", MINAFRAME, MAXFRAME);
1070         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1071         parm = RNA_def_pointer(func, "frame", "GPencilFrame", "", "The newly created frame");
1072         RNA_def_function_return(func, parm);
1073
1074         func = RNA_def_function(srna, "remove", "rna_GPencil_frame_remove");
1075         RNA_def_function_ui_description(func, "Remove a grease pencil frame");
1076         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1077         parm = RNA_def_pointer(func, "frame", "GPencilFrame", "Frame", "The frame to remove");
1078         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1079         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1080
1081         func = RNA_def_function(srna, "copy", "rna_GPencil_frame_copy");
1082         RNA_def_function_ui_description(func, "Copy a grease pencil frame");
1083         parm = RNA_def_pointer(func, "source", "GPencilFrame", "Source", "The source frame");
1084         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1085         parm = RNA_def_pointer(func, "copy", "GPencilFrame", "", "The newly copied frame");
1086         RNA_def_function_return(func, parm);
1087 }
1088
1089 static void rna_def_gpencil_layer(BlenderRNA *brna)
1090 {
1091         StructRNA *srna;
1092         PropertyRNA *prop;
1093
1094         FunctionRNA *func;
1095         static const float default_onion_color_b[] = { 0.302f, 0.851f, 0.302f };
1096         static const float default_onion_color_a[] = { 0.250f, 0.1f, 1.0f };
1097
1098         srna = RNA_def_struct(brna, "GPencilLayer", NULL);
1099         RNA_def_struct_sdna(srna, "bGPDlayer");
1100         RNA_def_struct_ui_text(srna, "Grease Pencil Layer", "Collection of related sketches");
1101         RNA_def_struct_path_func(srna, "rna_GPencilLayer_path");
1102
1103         /* Name */
1104         prop = RNA_def_property(srna, "info", PROP_STRING, PROP_NONE);
1105         RNA_def_property_ui_text(prop, "Info", "Layer name");
1106         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilLayer_info_set");
1107         RNA_def_struct_name_property(srna, prop);
1108         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_RENAME, NULL);
1109
1110         /* Frames */
1111         prop = RNA_def_property(srna, "frames", PROP_COLLECTION, PROP_NONE);
1112         RNA_def_property_collection_sdna(prop, NULL, "frames", NULL);
1113         RNA_def_property_struct_type(prop, "GPencilFrame");
1114         RNA_def_property_ui_text(prop, "Frames", "Sketches for this layer on different frames");
1115         rna_def_gpencil_frames_api(brna, prop);
1116
1117         /* Active Frame */
1118         prop = RNA_def_property(srna, "active_frame", PROP_POINTER, PROP_NONE);
1119         RNA_def_property_pointer_sdna(prop, NULL, "actframe");
1120         RNA_def_property_ui_text(prop, "Active Frame", "Frame currently being displayed for this layer");
1121         RNA_def_property_editable_func(prop, "rna_GPencilLayer_active_frame_editable");
1122         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1123
1124
1125         /* Layer Opacity */
1126         prop = RNA_def_property(srna, "opacity", PROP_FLOAT, PROP_NONE);
1127         RNA_def_property_float_sdna(prop, NULL, "opacity");
1128         RNA_def_property_range(prop, 0.0, 1.0f);
1129         RNA_def_property_ui_text(prop, "Opacity", "Layer Opacity");
1130         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1131
1132
1133         /* Stroke Drawing Color (Annotations) */
1134         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
1135         RNA_def_property_array(prop, 3);
1136         RNA_def_property_range(prop, 0.0f, 1.0f);
1137         RNA_def_property_ui_text(prop, "Color", "Color for all strokes in this layer");
1138         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1139
1140         /* Line Thickness (Annotations) */
1141         prop = RNA_def_property(srna, "thickness", PROP_INT, PROP_PIXEL);
1142         RNA_def_property_int_sdna(prop, NULL, "thickness");
1143         RNA_def_property_range(prop, 1, 10);
1144         RNA_def_property_ui_text(prop, "Thickness", "Thickness of annotation strokes");
1145         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1146
1147
1148         /* Tint Color */
1149         prop = RNA_def_property(srna, "tint_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1150         RNA_def_property_float_sdna(prop, NULL, "tintcolor");
1151         RNA_def_property_array(prop, 3);
1152         RNA_def_property_range(prop, 0.0f, 1.0f);
1153         RNA_def_property_ui_text(prop, "Tint Color", "Color for tinting stroke colors");
1154         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1155
1156         /* Tint factor */
1157         prop = RNA_def_property(srna, "tint_factor", PROP_FLOAT, PROP_NONE);
1158         RNA_def_property_float_sdna(prop, NULL, "tintcolor[3]");
1159         RNA_def_property_range(prop, 0.0, 1.0f);
1160         RNA_def_property_ui_text(prop, "Tint Factor", "Factor of tinting color");
1161         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1162
1163         /* Line Thickness Change */
1164         prop = RNA_def_property(srna, "line_change", PROP_INT, PROP_PIXEL);
1165         RNA_def_property_int_sdna(prop, NULL, "line_change");
1166         RNA_def_property_range(prop, -300, 300);
1167         RNA_def_property_ui_range(prop, -100, 100, 1.0, 1);
1168         RNA_def_property_ui_text(prop, "Thickness Change", "Thickness change to apply to current strokes (in pixels)");
1169         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1170
1171
1172         /* Onion-Skinning */
1173         prop = RNA_def_property(srna, "use_onion_skinning", PROP_BOOLEAN, PROP_NONE);
1174         RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_LAYER_ONIONSKIN);
1175         RNA_def_property_ui_text(prop, "Onion Skinning", "Display onion skins before and after the current frame");
1176         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1177
1178         prop = RNA_def_property(srna, "use_annotation_onion_skinning", PROP_BOOLEAN, PROP_NONE);
1179         RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_LAYER_ONIONSKIN);
1180         RNA_def_property_ui_text(prop, "Onion Skinning",
1181                 "Display annotation onion skins before and after the current frame");
1182         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1183
1184         prop = RNA_def_property(srna, "annotation_onion_before_range", PROP_INT, PROP_NONE);
1185         RNA_def_property_int_sdna(prop, NULL, "gstep");
1186         RNA_def_property_range(prop, -1, 120);
1187         RNA_def_property_ui_text(prop, "Frames Before",
1188                 "Maximum number of frames to show before current frame");
1189         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1190
1191         prop = RNA_def_property(srna, "annotation_onion_after_range", PROP_INT, PROP_NONE);
1192         RNA_def_property_int_sdna(prop, NULL, "gstep_next");
1193         RNA_def_property_range(prop, -1, 120);
1194         RNA_def_property_ui_text(prop, "Frames After",
1195                 "Maximum number of frames to show after current frame");
1196         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1197
1198         prop = RNA_def_property(srna, "annotation_onion_before_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1199         RNA_def_property_float_sdna(prop, NULL, "gcolor_prev");
1200         RNA_def_property_array(prop, 3);
1201         RNA_def_property_range(prop, 0.0f, 1.0f);
1202         RNA_def_property_float_array_default(prop, default_onion_color_b);
1203         RNA_def_property_ui_text(prop, "Before Color", "Base color for ghosts before the active frame");
1204         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1205
1206         prop = RNA_def_property(srna, "annotation_onion_after_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1207         RNA_def_property_float_sdna(prop, NULL, "gcolor_next");
1208         RNA_def_property_array(prop, 3);
1209         RNA_def_property_range(prop, 0.0f, 1.0f);
1210         RNA_def_property_float_array_default(prop, default_onion_color_a);
1211         RNA_def_property_ui_text(prop, "After Color", "Base color for ghosts after the active frame");
1212         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1213
1214         /* pass index for compositing and modifiers */
1215         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_UNSIGNED);
1216         RNA_def_property_int_sdna(prop, NULL, "pass_index");
1217         RNA_def_property_ui_text(prop, "Pass Index", "Index number for the \"Layer Index\" pass");
1218         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1219
1220         prop = RNA_def_property(srna, "viewlayer_render", PROP_STRING, PROP_NONE);
1221         RNA_def_property_string_sdna(prop, NULL, "viewlayername");
1222         RNA_def_property_ui_text(prop, "ViewLayer",
1223                 "Only include Layer in this View Layer render output (leave blank to include always)");
1224
1225         /* blend mode */
1226         prop = RNA_def_property(srna, "blend_mode", PROP_ENUM, PROP_NONE);
1227         RNA_def_property_enum_sdna(prop, NULL, "blend_mode");
1228         RNA_def_property_enum_items(prop, rna_enum_layer_blend_modes_items);
1229         RNA_def_property_ui_text(prop, "Blend Mode", "Blend mode");
1230         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1231
1232         /* Flags */
1233         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1234         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_HIDE);
1235         RNA_def_property_ui_icon(prop, ICON_HIDE_OFF, -1);
1236         RNA_def_property_ui_text(prop, "Hide", "Set layer Visibility");
1237         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1238
1239         prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
1240         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_LOCKED);
1241         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
1242         RNA_def_property_ui_text(prop, "Locked", "Protect layer from further editing and/or frame changes");
1243         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1244
1245         prop = RNA_def_property(srna, "lock_frame", PROP_BOOLEAN, PROP_NONE);
1246         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_FRAMELOCK);
1247         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
1248         RNA_def_property_ui_text(prop, "Frame Locked", "Lock current frame displayed by layer");
1249         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1250
1251         prop = RNA_def_property(srna, "lock_material", PROP_BOOLEAN, PROP_NONE);
1252         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GP_LAYER_UNLOCK_COLOR);
1253         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1254         RNA_def_property_ui_text(prop, "Lock Material", "Disable Material editing");
1255         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1256
1257         prop = RNA_def_property(srna, "clamp_layer", PROP_BOOLEAN, PROP_NONE);
1258         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_USE_MASK);
1259         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1260         RNA_def_property_ui_text(prop, "Clamp Layer",
1261                 "Clamp any pixel outside underlying layers drawing");
1262         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1263
1264         /* exposed as layers.active */
1265 #if 0
1266         prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1267         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_ACTIVE);
1268         RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencilLayer_active_set");
1269         RNA_def_property_ui_text(prop, "Active", "Set active layer for editing");
1270         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_SELECTED, NULL);
1271 #endif
1272
1273         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1274         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_SELECT);
1275         RNA_def_property_ui_text(prop, "Select", "Layer is selected for editing in the Dope Sheet");
1276         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_SELECTED, "rna_GPencil_update");
1277
1278         prop = RNA_def_property(srna, "show_points", PROP_BOOLEAN, PROP_NONE);
1279         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_DRAWDEBUG);
1280         RNA_def_property_ui_text(prop, "Show Points", "Draw the points which make up the strokes (for debugging purposes)");
1281         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1282
1283         /* In Front */
1284         prop = RNA_def_property(srna, "show_in_front", PROP_BOOLEAN, PROP_NONE);
1285         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GP_LAYER_NO_XRAY);
1286         RNA_def_property_ui_text(prop, "In Front", "Make the layer draw in front of objects");
1287         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1288
1289         /* Parent object */
1290         prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
1291         RNA_def_property_pointer_funcs(prop, NULL, "rna_GPencilLayer_parent_set", NULL, NULL);
1292         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
1293         RNA_def_property_ui_text(prop, "Parent", "Parent Object");
1294         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1295
1296         /* parent type */
1297         prop = RNA_def_property(srna, "parent_type", PROP_ENUM, PROP_NONE);
1298         RNA_def_property_enum_bitflag_sdna(prop, NULL, "partype");
1299         RNA_def_property_enum_items(prop, parent_type_items);
1300         RNA_def_property_enum_funcs(prop, NULL, "rna_GPencilLayer_parent_type_set", "rna_Object_parent_type_itemf");
1301         RNA_def_property_ui_text(prop, "Parent Type", "Type of parent relation");
1302         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1303
1304         /* parent bone */
1305         prop = RNA_def_property(srna, "parent_bone", PROP_STRING, PROP_NONE);
1306         RNA_def_property_string_sdna(prop, NULL, "parsubstr");
1307         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilLayer_parent_bone_set");
1308         RNA_def_property_ui_text(prop, "Parent Bone", "Name of parent bone in case of a bone parenting relation");
1309         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1310
1311         /* matrix */
1312         prop = RNA_def_property(srna, "matrix_inverse", PROP_FLOAT, PROP_MATRIX);
1313         RNA_def_property_float_sdna(prop, NULL, "inverse");
1314         RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
1315         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1316         RNA_def_property_ui_text(prop, "Inverse Matrix", "Parent inverse transformation matrix");
1317         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1318
1319         /* read only parented flag */
1320         prop = RNA_def_property(srna, "is_parented", PROP_BOOLEAN, PROP_NONE);
1321         RNA_def_property_boolean_funcs(prop, "rna_GPencilLayer_is_parented_get", NULL);
1322         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1323         RNA_def_property_ui_text(prop, "Is Parented", "True when the layer parent object is set");
1324
1325         /* Layers API */
1326         func = RNA_def_function(srna, "clear", "rna_GPencil_layer_clear");
1327         RNA_def_function_ui_description(func, "Remove all the grease pencil layer data");
1328 }
1329
1330 static void rna_def_gpencil_layers_api(BlenderRNA *brna, PropertyRNA *cprop)
1331 {
1332         StructRNA *srna;
1333         PropertyRNA *prop;
1334
1335         FunctionRNA *func;
1336         PropertyRNA *parm;
1337
1338         RNA_def_property_srna(cprop, "GreasePencilLayers");
1339         srna = RNA_def_struct(brna, "GreasePencilLayers", NULL);
1340         RNA_def_struct_sdna(srna, "bGPdata");
1341         RNA_def_struct_ui_text(srna, "Grease Pencil Layers", "Collection of grease pencil layers");
1342
1343         func = RNA_def_function(srna, "new", "rna_GPencil_layer_new");
1344         RNA_def_function_ui_description(func, "Add a new grease pencil layer");
1345         parm = RNA_def_string(func, "name", "GPencilLayer", MAX_NAME, "Name", "Name of the layer");
1346         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1347         RNA_def_boolean(func, "set_active", true, "Set Active", "Set the newly created layer to the active layer");
1348         parm = RNA_def_pointer(func, "layer", "GPencilLayer", "", "The newly created layer");
1349         RNA_def_function_return(func, parm);
1350
1351         func = RNA_def_function(srna, "remove", "rna_GPencil_layer_remove");
1352         RNA_def_function_ui_description(func, "Remove a grease pencil layer");
1353         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1354         parm = RNA_def_pointer(func, "layer", "GPencilLayer", "", "The layer to remove");
1355         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1356         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1357
1358         func = RNA_def_function(srna, "move", "rna_GPencil_layer_move");
1359         RNA_def_function_ui_description(func, "Move a grease pencil layer in the layer stack");
1360         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1361         parm = RNA_def_pointer(func, "layer", "GPencilLayer", "", "The layer to move");
1362         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1363         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1364         parm = RNA_def_enum(func, "type", rna_enum_gplayer_move_type_items, 1, "", "Direction of movement");
1365         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1366
1367         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1368         RNA_def_property_struct_type(prop, "GPencilLayer");
1369         RNA_def_property_pointer_funcs(prop, "rna_GPencil_active_layer_get", "rna_GPencil_active_layer_set", NULL, NULL);
1370         RNA_def_property_flag(prop, PROP_EDITABLE);
1371         RNA_def_property_ui_text(prop, "Active Layer", "Active grease pencil layer");
1372         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_SELECTED, NULL);
1373
1374         prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
1375         RNA_def_property_int_funcs(
1376                 prop,
1377                 "rna_GPencil_active_layer_index_get",
1378                 "rna_GPencil_active_layer_index_set",
1379                 "rna_GPencil_active_layer_index_range");
1380         RNA_def_property_ui_text(prop, "Active Layer Index", "Index of active grease pencil layer");
1381         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_SELECTED, NULL);
1382
1383         /* Active Layer - As an enum (for selecting active layer for annotations) */
1384         prop = RNA_def_property(srna, "active_note", PROP_ENUM, PROP_NONE);
1385         RNA_def_property_enum_funcs(
1386                 prop,
1387                 "rna_GPencil_active_layer_index_get",
1388                 "rna_GPencil_active_layer_index_set",
1389                 "rna_GPencil_active_layer_itemf");
1390         RNA_def_property_enum_items(prop, DummyRNA_DEFAULT_items); /* purely dynamic, as it maps to user-data */
1391         RNA_def_property_ui_text(prop, "Active Note", "Note/Layer to add annotation strokes to");
1392         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1393 }
1394
1395 static void rna_def_gpencil_grid(BlenderRNA *brna)
1396 {
1397         StructRNA *srna;
1398         PropertyRNA *prop;
1399
1400         static const float default_grid_color[] = { 0.5f, 0.5f, 0.5f };
1401
1402         srna = RNA_def_struct(brna, "GreasePencilGrid", NULL);
1403         RNA_def_struct_sdna(srna, "bGPgrid");
1404         RNA_def_struct_nested(brna, srna, "GreasePencil");
1405
1406         RNA_def_struct_path_func(srna, "rna_GreasePencilGrid_path");
1407         RNA_def_struct_ui_text(srna, "Grid and Canvas Settings",
1408                                "Settings for grid and canvas in 3D viewport");
1409
1410         prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
1411         RNA_def_property_float_sdna(prop, NULL, "scale");
1412         RNA_def_property_range(prop, 0.01f, FLT_MAX);
1413         RNA_def_property_float_default(prop, 1.0f);
1414         RNA_def_property_ui_text(prop, "Grid Scale", "Grid scale");
1415         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1416
1417         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
1418         RNA_def_property_float_sdna(prop, NULL, "color");
1419         RNA_def_property_array(prop, 3);
1420         RNA_def_property_range(prop, 0.0f, 1.0f);
1421         RNA_def_property_float_array_default(prop, default_grid_color);
1422         RNA_def_property_ui_text(prop, "Grid Color", "Color for grid lines");
1423         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1424
1425         prop = RNA_def_property(srna, "lines", PROP_INT, PROP_NONE);
1426         RNA_def_property_int_sdna(prop, NULL, "lines");
1427         RNA_def_property_range(prop, 0, INT_MAX);
1428         RNA_def_property_int_default(prop, GP_DEFAULT_GRID_LINES);
1429         RNA_def_property_ui_text(prop, "Grid Subdivisions", "Number of subdivisions in each side of symmetry line");
1430         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1431
1432         prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_XYZ);
1433         RNA_def_property_float_sdna(prop, NULL, "offset");
1434         RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
1435         RNA_def_property_array(prop, 2);
1436         RNA_def_property_ui_text(prop, "Offset", "Offset of the canvas");
1437         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1438 }
1439
1440 static void rna_def_gpencil_data(BlenderRNA *brna)
1441 {
1442         StructRNA *srna;
1443         PropertyRNA *prop;
1444         FunctionRNA *func;
1445
1446         static float default_1[4] = { 0.6f, 0.6f, 0.6f, 0.5f };
1447         static float onion_dft1[3] = { 0.145098f, 0.419608f, 0.137255f }; /* green */
1448         static float onion_dft2[3] = { 0.125490f, 0.082353f, 0.529412f }; /* blue */
1449
1450         srna = RNA_def_struct(brna, "GreasePencil", "ID");
1451         RNA_def_struct_sdna(srna, "bGPdata");
1452         RNA_def_struct_ui_text(srna, "Grease Pencil", "Freehand annotation sketchbook");
1453         RNA_def_struct_ui_icon(srna, ICON_GREASEPENCIL);
1454
1455         /* Layers */
1456         prop = RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);
1457         RNA_def_property_collection_sdna(prop, NULL, "layers", NULL);
1458         RNA_def_property_struct_type(prop, "GPencilLayer");
1459         RNA_def_property_ui_text(prop, "Layers", "");
1460         rna_def_gpencil_layers_api(brna, prop);
1461
1462         /* Animation Data */
1463         rna_def_animdata_common(srna);
1464
1465         /* materials */
1466         prop = RNA_def_property(srna, "materials", PROP_COLLECTION, PROP_NONE);
1467         RNA_def_property_collection_sdna(prop, NULL, "mat", "totcol");
1468         RNA_def_property_struct_type(prop, "Material");
1469         RNA_def_property_ui_text(prop, "Materials", "");
1470         RNA_def_property_srna(prop, "IDMaterials"); /* see rna_ID.c */
1471         RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "rna_IDMaterials_assign_int");
1472
1473         /* xray modes */
1474         prop = RNA_def_property(srna, "xray_mode", PROP_ENUM, PROP_NONE);
1475         RNA_def_property_enum_sdna(prop, NULL, "xray_mode");
1476         RNA_def_property_enum_items(prop, rna_enum_gpencil_xraymodes_items);
1477         RNA_def_property_ui_text(prop, "Xray", "");
1478         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1479
1480         /* Flags */
1481         prop = RNA_def_property(srna, "use_stroke_edit_mode", PROP_BOOLEAN, PROP_NONE);
1482         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_EDITMODE);
1483         RNA_def_property_ui_text(prop, "Stroke Edit Mode", "Edit Grease Pencil strokes instead of viewport data");
1484         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");
1485
1486         prop = RNA_def_property(srna, "is_stroke_paint_mode", PROP_BOOLEAN, PROP_NONE);
1487         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_PAINTMODE);
1488         RNA_def_property_ui_text(prop, "Stroke Paint Mode", "Draw Grease Pencil strokes on click/drag");
1489         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1490         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");
1491
1492         prop = RNA_def_property(srna, "is_stroke_sculpt_mode", PROP_BOOLEAN, PROP_NONE);
1493         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_SCULPTMODE);
1494         RNA_def_property_ui_text(prop, "Stroke Sculpt Mode", "Sculpt Grease Pencil strokes instead of viewport data");
1495         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1496         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");
1497
1498         prop = RNA_def_property(srna, "is_stroke_weight_mode", PROP_BOOLEAN, PROP_NONE);
1499         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_WEIGHTMODE);
1500         RNA_def_property_ui_text(prop, "Stroke Weight Paint Mode", "Grease Pencil weight paint");
1501         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1502         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");
1503
1504         prop = RNA_def_property(srna, "use_onion_skinning", PROP_BOOLEAN, PROP_NONE);
1505         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_SHOW_ONIONSKINS);
1506         RNA_def_property_boolean_default(prop, true);
1507         RNA_def_property_ui_text(prop, "Onion Skins", "Show ghosts of the keyframes before and after the current frame");
1508         RNA_def_property_update(prop, NC_SCREEN | NC_SCENE | ND_TOOLSETTINGS | ND_DATA | NC_GPENCIL, "rna_GPencil_update");
1509
1510         prop = RNA_def_property(srna, "show_stroke_direction", PROP_BOOLEAN, PROP_NONE);
1511         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_SHOW_DIRECTION);
1512         RNA_def_property_ui_text(prop, "Show Direction", "Show stroke drawing direction with a bigger green dot (start) "
1513                                  "and smaller red dot (end) points");
1514         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1515
1516         prop = RNA_def_property(srna, "show_constant_thickness", PROP_BOOLEAN, PROP_NONE);
1517         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_KEEPTHICKNESS);
1518         RNA_def_property_ui_text(prop, "Keep Thickness", "Maintain the thickness of the stroke when the viewport zoom changes");
1519         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1520
1521         prop = RNA_def_property(srna, "pixel_factor", PROP_FLOAT, PROP_NONE);
1522         RNA_def_property_float_sdna(prop, NULL, "pixfactor");
1523         RNA_def_property_range(prop, 0.1f, 30.0f);
1524         RNA_def_property_ui_range(prop, 0.1f, 30.0f, 1, 2);
1525         RNA_def_property_ui_text(prop, "Scale", "Scale conversion factor for pixel size (use larger values for thicker lines)");
1526         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1527
1528         prop = RNA_def_property(srna, "use_multiedit", PROP_BOOLEAN, PROP_NONE);
1529         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_MULTIEDIT);
1530         RNA_def_property_ui_text(prop, "MultiFrame", "Edit strokes from multiple grease pencil keyframes at the same time (keyframes must be selected to be included)");
1531         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1532
1533         prop = RNA_def_property(srna, "use_force_fill_recalc", PROP_BOOLEAN, PROP_NONE);
1534         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_FORCE_RECALC);
1535         RNA_def_property_ui_text(prop, "Force Fill Update", "Force recalc of fill data after use deformation modifiers (reduce FPS)");
1536         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1537
1538         prop = RNA_def_property(srna, "use_adaptative_uv", PROP_BOOLEAN, PROP_NONE);
1539         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_UV_ADAPTATIVE);
1540         RNA_def_property_ui_text(prop, "Adaptative UV", "Automatic UVs are calculated depending of the stroke size");
1541         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1542
1543         prop = RNA_def_property(srna, "use_autolock_layers", PROP_BOOLEAN, PROP_NONE);
1544         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_AUTOLOCK_LAYERS);
1545         RNA_def_property_ui_text(prop, "Autolock Layers",
1546                 "Lock automatically all layers except active one to avoid accidental changes");
1547         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_autolock");
1548
1549         prop = RNA_def_property(srna, "edit_line_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1550         RNA_def_property_float_sdna(prop, NULL, "line_color");
1551         RNA_def_property_array(prop, 4);
1552         RNA_def_property_range(prop, 0.0f, 1.0f);
1553         RNA_def_property_float_array_default(prop, default_1);
1554         RNA_def_property_ui_text(prop, "Edit Line Color", "Color for editing line");
1555         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1556
1557         /* onion skinning */
1558         prop = RNA_def_property(srna, "ghost_before_range", PROP_INT, PROP_NONE);
1559         RNA_def_property_int_sdna(prop, NULL, "gstep");
1560         RNA_def_property_range(prop, 0, 120);
1561         RNA_def_property_int_default(prop, 1);
1562         RNA_def_property_ui_text(prop, "Frames Before",
1563                 "Maximum number of frames to show before current frame "
1564                 "(0 = don't show any frames before current)");
1565         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1566
1567         prop = RNA_def_property(srna, "ghost_after_range", PROP_INT, PROP_NONE);
1568         RNA_def_property_int_sdna(prop, NULL, "gstep_next");
1569         RNA_def_property_range(prop, 0, 120);
1570         RNA_def_property_int_default(prop, 1);
1571         RNA_def_property_ui_text(prop, "Frames After",
1572                 "Maximum number of frames to show after current frame "
1573                 "(0 = don't show any frames after current)");
1574         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1575
1576         prop = RNA_def_property(srna, "use_ghost_custom_colors", PROP_BOOLEAN, PROP_NONE);
1577         RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_ONION_GHOST_PREVCOL | GP_ONION_GHOST_NEXTCOL);
1578         RNA_def_property_ui_text(prop, "Use Custom Ghost Colors", "Use custom colors for ghost frames");
1579         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1580
1581         prop = RNA_def_property(srna, "before_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1582         RNA_def_property_float_sdna(prop, NULL, "gcolor_prev");
1583         RNA_def_property_array(prop, 3);
1584         RNA_def_property_range(prop, 0.0f, 1.0f);
1585         RNA_def_property_float_array_default(prop, onion_dft1);
1586         RNA_def_property_ui_text(prop, "Before Color", "Base color for ghosts before the active frame");
1587         RNA_def_property_update(prop, NC_SCREEN | NC_SCENE | ND_TOOLSETTINGS | ND_DATA | NC_GPENCIL, "rna_GPencil_update");
1588
1589         prop = RNA_def_property(srna, "after_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1590         RNA_def_property_float_sdna(prop, NULL, "gcolor_next");
1591         RNA_def_property_array(prop, 3);
1592         RNA_def_property_range(prop, 0.0f, 1.0f);
1593         RNA_def_property_float_array_default(prop, onion_dft2);
1594         RNA_def_property_ui_text(prop, "After Color", "Base color for ghosts after the active frame");
1595         RNA_def_property_update(prop, NC_SCREEN | NC_SCENE | ND_TOOLSETTINGS | ND_DATA | NC_GPENCIL, "rna_GPencil_update");
1596
1597         prop = RNA_def_property(srna, "use_ghosts_always", PROP_BOOLEAN, PROP_NONE);
1598         RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_ONION_GHOST_ALWAYS);
1599         RNA_def_property_ui_text(prop, "Always Show Ghosts",
1600                 "Ghosts are shown in renders and animation playback. Useful for special effects (e.g. motion blur)");
1601         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1602
1603         prop = RNA_def_property(srna, "onion_mode", PROP_ENUM, PROP_NONE);
1604         RNA_def_property_enum_sdna(prop, NULL, "onion_mode");
1605         RNA_def_property_enum_items(prop, rna_enum_gpencil_onion_modes_items);
1606         RNA_def_property_ui_text(prop, "Mode", "Mode to display frames");
1607         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1608
1609         prop = RNA_def_property(srna, "use_onion_fade", PROP_BOOLEAN, PROP_NONE);
1610         RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_ONION_FADE);
1611         RNA_def_property_ui_text(prop, "Fade",
1612                 "Display onion keyframes with a fade in color transparency");
1613         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1614
1615         prop = RNA_def_property(srna, "use_onion_loop", PROP_BOOLEAN, PROP_NONE);
1616         RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_ONION_LOOP);
1617         RNA_def_property_ui_text(prop, "Loop",
1618                 "Display first onion keyframes using next frame color to show indication of loop start frame");
1619         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1620
1621         prop = RNA_def_property(srna, "onion_factor", PROP_FLOAT, PROP_NONE);
1622         RNA_def_property_float_sdna(prop, NULL, "onion_factor");
1623         RNA_def_property_float_default(prop, 0.5f);
1624         RNA_def_property_range(prop, 0.0, 1.0f);
1625         RNA_def_property_ui_text(prop, "Onion Opacity", "Change fade opacity of displayed onion frames");
1626         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1627
1628         prop = RNA_def_property(srna, "zdepth_offset", PROP_FLOAT, PROP_NONE);
1629         RNA_def_property_float_sdna(prop, NULL, "zdepth_offset");
1630         RNA_def_property_range(prop, 0.0f, 1.0f);
1631         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 5);
1632         RNA_def_property_ui_text(prop, "Surface Offset",
1633                 "Offset amount when drawing in surface mode");
1634         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1635
1636         /* Nested Structs */
1637         prop = RNA_def_property(srna, "grid", PROP_POINTER, PROP_NONE);
1638         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1639         RNA_def_property_struct_type(prop, "GreasePencilGrid");
1640         RNA_def_property_ui_text(prop, "Grid Settings", "Settings for grid and canvas in the 3D viewport");
1641
1642         rna_def_gpencil_grid(brna);
1643
1644         /* API Functions */
1645         func = RNA_def_function(srna, "clear", "rna_GPencil_clear");
1646         RNA_def_function_ui_description(func, "Remove all the Grease Pencil data");
1647 }
1648
1649 /* --- */
1650
1651 void RNA_def_gpencil(BlenderRNA *brna)
1652 {
1653         rna_def_gpencil_data(brna);
1654
1655         rna_def_gpencil_layer(brna);
1656         rna_def_gpencil_frame(brna);
1657
1658         rna_def_gpencil_stroke(brna);
1659         rna_def_gpencil_stroke_point(brna);
1660         rna_def_gpencil_triangle(brna);
1661
1662         rna_def_gpencil_mvert_group(brna);
1663 }
1664
1665 #endif