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