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