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