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