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