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