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