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