Pass EvaluationContext argument everywhere
[blender.git] / source / blender / editors / gpencil / gpencil_utils.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) 2014, Blender Foundation
19  *
20  * Contributor(s): Joshua Leung, Antonio Vazquez
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 /** \file blender/editors/gpencil/gpencil_utils.c
26  *  \ingroup edgpencil
27  */
28
29 #include <stdio.h>
30 #include <string.h>
31 #include <stdlib.h>
32 #include <stddef.h>
33 #include <math.h>
34
35 #include "MEM_guardedalloc.h"
36
37 #include "BLI_math.h"
38 #include "BLI_blenlib.h"
39 #include "BLI_utildefines.h"
40 #include "BLT_translation.h"
41 #include "BLI_rand.h"
42
43 #include "DNA_gpencil_types.h"
44 #include "DNA_object_types.h"
45 #include "DNA_scene_types.h"
46 #include "DNA_screen_types.h"
47 #include "DNA_space_types.h"
48 #include "DNA_view3d_types.h"
49
50 #include "BKE_context.h"
51 #include "BKE_gpencil.h"
52 #include "BKE_tracking.h"
53 #include "BKE_action.h"
54
55 #include "WM_api.h"
56
57 #include "RNA_access.h"
58 #include "RNA_define.h"
59 #include "RNA_enum_types.h"
60
61 #include "UI_resources.h"
62 #include "UI_view2d.h"
63
64 #include "ED_gpencil.h"
65 #include "ED_clip.h"
66 #include "ED_view3d.h"
67
68 #include "gpencil_intern.h"
69
70 /* ******************************************************** */
71 /* Context Wrangling... */
72
73 /* Get pointer to active Grease Pencil datablock, and an RNA-pointer to trace back to whatever owns it,
74  * when context info is not available.
75  */
76 bGPdata **ED_gpencil_data_get_pointers_direct(ID *screen_id, Scene *scene, ScrArea *sa, Object *ob, PointerRNA *ptr)
77 {
78         /* if there's an active area, check if the particular editor may
79          * have defined any special Grease Pencil context for editing...
80          */
81         if (sa) {
82                 SpaceLink *sl = sa->spacedata.first;
83                 
84                 switch (sa->spacetype) {
85                         case SPACE_VIEW3D: /* 3D-View */
86                         {
87                                 BLI_assert(scene && ELEM(scene->toolsettings->gpencil_src,
88                                                          GP_TOOL_SOURCE_SCENE, GP_TOOL_SOURCE_OBJECT));
89                                 
90                                 if (scene->toolsettings->gpencil_src == GP_TOOL_SOURCE_OBJECT) {
91                                         /* legacy behaviour for usage with old addons requiring object-linked to objects */
92                                         
93                                         /* just in case no active/selected object... */
94                                         if (ob && (ob->flag & SELECT)) {
95                                                 /* for now, as long as there's an object, default to using that in 3D-View */
96                                                 if (ptr) RNA_id_pointer_create(&ob->id, ptr);
97                                                 return &ob->gpd;
98                                         }
99                                         /* else: defaults to scene... */
100                                 }
101                                 else {
102                                         if (ptr) RNA_id_pointer_create(&scene->id, ptr);
103                                         return &scene->gpd;
104                                 }
105                                 break;
106                         }
107                         case SPACE_NODE: /* Nodes Editor */
108                         {
109                                 SpaceNode *snode = (SpaceNode *)sl;
110                                 
111                                 /* return the GP data for the active node block/node */
112                                 if (snode && snode->nodetree) {
113                                         /* for now, as long as there's an active node tree, default to using that in the Nodes Editor */
114                                         if (ptr) RNA_id_pointer_create(&snode->nodetree->id, ptr);
115                                         return &snode->nodetree->gpd;
116                                 }
117                                 
118                                 /* even when there is no node-tree, don't allow this to flow to scene */
119                                 return NULL;
120                         }
121                         case SPACE_SEQ: /* Sequencer */
122                         {
123                                 SpaceSeq *sseq = (SpaceSeq *)sl;
124                         
125                                 /* for now, Grease Pencil data is associated with the space (actually preview region only) */
126                                 /* XXX our convention for everything else is to link to data though... */
127                                 if (ptr) RNA_pointer_create(screen_id, &RNA_SpaceSequenceEditor, sseq, ptr);
128                                 return &sseq->gpd;
129                         }
130                         case SPACE_IMAGE: /* Image/UV Editor */
131                         {
132                                 SpaceImage *sima = (SpaceImage *)sl;
133                                 
134                                 /* for now, Grease Pencil data is associated with the space... */
135                                 /* XXX our convention for everything else is to link to data though... */
136                                 if (ptr) RNA_pointer_create(screen_id, &RNA_SpaceImageEditor, sima, ptr);
137                                 return &sima->gpd;
138                         }
139                         case SPACE_CLIP: /* Nodes Editor */
140                         {
141                                 SpaceClip *sc = (SpaceClip *)sl;
142                                 MovieClip *clip = ED_space_clip_get_clip(sc);
143                                 
144                                 if (clip) {
145                                         if (sc->gpencil_src == SC_GPENCIL_SRC_TRACK) {
146                                                 MovieTrackingTrack *track = BKE_tracking_track_get_active(&clip->tracking);
147                                                 
148                                                 if (!track)
149                                                         return NULL;
150                                                 
151                                                 if (ptr)
152                                                         RNA_pointer_create(&clip->id, &RNA_MovieTrackingTrack, track, ptr);
153                                                 
154                                                 return &track->gpd;
155                                         }
156                                         else {
157                                                 if (ptr)
158                                                         RNA_id_pointer_create(&clip->id, ptr);
159                                                 
160                                                 return &clip->gpd;
161                                         }
162                                 }
163                                 break;
164                         }
165                         default: /* unsupported space */
166                                 return NULL;
167                 }
168         }
169         
170         /* just fall back on the scene's GP data */
171         if (ptr) RNA_id_pointer_create((ID *)scene, ptr);
172         return (scene) ? &scene->gpd : NULL;
173 }
174
175 /* Get pointer to active Grease Pencil datablock, and an RNA-pointer to trace back to whatever owns it */
176 bGPdata **ED_gpencil_data_get_pointers(const bContext *C, PointerRNA *ptr)
177 {
178         ID *screen_id = (ID *)CTX_wm_screen(C);
179         Scene *scene = CTX_data_scene(C);
180         ScrArea *sa = CTX_wm_area(C);
181         Object *ob = CTX_data_active_object(C);
182         
183         return ED_gpencil_data_get_pointers_direct(screen_id, scene, sa, ob, ptr);
184 }
185
186 /* -------------------------------------------------------- */
187
188 /* Get the active Grease Pencil datablock, when context is not available */
189 bGPdata *ED_gpencil_data_get_active_direct(ID *screen_id, Scene *scene, ScrArea *sa, Object *ob)
190 {
191         bGPdata **gpd_ptr = ED_gpencil_data_get_pointers_direct(screen_id, scene, sa, ob, NULL);
192         return (gpd_ptr) ? *(gpd_ptr) : NULL;
193 }
194
195 /* Get the active Grease Pencil datablock */
196 bGPdata *ED_gpencil_data_get_active(const bContext *C)
197 {
198         bGPdata **gpd_ptr = ED_gpencil_data_get_pointers(C, NULL);
199         return (gpd_ptr) ? *(gpd_ptr) : NULL;
200 }
201
202 /* -------------------------------------------------------- */
203
204 // XXX: this should be removed... We really shouldn't duplicate logic like this!
205 bGPdata *ED_gpencil_data_get_active_v3d(Scene *scene, View3D *v3d)
206 {
207         BaseLegacy *base = scene->basact;
208         bGPdata *gpd = NULL;
209         /* We have to make sure active object is actually visible and selected, else we must use default scene gpd,
210          * to be consistent with ED_gpencil_data_get_active's behavior.
211          */
212         
213         if (base && TESTBASE(v3d, base)) {
214                 gpd = base->object->gpd;
215         }
216         return gpd ? gpd : scene->gpd;
217 }
218
219 /* ******************************************************** */
220 /* Keyframe Indicator Checks */
221
222 /* Check whether there's an active GP keyframe on the current frame */
223 bool ED_gpencil_has_keyframe_v3d(Scene *scene, Object *ob, int cfra)
224 {
225         /* just check both for now... */
226         // XXX: this could get confusing (e.g. if only on the object, but other places don't show this)
227         if (scene->gpd) {
228                 bGPDlayer *gpl = BKE_gpencil_layer_getactive(scene->gpd);
229                 if (gpl) {
230                         if (gpl->actframe) {
231                                 // XXX: assumes that frame has been fetched already
232                                 return (gpl->actframe->framenum == cfra);
233                         }
234                         else {
235                                 /* XXX: disabled as could be too much of a penalty */
236                                 /* return BKE_gpencil_layer_find_frame(gpl, cfra); */
237                         }
238                 }
239         }
240         
241         if (ob && ob->gpd) {
242                 bGPDlayer *gpl = BKE_gpencil_layer_getactive(ob->gpd);
243                 if (gpl) {
244                         if (gpl->actframe) {
245                                 // XXX: assumes that frame has been fetched already
246                                 return (gpl->actframe->framenum == cfra);
247                         }
248                         else {
249                                 /* XXX: disabled as could be too much of a penalty */
250                                 /* return BKE_gpencil_layer_find_frame(gpl, cfra); */
251                         }
252                 }
253         }
254         
255         return false;
256 }
257
258 /* ******************************************************** */
259 /* Poll Callbacks */
260
261 /* poll callback for adding data/layers - special */
262 int gp_add_poll(bContext *C)
263 {
264         /* the base line we have is that we have somewhere to add Grease Pencil data */
265         return ED_gpencil_data_get_pointers(C, NULL) != NULL;
266 }
267
268 /* poll callback for checking if there is an active layer */
269 int gp_active_layer_poll(bContext *C)
270 {
271         bGPdata *gpd = ED_gpencil_data_get_active(C);
272         bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
273         
274         return (gpl != NULL);
275 }
276
277 /* poll callback for checking if there is an active brush */
278 int gp_active_brush_poll(bContext *C)
279 {
280         ToolSettings *ts = CTX_data_tool_settings(C);
281         bGPDbrush *brush = BKE_gpencil_brush_getactive(ts);
282
283         return (brush != NULL);
284 }
285
286 /* poll callback for checking if there is an active palette */
287 int gp_active_palette_poll(bContext *C)
288 {
289         bGPdata *gpd = ED_gpencil_data_get_active(C);
290         bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
291
292         return (palette != NULL);
293 }
294
295 /* poll callback for checking if there is an active palette color */
296 int gp_active_palettecolor_poll(bContext *C)
297 {
298         bGPdata *gpd = ED_gpencil_data_get_active(C);
299         bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
300         bGPDpalettecolor *palcolor = BKE_gpencil_palettecolor_getactive(palette);
301
302         return (palcolor != NULL);
303 }
304
305 /* ******************************************************** */
306 /* Dynamic Enums of GP Layers */
307 /* NOTE: These include an option to create a new layer and use that... */
308
309 /* Just existing layers */
310 EnumPropertyItem *ED_gpencil_layers_enum_itemf(bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
311 {
312         bGPdata *gpd = CTX_data_gpencil_data(C);
313         bGPDlayer *gpl;
314         EnumPropertyItem *item = NULL, item_tmp = {0};
315         int totitem = 0;
316         int i = 0;
317         
318         if (ELEM(NULL, C, gpd)) {
319                 return DummyRNA_DEFAULT_items;
320         }
321         
322         /* Existing layers */
323         for (gpl = gpd->layers.first; gpl; gpl = gpl->next, i++) {
324                 item_tmp.identifier = gpl->info;
325                 item_tmp.name = gpl->info;
326                 item_tmp.value = i;
327                 
328                 if (gpl->flag & GP_LAYER_ACTIVE)
329                         item_tmp.icon = ICON_GREASEPENCIL;
330                 else 
331                         item_tmp.icon = ICON_NONE;
332                 
333                 RNA_enum_item_add(&item, &totitem, &item_tmp);
334         }
335         
336         RNA_enum_item_end(&item, &totitem);
337         *r_free = true;
338
339         return item;
340 }
341
342 /* Existing + Option to add/use new layer */
343 EnumPropertyItem *ED_gpencil_layers_with_new_enum_itemf(bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
344 {
345         bGPdata *gpd = CTX_data_gpencil_data(C);
346         bGPDlayer *gpl;
347         EnumPropertyItem *item = NULL, item_tmp = {0};
348         int totitem = 0;
349         int i = 0;
350         
351         if (ELEM(NULL, C, gpd)) {
352                 return DummyRNA_DEFAULT_items;
353         }
354         
355         /* Create new layer */
356         /* TODO: have some way of specifying that we don't want this? */
357         {
358                 /* active Keying Set */
359                 item_tmp.identifier = "__CREATE__";
360                 item_tmp.name = "New Layer";
361                 item_tmp.value = -1;
362                 item_tmp.icon = ICON_ZOOMIN;
363                 RNA_enum_item_add(&item, &totitem, &item_tmp);
364                 
365                 /* separator */
366                 RNA_enum_item_add_separator(&item, &totitem);
367         }
368         
369         /* Existing layers */
370         for (gpl = gpd->layers.first, i = 0; gpl; gpl = gpl->next, i++) {
371                 item_tmp.identifier = gpl->info;
372                 item_tmp.name = gpl->info;
373                 item_tmp.value = i;
374                 
375                 if (gpl->flag & GP_LAYER_ACTIVE)
376                         item_tmp.icon = ICON_GREASEPENCIL;
377                 else 
378                         item_tmp.icon = ICON_NONE;
379                 
380                 RNA_enum_item_add(&item, &totitem, &item_tmp);
381         }
382         
383         RNA_enum_item_end(&item, &totitem);
384         *r_free = true;
385
386         return item;
387 }
388
389
390
391 /* ******************************************************** */
392 /* Brush Tool Core */
393
394 /**
395  * Check whether a given stroke segment is inside a circular brush
396  *
397  * \param mval     The current screen-space coordinates (midpoint) of the brush
398  * \param mvalo    The previous screen-space coordinates (midpoint) of the brush (NOT CURRENTLY USED)
399  * \param rad      The radius of the brush
400  *
401  * \param x0, y0   The screen-space x and y coordinates of the start of the stroke segment
402  * \param x1, y1   The screen-space x and y coordinates of the end of the stroke segment
403  */
404 bool gp_stroke_inside_circle(const int mval[2], const int UNUSED(mvalo[2]),
405                              int rad, int x0, int y0, int x1, int y1)
406 {
407         /* simple within-radius check for now */
408         const float mval_fl[2]     = {mval[0], mval[1]};
409         const float screen_co_a[2] = {x0, y0};
410         const float screen_co_b[2] = {x1, y1};
411         
412         if (edge_inside_circle(mval_fl, rad, screen_co_a, screen_co_b)) {
413                 return true;
414         }
415         
416         /* not inside */
417         return false;
418 }
419
420 /* ******************************************************** */
421 /* Stroke Validity Testing */
422
423 /* Check whether given stroke can be edited given the supplied context */
424 // XXX: do we need additional flags for screenspace vs dataspace?
425 bool ED_gpencil_stroke_can_use_direct(const ScrArea *sa, const bGPDstroke *gps)
426 {
427         /* sanity check */
428         if (ELEM(NULL, sa, gps))
429                 return false;
430
431         /* filter stroke types by flags + spacetype */
432         if (gps->flag & GP_STROKE_3DSPACE) {
433                 /* 3D strokes - only in 3D view */
434                 return (sa->spacetype == SPACE_VIEW3D);
435         }
436         else if (gps->flag & GP_STROKE_2DIMAGE) {
437                 /* Special "image" strokes - only in Image Editor */
438                 return (sa->spacetype == SPACE_IMAGE);
439         }
440         else if (gps->flag & GP_STROKE_2DSPACE) {
441                 /* 2D strokes (dataspace) - for any 2D view (i.e. everything other than 3D view) */
442                 return (sa->spacetype != SPACE_VIEW3D);
443         }
444         else {
445                 /* view aligned - anything goes */
446                 return true;
447         }
448 }
449
450 /* Check whether given stroke can be edited in the current context */
451 bool ED_gpencil_stroke_can_use(const bContext *C, const bGPDstroke *gps)
452 {
453         ScrArea *sa = CTX_wm_area(C);
454         return ED_gpencil_stroke_can_use_direct(sa, gps);
455 }
456
457 /* Check whether given stroke can be edited for the current color */
458 bool ED_gpencil_stroke_color_use(const bGPDlayer *gpl, const bGPDstroke *gps)
459 {
460         /* check if the color is editable */
461         bGPDpalettecolor *palcolor = gps->palcolor;
462         if (palcolor != NULL) {
463                 if (palcolor->flag & PC_COLOR_HIDE)
464                         return false;
465                 if (((gpl->flag & GP_LAYER_UNLOCK_COLOR) == 0) && (palcolor->flag & PC_COLOR_LOCKED))
466                         return false;
467         }
468         
469         return true;
470 }
471
472 /* Get palette color or create a new one */
473 bGPDpalettecolor *ED_gpencil_stroke_getcolor(bGPdata *gpd, bGPDstroke *gps)
474 {
475         bGPDpalette *palette;
476         bGPDpalettecolor *palcolor;
477
478         if ((gps->palcolor != NULL) && ((gps->flag & GP_STROKE_RECALC_COLOR) == 0))
479                 return gps->palcolor;
480
481         /* get palette */
482         palette = BKE_gpencil_palette_getactive(gpd);
483         if (palette == NULL) {
484                 palette = BKE_gpencil_palette_addnew(gpd, DATA_("GP_Palette"), true);
485         }
486         /* get color */
487         palcolor = BKE_gpencil_palettecolor_getbyname(palette, gps->colorname);
488         if (palcolor == NULL) {
489                 if (gps->palcolor == NULL) {
490                         palcolor = BKE_gpencil_palettecolor_addnew(palette, DATA_("Color"), true);
491                         /* set to a different color */
492                         ARRAY_SET_ITEMS(palcolor->color, 1.0f, 0.0f, 1.0f, 0.9f);
493                 }
494                 else {
495                         palcolor = BKE_gpencil_palettecolor_addnew(palette, gps->colorname, true);
496                         /* set old color and attributes */
497                         bGPDpalettecolor *gpscolor = gps->palcolor;
498                         copy_v4_v4(palcolor->color, gpscolor->color);
499                         copy_v4_v4(palcolor->fill, gpscolor->fill);
500                         palcolor->flag = gpscolor->flag;
501                 }
502         }
503
504         /* clear flag and set pointer */
505         gps->flag &= ~GP_STROKE_RECALC_COLOR;
506         gps->palcolor = palcolor;
507
508         return palcolor;
509 }
510
511 /* ******************************************************** */
512 /* Space Conversion */
513
514 /**
515  * Init settings for stroke point space conversions
516  *
517  * \param r_gsc: [out] The space conversion settings struct, populated with necessary params
518  */
519 void gp_point_conversion_init(bContext *C, GP_SpaceConversion *r_gsc)
520 {
521         ScrArea *sa = CTX_wm_area(C);
522         ARegion *ar = CTX_wm_region(C);
523         
524         /* zero out the storage (just in case) */
525         memset(r_gsc, 0, sizeof(GP_SpaceConversion));
526         unit_m4(r_gsc->mat);
527         
528         /* store settings */
529         r_gsc->sa = sa;
530         r_gsc->ar = ar;
531         r_gsc->v2d = &ar->v2d;
532         
533         /* init region-specific stuff */
534         if (sa->spacetype == SPACE_VIEW3D) {
535                 wmWindow *win = CTX_wm_window(C);
536                 Scene *scene = CTX_data_scene(C);
537                 struct Depsgraph *graph = CTX_data_depsgraph(C);
538                 View3D *v3d = (View3D *)CTX_wm_space_data(C);
539                 RegionView3D *rv3d = ar->regiondata;
540                 
541                 /* init 3d depth buffers */
542                 view3d_operator_needs_opengl(C);
543                 
544                 view3d_region_operator_needs_opengl(win, ar);
545                 ED_view3d_autodist_init(C, graph, ar, v3d, 0);
546                 
547                 /* for camera view set the subrect */
548                 if (rv3d->persp == RV3D_CAMOB) {
549                         ED_view3d_calc_camera_border(scene, ar, v3d, rv3d, &r_gsc->subrect_data, true); /* no shift */
550                         r_gsc->subrect = &r_gsc->subrect_data;
551                 }
552         }
553 }
554
555 /**
556  * Convert point to parent space
557  *
558  * \param pt         Original point
559  * \param diff_mat   Matrix with the difference between original parent matrix
560  * \param[out] r_pt  Pointer to new point after apply matrix
561  */
562 void gp_point_to_parent_space(bGPDspoint *pt, float diff_mat[4][4], bGPDspoint *r_pt) 
563 {
564         float fpt[3];
565
566         mul_v3_m4v3(fpt, diff_mat, &pt->x);
567         copy_v3_v3(&r_pt->x, fpt);
568 }
569
570 /**
571  * Change points position relative to parent object
572  */
573 void gp_apply_parent(bGPDlayer *gpl, bGPDstroke *gps)
574 {
575         bGPDspoint *pt;
576         int i;
577
578         /* undo matrix */
579         float diff_mat[4][4];
580         float inverse_diff_mat[4][4];
581         float fpt[3];
582
583         ED_gpencil_parent_location(gpl, diff_mat);
584         invert_m4_m4(inverse_diff_mat, diff_mat);
585
586         for (i = 0; i < gps->totpoints; i++) {
587                 pt = &gps->points[i];
588                 mul_v3_m4v3(fpt, inverse_diff_mat, &pt->x);
589                 copy_v3_v3(&pt->x, fpt);
590         }
591 }
592
593 /**
594  * Change point position relative to parent object
595  */
596 void gp_apply_parent_point(bGPDlayer *gpl, bGPDspoint *pt)
597 {
598         /* undo matrix */
599         float diff_mat[4][4];
600         float inverse_diff_mat[4][4];
601         float fpt[3];
602
603         ED_gpencil_parent_location(gpl, diff_mat);
604         invert_m4_m4(inverse_diff_mat, diff_mat);
605
606         mul_v3_m4v3(fpt, inverse_diff_mat, &pt->x);
607         copy_v3_v3(&pt->x, fpt);
608 }
609
610 /**
611  * Convert a Grease Pencil coordinate (i.e. can be 2D or 3D) to screenspace (2D)
612  *
613  * \param[out] r_x  The screen-space x-coordinate of the point
614  * \param[out] r_y  The screen-space y-coordinate of the point
615  *
616  * \warning This assumes that the caller has already checked whether the stroke in question can be drawn.
617  */
618 void gp_point_to_xy(GP_SpaceConversion *gsc, bGPDstroke *gps, bGPDspoint *pt,
619                     int *r_x, int *r_y)
620 {
621         ARegion *ar = gsc->ar;
622         View2D *v2d = gsc->v2d;
623         rctf *subrect = gsc->subrect;
624         int xyval[2];
625         
626         /* sanity checks */
627         BLI_assert(!(gps->flag & GP_STROKE_3DSPACE) || (gsc->sa->spacetype == SPACE_VIEW3D));
628         BLI_assert(!(gps->flag & GP_STROKE_2DSPACE) || (gsc->sa->spacetype != SPACE_VIEW3D));
629         
630         
631         if (gps->flag & GP_STROKE_3DSPACE) {
632                 if (ED_view3d_project_int_global(ar, &pt->x, xyval, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
633                         *r_x = xyval[0];
634                         *r_y = xyval[1];
635                 }
636                 else {
637                         *r_x = V2D_IS_CLIPPED;
638                         *r_y = V2D_IS_CLIPPED;
639                 }
640         }
641         else if (gps->flag & GP_STROKE_2DSPACE) {
642                 float vec[3] = {pt->x, pt->y, 0.0f};
643                 mul_m4_v3(gsc->mat, vec);
644                 UI_view2d_view_to_region_clip(v2d, vec[0], vec[1], r_x, r_y);
645         }
646         else {
647                 if (subrect == NULL) {
648                         /* normal 3D view (or view space) */
649                         *r_x = (int)(pt->x / 100 * ar->winx);
650                         *r_y = (int)(pt->y / 100 * ar->winy);
651                 }
652                 else {
653                         /* camera view, use subrect */
654                         *r_x = (int)((pt->x / 100) * BLI_rctf_size_x(subrect)) + subrect->xmin;
655                         *r_y = (int)((pt->y / 100) * BLI_rctf_size_y(subrect)) + subrect->ymin;
656                 }
657         }
658 }
659
660 /**
661  * Convert a Grease Pencil coordinate (i.e. can be 2D or 3D) to screenspace (2D)
662  *
663  * Just like gp_point_to_xy(), except the resulting coordinates are floats not ints.
664  * Use this version to solve "stair-step" artifacts which may arise when roundtripping the calculations.
665  *
666  * \param r_x: [out] The screen-space x-coordinate of the point
667  * \param r_y: [out] The screen-space y-coordinate of the point
668  *
669  * \warning This assumes that the caller has already checked whether the stroke in question can be drawn
670  */
671 void gp_point_to_xy_fl(GP_SpaceConversion *gsc, bGPDstroke *gps, bGPDspoint *pt,
672                        float *r_x, float *r_y)
673 {
674         ARegion *ar = gsc->ar;
675         View2D *v2d = gsc->v2d;
676         rctf *subrect = gsc->subrect;
677         float xyval[2];
678         
679         /* sanity checks */
680         BLI_assert(!(gps->flag & GP_STROKE_3DSPACE) || (gsc->sa->spacetype == SPACE_VIEW3D));
681         BLI_assert(!(gps->flag & GP_STROKE_2DSPACE) || (gsc->sa->spacetype != SPACE_VIEW3D));
682         
683         
684         if (gps->flag & GP_STROKE_3DSPACE) {
685                 if (ED_view3d_project_float_global(ar, &pt->x, xyval, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
686                         *r_x = xyval[0];
687                         *r_y = xyval[1];
688                 }
689                 else {
690                         *r_x = 0.0f;
691                         *r_y = 0.0f;
692                 }
693         }
694         else if (gps->flag & GP_STROKE_2DSPACE) {
695                 float vec[3] = {pt->x, pt->y, 0.0f};
696                 int t_x, t_y;
697                 
698                 mul_m4_v3(gsc->mat, vec);
699                 UI_view2d_view_to_region_clip(v2d, vec[0], vec[1], &t_x, &t_y);
700                 
701                 if ((t_x == t_y) && (t_x == V2D_IS_CLIPPED)) {
702                         /* XXX: Or should we just always use the values as-is? */
703                         *r_x = 0.0f;
704                         *r_y = 0.0f;
705                 }
706                 else {
707                         *r_x = (float)t_x;
708                         *r_y = (float)t_y;
709                 }
710         }
711         else {
712                 if (subrect == NULL) {
713                         /* normal 3D view (or view space) */
714                         *r_x = (pt->x / 100.0f * ar->winx);
715                         *r_y = (pt->y / 100.0f * ar->winy);
716                 }
717                 else {
718                         /* camera view, use subrect */
719                         *r_x = ((pt->x / 100.0f) * BLI_rctf_size_x(subrect)) + subrect->xmin;
720                         *r_y = ((pt->y / 100.0f) * BLI_rctf_size_y(subrect)) + subrect->ymin;
721                 }
722         }
723 }
724
725 /**
726  * Project screenspace coordinates to 3D-space
727  *
728  * For use with editing tools where it is easier to perform the operations in 2D,
729  * and then later convert the transformed points back to 3D.
730  *
731  * \param screen_co: The screenspace 2D coordinates to convert to
732  * \param r_out: The resulting 3D coordinates of the input point
733  *
734  * \note We include this as a utility function, since the standard method
735  * involves quite a few steps, which are invariably always the same
736  * for all GPencil operations. So, it's nicer to just centralize these.
737  *
738  * \warning Assumes that it is getting called in a 3D view only.
739  */
740 bool gp_point_xy_to_3d(GP_SpaceConversion *gsc, Scene *scene, const float screen_co[2], float r_out[3])
741 {
742         View3D *v3d = gsc->sa->spacedata.first;
743         RegionView3D *rv3d = gsc->ar->regiondata;
744         float *rvec = ED_view3d_cursor3d_get(scene, v3d);
745         float ref[3] = {rvec[0], rvec[1], rvec[2]};
746         float zfac = ED_view3d_calc_zfac(rv3d, rvec, NULL);
747         
748         float mval_f[2], mval_prj[2];
749         float dvec[3];
750         
751         copy_v2_v2(mval_f, screen_co);
752         
753         if (ED_view3d_project_float_global(gsc->ar, ref, mval_prj, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
754                 sub_v2_v2v2(mval_f, mval_prj, mval_f);
755                 ED_view3d_win_to_delta(gsc->ar, mval_f, dvec, zfac);
756                 sub_v3_v3v3(r_out, rvec, dvec);
757                 
758                 return true;
759         }
760         else {
761                 zero_v3(r_out);
762                 
763                 return false;
764         }
765 }
766
767 /**
768  * Apply smooth to stroke point
769  * \param gps              Stroke to smooth
770  * \param i                Point index
771  * \param inf              Amount of smoothing to apply
772  * \param affect_pressure  Apply smoothing to pressure values too?
773  */
774 bool gp_smooth_stroke(bGPDstroke *gps, int i, float inf, bool affect_pressure)
775 {
776         bGPDspoint *pt = &gps->points[i];
777         float pressure = 0.0f;
778         float sco[3] = {0.0f};
779         
780         /* Do nothing if not enough points to smooth out */
781         if (gps->totpoints <= 2) {
782                 return false;
783         }
784         
785         /* Only affect endpoints by a fraction of the normal strength,
786          * to prevent the stroke from shrinking too much
787          */
788         if ((i == 0) || (i == gps->totpoints - 1)) {
789                 inf *= 0.1f;
790         }
791         
792         /* Compute smoothed coordinate by taking the ones nearby */
793         /* XXX: This is potentially slow, and suffers from accumulation error as earlier points are handled before later ones */
794         {
795                 // XXX: this is hardcoded to look at 2 points on either side of the current one (i.e. 5 items total)
796                 const int   steps = 2;
797                 const float average_fac = 1.0f / (float)(steps * 2 + 1);
798                 int step;
799                 
800                 /* add the point itself */
801                 madd_v3_v3fl(sco, &pt->x, average_fac);
802                 
803                 if (affect_pressure) {
804                         pressure += pt->pressure * average_fac;
805                 }
806                 
807                 /* n-steps before/after current point */
808                 // XXX: review how the endpoints are treated by this algorithm
809                 // XXX: falloff measures should also introduce some weighting variations, so that further-out points get less weight
810                 for (step = 1; step <= steps; step++) {
811                         bGPDspoint *pt1, *pt2;
812                         int before = i - step;
813                         int after = i + step;
814                         
815                         CLAMP_MIN(before, 0);
816                         CLAMP_MAX(after, gps->totpoints - 1);
817                         
818                         pt1 = &gps->points[before];
819                         pt2 = &gps->points[after];
820                         
821                         /* add both these points to the average-sum (s += p[i]/n) */
822                         madd_v3_v3fl(sco, &pt1->x, average_fac);
823                         madd_v3_v3fl(sco, &pt2->x, average_fac);
824                         
825 #if 0
826                         /* XXX: Disabled because get weird result */
827                         /* do pressure too? */
828                         if (affect_pressure) {
829                                 pressure += pt1->pressure * average_fac;
830                                 pressure += pt2->pressure * average_fac;
831                         }
832 #endif
833                 }
834         }
835         
836         /* Based on influence factor, blend between original and optimal smoothed coordinate */
837         interp_v3_v3v3(&pt->x, &pt->x, sco, inf);
838         
839 #if 0
840         /* XXX: Disabled because get weird result */
841         if (affect_pressure) {
842                 pt->pressure = pressure;
843         }
844 #endif
845         
846         return true;
847 }
848
849 /**
850 * Apply smooth for strength to stroke point
851 * \param gps              Stroke to smooth
852 * \param i                Point index
853 * \param inf              Amount of smoothing to apply
854 */
855 bool gp_smooth_stroke_strength(bGPDstroke *gps, int i, float inf)
856 {
857         bGPDspoint *ptb = &gps->points[i];
858
859         /* Do nothing if not enough points */
860         if (gps->totpoints <= 2) {
861                 return false;
862         }
863
864         /* Compute theoretical optimal value using distances */
865         bGPDspoint *pta, *ptc;
866         int before = i - 1;
867         int after = i + 1;
868
869         CLAMP_MIN(before, 0);
870         CLAMP_MAX(after, gps->totpoints - 1);
871
872         pta = &gps->points[before];
873         ptc = &gps->points[after];
874
875         /* the optimal value is the corresponding to the interpolation of the strength
876          *  at the distance of point b
877          */
878         const float fac = line_point_factor_v3(&ptb->x, &pta->x, &ptc->x);
879         const float optimal = (1.0f - fac) * pta->strength + fac * ptc->strength;
880
881         /* Based on influence factor, blend between original and optimal */
882         ptb->strength = (1.0f - inf) * ptb->strength + inf * optimal;
883
884         return true;
885 }
886
887 /**
888 * Apply smooth for thickness to stroke point (use pressure)
889 * \param gps              Stroke to smooth
890 * \param i                Point index
891 * \param inf              Amount of smoothing to apply
892 */
893 bool gp_smooth_stroke_thickness(bGPDstroke *gps, int i, float inf)
894 {
895         bGPDspoint *ptb = &gps->points[i];
896
897         /* Do nothing if not enough points */
898         if (gps->totpoints <= 2) {
899                 return false;
900         }
901
902         /* Compute theoretical optimal value using distances */
903         bGPDspoint *pta, *ptc;
904         int before = i - 1;
905         int after = i + 1;
906
907         CLAMP_MIN(before, 0);
908         CLAMP_MAX(after, gps->totpoints - 1);
909
910         pta = &gps->points[before];
911         ptc = &gps->points[after];
912
913         /* the optimal value is the corresponding to the interpolation of the pressure
914          *  at the distance of point b
915          */
916         float fac = line_point_factor_v3(&ptb->x, &pta->x, &ptc->x);
917         float optimal = (1.0f - fac) * pta->pressure + fac * ptc->pressure;
918
919         /* Based on influence factor, blend between original and optimal */
920         ptb->pressure = (1.0f - inf) * ptb->pressure + inf * optimal;
921
922         return true;
923 }
924
925 /**
926  * Subdivide a stroke once, by adding a point half way between each pair of existing points
927  * \param gps           Stroke data
928  * \param new_totpoints Total number of points (after subdividing)
929  */
930 void gp_subdivide_stroke(bGPDstroke *gps, const int new_totpoints)
931 {
932         /* Move points towards end of enlarged points array to leave space for new points */
933         int y = 1;
934         for (int i = gps->totpoints - 1; i > 0; i--) {
935                 gps->points[new_totpoints - y] = gps->points[i];
936                 y += 2;
937         }
938         
939         /* Create interpolated points */
940         for (int i = 0; i < new_totpoints - 1; i += 2) {
941                 bGPDspoint *prev  = &gps->points[i];
942                 bGPDspoint *pt    = &gps->points[i + 1];
943                 bGPDspoint *next  = &gps->points[i + 2];
944                 
945                 /* Interpolate all values */
946                 interp_v3_v3v3(&pt->x, &prev->x, &next->x, 0.5f);
947                 
948                 pt->pressure = interpf(prev->pressure, next->pressure, 0.5f);
949                 pt->strength = interpf(prev->strength, next->strength, 0.5f);
950                 CLAMP(pt->strength, GPENCIL_STRENGTH_MIN, 1.0f);
951                 pt->time = interpf(prev->time, next->time, 0.5f);
952         }
953         
954         /* Update to new total number of points */
955         gps->totpoints = new_totpoints;
956 }
957
958 /**
959  * Add randomness to stroke
960  * \param gps           Stroke data
961  * \param brush         Brush data
962  */
963 void gp_randomize_stroke(bGPDstroke *gps, bGPDbrush *brush)
964 {
965         bGPDspoint *pt1, *pt2, *pt3;
966         float v1[3];
967         float v2[3];
968         if (gps->totpoints < 3) {
969                 return;
970         }
971
972         /* get two vectors using 3 points */
973         pt1 = &gps->points[0];
974         pt2 = &gps->points[1];
975         pt3 = &gps->points[(int)(gps->totpoints * 0.75)];
976
977         sub_v3_v3v3(v1, &pt2->x, &pt1->x);
978         sub_v3_v3v3(v2, &pt3->x, &pt2->x);
979         normalize_v3(v1);
980         normalize_v3(v2);
981
982         /* get normal vector to plane created by two vectors */
983         float normal[3];
984         cross_v3_v3v3(normal, v1, v2);
985         normalize_v3(normal);
986         
987         /* get orthogonal vector to plane to rotate random effect */
988         float ortho[3];
989         cross_v3_v3v3(ortho, v1, normal);
990         normalize_v3(ortho);
991         
992         /* Read all points and apply shift vector (first and last point not modified) */
993         for (int i = 1; i < gps->totpoints - 1; ++i) {
994                 bGPDspoint *pt = &gps->points[i];
995                 /* get vector with shift (apply a division because random is too sensitive */
996                 const float fac = BLI_frand() * (brush->draw_random_sub / 10.0f);
997                 float svec[3];
998                 copy_v3_v3(svec, ortho);
999                 if (BLI_frand() > 0.5f) {
1000                         mul_v3_fl(svec, -fac);
1001                 }
1002                 else {
1003                         mul_v3_fl(svec, fac);
1004                 }
1005
1006                 /* apply shift */
1007                 add_v3_v3(&pt->x, svec);
1008         }
1009
1010 }
1011 /* calculate difference matrix */
1012 void ED_gpencil_parent_location(bGPDlayer *gpl, float diff_mat[4][4])
1013 {
1014         Object *ob = gpl->parent;
1015
1016         if (ob == NULL) {
1017                 unit_m4(diff_mat);
1018                 return;
1019         }
1020         else {
1021                 if ((gpl->partype == PAROBJECT) || (gpl->partype == PARSKEL)) {
1022                         mul_m4_m4m4(diff_mat, ob->obmat, gpl->inverse);
1023                         return;
1024                 }
1025                 else if (gpl->partype == PARBONE) {
1026                         bPoseChannel *pchan = BKE_pose_channel_find_name(ob->pose, gpl->parsubstr);
1027                         if (pchan) {
1028                                 float tmp_mat[4][4];
1029                                 mul_m4_m4m4(tmp_mat, ob->obmat, pchan->pose_mat);
1030                                 mul_m4_m4m4(diff_mat, tmp_mat, gpl->inverse);
1031                         }
1032                         else {
1033                                 mul_m4_m4m4(diff_mat, ob->obmat, gpl->inverse); /* if bone not found use object (armature) */
1034                         }
1035                         return;
1036                 }
1037                 else {
1038                         unit_m4(diff_mat); /* not defined type */
1039                 }
1040         }
1041 }
1042
1043 /* reset parent matrix for all layers */
1044 void ED_gpencil_reset_layers_parent(bGPdata *gpd)
1045 {
1046         bGPDspoint *pt;
1047         int i;
1048         float diff_mat[4][4];
1049         float cur_mat[4][4];
1050
1051         for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1052                 if (gpl->parent != NULL) {
1053                         /* calculate new matrix */
1054                         if ((gpl->partype == PAROBJECT) || (gpl->partype == PARSKEL)) {
1055                                 invert_m4_m4(cur_mat, gpl->parent->obmat);
1056                         }
1057                         else if (gpl->partype == PARBONE) {
1058                                 bPoseChannel *pchan = BKE_pose_channel_find_name(gpl->parent->pose, gpl->parsubstr);
1059                                 if (pchan) {
1060                                         float tmp_mat[4][4];
1061                                         mul_m4_m4m4(tmp_mat, gpl->parent->obmat, pchan->pose_mat);
1062                                         invert_m4_m4(cur_mat, tmp_mat);
1063                                 }
1064                         }
1065
1066                         /* only redo if any change */
1067                         if (!equals_m4m4(gpl->inverse, cur_mat)) {
1068                                 /* first apply current transformation to all strokes */
1069                                 ED_gpencil_parent_location(gpl, diff_mat);
1070                                 for (bGPDframe *gpf = gpl->frames.first; gpf; gpf = gpf->next) {
1071                                         for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
1072                                                 for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
1073                                                         mul_m4_v3(diff_mat, &pt->x);
1074                                                 }
1075                                         }
1076                                 }
1077                                 /* set new parent matrix */
1078                                 copy_m4_m4(gpl->inverse, cur_mat);
1079                         }
1080                 }
1081         }
1082 }
1083 /* ******************************************************** */
1084 bool ED_gpencil_stroke_minmax(
1085         const bGPDstroke *gps, const bool use_select,
1086         float r_min[3], float r_max[3])
1087 {
1088         const bGPDspoint *pt;
1089         int i;
1090         bool changed = false;
1091
1092         for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
1093                 if ((use_select == false) || (pt->flag & GP_SPOINT_SELECT)) {;
1094                         minmax_v3v3_v3(r_min, r_max, &pt->x);
1095                         changed = true;
1096                 }
1097         }
1098         return changed;
1099 }
1100
1101 /* Dynamic Enums of GP Brushes */
1102 EnumPropertyItem *ED_gpencil_brushes_enum_itemf(
1103         bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop),
1104         bool *r_free)
1105 {
1106         ToolSettings *ts = CTX_data_tool_settings(C);
1107         bGPDbrush *brush;
1108         EnumPropertyItem *item = NULL, item_tmp = { 0 };
1109         int totitem = 0;
1110         int i = 0;
1111
1112         if (ELEM(NULL, C, ts)) {
1113                 return DummyRNA_DEFAULT_items;
1114         }
1115
1116         /* Existing brushes */
1117         for (brush = ts->gp_brushes.first; brush; brush = brush->next, i++) {
1118                 item_tmp.identifier = brush->info;
1119                 item_tmp.name = brush->info;
1120                 item_tmp.value = i;
1121
1122                 if (brush->flag & GP_BRUSH_ACTIVE)
1123                         item_tmp.icon = ICON_BRUSH_DATA;
1124                 else
1125                         item_tmp.icon = ICON_NONE;
1126
1127                 RNA_enum_item_add(&item, &totitem, &item_tmp);
1128         }
1129
1130         RNA_enum_item_end(&item, &totitem);
1131         *r_free = true;
1132
1133         return item;
1134 }
1135
1136 /* Dynamic Enums of GP Palettes */
1137 EnumPropertyItem *ED_gpencil_palettes_enum_itemf(
1138         bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop),
1139         bool *r_free)
1140 {
1141         bGPdata *gpd = CTX_data_gpencil_data(C);
1142         bGPDpalette *palette;
1143         EnumPropertyItem *item = NULL, item_tmp = { 0 };
1144         int totitem = 0;
1145         int i = 0;
1146
1147         if (ELEM(NULL, C, gpd)) {
1148                 return DummyRNA_DEFAULT_items;
1149         }
1150
1151         /* Existing palettes */
1152         for (palette = gpd->palettes.first; palette; palette = palette->next, i++) {
1153                 item_tmp.identifier = palette->info;
1154                 item_tmp.name = palette->info;
1155                 item_tmp.value = i;
1156
1157                 if (palette->flag & PL_PALETTE_ACTIVE)
1158                         item_tmp.icon = ICON_COLOR;
1159                 else
1160                         item_tmp.icon = ICON_NONE;
1161
1162                 RNA_enum_item_add(&item, &totitem, &item_tmp);
1163         }
1164
1165         RNA_enum_item_end(&item, &totitem);
1166         *r_free = true;
1167
1168         return item;
1169 }
1170 /* ******************************************************** */