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