Defines: replace ELEM3-16 with ELEM(...), that can take varargs
[blender.git] / source / blender / editors / gpencil / gpencil_edit.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  * The Original Code is Copyright (C) 2008, Blender Foundation, Joshua Leung
19  * This is a new part of Blender
20  *
21  * Contributor(s): Joshua Leung
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file blender/editors/gpencil/gpencil_edit.c
27  *  \ingroup edgpencil
28  */
29
30 #include <stdio.h>
31 #include <string.h>
32 #include <stdlib.h>
33 #include <stddef.h>
34 #include <math.h>
35
36 #include "MEM_guardedalloc.h"
37
38 #include "BLI_math.h"
39 #include "BLI_blenlib.h"
40 #include "BLI_rand.h"
41 #include "BLI_utildefines.h"
42
43 #include "BLF_translation.h"
44
45 #include "DNA_anim_types.h"
46 #include "DNA_curve_types.h"
47 #include "DNA_object_types.h"
48 #include "DNA_node_types.h"
49 #include "DNA_scene_types.h"
50 #include "DNA_screen_types.h"
51 #include "DNA_space_types.h"
52 #include "DNA_view3d_types.h"
53 #include "DNA_gpencil_types.h"
54
55 #include "BKE_context.h"
56 #include "BKE_curve.h"
57 #include "BKE_depsgraph.h"
58 #include "BKE_fcurve.h"
59 #include "BKE_global.h"
60 #include "BKE_gpencil.h"
61 #include "BKE_library.h"
62 #include "BKE_object.h"
63 #include "BKE_report.h"
64 #include "BKE_scene.h"
65 #include "BKE_tracking.h"
66
67 #include "UI_interface.h"
68
69 #include "WM_api.h"
70 #include "WM_types.h"
71
72 #include "RNA_access.h"
73 #include "RNA_define.h"
74
75 #include "UI_view2d.h"
76
77 #include "ED_gpencil.h"
78 #include "ED_view3d.h"
79 #include "ED_clip.h"
80 #include "ED_keyframing.h"
81
82 #include "gpencil_intern.h"
83
84
85 /* ************************************************ */
86 /* Context Wrangling... */
87
88 /* Get pointer to active Grease Pencil datablock, and an RNA-pointer to trace back to whatever owns it */
89 bGPdata **ED_gpencil_data_get_pointers(const bContext *C, PointerRNA *ptr)
90 {
91         ID *screen_id = (ID *)CTX_wm_screen(C);
92         Scene *scene = CTX_data_scene(C);
93         ScrArea *sa = CTX_wm_area(C);
94
95         /* if there's an active area, check if the particular editor may
96          * have defined any special Grease Pencil context for editing...
97          */
98         if (sa) {
99                 switch (sa->spacetype) {
100                         case SPACE_VIEW3D: /* 3D-View */
101                         {
102                                 Object *ob = CTX_data_active_object(C);
103
104                                 /* TODO: we can include other data-types such as bones later if need be... */
105
106                                 /* just in case no active/selected object */
107                                 if (ob && (ob->flag & SELECT)) {
108                                         /* for now, as long as there's an object, default to using that in 3D-View */
109                                         if (ptr) RNA_id_pointer_create(&ob->id, ptr);
110                                         return &ob->gpd;
111                                 }
112                                 break;
113                         }
114                         case SPACE_NODE: /* Nodes Editor */
115                         {
116                                 SpaceNode *snode = (SpaceNode *)CTX_wm_space_data(C);
117
118                                 /* return the GP data for the active node block/node */
119                                 if (snode && snode->nodetree) {
120                                         /* for now, as long as there's an active node tree, default to using that in the Nodes Editor */
121                                         if (ptr) RNA_id_pointer_create(&snode->nodetree->id, ptr);
122                                         return &snode->nodetree->gpd;
123                                 }
124
125                                 /* even when there is no node-tree, don't allow this to flow to scene */
126                                 return NULL;
127                         }
128                         case SPACE_SEQ: /* Sequencer */
129                         {
130                                 SpaceSeq *sseq = (SpaceSeq *)CTX_wm_space_data(C);
131
132                                 /* for now, Grease Pencil data is associated with the space (actually preview region only) */
133                                 /* XXX our convention for everything else is to link to data though... */
134                                 if (ptr) RNA_pointer_create(screen_id, &RNA_SpaceSequenceEditor, sseq, ptr);
135                                 return &sseq->gpd;
136                         }
137                         case SPACE_IMAGE: /* Image/UV Editor */
138                         {
139                                 SpaceImage *sima = (SpaceImage *)CTX_wm_space_data(C);
140
141                                 /* for now, Grease Pencil data is associated with the space... */
142                                 /* XXX our convention for everything else is to link to data though... */
143                                 if (ptr) RNA_pointer_create(screen_id, &RNA_SpaceImageEditor, sima, ptr);
144                                 return &sima->gpd;
145                         }
146                         case SPACE_CLIP: /* Nodes Editor */
147                         {
148                                 SpaceClip *sc = (SpaceClip *)CTX_wm_space_data(C);
149                                 MovieClip *clip = ED_space_clip_get_clip(sc);
150
151                                 if (clip) {
152                                         if (sc->gpencil_src == SC_GPENCIL_SRC_TRACK) {
153                                                 MovieTrackingTrack *track = BKE_tracking_track_get_active(&clip->tracking);
154
155                                                 if (!track)
156                                                         return NULL;
157
158                                                 if (ptr)
159                                                         RNA_pointer_create(&clip->id, &RNA_MovieTrackingTrack, track, ptr);
160
161                                                 return &track->gpd;
162                                         }
163                                         else {
164                                                 if (ptr)
165                                                         RNA_id_pointer_create(&clip->id, ptr);
166
167                                                 return &clip->gpd;
168                                         }
169                                 }
170                                 break;
171                         }
172                         default: /* unsupported space */
173                                 return NULL;
174                 }
175         }
176
177         /* just fall back on the scene's GP data */
178         if (ptr) RNA_id_pointer_create((ID *)scene, ptr);
179         return (scene) ? &scene->gpd : NULL;
180 }
181
182 /* Get the active Grease Pencil datablock */
183 bGPdata *ED_gpencil_data_get_active(const bContext *C)
184 {
185         bGPdata **gpd_ptr = ED_gpencil_data_get_pointers(C, NULL);
186         return (gpd_ptr) ? *(gpd_ptr) : NULL;
187 }
188
189 /* needed for offscreen rendering */
190 bGPdata *ED_gpencil_data_get_active_v3d(Scene *scene)
191 {
192         Base *base = scene->basact;
193         bGPdata *gpd = NULL;
194         /* We have to make sure active object is actually visible and selected, else we must use default scene gpd,
195          * to be consistent with ED_gpencil_data_get_active's behavior.
196          */
197         if (base && (scene->lay & base->lay) && (base->object->flag & SELECT)) {
198                 gpd = base->object->gpd;
199         }
200         return gpd ? gpd : scene->gpd;
201 }
202
203 /* ************************************************ */
204 /* Panel Operators */
205
206 /* poll callback for adding data/layers - special */
207 static int gp_add_poll(bContext *C)
208 {
209         /* the base line we have is that we have somewhere to add Grease Pencil data */
210         return ED_gpencil_data_get_pointers(C, NULL) != NULL;
211 }
212
213 /* ******************* Add New Data ************************ */
214
215 /* add new datablock - wrapper around API */
216 static int gp_data_add_exec(bContext *C, wmOperator *op)
217 {
218         bGPdata **gpd_ptr = ED_gpencil_data_get_pointers(C, NULL);
219
220         if (gpd_ptr == NULL) {
221                 BKE_report(op->reports, RPT_ERROR, "Nowhere for grease pencil data to go");
222                 return OPERATOR_CANCELLED;
223         }
224         else {
225                 /* decrement user count and add new datablock */
226                 bGPdata *gpd = (*gpd_ptr);
227
228                 id_us_min(&gpd->id);
229                 *gpd_ptr = gpencil_data_addnew(DATA_("GPencil"));
230         }
231
232         /* notifiers */
233         WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
234
235         return OPERATOR_FINISHED;
236 }
237
238 void GPENCIL_OT_data_add(wmOperatorType *ot)
239 {
240         /* identifiers */
241         ot->name = "Grease Pencil Add New";
242         ot->idname = "GPENCIL_OT_data_add";
243         ot->description = "Add new Grease Pencil datablock";
244         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
245
246         /* callbacks */
247         ot->exec = gp_data_add_exec;
248         ot->poll = gp_add_poll;
249 }
250
251 /* ******************* Unlink Data ************************ */
252
253 /* poll callback for adding data/layers - special */
254 static int gp_data_unlink_poll(bContext *C)
255 {
256         bGPdata **gpd_ptr = ED_gpencil_data_get_pointers(C, NULL);
257
258         /* if we have access to some active data, make sure there's a datablock before enabling this */
259         return (gpd_ptr && *gpd_ptr);
260 }
261
262
263 /* unlink datablock - wrapper around API */
264 static int gp_data_unlink_exec(bContext *C, wmOperator *op)
265 {
266         bGPdata **gpd_ptr = ED_gpencil_data_get_pointers(C, NULL);
267
268         if (gpd_ptr == NULL) {
269                 BKE_report(op->reports, RPT_ERROR, "Nowhere for grease pencil data to go");
270                 return OPERATOR_CANCELLED;
271         }
272         else {
273                 /* just unlink datablock now, decreasing its user count */
274                 bGPdata *gpd = (*gpd_ptr);
275
276                 id_us_min(&gpd->id);
277                 *gpd_ptr = NULL;
278         }
279
280         /* notifiers */
281         WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL); 
282
283         return OPERATOR_FINISHED;
284 }
285
286 void GPENCIL_OT_data_unlink(wmOperatorType *ot)
287 {
288         /* identifiers */
289         ot->name = "Grease Pencil Unlink";
290         ot->idname = "GPENCIL_OT_data_unlink";
291         ot->description = "Unlink active Grease Pencil datablock";
292         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
293
294         /* callbacks */
295         ot->exec = gp_data_unlink_exec;
296         ot->poll = gp_data_unlink_poll;
297 }
298
299 /* ******************* Add New Layer ************************ */
300
301 /* add new layer - wrapper around API */
302 static int gp_layer_add_exec(bContext *C, wmOperator *op)
303 {
304         bGPdata **gpd_ptr = ED_gpencil_data_get_pointers(C, NULL);
305
306         /* if there's no existing Grease-Pencil data there, add some */
307         if (gpd_ptr == NULL) {
308                 BKE_report(op->reports, RPT_ERROR, "Nowhere for grease pencil data to go");
309                 return OPERATOR_CANCELLED;
310         }
311         if (*gpd_ptr == NULL)
312                 *gpd_ptr = gpencil_data_addnew(DATA_("GPencil"));
313
314         /* add new layer now */
315         gpencil_layer_addnew(*gpd_ptr, DATA_("GP_Layer"), 1);
316
317         /* notifiers */
318         WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
319
320         return OPERATOR_FINISHED;
321 }
322
323 void GPENCIL_OT_layer_add(wmOperatorType *ot)
324 {
325         /* identifiers */
326         ot->name = "Add New Layer";
327         ot->idname = "GPENCIL_OT_layer_add";
328         ot->description = "Add new Grease Pencil layer for the active Grease Pencil datablock";
329         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
330
331         /* callbacks */
332         ot->exec = gp_layer_add_exec;
333         ot->poll = gp_add_poll;
334 }
335
336 /* ******************* Delete Active Frame ************************ */
337
338 static int gp_actframe_delete_poll(bContext *C)
339 {
340         bGPdata *gpd = ED_gpencil_data_get_active(C);
341         bGPDlayer *gpl = gpencil_layer_getactive(gpd);
342
343         /* only if there's an active layer with an active frame */
344         return (gpl && gpl->actframe);
345 }
346
347 /* delete active frame - wrapper around API calls */
348 static int gp_actframe_delete_exec(bContext *C, wmOperator *op)
349 {
350         Scene *scene = CTX_data_scene(C);
351         bGPdata *gpd = ED_gpencil_data_get_active(C);
352         bGPDlayer *gpl = gpencil_layer_getactive(gpd);
353         bGPDframe *gpf = gpencil_layer_getframe(gpl, CFRA, 0);
354
355         /* if there's no existing Grease-Pencil data there, add some */
356         if (gpd == NULL) {
357                 BKE_report(op->reports, RPT_ERROR, "No grease pencil data");
358                 return OPERATOR_CANCELLED;
359         }
360         if (ELEM(NULL, gpl, gpf)) {
361                 BKE_report(op->reports, RPT_ERROR, "No active frame to delete");
362                 return OPERATOR_CANCELLED;
363         }
364
365         /* delete it... */
366         gpencil_layer_delframe(gpl, gpf);
367
368         /* notifiers */
369         WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL);
370
371         return OPERATOR_FINISHED;
372 }
373
374 void GPENCIL_OT_active_frame_delete(wmOperatorType *ot)
375 {
376         /* identifiers */
377         ot->name = "Delete Active Frame";
378         ot->idname = "GPENCIL_OT_active_frame_delete";
379         ot->description = "Delete the active frame for the active Grease Pencil datablock";
380         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
381
382         /* callbacks */
383         ot->exec = gp_actframe_delete_exec;
384         ot->poll = gp_actframe_delete_poll;
385 }
386
387 /* ************************************************ */
388 /* Grease Pencil to Data Operator */
389
390 /* defines for possible modes */
391 enum {
392         GP_STROKECONVERT_PATH = 1,
393         GP_STROKECONVERT_CURVE,
394         GP_STROKECONVERT_POLY,
395 };
396
397 /* Defines for possible timing modes */
398 enum {
399         GP_STROKECONVERT_TIMING_NONE = 1,
400         GP_STROKECONVERT_TIMING_LINEAR = 2,
401         GP_STROKECONVERT_TIMING_FULL = 3,
402         GP_STROKECONVERT_TIMING_CUSTOMGAP = 4,
403 };
404
405 /* RNA enum define */
406 static EnumPropertyItem prop_gpencil_convertmodes[] = {
407         {GP_STROKECONVERT_PATH, "PATH", 0, "Path", ""},
408         {GP_STROKECONVERT_CURVE, "CURVE", 0, "Bezier Curve", ""},
409         {GP_STROKECONVERT_POLY, "POLY", 0, "Polygon Curve", ""},
410         {0, NULL, 0, NULL, NULL}
411 };
412
413 static EnumPropertyItem prop_gpencil_convert_timingmodes_restricted[] = {
414         {GP_STROKECONVERT_TIMING_NONE, "NONE", 0, "No Timing", "Ignore timing"},
415         {GP_STROKECONVERT_TIMING_LINEAR, "LINEAR", 0, "Linear", "Simple linear timing"},
416         {0, NULL, 0, NULL, NULL},
417 };
418
419 static EnumPropertyItem prop_gpencil_convert_timingmodes[] = {
420         {GP_STROKECONVERT_TIMING_NONE, "NONE", 0, "No Timing", "Ignore timing"},
421         {GP_STROKECONVERT_TIMING_LINEAR, "LINEAR", 0, "Linear", "Simple linear timing"},
422         {GP_STROKECONVERT_TIMING_FULL, "FULL", 0, "Original", "Use the original timing, gaps included"},
423         {GP_STROKECONVERT_TIMING_CUSTOMGAP, "CUSTOMGAP", 0, "Custom Gaps",
424                                             "Use the original timing, but with custom gap lengths (in frames)"},
425         {0, NULL, 0, NULL, NULL},
426 };
427
428 static EnumPropertyItem *rna_GPConvert_mode_items(bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop),
429                                                   bool *UNUSED(r_free))
430 {
431         if (RNA_boolean_get(ptr, "use_timing_data")) {
432                 return prop_gpencil_convert_timingmodes;
433         }
434         return prop_gpencil_convert_timingmodes_restricted;
435 }
436
437 /* --- */
438
439 /* convert the coordinates from the given stroke point into 3d-coordinates 
440  *      - assumes that the active space is the 3D-View
441  */
442 static void gp_strokepoint_convertcoords(bContext *C, bGPDstroke *gps, bGPDspoint *pt, float p3d[3], rctf *subrect)
443 {
444         Scene *scene = CTX_data_scene(C);
445         View3D *v3d = CTX_wm_view3d(C);
446         ARegion *ar = CTX_wm_region(C);
447
448         if (gps->flag & GP_STROKE_3DSPACE) {
449                 /* directly use 3d-coordinates */
450                 copy_v3_v3(p3d, &pt->x);
451         }
452         else {
453                 const float *fp = ED_view3d_cursor3d_get(scene, v3d);
454                 float mvalf[2];
455
456                 /* get screen coordinate */
457                 if (gps->flag & GP_STROKE_2DSPACE) {
458                         View2D *v2d = &ar->v2d;
459                         UI_view2d_view_to_region_fl(v2d, pt->x, pt->y, &mvalf[0], &mvalf[1]);
460                 }
461                 else {
462                         if (subrect) {
463                                 mvalf[0] = (((float)pt->x / 100.0f) * BLI_rctf_size_x(subrect)) + subrect->xmin;
464                                 mvalf[1] = (((float)pt->y / 100.0f) * BLI_rctf_size_y(subrect)) + subrect->ymin;
465                         }
466                         else {
467                                 mvalf[0] = (float)pt->x / 100.0f * ar->winx;
468                                 mvalf[1] = (float)pt->y / 100.0f * ar->winy;
469                         }
470                 }
471
472                 ED_view3d_win_to_3d(ar, fp, mvalf, p3d);
473         }
474 }
475
476 /* --- */
477
478 /* temp struct for gp_stroke_path_animation() */
479 typedef struct tGpTimingData {
480         /* Data set from operator settings */
481         int mode;
482         int frame_range; /* Number of frames evaluated for path animation */
483         int start_frame, end_frame;
484         bool realtime; /* Will overwrite end_frame in case of Original or CustomGap timing... */
485         float gap_duration, gap_randomness; /* To be used with CustomGap mode*/
486         int seed;
487
488         /* Data set from points, used to compute final timing FCurve */
489         int num_points, cur_point;
490
491         /* Distances */
492         float *dists;
493         float tot_dist;
494
495         /* Times */
496         float *times; /* Note: Gap times will be negative! */
497         float tot_time, gap_tot_time;
498         double inittime;
499
500         /* Only used during creation of dists & times lists. */
501         float offset_time;
502 } tGpTimingData;
503
504 /* Init point buffers for timing data.
505  * Note this assumes we only grow those arrays!
506  */
507 static void gp_timing_data_set_nbr(tGpTimingData *gtd, const int nbr)
508 {
509         float *tmp;
510
511         BLI_assert(nbr > gtd->num_points);
512
513         /* distances */
514         tmp = gtd->dists;
515         gtd->dists = MEM_callocN(sizeof(float) * nbr, __func__);
516         if (tmp) {
517                 memcpy(gtd->dists, tmp, sizeof(float) * gtd->num_points);
518                 MEM_freeN(tmp);
519         }
520
521         /* times */
522         tmp = gtd->times;
523         gtd->times = MEM_callocN(sizeof(float) * nbr, __func__);
524         if (tmp) {
525                 memcpy(gtd->times, tmp, sizeof(float) * gtd->num_points);
526                 MEM_freeN(tmp);
527         }
528
529         gtd->num_points = nbr;
530 }
531
532 /* add stroke point to timing buffers */
533 static void gp_timing_data_add_point(tGpTimingData *gtd, const double stroke_inittime, const float time,
534                                      const float delta_dist)
535 {
536         float delta_time = 0.0f;
537         const int cur_point = gtd->cur_point;
538
539         if (!cur_point) {
540                 /* Special case, first point, if time is not 0.0f we have to compensate! */
541                 gtd->offset_time = -time;
542                 gtd->times[cur_point] = 0.0f;
543         }
544         else if (time < 0.0f) {
545                 /* This is a gap, negative value! */
546                 gtd->times[cur_point] = -(((float)(stroke_inittime - gtd->inittime)) + time + gtd->offset_time);
547                 delta_time = -gtd->times[cur_point] - gtd->times[cur_point - 1];
548
549                 gtd->gap_tot_time += delta_time;
550         }
551         else {
552                 gtd->times[cur_point] = (((float)(stroke_inittime - gtd->inittime)) + time + gtd->offset_time);
553                 delta_time = gtd->times[cur_point] - fabsf(gtd->times[cur_point - 1]);
554         }
555
556         gtd->tot_time += delta_time;
557         gtd->tot_dist += delta_dist;
558         gtd->dists[cur_point] = gtd->tot_dist;
559
560         gtd->cur_point++;
561 }
562
563 /* In frames! Binary search for FCurve keys have a threshold of 0.01, so we can't set
564  * arbitrarily close points - this is esp. important with NoGaps mode!
565  */
566 #define MIN_TIME_DELTA 0.02f
567
568 /* Loop over next points to find the end of the stroke, and compute */
569 static int gp_find_end_of_stroke_idx(tGpTimingData *gtd, RNG *rng, const int idx, const int nbr_gaps,
570                                      int *nbr_done_gaps, const float tot_gaps_time, const float delta_time,
571                                      float *next_delta_time)
572 {
573         int j;
574
575         for (j = idx + 1; j < gtd->num_points; j++) {
576                 if (gtd->times[j] < 0) {
577                         gtd->times[j] = -gtd->times[j];
578                         if (gtd->mode == GP_STROKECONVERT_TIMING_CUSTOMGAP) {
579                                 /* In this mode, gap time between this stroke and the next should be 0 currently...
580                                  * So we have to compute its final duration!
581                                  */
582                                 if (gtd->gap_randomness > 0.0f) {
583                                         /* We want gaps that are in gtd->gap_duration +/- gtd->gap_randomness range,
584                                          * and which sum to exactly tot_gaps_time...
585                                          */
586                                         int rem_gaps = nbr_gaps - (*nbr_done_gaps);
587                                         if (rem_gaps < 2) {
588                                                 /* Last gap, just give remaining time! */
589                                                 *next_delta_time = tot_gaps_time;
590                                         }
591                                         else {
592                                                 float delta, min, max;
593
594                                                 /* This code ensures that if the first gaps have been shorter than average gap_duration,
595                                                  * next gaps will tend to be longer (i.e. try to recover the lateness), and vice-versa!
596                                                  */
597                                                 delta = delta_time - (gtd->gap_duration * (*nbr_done_gaps));
598
599                                                 /* Clamp min between [-gap_randomness, 0.0], with lower delta giving higher min */
600                                                 min = -gtd->gap_randomness - delta;
601                                                 CLAMP(min, -gtd->gap_randomness, 0.0f);
602
603                                                 /* Clamp max between [0.0, gap_randomness], with lower delta giving higher max */
604                                                 max = gtd->gap_randomness - delta;
605                                                 CLAMP(max, 0.0f, gtd->gap_randomness);
606                                                 *next_delta_time += gtd->gap_duration + (BLI_rng_get_float(rng) * (max - min)) + min;
607                                         }
608                                 }
609                                 else {
610                                         *next_delta_time += gtd->gap_duration;
611                                 }
612                         }
613                         (*nbr_done_gaps)++;
614                         break;
615                 }
616         }
617
618         return j - 1;
619 }
620
621 static void gp_stroke_path_animation_preprocess_gaps(tGpTimingData *gtd, RNG *rng, int *nbr_gaps, float *tot_gaps_time)
622 {
623         int i;
624         float delta_time = 0.0f;
625
626         for (i = 0; i < gtd->num_points; i++) {
627                 if (gtd->times[i] < 0 && i) {
628                         (*nbr_gaps)++;
629                         gtd->times[i] = -gtd->times[i] - delta_time;
630                         delta_time += gtd->times[i] - gtd->times[i - 1];
631                         gtd->times[i] = -gtd->times[i - 1]; /* Temp marker, values *have* to be different! */
632                 }
633                 else {
634                         gtd->times[i] -= delta_time;
635                 }
636         }
637         gtd->tot_time -= delta_time;
638
639         *tot_gaps_time = (float)(*nbr_gaps) * gtd->gap_duration;
640         gtd->tot_time += *tot_gaps_time;
641         if (G.debug & G_DEBUG) {
642                 printf("%f, %f, %f, %d\n", gtd->tot_time, delta_time, *tot_gaps_time, *nbr_gaps);
643         }
644         if (gtd->gap_randomness > 0.0f) {
645                 BLI_rng_srandom(rng, gtd->seed);
646         }
647 }
648
649 static void gp_stroke_path_animation_add_keyframes(ReportList *reports, PointerRNA ptr, PropertyRNA *prop, FCurve *fcu,
650                                                    Curve *cu, tGpTimingData *gtd, RNG *rng, const float time_range,
651                                                    const int nbr_gaps, const float tot_gaps_time)
652 {
653         /* Use actual recorded timing! */
654         const float time_start = (float)gtd->start_frame;
655
656         float last_valid_time = 0.0f;
657         int end_stroke_idx = -1, start_stroke_idx = 0;
658         float end_stroke_time = 0.0f;
659
660         /* CustomGaps specific */
661         float delta_time = 0.0f, next_delta_time = 0.0f;
662         int nbr_done_gaps = 0;
663
664         int i;
665         float cfra;
666
667         /* This is a bit tricky, as:
668          * - We can't add arbitrarily close points on FCurve (in time).
669          * - We *must* have all "caps" points of all strokes in FCurve, as much as possible!
670          */
671         for (i = 0; i < gtd->num_points; i++) {
672                 /* If new stroke... */
673                 if (i > end_stroke_idx) {
674                         start_stroke_idx = i;
675                         delta_time = next_delta_time;
676                         /* find end of that new stroke */
677                         end_stroke_idx = gp_find_end_of_stroke_idx(gtd, rng, i, nbr_gaps, &nbr_done_gaps,
678                                                                    tot_gaps_time, delta_time, &next_delta_time);
679                         /* This one should *never* be negative! */
680                         end_stroke_time = time_start + ((gtd->times[end_stroke_idx] + delta_time) / gtd->tot_time * time_range);
681                 }
682
683                 /* Simple proportional stuff... */
684                 cu->ctime = gtd->dists[i] / gtd->tot_dist * cu->pathlen;
685                 cfra = time_start + ((gtd->times[i] + delta_time) / gtd->tot_time * time_range);
686
687                 /* And now, the checks about timing... */
688                 if (i == start_stroke_idx) {
689                         /* If first point of a stroke, be sure it's enough ahead of last valid keyframe, and
690                          * that the end point of the stroke is far enough!
691                          * In case it is not, we keep the end point...
692                          * Note that with CustomGaps mode, this is here we set the actual gap timing!
693                          */
694                         if ((end_stroke_time - last_valid_time) > MIN_TIME_DELTA * 2) {
695                                 if ((cfra - last_valid_time) < MIN_TIME_DELTA) {
696                                         cfra = last_valid_time + MIN_TIME_DELTA;
697                                 }
698                                 insert_keyframe_direct(reports, ptr, prop, fcu, cfra, INSERTKEY_FAST);
699                                 last_valid_time = cfra;
700                         }
701                         else if (G.debug & G_DEBUG) {
702                                 printf("\t Skipping start point %d, too close from end point %d\n", i, end_stroke_idx);
703                         }
704                 }
705                 else if (i == end_stroke_idx) {
706                         /* Always try to insert end point of a curve (should be safe enough, anyway...) */
707                         if ((cfra - last_valid_time) < MIN_TIME_DELTA) {
708                                 cfra = last_valid_time + MIN_TIME_DELTA;
709                         }
710                         insert_keyframe_direct(reports, ptr, prop, fcu, cfra, INSERTKEY_FAST);
711                         last_valid_time = cfra;
712                 }
713                 else {
714                         /* Else ("middle" point), we only insert it if it's far enough from last keyframe,
715                          * and also far enough from (not yet added!) end_stroke keyframe!
716                          */
717                         if ((cfra - last_valid_time) > MIN_TIME_DELTA && (end_stroke_time - cfra) > MIN_TIME_DELTA) {
718                                 insert_keyframe_direct(reports, ptr, prop, fcu, cfra, INSERTKEY_FAST);
719                                 last_valid_time = cfra;
720                         }
721                         else if (G.debug & G_DEBUG) {
722                                 printf("\t Skipping \"middle\" point %d, too close from last added point or end point %d\n",
723                                        i, end_stroke_idx);
724                         }
725                 }
726         }
727 }
728
729 static void gp_stroke_path_animation(bContext *C, ReportList *reports, Curve *cu, tGpTimingData *gtd)
730 {
731         Scene *scene = CTX_data_scene(C);
732         bAction *act;
733         FCurve *fcu;
734         PointerRNA ptr;
735         PropertyRNA *prop = NULL;
736         int nbr_gaps = 0, i;
737
738         if (gtd->mode == GP_STROKECONVERT_TIMING_NONE)
739                 return;
740
741         /* gap_duration and gap_randomness are in frames, but we need seconds!!! */
742         gtd->gap_duration = FRA2TIME(gtd->gap_duration);
743         gtd->gap_randomness = FRA2TIME(gtd->gap_randomness);
744
745         /* Enable path! */
746         cu->flag |= CU_PATH;
747         cu->pathlen = gtd->frame_range;
748
749         /* Get RNA pointer to read/write path time values */
750         RNA_id_pointer_create((ID *)cu, &ptr);
751         prop = RNA_struct_find_property(&ptr, "eval_time");
752
753         /* Ensure we have an F-Curve to add keyframes to */
754         act = verify_adt_action((ID *)cu, true);
755         fcu = verify_fcurve(act, NULL, &ptr, "eval_time", 0, true);
756
757         if (G.debug & G_DEBUG) {
758                 printf("%s: tot len: %f\t\ttot time: %f\n", __func__, gtd->tot_dist, gtd->tot_time);
759                 for (i = 0; i < gtd->num_points; i++) {
760                         printf("\tpoint %d:\t\tlen: %f\t\ttime: %f\n", i, gtd->dists[i], gtd->times[i]);
761                 }
762         }
763
764         if (gtd->mode == GP_STROKECONVERT_TIMING_LINEAR) {
765                 float cfra;
766
767                 /* Linear extrapolation! */
768                 fcu->extend = FCURVE_EXTRAPOLATE_LINEAR;
769
770                 cu->ctime = 0.0f;
771                 cfra = (float)gtd->start_frame;
772                 insert_keyframe_direct(reports, ptr, prop, fcu, cfra, INSERTKEY_FAST);
773
774                 cu->ctime = cu->pathlen;
775                 if (gtd->realtime) {
776                         cfra += (float)TIME2FRA(gtd->tot_time); /* Seconds to frames */
777                 }
778                 else {
779                         cfra = (float)gtd->end_frame;
780                 }
781                 insert_keyframe_direct(reports, ptr, prop, fcu, cfra, INSERTKEY_FAST);
782         }
783         else {
784                 /* Use actual recorded timing! */
785                 RNG *rng = BLI_rng_new(0);
786                 float time_range;
787
788                 /* CustomGaps specific */
789                 float tot_gaps_time = 0.0f;
790
791                 /* Pre-process gaps, in case we don't want to keep their original timing */
792                 if (gtd->mode == GP_STROKECONVERT_TIMING_CUSTOMGAP) {
793                         gp_stroke_path_animation_preprocess_gaps(gtd, rng, &nbr_gaps, &tot_gaps_time);
794                 }
795
796                 if (gtd->realtime) {
797                         time_range = (float)TIME2FRA(gtd->tot_time); /* Seconds to frames */
798                 }
799                 else {
800                         time_range = (float)(gtd->end_frame - gtd->start_frame);
801                 }
802
803                 if (G.debug & G_DEBUG) {
804                         printf("GP Stroke Path Conversion: Starting keying!\n");
805                 }
806
807                 gp_stroke_path_animation_add_keyframes(reports, ptr, prop, fcu, cu, gtd, rng, time_range,
808                                                        nbr_gaps, tot_gaps_time);
809
810                 BLI_rng_free(rng);
811         }
812
813         /* As we used INSERTKEY_FAST mode, we need to recompute all curve's handles now */
814         calchandles_fcurve(fcu);
815
816         if (G.debug & G_DEBUG) {
817                 printf("%s: \ntot len: %f\t\ttot time: %f\n", __func__, gtd->tot_dist, gtd->tot_time);
818                 for (i = 0; i < gtd->num_points; i++) {
819                         printf("\tpoint %d:\t\tlen: %f\t\ttime: %f\n", i, gtd->dists[i], gtd->times[i]);
820                 }
821                 printf("\n\n");
822         }
823
824         WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
825
826         /* send updates */
827         DAG_id_tag_update(&cu->id, 0);
828 }
829
830 #undef MIN_TIME_DELTA
831
832 #define GAP_DFAC 0.01f
833 #define WIDTH_CORR_FAC 0.1f
834 #define BEZT_HANDLE_FAC 0.3f
835
836 /* convert stroke to 3d path */
837
838 /* helper */
839 static void gp_stroke_to_path_add_point(tGpTimingData *gtd, BPoint *bp, const float p[3], const float prev_p[3],
840                                         const bool do_gtd, const double inittime, const float time,
841                                         const float width, const float rad_fac, float minmax_weights[2])
842 {
843         copy_v3_v3(bp->vec, p);
844         bp->vec[3] = 1.0f;
845
846         /* set settings */
847         bp->f1 = SELECT;
848         bp->radius = width * rad_fac;
849         bp->weight = width;
850         CLAMP(bp->weight, 0.0f, 1.0f);
851         if (bp->weight < minmax_weights[0]) {
852                 minmax_weights[0] = bp->weight;
853         }
854         else if (bp->weight > minmax_weights[1]) {
855                 minmax_weights[1] = bp->weight;
856         }
857
858         /* Update timing data */
859         if (do_gtd) {
860                 gp_timing_data_add_point(gtd, inittime, time, len_v3v3(prev_p, p));
861         }
862 }
863
864 static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curve *cu, rctf *subrect, Nurb **curnu,
865                               float minmax_weights[2], const float rad_fac, bool stitch, const bool add_start_point,
866                               const bool add_end_point, tGpTimingData *gtd)
867 {
868         bGPDspoint *pt;
869         Nurb *nu = (curnu) ? *curnu : NULL;
870         BPoint *bp, *prev_bp = NULL;
871         const bool do_gtd = (gtd->mode != GP_STROKECONVERT_TIMING_NONE);
872         const int add_start_end_points = (add_start_point ? 1 : 0) + (add_end_point ? 1 : 0);
873         int i, old_nbp = 0;
874
875         /* create new 'nurb' or extend current one within the curve */
876         if (nu) {
877                 old_nbp = nu->pntsu;
878
879                 /* If stitch, the first point of this stroke is already present in current nu.
880                  * Else, we have to add two additional points to make the zero-radius link between strokes.
881                  */
882                 BKE_nurb_points_add(nu, gps->totpoints + (stitch ? -1 : 2) + add_start_end_points);
883         }
884         else {
885                 nu = (Nurb *)MEM_callocN(sizeof(Nurb), "gpstroke_to_path(nurb)");
886
887                 nu->pntsu = gps->totpoints + add_start_end_points;
888                 nu->pntsv = 1;
889                 nu->orderu = 2; /* point-to-point! */
890                 nu->type = CU_NURBS;
891                 nu->flagu = CU_NURB_ENDPOINT;
892                 nu->resolu = cu->resolu;
893                 nu->resolv = cu->resolv;
894                 nu->knotsu = NULL;
895
896                 nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * nu->pntsu, "bpoints");
897
898                 stitch = false; /* Security! */
899         }
900
901         if (do_gtd) {
902                 gp_timing_data_set_nbr(gtd, nu->pntsu);
903         }
904
905         /* If needed, make the link between both strokes with two zero-radius additional points */
906         /* About "zero-radius" point interpolations:
907          * - If we have at least two points in current curve (most common case), we linearly extrapolate
908          *   the last segment to get the first point (p1) position and timing.
909          * - If we do not have those (quite odd, but may happen), we linearly interpolate the last point
910          *   with the first point of the current stroke.
911          * The same goes for the second point, first segment of the current stroke is "negatively" extrapolated
912          * if it exists, else (if the stroke is a single point), linear interpolation with last curve point...
913          */
914         if (curnu && !stitch && old_nbp) {
915                 float p1[3], p2[3], p[3], next_p[3];
916                 float dt1 = 0.0f, dt2 = 0.0f;
917
918                 BLI_assert(gps->prev != NULL);
919
920                 prev_bp = NULL;
921                 if ((old_nbp > 1) && (gps->prev->totpoints > 1)) {
922                         /* Only use last curve segment if previous stroke was not a single-point one! */
923                         prev_bp = &nu->bp[old_nbp - 2];
924                 }
925                 bp = &nu->bp[old_nbp - 1];
926
927                 /* First point */
928                 gp_strokepoint_convertcoords(C, gps, gps->points, p, subrect);
929                 if (prev_bp) {
930                         interp_v3_v3v3(p1, bp->vec, prev_bp->vec, -GAP_DFAC);
931                         if (do_gtd) {
932                                 const int idx = gps->prev->totpoints - 1;
933                                 dt1 = interpf(gps->prev->points[idx - 1].time, gps->prev->points[idx].time, -GAP_DFAC);
934                         }
935                 }
936                 else {
937                         interp_v3_v3v3(p1, bp->vec, p, GAP_DFAC);
938                         if (do_gtd) {
939                                 dt1 = interpf(gps->inittime - gps->prev->inittime, 0.0f, GAP_DFAC);
940                         }
941                 }
942                 bp++;
943                 gp_stroke_to_path_add_point(gtd, bp, p1, (bp - 1)->vec, do_gtd, gps->prev->inittime, dt1,
944                                             0.0f, rad_fac, minmax_weights);
945
946                 /* Second point */
947                 /* Note dt2 is always negative, which marks the gap. */
948                 if (gps->totpoints > 1) {
949                         gp_strokepoint_convertcoords(C, gps, gps->points + 1, next_p, subrect);
950                         interp_v3_v3v3(p2, p, next_p, -GAP_DFAC);
951                         if (do_gtd) {
952                                 dt2 = interpf(gps->points[1].time, gps->points[0].time, -GAP_DFAC);
953                         }
954                 }
955                 else {
956                         interp_v3_v3v3(p2, p, bp->vec, GAP_DFAC);
957                         if (do_gtd) {
958                                 dt2 = interpf(gps->prev->inittime - gps->inittime, 0.0f, GAP_DFAC);
959                         }
960                 }
961                 bp++;
962                 gp_stroke_to_path_add_point(gtd, bp, p2, p1, do_gtd, gps->inittime, dt2, 0.0f, rad_fac, minmax_weights);
963
964                 old_nbp += 2;
965         }
966         else if (add_start_point) {
967                 float p[3], next_p[3];
968                 float dt = 0.0f;
969
970                 gp_strokepoint_convertcoords(C, gps, gps->points, p, subrect);
971                 if (gps->totpoints > 1) {
972                         gp_strokepoint_convertcoords(C, gps, gps->points + 1, next_p, subrect);
973                         interp_v3_v3v3(p, p, next_p, -GAP_DFAC);
974                         if (do_gtd) {
975                                 dt = interpf(gps->points[1].time, gps->points[0].time, -GAP_DFAC);
976                         }
977                 }
978                 else {
979                         p[0] -= GAP_DFAC;  /* Rather arbitrary... */
980                         dt = -GAP_DFAC;  /* Rather arbitrary too! */
981                 }
982                 bp = &nu->bp[old_nbp];
983                 /* Note we can't give anything else than 0.0 as time here, since a negative one (which would be expected value)
984                  * would not work (it would be *before* gtd->inittime, which is not supported currently).
985                  */
986                 gp_stroke_to_path_add_point(gtd, bp, p, p, do_gtd, gps->inittime, dt, 0.0f, rad_fac, minmax_weights);
987
988                 old_nbp++;
989         }
990
991         if (old_nbp) {
992                 prev_bp = &nu->bp[old_nbp - 1];
993         }
994
995         /* add points */
996         for (i = (stitch) ? 1 : 0, pt = &gps->points[(stitch) ? 1 : 0], bp = &nu->bp[old_nbp];
997              i < gps->totpoints;
998              i++, pt++, bp++)
999         {
1000                 float p[3];
1001                 float width = pt->pressure * gpl->thickness * WIDTH_CORR_FAC;
1002
1003                 /* get coordinates to add at */
1004                 gp_strokepoint_convertcoords(C, gps, pt, p, subrect);
1005
1006                 gp_stroke_to_path_add_point(gtd, bp, p, (prev_bp) ? prev_bp->vec : p, do_gtd, gps->inittime, pt->time,
1007                                             width, rad_fac, minmax_weights);
1008
1009                 prev_bp = bp;
1010         }
1011
1012         if (add_end_point) {
1013                 float p[3];
1014                 float dt = 0.0f;
1015
1016                 if (gps->totpoints > 1) {
1017                         interp_v3_v3v3(p, prev_bp->vec, (prev_bp - 1)->vec, -GAP_DFAC);
1018                         if (do_gtd) {
1019                                 const int idx = gps->totpoints - 1;
1020                                 dt = interpf(gps->points[idx - 1].time, gps->points[idx].time, -GAP_DFAC);
1021                         }
1022                 }
1023                 else {
1024                         copy_v3_v3(p, prev_bp->vec);
1025                         p[0] += GAP_DFAC;  /* Rather arbitrary... */
1026                         dt = GAP_DFAC;  /* Rather arbitrary too! */
1027                 }
1028                 /* Note bp has already been incremented in main loop above, so it points to the right place. */
1029                 gp_stroke_to_path_add_point(gtd, bp, p, prev_bp->vec, do_gtd, gps->inittime, dt, 0.0f, rad_fac, minmax_weights);
1030         }
1031
1032         /* add nurb to curve */
1033         if (!curnu || !*curnu) {
1034                 BLI_addtail(&cu->nurb, nu);
1035         }
1036         if (curnu) {
1037                 *curnu = nu;
1038         }
1039
1040         BKE_nurb_knot_calc_u(nu);
1041 }
1042
1043 /* convert stroke to 3d bezier */
1044
1045 /* helper */
1046 static void gp_stroke_to_bezier_add_point(tGpTimingData *gtd, BezTriple *bezt,
1047                                           const float p[3], const float h1[3], const float h2[3], const float prev_p[3],
1048                                           const bool do_gtd, const double inittime, const float time,
1049                                           const float width, const float rad_fac, float minmax_weights[2])
1050 {
1051         copy_v3_v3(bezt->vec[0], h1);
1052         copy_v3_v3(bezt->vec[1], p);
1053         copy_v3_v3(bezt->vec[2], h2);
1054
1055         /* set settings */
1056         bezt->h1 = bezt->h2 = HD_FREE;
1057         bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
1058         bezt->radius = width * rad_fac;
1059         bezt->weight = width;
1060         CLAMP(bezt->weight, 0.0f, 1.0f);
1061         if (bezt->weight < minmax_weights[0]) {
1062                 minmax_weights[0] = bezt->weight;
1063         }
1064         else if (bezt->weight > minmax_weights[1]) {
1065                 minmax_weights[1] = bezt->weight;
1066         }
1067
1068         /* Update timing data */
1069         if (do_gtd) {
1070                 gp_timing_data_add_point(gtd, inittime, time, len_v3v3(prev_p, p));
1071         }
1072 }
1073
1074 static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curve *cu, rctf *subrect, Nurb **curnu,
1075                               float minmax_weights[2], const float rad_fac, bool stitch, const bool add_start_point,
1076                               const bool add_end_point, tGpTimingData *gtd)
1077 {
1078         bGPDspoint *pt;
1079         Nurb *nu = (curnu) ? *curnu : NULL;
1080         BezTriple *bezt, *prev_bezt = NULL;
1081         int i, tot, old_nbezt = 0;
1082         const int add_start_end_points = (add_start_point ? 1 : 0) + (add_end_point ? 1 : 0);
1083         float p3d_cur[3], p3d_prev[3], p3d_next[3], h1[3], h2[3];
1084         const bool do_gtd = (gtd->mode != GP_STROKECONVERT_TIMING_NONE);
1085
1086         /* create new 'nurb' or extend current one within the curve */
1087         if (nu) {
1088                 old_nbezt = nu->pntsu;
1089                 /* If we do stitch, first point of current stroke is assumed the same as last point of previous stroke,
1090                  * so no need to add it.
1091                  * If no stitch, we want to add two additional points to make a "zero-radius" link between both strokes.
1092                  */
1093                 BKE_nurb_bezierPoints_add(nu, gps->totpoints + ((stitch) ? -1 : 2) + add_start_end_points);
1094         }
1095         else {
1096                 nu = (Nurb *)MEM_callocN(sizeof(Nurb), "gpstroke_to_bezier(nurb)");
1097
1098                 nu->pntsu = gps->totpoints + add_start_end_points;
1099                 nu->resolu = 12;
1100                 nu->resolv = 12;
1101                 nu->type = CU_BEZIER;
1102                 nu->bezt = (BezTriple *)MEM_callocN(sizeof(BezTriple) * nu->pntsu, "bezts");
1103
1104                 stitch = false; /* Security! */
1105         }
1106
1107         if (do_gtd) {
1108                 gp_timing_data_set_nbr(gtd, nu->pntsu);
1109         }
1110
1111         tot = gps->totpoints;
1112
1113         /* get initial coordinates */
1114         pt = gps->points;
1115         if (tot) {
1116                 gp_strokepoint_convertcoords(C, gps, pt, (stitch) ? p3d_prev : p3d_cur, subrect);
1117                 if (tot > 1) {
1118                         gp_strokepoint_convertcoords(C, gps, pt + 1, (stitch) ? p3d_cur : p3d_next, subrect);
1119                 }
1120                 if (stitch && tot > 2) {
1121                         gp_strokepoint_convertcoords(C, gps, pt + 2, p3d_next, subrect);
1122                 }
1123         }
1124
1125         /* If needed, make the link between both strokes with two zero-radius additional points */
1126         if (curnu && old_nbezt) {
1127                 BLI_assert(gps->prev != NULL);
1128
1129                 /* Update last point's second handle */
1130                 if (stitch) {
1131                         bezt = &nu->bezt[old_nbezt - 1];
1132                         interp_v3_v3v3(h2, bezt->vec[1], p3d_cur, BEZT_HANDLE_FAC);
1133                         copy_v3_v3(bezt->vec[2], h2);
1134                         pt++;
1135                 }
1136
1137                 /* Create "link points" */
1138                 /* About "zero-radius" point interpolations:
1139                  * - If we have at least two points in current curve (most common case), we linearly extrapolate
1140                  *   the last segment to get the first point (p1) position and timing.
1141                  * - If we do not have those (quite odd, but may happen), we linearly interpolate the last point
1142                  *   with the first point of the current stroke.
1143                  * The same goes for the second point, first segment of the current stroke is "negatively" extrapolated
1144                  * if it exists, else (if the stroke is a single point), linear interpolation with last curve point...
1145                  */
1146                 else {
1147                         float p1[3], p2[3];
1148                         float dt1 = 0.0f, dt2 = 0.0f;
1149
1150                         prev_bezt = NULL;
1151                         if ((old_nbezt > 1) && (gps->prev->totpoints > 1)) {
1152                                 /* Only use last curve segment if previous stroke was not a single-point one! */
1153                                 prev_bezt = &nu->bezt[old_nbezt - 2];
1154                         }
1155                         bezt = &nu->bezt[old_nbezt - 1];
1156
1157                         /* First point */
1158                         if (prev_bezt) {
1159                                 interp_v3_v3v3(p1, prev_bezt->vec[1], bezt->vec[1], 1.0f + GAP_DFAC);
1160                                 if (do_gtd) {
1161                                         const int idx = gps->prev->totpoints - 1;
1162                                         dt1 = interpf(gps->prev->points[idx - 1].time, gps->prev->points[idx].time, -GAP_DFAC);
1163                                 }
1164                         }
1165                         else {
1166                                 interp_v3_v3v3(p1, bezt->vec[1], p3d_cur, GAP_DFAC);
1167                                 if (do_gtd) {
1168                                         dt1 = interpf(gps->inittime - gps->prev->inittime, 0.0f, GAP_DFAC);
1169                                 }
1170                         }
1171
1172                         /* Second point */
1173                         /* Note dt2 is always negative, which marks the gap. */
1174                         if (tot > 1) {
1175                                 interp_v3_v3v3(p2, p3d_cur, p3d_next, -GAP_DFAC);
1176                                 if (do_gtd) {
1177                                         dt2 = interpf(gps->points[1].time, gps->points[0].time, -GAP_DFAC);
1178                                 }
1179                         }
1180                         else {
1181                                 interp_v3_v3v3(p2, p3d_cur, bezt->vec[1], GAP_DFAC);
1182                                 if (do_gtd) {
1183                                         dt2 = interpf(gps->prev->inittime - gps->inittime, 0.0f, GAP_DFAC);
1184                                 }
1185                         }
1186
1187                         /* Second handle of last point of previous stroke. */
1188                         interp_v3_v3v3(h2, bezt->vec[1], p1, BEZT_HANDLE_FAC);
1189                         copy_v3_v3(bezt->vec[2], h2);
1190
1191                         /* First point */
1192                         interp_v3_v3v3(h1, p1, bezt->vec[1], BEZT_HANDLE_FAC);
1193                         interp_v3_v3v3(h2, p1, p2, BEZT_HANDLE_FAC);
1194                         bezt++;
1195                         gp_stroke_to_bezier_add_point(gtd, bezt, p1, h1, h2, (bezt - 1)->vec[1], do_gtd, gps->prev->inittime, dt1,
1196                                                       0.0f, rad_fac, minmax_weights);
1197
1198                         /* Second point */
1199                         interp_v3_v3v3(h1, p2, p1, BEZT_HANDLE_FAC);
1200                         interp_v3_v3v3(h2, p2, p3d_cur, BEZT_HANDLE_FAC);
1201                         bezt++;
1202                         gp_stroke_to_bezier_add_point(gtd, bezt, p2, h1, h2, p1, do_gtd, gps->inittime, dt2,
1203                                                       0.0f, rad_fac, minmax_weights);
1204
1205                         old_nbezt += 2;
1206                         copy_v3_v3(p3d_prev, p2);
1207                 }
1208         }
1209         else if (add_start_point) {
1210                 float p[3];
1211                 float dt = 0.0f;
1212
1213                 if (gps->totpoints > 1) {
1214                         interp_v3_v3v3(p, p3d_cur, p3d_next, -GAP_DFAC);
1215                         if (do_gtd) {
1216                                 dt = interpf(gps->points[1].time, gps->points[0].time, -GAP_DFAC);
1217                         }
1218                 }
1219                 else {
1220                         copy_v3_v3(p, p3d_cur);
1221                         p[0] -= GAP_DFAC;  /* Rather arbitrary... */
1222                         dt = -GAP_DFAC;  /* Rather arbitrary too! */
1223                 }
1224                 interp_v3_v3v3(h1, p, p3d_cur, -BEZT_HANDLE_FAC);
1225                 interp_v3_v3v3(h2, p, p3d_cur, BEZT_HANDLE_FAC);
1226                 bezt = &nu->bezt[old_nbezt];
1227                 gp_stroke_to_bezier_add_point(gtd, bezt, p, h1, h2, p, do_gtd, gps->inittime, dt,
1228                                               0.0f, rad_fac, minmax_weights);
1229
1230                 old_nbezt++;
1231                 copy_v3_v3(p3d_prev, p);
1232         }
1233
1234         if (old_nbezt) {
1235                 prev_bezt = &nu->bezt[old_nbezt - 1];
1236         }
1237
1238         /* add points */
1239         for (i = stitch ? 1 : 0, bezt = &nu->bezt[old_nbezt]; i < tot; i++, pt++, bezt++) {
1240                 float width = pt->pressure * gpl->thickness * WIDTH_CORR_FAC;
1241
1242                 if (i || old_nbezt) {
1243                         interp_v3_v3v3(h1, p3d_cur, p3d_prev, BEZT_HANDLE_FAC);
1244                 }
1245                 else {
1246                         interp_v3_v3v3(h1, p3d_cur, p3d_next, -BEZT_HANDLE_FAC);
1247                 }
1248
1249                 if (i < tot - 1) {
1250                         interp_v3_v3v3(h2, p3d_cur, p3d_next, BEZT_HANDLE_FAC);
1251                 }
1252                 else {
1253                         interp_v3_v3v3(h2, p3d_cur, p3d_prev, -BEZT_HANDLE_FAC);
1254                 }
1255
1256                 gp_stroke_to_bezier_add_point(gtd, bezt, p3d_cur, h1, h2, prev_bezt ? prev_bezt->vec[1] : p3d_cur,
1257                                               do_gtd, gps->inittime, pt->time, width, rad_fac, minmax_weights);
1258
1259                 /* shift coord vects */
1260                 copy_v3_v3(p3d_prev, p3d_cur);
1261                 copy_v3_v3(p3d_cur, p3d_next);
1262
1263                 if (i + 2 < tot) {
1264                         gp_strokepoint_convertcoords(C, gps, pt + 2, p3d_next, subrect);
1265                 }
1266
1267                 prev_bezt = bezt;
1268         }
1269
1270         if (add_end_point) {
1271                 float p[3];
1272                 float dt = 0.0f;
1273
1274                 if (gps->totpoints > 1) {
1275                         interp_v3_v3v3(p, prev_bezt->vec[1], (prev_bezt - 1)->vec[1], -GAP_DFAC);
1276                         if (do_gtd) {
1277                                 const int idx = gps->totpoints - 1;
1278                                 dt = interpf(gps->points[idx - 1].time, gps->points[idx].time, -GAP_DFAC);
1279                         }
1280                 }
1281                 else {
1282                         copy_v3_v3(p, prev_bezt->vec[1]);
1283                         p[0] += GAP_DFAC;  /* Rather arbitrary... */
1284                         dt = GAP_DFAC;  /* Rather arbitrary too! */
1285                 }
1286
1287                 /* Second handle of last point of this stroke. */
1288                 interp_v3_v3v3(h2, prev_bezt->vec[1], p, BEZT_HANDLE_FAC);
1289                 copy_v3_v3(prev_bezt->vec[2], h2);
1290
1291                 /* The end point */
1292                 interp_v3_v3v3(h1, p, prev_bezt->vec[1], BEZT_HANDLE_FAC);
1293                 interp_v3_v3v3(h2, p, prev_bezt->vec[1], -BEZT_HANDLE_FAC);
1294                 /* Note bezt has already been incremented in main loop above, so it points to the right place. */
1295                 gp_stroke_to_bezier_add_point(gtd, bezt, p, h1, h2, prev_bezt->vec[1], do_gtd, gps->inittime, dt,
1296                                               0.0f, rad_fac, minmax_weights);
1297         }
1298
1299         /* must calculate handles or else we crash */
1300         BKE_nurb_handles_calc(nu);
1301
1302         if (!curnu || !*curnu) {
1303                 BLI_addtail(&cu->nurb, nu);
1304         }
1305         if (curnu) {
1306                 *curnu = nu;
1307         }
1308 }
1309
1310 #undef GAP_DFAC
1311 #undef WIDTH_CORR_FAC
1312 #undef BEZT_HANDLE_FAC
1313
1314 static void gp_stroke_finalize_curve_endpoints(Curve *cu)
1315 {
1316         /* start */
1317         Nurb *nu = cu->nurb.first;
1318         int i = 0;
1319         if (nu->bezt) {
1320                 BezTriple *bezt = nu->bezt;
1321                 if (bezt) {
1322                         bezt[i].weight = bezt[i].radius = 0.0f;
1323                 }
1324         }
1325         else if (nu->bp) {
1326                 BPoint *bp = nu->bp;
1327                 if (bp) {
1328                         bp[i].weight = bp[i].radius = 0.0f;
1329                 }
1330         }
1331
1332         /* end */
1333         nu = cu->nurb.last;
1334         i = nu->pntsu - 1;
1335         if (nu->bezt) {
1336                 BezTriple *bezt = nu->bezt;
1337                 if (bezt) {
1338                         bezt[i].weight = bezt[i].radius = 0.0f;
1339                 }
1340         }
1341         else if (nu->bp) {
1342                 BPoint *bp = nu->bp;
1343                 if (bp) {
1344                         bp[i].weight = bp[i].radius = 0.0f;
1345                 }
1346         }
1347 }
1348
1349 static void gp_stroke_norm_curve_weights(Curve *cu, const float minmax_weights[2])
1350 {
1351         Nurb *nu;
1352         const float delta = minmax_weights[0];
1353         float fac;
1354         int i;
1355
1356         /* when delta == minmax_weights[0] == minmax_weights[1], we get div by zero [#35686] */
1357         if (IS_EQF(delta, minmax_weights[1]))
1358                 fac = 1.0f;
1359         else
1360                 fac = 1.0f / (minmax_weights[1] - delta);
1361
1362         for (nu = cu->nurb.first; nu; nu = nu->next) {
1363                 if (nu->bezt) {
1364                         BezTriple *bezt = nu->bezt;
1365                         for (i = 0; i < nu->pntsu; i++, bezt++) {
1366                                 bezt->weight = (bezt->weight - delta) * fac;
1367                         }
1368                 }
1369                 else if (nu->bp) {
1370                         BPoint *bp = nu->bp;
1371                         for (i = 0; i < nu->pntsu; i++, bp++) {
1372                                 bp->weight = (bp->weight - delta) * fac;
1373                         }
1374                 }
1375         }
1376 }
1377
1378 static int gp_camera_view_subrect(bContext *C, rctf *subrect)
1379 {
1380         View3D *v3d = CTX_wm_view3d(C);
1381         ARegion *ar = CTX_wm_region(C);
1382
1383         if (v3d) {
1384                 RegionView3D *rv3d = ar->regiondata;
1385
1386                 /* for camera view set the subrect */
1387                 if (rv3d->persp == RV3D_CAMOB) {
1388                         Scene *scene = CTX_data_scene(C);
1389                         ED_view3d_calc_camera_border(scene, ar, v3d, rv3d, subrect, true); /* no shift */
1390                         return 1;
1391                 }
1392         }
1393
1394         return 0;
1395 }
1396
1397 /* convert a given grease-pencil layer to a 3d-curve representation (using current view if appropriate) */
1398 static void gp_layer_to_curve(bContext *C, ReportList *reports, bGPdata *gpd, bGPDlayer *gpl, const int mode,
1399                               const bool norm_weights, const float rad_fac, const bool link_strokes, tGpTimingData *gtd)
1400 {
1401         struct Main *bmain = CTX_data_main(C);
1402         Scene *scene = CTX_data_scene(C);
1403         bGPDframe *gpf = gpencil_layer_getframe(gpl, CFRA, 0);
1404         bGPDstroke *gps, *prev_gps = NULL;
1405         Object *ob;
1406         Curve *cu;
1407         Nurb *nu = NULL;
1408         Base *base_orig = BASACT, *base_new = NULL;
1409         float minmax_weights[2] = {1.0f, 0.0f};
1410
1411         /* camera framing */
1412         rctf subrect, *subrect_ptr = NULL;
1413
1414         /* error checking */
1415         if (ELEM(NULL, gpd, gpl, gpf))
1416                 return;
1417
1418         /* only convert if there are any strokes on this layer's frame to convert */
1419         if (BLI_listbase_is_empty(&gpf->strokes))
1420                 return;
1421
1422         /* initialize camera framing */
1423         if (gp_camera_view_subrect(C, &subrect)) {
1424                 subrect_ptr = &subrect;
1425         }
1426
1427         /* init the curve object (remove rotation and get curve data from it)
1428          *      - must clear transforms set on object, as those skew our results
1429          */
1430         ob = BKE_object_add_only_object(bmain, OB_CURVE, gpl->info);
1431         cu = ob->data = BKE_curve_add(bmain, gpl->info, OB_CURVE);
1432         base_new = BKE_scene_base_add(scene, ob);
1433
1434         cu->flag |= CU_3D;
1435
1436         gtd->inittime = ((bGPDstroke *)gpf->strokes.first)->inittime;
1437
1438         /* add points to curve */
1439         for (gps = gpf->strokes.first; gps; gps = gps->next) {
1440                 const bool add_start_point = (link_strokes && !(prev_gps));
1441                 const bool add_end_point = (link_strokes && !(gps->next));
1442
1443                 /* Detect new strokes created because of GP_STROKE_BUFFER_MAX reached, and stitch them to previous one. */
1444                 bool stitch = false;
1445                 if (prev_gps) {
1446                         bGPDspoint *pt1 = &prev_gps->points[prev_gps->totpoints - 1];
1447                         bGPDspoint *pt2 = &gps->points[0];
1448
1449                         if ((pt1->x == pt2->x) && (pt1->y == pt2->y)) {
1450                                 stitch = true;
1451                         }
1452                 }
1453
1454                 /* Decide whether we connect this stroke to previous one */
1455                 if (!(stitch || link_strokes)) {
1456                         nu = NULL;
1457                 }
1458
1459                 switch (mode) {
1460                         case GP_STROKECONVERT_PATH: 
1461                                 gp_stroke_to_path(C, gpl, gps, cu, subrect_ptr, &nu, minmax_weights, rad_fac, stitch,
1462                                                   add_start_point, add_end_point, gtd);
1463                                 break;
1464                         case GP_STROKECONVERT_CURVE:
1465                         case GP_STROKECONVERT_POLY:  /* convert after */
1466                                 gp_stroke_to_bezier(C, gpl, gps, cu, subrect_ptr, &nu, minmax_weights, rad_fac, stitch,
1467                                                     add_start_point, add_end_point, gtd);
1468                                 break;
1469                         default:
1470                                 BLI_assert(!"invalid mode");
1471                                 break;
1472                 }
1473                 prev_gps = gps;
1474         }
1475
1476         /* If link_strokes, be sure first and last points have a zero weight/size! */
1477         if (link_strokes) {
1478                 gp_stroke_finalize_curve_endpoints(cu);
1479         }
1480
1481         /* Update curve's weights, if needed */
1482         if (norm_weights && ((minmax_weights[0] > 0.0f) || (minmax_weights[1] < 1.0f))) {
1483                 gp_stroke_norm_curve_weights(cu, minmax_weights);
1484         }
1485
1486         /* Create the path animation, if needed */
1487         gp_stroke_path_animation(C, reports, cu, gtd);
1488
1489         if (mode == GP_STROKECONVERT_POLY) {
1490                 for (nu = cu->nurb.first; nu; nu = nu->next) {
1491                         BKE_nurb_type_convert(nu, CU_POLY, false);
1492                 }
1493         }
1494
1495         /* set the layer and select */
1496         base_new->lay  = ob->lay  = base_orig ? base_orig->lay : scene->lay;
1497         base_new->flag = ob->flag = base_new->flag | SELECT;
1498 }
1499
1500 /* --- */
1501
1502 /* Check a GP layer has valid timing data! Else, most timing options are hidden in the operator.
1503  * op may be NULL.
1504  */
1505 static bool gp_convert_check_has_valid_timing(bContext *C, bGPDlayer *gpl, wmOperator *op)
1506 {
1507         Scene *scene = CTX_data_scene(C);
1508         bGPDframe *gpf = NULL;
1509         bGPDstroke *gps = NULL;
1510         bGPDspoint *pt;
1511         double base_time, cur_time, prev_time = -1.0;
1512         int i;
1513         bool valid = true;
1514
1515         if (!gpl || !(gpf = gpencil_layer_getframe(gpl, CFRA, 0)) || !(gps = gpf->strokes.first))
1516                 return false;
1517
1518         do {
1519                 base_time = cur_time = gps->inittime;
1520                 if (cur_time <= prev_time) {
1521                         valid = false;
1522                         break;
1523                 }
1524
1525                 prev_time = cur_time;
1526                 for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
1527                         cur_time = base_time + (double)pt->time;
1528                         /* First point of a stroke should have the same time as stroke's inittime,
1529                          * so it's the only case where equality is allowed!
1530                          */
1531                         if ((i && cur_time <= prev_time) || (cur_time < prev_time)) {
1532                                 valid = false;
1533                                 break;
1534                         }
1535                         prev_time = cur_time;
1536                 }
1537
1538                 if (!valid) {
1539                         break;
1540                 }
1541         } while ((gps = gps->next));
1542
1543         if (op) {
1544                 RNA_boolean_set(op->ptr, "use_timing_data", valid);
1545         }
1546         return valid;
1547 }
1548
1549 /* Check end_frame is always > start frame! */
1550 static void gp_convert_set_end_frame(struct Main *UNUSED(main), struct Scene *UNUSED(scene), struct PointerRNA *ptr)
1551 {
1552         int start_frame = RNA_int_get(ptr, "start_frame");
1553         int end_frame = RNA_int_get(ptr, "end_frame");
1554
1555         if (end_frame <= start_frame) {
1556                 RNA_int_set(ptr, "end_frame", start_frame + 1);
1557         }
1558 }
1559
1560 static int gp_convert_poll(bContext *C)
1561 {
1562         bGPdata *gpd = ED_gpencil_data_get_active(C);
1563         bGPDlayer *gpl = NULL;
1564         bGPDframe *gpf = NULL;
1565         ScrArea *sa = CTX_wm_area(C);
1566         Scene *scene = CTX_data_scene(C);
1567
1568         /* only if the current view is 3D View, if there's valid data (i.e. at least one stroke!),
1569          * and if we are not in edit mode!
1570          */
1571         return ((sa && sa->spacetype == SPACE_VIEW3D) &&
1572                 (gpl = gpencil_layer_getactive(gpd)) &&
1573                 (gpf = gpencil_layer_getframe(gpl, CFRA, 0)) &&
1574                 (gpf->strokes.first) &&
1575                 (scene->obedit == NULL));
1576 }
1577
1578 static int gp_convert_layer_exec(bContext *C, wmOperator *op)
1579 {
1580         PropertyRNA *prop = RNA_struct_find_property(op->ptr, "use_timing_data");
1581         bGPdata *gpd = ED_gpencil_data_get_active(C);
1582         bGPDlayer *gpl = gpencil_layer_getactive(gpd);
1583         Scene *scene = CTX_data_scene(C);
1584         const int mode = RNA_enum_get(op->ptr, "type");
1585         const bool norm_weights = RNA_boolean_get(op->ptr, "use_normalize_weights");
1586         const float rad_fac = RNA_float_get(op->ptr, "radius_multiplier");
1587         const bool link_strokes = RNA_boolean_get(op->ptr, "use_link_strokes");
1588         bool valid_timing;
1589         tGpTimingData gtd;
1590
1591         /* check if there's data to work with */
1592         if (gpd == NULL) {
1593                 BKE_report(op->reports, RPT_ERROR, "No Grease Pencil data to work on");
1594                 return OPERATOR_CANCELLED;
1595         }
1596
1597         if (!RNA_property_is_set(op->ptr, prop) && !gp_convert_check_has_valid_timing(C, gpl, op)) {
1598                 BKE_report(op->reports, RPT_WARNING,
1599                            "Current Grease Pencil strokes have no valid timing data, most timing options will be hidden!");
1600         }
1601         valid_timing = RNA_property_boolean_get(op->ptr, prop);
1602
1603         gtd.mode = RNA_enum_get(op->ptr, "timing_mode");
1604         /* Check for illegal timing mode! */
1605         if (!valid_timing && !ELEM(gtd.mode, GP_STROKECONVERT_TIMING_NONE, GP_STROKECONVERT_TIMING_LINEAR)) {
1606                 gtd.mode = GP_STROKECONVERT_TIMING_LINEAR;
1607                 RNA_enum_set(op->ptr, "timing_mode", gtd.mode);
1608         }
1609         if (!link_strokes) {
1610                 gtd.mode = GP_STROKECONVERT_TIMING_NONE;
1611         }
1612
1613         /* grab all relevant settings */
1614         gtd.frame_range = RNA_int_get(op->ptr, "frame_range");
1615         gtd.start_frame = RNA_int_get(op->ptr, "start_frame");
1616         gtd.realtime = valid_timing ? RNA_boolean_get(op->ptr, "use_realtime") : false;
1617         gtd.end_frame = RNA_int_get(op->ptr, "end_frame");
1618         gtd.gap_duration = RNA_float_get(op->ptr, "gap_duration");
1619         gtd.gap_randomness = RNA_float_get(op->ptr, "gap_randomness");
1620         gtd.gap_randomness = min_ff(gtd.gap_randomness, gtd.gap_duration);
1621         gtd.seed = RNA_int_get(op->ptr, "seed");
1622         gtd.num_points = gtd.cur_point = 0;
1623         gtd.dists = gtd.times = NULL;
1624         gtd.tot_dist = gtd.tot_time = gtd.gap_tot_time = 0.0f;
1625         gtd.inittime = 0.0;
1626         gtd.offset_time = 0.0f;
1627
1628         /* perform conversion */
1629         gp_layer_to_curve(C, op->reports, gpd, gpl, mode, norm_weights, rad_fac, link_strokes, &gtd);
1630
1631         /* free temp memory */
1632         if (gtd.dists) {
1633                 MEM_freeN(gtd.dists);
1634                 gtd.dists = NULL;
1635         }
1636         if (gtd.times) {
1637                 MEM_freeN(gtd.times);
1638                 gtd.times = NULL;
1639         }
1640
1641         /* notifiers */
1642         WM_event_add_notifier(C, NC_OBJECT | NA_ADDED, NULL);
1643         WM_event_add_notifier(C, NC_SCENE | ND_OB_ACTIVE, scene);
1644
1645         /* done */
1646         return OPERATOR_FINISHED;
1647 }
1648
1649 static bool gp_convert_draw_check_prop(PointerRNA *ptr, PropertyRNA *prop)
1650 {
1651         const char *prop_id = RNA_property_identifier(prop);
1652         const bool link_strokes = RNA_boolean_get(ptr, "use_link_strokes");
1653         int timing_mode = RNA_enum_get(ptr, "timing_mode");
1654         bool realtime = RNA_boolean_get(ptr, "use_realtime");
1655         float gap_duration = RNA_float_get(ptr, "gap_duration");
1656         float gap_randomness = RNA_float_get(ptr, "gap_randomness");
1657         const bool valid_timing = RNA_boolean_get(ptr, "use_timing_data");
1658
1659         /* Always show those props */
1660         if (strcmp(prop_id, "type") == 0 ||
1661             strcmp(prop_id, "use_normalize_weights") == 0 ||
1662             strcmp(prop_id, "radius_multiplier") == 0 ||
1663             strcmp(prop_id, "use_link_strokes") == 0)
1664         {
1665                 return true;
1666         }
1667
1668         /* Never show this prop */
1669         if (strcmp(prop_id, "use_timing_data") == 0)
1670                 return false;
1671
1672         if (link_strokes) {
1673                 /* Only show when link_stroke is true */
1674                 if (strcmp(prop_id, "timing_mode") == 0)
1675                         return true;
1676
1677                 if (timing_mode != GP_STROKECONVERT_TIMING_NONE) {
1678                         /* Only show when link_stroke is true and stroke timing is enabled */
1679                         if (strcmp(prop_id, "frame_range") == 0 ||
1680                             strcmp(prop_id, "start_frame") == 0)
1681                         {
1682                                 return true;
1683                         }
1684
1685                         /* Only show if we have valid timing data! */
1686                         if (valid_timing && strcmp(prop_id, "use_realtime") == 0)
1687                                 return true;
1688
1689                         /* Only show if realtime or valid_timing is false! */
1690                         if ((!realtime || !valid_timing) && strcmp(prop_id, "end_frame") == 0)
1691                                 return true;
1692
1693                         if (valid_timing && timing_mode == GP_STROKECONVERT_TIMING_CUSTOMGAP) {
1694                                 /* Only show for custom gaps! */
1695                                 if (strcmp(prop_id, "gap_duration") == 0)
1696                                         return true;
1697
1698                                 /* Only show randomness for non-null custom gaps! */
1699                                 if (strcmp(prop_id, "gap_randomness") == 0 && (gap_duration > 0.0f))
1700                                         return true;
1701
1702                                 /* Only show seed for randomize action! */
1703                                 if (strcmp(prop_id, "seed") == 0 && (gap_duration > 0.0f) && (gap_randomness > 0.0f))
1704                                         return true;
1705                         }
1706                 }
1707         }
1708
1709         /* Else, hidden! */
1710         return false;
1711 }
1712
1713 static void gp_convert_ui(bContext *C, wmOperator *op)
1714 {
1715         uiLayout *layout = op->layout;
1716         wmWindowManager *wm = CTX_wm_manager(C);
1717         PointerRNA ptr;
1718
1719         RNA_pointer_create(&wm->id, op->type->srna, op->properties, &ptr);
1720
1721         /* Main auto-draw call */
1722         uiDefAutoButsRNA(layout, &ptr, gp_convert_draw_check_prop, '\0');
1723 }
1724
1725 void GPENCIL_OT_convert(wmOperatorType *ot)
1726 {
1727         PropertyRNA *prop;
1728
1729         /* identifiers */
1730         ot->name = "Convert Grease Pencil";
1731         ot->idname = "GPENCIL_OT_convert";
1732         ot->description = "Convert the active Grease Pencil layer to a new Curve Object";
1733
1734         /* callbacks */
1735         ot->invoke = WM_menu_invoke;
1736         ot->exec = gp_convert_layer_exec;
1737         ot->poll = gp_convert_poll;
1738         ot->ui = gp_convert_ui;
1739
1740         /* flags */
1741         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1742
1743         /* properties */
1744         ot->prop = RNA_def_enum(ot->srna, "type", prop_gpencil_convertmodes, 0, "Type", "Which type of curve to convert to");
1745
1746         RNA_def_boolean(ot->srna, "use_normalize_weights", true, "Normalize Weight",
1747                         "Normalize weight (set from stroke width)");
1748         RNA_def_float(ot->srna, "radius_multiplier", 1.0f, 0.0f, 1000.0f, "Radius Fac",
1749                       "Multiplier for the points' radii (set from stroke width)", 0.0f, 10.0f);
1750         RNA_def_boolean(ot->srna, "use_link_strokes", true, "Link Strokes",
1751                         "Whether to link strokes with zero-radius sections of curves");
1752
1753         prop = RNA_def_enum(ot->srna, "timing_mode", prop_gpencil_convert_timingmodes, GP_STROKECONVERT_TIMING_FULL,
1754                             "Timing Mode", "How to use timing data stored in strokes");
1755         RNA_def_enum_funcs(prop, rna_GPConvert_mode_items);
1756
1757         RNA_def_int(ot->srna, "frame_range", 100, 1, 10000, "Frame Range",
1758                     "The duration of evaluation of the path control curve", 1, 1000);
1759         RNA_def_int(ot->srna, "start_frame", 1, 1, 100000, "Start Frame",
1760                     "The start frame of the path control curve", 1, 100000);
1761         RNA_def_boolean(ot->srna, "use_realtime", false, "Realtime",
1762                         "Whether the path control curve reproduces the drawing in realtime, starting from Start Frame");
1763         prop = RNA_def_int(ot->srna, "end_frame", 250, 1, 100000, "End Frame",
1764                            "The end frame of the path control curve (if Realtime is not set)", 1, 100000);
1765         RNA_def_property_update_runtime(prop, gp_convert_set_end_frame);
1766
1767         RNA_def_float(ot->srna, "gap_duration", 0.0f, 0.0f, 10000.0f, "Gap Duration",
1768                       "Custom Gap mode: (Average) length of gaps, in frames "
1769                       "(Note: Realtime value, will be scaled if Realtime is not set)", 0.0f, 1000.0f);
1770         RNA_def_float(ot->srna, "gap_randomness", 0.0f, 0.0f, 10000.0f, "Gap Randomness",
1771                       "Custom Gap mode: Number of frames that gap lengths can vary", 0.0f, 1000.0f);
1772         RNA_def_int(ot->srna, "seed", 0, 0, 1000, "Random Seed",
1773                     "Custom Gap mode: Random generator seed", 0, 100);
1774
1775         /* Note: Internal use, this one will always be hidden by UI code... */
1776         prop = RNA_def_boolean(ot->srna, "use_timing_data", false, "Has Valid Timing",
1777                                "Whether the converted Grease Pencil layer has valid timing data (internal use)");
1778         RNA_def_property_flag(prop, PROP_SKIP_SAVE);
1779 }
1780
1781 /* ************************************************ */