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