GP: New Python update API functions (WIP)
[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(bGPDstroke *stroke, int count, float pressure, float strength)
504 {
505         if (count > 0) {
506                 /* create space at the end of the array for extra points */
507                 stroke->points = MEM_recallocN_id(stroke->points,
508                                                   sizeof(bGPDspoint) * (stroke->totpoints + count),
509                                                   "gp_stroke_points");
510                 stroke->dvert = MEM_recallocN_id(stroke->dvert,
511                                                   sizeof(MDeformVert) * (stroke->totpoints + count),
512                                                   "gp_stroke_weight");
513
514                 /* init the pressure and strength values so that old scripts won't need to
515                  * be modified to give these initial values...
516                  */
517                 for (int i = 0; i < count; i++) {
518                         bGPDspoint *pt = stroke->points + (stroke->totpoints + i);
519                         MDeformVert *dvert = stroke->dvert + (stroke->totpoints + i);
520                         pt->pressure = pressure;
521                         pt->strength = strength;
522
523                         dvert->totweight = 0;
524                         dvert->dw = NULL;
525                 }
526
527                 stroke->totpoints += count;
528         }
529 }
530
531 static void rna_GPencil_stroke_point_pop(bGPDstroke *stroke, ReportList *reports, int index)
532 {
533         bGPDspoint *pt_tmp = stroke->points;
534         MDeformVert *pt_dvert = stroke->dvert;
535
536         /* python style negative indexing */
537         if (index < 0) {
538                 index += stroke->totpoints;
539         }
540
541         if (stroke->totpoints <= index || index < 0) {
542                 BKE_report(reports, RPT_ERROR, "GPencilStrokePoints.pop: index out of range");
543                 return;
544         }
545
546         stroke->totpoints--;
547
548         stroke->points = MEM_callocN(sizeof(bGPDspoint) * stroke->totpoints, "gp_stroke_points");
549         if (pt_dvert != NULL) {
550                 stroke->dvert = MEM_callocN(sizeof(MDeformVert) * stroke->totpoints, "gp_stroke_weights");
551         }
552
553         if (index > 0) {
554                 memcpy(stroke->points, pt_tmp, sizeof(bGPDspoint) * index);
555                 /* verify weight data is available */
556                 if (pt_dvert != NULL) {
557                         memcpy(stroke->dvert, pt_dvert, sizeof(MDeformVert) * index);
558                 }
559         }
560
561         if (index < stroke->totpoints) {
562                 memcpy(&stroke->points[index], &pt_tmp[index + 1], sizeof(bGPDspoint) * (stroke->totpoints - index));
563                 if (pt_dvert != NULL) {
564                         memcpy(&stroke->dvert[index], &pt_dvert[index + 1], sizeof(MDeformVert) * (stroke->totpoints - index));
565                 }
566         }
567
568         /* free temp buffer */
569         MEM_freeN(pt_tmp);
570         if (pt_dvert != NULL) {
571                 MEM_freeN(pt_dvert);
572         }
573
574         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
575 }
576
577 static bGPDstroke *rna_GPencil_stroke_new(bGPDframe *frame)
578 {
579         bGPDstroke *stroke = MEM_callocN(sizeof(bGPDstroke), "gp_stroke");
580         BLI_addtail(&frame->strokes, stroke);
581
582         return stroke;
583 }
584
585 static void rna_GPencil_stroke_remove(bGPDframe *frame, ReportList *reports, PointerRNA *stroke_ptr)
586 {
587         bGPDstroke *stroke = stroke_ptr->data;
588         if (BLI_findindex(&frame->strokes, stroke) == -1) {
589                 BKE_report(reports, RPT_ERROR, "Stroke not found in grease pencil frame");
590                 return;
591         }
592
593         BLI_freelinkN(&frame->strokes, stroke);
594         RNA_POINTER_INVALIDATE(stroke_ptr);
595
596         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
597 }
598
599 static void rna_GPencil_stroke_update(bGPDframe *frame, ReportList *reports, PointerRNA *stroke_ptr)
600 {
601         bGPDstroke *stroke = stroke_ptr->data;
602         if (BLI_findindex(&frame->strokes, stroke) == -1) {
603                 BKE_report(reports, RPT_ERROR, "Stroke not found in grease pencil frame");
604                 return;
605         }
606         stroke->flag |= GP_STROKE_RECALC_CACHES;
607
608         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
609 }
610
611 static void rna_GPencil_stroke_select_set(PointerRNA *ptr, const bool value)
612 {
613         bGPDstroke *gps = ptr->data;
614         bGPDspoint *pt;
615         int i;
616
617         /* set new value */
618         if (value)
619                 gps->flag |= GP_STROKE_SELECT;
620         else
621                 gps->flag &= ~GP_STROKE_SELECT;
622
623         /* ensure that the stroke's points are selected in the same way */
624         for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
625                 if (value)
626                         pt->flag |= GP_SPOINT_SELECT;
627                 else
628                         pt->flag &= ~GP_SPOINT_SELECT;
629         }
630 }
631
632 static bGPDframe *rna_GPencil_frame_new(bGPDlayer *layer, ReportList *reports, int frame_number)
633 {
634         bGPDframe *frame;
635
636         if (BKE_gpencil_layer_find_frame(layer, frame_number)) {
637                 BKE_reportf(reports, RPT_ERROR, "Frame already exists on this frame number %d", frame_number);
638                 return NULL;
639         }
640
641         frame = BKE_gpencil_frame_addnew(layer, frame_number);
642
643         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
644
645         return frame;
646 }
647
648 static void rna_GPencil_frame_remove(bGPDlayer *layer, ReportList *reports, PointerRNA *frame_ptr)
649 {
650         bGPDframe *frame = frame_ptr->data;
651         if (BLI_findindex(&layer->frames, frame) == -1) {
652                 BKE_report(reports, RPT_ERROR, "Frame not found in grease pencil layer");
653                 return;
654         }
655
656         BKE_gpencil_layer_delframe(layer, frame);
657         RNA_POINTER_INVALIDATE(frame_ptr);
658
659         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
660 }
661
662 static bGPDframe *rna_GPencil_frame_copy(bGPDlayer *layer, bGPDframe *src)
663 {
664         bGPDframe *frame = BKE_gpencil_frame_duplicate(src);
665
666         while (BKE_gpencil_layer_find_frame(layer, frame->framenum)) {
667                 frame->framenum++;
668         }
669
670         BLI_addtail(&layer->frames, frame);
671
672         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
673
674         return frame;
675 }
676
677 static bGPDlayer *rna_GPencil_layer_new(bGPdata *gpd, const char *name, bool setactive)
678 {
679         bGPDlayer *gpl = BKE_gpencil_layer_addnew(gpd, name, setactive != 0);
680
681         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
682
683         return gpl;
684 }
685
686 static void rna_GPencil_layer_remove(bGPdata *gpd, ReportList *reports, PointerRNA *layer_ptr)
687 {
688         bGPDlayer *layer = layer_ptr->data;
689         if (BLI_findindex(&gpd->layers, layer) == -1) {
690                 BKE_report(reports, RPT_ERROR, "Layer not found in grease pencil data");
691                 return;
692         }
693
694         BKE_gpencil_layer_delete(gpd, layer);
695         RNA_POINTER_INVALIDATE(layer_ptr);
696
697         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
698 }
699
700 static void rna_GPencil_layer_move(bGPdata *gpd, ReportList *reports, PointerRNA *layer_ptr, int type)
701 {
702         bGPDlayer *gpl = layer_ptr->data;
703         if (BLI_findindex(&gpd->layers, gpl) == -1) {
704                 BKE_report(reports, RPT_ERROR, "Layer not found in grease pencil data");
705                 return;
706         }
707
708         BLI_assert(ELEM(type, -1, 0, 1)); /* we use value below */
709
710         const int direction = type * -1;
711
712         if (BLI_listbase_link_move(&gpd->layers, gpl, direction)) {
713                 DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
714         }
715
716         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
717 }
718
719 static void rna_GPencil_frame_clear(bGPDframe *frame)
720 {
721         BKE_gpencil_free_strokes(frame);
722
723         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
724 }
725
726 static void rna_GPencil_layer_clear(bGPDlayer *layer)
727 {
728         BKE_gpencil_free_frames(layer);
729
730         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
731 }
732
733 static void rna_GPencil_clear(bGPdata *gpd)
734 {
735         BKE_gpencil_free_layers(&gpd->layers);
736
737         WM_main_add_notifier(NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
738 }
739
740 static void rna_GPencil_update_data(bGPdata *gpd)
741 {
742         DEG_id_tag_update(&gpd->id, ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY);
743         DEG_id_tag_update(&gpd->id, ID_RECALC_COPY_ON_WRITE);
744
745         WM_main_add_notifier(NC_GPENCIL | NA_EDITED, NULL);
746 }
747
748 static void rna_GpencilVertex_groups_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
749 {
750         bGPDstroke *gps = ptr->data;
751
752         if (gps->dvert) {
753                 MDeformVert *dvert = gps->dvert;
754
755                 rna_iterator_array_begin(iter, (void *)dvert->dw, sizeof(MDeformWeight), dvert->totweight, 0, NULL);
756         }
757         else
758                 rna_iterator_array_begin(iter, NULL, 0, 0, 0, NULL);
759 }
760
761 static char *rna_GreasePencilGrid_path(PointerRNA *UNUSED(ptr))
762 {
763         return BLI_sprintfN("grid");
764 }
765
766 #else
767
768 static void rna_def_gpencil_stroke_point(BlenderRNA *brna)
769 {
770         StructRNA *srna;
771         PropertyRNA *prop;
772
773         srna = RNA_def_struct(brna, "GPencilStrokePoint", NULL);
774         RNA_def_struct_sdna(srna, "bGPDspoint");
775         RNA_def_struct_ui_text(srna, "Grease Pencil Stroke Point", "Data point for freehand stroke curve");
776
777         prop = RNA_def_property(srna, "co", PROP_FLOAT, PROP_XYZ);
778         RNA_def_property_float_sdna(prop, NULL, "x");
779         RNA_def_property_array(prop, 3);
780         RNA_def_property_ui_text(prop, "Coordinates", "");
781         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
782
783         prop = RNA_def_property(srna, "pressure", PROP_FLOAT, PROP_NONE);
784         RNA_def_property_float_sdna(prop, NULL, "pressure");
785         RNA_def_property_range(prop, 0.0f, 1.0f);
786         RNA_def_property_ui_text(prop, "Pressure", "Pressure of tablet at point when drawing it");
787         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
788
789         prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
790         RNA_def_property_float_sdna(prop, NULL, "strength");
791         RNA_def_property_range(prop, 0.0f, 1.0f);
792         RNA_def_property_ui_text(prop, "Strength", "Color intensity (alpha factor)");
793         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
794
795         prop = RNA_def_property(srna, "uv_factor", PROP_FLOAT, PROP_NONE);
796         RNA_def_property_float_sdna(prop, NULL, "uv_fac");
797         RNA_def_property_range(prop, 0.0f, 1.0f);
798         RNA_def_property_ui_text(prop, "UV Factor", "Internal UV factor");
799         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
800
801         prop = RNA_def_property(srna, "uv_rotation", PROP_FLOAT, PROP_ANGLE);
802         RNA_def_property_float_sdna(prop, NULL, "uv_rot");
803         RNA_def_property_range(prop, 0.0f, M_PI * 2);
804         RNA_def_property_ui_text(prop, "UV Rotation", "Internal UV factor for dot mode");
805         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
806
807         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
808         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SPOINT_SELECT);
809         RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencil_stroke_point_select_set");
810         RNA_def_property_ui_text(prop, "Select", "Point is selected for viewport editing");
811         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
812
813 }
814
815 static void rna_def_gpencil_stroke_points_api(BlenderRNA *brna, PropertyRNA *cprop)
816 {
817         StructRNA *srna;
818         FunctionRNA *func;
819         PropertyRNA *parm;
820
821         RNA_def_property_srna(cprop, "GPencilStrokePoints");
822         srna = RNA_def_struct(brna, "GPencilStrokePoints", NULL);
823         RNA_def_struct_sdna(srna, "bGPDstroke");
824         RNA_def_struct_ui_text(srna, "Grease Pencil Stroke Points", "Collection of grease pencil stroke points");
825
826         func = RNA_def_function(srna, "add", "rna_GPencil_stroke_point_add");
827         RNA_def_function_ui_description(func, "Add a new grease pencil stroke point");
828         parm = RNA_def_int(func, "count", 1, 0, INT_MAX, "Number", "Number of points to add to the stroke", 0, INT_MAX);
829         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
830         RNA_def_float(func, "pressure", 1.0f, 0.0f, 1.0f, "Pressure", "Pressure for newly created points", 0.0f, 1.0f);
831         RNA_def_float(func, "strength", 1.0f, 0.0f, 1.0f, "Strength", "Color intensity (alpha factor) for newly created points", 0.0f, 1.0f);
832
833         func = RNA_def_function(srna, "pop", "rna_GPencil_stroke_point_pop");
834         RNA_def_function_ui_description(func, "Remove a grease pencil stroke point");
835         RNA_def_function_flag(func, FUNC_USE_REPORTS);
836         RNA_def_int(func, "index", -1, INT_MIN, INT_MAX, "Index", "point index", INT_MIN, INT_MAX);
837 }
838
839 /* This information is read only and it can be used by add-ons */
840 static void rna_def_gpencil_triangle(BlenderRNA *brna)
841 {
842         StructRNA *srna;
843         PropertyRNA *prop;
844
845         srna = RNA_def_struct(brna, "GPencilTriangle", NULL);
846         RNA_def_struct_sdna(srna, "bGPDtriangle");
847         RNA_def_struct_ui_text(srna, "Triangle", "Triangulation data for Grease Pencil fills");
848
849         /* point v1 */
850         prop = RNA_def_property(srna, "v1", PROP_INT, PROP_NONE);
851         RNA_def_property_int_sdna(prop, NULL, "verts[0]");
852         RNA_def_property_ui_text(prop, "v1", "First triangle vertex index");
853         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
854
855         /* point v2 */
856         prop = RNA_def_property(srna, "v2", PROP_INT, PROP_NONE);
857         RNA_def_property_int_sdna(prop, NULL, "verts[1]");
858         RNA_def_property_ui_text(prop, "v2", "Second triangle vertex index");
859         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
860
861         /* point v3 */
862         prop = RNA_def_property(srna, "v3", PROP_INT, PROP_NONE);
863         RNA_def_property_int_sdna(prop, NULL, "verts[2]");
864         RNA_def_property_ui_text(prop, "v3", "Third triangle vertex index");
865         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
866
867         /* texture coord for point v1 */
868         prop = RNA_def_property(srna, "uv1", PROP_FLOAT, PROP_COORDS);
869         RNA_def_property_float_sdna(prop, NULL, "uv[0]");
870         RNA_def_property_array(prop, 2);
871         RNA_def_property_ui_text(prop, "uv1", "First triangle vertex texture coordinates");
872         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
873
874         /* texture coord for point v2 */
875         prop = RNA_def_property(srna, "uv2", PROP_FLOAT, PROP_COORDS);
876         RNA_def_property_float_sdna(prop, NULL, "uv[1]");
877         RNA_def_property_array(prop, 2);
878         RNA_def_property_ui_text(prop, "uv2", "Second triangle vertex texture coordinates");
879         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
880
881         /* texture coord for point v3 */
882         prop = RNA_def_property(srna, "uv3", PROP_FLOAT, PROP_COORDS);
883         RNA_def_property_float_sdna(prop, NULL, "uv[2]");
884         RNA_def_property_array(prop, 2);
885         RNA_def_property_ui_text(prop, "uv3", "Third triangle vertex texture coordinates");
886         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
887 }
888
889 static void rna_def_gpencil_mvert_group(BlenderRNA *brna)
890 {
891         StructRNA *srna;
892         PropertyRNA *prop;
893
894         srna = RNA_def_struct(brna, "GpencilVertexGroupElement", NULL);
895         RNA_def_struct_sdna(srna, "MDeformWeight");
896         RNA_def_struct_ui_text(srna, "Vertex Group Element", "Weight value of a vertex in a vertex group");
897         RNA_def_struct_ui_icon(srna, ICON_GROUP_VERTEX);
898
899         /* we can't point to actual group, it is in the object and so
900          * there is no unique group to point to, hence the index */
901         prop = RNA_def_property(srna, "group", PROP_INT, PROP_UNSIGNED);
902         RNA_def_property_int_sdna(prop, NULL, "def_nr");
903         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
904         RNA_def_property_ui_text(prop, "Group Index", "");
905         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
906
907         prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
908         RNA_def_property_range(prop, 0.0f, 1.0f);
909         RNA_def_property_ui_text(prop, "Weight", "Vertex Weight");
910         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
911 }
912
913 static void rna_def_gpencil_stroke(BlenderRNA *brna)
914 {
915         StructRNA *srna;
916         PropertyRNA *prop;
917
918         static const EnumPropertyItem stroke_display_mode_items[] = {
919                 {0, "SCREEN", 0, "Screen", "Stroke is in screen-space"},
920                 {GP_STROKE_3DSPACE, "3DSPACE", 0, "3D Space", "Stroke is in 3D-space"},
921                 {GP_STROKE_2DSPACE, "2DSPACE", 0, "2D Space", "Stroke is in 2D-space"},
922                 {GP_STROKE_2DIMAGE, "2DIMAGE", 0, "2D Image", "Stroke is in 2D-space (but with special 'image' scaling)"},
923                 {0, NULL, 0, NULL, NULL}
924         };
925
926         srna = RNA_def_struct(brna, "GPencilStroke", NULL);
927         RNA_def_struct_sdna(srna, "bGPDstroke");
928         RNA_def_struct_ui_text(srna, "Grease Pencil Stroke", "Freehand curve defining part of a sketch");
929
930         /* Points */
931         prop = RNA_def_property(srna, "points", PROP_COLLECTION, PROP_NONE);
932         RNA_def_property_collection_sdna(prop, NULL, "points", "totpoints");
933         RNA_def_property_struct_type(prop, "GPencilStrokePoint");
934         RNA_def_property_ui_text(prop, "Stroke Points", "Stroke data points");
935         rna_def_gpencil_stroke_points_api(brna, prop);
936
937         /* vertex groups */
938         prop = RNA_def_property(srna, "groups", PROP_COLLECTION, PROP_NONE);
939         RNA_def_property_collection_funcs(prop, "rna_GpencilVertex_groups_begin", "rna_iterator_array_next",
940                 "rna_iterator_array_end", "rna_iterator_array_get", NULL, NULL, NULL, NULL);
941         RNA_def_property_struct_type(prop, "GpencilVertexGroupElement");
942         RNA_def_property_ui_text(prop, "Groups", "Weights for the vertex groups this vertex is member of");
943
944         /* Triangles */
945         prop = RNA_def_property(srna, "triangles", PROP_COLLECTION, PROP_NONE);
946         RNA_def_property_collection_sdna(prop, NULL, "triangles", "tot_triangles");
947         RNA_def_property_struct_type(prop, "GPencilTriangle");
948         RNA_def_property_ui_text(prop, "Triangles", "Triangulation data for HQ fill");
949
950         /* Material Index */
951         prop = RNA_def_property(srna, "material_index", PROP_INT, PROP_NONE);
952         RNA_def_property_int_sdna(prop, NULL, "mat_nr");
953         RNA_def_property_ui_text(prop, "Material Index", "Index of material used in this stroke");
954         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
955
956         /* Settings */
957         prop = RNA_def_property(srna, "display_mode", PROP_ENUM, PROP_NONE);
958         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
959         RNA_def_property_enum_items(prop, stroke_display_mode_items);
960         RNA_def_property_ui_text(prop, "Draw Mode", "Coordinate space that stroke is in");
961         RNA_def_property_update(prop, 0, "rna_GPencil_update");
962
963         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
964         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STROKE_SELECT);
965         RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencil_stroke_select_set");
966         RNA_def_property_ui_text(prop, "Select", "Stroke is selected for viewport editing");
967         RNA_def_property_update(prop, 0, "rna_GPencil_update");
968
969         /* Cyclic: Draw a line from end to start point */
970         prop = RNA_def_property(srna, "draw_cyclic", PROP_BOOLEAN, PROP_NONE);
971         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STROKE_CYCLIC);
972         RNA_def_property_ui_text(prop, "Cyclic", "Enable cyclic drawing, closing the stroke");
973         RNA_def_property_update(prop, 0, "rna_GPencil_update");
974
975         /* No fill: The stroke never must fill area and must use fill color as stroke color (this is a special flag for fill brush) */
976         prop = RNA_def_property(srna, "is_nofill_stroke", PROP_BOOLEAN, PROP_NONE);
977         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STROKE_NOFILL);
978         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
979         RNA_def_property_ui_text(prop, "No Fill", "Special stroke to use as boundary for filling areas");
980         RNA_def_property_update(prop, 0, "rna_GPencil_update");
981
982         /* Line Thickness */
983         prop = RNA_def_property(srna, "line_width", PROP_INT, PROP_PIXEL);
984         RNA_def_property_int_sdna(prop, NULL, "thickness");
985         RNA_def_property_range(prop, 1, 1000);
986         RNA_def_property_ui_range(prop, 1, 10, 1, 0);
987         RNA_def_property_ui_text(prop, "Thickness", "Thickness of stroke (in pixels)");
988         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
989
990 }
991
992 static void rna_def_gpencil_strokes_api(BlenderRNA *brna, PropertyRNA *cprop)
993 {
994         StructRNA *srna;
995
996         FunctionRNA *func;
997         PropertyRNA *parm;
998
999         RNA_def_property_srna(cprop, "GPencilStrokes");
1000         srna = RNA_def_struct(brna, "GPencilStrokes", NULL);
1001         RNA_def_struct_sdna(srna, "bGPDframe");
1002         RNA_def_struct_ui_text(srna, "Grease Pencil Frames", "Collection of grease pencil stroke");
1003
1004         func = RNA_def_function(srna, "new", "rna_GPencil_stroke_new");
1005         RNA_def_function_ui_description(func, "Add a new grease pencil stroke");
1006         parm = RNA_def_pointer(func, "stroke", "GPencilStroke", "", "The newly created stroke");
1007         RNA_def_function_return(func, parm);
1008
1009         func = RNA_def_function(srna, "remove", "rna_GPencil_stroke_remove");
1010         RNA_def_function_ui_description(func, "Remove a grease pencil stroke");
1011         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1012         parm = RNA_def_pointer(func, "stroke", "GPencilStroke", "Stroke", "The stroke to remove");
1013         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1014         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1015
1016         func = RNA_def_function(srna, "update", "rna_GPencil_stroke_update");
1017         RNA_def_function_ui_description(func, "Update stroke geometry");
1018         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1019         parm = RNA_def_pointer(func, "stroke", "GPencilStroke", "Stroke", "The stroke to remove");
1020         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1021         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1022 }
1023
1024 static void rna_def_gpencil_frame(BlenderRNA *brna)
1025 {
1026         StructRNA *srna;
1027         PropertyRNA *prop;
1028
1029         FunctionRNA *func;
1030
1031         srna = RNA_def_struct(brna, "GPencilFrame", NULL);
1032         RNA_def_struct_sdna(srna, "bGPDframe");
1033         RNA_def_struct_ui_text(srna, "Grease Pencil Frame", "Collection of related sketches on a particular frame");
1034
1035         /* Strokes */
1036         prop = RNA_def_property(srna, "strokes", PROP_COLLECTION, PROP_NONE);
1037         RNA_def_property_collection_sdna(prop, NULL, "strokes", NULL);
1038         RNA_def_property_struct_type(prop, "GPencilStroke");
1039         RNA_def_property_ui_text(prop, "Strokes", "Freehand curves defining the sketch on this frame");
1040         rna_def_gpencil_strokes_api(brna, prop);
1041
1042         /* Frame Number */
1043         prop = RNA_def_property(srna, "frame_number", PROP_INT, PROP_NONE);
1044         RNA_def_property_int_sdna(prop, NULL, "framenum");
1045         /* XXX note: this cannot occur on the same frame as another sketch */
1046         RNA_def_property_range(prop, -MAXFRAME, MAXFRAME);
1047         RNA_def_property_ui_text(prop, "Frame Number", "The frame on which this sketch appears");
1048
1049         /* Flags */
1050         prop = RNA_def_property(srna, "is_edited", PROP_BOOLEAN, PROP_NONE);
1051         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_FRAME_PAINT); /* XXX should it be editable? */
1052         RNA_def_property_ui_text(prop, "Paint Lock", "Frame is being edited (painted on)");
1053
1054         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1055         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_FRAME_SELECT);
1056         RNA_def_property_ui_text(prop, "Select", "Frame is selected for editing in the Dope Sheet");
1057
1058
1059         /* API */
1060         func = RNA_def_function(srna, "clear", "rna_GPencil_frame_clear");
1061         RNA_def_function_ui_description(func, "Remove all the grease pencil frame data");
1062 }
1063
1064 static void rna_def_gpencil_frames_api(BlenderRNA *brna, PropertyRNA *cprop)
1065 {
1066         StructRNA *srna;
1067
1068         FunctionRNA *func;
1069         PropertyRNA *parm;
1070
1071         RNA_def_property_srna(cprop, "GPencilFrames");
1072         srna = RNA_def_struct(brna, "GPencilFrames", NULL);
1073         RNA_def_struct_sdna(srna, "bGPDlayer");
1074         RNA_def_struct_ui_text(srna, "Grease Pencil Frames", "Collection of grease pencil frames");
1075
1076         func = RNA_def_function(srna, "new", "rna_GPencil_frame_new");
1077         RNA_def_function_ui_description(func, "Add a new grease pencil frame");
1078         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1079         parm = RNA_def_int(func, "frame_number", 1, MINAFRAME, MAXFRAME, "Frame Number",
1080                            "The frame on which this sketch appears", MINAFRAME, MAXFRAME);
1081         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1082         parm = RNA_def_pointer(func, "frame", "GPencilFrame", "", "The newly created frame");
1083         RNA_def_function_return(func, parm);
1084
1085         func = RNA_def_function(srna, "remove", "rna_GPencil_frame_remove");
1086         RNA_def_function_ui_description(func, "Remove a grease pencil frame");
1087         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1088         parm = RNA_def_pointer(func, "frame", "GPencilFrame", "Frame", "The frame to remove");
1089         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1090         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1091
1092         func = RNA_def_function(srna, "copy", "rna_GPencil_frame_copy");
1093         RNA_def_function_ui_description(func, "Copy a grease pencil frame");
1094         parm = RNA_def_pointer(func, "source", "GPencilFrame", "Source", "The source frame");
1095         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1096         parm = RNA_def_pointer(func, "copy", "GPencilFrame", "", "The newly copied frame");
1097         RNA_def_function_return(func, parm);
1098 }
1099
1100 static void rna_def_gpencil_layer(BlenderRNA *brna)
1101 {
1102         StructRNA *srna;
1103         PropertyRNA *prop;
1104
1105         FunctionRNA *func;
1106         static const float default_onion_color_b[] = { 0.302f, 0.851f, 0.302f };
1107         static const float default_onion_color_a[] = { 0.250f, 0.1f, 1.0f };
1108
1109         srna = RNA_def_struct(brna, "GPencilLayer", NULL);
1110         RNA_def_struct_sdna(srna, "bGPDlayer");
1111         RNA_def_struct_ui_text(srna, "Grease Pencil Layer", "Collection of related sketches");
1112         RNA_def_struct_path_func(srna, "rna_GPencilLayer_path");
1113
1114         /* Name */
1115         prop = RNA_def_property(srna, "info", PROP_STRING, PROP_NONE);
1116         RNA_def_property_ui_text(prop, "Info", "Layer name");
1117         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilLayer_info_set");
1118         RNA_def_struct_name_property(srna, prop);
1119         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_RENAME, NULL);
1120
1121         /* Frames */
1122         prop = RNA_def_property(srna, "frames", PROP_COLLECTION, PROP_NONE);
1123         RNA_def_property_collection_sdna(prop, NULL, "frames", NULL);
1124         RNA_def_property_struct_type(prop, "GPencilFrame");
1125         RNA_def_property_ui_text(prop, "Frames", "Sketches for this layer on different frames");
1126         rna_def_gpencil_frames_api(brna, prop);
1127
1128         /* Active Frame */
1129         prop = RNA_def_property(srna, "active_frame", PROP_POINTER, PROP_NONE);
1130         RNA_def_property_pointer_sdna(prop, NULL, "actframe");
1131         RNA_def_property_ui_text(prop, "Active Frame", "Frame currently being displayed for this layer");
1132         RNA_def_property_editable_func(prop, "rna_GPencilLayer_active_frame_editable");
1133         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1134
1135
1136         /* Layer Opacity */
1137         prop = RNA_def_property(srna, "opacity", PROP_FLOAT, PROP_NONE);
1138         RNA_def_property_float_sdna(prop, NULL, "opacity");
1139         RNA_def_property_range(prop, 0.0, 1.0f);
1140         RNA_def_property_ui_text(prop, "Opacity", "Layer Opacity");
1141         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1142
1143
1144         /* Stroke Drawing Color (Annotations) */
1145         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
1146         RNA_def_property_array(prop, 3);
1147         RNA_def_property_range(prop, 0.0f, 1.0f);
1148         RNA_def_property_ui_text(prop, "Color", "Color for all strokes in this layer");
1149         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1150
1151         /* Line Thickness (Annotations) */
1152         prop = RNA_def_property(srna, "thickness", PROP_INT, PROP_PIXEL);
1153         RNA_def_property_int_sdna(prop, NULL, "thickness");
1154         RNA_def_property_range(prop, 1, 10);
1155         RNA_def_property_ui_text(prop, "Thickness", "Thickness of annotation strokes");
1156         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1157
1158
1159         /* Tint Color */
1160         prop = RNA_def_property(srna, "tint_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1161         RNA_def_property_float_sdna(prop, NULL, "tintcolor");
1162         RNA_def_property_array(prop, 3);
1163         RNA_def_property_range(prop, 0.0f, 1.0f);
1164         RNA_def_property_ui_text(prop, "Tint Color", "Color for tinting stroke colors");
1165         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1166
1167         /* Tint factor */
1168         prop = RNA_def_property(srna, "tint_factor", PROP_FLOAT, PROP_NONE);
1169         RNA_def_property_float_sdna(prop, NULL, "tintcolor[3]");
1170         RNA_def_property_range(prop, 0.0, 1.0f);
1171         RNA_def_property_ui_text(prop, "Tint Factor", "Factor of tinting color");
1172         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1173
1174         /* Line Thickness Change */
1175         prop = RNA_def_property(srna, "line_change", PROP_INT, PROP_PIXEL);
1176         RNA_def_property_int_sdna(prop, NULL, "line_change");
1177         RNA_def_property_range(prop, -300, 300);
1178         RNA_def_property_ui_range(prop, -100, 100, 1.0, 1);
1179         RNA_def_property_ui_text(prop, "Thickness Change", "Thickness change to apply to current strokes (in pixels)");
1180         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1181
1182
1183         /* Onion-Skinning */
1184         prop = RNA_def_property(srna, "use_onion_skinning", PROP_BOOLEAN, PROP_NONE);
1185         RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_LAYER_ONIONSKIN);
1186         RNA_def_property_ui_text(prop, "Onion Skinning", "Display onion skins before and after the current frame");
1187         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1188
1189         prop = RNA_def_property(srna, "use_annotation_onion_skinning", PROP_BOOLEAN, PROP_NONE);
1190         RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_LAYER_ONIONSKIN);
1191         RNA_def_property_ui_text(prop, "Onion Skinning",
1192                 "Display annotation onion skins before and after the current frame");
1193         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1194
1195         prop = RNA_def_property(srna, "annotation_onion_before_range", PROP_INT, PROP_NONE);
1196         RNA_def_property_int_sdna(prop, NULL, "gstep");
1197         RNA_def_property_range(prop, -1, 120);
1198         RNA_def_property_ui_text(prop, "Frames Before",
1199                 "Maximum number of frames to show before current frame");
1200         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1201
1202         prop = RNA_def_property(srna, "annotation_onion_after_range", PROP_INT, PROP_NONE);
1203         RNA_def_property_int_sdna(prop, NULL, "gstep_next");
1204         RNA_def_property_range(prop, -1, 120);
1205         RNA_def_property_ui_text(prop, "Frames After",
1206                 "Maximum number of frames to show after current frame");
1207         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1208
1209         prop = RNA_def_property(srna, "annotation_onion_before_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1210         RNA_def_property_float_sdna(prop, NULL, "gcolor_prev");
1211         RNA_def_property_array(prop, 3);
1212         RNA_def_property_range(prop, 0.0f, 1.0f);
1213         RNA_def_property_float_array_default(prop, default_onion_color_b);
1214         RNA_def_property_ui_text(prop, "Before Color", "Base color for ghosts before the active frame");
1215         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1216
1217         prop = RNA_def_property(srna, "annotation_onion_after_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1218         RNA_def_property_float_sdna(prop, NULL, "gcolor_next");
1219         RNA_def_property_array(prop, 3);
1220         RNA_def_property_range(prop, 0.0f, 1.0f);
1221         RNA_def_property_float_array_default(prop, default_onion_color_a);
1222         RNA_def_property_ui_text(prop, "After Color", "Base color for ghosts after the active frame");
1223         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1224
1225         /* pass index for compositing and modifiers */
1226         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_UNSIGNED);
1227         RNA_def_property_int_sdna(prop, NULL, "pass_index");
1228         RNA_def_property_ui_text(prop, "Pass Index", "Index number for the \"Layer Index\" pass");
1229         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1230
1231         prop = RNA_def_property(srna, "viewlayer_render", PROP_STRING, PROP_NONE);
1232         RNA_def_property_string_sdna(prop, NULL, "viewlayername");
1233         RNA_def_property_ui_text(prop, "ViewLayer",
1234                 "Only include Layer in this View Layer render output (leave blank to include always)");
1235
1236         /* blend mode */
1237         prop = RNA_def_property(srna, "blend_mode", PROP_ENUM, PROP_NONE);
1238         RNA_def_property_enum_sdna(prop, NULL, "blend_mode");
1239         RNA_def_property_enum_items(prop, rna_enum_layer_blend_modes_items);
1240         RNA_def_property_ui_text(prop, "Blend Mode", "Blend mode");
1241         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1242
1243         /* Flags */
1244         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1245         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_HIDE);
1246         RNA_def_property_ui_icon(prop, ICON_HIDE_OFF, -1);
1247         RNA_def_property_ui_text(prop, "Hide", "Set layer Visibility");
1248         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1249
1250         prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
1251         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_LOCKED);
1252         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
1253         RNA_def_property_ui_text(prop, "Locked", "Protect layer from further editing and/or frame changes");
1254         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1255
1256         prop = RNA_def_property(srna, "lock_frame", PROP_BOOLEAN, PROP_NONE);
1257         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_FRAMELOCK);
1258         RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
1259         RNA_def_property_ui_text(prop, "Frame Locked", "Lock current frame displayed by layer");
1260         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1261
1262         prop = RNA_def_property(srna, "lock_material", PROP_BOOLEAN, PROP_NONE);
1263         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GP_LAYER_UNLOCK_COLOR);
1264         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1265         RNA_def_property_ui_text(prop, "Lock Material", "Disable Material editing");
1266         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1267
1268         prop = RNA_def_property(srna, "clamp_layer", PROP_BOOLEAN, PROP_NONE);
1269         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_USE_MASK);
1270         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1271         RNA_def_property_ui_text(prop, "Clamp Layer",
1272                 "Clamp any pixel outside underlying layers drawing");
1273         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
1274
1275         /* exposed as layers.active */
1276 #if 0
1277         prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
1278         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_ACTIVE);
1279         RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencilLayer_active_set");
1280         RNA_def_property_ui_text(prop, "Active", "Set active layer for editing");
1281         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_SELECTED, NULL);
1282 #endif
1283
1284         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1285         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_SELECT);
1286         RNA_def_property_ui_text(prop, "Select", "Layer is selected for editing in the Dope Sheet");
1287         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_SELECTED, "rna_GPencil_update");
1288
1289         prop = RNA_def_property(srna, "show_points", PROP_BOOLEAN, PROP_NONE);
1290         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_DRAWDEBUG);
1291         RNA_def_property_ui_text(prop, "Show Points", "Draw the points which make up the strokes (for debugging purposes)");
1292         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1293
1294         /* In Front */
1295         prop = RNA_def_property(srna, "show_in_front", PROP_BOOLEAN, PROP_NONE);
1296         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GP_LAYER_NO_XRAY);
1297         RNA_def_property_ui_text(prop, "In Front", "Make the layer draw in front of objects");
1298         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1299
1300         /* Parent object */
1301         prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
1302         RNA_def_property_pointer_funcs(prop, NULL, "rna_GPencilLayer_parent_set", NULL, NULL);
1303         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
1304         RNA_def_property_ui_text(prop, "Parent", "Parent Object");
1305         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1306
1307         /* parent type */
1308         prop = RNA_def_property(srna, "parent_type", PROP_ENUM, PROP_NONE);
1309         RNA_def_property_enum_bitflag_sdna(prop, NULL, "partype");
1310         RNA_def_property_enum_items(prop, parent_type_items);
1311         RNA_def_property_enum_funcs(prop, NULL, "rna_GPencilLayer_parent_type_set", "rna_Object_parent_type_itemf");
1312         RNA_def_property_ui_text(prop, "Parent Type", "Type of parent relation");
1313         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1314
1315         /* parent bone */
1316         prop = RNA_def_property(srna, "parent_bone", PROP_STRING, PROP_NONE);
1317         RNA_def_property_string_sdna(prop, NULL, "parsubstr");
1318         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilLayer_parent_bone_set");
1319         RNA_def_property_ui_text(prop, "Parent Bone", "Name of parent bone in case of a bone parenting relation");
1320         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1321
1322         /* matrix */
1323         prop = RNA_def_property(srna, "matrix_inverse", PROP_FLOAT, PROP_MATRIX);
1324         RNA_def_property_float_sdna(prop, NULL, "inverse");
1325         RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
1326         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1327         RNA_def_property_ui_text(prop, "Inverse Matrix", "Parent inverse transformation matrix");
1328         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1329
1330         /* read only parented flag */
1331         prop = RNA_def_property(srna, "is_parented", PROP_BOOLEAN, PROP_NONE);
1332         RNA_def_property_boolean_funcs(prop, "rna_GPencilLayer_is_parented_get", NULL);
1333         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1334         RNA_def_property_ui_text(prop, "Is Parented", "True when the layer parent object is set");
1335
1336         /* Layers API */
1337         func = RNA_def_function(srna, "clear", "rna_GPencil_layer_clear");
1338         RNA_def_function_ui_description(func, "Remove all the grease pencil layer data");
1339 }
1340
1341 static void rna_def_gpencil_layers_api(BlenderRNA *brna, PropertyRNA *cprop)
1342 {
1343         StructRNA *srna;
1344         PropertyRNA *prop;
1345
1346         FunctionRNA *func;
1347         PropertyRNA *parm;
1348
1349         RNA_def_property_srna(cprop, "GreasePencilLayers");
1350         srna = RNA_def_struct(brna, "GreasePencilLayers", NULL);
1351         RNA_def_struct_sdna(srna, "bGPdata");
1352         RNA_def_struct_ui_text(srna, "Grease Pencil Layers", "Collection of grease pencil layers");
1353
1354         func = RNA_def_function(srna, "new", "rna_GPencil_layer_new");
1355         RNA_def_function_ui_description(func, "Add a new grease pencil layer");
1356         parm = RNA_def_string(func, "name", "GPencilLayer", MAX_NAME, "Name", "Name of the layer");
1357         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1358         RNA_def_boolean(func, "set_active", true, "Set Active", "Set the newly created layer to the active layer");
1359         parm = RNA_def_pointer(func, "layer", "GPencilLayer", "", "The newly created layer");
1360         RNA_def_function_return(func, parm);
1361
1362         func = RNA_def_function(srna, "remove", "rna_GPencil_layer_remove");
1363         RNA_def_function_ui_description(func, "Remove a grease pencil layer");
1364         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1365         parm = RNA_def_pointer(func, "layer", "GPencilLayer", "", "The layer to remove");
1366         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1367         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1368
1369         func = RNA_def_function(srna, "move", "rna_GPencil_layer_move");
1370         RNA_def_function_ui_description(func, "Move a grease pencil layer in the layer stack");
1371         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1372         parm = RNA_def_pointer(func, "layer", "GPencilLayer", "", "The layer to move");
1373         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1374         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1375         parm = RNA_def_enum(func, "type", rna_enum_gplayer_move_type_items, 1, "", "Direction of movement");
1376         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1377
1378         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1379         RNA_def_property_struct_type(prop, "GPencilLayer");
1380         RNA_def_property_pointer_funcs(prop, "rna_GPencil_active_layer_get", "rna_GPencil_active_layer_set", NULL, NULL);
1381         RNA_def_property_flag(prop, PROP_EDITABLE);
1382         RNA_def_property_ui_text(prop, "Active Layer", "Active grease pencil layer");
1383         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_SELECTED, NULL);
1384
1385         prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
1386         RNA_def_property_int_funcs(
1387                 prop,
1388                 "rna_GPencil_active_layer_index_get",
1389                 "rna_GPencil_active_layer_index_set",
1390                 "rna_GPencil_active_layer_index_range");
1391         RNA_def_property_ui_text(prop, "Active Layer Index", "Index of active grease pencil layer");
1392         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | NA_SELECTED, NULL);
1393
1394         /* Active Layer - As an enum (for selecting active layer for annotations) */
1395         prop = RNA_def_property(srna, "active_note", PROP_ENUM, PROP_NONE);
1396         RNA_def_property_enum_funcs(
1397                 prop,
1398                 "rna_GPencil_active_layer_index_get",
1399                 "rna_GPencil_active_layer_index_set",
1400                 "rna_GPencil_active_layer_itemf");
1401         RNA_def_property_enum_items(prop, DummyRNA_DEFAULT_items); /* purely dynamic, as it maps to user-data */
1402         RNA_def_property_ui_text(prop, "Active Note", "Note/Layer to add annotation strokes to");
1403         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1404 }
1405
1406 static void rna_def_gpencil_grid(BlenderRNA *brna)
1407 {
1408         StructRNA *srna;
1409         PropertyRNA *prop;
1410
1411         static const float default_grid_color[] = { 0.5f, 0.5f, 0.5f };
1412
1413         srna = RNA_def_struct(brna, "GreasePencilGrid", NULL);
1414         RNA_def_struct_sdna(srna, "bGPgrid");
1415         RNA_def_struct_nested(brna, srna, "GreasePencil");
1416
1417         RNA_def_struct_path_func(srna, "rna_GreasePencilGrid_path");
1418         RNA_def_struct_ui_text(srna, "Grid and Canvas Settings",
1419                                "Settings for grid and canvas in 3D viewport");
1420
1421         prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
1422         RNA_def_property_float_sdna(prop, NULL, "scale");
1423         RNA_def_property_range(prop, 0.01f, FLT_MAX);
1424         RNA_def_property_float_default(prop, 1.0f);
1425         RNA_def_property_ui_text(prop, "Grid Scale", "Grid scale");
1426         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1427
1428         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
1429         RNA_def_property_float_sdna(prop, NULL, "color");
1430         RNA_def_property_array(prop, 3);
1431         RNA_def_property_range(prop, 0.0f, 1.0f);
1432         RNA_def_property_float_array_default(prop, default_grid_color);
1433         RNA_def_property_ui_text(prop, "Grid Color", "Color for grid lines");
1434         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1435
1436         prop = RNA_def_property(srna, "lines", PROP_INT, PROP_NONE);
1437         RNA_def_property_int_sdna(prop, NULL, "lines");
1438         RNA_def_property_range(prop, 0, INT_MAX);
1439         RNA_def_property_int_default(prop, GP_DEFAULT_GRID_LINES);
1440         RNA_def_property_ui_text(prop, "Grid Subdivisions", "Number of subdivisions in each side of symmetry line");
1441         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1442
1443         prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_XYZ);
1444         RNA_def_property_float_sdna(prop, NULL, "offset");
1445         RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
1446         RNA_def_property_array(prop, 2);
1447         RNA_def_property_ui_text(prop, "Offset", "Offset of the canvas");
1448         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1449 }
1450
1451 static void rna_def_gpencil_data(BlenderRNA *brna)
1452 {
1453         StructRNA *srna;
1454         PropertyRNA *prop;
1455         FunctionRNA *func;
1456
1457         static float default_1[4] = { 0.6f, 0.6f, 0.6f, 0.5f };
1458         static float onion_dft1[3] = { 0.145098f, 0.419608f, 0.137255f }; /* green */
1459         static float onion_dft2[3] = { 0.125490f, 0.082353f, 0.529412f }; /* blue */
1460
1461         srna = RNA_def_struct(brna, "GreasePencil", "ID");
1462         RNA_def_struct_sdna(srna, "bGPdata");
1463         RNA_def_struct_ui_text(srna, "Grease Pencil", "Freehand annotation sketchbook");
1464         RNA_def_struct_ui_icon(srna, ICON_GREASEPENCIL);
1465
1466         /* Layers */
1467         prop = RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);
1468         RNA_def_property_collection_sdna(prop, NULL, "layers", NULL);
1469         RNA_def_property_struct_type(prop, "GPencilLayer");
1470         RNA_def_property_ui_text(prop, "Layers", "");
1471         rna_def_gpencil_layers_api(brna, prop);
1472
1473         /* Animation Data */
1474         rna_def_animdata_common(srna);
1475
1476         /* materials */
1477         prop = RNA_def_property(srna, "materials", PROP_COLLECTION, PROP_NONE);
1478         RNA_def_property_collection_sdna(prop, NULL, "mat", "totcol");
1479         RNA_def_property_struct_type(prop, "Material");
1480         RNA_def_property_ui_text(prop, "Materials", "");
1481         RNA_def_property_srna(prop, "IDMaterials"); /* see rna_ID.c */
1482         RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "rna_IDMaterials_assign_int");
1483
1484         /* xray modes */
1485         prop = RNA_def_property(srna, "xray_mode", PROP_ENUM, PROP_NONE);
1486         RNA_def_property_enum_sdna(prop, NULL, "xray_mode");
1487         RNA_def_property_enum_items(prop, rna_enum_gpencil_xraymodes_items);
1488         RNA_def_property_ui_text(prop, "Xray", "");
1489         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1490
1491         /* Flags */
1492         prop = RNA_def_property(srna, "use_stroke_edit_mode", PROP_BOOLEAN, PROP_NONE);
1493         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_EDITMODE);
1494         RNA_def_property_ui_text(prop, "Stroke Edit Mode", "Edit Grease Pencil strokes instead of viewport data");
1495         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");
1496
1497         prop = RNA_def_property(srna, "is_stroke_paint_mode", PROP_BOOLEAN, PROP_NONE);
1498         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_PAINTMODE);
1499         RNA_def_property_ui_text(prop, "Stroke Paint Mode", "Draw Grease Pencil strokes on click/drag");
1500         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1501         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");
1502
1503         prop = RNA_def_property(srna, "is_stroke_sculpt_mode", PROP_BOOLEAN, PROP_NONE);
1504         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_SCULPTMODE);
1505         RNA_def_property_ui_text(prop, "Stroke Sculpt Mode", "Sculpt Grease Pencil strokes instead of viewport data");
1506         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1507         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");
1508
1509         prop = RNA_def_property(srna, "is_stroke_weight_mode", PROP_BOOLEAN, PROP_NONE);
1510         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_WEIGHTMODE);
1511         RNA_def_property_ui_text(prop, "Stroke Weight Paint Mode", "Grease Pencil weight paint");
1512         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1513         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA | ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");
1514
1515         prop = RNA_def_property(srna, "use_onion_skinning", PROP_BOOLEAN, PROP_NONE);
1516         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_SHOW_ONIONSKINS);
1517         RNA_def_property_boolean_default(prop, true);
1518         RNA_def_property_ui_text(prop, "Onion Skins", "Show ghosts of the keyframes before and after the current frame");
1519         RNA_def_property_update(prop, NC_SCREEN | NC_SCENE | ND_TOOLSETTINGS | ND_DATA | NC_GPENCIL, "rna_GPencil_update");
1520
1521         prop = RNA_def_property(srna, "show_stroke_direction", PROP_BOOLEAN, PROP_NONE);
1522         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_SHOW_DIRECTION);
1523         RNA_def_property_ui_text(prop, "Show Direction", "Show stroke drawing direction with a bigger green dot (start) "
1524                                  "and smaller red dot (end) points");
1525         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1526
1527         prop = RNA_def_property(srna, "show_constant_thickness", PROP_BOOLEAN, PROP_NONE);
1528         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_KEEPTHICKNESS);
1529         RNA_def_property_ui_text(prop, "Keep Thickness", "Maintain the thickness of the stroke when the viewport zoom changes");
1530         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1531
1532         prop = RNA_def_property(srna, "pixel_factor", PROP_FLOAT, PROP_NONE);
1533         RNA_def_property_float_sdna(prop, NULL, "pixfactor");
1534         RNA_def_property_range(prop, 0.1f, 30.0f);
1535         RNA_def_property_ui_range(prop, 0.1f, 30.0f, 1, 2);
1536         RNA_def_property_ui_text(prop, "Scale", "Scale conversion factor for pixel size (use larger values for thicker lines)");
1537         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1538
1539         prop = RNA_def_property(srna, "use_multiedit", PROP_BOOLEAN, PROP_NONE);
1540         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_MULTIEDIT);
1541         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)");
1542         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1543
1544         prop = RNA_def_property(srna, "use_force_fill_recalc", PROP_BOOLEAN, PROP_NONE);
1545         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_FORCE_RECALC);
1546         RNA_def_property_ui_text(prop, "Force Fill Update", "Force recalc of fill data after use deformation modifiers (reduce FPS)");
1547         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1548
1549         prop = RNA_def_property(srna, "use_adaptative_uv", PROP_BOOLEAN, PROP_NONE);
1550         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_UV_ADAPTATIVE);
1551         RNA_def_property_ui_text(prop, "Adaptative UV", "Automatic UVs are calculated depending of the stroke size");
1552         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1553
1554         prop = RNA_def_property(srna, "use_autolock_layers", PROP_BOOLEAN, PROP_NONE);
1555         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_AUTOLOCK_LAYERS);
1556         RNA_def_property_ui_text(prop, "Autolock Layers",
1557                 "Lock automatically all layers except active one to avoid accidental changes");
1558         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_autolock");
1559
1560         prop = RNA_def_property(srna, "edit_line_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1561         RNA_def_property_float_sdna(prop, NULL, "line_color");
1562         RNA_def_property_array(prop, 4);
1563         RNA_def_property_range(prop, 0.0f, 1.0f);
1564         RNA_def_property_float_array_default(prop, default_1);
1565         RNA_def_property_ui_text(prop, "Edit Line Color", "Color for editing line");
1566         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1567
1568         /* onion skinning */
1569         prop = RNA_def_property(srna, "ghost_before_range", PROP_INT, PROP_NONE);
1570         RNA_def_property_int_sdna(prop, NULL, "gstep");
1571         RNA_def_property_range(prop, 0, 120);
1572         RNA_def_property_int_default(prop, 1);
1573         RNA_def_property_ui_text(prop, "Frames Before",
1574                 "Maximum number of frames to show before current frame "
1575                 "(0 = don't show any frames before current)");
1576         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1577
1578         prop = RNA_def_property(srna, "ghost_after_range", PROP_INT, PROP_NONE);
1579         RNA_def_property_int_sdna(prop, NULL, "gstep_next");
1580         RNA_def_property_range(prop, 0, 120);
1581         RNA_def_property_int_default(prop, 1);
1582         RNA_def_property_ui_text(prop, "Frames After",
1583                 "Maximum number of frames to show after current frame "
1584                 "(0 = don't show any frames after current)");
1585         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1586
1587         prop = RNA_def_property(srna, "use_ghost_custom_colors", PROP_BOOLEAN, PROP_NONE);
1588         RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_ONION_GHOST_PREVCOL | GP_ONION_GHOST_NEXTCOL);
1589         RNA_def_property_ui_text(prop, "Use Custom Ghost Colors", "Use custom colors for ghost frames");
1590         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1591
1592         prop = RNA_def_property(srna, "before_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1593         RNA_def_property_float_sdna(prop, NULL, "gcolor_prev");
1594         RNA_def_property_array(prop, 3);
1595         RNA_def_property_range(prop, 0.0f, 1.0f);
1596         RNA_def_property_float_array_default(prop, onion_dft1);
1597         RNA_def_property_ui_text(prop, "Before Color", "Base color for ghosts before the active frame");
1598         RNA_def_property_update(prop, NC_SCREEN | NC_SCENE | ND_TOOLSETTINGS | ND_DATA | NC_GPENCIL, "rna_GPencil_update");
1599
1600         prop = RNA_def_property(srna, "after_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1601         RNA_def_property_float_sdna(prop, NULL, "gcolor_next");
1602         RNA_def_property_array(prop, 3);
1603         RNA_def_property_range(prop, 0.0f, 1.0f);
1604         RNA_def_property_float_array_default(prop, onion_dft2);
1605         RNA_def_property_ui_text(prop, "After Color", "Base color for ghosts after the active frame");
1606         RNA_def_property_update(prop, NC_SCREEN | NC_SCENE | ND_TOOLSETTINGS | ND_DATA | NC_GPENCIL, "rna_GPencil_update");
1607
1608         prop = RNA_def_property(srna, "use_ghosts_always", PROP_BOOLEAN, PROP_NONE);
1609         RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_ONION_GHOST_ALWAYS);
1610         RNA_def_property_ui_text(prop, "Always Show Ghosts",
1611                 "Ghosts are shown in renders and animation playback. Useful for special effects (e.g. motion blur)");
1612         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1613
1614         prop = RNA_def_property(srna, "onion_mode", PROP_ENUM, PROP_NONE);
1615         RNA_def_property_enum_sdna(prop, NULL, "onion_mode");
1616         RNA_def_property_enum_items(prop, rna_enum_gpencil_onion_modes_items);
1617         RNA_def_property_ui_text(prop, "Mode", "Mode to display frames");
1618         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1619
1620         prop = RNA_def_property(srna, "use_onion_fade", PROP_BOOLEAN, PROP_NONE);
1621         RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_ONION_FADE);
1622         RNA_def_property_ui_text(prop, "Fade",
1623                 "Display onion keyframes with a fade in color transparency");
1624         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1625
1626         prop = RNA_def_property(srna, "use_onion_loop", PROP_BOOLEAN, PROP_NONE);
1627         RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_ONION_LOOP);
1628         RNA_def_property_ui_text(prop, "Loop",
1629                 "Display first onion keyframes using next frame color to show indication of loop start frame");
1630         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1631
1632         prop = RNA_def_property(srna, "onion_factor", PROP_FLOAT, PROP_NONE);
1633         RNA_def_property_float_sdna(prop, NULL, "onion_factor");
1634         RNA_def_property_float_default(prop, 0.5f);
1635         RNA_def_property_range(prop, 0.0, 1.0f);
1636         RNA_def_property_ui_text(prop, "Onion Opacity", "Change fade opacity of displayed onion frames");
1637         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1638
1639         prop = RNA_def_property(srna, "zdepth_offset", PROP_FLOAT, PROP_NONE);
1640         RNA_def_property_float_sdna(prop, NULL, "zdepth_offset");
1641         RNA_def_property_range(prop, 0.0f, 1.0f);
1642         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 5);
1643         RNA_def_property_ui_text(prop, "Surface Offset",
1644                 "Offset amount when drawing in surface mode");
1645         RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, "rna_GPencil_update");
1646
1647         /* Nested Structs */
1648         prop = RNA_def_property(srna, "grid", PROP_POINTER, PROP_NONE);
1649         RNA_def_property_flag(prop, PROP_NEVER_NULL);
1650         RNA_def_property_struct_type(prop, "GreasePencilGrid");
1651         RNA_def_property_ui_text(prop, "Grid Settings", "Settings for grid and canvas in the 3D viewport");
1652
1653         rna_def_gpencil_grid(brna);
1654
1655         /* API Functions */
1656         func = RNA_def_function(srna, "clear", "rna_GPencil_clear");
1657         RNA_def_function_ui_description(func, "Remove all the Grease Pencil data");
1658
1659         func = RNA_def_function(srna, "update", "rna_GPencil_update_data");
1660         RNA_def_function_ui_description(func, "Force internal data update");
1661 }
1662
1663 /* --- */
1664
1665 void RNA_def_gpencil(BlenderRNA *brna)
1666 {
1667         rna_def_gpencil_data(brna);
1668
1669         rna_def_gpencil_layer(brna);
1670         rna_def_gpencil_frame(brna);
1671
1672         rna_def_gpencil_stroke(brna);
1673         rna_def_gpencil_stroke_point(brna);
1674         rna_def_gpencil_triangle(brna);
1675
1676         rna_def_gpencil_mvert_group(brna);
1677 }
1678
1679 #endif