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