b78c292236ad190a2b6d37aa0ed9e96517906c1f
[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_meshdata_types.h"
44 #include "DNA_gpencil_types.h"
45 #include "DNA_brush_types.h"
46 #include "DNA_object_types.h"
47 #include "DNA_scene_types.h"
48 #include "DNA_screen_types.h"
49 #include "DNA_space_types.h"
50 #include "DNA_view3d_types.h"
51
52 #include "BKE_action.h"
53 #include "BKE_deform.h"
54 #include "BKE_main.h"
55 #include "BKE_brush.h"
56 #include "BKE_context.h"
57 #include "BKE_gpencil.h"
58 #include "BKE_object.h"
59 #include "BKE_paint.h"
60 #include "BKE_material.h"
61 #include "BKE_tracking.h"
62
63 #include "WM_api.h"
64
65 #include "RNA_access.h"
66 #include "RNA_define.h"
67 #include "RNA_enum_types.h"
68
69 #include "UI_resources.h"
70 #include "UI_view2d.h"
71
72 #include "ED_gpencil.h"
73 #include "ED_clip.h"
74 #include "ED_view3d.h"
75 #include "ED_object.h"
76 #include "ED_screen.h"
77
78 #include "GPU_immediate.h"
79 #include "GPU_immediate_util.h"
80
81 #include "DEG_depsgraph.h"
82 #include "DEG_depsgraph_query.h"
83
84 #include "gpencil_intern.h"
85
86 /* ******************************************************** */
87 /* Context Wrangling... */
88
89 /* Get pointer to active Grease Pencil datablock, and an RNA-pointer to trace back to whatever owns it,
90  * when context info is not available.
91  */
92 bGPdata **ED_gpencil_data_get_pointers_direct(ID *screen_id, ScrArea *sa, Scene *scene, Object *ob, PointerRNA *r_ptr)
93 {
94         /* if there's an active area, check if the particular editor may
95          * have defined any special Grease Pencil context for editing...
96          */
97         if (sa) {
98                 SpaceLink *sl = sa->spacedata.first;
99
100                 switch (sa->spacetype) {
101                         /* XXX: Should we reduce reliance on context.gpencil_data for these cases? */
102                         case SPACE_BUTS: /* properties */
103                         case SPACE_INFO: /* header info (needed after workspaces merge) */
104                         {
105                                 if (ob && (ob->type == OB_GPENCIL)) {
106                                         /* GP Object */
107                                         if (r_ptr) RNA_id_pointer_create(&ob->id, r_ptr);
108                                         return (bGPdata **)&ob->data;
109                                 }
110                                 else {
111                                         return NULL;
112                                 }
113
114                                 break;
115                         }
116
117                         case SPACE_TOPBAR: /* Topbar (needed after topbar merge) */
118                         case SPACE_VIEW3D: /* 3D-View */
119                         {
120                                 if (ob && (ob->type == OB_GPENCIL)) {
121                                         /* GP Object */
122                                         if (r_ptr) RNA_id_pointer_create(&ob->id, r_ptr);
123                                         return (bGPdata **)&ob->data;
124                                 }
125                                 else {
126                                         /* Annotations */
127                                         /* XXX: */
128                                         if (r_ptr) RNA_id_pointer_create(&scene->id, r_ptr);
129                                         return &scene->gpd;
130                                 }
131
132                                 break;
133                         }
134                         case SPACE_NODE: /* Nodes Editor */
135                         {
136                                 SpaceNode *snode = (SpaceNode *)sl;
137
138                                 /* return the GP data for the active node block/node */
139                                 if (snode && snode->nodetree) {
140                                         /* for now, as long as there's an active node tree, default to using that in the Nodes Editor */
141                                         if (r_ptr) RNA_id_pointer_create(&snode->nodetree->id, r_ptr);
142                                         return &snode->nodetree->gpd;
143                                 }
144
145                                 /* even when there is no node-tree, don't allow this to flow to scene */
146                                 return NULL;
147                         }
148                         case SPACE_SEQ: /* Sequencer */
149                         {
150                                 SpaceSeq *sseq = (SpaceSeq *)sl;
151
152                                 /* for now, Grease Pencil data is associated with the space (actually preview region only) */
153                                 /* XXX our convention for everything else is to link to data though... */
154                                 if (r_ptr) RNA_pointer_create(screen_id, &RNA_SpaceSequenceEditor, sseq, r_ptr);
155                                 return &sseq->gpd;
156                         }
157                         case SPACE_IMAGE: /* Image/UV Editor */
158                         {
159                                 SpaceImage *sima = (SpaceImage *)sl;
160
161                                 /* for now, Grease Pencil data is associated with the space... */
162                                 /* XXX our convention for everything else is to link to data though... */
163                                 if (r_ptr) RNA_pointer_create(screen_id, &RNA_SpaceImageEditor, sima, r_ptr);
164                                 return &sima->gpd;
165                         }
166                         case SPACE_CLIP: /* Nodes Editor */
167                         {
168                                 SpaceClip *sc = (SpaceClip *)sl;
169                                 MovieClip *clip = ED_space_clip_get_clip(sc);
170
171                                 if (clip) {
172                                         if (sc->gpencil_src == SC_GPENCIL_SRC_TRACK) {
173                                                 MovieTrackingTrack *track = BKE_tracking_track_get_active(&clip->tracking);
174
175                                                 if (!track)
176                                                         return NULL;
177
178                                                 if (r_ptr) RNA_pointer_create(&clip->id, &RNA_MovieTrackingTrack, track, r_ptr);
179                                                 return &track->gpd;
180                                         }
181                                         else {
182                                                 if (r_ptr) RNA_id_pointer_create(&clip->id, r_ptr);
183                                                 return &clip->gpd;
184                                         }
185                                 }
186                                 break;
187                         }
188                         default: /* unsupported space */
189                                 return NULL;
190                 }
191         }
192
193         return NULL;
194 }
195
196 /* Get pointer to active Grease Pencil datablock, and an RNA-pointer to trace back to whatever owns it */
197 bGPdata **ED_gpencil_data_get_pointers(const bContext *C, PointerRNA *r_ptr)
198 {
199         ID *screen_id = (ID *)CTX_wm_screen(C);
200         Scene *scene = CTX_data_scene(C);
201         ScrArea *sa = CTX_wm_area(C);
202         Object *ob = CTX_data_active_object(C);
203
204         return ED_gpencil_data_get_pointers_direct(screen_id, sa, scene, ob, r_ptr);
205 }
206
207 /* -------------------------------------------------------- */
208
209 /* Get the active Grease Pencil datablock, when context is not available */
210 bGPdata *ED_gpencil_data_get_active_direct(ID *screen_id, ScrArea *sa, Scene *scene, Object *ob)
211 {
212         bGPdata **gpd_ptr = ED_gpencil_data_get_pointers_direct(screen_id, sa, scene, ob, NULL);
213         return (gpd_ptr) ? *(gpd_ptr) : NULL;
214 }
215
216 /**
217  * Get the active Grease Pencil datablock
218  * \note This is the original (bmain) copy of the datablock, stored in files.
219  *       Do not use for reading evaluated copies of GP Objects data
220  */
221 bGPdata *ED_gpencil_data_get_active(const bContext *C)
222 {
223         bGPdata **gpd_ptr = ED_gpencil_data_get_pointers(C, NULL);
224         return (gpd_ptr) ? *(gpd_ptr) : NULL;
225 }
226
227 /**
228  * Get the evaluated copy of the active Grease Pencil datablock (where applicable)
229  * - For the 3D View (i.e. "GP Objects"), this gives the evaluated copy of the GP datablock
230  *   (i.e. a copy of the active GP datablock for the active object, where modifiers have been
231  *   applied). This is needed to correctly work with "Copy-on-Write"
232  * - For all other editors (i.e. "GP Annotations"), this just gives the active datablock
233  *   like for ED_gpencil_data_get_active()
234  */
235 bGPdata *ED_gpencil_data_get_active_evaluated(const bContext *C)
236 {
237         ID *screen_id = (ID *)CTX_wm_screen(C);
238         ScrArea *sa = CTX_wm_area(C);
239
240         const Depsgraph *depsgraph = CTX_data_depsgraph(C);
241         Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
242         Object *ob = CTX_data_active_object(C);
243         Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
244
245         /* if (ob && ob->type == OB_GPENCIL) BLI_assert(ob_eval->data == DEG_get_evaluated_id(ob->data)); */
246         return ED_gpencil_data_get_active_direct(screen_id, sa, scene_eval, ob_eval);
247 }
248
249 /* -------------------------------------------------------- */
250
251 /**
252  * Utility to check whether the r_ptr output of ED_gpencil_data_get_pointers()
253  * is for annotation usage.
254  */
255 bool ED_gpencil_data_owner_is_annotation(PointerRNA *owner_ptr)
256 {
257         /* Key Assumption: If the pointer is an object, we're dealing with a GP Object's data.
258          * Otherwise, the GP datablock is being used for annotations (i.e. everywhere else)
259          */
260         return ((owner_ptr) && (owner_ptr->type != &RNA_Object));
261 }
262
263 /* -------------------------------------------------------- */
264
265 // XXX: this should be removed... We really shouldn't duplicate logic like this!
266 bGPdata *ED_gpencil_data_get_active_v3d(ViewLayer *view_layer)
267 {
268         Base *base = view_layer->basact;
269         bGPdata *gpd = NULL;
270
271         /* We have to make sure active object is actually visible and selected, else we must use default scene gpd,
272          * to be consistent with ED_gpencil_data_get_active's behavior.
273          */
274         if (base && TESTBASE(base)) {
275                 if (base->object->type == OB_GPENCIL)
276                         gpd = base->object->data;
277         }
278         return gpd ? gpd : NULL;
279 }
280
281 /* ******************************************************** */
282 /* Keyframe Indicator Checks */
283
284 /* Check whether there's an active GP keyframe on the current frame */
285 bool ED_gpencil_has_keyframe_v3d(Scene *UNUSED(scene), Object *ob, int cfra)
286 {
287         if (ob && ob->data && (ob->type == OB_GPENCIL)) {
288                 bGPDlayer *gpl = BKE_gpencil_layer_getactive(ob->data);
289                 if (gpl) {
290                         if (gpl->actframe) {
291                                 // XXX: assumes that frame has been fetched already
292                                 return (gpl->actframe->framenum == cfra);
293                         }
294                         else {
295                                 /* XXX: disabled as could be too much of a penalty */
296                                 /* return BKE_gpencil_layer_find_frame(gpl, cfra); */
297                         }
298                 }
299         }
300
301         return false;
302 }
303
304 /* ******************************************************** */
305 /* Poll Callbacks */
306
307 /* poll callback for adding data/layers - special */
308 bool gp_add_poll(bContext *C)
309 {
310         /* the base line we have is that we have somewhere to add Grease Pencil data */
311         return ED_gpencil_data_get_pointers(C, NULL) != NULL;
312 }
313
314 /* poll callback for checking if there is an active layer */
315 bool gp_active_layer_poll(bContext *C)
316 {
317         bGPdata *gpd = ED_gpencil_data_get_active(C);
318         bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
319
320         return (gpl != NULL);
321 }
322
323 /* poll callback for checking if there is an active brush */
324 bool gp_active_brush_poll(bContext *C)
325 {
326         ToolSettings *ts = CTX_data_tool_settings(C);
327         Paint *paint = &ts->gp_paint->paint;
328         if (paint) {
329                 return (paint->brush != NULL);
330         }
331         else {
332                 return false;
333         }
334 }
335
336 /* ******************************************************** */
337 /* Dynamic Enums of GP Layers */
338 /* NOTE: These include an option to create a new layer and use that... */
339
340 /* Just existing layers */
341 const EnumPropertyItem *ED_gpencil_layers_enum_itemf(
342         bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
343 {
344         bGPdata *gpd = CTX_data_gpencil_data(C);
345         bGPDlayer *gpl;
346         EnumPropertyItem *item = NULL, item_tmp = {0};
347         int totitem = 0;
348         int i = 0;
349
350         if (ELEM(NULL, C, gpd)) {
351                 return DummyRNA_DEFAULT_items;
352         }
353
354         /* Existing layers */
355         for (gpl = gpd->layers.first; gpl; gpl = gpl->next, i++) {
356                 item_tmp.identifier = gpl->info;
357                 item_tmp.name = gpl->info;
358                 item_tmp.value = i;
359
360                 if (gpl->flag & GP_LAYER_ACTIVE)
361                         item_tmp.icon = ICON_GREASEPENCIL;
362                 else
363                         item_tmp.icon = ICON_NONE;
364
365                 RNA_enum_item_add(&item, &totitem, &item_tmp);
366         }
367
368         RNA_enum_item_end(&item, &totitem);
369         *r_free = true;
370
371         return item;
372 }
373
374 /* Existing + Option to add/use new layer */
375 const EnumPropertyItem *ED_gpencil_layers_with_new_enum_itemf(
376         bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
377 {
378         bGPdata *gpd = CTX_data_gpencil_data(C);
379         bGPDlayer *gpl;
380         EnumPropertyItem *item = NULL, item_tmp = {0};
381         int totitem = 0;
382         int i = 0;
383
384         if (ELEM(NULL, C, gpd)) {
385                 return DummyRNA_DEFAULT_items;
386         }
387
388         /* Create new layer */
389         /* TODO: have some way of specifying that we don't want this? */
390         {
391                 /* "New Layer" entry */
392                 item_tmp.identifier = "__CREATE__";
393                 item_tmp.name = "New Layer";
394                 item_tmp.value = -1;
395                 item_tmp.icon = ICON_ZOOMIN;
396                 RNA_enum_item_add(&item, &totitem, &item_tmp);
397
398                 /* separator */
399                 RNA_enum_item_add_separator(&item, &totitem);
400         }
401
402         /* Existing layers */
403         for (gpl = gpd->layers.first, i = 0; gpl; gpl = gpl->next, i++) {
404                 item_tmp.identifier = gpl->info;
405                 item_tmp.name = gpl->info;
406                 item_tmp.value = i;
407
408                 if (gpl->flag & GP_LAYER_ACTIVE)
409                         item_tmp.icon = ICON_GREASEPENCIL;
410                 else
411                         item_tmp.icon = ICON_NONE;
412
413                 RNA_enum_item_add(&item, &totitem, &item_tmp);
414         }
415
416         RNA_enum_item_end(&item, &totitem);
417         *r_free = true;
418
419         return item;
420 }
421
422
423 /* ******************************************************** */
424 /* Brush Tool Core */
425
426 /**
427  * Check whether a given stroke segment is inside a circular brush
428  *
429  * \param mval     The current screen-space coordinates (midpoint) of the brush
430  * \param mvalo    The previous screen-space coordinates (midpoint) of the brush (NOT CURRENTLY USED)
431  * \param rad      The radius of the brush
432  *
433  * \param x0, y0   The screen-space x and y coordinates of the start of the stroke segment
434  * \param x1, y1   The screen-space x and y coordinates of the end of the stroke segment
435  */
436 bool gp_stroke_inside_circle(const int mval[2], const int UNUSED(mvalo[2]),
437                              int rad, int x0, int y0, int x1, int y1)
438 {
439         /* simple within-radius check for now */
440         const float mval_fl[2]     = {mval[0], mval[1]};
441         const float screen_co_a[2] = {x0, y0};
442         const float screen_co_b[2] = {x1, y1};
443
444         if (edge_inside_circle(mval_fl, rad, screen_co_a, screen_co_b)) {
445                 return true;
446         }
447
448         /* not inside */
449         return false;
450 }
451
452 /* ******************************************************** */
453 /* Stroke Validity Testing */
454
455 /* Check whether given stroke can be edited given the supplied context */
456 /* TODO: do we need additional flags for screenspace vs dataspace? */
457 bool ED_gpencil_stroke_can_use_direct(const ScrArea *sa, const bGPDstroke *gps)
458 {
459         /* sanity check */
460         if (ELEM(NULL, sa, gps))
461                 return false;
462
463         /* filter stroke types by flags + spacetype */
464         if (gps->flag & GP_STROKE_3DSPACE) {
465                 /* 3D strokes - only in 3D view */
466                 return ((sa->spacetype == SPACE_VIEW3D) || (sa->spacetype == SPACE_BUTS));
467         }
468         else if (gps->flag & GP_STROKE_2DIMAGE) {
469                 /* Special "image" strokes - only in Image Editor */
470                 return (sa->spacetype == SPACE_IMAGE);
471         }
472         else if (gps->flag & GP_STROKE_2DSPACE) {
473                 /* 2D strokes (dataspace) - for any 2D view (i.e. everything other than 3D view) */
474                 return (sa->spacetype != SPACE_VIEW3D);
475         }
476         else {
477                 /* view aligned - anything goes */
478                 return true;
479         }
480 }
481
482 /* Check whether given stroke can be edited in the current context */
483 bool ED_gpencil_stroke_can_use(const bContext *C, const bGPDstroke *gps)
484 {
485         ScrArea *sa = CTX_wm_area(C);
486         return ED_gpencil_stroke_can_use_direct(sa, gps);
487 }
488
489 /* Check whether given stroke can be edited for the current color */
490 bool ED_gpencil_stroke_color_use(Object *ob, const bGPDlayer *gpl, const bGPDstroke *gps)
491 {
492         /* check if the color is editable */
493         MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
494
495         if (gp_style != NULL) {
496                 if (gp_style->flag & GP_STYLE_COLOR_HIDE)
497                         return false;
498                 if (((gpl->flag & GP_LAYER_UNLOCK_COLOR) == 0) && (gp_style->flag & GP_STYLE_COLOR_LOCKED))
499                         return false;
500         }
501
502         return true;
503 }
504
505 /* ******************************************************** */
506 /* Space Conversion */
507
508 /**
509  * Init settings for stroke point space conversions
510  *
511  * \param r_gsc: [out] The space conversion settings struct, populated with necessary params
512  */
513 void gp_point_conversion_init(bContext *C, GP_SpaceConversion *r_gsc)
514 {
515         ScrArea *sa = CTX_wm_area(C);
516         ARegion *ar = CTX_wm_region(C);
517
518         /* zero out the storage (just in case) */
519         memset(r_gsc, 0, sizeof(GP_SpaceConversion));
520         unit_m4(r_gsc->mat);
521
522         /* store settings */
523         r_gsc->sa = sa;
524         r_gsc->ar = ar;
525         r_gsc->v2d = &ar->v2d;
526
527         /* init region-specific stuff */
528         if (sa->spacetype == SPACE_VIEW3D) {
529                 wmWindow *win = CTX_wm_window(C);
530                 Scene *scene = CTX_data_scene(C);
531                 struct Depsgraph *depsgraph = CTX_data_depsgraph(C);
532                 View3D *v3d = (View3D *)CTX_wm_space_data(C);
533                 RegionView3D *rv3d = ar->regiondata;
534
535                 /* init 3d depth buffers */
536                 view3d_operator_needs_opengl(C);
537
538                 view3d_region_operator_needs_opengl(win, ar);
539                 ED_view3d_autodist_init(depsgraph, ar, v3d, 0);
540
541                 /* for camera view set the subrect */
542                 if (rv3d->persp == RV3D_CAMOB) {
543                         ED_view3d_calc_camera_border(scene, CTX_data_depsgraph(C), ar, v3d, rv3d, &r_gsc->subrect_data, true); /* no shift */
544                         r_gsc->subrect = &r_gsc->subrect_data;
545                 }
546         }
547 }
548
549 /**
550  * Convert point to parent space
551  *
552  * \param pt         Original point
553  * \param diff_mat   Matrix with the difference between original parent matrix
554  * \param[out] r_pt  Pointer to new point after apply matrix
555  */
556 void gp_point_to_parent_space(bGPDspoint *pt, float diff_mat[4][4], bGPDspoint *r_pt)
557 {
558         float fpt[3];
559
560         mul_v3_m4v3(fpt, diff_mat, &pt->x);
561         copy_v3_v3(&r_pt->x, fpt);
562 }
563
564 /**
565  * Change position relative to parent object
566  */
567 void gp_apply_parent(Depsgraph *depsgraph, Object *obact, bGPdata *gpd, bGPDlayer *gpl, bGPDstroke *gps)
568 {
569         bGPDspoint *pt;
570         int i;
571
572         /* undo matrix */
573         float diff_mat[4][4];
574         float inverse_diff_mat[4][4];
575         float fpt[3];
576
577         ED_gpencil_parent_location(depsgraph, obact, gpd, gpl, diff_mat);
578         invert_m4_m4(inverse_diff_mat, diff_mat);
579
580         for (i = 0; i < gps->totpoints; i++) {
581                 pt = &gps->points[i];
582                 mul_v3_m4v3(fpt, inverse_diff_mat, &pt->x);
583                 copy_v3_v3(&pt->x, fpt);
584         }
585 }
586
587 /**
588  * Change point position relative to parent object
589  */
590 void gp_apply_parent_point(Depsgraph *depsgraph, Object *obact, bGPdata *gpd, bGPDlayer *gpl, bGPDspoint *pt)
591 {
592         /* undo matrix */
593         float diff_mat[4][4];
594         float inverse_diff_mat[4][4];
595         float fpt[3];
596
597         ED_gpencil_parent_location(depsgraph, obact, gpd, gpl, diff_mat);
598         invert_m4_m4(inverse_diff_mat, diff_mat);
599
600         mul_v3_m4v3(fpt, inverse_diff_mat, &pt->x);
601         copy_v3_v3(&pt->x, fpt);
602 }
603
604 /**
605  * Convert a Grease Pencil coordinate (i.e. can be 2D or 3D) to screenspace (2D)
606  *
607  * \param[out] r_x  The screen-space x-coordinate of the point
608  * \param[out] r_y  The screen-space y-coordinate of the point
609  *
610  * \warning This assumes that the caller has already checked whether the stroke in question can be drawn.
611  */
612 void gp_point_to_xy(GP_SpaceConversion *gsc, bGPDstroke *gps, bGPDspoint *pt,
613                     int *r_x, int *r_y)
614 {
615         ARegion *ar = gsc->ar;
616         View2D *v2d = gsc->v2d;
617         rctf *subrect = gsc->subrect;
618         int xyval[2];
619
620         /* sanity checks */
621         BLI_assert(!(gps->flag & GP_STROKE_3DSPACE) || (gsc->sa->spacetype == SPACE_VIEW3D));
622         BLI_assert(!(gps->flag & GP_STROKE_2DSPACE) || (gsc->sa->spacetype != SPACE_VIEW3D));
623
624
625         if (gps->flag & GP_STROKE_3DSPACE) {
626                 if (ED_view3d_project_int_global(ar, &pt->x, xyval, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
627                         *r_x = xyval[0];
628                         *r_y = xyval[1];
629                 }
630                 else {
631                         *r_x = V2D_IS_CLIPPED;
632                         *r_y = V2D_IS_CLIPPED;
633                 }
634         }
635         else if (gps->flag & GP_STROKE_2DSPACE) {
636                 float vec[3] = {pt->x, pt->y, 0.0f};
637                 mul_m4_v3(gsc->mat, vec);
638                 UI_view2d_view_to_region_clip(v2d, vec[0], vec[1], r_x, r_y);
639         }
640         else {
641                 if (subrect == NULL) {
642                         /* normal 3D view (or view space) */
643                         *r_x = (int)(pt->x / 100 * ar->winx);
644                         *r_y = (int)(pt->y / 100 * ar->winy);
645                 }
646                 else {
647                         /* camera view, use subrect */
648                         *r_x = (int)((pt->x / 100) * BLI_rctf_size_x(subrect)) + subrect->xmin;
649                         *r_y = (int)((pt->y / 100) * BLI_rctf_size_y(subrect)) + subrect->ymin;
650                 }
651         }
652 }
653
654 /**
655  * Convert a Grease Pencil coordinate (i.e. can be 2D or 3D) to screenspace (2D)
656  *
657  * Just like gp_point_to_xy(), except the resulting coordinates are floats not ints.
658  * Use this version to solve "stair-step" artifacts which may arise when roundtripping the calculations.
659  *
660  * \param r_x: [out] The screen-space x-coordinate of the point
661  * \param r_y: [out] The screen-space y-coordinate of the point
662  *
663  * \warning This assumes that the caller has already checked whether the stroke in question can be drawn
664  */
665 void gp_point_to_xy_fl(GP_SpaceConversion *gsc, bGPDstroke *gps, bGPDspoint *pt,
666                        float *r_x, float *r_y)
667 {
668         ARegion *ar = gsc->ar;
669         View2D *v2d = gsc->v2d;
670         rctf *subrect = gsc->subrect;
671         float xyval[2];
672
673         /* sanity checks */
674         BLI_assert(!(gps->flag & GP_STROKE_3DSPACE) || (gsc->sa->spacetype == SPACE_VIEW3D));
675         BLI_assert(!(gps->flag & GP_STROKE_2DSPACE) || (gsc->sa->spacetype != SPACE_VIEW3D));
676
677
678         if (gps->flag & GP_STROKE_3DSPACE) {
679                 if (ED_view3d_project_float_global(ar, &pt->x, xyval, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
680                         *r_x = xyval[0];
681                         *r_y = xyval[1];
682                 }
683                 else {
684                         *r_x = 0.0f;
685                         *r_y = 0.0f;
686                 }
687         }
688         else if (gps->flag & GP_STROKE_2DSPACE) {
689                 float vec[3] = {pt->x, pt->y, 0.0f};
690                 int t_x, t_y;
691
692                 mul_m4_v3(gsc->mat, vec);
693                 UI_view2d_view_to_region_clip(v2d, vec[0], vec[1], &t_x, &t_y);
694
695                 if ((t_x == t_y) && (t_x == V2D_IS_CLIPPED)) {
696                         /* XXX: Or should we just always use the values as-is? */
697                         *r_x = 0.0f;
698                         *r_y = 0.0f;
699                 }
700                 else {
701                         *r_x = (float)t_x;
702                         *r_y = (float)t_y;
703                 }
704         }
705         else {
706                 if (subrect == NULL) {
707                         /* normal 3D view (or view space) */
708                         *r_x = (pt->x / 100.0f * ar->winx);
709                         *r_y = (pt->y / 100.0f * ar->winy);
710                 }
711                 else {
712                         /* camera view, use subrect */
713                         *r_x = ((pt->x / 100.0f) * BLI_rctf_size_x(subrect)) + subrect->xmin;
714                         *r_y = ((pt->y / 100.0f) * BLI_rctf_size_y(subrect)) + subrect->ymin;
715                 }
716         }
717 }
718
719 /**
720  * Project screenspace coordinates to 3D-space
721  *
722  * For use with editing tools where it is easier to perform the operations in 2D,
723  * and then later convert the transformed points back to 3D.
724  *
725  * \param screen_co: The screenspace 2D coordinates to convert to
726  * \param r_out: The resulting 3D coordinates of the input point
727  *
728  * \note We include this as a utility function, since the standard method
729  * involves quite a few steps, which are invariably always the same
730  * for all GPencil operations. So, it's nicer to just centralize these.
731  *
732  * \warning Assumes that it is getting called in a 3D view only.
733  */
734 bool gp_point_xy_to_3d(GP_SpaceConversion *gsc, Scene *scene, const float screen_co[2], float r_out[3])
735 {
736         View3D *v3d = gsc->sa->spacedata.first;
737         RegionView3D *rv3d = gsc->ar->regiondata;
738         float *rvec = ED_view3d_cursor3d_get(scene, v3d)->location;
739         float ref[3] = {rvec[0], rvec[1], rvec[2]};
740         float zfac = ED_view3d_calc_zfac(rv3d, rvec, NULL);
741
742         float mval_f[2], mval_prj[2];
743         float dvec[3];
744
745         copy_v2_v2(mval_f, screen_co);
746
747         if (ED_view3d_project_float_global(gsc->ar, ref, mval_prj, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
748                 sub_v2_v2v2(mval_f, mval_prj, mval_f);
749                 ED_view3d_win_to_delta(gsc->ar, mval_f, dvec, zfac);
750                 sub_v3_v3v3(r_out, rvec, dvec);
751
752                 return true;
753         }
754         else {
755                 zero_v3(r_out);
756
757                 return false;
758         }
759 }
760
761 /**
762  * Convert tGPspoint (temporary 2D/screenspace point data used by GP modal operators)
763  * to 3D coordinates.
764  *
765  * \param point2D: The screenspace 2D point data to convert
766  * \param depth: Depth array (via ED_view3d_autodist_depth())
767  * \param[out] r_out: The resulting 2D point data
768  */
769 void gp_stroke_convertcoords_tpoint(
770         Scene *scene, ARegion *ar, View3D *v3d,
771         Object *ob, bGPDlayer *gpl,
772         const tGPspoint *point2D, float *depth,
773         float r_out[3])
774 {
775         ToolSettings *ts = scene->toolsettings;
776         const int mval[2] = {point2D->x, point2D->y};
777
778         if ((depth != NULL) && (ED_view3d_autodist_simple(ar, mval, r_out, 0, depth))) {
779                 /* projecting onto 3D-Geometry
780                  * - nothing more needs to be done here, since view_autodist_simple() has already done it
781                  */
782         }
783         else {
784                 float mval_f[2] = {(float)point2D->x, (float)point2D->y};
785                 float mval_prj[2];
786                 float rvec[3], dvec[3];
787                 float zfac;
788
789                 /* Current method just converts each point in screen-coordinates to
790                  * 3D-coordinates using the 3D-cursor as reference.
791                  */
792                 ED_gp_get_drawing_reference(v3d, scene, ob, gpl, ts->gpencil_v3d_align, rvec);
793                 zfac = ED_view3d_calc_zfac(ar->regiondata, rvec, NULL);
794
795                 if (ED_view3d_project_float_global(ar, rvec, mval_prj, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
796                         sub_v2_v2v2(mval_f, mval_prj, mval_f);
797                         ED_view3d_win_to_delta(ar, mval_f, dvec, zfac);
798                         sub_v3_v3v3(r_out, rvec, dvec);
799                 }
800                 else {
801                         zero_v3(r_out);
802                 }
803         }
804 }
805
806 /**
807  * Get drawing reference point for conversion or projection of the stroke
808  * \param[out] r_vec : Reference point found
809  */
810 void ED_gp_get_drawing_reference(
811         View3D *v3d, Scene *scene, Object *ob, bGPDlayer *UNUSED(gpl),
812         char align_flag, float r_vec[3])
813 {
814         const float *fp = ED_view3d_cursor3d_get(scene, v3d)->location;
815
816         /* if using a gpencil object at cursor mode, can use the location of the object */
817         if (align_flag & GP_PROJECT_VIEWSPACE) {
818                 if (ob && (ob->type == OB_GPENCIL)) {
819                         /* fallback (no strokes) - use cursor or object location */
820                         if (align_flag & GP_PROJECT_CURSOR) {
821                                 /* use 3D-cursor */
822                                 copy_v3_v3(r_vec, fp);
823                         }
824                         else {
825                                 /* use object location */
826                                 copy_v3_v3(r_vec, ob->obmat[3]);
827                         }
828                 }
829         }
830         else {
831                 /* use 3D-cursor */
832                 copy_v3_v3(r_vec, fp);
833         }
834 }
835
836
837 /**
838  * Reproject all points of the stroke to a plane locked to axis to avoid stroke offset
839  */
840 void ED_gp_project_stroke_to_plane(Object *ob, RegionView3D *rv3d, bGPDstroke *gps, const float origin[3], const int axis)
841 {
842         float plane_normal[3];
843         float vn[3];
844
845         float ray[3];
846         float rpoint[3];
847
848         /* normal vector for a plane locked to axis */
849         zero_v3(plane_normal);
850         if (axis < 0) {
851                 /* if the axis is not locked, need a vector to the view direction
852                  * in order to get the right size of the stroke.
853                  */
854                 ED_view3d_global_to_vector(rv3d, origin, plane_normal);
855         }
856         else {
857                 plane_normal[axis] = 1.0f;
858                 /* if object, apply object rotation */
859                 if (ob && (ob->type == OB_GPENCIL)) {
860                         mul_mat3_m4_v3(ob->obmat, plane_normal);
861                 }
862         }
863
864         /* Reproject the points in the plane */
865         for (int i = 0; i < gps->totpoints; i++) {
866                 bGPDspoint *pt = &gps->points[i];
867
868                 /* get a vector from the point with the current view direction of the viewport */
869                 ED_view3d_global_to_vector(rv3d, &pt->x, vn);
870
871                 /* calculate line extreme point to create a ray that cross the plane */
872                 mul_v3_fl(vn, -50.0f);
873                 add_v3_v3v3(ray, &pt->x, vn);
874
875                 /* if the line never intersect, the point is not changed */
876                 if (isect_line_plane_v3(rpoint, &pt->x, ray, origin, plane_normal)) {
877                         copy_v3_v3(&pt->x, rpoint);
878                 }
879         }
880 }
881
882 /**
883  * Reproject given point to a plane locked to axis to avoid stroke offset
884  * \param[in, out] pt : Point to affect
885  */
886 void ED_gp_project_point_to_plane(Object *ob, RegionView3D *rv3d, const float origin[3], const int axis, bGPDspoint *pt)
887 {
888         float plane_normal[3];
889         float vn[3];
890
891         float ray[3];
892         float rpoint[3];
893
894         /* normal vector for a plane locked to axis */
895         zero_v3(plane_normal);
896         if (axis < 0) {
897                 /* if the axis is not locked, need a vector to the view direction
898                  * in order to get the right size of the stroke.
899                  */
900                 ED_view3d_global_to_vector(rv3d, origin, plane_normal);
901         }
902         else {
903                 plane_normal[axis] = 1.0f;
904                 /* if object, apply object rotation */
905                 if (ob && (ob->type == OB_GPENCIL)) {
906                         mul_mat3_m4_v3(ob->obmat, plane_normal);
907                 }
908         }
909
910
911         /* Reproject the points in the plane */
912         /* get a vector from the point with the current view direction of the viewport */
913         ED_view3d_global_to_vector(rv3d, &pt->x, vn);
914
915         /* calculate line extrem point to create a ray that cross the plane */
916         mul_v3_fl(vn, -50.0f);
917         add_v3_v3v3(ray, &pt->x, vn);
918
919         /* if the line never intersect, the point is not changed */
920         if (isect_line_plane_v3(rpoint, &pt->x, ray, origin, plane_normal)) {
921                 copy_v3_v3(&pt->x, rpoint);
922         }
923 }
924
925 /* ******************************************************** */
926 /* Stroke Operations */
927 // XXX: Check if these functions duplicate stuff in blenkernel, and/or whether we should just deduplicate
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 subdivide      Number of times to subdivide
933  */
934 void gp_subdivide_stroke(bGPDstroke *gps, const int subdivide)
935 {
936         bGPDspoint *temp_points;
937         int totnewpoints, oldtotpoints;
938         int i2;
939
940         /* loop as many times as levels */
941         for (int s = 0; s < subdivide; s++) {
942                 totnewpoints = gps->totpoints - 1;
943                 /* duplicate points in a temp area */
944                 temp_points = MEM_dupallocN(gps->points);
945                 oldtotpoints = gps->totpoints;
946
947                 /* resize the points arrys */
948                 gps->totpoints += totnewpoints;
949                 gps->points = MEM_recallocN(gps->points, sizeof(*gps->points) * gps->totpoints);
950                 if (gps->dvert != NULL) {
951                         gps->dvert = MEM_recallocN(gps->dvert, sizeof(*gps->dvert) * gps->totpoints);
952                 }
953                 gps->flag |= GP_STROKE_RECALC_CACHES;
954
955                 /* move points from last to first to new place */
956                 i2 = gps->totpoints - 1;
957                 for (int i = oldtotpoints - 1; i > 0; i--) {
958                         bGPDspoint *pt = &temp_points[i];
959                         bGPDspoint *pt_final = &gps->points[i2];
960
961                         copy_v3_v3(&pt_final->x, &pt->x);
962                         pt_final->pressure = pt->pressure;
963                         pt_final->strength = pt->strength;
964                         pt_final->time = pt->time;
965                         pt_final->flag = pt->flag;
966                         pt_final->uv_fac = pt->uv_fac;
967                         pt_final->uv_rot = pt->uv_rot;
968
969                         if (gps->dvert != NULL) {
970                                 MDeformVert *dvert = &gps->dvert[i];
971                                 MDeformVert *dvert_final = &gps->dvert[i2];
972
973                                 dvert_final->totweight = dvert->totweight;
974                                 dvert_final->dw = dvert->dw;
975                         }
976
977                         i2 -= 2;
978                 }
979                 /* interpolate mid points */
980                 i2 = 1;
981                 for (int i = 0; i < oldtotpoints - 1; i++) {
982                         bGPDspoint *pt = &temp_points[i];
983                         bGPDspoint *next = &temp_points[i + 1];
984                         bGPDspoint *pt_final = &gps->points[i2];
985
986                         /* add a half way point */
987                         interp_v3_v3v3(&pt_final->x, &pt->x, &next->x, 0.5f);
988                         pt_final->pressure = interpf(pt->pressure, next->pressure, 0.5f);
989                         pt_final->strength = interpf(pt->strength, next->strength, 0.5f);
990                         CLAMP(pt_final->strength, GPENCIL_STRENGTH_MIN, 1.0f);
991                         pt_final->time = interpf(pt->time, next->time, 0.5f);
992                         pt_final->uv_fac = interpf(pt->uv_fac, next->uv_fac, 0.5f);
993                         pt_final->uv_rot = interpf(pt->uv_rot, next->uv_rot, 0.5f);
994
995                         if (gps->dvert != NULL) {
996                                 MDeformVert *dvert_final = &gps->dvert[i2];
997                                 dvert_final->totweight = 0;
998                                 dvert_final->dw = NULL;
999                         }
1000
1001                         i2 += 2;
1002                 }
1003
1004                 MEM_SAFE_FREE(temp_points);
1005
1006                 /* move points to smooth stroke */
1007                 /* duplicate points in a temp area with the new subdivide data */
1008                 temp_points = MEM_dupallocN(gps->points);
1009
1010                 /* extreme points are not changed */
1011                 for (int i = 0; i < gps->totpoints - 2; i++) {
1012                         bGPDspoint *pt = &temp_points[i];
1013                         bGPDspoint *next = &temp_points[i + 1];
1014                         bGPDspoint *pt_final = &gps->points[i + 1];
1015
1016                         /* move point */
1017                         interp_v3_v3v3(&pt_final->x, &pt->x, &next->x, 0.5f);
1018                 }
1019                 /* free temp memory */
1020                 MEM_SAFE_FREE(temp_points);
1021         }
1022 }
1023
1024 /**
1025  * Add randomness to stroke
1026  * \param gps           Stroke data
1027  * \param brush         Brush data
1028  */
1029 void gp_randomize_stroke(bGPDstroke *gps, Brush *brush, RNG *rng)
1030 {
1031         bGPDspoint *pt1, *pt2, *pt3;
1032         float v1[3];
1033         float v2[3];
1034         if (gps->totpoints < 3) {
1035                 return;
1036         }
1037
1038         /* get two vectors using 3 points */
1039         pt1 = &gps->points[0];
1040         pt2 = &gps->points[1];
1041         pt3 = &gps->points[(int)(gps->totpoints * 0.75)];
1042
1043         sub_v3_v3v3(v1, &pt2->x, &pt1->x);
1044         sub_v3_v3v3(v2, &pt3->x, &pt2->x);
1045         normalize_v3(v1);
1046         normalize_v3(v2);
1047
1048         /* get normal vector to plane created by two vectors */
1049         float normal[3];
1050         cross_v3_v3v3(normal, v1, v2);
1051         normalize_v3(normal);
1052
1053         /* get orthogonal vector to plane to rotate random effect */
1054         float ortho[3];
1055         cross_v3_v3v3(ortho, v1, normal);
1056         normalize_v3(ortho);
1057
1058         /* Read all points and apply shift vector (first and last point not modified) */
1059         for (int i = 1; i < gps->totpoints - 1; i++) {
1060                 bGPDspoint *pt = &gps->points[i];
1061                 /* get vector with shift (apply a division because random is too sensitive */
1062                 const float fac = BLI_rng_get_float(rng) * (brush->gpencil_settings->draw_random_sub / 10.0f);
1063                 float svec[3];
1064                 copy_v3_v3(svec, ortho);
1065                 if (BLI_rng_get_float(rng) > 0.5f) {
1066                         mul_v3_fl(svec, -fac);
1067                 }
1068                 else {
1069                         mul_v3_fl(svec, fac);
1070                 }
1071
1072                 /* apply shift */
1073                 add_v3_v3(&pt->x, svec);
1074         }
1075 }
1076
1077 /* ******************************************************** */
1078 /* Layer Parenting  - Compute Parent Transforms */
1079
1080 /* calculate difference matrix */
1081 void ED_gpencil_parent_location(
1082         const Depsgraph *depsgraph, Object *obact, bGPdata *UNUSED(gpd),
1083         bGPDlayer *gpl, float diff_mat[4][4])
1084 {
1085         Object *ob_eval = depsgraph != NULL ? DEG_get_evaluated_object(depsgraph, obact) : obact;
1086         Object *obparent = gpl->parent;
1087         Object *obparent_eval = depsgraph != NULL ? DEG_get_evaluated_object(depsgraph, obparent) : obparent;
1088
1089         /* if not layer parented, try with object parented */
1090         if (obparent_eval == NULL) {
1091                 if (ob_eval != NULL) {
1092                         if (ob_eval->type == OB_GPENCIL) {
1093                                 copy_m4_m4(diff_mat, ob_eval->obmat);
1094                                 return;
1095                         }
1096                 }
1097                 /* not gpencil object */
1098                 unit_m4(diff_mat);
1099                 return;
1100         }
1101         else {
1102                 if ((gpl->partype == PAROBJECT) || (gpl->partype == PARSKEL)) {
1103                         mul_m4_m4m4(diff_mat, obparent_eval->obmat, gpl->inverse);
1104                         return;
1105                 }
1106                 else if (gpl->partype == PARBONE) {
1107                         bPoseChannel *pchan = BKE_pose_channel_find_name(obparent_eval->pose, gpl->parsubstr);
1108                         if (pchan) {
1109                                 float tmp_mat[4][4];
1110                                 mul_m4_m4m4(tmp_mat, obparent_eval->obmat, pchan->pose_mat);
1111                                 mul_m4_m4m4(diff_mat, tmp_mat, gpl->inverse);
1112                         }
1113                         else {
1114                                 mul_m4_m4m4(diff_mat, obparent_eval->obmat, gpl->inverse); /* if bone not found use object (armature) */
1115                         }
1116                         return;
1117                 }
1118                 else {
1119                         unit_m4(diff_mat); /* not defined type */
1120                 }
1121         }
1122 }
1123
1124 /* reset parent matrix for all layers */
1125 void ED_gpencil_reset_layers_parent(Depsgraph *depsgraph, Object *obact, bGPdata *gpd)
1126 {
1127         bGPDspoint *pt;
1128         int i;
1129         float diff_mat[4][4];
1130         float cur_mat[4][4];
1131
1132         for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1133                 if (gpl->parent != NULL) {
1134                         /* calculate new matrix */
1135                         if ((gpl->partype == PAROBJECT) || (gpl->partype == PARSKEL)) {
1136                                 invert_m4_m4(cur_mat, gpl->parent->obmat);
1137                         }
1138                         else if (gpl->partype == PARBONE) {
1139                                 bPoseChannel *pchan = BKE_pose_channel_find_name(gpl->parent->pose, gpl->parsubstr);
1140                                 if (pchan) {
1141                                         float tmp_mat[4][4];
1142                                         mul_m4_m4m4(tmp_mat, gpl->parent->obmat, pchan->pose_mat);
1143                                         invert_m4_m4(cur_mat, tmp_mat);
1144                                 }
1145                         }
1146
1147                         /* only redo if any change */
1148                         if (!equals_m4m4(gpl->inverse, cur_mat)) {
1149                                 /* first apply current transformation to all strokes */
1150                                 ED_gpencil_parent_location(depsgraph, obact, gpd, gpl, diff_mat);
1151                                 for (bGPDframe *gpf = gpl->frames.first; gpf; gpf = gpf->next) {
1152                                         for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
1153                                                 for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
1154                                                         mul_m4_v3(diff_mat, &pt->x);
1155                                                 }
1156                                         }
1157                                 }
1158                                 /* set new parent matrix */
1159                                 copy_m4_m4(gpl->inverse, cur_mat);
1160                         }
1161                 }
1162         }
1163 }
1164 /* ******************************************************** */
1165 /* GP Object Stuff */
1166
1167 /* Helper function to create new OB_GPENCIL Object */
1168 Object *ED_add_gpencil_object(bContext *C, Scene *UNUSED(scene), const float loc[3])
1169 {
1170         float rot[3] = {0.0f};
1171
1172         Object *ob = ED_object_add_type(C, OB_GPENCIL, NULL, loc, rot, false);
1173
1174         /* define size */
1175         BKE_object_obdata_size_init(ob, GP_OBGPENCIL_DEFAULT_SIZE);
1176         /* create default brushes and colors */
1177         ED_gpencil_add_defaults(C);
1178
1179         return ob;
1180 }
1181
1182 /* Helper function to create default colors and drawing brushes */
1183 void ED_gpencil_add_defaults(bContext *C)
1184 {
1185         Main *bmain = CTX_data_main(C);
1186         Object *ob = CTX_data_active_object(C);
1187         ToolSettings *ts = CTX_data_tool_settings(C);
1188
1189         /* first try to reuse default material */
1190         if (ob->actcol > 0) {
1191                 Material *ma = give_current_material(ob, ob->actcol);
1192                 if ((ma) && (ma->gp_style == NULL)) {
1193                         BKE_material_init_gpencil_settings(ma);
1194                 }
1195         }
1196
1197         /* ensure color exist */
1198         BKE_gpencil_material_ensure(bmain, ob);
1199
1200         Paint *paint = BKE_brush_get_gpencil_paint(ts);
1201         /* if not exist, create a new one */
1202         if (paint->brush == NULL) {
1203                 /* create new brushes */
1204                 BKE_brush_gpencil_presets(C);
1205         }
1206
1207 }
1208
1209 /* ******************************************************** */
1210 /* Vertex Groups */
1211
1212 /* assign points to vertex group */
1213 void ED_gpencil_vgroup_assign(bContext *C, Object *ob, float weight)
1214 {
1215         const int def_nr = ob->actdef - 1;
1216         if (!BLI_findlink(&ob->defbase, def_nr))
1217                 return;
1218
1219         CTX_DATA_BEGIN(C, bGPDstroke *, gps, editable_gpencil_strokes)
1220         {
1221                 if (gps->flag & GP_STROKE_SELECT) {
1222                         /* verify the weight array is created */
1223                         BKE_gpencil_dvert_ensure(gps);
1224
1225                         for (int i = 0; i < gps->totpoints; i++) {
1226                                 bGPDspoint *pt = &gps->points[i];
1227                                 MDeformVert *dvert = &gps->dvert[i];
1228                                 if (pt->flag & GP_SPOINT_SELECT) {
1229                                         MDeformWeight *dw = defvert_verify_index(dvert, def_nr);
1230                                         if (dw) {
1231                                                 dw->weight = weight;
1232                                         }
1233                                 }
1234                         }
1235                 }
1236         }
1237         CTX_DATA_END;
1238 }
1239
1240 /* remove points from vertex group */
1241 void ED_gpencil_vgroup_remove(bContext *C, Object *ob)
1242 {
1243         const int def_nr = ob->actdef - 1;
1244         if (!BLI_findlink(&ob->defbase, def_nr))
1245                 return;
1246
1247         CTX_DATA_BEGIN(C, bGPDstroke *, gps, editable_gpencil_strokes)
1248         {
1249                 for (int i = 0; i < gps->totpoints; i++) {
1250                         bGPDspoint *pt = &gps->points[i];
1251                         if (gps->dvert == NULL) {
1252                                 continue;
1253                         }
1254                         MDeformVert *dvert = &gps->dvert[i];
1255
1256                         if ((pt->flag & GP_SPOINT_SELECT) && (dvert->totweight > 0)) {
1257                                 MDeformWeight *dw = defvert_find_index(dvert, def_nr);
1258                                 if (dw != NULL) {
1259                                         defvert_remove_group(dvert, dw);
1260                                 }
1261                         }
1262                 }
1263         }
1264         CTX_DATA_END;
1265 }
1266
1267 /* select points of vertex group */
1268 void ED_gpencil_vgroup_select(bContext *C, Object *ob)
1269 {
1270         const int def_nr = ob->actdef - 1;
1271         if (!BLI_findlink(&ob->defbase, def_nr))
1272                 return;
1273
1274         CTX_DATA_BEGIN(C, bGPDstroke *, gps, editable_gpencil_strokes)
1275         {
1276                 for (int i = 0; i < gps->totpoints; i++) {
1277                         bGPDspoint *pt = &gps->points[i];
1278                         if (gps->dvert == NULL) {
1279                                 continue;
1280                         }
1281                         MDeformVert *dvert = &gps->dvert[i];
1282
1283                         if (defvert_find_index(dvert, def_nr) != NULL) {
1284                                 pt->flag |= GP_SPOINT_SELECT;
1285                                 gps->flag |= GP_STROKE_SELECT;
1286                         }
1287                 }
1288         }
1289         CTX_DATA_END;
1290 }
1291
1292 /* unselect points of vertex group */
1293 void ED_gpencil_vgroup_deselect(bContext *C, Object *ob)
1294 {
1295         const int def_nr = ob->actdef - 1;
1296         if (!BLI_findlink(&ob->defbase, def_nr))
1297                 return;
1298
1299         CTX_DATA_BEGIN(C, bGPDstroke *, gps, editable_gpencil_strokes)
1300         {
1301                 for (int i = 0; i < gps->totpoints; i++) {
1302                         bGPDspoint *pt = &gps->points[i];
1303                         if (gps->dvert == NULL) {
1304                                 continue;
1305                         }
1306                         MDeformVert *dvert = &gps->dvert[i];
1307
1308                         if (defvert_find_index(dvert, def_nr) != NULL) {
1309                                 pt->flag &= ~GP_SPOINT_SELECT;
1310                                 gps->flag |= GP_STROKE_SELECT;
1311                         }
1312                 }
1313         }
1314         CTX_DATA_END;
1315 }
1316
1317 /* ******************************************************** */
1318 /* Cursor drawing */
1319
1320 /* check if cursor is in drawing region */
1321 static bool gp_check_cursor_region(bContext *C, int mval[2])
1322 {
1323         ARegion *ar = CTX_wm_region(C);
1324         ScrArea *sa = CTX_wm_area(C);
1325         /* TODO: add more spacetypes */
1326         if (!ELEM(sa->spacetype, SPACE_VIEW3D)) {
1327                 return false;
1328         }
1329         if ((ar) && (ar->regiontype != RGN_TYPE_WINDOW)) {
1330                 return false;
1331         }
1332         else if (ar) {
1333                 rcti region_rect;
1334
1335                 /* Perform bounds check using  */
1336                 ED_region_visible_rect(ar, &region_rect);
1337                 return BLI_rcti_isect_pt_v(&region_rect, mval);
1338         }
1339         else {
1340                 return false;
1341         }
1342 }
1343
1344 /* draw eraser cursor */
1345 void ED_gpencil_brush_draw_eraser(Brush *brush, int x, int y)
1346 {
1347         short radius = (short)brush->size;
1348
1349         GPUVertFormat *format = immVertexFormat();
1350         const uint shdr_pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1351         immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
1352
1353         glEnable(GL_LINE_SMOOTH);
1354         glEnable(GL_BLEND);
1355         glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1356
1357         immUniformColor4ub(255, 100, 100, 20);
1358         imm_draw_circle_fill_2d(shdr_pos, x, y, radius, 40);
1359
1360         immUnbindProgram();
1361
1362         immBindBuiltinProgram(GPU_SHADER_2D_LINE_DASHED_UNIFORM_COLOR);
1363
1364         float viewport_size[4];
1365         glGetFloatv(GL_VIEWPORT, viewport_size);
1366         immUniform2f("viewport_size", viewport_size[2], viewport_size[3]);
1367
1368         immUniformColor4f(1.0f, 0.39f, 0.39f, 0.78f);
1369         immUniform1i("colors_len", 0);  /* "simple" mode */
1370         immUniform1f("dash_width", 12.0f);
1371         immUniform1f("dash_factor", 0.5f);
1372
1373         imm_draw_circle_wire_2d(
1374                 shdr_pos, x, y, radius,
1375                 /* XXX Dashed shader gives bad results with sets of small segments currently,
1376                  *     temp hack around the issue. :( */
1377                 max_ii(8, radius / 2));  /* was fixed 40 */
1378
1379         immUnbindProgram();
1380
1381         glDisable(GL_BLEND);
1382         glDisable(GL_LINE_SMOOTH);
1383 }
1384
1385 /* Helper callback for drawing the cursor itself */
1386 static void gp_brush_drawcursor(bContext *C, int x, int y, void *customdata)
1387 {
1388         Main *bmain = CTX_data_main(C);
1389         Scene *scene = CTX_data_scene(C);
1390         Object *ob = CTX_data_active_object(C);
1391         ARegion *ar = CTX_wm_region(C);
1392
1393         GP_BrushEdit_Settings *gset = &scene->toolsettings->gp_sculpt;
1394         bGPdata *gpd = ED_gpencil_data_get_active(C);
1395         GP_EditBrush_Data *brush = NULL;
1396         Brush *paintbrush = NULL;
1397         Material *ma = NULL;
1398         MaterialGPencilStyle *gp_style = NULL;
1399         int *last_mouse_position = customdata;
1400
1401         if ((gpd) && (gpd->flag & GP_DATA_STROKE_WEIGHTMODE)) {
1402                 brush = &gset->brush[gset->weighttype];
1403         }
1404         else {
1405                 brush = &gset->brush[gset->brushtype];
1406         }
1407
1408         /* default radius and color */
1409         float color[3] = {1.0f, 1.0f, 1.0f};
1410         float darkcolor[3];
1411         float radius = 3.0f;
1412
1413         int mval[2] = {x, y};
1414         /* check if cursor is in drawing region and has valid datablock */
1415         if ((!gp_check_cursor_region(C, mval)) || (gpd == NULL)) {
1416                 return;
1417         }
1418
1419         /* for paint use paint brush size and color */
1420         if (gpd->flag & GP_DATA_STROKE_PAINTMODE) {
1421                 paintbrush = BKE_brush_getactive_gpencil(scene->toolsettings);
1422                 /* while drawing hide */
1423                 if ((gpd->runtime.sbuffer_size > 0) &&
1424                     (paintbrush) && ((paintbrush->gpencil_settings->flag & GP_BRUSH_STABILIZE_MOUSE) == 0) &&
1425                     ((paintbrush->gpencil_settings->flag & GP_BRUSH_STABILIZE_MOUSE_TEMP) == 0))
1426                 {
1427                         return;
1428                 }
1429
1430                 if (paintbrush) {
1431                         if ((paintbrush->gpencil_settings->flag & GP_BRUSH_ENABLE_CURSOR) == 0) {
1432                                 return;
1433                         }
1434
1435                         /* eraser has special shape and use a different shader program */
1436                         if (paintbrush->gpencil_settings->brush_type == GP_BRUSH_TYPE_ERASE) {
1437                                 ED_gpencil_brush_draw_eraser(paintbrush, x, y);
1438                                 return;
1439                         }
1440
1441                         /* get current drawing color */
1442                         ma = BKE_gpencil_get_material_from_brush(paintbrush);
1443                         if (ma == NULL) {
1444                                 BKE_gpencil_material_ensure(bmain, ob);
1445                                 /* assign the first material to the brush */
1446                                 ma = give_current_material(ob, 1);
1447                                 paintbrush->gpencil_settings->material = ma;
1448                         }
1449                         gp_style = ma->gp_style;
1450
1451                         /* after some testing, display the size of the brush is not practical because
1452                          * is too disruptive and the size of cursor does not change with zoom factor.
1453                          * The decision was to use a fix size, instead of paintbrush->thickness value.
1454                          */
1455                         if ((gp_style) && (GPENCIL_PAINT_MODE(gpd)) &&
1456                             ((paintbrush->gpencil_settings->flag & GP_BRUSH_STABILIZE_MOUSE) == 0) &&
1457                             ((paintbrush->gpencil_settings->flag & GP_BRUSH_STABILIZE_MOUSE_TEMP) == 0) &&
1458                             (paintbrush->gpencil_settings->brush_type == GP_BRUSH_TYPE_DRAW))
1459                         {
1460                                 radius = 2.0f;
1461                                 copy_v3_v3(color, gp_style->stroke_rgba);
1462                         }
1463                         else {
1464                                 radius = 5.0f;
1465                                 copy_v3_v3(color, paintbrush->add_col);
1466                         }
1467                 }
1468                 else {
1469                         return;
1470                 }
1471         }
1472
1473         /* for sculpt use sculpt brush size */
1474         if (GPENCIL_SCULPT_OR_WEIGHT_MODE(gpd)) {
1475                 if (brush) {
1476                         if ((brush->flag & GP_EDITBRUSH_FLAG_ENABLE_CURSOR) == 0) {
1477                                 return;
1478                         }
1479
1480                         radius = brush->size;
1481                         if (brush->flag & (GP_EDITBRUSH_FLAG_INVERT | GP_EDITBRUSH_FLAG_TMP_INVERT)) {
1482                                 copy_v3_v3(color, brush->curcolor_sub);
1483                         }
1484                         else {
1485                                 copy_v3_v3(color, brush->curcolor_add);
1486                         }
1487                 }
1488         }
1489
1490         /* draw icon */
1491         GPUVertFormat *format = immVertexFormat();
1492         uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1493         immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
1494
1495         glEnable(GL_LINE_SMOOTH);
1496         glEnable(GL_BLEND);
1497
1498         /* Inner Ring: Color from UI panel */
1499         immUniformColor4f(color[0], color[1], color[2], 0.8f);
1500         if ((gp_style) && (GPENCIL_PAINT_MODE(gpd)) &&
1501             ((paintbrush->gpencil_settings->flag & GP_BRUSH_STABILIZE_MOUSE) == 0) &&
1502             ((paintbrush->gpencil_settings->flag & GP_BRUSH_STABILIZE_MOUSE_TEMP) == 0) &&
1503             (paintbrush->gpencil_settings->brush_type == GP_BRUSH_TYPE_DRAW))
1504         {
1505                 imm_draw_circle_fill_2d(pos, x, y, radius, 40);
1506         }
1507         else {
1508                 imm_draw_circle_wire_2d(pos, x, y, radius, 40);
1509         }
1510
1511         /* Outer Ring: Dark color for contrast on light backgrounds (e.g. gray on white) */
1512         mul_v3_v3fl(darkcolor, color, 0.40f);
1513         immUniformColor4f(darkcolor[0], darkcolor[1], darkcolor[2], 0.8f);
1514         imm_draw_circle_wire_2d(pos, x, y, radius + 1, 40);
1515
1516         glDisable(GL_BLEND);
1517         glDisable(GL_LINE_SMOOTH);
1518
1519         /* Draw line for lazy mouse */
1520         if ((last_mouse_position) &&
1521             (paintbrush->gpencil_settings->flag & GP_BRUSH_STABILIZE_MOUSE_TEMP))
1522         {
1523                 glEnable(GL_LINE_SMOOTH);
1524                 glEnable(GL_BLEND);
1525
1526                 copy_v3_v3(color, paintbrush->add_col);
1527                 immUniformColor4f(color[0], color[1], color[2], 0.8f);
1528
1529                 immBegin(GPU_PRIM_LINES, 2);
1530                 immVertex2f(pos, x, y);
1531                 immVertex2f(
1532                         pos,
1533                         last_mouse_position[0] + ar->winrct.xmin,
1534                         last_mouse_position[1] + ar->winrct.ymin);
1535                 immEnd();
1536
1537                 glDisable(GL_BLEND);
1538                 glDisable(GL_LINE_SMOOTH);
1539         }
1540
1541         immUnbindProgram();
1542 }
1543
1544 /* Turn brush cursor in on/off */
1545 void ED_gpencil_toggle_brush_cursor(bContext *C, bool enable, void *customdata)
1546 {
1547         Scene *scene = CTX_data_scene(C);
1548         GP_BrushEdit_Settings *gset = &scene->toolsettings->gp_sculpt;
1549         int *lastpost = customdata;
1550
1551         if (gset->paintcursor && !enable) {
1552                 /* clear cursor */
1553                 WM_paint_cursor_end(CTX_wm_manager(C), gset->paintcursor);
1554                 gset->paintcursor = NULL;
1555         }
1556         else if (enable) {
1557                 /* in some situations cursor could be duplicated, so it is better disable first if exist */
1558                 if (gset->paintcursor) {
1559                         /* clear cursor */
1560                         WM_paint_cursor_end(CTX_wm_manager(C), gset->paintcursor);
1561                         gset->paintcursor = NULL;
1562                 }
1563                 /* enable cursor */
1564                 gset->paintcursor = WM_paint_cursor_activate(CTX_wm_manager(C),
1565                                                              NULL,
1566                                                              gp_brush_drawcursor,
1567                                                              (lastpost) ? customdata : NULL);
1568         }
1569 }
1570
1571 /* verify if is using the right brush */
1572 static void gpencil_verify_brush_type(bContext *C, int newmode)
1573 {
1574         ToolSettings *ts = CTX_data_tool_settings(C);
1575         GP_BrushEdit_Settings *gset = &ts->gp_sculpt;
1576
1577         switch (newmode) {
1578                 case OB_MODE_GPENCIL_SCULPT:
1579                         gset->flag &= ~GP_BRUSHEDIT_FLAG_WEIGHT_MODE;
1580                         if ((gset->brushtype < 0) || (gset->brushtype >= GP_EDITBRUSH_TYPE_WEIGHT)) {
1581                                 gset->brushtype = GP_EDITBRUSH_TYPE_PUSH;
1582                         }
1583                         break;
1584                 case OB_MODE_GPENCIL_WEIGHT:
1585                         gset->flag |= GP_BRUSHEDIT_FLAG_WEIGHT_MODE;
1586                         if ((gset->weighttype < GP_EDITBRUSH_TYPE_WEIGHT) || (gset->weighttype >= TOT_GP_EDITBRUSH_TYPES)) {
1587                                 gset->weighttype = GP_EDITBRUSH_TYPE_WEIGHT;
1588                         }
1589                         break;
1590                 default:
1591                         break;
1592         }
1593 }
1594
1595 /* set object modes */
1596 void ED_gpencil_setup_modes(bContext *C, bGPdata *gpd, int newmode)
1597 {
1598         if (!gpd) {
1599                 return;
1600         }
1601
1602         switch (newmode) {
1603                 case OB_MODE_GPENCIL_EDIT:
1604                         gpd->flag |= GP_DATA_STROKE_EDITMODE;
1605                         gpd->flag &= ~GP_DATA_STROKE_PAINTMODE;
1606                         gpd->flag &= ~GP_DATA_STROKE_SCULPTMODE;
1607                         gpd->flag &= ~GP_DATA_STROKE_WEIGHTMODE;
1608                         ED_gpencil_toggle_brush_cursor(C, false, NULL);
1609                         break;
1610                 case OB_MODE_GPENCIL_PAINT:
1611                         gpd->flag &= ~GP_DATA_STROKE_EDITMODE;
1612                         gpd->flag |= GP_DATA_STROKE_PAINTMODE;
1613                         gpd->flag &= ~GP_DATA_STROKE_SCULPTMODE;
1614                         gpd->flag &= ~GP_DATA_STROKE_WEIGHTMODE;
1615                         ED_gpencil_toggle_brush_cursor(C, true, NULL);
1616                         break;
1617                 case OB_MODE_GPENCIL_SCULPT:
1618                         gpd->flag &= ~GP_DATA_STROKE_EDITMODE;
1619                         gpd->flag &= ~GP_DATA_STROKE_PAINTMODE;
1620                         gpd->flag |= GP_DATA_STROKE_SCULPTMODE;
1621                         gpd->flag &= ~GP_DATA_STROKE_WEIGHTMODE;
1622                         gpencil_verify_brush_type(C, OB_MODE_GPENCIL_SCULPT);
1623                         ED_gpencil_toggle_brush_cursor(C, true, NULL);
1624                         break;
1625                 case OB_MODE_GPENCIL_WEIGHT:
1626                         gpd->flag &= ~GP_DATA_STROKE_EDITMODE;
1627                         gpd->flag &= ~GP_DATA_STROKE_PAINTMODE;
1628                         gpd->flag &= ~GP_DATA_STROKE_SCULPTMODE;
1629                         gpd->flag |= GP_DATA_STROKE_WEIGHTMODE;
1630                         gpencil_verify_brush_type(C, OB_MODE_GPENCIL_WEIGHT);
1631                         ED_gpencil_toggle_brush_cursor(C, true, NULL);
1632                         break;
1633                 default:
1634                         gpd->flag &= ~GP_DATA_STROKE_EDITMODE;
1635                         gpd->flag &= ~GP_DATA_STROKE_PAINTMODE;
1636                         gpd->flag &= ~GP_DATA_STROKE_SCULPTMODE;
1637                         gpd->flag &= ~GP_DATA_STROKE_WEIGHTMODE;
1638                         ED_gpencil_toggle_brush_cursor(C, false, NULL);
1639                         break;
1640         }
1641 }
1642
1643 /* helper to convert 2d to 3d for simple drawing buffer */
1644 static void gpencil_stroke_convertcoords(ARegion *ar, const tGPspoint *point2D, float origin[3], float out[3])
1645 {
1646         float mval_f[2] = { (float)point2D->x, (float)point2D->y };
1647         float mval_prj[2];
1648         float rvec[3], dvec[3];
1649         float zfac;
1650
1651         copy_v3_v3(rvec, origin);
1652
1653         zfac = ED_view3d_calc_zfac(ar->regiondata, rvec, NULL);
1654
1655         if (ED_view3d_project_float_global(ar, rvec, mval_prj, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
1656                 sub_v2_v2v2(mval_f, mval_prj, mval_f);
1657                 ED_view3d_win_to_delta(ar, mval_f, dvec, zfac);
1658                 sub_v3_v3v3(out, rvec, dvec);
1659         }
1660         else {
1661                 zero_v3(out);
1662         }
1663 }
1664
1665 /* convert 2d tGPspoint to 3d bGPDspoint */
1666 void ED_gpencil_tpoint_to_point(ARegion *ar, float origin[3], const tGPspoint *tpt, bGPDspoint *pt)
1667 {
1668         float p3d[3];
1669         /* conversion to 3d format */
1670         gpencil_stroke_convertcoords(ar, tpt, origin, p3d);
1671         copy_v3_v3(&pt->x, p3d);
1672
1673         pt->pressure = tpt->pressure;
1674         pt->strength = tpt->strength;
1675         pt->uv_fac = tpt->uv_fac;
1676         pt->uv_rot = tpt->uv_rot;
1677 }
1678
1679 /* texture coordinate utilities */
1680 void ED_gpencil_calc_stroke_uv(Object *ob, bGPDstroke *gps)
1681 {
1682         if (gps == NULL) {
1683                 return;
1684         }
1685         MaterialGPencilStyle *gp_style = BKE_material_gpencil_settings_get(ob, gps->mat_nr + 1);
1686         float pixsize;
1687         if (gp_style) {
1688                 pixsize = gp_style->texture_pixsize / 1000000.0f;
1689         }
1690         else {
1691                 /* use this value by default */
1692                 pixsize = 0.000100f;
1693         }
1694         pixsize = MAX2(pixsize, 0.0000001f);
1695
1696         bGPDspoint *pt = NULL;
1697         bGPDspoint *ptb = NULL;
1698         int i;
1699         float totlen = 0;
1700
1701         /* first read all points and calc distance */
1702         for (i = 0; i < gps->totpoints; i++) {
1703                 pt = &gps->points[i];
1704                 /* first point */
1705                 if (i == 0) {
1706                         pt->uv_fac = 0.0f;
1707                         continue;
1708                 }
1709
1710                 ptb = &gps->points[i - 1];
1711                 totlen += len_v3v3(&pt->x, &ptb->x) / pixsize;
1712                 pt->uv_fac = totlen;
1713         }
1714         /* normalize the distance using a factor */
1715         float factor;
1716         /* if image, use texture width */
1717         if ((gp_style) && (gp_style->sima)) {
1718                 factor = gp_style->sima->gen_x;
1719         }
1720         else {
1721                 factor = totlen;
1722         }
1723         for (i = 0; i < gps->totpoints; i++) {
1724                 pt = &gps->points[i];
1725                 pt->uv_fac /= factor;
1726         }
1727 }
1728
1729 /* recalc uv for any stroke using the material */
1730 void ED_gpencil_update_color_uv(Main *bmain, Material *mat)
1731 {
1732         Material *gps_ma = NULL;
1733         /* read all strokes  */
1734         for (Object *ob = bmain->object.first; ob; ob = ob->id.next) {
1735                 if (ob->type == OB_GPENCIL) {
1736                         bGPdata *gpd = ob->data;
1737                         if (gpd == NULL) {
1738                                 continue;
1739                         }
1740
1741                         for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1742                                 /* only editable and visible layers are considered */
1743                                 if (gpencil_layer_is_editable(gpl)) {
1744                                         for (bGPDframe *gpf = gpl->frames.first; gpf; gpf = gpf->next) {
1745                                                 for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
1746                                                         /* check if it is editable */
1747                                                         if (ED_gpencil_stroke_color_use(ob, gpl, gps) == false) {
1748                                                                 continue;
1749                                                         }
1750                                                         gps_ma = give_current_material(ob, gps->mat_nr + 1);
1751                                                         /* update */
1752                                                         if ((gps_ma) && (gps_ma == mat)) {
1753                                                                 ED_gpencil_calc_stroke_uv(ob, gps);
1754                                                         }
1755                                                 }
1756                                         }
1757                                 }
1758                         }
1759                 }
1760         }
1761 }
1762 /* ******************************************************** */