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