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