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